@basmilius/apple-encoding 0.6.5 → 0.6.6

package/dist/index.js

@@ -391,6 +391,8 @@ var TAG = {
   DICT_VARIABLE: 239,
   DICT_TERMINATOR: 129
 };
+var textDecoder = new TextDecoder;
+var textEncoder = new TextEncoder;
 
 class Float {
   get value() {
@@ -439,22 +441,12 @@ function sizedInteger(value, size) {
   return new SizedInteger(value, size);
 }
 function decode3(data) {
-  const [value] = _unpack(data, []);
-  return value;
+  const result = _unpackAt(data, 0, []);
+  return result.value;
 }
 function encode2(data) {
   return _pack(data, []);
 }
-function concat(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;
-  }
-  return out;
-}
 function u8(b) {
   return Uint8Array.of(b);
 }
@@ -467,18 +459,20 @@ function uintToLEBytes(value, byteLen) {
   }
   return out;
 }
-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]);
+  if (len === 1) {
+    return buf[offset];
+  } else if (len === 2) {
+    return buf[offset] | buf[offset + 1] << 8;
+  } else if (len === 4) {
+    return buf[offset] | buf[offset + 1] << 8 | buf[offset + 2] << 16 | buf[offset + 3] << 24 >>> 0;
+  } else {
+    let v = 0n;
+    for (let i = len - 1;i >= 0; i--) {
+      v = v << 8n | BigInt(buf[offset + i]);
+    }
+    return Number(v);
   }
-  return Number(v);
 }
 function _pack(data, objectList) {
   let packed = null;
@@ -487,96 +481,187 @@ function _pack(data, objectList) {
   } 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(TAG.FLOAT64), new Uint8Array(buf)]);
+    packed = new Uint8Array(9);
+    packed[0] = TAG.FLOAT64;
+    new DataView(packed.buffer, packed.byteOffset + 1, 8).setFloat64(0, data.value, true);
   } else if (data instanceof Integer) {
     const val = data.value;
     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)]);
+      packed = new Uint8Array(2);
+      packed[0] = TAG.INT_1BYTE;
+      packed[1] = val;
     } else if (val <= 65535) {
-      packed = concat([u8(TAG.INT_2BYTE), uintToLEBytes(val, 2)]);
+      packed = new Uint8Array(3);
+      packed[0] = TAG.INT_2BYTE;
+      packed[1] = val & 255;
+      packed[2] = val >> 8 & 255;
     } else if (val <= 4294967295) {
-      packed = concat([u8(TAG.INT_4BYTE), uintToLEBytes(val, 4)]);
+      packed = new Uint8Array(5);
+      packed[0] = TAG.INT_4BYTE;
+      packed[1] = val & 255;
+      packed[2] = val >> 8 & 255;
+      packed[3] = val >> 16 & 255;
+      packed[4] = val >> 24 & 255;
     } else {
-      packed = concat([u8(TAG.INT_8BYTE), uintToLEBytes(val, 8)]);
+      packed = new Uint8Array(9);
+      packed[0] = TAG.INT_8BYTE;
+      packed.set(uintToLEBytes(val, 8), 1);
     }
   } else if (typeof data === "number") {
     if (!Number.isInteger(data)) {
-      const buf = new ArrayBuffer(8);
-      new DataView(buf).setFloat64(0, data, true);
-      packed = concat([u8(TAG.FLOAT64), new Uint8Array(buf)]);
+      packed = new Uint8Array(9);
+      packed[0] = TAG.FLOAT64;
+      new DataView(packed.buffer, packed.byteOffset + 1, 8).setFloat64(0, data, true);
     } else {
       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)]);
