@basmilius/apple-encoding 0.5.3 → 0.6.0

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/daap.d.ts

@@ -0,0 +1,95 @@
+export declare const ContentCode: {
+	readonly mlit: "dmap.listingitem";
+	readonly mlcl: "dmap.listing";
+	readonly msrv: "dmap.serverinforesponse";
+	readonly mcon: "dmap.container";
+	readonly miid: "dmap.itemid";
+	readonly minm: "dmap.itemname";
+	readonly mikd: "dmap.itemkind";
+	readonly mper: "dmap.persistentid";
+	readonly asal: "daap.songalbum";
+	readonly asar: "daap.songartist";
+	readonly asaa: "daap.songalbumartist";
+	readonly ascp: "daap.songcomposer";
+	readonly asgn: "daap.songgenre";
+	readonly astm: "daap.songtime";
+	readonly astn: "daap.songtracknumber";
+	readonly asdc: "daap.songdisccount";
+	readonly asdn: "daap.songdiscnumber";
+	readonly astc: "daap.songtrackcount";
+	readonly asyr: "daap.songyear";
+	readonly asbr: "daap.songbitrate";
+	readonly assr: "daap.songsamplerate";
+	readonly assz: "daap.songsize";
+	readonly caps: "daap.songplaystatus";
+	readonly cash: "daap.songshufflestate";
+	readonly carp: "daap.songrepeatstate";
+	readonly cavs: "daap.songvisiblestate";
+	readonly aePP: "com.apple.itunes.photo-properties";
+};
+export declare const TagType: {
+	readonly mlit: 12;
+	readonly mlcl: 12;
+	readonly mcon: 12;
+	readonly msrv: 12;
+	readonly miid: 5;
+	readonly minm: 9;
+	readonly mikd: 1;
+	readonly mper: 7;
+	readonly asal: 9;
+	readonly asar: 9;
+	readonly asaa: 9;
+	readonly ascp: 9;
+	readonly asgn: 9;
+	readonly astm: 5;
+	readonly astn: 3;
+	readonly asdc: 3;
+	readonly asdn: 3;
+	readonly astc: 3;
+	readonly asyr: 3;
+	readonly asbr: 3;
+	readonly assr: 5;
+	readonly assz: 5;
+	readonly caps: 1;
+	readonly cash: 1;
+	readonly carp: 1;
+	readonly cavs: 1;
+	readonly aePP: 9;
+};
+export declare function encodeTag(tag: string, value: Buffer | string | number | bigint): Buffer;
+export declare function encodeContainer(tag: string, content: Buffer): Buffer;
+export declare function encodePlaybackStatus(status: PlaybackStatus): Buffer;
+export declare function encodeTagWithSize(tag: string, value: number, byteSize: 1 | 2 | 4 | 8): Buffer;
+export declare function encodeTrackMetadata(metadata: TrackMetadata): Buffer;
+export declare function decode(buffer: Buffer): DecodedTag[];
+export declare function decodeTag(buffer: Buffer): [DecodedTag, Buffer] | null;
+export declare function decodeToObject(buffer: Buffer): Record<string, unknown>;
+export declare function decodeTrackMetadata(buffer: Buffer): TrackMetadata;
+export type ContentCodeKey = keyof typeof ContentCode;
+export type DecodedTag = {
+	readonly tag: string;
+	readonly length: number;
+	readonly value: Buffer;
+};
+export type PlaybackStatus = {
+	readonly playing?: boolean;
+	readonly shuffle?: boolean;
+	readonly repeat?: "off" | "one" | "all";
+};
+export type TrackMetadata = {
+	readonly title?: string;
+	readonly artist?: string;
+	readonly albumArtist?: string;
+	readonly album?: string;
+	readonly composer?: string;
+	readonly genre?: string;
+	readonly duration?: number;
+	readonly trackNumber?: number;
+	readonly trackCount?: number;
+	readonly discNumber?: number;
+	readonly discCount?: number;
+	readonly year?: number;
+	readonly bitrate?: number;
+	readonly sampleRate?: number;
+	readonly size?: number;
+};

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+export * as DAAP from "./daap";
 export * as NTP from "./ntp";
 export * as OPack from "./opack";
 export * as Plist from "./plist";

package/dist/index.js

@@ -9,6 +9,284 @@ var __export = (target, all) => {
     });
 };
 
