@basmilius/apple-common 0.8.1 → 0.9.2

package/dist/index.mjs

@@ -1,3 +1,1479 @@
-import{randomBytes as e,randomFillSync as t,randomUUID as n}from"node:crypto";import r from"node-dns-sd";import{createInterface as i}from"node:readline";import{EventEmitter as a}from"node:events";import{Socket as o}from"node:net";import{NTP as s,OPack as c,TLV8 as l}from"@basmilius/apple-encoding";import{Chacha20 as u,Curve25519 as d,Ed25519 as f,hkdf as p}from"@basmilius/apple-encryption";import{SRP as m,SrpClient as h}from"fast-srp-hap";import{createSocket as g}from"node:dgram";import{networkInterfaces as _}from"node:os";const v=[];for(let e=0;e<256;++e)v.push((e+256).toString(16).slice(1));function y(e,t=0){return(v[e[t+0]]+v[e[t+1]]+v[e[t+2]]+v[e[t+3]]+`-`+v[e[t+4]]+v[e[t+5]]+`-`+v[e[t+6]]+v[e[t+7]]+`-`+v[e[t+8]]+v[e[t+9]]+`-`+v[e[t+10]]+v[e[t+11]]+v[e[t+12]]+v[e[t+13]]+v[e[t+14]]+v[e[t+15]]).toLowerCase()}const b=new Uint8Array(256);let x=b.length;function S(){return x>b.length-16&&(t(b),x=0),b.slice(x,x+=16)}var C={randomUUID:n};function w(e,t,n){e||={};let r=e.random??e.rng?.()??S();if(r.length<16)throw Error(`Random bytes length must be >= 16`);if(r[6]=r[6]&15|64,r[8]=r[8]&63|128,t){if(n||=0,n<0||n+16>t.length)throw RangeError(`UUID byte range ${n}:${n+15} is out of buffer bounds`);for(let e=0;e<16;++e)t[n+e]=r[e];return t}return y(r)}function T(e,t,n){return C.randomUUID&&!t&&!e?C.randomUUID():w(e,t,n)}async function E(e){let t=i({input:process.stdin,output:process.stdout}),n=await new Promise(n=>t.question(`${e}: `,n));return t.close(),n}async function D(e){return new Promise(t=>setTimeout(t,e))}const O=`3939`,k=6e3,A=`_airplay._tcp.local`,j=`_companion-link._tcp.local`,M=`_raop._tcp.local`;var N=class e{#e;constructor(e){this.#e=e}async find(){return(await r.discover({name:this.#e})).map(e=>({id:P(e)??e.fqdn,txt:ee(e),...e}))}async findUntil(e,t=10,n=1e3){for(;t>0;){let r=await this.find(),i=r.find(t=>t.id===e);if(i)return i;console.log(),console.log(`Device not found, retrying in ${n}ms...`),console.log(r.map(e=>` ● ${e.id} (${e.fqdn})`).join(`
-`)),t--,await D(n)}throw Error(`Device not found after serveral tries, aborting.`)}static airplay(){return new e(A)}static companionLink(){return new e(j)}static raop(){return new e(M)}};function P(e){if(!e?.packet)return null;let{answers:t=[],additionals:n=[]}=e.packet,r=[...t,...n],i=r.find(e=>e.type===`SRV`);if(i?.rdata?.target)return i.rdata.target;if(e.address){let t=r.find(t=>(t.type===`A`||t.type===`AAAA`)&&t.rdata===e.address);if(t?.name)return t.name}let a=r.find(e=>e.type===`A`);return a?.name?a.name:e.modelName?`${e.modelName.replace(/\s+/g,`-`).replace(/[^a-zA-Z0-9-]/g,``)}.local`:null}function ee(e){if(!e.packet)return{};let{answers:t=[],additionals:n=[]}=e.packet,r=[...t,...n],i={};for(let e of r)e.type===`TXT`&&e.rdata&&Object.assign(i,e.rdata);return i}const F=Symbol(),I={resolve:()=>{},reject:e=>{}};var L=class extends a{get address(){return this.#e}get context(){return this.#n}get port(){return this.#t}get isConnected(){return this.#u===`connected`}get state(){if(this.#u===`closing`||this.#u===`failed`)return this.#u;if(!this.#l)return`disconnected`;switch(this.#l.readyState){case`opening`:return`connecting`;case`open`:return`connected`;default:return this.#u}}#e;#t;#n;#r=!1;#i=0;#a=3;#o=!0;#s=3e3;#c;#l;#u;#d;constructor(e,t,n){super(),this.#e=t,this.#t=n,this.#n=e,this.#u=`disconnected`}async connect(){if(this.#u!==`connected`){if(this.#u===`connecting`)throw Error(`A connection is already being established.`);return this.#o=!0,this.#i=0,this.#f()}}destroy(){this.#l?.destroy()}async disconnect(){if(this.#c&&=(clearTimeout(this.#c),void 0),this.#o=!1,!(!this.#l||this.#u===`disconnected`))return new Promise(e=>{this.#u=`closing`,this.#l.once(`close`,()=>{this.#p(),e()}),this.#l.end()})}debug(e){return this.#r=e,this}retry(e,t=3e3){return this.#a=e,this.#s=t,this}write(e){if(!this.#l||this.state!==`connected`||!this.#l.writable){this.emit(`error`,Error(`Cannot write to a disconnected connection.`));return}this.#l.write(e,e=>{e&&(this.#n.logger.error(`Failed to write data to socket.`),this.emit(`error`,e))})}async#f(){return new Promise((e,t)=>{this.#u=`connecting`,this.#d={resolve:e,reject:t},this.#l?.removeAllListeners(),this.#l=void 0,this.#l=new o,this.#l.setNoDelay(!0),this.#l.setTimeout(1e4),this.#l.on(`close`,this.#h.bind(this)),this.#l.on(`connect`,this.#g.bind(this)),this.#l.on(`data`,this.#_.bind(this)),this.#l.on(`end`,this.#v.bind(this)),this.#l.on(`error`,this.#y.bind(this)),this.#l.on(`timeout`,this.#b.bind(this)),this.#n.logger.net(`Connecting to ${this.#e}:${this.#t}...`),this.#l.connect({host:this.#e,port:this.#t,keepAlive:!0})})}#p(){this.#c&&=(clearTimeout(this.#c),void 0),this.#l&&=(this.#l.removeAllListeners(),this.#l.destroy(),void 0),this.#u=`disconnected`,this.#d=void 0}#m(e){if(!this.#o||this.#i>=this.#a){this.#u=`failed`,this.#d?.reject(e),this.#d=void 0;return}this.#c&&=(clearTimeout(this.#c),void 0),this.#i++,this.#n.logger.net(`Retry attempt ${this.#i} / ${this.#a} in ${this.#s}ms...`);let{resolve:t,reject:n}=this.#d??I;this.#p(),this.#c=setTimeout(async()=>{this.#c=void 0;try{this.#d={resolve:t,reject:n},await this.#f(),t()}catch{}},this.#s)}#h(e){let t=this.#u===`connected`;this.#u!==`closing`&&(this.#u=`disconnected`,this.#n.logger.net(`Connection closed (${e?`with error`:`normally`}).`)),this.emit(`close`,e),t&&this.#o&&e&&this.#m(Error(`Connection closed unexpectedly.`))}#g(){this.#u=`connected`,this.#i=0,this.#l.setKeepAlive(!0,1e4),this.#l.setTimeout(0),this.emit(`connect`),this.#d?.resolve(),this.#d=void 0}#_(e){if(this.#r){let t=Math.min(e.byteLength,64);this.#n.logger.debug(`Received ${e.byteLength} bytes of data.`),this.#n.logger.debug(`hex=${e.subarray(0,t).toString(`hex`)}`),this.#n.logger.debug(`ascii=${e.toString(`ascii`).replace(/[^\x20-\x7E]/g,`.`).substring(0,t)}`)}this.emit(`data`,e)}#v(){this.emit(`end`)}#y(e){this.#n.logger.error(`Connection error: ${e.message}`),this.listenerCount(`error`)>0?this.emit(`error`,e):this.#n.logger.warn(`No error handler registered. This is likely a bug.`,this.constructor.name,`#onError`),this.#u===`connecting`?this.#m(e):this.#u=`failed`}#b(){this.#n.logger.error(`Connection timed out.`);let e=Error(`Connection timed out.`);this.emit(`timeout`),this.#u===`connecting`?this.#m(e):(this.#u=`failed`,this.#l?.destroy())}},R=class extends L{get isEncrypted(){return!!this[F]}[F];enableEncryption(e,t){this[F]=new z(e,t)}},z=class{readKey;readCount;writeKey;writeCount;constructor(e,t){this.readCount=0,this.readKey=e,this.writeCount=0,this.writeKey=t}},B=class{get id(){return this.#e}get label(){return this.#t}#e;#t;constructor(e){this.#e=e,this.#t=`\u001b[36m[${e}]\u001b[39m`}debug(...e){H(this.#t,...e)}error(...e){U(this.#t,...e)}info(...e){W(this.#t,...e)}net(...e){G(this.#t,...e)}raw(...e){K(this.#t,...e)}warn(...e){q(this.#t,...e)}},V=class{#e=[];all(){this.#e=[`debug`,`error`,`info`,`net`,`raw`,`warn`]}disable(e){this.#e.includes(e)&&this.#e.splice(this.#e.indexOf(e),1)}enable(e){this.#e.includes(e)||this.#e.push(e)}isEnabled(e){return this.#e.includes(e)}};function H(...e){J.isEnabled(`debug`)&&console.debug(`\x1B[36m[debug]\x1B[39m`,...e)}function U(...e){J.isEnabled(`error`)&&console.error(`\x1B[31m[error]\x1B[39m`,...e)}function W(...e){J.isEnabled(`info`)&&console.info(`\x1B[32m[info]\x1B[39m`,...e)}function G(...e){J.isEnabled(`net`)&&console.info(`\x1B[33m[net]\x1B[39m`,...e)}function K(...e){J.isEnabled(`raw`)&&console.log(`\x1B[34m[raw]\x1B[39m`,...e)}function q(...e){J.isEnabled(`warn`)&&console.warn(`\x1B[33m[warn]\x1B[39m`,...e)}const J=new V;var Y=class{get deviceId(){return this.#e}get logger(){return this.#t}#e;#t;constructor(e){this.#e=e,this.#t=new B(e)}},X=class{get context(){return this.#e}#e;constructor(e){this.#e=e}tlv(e){let t=l.decode(e);return t.has(l.Value.Error)&&l.bail(t),this.#e.logger.raw(`Decoded TLV`,t),t}},Z=class extends X{#e;#t;#n;#r;#i;#a;constructor(e,t){super(e),this.#e=`basmilius/apple-protocols`,this.#t=Buffer.from(T().toUpperCase()),this.#n=t}async start(){let e=f.generateKeyPair();this.#r=Buffer.from(e.publicKey),this.#i=Buffer.from(e.secretKey)}async pin(e){let t=await this.m1(),n=await this.m2(t,await e()),r=await this.m3(n),i=await this.m4(r),a=await this.m5(i),o=await this.m6(i,a);if(!o)throw Error(`Pairing failed, could not get accessory keys.`);return o}async transient(){let e=await this.m1([[l.Value.Flags,l.Flags.TransientPairing]]),t=await this.m2(e),n=await this.m3(t),r=await this.m4(n),i=p({hash:`sha512`,key:r.sharedSecret,length:32,salt:Buffer.from(`Control-Salt`),info:Buffer.from(`Control-Read-Encryption-Key`)}),a=p({hash:`sha512`,key:r.sharedSecret,length:32,salt:Buffer.from(`Control-Salt`),info:Buffer.from(`Control-Write-Encryption-Key`)});return{pairingId:this.#t,sharedSecret:r.sharedSecret,accessoryToControllerKey:i,controllerToAccessoryKey:a}}async m1(e=[]){let t=await this.#n(`m1`,l.encode([[l.Value.Method,l.Method.PairSetup],[l.Value.State,l.State.M1],...e])),n=this.tlv(t);return{publicKey:n.get(l.Value.PublicKey),salt:n.get(l.Value.Salt)}}async m2(e,t=O){let n=await m.genKey(32);return this.#a=new h(m.params.hap,e.salt,Buffer.from(`Pair-Setup`),Buffer.from(t),n,!0),this.#a.setB(e.publicKey),{publicKey:this.#a.computeA(),proof:this.#a.computeM1()}}async m3(e){let t=await this.#n(`m3`,l.encode([[l.Value.State,l.State.M3],[l.Value.PublicKey,e.publicKey],[l.Value.Proof,e.proof]]));return{serverProof:this.tlv(t).get(l.Value.Proof)}}async m4(e){return this.#a.checkM2(e.serverProof),{sharedSecret:this.#a.computeK()}}async m5(e){let t=p({hash:`sha512`,key:e.sharedSecret,length:32,salt:Buffer.from(`Pair-Setup-Controller-Sign-Salt`,`utf8`),info:Buffer.from(`Pair-Setup-Controller-Sign-Info`,`utf8`)}),n=p({hash:`sha512`,key:e.sharedSecret,length:32,salt:Buffer.from(`Pair-Setup-Encrypt-Salt`,`utf8`),info:Buffer.from(`Pair-Setup-Encrypt-Info`,`utf8`)}),r=Buffer.concat([t,this.#t,this.#r]),i=f.sign(r,this.#i),a=l.encode([[l.Value.Identifier,this.#t],[l.Value.PublicKey,this.#r],[l.Value.Signature,Buffer.from(i)],[l.Value.Name,c.encode({name:this.#e})]]),{authTag:o,ciphertext:s}=u.encrypt(n,Buffer.from(`PS-Msg05`),null,a),d=Buffer.concat([s,o]),m=await this.#n(`m5`,l.encode([[l.Value.State,l.State.M5],[l.Value.EncryptedData,d]])),h=this.tlv(m).get(l.Value.EncryptedData),g=h.subarray(0,-16);return{authTag:h.subarray(-16),data:g,sessionKey:n}}async m6(e,t){let n=u.decrypt(t.sessionKey,Buffer.from(`PS-Msg06`),null,t.data,t.authTag),r=l.decode(n),i=r.get(l.Value.Identifier),a=r.get(l.Value.PublicKey),o=r.get(l.Value.Signature),s=p({hash:`sha512`,key:e.sharedSecret,length:32,salt:Buffer.from(`Pair-Setup-Accessory-Sign-Salt`),info:Buffer.from(`Pair-Setup-Accessory-Sign-Info`)}),c=Buffer.concat([s,i,a]);if(!f.verify(c,o,a))throw Error(`Invalid accessory signature.`);return{accessoryIdentifier:i.toString(),accessoryLongTermPublicKey:a,pairingId:this.#t,publicKey:this.#r,secretKey:this.#i}}},Q=class extends X{#e;#t;constructor(e,t){super(e),this.#e=d.generateKeyPair(),this.#t=t}async start(e){let t=await this.#n(),n=await this.#r(e.accessoryIdentifier,e.accessoryLongTermPublicKey,t);return await this.#i(e.pairingId,e.secretKey,n),await this.#a(n,e.pairingId)}async#n(){let e=await this.#t(`m1`,l.encode([[l.Value.State,l.State.M1],[l.Value.PublicKey,Buffer.from(this.#e.publicKey)]])),t=this.tlv(e),n=t.get(l.Value.PublicKey);return{encryptedData:t.get(l.Value.EncryptedData),serverPublicKey:n}}async#r(e,t,n){let r=Buffer.from(d.generateSharedSecKey(this.#e.secretKey,n.serverPublicKey)),i=p({hash:`sha512`,key:r,length:32,salt:Buffer.from(`Pair-Verify-Encrypt-Salt`),info:Buffer.from(`Pair-Verify-Encrypt-Info`)}),a=n.encryptedData.subarray(0,-16),o=n.encryptedData.subarray(-16),s=u.decrypt(i,Buffer.from(`PV-Msg02`),null,a,o),c=l.decode(s),m=c.get(l.Value.Identifier),h=c.get(l.Value.Signature);if(m.toString()!==e)throw Error(`Invalid accessory identifier. Expected ${m.toString()} to be ${e}.`);let g=Buffer.concat([n.serverPublicKey,m,this.#e.publicKey]);if(!f.verify(g,h,t))throw Error(`Invalid accessory signature.`);return{serverEphemeralPublicKey:n.serverPublicKey,sessionKey:i,sharedSecret:r}}async#i(e,t,n){let r=Buffer.concat([this.#e.publicKey,e,n.serverEphemeralPublicKey]),i=Buffer.from(f.sign(r,t)),a=l.encode([[l.Value.Identifier,e],[l.Value.Signature,i]]),{authTag:o,ciphertext:s}=u.encrypt(n.sessionKey,Buffer.from(`PV-Msg03`),null,a),c=Buffer.concat([s,o]);return await this.#t(`m3`,l.encode([[l.Value.State,l.State.M3],[l.Value.EncryptedData,c]])),{}}async#a(e,t){return{accessoryToControllerKey:Buffer.alloc(0),controllerToAccessoryKey:Buffer.alloc(0),pairingId:t,sharedSecret:e.sharedSecret}}},te=class{get port(){return this.#n}#e;#t;#n=0;constructor(){this.#e=new B(`timing-server`),this.#t=g(`udp4`),this.#t.on(`connect`,this.#r.bind(this)),this.#t.on(`error`,this.#i.bind(this)),this.#t.on(`message`,this.#o.bind(this))}close(){this.#t.close(),this.#n=0}listen(){return new Promise((e,t)=>{this.#t.once(`error`,t),this.#t.once(`listening`,()=>{this.#t.removeListener(`error`,t),this.#a(),e()}),this.#t.bind(0,e)})}#r(){this.#t.setRecvBufferSize(16384),this.#t.setSendBufferSize(16384)}#i(e){this.#e.error(`Timing server error`,e)}#a(){let{port:e}=this.#t.address();this.#n=e}#o(e,t){try{let n=s.decode(e),r=s.now(),[i,a]=s.parts(r);this.#e.info(`Timing server ntp=${r} receivedSeconds=${i} receivedFraction=${a}`);let o=s.encode({proto:n.proto,type:211,seqno:n.seqno,padding:0,reftime_sec:n.sendtime_sec,reftime_frac:n.sendtime_frac,recvtime_sec:i,recvtime_frac:a,sendtime_sec:i,sendtime_frac:a});this.#t.send(o,t.port,t.address,e=>{e&&this.#e.warn(`Timing server failed to send response to ${t.address}:${t.port}`,e)})}catch(n){this.#e.warn(`Timing server received malformed packet (${e.length} bytes) from ${t.address}:${t.port}`,n)}}};function ne(){return Math.floor(Math.random()*2**32).toString(10)}function re(){return Math.floor(Math.random()*2**64).toString(16).toUpperCase()}function ie(){return Math.floor(Math.random()*2**32).toString(10)}function $(){let e=_();for(let t of Object.values(e))if(t){for(let e of t)if(!(e.internal||e.family!==`IPv4`)&&e.address&&e.address!==`127.0.0.1`)return e.address}return null}function ae(){let e=_();for(let t of Object.values(e))if(t){for(let e of t)if(!(e.internal||e.family!==`IPv4`)&&e.mac&&e.mac!==`00:00:00:00:00:00`)return e.mac.toUpperCase()}return`00:00:00:00:00:00`}function oe(){return e(4).readUInt32BE(0)}function se(){return e(8).readBigUint64LE(0)}function ce(e){let t=Buffer.allocUnsafe(2);return t.writeUInt16BE(e,0),t}function le(e){let[t,n]=ue(e),r=Buffer.allocUnsafe(8);return r.writeUInt32LE(n,0),r.writeUInt32LE(t,4),r}function ue(e){let t=4294967295;if(e<=-1||e>9007199254740991)throw Error(`Number out of range.`);if(Math.floor(e)!==e)throw Error(`Number is not an integer.`);let n=0,r=e&4294967295,i=r<0?(e&2147483647)+2147483648:r;return e>t&&(n=(e-i)/(t+1)),[n,i]}export{A as AIRPLAY_SERVICE,O as AIRPLAY_TRANSIENT_PIN,Z as AccessoryPair,Q as AccessoryVerify,j as COMPANION_LINK_SERVICE,L as Connection,Y as Context,N as Discovery,F as ENCRYPTION,R as EncryptionAwareConnection,z as EncryptionState,k as HTTP_TIMEOUT,M as RAOP_SERVICE,te as TimingServer,ne as generateActiveRemoteId,re as generateDacpId,ie as generateSessionId,$ as getLocalIP,ae as getMacAddress,E as prompt,oe as randomInt32,se as randomInt64,J as reporter,ce as uint16ToBE,le as uint53ToLE,T as uuid,D as waitFor};
+import { createRequire } from "node:module";
+import { randomBytes, randomFillSync, randomUUID } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { Socket, createConnection } from "node:net";
+import { createInterface } from "node:readline";
+import { createSocket } from "node:dgram";
+import { networkInterfaces } from "node:os";
+import { EventEmitter } from "node:events";
+import { NTP, OPack, TLV8 } from "@basmilius/apple-encoding";
+import { Chacha20, Curve25519, Ed25519, hkdf } from "@basmilius/apple-encryption";
+import { SRP, SrpClient } from "fast-srp-hap";
+
+//#region \0rolldown/runtime.js
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+//#region ../../node_modules/.bun/uuid@13.0.0/node_modules/uuid/dist-node/stringify.js
+const byteToHex = [];
+for (let i = 0; i < 256; ++i) byteToHex.push((i + 256).toString(16).slice(1));
+function unsafeStringify(arr, offset = 0) {
+	return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
+}
+
+//#endregion
+//#region ../../node_modules/.bun/uuid@13.0.0/node_modules/uuid/dist-node/rng.js
+const rnds8Pool = new Uint8Array(256);
+let poolPtr = rnds8Pool.length;
+function rng() {
+	if (poolPtr > rnds8Pool.length - 16) {
+		randomFillSync(rnds8Pool);
+		poolPtr = 0;
+	}
+	return rnds8Pool.slice(poolPtr, poolPtr += 16);
+}
+
+//#endregion
+//#region ../../node_modules/.bun/uuid@13.0.0/node_modules/uuid/dist-node/native.js
+var native_default = { randomUUID };
+
+//#endregion
+//#region ../../node_modules/.bun/uuid@13.0.0/node_modules/uuid/dist-node/v4.js
+function _v4(options, buf, offset) {
+	options = options || {};
+	const rnds = options.random ?? options.rng?.() ?? rng();
+	if (rnds.length < 16) throw new Error("Random bytes length must be >= 16");
+	rnds[6] = rnds[6] & 15 | 64;
+	rnds[8] = rnds[8] & 63 | 128;
+	if (buf) {
+		offset = offset || 0;
+		if (offset < 0 || offset + 16 > buf.length) throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+		for (let i = 0; i < 16; ++i) buf[offset + i] = rnds[i];
+		return buf;
+	}
+	return unsafeStringify(rnds);
+}
+function v4(options, buf, offset) {
+	if (native_default.randomUUID && !buf && !options) return native_default.randomUUID();
+	return _v4(options, buf, offset);
+}
+
+//#endregion
+//#region src/airplayFeatures.ts
+const AirPlayFeatureFlags = {
+	SupportsAirPlayVideoV1: 1n << 0n,
+	SupportsAirPlayPhoto: 1n << 1n,
+	SupportsAirPlayVideoFairPlay: 1n << 2n,
+	SupportsAirPlayVideoVolumeControl: 1n << 3n,
+	SupportsAirPlayVideoHTTPLiveStreams: 1n << 4n,
+	SupportsAirPlaySlideShow: 1n << 5n,
+	SupportsAirPlayScreen: 1n << 7n,
+	SupportsAirPlayAudio: 1n << 9n,
+	AudioRedundant: 1n << 11n,
+	Authentication_4: 1n << 14n,
+	MetadataFeatures_0: 1n << 15n,
+	MetadataFeatures_1: 1n << 16n,
+	MetadataFeatures_2: 1n << 17n,
+	AudioFormats_0: 1n << 18n,
+	AudioFormats_1: 1n << 19n,
+	AudioFormats_2: 1n << 20n,
+	AudioFormats_3: 1n << 21n,
+	Authentication_1: 1n << 23n,
+	Authentication_8: 1n << 26n,
+	SupportsLegacyPairing: 1n << 27n,
+	HasUnifiedAdvertiserInfo: 1n << 30n,
+	IsCarPlay: 1n << 32n,
+	SupportsAirPlayVideoPlayQueue: 1n << 33n,
+	SupportsAirPlayFromCloud: 1n << 34n,
+	SupportsTLS_PSK: 1n << 35n,
+	SupportsUnifiedMediaControl: 1n << 38n,
+	SupportsBufferedAudio: 1n << 40n,
+	SupportsPTP: 1n << 41n,
+	SupportsScreenMultiCodec: 1n << 42n,
+	SupportsSystemPairing: 1n << 43n,
+	IsAPValeriaScreenSender: 1n << 44n,
+	SupportsHKPairingAndAccessControl: 1n << 46n,
+	SupportsCoreUtilsPairingAndEncryption: 1n << 48n,
+	SupportsAirPlayVideoV2: 1n << 49n,
+	MetadataFeatures_3: 1n << 50n,
+	SupportsUnifiedPairSetupAndMFi: 1n << 51n,
+	SupportsSetPeersExtendedMessage: 1n << 52n,
+	SupportsAPSync: 1n << 54n,
+	SupportsWoL: 1n << 55n,
+	SupportsWoL2: 1n << 56n,
+	SupportsHangdogRemoteControl: 1n << 58n,
+	SupportsAudioStreamConnectionSetup: 1n << 59n,
+	SupportsAudioMetadataControl: 1n << 60n,
+	SupportsRFC2198Redundancy: 1n << 61n
+};
+const PASSWORD_BIT = 128n;
+const LEGACY_PAIRING_BIT = 512n;
+const PIN_REQUIRED_BIT = 8n;
+const parseFeatures = (features) => {
+	const parts = features.split(",").map((part) => part.trim());
+	if (parts.length === 1) return BigInt(parts[0]);
+	if (parts.length === 2) {
+		const low = BigInt(parts[0]);
+		return BigInt(parts[1]) << 32n | low;
+	}
+	throw new Error(`Invalid features format: ${features}`);
+};
+const hasFeatureFlag = (features, flag) => (features & flag) !== 0n;
+const describeFlags = (features) => {
+	const result = [];
+	for (const [name, flag] of Object.entries(AirPlayFeatureFlags)) if (hasFeatureFlag(features, flag)) result.push(name);
+	return result;
+};
+const getProtocolVersion = (txt) => {
+	const featuresStr = txt.features ?? txt.ft;
+	if (!featuresStr) return 1;
+	const features = parseFeatures(featuresStr);
+	if (hasFeatureFlag(features, AirPlayFeatureFlags.SupportsUnifiedMediaControl)) return 2;
+	if (hasFeatureFlag(features, AirPlayFeatureFlags.SupportsCoreUtilsPairingAndEncryption)) return 2;
+	return 1;
+};
+const getPairingRequirement = (txt) => {
+	const featuresStr = txt.features ?? txt.ft;
+	if (!featuresStr) return "none";
+	const features = parseFeatures(featuresStr);
+	const sf = txt.sf ? BigInt(txt.sf) : 0n;
+	if (hasFeatureFlag(features, AirPlayFeatureFlags.SupportsHKPairingAndAccessControl)) return "homekit";
+	if ((sf & PIN_REQUIRED_BIT) !== 0n) return "pin";
+	if (hasFeatureFlag(features, AirPlayFeatureFlags.SupportsSystemPairing)) return "transient";
+	if ((sf & LEGACY_PAIRING_BIT) !== 0n) return "pin";
+	return "none";
+};
+const isPasswordRequired = (txt) => {
+	if (txt.pw === "true") return true;
+	return ((txt.sf ? BigInt(txt.sf) : 0n) & PASSWORD_BIT) !== 0n;
+};
+const isRemoteControlSupported = (txt) => {
+	const featuresStr = txt.features ?? txt.ft;
+	if (!featuresStr) return false;
+	return hasFeatureFlag(parseFeatures(featuresStr), AirPlayFeatureFlags.SupportsHangdogRemoteControl);
+};
+
+//#endregion
+//#region src/storage.ts
+const credentialKey = (deviceId, protocol) => `${deviceId}:${protocol}`;
+const serializeCredentials = (credentials) => ({
+	accessoryIdentifier: credentials.accessoryIdentifier,
+	accessoryLongTermPublicKey: credentials.accessoryLongTermPublicKey.toString("base64"),
+	pairingId: credentials.pairingId.toString("base64"),
+	publicKey: credentials.publicKey.toString("base64"),
+	secretKey: credentials.secretKey.toString("base64")
+});
+const deserializeCredentials = (stored) => ({
+	accessoryIdentifier: stored.accessoryIdentifier,
+	accessoryLongTermPublicKey: Buffer.from(stored.accessoryLongTermPublicKey, "base64"),
+	pairingId: Buffer.from(stored.pairingId, "base64"),
+	publicKey: Buffer.from(stored.publicKey, "base64"),
+	secretKey: Buffer.from(stored.secretKey, "base64")
+});
+const createEmptyData = () => ({
+	version: 1,
+	devices: {},
+	credentials: {}
+});
+var Storage = class {
+	#data = createEmptyData();
+	get data() {
+		return this.#data;
+	}
+	setData(data) {
+		this.#data = data;
+	}
+	getDevice(identifier) {
+		return this.#data.devices[identifier];
+	}
+	setDevice(identifier, device) {
+		this.#data.devices[identifier] = device;
+	}
+	removeDevice(identifier) {
+		delete this.#data.devices[identifier];
+		for (const key of Object.keys(this.#data.credentials)) if (key.startsWith(`${identifier}:`)) delete this.#data.credentials[key];
+	}
+	listDevices() {
+		return Object.values(this.#data.devices);
+	}
+	getCredentials(deviceId, protocol) {
+		const stored = this.#data.credentials[credentialKey(deviceId, protocol)];
+		if (!stored) return;
+		return deserializeCredentials(stored);
+	}
+	setCredentials(deviceId, protocol, credentials) {
+		this.#data.credentials[credentialKey(deviceId, protocol)] = serializeCredentials(credentials);
+	}
+	removeCredentials(deviceId, protocol) {
+		delete this.#data.credentials[credentialKey(deviceId, protocol)];
+	}
+};
+var JsonStorage = class extends Storage {
+	#path;
+	constructor(path) {
+		super();
+		this.#path = path ?? join(process.env.HOME ?? process.env.USERPROFILE ?? ".", ".config", "apple-protocols", "storage.json");
+	}
+	async load() {
+		if (!existsSync(this.#path)) return;
+		const raw = readFileSync(this.#path, "utf-8");
+		const json = JSON.parse(raw);
+		if (json.version === 1) this.setData(json);
+	}
+	async save() {
+		mkdirSync(dirname(this.#path), { recursive: true });
+		writeFileSync(this.#path, JSON.stringify(this.data, null, 2), "utf-8");
+	}
+};
+var MemoryStorage = class extends Storage {
+	async load() {}
+	async save() {}
+};
+
+//#endregion
+//#region src/cli.ts
+async function prompt(message) {
+	const cli = createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+	const answer = await new Promise((resolve) => cli.question(`${message}: `, resolve));
+	cli.close();
+	return answer;
+}
+async function waitFor(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+//#endregion
+//#region src/const.ts
+const AIRPLAY_TRANSIENT_PIN = "3939";
+const HTTP_TIMEOUT = 6e3;
+const SOCKET_TIMEOUT = 1e4;
+const AIRPLAY_SERVICE = "_airplay._tcp.local";
+const COMPANION_LINK_SERVICE = "_companion-link._tcp.local";
+const RAOP_SERVICE = "_raop._tcp.local";
+
+//#endregion
+//#region src/mdns.ts
+const MDNS_ADDRESS = "224.0.0.251";
+const MDNS_PORT = 5353;
+const QUERY_ID = 13823;
+const SERVICES_PER_MSG = 3;
+const QueryType = {
+	A: 1,
+	PTR: 12,
+	TXT: 16,
+	AAAA: 28,
+	SRV: 33,
+	ANY: 255
+};
+const encodeQName = (name) => {
+	const parts = [];
+	const labels = splitServiceName(name);
+	for (const label of labels) {
+		const encoded = Buffer.from(label, "utf-8");
+		if (encoded.byteLength > 63) parts.push(Buffer.from([63]), encoded.subarray(0, 63));
+		else parts.push(Buffer.from([encoded.byteLength]), encoded);
+	}
+	parts.push(Buffer.from([0]));
+	return Buffer.concat(parts);
+};
+const splitServiceName = (name) => {
+	const match = name.match(/\._[a-z]+\._(?:tcp|udp)\.local$/);
+	if (match) return [name.substring(0, match.index), ...match[0].substring(1).split(".")];
+	return name.split(".");
+};
+const encodeDnsHeader = (header) => {
+	const buf = Buffer.allocUnsafe(12);
+	buf.writeUInt16BE(header.id, 0);
+	buf.writeUInt16BE(header.flags, 2);
+	buf.writeUInt16BE(header.qdcount, 4);
+	buf.writeUInt16BE(header.ancount, 6);
+	buf.writeUInt16BE(header.nscount, 8);
+	buf.writeUInt16BE(header.arcount, 10);
+	return buf;
+};
+const encodeDnsQuestion = (name, qtype, unicastResponse = false) => {
+	const qname = encodeQName(name);
+	const suffix = Buffer.allocUnsafe(4);
+	suffix.writeUInt16BE(qtype, 0);
+	suffix.writeUInt16BE(unicastResponse ? 32769 : 1, 2);
+	return Buffer.concat([qname, suffix]);
+};
+const createQueryPackets = (services, qtype = QueryType.PTR, unicastResponse = false) => {
+	const packets = [];
+	for (let i = 0; i < services.length; i += SERVICES_PER_MSG) {
+		const chunk = services.slice(i, i + SERVICES_PER_MSG);
+		const questions = chunk.map((s) => encodeDnsQuestion(s, qtype, unicastResponse));
+		const header = encodeDnsHeader({
+			id: QUERY_ID,
+			flags: 0,
+			qdcount: chunk.length,
+			ancount: 0,
+			nscount: 0,
+			arcount: 0
+		});
+		packets.push(Buffer.concat([header, ...questions]));
+	}
+	return packets;
+};
+const decodeQName = (buf, offset) => {
+	const labels = [];
+	let currentOffset = offset;
+	let jumped = false;
+	let returnOffset = offset;
+	while (currentOffset < buf.byteLength) {
+		const length = buf[currentOffset];
+		if (length === 0) {
+			if (!jumped) returnOffset = currentOffset + 1;
+			break;
+		}
+		if ((length & 192) === 192) {
+			const pointer = (length & 63) << 8 | buf[currentOffset + 1];
+			if (!jumped) returnOffset = currentOffset + 2;
+			currentOffset = pointer;
+			jumped = true;
+			continue;
+		}
+		currentOffset++;
+		labels.push(buf.toString("utf-8", currentOffset, currentOffset + length));
+		currentOffset += length;
+		if (!jumped) returnOffset = currentOffset;
+	}
+	return [labels.join("."), returnOffset];
+};
+const decodeDnsHeader = (buf) => ({
+	id: buf.readUInt16BE(0),
+	flags: buf.readUInt16BE(2),
+	qdcount: buf.readUInt16BE(4),
+	ancount: buf.readUInt16BE(6),
+	nscount: buf.readUInt16BE(8),
+	arcount: buf.readUInt16BE(10)
+});
+const decodeQuestion = (buf, offset) => {
+	const [qname, newOffset] = decodeQName(buf, offset);
+	return [{
+		qname,
+		qtype: buf.readUInt16BE(newOffset),
+		qclass: buf.readUInt16BE(newOffset + 2)
+	}, newOffset + 4];
+};
+const decodeTxtRecord = (buf, offset, length) => {
+	const properties = {};
+	let pos = offset;
+	const end = offset + length;
+	while (pos < end) {
+		const strLen = buf[pos];
+		pos++;
+		if (strLen === 0 || pos + strLen > end) break;
+		const str = buf.toString("utf-8", pos, pos + strLen);
+		pos += strLen;
+		const eqIndex = str.indexOf("=");
+		if (eqIndex >= 0) properties[str.substring(0, eqIndex)] = str.substring(eqIndex + 1);
+		else properties[str] = "";
+	}
+	return properties;
+};
+const decodeSrvRecord = (buf, offset) => {
+	const priority = buf.readUInt16BE(offset);
+	const weight = buf.readUInt16BE(offset + 2);
+	const port = buf.readUInt16BE(offset + 4);
+	const [target] = decodeQName(buf, offset + 6);
+	return {
+		priority,
+		weight,
+		port,
+		target
+	};
+};
+const decodeResource = (buf, offset) => {
+	const [qname, nameEnd] = decodeQName(buf, offset);
+	const qtype = buf.readUInt16BE(nameEnd);
+	const qclass = buf.readUInt16BE(nameEnd + 2);
+	const ttl = buf.readUInt32BE(nameEnd + 4);
+	const rdLength = buf.readUInt16BE(nameEnd + 8);
+	const rdOffset = nameEnd + 10;
+	let rdata;
+	switch (qtype) {
+		case QueryType.A:
+			rdata = `${buf[rdOffset]}.${buf[rdOffset + 1]}.${buf[rdOffset + 2]}.${buf[rdOffset + 3]}`;
+			break;
+		case QueryType.AAAA: {
+			const parts = [];
+			for (let i = 0; i < 8; i++) parts.push(buf.readUInt16BE(rdOffset + i * 2).toString(16));
+			rdata = parts.join(":");
+			break;
+		}
+		case QueryType.PTR: {
+			const [name] = decodeQName(buf, rdOffset);
+			rdata = name;
+			break;
+		}
+		case QueryType.SRV:
+			rdata = decodeSrvRecord(buf, rdOffset);
+			break;
+		case QueryType.TXT:
+			rdata = decodeTxtRecord(buf, rdOffset, rdLength);
+			break;
+		default: rdata = buf.subarray(rdOffset, rdOffset + rdLength);
+	}
+	return [{
+		qname,
+		qtype,
+		qclass,
+		ttl,
+		rdata
+	}, rdOffset + rdLength];
+};
+const decodeDnsResponse = (buf) => {
+	const header = decodeDnsHeader(buf);
+	let offset = 12;
+	for (let i = 0; i < header.qdcount; i++) {
+		const [, newOffset] = decodeQuestion(buf, offset);
+		offset = newOffset;
+	}
+	const answers = [];
+	for (let i = 0; i < header.ancount; i++) {
+		const [record, newOffset] = decodeResource(buf, offset);
+		answers.push(record);
+		offset = newOffset;
+	}
+	for (let i = 0; i < header.nscount; i++) {
+		const [, newOffset] = decodeResource(buf, offset);
+		offset = newOffset;
+	}
+	const resources = [];
+	for (let i = 0; i < header.arcount; i++) {
+		const [record, newOffset] = decodeResource(buf, offset);
+		resources.push(record);
+		offset = newOffset;
+	}
+	return {
+		header,
+		answers,
+		resources
+	};
+};
+var ServiceCollector = class {
+	#ptrMap = /* @__PURE__ */ new Map();
+	#srvMap = /* @__PURE__ */ new Map();
+	#txtMap = /* @__PURE__ */ new Map();
+	#addressMap = /* @__PURE__ */ new Map();
+	addRecords(answers, resources) {
+		for (const record of [...answers, ...resources]) switch (record.qtype) {
+			case QueryType.PTR: {
+				const existing = this.#ptrMap.get(record.qname);
+				if (existing) existing.add(record.rdata);
+				else this.#ptrMap.set(record.qname, new Set([record.rdata]));
+				break;
+			}
+			case QueryType.SRV:
+				this.#srvMap.set(record.qname, record.rdata);
+				break;
+			case QueryType.TXT:
+				this.#txtMap.set(record.qname, record.rdata);
+				break;
+			case QueryType.A:
+				this.#addressMap.set(record.qname, record.rdata);
+				break;
+		}
+	}
+	get services() {
+		const results = [];
+		for (const [serviceType, instanceNames] of this.#ptrMap) for (const instanceQName of instanceNames) {
+			const srv = this.#srvMap.get(instanceQName);
+			if (!srv || srv.port === 0) continue;
+			const address = this.#addressMap.get(srv.target);
+			if (!address) continue;
+			const txt = this.#txtMap.get(instanceQName) ?? {};
+			const typeIndex = instanceQName.indexOf("._");
+			const name = typeIndex >= 0 ? instanceQName.substring(0, typeIndex) : instanceQName;
+			if (!results.some((s) => s.name === name && s.type === serviceType)) results.push({
+				name,
+				type: serviceType,
+				address,
+				port: srv.port,
+				properties: txt
+			});
+		}
+		return results;
+	}
+};
+const WAKE_PORTS$1 = [
+	7e3,
+	3689,
+	49152,
+	32498
+];
+const knock = (address) => {
+	const promises = WAKE_PORTS$1.map((port) => new Promise((resolve) => {
+		const socket = createConnection({
+			host: address,
+			port,
+			timeout: 500
+		});
+		socket.on("connect", () => {
+			socket.destroy();
+			resolve();
+		});
+		socket.on("error", () => {
+			socket.destroy();
+			resolve();
+		});
+		socket.on("timeout", () => {
+			socket.destroy();
+			resolve();
+		});
+	}));
+	return Promise.all(promises).then(() => {});
+};
+const unicast = (hosts, services, timeout = 4) => {
+	return new Promise((resolve) => {
+		const queries = createQueryPackets(services);
+		const collector = new ServiceCollector();
+		const sockets = [];
+		let resolved = false;
+		const finish = () => {
+			if (resolved) return;
+			resolved = true;
+			clearInterval(interval);
+			for (const socket of sockets) try {
+				socket.close();
+			} catch {}
+			resolve(collector.services);
+		};
+		for (const host of hosts) {
+			const socket = createSocket("udp4");
+			sockets.push(socket);
+			socket.on("message", (data) => {
+				try {
+					const response = decodeDnsResponse(data);
+					collector.addRecords(response.answers, response.resources);
+				} catch {}
+			});
+			socket.on("error", () => {});
+		}
+		let interval;
+		Promise.all(hosts.map((h) => knock(h))).then(() => {
+			const sendQueries = () => {
+				for (let i = 0; i < hosts.length; i++) for (const query of queries) sockets[i]?.send(query, MDNS_PORT, hosts[i]);
+			};
+			sendQueries();
+			interval = setInterval(sendQueries, 1e3);
+			setTimeout(finish, timeout * 1e3);
+		});
+	});
+};
+const multicast = (services, timeout = 4) => {
+	return new Promise((resolve) => {
+		const collector = new ServiceCollector();
+		const queries = createQueryPackets(services);
+		const sockets = [];
+		let resolved = false;
+		let interval;
+		const finish = () => {
+			if (resolved) return;
+			resolved = true;
+			clearInterval(interval);
+			for (const socket of sockets) try {
+				socket.close();
+			} catch {}
+			resolve(collector.services);
+		};
+		const onMessage = (data) => {
+			try {
+				const response = decodeDnsResponse(data);
+				collector.addRecords(response.answers, response.resources);
+			} catch {}
+		};
+		const addSocket = (address, port) => {
+			return new Promise((resolveSocket) => {
+				const socket = createSocket({
+					type: "udp4",
+					reuseAddr: true
+				});
+				socket.on("message", onMessage);
+				socket.on("error", () => {
+					resolveSocket(null);
+				});
+				socket.bind(port, address ?? "", () => {
+					if (address) try {
+						socket.setMulticastInterface(address);
+						socket.addMembership(MDNS_ADDRESS, address);
+					} catch {}
+					else try {
+						socket.addMembership(MDNS_ADDRESS);
+					} catch {}
+					sockets.push(socket);
+					resolveSocket(socket);
+				});
+			});
+		};
+		const getPrivateAddresses = () => {
+			try {
+				const { networkInterfaces } = __require("node:os");
+				const interfaces = networkInterfaces();
+				const addresses = [];
+				for (const nets of Object.values(interfaces)) for (const net of nets) if (net.family === "IPv4" && net.internal === false) addresses.push(net.address);
+				return addresses;
+			} catch {
+				return [];
+			}
+		};
+		const setup = async () => {
+			await addSocket(null, MDNS_PORT);
+			for (const address of getPrivateAddresses()) await addSocket(address, 0);
+			if (sockets.length === 0) {
+				resolve([]);
+				return;
+			}
+			const sendQueries = () => {
+				for (const socket of sockets) for (const query of queries) try {
+					socket.send(query, MDNS_PORT, MDNS_ADDRESS);
+				} catch {}
+			};
+			sendQueries();
+			interval = setInterval(sendQueries, 1e3);
+			setTimeout(finish, timeout * 1e3);
+		};
+		setup();
+	});
+};
+
+//#endregion
+//#region src/discovery.ts
+const CACHE_TTL = 3e4;
+const WAKE_PORTS = [
+	7e3,
+	3689,
+	49152,
+	32498
+];
+const toDiscoveryResult = (service) => {
+	const txt = service.properties;
+	const featuresStr = txt.features ?? txt.ft;
+	const model = txt.model ?? txt.am ?? "";
+	const protocol = service.type.includes("._tcp") ? "tcp" : "udp";
+	const hostname = service.name.replace(/\s+/g, "-");
+	return {
+		id: `${hostname}.local`,
+		fqdn: `${hostname}.local`,
+		address: service.address,
+		modelName: model,
+		familyName: null,
+		txt,
+		features: featuresStr ? tryParseFeatures(featuresStr) : void 0,
+		service: {
+			port: service.port,
+			protocol,
+			type: service.type
+		},
+		packet: null
+	};
+};
+const tryParseFeatures = (features) => {
+	try {
+		return parseFeatures(features);
+	} catch {
+		return;
+	}
+};
+var Discovery = class Discovery {
+	static #cache = /* @__PURE__ */ new Map();
+	#service;
+	constructor(service) {
+		this.#service = service;
+	}
+	async find(useCache = true) {
+		if (useCache) {
+			const cached = Discovery.#cache.get(this.#service);
+			if (cached && cached.expiresAt > Date.now()) return cached.results;
+		}
+		const mapped = (await multicast([this.#service], 4)).map(toDiscoveryResult);
+		Discovery.#cache.set(this.#service, {
+			results: mapped,
+			expiresAt: Date.now() + CACHE_TTL
+		});
+		return mapped;
+	}
+	async findUntil(id, tries = 10, timeout = 1e3) {
+		while (tries > 0) {
+			const devices = await this.find(false);
+			const device = devices.find((device) => device.id === id);
+			if (device) return device;
+			console.log();
+			console.log(`Device not found, retrying in ${timeout}ms...`);
+			console.log(devices.map((d) => ` ● ${d.id} (${d.fqdn})`).join("\n"));
+			tries--;
+			await waitFor(timeout);
+		}
+		throw new Error("Device not found after several tries, aborting.");
+	}
+	static clearCache() {
+		Discovery.#cache.clear();
+	}
+	static async wake(address) {
+		const promises = WAKE_PORTS.map((port) => new Promise((resolve) => {
+			const socket = createConnection({
+				host: address,
+				port,
+				timeout: 500
+			});
+			socket.on("connect", () => {
+				socket.destroy();
+				resolve();
+			});
+			socket.on("error", () => {
+				socket.destroy();
+				resolve();
+			});
+			socket.on("timeout", () => {
+				socket.destroy();
+				resolve();
+			});
+		}));
+		await Promise.all(promises);
+	}
+	static async discoverAll() {
+		const allServices = await multicast([
+			AIRPLAY_SERVICE,
+			COMPANION_LINK_SERVICE,
+			RAOP_SERVICE
+		], 4);
+		const devices = /* @__PURE__ */ new Map();
+		for (const service of allServices) {
+			const result = toDiscoveryResult(service);
+			const existing = devices.get(result.id);
+			if (existing) {
+				if (service.type === AIRPLAY_SERVICE) existing.airplay = result;
+				else if (service.type === COMPANION_LINK_SERVICE) existing.companionLink = result;
+				else if (service.type === RAOP_SERVICE) existing.raop = result;
+			} else devices.set(result.id, {
+				id: result.id,
+				name: result.fqdn,
+				address: result.address,
+				airplay: service.type === AIRPLAY_SERVICE ? result : void 0,
+				companionLink: service.type === COMPANION_LINK_SERVICE ? result : void 0,
+				raop: service.type === RAOP_SERVICE ? result : void 0
+			});
+		}
+		return [...devices.values()];
+	}
+	static airplay() {
+		return new Discovery(AIRPLAY_SERVICE);
+	}
+	static companionLink() {
+		return new Discovery(COMPANION_LINK_SERVICE);
+	}
+	static raop() {
+		return new Discovery(RAOP_SERVICE);
+	}
+};
+
+//#endregion
+//#region src/symbols.ts
+const ENCRYPTION = Symbol();
+
+//#endregion
+//#region src/connection.ts
+const NOOP_PROMISE_HANDLER = {
+	resolve: () => {},
+	reject: (_) => {}
+};
+var Connection = class extends EventEmitter {
+	get address() {
+		return this.#address;
+	}
+	get context() {
+		return this.#context;
+	}
+	get port() {
+		return this.#port;
+	}
+	get isConnected() {
+		return this.#state === "connected";
+	}
+	get state() {
+		if (this.#state === "closing" || this.#state === "failed") return this.#state;
+		if (!this.#socket) return "disconnected";
+		switch (this.#socket.readyState) {
+			case "opening": return "connecting";
+			case "open": return "connected";
+			default: return this.#state;
+		}
+	}
+	#address;
+	#port;
+	#context;
+	#debug = false;
+	#retryAttempt = 0;
+	#retryAttempts = 3;
+	#retryEnabled = true;
+	#retryInterval = 3e3;
+	#retryTimeout;
+	#socket;
+	#state;
+	#connectPromise;
+	constructor(context, address, port) {
+		super();
+		this.#address = address;
+		this.#port = port;
+		this.#context = context;
+		this.#state = "disconnected";
+	}
+	async connect() {
+		if (this.#state === "connected") return;
+		if (this.#state === "connecting") throw new Error("A connection is already being established.");
+		this.#retryEnabled = true;
+		this.#retryAttempt = 0;
+		return this.#attemptConnect();
+	}
+	destroy() {
+		this.#socket?.destroy();
+	}
+	async disconnect() {
+		if (this.#retryTimeout) {
+			clearTimeout(this.#retryTimeout);
+			this.#retryTimeout = void 0;
+		}
+		this.#retryEnabled = false;
+		if (!this.#socket || this.#state === "disconnected") return;
+		return new Promise((resolve) => {
+			this.#state = "closing";
+			this.#socket.once("close", () => {
+				this.#cleanup();
+				resolve();
+			});
+			this.#socket.end();
+		});
+	}
+	debug(enabled) {
+		this.#debug = enabled;
+		return this;
+	}
+	retry(attempts, interval = 3e3) {
+		this.#retryAttempts = attempts;
+		this.#retryInterval = interval;
+		return this;
+	}
+	write(data) {
+		if (!this.#socket || this.state !== "connected" || !this.#socket.writable) {
+			this.emit("error", /* @__PURE__ */ new Error("Cannot write to a disconnected connection."));
+			return;
+		}
+		this.#socket.write(data, (err) => {
+			if (!err) return;
+			this.#context.logger.error("Failed to write data to socket.");
+			this.emit("error", err);
+		});
+	}
+	async #attemptConnect() {
+		return new Promise((resolve, reject) => {
+			this.#state = "connecting";
+			this.#connectPromise = {
+				resolve,
+				reject
+			};
+			this.#socket?.removeAllListeners();
+			this.#socket = void 0;
+			this.#socket = new Socket();
+			this.#socket.setNoDelay(true);
+			this.#socket.setTimeout(SOCKET_TIMEOUT);
+			this.#socket.on("close", this.#onClose.bind(this));
+			this.#socket.on("connect", this.#onConnect.bind(this));
+			this.#socket.on("data", this.#onData.bind(this));
+			this.#socket.on("end", this.#onEnd.bind(this));
+			this.#socket.on("error", this.#onError.bind(this));
+			this.#socket.on("timeout", this.#onTimeout.bind(this));
+			this.#context.logger.net(`Connecting to ${this.#address}:${this.#port}...`);
+			this.#socket.connect({
+				host: this.#address,
+				port: this.#port,
+				keepAlive: true
+			});
+		});
+	}
+	#cleanup() {
+		if (this.#retryTimeout) {
+			clearTimeout(this.#retryTimeout);
+			this.#retryTimeout = void 0;
+		}
+		if (this.#socket) {
+			this.#socket.removeAllListeners();
+			this.#socket.destroy();
+			this.#socket = void 0;
+		}
+		this.#state = "disconnected";
+		this.#connectPromise = void 0;
+	}
+	#scheduleRetry(err) {
+		if (!this.#retryEnabled || this.#retryAttempt >= this.#retryAttempts) {
+			this.#state = "failed";
+			this.#connectPromise?.reject(err);
+			this.#connectPromise = void 0;
+			return;
+		}
+		if (this.#retryTimeout) {
+			clearTimeout(this.#retryTimeout);
+			this.#retryTimeout = void 0;
+		}
+		this.#retryAttempt++;
+		this.#context.logger.net(`Retry attempt ${this.#retryAttempt} / ${this.#retryAttempts} in ${this.#retryInterval}ms...`);
+		const { resolve, reject } = this.#connectPromise ?? NOOP_PROMISE_HANDLER;
+		this.#cleanup();
+		this.#retryTimeout = setTimeout(async () => {
+			this.#retryTimeout = void 0;
+			try {
+				this.#connectPromise = {
+					resolve,
+					reject
+				};
+				await this.#attemptConnect();
+				resolve();
+			} catch (retryErr) {}
+		}, this.#retryInterval);
+	}
+	#onClose(hadError) {
+		const wasConnected = this.#state === "connected";
+		if (this.#state !== "closing") {
+			this.#state = "disconnected";
+			this.#context.logger.net(`Connection closed (${hadError ? "with error" : "normally"}).`);
+		}
+		this.emit("close", hadError);
+		if (wasConnected && this.#retryEnabled && hadError) this.#scheduleRetry(/* @__PURE__ */ new Error("Connection closed unexpectedly."));
+	}
+	#onConnect() {
+		this.#state = "connected";
+		this.#retryAttempt = 0;
+		this.#socket.setKeepAlive(true, 1e4);
+		this.#socket.setTimeout(0);
+		this.emit("connect");
+		this.#connectPromise?.resolve();
+		this.#connectPromise = void 0;
+	}
+	#onData(data) {
+		if (this.#debug) {
+			const cutoff = Math.min(data.byteLength, 64);
+			this.#context.logger.debug(`Received ${data.byteLength} bytes of data.`);
+			this.#context.logger.debug(`hex=${data.subarray(0, cutoff).toString("hex")}`);
+			this.#context.logger.debug(`ascii=${data.toString("ascii").replace(/[^\x20-\x7E]/g, ".").substring(0, cutoff)}`);
+		}
+		this.emit("data", data);
+	}
+	#onEnd() {
+		this.emit("end");
+	}
+	#onError(err) {
+		this.#context.logger.error(`Connection error: ${err.message}`);
+		if (this.listenerCount("error") > 0) this.emit("error", err);
+		else this.#context.logger.warn("No error handler registered. This is likely a bug.", this.constructor.name, "#onError");
+		if (this.#state === "connecting") this.#scheduleRetry(err);
+		else this.#state = "failed";
+	}
+	#onTimeout() {
+		this.#context.logger.error("Connection timed out.");
+		const err = /* @__PURE__ */ new Error("Connection timed out.");
+		this.emit("timeout");
+		if (this.#state === "connecting") this.#scheduleRetry(err);
+		else {
+			this.#state = "failed";
+			this.#socket?.destroy();
+		}
+	}
+};
+var EncryptionAwareConnection = class extends Connection {
+	get isEncrypted() {
+		return !!this[ENCRYPTION];
+	}
+	[ENCRYPTION];
+	enableEncryption(readKey, writeKey) {
+		this[ENCRYPTION] = new EncryptionState(readKey, writeKey);
+	}
+};
+var EncryptionState = class {
+	readKey;
+	readCount;
+	writeKey;
+	writeCount;
+	constructor(readKey, writeKey) {
+		this.readCount = 0;
+		this.readKey = readKey;
+		this.writeCount = 0;
+		this.writeKey = writeKey;
+	}
+};
+
+//#endregion
+//#region src/reporter.ts
+var Logger = class {
+	get id() {
+		return this.#id;
+	}
+	get label() {
+		return this.#label;
+	}
+	#id;
+	#label;
+	constructor(id) {
+		this.#id = id;
+		this.#label = `\u001b[36m[${id}]\u001b[39m`;
+	}
+	debug(...data) {
+		debug(this.#label, ...data);
+	}
+	error(...data) {
+		error(this.#label, ...data);
+	}
+	info(...data) {
+		info(this.#label, ...data);
+	}
+	net(...data) {
+		net(this.#label, ...data);
+	}
+	raw(...data) {
+		raw(this.#label, ...data);
+	}
+	warn(...data) {
+		warn(this.#label, ...data);
+	}
+};
+var Reporter = class {
+	#enabled = [];
+	all() {
+		this.#enabled = [
+			"debug",
+			"error",
+			"info",
+			"net",
+			"raw",
+			"warn"
+		];
+	}
+	disable(group) {
+		if (this.#enabled.includes(group)) this.#enabled.splice(this.#enabled.indexOf(group), 1);
+	}
+	enable(group) {
+		if (!this.#enabled.includes(group)) this.#enabled.push(group);
+	}
+	isEnabled(group) {
+		return this.#enabled.includes(group);
+	}
+};
+function debug(...data) {
+	reporter.isEnabled("debug") && console.debug(`\u001b[36m[debug]\u001b[39m`, ...data);
+}
+function error(...data) {
+	reporter.isEnabled("error") && console.error(`\u001b[31m[error]\u001b[39m`, ...data);
+}
+function info(...data) {
+	reporter.isEnabled("info") && console.info(`\u001b[32m[info]\u001b[39m`, ...data);
+}
+function net(...data) {
+	reporter.isEnabled("net") && console.info(`\u001b[33m[net]\u001b[39m`, ...data);
+}
+function raw(...data) {
+	reporter.isEnabled("raw") && console.log(`\u001b[34m[raw]\u001b[39m`, ...data);
+}
+function warn(...data) {
+	reporter.isEnabled("warn") && console.warn(`\u001b[33m[warn]\u001b[39m`, ...data);
+}
+const reporter = new Reporter();
+
+//#endregion
+//#region src/context.ts
+var Context = class {
+	get deviceId() {
+		return this.#deviceId;
+	}
+	get logger() {
+		return this.#logger;
+	}
+	#deviceId;
+	#logger;
+	constructor(deviceId) {
+		this.#deviceId = deviceId;
+		this.#logger = new Logger(deviceId);
+	}
+};
+
+//#endregion
+//#region src/pairing.ts
+var BasePairing = class {
+	get context() {
+		return this.#context;
+	}
+	#context;
+	constructor(context) {
+		this.#context = context;
+	}
+	tlv(buffer) {
+		const data = TLV8.decode(buffer);
+		if (data.has(TLV8.Value.Error)) TLV8.bail(data);
+		this.#context.logger.raw("Decoded TLV", data);
+		return data;
+	}
+};
+var AccessoryPair = class extends BasePairing {
+	#name;
+	#pairingId;
+	#requestHandler;
+	#publicKey;
+	#secretKey;
+	#srp;
+	constructor(context, requestHandler) {
+		super(context);
+		this.#name = "basmilius/apple-protocols";
+		this.#pairingId = Buffer.from(v4().toUpperCase());
+		this.#requestHandler = requestHandler;
+	}
+	async start() {
+		const keyPair = Ed25519.generateKeyPair();
+		this.#publicKey = Buffer.from(keyPair.publicKey);
+		this.#secretKey = Buffer.from(keyPair.secretKey);
+	}
+	async pin(askPin) {
+		const m1 = await this.m1();
+		const m2 = await this.m2(m1, await askPin());
+		const m3 = await this.m3(m2);
+		const m4 = await this.m4(m3);
+		const m5 = await this.m5(m4);
+		const m6 = await this.m6(m4, m5);
+		if (!m6) throw new Error("Pairing failed, could not get accessory keys.");
+		return m6;
+	}
+	async transient() {
+		const m1 = await this.m1([[TLV8.Value.Flags, TLV8.Flags.TransientPairing]]);
+		const m2 = await this.m2(m1);
+		const m3 = await this.m3(m2);
+		const m4 = await this.m4(m3);
+		const accessoryToControllerKey = hkdf({
+			hash: "sha512",
+			key: m4.sharedSecret,
+			length: 32,
+			salt: Buffer.from("Control-Salt"),
+			info: Buffer.from("Control-Read-Encryption-Key")
+		});
+		const controllerToAccessoryKey = hkdf({
+			hash: "sha512",
+			key: m4.sharedSecret,
+			length: 32,
+			salt: Buffer.from("Control-Salt"),
+			info: Buffer.from("Control-Write-Encryption-Key")
+		});
+		return {
+			pairingId: this.#pairingId,
+			sharedSecret: m4.sharedSecret,
+			accessoryToControllerKey,
+			controllerToAccessoryKey
+		};
+	}
+	async m1(additionalTlv = []) {
+		const response = await this.#requestHandler("m1", TLV8.encode([
+			[TLV8.Value.Method, TLV8.Method.PairSetup],
+			[TLV8.Value.State, TLV8.State.M1],
+			...additionalTlv
+		]));
+		const data = this.tlv(response);
+		return {
+			publicKey: data.get(TLV8.Value.PublicKey),
+			salt: data.get(TLV8.Value.Salt)
+		};
+	}
+	async m2(m1, pin = AIRPLAY_TRANSIENT_PIN) {
+		const srpKey = await SRP.genKey(32);
+		this.#srp = new SrpClient(SRP.params.hap, m1.salt, Buffer.from("Pair-Setup"), Buffer.from(pin), srpKey, true);
+		this.#srp.setB(m1.publicKey);
+		return {
+			publicKey: this.#srp.computeA(),
+			proof: this.#srp.computeM1()
+		};
+	}
+	async m3(m2) {
+		const response = await this.#requestHandler("m3", TLV8.encode([
+			[TLV8.Value.State, TLV8.State.M3],
+			[TLV8.Value.PublicKey, m2.publicKey],
+			[TLV8.Value.Proof, m2.proof]
+		]));
+		return { serverProof: this.tlv(response).get(TLV8.Value.Proof) };
+	}
+	async m4(m3) {
+		this.#srp.checkM2(m3.serverProof);
+		return { sharedSecret: this.#srp.computeK() };
+	}
+	async m5(m4) {
+		const iosDeviceX = hkdf({
+			hash: "sha512",
+			key: m4.sharedSecret,
+			length: 32,
+			salt: Buffer.from("Pair-Setup-Controller-Sign-Salt", "utf8"),
+			info: Buffer.from("Pair-Setup-Controller-Sign-Info", "utf8")
+		});
+		const sessionKey = hkdf({
+			hash: "sha512",
+			key: m4.sharedSecret,
+			length: 32,
+			salt: Buffer.from("Pair-Setup-Encrypt-Salt", "utf8"),
+			info: Buffer.from("Pair-Setup-Encrypt-Info", "utf8")
+		});
+		const deviceInfo = Buffer.concat([
+			iosDeviceX,
+			this.#pairingId,
+			this.#publicKey
+		]);
+		const signature = Ed25519.sign(deviceInfo, this.#secretKey);
+		const innerTlv = TLV8.encode([
+			[TLV8.Value.Identifier, this.#pairingId],
+			[TLV8.Value.PublicKey, this.#publicKey],
+			[TLV8.Value.Signature, Buffer.from(signature)],
+			[TLV8.Value.Name, OPack.encode({ name: this.#name })]
+		]);
+		const { authTag, ciphertext } = Chacha20.encrypt(sessionKey, Buffer.from("PS-Msg05"), null, innerTlv);
+		const encrypted = Buffer.concat([ciphertext, authTag]);
+		const response = await this.#requestHandler("m5", TLV8.encode([[TLV8.Value.State, TLV8.State.M5], [TLV8.Value.EncryptedData, encrypted]]));
+		const encryptedDataRaw = this.tlv(response).get(TLV8.Value.EncryptedData);
+		const encryptedData = encryptedDataRaw.subarray(0, -16);
+		return {
+			authTag: encryptedDataRaw.subarray(-16),
+			data: encryptedData,
+			sessionKey
+		};
+	}
+	async m6(m4, m5) {
+		const data = Chacha20.decrypt(m5.sessionKey, Buffer.from("PS-Msg06"), null, m5.data, m5.authTag);
+		const tlv = TLV8.decode(data);
+		const accessoryIdentifier = tlv.get(TLV8.Value.Identifier);
+		const accessoryLongTermPublicKey = tlv.get(TLV8.Value.PublicKey);
+		const accessorySignature = tlv.get(TLV8.Value.Signature);
+		const accessoryX = hkdf({
+			hash: "sha512",
+			key: m4.sharedSecret,
+			length: 32,
+			salt: Buffer.from("Pair-Setup-Accessory-Sign-Salt"),
+			info: Buffer.from("Pair-Setup-Accessory-Sign-Info")
+		});
+		const accessoryInfo = Buffer.concat([
+			accessoryX,
+			accessoryIdentifier,
+			accessoryLongTermPublicKey
+		]);
+		if (!Ed25519.verify(accessoryInfo, accessorySignature, accessoryLongTermPublicKey)) throw new Error("Invalid accessory signature.");
+		return {
+			accessoryIdentifier: accessoryIdentifier.toString(),
+			accessoryLongTermPublicKey,
+			pairingId: this.#pairingId,
+			publicKey: this.#publicKey,
+			secretKey: this.#secretKey
+		};
+	}
+};
+var AccessoryVerify = class extends BasePairing {
+	#ephemeralKeyPair;
+	#requestHandler;
+	constructor(context, requestHandler) {
+		super(context);
+		this.#ephemeralKeyPair = Curve25519.generateKeyPair();
+		this.#requestHandler = requestHandler;
+	}
+	async start(credentials) {
+		const m1 = await this.#m1();
+		const m2 = await this.#m2(credentials.accessoryIdentifier, credentials.accessoryLongTermPublicKey, m1);
+		await this.#m3(credentials.pairingId, credentials.secretKey, m2);
+		return await this.#m4(m2, credentials.pairingId);
+	}
+	async #m1() {
+		const response = await this.#requestHandler("m1", TLV8.encode([[TLV8.Value.State, TLV8.State.M1], [TLV8.Value.PublicKey, Buffer.from(this.#ephemeralKeyPair.publicKey)]]));
+		const data = this.tlv(response);
+		const serverPublicKey = data.get(TLV8.Value.PublicKey);
+		return {
+			encryptedData: data.get(TLV8.Value.EncryptedData),
+			serverPublicKey
+		};
+	}
+	async #m2(localAccessoryIdentifier, longTermPublicKey, m1) {
+		const sharedSecret = Buffer.from(Curve25519.generateSharedSecKey(this.#ephemeralKeyPair.secretKey, m1.serverPublicKey));
+		const sessionKey = hkdf({
+			hash: "sha512",
+			key: sharedSecret,
+			length: 32,
+			salt: Buffer.from("Pair-Verify-Encrypt-Salt"),
+			info: Buffer.from("Pair-Verify-Encrypt-Info")
+		});
+		const encryptedData = m1.encryptedData.subarray(0, -16);
+		const encryptedTag = m1.encryptedData.subarray(-16);
+		const data = Chacha20.decrypt(sessionKey, Buffer.from("PV-Msg02"), null, encryptedData, encryptedTag);
+		const tlv = TLV8.decode(data);
+		const accessoryIdentifier = tlv.get(TLV8.Value.Identifier);
+		const accessorySignature = tlv.get(TLV8.Value.Signature);
+		if (accessoryIdentifier.toString() !== localAccessoryIdentifier) throw new Error(`Invalid accessory identifier. Expected ${accessoryIdentifier.toString()} to be ${localAccessoryIdentifier}.`);
+		const accessoryInfo = Buffer.concat([
+			m1.serverPublicKey,
+			accessoryIdentifier,
+			this.#ephemeralKeyPair.publicKey
+		]);
+		if (!Ed25519.verify(accessoryInfo, accessorySignature, longTermPublicKey)) throw new Error("Invalid accessory signature.");
+		return {
+			serverEphemeralPublicKey: m1.serverPublicKey,
+			sessionKey,
+			sharedSecret
+		};
+	}
+	async #m3(pairingId, secretKey, m2) {
+		const iosDeviceInfo = Buffer.concat([
+			this.#ephemeralKeyPair.publicKey,
+			pairingId,
+			m2.serverEphemeralPublicKey
+		]);
+		const iosDeviceSignature = Buffer.from(Ed25519.sign(iosDeviceInfo, secretKey));
+		const innerTlv = TLV8.encode([[TLV8.Value.Identifier, pairingId], [TLV8.Value.Signature, iosDeviceSignature]]);
+		const { authTag, ciphertext } = Chacha20.encrypt(m2.sessionKey, Buffer.from("PV-Msg03"), null, innerTlv);
+		const encrypted = Buffer.concat([ciphertext, authTag]);
+		await this.#requestHandler("m3", TLV8.encode([[TLV8.Value.State, TLV8.State.M3], [TLV8.Value.EncryptedData, encrypted]]));
+		return {};
+	}
+	async #m4(m2, pairingId) {
+		return {
+			accessoryToControllerKey: Buffer.alloc(0),
+			controllerToAccessoryKey: Buffer.alloc(0),
+			pairingId,
+			sharedSecret: m2.sharedSecret
+		};
+	}
+};
+
+//#endregion
+//#region src/timing.ts
+var TimingServer = class {
+	get port() {
+		return this.#port;
+	}
+	#logger;
+	#socket;
+	#port = 0;
+	constructor() {
+		this.#logger = new Logger("timing-server");
+		this.#socket = createSocket("udp4");
+		this.#socket.on("connect", this.#onConnect.bind(this));
+		this.#socket.on("error", this.#onError.bind(this));
+		this.#socket.on("message", this.#onMessage.bind(this));
+	}
+	close() {
+		this.#socket.close();
+		this.#port = 0;
+	}
+	listen() {
+		return new Promise((resolve, reject) => {
+			this.#socket.once("error", reject);
+			this.#socket.once("listening", () => {
+				this.#socket.removeListener("error", reject);
+				this.#onListening();
+				resolve();
+			});
+			this.#socket.bind(0, resolve);
+		});
+	}
+	#onConnect() {
+		this.#socket.setRecvBufferSize(16384);
+		this.#socket.setSendBufferSize(16384);
+	}
+	#onError(err) {
+		this.#logger.error("Timing server error", err);
+	}
+	#onListening() {
+		const { port } = this.#socket.address();
+		this.#port = port;
+	}
+	#onMessage(data, info) {
+		try {
+			const request = NTP.decode(data);
+			const ntp = NTP.now();
+			const [receivedSeconds, receivedFraction] = NTP.parts(ntp);
+			this.#logger.info(`Timing server ntp=${ntp} receivedSeconds=${receivedSeconds} receivedFraction=${receivedFraction}`);
+			const response = NTP.encode({
+				proto: request.proto,
+				type: 211,
+				seqno: request.seqno,
+				padding: 0,
+				reftime_sec: request.sendtime_sec,
+				reftime_frac: request.sendtime_frac,
+				recvtime_sec: receivedSeconds,
+				recvtime_frac: receivedFraction,
+				sendtime_sec: receivedSeconds,
+				sendtime_frac: receivedFraction
+			});
+			this.#socket.send(response, info.port, info.address, (err) => {
+				if (!err) return;
+				this.#logger.warn(`Timing server failed to send response to ${info.address}:${info.port}`, err);
+			});
+		} catch (err) {
+			this.#logger.warn(`Timing server received malformed packet (${data.length} bytes) from ${info.address}:${info.port}`, err);
+		}
+	}
+};
+
+//#endregion
+//#region src/utils.ts
+function generateActiveRemoteId() {
+	return Math.floor(Math.random() * 2 ** 32).toString(10);
+}
+function generateDacpId() {
+	return Math.floor(Math.random() * 2 ** 64).toString(16).toUpperCase();
+}
+function generateSessionId() {
+	return Math.floor(Math.random() * 2 ** 32).toString(10);
+}
+function getLocalIP() {
+	const interfaces = networkInterfaces();
+	for (const iface of Object.values(interfaces)) {
+		if (!iface) continue;
+		for (const net of iface) {
+			if (net.internal || net.family !== "IPv4") continue;
+			if (net.address && net.address !== "127.0.0.1") return net.address;
+		}
+	}
+	return null;
+}
+function getMacAddress() {
+	const interfaces = networkInterfaces();
+	for (const iface of Object.values(interfaces)) {
+		if (!iface) continue;
+		for (const net of iface) {
+			if (net.internal || net.family !== "IPv4") continue;
+			if (net.mac && net.mac !== "00:00:00:00:00:00") return net.mac.toUpperCase();
+		}
+	}
+	return "00:00:00:00:00:00";
+}
+function randomInt32() {
+	return randomBytes(4).readUInt32BE(0);
+}
+function randomInt64() {
+	return randomBytes(8).readBigUint64LE(0);
+}
+function uint16ToBE(value) {
+	const buffer = Buffer.allocUnsafe(2);
+	buffer.writeUInt16BE(value, 0);
+	return buffer;
+}
+function uint53ToLE(value) {
+	const [upper, lower] = splitUInt53(value);
+	const buffer = Buffer.allocUnsafe(8);
+	buffer.writeUInt32LE(lower, 0);
+	buffer.writeUInt32LE(upper, 4);
+	return buffer;
+}
+function splitUInt53(number) {
+	const MAX_UINT32 = 4294967295;
+	if (number <= -1 || number > 9007199254740991) throw new Error("Number out of range.");
+	if (Math.floor(number) !== number) throw new Error("Number is not an integer.");
+	let upper = 0;
+	const signbit = number & 4294967295;
+	const lower = signbit < 0 ? (number & 2147483647) + 2147483648 : signbit;
+	if (number > MAX_UINT32) upper = (number - lower) / (MAX_UINT32 + 1);
+	return [upper, lower];
+}
+
+//#endregion
+export { AIRPLAY_SERVICE, AIRPLAY_TRANSIENT_PIN, AccessoryPair, AccessoryVerify, AirPlayFeatureFlags, COMPANION_LINK_SERVICE, Connection, Context, Discovery, ENCRYPTION, EncryptionAwareConnection, EncryptionState, HTTP_TIMEOUT, JsonStorage, MemoryStorage, RAOP_SERVICE, Storage, TimingServer, describeFlags, generateActiveRemoteId, generateDacpId, generateSessionId, getLocalIP, getMacAddress, getPairingRequirement, getProtocolVersion, hasFeatureFlag, isPasswordRequired, isRemoteControlSupported, multicast as mdnsMulticast, unicast as mdnsUnicast, parseFeatures, prompt, randomInt32, randomInt64, reporter, uint16ToBE, uint53ToLE, v4 as uuid, waitFor };
 //# sourceMappingURL=index.mjs.map