@lakutata/webrtc 0.0.0-stage → 3.1.1

package/dist/cjs/exports/WebRTC.js

@@ -0,0 +1,72 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setDebugHandler = exports.PeerServiceError = exports.PeerServiceProxy = exports.ChunkedChannel = exports.SignalingRequestError = exports.RtpTransceiver = exports.RtpSender = exports.RtpReceiver = exports.RtpPacket = exports.MediaTrack = exports.createTURNCredentials = void 0;
+__exportStar(require("../protocol/SignalingProtocol.js"), exports);
+__exportStar(require("../cluster/Cluster.js"), exports);
+__exportStar(require("../exceptions/ClusterRequestException.js"), exports);
+__exportStar(require("../exceptions/ClusterTimeoutException.js"), exports);
+__exportStar(require("../exceptions/ClusterTransportNotFoundException.js"), exports);
+var TURNCredentials_js_1 = require("../turn/TURNCredentials.js");
+Object.defineProperty(exports, "createTURNCredentials", { enumerable: true, get: function () { return TURNCredentials_js_1.createTURNCredentials; } });
+__exportStar(require("../turn/TURNServer.js"), exports);
+__exportStar(require("../signaling/Signaling.js"), exports);
+__exportStar(require("../signaling/SignalingController.js"), exports);
+__exportStar(require("../exceptions/SignalingClientRequiredException.js"), exports);
+__exportStar(require("../exceptions/SignalingDeniedException.js"), exports);
+__exportStar(require("../exceptions/SignalingLimitException.js"), exports);
+__exportStar(require("../exceptions/SignalingNotAMemberException.js"), exports);
+__exportStar(require("../exceptions/SignalingConnectionException.js"), exports);
+__exportStar(require("../whip/WHIP.js"), exports);
+__exportStar(require("../whip/WHIPController.js"), exports);
+__exportStar(require("../exceptions/WHIPDeniedException.js"), exports);
+__exportStar(require("../exceptions/WHIPLimitException.js"), exports);
+__exportStar(require("../exceptions/WHIPMediaTypeException.js"), exports);
+__exportStar(require("../exceptions/WHIPOfferException.js"), exports);
+__exportStar(require("../exceptions/WHIPSessionNotFoundException.js"), exports);
+__exportStar(require("../sfu/SFU.js"), exports);
+__exportStar(require("../whep/WHEP.js"), exports);
+__exportStar(require("../whep/WHEPController.js"), exports);
+__exportStar(require("../exceptions/WHEPDeniedException.js"), exports);
+__exportStar(require("../exceptions/WHEPLimitException.js"), exports);
+__exportStar(require("../exceptions/WHEPMediaTypeException.js"), exports);
+__exportStar(require("../exceptions/WHEPOfferException.js"), exports);
+__exportStar(require("../exceptions/WHEPSessionNotFoundException.js"), exports);
+__exportStar(require("../peer/PeerConnection.js"), exports);
+__exportStar(require("../peer/PeerThreads.js"), exports);
+__exportStar(require("../peer/PeerChannel.js"), exports);
+var MediaTrack_js_1 = require("../peer/MediaTrack.js");
+Object.defineProperty(exports, "MediaTrack", { enumerable: true, get: function () { return MediaTrack_js_1.MediaTrack; } });
+var RtpPacket_js_1 = require("../peer/RtpPacket.js");
+Object.defineProperty(exports, "RtpPacket", { enumerable: true, get: function () { return RtpPacket_js_1.RtpPacket; } });
+var RtpTransceiver_js_1 = require("../peer/RtpTransceiver.js");
+Object.defineProperty(exports, "RtpReceiver", { enumerable: true, get: function () { return RtpTransceiver_js_1.RtpReceiver; } });
+Object.defineProperty(exports, "RtpSender", { enumerable: true, get: function () { return RtpTransceiver_js_1.RtpSender; } });
+Object.defineProperty(exports, "RtpTransceiver", { enumerable: true, get: function () { return RtpTransceiver_js_1.RtpTransceiver; } });
+__exportStar(require("../peer/SignalingClient.js"), exports);
+var SignalingError_js_1 = require("../shared/SignalingError.js");
+Object.defineProperty(exports, "SignalingRequestError", { enumerable: true, get: function () { return SignalingError_js_1.SignalingRequestError; } });
+var ChunkedChannel_js_1 = require("../shared/ChunkedChannel.js");
+Object.defineProperty(exports, "ChunkedChannel", { enumerable: true, get: function () { return ChunkedChannel_js_1.ChunkedChannel; } });
+__exportStar(require("../service/WebRTCServiceEntrypoint.js"), exports);
+var PeerServiceProxy_js_1 = require("../shared/PeerServiceProxy.js");
+Object.defineProperty(exports, "PeerServiceProxy", { enumerable: true, get: function () { return PeerServiceProxy_js_1.PeerServiceProxy; } });
+Object.defineProperty(exports, "PeerServiceError", { enumerable: true, get: function () { return PeerServiceProxy_js_1.PeerServiceError; } });
+var log_js_1 = require("../lib/common/log.js");
+Object.defineProperty(exports, "setDebugHandler", { enumerable: true, get: function () { return log_js_1.setDebugHandler; } });
+
+//The default of the entry: the entry itself (scripts/package-build/cjs-package.mjs)
+if (!Object.prototype.hasOwnProperty.call(exports, 'default')) Object.defineProperty(exports, 'default', {value: exports})

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

