@fuman/plist 0.1.0

package/index.d.cts

@@ -0,0 +1,7 @@
+export * from './bplist-reader.js';
+export * from './bplist-writer.js';
+export * from './ns-keyed-archiver.js';
+export * from './ns-keyed-unarchiver.js';
+export * from './plist-reader.js';
+export * from './plist-writer.js';
+export * from './types.js';

package/index.d.ts

@@ -0,0 +1,7 @@
+export * from './bplist-reader.js';
+export * from './bplist-writer.js';
+export * from './ns-keyed-archiver.js';
+export * from './ns-keyed-unarchiver.js';
+export * from './plist-reader.js';
+export * from './plist-writer.js';
+export * from './types.js';

package/index.js

@@ -0,0 +1,17 @@
+import { readBinaryPlist } from "./bplist-reader.js";
+import { writeBinaryPlist } from "./bplist-writer.js";
+import { nsKeyedArchive } from "./ns-keyed-archiver.js";
+import { nsKeyedUnarchive } from "./ns-keyed-unarchiver.js";
+import { readXmlPlist } from "./plist-reader.js";
+import { writeXmlPlist } from "./plist-writer.js";
+import { KeyedArchiverValue, PlistValue } from "./types.js";
+export {
+  KeyedArchiverValue,
+  PlistValue,
+  nsKeyedArchive,
+  nsKeyedUnarchive,
+  readBinaryPlist,
+  readXmlPlist,
+  writeBinaryPlist,
+  writeXmlPlist
+};

package/ns-keyed-archiver.cjs

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const utils = require("@fuman/utils");
+const _constants = require("./_constants.cjs");
+const _utils = require("./_utils.cjs");
+const types = require("./types.cjs");
+const NsDictionaryHeader = {
+  $classname: "NSDictionary",
+  $classes: ["NSDictionary", "NSObject"]
+};
+const NsArrayHeader = {
+  $classname: "NSArray",
+  $classes: ["NSArray", "NSObject"]
+};
+const NsDateHeader = {
+  $classname: "NSDate",
+  $classes: ["NSDate", "NSObject"]
+};
+class NsKeyedArchiver {
+  #values = /* @__PURE__ */ new Map();
+  #objects = [];
+  #nextUid = 0;
+  #allocateUid() {
+    return new types.PlistValue("uid", this.#nextUid++);
+  }
+  #serializeObject(uid, header, object) {
+    let headerUid = this.#values.get(header);
+    if (!headerUid) {
+      headerUid = this.#allocateUid();
+      this.#values.set(header, headerUid);
+      this.#objects[_utils.safeToNumber(headerUid.value)] = header;
+    }
+    object.$class = headerUid;
+    this.#objects[_utils.safeToNumber(uid.value)] = object;
+    return uid;
+  }
+  #serializeValue(value) {
+    const existing = this.#values.get(value);
+    if (existing) return existing;
+    const uid = this.#allocateUid();
+    const uidValue = _utils.safeToNumber(uid.value);
+    this.#values.set(value, uid);
+    switch (typeof value) {
+      case "string":
+      case "number":
+      case "bigint":
+      case "boolean":
+        this.#objects[uidValue] = value;
+        return uid;
+      case "object": {
+        if (value === null) utils.unreachable();
+        let overrideHeader;
+        if (value instanceof types.KeyedArchiverValue) {
+          overrideHeader = value.header;
+          value = value.value;
+          if (typeof value === "string") {
+            return this.#serializeObject(uid, overrideHeader, {
+              "NS.string": value
+            });
+          }
+          if (value instanceof Uint8Array) {
+            return this.#serializeObject(uid, overrideHeader, {
+              "NS.data": value
+            });
+          }
+          if (value == null || typeof value !== "object") {
+            throw new Error("invalid value in KeyedArchiverValue", { cause: value });
+          }
+        }
+        if (value instanceof Uint8Array) {
+          this.#objects[uidValue] = value;
+          return uid;
+        }
+        if (value instanceof Date) {
+          return this.#serializeObject(uid, overrideHeader ?? NsDateHeader, {
+            "NS.time": (value.getTime() - _constants.CORE_DATA_EPOCH) / 1e3
+          });
+        }
+        if (value instanceof Set) value = Array.from(value);
+        if (value instanceof Map) value = Object.fromEntries(value);
+        if (Array.isArray(value)) {
+          const uids = value.map((item) => this.#serializeValue(item));
+          return this.#serializeObject(uid, overrideHeader ?? NsArrayHeader, {
+            "NS.objects": uids
+          });
+        }
+        const keyUids = [];
+        const valueUids = [];
+        for (const [key, dictValue] of Object.entries(value)) {
+          keyUids.push(this.#serializeValue(key));
+          valueUids.push(this.#serializeValue(dictValue));
+        }
+        return this.#serializeObject(uid, overrideHeader ?? NsDictionaryHeader, {
+          "NS.keys": keyUids,
+          "NS.objects": valueUids
+        });
+      }
+      default:
+        throw new Error(`invalid value: ${JSON.stringify(value)}`);
+    }
+  }
+  writeTop(value) {
+    this.#objects.push("$null");
+    this.#values.set(null, this.#allocateUid());
+    let top;
+    if (Array.isArray(value)) {
+      const obj = {};
+      for (let i = 0; i < value.length; i++) {
+        obj[`$${i}`] = this.#serializeValue(value[i]);
+      }
+      top = obj;
+    } else {
+      top = {
+        root: this.#serializeValue(value)
+      };
+    }
+    return {
+      $version: _constants.NS_KEYED_ARCHIVER_VERSION,
+      $archiver: "NSKeyedArchiver",
+      $top: top,
+      $objects: this.#objects
+    };
+  }
+}
+function nsKeyedArchive(data) {
+  const archiver = new NsKeyedArchiver();
+  return archiver.writeTop(data);
+}
+exports.nsKeyedArchive = nsKeyedArchive;

