@basmilius/apple-encoding 0.5.3 → 0.5.4

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024-2025 Bas Milius
+Copyright (c) 2024-present Bas Milius
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/dist/index.js

@@ -453,8 +453,611 @@ __export(exports_plist, {
   serialize: () => serialize,
   parse: () => parse
 });
-import { parse } from "@plist/binary.parse";
-import { serialize } from "@plist/binary.serialize";
+// ../../node_modules/@plist/common/lib/esm/constants.js
+var EPOCH2 = 978307200000;
+var HEADER_BINARY = "bplist00";
+var PlistFormat;
+(function(PlistFormat2) {
+  PlistFormat2[PlistFormat2["BINARY"] = 0] = "BINARY";
+  PlistFormat2[PlistFormat2["XML"] = 1] = "XML";
+  PlistFormat2[PlistFormat2["OPENSTEP"] = 2] = "OPENSTEP";
+})(PlistFormat || (PlistFormat = {}));
+// ../../node_modules/@plist/binary.parse/lib/esm/index.js
+var maxObjectSize = 100 * 1000 * 1000;
+var maxObjectCount = 32768;
+var DECODER_UTF8 = new TextDecoder("utf-8");
+var DECODER_UTF16 = new TextDecoder("utf-16");
+function readDouble(buffer, start = 0) {
+  return new DataView(buffer).getFloat64(start, false);
+}
+function readFloat(buffer, start = 0) {
+  return new DataView(buffer).getFloat32(start, false);
+}
+function readUInt8(buffer, start = 0) {
+  return new DataView(buffer).getUint8(start);
+}
+function readUInt16(buffer, start = 0) {
+  return new DataView(buffer).getUint16(start, false);
+}
+function readUInt32(buffer, start = 0) {
+  return new DataView(buffer).getUint32(start, false);
+}
+function readUInt64(buffer, start = 0) {
+  return new DataView(buffer).getBigUint64(start, false);
+}
+function readUInt(buffer) {
+  switch (buffer.byteLength) {
+    case 1:
+      return readUInt8(buffer);
+    case 2:
+      return readUInt16(buffer);
+    case 4:
+      return readUInt32(buffer);
+    case 8:
+      return readUInt64(buffer);
+    case 16:
+      return readUInt64(buffer, 8);
+  }
+  throw new Error(`Invalid unsigned int length: ${buffer.byteLength}`);
+}
+function readInt8(buffer, start = 0) {
+  return new DataView(buffer).getInt8(start);
+}
+function readInt16(buffer, start = 0) {
+  return new DataView(buffer).getInt16(start, false);
+}
+function readInt32(buffer, start = 0) {
+  return new DataView(buffer).getInt32(start, false);
+}
+function readInt64(buffer, start = 0) {
+  return new DataView(buffer).getBigInt64(start, false);
+}
+function readInt(buffer) {
+  switch (buffer.byteLength) {
+    case 1:
+      return readInt8(buffer);
+    case 2:
+      return readInt16(buffer);
+    case 4:
+      return readInt32(buffer);
+    case 8:
+      return readInt64(buffer);
+    case 16:
+      return readUInt64(buffer, 8);
+  }
+  throw new Error(`Invalid int length: ${buffer.byteLength}`);
+}
+function swapBytes(buffer) {
+  const array = new Uint8Array(buffer);
+  for (let i = 0;i < array.length; i += 2) {
+    const a = array[i];
+    array[i] = array[i + 1];
+    array[i + 1] = a;
+  }
+  return array.buffer;
+}
+var parse = (buffer) => {
+  const headerBytes = buffer.slice(0, HEADER_BINARY.length);
+  if (DECODER_UTF8.decode(headerBytes) !== HEADER_BINARY) {
+    throw new Error(`Invalid binary plist. Expected '${HEADER_BINARY}' at offset 0.`);
+  }
+  const trailer = buffer.slice(buffer.byteLength - 32, buffer.byteLength);
+  const offsetSize = readUInt8(trailer, 6);
+  const objectRefSize = readUInt8(trailer, 7);
+  const numObjects = Number(readUInt64(trailer, 8));
+  const topObject = Number(readUInt64(trailer, 16));
+  const offsetTableOffset = Number(readUInt64(trailer, 24));
+  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] = Number(readUInt(offsetBytes));
+  }
+  function parseObject(tableOffset) {
+    const offset = offsetTable[tableOffset];
+    const type = readUInt8(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 readInt(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 {
+          CF$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 readFloat(realBuffer);
+        } else if (length === 8) {
+          return readDouble(realBuffer);
+        }
+        throw new Error(`Invalid real length: ${length}`);
+      } 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(EPOCH2 + 1000 * readDouble(dateBuffer));
+    }
+    function parseData() {
+      let dataoffset = 1;
+      let length = objInfo;
+      if (objInfo == 15) {
+        const int_type = readInt8(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;
+        length = Number(readUInt(buffer.slice(offset + 2, offset + 2 + intLength)));
+      }
+      if (length < maxObjectSize) {
+        return buffer.slice(offset + dataoffset, offset + dataoffset + Number(length));
+      }
+      throw new Error("Too little heap space available! Wanted to read " + length + " bytes, but only " + maxObjectSize + " are available.");
+    }
+    function parsePlistString(isUtf16 = false) {
+      let length = objInfo;
+      let stroffset = 1;
+      if (objInfo == 15) {
+        const int_type = readUInt8(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;
+        length = Number(readUInt(buffer.slice(offset + 2, offset + 2 + intLength)));
+      }
+      length *= isUtf16 ? 2 : 1;
+      if (length < maxObjectSize) {
+        let plistString = buffer.slice(offset + stroffset, offset + stroffset + length);
+        if (isUtf16) {
+          plistString = swapBytes(plistString);
+          return DECODER_UTF16.decode(plistString);
+        } else {
+          return DECODER_UTF8.decode(plistString);
+        }
+      }
+      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 = readUInt8(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;
+        length = Number(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 = Number(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 = readUInt8(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;
+        length = Number(readUInt(buffer.slice(offset + 2, offset + 2 + intLength)));
+      }
+      if (length * 2 * objectRefSize > maxObjectSize) {
+        throw new Error("Too little heap space available!");
+      }
+      const dict = {};
+      for (let i = 0;i < length; i++) {
+        const keyRef = Number(readUInt(buffer.slice(offset + dictoffset + i * objectRefSize, offset + dictoffset + (i + 1) * objectRefSize)));
+        const valRef = Number(readUInt(buffer.slice(offset + dictoffset + length * objectRefSize + i * objectRefSize, offset + dictoffset + length * objectRefSize + (i + 1) * objectRefSize)));
+        const key = parseObject(keyRef);
+        if (typeof key !== "string") {
+          throw new Error("Invalid key type.");
+        }
+        if (key === "__proto__") {
+          throw new Error("Attempted prototype pollution");
+        }
+        const val = parseObject(valRef);
+        dict[key] = val;
+      }
+      return dict;
+    }
+  }
+  return parseObject(topObject);
+};
+// ../../node_modules/@plist/binary.serialize/lib/esm/index.js
+var encoder = new TextEncoder;
+var nullBytes = new Uint8Array([0, 0, 0, 0, 0, 0]);
+var fromHexString = (hexString) => Uint8Array.from(hexString.match(/.{1,2}/g).map((byte) => parseInt(byte, 16)));
+var isUID = (value) => !!value && typeof value === "object" && Object.keys(value).length == 1 && typeof value.CF$UID === "number";
+var toUTF16 = (string) => {
+  const buf = new ArrayBuffer(string.length * 2);
+  const bufView = new Uint16Array(buf);
+  for (let i = 0, strLen = string.length;i < strLen; i++) {
+    bufView[i] = string.charCodeAt(i);
+  }
+  return new Uint8Array(buf);
+};
+var concat2 = (first, second) => {
+  const third = new Uint8Array(first.length + second.length);
+  third.set(first);
+  third.set(second, first.length);
+  return third;
+};
+var writeUInt = (buffer, int2, size) => {
+  const output = new Uint8Array(buffer.length + size);
+  const dataView = new DataView(output.buffer);
+  output.set(buffer);
+  switch (size) {
+    case 1:
+      dataView.setUint8(buffer.length, Number(int2));
+      break;
+    case 2:
+      dataView.setUint16(buffer.length, Number(int2), false);
+      break;
+    case 4:
+      dataView.setUint32(buffer.length, Number(int2), false);
+      break;
+    case 8:
+      dataView.setBigUint64(buffer.length, BigInt(int2), false);
+      break;
+    default:
+      throw new Error("Unsupported int size");
+  }
+  return output;
+};
+var writeInt = (buffer, int2, size) => {
+  const output = new Uint8Array(buffer.length + size);
+  const dataView = new DataView(output.buffer);
+  output.set(buffer);
+  switch (size) {
+    case 1:
+      dataView.setInt8(buffer.length, Number(int2));
+      break;
+    case 2:
+      dataView.setInt16(buffer.length, Number(int2), false);
+      break;
+    case 4:
+      dataView.setInt32(buffer.length, Number(int2), false);
+      break;
+    case 8:
+      dataView.setBigInt64(buffer.length, BigInt(int2), false);
+      break;
+    default:
+      throw new Error("Unsupported int size");
+  }
+  return output;
+};
+var writeDouble = (buffer, double) => {
+  const output = new Uint8Array(buffer.length + 8);
+  const dataView = new DataView(output.buffer);
+  output.set(buffer);
+  dataView.setFloat64(buffer.length, double);
+  return output;
+};
+var serialize = (value) => {
+  let buffer = encoder.encode(HEADER_BINARY);
+  if (value instanceof Array && value.length === 1) {
+    value = value[0];
+  }
+  let entries = toEntries(value);
+  const idSizeInBytes = computeIdSizeInBytes(entries.length);
+  const offsets = [];
+  let offsetSizeInBytes;
+  let offsetTableOffset;
+  updateEntryIds();
+  entries.forEach((entry, entryIdx) => {
+    offsets[entryIdx] = buffer.byteLength;
+    if (typeof entry === "undefined" || entry === null) {
+      buffer = writeUInt(buffer, 0, 1);
+    } else {
+      write(entry);
+    }
+  });
+  writeOffsetTable();
+  writeTrailer();
+  return buffer.buffer;
+  function updateEntryIds() {
+    const strings = {};
+    let entryId = 0;
+    entries.forEach((entry) => {
+      if (entry.id) {
+        return;
+      }
+      if (typeof entry.value === "string") {
+        if (strings.hasOwnProperty(entry.value)) {
+          entry.type = "stringref";
+          entry.id = strings[entry.value];
+        } else {
+          strings[entry.value] = entry.id = entryId++;
+        }
+      } else {
+        entry.id = entryId++;
+      }
+    });
+    entries = entries.filter((entry) => {
+      return entry.type !== "stringref";
+    });
+  }
+  function writeTrailer() {
+    buffer = concat2(buffer, nullBytes);
+    buffer = concat2(buffer, new Uint8Array([offsetSizeInBytes, idSizeInBytes]));
+    buffer = writeUInt(buffer, BigInt(entries.length), 8);
+    buffer = writeUInt(buffer, BigInt("0"), 8);
+    buffer = writeUInt(buffer, BigInt(offsetTableOffset), 8);
+  }
+  function writeOffsetTable() {
+    offsetTableOffset = buffer.byteLength;
+    offsetSizeInBytes = computeOffsetSizeInBytes(offsetTableOffset);
+    offsets.forEach((offset) => {
+      buffer = writeUInt(buffer, offset, offsetSizeInBytes);
+    });
+  }
+  function write(entry) {
+    if (entry.type === "primitive") {
+      const value2 = entry.value;
+      switch (typeof value2) {
+        case "number":
+        case "bigint":
+          writeNumber(value2);
+          break;
+        case "string":
+          writeString(value2);
+          break;
+        case "boolean":
+          writeBoolean(value2);
+          break;
+      }
+      if (value2 instanceof Date) {
+        writeDate(value2);
+      } else if (value2 instanceof ArrayBuffer) {
+        writeData(value2);
+      } else if (isUID(value2)) {
+        writeUID(value2.CF$UID);
+      }
+      return;
+    }
+    switch (entry.type) {
+      case "dict":
+        writeDict(entry);
+        break;
+      case "array":
+        writeArray(entry);
+        break;
+      default:
+        throw new Error("unhandled entry type: " + entry.type);
+    }
+  }
+  function writeDate(value2) {
+    buffer = writeUInt(buffer, 51, 1);
+    const date = (value2.getTime() - EPOCH2) / 1000;
+    buffer = writeDouble(buffer, date);
+  }
+  function writeDict(entry) {
+    writeIntHeader(13, entry.entryKeys.length);
+    entry.entryKeys.forEach((entry2) => {
+      writeID(entry2.id);
+    });
+    entry.entryValues.forEach((entry2) => {
+      writeID(entry2.id);
+    });
+  }
+  function writeNumber(value2) {
+    if (typeof value2 === "bigint") {
+      const width = 16;
+      const hex = value2.toString(16);
+      const buf = fromHexString(hex.padStart(width * 2, "0").slice(0, width * 2));
+      buffer = writeUInt(buffer, 20, 1);
+      buffer = concat2(buffer, buf);
+    } else {
+      if (Number.isInteger(value2)) {
+        if (value2 < 0) {
+          buffer = writeUInt(buffer, 19, 1);
+          buffer = writeInt(buffer, value2, 8);
+        } else if (value2 <= 255) {
+          buffer = writeUInt(buffer, 16, 1);
+          buffer = writeUInt(buffer, value2, 1);
+        } else if (value2 <= 65535) {
+          buffer = writeUInt(buffer, 17, 1);
+          buffer = writeUInt(buffer, value2, 2);
+        } else if (value2 <= 4294967295) {
+          buffer = writeUInt(buffer, 18, 1);
+          buffer = writeUInt(buffer, value2, 4);
+        } else {
+          buffer = writeUInt(buffer, 19, 1);
+          buffer = writeUInt(buffer, value2, 8);
+        }
+      } else {
+        buffer = writeUInt(buffer, 35, 1);
+        buffer = writeDouble(buffer, value2);
+      }
+    }
+  }
+  function writeUID(uid) {
+    writeIntHeader(8, 0);
+    writeID(uid);
+  }
+  function writeArray(entry) {
+    writeIntHeader(10, entry.entries.length);
+    entry.entries.forEach((e) => {
+      writeID(e.id);
+    });
+  }
+  function writeBoolean(value2) {
+    buffer = writeUInt(buffer, value2 ? 9 : 8, 1);
+  }
+  function writeString(value2) {
+    if (mustBeUtf16(value2)) {
+      const utf16 = toUTF16(value2);
+      writeIntHeader(6, utf16.length / 2);
+      for (let i = 0;i < utf16.length; i += 2) {
+        const t = utf16[i + 0];
+        utf16[i + 0] = utf16[i + 1];
+        utf16[i + 1] = t;
+      }
+      buffer = concat2(buffer, utf16);
+    } else {
+      const utf8 = encoder.encode(value2);
+      writeIntHeader(5, utf8.length);
+      buffer = concat2(buffer, utf8);
+    }
+  }
+  function writeData(data) {
+    writeIntHeader(4, data.byteLength);
+    buffer = concat2(buffer, new Uint8Array(data));
+  }
+  function writeIntHeader(kind, value2) {
+    if (value2 < 15) {
+      buffer = writeUInt(buffer, (kind << 4) + value2, 1);
+    } else {
+      buffer = writeUInt(buffer, (kind << 4) + 15, 1);
+      writeNumber(value2);
+    }
+  }
+  function writeID(id) {
+    buffer = writeUInt(buffer, id, idSizeInBytes);
+  }
+  function mustBeUtf16(string) {
+    return encoder.encode(string).byteLength != string.length;
+  }
+};
+var typeofPrimitive = ["string", "number", "boolean", "bigint"];
+function toEntries(value) {
+  if (typeofPrimitive.includes(typeof value) || value instanceof ArrayBuffer || value instanceof Date || isUID(value)) {
+    return [
+      {
+        type: "primitive",
+        value
+      }
+    ];
+  }
+  if (value != null && typeof value === "object") {
+    return Array.isArray(value) ? toEntriesArray(value) : toEntriesObject(value);
+  }
+  throw new Error("unhandled entry: " + value);
+}
+function toEntriesArray(array) {
+  const entries = array.map(toEntries);
+  return [
+    {
+      type: "array",
+      value: undefined,
+      entries: entries.map((entries2) => entries2[0])
+    },
+    ...entries.flat()
+  ];
+}
+function toEntriesObject(dict) {
+  const entryKeys = Object.keys(dict).map(toEntries).flat(1);
+  const entryValues = Object.values(dict).map(toEntries);
+  return [
+    {
+      type: "dict",
+      value: undefined,
+      entryKeys,
+      entryValues: entryValues.map((entries) => entries[0])
+    },
+    ...entryKeys,
+    ...entryValues.flat()
+  ];
+}
+function computeOffsetSizeInBytes(maxOffset) {
+  if (maxOffset < 256) {
+    return 1;
+  }
+  if (maxOffset < 65536) {
+    return 2;
+  }
+  if (maxOffset < 4294967296) {
+    return 4;
+  }
+  return 8;
+}
+function computeIdSizeInBytes(numberOfIds) {
+  if (numberOfIds < 256) {
+    return 1;
+  }
+  if (numberOfIds < 65536) {
+    return 2;
+  }
+  return 4;
+}
 // src/rtsp.ts
 var exports_rtsp = {};
 __export(exports_rtsp, {

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@basmilius/apple-encoding",
     "description": "Common encoding utilities for Apple Protocols.",
-    "version": "0.5.3",
+    "version": "0.5.4",
     "type": "module",
     "license": "MIT",
     "author": {
@@ -38,12 +38,10 @@
             "default": "./dist/index.js"
         }
     },
-    "dependencies": {
-        "@plist/binary.parse": "^1.1.0",
-        "@plist/binary.serialize": "^1.1.0"
-    },
     "devDependencies": {
         "@basmilius/tools": "^2.23.0",
+        "@plist/binary.parse": "^1.1.0",
+        "@plist/binary.serialize": "^1.1.0",
         "@types/bun": "^1.3.8"
     }
 }