lox-slimproto 0.1.0

package/dist/discovery.js

@@ -0,0 +1,104 @@
+import dgram from 'dgram';
+function parseTlvDiscoveryRequest(payload) {
+    const data = payload.toString('utf-8', 1); // drop leading 'e'
+    const result = [];
+    let idx = 0;
+    while (idx <= data.length - 5) {
+        const key = data.slice(idx, idx + 4);
+        const len = data.charCodeAt(idx + 4);
+        idx += 5;
+        const value = len > 0 ? data.slice(idx, idx + len) : null;
+        idx += len;
+        result.push([key, value]);
+    }
+    return result;
+}
+function buildTlvResponse(requestData, opts) {
+    const response = [];
+    for (const [key, val] of requestData) {
+        switch (key) {
+            case 'NAME':
+                response.push([key, opts.name]);
+                break;
+            case 'IPAD':
+                response.push([key, opts.ipAddress]);
+                break;
+            case 'JSON':
+                if (opts.cliPortJson != null)
+                    response.push([key, String(opts.cliPortJson)]);
+                break;
+            case 'CLIP':
+                if (opts.cliPort != null)
+                    response.push([key, String(opts.cliPort)]);
+                break;
+            case 'VERS':
+                response.push([key, '7.999.999']);
+                break;
+            case 'UUID':
+                response.push([key, opts.uuid]);
+                break;
+            default:
+                response.push([key, val]);
+        }
+    }
+    return response;
+}
+function encodeTlvResponse(responseData) {
+    const parts = ['E']; // response prefix
+    for (const [key, value] of responseData) {
+        const val = value ?? '';
+        const truncated = val.length > 255 ? val.slice(0, 255) : val;
+        parts.push(key, String.fromCharCode(truncated.length), truncated);
+    }
+    return Buffer.from(parts.join(''), 'utf-8');
+}
+function encodeLegacyDiscovery(ipAddress) {
+    const hostname = ipAddress.slice(0, 16).padEnd(16, '\u0000');
+    const buf = Buffer.alloc(17);
+    buf.write('D', 0, 'ascii');
+    buf.write(hostname, 1, 'binary');
+    return buf;
+}
+export function startDiscovery(opts) {
+    const socket = dgram.createSocket({ type: 'udp4', reuseAddr: true });
+    const name = opts.name ?? 'Slimproto';
+    const uuid = opts.uuid ?? 'slimproto';
+    socket.on('listening', () => {
+        try {
+            socket.addMembership('239.255.255.250');
+        }
+        catch (err) {
+            // eslint-disable-next-line no-console
+            console.warn('Failed to join discovery multicast group', err);
+        }
+    });
+    socket.on('message', (msg, rinfo) => {
+        try {
+            if (msg.length === 0)
+                return;
+            if (msg[0] === 0x65) {
+                const requestData = parseTlvDiscoveryRequest(msg);
+                const responseData = buildTlvResponse(requestData, {
+                    name,
+                    ipAddress: opts.ipAddress,
+                    cliPort: opts.cliPort,
+                    cliPortJson: opts.cliPortJson,
+                    uuid,
+                });
+                const payload = encodeTlvResponse(responseData);
+                socket.send(payload, rinfo.port, rinfo.address);
+                return;
+            }
+            if (msg[0] === 0x64) {
+                const payload = encodeLegacyDiscovery(opts.ipAddress);
+                socket.send(payload, rinfo.port, rinfo.address);
+            }
+        }
+        catch (err) {
+            // eslint-disable-next-line no-console
+            console.error('Error handling discovery message from', rinfo.address, err);
+        }
+    });
+    socket.bind(opts.controlPort, '0.0.0.0');
+    return socket;
+}

package/dist/errors.d.ts

@@ -0,0 +1,3 @@
+export declare class UnsupportedContentType extends Error {
+    constructor(message: string);
+}

package/dist/errors.js

@@ -0,0 +1,6 @@
+export class UnsupportedContentType extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'UnsupportedContentType';
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from './constants.js';
+export * from './models.js';
+export * from './util.js';
+export * from './volume.js';
+export * from './discovery.js';
+export * from './errors.js';
+export * from './client.js';
+export * from './server.js';

