initial commit

node_modules/bplist-parser/README.md

@@ -0,0 +1,48 @@
+# bplist-parser
+
+Binary Mac OS X Plist (property list) parser.
+
+## Installation
+
+```bash
+$ npm install bplist-parser
+```
+
+## Quick Examples
+
+```javascript
+const bplist = require('bplist-parser');
+
+(async () => {
+
+  const obj = await bplist.parseFile('myPlist.bplist');
+
+  console.log(JSON.stringify(obj));
+
+})();
+```
+
+## License
+
+(The MIT License)
+
+Copyright (c) 2012 Near Infinity Corporation
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/bplist-parser/bplistParser.js

@@ -0,0 +1,363 @@
+'use strict';
+
+// adapted from http://code.google.com/p/plist/source/browse/trunk/src/com/dd/plist/BinaryPropertyListParser.java
+
+const fs = require('fs');
+const bigInt = require("big-integer");
+const debug = false;
+
+exports.maxObjectSize = 100 * 1000 * 1000; // 100Meg
+exports.maxObjectCount = 32768;
+
+// EPOCH = new SimpleDateFormat("yyyy MM dd zzz").parse("2001 01 01 GMT").getTime();
+// ...but that's annoying in a static initializer because it can throw exceptions, ick.
+// So we just hardcode the correct value.
+const EPOCH = 978307200000;
+
+// UID object definition
+const UID = exports.UID = function(id) {
+  this.UID = id;
+};
+
+const parseFile = exports.parseFile = function (fileNameOrBuffer, callback) {
+  return new Promise(function (resolve, reject) {
+    function tryParseBuffer(buffer) {
+      let err = null;
+      let result;
+      try {
+        result = parseBuffer(buffer);
+        resolve(result);
+      } catch (ex) {
+        err = ex;
+        reject(err);
+      } finally {
+        if (callback) callback(err, result);
+      }
+    }
+
+    if (Buffer.isBuffer(fileNameOrBuffer)) {
+      return tryParseBuffer(fileNameOrBuffer);
+    }
+    fs.readFile(fileNameOrBuffer, function (err, data) {
+      if (err) {
+        reject(err);
+        return callback(err);
+      }
+      tryParseBuffer(data);
+    });
+  });
+};
+
+const parseBuffer = exports.parseBuffer = function (buffer) {
+  // check header
+  const header = buffer.slice(0, 'bplist'.length).toString('utf8');
+  if (header !== 'bplist') {
+    throw new Error("Invalid binary plist. Expected 'bplist' at offset 0.");
+  }
+
+  // Handle trailer, last 32 bytes of the file
+  const trailer = buffer.slice(buffer.length - 32, buffer.length);
+  // 6 null bytes (index 0 to 5)
+  const offsetSize = trailer.readUInt8(6);
+  if (debug) {
+    console.log("offsetSize: " + offsetSize);
+  }
+  const objectRefSize = trailer.readUInt8(7);
+  if (debug) {
+    console.log("objectRefSize: " + objectRefSize);
+  }
+  const numObjects = readUInt64BE(trailer, 8);
+  if (debug) {
+    console.log("numObjects: " + numObjects);
+  }
+  const topObject = readUInt64BE(trailer, 16);
+  if (debug) {
+    console.log("topObject: " + topObject);
+  }
+  const offsetTableOffset = readUInt64BE(trailer, 24);
+  if (debug) {
+    console.log("offsetTableOffset: " + offsetTableOffset);
+  }
+
+  if (numObjects > exports.maxObjectCount) {
+    throw new Error("maxObjectCount exceeded");
+  }
+
+  // Handle offset table
+  const offsetTable = [];
+
+  for (let i = 0; i < numObjects; i++) {
+    const offsetBytes = buffer.slice(offsetTableOffset + i * offsetSize, offsetTableOffset + (i + 1) * offsetSize);
+    offsetTable[i] = readUInt(offsetBytes, 0);
+    if (debug) {
+      console.log("Offset for Object #" + i + " is " + offsetTable[i] + " [" + offsetTable[i].toString(16) + "]");
+    }
+  }
+
+  // Parses an object inside the currently parsed binary property list.
+  // For the format specification check
+  // <a href="http://www.opensource.apple.com/source/CF/CF-635/CFBinaryPList.c">
+  // Apple's binary property list parser implementation</a>.
+  function parseObject(tableOffset) {
+    const offset = offsetTable[tableOffset];
+    const type = buffer[offset];
+    const objType = (type & 0xF0) >> 4; //First  4 bits
+    const objInfo = (type & 0x0F);      //Second 4 bits
+    switch (objType) {
+    case 0x0:
+      return parseSimple();
+    case 0x1:
+      return parseInteger();
+    case 0x8:
+      return parseUID();
+    case 0x2:
+      return parseReal();
+    case 0x3:
+      return parseDate();
+    case 0x4:
+      return parseData();
+    case 0x5: // ASCII
+      return parsePlistString();
+    case 0x6: // UTF-16
+      return parsePlistString(true);
+    case 0xA:
+      return parseArray();
+    case 0xD:
+      return parseDictionary();
+    default:
+      throw new Error("Unhandled type 0x" + objType.toString(16));
+    }
+
+    function parseSimple() {
+      //Simple
+      switch (objInfo) {
+      case 0x0: // null
+        return null;
+      case 0x8: // false
+        return false;
+      case 0x9: // true
+        return true;
+      case 0xF: // filler byte
+        return null;
+      default:
+        throw new Error("Unhandled simple type 0x" + objType.toString(16));
+      }
+    }
+
+    function bufferToHexString(buffer) {
+      let str = '';
+      let i;
+      for (i = 0; i < buffer.length; i++) {
+        if (buffer[i] != 0x00) {
+          break;
+        }
+      }
+      for (; i < buffer.length; i++) {
+        const part = '00' + buffer[i].toString(16);
+        str += part.substr(part.length - 2);
+      }
+      return str;
+    }
+
+    function parseInteger() {
+      const length = Math.pow(2, objInfo);
+
+      if (objInfo == 0x4) {
+        const data = buffer.slice(offset + 1, offset + 1 + length);
+        const str = bufferToHexString(data);
+        return bigInt(str, 16);
+      }
+      if (objInfo == 0x3) {
+        return buffer.readInt32BE(offset + 1);
+      }
+      if (length < exports.maxObjectSize) {
+        return readUInt(buffer.slice(offset + 1, offset + 1 + length));
+      }
+      throw new Error("To little heap space available! Wanted to read " + length + " bytes, but only " + exports.maxObjectSize + " are available.");
+    }
+
+    function parseUID() {
+      const length = objInfo + 1;
+      if (length < exports.maxObjectSize) {
+        return new UID(readUInt(buffer.slice(offset + 1, offset + 1 + length)));
+      }
+      throw new Error("To little heap space available! Wanted to read " + length + " bytes, but only " + exports.maxObjectSize + " are available.");
+    }
+
+    function parseReal() {
+      const length = Math.pow(2, objInfo);
+      if (length < exports.maxObjectSize) {
+        const realBuffer = buffer.slice(offset + 1, offset + 1 + length);
+        if (length === 4) {
+          return realBuffer.readFloatBE(0);
+        }
+        if (length === 8) {
+          return realBuffer.readDoubleBE(0);
+        }
+      } else {
+        throw new Error("To little heap space available! Wanted to read " + length + " bytes, but only " + exports.maxObjectSize + " are available.");
+      }
+    }
+
+    function parseDate() {
+      if (objInfo != 0x3) {
+        console.error("Unknown date type :" + objInfo + ". Parsing anyway...");
+      }
+      const dateBuffer = buffer.slice(offset + 1, offset + 9);
+      return new Date(EPOCH + (1000 * dateBuffer.readDoubleBE(0)));
+    }
+
+    function parseData() {
+      let dataoffset = 1;
+      let length = objInfo;
+      if (objInfo == 0xF) {
+        const int_type = buffer[offset + 1];
+        const intType = (int_type & 0xF0) / 0x10;
+        if (intType != 0x1) {
+          console.error("0x4: UNEXPECTED LENGTH-INT TYPE! " + intType);
+        }
+        const intInfo = int_type & 0x0F;
+        const intLength = Math.pow(2, intInfo);
+        dataoffset = 2 + intLength;
+        if (intLength < 3) {
+          length = readUInt(buffer.slice(offset + 2, offset + 2 + intLength));
+        } else {
+          length = readUInt(buffer.slice(offset + 2, offset + 2 + intLength));
+        }
+      }
+      if (length < exports.maxObjectSize) {
+        return buffer.slice(offset + dataoffset, offset + dataoffset + length);
+      }
+      throw new Error("To little heap space available! Wanted to read " + length + " bytes, but only " + exports.maxObjectSize + " are available.");
+    }
+
+    function parsePlistString (isUtf16) {
+      isUtf16 = isUtf16 || 0;
+      let enc = "utf8";
+      let length = objInfo;
+      let stroffset = 1;
+      if (objInfo == 0xF) {
+        const int_type = buffer[offset + 1];
+        const intType = (int_type & 0xF0) / 0x10;
+        if (intType != 0x1) {
+          console.err("UNEXPECTED LENGTH-INT TYPE! " + intType);
+        }
+        const intInfo = int_type & 0x0F;
+        const intLength = Math.pow(2, intInfo);
+        stroffset = 2 + intLength;
+        if (intLength < 3) {
+          length = readUInt(buffer.slice(offset + 2, offset + 2 + intLength));
+        } else {
+          length = readUInt(buffer.slice(offset + 2, offset + 2 + intLength));
+        }
+      }
+      // length is String length -> to get byte length multiply by 2, as 1 character takes 2 bytes in UTF-16
+      length *= (isUtf16 + 1);
+      if (length < exports.maxObjectSize) {
+        let plistString = Buffer.from(buffer.slice(offset + stroffset, offset + stroffset + length));
+        if (isUtf16) {
+          plistString = swapBytes(plistString);
+          enc = "ucs2";
+        }
+        return plistString.toString(enc);
+      }
+      throw new Error("To little heap space available! Wanted to read " + length + " bytes, but only " + exports.maxObjectSize + " are available.");
+    }
+
+    function parseArray() {
+      let length = objInfo;
+      let arrayoffset = 1;
+      if (objInfo == 0xF) {
+        const int_type = buffer[offset + 1];
+        const intType = (int_type & 0xF0) / 0x10;
+        if (intType != 0x1) {
+          console.error("0xa: UNEXPECTED LENGTH-INT TYPE! " + intType);
+        }
+        const intInfo = int_type & 0x0F;
+        const intLength = Math.pow(2, intInfo);
+        arrayoffset = 2 + intLength;
+        if (intLength < 3) {
+          length = readUInt(buffer.slice(offset + 2, offset + 2 + intLength));
+        } else {
+          length = readUInt(buffer.slice(offset + 2, offset + 2 + intLength));
+        }
+      }
+      if (length * objectRefSize > exports.maxObjectSize) {
+        throw new Error("To little heap space available!");
+      }
+      const array = [];
+      for (let i = 0; i < length; i++) {
+        const objRef = readUInt(buffer.slice(offset + arrayoffset + i * objectRefSize, offset + arrayoffset + (i + 1) * objectRefSize));
+        array[i] = parseObject(objRef);
+      }
+      return array;
+    }
+
+    function parseDictionary() {
+      let length = objInfo;
+      let dictoffset = 1;
+      if (objInfo == 0xF) {
+        const int_type = buffer[offset + 1];
+        const intType = (int_type & 0xF0) / 0x10;
+        if (intType != 0x1) {
+          console.error("0xD: UNEXPECTED LENGTH-INT TYPE! " + intType);
+        }
+        const intInfo = int_type & 0x0F;
+        const intLength = Math.pow(2, intInfo);
+        dictoffset = 2 + intLength;
+        if (intLength < 3) {
+          length = readUInt(buffer.slice(offset + 2, offset + 2 + intLength));
+        } else {
+          length = readUInt(buffer.slice(offset + 2, offset + 2 + intLength));
+        }
+      }
+      if (length * 2 * objectRefSize > exports.maxObjectSize) {
+        throw new Error("To little heap space available!");
+      }
+      if (debug) {
+        console.log("Parsing dictionary #" + tableOffset);
+      }
+      const dict = {};
+      for (let i = 0; i < length; i++) {
+        const keyRef = readUInt(buffer.slice(offset + dictoffset + i * objectRefSize, offset + dictoffset + (i + 1) * objectRefSize));
+        const valRef = readUInt(buffer.slice(offset + dictoffset + (length * objectRefSize) + i * objectRefSize, offset + dictoffset + (length * objectRefSize) + (i + 1) * objectRefSize));
+        const key = parseObject(keyRef);
+        const val = parseObject(valRef);
+        if (debug) {
+          console.log("  DICT #" + tableOffset + ": Mapped " + key + " to " + val);
+        }
+        dict[key] = val;
+      }
+      return dict;
+    }
+  }
+
+  return [ parseObject(topObject) ];
+};
+
+function readUInt(buffer, start) {
+  start = start || 0;
+
+  let l = 0;
+  for (let i = start; i < buffer.length; i++) {
+    l <<= 8;
+    l |= buffer[i] & 0xFF;
+  }
+  return l;
+}
+
+// we're just going to toss the high order bits because javascript doesn't have 64-bit ints
+function readUInt64BE(buffer, start) {
+  const data = buffer.slice(start, start + 8);
+  return data.readUInt32BE(4, 8);
+}
+
+function swapBytes(buffer) {
+  const len = buffer.length;
+  for (let i = 0; i < len; i += 2) {
+    const a = buffer[i];
+    buffer[i] = buffer[i+1];
+    buffer[i+1] = a;
+  }
+  return buffer;
+}