+        packed = new Uint8Array(2);
+        packed[0] = TAG.INT_1BYTE;
+        packed[1] = data;
       } else if (data <= 65535) {
-        packed = concat([u8(TAG.INT_2BYTE), uintToLEBytes(data, 2)]);
+        packed = new Uint8Array(3);
+        packed[0] = TAG.INT_2BYTE;
+        packed[1] = data & 255;
+        packed[2] = data >> 8 & 255;
       } else if (data <= 4294967295) {
-        packed = concat([u8(TAG.INT_4BYTE), uintToLEBytes(data, 4)]);
+        packed = new Uint8Array(5);
+        packed[0] = TAG.INT_4BYTE;
+        packed[1] = data & 255;
+        packed[2] = data >> 8 & 255;
+        packed[3] = data >> 16 & 255;
+        packed[4] = data >> 24 & 255;
       } else {
-        packed = concat([u8(TAG.INT_8BYTE), uintToLEBytes(data, 8)]);
+        packed = new Uint8Array(9);
+        packed[0] = TAG.INT_8BYTE;
+        packed.set(uintToLEBytes(data, 8), 1);
       }
     }
   } else if (data instanceof SizedInteger) {
-    packed = concat([u8(TAG.INT_1BYTE + Math.log2(data.size)), uintToLEBytes(data.valueOf(), data.size)]);
+    const byteSize = data.size;
+    packed = new Uint8Array(byteSize + 1);
+    packed[0] = TAG.INT_1BYTE + (31 - Math.clz32(byteSize));
+    if (byteSize === 1) {
+      packed[1] = data.valueOf();
+    } else if (byteSize === 2) {
+      const val = data.valueOf();
+      packed[1] = val & 255;
+      packed[2] = val >> 8 & 255;
+    } else if (byteSize === 4) {
+      const val = data.valueOf();
+      packed[1] = val & 255;
+      packed[2] = val >> 8 & 255;
+      packed[3] = val >> 16 & 255;
+      packed[4] = val >> 24 & 255;
+    } else {
+      packed.set(uintToLEBytes(data.valueOf(), 8), 1);
+    }
   } else if (typeof data === "string") {
-    const b = new TextEncoder().encode(data);
+    const b = textEncoder.encode(data);
     const len = b.length;
     if (len <= 32) {
-      packed = concat([u8(TAG.STR_BASE + len), b]);
+      packed = new Uint8Array(1 + len);
+      packed[0] = TAG.STR_BASE + len;
+      packed.set(b, 1);
     } else if (len <= 255) {
-      packed = concat([u8(TAG.STR_1BYTE_LEN), uintToLEBytes(len, 1), b]);
+      packed = new Uint8Array(2 + len);
+      packed[0] = TAG.STR_1BYTE_LEN;
+      packed[1] = len;
+      packed.set(b, 2);
     } else if (len <= 65535) {
-      packed = concat([u8(TAG.STR_2BYTE_LEN), uintToLEBytes(len, 2), b]);
+      packed = new Uint8Array(3 + len);
+      packed[0] = TAG.STR_2BYTE_LEN;
+      packed[1] = len & 255;
+      packed[2] = len >> 8 & 255;
+      packed.set(b, 3);
     } else if (len <= 16777215) {
-      packed = concat([u8(TAG.STR_3BYTE_LEN), uintToLEBytes(len, 3), b]);
+      packed = new Uint8Array(4 + len);
+      packed[0] = TAG.STR_3BYTE_LEN;
+      packed[1] = len & 255;
+      packed[2] = len >> 8 & 255;
+      packed[3] = len >> 16 & 255;
+      packed.set(b, 4);
     } else {
-      packed = concat([u8(TAG.STR_4BYTE_LEN), uintToLEBytes(len, 4), b]);
+      packed = new Uint8Array(5 + len);
+      packed[0] = TAG.STR_4BYTE_LEN;
+      packed[1] = len & 255;
+      packed[2] = len >> 8 & 255;
+      packed[3] = len >> 16 & 255;
+      packed[4] = len >> 24 & 255;
+      packed.set(b, 5);
     }
   } 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(TAG.BYTES_BASE + len), bytes]);
