@lakutata/webrtc 0.0.0-stage → 3.1.4

package/dist/esm/lib/common/crc.js

@@ -0,0 +1,118 @@
+const POLY_CRC32 = 0xedb88320;
+const POLY_CRC32C = 0x82f63b78;
+function isBufferLike(input) {
+    return typeof input !== 'string';
+}
+function generateCRCTable(polynomial) {
+    const table = new Array(256);
+    for (let n = 0; n < 256; ++n) {
+        let c = n;
+        c = c & 1 ? polynomial ^ (c >>> 1) : c >>> 1;
+        c = c & 1 ? polynomial ^ (c >>> 1) : c >>> 1;
+        c = c & 1 ? polynomial ^ (c >>> 1) : c >>> 1;
+        c = c & 1 ? polynomial ^ (c >>> 1) : c >>> 1;
+        c = c & 1 ? polynomial ^ (c >>> 1) : c >>> 1;
+        c = c & 1 ? polynomial ^ (c >>> 1) : c >>> 1;
+        c = c & 1 ? polynomial ^ (c >>> 1) : c >>> 1;
+        c = c & 1 ? polynomial ^ (c >>> 1) : c >>> 1;
+        table[n] = c;
+    }
+    return new Int32Array(table);
+}
+function generateSliceBy16Tables(table0) {
+    const table = new Int32Array(4096);
+    let c;
+    let v;
+    let n;
+    for (n = 0; n < 256; ++n)
+        table[n] = table0[n];
+    for (n = 0; n < 256; ++n) {
+        v = table0[n];
+        for (c = 256 + n; c < 4096; c += 256) {
+            v = table[c] = (v >>> 8) ^ table0[v & 0xff];
+        }
+    }
+    const out = [];
+    for (n = 1; n < 16; ++n) {
+        out[n - 1] = table.subarray(n * 256, n * 256 + 256);
+    }
+    return out;
+}
+function crcGenericString(value, seed, table0) {
+    let crc = seed ^ -1;
+    let i = 0;
+    const len = value.length;
+    let c;
+    let d;
+    while (i < len) {
+        c = value.charCodeAt(i++);
+        if (c < 0x80) {
+            crc = (crc >>> 8) ^ table0[(crc ^ c) & 0xff];
+        }
+        else if (c < 0x800) {
+            crc = (crc >>> 8) ^ table0[(crc ^ (192 | ((c >> 6) & 31))) & 0xff];
+            crc = (crc >>> 8) ^ table0[(crc ^ (128 | (c & 63))) & 0xff];
+        }
+        else if (c >= 0xd800 && c < 0xe000) {
+            c = (c & 1023) + 64;
+            d = value.charCodeAt(i++) & 1023;
+            crc = (crc >>> 8) ^ table0[(crc ^ (240 | ((c >> 8) & 7))) & 0xff];
+            crc = (crc >>> 8) ^ table0[(crc ^ (128 | ((c >> 2) & 63))) & 0xff];
+            crc =
+                (crc >>> 8) ^
+                    table0[(crc ^ (128 | ((d >> 6) & 15) | ((c & 3) << 4))) & 0xff];
+            crc = (crc >>> 8) ^ table0[(crc ^ (128 | (d & 63))) & 0xff];
+        }
+        else {
+            crc = (crc >>> 8) ^ table0[(crc ^ (224 | ((c >> 12) & 15))) & 0xff];
+            crc = (crc >>> 8) ^ table0[(crc ^ (128 | ((c >> 6) & 63))) & 0xff];
+            crc = (crc >>> 8) ^ table0[(crc ^ (128 | (c & 63))) & 0xff];
+        }
+    }
+    return ~crc >>> 0;
+}
+function crcBuffer(value, seed, table0, tables16) {
+    const [t1, t2, t3, t4, t5, t6, t7, t8, t9, ta, tb, tc, td, te, tf] = tables16;
+    let crc = seed ^ -1;
+    let i = 0;
+    let len = value.length - 15;
+    while (i < len) {
+        crc =
+            tf[value[i++] ^ (crc & 255)] ^
+                te[value[i++] ^ ((crc >>> 8) & 255)] ^
+                td[value[i++] ^ ((crc >>> 16) & 255)] ^
+                tc[value[i++] ^ (crc >>> 24)] ^
+                tb[value[i++]] ^
+                ta[value[i++]] ^
+                t9[value[i++]] ^
+                t8[value[i++]] ^
+                t7[value[i++]] ^
+                t6[value[i++]] ^
+                t5[value[i++]] ^
+                t4[value[i++]] ^
+                t3[value[i++]] ^
+                t2[value[i++]] ^
+                t1[value[i++]] ^
+                table0[value[i++]];
+    }
+    for (len += 15; i < len;) {
+        crc = (crc >>> 8) ^ table0[(crc ^ value[i++]) & 0xff];
+    }
+    return ~crc >>> 0;
+}
+const table32 = generateCRCTable(POLY_CRC32);
+const tables32By16 = generateSliceBy16Tables(table32);
+const table32c = generateCRCTable(POLY_CRC32C);
+const tables32cBy16 = generateSliceBy16Tables(table32c);
+export function crc32(input, seed = 0) {
+    if (isBufferLike(input)) {
+        return crcBuffer(input, seed, table32, tables32By16);
+    }
+    return crcGenericString(input, seed, table32);
+}
+export function crc32c(input, seed = 0) {
+    if (isBufferLike(input)) {
+        return crcBuffer(input, seed, table32c, tables32cBy16);
+    }
+    return crcGenericString(input, seed, table32c);
+}