package/dist/index.js

@@ -0,0 +1,8 @@
+export * from './constants.js';
+export * from './models.js';
+export * from './util.js';
+export * from './volume.js';
+export * from './discovery.js';
+export * from './errors.js';
+export * from './client.js';
+export * from './server.js';

package/dist/models.d.ts

@@ -0,0 +1,119 @@
+export declare enum EventType {
+    PLAYER_UPDATED = "player_updated",
+    PLAYER_HEARTBEAT = "player_heartbeat",
+    PLAYER_CONNECTED = "player_connected",
+    PLAYER_DISCONNECTED = "player_disconnected",
+    PLAYER_NAME_RECEIVED = "player_name_received",
+    PLAYER_DISPLAY_RESOLUTION = "player_display_resolution",
+    PLAYER_DECODER_READY = "player_decoder_ready",
+    PLAYER_DECODER_ERROR = "player_decoder_error",
+    PLAYER_OUTPUT_UNDERRUN = "player_output_underrun",
+    PLAYER_BUFFER_READY = "player_buffer_ready",
+    PLAYER_CLI_EVENT = "player_cli_event",
+    PLAYER_BTN_EVENT = "player_btn_event",
+    PLAYER_PRESETS_UPDATED = "player_presets_updated"
+}
+export interface SlimEvent<T = unknown> {
+    type: EventType;
+    playerId: string;
+    data?: T;
+}
+export declare const DEVICE_TYPE: Record<number, string>;
+export declare enum PlayerState {
+    PLAYING = "playing",
+    STOPPED = "stopped",
+    PAUSED = "paused",
+    BUFFERING = "buffering",
+    BUFFER_READY = "buffer_ready"
+}
+export declare enum TransitionType {
+    NONE = "0",
+    CROSSFADE = "1",
+    FADE_IN = "2",
+    FADE_OUT = "3",
+    FADE_IN_OUT = "4"
+}
+export declare enum VisualisationType {
+    NONE = "none",
+    SPECTRUM_ANALYZER = "spectrum_analyzer",
+    VU_METER_ANALOG = "vu_meter_analog",
+    VU_METER_DIGITAL = "vu_meter_digital",
+    WAVEFORM = "waveform"
+}
+export declare enum RemoteCode {
+    SLEEP = 1988737095,
+    POWER = 1988706495,
+    REWIND = 1988739135,
+    PAUSE = 1988698335,
+    FORWARD = 1988730975,
+    ADD = 1988714655,
+    PLAY = 1988694255,
+    UP = 1988747295,
+    DOWN = 1988735055,
+    LEFT = 1988726895,
+    RIGHT = 1988743215,
+    VOLUME_UP = 1988722815,
+    VOLUME_DOWN = 1988690175,
+    NUM_1 = 1988751375,
+    NUM_2 = 1988692215,
+    NUM_3 = 1988724855,
+    NUM_4 = 1988708535,
+    NUM_5 = 1988741175,
+    NUM_6 = 1988700375,
+    NUM_7 = 1988733015,
+    NUM_8 = 1988716695,
+    NUM_9 = 1988749335,
+    NUM_0 = 1988728935,
+    FAVORITES = 1988696295,
+    SEARCH = 1988712615,
+    BROWSE = 1988718735,
+    SHUFFLE = 1988745255,
+    REPEAT = 1988704455,
+    NOW_PLAYING = 1988720775,
+    SIZE = 1988753415,
+    BRIGHTNESS = 1988691195
+}
+export declare enum ButtonCode {
+    POWER = 65546,
+    PRESET_1 = 131104,
+    PRESET_2 = 131105,
+    PRESET_3 = 131106,
+    PRESET_4 = 131107,
+    PRESET_5 = 131108,
+    PRESET_6 = 131109,
+    BACK = 131085,
+    PLAY = 131090,
+    ADD = 131091,
+    UP = 131083,
+    OK = 131086,
+    REWIND = 131088,
+    PAUSE = 131095,
+    FORWARD = 131101,
+    VOLUME_DOWN = 131081,
+    POWER_RELEASE = 131082
+}
+export declare const PCM_SAMPLE_SIZE: Record<number, Buffer>;
+export declare const PCM_SAMPLE_RATE: Record<number, Buffer>;
+export declare const CODEC_MAPPING: Record<string, string>;
+export declare const FORMAT_BYTE: Record<string, Buffer>;
+export declare const PLAYMODE_MAP: Record<PlayerState, string>;
+export interface MediaMetadata {
+    item_id?: string;
+    artist?: string;
+    album?: string;
+    title?: string;
+    image_url?: string;
+    duration?: number;
+}
+export interface MediaDetails {
+    url: string;
+    mimeType?: string;
+    metadata?: MediaMetadata;
+    transition?: TransitionType;
+    transitionDuration?: number;
+}
+export interface Preset {
+    uri: string;
+    text: string;
+    icon: string;
+}