package/ns-keyed-archiver.d.cts

@@ -0,0 +1 @@
+export declare function nsKeyedArchive(data: unknown[] | Record<string, unknown>): Record<string, unknown>;

package/ns-keyed-archiver.d.ts

@@ -0,0 +1 @@
+export declare function nsKeyedArchive(data: unknown[] | Record<string, unknown>): Record<string, unknown>;

package/ns-keyed-archiver.js

@@ -0,0 +1,129 @@
+import { unreachable } from "@fuman/utils";
+import { CORE_DATA_EPOCH, NS_KEYED_ARCHIVER_VERSION } from "./_constants.js";
+import { safeToNumber } from "./_utils.js";
+import { PlistValue, KeyedArchiverValue } from "./types.js";
+const NsDictionaryHeader = {
+  $classname: "NSDictionary",
+  $classes: ["NSDictionary", "NSObject"]
+};
+const NsArrayHeader = {
+  $classname: "NSArray",
+  $classes: ["NSArray", "NSObject"]
+};
+const NsDateHeader = {
+  $classname: "NSDate",
+  $classes: ["NSDate", "NSObject"]
+};
+class NsKeyedArchiver {
+  #values = /* @__PURE__ */ new Map();
+  #objects = [];
+  #nextUid = 0;
+  #allocateUid() {
+    return new PlistValue("uid", this.#nextUid++);
+  }
+  #serializeObject(uid, header, object) {
+    let headerUid = this.#values.get(header);
+    if (!headerUid) {
+      headerUid = this.#allocateUid();
+      this.#values.set(header, headerUid);
+      this.#objects[safeToNumber(headerUid.value)] = header;
+    }
+    object.$class = headerUid;
+    this.#objects[safeToNumber(uid.value)] = object;
+    return uid;
+  }
+  #serializeValue(value) {
+    const existing = this.#values.get(value);
+    if (existing) return existing;
+    const uid = this.#allocateUid();
+    const uidValue = safeToNumber(uid.value);
+    this.#values.set(value, uid);
+    switch (typeof value) {
+      case "string":
+      case "number":
+      case "bigint":
+      case "boolean":
+        this.#objects[uidValue] = value;
+        return uid;
+      case "object": {
+        if (value === null) unreachable();
+        let overrideHeader;
+        if (value instanceof KeyedArchiverValue) {
+          overrideHeader = value.header;
+          value = value.value;
+          if (typeof value === "string") {
+            return this.#serializeObject(uid, overrideHeader, {
+              "NS.string": value
+            });
+          }
+          if (value instanceof Uint8Array) {
+            return this.#serializeObject(uid, overrideHeader, {
+              "NS.data": value
+            });
+          }
+          if (value == null || typeof value !== "object") {
+            throw new Error("invalid value in KeyedArchiverValue", { cause: value });
+          }
+        }
+        if (value instanceof Uint8Array) {
+          this.#objects[uidValue] = value;
+          return uid;
+        }
+        if (value instanceof Date) {
+          return this.#serializeObject(uid, overrideHeader ?? NsDateHeader, {
+            "NS.time": (value.getTime() - CORE_DATA_EPOCH) / 1e3
+          });
+        }
+        if (value instanceof Set) value = Array.from(value);
+        if (value instanceof Map) value = Object.fromEntries(value);
+        if (Array.isArray(value)) {
+          const uids = value.map((item) => this.#serializeValue(item));
+          return this.#serializeObject(uid, overrideHeader ?? NsArrayHeader, {
+            "NS.objects": uids
+          });
+        }
+        const keyUids = [];
+        const valueUids = [];
+        for (const [key, dictValue] of Object.entries(value)) {
+          keyUids.push(this.#serializeValue(key));
+          valueUids.push(this.#serializeValue(dictValue));
+        }
+        return this.#serializeObject(uid, overrideHeader ?? NsDictionaryHeader, {
+          "NS.keys": keyUids,
+          "NS.objects": valueUids
+        });
+      }
+      default:
+        throw new Error(`invalid value: ${JSON.stringify(value)}`);
+    }
+  }
+  writeTop(value) {
+    this.#objects.push("$null");
+    this.#values.set(null, this.#allocateUid());
+    let top;
+    if (Array.isArray(value)) {
+      const obj = {};
+      for (let i = 0; i < value.length; i++) {
+        obj[`$${i}`] = this.#serializeValue(value[i]);
+      }
+      top = obj;
+    } else {
+      top = {
+        root: this.#serializeValue(value)
+      };
+    }
+    return {
+      $version: NS_KEYED_ARCHIVER_VERSION,
+      $archiver: "NSKeyedArchiver",
+      $top: top,
+      $objects: this.#objects
+    };
+  }
+}
+function nsKeyedArchive(data) {
+  const archiver = new NsKeyedArchiver();
+  return archiver.writeTop(data);
+}
+export {
+  nsKeyedArchive
+};