@@ -0,0 +1,51 @@
+export declare function random16(): number;
+export declare function random32(): number;
+export declare function bufferXor(a: Buffer, b: Buffer): Buffer;
+export declare function bufferArrayXor(arr: Buffer[]): Buffer;
+export declare class BitWriter {
+    private bitLength;
+    value: number;
+    constructor(bitLength: number);
+    set(size: number, startIndex: number, value: number): this;
+    get buffer(): Buffer<ArrayBuffer>;
+}
+export declare class BitWriter2 {
+    /**Max 32bit */
+    private bitLength;
+    private _value;
+    offset: bigint;
+    /**
+   * 各valueがオクテットを跨いではならない
+   */
+    constructor(
+    /**Max 32bit */
+    bitLength: number);
+    set(value: number, size?: number): this;
+    get value(): number;
+    get buffer(): Buffer<ArrayBuffer>;
+}
+export declare function getBit(bits: number, startIndex: number, length?: number): number;
+export declare function paddingByte(bits: number): string;
+export declare function paddingBits(bits: number, expectLength: number): string;
+export declare function bufferWriter(bytes: number[], values: (number | bigint)[]): Buffer<ArrayBuffer>;
+export declare function createBufferWriter(bytes: number[], singleBuffer?: boolean): (values: (number | bigint)[]) => Buffer<ArrayBuffer>;
+export declare function bufferWriterLE(bytes: number[], values: (number | bigint)[]): Buffer<ArrayBuffer>;
+export declare function bufferReader(buf: Buffer, bytes: number[]): any[];
+export declare class BufferChain {
+    buffer: Buffer;
+    constructor(size: number);
+    writeInt16BE(value: number, offset?: number | undefined): this;
+    writeUInt8(value: number, offset?: number | undefined): this;
+}
+export declare const dumpBuffer: (data: Buffer) => string;
+export declare function buffer2ArrayBuffer(buf: Buffer): ArrayBuffer | SharedArrayBuffer;
+export declare class BitStream {
+    uint8Array: Buffer;
+    private position;
+    private bitsPending;
+    constructor(uint8Array: Buffer);
+    writeBits(bits: number, value: number): BitStream;
+    readBits(bits: number): number;
+    private _readBits;
+    seekTo(bitPos: number): void;
+}

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