package/dist/models.js

@@ -0,0 +1,168 @@
+export var EventType;
+(function (EventType) {
+    EventType["PLAYER_UPDATED"] = "player_updated";
+    EventType["PLAYER_HEARTBEAT"] = "player_heartbeat";
+    EventType["PLAYER_CONNECTED"] = "player_connected";
+    EventType["PLAYER_DISCONNECTED"] = "player_disconnected";
+    EventType["PLAYER_NAME_RECEIVED"] = "player_name_received";
+    EventType["PLAYER_DISPLAY_RESOLUTION"] = "player_display_resolution";
+    EventType["PLAYER_DECODER_READY"] = "player_decoder_ready";
+    EventType["PLAYER_DECODER_ERROR"] = "player_decoder_error";
+    EventType["PLAYER_OUTPUT_UNDERRUN"] = "player_output_underrun";
+    EventType["PLAYER_BUFFER_READY"] = "player_buffer_ready";
+    EventType["PLAYER_CLI_EVENT"] = "player_cli_event";
+    EventType["PLAYER_BTN_EVENT"] = "player_btn_event";
+    EventType["PLAYER_PRESETS_UPDATED"] = "player_presets_updated";
+})(EventType || (EventType = {}));
+export const DEVICE_TYPE = {
+    2: 'squeezebox',
+    3: 'softsqueeze',
+    4: 'squeezebox2',
+    5: 'transporter',
+    6: 'softsqueeze3',
+    7: 'receiver',
+    8: 'squeezeslave',
+    9: 'controller',
+    10: 'boom',
+    11: 'softboom',
+    12: 'squeezeplay',
+    100: 'squeezeesp32',
+};
+export var PlayerState;
+(function (PlayerState) {
+    PlayerState["PLAYING"] = "playing";
+    PlayerState["STOPPED"] = "stopped";
+    PlayerState["PAUSED"] = "paused";
+    PlayerState["BUFFERING"] = "buffering";
+    PlayerState["BUFFER_READY"] = "buffer_ready";
+})(PlayerState || (PlayerState = {}));
+export var TransitionType;
+(function (TransitionType) {
+    TransitionType["NONE"] = "0";
+    TransitionType["CROSSFADE"] = "1";
+    TransitionType["FADE_IN"] = "2";
+    TransitionType["FADE_OUT"] = "3";
+    TransitionType["FADE_IN_OUT"] = "4";
+})(TransitionType || (TransitionType = {}));
+export var VisualisationType;
+(function (VisualisationType) {
+    VisualisationType["NONE"] = "none";
+    VisualisationType["SPECTRUM_ANALYZER"] = "spectrum_analyzer";
+    VisualisationType["VU_METER_ANALOG"] = "vu_meter_analog";
+    VisualisationType["VU_METER_DIGITAL"] = "vu_meter_digital";
+    VisualisationType["WAVEFORM"] = "waveform";
+})(VisualisationType || (VisualisationType = {}));
+export var RemoteCode;
+(function (RemoteCode) {
+    RemoteCode[RemoteCode["SLEEP"] = 1988737095] = "SLEEP";
+    RemoteCode[RemoteCode["POWER"] = 1988706495] = "POWER";
+    RemoteCode[RemoteCode["REWIND"] = 1988739135] = "REWIND";
+    RemoteCode[RemoteCode["PAUSE"] = 1988698335] = "PAUSE";
+    RemoteCode[RemoteCode["FORWARD"] = 1988730975] = "FORWARD";
+    RemoteCode[RemoteCode["ADD"] = 1988714655] = "ADD";
+    RemoteCode[RemoteCode["PLAY"] = 1988694255] = "PLAY";
+    RemoteCode[RemoteCode["UP"] = 1988747295] = "UP";
+    RemoteCode[RemoteCode["DOWN"] = 1988735055] = "DOWN";
+    RemoteCode[RemoteCode["LEFT"] = 1988726895] = "LEFT";
+    RemoteCode[RemoteCode["RIGHT"] = 1988743215] = "RIGHT";
+    RemoteCode[RemoteCode["VOLUME_UP"] = 1988722815] = "VOLUME_UP";
+    RemoteCode[RemoteCode["VOLUME_DOWN"] = 1988690175] = "VOLUME_DOWN";
+    RemoteCode[RemoteCode["NUM_1"] = 1988751375] = "NUM_1";
+    RemoteCode[RemoteCode["NUM_2"] = 1988692215] = "NUM_2";
+    RemoteCode[RemoteCode["NUM_3"] = 1988724855] = "NUM_3";
+    RemoteCode[RemoteCode["NUM_4"] = 1988708535] = "NUM_4";
+    RemoteCode[RemoteCode["NUM_5"] = 1988741175] = "NUM_5";
+    RemoteCode[RemoteCode["NUM_6"] = 1988700375] = "NUM_6";
+    RemoteCode[RemoteCode["NUM_7"] = 1988733015] = "NUM_7";
+    RemoteCode[RemoteCode["NUM_8"] = 1988716695] = "NUM_8";
+    RemoteCode[RemoteCode["NUM_9"] = 1988749335] = "NUM_9";
+    RemoteCode[RemoteCode["NUM_0"] = 1988728935] = "NUM_0";
+    RemoteCode[RemoteCode["FAVORITES"] = 1988696295] = "FAVORITES";
+    RemoteCode[RemoteCode["SEARCH"] = 1988712615] = "SEARCH";
+    RemoteCode[RemoteCode["BROWSE"] = 1988718735] = "BROWSE";
+    RemoteCode[RemoteCode["SHUFFLE"] = 1988745255] = "SHUFFLE";
+    RemoteCode[RemoteCode["REPEAT"] = 1988704455] = "REPEAT";
+    RemoteCode[RemoteCode["NOW_PLAYING"] = 1988720775] = "NOW_PLAYING";
+    RemoteCode[RemoteCode["SIZE"] = 1988753415] = "SIZE";
+    RemoteCode[RemoteCode["BRIGHTNESS"] = 1988691195] = "BRIGHTNESS";
+})(RemoteCode || (RemoteCode = {}));
+export var ButtonCode;
+(function (ButtonCode) {
+    ButtonCode[ButtonCode["POWER"] = 65546] = "POWER";
+    ButtonCode[ButtonCode["PRESET_1"] = 131104] = "PRESET_1";
+    ButtonCode[ButtonCode["PRESET_2"] = 131105] = "PRESET_2";
+    ButtonCode[ButtonCode["PRESET_3"] = 131106] = "PRESET_3";
+    ButtonCode[ButtonCode["PRESET_4"] = 131107] = "PRESET_4";
+    ButtonCode[ButtonCode["PRESET_5"] = 131108] = "PRESET_5";
+    ButtonCode[ButtonCode["PRESET_6"] = 131109] = "PRESET_6";
+    ButtonCode[ButtonCode["BACK"] = 131085] = "BACK";
+    ButtonCode[ButtonCode["PLAY"] = 131090] = "PLAY";
+    ButtonCode[ButtonCode["ADD"] = 131091] = "ADD";
+    ButtonCode[ButtonCode["UP"] = 131083] = "UP";
+    ButtonCode[ButtonCode["OK"] = 131086] = "OK";
+    ButtonCode[ButtonCode["REWIND"] = 131088] = "REWIND";
+    ButtonCode[ButtonCode["PAUSE"] = 131095] = "PAUSE";
+    ButtonCode[ButtonCode["FORWARD"] = 131101] = "FORWARD";
+    ButtonCode[ButtonCode["VOLUME_DOWN"] = 131081] = "VOLUME_DOWN";
+    ButtonCode[ButtonCode["POWER_RELEASE"] = 131082] = "POWER_RELEASE";
+})(ButtonCode || (ButtonCode = {}));
+export const PCM_SAMPLE_SIZE = {
+    8: Buffer.from('0'),
+    16: Buffer.from('1'),
+    20: Buffer.from('2'),
+    32: Buffer.from('3'),
+    24: Buffer.from('4'),
+    0: Buffer.from('?'),
+};
+export const PCM_SAMPLE_RATE = {
+    11000: Buffer.from('0'),
+    22000: Buffer.from('1'),
+    44100: Buffer.from('3'),
+    48000: Buffer.from('4'),
+    8000: Buffer.from('5'),
+    12000: Buffer.from('6'),
+    16000: Buffer.from('7'),
+    24000: Buffer.from('8'),
+    88200: Buffer.from(':'),
+    96000: Buffer.from('9'),
+    176400: Buffer.from(';'),
+    192000: Buffer.from('<'),
+    352800: Buffer.from('='),
+    384000: Buffer.from('>'),
+    0: Buffer.from('?'),
+};
+export const CODEC_MAPPING = {
+    'audio/mp3': 'mp3',
+    'audio/mpeg': 'mp3',
+    'audio/flac': 'flc',
+    'audio/x-flac': 'flc',
+    'audio/wma': 'wma',
+    'audio/ogg': 'ogg',
+    'audio/oga': 'ogg',
+    'audio/aac': 'aac',
+    'audio/aacp': 'aac',
+    'audio/alac': 'alc',
+    'audio/wav': 'pcm',
+    'audio/x-wav': 'pcm',
+    'audio/dsf': 'dsf',
+    'audio/pcm,': 'pcm',
+};
+export const FORMAT_BYTE = {
+    pcm: Buffer.from('p'),
+    mp3: Buffer.from('m'),
+    flc: Buffer.from('f'),
+    wma: Buffer.from('w'),
+    ogg: Buffer.from('o'),
+    aac: Buffer.from('a'),
+    alc: Buffer.from('l'),
+    dsf: Buffer.from('p'),
+    dff: Buffer.from('p'),
+    aif: Buffer.from('p'),
+};
+export const PLAYMODE_MAP = {
+    [PlayerState.STOPPED]: 'stop',
+    [PlayerState.PLAYING]: 'play',
+    [PlayerState.BUFFER_READY]: 'play',
+    [PlayerState.BUFFERING]: 'play',
+    [PlayerState.PAUSED]: 'pause',
+};

