@corewire/core 0.0.0 → 1.0.0-next.2

package/dist/encoding-BaLbwFQ0.mjs

@@ -0,0 +1,1663 @@
+import { n as __exportAll } from "./chunk-wE0WeVzl.mjs";
+import { h as TLV8PairingError } from "./errors-DVv1n4fL.mjs";
+
+//#region src/encoding/daap.ts
+var daap_exports = /* @__PURE__ */ __exportAll({
+	ContentCode: () => ContentCode,
+	TagType: () => TagType,
+	decode: () => decode$4,
+	decodeTag: () => decodeTag,
+	decodeToObject: () => decodeToObject,
+	decodeTrackMetadata: () => decodeTrackMetadata,
+	encodeContainer: () => encodeContainer,
+	encodePlaybackStatus: () => encodePlaybackStatus,
+	encodeTag: () => encodeTag,
+	encodeTagWithSize: () => encodeTagWithSize,
+	encodeTrackMetadata: () => encodeTrackMetadata
+});
+/**
+* Maps four-character DAAP tag codes to their DMAP/DAAP content code names.
+*/
+const 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"
+};
+/**
+* Maps four-character DAAP tag codes to the type the decoder reads their value as.
+*
+* Type values: 1=byte, 2=unsigned byte, 3=short, 4=unsigned short,
+* 5=int, 6=unsigned int, 7=long, 8=unsigned long,
+* 9=string, 10=date, 11=version, 12=container.
+*/
+const 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
+};
+/**
+* Encodes a single DAAP tag. A number takes the smallest big-endian size that fits.
+*
+* @param tag - Four-character ASCII tag code, such as `minm`.
+* @param value - A string is written as UTF-8, a bigint as 8 bytes and a Buffer as is.
+* @throws Error if the tag is not exactly 4 characters.
+*/
+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
+	]);
+}
+/**
+* Encodes a DAAP container tag around tags that are already encoded.
+*
+* @param tag - Four-character ASCII container tag code, such as `mlit`.
+* @throws Error if the tag is not exactly 4 characters.
+*/
+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
+	]);
+}
+/**
+* Encodes the playback status into DAAP tags, one tag per defined field.
+*/
+function encodePlaybackStatus(status) {
+	const tags = [];
+	if (status.playing !== void 0) tags.push(encodeTagWithSize("caps", status.playing ? 4 : 3, 1));
+	if (status.shuffle !== void 0) tags.push(encodeTagWithSize("cash", status.shuffle ? 1 : 0, 1));
+	if (status.repeat !== void 0) {
+		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);
+}
+/**
+* Encodes a numeric DAAP tag with a fixed value size, for tags whose size the protocol fixes.
+*
+* @param tag - Four-character ASCII tag code.
+* @param byteSize - Size of the big-endian value in bytes.
+* @throws Error if the tag is not exactly 4 characters.
+*/
+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
+	]);
+}
+/**
+* Encodes track metadata into a DAAP listing item (`mlit`), one tag per defined field.
+* The duration goes from seconds to the milliseconds of `astm`.
+*/
+function encodeTrackMetadata(metadata) {
+	const tags = [];
+	if (metadata.title !== void 0) tags.push(encodeTag("minm", metadata.title));
+	if (metadata.artist !== void 0) tags.push(encodeTag("asar", metadata.artist));
+	if (metadata.albumArtist !== void 0) tags.push(encodeTag("asaa", metadata.albumArtist));
+	if (metadata.album !== void 0) tags.push(encodeTag("asal", metadata.album));
+	if (metadata.composer !== void 0) tags.push(encodeTag("ascp", metadata.composer));
+	if (metadata.genre !== void 0) tags.push(encodeTag("asgn", metadata.genre));
+	if (metadata.duration !== void 0) tags.push(encodeTagWithSize("astm", Math.floor(metadata.duration * 1e3), 4));
+	if (metadata.trackNumber !== void 0) tags.push(encodeTagWithSize("astn", metadata.trackNumber, 2));
+	if (metadata.trackCount !== void 0) tags.push(encodeTagWithSize("astc", metadata.trackCount, 2));
+	if (metadata.discNumber !== void 0) tags.push(encodeTagWithSize("asdn", metadata.discNumber, 2));
+	if (metadata.discCount !== void 0) tags.push(encodeTagWithSize("asdc", metadata.discCount, 2));
+	if (metadata.year !== void 0) tags.push(encodeTagWithSize("asyr", metadata.year, 2));
+	if (metadata.bitrate !== void 0) tags.push(encodeTagWithSize("asbr", metadata.bitrate, 2));
+	if (metadata.sampleRate !== void 0) tags.push(encodeTagWithSize("assr", metadata.sampleRate, 4));
+	if (metadata.size !== void 0) tags.push(encodeTagWithSize("assz", metadata.size, 4));
+	return encodeContainer("mlit", Buffer.concat(tags));
+}
+/**
+* Decodes the DAAP tags in a buffer, up to its end or the first incomplete tag.
+*/
+function decode$4(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;
+}
+/**
+* Decodes the DAAP tag at the start of a buffer.
+*
+* @returns The tag and the rest of the buffer, or null when the buffer holds no complete tag.
+*/
+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];
+}
+/**
+* Decodes a DAAP buffer into an object keyed by tag code, with values read as {@link TagType} says.
+* Containers decode recursively; a tag of unknown type keeps its raw buffer.
+*/
+function decodeToObject(buffer) {
+	const result = {};
+	const tags = decode$4(buffer);
+	for (const { tag, value } of tags) {
+		const tagType = TagType[tag];
+		if (tagType === void 0) 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;
+}
+/**
+* Decodes track metadata from a bare tag list or an `mlit` container.
+* The duration goes from the milliseconds of `astm` back to seconds.
+*/
+function decodeTrackMetadata(buffer) {
+	const decoded = decodeToObject(buffer);
+	const mlit = decoded.mlit ?? decoded;
+	return {
+		title: mlit.minm,
+		artist: mlit.asar,
+		albumArtist: mlit.asaa,
+		album: mlit.asal,
+		composer: mlit.ascp,
+		genre: mlit.asgn,
+		duration: mlit.astm !== void 0 ? mlit.astm / 1e3 : void 0,
+		trackNumber: mlit.astn,
+		trackCount: mlit.astc,
+		discNumber: mlit.asdn,
+		discCount: mlit.asdc,
+		year: mlit.asyr,
+		bitrate: mlit.asbr,
+		sampleRate: mlit.assr,
+		size: mlit.assz
+	};
+}
+
+//#endregion
+//#region src/encoding/nskeyedarchiver.ts
+var nskeyedarchiver_exports = /* @__PURE__ */ __exportAll({
+	decode: () => decode$3,
+	decodeAsArray: () => decodeAsArray
+});
+/**
+* Decodes an NSKeyedArchiver plist into plain objects. It resolves `CF$UID` references, turns
+* NSArray and NSDictionary into arrays and objects, and drops the class metadata.
+*
+* @param archive - The parsed plist, with `$objects` and `$top`.
+* @returns The root object, or null when the archive lacks `$objects` or `$top`.
+*/
+function decode$3(archive) {
+	const objects = archive?.["$objects"];
+	const top = archive?.["$top"];
+	if (!objects || !top) return null;
+	const resolve = (ref) => {
+		if (ref && typeof ref === "object" && "CF$UID" in ref) return resolve(objects[ref["CF$UID"]]);
+		if (ref === "$null") return null;
+		if (ref && typeof ref === "object") {
+			const obj = ref;
+			if (Array.isArray(obj["NS.keys"]) && Array.isArray(obj["NS.objects"])) {
+				const keys = obj["NS.keys"].map(resolve);
+				const values = obj["NS.objects"].map(resolve);
+				const result = {};
+				for (let i = 0; i < keys.length; i++) result[keys[i]] = values[i];
+				return result;
+			}
+			if (Array.isArray(obj["NS.objects"])) return obj["NS.objects"].map(resolve);
+			const result = {};
+			for (const [key, value] of Object.entries(obj)) {
+				if (key === "$class" || key === "$classname" || key === "$classes") continue;
+				result[key] = resolve(value);
+			}
+			return result;
+		}
+		return ref;
+	};
+	return resolve(top.root ?? top);
+}
+/** Like {@link decode}, but wraps a root that is not an array in a single-element array. */
+function decodeAsArray(archive) {
+	const root = decode$3(archive);
+	return Array.isArray(root) ? root : [root];
+}
+
+//#endregion
+//#region src/encoding/ntp.ts
+var ntp_exports = /* @__PURE__ */ __exportAll({
+	decode: () => decode$2,
+	encode: () => encode$2,
+	now: () => now,
+	parts: () => parts
+});
+/** Seconds between the NTP epoch (1900-01-01) and the Unix epoch (1970-01-01). */
+const EPOCH$1 = 2208988800n;
+/**
+* Returns the wall-clock time as a 64-bit NTP timestamp: whole seconds since 1900 in the upper
+* 32 bits, the fraction in the lower 32 bits.
+*
+* It reads `Date.now()` instead of a monotonic clock, because Apple devices expect NTP
+* timestamps anchored to real time.
+*/
+function now() {
+	const nowMs = BigInt(Date.now());
+	const seconds = nowMs / 1000n;
+	const frac = nowMs - seconds * 1000n;
+	return seconds + EPOCH$1 << 32n | (frac << 32n) / 1000n;
+}
+/** Splits a 64-bit NTP timestamp into `[seconds, fraction]`, both 32-bit unsigned integers. */
+function parts(ntp) {
+	return [Number(ntp >> 32n), Number(ntp & 4294967295n)];
+}
+/**
+* Decodes an NTP timing packet. The send timestamp (bytes 24 to 31) reads as 0 when the packet
+* stops before it.
+*
+* @throws {RangeError} When the packet is shorter than 24 bytes.
+*/
+function decode$2(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
+	};
+}
+/** Encodes a 32-byte NTP timing packet. */
+function encode$2(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;
+}
+
+//#endregion
+//#region src/encoding/opack.ts
+var opack_exports = /* @__PURE__ */ __exportAll({
+	decode: () => decode$1,
+	encode: () => encode$1,
+	float: () => float,
+	int: () => int,
+	sizedInteger: () => sizedInteger
+});
+/**
+* The OPack tag bytes. A tag holds the type of the value that follows, and for small
+* values also its inline length.
+*/
+const TAG = {
+	TRUE: 1,
+	FALSE: 2,
+	TERMINATOR: 3,
+	NULL: 4,
+	UUID: 5,
+	DATE: 6,
+	INT_BASE: 8,
+	INT_INLINE_MIN: 7,
+	INT_INLINE_MAX: 47,
+	INT_SIZED: 48,
+	INT_SIZED_MAX: 52,
+	FLOAT32: 53,
+	FLOAT64: 54,
+	STR_BASE: 64,
+	STR_MAX_INLINE: 96,
+	STR_SIZED: 97,
+	STR_SIZED_MAX: 100,
+	STR_NUL_TERMINATED: 111,
+	BYTES_BASE: 112,
+	BYTES_MAX_INLINE: 144,
+	BYTES_SIZED: 145,
+	BYTES_SIZED_MAX: 148,
+	BYTES_CHUNKED: 159,
+	REF_BASE: 160,
+	REF_MAX_INLINE: 192,
+	REF_SIZED: 193,
+	REF_SIZED_MAX: 196,
+	ARRAY_BASE: 208,
+	ARRAY_VARIABLE: 223,
+	DICT_BASE: 224,
+	DICT_VARIABLE: 239
+};
+/** The widths in bytes of the sized integers 0x30 to 0x34. */
+const INT_WIDTHS = [
+	1,
+	2,
+	4,
+	8,
+	16
+];
+/** The widths in bytes of the length of the sized strings 0x61 to 0x64 and bytes 0x91 to 0x94. */
+const LENGTH_WIDTHS = [
+	1,
+	2,
+	4,
+	8
+];
+/** The widths in bytes of the index of the sized references 0xC1 to 0xC4. */
+const REF_WIDTHS = [
+	1,
+	2,
+	3,
+	4
+];
+/** The deepest a value may sit in nested arrays and dictionaries; devices reject anything deeper. */
+const MAX_DEPTH$1 = 32;
+/** Dates travel as seconds since 2001-01-01 UTC; this is that moment in milliseconds since 1970. */
+const DATE_EPOCH_MS = 9783072e5;
+const textDecoder = new TextDecoder();
+const textEncoder = new TextEncoder();
+/**
+* A number that OPack encodes as FLOAT64. A plain number with an integer value
+* would encode as an OPack integer.
+*/
+var Float = class {
+	get value() {
+		return this.#value;
+	}
+	#value;
+	constructor(value) {
+		this.#value = value;
+	}
+};
+/**
+* A number that OPack encodes as an integer in the smallest width that holds it.
+*/
+var Integer = class {
+	get value() {
+		return this.#value;
+	}
+	#value;
+	constructor(value) {
+		this.#value = value;
+	}
+};
+/**
+* A signed integer with a fixed width on the wire. The decoder returns one for every sized
+* integer, so encoding it again writes the same width.
+*/
+var SizedInteger = class {
+	/** The width of the integer on the wire in bytes: 1, 2, 4, 8 or 16. */
+	get size() {
+		return this.#size;
+	}
+	/** The value; a bigint when it lies outside the safe integer range of a number. */
+	get value() {
+		return this.#value;
+	}
+	#size;
+	#value;
+	constructor(value, size) {
+		this.#size = size;
+		this.#value = value;
+	}
+	/**
+	* Returns the value, so the integer works in arithmetic and comparisons.
+	*/
+	valueOf() {
+		return this.#value;
+	}
+};
+/**
+* Wraps a number so OPack encodes it as FLOAT64, also when it is a whole number.
+*/
+function float(value) {
+	return new Float(value);
+}
+/**
+* Wraps an integer so OPack encodes it as an integer in the smallest width that holds it.
+*
+* @throws RangeError if the value is not an integer.
+*/
+function int(value) {
+	if (typeof value === "number" && !Number.isInteger(value)) throw new RangeError(`OPack integer ${value} is not an integer`);
+	return new Integer(value);
+}
+/**
+* Wraps an integer so OPack encodes it with a fixed width.
+*
+* @param size - The width in bytes: 1, 2, 4, 8 or 16. The value must fit as a signed integer.
+* @throws RangeError if the width is not one of these or the value does not fit in it.
+*/
+function sizedInteger(value, size) {
+	if (!INT_WIDTHS.includes(size)) throw new RangeError(`OPack integer width ${size} is not 1, 2, 4, 8 or 16`);
+	if (typeof value === "number" && !Number.isInteger(value)) throw new RangeError(`OPack integer ${value} is not an integer`);
+	if (!fitsSigned(BigInt(value), size)) throw new RangeError(`OPack integer ${value} does not fit in ${size} bytes`);
+	return new SizedInteger(value, size);
+}
+/**
+* Decodes OPack bytes into a value. Inline integers come back as numbers, sized integers as
+* {@link sizedInteger} values, dates as `Date`, UUIDs and byte strings as `Uint8Array`.
+*
+* @throws TypeError if the buffer ends early, nests deeper than 32 containers, refers to a
+* value that does not exist or holds a tag OPack does not define.
+*/
+function decode$1(data) {
+	return _unpackAt(data, 0, [], 0).value;
+}
+/**
+* Encodes a value as OPack. It takes null, booleans, numbers, bigints, strings, bytes, dates,
+* arrays, plain objects and the wrappers {@link float}, {@link int} and {@link sizedInteger}.
+* A repeated string, byte string of two bytes or more, number outside -1 to 39 or date becomes
+* a reference to its first occurrence; arrays and objects are always written in full.
+*
+* @throws TypeError if the value has an unsupported type or nests deeper than 32 containers.
+* @throws RangeError if an integer does not fit in 128 bits or a date is invalid.
+*/
+function encode$1(data) {
+	return _pack(data, {
+		values: [],
+		index: /* @__PURE__ */ new Map()
+	}, 0);
+}
+/**
+* Joins byte arrays into one.
+*/
+function concat$1(arrays) {
+	const total = arrays.reduce((sum, array) => sum + array.length, 0);
+	const out = new Uint8Array(total);
+	let offset = 0;
+	for (const array of arrays) {
+		out.set(array, offset);
+		offset += array.length;
+	}
+	return out;
+}
+/**
+* Returns a byte array that holds one byte.
+*/
+function u8(byte) {
+	return Uint8Array.of(byte);
+}
+/**
+* Writes an integer as `byteLen` little-endian bytes, in two's complement when negative.
+*/
+function intToLEBytes(value, byteLen) {
+	const out = new Uint8Array(byteLen);
+	let remaining = BigInt(value);
+	for (let i = 0; i < byteLen; i++) {
+		out[i] = Number(remaining & 255n);
+		remaining >>= 8n;
+	}
+	return out;
+}
+/**
+* Whether a value fits in `size` bytes as a signed integer.
+*/
+function fitsSigned(value, size) {
+	const limit = 1n << BigInt(size * 8 - 1);
+	return value >= -limit && value < limit;
+}
+/**
+* Whether an integer has an inline tag (-1 to 39). Such integers never join the object list,
+* also when they are written in a fixed width.
+*/
+function isInlineInteger(value) {
+	return value >= -1 && value <= 39;
+}
+/**
+* Returns an integer as a number when that is exact, otherwise as a bigint.
+*/
+function toInteger(value) {
+	return value >= BigInt(Number.MIN_SAFE_INTEGER) && value <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(value) : value;
+}
+/**
+* Checks that `length` bytes from `offset` lie within the buffer.
+*
+* @throws TypeError if they run past the end.
+*/
+function ensureAvailable(data, offset, length) {
+	if (length < 0 || offset + length > data.length) throw new TypeError("Truncated OPack value");
+}
+/**
+* Whether the byte at `offset` ends a container or chunked byte string.
+*
+* @throws TypeError if the buffer ends before it.
+*/
+function isTerminator(data, offset) {
+	ensureAvailable(data, offset, 1);
+	return data[offset] === TAG.TERMINATOR;
+}
+/**
+* Reads a little-endian unsigned length or index of `width` bytes.
+*
+* @throws TypeError if it runs past the end of the buffer or exceeds the safe integer range.
+*/
+function readUnsigned(data, offset, width) {
+	ensureAvailable(data, offset, width);
+	let value = 0n;
+	for (let i = width - 1; i >= 0; i--) value = value << 8n | BigInt(data[offset + i]);
+	if (value > BigInt(Number.MAX_SAFE_INTEGER)) throw new TypeError("OPack length out of range");
+	return Number(value);
+}
+/**
+* Reads a little-endian signed integer of `width` bytes.
+*/
+function readSigned(data, offset, width) {
+	ensureAvailable(data, offset, width);
+	let value = 0n;
+	for (let i = width - 1; i >= 0; i--) value = value << 8n | BigInt(data[offset + i]);
+	return BigInt.asIntN(width * 8, value);
+}
+/**
+* Packs an integer in the smallest width that holds it.
+*
+* @throws RangeError if it does not fit in 128 bits.
+*/
+function packInteger(value) {
+	if (isInlineInteger(value)) return u8(TAG.INT_BASE + Number(value));
+	const size = INT_WIDTHS.find((width) => fitsSigned(value, width));
+	if (size === void 0) throw new RangeError(`OPack integer ${value} does not fit in 128 bits`);
+	return packSizedInteger(value, size);
+}
+/**
+* Packs an integer in a fixed width.
+*/
+function packSizedInteger(value, size) {
+	return concat$1([u8(TAG.INT_SIZED + INT_WIDTHS.indexOf(size)), intToLEBytes(value, size)]);
+}
+/**
+* Packs a string or byte string: inline up to 32 bytes, otherwise with a length of 1, 2, 4 or
+* 8 bytes after the first sized tag.
+*/
+function packWithLength(inlineBase, sizedBase, payload) {
+	const length = payload.length;
+	if (length <= 32) return concat$1([u8(inlineBase + length), payload]);
+	const widthIndex = length <= 255 ? 0 : length <= 65535 ? 1 : length <= 4294967295 ? 2 : 3;
+	const width = LENGTH_WIDTHS[widthIndex];
+	return concat$1([
+		u8(sizedBase + widthIndex),
+		intToLEBytes(length, width),
+		payload
+	]);
+}
+/**
+* Packs a reference to the value at `index` in the object list.
+*
+* @throws RangeError if the index does not fit in 4 bytes.
+*/
+function packReference(index) {
+	if (index <= TAG.REF_MAX_INLINE - TAG.REF_BASE) return u8(TAG.REF_BASE + index);
+	const widthIndex = REF_WIDTHS.findIndex((width) => index < 2 ** (width * 8));
+	if (widthIndex < 0) throw new RangeError(`OPack reference index ${index} does not fit in 4 bytes`);
+	return concat$1([u8(TAG.REF_SIZED + widthIndex), intToLEBytes(index, REF_WIDTHS[widthIndex])]);
+}
+/**
+* Packs the items of an array or the keys and values of a dictionary behind their tag. Up to
+* 14 entries the tag holds the count, from 15 a terminator ends the list.
+*/
+function packContainer(base, variable, count, parts) {
+	if (count < 15) return concat$1([u8(base + count), ...parts]);
+	return concat$1([
+		u8(variable),
+		...parts,
+		u8(TAG.TERMINATOR)
+	]);
+}
+/**
+* Packs a value and its children, without looking at the object list for the value itself.
+*
+* @throws TypeError if the value has an unsupported type or nests too deep.
+* @throws RangeError if an integer does not fit in 128 bits or a date is invalid.
+*/
+function _packValue(data, objectList, depth) {
+	if (data === null || data === void 0) return {
+		packed: u8(TAG.NULL),
+		shareable: false
+	};
+	if (typeof data === "boolean") return {
+		packed: u8(data ? TAG.TRUE : TAG.FALSE),
+		shareable: false
+	};
+	if (data instanceof Float || typeof data === "number" && !Number.isInteger(data)) {
+		const packed = new Uint8Array(9);
+		packed[0] = TAG.FLOAT64;
+		new DataView(packed.buffer).setFloat64(1, data instanceof Float ? data.value : data, true);
+		return {
+			packed,
+			shareable: true
+		};
+	}
+	if (typeof data === "number") {
+		const value = BigInt(data);
+		return {
+			packed: value < 0n && fitsSigned(value, 8) ? packSizedInteger(value, 8) : packInteger(value),
+			shareable: !isInlineInteger(value)
+		};
+	}
+	if (typeof data === "bigint" || data instanceof Integer) {
+		const value = BigInt(data instanceof Integer ? data.value : data);
+		return {
+			packed: packInteger(value),
+			shareable: !isInlineInteger(value)
+		};
+	}
+	if (data instanceof SizedInteger) return {
+		packed: packSizedInteger(data.value, data.size),
+		shareable: !isInlineInteger(data.value)
+	};
+	if (typeof data === "string") {
+		const packed = packWithLength(TAG.STR_BASE, TAG.STR_SIZED, textEncoder.encode(data));
+		return {
+			packed,
+			shareable: packed.length > 1
+		};
+	}
+	if (data instanceof Uint8Array) return {
+		packed: packWithLength(TAG.BYTES_BASE, TAG.BYTES_SIZED, data),
+		shareable: data.length >= 2
+	};
+	if (data instanceof Date) {
+		const time = data.getTime();
+		if (Number.isNaN(time)) throw new RangeError("OPack cannot encode an invalid date");
+		const packed = new Uint8Array(9);
+		packed[0] = TAG.DATE;
+		new DataView(packed.buffer).setFloat64(1, (time - DATE_EPOCH_MS) / 1e3, true);
+		return {
+			packed,
+			shareable: true
+		};
+	}
+	if (Array.isArray(data)) {
+		const parts = data.map((item) => _pack(item, objectList, depth + 1));
+		return {
+			packed: packContainer(TAG.ARRAY_BASE, TAG.ARRAY_VARIABLE, data.length, parts),
+			shareable: false
+		};
+	}
+	if (typeof data === "object") {
+		const keys = Object.keys(data);
+		const parts = [];
+		for (const key of keys) parts.push(_pack(key, objectList, depth + 1), _pack(data[key], objectList, depth + 1));
+		return {
+			packed: packContainer(TAG.DICT_BASE, TAG.DICT_VARIABLE, keys.length, parts),
+			shareable: false
+		};
+	}
+	throw new TypeError(`OPack cannot encode a value of type ${typeof data}`);
+}
+/**
+* Packs a value and its children. A shareable value already in the object list becomes a
+* reference to it; the first occurrence joins the list.
+*
+* @throws TypeError if the value has an unsupported type or nests too deep.
+* @throws RangeError if an integer does not fit in 128 bits or a date is invalid.
+*/
+function _pack(data, objectList, depth) {
+	if (depth > MAX_DEPTH$1) throw new TypeError(`OPack nesting deeper than ${MAX_DEPTH$1} containers`);
+	const { packed, shareable } = _packValue(data, objectList, depth);
+	if (!shareable) return packed;
+	let hash = 2166136261;
+	for (const byte of packed) hash = Math.imul(hash ^ byte, 16777619);
+	const candidates = objectList.index.get(hash);
+	const existing = candidates?.find((index) => {
+		const value = objectList.values[index];
+		return value.length === packed.length && value.every((byte, offset) => byte === packed[offset]);
+	});
+	if (existing !== void 0) return packReference(existing);
+	const index = objectList.values.length;
+	objectList.values.push(packed);
+	if (candidates) candidates.push(index);
+	else objectList.index.set(hash, [index]);
+	return packed;
+}
+/**
+* Unpacks the items of a byte string in chunks (0x9F), which ends at a terminator.
+*
+* @throws TypeError if a chunk is not a byte string or the terminator is missing.
+*/
+function _unpackChunks(data, offset) {
+	const chunks = [];
+	let pos = offset;
+	while (!isTerminator(data, pos)) {
+		const tag = data[pos];
+		let length;
+		let start;
+		if (tag >= TAG.BYTES_BASE && tag <= TAG.BYTES_MAX_INLINE) {
+			length = tag - TAG.BYTES_BASE;
+			start = pos + 1;
+		} else if (tag >= TAG.BYTES_SIZED && tag <= TAG.BYTES_SIZED_MAX) {
+			const width = LENGTH_WIDTHS[tag - TAG.BYTES_SIZED];
+			length = readUnsigned(data, pos + 1, width);
+			start = pos + 1 + width;
+		} else throw new TypeError(`Invalid OPack data chunk 0x${tag.toString(16)}`);
+		ensureAvailable(data, start, length);
+		chunks.push(data.subarray(start, start + length));
+		pos = start + length;
+	}
+	return {
+		value: concat$1(chunks),
+		offset: pos + 1
+	};
+}
+/**
+* Unpacks the OPack value at `offset`. Strings, byte strings of two bytes or more, numbers
+* outside -1 to 39, dates and UUIDs join the object list in the order they appear, so later
+* references can point to them. Arrays, dictionaries and references never join it.
+*
+* @throws TypeError if the buffer ends early, nests too deep, refers to a value that does not
+* exist or holds a tag OPack does not define.
+*/
+function _unpackAt(data, offset, objectList, depth) {
+	if (depth > MAX_DEPTH$1) throw new TypeError(`OPack nesting deeper than ${MAX_DEPTH$1} containers`);
+	ensureAvailable(data, offset, 1);
+	const tag = data[offset];
+	let shareable = false;
+	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) {
+		ensureAvailable(data, offset + 1, 16);
+		value = data.subarray(offset + 1, offset + 17);
+		newOffset = offset + 17;
+		shareable = true;
+	} else if (tag === TAG.DATE) {
+		ensureAvailable(data, offset + 1, 8);
+		const seconds = new DataView(data.buffer, data.byteOffset + offset + 1, 8).getFloat64(0, true);
+		value = /* @__PURE__ */ new Date(DATE_EPOCH_MS + seconds * 1e3);
+		newOffset = offset + 9;
+		shareable = true;
+	} else if (tag >= TAG.INT_INLINE_MIN && tag <= TAG.INT_INLINE_MAX) {
+		value = tag - TAG.INT_BASE;
+		newOffset = offset + 1;
+	} else if (tag >= TAG.INT_SIZED && tag <= TAG.INT_SIZED_MAX) {
+		const size = INT_WIDTHS[tag - TAG.INT_SIZED];
+		const integer = readSigned(data, offset + 1, size);
+		value = sizedInteger(toInteger(integer), size);
+		newOffset = offset + 1 + size;
+		shareable = !isInlineInteger(integer);
+	} else if (tag === TAG.FLOAT32) {
+		ensureAvailable(data, offset + 1, 4);
+		value = new DataView(data.buffer, data.byteOffset + offset + 1, 4).getFloat32(0, true);
+		newOffset = offset + 5;
+		shareable = true;
+	} else if (tag === TAG.FLOAT64) {
+		ensureAvailable(data, offset + 1, 8);
+		value = new DataView(data.buffer, data.byteOffset + offset + 1, 8).getFloat64(0, true);
+		newOffset = offset + 9;
+		shareable = true;
+	} else if (tag >= TAG.STR_BASE && tag <= TAG.STR_MAX_INLINE) {
+		const length = tag - TAG.STR_BASE;
+		ensureAvailable(data, offset + 1, length);
+		value = textDecoder.decode(data.subarray(offset + 1, offset + 1 + length));
+		newOffset = offset + 1 + length;
+		shareable = length > 0;
+	} else if (tag >= TAG.STR_SIZED && tag <= TAG.STR_SIZED_MAX) {
+		const width = LENGTH_WIDTHS[tag - TAG.STR_SIZED];
+		const length = readUnsigned(data, offset + 1, width);
+		const start = offset + 1 + width;
+		ensureAvailable(data, start, length);
+		value = textDecoder.decode(data.subarray(start, start + length));
+		newOffset = start + length;
+		shareable = length > 0;
+	} else if (tag === TAG.STR_NUL_TERMINATED) {
+		const end = data.indexOf(0, offset + 1);
+		if (end < 0) throw new TypeError("Truncated OPack value");
+		value = textDecoder.decode(data.subarray(offset + 1, end));
+		newOffset = end + 1;
+		shareable = end > offset + 1;
+	} else if (tag >= TAG.BYTES_BASE && tag <= TAG.BYTES_MAX_INLINE) {
+		const length = tag - TAG.BYTES_BASE;
+		ensureAvailable(data, offset + 1, length);
+		value = data.subarray(offset + 1, offset + 1 + length);
+		newOffset = offset + 1 + length;
+		shareable = length >= 2;
+	} else if (tag >= TAG.BYTES_SIZED && tag <= TAG.BYTES_SIZED_MAX) {
+		const width = LENGTH_WIDTHS[tag - TAG.BYTES_SIZED];
+		const length = readUnsigned(data, offset + 1, width);
+		const start = offset + 1 + width;
+		ensureAvailable(data, start, length);
+		value = data.subarray(start, start + length);
+		newOffset = start + length;
+		shareable = length >= 2;
+	} else if (tag === TAG.BYTES_CHUNKED) {
+		const result = _unpackChunks(data, offset + 1);
+		value = result.value;
+		newOffset = result.offset;
+		shareable = value.length >= 2;
+	} else if (tag >= TAG.REF_BASE && tag <= TAG.REF_SIZED_MAX) {
+		const inline = tag <= TAG.REF_MAX_INLINE;
+		const width = inline ? 0 : REF_WIDTHS[tag - TAG.REF_SIZED];
+		const index = inline ? tag - TAG.REF_BASE : readUnsigned(data, offset + 1, width);
+		if (index >= objectList.length) throw new TypeError(`OPack reference index ${index} out of range`);
+		value = objectList[index];
+		newOffset = offset + 1 + width;
+	} else if ((tag & 240) === TAG.ARRAY_BASE) {
+		const items = [];
+		let pos = offset + 1;
+		if (tag === TAG.ARRAY_VARIABLE) {
+			while (!isTerminator(data, pos)) {
+				const result = _unpackAt(data, pos, objectList, depth + 1);
+				items.push(result.value);
+				pos = result.offset;
+			}
+			pos++;
+		} else for (let i = 0; i < (tag & 15); i++) {
+			const result = _unpackAt(data, pos, objectList, depth + 1);
+			items.push(result.value);
+			pos = result.offset;
+		}
+		value = items;
+		newOffset = pos;
+	} else if ((tag & 240) === TAG.DICT_BASE) {
+		const dictionary = {};
+		let pos = offset + 1;
+		const unpackEntry = () => {
+			const keyResult = _unpackAt(data, pos, objectList, depth + 1);
+			const valueResult = _unpackAt(data, keyResult.offset, objectList, depth + 1);
+			Object.defineProperty(dictionary, keyResult.value, {
+				value: valueResult.value,
+				enumerable: true,
+				configurable: true,
+				writable: true
+			});
+			pos = valueResult.offset;
+		};
+		if (tag === TAG.DICT_VARIABLE) {
+			while (!isTerminator(data, pos)) unpackEntry();
+			pos++;
+		} else for (let i = 0; i < (tag & 15); i++) unpackEntry();
+		value = dictionary;
+		newOffset = pos;
+	} else throw new TypeError(`Unsupported OPack tag 0x${tag.toString(16)}`);
+	if (shareable) objectList.push(value);
+	return {
+		value,
+		offset: newOffset
+	};
+}
+
+//#endregion
+//#region ../../node_modules/.bun/@plist+common@1.1.0/node_modules/@plist/common/lib/esm/constants.js
+const EPOCH = 9783072e5;
+const HEADER_BINARY = "bplist00";
+var PlistFormat;
+(function(PlistFormat) {
+	PlistFormat[PlistFormat["BINARY"] = 0] = "BINARY";
+	PlistFormat[PlistFormat["XML"] = 1] = "XML";
+	PlistFormat[PlistFormat["OPENSTEP"] = 2] = "OPENSTEP";
+})(PlistFormat || (PlistFormat = {}));
+
+//#endregion
+//#region ../../node_modules/.bun/@plist+binary.serialize@1.1.0/node_modules/@plist/binary.serialize/lib/esm/index.js
+const encoder = new TextEncoder();
+const nullBytes = new Uint8Array([
+	0,
+	0,
+	0,
+	0,
+	0,
+	0
+]);
+const fromHexString = (hexString) => Uint8Array.from(hexString.match(/.{1,2}/g).map((byte) => parseInt(byte, 16)));
+const isUID = (value) => !!value && typeof value === "object" && Object.keys(value).length == 1 && typeof value.CF$UID === "number";
+const toUTF16 = (string) => {
+	const buf = /* @__PURE__ */ 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);
+};
+const concat = (first, second) => {
+	const third = new Uint8Array(first.length + second.length);
+	third.set(first);
+	third.set(second, first.length);
+	return third;
+};
+const writeUInt = (buffer, int, 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(int));
+			break;
+		case 2:
+			dataView.setUint16(buffer.length, Number(int), false);
+			break;
+		case 4:
+			dataView.setUint32(buffer.length, Number(int), false);
+			break;
+		case 8:
+			dataView.setBigUint64(buffer.length, BigInt(int), false);
+			break;
+		default: throw new Error("Unsupported int size");
+	}
+	return output;
+};
+const writeInt = (buffer, int, 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(int));
+			break;
+		case 2:
+			dataView.setInt16(buffer.length, Number(int), false);
+			break;
+		case 4:
+			dataView.setInt32(buffer.length, Number(int), false);
+			break;
+		case 8:
+			dataView.setBigInt64(buffer.length, BigInt(int), false);
+			break;
+		default: throw new Error("Unsupported int size");
+	}
+	return output;
+};
+const 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;
+};
+const 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 value = entry.value;
+			switch (typeof value) {
+				case "number":
+				case "bigint":
+					writeNumber(value);
+					break;
+				case "string":
+					writeString(value);
+					break;
+				case "boolean":
+					writeBoolean(value);
+					break;
+			}
+			if (value instanceof Date) writeDate(value);
+			else if (value instanceof ArrayBuffer) writeData(value);
+			else if (isUID(value)) writeUID(value.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(value) {
+		buffer = writeUInt(buffer, 51, 1);
+		const date = (value.getTime() - EPOCH) / 1e3;
+		buffer = writeDouble(buffer, date);
+	}
+	function writeDict(entry) {
+		writeIntHeader(13, entry.entryKeys.length);
+		entry.entryKeys.forEach((entry) => {
+			writeID(entry.id);
+		});
+		entry.entryValues.forEach((entry) => {
+			writeID(entry.id);
+		});
+	}
+	function writeNumber(value) {
+		if (typeof value === "bigint") {
+			const width = 16;
+			const buf = fromHexString(value.toString(16).padStart(width * 2, "0").slice(0, width * 2));
+			buffer = writeUInt(buffer, 20, 1);
+			buffer = concat(buffer, buf);
+		} else if (Number.isInteger(value)) if (value < 0) {
+			buffer = writeUInt(buffer, 19, 1);
+			buffer = writeInt(buffer, value, 8);
+		} else if (value <= 255) {
+			buffer = writeUInt(buffer, 16, 1);
+			buffer = writeUInt(buffer, value, 1);
+		} else if (value <= 65535) {
+			buffer = writeUInt(buffer, 17, 1);
+			buffer = writeUInt(buffer, value, 2);
+		} else if (value <= 4294967295) {
+			buffer = writeUInt(buffer, 18, 1);
+			buffer = writeUInt(buffer, value, 4);
+		} else {
+			buffer = writeUInt(buffer, 19, 1);
+			buffer = writeUInt(buffer, value, 8);
+		}
+		else {
+			buffer = writeUInt(buffer, 35, 1);
+			buffer = writeDouble(buffer, value);
+		}
+	}
+	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(value) {
+		buffer = writeUInt(buffer, value ? 9 : 8, 1);
+	}
+	function writeString(value) {
+		if (mustBeUtf16(value)) {
+			const utf16 = toUTF16(value);
+			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(value);
+			writeIntHeader(5, utf8.length);
+			buffer = concat(buffer, utf8);
+		}
+	}
+	function writeData(data) {
+		writeIntHeader(4, data.byteLength);
+		buffer = concat(buffer, new Uint8Array(data));
+	}
+	function writeIntHeader(kind, value) {
+		if (value < 15) buffer = writeUInt(buffer, (kind << 4) + value, 1);
+		else {
+			buffer = writeUInt(buffer, (kind << 4) + 15, 1);
+			writeNumber(value);
+		}
+	}
+	function writeID(id) {
+		buffer = writeUInt(buffer, id, idSizeInBytes);
+	}
+	function mustBeUtf16(string) {
+		return encoder.encode(string).byteLength != string.length;
+	}
+};
+const 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: void 0,
+		entries: entries.map((entries) => entries[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: void 0,
+			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;
+}
+
+//#endregion
+//#region src/encoding/plist.ts
+var plist_exports = /* @__PURE__ */ __exportAll({
+	parse: () => parse,
+	serialize: () => serialize
+});
+const HEADER = "bplist00";
+const TRAILER_SIZE = 32;
+const MAX_OBJECT_COUNT = 32768;
+const MAX_DEPTH = 256;
+/** Milliseconds between the Unix epoch and the Cocoa epoch (2001-01-01 GMT). */
+const COCOA_EPOCH = 9783072e5;
+const UTF8 = new TextDecoder("utf-8");
+const UTF16_BE = new TextDecoder("utf-16be");
+/**
+* Parses a binary plist.
+*
+* Integers of 1, 2 and 4 bytes are unsigned; only 8-byte integers carry a sign. A signed
+* read turns 200 into -56 and 44100 into -21436. An 8-byte integer comes back as a `bigint`.
+*
+* @throws Error when the buffer is not a well-formed binary plist.
+*/
+function parse(buffer) {
+	const bytes = new Uint8Array(buffer);
+	const view = new DataView(buffer);
+	if (bytes.byteLength < 40 || UTF8.decode(bytes.subarray(0, 8)) !== HEADER) throw new Error(`Invalid binary plist. Expected '${HEADER}' at offset 0.`);
+	const trailer = bytes.byteLength - TRAILER_SIZE;
+	const offsetSize = view.getUint8(trailer + 6);
+	const refSize = view.getUint8(trailer + 7);
+	const objectCount = Number(view.getBigUint64(trailer + 8));
+	const topObject = Number(view.getBigUint64(trailer + 16));
+	const offsetTable = Number(view.getBigUint64(trailer + 24));
+	if (objectCount > MAX_OBJECT_COUNT) throw new Error("Binary plist has too many objects.");
+	const readUInt = (offset, size) => {
+		if (offset < 0 || offset + size > bytes.byteLength) throw new Error("Binary plist points outside the buffer.");
+		let value = 0;
+		for (let i = 0; i < size; i++) value = value * 256 + bytes[offset + i];
+		return value;
+	};
+	/** Reads a count that is either the low nibble or, for 0xF, an integer object that follows. */
+	const readCount = (offset, info) => {
+		if (info !== 15) return [info, offset + 1];
+		const size = 1 << (view.getUint8(offset + 1) & 15);
+		return [readUInt(offset + 2, size), offset + 2 + size];
+	};
+	const readInteger = (offset, size) => {
+		if (size === 8) return view.getBigInt64(offset, false);
+		if (size === 16) return view.getBigUint64(offset + 8, false);
+		return readUInt(offset, size);
+	};
+	const readReal = (offset, size) => {
+		if (size === 4) return view.getFloat32(offset, false);
+		if (size === 8) return view.getFloat64(offset, false);
+		throw new Error(`Invalid real length: ${size}`);
+	};
+	const readObject = (index, depth) => {
+		if (index >= objectCount || depth > MAX_DEPTH) throw new Error("Binary plist has an invalid object reference.");
+		const offset = readUInt(offsetTable + index * offsetSize, offsetSize);
+		const marker = readUInt(offset, 1);
+		const type = marker >> 4;
+		const info = marker & 15;
+		switch (type) {
+			case 0:
+				if (info === 8 || info === 9) return info === 9;
+				if (info === 0 || info === 15) return null;
+				throw new Error(`Unhandled simple type 0x${info.toString(16)}`);
+			case 1: return readInteger(offset + 1, 1 << info);
+			case 2: return readReal(offset + 1, 1 << info);
+			case 3: return /* @__PURE__ */ new Date(COCOA_EPOCH + 1e3 * view.getFloat64(offset + 1, false));
+			case 4: {
+				const [length, start] = readCount(offset, info);
+				readUInt(start + length, 0);
+				return buffer.slice(start, start + length);
+			}
+			case 5: {
+				const [length, start] = readCount(offset, info);
+				readUInt(start + length, 0);
+				return UTF8.decode(bytes.subarray(start, start + length));
+			}
+			case 6: {
+				const [length, start] = readCount(offset, info);
+				readUInt(start + length * 2, 0);
+				return UTF16_BE.decode(bytes.subarray(start, start + length * 2));
+			}
+			case 8: return { CF$UID: readUInt(offset + 1, info + 1) };
+			case 10: {
+				const [length, start] = readCount(offset, info);
+				const items = [];
+				for (let i = 0; i < length; i++) items.push(readObject(readUInt(start + i * refSize, refSize), depth + 1));
+				return items;
+			}
+			case 13: {
+				const [length, start] = readCount(offset, info);
+				const dictionary = {};
+				for (let i = 0; i < length; i++) {
+					const key = readObject(readUInt(start + i * refSize, refSize), depth + 1);
+					if (typeof key !== "string") throw new Error("Invalid key type.");
+					if (key === "__proto__") throw new Error("Attempted prototype pollution");
+					dictionary[key] = readObject(readUInt(start + (length + i) * refSize, refSize), depth + 1);
+				}
+				return dictionary;
+			}
+			default: throw new Error(`Unhandled type 0x${type.toString(16)}`);
+		}
+	};
+	return readObject(topObject, 0);
+}
+
+//#endregion
+//#region src/encoding/tlv8.ts
+var tlv8_exports = /* @__PURE__ */ __exportAll({
+	ErrorCode: () => ErrorCode,
+	Flags: () => Flags,
+	Method: () => Method,
+	State: () => State,
+	Value: () => Value,
+	bail: () => bail,
+	decode: () => decode,
+	decodeEntries: () => decodeEntries,
+	encode: () => encode
+});
+/**
+* TLV8 pairing flags used during HAP pair-setup and pair-verify.
+* Sent as part of the TLV8 Flags (0x13) value.
+*/
+const Flags = { TransientPairing: 16 };
+/**
+* TLV8 error codes returned by the accessory during pairing.
+* Included in the Error (0x07) TLV value.
+*/
+const ErrorCode = {
+	Unknown: 1,
+	Authentication: 2,
+	BackOff: 3,
+	MaxPeers: 4,
+	MaxTries: 5,
+	Unavailable: 6,
+	Busy: 7
+};
+/**
+* HAP pairing method identifiers. Sent in the Method (0x00) TLV value
+* to indicate which pairing operation is being performed.
+*/
+const Method = {
+	PairSetup: 0,
+	PairSetupWithAuth: 1,
+	PairVerify: 2,
+	AddPairing: 3,
+	RemovePairing: 4,
+	ListPairing: 5
+};
+/**
+* HAP pairing state machine steps (M1 through M6).
+* Each state corresponds to a message in the SRP pair-setup or pair-verify flow.
+*/
+const State = {
+	M1: 1,
+	M2: 2,
+	M3: 3,
+	M4: 4,
+	M5: 5,
+	M6: 6
+};
+/**
+* TLV8 type identifiers for the fields exchanged during HAP pairing.
+* Each value is the type byte that precedes the length and data in a TLV8 entry.
+*/
+const 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
+};
+/** Throws the {@link TLV8PairingError} for the error or back-off in a decoded pairing response. */
+function bail(data) {
+	if (data.has(Value.BackOff)) {
+		const buffer = data.get(Value.BackOff);
+		throw new TLV8PairingError(`Device is busy, try again in ${buffer.readUintLE(0, buffer.length)} seconds.`, ErrorCode.BackOff);
+	}
+	if (data.has(Value.Error)) {
+		const code = data.get(Value.Error).readUint8();
+		const errorCode = Object.entries(ErrorCode).find(([, value]) => value === code);
+		if (!errorCode) throw new TLV8PairingError(`Device returned an unknown error code: ${code}`, code);
+		throw new TLV8PairingError(`Device returned an error code: ${errorCode[0]}`, code);
+	}
+	throw new TLV8PairingError("Invalid response");
+}
+/**
+* Encodes `[type, value]` entries; a number value is a single byte. A value longer than 255 bytes
+* becomes consecutive fragments of the same type, as TLV8 requires.
+*/
+function encode(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;
+}
+/**
+* Decodes a TLV8 buffer into a map from type to value, for messages that hold each type once,
+* such as pairing messages. Adjacent entries of the same type are concatenated, which reassembles
+* fragmented values. When a type appears again after another type, the first value wins.
+*
+* @throws {RangeError} When an entry is truncated.
+*/
+function decode(buf) {
+	const map = /* @__PURE__ */ new Map();
+	for (const [type, value] of decodeEntries(buf)) if (!map.has(type)) map.set(type, value);
+	return map;
+}
+/**
+* Decodes a TLV8 buffer into its `[type, value]` entries in order, for lists in which a type
+* repeats. Adjacent entries of the same type are concatenated into one value, which reassembles
+* fragmented values; a separator entry between two items keeps them apart.
+*
+* @throws {RangeError} When an entry is truncated.
+*/
+function decodeEntries(buf) {
+	const entries = [];
+	let i = 0;
+	while (i < buf.length) {
+		if (buf.length - i < 2) throw new RangeError("Truncated TLV8 header");
+		const type = buf[i++];
+		const len = buf[i++];
+		if (len > buf.length - i) throw new RangeError("Truncated TLV8 value");
+		const value = buf.subarray(i, i + len);
+		const last = entries.at(-1);
+		if (last && last[0] === type) last[1] = Buffer.concat([last[1], value]);
+		else entries.push([type, value]);
+		i += len;
+	}
+	return entries;
+}
+
+//#endregion
+//#region src/encoding/rti.ts
+var rti_exports = /* @__PURE__ */ __exportAll({
+	decodeSession: () => decodeSession,
+	encodeOperation: () => encodeOperation
+});
+/** Reads RTIKeyedArchiver roots without exposing bytes outside the supplied view. */
+function decodeSession(data) {
+	const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
+	const archive = parse(Uint8Array.from(bytes).buffer);
+	const objects = archive?.$objects;
+	if (!Array.isArray(objects) || !archive?.$top) throw new Error("Invalid RTI archive.");
+	const resolve = (value, depth = 0) => {
+		if (depth > 64) throw new Error("Invalid RTI archive reference cycle.");
+		if (value === "$null") return null;
+		if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) return value;
+		if (!value || typeof value !== "object") return value;
+		if ("CF$UID" in value) {
+			const index = value["CF$UID"];
+			if (!Number.isInteger(index) || index < 0 || index >= objects.length) throw new Error("Invalid RTI archive reference.");
+			return resolve(objects[index], depth + 1);
+		}
+		if (Array.isArray(value)) return value.map((item) => resolve(item, depth + 1));
+		const result = {};
+		for (const [key, item] of Object.entries(value)) if (key !== "$class") result[key] = resolve(item, depth + 1);
+		return result;
+	};
+	const roots = resolve(archive.$top);
+	const root = roots.root ?? roots;
+	const uuidValue = root.sessionUUID?.["NS.uuidbytes"] ?? root.sessionUUID;
+	const uuid = uuidValue instanceof ArrayBuffer ? new Uint8Array(uuidValue) : uuidValue instanceof Uint8Array ? uuidValue : null;
+	if (!uuid || uuid.byteLength !== 16) throw new Error("Invalid RTI session UUID.");
+	const document = root.documentState ?? {};
+	const traits = root.documentTraits ?? {};
+	const text = document.docSt ?? document.documentContextBeforeInput ?? "";
+	const documentText = typeof text === "string" ? text : text?.["NS.string"] ?? "";
+	return {
+		uuid: Uint8Array.from(uuid),
+		documentText: typeof documentText === "string" ? documentText : "",
+		isSecure: !!traits.secureTextEntry,
+		keyboardType: Number(traits.keyboardType ?? 0),
+		autocorrection: Number(traits.autocorrectionType ?? 0) === 2,
+		autocapitalization: Number(traits.autocapitalizationType ?? 0) !== 0
+	};
+}
+function uid(index) {
+	return { "CF$UID": index };
+}
+/** Encodes an RTITextOperations archive that inserts `text`, or clears the field when `clear` is set. */
+function encodeOperation(sessionUUID, text, clear) {
+	if (sessionUUID.byteLength !== 16) throw new Error("Invalid RTI session UUID.");
+	return serialize({
+		"$version": 1e5,
+		"$archiver": "RTIKeyedArchiver",
+		"$top": { textOperations: uid(1) },
+		"$objects": [
+			"$null",
+			{
+				$class: uid(7),
+				targetSessionUUID: uid(5),
+				keyboardOutput: uid(2),
+				...clear ? { textToAssert: uid(3) } : {}
+			},
+			{
+				$class: uid(4),
+				...clear ? {} : { insertionText: uid(3) }
+			},
+			clear ? "" : text,
+			{
+				$classname: "TIKeyboardOutput",
+				$classes: ["TIKeyboardOutput", "NSObject"]
+			},
+			{
+				"NS.uuidbytes": Uint8Array.from(sessionUUID).buffer,
+				$class: uid(6)
+			},
+			{
+				$classname: "NSUUID",
+				$classes: ["NSUUID", "NSObject"]
+			},
+			{
+				$classname: "RTITextOperations",
+				$classes: ["RTITextOperations", "NSObject"]
+			}
+		]
+	});
+}
+
+//#endregion
+export { Value as a, encode as c, encode$1 as d, opack_exports as f, daap_exports as h, State as i, tlv8_exports as l, nskeyedarchiver_exports as m, Flags as n, bail as o, ntp_exports as p, Method as r, decode as s, rti_exports as t, plist_exports as u };