+// src/daap.ts
+var exports_daap = {};
+__export(exports_daap, {
+  encodeTrackMetadata: () => encodeTrackMetadata,
+  encodeTagWithSize: () => encodeTagWithSize,
+  encodeTag: () => encodeTag,
+  encodePlaybackStatus: () => encodePlaybackStatus,
+  encodeContainer: () => encodeContainer,
+  decodeTrackMetadata: () => decodeTrackMetadata,
+  decodeToObject: () => decodeToObject,
+  decodeTag: () => decodeTag,
+  decode: () => decode,
+  TagType: () => TagType,
+  ContentCode: () => ContentCode
+});
+var ContentCode = {
+  mlit: "dmap.listingitem",
+  mlcl: "dmap.listing",
+  msrv: "dmap.serverinforesponse",
+  mcon: "dmap.container",
+  miid: "dmap.itemid",
+  minm: "dmap.itemname",
+  mikd: "dmap.itemkind",
+  mper: "dmap.persistentid",
+  asal: "daap.songalbum",
+  asar: "daap.songartist",
+  asaa: "daap.songalbumartist",
+  ascp: "daap.songcomposer",
+  asgn: "daap.songgenre",
+  astm: "daap.songtime",
+  astn: "daap.songtracknumber",
+  asdc: "daap.songdisccount",
+  asdn: "daap.songdiscnumber",
+  astc: "daap.songtrackcount",
+  asyr: "daap.songyear",
+  asbr: "daap.songbitrate",
+  assr: "daap.songsamplerate",
+  assz: "daap.songsize",
+  caps: "daap.songplaystatus",
+  cash: "daap.songshufflestate",
+  carp: "daap.songrepeatstate",
+  cavs: "daap.songvisiblestate",
+  aePP: "com.apple.itunes.photo-properties"
+};
+var TagType = {
+  mlit: 12,
+  mlcl: 12,
+  mcon: 12,
+  msrv: 12,
+  miid: 5,
+  minm: 9,
+  mikd: 1,
+  mper: 7,
+  asal: 9,
+  asar: 9,
+  asaa: 9,
+  ascp: 9,
+  asgn: 9,
+  astm: 5,
+  astn: 3,
+  asdc: 3,
+  asdn: 3,
+  astc: 3,
+  asyr: 3,
+  asbr: 3,
+  assr: 5,
+  assz: 5,
+  caps: 1,
+  cash: 1,
+  carp: 1,
+  cavs: 1,
+  aePP: 9
+};
+function encodeTag(tag, value) {
+  if (tag.length !== 4) {
+    throw new Error(`Invalid DAAP tag: ${tag}. Tags must be exactly 4 characters.`);
+  }
+  const tagBuffer = Buffer.from(tag, "ascii");
+  let valueBuffer;
+  if (typeof value === "string") {
+    valueBuffer = Buffer.from(value, "utf8");
+  } else if (typeof value === "bigint") {
+    valueBuffer = Buffer.alloc(8);
+    valueBuffer.writeBigUInt64BE(value, 0);
+  } else if (typeof value === "number") {
+    if (value <= 255 && value >= 0) {
+      valueBuffer = Buffer.alloc(1);
+      valueBuffer.writeUInt8(value, 0);
+    } else if (value <= 65535 && value >= 0) {
+      valueBuffer = Buffer.alloc(2);
+      valueBuffer.writeUInt16BE(value, 0);
+    } else if (value <= 4294967295 && value >= 0) {
+      valueBuffer = Buffer.alloc(4);
+      valueBuffer.writeUInt32BE(value, 0);
+    } else {
+      valueBuffer = Buffer.alloc(8);
+      valueBuffer.writeBigInt64BE(BigInt(value), 0);
+    }
+  } else {
+    valueBuffer = value;
+  }
+  const lengthBuffer = Buffer.alloc(4);
+  lengthBuffer.writeUInt32BE(valueBuffer.length, 0);
+  return Buffer.concat([tagBuffer, lengthBuffer, valueBuffer]);
+}
+function encodeContainer(tag, content) {
+  if (tag.length !== 4) {
+    throw new Error(`Invalid DAAP tag: ${tag}. Tags must be exactly 4 characters.`);
+  }
+  const tagBuffer = Buffer.from(tag, "ascii");
+  const lengthBuffer = Buffer.alloc(4);
+  lengthBuffer.writeUInt32BE(content.length, 0);
+  return Buffer.concat([tagBuffer, lengthBuffer, content]);
+}
+function encodePlaybackStatus(status) {
+  const tags = [];
+  if (status.playing !== undefined) {
+    tags.push(encodeTagWithSize("caps", status.playing ? 4 : 3, 1));
+  }
+  if (status.shuffle !== undefined) {
+    tags.push(encodeTagWithSize("cash", status.shuffle ? 1 : 0, 1));
+  }
+  if (status.repeat !== undefined) {
+    let repeatValue = 0;
+    if (status.repeat === "one")
+      repeatValue = 1;
+    else if (status.repeat === "all")
+      repeatValue = 2;
+    tags.push(encodeTagWithSize("carp", repeatValue, 1));
+  }
+  return Buffer.concat(tags);
+}
+function encodeTagWithSize(tag, value, byteSize) {
+  if (tag.length !== 4) {
+    throw new Error(`Invalid DAAP tag: ${tag}. Tags must be exactly 4 characters.`);
+  }
+  const tagBuffer = Buffer.from(tag, "ascii");
+  const valueBuffer = Buffer.alloc(byteSize);
+  switch (byteSize) {
+    case 1:
+      valueBuffer.writeUInt8(value, 0);
+      break;
+    case 2:
+      valueBuffer.writeUInt16BE(value, 0);
+      break;
+    case 4:
+      valueBuffer.writeUInt32BE(value, 0);
+      break;
+    case 8:
+      valueBuffer.writeBigUInt64BE(BigInt(value), 0);
+      break;
+  }
+  const lengthBuffer = Buffer.alloc(4);
+  lengthBuffer.writeUInt32BE(byteSize, 0);
+  return Buffer.concat([tagBuffer, lengthBuffer, valueBuffer]);
+}
+function encodeTrackMetadata(metadata) {
+  const tags = [];
+  if (metadata.title !== undefined) {
+    tags.push(encodeTag("minm", metadata.title));
+  }
+  if (metadata.artist !== undefined) {
+    tags.push(encodeTag("asar", metadata.artist));
+  }
+  if (metadata.albumArtist !== undefined) {
+    tags.push(encodeTag("asaa", metadata.albumArtist));
+  }
+  if (metadata.album !== undefined) {
+    tags.push(encodeTag("asal", metadata.album));
+  }
+  if (metadata.composer !== undefined) {
+    tags.push(encodeTag("ascp", metadata.composer));
+  }
+  if (metadata.genre !== undefined) {
+    tags.push(encodeTag("asgn", metadata.genre));
+  }
+  if (metadata.duration !== undefined) {
+    tags.push(encodeTagWithSize("astm", Math.floor(metadata.duration * 1000), 4));
+  }
+  if (metadata.trackNumber !== undefined) {
+    tags.push(encodeTagWithSize("astn", metadata.trackNumber, 2));
+  }
+  if (metadata.trackCount !== undefined) {
+    tags.push(encodeTagWithSize("astc", metadata.trackCount, 2));
+  }
+  if (metadata.discNumber !== undefined) {
+    tags.push(encodeTagWithSize("asdn", metadata.discNumber, 2));
+  }
+  if (metadata.discCount !== undefined) {
+    tags.push(encodeTagWithSize("asdc", metadata.discCount, 2));
+  }
+  if (metadata.year !== undefined) {
+    tags.push(encodeTagWithSize("asyr", metadata.year, 2));
+  }
+  if (metadata.bitrate !== undefined) {
+    tags.push(encodeTagWithSize("asbr", metadata.bitrate, 2));
+  }
+  if (metadata.sampleRate !== undefined) {
+    tags.push(encodeTagWithSize("assr", metadata.sampleRate, 4));
+  }
+  if (metadata.size !== undefined) {
+    tags.push(encodeTagWithSize("assz", metadata.size, 4));
+  }
+  const content = Buffer.concat(tags);
+  return encodeContainer("mlit", content);
+}
+function decode(buffer) {
+  const tags = [];
+  let remaining = buffer;
+  while (remaining.length > 0) {
+    const result = decodeTag(remaining);
+    if (!result)
+      break;
+    const [tag, rest] = result;
+    tags.push(tag);
+    remaining = rest;
+  }
+  return tags;
+}
+function decodeTag(buffer) {
+  if (buffer.length < 8) {
+    return null;
+  }
+  const tag = buffer.subarray(0, 4).toString("ascii");
+  const length = buffer.readUInt32BE(4);
+  if (buffer.length < 8 + length) {
+    return null;
+  }
+  const value = buffer.subarray(8, 8 + length);
+  const remaining = buffer.subarray(8 + length);
+  return [{ tag, length, value }, remaining];
+}
+function decodeToObject(buffer) {
+  const result = {};
+  const tags = decode(buffer);
+  for (const { tag, value } of tags) {
+    const tagType = TagType[tag];
+    if (tagType === undefined) {
+      result[tag] = value;
+    } else if (tagType === 12) {
+      result[tag] = decodeToObject(value);
+    } else if (tagType === 9) {
+      result[tag] = value.toString("utf8");
+    } else if (tagType === 1 || tagType === 2) {
+      result[tag] = value.readUInt8(0);
+    } else if (tagType === 3 || tagType === 4) {
+      result[tag] = value.readUInt16BE(0);
+    } else if (tagType === 5 || tagType === 6) {
+      result[tag] = value.readUInt32BE(0);
+    } else if (tagType === 7 || tagType === 8) {
+      result[tag] = value.readBigUInt64BE(0);
+    } else {
+      result[tag] = value;
+    }
+  }
+  return result;
+}
+function decodeTrackMetadata(buffer) {
+  const obj = decodeToObject(buffer);
+  const mlit = obj.mlit ?? obj;
+  return {
+    title: mlit.minm,
+    artist: mlit.asar,
+    albumArtist: mlit.asaa,
+    album: mlit.asal,
+    composer: mlit.ascp,
+    genre: mlit.asgn,
+    duration: mlit.astm !== undefined ? mlit.astm / 1000 : undefined,
+    trackNumber: mlit.astn,
+    trackCount: mlit.astc,
+    discNumber: mlit.asdn,
+    discCount: mlit.asdc,
+    year: mlit.asyr,
+    bitrate: mlit.asbr,
+    sampleRate: mlit.assr,
+    size: mlit.assz
+  };
+}
 // src/ntp.ts
 var exports_ntp = {};
 __export(exports_ntp, {
@@ -16,7 +294,7 @@ __export(exports_ntp, {
   ns: () => ns,
   now: () => now,
   encode: () => encode,
-  decode: () => decode
+  decode: () => decode2
 });
 var EPOCH = 0x83AA7E80n;
 function now() {
@@ -34,7 +312,7 @@ function parts(ntp) {
     Number(ntp & 0xFFFFFFFFn)
   ];
 }
-function decode(buffer) {
+function decode2(buffer) {
   if (buffer.length < 24) {
     throw new RangeError(`NTP packet too small: expected at least 24 bytes, got ${buffer.length}`);
   }
@@ -72,7 +350,7 @@ __export(exports_opack, {
   int: () => int,
   float: () => float,
   encode: () => encode2,
-  decode: () => decode2
+  decode: () => decode3
 });
 var TAG = {
   TRUE: 1,
@@ -160,7 +438,7 @@ function int(value) {
 function sizedInteger(value, size) {
   return new SizedInteger(value, size);
 }
-function decode2(data) {
+function decode3(data) {
   const [value] = _unpack(data, []);
   return value;
 }
@@ -453,8 +731,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, {
@@ -569,7 +1450,7 @@ function parseResponseHeaders(buffer) {
 var exports_tlv8 = {};
 __export(exports_tlv8, {
   encode: () => encode3,
-  decode: () => decode3,
+  decode: () => decode4,
   bail: () => bail,
   Value: () => Value,
   State: () => State,
@@ -664,7 +1545,7 @@ function encode3(entries) {
   }
   return Buffer.from(chunks);
 }
-function decode3(buf) {
+function decode4(buf) {
   const map = new Map;
   let i = 0;
   while (i < buf.length) {
@@ -686,5 +1567,6 @@ export {
   exports_rtsp as RTSP,
   exports_plist as Plist,
   exports_opack as OPack,
-  exports_ntp as NTP
+  exports_ntp as NTP,
+  exports_daap as DAAP
 };

package/dist/rtsp.d.ts

@@ -1,4 +1,4 @@
-export type Method = "GET" | "OPTIONS" | "POST" | "PUT" | "GET_PARAMETER" | "SET_PARAMETER" | "ANNOUNCE" | "RECORD" | "SETUP" | "TEARDOWN";
+export type Method = "GET" | "OPTIONS" | "POST" | "PUT" | "GET_PARAMETER" | "SET_PARAMETER" | "ANNOUNCE" | "FLUSH" | "RECORD" | "SETUP" | "TEARDOWN";
 export declare function makeHeader(method: Method, path: string, headers: HeadersInit, cseq: number, activeRemote: string, dacpId: string, sessionId: string): string;
 export declare function makeRequest(buffer: Buffer): HttpRequest | null;
 export declare function makeResponse(buffer: Buffer): HttpResponse | null;

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@basmilius/apple-encoding",
     "description": "Common encoding utilities for Apple Protocols.",
-    "version": "0.5.3",
+    "version": "0.6.0",
     "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"
     }
 }