package/dist/server.d.ts

@@ -0,0 +1,27 @@
+import { EventEmitter } from 'events';
+import { EventType, SlimEvent } from './models.js';
+import { SlimClient } from './client.js';
+export interface SlimServerOptions {
+    cliPort?: number | null;
+    cliPortJson?: number | null;
+    ipAddress?: string | null;
+    name?: string | null;
+    controlPort?: number;
+}
+export declare class SlimServer extends EventEmitter {
+    readonly options: SlimServerOptions;
+    private server?;
+    private discovery?;
+    private playersMap;
+    private subscriptions;
+    constructor(options?: SlimServerOptions);
+    get players(): SlimClient[];
+    getPlayer(playerId: string): SlimClient | undefined;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    subscribe(cb: (event: SlimEvent) => void | Promise<void>, eventFilter?: EventType | EventType[] | null, playerFilter?: string | string[] | null): () => void;
+    private registerPlayer;
+    private handleDisconnect;
+    private handleClientEvent;
+    private forwardEvent;
+}

package/dist/server.js

@@ -0,0 +1,109 @@
+import { EventEmitter } from 'events';
+import net from 'net';
+import { startDiscovery } from './discovery.js';
+import { SLIMPROTO_PORT } from './constants.js';
+import { EventType } from './models.js';
+import { getHostname, getIp } from './util.js';
+import { SlimClient } from './client.js';
+export class SlimServer extends EventEmitter {
+    options;
+    server;
+    discovery;
+    playersMap = new Map();
+    subscriptions = [];
+    constructor(options = {}) {
+        super();
+        this.options = options;
+    }
+    get players() {
+        return Array.from(this.playersMap.values());
+    }
+    getPlayer(playerId) {
+        return this.playersMap.get(playerId);
+    }
+    async start() {
+        const ipAddress = this.options.ipAddress ?? (await getIp());
+        const name = this.options.name ?? getHostname();
+        const controlPort = this.options.controlPort ?? SLIMPROTO_PORT;
+        this.server = net.createServer((socket) => this.registerPlayer(socket));
+        await new Promise((resolve, reject) => {
+            this.server?.once('error', reject);
+            this.server?.listen(controlPort, '0.0.0.0', () => resolve());
+        });
+        this.discovery = startDiscovery({
+            ipAddress,
+            controlPort,
+            cliPort: this.options.cliPort ?? null,
+            cliPortJson: this.options.cliPortJson ?? null,
+            name,
+        });
+    }
+    async stop() {
+        for (const client of this.playersMap.values()) {
+            client.disconnect();
+        }
+        this.playersMap.clear();
+        if (this.server) {
+            await new Promise((resolve) => this.server?.close(() => resolve()));
+            this.server = undefined;
+        }
+        this.discovery?.close();
+        this.discovery = undefined;
+    }
+    subscribe(cb, eventFilter, playerFilter) {
+        const eventList = eventFilter == null ? null : Array.isArray(eventFilter) ? eventFilter : [eventFilter];
+        const playerList = playerFilter == null ? null : Array.isArray(playerFilter) ? playerFilter : [playerFilter];
+        const subscription = { callback: cb, eventFilter: eventList, playerFilter: playerList };
+        this.subscriptions.push(subscription);
+        return () => {
+            const idx = this.subscriptions.indexOf(subscription);
+            if (idx >= 0)
+                this.subscriptions.splice(idx, 1);
+        };
+    }
+    registerPlayer(socket) {
+        const client = new SlimClient(socket, (player, eventType, data) => {
+            this.handleClientEvent(player, eventType, data);
+        });
+        socket.on('close', () => this.handleDisconnect(client));
+        socket.on('error', () => this.handleDisconnect(client));
+    }
+    handleDisconnect(client) {
+        if (client.playerId) {
+            this.playersMap.delete(client.playerId);
+        }
+    }
+    handleClientEvent(player, eventType, data) {
+        const playerId = player.playerId;
+        if (eventType === EventType.PLAYER_CONNECTED) {
+            const existing = this.playersMap.get(playerId);
+            if (existing && existing.connected) {
+                player.disconnect();
+                return;
+            }
+            if (existing) {
+                existing.disconnect();
+            }
+            this.playersMap.set(playerId, player);
+        }
+        if (eventType === EventType.PLAYER_DISCONNECTED) {
+            if (playerId) {
+                this.playersMap.delete(playerId);
+            }
+        }
+        this.forwardEvent(playerId, eventType, data);
+    }
+    forwardEvent(playerId, eventType, data) {
+        const event = { type: eventType, playerId, data };
+        this.emit(eventType, event);
+        for (const sub of this.subscriptions) {
+            if (sub.playerFilter && playerId && !sub.playerFilter.includes(playerId))
+                continue;
+            if (sub.eventFilter && !sub.eventFilter.includes(eventType))
+                continue;
+            Promise.resolve(sub.callback(event)).catch((err) => 
+            // eslint-disable-next-line no-console
+            console.error('Error in subscriber', err));
+        }
+    }
+}

