@lakutata/webrtc 0.0.0-stage → 3.1.4

package/dist/cjs/lib/common/binaryData.js

@@ -0,0 +1,400 @@
+"use strict";
+/**
+ * Declarative binary data encoder / decoder.
+ *
+ * TypeScript port of the subset of `binary-data` used by werift.
+ * https://github.com/reklatsmasters/binary-data
+ * https://github.com/shinyoshiaki/binary-data
+ *
+ * MIT License
+ *
+ * Copyright (c) 2017 Dmitry Tsvettsikh
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.types = exports.BinaryWriter = exports.BinaryReader = exports.NotEnoughDataError = void 0;
+exports.encode = encode;
+exports.decode = decode;
+/** Thrown when the input does not contain enough bytes to decode. */
+class NotEnoughDataError extends Error {
+    constructor(expected, received) {
+        super(`requested ${expected} bytes but only ${received} available`);
+        this.name = 'NotEnoughDataError';
+    }
+}
+exports.NotEnoughDataError = NotEnoughDataError;
+/** Sequential reader over a single Buffer. Returned buffers share memory with the input. */
+class BinaryReader {
+    constructor(buf) {
+        this.buf = buf;
+        this.offset = 0;
+    }
+    /** The number of unread bytes. */
+    get length() {
+        return this.buf.length - this.offset;
+    }
+    /** The number of bytes consumed so far. */
+    get bytes() {
+        return this.offset;
+    }
+    readBuffer(size) {
+        this.assertSize(size);
+        const res = this.buf.subarray(this.offset, this.offset + size);
+        this.offset += size;
+        return res;
+    }
+    readUIntBE(size) {
+        this.assertSize(size);
+        const res = this.buf.readUIntBE(this.offset, size);
+        this.offset += size;
+        return res;
+    }
+    assertSize(size) {
+        if (size > this.length) {
+            throw new NotEnoughDataError(size, this.length);
+        }
+    }
+}
+exports.BinaryReader = BinaryReader;
+/** Collects written chunks and concatenates them once at the end. */
+class BinaryWriter {
+    constructor() {
+        this.chunks = [];
+        this.written = 0;
+    }
+    /** The number of bytes written so far. */
+    get bytes() {
+        return this.written;
+    }
+    writeBuffer(buf) {
+        this.chunks.push(buf);
+        this.written += buf.length;
+    }
+    writeUIntBE(value, size) {
+        const buf = Buffer.allocUnsafe(size);
+        switch (size) {
+            case 1:
+                buf.writeUInt8(value, 0);
+                break;
+            case 2:
+                buf.writeUInt16BE(value, 0);
+                break;
+            case 4:
+                buf.writeUInt32BE(value, 0);
+                break;
+            default:
+                buf.writeUIntBE(value, 0, size);
+        }
+        this.writeBuffer(buf);
+    }
+    toBuffer() {
+        return Buffer.concat(this.chunks, this.written);
+    }
+}
+exports.BinaryWriter = BinaryWriter;
+const isObject = (value) => typeof value === 'object' && value !== null;
+const isType = (value) => isObject(value) &&
+    typeof value.encode === 'function' &&
+    typeof value.decode === 'function';
+const isPlainObject = (value) => {
+    if (!isObject(value))
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+};
+const createContext = () => ({
+    node: undefined,
+    current: undefined
+});
+const cloneContext = (context) => ({
+    node: context.node,
+    current: context.current
+});
+const assertSchema = (schema, message) => {
+    if (!isPlainObject(schema)) {
+        throw new TypeError(message);
+    }
+};
+const encodeCommon = (value, typeOrSchema, writer, context) => {
+    if (isType(typeOrSchema)) {
+        typeOrSchema.encode(value, writer, context);
+    }
+    else {
+        encodeSchema(value, typeOrSchema, writer, context);
+    }
+};
+const encodeSchema = (obj, schema, writer, context) => {
+    assertSchema(schema, 'Argument `schema` should be a plain object.');
+    if (context.node === undefined) {
+        context.node = obj;
+    }
+    context.current = obj;
+    for (const key of Object.keys(schema)) {
+        const type = schema[key];
+        const value = obj[key];
+        if (isType(type)) {
+            type.encode(value, writer, context);
+        }
+        else {
+            encodeSchema(value, type, writer, context);
+            context.current = obj;
+        }
+    }
+};
+const decodeCommon = (reader, typeOrSchema, context) => {
+    if (isType(typeOrSchema)) {
+        return typeOrSchema.decode(reader, context);
+    }
+    return decodeSchema(reader, typeOrSchema, context);
+};
+const decodeSchema = (reader, schema, context) => {
+    assertSchema(schema, 'Argument #2 should be a plain object.');
+    const node = Object.create(null);
+    if (context.node === undefined) {
+        context.node = node;
+    }
+    context.current = node;
+    for (const key of Object.keys(schema)) {
+        const type = schema[key];
+        if (isType(type)) {
+            node[key] = type.decode(reader, context);
+        }
+        else {
+            node[key] = decodeSchema(reader, type, context);
+            context.current = node;
+        }
+    }
+    return node;
+};
+/** Encode `obj` using a type or schema. */
+function encode(obj, typeOrSchema) {
+    const writer = new BinaryWriter();
+    encodeCommon(obj, typeOrSchema, writer, createContext());
+    return writer.toBuffer();
+}
+/**
+ * Decode `buf` using a type or schema.
+ * Trailing bytes are ignored. Throws NotEnoughDataError when `buf` is too short.
+ */
+function decode(buf, typeOrSchema) {
+    return decodeCommon(new BinaryReader(buf), typeOrSchema, createContext());
+}
+const createUIntBE = (size) => ({
+    encode: (value, writer) => writer.writeUIntBE(value, size),
+    decode: (reader) => reader.readUIntBE(size)
+});
+const assertLengthSpec = (length) => {
+    if (typeof length !== 'number' &&
+        !isType(length) &&
+        typeof length !== 'function') {
+        throw new TypeError('Unknown type of argument #1.');
+    }
+};
+const checkLength = (required, having, name) => {
+    if (required !== having) {
+        throw new Error(`${name} required length ${required} instead of ${having}`);
+    }
+};
+const checkLengthType = (length, message) => {
+    if (typeof length !== 'number') {
+        throw new TypeError(message);
+    }
+};
+/**
+ * Buffer type.
+ * @param length fixed number of bytes, number type for size-prefixed buffers,
+ * or callback returning the number of bytes.
+ */
+function buffer(length) {
+    assertLengthSpec(length);
+    const lengthTypeError = 'Length of a buffer should be a number.';
+    return {
+        encode(buf, writer, context) {
+            if (!Buffer.isBuffer(buf)) {
+                throw new TypeError('Argument 1 should be a Buffer or a BinaryStream.');
+            }
+            if (typeof length === 'number') {
+                checkLength(length, buf.length, 'Buffer');
+            }
+            else if (isType(length)) {
+                length.encode(buf.length, writer, context);
+            }
+            else {
+                const expected = length(context);
+                checkLengthType(expected, lengthTypeError);
+                checkLength(expected, buf.length, 'Buffer');
+            }
+            writer.writeBuffer(buf);
+        },
+        decode(reader, context) {
+            let size;
+            if (typeof length === 'number') {
+                size = length;
+            }
+            else if (isType(length)) {
+                size = length.decode(reader, context);
+            }
+            else {
+                size = length(context);
+            }
+            checkLengthType(size, lengthTypeError);
+            return reader.readBuffer(size);
+        }
+    };
+}
+/**
+ * Array type.
+ * @param type type or schema of each item.
+ * @param length fixed length, number type for length-prefixed arrays, or callback.
+ * @param lengthType `count` (number of items) or `bytes` (number of bytes).
+ */
+function array(type, length, lengthType = 'count') {
+    if (!isType(type) && !isPlainObject(type)) {
+        throw new TypeError('Argument #1 should be a valid type.');
+    }
+    assertLengthSpec(length);
+    const isLengthInBytes = lengthType === 'bytes';
+    const sizeTypeError = 'Length of an array should be a number.';
+    return {
+        encode(items, writer, parent) {
+            if (!Array.isArray(items)) {
+                throw new TypeError('Argument #1 should be an Array.');
+            }
+            const context = cloneContext(parent);
+            let expectedSize;
+            if (typeof length === 'number') {
+                expectedSize = length;
+            }
+            else if (isType(length)) {
+                expectedSize = items.length;
+            }
+            else {
+                expectedSize = length(context);
+                checkLengthType(expectedSize, sizeTypeError);
+            }
+            // Encode items first so that the byte length is known for the prefix.
+            const body = new BinaryWriter();
+            for (const item of items) {
+                encodeCommon(item, type, body, context);
+            }
+            if (isLengthInBytes) {
+                if (isType(length)) {
+                    expectedSize = body.bytes;
+                }
+                checkLength(body.bytes, expectedSize, 'Argument #1');
+            }
+            else {
+                checkLength(expectedSize, items.length, 'Argument #1');
+            }
+            if (isType(length)) {
+                length.encode(expectedSize, writer, context);
+            }
+            writer.writeBuffer(body.toBuffer());
+        },
+        decode(reader, parent) {
+            const context = cloneContext(parent);
+            let expectedSize;
+            if (typeof length === 'number') {
+                expectedSize = length;
+            }
+            else if (isType(length)) {
+                expectedSize = length.decode(reader, context);
+            }
+            else {
+                expectedSize = length(context);
+            }
+            checkLengthType(expectedSize, sizeTypeError);
+            const items = [];
+            if (isLengthInBytes) {
+                const before = reader.bytes;
+                let bytes = 0;
+                while (bytes < expectedSize) {
+                    items.push(decodeCommon(reader, type, context));
+                    bytes = reader.bytes - before;
+                }
+                if (bytes > expectedSize) {
+                    throw new Error('Incorrect length of an array.');
+                }
+            }
+            else {
+                for (let i = 0; i < expectedSize; i++) {
+                    items.push(decodeCommon(reader, type, context));
+                }
+            }
+            return items;
+        }
+    };
+}
+/**
+ * String type.
+ * @param length fixed number of bytes, number type for size-prefixed strings,
+ * or callback returning the number of bytes.
+ */
+function string(length, encoding = 'ascii') {
+    if (!Buffer.isEncoding(encoding)) {
+        throw new Error('Argument #2 should be an encoding name.');
+    }
+    assertLengthSpec(length);
+    const lengthTypeError = 'Length of a buffer should be a number.';
+    return {
+        encode(value, writer, context) {
+            const buf = Buffer.from(value.toString(), encoding);
+            if (typeof length === 'number') {
+                if (buf.length !== length) {
+                    throw new Error(`Size of string should be ${length} in bytes.`);
+                }
+            }
+            else if (isType(length)) {
+                length.encode(buf.length, writer, context);
+            }
+            else {
+                const expected = length(context);
+                checkLengthType(expected, lengthTypeError);
+                checkLength(expected, buf.length, 'Buffer');
+            }
+            writer.writeBuffer(buf);
+        },
+        decode(reader, context) {
+            let size;
+            if (typeof length === 'number') {
+                size = length;
+            }
+            else if (isType(length)) {
+                size = length.decode(reader, context);
+                checkLengthType(size, 'Size of a string should be a number.');
+            }
+            else {
+                size = length(context);
+                checkLengthType(size, lengthTypeError);
+            }
+            return reader.readBuffer(size).toString(encoding);
+        }
+    };
+}
+exports.types = {
+    uint8: createUIntBE(1),
+    uint16be: createUIntBE(2),
+    uint24be: createUIntBE(3),
+    uint32be: createUIntBE(4),
+    uint48be: createUIntBE(6),
+    buffer,
+    array,
+    string
+};

