@lakutata/webrtc 0.0.0-stage → 3.1.4

package/dist/cjs/lib/ice/types/model.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/lib/ice/utils.d.ts

@@ -0,0 +1,13 @@
+import * as os from 'node:os';
+import { type Address, type InterfaceAddresses } from './imports/common.js';
+export declare function getGlobalIp(stunServer: Address, interfaceAddresses?: InterfaceAddresses): Promise<string>;
+export declare function isLinkLocalAddress(info: os.NetworkInterfaceInfo): boolean;
+export declare function nodeIpAddress(family: number, { useLinkLocalAddress }?: {
+    /** such as google cloud run */
+    useLinkLocalAddress?: boolean;
+}): string[];
+export declare function getHostAddresses(useIpv4: boolean, useIpv6: boolean, options?: {
+    /** such as google cloud run */
+    useLinkLocalAddress?: boolean;
+}): string[];
+export declare const url2Address: (url?: string) => readonly [string, number] | undefined;

package/dist/cjs/lib/ice/utils.js

@@ -0,0 +1,84 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.url2Address = void 0;
+exports.getGlobalIp = getGlobalIp;
+exports.isLinkLocalAddress = isLinkLocalAddress;
+exports.nodeIpAddress = nodeIpAddress;
+exports.getHostAddresses = getHostAddresses;
+const os = __importStar(require("node:os"));
+const common_js_1 = require("./imports/common.js");
+const selectAddresses_js_1 = require("./internal/selectAddresses.js");
+const const_js_1 = require("./stun/const.js");
+const message_js_1 = require("./stun/message.js");
+const protocol_js_1 = require("./stun/protocol.js");
+const logger = (0, common_js_1.debug)('webrtc/ice/utils');
+async function getGlobalIp(stunServer, interfaceAddresses) {
+    const protocol = new protocol_js_1.StunProtocol();
+    await protocol.connectionMade(true, undefined, interfaceAddresses);
+    const request = new message_js_1.Message(const_js_1.methods.BINDING, const_js_1.classes.REQUEST);
+    const [response] = await protocol.request(request, stunServer);
+    await protocol.close();
+    const address = response.getAttributeValue('XOR-MAPPED-ADDRESS');
+    return address[0];
+}
+function isLinkLocalAddress(info) {
+    return (((0, common_js_1.normalizeFamilyNodeV18)(info.family) === 4 &&
+        info.address?.startsWith('169.254.')) ||
+        ((0, common_js_1.normalizeFamilyNodeV18)(info.family) === 6 &&
+            info.address?.startsWith('fe80::')));
+}
+function nodeIpAddress(family, { useLinkLocalAddress } = {}) {
+    const interfaces = os.networkInterfaces();
+    logger(interfaces);
+    return (0, selectAddresses_js_1.selectAddressesFromInterfaces)(interfaces, family, { useLinkLocalAddress }, isLinkLocalAddress);
+}
+function getHostAddresses(useIpv4, useIpv6, options = {}) {
+    const address = [];
+    if (useIpv4) {
+        address.push(...nodeIpAddress(4, options));
+    }
+    if (useIpv6) {
+        address.push(...nodeIpAddress(6, options));
+    }
+    return address;
+}
+const url2Address = (url) => {
+    if (!url)
+        return;
+    const [address, port] = url.split(':');
+    return [address, Number.parseInt(port)];
+};
+exports.url2Address = url2Address;

package/dist/cjs/lib/peer/const.d.ts

