@lakutata/webrtc 0.0.0-stage → 3.1.4

package/dist/esm/exports/WebRTC.js

@@ -0,0 +1,41 @@
+export * from '../protocol/SignalingProtocol.js';
+export * from '../cluster/Cluster.js';
+export * from '../exceptions/ClusterRequestException.js';
+export * from '../exceptions/ClusterTimeoutException.js';
+export * from '../exceptions/ClusterTransportNotFoundException.js';
+export { createTURNCredentials } from '../turn/TURNCredentials.js';
+export * from '../turn/TURNServer.js';
+export * from '../signaling/Signaling.js';
+export * from '../signaling/SignalingController.js';
+export * from '../exceptions/SignalingClientRequiredException.js';
+export * from '../exceptions/SignalingDeniedException.js';
+export * from '../exceptions/SignalingLimitException.js';
+export * from '../exceptions/SignalingNotAMemberException.js';
+export * from '../exceptions/SignalingConnectionException.js';
+export * from '../whip/WHIP.js';
+export * from '../whip/WHIPController.js';
+export * from '../exceptions/WHIPDeniedException.js';
+export * from '../exceptions/WHIPLimitException.js';
+export * from '../exceptions/WHIPMediaTypeException.js';
+export * from '../exceptions/WHIPOfferException.js';
+export * from '../exceptions/WHIPSessionNotFoundException.js';
+export * from '../sfu/SFU.js';
+export * from '../whep/WHEP.js';
+export * from '../whep/WHEPController.js';
+export * from '../exceptions/WHEPDeniedException.js';
+export * from '../exceptions/WHEPLimitException.js';
+export * from '../exceptions/WHEPMediaTypeException.js';
+export * from '../exceptions/WHEPOfferException.js';
+export * from '../exceptions/WHEPSessionNotFoundException.js';
+export * from '../peer/PeerConnection.js';
+export * from '../peer/PeerThreads.js';
+export * from '../peer/PeerChannel.js';
+export { MediaTrack } from '../peer/MediaTrack.js';
+export { RtpPacket } from '../peer/RtpPacket.js';
+export { RtpReceiver, RtpSender, RtpTransceiver } from '../peer/RtpTransceiver.js';
+export * from '../peer/SignalingClient.js';
+export { SignalingRequestError } from '../shared/SignalingError.js';
+export { ChunkedChannel } from '../shared/ChunkedChannel.js';
+export * from '../service/WebRTCServiceEntrypoint.js';
+export { PeerServiceProxy, PeerServiceError } from '../shared/PeerServiceProxy.js';
+export { setDebugHandler } from '../lib/common/log.js';

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

