appium-mac2-driver 4.3.5 → 4.4.0

package/node_modules/bplist-parser/dist/index.cjs

@@ -0,0 +1,385 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// bplistParser.ts
+var bplistParser_exports = {};
+__export(bplistParser_exports, {
+  UID: () => UID,
+  maxObjectCount: () => maxObjectCount,
+  maxObjectSize: () => maxObjectSize,
+  parseBuffer: () => parseBuffer,
+  parseFile: () => parseFile,
+  parseFileSync: () => parseFileSync,
+  setMaxObjectCount: () => setMaxObjectCount,
+  setMaxObjectSize: () => setMaxObjectSize
+});
+module.exports = __toCommonJS(bplistParser_exports);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var debug = false;
+var maxObjectSize = 100 * 1e3 * 1e3;
+var maxObjectCount = 32768;
+function setMaxObjectSize(value) {
+  maxObjectSize = value;
+}
+function setMaxObjectCount(value) {
+  maxObjectCount = value;
+}
+var EPOCH = 9783072e5;
+var UID = class {
+  UID;
+  constructor(id) {
+    this.UID = id;
+  }
+};
+function parseFile(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);
+    }
+    import_node_fs.default.readFile(fileNameOrBuffer, function(err, data) {
+      if (err) {
+        reject(err);
+        if (callback) callback(err);
+        return;
+      }
+      tryParseBuffer(data);
+    });
+  });
+}
+function parseFileSync(fileNameOrBuffer) {
+  const buffer = Buffer.isBuffer(fileNameOrBuffer) ? fileNameOrBuffer : import_node_fs.default.readFileSync(fileNameOrBuffer);
+  return parseBuffer(buffer);
+}
+function parseBuffer(buffer) {
+  const header = buffer.slice(0, "bplist00".length).toString("utf8");
+  if (header !== "bplist00") {
+    throw new Error("Invalid binary plist. Expected 'bplist00' at offset 0.");
+  }
+  if (buffer.length < "bplist00".length + 32) {
+    throw new Error("Invalid binary plist. Expected a trailer.");
+  }
+  const trailer = buffer.slice(buffer.length - 32, buffer.length);
+  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 > maxObjectCount) {
+    throw new Error("maxObjectCount exceeded");
+  }
+  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) + "]");
+    }
+  }
+  function parseObject(tableOffset) {
+    const offset = offsetTable[tableOffset];
+    const type = buffer[offset];
+    const objType = (type & 240) >> 4;
+    const objInfo = type & 15;
+    switch (objType) {
+      case 0:
+        return parseSimple();
+      case 1:
+        return parseInteger();
+      case 8:
+        return parseUID();
+      case 2:
+        return parseReal();
+      case 3:
+        return parseDate();
+      case 4:
+        return parseData();
+      case 5:
+        return parsePlistString();
+      case 6:
+        return parsePlistString(true);
+      case 10:
+        return parseArray();
+      case 13:
+        return parseDictionary();
+      default:
+        throw new Error("Unhandled type 0x" + objType.toString(16));
+    }
+    function parseSimple() {
+      switch (objInfo) {
+        case 0:
+          return null;
+        case 8:
+          return false;
+        case 9:
+          return true;
+        case 15:
+          return null;
+        default:
+          throw new Error("Unhandled simple type 0x" + objType.toString(16));
+      }
+    }
+    function parseInteger() {
+      const length = Math.pow(2, objInfo);
+      if (length < maxObjectSize) {
+        const data = buffer.slice(offset + 1, offset + 1 + length);
+        return readInteger(data);
+      }
+      throw new Error("Too little heap space available! Wanted to read " + length + " bytes, but only " + maxObjectSize + " are available.");
+    }
+    function parseUID() {
+      const length = objInfo + 1;
+      if (length < maxObjectSize) {
+        return new UID(readUInt(buffer.slice(offset + 1, offset + 1 + length)));
+      }
+      throw new Error("Too little heap space available! Wanted to read " + length + " bytes, but only " + maxObjectSize + " are available.");
+    }
+    function parseReal() {
+      const length = Math.pow(2, objInfo);
+      if (length < 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("Too little heap space available! Wanted to read " + length + " bytes, but only " + maxObjectSize + " are available.");
+      }
+    }
+    function parseDate() {
+      if (objInfo != 3) {
+        console.error("Unknown date type :" + objInfo + ". Parsing anyway...");
+      }
+      const dateBuffer = buffer.slice(offset + 1, offset + 9);
+      return new Date(EPOCH + 1e3 * dateBuffer.readDoubleBE(0));
+    }
+    function parseData() {
+      let dataoffset = 1;
+      let length = objInfo;
+      if (objInfo == 15) {
+        const int_type = buffer[offset + 1];
+        const intType = (int_type & 240) / 16;
+        if (intType != 1) {
+          console.error("0x4: UNEXPECTED LENGTH-INT TYPE! " + intType);
+        }
+        const intInfo = int_type & 15;
+        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 < maxObjectSize) {
+        return buffer.slice(offset + dataoffset, offset + dataoffset + length);
+      }
+      throw new Error("Too little heap space available! Wanted to read " + length + " bytes, but only " + maxObjectSize + " are available.");
+    }
+    function parsePlistString(isUtf16) {
+      const utf16Flag = isUtf16 || false;
+      let enc = "utf8";
+      let length = objInfo;
+      let stroffset = 1;
+      if (objInfo == 15) {
+        const int_type = buffer[offset + 1];
+        const intType = (int_type & 240) / 16;
+        if (intType != 1) {
+          console.error("UNEXPECTED LENGTH-INT TYPE! " + intType);
+        }
+        const intInfo = int_type & 15;
+        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 *= utf16Flag ? 2 : 1;
+      if (length < maxObjectSize) {
+        let plistString = Buffer.from(buffer.slice(offset + stroffset, offset + stroffset + length));
+        if (utf16Flag) {
+          plistString = swapBytes(plistString);
+          enc = "ucs2";
+        }
+        return plistString.toString(enc);
+      }
+      throw new Error("Too little heap space available! Wanted to read " + length + " bytes, but only " + maxObjectSize + " are available.");
+    }
+    function parseArray() {
+      let length = objInfo;
+      let arrayoffset = 1;
+      if (objInfo == 15) {
+        const int_type = buffer[offset + 1];
+        const intType = (int_type & 240) / 16;
+        if (intType != 1) {
+          console.error("0xa: UNEXPECTED LENGTH-INT TYPE! " + intType);
+        }
+        const intInfo = int_type & 15;
+        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 > maxObjectSize) {
+        throw new Error("Too 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 == 15) {
+        const int_type = buffer[offset + 1];
+        const intType = (int_type & 240) / 16;
+        if (intType != 1) {
+          console.error("0xD: UNEXPECTED LENGTH-INT TYPE! " + intType);
+        }
+        const intInfo = int_type & 15;
+        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 > maxObjectSize) {
+        throw new Error("Too 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 = l * 256 + buffer[i];
+  }
+  return l;
+}
+function readBigUInt(buffer) {
+  let value = 0n;
+  for (const byte of buffer) {
+    value = value << 8n | BigInt(byte);
+  }
+  return value;
+}
+function simplifyInteger(value) {
+  if (value >= BigInt(Number.MIN_SAFE_INTEGER) && value <= BigInt(Number.MAX_SAFE_INTEGER)) {
+    return Number(value);
+  }
+  return value;
+}
+function readInteger(buffer) {
+  let value = readBigUInt(buffer);
+  if (buffer.length === 8 && buffer[0] & 128) {
+    value -= 1n << 64n;
+  }
+  return simplifyInteger(value);
+}
+function readUInt64BE(buffer, start) {
+  const data = buffer.slice(start, start + 8);
+  return readUInt(data, 0);
+}
+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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  UID,
+  maxObjectCount,
+  maxObjectSize,
+  parseBuffer,
+  parseFile,
+  parseFileSync,
+  setMaxObjectCount,
+  setMaxObjectSize
+});
+//# sourceMappingURL=index.cjs.map

package/node_modules/bplist-parser/dist/index.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../bplistParser.ts"],
+  "sourcesContent": ["/* eslint-disable no-console */\n\n// adapted from https://github.com/3breadt/dd-plist\n\nimport fs from 'node:fs';\nconst debug = false;\n\nexport let maxObjectSize = 100 * 1000 * 1000; // 100Meg\nexport let maxObjectCount = 32768;\n\n// Exported bindings are read-only to consumers (an ESM import binding cannot be\n// assigned, and the CommonJS build exposes exports as getters), so these knobs\n// are tuned through setters rather than by assigning to the exports.\nexport function setMaxObjectSize(value: number): void {\n  maxObjectSize = value;\n}\n\nexport function setMaxObjectCount(value: number): void {\n  maxObjectCount = value;\n}\n\n// EPOCH = new SimpleDateFormat(\"yyyy MM dd zzz\").parse(\"2001 01 01 GMT\").getTime();\n// ...but that's annoying in a static initializer because it can throw exceptions, ick.\n// So we just hardcode the correct value.\nconst EPOCH = 978307200000;\n\n/** Wrapper for a CoreFoundation keyed-archiver UID value. */\nexport class UID {\n  UID: number;\n\n  constructor(id: number) {\n    this.UID = id;\n  }\n}\n\nexport type CallbackFunction<T = any> = (error: Error | null, result?: [T]) => void;\n\nexport function parseFile<T = any>(\n  fileNameOrBuffer: string | Buffer,\n  callback?: CallbackFunction<T>\n): Promise<[T]> {\n  return new Promise<[T]>(function (resolve, reject) {\n    function tryParseBuffer(buffer: Buffer) {\n      let err: Error | null = null;\n      let result: [T] | undefined;\n      try {\n        result = parseBuffer<T>(buffer);\n        resolve(result);\n      } catch (ex) {\n        err = ex as Error;\n        reject(err);\n      } finally {\n        if (callback) callback(err, result);\n      }\n    }\n\n    if (Buffer.isBuffer(fileNameOrBuffer)) {\n      return tryParseBuffer(fileNameOrBuffer);\n    }\n    fs.readFile(fileNameOrBuffer, function (err, data) {\n      if (err) {\n        reject(err);\n        if (callback) callback(err);\n        return;\n      }\n      tryParseBuffer(data);\n    });\n  });\n}\n\nexport function parseFileSync<T = any>(fileNameOrBuffer: string | Buffer): [T] {\n  const buffer = Buffer.isBuffer(fileNameOrBuffer) ? fileNameOrBuffer : fs.readFileSync(fileNameOrBuffer);\n  return parseBuffer<T>(buffer);\n}\n\nexport function parseBuffer<T = any>(buffer: Buffer): [T] {\n  // check header\n  const header = buffer.slice(0, 'bplist00'.length).toString('utf8');\n  if (header !== 'bplist00') {\n    throw new Error(\"Invalid binary plist. Expected 'bplist00' at offset 0.\");\n  }\n  if (buffer.length < 'bplist00'.length + 32) {\n    throw new Error(\"Invalid binary plist. Expected a trailer.\");\n  }\n\n  // Handle trailer, last 32 bytes of the file\n  const trailer = buffer.slice(buffer.length - 32, buffer.length);\n  // 6 null bytes (index 0 to 5)\n  const offsetSize = trailer.readUInt8(6);\n  if (debug) {\n    console.log(\"offsetSize: \" + offsetSize);\n  }\n  const objectRefSize = trailer.readUInt8(7);\n  if (debug) {\n    console.log(\"objectRefSize: \" + objectRefSize);\n  }\n  const numObjects = readUInt64BE(trailer, 8);\n  if (debug) {\n    console.log(\"numObjects: \" + numObjects);\n  }\n  const topObject = readUInt64BE(trailer, 16);\n  if (debug) {\n    console.log(\"topObject: \" + topObject);\n  }\n  const offsetTableOffset = readUInt64BE(trailer, 24);\n  if (debug) {\n    console.log(\"offsetTableOffset: \" + offsetTableOffset);\n  }\n\n  if (numObjects > maxObjectCount) {\n    throw new Error(\"maxObjectCount exceeded\");\n  }\n\n  // Handle offset table\n  const offsetTable: number[] = [];\n\n  for (let i = 0; i < numObjects; i++) {\n    const offsetBytes = buffer.slice(offsetTableOffset + i * offsetSize, offsetTableOffset + (i + 1) * offsetSize);\n    offsetTable[i] = readUInt(offsetBytes, 0);\n    if (debug) {\n      console.log(\"Offset for Object #\" + i + \" is \" + offsetTable[i] + \" [\" + offsetTable[i].toString(16) + \"]\");\n    }\n  }\n\n  // Parses an object inside the currently parsed binary property list.\n  // For the format specification check\n  // <a href=\"https://www.opensource.apple.com/source/CF/CF-635/CFBinaryPList.c\">\n  // Apple's binary property list parser implementation</a>.\n  function parseObject(tableOffset: number): any {\n    const offset = offsetTable[tableOffset];\n    const type = buffer[offset];\n    const objType = (type & 0xF0) >> 4; //First  4 bits\n    const objInfo = (type & 0x0F);      //Second 4 bits\n    switch (objType) {\n    case 0x0:\n      return parseSimple();\n    case 0x1:\n      return parseInteger();\n    case 0x8:\n      return parseUID();\n    case 0x2:\n      return parseReal();\n    case 0x3:\n      return parseDate();\n    case 0x4:\n      return parseData();\n    case 0x5: // ASCII\n      return parsePlistString();\n    case 0x6: // UTF-16\n      return parsePlistString(true);\n    case 0xA:\n      return parseArray();\n    case 0xD:\n      return parseDictionary();\n    default:\n      throw new Error(\"Unhandled type 0x\" + objType.toString(16));\n    }\n\n    function parseSimple(): any {\n      //Simple\n      switch (objInfo) {\n      case 0x0: // null\n        return null;\n      case 0x8: // false\n        return false;\n      case 0x9: // true\n        return true;\n      case 0xF: // filler byte\n        return null;\n      default:\n        throw new Error(\"Unhandled simple type 0x\" + objType.toString(16));\n      }\n    }\n\n    function parseInteger(): number | bigint {\n      const length = Math.pow(2, objInfo);\n      if (length < maxObjectSize) {\n        const data = buffer.slice(offset + 1, offset + 1 + length);\n        return readInteger(data);\n      }\n        throw new Error(\"Too little heap space available! Wanted to read \" + length + \" bytes, but only \" + maxObjectSize + \" are available.\");\n\n    }\n\n    function parseUID(): UID {\n      const length = objInfo + 1;\n      if (length < maxObjectSize) {\n        return new UID(readUInt(buffer.slice(offset + 1, offset + 1 + length)));\n      }\n      throw new Error(\"Too little heap space available! Wanted to read \" + length + \" bytes, but only \" + maxObjectSize + \" are available.\");\n    }\n\n    function parseReal(): number | undefined {\n      const length = Math.pow(2, objInfo);\n      if (length < maxObjectSize) {\n        const realBuffer = buffer.slice(offset + 1, offset + 1 + length);\n        if (length === 4) {\n          return realBuffer.readFloatBE(0);\n        }\n        if (length === 8) {\n          return realBuffer.readDoubleBE(0);\n        }\n      } else {\n        throw new Error(\"Too little heap space available! Wanted to read \" + length + \" bytes, but only \" + maxObjectSize + \" are available.\");\n      }\n    }\n\n    function parseDate(): Date {\n      if (objInfo != 0x3) {\n        console.error(\"Unknown date type :\" + objInfo + \". Parsing anyway...\");\n      }\n      const dateBuffer = buffer.slice(offset + 1, offset + 9);\n      return new Date(EPOCH + (1000 * dateBuffer.readDoubleBE(0)));\n    }\n\n    function parseData(): Buffer {\n      let dataoffset = 1;\n      let length = objInfo;\n      if (objInfo == 0xF) {\n        const int_type = buffer[offset + 1];\n        const intType = (int_type & 0xF0) / 0x10;\n        if (intType != 0x1) {\n          console.error(\"0x4: UNEXPECTED LENGTH-INT TYPE! \" + intType);\n        }\n        const intInfo = int_type & 0x0F;\n        const intLength = Math.pow(2, intInfo);\n        dataoffset = 2 + intLength;\n        if (intLength < 3) {\n          length = readUInt(buffer.slice(offset + 2, offset + 2 + intLength));\n        } else {\n          length = readUInt(buffer.slice(offset + 2, offset + 2 + intLength));\n        }\n      }\n      if (length < maxObjectSize) {\n        return buffer.slice(offset + dataoffset, offset + dataoffset + length);\n      }\n      throw new Error(\"Too little heap space available! Wanted to read \" + length + \" bytes, but only \" + maxObjectSize + \" are available.\");\n    }\n\n    function parsePlistString(isUtf16?: boolean): string {\n      const utf16Flag = isUtf16 || false;\n      let enc: BufferEncoding = \"utf8\";\n      let length = objInfo;\n      let stroffset = 1;\n      if (objInfo == 0xF) {\n        const int_type = buffer[offset + 1];\n        const intType = (int_type & 0xF0) / 0x10;\n        if (intType != 0x1) {\n          console.error(\"UNEXPECTED LENGTH-INT TYPE! \" + intType);\n        }\n        const intInfo = int_type & 0x0F;\n        const intLength = Math.pow(2, intInfo);\n        stroffset = 2 + intLength;\n        if (intLength < 3) {\n          length = readUInt(buffer.slice(offset + 2, offset + 2 + intLength));\n        } else {\n          length = readUInt(buffer.slice(offset + 2, offset + 2 + intLength));\n        }\n      }\n      // length is String length -> to get byte length multiply by 2, as 1 character takes 2 bytes in UTF-16\n      length *= (utf16Flag ? 2 : 1);\n      if (length < maxObjectSize) {\n        let plistString = Buffer.from(buffer.slice(offset + stroffset, offset + stroffset + length));\n        if (utf16Flag) {\n          plistString = swapBytes(plistString);\n          enc = \"ucs2\";\n        }\n        return plistString.toString(enc);\n      }\n      throw new Error(\"Too little heap space available! Wanted to read \" + length + \" bytes, but only \" + maxObjectSize + \" are available.\");\n    }\n\n    function parseArray(): any[] {\n      let length = objInfo;\n      let arrayoffset = 1;\n      if (objInfo == 0xF) {\n        const int_type = buffer[offset + 1];\n        const intType = (int_type & 0xF0) / 0x10;\n        if (intType != 0x1) {\n          console.error(\"0xa: UNEXPECTED LENGTH-INT TYPE! \" + intType);\n        }\n        const intInfo = int_type & 0x0F;\n        const intLength = Math.pow(2, intInfo);\n        arrayoffset = 2 + intLength;\n        if (intLength < 3) {\n          length = readUInt(buffer.slice(offset + 2, offset + 2 + intLength));\n        } else {\n          length = readUInt(buffer.slice(offset + 2, offset + 2 + intLength));\n        }\n      }\n      if (length * objectRefSize > maxObjectSize) {\n        throw new Error(\"Too little heap space available!\");\n      }\n      const array: any[] = [];\n      for (let i = 0; i < length; i++) {\n        const objRef = readUInt(buffer.slice(offset + arrayoffset + i * objectRefSize, offset + arrayoffset + (i + 1) * objectRefSize));\n        array[i] = parseObject(objRef);\n      }\n      return array;\n    }\n\n    function parseDictionary(): Record<string, any> {\n      let length = objInfo;\n      let dictoffset = 1;\n      if (objInfo == 0xF) {\n        const int_type = buffer[offset + 1];\n        const intType = (int_type & 0xF0) / 0x10;\n        if (intType != 0x1) {\n          console.error(\"0xD: UNEXPECTED LENGTH-INT TYPE! \" + intType);\n        }\n        const intInfo = int_type & 0x0F;\n        const intLength = Math.pow(2, intInfo);\n        dictoffset = 2 + intLength;\n        if (intLength < 3) {\n          length = readUInt(buffer.slice(offset + 2, offset + 2 + intLength));\n        } else {\n          length = readUInt(buffer.slice(offset + 2, offset + 2 + intLength));\n        }\n      }\n      if (length * 2 * objectRefSize > maxObjectSize) {\n        throw new Error(\"Too little heap space available!\");\n      }\n      if (debug) {\n        console.log(\"Parsing dictionary #\" + tableOffset);\n      }\n      const dict: Record<string, any> = {};\n      for (let i = 0; i < length; i++) {\n        const keyRef = readUInt(buffer.slice(offset + dictoffset + i * objectRefSize, offset + dictoffset + (i + 1) * objectRefSize));\n        const valRef = readUInt(buffer.slice(offset + dictoffset + (length * objectRefSize) + i * objectRefSize, offset + dictoffset + (length * objectRefSize) + (i + 1) * objectRefSize));\n        const key = parseObject(keyRef);\n        const val = parseObject(valRef);\n        if (debug) {\n          console.log(\"  DICT #\" + tableOffset + \": Mapped \" + key + \" to \" + val);\n        }\n        dict[key] = val;\n      }\n      return dict;\n    }\n  }\n\n  return [ parseObject(topObject) ];\n}\n\nfunction readUInt(buffer: Buffer, start?: number): number {\n  start = start || 0;\n\n  let l = 0;\n  for (let i = start; i < buffer.length; i++) {\n    l = (l * 0x100) + buffer[i];\n  }\n  return l;\n}\n\nfunction readBigUInt(buffer: Buffer): bigint {\n  let value = 0n;\n  for (const byte of buffer) {\n    value = (value << 8n) | BigInt(byte);\n  }\n  return value;\n}\n\nfunction simplifyInteger(value: bigint): number | bigint {\n  if (value >= BigInt(Number.MIN_SAFE_INTEGER) && value <= BigInt(Number.MAX_SAFE_INTEGER)) {\n    return Number(value);\n  }\n  return value;\n}\n\nfunction readInteger(buffer: Buffer): number | bigint {\n  let value = readBigUInt(buffer);\n\n  if (buffer.length === 8 && (buffer[0] & 0x80)) {\n    value -= 1n << 64n;\n  }\n\n  return simplifyInteger(value);\n}\n\n// we're just going to toss the high order bits because javascript doesn't have 64-bit ints\nfunction readUInt64BE(buffer: Buffer, start: number): number {\n  const data = buffer.slice(start, start + 8);\n  return readUInt(data, 0);\n}\n\nfunction swapBytes<T extends Buffer>(buffer: T): T {\n  const len = buffer.length;\n  for (let i = 0; i < len; i += 2) {\n    const a = buffer[i];\n    buffer[i] = buffer[i+1];\n    buffer[i+1] = a;\n  }\n  return buffer;\n}\n"],
+  "mappings": "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",
+  "names": ["fs"]
+}

package/node_modules/bplist-parser/dist/index.d.cts

@@ -0,0 +1,13 @@
+export declare let maxObjectSize: number;
+export declare let maxObjectCount: number;
+export declare function setMaxObjectSize(value: number): void;
+export declare function setMaxObjectCount(value: number): void;
+/** Wrapper for a CoreFoundation keyed-archiver UID value. */
+export declare class UID {
+    UID: number;
+    constructor(id: number);
+}
+export type CallbackFunction<T = any> = (error: Error | null, result?: [T]) => void;
+export declare function parseFile<T = any>(fileNameOrBuffer: string | Buffer, callback?: CallbackFunction<T>): Promise<[T]>;
+export declare function parseFileSync<T = any>(fileNameOrBuffer: string | Buffer): [T];
+export declare function parseBuffer<T = any>(buffer: Buffer): [T];

package/node_modules/bplist-parser/dist/index.d.ts

@@ -0,0 +1,13 @@
+export declare let maxObjectSize: number;
+export declare let maxObjectCount: number;
+export declare function setMaxObjectSize(value: number): void;
+export declare function setMaxObjectCount(value: number): void;
+/** Wrapper for a CoreFoundation keyed-archiver UID value. */
+export declare class UID {
+    UID: number;
+    constructor(id: number);
+}
+export type CallbackFunction<T = any> = (error: Error | null, result?: [T]) => void;
+export declare function parseFile<T = any>(fileNameOrBuffer: string | Buffer, callback?: CallbackFunction<T>): Promise<[T]>;
+export declare function parseFileSync<T = any>(fileNameOrBuffer: string | Buffer): [T];
+export declare function parseBuffer<T = any>(buffer: Buffer): [T];