@basmilius/apple-encoding 0.3.3 → 0.4.1

package/dist/index.js

@@ -68,50 +68,112 @@ function encode(fields) {
 // src/opack.ts
 var exports_opack = {};
 __export(exports_opack, {
-  sizedInt: () => sizedInt,
+  sizedInteger: () => sizedInteger,
   int: () => int,
   float: () => float,
   encode: () => encode2,
   decode: () => decode2
 });
+var TAG = {
+  TRUE: 1,
+  FALSE: 2,
+  TERMINATOR: 3,
+  NULL: 4,
+  UUID: 5,
+  TIMESTAMP: 6,
+  INT_BASE: 8,
+  INT_INLINE_MAX_VALUE: 39,
+  INT_MAX_INLINE: 47,
+  INT_1BYTE: 48,
+  INT_2BYTE: 49,
+  INT_4BYTE: 50,
+  INT_8BYTE: 51,
+  FLOAT32: 53,
+  FLOAT64: 54,
+  STR_BASE: 64,
+  STR_MAX_INLINE: 96,
+  STR_1BYTE_LEN: 97,
+  STR_2BYTE_LEN: 98,
+  STR_3BYTE_LEN: 99,
+  STR_4BYTE_LEN: 100,
+  BYTES_BASE: 112,
+  BYTES_MAX_INLINE: 144,
+  BYTES_1BYTE_LEN: 145,
+  BYTES_2BYTE_LEN: 146,
+  BYTES_4BYTE_LEN: 147,
+  REF_BASE: 160,
+  REF_MAX_INLINE: 192,
+  REF_1BYTE: 193,
+  REF_2BYTE: 194,
+  REF_4BYTE: 195,
+  REF_8BYTE: 196,
+  ARRAY_BASE: 208,
+  ARRAY_VARIABLE: 223,
+  DICT_BASE: 224,
+  DICT_VARIABLE: 239,
+  DICT_TERMINATOR: 129
+};
 
-class OPackSizedInt extends Number {
-  size;
-  constructor(value, size) {
-    super(value);
-    this.size = size;
+class Float {
+  get value() {
+    return this.#value;
   }
-}
-
-class OPackFloat {
-  value;
+  #value;
   constructor(value) {
-    this.value = value;
+    this.#value = value;
   }
 }
 
-class OPackInteger {
-  value;
+class Integer {
+  get value() {
+    return this.#value;
+  }
+  #value;
   constructor(value) {
-    this.value = value;
+    this.#value = value;
   }
 }
-function sizedInt(value, size) {
-  return new OPackSizedInt(value, size);
+
+class SizedInteger {
+  get size() {
+    return this.#size;
+  }
+  get value() {
+    return this.#value;
+  }
+  #size;
+  #value;
+  constructor(value, size) {
+    this.#size = size;
+    this.#value = value;
+  }
+  valueOf() {
+    return this.#value;
+  }
 }
 function float(value) {
-  return new OPackFloat(value);
+  return new Float(value);
 }
 function int(value) {
-  return new OPackInteger(value);
+  return new Integer(value);
+}
+function sizedInteger(value, size) {
+  return new SizedInteger(value, size);
+}
+function decode2(data) {
+  const [value] = _unpack(data, []);
+  return value;
+}
+function encode2(data) {
+  return _pack(data, []);
 }
-function concat(arr) {
-  const total = arr.reduce((s, a) => s + a.length, 0);
+function concat(arrays) {
+  const total = arrays.reduce((sum, a) => sum + a.length, 0);
   const out = new Uint8Array(total);
-  let off = 0;
-  for (const a of arr) {
-    out.set(a, off);
-    off += a.length;
+  let offset = 0;
+  for (const a of arrays) {
+    out.set(a, offset);
+    offset += a.length;
   }
   return out;
 }
@@ -127,93 +189,99 @@ function uintToLEBytes(value, byteLen) {
   }
   return out;
 }
-function concatUint8Arrays(arrays) {
-  const total = arrays.reduce((sum, a) => sum + a.length, 0);
-  const out = new Uint8Array(total);
-  let offset = 0;
-  for (const a of arrays) {
-    out.set(a, offset);
-    offset += a.length;
+function ensureAvailable(buf, need) {
+  if (buf.length < need) {
+    throw new TypeError(`Not enough data: need ${need} bytes, have ${buf.length}`);
   }
-  return out;
 }
-function encode2(data) {
-  return _pack(data, []);
+function readLittleEndian(buf, offset, len) {
+  ensureAvailable(buf.subarray(offset), len);
+  let v = 0n;
+  for (let i = len - 1;i >= 0; i--) {
+    v = v << 8n | BigInt(buf[offset + i]);
+  }
+  return Number(v);
 }
 function _pack(data, objectList) {
   let packed = null;
-  if (data === null || data === undefined)
-    packed = u8(4);
-  else if (typeof data === "boolean")
-    packed = u8(data ? 1 : 2);
-  else if (data instanceof OPackFloat) {
+  if (data === null || data === undefined) {
+    packed = u8(TAG.NULL);
+  } else if (typeof data === "boolean") {
+    packed = u8(data ? TAG.TRUE : TAG.FALSE);
+  } else if (data instanceof Float) {
     const buf = new ArrayBuffer(8);
     new DataView(buf).setFloat64(0, data.value, true);
-    packed = concat([u8(54), new Uint8Array(buf)]);
-  } else if (data instanceof OPackInteger) {
+    packed = concat([u8(TAG.FLOAT64), new Uint8Array(buf)]);
+  } else if (data instanceof Integer) {
     const val = data.value;
-    if (val < 40)
-      packed = u8(8 + val);
-    else if (val <= 255)
-      packed = concatUint8Arrays([u8(48), uintToLEBytes(val, 1)]);
-    else if (val <= 65535)
-      packed = concatUint8Arrays([u8(49), uintToLEBytes(val, 2)]);
-    else if (val <= 4294967295)
-      packed = concatUint8Arrays([u8(50), uintToLEBytes(val, 4)]);
-    else
-      packed = concatUint8Arrays([u8(51), uintToLEBytes(val, 8)]);
+    if (val <= TAG.INT_INLINE_MAX_VALUE) {
+      packed = u8(TAG.INT_BASE + val);
+    } else if (val <= 255) {
+      packed = concat([u8(TAG.INT_1BYTE), uintToLEBytes(val, 1)]);
+    } else if (val <= 65535) {
+      packed = concat([u8(TAG.INT_2BYTE), uintToLEBytes(val, 2)]);
+    } else if (val <= 4294967295) {
+      packed = concat([u8(TAG.INT_4BYTE), uintToLEBytes(val, 4)]);
+    } else {
+      packed = concat([u8(TAG.INT_8BYTE), uintToLEBytes(val, 8)]);
+    }
   } else if (typeof data === "number") {
     if (!Number.isInteger(data)) {
       const buf = new ArrayBuffer(8);
       new DataView(buf).setFloat64(0, data, true);
-      packed = concat([u8(54), new Uint8Array(buf)]);
+      packed = concat([u8(TAG.FLOAT64), new Uint8Array(buf)]);
     } else {
-      if (data < 40)
-        packed = u8(8 + data);
-      else if (data <= 255)
-        packed = concat([u8(48), uintToLEBytes(data, 1)]);
-      else if (data <= 65535)
-        packed = concat([u8(49), uintToLEBytes(data, 2)]);
-      else if (data <= 4294967295)
-        packed = concat([u8(50), uintToLEBytes(data, 4)]);
-      else
-        packed = concat([u8(51), uintToLEBytes(data, 8)]);
+      if (data <= TAG.INT_INLINE_MAX_VALUE) {
+        packed = u8(TAG.INT_BASE + data);
+      } else if (data <= 255) {
+        packed = concat([u8(TAG.INT_1BYTE), uintToLEBytes(data, 1)]);
+      } else if (data <= 65535) {
+        packed = concat([u8(TAG.INT_2BYTE), uintToLEBytes(data, 2)]);
+      } else if (data <= 4294967295) {
+        packed = concat([u8(TAG.INT_4BYTE), uintToLEBytes(data, 4)]);
+      } else {
+        packed = concat([u8(TAG.INT_8BYTE), uintToLEBytes(data, 8)]);
+      }
     }
-  } else if (data instanceof OPackSizedInt) {
-    packed = concat([u8(48 + Math.log2(data.size)), uintToLEBytes(data.valueOf(), data.size)]);
+  } else if (data instanceof SizedInteger) {
+    packed = concat([u8(TAG.INT_1BYTE + Math.log2(data.size)), uintToLEBytes(data.valueOf(), data.size)]);
   } else if (typeof data === "string") {
     const b = new TextEncoder().encode(data);
     const len = b.length;
-    if (len <= 32)
-      packed = concat([u8(64 + len), b]);
-    else if (len <= 255)
-      packed = concat([u8(97), uintToLEBytes(len, 1), b]);
-    else if (len <= 65535)
-      packed = concat([u8(98), uintToLEBytes(len, 2), b]);
-    else if (len <= 16777215)
-      packed = concat([u8(99), uintToLEBytes(len, 3), b]);
-    else
-      packed = concat([u8(100), uintToLEBytes(len, 4), b]);
+    if (len <= 32) {
+      packed = concat([u8(TAG.STR_BASE + len), b]);
+    } else if (len <= 255) {
+      packed = concat([u8(TAG.STR_1BYTE_LEN), uintToLEBytes(len, 1), b]);
+    } else if (len <= 65535) {
+      packed = concat([u8(TAG.STR_2BYTE_LEN), uintToLEBytes(len, 2), b]);
+    } else if (len <= 16777215) {
+      packed = concat([u8(TAG.STR_3BYTE_LEN), uintToLEBytes(len, 3), b]);
+    } else {
+      packed = concat([u8(TAG.STR_4BYTE_LEN), uintToLEBytes(len, 4), b]);
+    }
   } else if (data instanceof Uint8Array || Buffer.isBuffer(data)) {
     const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
     const len = bytes.length;
-    if (len <= 32)
-      packed = concat([u8(112 + len), bytes]);
-    else if (len <= 255)
-      packed = concat([u8(145), uintToLEBytes(len, 1), bytes]);
-    else if (len <= 65535)
-      packed = concat([u8(146), uintToLEBytes(len, 2), bytes]);
-    else
-      packed = concat([u8(147), uintToLEBytes(len, 4), bytes]);
+    if (len <= 32) {
+      packed = concat([u8(TAG.BYTES_BASE + len), bytes]);
+    } else if (len <= 255) {
+      packed = concat([u8(TAG.BYTES_1BYTE_LEN), uintToLEBytes(len, 1), bytes]);
+    } else if (len <= 65535) {
+      packed = concat([u8(TAG.BYTES_2BYTE_LEN), uintToLEBytes(len, 2), bytes]);
+    } else {
+      packed = concat([u8(TAG.BYTES_4BYTE_LEN), uintToLEBytes(len, 4), bytes]);
+    }
   } else if (Array.isArray(data)) {
     const body = concat(data.map((d) => _pack(d, objectList)));
     const len = data.length;
     if (len <= 15) {
-      packed = concat([u8(208 + len), body]);
-      if (len >= 15)
-        packed = concat([packed, u8(3)]);
-    } else
-      packed = concat([u8(223), body, u8(3)]);
+      packed = concat([u8(TAG.ARRAY_BASE + len), body]);
+      if (len >= 15) {
+        packed = concat([packed, u8(TAG.TERMINATOR)]);
+      }
+    } else {
+      packed = concat([u8(TAG.ARRAY_VARIABLE), body, u8(TAG.TERMINATOR)]);
+    }
   } else if (typeof data === "object") {
     const keys = Object.keys(data);
     const len = keys.length;
@@ -224,47 +292,35 @@ function _pack(data, objectList) {
     }
     let header;
     if (len <= 15) {
-      header = u8(224 + len);
+      header = u8(TAG.DICT_BASE + len);
     } else {
-      header = u8(239);
+      header = u8(TAG.DICT_VARIABLE);
     }
-    packed = concatUint8Arrays([header, concatUint8Arrays(pairs)]);
+    packed = concat([header, concat(pairs)]);
     if (len >= 15 || objectList.some((v) => v === packed)) {
-      packed = concatUint8Arrays([packed, u8(129)]);
+      packed = concat([packed, u8(TAG.DICT_TERMINATOR)]);
     }
-  } else
+  } else {
     throw new TypeError(typeof data + "");
+  }
   const idx = objectList.findIndex((v) => v.length === packed.length && v.every((x, i) => x === packed[i]));
   if (idx >= 0) {
-    if (idx < 33)
-      packed = u8(160 + idx);
-    else if (idx <= 255)
-      packed = concat([u8(193), uintToLEBytes(idx, 1)]);
-    else if (idx <= 65535)
-      packed = concat([u8(194), uintToLEBytes(idx, 2)]);
-    else if (idx <= 4294967295)
-      packed = concat([u8(195), uintToLEBytes(idx, 4)]);
-    else
-      packed = concat([u8(196), uintToLEBytes(idx, 8)]);
-  } else if (packed.length > 1)
+    if (idx < 33) {
+      packed = u8(TAG.REF_BASE + idx);
+    } else if (idx <= 255) {
+      packed = concat([u8(TAG.REF_1BYTE), uintToLEBytes(idx, 1)]);
+    } else if (idx <= 65535) {
+      packed = concat([u8(TAG.REF_2BYTE), uintToLEBytes(idx, 2)]);
+    } else if (idx <= 4294967295) {
+      packed = concat([u8(TAG.REF_4BYTE), uintToLEBytes(idx, 4)]);
+    } else {
+      packed = concat([u8(TAG.REF_8BYTE), uintToLEBytes(idx, 8)]);
+    }
+  } else if (packed.length > 1) {
     objectList.push(packed);
+  }
   return packed;
 }
-function decode2(data) {
-  const [value] = _unpack(data, []);
-  return value;
-}
-function ensureAvailable(buf, need) {
-  if (buf.length < need)
-    throw new TypeError(`Not enough data: need ${need} bytes, have ${buf.length}`);
-}
-function readLittleEndian(buf, offset, len) {
-  ensureAvailable(buf.subarray(offset), len);
-  let v = 0n;
-  for (let i = len - 1;i >= 0; i--)
-    v = v << 8n | BigInt(buf[offset + i]);
-  return Number(v);
-}
 function _unpack(data, objectList) {
   if (data.length === 0)
     throw new TypeError("No data to unpack");
@@ -272,62 +328,62 @@ function _unpack(data, objectList) {
   let addToObjectList = true;
   let value;
   let rest;
-  if (tag === 1) {
+  if (tag === TAG.TRUE) {
     value = true;
     rest = data.subarray(1);
-  } else if (tag === 2) {
+  } else if (tag === TAG.FALSE) {
     value = false;
     rest = data.subarray(1);
-  } else if (tag === 4) {
+  } else if (tag === TAG.NULL) {
     value = null;
     rest = data.subarray(1);
-  } else if (tag === 5) {
+  } else if (tag === TAG.UUID) {
     value = data.subarray(1, 17);
     rest = data.subarray(17);
-  } else if (tag === 6) {
+  } else if (tag === TAG.TIMESTAMP) {
     value = readLittleEndian(data, 1, 8);
     rest = data.subarray(9);
-  } else if (tag >= 8 && tag <= 47) {
-    value = tag - 8;
+  } else if (tag >= TAG.INT_BASE && tag <= TAG.INT_MAX_INLINE) {
+    value = tag - TAG.INT_BASE;
     rest = data.subarray(1);
-  } else if (tag === 53) {
+  } else if (tag === TAG.FLOAT32) {
     const view = new DataView(data.buffer, data.byteOffset + 1, 4);
     value = view.getFloat32(0, true);
     rest = data.subarray(5);
-  } else if (tag === 54) {
+  } else if (tag === TAG.FLOAT64) {
     const view = new DataView(data.buffer, data.byteOffset + 1, 8);
     value = view.getFloat64(0, true);
     rest = data.subarray(9);
-  } else if ((tag & 240) === 48) {
+  } else if ((tag & 240) === TAG.INT_1BYTE) {
     const noOfBytes = 2 ** (tag & 15);
     const val = readLittleEndian(data, 1, noOfBytes);
-    value = sizedInt(val, noOfBytes);
+    value = sizedInteger(val, noOfBytes);
     rest = data.subarray(1 + noOfBytes);
-  } else if (tag >= 64 && tag <= 96) {
-    const length = tag - 64;
+  } else if (tag >= TAG.STR_BASE && tag <= TAG.STR_MAX_INLINE) {
+    const length = tag - TAG.STR_BASE;
     value = new TextDecoder().decode(data.subarray(1, 1 + length));
     rest = data.subarray(1 + length);
-  } else if (tag >= 97 && tag <= 100) {
+  } else if (tag >= TAG.STR_1BYTE_LEN && tag <= TAG.STR_4BYTE_LEN) {
     const lenBytes = tag & 15;
     const length = readLittleEndian(data, 1, lenBytes);
     value = new TextDecoder().decode(data.subarray(1 + lenBytes, 1 + lenBytes + length));
     rest = data.subarray(1 + lenBytes + length);
-  } else if (tag >= 112 && tag <= 144) {
-    const length = tag - 112;
+  } else if (tag >= TAG.BYTES_BASE && tag <= TAG.BYTES_MAX_INLINE) {
+    const length = tag - TAG.BYTES_BASE;
     value = data.subarray(1, 1 + length);
     rest = data.subarray(1 + length);
-  } else if (tag >= 145 && tag <= 148) {
+  } else if (tag >= TAG.BYTES_1BYTE_LEN && tag <= TAG.BYTES_4BYTE_LEN) {
     const noOfBytes = 1 << (tag & 15) - 1;
     const length = readLittleEndian(data, 1, noOfBytes);
     const start = 1 + noOfBytes;
     value = data.subarray(start, start + length);
     rest = data.subarray(start + length);
-  } else if ((tag & 240) === 208) {
+  } else if ((tag & 240) === TAG.ARRAY_BASE) {
     const count = tag & 15;
     let ptr = data.subarray(1);
     const arr = [];
     if (count === 15) {
-      while (ptr[0] !== 3) {
+      while (ptr[0] !== TAG.TERMINATOR) {
         const [v, r] = _unpack(ptr, objectList);
         arr.push(v);
         ptr = r;
@@ -343,12 +399,12 @@ function _unpack(data, objectList) {
     value = arr;
     rest = ptr;
     addToObjectList = false;
-  } else if ((tag & 224) === 224) {
+  } else if ((tag & 240) === TAG.DICT_BASE) {
     const count = tag & 15;
-    let ptr = data.subarray(1);
     const obj = {};
+    let ptr = data.subarray(1);
     if (count === 15) {
-      while (ptr[0] !== 3) {
+      while (ptr[0] !== TAG.TERMINATOR) {
         const [k, r1] = _unpack(ptr, objectList);
         const [v, r2] = _unpack(r1, objectList);
         obj[k] = v;
@@ -366,26 +422,29 @@ function _unpack(data, objectList) {
     value = obj;
     rest = ptr;
     addToObjectList = false;
-  } else if (tag >= 160 && tag <= 192) {
-    const idx = tag - 160;
-    if (idx >= objectList.length)
+  } else if (tag >= TAG.REF_BASE && tag <= TAG.REF_MAX_INLINE) {
+    const idx = tag - TAG.REF_BASE;
+    if (idx >= objectList.length) {
       throw new TypeError(`Reference index ${idx} out of range`);
+    }
     value = objectList[idx];
     rest = data.subarray(1);
     addToObjectList = false;
-  } else if (tag >= 193 && tag <= 196) {
-    const len = tag - 192;
+  } else if (tag >= TAG.REF_1BYTE && tag <= TAG.REF_8BYTE) {
+    const len = tag - TAG.REF_MAX_INLINE;
     const uid = readLittleEndian(data, 1, len);
-    if (uid >= objectList.length)
+    if (uid >= objectList.length) {
       throw new TypeError(`UID ${uid} out of range`);
+    }
     value = objectList[uid];
     rest = data.subarray(1 + len);
     addToObjectList = false;
   } else {
     throw new TypeError(`Unknown tag 0x${tag.toString(16)}`);
   }
-  if (addToObjectList)
+  if (addToObjectList) {
     objectList.push(value);
+  }
   return [value, rest];
 }
 // src/plist.ts

package/dist/ntp.d.ts

@@ -4,14 +4,14 @@ export declare function parts(ntp: bigint): [number, number];
 export declare function decode(buffer: Buffer): PacketFields;
 export declare function encode(fields: PacketFields): Buffer;
 export type PacketFields = {
-	proto: number;
-	type: number;
-	seqno: number;
-	padding: number;
-	reftime_sec: number;
-	reftime_frac: number;
-	recvtime_sec: number;
-	recvtime_frac: number;
-	sendtime_sec: number;
-	sendtime_frac: number;
+	readonly proto: number;
+	readonly type: number;
+	readonly seqno: number;
+	readonly padding: number;
+	readonly reftime_sec: number;
+	readonly reftime_frac: number;
+	readonly recvtime_sec: number;
+	readonly recvtime_frac: number;
+	readonly sendtime_sec: number;
+	readonly sendtime_frac: number;
 };

package/dist/opack.d.ts

@@ -1,10 +1,23 @@
-declare class OPackSizedInt extends Number {
-	size: number;
+declare class Float {
+	#private;
+	get value(): number;
+	constructor(value: number);
+}
+declare class Integer {
+	#private;
+	get value(): number;
+	constructor(value: number);
+}
+declare class SizedInteger {
+	#private;
+	get size(): number;
+	get value(): number;
 	constructor(value: number, size: number);
+	valueOf(): number;
 }
-export declare function sizedInt(value: number, size: number): OPackSizedInt;
-export declare function float(value: number);
-export declare function int(value: number);
-export declare function encode(data: any): Uint8Array;
+export declare function float(value: number): Float;
+export declare function int(value: number): Integer;
+export declare function sizedInteger(value: number, size: number): SizedInteger;
 export declare function decode(data: Uint8Array): any;
+export declare function encode(data: any): Uint8Array;
 export {};

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@basmilius/apple-encoding",
     "description": "Common encoding utilities for Apple Protocols.",
-    "version": "0.3.3",
+    "version": "0.4.1",
     "type": "module",
     "license": "MIT",
     "author": {