@@ -0,0 +1,244 @@
+import { randomBytes } from 'node:crypto';
+export function random16() {
+    return randomBytes(2).readUInt16BE(0);
+}
+export function random32() {
+    return randomBytes(4).readUInt32BE(0);
+}
+export function bufferXor(a, b) {
+    if (a.length !== b.length) {
+        throw new TypeError('[webrtc-stun] You can not XOR buffers which length are different');
+    }
+    const length = a.length;
+    const buffer = Buffer.allocUnsafe(length);
+    for (let i = 0; i < length; i++) {
+        buffer[i] = a[i] ^ b[i];
+    }
+    return buffer;
+}
+export function bufferArrayXor(arr) {
+    const length = [...arr]
+        .sort((a, b) => a.length - b.length)
+        .reverse()[0].length;
+    const xored = Buffer.allocUnsafe(length);
+    for (let i = 0; i < length; i++) {
+        xored[i] = 0;
+        arr.forEach((buffer) => {
+            xored[i] ^= buffer[i] ?? 0;
+        });
+    }
+    return xored;
+}
+export class BitWriter {
+    constructor(bitLength) {
+        this.bitLength = bitLength;
+        this.value = 0;
+    }
+    set(size, startIndex, value) {
+        value &= (1 << size) - 1;
+        this.value |= value << (this.bitLength - size - startIndex);
+        return this;
+    }
+    get buffer() {
+        const length = Math.ceil(this.bitLength / 8);
+        const buf = Buffer.alloc(length);
+        buf.writeUIntBE(this.value, 0, length);
+        return buf;
+    }
+}
+export class BitWriter2 {
+    /**
+   * 各valueがオクテットを跨いではならない
+   */
+    constructor(
+    /**Max 32bit */
+    bitLength) {
+        this.bitLength = bitLength;
+        this._value = 0n;
+        this.offset = 0n;
+        if (bitLength > 32) {
+            throw new Error();
+        }
+    }
+    set(value, size = 1) {
+        let value_b = BigInt(value);
+        const size_b = BigInt(size);
+        value_b &= (1n << size_b) - 1n;
+        this._value |= value_b << (BigInt(this.bitLength) - size_b - this.offset);
+        this.offset += size_b;
+        return this;
+    }
+    get value() {
+        return Number(this._value);
+    }
+    get buffer() {
+        const length = Math.ceil(this.bitLength / 8);
+        const buf = Buffer.alloc(length);
+        buf.writeUIntBE(this.value, 0, length);
+        return buf;
+    }
+}
+export function getBit(bits, startIndex, length = 1) {
+    //The bits of a byte from its most significant one, as many as there are up to its end
+    const end = Math.min(startIndex + length, 8);
+    return (bits >> (8 - end)) & ((1 << (end - startIndex)) - 1);
+}
+export function paddingByte(bits) {
+    const dec = bits.toString(2).split('');
+    return [...[...Array(8 - dec.length)].map(() => '0'), ...dec].join('');
+}
+export function paddingBits(bits, expectLength) {
+    const dec = bits.toString(2);
+    return [...[...Array(expectLength - dec.length)].map(() => '0'), ...dec].join('');
+}
+export function bufferWriter(bytes, values) {
+    return createBufferWriter(bytes)(values);
+}
+export function createBufferWriter(bytes, singleBuffer) {
+    const length = bytes.reduce((acc, cur) => acc + cur, 0);
+    const reuseBuffer = singleBuffer ? Buffer.alloc(length) : undefined;
+    return (values) => {
+        const buf = reuseBuffer || Buffer.alloc(length);
+        let offset = 0;
+        values.forEach((v, i) => {
+            const size = bytes[i];
+            if (size === 8)
+                buf.writeBigUInt64BE(v, offset);
+            else
+                buf.writeUIntBE(v, offset, size);
+            offset += size;
+        });
+        return buf;
+    };
+}
+export function bufferWriterLE(bytes, values) {
+    const length = bytes.reduce((acc, cur) => acc + cur, 0);
+    const buf = Buffer.alloc(length);
+    let offset = 0;
+    values.forEach((v, i) => {
+        const size = bytes[i];
+        if (size === 8)
+            buf.writeBigUInt64LE(v, offset);
+        else
+            buf.writeUIntLE(v, offset, size);
+        offset += size;
+    });
+    return buf;
+}
+export function bufferReader(buf, bytes) {
+    let offset = 0;
+    return bytes.map((v) => {
+        let read;
+        if (v === 8) {
+            read = buf.readBigUInt64BE(offset);
+        }
+        else {
+            read = buf.readUIntBE(offset, v);
+        }
+        offset += v;
+        return read;
+    });
+}
+export class BufferChain {
+    constructor(size) {
+        this.buffer = Buffer.alloc(size);
+    }
+    writeInt16BE(value, offset) {
+        this.buffer.writeInt16BE(value, offset);
+        return this;
+    }
+    writeUInt8(value, offset) {
+        this.buffer.writeUInt8(value, offset);
+        return this;
+    }
+}
+export const dumpBuffer = (data) => '0x' +
+    data
+        .toString('hex')
+        .replace(/(.)(.)/g, '$1$2 ')
+        .split(' ')
+        .filter((s) => s != undefined && s.length > 0)
+        .join(',0x');
+export function buffer2ArrayBuffer(buf) {
+    return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+}
+export class BitStream {
+    constructor(uint8Array) {
+        this.uint8Array = uint8Array;
+        this.position = 0;
+        this.bitsPending = 0;
+    }
+    writeBits(bits, value) {
+        if (bits == 0) {
+            return this;
+        }
+        value &= 0xffffffff >>> (32 - bits);
+        let bitsConsumed;
+        if (this.bitsPending > 0) {
+            if (this.bitsPending > bits) {
+                this.uint8Array[this.position - 1] |=
+                    value << (this.bitsPending - bits);
+                bitsConsumed = bits;
+                this.bitsPending -= bits;
+            }
+            else if (this.bitsPending == bits) {
+                this.uint8Array[this.position - 1] |= value;
+                bitsConsumed = bits;
+                this.bitsPending = 0;
+            }
+            else {
+                this.uint8Array[this.position - 1] |=
+                    value >> (bits - this.bitsPending);
+                // ???
+                bitsConsumed = this.bitsPending;
+                this.bitsPending = 0;
+            }
+        }
+        else {
+            bitsConsumed = Math.min(8, bits);
+            this.bitsPending = 8 - bitsConsumed;
+            this.uint8Array[this.position++] =
+                (value >> (bits - bitsConsumed)) << this.bitsPending;
+        }
+        bits -= bitsConsumed;
+        if (bits > 0) {
+            this.writeBits(bits, value);
+        }
+        return this;
+    }
+    readBits(bits) {
+        return this._readBits(bits);
+    }
+    _readBits(bits, bitBuffer) {
+        if (typeof bitBuffer == 'undefined') {
+            bitBuffer = 0;
+        }
+        if (bits == 0) {
+            return bitBuffer;
+        }
+        let partial;
+        let bitsConsumed;
+        if (this.bitsPending > 0) {
+            const byte = this.uint8Array[this.position - 1] & (0xff >> (8 - this.bitsPending));
+            bitsConsumed = Math.min(this.bitsPending, bits);
+            this.bitsPending -= bitsConsumed;
+            partial = byte >> this.bitsPending;
+        }
+        else {
+            bitsConsumed = Math.min(8, bits);
+            this.bitsPending = 8 - bitsConsumed;
+            partial = this.uint8Array[this.position++] >> this.bitsPending;
+        }
+        bits -= bitsConsumed;
+        bitBuffer = (bitBuffer << bitsConsumed) | partial;
+        return bits > 0 ? this._readBits(bits, bitBuffer) : bitBuffer;
+    }
+    seekTo(bitPos) {
+        this.position = (bitPos / 8) | 0;
+        this.bitsPending = bitPos % 8;
+        if (this.bitsPending > 0) {
+            this.bitsPending = 8 - this.bitsPending;
+            this.position++;
+        }
+    }
+}

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

@@ -0,0 +1,392 @@
+/**
+ * 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.
+ */
+/** Thrown when the input does not contain enough bytes to decode. */
+export class NotEnoughDataError extends Error {
+    constructor(expected, received) {
+        super(`requested ${expected} bytes but only ${received} available`);
+        this.name = 'NotEnoughDataError';
+    }
+}
+/** Sequential reader over a single Buffer. Returned buffers share memory with the input. */
+export 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);
+        }
+    }
+}
+/** Collects written chunks and concatenates them once at the end. */
+export 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);
+    }
+}
+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. */
+export 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.
+ */
+export 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);
+        }
+    };
+}
+export const types = {
+    uint8: createUIntBE(1),
+    uint16be: createUIntBE(2),
+    uint24be: createUIntBE(3),
+    uint32be: createUIntBE(4),
+    uint48be: createUIntBE(6),
+    buffer,
+    array,
+    string
+};