@@ -0,0 +1,36 @@
+import { type HashAlgorithms, SignatureAlgorithm } from './imports/dtls.js';
+import type { DtlsRole } from './transport/dtls.js';
+export declare const DATA_CHANNEL_ACK = 2;
+export declare const DATA_CHANNEL_OPEN = 3;
+export declare const DATA_CHANNEL_RELIABLE = 0;
+export declare const DATA_CHANNEL_PARTIAL_RELIABLE_REXMIT = 1;
+export declare const DATA_CHANNEL_PARTIAL_RELIABLE_TIMED = 2;
+export declare const DATA_CHANNEL_RELIABLE_UNORDERED = 128;
+export declare const DATA_CHANNEL_PARTIAL_RELIABLE_REXMIT_UNORDERED = 129;
+export declare const DATA_CHANNEL_PARTIAL_RELIABLE_TIMED_UNORDERED = 130;
+export declare const WEBRTC_DCEP = 50;
+export declare const WEBRTC_STRING = 51;
+export declare const WEBRTC_BINARY = 53;
+export declare const WEBRTC_STRING_EMPTY = 56;
+export declare const WEBRTC_BINARY_EMPTY = 57;
+export declare const DISCARD_HOST = "0.0.0.0";
+export declare const DISCARD_PORT = 9;
+export declare const MEDIA_KINDS: string[];
+export declare const DIRECTIONS: string[];
+export declare const DTLS_ROLE_SETUP: {
+    auto: string;
+    client: string;
+    server: string;
+};
+export declare const DTLS_SETUP_ROLE: {
+    [key: string]: DtlsRole;
+};
+export declare const FMTP_INT_PARAMETERS: string[];
+export declare const SSRC_INFO_ATTRS: string[];
+export declare const SRTP_PROFILE: {
+    readonly SRTP_AES128_CM_HMAC_SHA1_80: 1;
+    readonly SRTP_AEAD_AES_128_GCM: 7;
+};
+export declare const SenderDirections: string[];
+export declare const ReceiverDirection: string[];
+export { type HashAlgorithms, SignatureAlgorithm };

package/dist/cjs/lib/peer/const.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignatureAlgorithm = exports.ReceiverDirection = exports.SenderDirections = exports.SRTP_PROFILE = exports.SSRC_INFO_ATTRS = exports.FMTP_INT_PARAMETERS = exports.DTLS_SETUP_ROLE = exports.DTLS_ROLE_SETUP = exports.DIRECTIONS = exports.MEDIA_KINDS = exports.DISCARD_PORT = exports.DISCARD_HOST = exports.WEBRTC_BINARY_EMPTY = exports.WEBRTC_STRING_EMPTY = exports.WEBRTC_BINARY = exports.WEBRTC_STRING = exports.WEBRTC_DCEP = exports.DATA_CHANNEL_PARTIAL_RELIABLE_TIMED_UNORDERED = exports.DATA_CHANNEL_PARTIAL_RELIABLE_REXMIT_UNORDERED = exports.DATA_CHANNEL_RELIABLE_UNORDERED = exports.DATA_CHANNEL_PARTIAL_RELIABLE_TIMED = exports.DATA_CHANNEL_PARTIAL_RELIABLE_REXMIT = exports.DATA_CHANNEL_RELIABLE = exports.DATA_CHANNEL_OPEN = exports.DATA_CHANNEL_ACK = void 0;
+const dtls_js_1 = require("./imports/dtls.js");
+Object.defineProperty(exports, "SignatureAlgorithm", { enumerable: true, get: function () { return dtls_js_1.SignatureAlgorithm; } });
+const rtp_js_1 = require("./imports/rtp.js");
+// data channel export constants
+exports.DATA_CHANNEL_ACK = 2;
+exports.DATA_CHANNEL_OPEN = 3;
+// 5.1.  DATA_CHANNEL_OPEN Message
+exports.DATA_CHANNEL_RELIABLE = 0x00;
+exports.DATA_CHANNEL_PARTIAL_RELIABLE_REXMIT = 0x01;
+exports.DATA_CHANNEL_PARTIAL_RELIABLE_TIMED = 0x02;
+exports.DATA_CHANNEL_RELIABLE_UNORDERED = 0x80;
+exports.DATA_CHANNEL_PARTIAL_RELIABLE_REXMIT_UNORDERED = 0x81;
+exports.DATA_CHANNEL_PARTIAL_RELIABLE_TIMED_UNORDERED = 0x82;
+exports.WEBRTC_DCEP = 50;
+exports.WEBRTC_STRING = 51;
+exports.WEBRTC_BINARY = 53;
+exports.WEBRTC_STRING_EMPTY = 56;
+exports.WEBRTC_BINARY_EMPTY = 57;
+exports.DISCARD_HOST = '0.0.0.0';
+exports.DISCARD_PORT = 9;
+exports.MEDIA_KINDS = ['audio', 'video'];
+exports.DIRECTIONS = ['inactive', 'sendonly', 'recvonly', 'sendrecv'];
+exports.DTLS_ROLE_SETUP = {
+    auto: 'actpass',
+    client: 'active',
+    server: 'passive'
+};
+exports.DTLS_SETUP_ROLE = Object.keys(exports.DTLS_ROLE_SETUP).reduce((acc, cur) => {
+    const key = exports.DTLS_ROLE_SETUP[cur];
+    acc[key] = cur;
+    return acc;
+}, {});
+exports.FMTP_INT_PARAMETERS = [
+    'apt',
+    'max-fr',
+    'max-fs',
+    'maxplaybackrate',
+    'minptime',
+    'packetization-mode',
+    'level-asymmetry-allowed',
+    'stereo',
+    'useinbandfec'
+];
+exports.SSRC_INFO_ATTRS = ['cname', 'msid', 'mslabel', 'label'];
+exports.SRTP_PROFILE = {
+    SRTP_AES128_CM_HMAC_SHA1_80: rtp_js_1.ProtectionProfileAes128CmHmacSha1_80,
+    SRTP_AEAD_AES_128_GCM: rtp_js_1.ProtectionProfileAeadAes128Gcm
+};
+exports.SenderDirections = ['sendonly', 'sendrecv'];
+exports.ReceiverDirection = ['sendrecv', 'recvonly'];