@@ -0,0 +1,264 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BitStream = exports.dumpBuffer = exports.BufferChain = exports.BitWriter2 = exports.BitWriter = void 0;
+exports.random16 = random16;
+exports.random32 = random32;
+exports.bufferXor = bufferXor;
+exports.bufferArrayXor = bufferArrayXor;
+exports.getBit = getBit;
+exports.paddingByte = paddingByte;
+exports.paddingBits = paddingBits;
+exports.bufferWriter = bufferWriter;
+exports.createBufferWriter = createBufferWriter;
+exports.bufferWriterLE = bufferWriterLE;
+exports.bufferReader = bufferReader;
+exports.buffer2ArrayBuffer = buffer2ArrayBuffer;
+const node_crypto_1 = require("node:crypto");
+function random16() {
+    return (0, node_crypto_1.randomBytes)(2).readUInt16BE(0);
+}
+function random32() {
+    return (0, node_crypto_1.randomBytes)(4).readUInt32BE(0);
+}
+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;
+}
+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;
+}
+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;
+    }
+}
+exports.BitWriter = BitWriter;
+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;
+    }
+}
+exports.BitWriter2 = BitWriter2;
+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);
+}
+function paddingByte(bits) {
+    const dec = bits.toString(2).split('');
+    return [...[...Array(8 - dec.length)].map(() => '0'), ...dec].join('');
+}
+function paddingBits(bits, expectLength) {
+    const dec = bits.toString(2);
+    return [...[...Array(expectLength - dec.length)].map(() => '0'), ...dec].join('');
+}
+function bufferWriter(bytes, values) {
+    return createBufferWriter(bytes)(values);
+}
+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;
+    };
+}
+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;
+}
+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;
+    });
+}
+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;
+    }
+}
+exports.BufferChain = BufferChain;
+const dumpBuffer = (data) => '0x' +
+    data
+        .toString('hex')
+        .replace(/(.)(.)/g, '$1$2 ')
+        .split(' ')
+        .filter((s) => s != undefined && s.length > 0)
+        .join(',0x');
+exports.dumpBuffer = dumpBuffer;
+function buffer2ArrayBuffer(buf) {
+    return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+}
+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++;
+        }
+    }
+}
+exports.BitStream = BitStream;

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

@@ -0,0 +1,116 @@
+/**
+ * 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 declare class NotEnoughDataError extends Error {
+    constructor(expected: number, received: number);
+}
+/** Sequential reader over a single Buffer. Returned buffers share memory with the input. */
+export declare class BinaryReader {
+    private readonly buf;
+    private offset;
+    constructor(buf: Buffer);
+    /** The number of unread bytes. */
+    get length(): number;
+    /** The number of bytes consumed so far. */
+    get bytes(): number;
+    readBuffer(size: number): Buffer;
+    readUIntBE(size: number): number;
+    private assertSize;
+}
+/** Collects written chunks and concatenates them once at the end. */
+export declare class BinaryWriter {
+    private readonly chunks;
+    private written;
+    /** The number of bytes written so far. */
+    get bytes(): number;
+    writeBuffer(buf: Buffer): void;
+    writeUIntBE(value: number, size: number): void;
+    toBuffer(): Buffer;
+}
+/**
+ * Encode / decode context.
+ * `node` is the root object, `current` is the object currently being processed.
+ */
+export interface BinaryContext {
+    node: any;
+    current: any;
+}
+export interface DataType<T> {
+    encode(value: T, writer: BinaryWriter, context: BinaryContext): void;
+    decode(reader: BinaryReader, context: BinaryContext): T;
+}
+export type NumberType = DataType<number>;
+export interface Schema {
+    [key: string]: DataType<any> | Schema;
+}
+export type TypeOrSchema = DataType<any> | Schema;
+/** Infer the decoded value from a type or schema. */
+export type Decoded<S> = S extends DataType<infer T> ? T : S extends Schema ? {
+    -readonly [K in keyof S]: Decoded<S[K]>;
+} : never;
+export type LengthCallback = (context: BinaryContext) => number;
+/** Encode `obj` using a type or schema. */
+export declare function encode(obj: any, typeOrSchema: TypeOrSchema): Buffer;
+/**
+ * Decode `buf` using a type or schema.
+ * Trailing bytes are ignored. Throws NotEnoughDataError when `buf` is too short.
+ */
+export declare function decode<S extends TypeOrSchema>(buf: Buffer, typeOrSchema: S): Decoded<S>;
+type LengthSpec = number | NumberType | LengthCallback;
+/**
+ * Buffer type.
+ * @param length fixed number of bytes, number type for size-prefixed buffers,
+ * or callback returning the number of bytes.
+ */
+declare function buffer(length: LengthSpec): DataType<Buffer>;
+/**
+ * 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).
+ */
+declare function array<S extends TypeOrSchema>(type: S, length: LengthSpec, lengthType?: 'count' | 'bytes'): DataType<Decoded<S>[]>;
+/**
+ * String type.
+ * @param length fixed number of bytes, number type for size-prefixed strings,
+ * or callback returning the number of bytes.
+ */
+declare function string(length: LengthSpec, encoding?: BufferEncoding): DataType<string>;
+export declare const types: {
+    uint8: NumberType;
+    uint16be: NumberType;
+    uint24be: NumberType;
+    uint32be: NumberType;
+    uint48be: NumberType;
+    buffer: typeof buffer;
+    array: typeof array;
+    string: typeof string;
+};
+export {};