node_modules/bplist-parser/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "bplist-parser",
+  "version": "0.2.0",
+  "description": "Binary plist parser.",
+  "main": "bplistParser.js",
+  "scripts": {
+    "test": "mocha test"
+  },
+  "keywords": [
+    "bplist",
+    "plist",
+    "parser"
+  ],
+  "author": "Joe Ferner <joe.ferner@nearinfinity.com>",
+  "contributors": [
+    "Brett Zamir"
+  ],
+  "license": "MIT",
+  "devDependencies": {
+    "mocha": "^6.1.4"
+  },
+  "homepage": "https://github.com/nearinfinity/node-bplist-parser",
+  "bugs": "https://github.com/nearinfinity/node-bplist-parser/issues",
+  "engines": {
+    "node": ">= 5.10.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nearinfinity/node-bplist-parser.git"
+  },
+  "dependencies": {
+    "big-integer": "^1.6.44"
+  }
+}

node_modules/bplist-parser/test/int64.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+  <dict>
+    <key>zero</key>
+    <integer>0</integer>
+    <key>int64item</key>
+    <integer>12345678901234567890</integer>
+  </dict>
+</plist>

node_modules/bplist-parser/test/parseTest.js

@@ -0,0 +1,104 @@
+'use strict';
+
+// tests are adapted from https://github.com/TooTallNate/node-plist
+
+const assert = require('assert');
+const path = require('path');
+const bplist = require('../');
+
+describe('bplist-parser', function () {
+  it('iTunes Small', async function () {
+    const file = path.join(__dirname, "iTunes-small.bplist");
+    const startTime1 = new Date();
+
+    const [dict] = await bplist.parseFile(file);
+    const endTime = new Date();
+    console.log('Parsed "' + file + '" in ' + (endTime - startTime1) + 'ms');
+    assert.equal(dict['Application Version'], "9.0.3");
+    assert.equal(dict['Library Persistent ID'], "6F81D37F95101437");
+  });
+
+  it('sample1', async function () {
+    const file = path.join(__dirname, "sample1.bplist");
+    const startTime = new Date();
+
+    const [dict] = await bplist.parseFile(file);
+    const endTime = new Date();
+    console.log('Parsed "' + file + '" in ' + (endTime - startTime) + 'ms');
+
+    assert.equal(dict['CFBundleIdentifier'], 'com.apple.dictionary.MySample');
+  });
+
+  it('sample2', async function () {
+    const file = path.join(__dirname, "sample2.bplist");
+    const startTime = new Date();
+
+    const [dict] = await bplist.parseFile(file);
+    const endTime = new Date();
+    console.log('Parsed "' + file + '" in ' + (endTime - startTime) + 'ms');
+
+    assert.equal(dict['PopupMenu'][2]['Key'], "\n        #import <Cocoa/Cocoa.h>\n\n#import <MacRuby/MacRuby.h>\n\nint main(int argc, char *argv[])\n{\n  return macruby_main(\"rb_main.rb\", argc, argv);\n}\n");
+  });
+
+  it('airplay', async function () {
+    const file = path.join(__dirname, "airplay.bplist");
+    const startTime = new Date();
+
+    const [dict] = await bplist.parseFile(file);
+    const endTime = new Date();
+    console.log('Parsed "' + file + '" in ' + (endTime - startTime) + 'ms');
+
+    assert.equal(dict['duration'], 5555.0495000000001);
+    assert.equal(dict['position'], 4.6269989039999997);
+  });
+
+  it('utf16', async function () {
+    const file = path.join(__dirname, "utf16.bplist");
+    const startTime = new Date();
+
+    const [dict] = await bplist.parseFile(file);
+    const endTime = new Date();
+    console.log('Parsed "' + file + '" in ' + (endTime - startTime) + 'ms');
+
+    assert.equal(dict['CFBundleName'], 'sellStuff');
+    assert.equal(dict['CFBundleShortVersionString'], '2.6.1');
+    assert.equal(dict['NSHumanReadableCopyright'], '©2008-2012, sellStuff, Inc.');
+  });
+
+  it('utf16chinese', async function () {
+    const file = path.join(__dirname, "utf16_chinese.plist");
+    const startTime = new Date();
+
+    const [dict] = await bplist.parseFile(file);
+    const endTime = new Date();
+    console.log('Parsed "' + file + '" in ' + (endTime - startTime) + 'ms');
+
+    assert.equal(dict['CFBundleName'], '天翼阅读');
+    assert.equal(dict['CFBundleDisplayName'], '天翼阅读');
+  });
+
+  it('uid', async function () {
+    const file = path.join(__dirname, "uid.bplist");
+    const startTime = new Date();
+
+    const [dict] = await bplist.parseFile(file);
+    const endTime = new Date();
+    console.log('Parsed "' + file + '" in ' + (endTime - startTime) + 'ms');
+
+    assert.deepEqual(dict['$objects'][1]['NS.keys'], [{UID:2}, {UID:3}, {UID:4}]);
+    assert.deepEqual(dict['$objects'][1]['NS.objects'], [{UID: 5}, {UID:6}, {UID:7}]);
+    assert.deepEqual(dict['$top']['root'], {UID:1});
+  });
+
+  it('int64', async function () {
+    const file = path.join(__dirname, "int64.bplist");
+    const startTime = new Date();
+
+    const [dict] = await bplist.parseFile(file);
+    const endTime = new Date();
+    console.log('Parsed "' + file + '" in ' + (endTime - startTime) + 'ms');
+
+    assert.equal(dict['zero'], '0');
+    assert.equal(dict['int64item'], '12345678901234567890');
+  });
+});