package/dist/cjs/lib/common/crc.d.ts

@@ -0,0 +1,4 @@
+type Input = string | Buffer | Uint8Array;
+export declare function crc32(input: Input, seed?: number): number;
+export declare function crc32c(input: Input, seed?: number): number;
+export {};

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

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.crc32 = crc32;
+exports.crc32c = crc32c;
+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);
+function crc32(input, seed = 0) {
+    if (isBufferLike(input)) {
+        return crcBuffer(input, seed, table32, tables32By16);
+    }
+    return crcGenericString(input, seed, table32);
+}
+function crc32c(input, seed = 0) {
+    if (isBufferLike(input)) {
+        return crcBuffer(input, seed, table32c, tables32cBy16);
+    }
+    return crcGenericString(input, seed, table32c);
+}

package/dist/cjs/lib/common/deque.d.ts

@@ -0,0 +1,36 @@
+/**
+ * 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 declare class Deque<T> implements Iterable<T> {
+    #private;
+    /**
+     * The number of items
+     */
+    get length(): number;
+    /**
+     * Adds an item at the end
+     */
+    push(item: T): void;
+    /**
+     * Adds an item at the start
+     */
+    unshift(item: T): void;
+    /**
+     * Removes the first item and returns it; undefined when empty
+     */
+    shift(): T | undefined;
+    /**
+     * The item at a position from the start (a negative position counts from the end); undefined out of range
+     */
+    at(index: number): T | undefined;
+    /**
+     * The position of the first item the predicate accepts; -1 when none does
+     */
+    findIndex(predicate: (item: T) => boolean): number;
+    /**
+     * Removes every item
+     */
+    clear(): void;
+    [Symbol.iterator](): Iterator<T>;
+}

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

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Deque = void 0;
+/**
+ * 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)
+ */
+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;
+    }
+}
+exports.Deque = Deque;