+      packed = new Uint8Array(1 + len);
+      packed[0] = TAG.BYTES_BASE + len;
+      packed.set(bytes, 1);
     } else if (len <= 255) {
-      packed = concat([u8(TAG.BYTES_1BYTE_LEN), uintToLEBytes(len, 1), bytes]);
+      packed = new Uint8Array(2 + len);
+      packed[0] = TAG.BYTES_1BYTE_LEN;
+      packed[1] = len;
+      packed.set(bytes, 2);
     } else if (len <= 65535) {
-      packed = concat([u8(TAG.BYTES_2BYTE_LEN), uintToLEBytes(len, 2), bytes]);
+      packed = new Uint8Array(3 + len);
+      packed[0] = TAG.BYTES_2BYTE_LEN;
+      packed[1] = len & 255;
+      packed[2] = len >> 8 & 255;
+      packed.set(bytes, 3);
     } else {
-      packed = concat([u8(TAG.BYTES_4BYTE_LEN), uintToLEBytes(len, 4), bytes]);
+      packed = new Uint8Array(5 + len);
+      packed[0] = TAG.BYTES_4BYTE_LEN;
+      packed[1] = len & 255;
+      packed[2] = len >> 8 & 255;
+      packed[3] = len >> 16 & 255;
+      packed[4] = len >> 24 & 255;
+      packed.set(bytes, 5);
     }
   } else if (Array.isArray(data)) {
-    const body = concat(data.map((d) => _pack(d, objectList)));
+    const parts2 = data.map((d) => _pack(d, objectList));
+    const bodyLen = parts2.reduce((sum, p) => sum + p.length, 0);
     const len = data.length;
-    if (len <= 15) {
-      packed = concat([u8(TAG.ARRAY_BASE + len), body]);
-      if (len >= 15) {
-        packed = concat([packed, u8(TAG.TERMINATOR)]);
+    if (len < 15) {
+      packed = new Uint8Array(1 + bodyLen);
+      packed[0] = TAG.ARRAY_BASE + len;
+      let pos = 1;
+      for (const part of parts2) {
+        packed.set(part, pos);
+        pos += part.length;
       }
     } else {
-      packed = concat([u8(TAG.ARRAY_VARIABLE), body, u8(TAG.TERMINATOR)]);
+      packed = new Uint8Array(2 + bodyLen);
+      packed[0] = TAG.ARRAY_VARIABLE;
+      let pos = 1;
+      for (const part of parts2) {
+        packed.set(part, pos);
+        pos += part.length;
+      }
+      packed[pos] = TAG.TERMINATOR;
     }
   } else if (typeof data === "object") {
     const keys = Object.keys(data);
     const len = keys.length;
-    const pairs = [];
+    const parts2 = [];
+    let bodyLen = 0;
     for (const k of keys) {
-      pairs.push(_pack(k, objectList));
-      pairs.push(_pack(data[k], objectList));
+      const keyPacked = _pack(k, objectList);
+      const valPacked = _pack(data[k], objectList);
+      parts2.push(keyPacked, valPacked);
+      bodyLen += keyPacked.length + valPacked.length;
     }
-    let header;
-    if (len <= 15) {
-      header = u8(TAG.DICT_BASE + len);
-    } else {
-      header = u8(TAG.DICT_VARIABLE);
+    const needsTerminator = len >= 15;
+    packed = new Uint8Array(1 + bodyLen + (needsTerminator ? 1 : 0));
+    packed[0] = len <= 15 ? TAG.DICT_BASE + len : TAG.DICT_VARIABLE;
+    let pos = 1;
+    for (const part of parts2) {
+      packed.set(part, pos);
+      pos += part.length;
     }
-    packed = concat([header, concat(pairs)]);
-    if (len >= 15 || objectList.some((v) => v === packed)) {
-      packed = concat([packed, u8(TAG.DICT_TERMINATOR)]);
+    if (needsTerminator) {
+      packed[pos] = TAG.DICT_TERMINATOR;
     }
   } else {
     throw new TypeError(typeof data + "");
@@ -586,119 +671,134 @@ function _pack(data, objectList) {
     if (idx < 33) {
       packed = u8(TAG.REF_BASE + idx);
     } else if (idx <= 255) {
-      packed = concat([u8(TAG.REF_1BYTE), uintToLEBytes(idx, 1)]);
+      packed = new Uint8Array(2);
+      packed[0] = TAG.REF_1BYTE;
+      packed[1] = idx;
     } else if (idx <= 65535) {
-      packed = concat([u8(TAG.REF_2BYTE), uintToLEBytes(idx, 2)]);
+      packed = new Uint8Array(3);
+      packed[0] = TAG.REF_2BYTE;
+      packed[1] = idx & 255;
+      packed[2] = idx >> 8 & 255;
     } else if (idx <= 4294967295) {
-      packed = concat([u8(TAG.REF_4BYTE), uintToLEBytes(idx, 4)]);
+      packed = new Uint8Array(5);
+      packed[0] = TAG.REF_4BYTE;
+      packed[1] = idx & 255;
+      packed[2] = idx >> 8 & 255;
+      packed[3] = idx >> 16 & 255;
+      packed[4] = idx >> 24 & 255;
     } else {
-      packed = concat([u8(TAG.REF_8BYTE), uintToLEBytes(idx, 8)]);
+      packed = new Uint8Array(9);
+      packed[0] = TAG.REF_8BYTE;
+      packed.set(uintToLEBytes(idx, 8), 1);
     }
   } else if (packed.length > 1) {
     objectList.push(packed);
   }
   return packed;
 }
-function _unpack(data, objectList) {
-  if (data.length === 0)
+function _unpackAt(data, offset, objectList) {
+  if (offset >= data.length)
     throw new TypeError("No data to unpack");
-  const tag = data[0];
+  const tag = data[offset];
   let addToObjectList = true;
   let value;
-  let rest;
+  let newOffset;
   if (tag === TAG.TRUE) {
     value = true;
-    rest = data.subarray(1);
+    newOffset = offset + 1;
   } else if (tag === TAG.FALSE) {
     value = false;
-    rest = data.subarray(1);
+    newOffset = offset + 1;
   } else if (tag === TAG.NULL) {
     value = null;
-    rest = data.subarray(1);
+    newOffset = offset + 1;
   } else if (tag === TAG.UUID) {
-    value = data.subarray(1, 17);
-    rest = data.subarray(17);
+    value = data.subarray(offset + 1, offset + 17);
+    newOffset = offset + 17;
   } else if (tag === TAG.TIMESTAMP) {
-    value = readLittleEndian(data, 1, 8);
-    rest = data.subarray(9);
+    value = readLittleEndian(data, offset + 1, 8);
+    newOffset = offset + 9;
   } else if (tag >= TAG.INT_BASE && tag <= TAG.INT_MAX_INLINE) {
     value = tag - TAG.INT_BASE;
-    rest = data.subarray(1);
+    newOffset = offset + 1;
   } else if (tag === TAG.FLOAT32) {
-    const view = new DataView(data.buffer, data.byteOffset + 1, 4);
+    const view = new DataView(data.buffer, data.byteOffset + offset + 1, 4);
     value = view.getFloat32(0, true);
-    rest = data.subarray(5);
+    newOffset = offset + 5;
   } else if (tag === TAG.FLOAT64) {
-    const view = new DataView(data.buffer, data.byteOffset + 1, 8);
+    const view = new DataView(data.buffer, data.byteOffset + offset + 1, 8);
     value = view.getFloat64(0, true);
-    rest = data.subarray(9);
+    newOffset = offset + 9;
   } else if ((tag & 240) === TAG.INT_1BYTE) {
-    const noOfBytes = 2 ** (tag & 15);
-    const val = readLittleEndian(data, 1, noOfBytes);
+    const noOfBytes = 1 << (tag & 15);
+    const val = readLittleEndian(data, offset + 1, noOfBytes);
     value = sizedInteger(val, noOfBytes);
-    rest = data.subarray(1 + noOfBytes);
+    newOffset = offset + 1 + noOfBytes;
   } 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);
+    value = textDecoder.decode(data.subarray(offset + 1, offset + 1 + length));
+    newOffset = offset + 1 + length;
   } 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);
+    const length = readLittleEndian(data, offset + 1, lenBytes);
+    const start = offset + 1 + lenBytes;
+    value = textDecoder.decode(data.subarray(start, start + length));
+    newOffset = start + length;
   } 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);
+    value = data.subarray(offset + 1, offset + 1 + length);
+    newOffset = offset + 1 + length;
   } 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;