package/ns-keyed-unarchiver.cjs

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const utils = require("@fuman/utils");
+const _constants = require("./_constants.cjs");
+const _utils = require("./_utils.cjs");
+const types = require("./types.cjs");
+function isUid(value) {
+  return value instanceof types.PlistValue && value.type === "uid";
+}
+function nsKeyedUnarchive(data, params) {
+  const { preserveType = false, extraHandlers } = params ?? {};
+  const extraHandlersEntries = extraHandlers ? utils.objectEntries(extraHandlers) : void 0;
+  utils.assert(typeof data === "object" && data !== null, "data is not an object");
+  utils.unsafeCastType(data);
+  if (data.$version !== _constants.NS_KEYED_ARCHIVER_VERSION) {
+    throw new Error("unsupported NSKeyedArchiver version");
+  }
+  if (data.$archiver !== "NSKeyedArchiver") {
+    throw new Error("invalid or missing $archiver");
+  }
+  utils.assertHasKey(data, "$objects");
+  utils.assert(Array.isArray(data.$objects), "$objects is not an array");
+  utils.assertHasKey(data, "$top");
+  utils.assert(typeof data.$top === "object" && data.$top !== null, "$top is not an object");
+  const objects = data.$objects;
+  const pending = /* @__PURE__ */ new Map();
+  function parseByUid(uid) {
+    const obj = objects[uid];
+    if (obj === "$null") return null;
+    if (typeof obj === "string" || typeof obj === "number" || typeof obj === "boolean" || obj instanceof Uint8Array) return obj;
+    if (typeof obj === "object" && obj !== null) {
+      utils.assertHasKey(obj, "$class");
+      utils.assert(isUid(obj.$class), "$class is not a UID");
+      const header = objects[_utils.safeToNumber(obj.$class.value)];
+      utils.assert(typeof header === "object" && header !== null, "referenced $class is not an object");
+      utils.assertHasKey(header, "$classes");
+      utils.assert(Array.isArray(header.$classes), "$classes is not an array");
+      utils.unsafeCastType(header);
+      const classes = header.$classes;
+      if (extraHandlersEntries) {
+        for (const [key, handler] of extraHandlersEntries) {
+          if (classes.includes(key)) {
+            return handler(obj, header, objects);
+          }
+        }
+      }
+      if (classes.includes("NSDictionary")) {
+        utils.assertHasKey(obj, "NS.keys");
+        utils.assertHasKey(obj, "NS.objects");
+        utils.assert(Array.isArray(obj["NS.keys"]), "NS.keys is not an array");
+        utils.assert(Array.isArray(obj["NS.objects"]), "NS.objects is not an array");
+        const keys = obj["NS.keys"];
+        const values = obj["NS.objects"];
+        if (keys.length !== values.length) {
+          throw new Error("invalid NSDictionary");
+        }
+        const result2 = {};
+        pending.set(uid, result2);
+        for (let i = 0; i < keys.length; i++) {
+          utils.assert(isUid(keys[i]), "key is not a UID");
+          utils.assert(isUid(values[i]), "value is not a UID");
+          const keyUid = _utils.safeToNumber(keys[i].value);
+          const valueUid = _utils.safeToNumber(values[i].value);
+          let parsedKey = parseByUid(keyUid);
+          if (preserveType && parsedKey instanceof types.KeyedArchiverValue) {
+            parsedKey = parsedKey.value;
+          }
+          utils.assert(typeof parsedKey === "string" || typeof parsedKey === "number", "key is not a string or number");
+          if (pending.has(valueUid)) {
+            result2[parsedKey] = pending.get(valueUid);
+          } else {
+            result2[parsedKey] = parseByUid(valueUid);
+          }
+        }
+        pending.delete(uid);
+        return preserveType ? new types.KeyedArchiverValue(header, result2) : result2;
+      }
+      if (classes.includes("NSDate")) {
+        utils.assertHasKey(obj, "NS.time");
+        utils.assert(typeof obj["NS.time"] === "number", "NS.time is not a number");
+        const val = new Date(obj["NS.time"] * 1e3 + _constants.CORE_DATA_EPOCH);
+        return preserveType ? new types.KeyedArchiverValue(header, val) : val;
+      }
+      const isSet = classes.includes("NSSet");
+      if (classes.includes("NSArray") || isSet) {
+        utils.assertHasKey(obj, "NS.objects");
+        utils.assert(Array.isArray(obj["NS.objects"]));
+        const result2 = [];
+        pending.set(uid, result2);
+        for (const value of obj["NS.objects"]) {
+          const valueUid = _utils.safeToNumber(value.value);
+          if (pending.has(valueUid)) {
+            result2.push(pending.get(valueUid));
+          } else {
+            result2.push(parseByUid(valueUid));
+          }
+        }
+        pending.delete(uid);
+        if (isSet) {
+          const set = new Set(result2);
+          return preserveType ? new types.KeyedArchiverValue(header, set) : set;
+        }
+        return preserveType ? new types.KeyedArchiverValue(header, result2) : result2;
+      }
+      if (classes.includes("NSString")) {
+        utils.assertHasKey(obj, "NS.string");
+        utils.assert(typeof obj["NS.string"] === "string");
+        const val = obj["NS.string"];
+        return preserveType ? new types.KeyedArchiverValue(header, val) : val;
+      }
+      if (classes.includes("NSData")) {
+        utils.assertHasKey(obj, "NS.data");
+        utils.assert(obj["NS.data"] instanceof Uint8Array);
+        const val = obj["NS.data"];
+        return preserveType ? new types.KeyedArchiverValue(header, val) : val;
+      }
+      const result = {};
+      pending.set(uid, result);
+      for (const key in obj) {
+        if (key === "$class") continue;
+        const value = obj[key];
+        if (isUid(value)) {
+          const valueUid = _utils.safeToNumber(value.value);
+          if (pending.has(valueUid)) {
+            result[key] = pending.get(valueUid);
+          } else {
+            result[key] = parseByUid(valueUid);
+          }
+        } else {
+          result[key] = value;
+        }
+      }
+      pending.delete(uid);
+      return new types.KeyedArchiverValue(header, result);
+    }
+  }
+  if (!("root" in data.$top)) {
+    const count = Object.keys(data.$top).length;
+    const array = [];
+    for (let i = 0; i < count; i++) {
+      const key = `$${i}`;
+      utils.assertHasKey(data.$top, key);
+      utils.assert(isUid(data.$top[key]), `${key} is not a UID`);
+      array.push(parseByUid(_utils.safeToNumber(data.$top[key].value)));
+    }
+    return array;
+  }
+  utils.assert(isUid(data.$top.root), "$top.root is not a UID");
+  const topObject = parseByUid(_utils.safeToNumber(data.$top.root.value));
+  if (typeof topObject !== "object" || topObject === null) {
+    throw new Error("top object is not an object");
+  }
+  return topObject;
+}
+exports.nsKeyedUnarchive = nsKeyedUnarchive;

