@fuman/plist 0.1.0

package/bplist-writer.cjs

@@ -0,0 +1,344 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const io = require("@fuman/io");
+const _constants = require("./_constants.cjs");
+const types = require("./types.cjs");
+function determineUintSize(value) {
+  if (value < 0) {
+    throw new Error(`unexpected negative value: ${value}`);
+  }
+  if (value < 256) {
+    return 1;
+  }
+  if (value < 65536) {
+    return 2;
+  }
+  if (value < 4294967296) {
+    return 4;
+  }
+  return 8;
+}
+function writeUint(bytes, value, size) {
+  switch (size) {
+    case 1:
+      io.write.uint8(bytes, value);
+      break;
+    case 2:
+      io.write.uint16be(bytes, value);
+      break;
+    case 4:
+      io.write.uint32be(bytes, value);
+      break;
+    case 8:
+      io.write.uint64be(bytes, value);
+      break;
+    default:
+      throw new Error(`invalid uint size: ${size}`);
+  }
+}
+function writeUintWithHeader(bytes, value, type = 16) {
+  const size = determineUintSize(value);
+  let headerSize;
+  if (size === 1) headerSize = 0;
+  else if (size === 2) headerSize = 1;
+  else if (size === 4) headerSize = 2;
+  else headerSize = 3;
+  io.write.uint8(bytes, type | headerSize);
+  writeUint(bytes, value, size);
+}
+function writeSizeHeader(bytes, type, size) {
+  if (size < 15) {
+    io.write.uint8(bytes, type | size);
+  } else {
+    io.write.uint8(bytes, type | 15);
+    writeUintWithHeader(bytes, size);
+  }
+}
+function isAscii(value) {
+  return /^[\x00-\x7F]*$/.test(value);
+}
+const INT32_MAX = 2 ** 31 - 1;
+const INT64_MAX = 2n ** 63n - 1n;
+const INT64_MIN = -(2n ** 63n);
+const INT128_MAX = 2n ** 127n - 1n;
+const INT128_MIN = -(2n ** 127n);
+function handleInt(id, value) {
+  if (value < 0 || value > INT32_MAX) {
+    value = BigInt(value);
+  }
+  if (typeof value === "number") {
+    return { id, type: "int", value, size: determineUintSize(value) };
+  }
+  const value_ = value;
+  if (value_ < INT64_MIN || value_ > INT64_MAX) {
+    if (value_ < INT128_MIN || value_ > INT128_MAX) {
+      throw new Error(`value is too large: ${value_}`);
+    }
+    return {
+      id,
+      type: "int",
+      value: value_,
+      size: 16
+    };
+  }
+  return {
+    id,
+    type: "int",
+    value: value_,
+    size: 8
+  };
+}
+class BinaryPlistWriter {
+  #nextId = 0;
+  #values = /* @__PURE__ */ new Map();
+  constructor() {
+    this.toPlistEntry = this.toPlistEntry.bind(this);
+  }
+  toPlistEntry(value) {
+    switch (typeof value) {
+      case "string": {
+        const existingId = this.#values.get(value);
+        if (existingId !== void 0) {
+          return existingId;
+        }
+        const id = this.#nextId++;
+        this.#values.set(value, id);
+        return {
+          id,
+          type: "string",
+          value,
+          format: isAscii(value) ? "ascii" : "utf16"
+        };
+      }
+      case "number":
+      case "bigint": {
+        const existingId = this.#values.get(value);
+        if (existingId !== void 0) {
+          return existingId;
+        }
+        const id = this.#nextId++;
+        this.#values.set(value, id);
+        if (typeof value === "number") {
+          if (value % 1 !== 0) {
+            return { id, type: "real", value, size: 8 };
+          }
+        }
+        return handleInt(id, value);
+      }
+      case "boolean": {
+        const existingId = this.#values.get(value);
+        if (existingId !== void 0) {
+          return existingId;
+        }
+        const id = this.#nextId++;
+        this.#values.set(value, id);
+        return { id, type: "bool", value };
+      }
+      case "object": {
+        if (value === null) {
+          const existingId = this.#values.get(value);
+          if (existingId !== void 0) {
+            return existingId;
+          }
+          const id2 = this.#nextId++;
+          this.#values.set(value, id2);
+          return { id: id2, type: "null" };
+        }
+        const id = this.#nextId++;
+        if (value instanceof Date) return { id, type: "date", value };
+        if (value instanceof Uint8Array) return { id, type: "data", value };
+        if (Array.isArray(value)) return { id, type: "array", items: value.map(this.toPlistEntry) };
+        if (value instanceof Set) return { id, type: "set", items: Array.from(value).map(this.toPlistEntry) };
+        if (value instanceof types.PlistValue) {
+          switch (value.type) {
+            case "float32":
+              return { id, type: "real", value: value.value, size: 4 };
+            case "float64":
+              return { id, type: "real", value: value.value, size: 8 };
+            case "int":
+              return handleInt(id, value.value);
+            case "uid":
+              return { id, type: "uid", value: value.value, size: determineUintSize(value.value) };
+            case "ascii":
+              return { id, type: "string", value: value.value, format: "ascii" };
+            case "utf16":
+              return { id, type: "string", value: value.value, format: "utf16" };
+            case "utf8":
+              return { id, type: "string", value: value.value, format: "utf8" };
+            default:
+              throw new Error(`unsupported plist value type: ${value.type}`);
+          }
+        }
+        const objEntries = value instanceof Map ? Array.from(value.entries()) : Object.entries(value);
+        const entries = [];
+        for (let i = 0; i < objEntries.length; i++) {
+          const [key, value2] = objEntries[i];
+          entries.push({ key: this.toPlistEntry(key), value: this.toPlistEntry(value2) });
+        }
+        return { id: this.#nextId++, type: "dict", entries };
+      }
+      default:
+        throw new Error(`unexpected value type: ${typeof value}`);
+    }
+  }
+  #offsetTable;
+  #objectRefSize;
+  writeRef(bytes, id) {
+    writeUint(bytes, id, this.#objectRefSize);
+  }
+  writeEntry(bytes, entry) {
+    if (typeof entry === "number") return entry;
+    switch (entry.type) {
+      case "null":
+        this.#offsetTable[entry.id] = bytes.written;
+        io.write.uint8(bytes, 0);
+        break;
+      case "bool":
+        this.#offsetTable[entry.id] = bytes.written;
+        io.write.uint8(bytes, entry.value ? 9 : 8);
+        break;
+      case "int": {
+        this.#offsetTable[entry.id] = bytes.written;
+        switch (entry.size) {
+          case 1: {
+            io.write.uint8(bytes, 16);
+            io.write.uint8(bytes, entry.value);
+            break;
+          }
+          case 2: {
+            io.write.uint8(bytes, 17);
+            io.write.uint16be(bytes, entry.value);
+            break;
+          }
+          case 4: {
+            io.write.uint8(bytes, 18);
+            io.write.uint32be(bytes, entry.value);
+            break;
+          }
+          case 8: {
+            io.write.uint8(bytes, 19);
+            io.write.int64be(bytes, entry.value);
+            break;
+          }
+          case 16: {
+            io.write.uint8(bytes, 20);
+            io.write.intbe(bytes, 16, entry.value);
+            break;
+          }
+          default:
+            throw new Error(`invalid int size: ${entry.size}`);
+        }
+        break;
+      }
+      case "real": {
+        this.#offsetTable[entry.id] = bytes.written;
+        switch (entry.size) {
+          case 4: {
+            io.write.uint8(bytes, 34);
+            io.write.float32be(bytes, entry.value);
+            break;
+          }
+          case 8: {
+            io.write.uint8(bytes, 35);
+            io.write.float64be(bytes, entry.value);
+            break;
+          }
+          default:
+            throw new Error(`invalid real size: ${entry.size}`);
+        }
+        break;
+      }
+      case "date": {
+        this.#offsetTable[entry.id] = bytes.written;
+        io.write.uint8(bytes, 51);
+        const seconds = (entry.value.getTime() - _constants.CORE_DATA_EPOCH) / 1e3;
+        io.write.float64be(bytes, seconds);
+        break;
+      }
+      case "data":
+        this.#offsetTable[entry.id] = bytes.written;
+        writeSizeHeader(bytes, 64, entry.value.length);
+        io.write.bytes(bytes, entry.value);
+        break;
+      case "string": {
+        this.#offsetTable[entry.id] = bytes.written;
+        switch (entry.format) {
+          case "ascii":
+            writeSizeHeader(bytes, 80, entry.value.length);
+            io.write.rawString(bytes, entry.value);
+            break;
+          case "utf16":
+            writeSizeHeader(bytes, 96, entry.value.length);
+            io.write.utf16beString(bytes, entry.value);
+            break;
+          case "utf8":
+            writeSizeHeader(bytes, 112, entry.value.length);
+            io.write.utf8String(bytes, entry.value);
+            break;
+          default:
+            throw new Error(`invalid string format: ${entry.format}`);
+        }
+        break;
+      }
+      case "uid":
+        this.#offsetTable[entry.id] = bytes.written;
+        writeUintWithHeader(bytes, entry.value, 128);
+        break;
+      case "array":
+      case "set": {
+        const type = entry.type === "array" ? 160 : 176;
+        const refs = [];
+        for (const item of entry.items) {
+          refs.push(this.writeEntry(bytes, item));
+        }
+        this.#offsetTable[entry.id] = bytes.written;
+        writeSizeHeader(bytes, type, refs.length);
+        refs.forEach((ref) => this.writeRef(bytes, ref));
+        break;
+      }
+      case "dict": {
+        const keyRefs = [];
+        const valueRefs = [];
+        for (const { key, value } of entry.entries) {
+          keyRefs.push(this.writeEntry(bytes, key));
+          valueRefs.push(this.writeEntry(bytes, value));
+        }
+        this.#offsetTable[entry.id] = bytes.written;
+        writeSizeHeader(bytes, 208, entry.entries.length);
+        keyRefs.forEach((ref) => this.writeRef(bytes, ref));
+        valueRefs.forEach((ref) => this.writeRef(bytes, ref));
+        break;
+      }
+    }
+    return entry.id;
+  }
+  writeTop(data) {
+    const topEntry = this.toPlistEntry(data);
+    const numObjects = this.#nextId;
+    if (numObjects > _constants.MAX_OBJECT_COUNT) {
+      throw new Error("MAX_OBJECT_COUNT exceeded");
+    }
+    this.#objectRefSize = determineUintSize(numObjects);
+    this.#offsetTable = Array.from({ length: numObjects });
+    const bytes = io.Bytes.alloc();
+    io.write.bytes(bytes, _constants.BPLIST_MAGIC);
+    io.write.int16be(bytes, 12336);
+    this.writeEntry(bytes, topEntry);
+    const offsetTableOffset = bytes.written;
+    const offsetSize = determineUintSize(bytes.written);
+    for (let i = 0; i < this.#offsetTable.length; i++) {
+      writeUint(bytes, this.#offsetTable[i], offsetSize);
+    }
+    io.write.bytes(bytes, new Uint8Array([0, 0, 0, 0, 0, 0]));
+    io.write.uint8(bytes, offsetSize);
+    io.write.uint8(bytes, this.#objectRefSize);
+    io.write.uint64be(bytes, BigInt(numObjects));
+    io.write.uint64be(bytes, BigInt(topEntry.id));
+    io.write.uint64be(bytes, BigInt(offsetTableOffset));
+    return bytes.result();
+  }
+}
+function writeBinaryPlist(data) {
+  return new BinaryPlistWriter().writeTop(data);
+}
+exports.writeBinaryPlist = writeBinaryPlist;

package/bplist-writer.d.cts

@@ -0,0 +1 @@
+export declare function writeBinaryPlist(data: unknown): Uint8Array;

package/bplist-writer.d.ts

@@ -0,0 +1 @@
+export declare function writeBinaryPlist(data: unknown): Uint8Array;

package/bplist-writer.js

@@ -0,0 +1,344 @@
+import { write, Bytes } from "@fuman/io";
+import { CORE_DATA_EPOCH, MAX_OBJECT_COUNT, BPLIST_MAGIC } from "./_constants.js";
+import { PlistValue } from "./types.js";
+function determineUintSize(value) {
+  if (value < 0) {
+    throw new Error(`unexpected negative value: ${value}`);
+  }
+  if (value < 256) {
+    return 1;
+  }
+  if (value < 65536) {
+    return 2;
+  }
+  if (value < 4294967296) {
+    return 4;
+  }
+  return 8;
+}
+function writeUint(bytes, value, size) {
+  switch (size) {
+    case 1:
+      write.uint8(bytes, value);
+      break;
+    case 2:
+      write.uint16be(bytes, value);
+      break;
+    case 4:
+      write.uint32be(bytes, value);
+      break;
+    case 8:
+      write.uint64be(bytes, value);
+      break;
+    default:
+      throw new Error(`invalid uint size: ${size}`);
+  }
+}
+function writeUintWithHeader(bytes, value, type = 16) {
+  const size = determineUintSize(value);
+  let headerSize;
+  if (size === 1) headerSize = 0;
+  else if (size === 2) headerSize = 1;
+  else if (size === 4) headerSize = 2;
+  else headerSize = 3;
+  write.uint8(bytes, type | headerSize);
+  writeUint(bytes, value, size);
+}
+function writeSizeHeader(bytes, type, size) {
+  if (size < 15) {
+    write.uint8(bytes, type | size);
+  } else {
+    write.uint8(bytes, type | 15);
+    writeUintWithHeader(bytes, size);
+  }
+}
+function isAscii(value) {
+  return /^[\x00-\x7F]*$/.test(value);
+}
+const INT32_MAX = 2 ** 31 - 1;
+const INT64_MAX = 2n ** 63n - 1n;
+const INT64_MIN = -(2n ** 63n);
+const INT128_MAX = 2n ** 127n - 1n;
+const INT128_MIN = -(2n ** 127n);
+function handleInt(id, value) {
+  if (value < 0 || value > INT32_MAX) {
+    value = BigInt(value);
+  }
+  if (typeof value === "number") {
+    return { id, type: "int", value, size: determineUintSize(value) };
+  }
+  const value_ = value;
+  if (value_ < INT64_MIN || value_ > INT64_MAX) {
+    if (value_ < INT128_MIN || value_ > INT128_MAX) {
+      throw new Error(`value is too large: ${value_}`);
+    }
+    return {
+      id,
+      type: "int",
+      value: value_,
+      size: 16
+    };
+  }
+  return {
+    id,
+    type: "int",
+    value: value_,
+    size: 8
+  };
+}
+class BinaryPlistWriter {
+  #nextId = 0;
+  #values = /* @__PURE__ */ new Map();
+  constructor() {
+    this.toPlistEntry = this.toPlistEntry.bind(this);
+  }
+  toPlistEntry(value) {
+    switch (typeof value) {
+      case "string": {
+        const existingId = this.#values.get(value);
+        if (existingId !== void 0) {
+          return existingId;
+        }
+        const id = this.#nextId++;
+        this.#values.set(value, id);
+        return {
+          id,
+          type: "string",
+          value,
+          format: isAscii(value) ? "ascii" : "utf16"
+        };
+      }
+      case "number":
+      case "bigint": {
+        const existingId = this.#values.get(value);
+        if (existingId !== void 0) {
+          return existingId;
+        }
+        const id = this.#nextId++;
+        this.#values.set(value, id);
+        if (typeof value === "number") {
+          if (value % 1 !== 0) {
+            return { id, type: "real", value, size: 8 };
+          }
+        }
+        return handleInt(id, value);
+      }
+      case "boolean": {
+        const existingId = this.#values.get(value);
+        if (existingId !== void 0) {
+          return existingId;
+        }
+        const id = this.#nextId++;
+        this.#values.set(value, id);
+        return { id, type: "bool", value };
+      }
+      case "object": {
+        if (value === null) {
+          const existingId = this.#values.get(value);
+          if (existingId !== void 0) {
+            return existingId;
+          }
+          const id2 = this.#nextId++;
+          this.#values.set(value, id2);
+          return { id: id2, type: "null" };
+        }
+        const id = this.#nextId++;
+        if (value instanceof Date) return { id, type: "date", value };
+        if (value instanceof Uint8Array) return { id, type: "data", value };
+        if (Array.isArray(value)) return { id, type: "array", items: value.map(this.toPlistEntry) };
+        if (value instanceof Set) return { id, type: "set", items: Array.from(value).map(this.toPlistEntry) };
+        if (value instanceof PlistValue) {
+          switch (value.type) {
+            case "float32":
+              return { id, type: "real", value: value.value, size: 4 };
+            case "float64":
+              return { id, type: "real", value: value.value, size: 8 };
+            case "int":
+              return handleInt(id, value.value);
+            case "uid":
+              return { id, type: "uid", value: value.value, size: determineUintSize(value.value) };
+            case "ascii":
+              return { id, type: "string", value: value.value, format: "ascii" };
+            case "utf16":
+              return { id, type: "string", value: value.value, format: "utf16" };
+            case "utf8":
+              return { id, type: "string", value: value.value, format: "utf8" };
+            default:
+              throw new Error(`unsupported plist value type: ${value.type}`);
+          }
+        }
+        const objEntries = value instanceof Map ? Array.from(value.entries()) : Object.entries(value);
+        const entries = [];
+        for (let i = 0; i < objEntries.length; i++) {
+          const [key, value2] = objEntries[i];
+          entries.push({ key: this.toPlistEntry(key), value: this.toPlistEntry(value2) });
+        }
+        return { id: this.#nextId++, type: "dict", entries };
+      }
+      default:
+        throw new Error(`unexpected value type: ${typeof value}`);
+    }
+  }
+  #offsetTable;
+  #objectRefSize;
+  writeRef(bytes, id) {
+    writeUint(bytes, id, this.#objectRefSize);
+  }
+  writeEntry(bytes, entry) {
+    if (typeof entry === "number") return entry;
+    switch (entry.type) {
+      case "null":
+        this.#offsetTable[entry.id] = bytes.written;
+        write.uint8(bytes, 0);
+        break;
+      case "bool":
+        this.#offsetTable[entry.id] = bytes.written;
+        write.uint8(bytes, entry.value ? 9 : 8);
+        break;
+      case "int": {
+        this.#offsetTable[entry.id] = bytes.written;
+        switch (entry.size) {
+          case 1: {
+            write.uint8(bytes, 16);
+            write.uint8(bytes, entry.value);
+            break;
+          }
+          case 2: {
+            write.uint8(bytes, 17);
+            write.uint16be(bytes, entry.value);
+            break;
+          }
+          case 4: {
+            write.uint8(bytes, 18);
+            write.uint32be(bytes, entry.value);
+            break;
+          }
+          case 8: {
+            write.uint8(bytes, 19);
+            write.int64be(bytes, entry.value);
+            break;
+          }
+          case 16: {
+            write.uint8(bytes, 20);
+            write.intbe(bytes, 16, entry.value);
+            break;
+          }
+          default:
+            throw new Error(`invalid int size: ${entry.size}`);
+        }
+        break;
+      }
+      case "real": {
+        this.#offsetTable[entry.id] = bytes.written;
+        switch (entry.size) {
+          case 4: {
+            write.uint8(bytes, 34);
+            write.float32be(bytes, entry.value);
+            break;
+          }
+          case 8: {
+            write.uint8(bytes, 35);
+            write.float64be(bytes, entry.value);
+            break;
+          }
+          default:
+            throw new Error(`invalid real size: ${entry.size}`);
+        }
+        break;
+      }
+      case "date": {
+        this.#offsetTable[entry.id] = bytes.written;
+        write.uint8(bytes, 51);
+        const seconds = (entry.value.getTime() - CORE_DATA_EPOCH) / 1e3;
+        write.float64be(bytes, seconds);
+        break;
+      }
+      case "data":
+        this.#offsetTable[entry.id] = bytes.written;
+        writeSizeHeader(bytes, 64, entry.value.length);
+        write.bytes(bytes, entry.value);
+        break;
+      case "string": {
+        this.#offsetTable[entry.id] = bytes.written;
+        switch (entry.format) {
+          case "ascii":
+            writeSizeHeader(bytes, 80, entry.value.length);
+            write.rawString(bytes, entry.value);
+            break;
+          case "utf16":
+            writeSizeHeader(bytes, 96, entry.value.length);
+            write.utf16beString(bytes, entry.value);
+            break;
+          case "utf8":
+            writeSizeHeader(bytes, 112, entry.value.length);
+            write.utf8String(bytes, entry.value);
+            break;
+          default:
+            throw new Error(`invalid string format: ${entry.format}`);
+        }
+        break;
+      }
+      case "uid":
+        this.#offsetTable[entry.id] = bytes.written;
+        writeUintWithHeader(bytes, entry.value, 128);
+        break;
+      case "array":
+      case "set": {
+        const type = entry.type === "array" ? 160 : 176;
+        const refs = [];
+        for (const item of entry.items) {
+          refs.push(this.writeEntry(bytes, item));
+        }
+        this.#offsetTable[entry.id] = bytes.written;
+        writeSizeHeader(bytes, type, refs.length);
+        refs.forEach((ref) => this.writeRef(bytes, ref));
+        break;
+      }
+      case "dict": {
+        const keyRefs = [];
+        const valueRefs = [];
+        for (const { key, value } of entry.entries) {
+          keyRefs.push(this.writeEntry(bytes, key));
+          valueRefs.push(this.writeEntry(bytes, value));
+        }
+        this.#offsetTable[entry.id] = bytes.written;
+        writeSizeHeader(bytes, 208, entry.entries.length);
+        keyRefs.forEach((ref) => this.writeRef(bytes, ref));
+        valueRefs.forEach((ref) => this.writeRef(bytes, ref));
+        break;
+      }
+    }
+    return entry.id;
+  }
+  writeTop(data) {
+    const topEntry = this.toPlistEntry(data);
+    const numObjects = this.#nextId;
+    if (numObjects > MAX_OBJECT_COUNT) {
+      throw new Error("MAX_OBJECT_COUNT exceeded");
+    }
+    this.#objectRefSize = determineUintSize(numObjects);
+    this.#offsetTable = Array.from({ length: numObjects });
+    const bytes = Bytes.alloc();
+    write.bytes(bytes, BPLIST_MAGIC);
+    write.int16be(bytes, 12336);
+    this.writeEntry(bytes, topEntry);
+    const offsetTableOffset = bytes.written;
+    const offsetSize = determineUintSize(bytes.written);
+    for (let i = 0; i < this.#offsetTable.length; i++) {
+      writeUint(bytes, this.#offsetTable[i], offsetSize);
+    }
+    write.bytes(bytes, new Uint8Array([0, 0, 0, 0, 0, 0]));
+    write.uint8(bytes, offsetSize);
+    write.uint8(bytes, this.#objectRefSize);
+    write.uint64be(bytes, BigInt(numObjects));
+    write.uint64be(bytes, BigInt(topEntry.id));
+    write.uint64be(bytes, BigInt(offsetTableOffset));
+    return bytes.result();
+  }
+}
+function writeBinaryPlist(data) {
+  return new BinaryPlistWriter().writeTop(data);
+}
+export {
+  writeBinaryPlist
+};

package/index.cjs

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const bplistReader = require("./bplist-reader.cjs");
+const bplistWriter = require("./bplist-writer.cjs");
+const nsKeyedArchiver = require("./ns-keyed-archiver.cjs");
+const nsKeyedUnarchiver = require("./ns-keyed-unarchiver.cjs");
+const plistReader = require("./plist-reader.cjs");
+const plistWriter = require("./plist-writer.cjs");
+const types = require("./types.cjs");
+exports.readBinaryPlist = bplistReader.readBinaryPlist;
+exports.writeBinaryPlist = bplistWriter.writeBinaryPlist;
+exports.nsKeyedArchive = nsKeyedArchiver.nsKeyedArchive;
+exports.nsKeyedUnarchive = nsKeyedUnarchiver.nsKeyedUnarchive;
+exports.readXmlPlist = plistReader.readXmlPlist;
+exports.writeXmlPlist = plistWriter.writeXmlPlist;
+exports.KeyedArchiverValue = types.KeyedArchiverValue;
+exports.PlistValue = types.PlistValue;