@basmilius/apple-common 0.7.2 → 0.8.0

package/dist/index.js

@@ -1,942 +0,0 @@
-// ../../node_modules/uuid/dist-node/stringify.js
-var 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();
-}
-
-// ../../node_modules/uuid/dist-node/rng.js
-import { randomFillSync } from "node:crypto";
-var rnds8Pool = new Uint8Array(256);
-var poolPtr = rnds8Pool.length;
-function rng() {
-  if (poolPtr > rnds8Pool.length - 16) {
-    randomFillSync(rnds8Pool);
-    poolPtr = 0;
-  }
-  return rnds8Pool.slice(poolPtr, poolPtr += 16);
-}
-
-// ../../node_modules/uuid/dist-node/native.js
-import { randomUUID } from "node:crypto";
-var native_default = { randomUUID };
-
-// ../../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);
-}
-var v4_default = v4;
-// src/discovery.ts
-import mdns from "node-dns-sd";
-
-// src/cli.ts
-import { createInterface } from "node:readline";
-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));
-}
-
-// src/const.ts
-var AIRPLAY_TRANSIENT_PIN = "3939";
-var HTTP_TIMEOUT = 6000;
-var SOCKET_TIMEOUT = 1e4;
-var AIRPLAY_SERVICE = "_airplay._tcp.local";
-var COMPANION_LINK_SERVICE = "_companion-link._tcp.local";
-var RAOP_SERVICE = "_raop._tcp.local";
-
-// src/discovery.ts
-class Discovery {
-  #service;
-  constructor(service) {
-    this.#service = service;
-  }
-  async find() {
-    const results = await mdns.discover({
-      name: this.#service
-    });
-    return results.map((result) => ({
-      id: generateId(result) ?? result.fqdn,
-      txt: getTxt(result),
-      ...result
-    }));
-  }
-  async findUntil(id, tries = 10, timeout = 1000) {
-    while (tries > 0) {
-      const devices = await this.find();
-      const device = devices.find((device2) => device2.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(`
-`));
-      tries--;
-      await waitFor(timeout);
-    }
-    throw new Error("Device not found after serveral tries, aborting.");
-  }
-  static airplay() {
-    return new Discovery(AIRPLAY_SERVICE);
-  }
-  static companionLink() {
-    return new Discovery(COMPANION_LINK_SERVICE);
-  }
-  static raop() {
-    return new Discovery(RAOP_SERVICE);
-  }
-}
-function generateId(result) {
-  if (!result?.packet) {
-    return null;
-  }
-  const { answers = [], additionals = [] } = result.packet;
-  const allRecords = [...answers, ...additionals];
-  const srvRecord = allRecords.find((record) => record.type === "SRV");
-  if (srvRecord?.rdata?.target) {
-    return srvRecord.rdata.target;
-  }
-  if (result.address) {
-    const addressRecord = allRecords.find((record) => (record.type === "A" || record.type === "AAAA") && record.rdata === result.address);
-    if (addressRecord?.name) {
-      return addressRecord.name;
-    }
-  }
-  const aRecord = allRecords.find((record) => record.type === "A");
-  if (aRecord?.name) {
-    return aRecord.name;
-  }
-  if (result.modelName) {
-    const hostname = result.modelName.replace(/\s+/g, "-").replace(/[^a-zA-Z0-9-]/g, "");
-    return `${hostname}.local`;
-  }
-  return null;
-}
-function getTxt(result) {
-  if (!result.packet) {
-    return {};
-  }
-  const { answers = [], additionals = [] } = result.packet;
-  const records = [
-    ...answers,
-    ...additionals
-  ];
-  const txt = {};
-  for (const record of records) {
-    if (record.type === "TXT" && record.rdata) {
-      Object.assign(txt, record.rdata);
-    }
-  }
-  return txt;
-}
-// src/connection.ts
-import { EventEmitter } from "node:events";
-import { Socket } from "node:net";
-
-// src/symbols.ts
-var ENCRYPTION = Symbol();
-
-// src/connection.ts
-var NOOP_PROMISE_HANDLER = {
-  resolve: () => {},
-  reject: (_) => {}
-};
-
-class Connection 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 = 3000;
-  #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();
-  }
-  async destroy() {
-    this.#socket?.destroy();
-  }
-  async disconnect() {
-    if (this.#retryTimeout) {
-      clearTimeout(this.#retryTimeout);
-      this.#retryTimeout = undefined;
-    }
-    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 = 3000) {
-    this.#retryAttempts = attempts;
-    this.#retryInterval = interval;
-    return this;
-  }
-  write(data) {
-    if (!this.#socket || this.state !== "connected" || !this.#socket.writable) {
-      this.emit("error", 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 = undefined;
-      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 = undefined;
-    }
-    if (this.#socket) {
-      this.#socket.removeAllListeners();
-      this.#socket.destroy();
-      this.#socket = undefined;
-    }
-    this.#state = "disconnected";
-    this.#connectPromise = undefined;
-  }
-  #scheduleRetry(err) {
-    if (!this.#retryEnabled || this.#retryAttempt >= this.#retryAttempts) {
-      this.#state = "failed";
-      this.#connectPromise?.reject(err);
-      this.#connectPromise = undefined;
-      return;
-    }
-    if (this.#retryTimeout) {
-      clearTimeout(this.#retryTimeout);
-      this.#retryTimeout = undefined;
-    }
-    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 = undefined;
-      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(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 = undefined;
-  }
-  #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 = new Error("Connection timed out.");
-    this.emit("timeout");
-    if (this.#state === "connecting") {
-      this.#scheduleRetry(err);
-    } else {
-      this.#state = "failed";
-      this.#socket?.destroy();
-    }
-  }
-}
-
-class EncryptionAwareConnection extends Connection {
-  get isEncrypted() {
-    return !!this[ENCRYPTION];
-  }
-  [ENCRYPTION];
-  enableEncryption(readKey, writeKey) {
-    this[ENCRYPTION] = new EncryptionState(readKey, writeKey);
-  }
-}
-
-class EncryptionState {
-  readKey;
-  readCount;
-  writeKey;
-  writeCount;
-  constructor(readKey, writeKey) {
-    this.readCount = 0;
-    this.readKey = readKey;
-    this.writeCount = 0;
-    this.writeKey = writeKey;
-  }
-}
-// src/reporter.ts
-class Logger {
-  get id() {
-    return this.#id;
-  }
-  get label() {
-    return this.#label;
-  }
-  #id;
-  #label;
-  constructor(id) {
-    this.#id = id;
-    this.#label = `\x1B[36m[${id}]\x1B[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);
-  }
-}
-
-class Reporter {
-  #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(`\x1B[36m[debug]\x1B[39m`, ...data);
-}
-function error(...data) {
-  reporter.isEnabled("error") && console.error(`\x1B[31m[error]\x1B[39m`, ...data);
-}
-function info(...data) {
-  reporter.isEnabled("info") && console.info(`\x1B[32m[info]\x1B[39m`, ...data);
-}
-function net(...data) {
-  reporter.isEnabled("net") && console.info(`\x1B[33m[net]\x1B[39m`, ...data);
-}
-function raw(...data) {
-  reporter.isEnabled("raw") && console.log(`\x1B[34m[raw]\x1B[39m`, ...data);
-}
-function warn(...data) {
-  reporter.isEnabled("warn") && console.warn(`\x1B[33m[warn]\x1B[39m`, ...data);
-}
-var reporter = new Reporter;
-
-// src/context.ts
-class Context {
-  get deviceId() {
-    return this.#deviceId;
-  }
-  get logger() {
-    return this.#logger;
-  }
-  #deviceId;
-  #logger;
-  constructor(deviceId) {
-    this.#deviceId = deviceId;
-    this.#logger = new Logger(deviceId);
-  }
-}
-// src/pairing.ts
-import { OPack, TLV8 } from "@basmilius/apple-encoding";
-import { Chacha20, Curve25519, Ed25519, hkdf } from "@basmilius/apple-encryption";
-import { SRP, SrpClient } from "fast-srp-hap";
-class BasePairing {
-  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;
-  }
-}
-
-class AccessoryPair extends BasePairing {
-  #name;
-  #pairingId;
-  #requestHandler;
-  #publicKey;
-  #secretKey;
-  #srp;
-  constructor(context, requestHandler) {
-    super(context);
-    this.#name = "basmilius/apple-protocols";
-    this.#pairingId = Buffer.from(v4_default().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);
-    const publicKey = data.get(TLV8.Value.PublicKey);
-    const salt = data.get(TLV8.Value.Salt);
-    return { publicKey, 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);
-    const publicKey = this.#srp.computeA();
-    const proof = this.#srp.computeM1();
-    return { publicKey, proof };
-  }
-  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]
-    ]));
-    const data = this.tlv(response);
-    const serverProof = data.get(TLV8.Value.Proof);
-    return { serverProof };
-  }
-  async m4(m3) {
-    this.#srp.checkM2(m3.serverProof);
-    const sharedSecret = this.#srp.computeK();
-    return { sharedSecret };
-  }
-  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 data = this.tlv(response);
-    const encryptedDataRaw = data.get(TLV8.Value.EncryptedData);
-    const encryptedData = encryptedDataRaw.subarray(0, -16);
-    const encryptedTag = encryptedDataRaw.subarray(-16);
-    return {
-      authTag: encryptedTag,
-      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
-    };
-  }
-}
-
-class AccessoryVerify 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);
-    const encryptedData = data.get(TLV8.Value.EncryptedData);
-    return {
-      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
-    };
-  }
-}
-// src/timing.ts
-import { createSocket } from "node:dgram";
-import { NTP } from "@basmilius/apple-encoding";
-class TimingServer {
-  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));
-  }
-  async close() {
-    this.#socket.close();
-    this.#port = 0;
-  }
-  async listen() {
-    return new Promise((resolve) => {
-      this.#socket.once("listening", () => this.#onListening());
-      this.#socket.bind(0, resolve);
-    });
-  }
-  #onConnect() {
-    this.#socket.setRecvBufferSize(16384);
-    this.#socket.setSendBufferSize(16384);
-  }
-  async#onError(err) {
-    this.#logger.error("Timing server error", err);
-  }
-  async#onListening() {
-    const { port } = this.#socket.address();
-    this.#port = port;
-  }
-  async#onMessage(data, info2) {
-    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: 83 | 128,
-        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, info2.port, info2.address);
-    } catch (err) {
-      this.#logger.warn(`Timing server received malformed packet (${data.length} bytes) from ${info2.address}:${info2.port}`, err);
-    }
-  }
-}
-// src/utils.ts
-import { randomBytes } from "node:crypto";
-import { networkInterfaces } from "node:os";
-function getLocalIP() {
-  const interfaces = networkInterfaces();
-  for (const iface of Object.values(interfaces)) {
-    if (!iface) {
-      continue;
-    }
-    for (const net2 of iface) {
-      if (net2.internal || net2.family !== "IPv4") {
-        continue;
-      }
-      if (net2.address && net2.address !== "127.0.0.1") {
-        return net2.address;
-      }
-    }
-  }
-  return null;
-}
-function getMacAddress() {
-  const interfaces = networkInterfaces();
-  for (const iface of Object.values(interfaces)) {
-    if (!iface) {
-      continue;
-    }
-    for (const net2 of iface) {
-      if (net2.internal || net2.family !== "IPv4") {
-        continue;
-      }
-      if (net2.mac && net2.mac !== "00:00:00:00:00:00") {
-        return net2.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;
-  const MAX_INT53 = 9007199254740991;
-  if (number <= -1 || number > MAX_INT53) {
-    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];
-}
-export {
-  waitFor,
-  v4_default as uuid,
-  uint53ToLE,
-  uint16ToBE,
-  reporter,
-  randomInt64,
-  randomInt32,
-  prompt,
-  getMacAddress,
-  getLocalIP,
-  TimingServer,
-  RAOP_SERVICE,
-  HTTP_TIMEOUT,
-  EncryptionState,
-  EncryptionAwareConnection,
-  ENCRYPTION,
-  Discovery,
-  Context,
-  Connection,
-  COMPANION_LINK_SERVICE,
-  AccessoryVerify,
-  AccessoryPair,
-  AIRPLAY_TRANSIENT_PIN,
-  AIRPLAY_SERVICE
-};