package/dist/util.d.ts

@@ -0,0 +1,12 @@
+export declare function getIp(): Promise<string>;
+export declare function getHostname(): string;
+export declare function selectFreePort(rangeStart: number, rangeEnd: number): Promise<number>;
+export declare function parseCapabilities(heloData: Buffer): Record<string, unknown>;
+export declare function parseHeaders(respData: Buffer): Record<string, string>;
+export declare function parseStatus(respData: Buffer): {
+    version: string;
+    statusCode: number;
+    statusText: string;
+};
+export declare function lookupHost(host: string): Promise<string>;
+export declare function ipToInt(ipAddress: string): number;

package/dist/util.js

@@ -0,0 +1,98 @@
+import dgram from 'dgram';
+import dns from 'dns/promises';
+import net from 'net';
+import os from 'os';
+import { FALLBACK_CODECS } from './constants.js';
+export async function getIp() {
+    const socket = dgram.createSocket('udp4');
+    return new Promise((resolve) => {
+        socket.connect(1, '10.255.255.255', () => {
+            const address = socket.address();
+            socket.close();
+            if (typeof address === 'object') {
+                resolve(address.address);
+            }
+            else {
+                resolve('127.0.0.1');
+            }
+        });
+        socket.on('error', () => {
+            socket.close();
+            resolve('127.0.0.1');
+        });
+    });
+}
+export function getHostname() {
+    return os.hostname();
+}
+export async function selectFreePort(rangeStart, rangeEnd) {
+    const isPortInUse = (port) => new Promise((resolve) => {
+        const tester = net.createServer();
+        tester.once('error', () => resolve(true));
+        tester.once('listening', () => tester.close(() => resolve(false)));
+        tester.listen(port, '0.0.0.0');
+    });
+    for (let port = rangeStart; port < rangeEnd; port += 1) {
+        // eslint-disable-next-line no-await-in-loop
+        const inUse = await isPortInUse(port);
+        if (!inUse) {
+            return port;
+        }
+    }
+    throw new Error('No free port available');
+}
+export function parseCapabilities(heloData) {
+    const params = {};
+    try {
+        const info = heloData.subarray(36).toString();
+        const pairs = info.replace(/,/g, '&').split('&');
+        for (const pair of pairs) {
+            if (!pair)
+                continue;
+            const [key, value] = pair.split('=');
+            if (key) {
+                params[key] = value ?? '';
+            }
+        }
+        params.SupportedCodecs =
+            ['alc', 'aac', 'ogg', 'ogf', 'flc', 'aif', 'pcm', 'mp3'].filter((codec) => info.includes(codec)) ||
+                FALLBACK_CODECS;
+    }
+    catch (err) {
+        // eslint-disable-next-line no-console
+        console.error('Failed to parse capabilities', err);
+    }
+    return params;
+}
+export function parseHeaders(respData) {
+    const result = {};
+    const lines = respData.toString().split('\r\n').slice(1);
+    for (const line of lines) {
+        const [key, ...rest] = line.split(': ');
+        if (!key || rest.length === 0)
+            continue;
+        result[key.toLowerCase()] = rest.join(': ');
+    }
+    return result;
+}
+export function parseStatus(respData) {
+    const [statusLine] = respData.toString().split('\r\n');
+    if (!statusLine) {
+        return { version: 'HTTP/1.0', statusCode: 200, statusText: '' };
+    }
+    const [version, code, ...rest] = statusLine.split(' ');
+    return {
+        version,
+        statusCode: Number(code ?? 200),
+        statusText: rest.join(' '),
+    };
+}
+export async function lookupHost(host) {
+    const result = await dns.lookup(host);
+    return result.address;
+}
+export function ipToInt(ipAddress) {
+    return ipAddress
+        .split('.')
+        .reduce((acc, octet) => (acc << 8) + Number(octet), 0) >>> 0;
+}

package/dist/volume.d.ts

@@ -0,0 +1,15 @@
+export declare class SlimProtoVolume {
+    minimum: number;
+    maximum: number;
+    step: number;
+    private static readonly oldMap;
+    private readonly totalVolumeRange;
+    private readonly stepPoint;
+    private readonly stepFraction;
+    volume: number;
+    increment(): void;
+    decrement(): void;
+    oldGain(): number;
+    decibels(): number;
+    newGain(): number;
+}