@basmilius/apple-encoding 0.7.2 → 0.8.1

package/dist/index.js

@@ -1,1687 +0,0 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-
-// 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.allocUnsafe(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, {
-  parts: () => parts,
-  ns: () => ns,
-  now: () => now,
-  encode: () => encode,
-  decode: () => decode2
-});
-var EPOCH = 0x83AA7E80n;
-function now() {
-  const now2 = ns() / 1000n;
-  const seconds = now2 / 1000000n;
-  const frac = now2 - seconds * 1000000n;
-  return seconds + EPOCH << 32n | (frac << 32n) / 1000000n;
-}
-function ns() {
-  return process.hrtime.bigint();
-}
-function parts(ntp) {
-  return [
-    Number(ntp >> 32n),
-    Number(ntp & 0xFFFFFFFFn)
-  ];
-}
-function decode2(buffer) {
-  if (buffer.length < 24) {
-    throw new RangeError(`NTP packet too small: expected at least 24 bytes, got ${buffer.length}`);
-  }
-  return {
-    proto: buffer.readUInt8(0),
-    type: buffer.readUInt8(1),
-    seqno: buffer.readUInt16BE(2),
-    padding: buffer.readUInt32BE(4),
-    reftime_sec: buffer.readUInt32BE(8),
-    reftime_frac: buffer.readUInt32BE(12),
-    recvtime_sec: buffer.readUInt32BE(16),
-    recvtime_frac: buffer.readUInt32BE(20),
-    sendtime_sec: buffer.length >= 28 ? buffer.readUInt32BE(24) : 0,
-    sendtime_frac: buffer.length >= 32 ? buffer.readUInt32BE(28) : 0
-  };
-}
-function encode(fields) {
-  const buffer = Buffer.allocUnsafe(32);
-  buffer.writeUInt8(fields.proto, 0);
-  buffer.writeUInt8(fields.type, 1);
-  buffer.writeUInt16BE(fields.seqno, 2);
-  buffer.writeUInt32BE(fields.padding, 4);
-  buffer.writeUInt32BE(fields.reftime_sec, 8);
-  buffer.writeUInt32BE(fields.reftime_frac, 12);
-  buffer.writeUInt32BE(fields.recvtime_sec, 16);
-  buffer.writeUInt32BE(fields.recvtime_frac, 20);
-  buffer.writeUInt32BE(fields.sendtime_sec, 24);
-  buffer.writeUInt32BE(fields.sendtime_frac, 28);
-  return buffer;
-}
-// src/opack.ts
-var exports_opack = {};
-__export(exports_opack, {
-  sizedInteger: () => sizedInteger,
-  int: () => int,
-  float: () => float,
-  encode: () => encode2,
-  decode: () => decode3
-});
-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
-};
-var textDecoder = new TextDecoder;
-var textEncoder = new TextEncoder;
-
-class Float {
-  get value() {
-    return this.#value;
-  }
-  #value;
-  constructor(value) {
-    this.#value = value;
-  }
-}
-
-class Integer {
-  get value() {
-    return this.#value;
-  }
-  #value;
-  constructor(value) {
-    this.#value = value;
-  }
-}
-
-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 Float(value);
-}
-function int(value) {
-  return new Integer(value);
-}
-function sizedInteger(value, size) {
-  return new SizedInteger(value, size);
-}
-function decode3(data) {
-  const result = _unpackAt(data, 0, []);
-  return result.value;
-}
-function encode2(data) {
-  return _pack(data, []);
-}
-function u8(b) {
-  return Uint8Array.of(b);
-}
-function uintToLEBytes(value, byteLen) {
-  const out = new Uint8Array(byteLen);
-  let v = BigInt(value);
-  for (let i = 0;i < byteLen; i++) {
-    out[i] = Number(v & 0xffn);
-    v >>= 8n;
-  }
-  return out;
-}
-function readLittleEndian(buf, offset, len) {
-  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);
-  }
-}
-function _pack(data, objectList) {
-  let packed = null;
-  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) {
-    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 = new Uint8Array(2);
-      packed[0] = TAG.INT_1BYTE;
-      packed[1] = val;
-    } else if (val <= 65535) {
-      packed = new Uint8Array(3);
-      packed[0] = TAG.INT_2BYTE;
-      packed[1] = val & 255;
-      packed[2] = val >> 8 & 255;
-    } else if (val <= 4294967295) {
-      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 = new Uint8Array(9);
-      packed[0] = TAG.INT_8BYTE;
-      packed.set(uintToLEBytes(val, 8), 1);
-    }
-  } else if (typeof data === "number") {
-    if (!Number.isInteger(data)) {
-      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 = new Uint8Array(2);
-        packed[0] = TAG.INT_1BYTE;
-        packed[1] = data;
-      } else if (data <= 65535) {
-        packed = new Uint8Array(3);
-        packed[0] = TAG.INT_2BYTE;
-        packed[1] = data & 255;
-        packed[2] = data >> 8 & 255;
-      } else if (data <= 4294967295) {
-        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 = new Uint8Array(9);
-        packed[0] = TAG.INT_8BYTE;
-        packed.set(uintToLEBytes(data, 8), 1);
-      }
-    }
-  } else if (data instanceof SizedInteger) {
-    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 = textEncoder.encode(data);
-    const len = b.length;
-    if (len <= 32) {
-      packed = new Uint8Array(1 + len);
-      packed[0] = TAG.STR_BASE + len;
-      packed.set(b, 1);
-    } else if (len <= 255) {
-      packed = new Uint8Array(2 + len);
-      packed[0] = TAG.STR_1BYTE_LEN;
-      packed[1] = len;
-      packed.set(b, 2);
-    } else if (len <= 65535) {
-      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 = 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 = 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 = new Uint8Array(1 + len);
-      packed[0] = TAG.BYTES_BASE + len;
-      packed.set(bytes, 1);
-    } else if (len <= 255) {
-      packed = new Uint8Array(2 + len);
-      packed[0] = TAG.BYTES_1BYTE_LEN;
-      packed[1] = len;
-      packed.set(bytes, 2);
-    } else if (len <= 65535) {
-      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 = 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 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 = 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 = 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 parts2 = [];
-    let bodyLen = 0;
-    for (const k of keys) {
-      const keyPacked = _pack(k, objectList);
-      const valPacked = _pack(data[k], objectList);
-      parts2.push(keyPacked, valPacked);
-      bodyLen += keyPacked.length + valPacked.length;
-    }
-    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;
-    }
-    if (needsTerminator) {
-      packed[pos] = TAG.DICT_TERMINATOR;
-    }
-  } 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(TAG.REF_BASE + idx);
-    } else if (idx <= 255) {
-      packed = new Uint8Array(2);
-      packed[0] = TAG.REF_1BYTE;
-      packed[1] = idx;
-    } else if (idx <= 65535) {
-      packed = new Uint8Array(3);
-      packed[0] = TAG.REF_2BYTE;
-      packed[1] = idx & 255;
-      packed[2] = idx >> 8 & 255;
-    } else if (idx <= 4294967295) {
-      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 = 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 _unpackAt(data, offset, objectList) {
-  if (offset >= data.length)
-    throw new TypeError("No data to unpack");
-  const tag = data[offset];
-  let addToObjectList = true;
-  let value;
-  let newOffset;
-  if (tag === TAG.TRUE) {
-    value = true;
-    newOffset = offset + 1;
-  } else if (tag === TAG.FALSE) {
-    value = false;
-    newOffset = offset + 1;
-  } else if (tag === TAG.NULL) {
-    value = null;
-    newOffset = offset + 1;
-  } else if (tag === TAG.UUID) {
-    value = data.subarray(offset + 1, offset + 17);
-    newOffset = offset + 17;
-  } else if (tag === TAG.TIMESTAMP) {
-    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;
-    newOffset = offset + 1;
-  } else if (tag === TAG.FLOAT32) {
-    const view = new DataView(data.buffer, data.byteOffset + offset + 1, 4);
-    value = view.getFloat32(0, true);
-    newOffset = offset + 5;
-  } else if (tag === TAG.FLOAT64) {
-    const view = new DataView(data.buffer, data.byteOffset + offset + 1, 8);
-    value = view.getFloat64(0, true);
-    newOffset = offset + 9;
-  } else if ((tag & 240) === TAG.INT_1BYTE) {
-    const noOfBytes = 1 << (tag & 15);
-    const val = readLittleEndian(data, offset + 1, noOfBytes);
-    value = sizedInteger(val, noOfBytes);
-    newOffset = offset + 1 + noOfBytes;
-  } else if (tag >= TAG.STR_BASE && tag <= TAG.STR_MAX_INLINE) {
-    const length = tag - TAG.STR_BASE;
-    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, 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(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, offset + 1, noOfBytes);
-    const start = offset + 1 + noOfBytes;
-    value = data.subarray(start, start + length);
-    newOffset = start + length;
-  } else if ((tag & 240) === TAG.ARRAY_BASE) {
-    const count = tag & 15;
-    let pos = offset + 1;
-    if (count === 15) {
-      const arr = [];
-      while (data[pos] !== TAG.TERMINATOR) {
-        const result = _unpackAt(data, pos, objectList);
-        arr.push(result.value);
-        pos = result.offset;
-      }
-      pos++;
-      value = arr;
-    } else {
-      const arr = new Array(count);
-      for (let i = 0;i < count; i++) {
-        const result = _unpackAt(data, pos, objectList);
-        arr[i] = result.value;
-        pos = result.offset;
-      }
-      value = arr;
-    }
-    newOffset = pos;
-    addToObjectList = false;
-  } else if ((tag & 240) === TAG.DICT_BASE) {
-    const count = tag & 15;
-    const obj = {};
-    let pos = offset + 1;
-    if (count === 15) {
-      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;
-      }
-      pos++;
-    } else {
-      for (let i = 0;i < count; i++) {
-        const keyResult = _unpackAt(data, pos, objectList);
-        const valResult = _unpackAt(data, keyResult.offset, objectList);
-        obj[keyResult.value] = valResult.value;
-        pos = valResult.offset;
-      }
-    }
-    value = obj;
-    newOffset = pos;
-    addToObjectList = false;
-  } 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];
-    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, offset + 1, len);
-    if (uid >= objectList.length) {
-      throw new TypeError(`UID ${uid} out of range`);
-    }
-    value = objectList[uid];
-    newOffset = offset + 1 + len;
-    addToObjectList = false;
-  } else {
-    throw new TypeError(`Unknown tag 0x${tag.toString(16)}`);
-  }
-  if (addToObjectList) {
-    objectList.push(value);
-  }
-  return { value, offset: newOffset };
-}
-// src/plist.ts
-var exports_plist = {};
-__export(exports_plist, {
-  serialize: () => serialize,
-  parse: () => parse
-});
-// ../../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 concat = (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 = 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);
-  }
-  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 = concat(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 = concat(buffer, utf16);
-    } else {
-      const utf8 = encoder.encode(value2);
-      writeIntHeader(5, utf8.length);
-      buffer = concat(buffer, utf8);
-    }
-  }
-  function writeData(data) {
-    writeIntHeader(4, data.byteLength);
-    buffer = concat(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, {
-  makeResponse: () => makeResponse,
-  makeRequest: () => makeRequest,
-  makeHeader: () => makeHeader
-});
-function makeHeader(method, path, headers, cseq, activeRemote, dacpId, sessionId) {
-  const lines = [];
-  lines.push(`${method} ${path} RTSP/1.0`);
-  lines.push(`CSeq: ${cseq}`);
-  lines.push(`Active-Remote: ${activeRemote}`);
-  lines.push(`Client-Instance: ${dacpId}`);
-  lines.push(`DACP-ID: ${dacpId}`);
-  lines.push("User-Agent: AirPlay/320.20");
-  lines.push("X-Apple-ProtocolVersion: 1");
-  lines.push(`X-Apple-Session-ID: ${sessionId}`);
-  lines.push("X-ProtocolVersion: 1");
-  for (const [name, value] of Object.entries(headers)) {
-    lines.push(`${name}: ${value}`);
-  }
-  lines.push("");
-  lines.push("");
-  return lines.join(`\r
-`);
-}
-function makeRequest(buffer) {
-  const headerLength = buffer.indexOf(`\r
-\r
-`);
-  const { headers, method, path } = parseRequestHeaders(buffer.subarray(0, headerLength));
-  let contentLength = headers["Content-Length"] ? Number(headers["Content-Length"]) : 0;
-  if (isNaN(contentLength)) {
-    contentLength = 0;
-  }
-  const requestLength = headerLength + 4 + contentLength;
-  if (buffer.byteLength < requestLength) {
-    return null;
-  }
-  const body = buffer.subarray(headerLength + 4, requestLength);
-  return {
-    headers,
-    method,
-    path,
-    body,
-    requestLength
-  };
-}
-function makeResponse(buffer) {
-  const headerLength = buffer.indexOf(`\r
-\r
-`);
-  const { headers, status, statusText } = parseResponseHeaders(buffer.subarray(0, headerLength));
-  let contentLength = headers["Content-Length"] ? Number(headers["Content-Length"]) : 0;
-  if (isNaN(contentLength)) {
-    contentLength = 0;
-  }
-  const responseLength = headerLength + 4 + contentLength;
-  if (buffer.byteLength < responseLength) {
-    return null;
-  }
-  const body = buffer.subarray(headerLength + 4, responseLength);
-  const response = new Response(body, {
-    status,
-    statusText,
-    headers
-  });
-  return {
-    response,
-    responseLength
-  };
-}
-function parseHeaders(lines) {
-  const headers = {};
-  for (let i = 0;i < lines.length; i++) {
-    const colon = lines[i].indexOf(":");
-    if (colon <= 0) {
-      continue;
-    }
-    const name = lines[i].substring(0, colon).trim();
-    headers[name] = lines[i].substring(colon + 1).trim();
-  }
-  return headers;
-}
-function parseRequestHeaders(buffer) {
-  const lines = buffer.toString("utf8").split(`\r
-`);
-  const rawRequest = lines[0].match(/^(\S+)\s+(\S+)\s+RTSP\/1\.0$/);
-  const method = rawRequest[1];
-  const path = rawRequest[2];
-  const headers = parseHeaders(lines.slice(1));
-  return {
-    headers,
-    method,
-    path
-  };
-}
-function parseResponseHeaders(buffer) {
-  const lines = buffer.toString("utf8").split(`\r
-`);
-  const rawStatus = lines[0].match(/(HTTP|RTSP)\/[\d.]+\s+(\d+)\s+(.+)/);
-  const status = Number(rawStatus[2]);
-  const statusText = rawStatus[3];
-  const headers = parseHeaders(lines.slice(1));
-  return {
-    headers,
-    status,
-    statusText
-  };
-}
-// src/tlv8.ts
-var exports_tlv8 = {};
-__export(exports_tlv8, {
-  encode: () => encode3,
-  decode: () => decode4,
-  bail: () => bail,
-  Value: () => Value,
-  State: () => State,
-  Method: () => Method,
-  Flags: () => Flags,
-  ErrorCode: () => ErrorCode
-});
-var Flags = {
-  TransientPairing: 16
-};
-var ErrorCode = {
-  Unknown: 1,
-  Authentication: 2,
-  BackOff: 3,
-  MaxPeers: 4,
-  MaxTries: 5,
-  Unavailable: 6,
-  Busy: 7
-};
-var Method = {
-  PairSetup: 0,
-  PairSetupWithAuth: 1,
-  PairVerify: 2,
-  AddPairing: 3,
-  RemovePairing: 4,
-  ListPairing: 5
-};
-var State = {
-  M1: 1,
-  M2: 2,
-  M3: 3,
-  M4: 4,
-  M5: 5,
-  M6: 6
-};
-var Value = {
-  Method: 0,
-  Identifier: 1,
-  Salt: 2,
-  PublicKey: 3,
-  Proof: 4,
-  EncryptedData: 5,
-  State: 6,
-  Error: 7,
-  BackOff: 8,
-  Certificate: 9,
-  Signature: 10,
-  Permissions: 11,
-  FragmentData: 12,
-  FragmentLast: 13,
-  Name: 17,
-  Flags: 19
-};
-function bail(data) {
-  if (data.has(Value.BackOff)) {
-    const buffer = data.get(Value.BackOff);
-    const time = buffer.readUintLE(0, buffer.length);
-    throw new Error(`Device is busy, try again in ${time} seconds.`);
-  }
-  if (data.has(Value.Error)) {
-    const errorCodeEntries = Object.entries(ErrorCode);
-    const errorCode = errorCodeEntries.find(([_, code]) => code === data.get(Value.Error).readUint8());
-    if (!errorCode) {
-      throw new Error(`Device returned an unknown error code: ${data.get(Value.Error).readUint8()}`);
-    }
-    throw new Error(`Device returned an error code: ${errorCode[0]}`);
-  }
-  throw new Error("Invalid response");
-}
-function encode3(entries) {
-  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.allocUnsafe(1);
-      value[0] = valueRaw;
-      valueLen = 1;
-    } else {
-      value = valueRaw;
-      valueLen = value.length;
-    }
-    let offset = 0;
-    do {
-      const len = Math.min(valueLen - offset, 255);
-      result[pos++] = type;
-      result[pos++] = len;
-      if (len > 0) {
-        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 < valueLen);
-  }
-  return result;
-}
-function decode4(buf) {
-  const map = new Map;
-  let i = 0;
-  while (i < buf.length) {
-    const type = buf[i++];
-    const len = buf[i++];
-    const existing = map.get(type);
-    if (existing) {
-      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, buf.subarray(i, i + len));
-    }
-    i += len;
-  }
-  return map;
-}
-export {
-  exports_tlv8 as TLV8,
-  exports_rtsp as RTSP,
-  exports_plist as Plist,
-  exports_opack as OPack,
-  exports_ntp as NTP,
-  exports_daap as DAAP
-};