package/dist/cjs/lib/peer/dataChannel.d.ts

@@ -0,0 +1,69 @@
+import { Event } from './imports/common.js';
+import { EventTarget } from './helper.js';
+import type { RTCSctpTransport } from './transport/sctp.js';
+import type { Callback, CallbackWithValue } from './types/util.js';
+export interface DataChannelStats {
+    messagesSent: number;
+    bytesSent: number;
+    messagesReceived: number;
+    bytesReceived: number;
+}
+export declare function getDataChannelMessageSize(data: Buffer | string): number;
+export declare class RTCDataChannel extends EventTarget implements DataChannelStats {
+    readonly sctp: RTCSctpTransport;
+    private readonly parameters;
+    readonly sendOpen: boolean;
+    readonly statsId: string;
+    readonly stateChange: Event<[DCState]>;
+    readonly stateChanged: Event<[DCState]>;
+    readonly onMessage: Event<[string | Buffer<ArrayBufferLike>]>;
+    readonly error: Event<[Error]>;
+    readonly bufferedAmountLow: Event<any[]>;
+    /**the amount buffered changed (a message queued, or sent): read by a worker thread serving the channel */
+    readonly bufferedAmountChanged: Event<any[]>;
+    onopen?: Callback;
+    onclose?: Callback;
+    onclosing?: Callback;
+    onmessage?: CallbackWithValue<MessageEvent>;
+    onerror?: CallbackWithValue<RTCErrorEvent>;
+    isCreatedByRemote: boolean;
+    id: number;
+    readyState: DCState;
+    bufferedAmount: number;
+    private _bufferedAmountLowThreshold;
+    messagesSent: number;
+    bytesSent: number;
+    messagesReceived: number;
+    bytesReceived: number;
+    constructor(sctp: RTCSctpTransport, parameters: RTCDataChannelParameters, sendOpen?: boolean);
+    get ordered(): boolean;
+    get maxRetransmits(): number | null;
+    get maxPacketLifeTime(): number | null;
+    get label(): string;
+    get protocol(): string;
+    get negotiated(): boolean;
+    get bufferedAmountLowThreshold(): number;
+    set bufferedAmountLowThreshold(value: number);
+    setId(id: number): void;
+    setReadyState(state: DCState): void;
+    addBufferedAmount(amount: number): void;
+    send(data: Buffer | string): void;
+    close(): void;
+}
+export type DCState = 'open' | 'closed' | 'connecting' | 'closing';
+export declare class RTCDataChannelParameters {
+    label: string;
+    maxPacketLifeTime?: number;
+    maxRetransmits?: number;
+    ordered: boolean;
+    protocol: string;
+    negotiated: boolean;
+    id: number;
+    constructor(props?: Partial<RTCDataChannelParameters>);
+}
+export interface MessageEvent {
+    data: string | Buffer;
+}
+export interface RTCErrorEvent {
+    error: any;
+}