package/ns-keyed-unarchiver.d.cts

@@ -0,0 +1,9 @@
+import { KeyedArchiverValueHeader } from './types.js';
+export declare function nsKeyedUnarchive(data: unknown, params?: {
+    /**
+     * if true, every value will be wrapped in {@link KeyedArchiverValue},
+     * allowing for lossless operation. otherwise, only unknown objects will be wrapped
+     */
+    preserveType?: boolean;
+    extraHandlers?: Record<string, (value: unknown, header: KeyedArchiverValueHeader, objects: unknown[]) => unknown>;
+}): unknown[] | Record<string, unknown>;

package/ns-keyed-unarchiver.d.ts

@@ -0,0 +1,9 @@
+import { KeyedArchiverValueHeader } from './types.js';
+export declare function nsKeyedUnarchive(data: unknown, params?: {
+    /**
+     * if true, every value will be wrapped in {@link KeyedArchiverValue},
+     * allowing for lossless operation. otherwise, only unknown objects will be wrapped
+     */
+    preserveType?: boolean;
+    extraHandlers?: Record<string, (value: unknown, header: KeyedArchiverValueHeader, objects: unknown[]) => unknown>;
+}): unknown[] | Record<string, unknown>;

package/ns-keyed-unarchiver.js

@@ -0,0 +1,155 @@
+import { objectEntries, assert, unsafeCastType, assertHasKey } from "@fuman/utils";
+import { NS_KEYED_ARCHIVER_VERSION, CORE_DATA_EPOCH } from "./_constants.js";
+import { safeToNumber } from "./_utils.js";
+import { PlistValue, KeyedArchiverValue } from "./types.js";
+function isUid(value) {
+  return value instanceof PlistValue && value.type === "uid";
+}
+function nsKeyedUnarchive(data, params) {
+  const { preserveType = false, extraHandlers } = params ?? {};
+  const extraHandlersEntries = extraHandlers ? objectEntries(extraHandlers) : void 0;
+  assert(typeof data === "object" && data !== null, "data is not an object");
+  unsafeCastType(data);
+  if (data.$version !== NS_KEYED_ARCHIVER_VERSION) {
+    throw new Error("unsupported NSKeyedArchiver version");
+  }
+  if (data.$archiver !== "NSKeyedArchiver") {
+    throw new Error("invalid or missing $archiver");
+  }
+  assertHasKey(data, "$objects");
+  assert(Array.isArray(data.$objects), "$objects is not an array");
+  assertHasKey(data, "$top");
+  assert(typeof data.$top === "object" && data.$top !== null, "$top is not an object");
+  const objects = data.$objects;
+  const pending = /* @__PURE__ */ new Map();
+  function parseByUid(uid) {
+    const obj = objects[uid];
+    if (obj === "$null") return null;
+    if (typeof obj === "string" || typeof obj === "number" || typeof obj === "boolean" || obj instanceof Uint8Array) return obj;
+    if (typeof obj === "object" && obj !== null) {
+      assertHasKey(obj, "$class");
+      assert(isUid(obj.$class), "$class is not a UID");
+      const header = objects[safeToNumber(obj.$class.value)];
+      assert(typeof header === "object" && header !== null, "referenced $class is not an object");
+      assertHasKey(header, "$classes");
+      assert(Array.isArray(header.$classes), "$classes is not an array");
+      unsafeCastType(header);
+      const classes = header.$classes;
+      if (extraHandlersEntries) {
+        for (const [key, handler] of extraHandlersEntries) {
+          if (classes.includes(key)) {
+            return handler(obj, header, objects);
+          }
+        }
+      }
+      if (classes.includes("NSDictionary")) {
+        assertHasKey(obj, "NS.keys");
+        assertHasKey(obj, "NS.objects");
+        assert(Array.isArray(obj["NS.keys"]), "NS.keys is not an array");
+        assert(Array.isArray(obj["NS.objects"]), "NS.objects is not an array");
+        const keys = obj["NS.keys"];
+        const values = obj["NS.objects"];
+        if (keys.length !== values.length) {
+          throw new Error("invalid NSDictionary");
+        }
+        const result2 = {};
+        pending.set(uid, result2);
+        for (let i = 0; i < keys.length; i++) {
+          assert(isUid(keys[i]), "key is not a UID");
+          assert(isUid(values[i]), "value is not a UID");
+          const keyUid = safeToNumber(keys[i].value);
+          const valueUid = safeToNumber(values[i].value);
+          let parsedKey = parseByUid(keyUid);
+          if (preserveType && parsedKey instanceof KeyedArchiverValue) {
+            parsedKey = parsedKey.value;
+          }
+          assert(typeof parsedKey === "string" || typeof parsedKey === "number", "key is not a string or number");
+          if (pending.has(valueUid)) {
+            result2[parsedKey] = pending.get(valueUid);
+          } else {
+            result2[parsedKey] = parseByUid(valueUid);
+          }
+        }
+        pending.delete(uid);
+        return preserveType ? new KeyedArchiverValue(header, result2) : result2;
+      }
+      if (classes.includes("NSDate")) {
+        assertHasKey(obj, "NS.time");
+        assert(typeof obj["NS.time"] === "number", "NS.time is not a number");
+        const val = new Date(obj["NS.time"] * 1e3 + CORE_DATA_EPOCH);
+        return preserveType ? new KeyedArchiverValue(header, val) : val;
+      }
+      const isSet = classes.includes("NSSet");
+      if (classes.includes("NSArray") || isSet) {
+        assertHasKey(obj, "NS.objects");
+        assert(Array.isArray(obj["NS.objects"]));
+        const result2 = [];
+        pending.set(uid, result2);
+        for (const value of obj["NS.objects"]) {
+          const valueUid = safeToNumber(value.value);
+          if (pending.has(valueUid)) {
+            result2.push(pending.get(valueUid));
+          } else {
+            result2.push(parseByUid(valueUid));
+          }
+        }
+        pending.delete(uid);
+        if (isSet) {
+          const set = new Set(result2);
+          return preserveType ? new KeyedArchiverValue(header, set) : set;
+        }
+        return preserveType ? new KeyedArchiverValue(header, result2) : result2;
+      }
+      if (classes.includes("NSString")) {
+        assertHasKey(obj, "NS.string");
+        assert(typeof obj["NS.string"] === "string");
+        const val = obj["NS.string"];
+        return preserveType ? new KeyedArchiverValue(header, val) : val;
+      }
+      if (classes.includes("NSData")) {
+        assertHasKey(obj, "NS.data");
+        assert(obj["NS.data"] instanceof Uint8Array);
+        const val = obj["NS.data"];
+        return preserveType ? new KeyedArchiverValue(header, val) : val;
+      }
+      const result = {};
+      pending.set(uid, result);
+      for (const key in obj) {
+        if (key === "$class") continue;
+        const value = obj[key];
+        if (isUid(value)) {
+          const valueUid = safeToNumber(value.value);
+          if (pending.has(valueUid)) {
+            result[key] = pending.get(valueUid);
+          } else {
+            result[key] = parseByUid(valueUid);
+          }
+        } else {
+          result[key] = value;
+        }
+      }
+      pending.delete(uid);
+      return new KeyedArchiverValue(header, result);
+    }
+  }
+  if (!("root" in data.$top)) {
+    const count = Object.keys(data.$top).length;
+    const array = [];
+    for (let i = 0; i < count; i++) {
+      const key = `$${i}`;
+      assertHasKey(data.$top, key);
+      assert(isUid(data.$top[key]), `${key} is not a UID`);
+      array.push(parseByUid(safeToNumber(data.$top[key].value)));
+    }
+    return array;
+  }
+  assert(isUid(data.$top.root), "$top.root is not a UID");
+  const topObject = parseByUid(safeToNumber(data.$top.root.value));
+  if (typeof topObject !== "object" || topObject === null) {
+    throw new Error("top object is not an object");
+  }
+  return topObject;
+}
+export {
+  nsKeyedUnarchive
+};

package/package.json

@@ -0,0 +1,30 @@
+{
+    "name": "@fuman/plist",
+    "type": "module",
+    "version": "0.1.0",
+    "description": "apple property list reader and writer",
+    "license": "MIT",
+    "dependencies": {
+        "@fuman/io": "^0.0.14",
+        "@fuman/utils": "^0.0.14"
+    },
+    "exports": {
+        ".": {
+            "import": {
+                "types": "./index.d.ts",
+                "default": "./index.js"
+            },
+            "require": {
+                "types": "./index.d.cts",
+                "default": "./index.cjs"
+            }
+        }
+    },
+    "sideEffects": false,
+    "author": "",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/teidesu/fuman.git"
+    },
+    "scripts": {}
+}