package/dist/esm/lib/common/deque.js

@@ -0,0 +1,85 @@
+/**
+ * A double-ended queue on a ring buffer: adding and removing at both ends take constant time, however long it is (a
+ * JavaScript array takes time in proportion to its length to remove its first item)
+ */
+export class Deque {
+    #items = new Array(16);
+    #head = 0;
+    #size = 0;
+    /**
+     * The number of items
+     */
+    get length() {
+        return this.#size;
+    }
+    /**
+     * Adds an item at the end
+     */
+    push(item) {
+        if (this.#size === this.#items.length)
+            this.#grow();
+        this.#items[(this.#head + this.#size) & (this.#items.length - 1)] = item;
+        this.#size++;
+    }
+    /**
+     * Adds an item at the start
+     */
+    unshift(item) {
+        if (this.#size === this.#items.length)
+            this.#grow();
+        this.#head = (this.#head - 1) & (this.#items.length - 1);
+        this.#items[this.#head] = item;
+        this.#size++;
+    }
+    /**
+     * Removes the first item and returns it; undefined when empty
+     */
+    shift() {
+        if (!this.#size)
+            return undefined;
+        const item = this.#items[this.#head];
+        this.#items[this.#head] = undefined;
+        this.#head = (this.#head + 1) & (this.#items.length - 1);
+        this.#size--;
+        return item;
+    }
+    /**
+     * The item at a position from the start (a negative position counts from the end); undefined out of range
+     */
+    at(index) {
+        const position = index < 0 ? this.#size + index : index;
+        if (position < 0 || position >= this.#size)
+            return undefined;
+        return this.#items[(this.#head + position) & (this.#items.length - 1)];
+    }
+    /**
+     * The position of the first item the predicate accepts; -1 when none does
+     */
+    findIndex(predicate) {
+        for (let i = 0; i < this.#size; i++) {
+            if (predicate(this.#items[(this.#head + i) & (this.#items.length - 1)]))
+                return i;
+        }
+        return -1;
+    }
+    /**
+     * Removes every item
+     */
+    clear() {
+        this.#items = new Array(16);
+        this.#head = 0;
+        this.#size = 0;
+    }
+    *[Symbol.iterator]() {
+        for (let i = 0; i < this.#size; i++)
+            yield this.#items[(this.#head + i) & (this.#items.length - 1)];
+    }
+    //Doubles the capacity (always a power of two), the items from position 0
+    #grow() {
+        const items = new Array(this.#items.length * 2);
+        for (let i = 0; i < this.#size; i++)
+            items[i] = this.#items[(this.#head + i) & (this.#items.length - 1)];
+        this.#items = items;
+        this.#head = 0;
+    }
+}

package/dist/esm/lib/common/event.js

@@ -0,0 +1,202 @@
+/**
+ * The subscribers of an event in their order. Unsubscribing marks a subscriber removed, in constant time; the list
+ * drops the removed ones once they outnumber the others, a copy left to the iterations going on
+ */
+class Subscribers {
+    constructor() {
+        this.list = [];
+        this.size = 0;
+        this.#removed = 0;
+    }
+    #removed;
+    add(subscriber) {
+        this.list.push(subscriber);
+        this.size++;
+    }
+    /**
+     * Remove a subscriber
+     * @param subscriber
+     * @returns Whether it was there
+     */
+    remove(subscriber) {
+        if (subscriber.removed)
+            return false;
+        subscriber.removed = true;
+        this.size--;
+        if (++this.#removed > 16 && this.#removed > this.size) {
+            this.list = this.list.filter((each) => !each.removed);
+            this.#removed = 0;
+        }
+        return true;
+    }
+    /**
+     * Remove them all: the iterations going on skip the ones they have not reached
+     */
+    clear() {
+        for (const subscriber of this.list)
+            subscriber.removed = true;
+        this.list = [];
+        this.size = 0;
+        this.#removed = 0;
+    }
+}
+export class Event {
+    constructor() {
+        this.subscribers = new Subscribers();
+        this.queued = new Subscribers();
+        this.ended = false;
+        this.onerror = (_error) => { };
+        this.execute = (...args) => {
+            if (this.ended) {
+                return;
+            }
+            for (const item of this.subscribers.list) {
+                if (!item.removed)
+                    item.execute(...args);
+            }
+            //The queued subscribers run one after the other; without them, no promise is made
+            if (this.queued.size === 0)
+                return;
+            (async () => {
+                for (const item of this.queued.list) {
+                    if (!item.removed)
+                        await item.execute(...args);
+                }
+            })().catch((e) => {
+                this.onerror(e);
+            });
+        };
+        this.complete = () => {
+            if (this.ended) {
+                return;
+            }
+            for (const item of this.subscribers.list) {
+                if (item.complete && !item.removed) {
+                    item.complete();
+                }
+            }
+            this.allUnsubscribe();
+            this.ended = true;
+            if (this.onended) {
+                this.onended();
+                this.onended = undefined;
+            }
+        };
+        this.error = (e) => {
+            if (this.ended) {
+                return;
+            }
+            for (const item of this.subscribers.list) {
+                if (item.error && !item.removed) {
+                    item.error(e);
+                }
+            }
+            this.allUnsubscribe();
+        };
+        this.allUnsubscribe = () => {
+            // complete() 後の再呼び出しを許容し、close 経路での二重クリーンアップを安全にする
+            if (this.ended) {
+                return;
+            }
+            this.subscribers.clear();
+            this.queued.clear();
+            this.onsubscriberschange?.();
+        };
+        this.subscribe = (execute, complete, error) => {
+            const subscriber = { execute, complete, error };
+            const subscribers = this.subscribers;
+            subscribers.add(subscriber);
+            this.onsubscriberschange?.();
+            const unSubscribe = () => {
+                if (subscribers.remove(subscriber))
+                    this.onsubscriberschange?.();
+            };
+            const disposer = (disposer) => {
+                disposer.push(unSubscribe);
+            };
+            return { unSubscribe, disposer };
+        };
+        this.queuingSubscribe = (execute, complete, error) => {
+            if (this.ended)
+                throw new Error('event completed');
+            const subscriber = { execute, complete, error };
+            const queued = this.queued;
+            queued.add(subscriber);
+            const unSubscribe = () => {
+                queued.remove(subscriber);
+            };
+            const disposer = (disposer) => {
+                disposer.push(unSubscribe);
+            };
+            return { unSubscribe, disposer };
+        };
+        this.once = (execute, complete, error) => {
+            const off = this.subscribe((...args) => {
+                off.unSubscribe();
+                execute(...args);
+            }, complete, error);
+        };
+        this.watch = (cb, timeLimit) => new Promise((resolve, reject) => {
+            const timeout = timeLimit &&
+                setTimeout(() => {
+                    reject('Event watch timeout');
+                }, timeLimit);
+            const { unSubscribe } = this.subscribe((...args) => {
+                const done = cb(...args);
+                if (done) {
+                    if (timeout)
+                        clearTimeout(timeout);
+                    unSubscribe();
+                    resolve(args);
+                }
+            });
+        });
+        this.asPromise = (timeLimit) => new Promise((resolve, reject) => {
+            const timeout = timeLimit &&
+                setTimeout(() => {
+                    reject('Event asPromise timeout');
+                }, timeLimit);
+            this.once((...args) => {
+                if (timeout)
+                    clearTimeout(timeout);
+                resolve(args);
+            }, () => {
+                if (timeout)
+                    clearTimeout(timeout);
+                resolve([]);
+            }, (err) => {
+                if (timeout)
+                    clearTimeout(timeout);
+                reject(err);
+            });
+        });
+    }
+    pipe(e) {
+        this.subscribe((...args) => {
+            e.execute(...args);
+        });
+    }
+    get returnTrigger() {
+        const { execute, error, complete } = this;
+        return { execute, error, complete };
+    }
+    get returnListener() {
+        const { subscribe, once, asPromise } = this;
+        return { subscribe, once, asPromise };
+    }
+    get length() {
+        return this.subscribers.size;
+    }
+}
+export class EventDisposer {
+    constructor() {
+        this._disposer = [];
+    }
+    push(disposer) {
+        this._disposer.push(disposer);
+    }
+    dispose() {
+        this._disposer.forEach((d) => d());
+        this._disposer = [];
+    }
+}

package/dist/esm/lib/common/index.js

@@ -0,0 +1,11 @@
+export * from './binary.js';
+export * from './crc.js';
+export * from './number.js';
+export * from './promise.js';
+export * from './network.js';
+export * from './type.js';
+export * from './log.js';
+export * from './event.js';
+export * from './transport.js';
+export * as binaryData from './binaryData.js';
+export * from './deque.js';

package/dist/esm/lib/common/log.js

@@ -0,0 +1,55 @@
+export class WeriftError extends Error {
+    constructor(props) {
+        super(props.message);
+    }
+    toJSON() {
+        return {
+            message: this.message,
+            payload: JSON.parse(JSON.stringify(this.payload)),
+            path: this.path
+        };
+    }
+}
+let debugHandler;
+/**
+ * Told when a handler is set or removed (the worker threads of the media server and of the TURN server send their
+ * messages to the handler of the main thread while there is one)
+ */
+export const debugHandlerWatchers = new Set();
+/**
+ * Whether a handler is set
+ */
+export function hasDebugHandler() {
+    return !!debugHandler;
+}
+/**
+ * Send the debug messages of the WebRTC implementation (ICE, DTLS, SCTP, TURN), including those of the worker threads of
+ * a media server or of a TURN server, to a handler, to find out why a connection fails; they are dropped by default.
+ * @param handler The handler, or undefined to drop them again.
+ * @example
+ * ```typescript
+ * import {format} from 'node:util'
+ * import {setDebugHandler} from '@lakutata/webrtc'
+ *
+ * //The messages of ICE only
+ * setDebugHandler((namespace: string, args: unknown[]): void => {
+ *     if (namespace.startsWith('webrtc/ice')) console.debug(namespace, format(...args))
+ * })
+ * ```
+ */
+export function setDebugHandler(handler) {
+    const changed = !!debugHandler !== !!handler;
+    debugHandler = handler;
+    if (changed)
+        for (const watcher of debugHandlerWatchers)
+            watcher(!!handler);
+}
+/**
+ * The logging function of a module: it does nothing while no handler is set
+ */
+export function debug(namespace) {
+    return (...args) => {
+        if (debugHandler)
+            debugHandler(namespace, args);
+    };
+}

package/dist/esm/lib/common/network.js

@@ -0,0 +1,52 @@
+import { createSocket } from 'node:dgram';
+export const interfaceAddress = (type, interfaceAddresses) => (interfaceAddresses ? interfaceAddresses[type] : undefined);
+export async function randomPort(protocol = 'udp4', interfaceAddresses) {
+    const socket = createSocket(protocol);
+    setImmediate(() => socket.bind({
+        port: 0,
+        address: interfaceAddress(protocol, interfaceAddresses)
+    }));
+    await new Promise((r) => {
+        socket.once('error', r);
+        socket.once('listening', r);
+    });
+    const port = socket.address()?.port;
+    await new Promise((r) => socket.close(() => r()));
+    return port;
+}
+export async function randomPorts(num, protocol = 'udp4', interfaceAddresses) {
+    return Promise.all([...Array(num)].map(() => randomPort(protocol, interfaceAddresses)));
+}
+export async function findPort(min, max, protocol = 'udp4', interfaceAddresses) {
+    let port;
+    for (let i = min; i <= max; i++) {
+        const socket = createSocket(protocol);
+        setImmediate(() => socket.bind({
+            port: i,
+            address: interfaceAddress(protocol, interfaceAddresses)
+        }));
+        const err = await new Promise((r) => {
+            socket.once('error', (e) => r(e));
+            socket.once('listening', () => r());
+        });
+        if (err) {
+            await new Promise((r) => socket.close(() => r()));
+            continue;
+        }
+        port = socket.address()?.port;
+        await new Promise((r) => socket.close(() => r()));
+        if (min <= port && port <= max) {
+            break;
+        }
+    }
+    if (!port)
+        throw new Error('port not found');
+    return port;
+}
+export function normalizeFamilyNodeV18(family) {
+    if (family === 'IPv4')
+        return 4;
+    if (family === 'IPv6')
+        return 6;
+    return family;
+}

package/dist/esm/lib/common/number.js

@@ -0,0 +1,31 @@
+export function uint8Add(a, b) {
+    return (a + b) & 0xff;
+}
+export function uint16Add(a, b) {
+    return (a + b) & 0xffff;
+}
+export function uint32Add(a, b) {
+    return Number((BigInt(a) + BigInt(b)) & 0xffffffffn);
+}
+export function uint24(v) {
+    return v & 0xffffff;
+}
+/**Return a > b */
+export function uint16Gt(a, b) {
+    const halfMod = 0x8000;
+    return (a < b && b - a > halfMod) || (a > b && a - b < halfMod);
+}
+/**Return a >= b */
+export function uint16Gte(a, b) {
+    return a === b || uint16Gt(a, b);
+}
+/**Return a > b */
+export function uint32Gt(a, b) {
+    const halfMod = 0x80000000;
+    return (a < b && b - a > halfMod) || (a > b && a - b < halfMod);
+}
+/**Return a >= b */
+export function uint32Gte(a, b) {
+    return a === b || uint32Gt(a, b);
+}
+export const int = (n) => Number.parseInt(n, 10);

package/dist/esm/lib/common/promise.js

@@ -0,0 +1,64 @@
+export class PromiseQueue {
+    constructor() {
+        this.queue = [];
+        this.running = false;
+        this.push = (promise) => new Promise((r, f) => {
+            this.queue.push({ promise, done: r, failed: f });
+            if (!this.running) {
+                //run() catches the failures of the tasks
+                void this.run();
+            }
+        });
+    }
+    async run() {
+        const task = this.queue.shift();
+        if (task) {
+            this.running = true;
+            try {
+                const res = await task.promise();
+                task.done(res);
+            }
+            catch (error) {
+                task.failed(error);
+            }
+            void this.run();
+        }
+        else {
+            this.running = false;
+        }
+    }
+    cancel() {
+        this.queue = [];
+    }
+}
+/**
+ * Runs a function that may return a promise without waiting for it: a failure, thrown or rejected, goes to onError.
+ * For the callbacks of the applications and the tasks started in the background, whose failures must not become
+ * unhandled rejections
+ */
+export function runDetached(fn, onError) {
+    try {
+        const result = fn();
+        if (result instanceof Promise)
+            result.catch(onError);
+    }
+    catch (error) {
+        onError(error);
+    }
+}
+/**
+ * A function for an event or a timer: it runs fn without waiting for it, a failure going to onError
+ */
+export function detached(fn, onError) {
+    //As runDetached, without a closure for each call (an event of each packet)
+    return (...args) => {
+        try {
+            const result = fn(...args);
+            if (result instanceof Promise)
+                result.catch(onError);
+        }
+        catch (error) {
+            onError(error);
+        }
+    };
+}