package/dist/cjs/lib/peer/dataChannel.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RTCDataChannelParameters = exports.RTCDataChannel = void 0;
+exports.getDataChannelMessageSize = getDataChannelMessageSize;
+const node_crypto_1 = require("node:crypto");
+const common_js_1 = require("./imports/common.js");
+const helper_js_1 = require("./helper.js");
+const log = (0, common_js_1.debug)('webrtc/peer/dataChannel');
+function getDataChannelMessageSize(data) {
+    return Buffer.isBuffer(data) ? data.length : Buffer.byteLength(data);
+}
+class RTCDataChannel extends helper_js_1.EventTarget {
+    constructor(sctp, parameters, sendOpen = true) {
+        super();
+        this.sctp = sctp;
+        this.parameters = parameters;
+        this.sendOpen = sendOpen;
+        this.statsId = (0, node_crypto_1.randomUUID)().toString();
+        this.stateChange = new common_js_1.Event();
+        this.stateChanged = new common_js_1.Event();
+        this.onMessage = new common_js_1.Event();
+        // todo impl
+        this.error = new common_js_1.Event();
+        this.bufferedAmountLow = new common_js_1.Event();
+        /**the amount buffered changed (a message queued, or sent): read by a worker thread serving the channel */
+        this.bufferedAmountChanged = new common_js_1.Event();
+        this.isCreatedByRemote = false;
+        this.readyState = 'connecting';
+        this.bufferedAmount = 0;
+        this._bufferedAmountLowThreshold = 0;
+        // Statistics
+        this.messagesSent = 0;
+        this.bytesSent = 0;
+        this.messagesReceived = 0;
+        this.bytesReceived = 0;
+        this.id = this.parameters.id;
+        if (parameters.negotiated) {
+            if (this.id == undefined || this.id < 0 || this.id > 65534) {
+                throw new Error('ID must be in range 0-65534 if data channel is negotiated out-of-band');
+            }
+            this.sctp.dataChannelAddNegotiated(this);
+        }
+        else {
+            if (sendOpen) {
+                this.sendOpen = false;
+                this.sctp.dataChannelOpen(this);
+            }
+        }
+    }
+    get ordered() {
+        return this.parameters.ordered;
+    }
+    get maxRetransmits() {
+        return this.parameters.maxRetransmits ?? null;
+    }
+    get maxPacketLifeTime() {
+        return this.parameters.maxPacketLifeTime ?? null;
+    }
+    get label() {
+        return this.parameters.label;
+    }
+    get protocol() {
+        return this.parameters.protocol;
+    }
+    get negotiated() {
+        return this.parameters.negotiated;
+    }
+    get bufferedAmountLowThreshold() {
+        return this._bufferedAmountLowThreshold;
+    }
+    set bufferedAmountLowThreshold(value) {
+        if (value < 0 || value > 4294967295) {
+            throw new Error('bufferedAmountLowThreshold must be in range 0 - 4294967295');
+        }
+        this._bufferedAmountLowThreshold = value;
+    }
+    setId(id) {
+        this.id = id;
+    }
+    setReadyState(state) {
+        if (state !== this.readyState) {
+            this.readyState = state;
+            this.stateChange.execute(state);
+            this.stateChanged.execute(state);
+            switch (state) {
+                case 'open':
+                    if (this.onopen)
+                        (0, common_js_1.runDetached)(() => this.onopen(), (error) => log('onopen failed', error));
+                    this.emit('open');
+                    break;
+                case 'closed':
+                    if (this.onclose)
+                        (0, common_js_1.runDetached)(() => this.onclose(), (error) => log('onclose failed', error));
+                    this.emit('close');
+                    break;
+                case 'closing':
+                    if (this.onclosing)
+                        (0, common_js_1.runDetached)(() => this.onclosing(), (error) => log('onclosing failed', error));
+                    break;
+            }
+            log('change state', state);
+        }
+    }
+    addBufferedAmount(amount) {
+        const crossesThreshold = this.bufferedAmount > this.bufferedAmountLowThreshold &&
+            this.bufferedAmount + amount <= this.bufferedAmountLowThreshold;
+        this.bufferedAmount += amount;
+        this.bufferedAmountChanged.execute();
+        if (crossesThreshold) {
+            this.bufferedAmountLow.execute();
+            this.emit('bufferedamountlow');
+        }
+    }
+    send(data) {
+        const size = this.sctp.datachannelSend(this, data);
+        this.messagesSent++;
+        this.bytesSent += size;
+    }
+    close() {
+        this.sctp.dataChannelClose(this);
+    }
+}
+exports.RTCDataChannel = RTCDataChannel;
+class RTCDataChannelParameters {
+    constructor(props = {}) {
+        this.label = '';
+        this.ordered = true;
+        this.protocol = '';
+        this.negotiated = false;
+        Object.assign(this, props);
+    }
+}
+exports.RTCDataChannelParameters = RTCDataChannelParameters;