package/dist/cjs/lib/common/event.d.ts

@@ -0,0 +1,48 @@
+type EventExecute<T extends any[]> = (...args: T) => void;
+type PromiseEventExecute<T extends any[]> = (...args: T) => Promise<void>;
+type EventComplete = () => void;
+type EventError = (e: any) => void;
+export declare class Event<T extends any[]> {
+    private readonly subscribers;
+    private readonly queued;
+    ended: boolean;
+    onended?: () => void;
+    onerror: (_error: any) => void;
+    onsubscriberschange?: () => void;
+    execute: (...args: T) => void;
+    complete: () => void;
+    error: (e: any) => void;
+    allUnsubscribe: () => void;
+    subscribe: (execute: EventExecute<T>, complete?: EventComplete, error?: EventError) => {
+        unSubscribe: () => void;
+        disposer: (disposer: EventDisposer) => void;
+    };
+    pipe(e: Event<T>): void;
+    queuingSubscribe: (execute: PromiseEventExecute<T>, complete?: EventComplete, error?: EventError) => {
+        unSubscribe: () => void;
+        disposer: (disposer: EventDisposer) => void;
+    };
+    once: (execute: EventExecute<T>, complete?: EventComplete, error?: EventError) => void;
+    watch: (cb: (...args: T) => boolean, timeLimit?: number) => Promise<T>;
+    asPromise: (timeLimit?: number) => Promise<T>;
+    get returnTrigger(): {
+        execute: (...args: T) => void;
+        error: (e: any) => void;
+        complete: () => void;
+    };
+    get returnListener(): {
+        subscribe: (execute: EventExecute<T>, complete?: EventComplete, error?: EventError) => {
+            unSubscribe: () => void;
+            disposer: (disposer: EventDisposer) => void;
+        };
+        once: (execute: EventExecute<T>, complete?: EventComplete, error?: EventError) => void;
+        asPromise: (timeLimit?: number) => Promise<T>;
+    };
+    get length(): number;
+}
+export declare class EventDisposer {
+    private _disposer;
+    push(disposer: () => void): void;
+    dispose(): void;
+}
+export {};