@ceeblue/web-utils 1.0.0

package/dist/web-utils.js

@@ -0,0 +1,1482 @@
+/**
+ * Copyright 2023 Ceeblue B.V.
+ * This file is part of https://github.com/CeeblueTV/web-utils which is released under GNU Affero General Public License.
+ * See file LICENSE or go to https://spdx.org/licenses/AGPL-3.0-or-later.html for full license details.
+ */
+/**
+ * BinaryReader allows to read binary data
+ */
+class BinaryReader {
+    constructor(data) {
+        this._data =
+            'buffer' in data ? new Uint8Array(data.buffer, data.byteOffset, data.byteLength) : new Uint8Array(data);
+        this._size = this._data.byteLength;
+        this._position = 0;
+        this._view = new DataView(this._data.buffer, this._data.byteOffset, this._size);
+    }
+    data() {
+        return this._data;
+    }
+    size() {
+        return this._size;
+    }
+    available() {
+        return this._size - this._position;
+    }
+    value(position = this._position) {
+        return this._data[position];
+    }
+    position() {
+        return this._position;
+    }
+    reset(position = 0) {
+        this._position = position > this._size ? this._size : position;
+    }
+    shrink(available) {
+        const rest = this._size - this._position;
+        if (available > rest) {
+            return rest;
+        }
+        this._size = this._position + available;
+        return available;
+    }
+    next(count = 1) {
+        const rest = this._size - this._position;
+        if (count > rest) {
+            count = rest;
+        }
+        this._position += count;
+        return count;
+    }
+    read8() {
+        return this.next(1) === 1 ? this._view.getUint8(this._position - 1) : 0;
+    }
+    read16() {
+        return this.next(2) === 2 ? this._view.getUint16(this._position - 2) : 0;
+    }
+    read24() {
+        return this.next(3) === 3
+            ? (this._view.getUint16(this._position - 3) << 8) | (this._view.getUint8(this._position - 1) & 0xff)
+            : 0;
+    }
+    read32() {
+        return this.next(4) === 4 ? this._view.getUint32(this._position - 4) : 0;
+    }
+    readFloat() {
+        return this.next(4) === 4 ? this._view.getFloat32(this._position - 4) : 0;
+    }
+    readDouble() {
+        return this.next(8) === 8 ? this._view.getFloat64(this._position - 8) : 0;
+    }
+    read7Bit(bytes = 5) {
+        if (bytes > 5) {
+            throw Error("BinaryReader in JS can't decode more than 32 usefull bits");
+        }
+        if (!(bytes > 0)) {
+            // negation to catch NaN value
+            throw Error('Have to indicate a positive number of bytes to decode');
+        }
+        let result = 0;
+        let byte;
+        do {
+            byte = this.read8();
+            if (!--bytes) {
+                return ((result << 8) | byte) >>> 0; // Use all 8 bits from the 5th byte
+            }
+            result = (result << 7) | (byte & 0x7f);
+        } while (byte & 0x80);
+        return result;
+    }
+    readString() {
+        return String.fromCharCode(...this.read(this.read7Bit()));
+    }
+    readHex(size) {
+        let hex = '';
+        while (size--) {
+            hex += ('0' + this.read8().toString(16)).slice(-2);
+        }
+        return hex;
+    }
+    /**
+     * Read bytes, to convert bytes to string use String.fromCharCode(...reader.read(size))
+     * @param {UInt32} size
+     */
+    read(size = this.available()) {
+        if (this.available() < size) {
+            return new Uint8Array(size); // default value = empty bytearray!
+        }
+        const value = this._data.subarray(this._position, this._position + size);
+        this._position += size;
+        return value;
+    }
+}/**
+ * Copyright 2023 Ceeblue B.V.
+ * This file is part of https://github.com/CeeblueTV/web-utils which is released under GNU Affero General Public License.
+ * See file LICENSE or go to https://spdx.org/licenses/AGPL-3.0-or-later.html for full license details.
+ */
+/**
+ * BinaryWriter allows to write data in its binary form
+ */
+class BinaryWriter {
+    get view() {
+        if (!this._view) {
+            this._view = new DataView(this._data.buffer, this._data.byteOffset, this._data.byteLength);
+        }
+        return this._view;
+    }
+    get capacity() {
+        return this._data.byteLength;
+    }
+    constructor(dataOrSize = 64, offset = 0, length) {
+        if (typeof dataOrSize == 'number') {
+            // allocate new buffer
+            this._data = new Uint8Array(dataOrSize);
+            this._size = 0;
+        }
+        else if ('buffer' in dataOrSize) {
+            // append to existing data!
+            this._data = new Uint8Array(dataOrSize.buffer, dataOrSize.byteOffset, dataOrSize.byteLength);
+            this._size = dataOrSize.byteLength;
+        }
+        else {
+            // overrides data
+            this._isConst = true; // better than boolean for memory usage
+            if (length == null) {
+                // /!\ Safari does not support undefined length, so we need to use byteLength instead
+                length = dataOrSize.byteLength;
+            }
+            this._data = new Uint8Array(dataOrSize, offset, length);
+            this._size = 0;
+        }
+    }
+    data() {
+        return new Uint8Array(this._data.buffer, this._data.byteOffset, this._size);
+    }
+    size() {
+        return this._size || 0;
+    }
+    next(count = 1) {
+        return this.reserve((this._size += count));
+    }
+    clear(size = 0) {
+        return this.reserve((this._size = size));
+    }
+    write(data) {
+        this.reserve(this._size + data.length);
+        if (typeof data === 'string') {
+            // beware here support just the 255 first bytes (compatible Latin-1)
+            for (let i = 0; i < data.length; ++i) {
+                const value = data.charCodeAt(i);
+                this._data[this._size++] = value > 255 ? 32 : value;
+            }
+            return this;
+        }
+        this._data.set(data, this._size);
+        this._size += data.length;
+        return this;
+    }
+    write8(value) {
+        if (value > 0xff) {
+            // cast to 8bits range
+            value = 0xff;
+        }
+        this.reserve(this._size + 1);
+        this._data[this._size++] = value;
+        return this;
+    }
+    write16(value) {
+        if (value > 0xffff) {
+            // cast to 16bits range
+            value = 0xffff;
+        }
+        this.reserve(this._size + 2);
+        this.view.setUint16(this._size, value);
+        this._size += 2;
+        return this;
+    }
+    write24(value) {
+        if (value > 0xffffff) {
+            // cast to 24bits range
+            value = 0xffffff;
+        }
+        this.reserve(this._size + 3);
+        this.view.setUint16(this._size, value >> 8);
+        this.view.setUint8((this._size += 2), value & 0xff);
+        ++this._size;
+        return this;
+    }
+    write32(value) {
+        if (value > 0xffffffff) {
+            // cast to 32bits range
+            value = 0xffffffff;
+        }
+        this.reserve(this._size + 4);
+        this.view.setUint32(this._size, value);
+        this._size += 4;
+        return this;
+    }
+    writeFloat(value) {
+        this.reserve(this._size + 4);
+        this.view.setFloat32(this._size, value);
+        this._size += 4;
+        return this;
+    }
+    writeDouble(value) {
+        this.reserve(this._size + 8);
+        this.view.setFloat64(this._size, value);
+        this._size += 8;
+        return this;
+    }
+    write7Bit(value, bytes = 5) {
+        if (bytes > 5) {
+            throw Error("BinaryWriter in JS can't encode more than 32 usefull bits");
+        }
+        if (!(bytes > 0)) {
+            // negation to catch NaN value
+            throw Error('Have to indicate a positive number of bytes to encode');
+        }
+        let bits = --bytes * 7;
+        const front = value > 0xffffffff ? 0x100 : value >>> bits;
+        if (front) {
+            ++bits;
+            if (front > 0xff) {
+                value = 0xffffffff;
+            }
+        }
+        else {
+            while ((bits -= 7) && !(value >>> bits)) {
+                continue;
+            }
+        }
+        while (bits > 1) {
+            this.write8(0x80 | ((value >>> bits) & 0xff));
+            bits -= 7;
+        }
+        return this.write8(value & (bits ? 0xff : 0x7f));
+    }
+    writeString(value) {
+        return this.write7Bit(value.length).write(value);
+    }
+    writeHex(value) {
+        for (let i = 0; i < value.length; i += 2) {
+            this.write8(parseInt(value.substring(i, i + 2), 16));
+        }
+        return this;
+    }
+    reserve(size) {
+        if (!this._data) {
+            throw new Error('buffer not writable');
+        }
+        if (size <= this._data.byteLength) {
+            return this;
+        }
+        if (this._isConst) {
+            throw new Error('writing exceeds maximum ' + this._data.byteLength + ' bytes limit');
+        }
+        --size;
+        size |= size >> 1;
+        size |= size >> 2;
+        size |= size >> 4;
+        size |= size >> 8;
+        size |= size >> 16;
+        ++size;
+        const data = new Uint8Array(size);
+        data.set(this._data); // copy old buffer!
+        this._data = data;
+        this._view = undefined; // release view
+        return this;
+    }
+}/**
+ * Copyright 2023 Ceeblue B.V.
+ * This file is part of https://github.com/CeeblueTV/web-utils which is released under GNU Affero General Public License.
+ * See file LICENSE or go to https://spdx.org/licenses/AGPL-3.0-or-later.html for full license details.
+ */
+class BitReader {
+    constructor(data) {
+        if ('buffer' in data) {
+            this._data = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+        }
+        else {
+            this._data = new Uint8Array(data);
+        }
+        this._size = this._data.byteLength;
+        this._position = 0;
+        this._bit = 0;
+    }
+    data() {
+        return this._data;
+    }
+    size() {
+        return this._size;
+    }
+    available() {
+        return (this._size - this._position) * 8 - this._bit;
+    }
+    next(count = 1) {
+        let gotten = 0;
+        while (this._position !== this._size && count--) {
+            ++gotten;
+            if (++this._bit === 8) {
+                this._bit = 0;
+                ++this._position;
+            }
+        }
+        return gotten;
+    }
+    read(count = 1) {
+        let result = 0;
+        while (this._position !== this._size && count--) {
+            result <<= 1;
+            if (this._data[this._position] & (0x80 >> this._bit++)) {
+                result |= 1;
+            }
+            if (this._bit === 8) {
+                this._bit = 0;
+                ++this._position;
+            }
+        }
+        return result;
+    }
+    read8() {
+        return this.read(8);
+    }
+    read16() {
+        return this.read(16);
+    }
+    read24() {
+        return this.read(24);
+    }
+    read32() {
+        return this.read(32);
+    }
+}/**
+ * Copyright 2023 Ceeblue B.V.
+ * This file is part of https://github.com/CeeblueTV/web-utils which is released under GNU Affero General Public License.
+ * See file LICENSE or go to https://spdx.org/licenses/AGPL-3.0-or-later.html for full license details.
+ */
+/**
+ * Help class to manipulate and parse a net address. The Address can be only the domain field,
+ * or a URL format with protocol and path part `(http://)domain(:port/path)`
+ * @example
+ * const address = new Address('nl-ams-42.live.ceeblue.tv:80');
+ * console.log(address.domain) // 'nl-ams-42.live.ceeblue.tv'
+ * console.log(address.port) // '80'
+ * console.log(address) // 'nl-ams-42.live.ceeblue.tv:80'
+ */
+class NetAddress {
+    /**
+     * Static help function to build an end point from an address `(proto://)domain(:port/path)`
+     *
+     * Mainly it fix the protocol, in addition if:
+     *  - the address passed is securized (TLS) and protocol is not => it tries to fix protocol to get its securize version
+     *  - the address passed is non securized and protocol is (TLS) => it tries to fix protocol to get its unsecurized version
+     * @param protocol protocol to set in the end point returned
+     * @param address string address to fix with protocol as indicated
+     * @returns the end point built
+     * @example
+     * console.log(NetAddress.fixProtocol('ws','http://domain/path')) // 'ws://domain/path'
+     * console.log(NetAddress.fixProtocol('ws','https://domain/path')) // 'wss://domain/path'
+     * console.log(NetAddress.fixProtocol('wss','http://domain/path')) // 'ws://domain/path'
+     */
+    static fixProtocol(protocol, address) {
+        const found = address.indexOf('://');
+        // isolate protocol is present in address
+        if (found >= 0) {
+            // In this case replace by protocol in keeping SSL like given in address
+            if (found > 2 && address.charAt(found - 1).toLowerCase() === 's') {
+                // SSL!
+                if (protocol.length <= 2 || !protocol.endsWith('s')) {
+                    protocol += 's'; // Add SSL
+                }
+            }
+            else {
+                // Not SSL!
+                if (protocol.length > 2 && protocol.endsWith('s')) {
+                    protocol = protocol.slice(0, -1); // Remove SSL
+                }
+            }
+            // Build host!
+            address = address.substring(found + 3);
+        }
+        return protocol + '://' + address;
+    }
+    /**
+     * The domain part from address `(http://)domain(:port/path)`
+     */
+    get domain() {
+        return this._domain;
+    }
+    /**
+     * The port part from address `(http://)domain(:port/path)`, or defaultPort if passed in NetAddress constructor
+     */
+    get port() {
+        return this._port;
+    }
+    /**
+     * @returns the string address as passed in the constructor
+     */
+    toString() {
+        return this._address;
+    }
+    /**
+     * @returns the string address as passed in the constructor
+     * @override
+     */
+    valueOf() {
+        return this._address;
+    }
+    /**
+     * Build a NetAddress object and parse address
+     * @param address string address to parse, accept an url format with protocol and path `(http://)domain(:port/path)`
+     * @param defaultPort set a default port to use if there is no port in the string address parsed
+     */
+    constructor(address, defaultPort) {
+        this._address = address;
+        // Remove Protocol
+        let pos = address.indexOf('/');
+        if (pos >= 0) {
+            // Remove ://
+            if (address.charCodeAt(pos + 1) === 47) {
+                // has //
+                if (pos > 0) {
+                    if (address.charCodeAt(pos - 1) === 58) {
+                        // has ://
+                        address = address.substring(pos + 2);
+                    } //  something else #//
+                }
+                else {
+                    // otherwise starts by //
+                    address = address.substring(2);
+                }
+            }
+            else if (!pos) {
+                // starts by /, remove it
+                address = address.substring(1);
+            } // else something else #/
+        }
+        this._domain = address;
+        this._port = defaultPort;
+        // Parse Port
+        pos = address.lastIndexOf(':');
+        if (pos >= 0) {
+            const port = parseInt(address.substring(pos + 1));
+            if (port && port <= 0xffff) {
+                this._port = port;
+                this._domain = address.substring(0, pos);
+            }
+        }
+        else {
+            // Remove Path!
+            pos = address.indexOf('/');
+            if (pos >= 0) {
+                this._domain = address.substring(0, pos);
+            }
+        }
+    }
+}/**
+ * Copyright 2023 Ceeblue B.V.
+ * This file is part of https://github.com/CeeblueTV/web-utils which is released under GNU Affero General Public License.
+ * See file LICENSE or go to https://spdx.org/licenses/AGPL-3.0-or-later.html for full license details.
+ */
+/**
+ * Type of connection
+ */
+var Type;
+(function (Type) {
+    Type["HESP"] = "hesp";
+    Type["WEBRTS"] = "webrts";
+    Type["WEBRTC"] = "webrtc";
+    Type["META"] = "meta";
+    Type["DATA"] = "data";
+})(Type || (Type = {}));
+/**
+ * Some connection utility functions
+ */
+/**
+ * Build an URL from {@link Type | type} and {@link Params | params}
+ * @param type Type of the connection wanted
+ * @param params Connection parameters
+ * @param protocol Optional parameter to choose the prefered protocol to connect
+ * @returns The URL of connection
+ */
+function buildURL(type, params, protocol = 'wss') {
+    const url = new URL(NetAddress.fixProtocol(protocol, params.host));
+    if (url.pathname.length <= 1) {
+        // build ceeblue path!
+        switch (type) {
+            case Type.HESP:
+                url.pathname = '/hesp/' + params.streamName + '/index.json';
+                break;
+            case Type.WEBRTC:
+                url.pathname = '/webrtc/' + params.streamName;
+                break;
+            case Type.WEBRTS:
+                url.pathname = '/webrts/' + params.streamName;
+                break;
+            case Type.META:
+                url.pathname = '/json_' + params.streamName + '.js';
+                break;
+            case Type.DATA:
+                url.pathname = '/' + params.streamName + '.json';
+                break;
+            default:
+                console.warn('Unknown url type ' + type);
+                break;
+        }
+    } // Host has already a path! keep it unchanged, it's user intentionnal (used with some other WHIP/WHEP server?)
+    if (params.accessToken) {
+        url.searchParams.set('id', params.accessToken);
+    }
+    for (const key in params.query) {
+        url.searchParams.set(key, params.query[key]);
+    }
+    return url;
+}var Connect=/*#__PURE__*/Object.freeze({__proto__:null,get Type(){return Type},buildURL:buildURL});/**
+ * Copyright 2023 Ceeblue B.V.
+ * This file is part of https://github.com/CeeblueTV/web-utils which is released under GNU Affero General Public License.
+ * See file LICENSE or go to https://spdx.org/licenses/AGPL-3.0-or-later.html for full license details.
+ */
+/**
+ * A advanced EventEmitter which allows to declare event as natural function in the inheriting children class,
+ * function must start by `on` prefix to be recognized as an event.
+ * The function can define a behavior by default, and user can choose to redefine this behavior,
+ * or add an additionnal subscription for this event.
+ * In addition you can unsubscribe to multiple events with an `AbortController`
+ * @example
+ * class Logger extends EventEmitter {
+ *    onLog(log:string) { console.log(log); } // behavior by default
+ *
+ *    test() {
+ *       // raise event onLog
+ *       this.onLog('test');
+ *    }
+ * }
+ *
+ * const logger = new Logger();
+ * logger.test(); // displays a log 'test'
+ *
+ * // redefine default behavior to display nothing
+ * logger.onLog = () => {}
+ * logger.test(); // displays nothing
+ *
+ * // add an additionnal subscription
+ * logger.on('log', console.log);
+ * logger.test(); // displays a log 'test'
+ *
+ * // remove the additionnal subscription
+ * logger.off('log', console.log);
+ * logger.test(); // displays nothing
+ *
+ * // add two additionnal subscriptions with a AbortController
+ * const controller = new AbortController();
+ * logger.on('log', log => console.log(log), controller);
+ * logger.on('log', log => console.error(log), controller);
+ * logger.test(); // displays a log 'test' + an error 'test'
+ *
+ * // Unsubscribe all the subscription with the AbortController
+ * controller.abort();
+ * logger.test(); // displays nothing
+ */
+class EventEmitter {
+    /**
+     * Build our EventEmitter, usually call from children class
+     */
+    constructor() {
+        this._events = new Map();
+        // Fill events with events as defined!
+        let proto = Object.getPrototypeOf(this);
+        while (proto && proto !== Object.prototype) {
+            for (const name of Object.getOwnPropertyNames(proto)) {
+                if (name.length < 3 || !name.startsWith('on')) {
+                    continue;
+                }
+                if (proto[name] instanceof Function) {
+                    const events = new Set();
+                    this._events.set(name.substring(2).toLowerCase(), events);
+                    let defaultEvent = proto[name];
+                    Object.defineProperties(this, {
+                        [name]: {
+                            get: () => (...args) => {
+                                // Call default event if not null (can happen in JS usage)
+                                if (defaultEvent) {
+                                    defaultEvent.call(this, ...args);
+                                }
+                                // Call subscribers
+                                for (const event of events) {
+                                    event(...args);
+                                }
+                            },
+                            set: (value) => {
+                                // Assign a default behavior!
+                                defaultEvent = value;
+                            }
+                        }
+                    });
+                }
+            }
+            proto = Object.getPrototypeOf(proto);
+        }
+    }
+    /**
+     * Event subscription
+     * @param name Name of event without the `on` prefix (ex: `log` to `onLog` event declared)
+     * @param event Subscriber Function
+     * @param abort Optional `AbortController` to stop this or multiple subscriptions in same time
+     */
+    on(name, event, abort) {
+        if (!event) {
+            throw Error('event to subscribe cannot be null');
+        }
+        const events = this._event(name);
+        events.add(event);
+        if (abort) {
+            abort.signal.addEventListener('abort', () => {
+                events.delete(event);
+            });
+        }
+    }
+    /**
+     * Event subscription only one time, once time fired it's automatically unsubscribe
+     * @param name Name of event without the `on` prefix (ex: `log` to `onLog` event declared)
+     * @param event Subscriber Function
+     * @param abort Optional `AbortController` to stop this or multiple subscriptions in same time
+     */
+    once(name, event, abort) {
+        if (!event) {
+            throw Error('event to subscribe cannot be null');
+        }
+        const events = this._event(name);
+        events.add(() => {
+            events.delete(event); // delete from events
+            event(); // execute event
+        });
+        if (abort) {
+            abort.signal.addEventListener('abort', () => {
+                events.delete(event);
+            });
+        }
+    }
+    /**
+     * Event unsubscription
+     * @param name Name of event without the 'on' prefix (ex: 'log' to 'onLog' event declared)
+     * @param event Unsubscriber Function, must be the one passed to {@link on} or {@link once} subscription methods
+     */
+    off(name, event) {
+        if (!event) {
+            throw Error('event to unsubscribe cannot be null');
+        }
+        this._event(name).delete(event);
+    }
+    _event(name) {
+        const events = this._events.get(name.toLowerCase());
+        if (!events) {
+            throw Error('No event on' + name + ' on class ' + this.constructor.name);
+        }
+        return events;
+    }
+}/**
+ * Copyright 2023 Ceeblue B.V.
+ * This file is part of https://github.com/CeeblueTV/web-utils which is released under GNU Affero General Public License.
+ * See file LICENSE or go to https://spdx.org/licenses/AGPL-3.0-or-later.html for full license details.
+ */
+/**
+ * Queue typed similar to a {@link https://en.cppreference.com/w/cpp/container/queue | std::queue<Type>} with possibility to limit the capacity like a FIFO
+ * @example
+ * const queue = new Queue<number>(2);
+ * queue.push(1); // [1]
+ * queue.push(2); // [1,2]
+ * queue.push(3); // [2,3] 1 has been removed to respect 2 capacity
+ */
+class Queue {
+    /**
+     * Number of element in the queue
+     */
+    get size() {
+        return this._queue.length;
+    }
+    /**
+     * Maximum capacity for the queue, if not set queue has unlimited capacity
+     */
+    get capacity() {
+        return this._capacity;
+    }
+    /**
+     * Set a maximum capacity for the queue,
+     * if you push new value exceding this capacity the firsts are removed (FIFO)
+     * if set to undefined the queue is unlimited
+     */
+    set capacity(value) {
+        this._capacity = value;
+        if (value != null && this._queue.length > value) {
+            this._queue.splice(0, this._queue.length - value);
+        }
+    }
+    /**
+     * The front element
+     */
+    get front() {
+        return this._queue[0];
+    }
+    /**
+     * The back element
+     */
+    get back() {
+        return this._queue[this._queue.length - 1];
+    }
+    /**
+     * Iterator though queue's elements
+     */
+    [Symbol.iterator]() {
+        return this._queue[Symbol.iterator]();
+    }
+    /**
+     * Instanciate a new queue object with the type passed as template
+     * @param capacity if set it limits the size of the queue, any exceding element pops the first element pushed (FIFO)
+     */
+    constructor(capacity) {
+        this._capacity = capacity;
+        this._queue = new Array();
+    }
+    /**
+     * Push a new element in the queue
+     * @param value value of the element
+     * @returns this
+     */
+    push(value) {
+        if (this._capacity != null && this._queue.push(value) > this._capacity) {
+            this.pop();
+        }
+        return this;
+    }
+    /**
+     * Pop the first element from the queue
+     * @returns The first element removed
+     */
+    pop() {
+        return this._queue.shift();
+    }
+    /**
+     * Clear all the elements, queue becomes empty
+     * @returns this
+     */
+    clear() {
+        this._queue.length = 0;
+        return this;
+    }
+}/**
+ * Copyright 2023 Ceeblue B.V.
+ * This file is part of https://github.com/CeeblueTV/web-utils which is released under GNU Affero General Public License.
+ * See file LICENSE or go to https://spdx.org/licenses/AGPL-3.0-or-later.html for full license details.
+ */
+/**
+ * A collection of number Queue<number> with the following efficient mathematic computation:
+ * - minimum value in the collection
+ * - maximum value in the collection
+ * - average value of the collection
+ */
+class Numbers extends Queue {
+    /**
+     * minimum value in the collection, or 0 if colleciton is empty
+     */
+    get minimum() {
+        return this._min;
+    }
+    /**
+     * maximum value in the collection, or 0 if colleciton is empty
+     */
+    get maximum() {
+        return this._max;
+    }
+    /**
+     * average value of the collection, or 0 if collection if empty
+     */
+    get average() {
+        if (this._average == null) {
+            this._average = this.size ? this._sum / this.size : 0;
+        }
+        return this._average;
+    }
+    /**
+     * Instantiate the collection of the number
+     * @param capacity if set it limits the number of values stored, any exceding number pops the first number pushed (FIFO)
+     */
+    constructor(capacity) {
+        super(capacity);
+        this._sum = 0;
+        this._min = 0;
+        this._max = 0;
+    }
+    /**
+     * Push a value to the back to the collection
+     * @param value number to add
+     * @returns this
+     */
+    push(value) {
+        if (value > this._max) {
+            this._max = value;
+        }
+        else if (value < this._min) {
+            this._min = value;
+        }
+        this._average = undefined;
+        this._sum += value;
+        super.push(value);
+        return this;
+    }
+    /**
+     * Pop the front number from the collection
+     * @returns the front number removed
+     */
+    pop() {
+        const front = super.pop();
+        if (front === this._max) {
+            this._max = Math.max(0, ...this);
+        }
+        else if (front === this._min) {
+            this._min = Math.min(0, ...this);
+        }
+        this._average = undefined;
+        this._sum -= front || 0;
+        return front;
+    }
+    /**
+     * Clear all the numbers, collection becomes empty
+     * @returns this
+     */
+    clear() {
+        this._min = this._max = this._sum = 0;
+        super.clear();
+        return this;
+    }
+}/**
+ * Copyright 2023 Ceeblue B.V.
+ * This file is part of https://github.com/CeeblueTV/web-utils which is released under GNU Affero General Public License.
+ * See file LICENSE or go to https://spdx.org/licenses/AGPL-3.0-or-later.html for full license details.
+ */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * Toolkit to deal with Session Description Protocol (SDP),
+ * mainly to tranform a SDP string Offer/Answer to a manipulable JS object representation
+ * @example
+ * const peerConnection = new RTCPeerConnection();
+ * peerConnection.createOffer()
+ * .then( offer =>
+ *    // Change offer.sdp string to a JS manipulable object
+ *    const sdp = SDP.fromString(offer.sdp || '');
+ *    // Change a property of SDP
+ *    sdp.v = 2; // change SDP version
+ *    // Reserialize to the legal SDP string format
+ *    offer.sdp = SDP.toString(sdp);
+ *    // Set SDP offer to peerConnection
+ *    peerConnection.setLocalDescription(offer);
+ * )
+ */
+const SDP = {
+    /**
+     * Unserialize SDP string to a manipulable JS object representation
+     * It's an object with:
+     *  - root SDP properties
+     *  - media description iterable
+     * @param lines SDP string reprensentation
+     * @returns SDP object representation, iterable through media description
+     * @example
+     * [
+     *    group: "DUNBLE 0 1",
+     *    o: "- 1699450751193623 0 IN IP4 0.0.0.0",
+     *    s: "-",
+     *    t: "0 0",
+     *    v: "0",
+     *    ice-lite: "",
+     *    length: 2,
+     *    {
+     *       m: "audio 9 UDP/TLS/RTP/SAVPF 111",
+     *       c: "IN IP4 0.0.0.0",
+     *       rtcp: "9",
+     *       sendonly: "",
+     *       setup: "passive",
+     *       fingerprint: "sha-256 51:36:ED:78:A4:9F:25:8C:39:9A:0E:A0:B4:9B:6E:04:37:FF:AD:96:93:71:43:88:2C:0B:0F:AB:6F:9A:52:B8",
+     *       ice-ufrag: "fa37",
+     *       ice-pwd: "JncCHryDsbzayy4cBWDxS2",
+     *       rtcp-mux: "",
+     *       rtcp-rsize: "",
+     *       rtpmap: "111 opus/48000/2",
+     *       rtcp-fb: "111 nack",
+     *       id: "0",
+     *       fmtp: "111 minptime=10;useinbandfec=1",
+     *       candidate: "1 1 udp 2130706431 89.105.221.108 56643 typ host",
+     *       end-of-candidates: ""
+     *    },
+     *    {
+     *       m: "video 9 UDP/TLS/RTP/SAVPF 106",
+     *       c: "IN IP4 0.0.0.0",
+     *       rtcp: "9",
+     *       sendonly: "",
+     *       setup: "passive",
+     *       fingerprint: "sha-256 51:36:ED:78:A4:9F:25:8C:39:9A:0E:A0:B4:9B:6E:04:37:FF:AD:96:93:71:43:88:2C:0B:0F:AB:6F:9A:52:B8",
+     *       ice-ufrag: "fa37",
+     *       ice-pwd: "JncCHryDsbzayy4cBWDxS2",
+     *       rtcp-mux: "",
+     *       rtcp-rsize: "",
+     *       rtpmap: "106 H264/90000",
+     *       rtcp-fb: [
+     *          "106 nack",
+     *          "106 goog-remb"
+     *       ],
+     *       mid: "1",
+     *       fmtp: "106 profile-level-id=42e01f;level-asymmetry-allowed=1;packetization-mode=1",
+     *       candidate: "1 1 udp 2130706431 89.105.221.108 56643 typ host",
+     *       end-of-candidates: ""
+     *    }
+     * ]
+     */
+    fromString(lines) {
+        if (Array.isArray(lines)) {
+            return lines; // already converted
+        }
+        const sdp = new Array();
+        let media = sdp;
+        let fingerprint;
+        for (let line of lines.toString().split('\n')) {
+            line = line.trim();
+            if (!line) {
+                continue;
+            }
+            let key = line[0];
+            const value = line.substring(line.indexOf('=') + 1).trim();
+            switch (key.toLowerCase()) {
+                case 'a': {
+                    if (!value) {
+                        continue;
+                    } // empty attribute!
+                    key = this.addAttribute(media, value);
+                    // save fingerprint to repeat it in medias
+                    if (sdp === media && key.toLowerCase() === 'fingerprint') {
+                        fingerprint = media.fingerprint;
+                    }
+                    break;
+                }
+                case 'm':
+                    if (sdp.length && fingerprint && !sdp[sdp.length - 1].fingerprint) {
+                        media.fingerprint = fingerprint;
+                    }
+                    sdp.push((media = { m: value }));
+                    break;
+                default:
+                    media[key] = value;
+            }
+        }
+        if (sdp.length && fingerprint && !sdp[sdp.length - 1].fingerprint) {
+            media.fingerprint = fingerprint;
+        }
+        return sdp;
+    },
+    /**
+     * Serialize SDP JS object to a SDP string legal representation
+     * @param sdp SDP object reprensetation
+     * @returns SDP string reprensentation
+     */
+    toString(sdp) {
+        if (typeof sdp === 'string') {
+            return sdp; // already converted
+        }
+        const medias = [];
+        // https://www.cl.cam.ac.uk/~jac22/books/mm/book/node182.html
+        let lines = 'v' in sdp ? 'v=' + sdp.v + '\n' : '';
+        if ('o' in sdp) {
+            lines += 'o=' + sdp.o + '\n';
+        }
+        if ('s' in sdp) {
+            lines += 's=' + sdp.s + '\n';
+        }
+        const obj = sdp;
+        for (const key of Object.keys(sdp)) {
+            if (key === 'v' || key === 'o' || key === 's') {
+                continue;
+            }
+            const value = obj[key];
+            if (value == null) {
+                continue;
+            } // ignore this key/value
+            const index = parseInt(key);
+            if (!isNaN(index)) {
+                // Is a number! Media object!
+                medias[index] = value;
+                continue;
+            }
+            const count = (Array.isArray(value) && value.length) || 1; // value can be numeric!
+            for (let i = 0; i < count; ++i) {
+                const line = Array.isArray(value) && value.length ? value[i] : value;
+                if (key.length > 1) {
+                    // when key is superior to 1 letter it's a attribute!
+                    lines += 'a=' + key;
+                    if (line) {
+                        lines += ':';
+                    }
+                }
+                else {
+                    lines += key + '=';
+                }
+                lines += line + '\n';
+            }
+        }
+        for (const media of medias) {
+            lines += this.toString(media);
+        }
+        return lines;
+    },
+    /**
+     * While set a property to a SDP object representation is possible directly,
+     * we could prefer add a new property without overload a possible already existing value.
+     * This function allows to add a property to our SDP representation:
+     *  - if the key's attribute doesn't exists yet it adds it like a simple JS property sdp[key] = value
+     *  - if the key's attribute exists already it morphs the value to a Array and push it inside
+     * @param sdp the SDP object representation on which added the attribute
+     * @param attribute the string attribut in a format "key:value" or just "key" to add an attribute without value
+     * @returns the key part of the attribute added (or if value is empty it returns the same attribute as passed in argument)
+     */
+    addAttribute(sdp, attribute) {
+        var _a;
+        const a = SDP.parseAttribute(attribute);
+        const value = (_a = a.value) !== null && _a !== void 0 ? _a : ''; // to allow to test if key exists even without value with if(sdp.key != null)
+        const obj = sdp;
+        const oldValue = obj[a.key];
+        if (!oldValue) {
+            obj[a.key] = value;
+        }
+        else if (Array.isArray(oldValue)) {
+            oldValue.push(value);
+        }
+        else if (value !== oldValue) {
+            obj[a.key] = [oldValue, value];
+        }
+        return a.key;
+    },
+    /**
+     * While it's possible to delete a attribute manually on the SDP object representation with a delete sdp.key,
+     * we could prefer remove only a value in a sdp.key array containing multiple values.
+     * Like opposite to addAttribute this method allows to remove an unique attribute value.
+     * @param sdp the SDP object representation on which removed the attribute
+     * @param attribute the string attribut in a format "key:value" or just "key" to remove the whole attribute and all its values
+     * @returns the key part of the attribute removed (or if value is empty it returns the same attribute as passed in argument)
+     */
+    removeAttribute(sdp, attribute) {
+        const a = SDP.parseAttribute(attribute);
+        const obj = sdp;
+        if (a.value === undefined) {
+            delete obj[attribute];
+            return attribute;
+        }
+        const current = obj[attribute];
+        if (Array.isArray(a.value)) {
+            const i = current.findIndex((current) => current === a.value);
+            if (i >= 0) {
+                current.splice(i, 1);
+            }
+        }
+        else if (current === a.value) {
+            delete obj[attribute];
+        }
+        return a.key;
+    },
+    /**
+     * Parse an attribute in a format "key:value"
+     * @param attribute string attribute to parse
+     * @returns the {key, value} result, with value undefined if attribute was a "key" without value
+     */
+    parseAttribute(attribute) {
+        const found = attribute.indexOf(':');
+        return {
+            key: (found >= 0 ? attribute.substring(0, found) : attribute).trim(),
+            value: found >= 0 ? attribute.substring(found + 1).trim() : undefined
+        };
+    }
+};
+Object.freeze(SDP);/**
+ * Copyright 2023 Ceeblue B.V.
+ * This file is part of https://github.com/CeeblueTV/web-utils which is released under GNU Affero General Public License.
+ * See file LICENSE or go to https://spdx.org/licenses/AGPL-3.0-or-later.html for full license details.
+ */
+const _decoder = new TextDecoder();
+const _encoder = new TextEncoder();
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const _perf = performance; // to increase x10 now performance!
+/**
+ * Some basic utility functions
+ */
+/**
+ * Version of the library
+ */
+const VERSION = '1.0.0';
+/**
+ * An empty lambda function, pratical to disable default behavior of function or events which are not expected to be null
+ * @example
+ * console.log = Util.EMPTY_FUNCTION; // disable logs without breaking calls
+ */
+const EMPTY_FUNCTION = () => { };
+/**
+ * Efficient and high resolution timestamp in milliseconds elapsed since {@link Util.timeOrigin}
+ */
+function time() {
+    return Math.floor(_perf.now());
+}
+/**
+ * Time origin represents the time when the application has started
+ */
+function timeOrigin() {
+    return Math.floor(_perf.now() + _perf.timeOrigin);
+}
+/**
+ * Parse query and returns it in an easy-to-use Javascript object form
+ * @param urlOrQueryOrSearch string, url, or searchParams containing query. If not set it uses `location.search` to determinate query.
+ * @returns An javascript object containing each option
+ */
+function options(urlOrQueryOrSearch = typeof location === 'undefined'
+    ? undefined
+    : location) {
+    if (!urlOrQueryOrSearch) {
+        return {};
+    }
+    try {
+        const url = urlOrQueryOrSearch;
+        urlOrQueryOrSearch = new URL(url).searchParams;
+    }
+    catch (e) {
+        if (typeof urlOrQueryOrSearch == 'string') {
+            if (urlOrQueryOrSearch.startsWith('?')) {
+                urlOrQueryOrSearch = urlOrQueryOrSearch.substring(1);
+            }
+            urlOrQueryOrSearch = new URLSearchParams(urlOrQueryOrSearch);
+        }
+    }
+    // works same if urlOrQueryOrSearch is null, integer, or a already object etc...
+    return objectFrom(urlOrQueryOrSearch, { withType: true, noEmptyString: true });
+}
+/**
+ * Returns an easy-to-use Javascript object something iterable, such as a Map, Set, or Array
+ * @param value iterable input
+ * @param params.withType `false`, if set it tries to cast string value to a JS number/boolean/undefined/null type.
+ * @param params.noEmptyString `false`, if set it converts empty string value to a true boolean, usefull to allow a `if(result.key)` check for example
+ * @returns An javascript object
+ */
+function objectFrom(value, params) {
+    params = Object.assign({ withType: false, noEmptyString: false }, params);
+    const obj = {};
+    if (!value) {
+        return obj;
+    }
+    for (const [key, val] of objectEntries(value)) {
+        value = val;
+        if (params.withType && value != null && value.substring) {
+            if (value) {
+                const number = Number(value);
+                if (isNaN(number)) {
+                    switch (value.toLowerCase()) {
+                        case 'true':
+                            value = true;
+                            break;
+                        case 'false':
+                            value = false;
+                            break;
+                        case 'null':
+                            value = null;
+                            break;
+                        case 'undefined':
+                            value = undefined;
+                            break;
+                    }
+                }
+                else {
+                    value = number;
+                }
+            }
+            else if (params.noEmptyString) {
+                // if empty string => TRUE to allow a if(options.key) check for example
+                value = true;
+            }
+        }
+        if (obj[key]) {
+            if (!Array.isArray(obj[key])) {
+                obj[key] = new Array(obj[key]);
+            }
+            obj[key].push(value);
+        }
+        else {
+            obj[key] = value;
+        }
+    }
+    return obj;
+}
+/**
+ * Returns entries from something iterable, such as a Map, Set, or Array
+ * @param value iterable input
+ * @returns An javascript object
+ */
+function objectEntries(value) {
+    if (value.entries) {
+        return value.entries();
+    }
+    return Array.from({
+        [Symbol.iterator]: function* () {
+            for (const key in value) {
+                yield [key, value[key]];
+            }
+        }
+    });
+}
+/**
+ * Converts various data types, such as objects, strings, exceptions, errors,
+ * or numbers, into a string representation. Since it offers a more comprehensive format,
+ * this function is preferred to `JSON.stringify()`.
+ * @param obj Any objects, strings, exceptions, errors, or number
+ * @param params.space `''`, allows to configure space in the string representation
+ * @param params.decimal `2`, allows to choose the number of decimal to display in the string representation
+ * @param params.recursive `false`, allows to serialize recursively every object value,  beware if a value refers to a already parsed value an infinite loop will occur.
+ * @returns the final string representation
+ */
+// Online Javascript Editor for free
+// Write, Edit and Run your Javascript code using JS Online Compiler
+function stringify(obj, params = {}) {
+    params = Object.assign({ space: ' ', decimal: 2, recursive: 1 }, params);
+    if (!obj) {
+        return String(obj);
+    }
+    const error = obj.error || obj.message;
+    if (error) {
+        // is a error!
+        obj = error;
+    }
+    if (obj.toFixed) {
+        return obj.toFixed(Number(params.decimal) || 0);
+    }
+    if (obj.substring || !params.recursive) {
+        // is already a string OR has to be stringified
+        return String(obj);
+    }
+    const space = params.space || '';
+    if (Array.isArray(obj)) {
+        // Array!
+        let res = '';
+        for (const value of obj) {
+            res += (res ? ',' : '[') + space;
+            res += stringify(value, Object.assign(params, { recursive: params.recursive - 1 }));
+        }
+        return (res += space + ']');
+    }
+    if (obj.byteLength != null && (obj === null || obj === void 0 ? void 0 : obj[Symbol.iterator])) {
+        // Binary!
+        return _decoder.decode(obj);
+    }
+    let res = '';
+    for (const name in obj) {
+        res += (res ? ',' : '{') + space + name + ':';
+        res += stringify(obj[name], Object.assign(params, { recursive: params.recursive - 1 }));
+    }
+    return (res += space + '}');
+}
+function toBin(value) {
+    return _encoder.encode(value);
+}var Util=/*#__PURE__*/Object.freeze({__proto__:null,EMPTY_FUNCTION:EMPTY_FUNCTION,VERSION:VERSION,objectFrom:objectFrom,options:options,stringify:stringify,time:time,timeOrigin:timeOrigin,toBin:toBin});/**
+ * Copyright 2023 Ceeblue B.V.
+ * This file is part of https://github.com/CeeblueTV/web-utils which is released under GNU Affero General Public License.
+ * See file LICENSE or go to https://spdx.org/licenses/AGPL-3.0-or-later.html for full license details.
+ */
+/**
+ * The WebSocketReliable class extends WebSocket to bring up the following improvements:
+ * - Fix all possible unintentional closing ways to get always a related error message, {@link onClose | onClose(error?) event}
+ * - Make possible message sending while connecting. Indeed no need to wait {@link onOpen} before to send message,
+ * you can open the socket and immediately send messages, it will be queue and flushs on connection etablishment
+ * - Make possible a delayed connection, or a reconnection. Indeed you can create an unconnected Websocket instance
+ * without passing any url argument and starts the conneciton more later with {@link WebSocketReliable.open(url) | open(url)} method
+ * - Make possible to control sending/queueing message: send method take an optional queueing=true argument to
+ * queue message rather send it, a futur call to flush will send it. Then queueing getter allows to handle the queue
+ * if need to purge it or remove some queued message. Use it all together can help to prioritize messages or control overload.
+ * @example
+ * const ws = new WebSocketReliable(url);
+ * ws.onClose = (error?:string) => {
+ *    if(error) {
+ *       console.error(error);
+ *    }
+ *    // reconnection attempt every seconds
+ *    setTimeout(() => ws.open(url), 1000);
+ * }
+ * ws.onMessage = (message:string) => {
+ *    console.log(message);
+ * }
+ * ws.send('hello'); // send immediatly a hello message is possible (no need to wait onOpen)
+ */
+class WebSocketReliable extends EventEmitter {
+    /**
+     * @event `open` fired when socket is connected
+     */
+    onOpen() { }
+    /**
+     * @event `message` fired on message reception
+     * @param message can be binary or string.
+     * If you subscribe to the event with message as string type (and not union),
+     * it means that you know that all your messages are distributed in a string format
+     */
+    onMessage(message) { }
+    /**
+     * @event `close` fired on websocket close
+     * @param error error description on an improper closure
+     */
+    onClose(error) {
+        if (error) {
+            console.error(error);
+        }
+    }
+    /**
+     * binaryType, fix binary type to arrayBuffer
+     */
+    get binaryType() {
+        return 'arraybuffer';
+    }
+    /**
+     * url of connection
+     */
+    get url() {
+        var _a, _b;
+        return (_b = (_a = this._ws) === null || _a === void 0 ? void 0 : _a.url) !== null && _b !== void 0 ? _b : '';
+    }
+    /**
+     * extensions negociated by the server
+     */
+    get extensions() {
+        var _a, _b;
+        return (_b = (_a = this._ws) === null || _a === void 0 ? void 0 : _a.extensions) !== null && _b !== void 0 ? _b : '';
+    }
+    /**
+     * protocol negociated by the server
+     */
+    get protocol() {
+        var _a, _b;
+        return (_b = (_a = this._ws) === null || _a === void 0 ? void 0 : _a.protocol) !== null && _b !== void 0 ? _b : '';
+    }
+    /**
+     * opened equals true when connection is etablished, in other word when onOpen event is fired
+     */
+    get opened() {
+        return this._opened;
+    }
+    /**
+     * {@link https://developer.mozilla.org/docs/Web/API/WebSocket/readyState | Official websocket readyState}
+     */
+    get readyState() {
+        return this._ws ? this._ws.readyState : 3;
+    }
+    /**
+     * True when connection is closed, in other words when {@link onClose} event is fired
+     * or when WebSocketReliable is build without url (disconnected creation)
+     */
+    get closed() {
+        return this._closed;
+    }
+    /**
+     * The number of bytes of data that were queued during calls to send() but not yet transmitted to the network
+     */
+    get bufferedAmount() {
+        var _a;
+        return this._queueingBytes + (((_a = this._ws) === null || _a === void 0 ? void 0 : _a.bufferedAmount) || 0);
+    }
+    /**
+     * Queued messages from a call to send() waiting to be transmit one time websocket connection opened (or with an explicit call to flush() method)
+     */
+    get queueing() {
+        return this._queueing;
+    }
+    /**
+     * Create a WebSocketReliable object, and open it if an url is passed in argument
+     * @param url URL of the WebSocket endpoint or null to start the connection later
+     */
+    constructor(url, protocols) {
+        super();
+        this._queueing = [];
+        this._queueingBytes = 0;
+        this._opened = false;
+        this._closed = true;
+        if (url) {
+            this.open(url, protocols);
+        }
+    }
+    /**
+     * Open a WebSocket connection
+     * @param url url of the websocket endpoint
+     * @returns this
+     */
+    open(url, protocols) {
+        this._closed = false;
+        const ws = (this._ws = new WebSocket(url, protocols));
+        ws.binaryType = this.binaryType;
+        ws.onmessage = e => this.onMessage(e.data);
+        // Add details and fix close ways
+        ws.onclose = (e) => {
+            if (!this._opened) {
+                // close during connection
+                this.close(url.toString() + ' connection failed (' + String(e.reason || e.code) + ')');
+            }
+            else if (e.code === 1000 || e.code === 1005) {
+                // normal disconnection from server (no error code)
+                this.close(url.toString() + ' shutdown');
+            }
+            else {
+                // disconnection from server
+                this.close(url.toString() + ' disconnection (' + String(e.reason || e.code) + ')');
+            }
+        };
+        // Wrap send method to queue messages until connection is established.
+        ws.onopen = _ => {
+            this._opened = true;
+            this.flush();
+            this.onOpen();
+        };
+        return this;
+    }
+    /**
+     * Send a message
+     * @param message
+     * @param queueing When set it reports the sending to a more later call to flush
+     * @returns this
+     */
+    send(message, queueing = false) {
+        if (!this._ws) {
+            throw Error('Open socket before to send data');
+        }
+        if (queueing || !this._opened) {
+            this._queueing.push(message);
+            this._queueingBytes += typeof message === 'string' ? message.length : message.byteLength;
+        }
+        else {
+            this._ws.send(message);
+        }
+        return this;
+    }
+    /**
+     * Send queueing messages
+     */
+    flush() {
+        if (this._ws) {
+            for (const message of this._queueing) {
+                this._ws.send(message);
+            }
+        }
+        this._queueing.length = 0;
+        this._queueingBytes = 0;
+    }
+    /**
+     * Close websocket
+     * @param error the error reason if is not a proper close
+     */
+    close(error) {
+        if (!this._ws || this._closed) {
+            return;
+        }
+        this._closed = true;
+        this._ws.onopen = this._ws.onclose = this._ws.onmessage = null; // otherwise can receive message AFTER close!
+        this._ws.close(); // Don't set to undefined to keep this._ws properties valid!
+        // release resources!
+        this._opened = false;
+        this._queueing.length = 0;
+        this._queueingBytes = 0;
+        this.onClose(error);
+    }
+}export{BinaryReader,BinaryWriter,BitReader,Connect,EventEmitter,NetAddress,Numbers,Queue,SDP,Util,WebSocketReliable};//# sourceMappingURL=web-utils.js.map