package/dist/cjs/lib/peer/errors.d.ts

@@ -0,0 +1,11 @@
+export type WebRtcDomExceptionName = 'AbortError' | 'InvalidAccessError' | 'InvalidModificationError' | 'InvalidStateError' | 'NotAllowedError' | 'NotFoundError' | 'NotReadableError' | 'NotSupportedError' | 'OperationError';
+export declare function createWebRtcDomException(name: WebRtcDomExceptionName, message?: string): DOMException;
+export declare function createWebRtcTypeError(message: string): TypeError;
+/**
+ * Media Capture and Streams `OverconstrainedError`.
+ * WPT `overconstrainederror.html` requires a DOMException subclass with `constraint`.
+ */
+export declare class OverconstrainedError extends DOMException {
+    readonly constraint: string;
+    constructor(constraint: string, message?: string);
+}

package/dist/cjs/lib/peer/errors.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OverconstrainedError = void 0;
+exports.createWebRtcDomException = createWebRtcDomException;
+exports.createWebRtcTypeError = createWebRtcTypeError;
+function createWebRtcDomException(name, message = name) {
+    return new DOMException(message, name);
+}
+function createWebRtcTypeError(message) {
+    return new TypeError(message);
+}
+/**
+ * Media Capture and Streams `OverconstrainedError`.
+ * WPT `overconstrainederror.html` requires a DOMException subclass with `constraint`.
+ */
+class OverconstrainedError extends DOMException {
+    constructor(constraint, message = '') {
+        super(message, 'OverconstrainedError');
+        Object.setPrototypeOf(this, new.target.prototype);
+        this.constraint = constraint;
+    }
+}
+exports.OverconstrainedError = OverconstrainedError;

package/dist/cjs/lib/peer/helper.d.ts

@@ -0,0 +1,20 @@
+import { EventEmitter } from 'node:events';
+export declare function enumerate<T>(arr: T[]): [number, T][];
+export declare function divide(from: string, split: string): [string, string];
+export declare class PromiseQueue {
+    queue: {
+        promise: () => Promise<any>;
+        done: () => void;
+    }[];
+    running: boolean;
+    push: (promise: () => Promise<any>) => Promise<void>;
+    private run;
+}
+export declare class EventTarget extends EventEmitter {
+    emit(type: string | symbol, ...args: any[]): boolean;
+    addEventListener: (type: string, listener: (...args: any[]) => void, options?: boolean | {
+        once?: boolean;
+    }) => void;
+    removeEventListener: (type: string, listener: (...args: any[]) => void) => void;
+    dispatchEvent: (event: Event) => boolean;
+}

