@lox-audioserver/node-airplay-sender 0.4.0

package/dist/utils/circularBuffer.js

@@ -0,0 +1,132 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_events_1 = require("node:events");
+const packetPool_1 = __importDefault(require("./packetPool"));
+const WAITING = 0;
+const FILLING = 1;
+const NORMAL = 2;
+const DRAINING = 3;
+const ENDING = 4;
+const ENDED = 5;
+/**
+ * Fixed-size circular buffer that smooths incoming PCM/ALAC chunks into fixed packet sizes.
+ * Emits status changes for buffering/playing/drain/end to drive UI + sync.
+ */
+class CircularBuffer extends node_events_1.EventEmitter {
+    packetPool;
+    maxSize;
+    packetSize;
+    writable = true;
+    muted = false;
+    buffers = [];
+    currentSize = 0;
+    status = WAITING;
+    hadUnderrun = false;
+    constructor(packetsInBuffer, packetSize) {
+        super();
+        this.packetPool = new packetPool_1.default(packetSize);
+        this.maxSize = packetsInBuffer * packetSize;
+        this.packetSize = packetSize;
+    }
+    /**
+     * Write a PCM/ALAC chunk into the buffer.
+     * Returns false when the buffer is full so upstream can throttle.
+     */
+    write(chunk) {
+        this.buffers.push(chunk);
+        this.currentSize += chunk.length;
+        if (this.status === ENDING || this.status === ENDED) {
+            throw new Error('Cannot write in buffer after closing it');
+        }
+        if (this.status === WAITING) {
+            this.emit('status', 'buffering');
+            this.status = FILLING;
+        }
+        if (this.status === FILLING && this.currentSize > this.maxSize / 2) {
+            this.status = NORMAL;
+            this.emit('status', 'playing');
+        }
+        if (this.currentSize >= this.maxSize) {
+            this.status = DRAINING;
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Read the next fixed-size packet, zero-filling gaps to preserve timing.
+     */
+    readPacket() {
+        const packet = this.packetPool.getPacket();
+        if (this.status !== ENDING &&
+            this.status !== ENDED &&
+            (this.status === FILLING || this.currentSize < this.packetSize)) {
+            packet.pcm.fill(0);
+            if (!this.hadUnderrun) {
+                this.hadUnderrun = true;
+                this.emit('underrun');
+            }
+            if (this.status !== FILLING && this.status !== WAITING) {
+                this.status = FILLING;
+                this.emit('status', 'buffering');
+            }
+        }
+        else {
+            let offset = 0;
+            let remaining = this.packetSize;
+            while (remaining > 0) {
+                if (this.buffers.length === 0) {
+                    packet.pcm.fill(0, offset);
+                    remaining = 0;
+                    break;
+                }
+                const first = this.buffers[0];
+                if (first.length <= remaining) {
+                    first.copy(packet.pcm, offset);
+                    offset += first.length;
+                    remaining -= first.length;
+                    this.buffers.shift();
+                }
+                else {
+                    first.copy(packet.pcm, offset, 0, remaining);
+                    this.buffers[0] = first.slice(remaining);
+                    offset += remaining;
+                    remaining = 0;
+                }
+            }
+            this.currentSize -= this.packetSize;
+            if (this.hadUnderrun && this.currentSize >= this.packetSize) {
+                this.hadUnderrun = false;
+            }
+            if (this.status === ENDING && this.currentSize <= 0) {
+                this.status = ENDED;
+                this.currentSize = 0;
+                this.emit('status', 'end');
+            }
+            if (this.status === DRAINING && this.currentSize < this.maxSize / 2) {
+                this.status = NORMAL;
+                this.emit('drain');
+            }
+        }
+        if (this.muted) {
+            packet.pcm.fill(0);
+        }
+        return packet;
+    }
+    /** Mark the buffer as ending; drains then emits `end`. */
+    end() {
+        if (this.status === FILLING) {
+            this.emit('status', 'playing');
+        }
+        this.status = ENDING;
+    }
+    /** Clear internal buffers and state. */
+    reset() {
+        this.buffers = [];
+        this.currentSize = 0;
+        this.status = WAITING;
+    }
+}
+exports.default = CircularBuffer;

package/dist/utils/config.d.ts

@@ -0,0 +1,42 @@
+export interface AirplayConfig {
+    user_agent: string;
+    udp_default_port: number;
+    frames_per_packet: number;
+    channels_per_frame: number;
+    bits_per_channel: number;
+    pcm_packet_size: number;
+    alac_packet_size: number;
+    packet_size: number;
+    packets_in_buffer: number;
+    coreaudio_min_level: number;
+    coreaudio_check_period: number;
+    coreaudio_preload: number;
+    sampling_rate: number;
+    sync_period: number;
+    stream_latency: number;
+    rtsp_timeout: number;
+    rtsp_heartbeat: number;
+    rtsp_retry_attempts: number;
+    rtsp_retry_base_ms: number;
+    rtsp_retry_max_ms: number;
+    rtsp_retry_jitter_ms: number;
+    control_sync_base_delay_ms: number;
+    control_sync_jitter_ms: number;
+    use_monotonic_clock: boolean;
+    jump_forward_enabled: boolean;
+    jump_forward_threshold_ms: number;
+    jump_forward_lead_ms: number;
+    device_magic: number;
+    resend_buffer_size: number;
+    send_rtcp_sr: boolean;
+    send_rtcp_rr: boolean;
+    send_rtcp_xr: boolean;
+    underrun_mute_ms: number;
+    debug_dump: boolean;
+    ntp_epoch: number;
+    iv_base64: string;
+    rsa_aeskey_base64: string;
+}
+export declare const config: AirplayConfig;
+export declare function applyConfig(overrides: Partial<AirplayConfig>): AirplayConfig;
+export default config;

package/dist/utils/config.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+exports.applyConfig = applyConfig;
+const numUtil_1 = require("./numUtil");
+exports.config = {
+    user_agent: 'iTunes/11.3.1 (Windows; Microsoft Windows 10 x64 (Build 19044); x64) (dt:2)',
+    udp_default_port: 54621, // preferred starting port in AirTunes v2
+    frames_per_packet: 352, // samples per frames in ALAC packets
+    channels_per_frame: 2, // always stereo in AirTunes v2
+    bits_per_channel: 16, // -> 2 bytes per channel
+    pcm_packet_size: 352 * 2 * 2, // frames*channels*bytes
+    alac_packet_size: 352 * 2 * 2 + 8, // pcm payload + alac header/footer
+    packet_size: 352 * 2 * 2, // active packet size (depends on input codec)
+    packets_in_buffer: 260, // ~2.1s of audio (matches MA's ~2000ms buffer)
+    coreaudio_min_level: 5, // if CoreAudio's internal buffer drops too much, inject some silence to raise it
+    coreaudio_check_period: 2000, // CoreAudio buffer level check period
+    coreaudio_preload: 352 * 2 * 2 * 50, // ~0.5s of silence pushed to CoreAudio to avoid draining AudioQueue
+    sampling_rate: 44100, // fixed by AirTunes v2
+    sync_period: 0, // UDP sync packets are sent to all AirTunes devices regularly (0 = derive from sample rate)
+    stream_latency: 200, // audio UDP packets are flushed in bursts periodically
+    rtsp_timeout: 2147483647, // RTSP servers are considered gone if no reply is received before the timeout (legacy default)
+    rtsp_heartbeat: 15000, // some RTSP (like HomePod) servers requires heartbeat.
+    rtsp_retry_attempts: 3,
+    rtsp_retry_base_ms: 300,
+    rtsp_retry_max_ms: 4000,
+    rtsp_retry_jitter_ms: 150,
+    control_sync_base_delay_ms: 2,
+    control_sync_jitter_ms: 3,
+    use_monotonic_clock: true,
+    jump_forward_enabled: false,
+    jump_forward_threshold_ms: 180,
+    jump_forward_lead_ms: 220,
+    device_magic: (0, numUtil_1.randomInt)(9),
+    resend_buffer_size: 1000,
+    send_rtcp_sr: true,
+    send_rtcp_rr: true,
+    send_rtcp_xr: false,
+    underrun_mute_ms: 50,
+    debug_dump: false,
+    ntp_epoch: 0x83aa7e80,
+    iv_base64: 'ePRBLI0XN5ArFaaz7ncNZw',
+    rsa_aeskey_base64: 'VjVbxWcmYgbBbhwBNlCh3K0CMNtWoB844BuiHGUJT51zQS7SDpMnlbBIobsKbfEJ3SCgWHRXjYWf7VQWRYtEcfx7ejA8xDIk5PSBYTvXP5dU2QoGrSBv0leDS6uxlEWuxBq3lIxCxpWO2YswHYKJBt06Uz9P2Fq2hDUwl3qOQ8oXb0OateTKtfXEwHJMprkhsJsGDrIc5W5NJFMAo6zCiM9bGSDeH2nvTlyW6bfI/Q0v0cDGUNeY3ut6fsoafRkfpCwYId+bg3diJh+uzw5htHDyZ2sN+BFYHzEfo8iv4KDxzeya9llqg6fRNQ8d5YjpvTnoeEQ9ye9ivjkBjcAfVw',
+};
+function applyConfig(overrides) {
+    Object.assign(exports.config, overrides);
+    return exports.config;
+}
+exports.default = exports.config;

package/dist/utils/http.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Minimal HTTP/1.1 client for plain TCP connections (no TLS).
+ * Used for AirPlay control endpoints where lightweight parsing is sufficient.
+ */
+type Headers = Record<string, string>;
+export type MessageObject = {
+    method?: string;
+    path?: string;
+    statusCode?: number;
+    headers: Headers;
+    body?: Buffer;
+};
+export interface HttpClientApi {
+    connect(host: string, port?: number): Promise<void>;
+    request(method: string, path: string, headers?: Headers, body?: Buffer): Promise<MessageObject | null>;
+    close(): void;
+}
+declare const createHttpClient: () => HttpClientApi;
+export default createHttpClient;

package/dist/utils/http.js

@@ -0,0 +1,148 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_net_1 = __importDefault(require("node:net"));
+const HttpMessage = (parseStartLine, writeStartLine) => {
+    const instance = {
+        parse: () => ({ headers: {} }),
+        write: () => Buffer.alloc(0),
+    };
+    instance.parse = (buffer) => {
+        const messageObject = { headers: {} };
+        // ...
+        let bodyIndex = buffer.indexOf('\r\n\r\n');
+        let headerString = buffer.slice(0, bodyIndex).toString();
+        let body = buffer.slice(bodyIndex + 4);
+        headerString = headerString.replace(/\r\n/g, '\n');
+        const lines = headerString.split('\n');
+        bodyIndex += 2;
+        // ...
+        let line = lines.shift();
+        if (line) {
+            parseStartLine(line, messageObject);
+        }
+        // ...
+        line = lines.shift();
+        while (line) {
+            const headerName = line.substr(0, line.indexOf(':'));
+            const headerValue = line.substr(line.indexOf(':') + 1);
+            messageObject.headers[headerName] = headerValue.trim();
+            line = lines.shift();
+        }
+        // ...
+        if (messageObject.headers['Content-Length'] && messageObject.headers['Content-Length'] !== '0') {
+            messageObject.body = body;
+        }
+        return messageObject;
+    };
+    instance.write = (messageObject) => {
+        let messageString = writeStartLine(messageObject);
+        messageString += '\r\n';
+        if (messageObject.body) {
+            messageObject.headers['Content-Length'] = String(Buffer.byteLength(messageObject.body));
+        }
+        for (const header in messageObject.headers) {
+            messageString += `${header}: ${messageObject.headers[header]}\r\n`;
+        }
+        messageString += '\r\n';
+        const buffer = Buffer.from(messageString);
+        if (!messageObject.body) {
+            return buffer;
+        }
+        return Buffer.concat([buffer, messageObject.body], buffer.length + messageObject.body.length);
+    };
+    return instance;
+};
+const HttpRequest = () => HttpMessage(() => { }, // currently not parsing requests.
+(messageObject) => `${messageObject.method} ${messageObject.path} HTTP/1.1`);
+const HttpResponse = () => HttpMessage((line, messageObject) => {
+    messageObject.statusCode = parseInt(line.split(' ')[1], 10);
+}, () => '');
+// ...
+class HttpClient {
+    resolveQueue = [];
+    pendingResponse = null;
+    socket;
+    host;
+    // ....
+    parseResponse(data) {
+        const res = HttpResponse().parse(data);
+        if (res.headers['Content-Length'] && Number(res.headers['Content-Length']) > 0) {
+            const remaining = Number(res.headers['Content-Length']) - (res.body?.byteLength ?? 0);
+            if (remaining > 0) {
+                // not all data for this response's corresponding request was read. Create a pending response object
+                // to use for further reads.
+                this.pendingResponse = {
+                    res,
+                    remaining
+                };
+            }
+        }
+        if (!this.pendingResponse) {
+            const rr = this.resolveQueue.shift();
+            if (!rr)
+                return;
+            res.statusCode === 200
+                ? rr.resolve(res)
+                : rr.resolve(null);
+        }
+    }
+    // ...
+    connect(host, port = 80) {
+        this.host = host;
+        return new Promise(resolve => {
+            this.socket = node_net_1.default.connect({
+                host,
+                port
+            }, resolve);
+            this.socket.on('data', data => {
+                if (!this.pendingResponse) {
+                    // there is no response pending, parse the data.
+                    this.parseResponse(data);
+                }
+                else {
+                    // incoming data for the pending response.
+                    const existing = this.pendingResponse.res.body ?? Buffer.alloc(0);
+                    this.pendingResponse.res.body = Buffer.concat([existing, data], data.byteLength + existing.byteLength);
+                    this.pendingResponse.remaining -= data.byteLength;
+                    if (this.pendingResponse.remaining === 0) {
+                        // all remaining data for the pending response has been read; resolve the promise for the 
+                        // corresponding request.
+                        const rr = this.resolveQueue.shift();
+                        if (!rr) {
+                            this.pendingResponse = null;
+                            return;
+                        }
+                        this.pendingResponse.res.statusCode === 200
+                            ? rr.resolve(this.pendingResponse.res)
+                            : rr.reject(new Error(`HTTP status: ${this.pendingResponse.res.statusCode}`));
+                        this.pendingResponse = null;
+                    }
+                }
+            });
+        });
+    }
+    request(method, path, headers, body) {
+        headers = headers || {};
+        // headers['Host'] = `${this.host}:${this.socket.remotePort}`;
+        const data = HttpRequest().write({
+            method,
+            path,
+            headers,
+            body
+        });
+        // ...
+        return new Promise((resolve, reject) => {
+            this.resolveQueue.push({ resolve, reject });
+            this.socket?.write(data);
+        });
+    }
+    close() {
+        this.socket?.end();
+    }
+}
+// ...
+const createHttpClient = () => new HttpClient();
+exports.default = createHttpClient;

package/dist/utils/ntp.d.ts

@@ -0,0 +1,21 @@
+export type NtpTimestampInput = bigint | number | {
+    sec: number;
+    frac: number;
+};
+declare class NTP {
+    /** Convert monotonic clock to NTP epoch (1900-01-01) seconds + fractional. */
+    timestamp(): Buffer;
+    /** Return the current NTP fractional component (for compatibility). */
+    getTime(): number;
+}
+declare const _default: NTP;
+export default _default;
+/** Pack various NTP timestamp representations into a uint64 bigint (sec<<32|frac). */
+export declare function toNtpTimestamp(input: NtpTimestampInput): bigint;
+/** Parse an NTP timestamp (uint64 or sec/frac) into components. */
+export declare function parseNtpTimestamp(input: NtpTimestampInput): {
+    sec: number;
+    frac: number;
+};
+/** Build an NTP timestamp from a Unix epoch (ms). */
+export declare function ntpFromUnixMs(unixMs: number): bigint;

package/dist/utils/ntp.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toNtpTimestamp = toNtpTimestamp;
+exports.parseNtpTimestamp = parseNtpTimestamp;
+exports.ntpFromUnixMs = ntpFromUnixMs;
+const config_1 = __importDefault(require("./config"));
+const NS_PER_SEC = 1000000000n;
+const FRAC_PER_SEC = 0x100000000n; // 2^32
+class NTP {
+    /** Convert monotonic clock to NTP epoch (1900-01-01) seconds + fractional. */
+    timestamp() {
+        const nowNs = process.hrtime.bigint();
+        const sec = Number(nowNs / NS_PER_SEC) + config_1.default.ntp_epoch;
+        const frac = Number(((nowNs % NS_PER_SEC) * FRAC_PER_SEC) / NS_PER_SEC);
+        const ts = Buffer.alloc(8);
+        ts.writeUInt32BE(sec >>> 0, 0);
+        ts.writeUInt32BE(frac >>> 0, 4);
+        return ts;
+    }
+    /** Return the current NTP fractional component (for compatibility). */
+    getTime() {
+        const nowNs = process.hrtime.bigint();
+        return Number(((nowNs % NS_PER_SEC) * FRAC_PER_SEC) / NS_PER_SEC);
+    }
+}
+exports.default = new NTP();
+/** Pack various NTP timestamp representations into a uint64 bigint (sec<<32|frac). */
+function toNtpTimestamp(input) {
+    if (typeof input === 'bigint')
+        return input;
+    if (typeof input === 'number')
+        return BigInt(input);
+    const sec = BigInt(input.sec >>> 0);
+    const frac = BigInt(input.frac >>> 0);
+    return (sec << 32n) | frac;
+}
+/** Parse an NTP timestamp (uint64 or sec/frac) into components. */
+function parseNtpTimestamp(input) {
+    if (typeof input === 'bigint' || typeof input === 'number') {
+        const value = typeof input === 'bigint' ? input : BigInt(input);
+        const sec = Number(value >> 32n);
+        const frac = Number(value & 0xffffffffn);
+        return { sec, frac };
+    }
+    return { sec: input.sec, frac: input.frac };
+}
+/** Build an NTP timestamp from a Unix epoch (ms). */
+function ntpFromUnixMs(unixMs) {
+    const sec = Math.floor(unixMs / 1000) + config_1.default.ntp_epoch;
+    const ms = unixMs % 1000;
+    const frac = Math.floor((ms / 1000) * Number(FRAC_PER_SEC));
+    return (BigInt(sec >>> 0) << 32n) | BigInt(frac >>> 0);
+}

package/dist/utils/numUtil.d.ts

@@ -0,0 +1,5 @@
+export declare const randomHex: (n: number) => string;
+export declare const randomBase64: (n: number) => string;
+export declare const randomInt: (n: number) => number;
+export declare const low16: (i: number) => number;
+export declare const low32: (i: number) => number;

package/dist/utils/numUtil.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.low32 = exports.low16 = exports.randomInt = exports.randomBase64 = exports.randomHex = void 0;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const randomHex = (n) => node_crypto_1.default.randomBytes(n).toString('hex');
+exports.randomHex = randomHex;
+const randomBase64 = (n) => node_crypto_1.default.randomBytes(n).toString('base64').replace('=', '');
+exports.randomBase64 = randomBase64;
+const randomInt = (n) => Math.floor(Math.random() * Math.pow(10, n));
+exports.randomInt = randomInt;
+const low16 = (i) => Math.abs(i) % 65536;
+exports.low16 = low16;
+const low32 = (i) => Math.abs(i) % 4294967296;
+exports.low32 = low32;

package/dist/utils/packetPool.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Reusable packet structure holding PCM/ALAC data plus sequence.
+ * Reference-counted to reduce allocations in the streaming path.
+ */
+export declare class Packet {
+    private readonly pool;
+    private ref;
+    seq: number | null;
+    readonly pcm: Buffer;
+    constructor(pool: PacketPool, packetSize: number);
+    /** Increment ref count when sharing the packet. */
+    retain(): void;
+    /** Decrement ref count and return to pool when free. */
+    release(): void;
+}
+/** Simple pool of Packet instances to avoid GC pressure during streaming. */
+export default class PacketPool {
+    private readonly packetSize;
+    private readonly pool;
+    constructor(packetSize: number);
+    /** Borrow a packet from the pool or allocate a new one. */
+    getPacket(): Packet;
+    /** Return a packet to the pool. */
+    release(packet: Packet): void;
+}

package/dist/utils/packetPool.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Packet = void 0;
+/**
+ * Reusable packet structure holding PCM/ALAC data plus sequence.
+ * Reference-counted to reduce allocations in the streaming path.
+ */
+class Packet {
+    pool;
+    ref = 1;
+    seq = null;
+    pcm;
+    constructor(pool, packetSize) {
+        this.pool = pool;
+        this.pcm = Buffer.alloc(packetSize);
+    }
+    /** Increment ref count when sharing the packet. */
+    retain() {
+        this.ref += 1;
+    }
+    /** Decrement ref count and return to pool when free. */
+    release() {
+        this.ref -= 1;
+        if (this.ref === 0) {
+            this.seq = null;
+            this.pool.release(this);
+        }
+    }
+}
+exports.Packet = Packet;
+/** Simple pool of Packet instances to avoid GC pressure during streaming. */
+class PacketPool {
+    packetSize;
+    pool = [];
+    constructor(packetSize) {
+        this.packetSize = packetSize;
+    }
+    /** Borrow a packet from the pool or allocate a new one. */
+    getPacket() {
+        const packet = this.pool.shift();
+        if (!packet) {
+            return new Packet(this, this.packetSize);
+        }
+        packet.retain();
+        return packet;
+    }
+    /** Return a packet to the pool. */
+    release(packet) {
+        this.pool.push(packet);
+    }
+}
+exports.default = PacketPool;

package/dist/utils/util.d.ts

@@ -0,0 +1,2 @@
+export declare const hexString2ArrayBuffer: (hexString: string) => Uint8Array;
+export declare const buf2hex: (buffer: ArrayBuffer | Uint8Array) => string;

package/dist/utils/util.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buf2hex = exports.hexString2ArrayBuffer = void 0;
+const hexString2ArrayBuffer = (hexString) => new Uint8Array(hexString.match(/[\da-f]{2}/gi)?.map((h) => parseInt(h, 16)) ?? []);
+exports.hexString2ArrayBuffer = hexString2ArrayBuffer;
+const buf2hex = (buffer) => Array.prototype.map
+    .call(new Uint8Array(buffer), (x) => `00${x.toString(16)}`.slice(-2))
+    .join('');
+exports.buf2hex = buf2hex;

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@lox-audioserver/node-airplay-sender",
+  "version": "0.4.0",
+  "description": "AirPlay sender (RAOP/AirPlay 1; AirPlay 2 control/auth, best-effort audio)",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "import": "./dist/esm/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist/**/*",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "npm run build:cjs && npm run build:esm",
+    "build:cjs": "tsc -p tsconfig.json",
+    "build:esm": "tsc -p tsconfig.esm.json && node -e \"const fs=require('fs');fs.mkdirSync('dist/esm',{recursive:true});fs.writeFileSync('dist/esm/package.json','{\\\"type\\\":\\\"module\\\"}\\n');\"",
+    "clean": "rimraf dist",
+    "prepare": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lox-audioserver/node-airplay-sender.git"
+  },
+  "bugs": {
+    "url": "https://github.com/lox-audioserver/node-airplay-sender/issues"
+  },
+  "homepage": "https://github.com/lox-audioserver/node-airplay-sender#readme",
+  "keywords": [
+    "airplay",
+    "raop",
+    "audio",
+    "streaming"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@noble/ed25519": "^1.7.3",
+    "async": "^3.2.5",
+    "big-integer": "^1.6.52",
+    "bplist-creator": "^0.1.1",
+    "bplist-parser": "^0.3.2",
+    "crypto-js": "^4.2.0",
+    "curve25519-js": "^0.0.4",
+    "elliptic": "^6.5.5",
+    "fast-srp-hap": "^2.0.4",
+    "js-crypto-aes": "^1.0.6",
+    "js-sha1": "^0.7.0",
+    "lodash": "^4.17.21",
+    "parse-raw-http": "0.0.1",
+    "python-struct": "^1.1.3",
+    "simple-plist": "^1.4.0",
+    "varint": "^6.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.19.3",
+    "rimraf": "^6.0.1",
+    "typescript": "^5.9.3"
+  },
+  "license": "AGPL-3.0"
+}