+    const length = readLittleEndian(data, offset + 1, noOfBytes);
+    const start = offset + 1 + noOfBytes;
     value = data.subarray(start, start + length);
-    rest = data.subarray(start + length);
+    newOffset = start + length;
   } else if ((tag & 240) === TAG.ARRAY_BASE) {
     const count = tag & 15;
-    let ptr = data.subarray(1);
-    const arr = [];
+    let pos = offset + 1;
     if (count === 15) {
-      while (ptr[0] !== TAG.TERMINATOR) {
-        const [v, r] = _unpack(ptr, objectList);
-        arr.push(v);
-        ptr = r;
+      const arr = [];
+      while (data[pos] !== TAG.TERMINATOR) {
+        const result = _unpackAt(data, pos, objectList);
+        arr.push(result.value);
+        pos = result.offset;
       }
-      ptr = ptr.subarray(1);
+      pos++;
+      value = arr;
     } else {
+      const arr = new Array(count);
       for (let i = 0;i < count; i++) {
-        const [v, r] = _unpack(ptr, objectList);
-        arr.push(v);
-        ptr = r;
+        const result = _unpackAt(data, pos, objectList);
+        arr[i] = result.value;
+        pos = result.offset;
       }
+      value = arr;
     }
-    value = arr;
-    rest = ptr;
+    newOffset = pos;
     addToObjectList = false;
   } else if ((tag & 240) === TAG.DICT_BASE) {
     const count = tag & 15;
     const obj = {};
-    let ptr = data.subarray(1);
+    let pos = offset + 1;
     if (count === 15) {
-      while (ptr[0] !== TAG.TERMINATOR) {
-        const [k, r1] = _unpack(ptr, objectList);
-        const [v, r2] = _unpack(r1, objectList);
-        obj[k] = v;
-        ptr = r2;
+      while (data[pos] !== TAG.TERMINATOR) {
+        const keyResult = _unpackAt(data, pos, objectList);
+        const valResult = _unpackAt(data, keyResult.offset, objectList);
+        obj[keyResult.value] = valResult.value;
+        pos = valResult.offset;
       }
-      ptr = ptr.subarray(1);
+      pos++;
     } else {
       for (let i = 0;i < count; i++) {
-        const [k, r1] = _unpack(ptr, objectList);
-        const [v, r2] = _unpack(r1, objectList);
-        obj[k] = v;
-        ptr = r2;
+        const keyResult = _unpackAt(data, pos, objectList);
+        const valResult = _unpackAt(data, keyResult.offset, objectList);
+        obj[keyResult.value] = valResult.value;
+        pos = valResult.offset;
       }
     }
     value = obj;
-    rest = ptr;
+    newOffset = pos;
     addToObjectList = false;
   } else if (tag >= TAG.REF_BASE && tag <= TAG.REF_MAX_INLINE) {
     const idx = tag - TAG.REF_BASE;
@@ -706,16 +806,16 @@ function _unpack(data, objectList) {
       throw new TypeError(`Reference index ${idx} out of range`);
     }
     value = objectList[idx];
-    rest = data.subarray(1);
+    newOffset = offset + 1;
     addToObjectList = false;
   } else if (tag >= TAG.REF_1BYTE && tag <= TAG.REF_8BYTE) {
     const len = tag - TAG.REF_MAX_INLINE;
-    const uid = readLittleEndian(data, 1, len);
+    const uid = readLittleEndian(data, offset + 1, len);
     if (uid >= objectList.length) {
       throw new TypeError(`UID ${uid} out of range`);
     }
     value = objectList[uid];
-    rest = data.subarray(1 + len);
+    newOffset = offset + 1 + len;
     addToObjectList = false;
   } else {
     throw new TypeError(`Unknown tag 0x${tag.toString(16)}`);
@@ -723,7 +823,7 @@ function _unpack(data, objectList) {
   if (addToObjectList) {
     objectList.push(value);
   }
-  return [value, rest];
+  return { value, offset: newOffset };
 }
 // src/plist.ts
 var exports_plist = {};
@@ -1032,7 +1132,7 @@ var toUTF16 = (string) => {
   }
   return new Uint8Array(buf);
 };
-var concat2 = (first, second) => {
+var concat = (first, second) => {
   const third = new Uint8Array(first.length + second.length);
   third.set(first);
   third.set(second, first.length);
@@ -1134,8 +1234,8 @@ var serialize = (value) => {
     });
   }
   function writeTrailer() {
-    buffer = concat2(buffer, nullBytes);
-    buffer = concat2(buffer, new Uint8Array([offsetSizeInBytes, idSizeInBytes]));
+    buffer = concat(buffer, nullBytes);
+    buffer = concat(buffer, new Uint8Array([offsetSizeInBytes, idSizeInBytes]));
     buffer = writeUInt(buffer, BigInt(entries.length), 8);
     buffer = writeUInt(buffer, BigInt("0"), 8);
     buffer = writeUInt(buffer, BigInt(offsetTableOffset), 8);
@@ -1202,7 +1302,7 @@ var serialize = (value) => {
       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);
+      buffer = concat(buffer, buf);
     } else {
       if (Number.isInteger(value2)) {
         if (value2 < 0) {
@@ -1249,16 +1349,16 @@ var serialize = (value) => {
         utf16[i + 0] = utf16[i + 1];
         utf16[i + 1] = t;
       }
-      buffer = concat2(buffer, utf16);
+      buffer = concat(buffer, utf16);
     } else {
       const utf8 = encoder.encode(value2);
       writeIntHeader(5, utf8.length);
-      buffer = concat2(buffer, utf8);
+      buffer = concat(buffer, utf8);
     }
   }
   function writeData(data) {
     writeIntHeader(4, data.byteLength);
-    buffer = concat2(buffer, new Uint8Array(data));
+    buffer = concat(buffer, new Uint8Array(data));
   }
   function writeIntHeader(kind, value2) {
     if (value2 < 15) {
@@ -1521,29 +1621,42 @@ function bail(data) {
   throw new Error("Invalid response");
 }
 function encode3(entries) {
-  const chunks = [];
+  let totalSize = 0;
+  for (const [, valueRaw] of entries) {
+    const len = typeof valueRaw === "number" ? 1 : valueRaw.length;
+    const chunks = Math.max(1, Math.ceil(len / 255));
+    totalSize += chunks * 2 + len;
+  }
+  const result = Buffer.allocUnsafe(totalSize);
+  let pos = 0;
   for (const [type, valueRaw] of entries) {
     let value;
+    let valueLen;
     if (typeof valueRaw === "number") {
-      value = Buffer.from([valueRaw]);
-    } else if (valueRaw instanceof Uint8Array) {
-      value = Buffer.from(valueRaw);
+      value = Buffer.allocUnsafe(1);
+      value[0] = valueRaw;
+      valueLen = 1;
     } else {
       value = valueRaw;
+      valueLen = value.length;
     }
     let offset = 0;
     do {
-      const len = Math.min(value.length - offset, 255);
-      chunks.push(type, len);
+      const len = Math.min(valueLen - offset, 255);
+      result[pos++] = type;
+      result[pos++] = len;
       if (len > 0) {
-        for (let i = 0;i < len; i++) {
-          chunks.push(value[offset + i]);
+        if (value instanceof Buffer) {
+          value.copy(result, pos, offset, offset + len);
+        } else {
+          result.set(value.subarray(offset, offset + len), pos);
         }
+        pos += len;
       }
       offset += len;
-    } while (offset < value.length);
+    } while (offset < valueLen);
   }
-  return Buffer.from(chunks);
+  return result;
 }
 function decode4(buf) {
   const map = new Map;
@@ -1551,14 +1664,16 @@ function decode4(buf) {
   while (i < buf.length) {
     const type = buf[i++];
     const len = buf[i++];
-    const value = new Uint8Array(buf).slice(i, i + len);
-    i += len;
     const existing = map.get(type);
     if (existing) {
-      map.set(type, Buffer.concat([existing, value]));
+      const newBuf = Buffer.allocUnsafe(existing.length + len);
+      existing.copy(newBuf, 0);
+      buf.copy(newBuf, existing.length, i, i + len);
+      map.set(type, newBuf);
     } else {
-      map.set(type, Buffer.from(value));
+      map.set(type, buf.subarray(i, i + len));
     }
+    i += len;
   }
   return map;
 }

package/package.json

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