package/dist/cjs/lib/peer/helper.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventTarget = exports.PromiseQueue = void 0;
+exports.enumerate = enumerate;
+exports.divide = divide;
+const node_events_1 = require("node:events");
+const common_js_1 = require("./imports/common.js");
+const log = (0, common_js_1.debug)('webrtc/peer/helper');
+function enumerate(arr) {
+    return arr.map((v, i) => [i, v]);
+}
+function divide(from, split) {
+    const arr = from.split(split);
+    return [arr[0], arr.slice(1).join(split)];
+}
+class PromiseQueue {
+    constructor() {
+        this.queue = [];
+        this.running = false;
+        this.push = (promise) => new Promise((r) => {
+            this.queue.push({ promise, done: r });
+            if (!this.running)
+                void this.run();
+        });
+    }
+    async run() {
+        const task = this.queue.shift();
+        if (task) {
+            this.running = true;
+            //A failed task is logged and the queue goes on: its caller is released as for a task done
+            try {
+                await task.promise();
+            }
+            catch (error) {
+                log('task failed', error);
+            }
+            task.done();
+            void this.run();
+        }
+        else {
+            this.running = false;
+        }
+    }
+}
+exports.PromiseQueue = PromiseQueue;
+class EventTarget extends node_events_1.EventEmitter {
+    constructor() {
+        super(...arguments);
+        this.addEventListener = (type, listener, options) => {
+            if (typeof options === 'object' && options?.once) {
+                this.once(type, listener);
+                return;
+            }
+            this.addListener(type, listener);
+        };
+        this.removeEventListener = (type, listener) => {
+            this.removeListener(type, listener);
+        };
+        this.dispatchEvent = (event) => this.emit(event.type, event);
+    }
+    emit(type, ...args) {
+        if (typeof type !== 'string') {
+            return super.emit(type, ...args);
+        }
+        if (args.length === 0) {
+            return super.emit(type, new Event(type));
+        }
+        const [event, ...rest] = args;
+        if (event && typeof event === 'object' && !('type' in event)) {
+            try {
+                Object.defineProperty(event, 'type', {
+                    configurable: true,
+                    enumerable: true,
+                    value: type
+                });
+            }
+            catch {
+                return super.emit(type, { type, ...event }, ...rest);
+            }
+        }
+        return super.emit(type, event, ...rest);
+    }
+}
+exports.EventTarget = EventTarget;

package/dist/cjs/lib/peer/imports/common.d.ts

@@ -0,0 +1 @@
+export * from '../../common/index.js';

package/dist/cjs/lib/peer/imports/common.js

@@ -0,0 +1,17 @@
+"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 });
+__exportStar(require("../../common/index.js"), exports);

package/dist/cjs/lib/peer/imports/dtls.d.ts

@@ -0,0 +1 @@
+export * from '../../dtls/index.js';

package/dist/cjs/lib/peer/imports/dtls.js

@@ -0,0 +1,17 @@
+"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 });
+__exportStar(require("../../dtls/index.js"), exports);

package/dist/cjs/lib/peer/imports/ice.d.ts

@@ -0,0 +1 @@
+export * from '../../ice/index.js';

package/dist/cjs/lib/peer/imports/ice.js

@@ -0,0 +1,17 @@
+"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 });
+__exportStar(require("../../ice/index.js"), exports);

package/dist/cjs/lib/peer/imports/rtp.d.ts

@@ -0,0 +1 @@
+export * from '../../rtp/index.js';

package/dist/cjs/lib/peer/imports/rtp.js

@@ -0,0 +1,17 @@
+"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 });
+__exportStar(require("../../rtp/index.js"), exports);

package/dist/cjs/lib/peer/index.d.ts

@@ -0,0 +1,14 @@
+export * from './imports/common.js';
+export * from './imports/dtls.js';
+export * from './imports/ice.js';
+export * from './imports/rtp.js';
+export * from './dataChannel.js';
+export * from './media/index.js';
+export * from './peerConnection.js';
+export * from './sdp.js';
+export * from './transport/dtls.js';
+export * from './transport/ice.js';
+export * from './transport/sctp.js';
+export * from './types/domain.js';
+export * from './utils.js';
+export * from './sdpManager.js';