@lakutata/webrtc 0.0.0-stage → 3.1.4

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

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Candidate = void 0;
+exports.candidateLocalPreference = candidateLocalPreference;
+exports.candidateFoundation = candidateFoundation;
+exports.candidatePriority = candidatePriority;
+exports.remoteTcpTypeForIncoming = remoteTcpTypeForIncoming;
+const node_crypto_1 = require("node:crypto");
+const node_net_1 = require("node:net");
+class Candidate {
+    constructor(foundation, component, transport, priority, host, port, type, relatedAddress, relatedPort, tcptype, generation, ufrag) {
+        this.foundation = foundation;
+        this.component = component;
+        this.transport = transport;
+        this.priority = priority;
+        this.host = host;
+        this.port = port;
+        this.type = type;
+        this.relatedAddress = relatedAddress;
+        this.relatedPort = relatedPort;
+        this.tcptype = tcptype;
+        this.generation = generation;
+        this.ufrag = ufrag;
+        // An ICE candidate.
+        this.id = (0, node_crypto_1.randomUUID)().toString();
+    }
+    refreshId() {
+        this.id = (0, node_crypto_1.randomUUID)().toString();
+    }
+    static fromSdp(sdp) {
+        // Parse a :class:`Candidate` from SDP.
+        // .. code-block:: python
+        //    Candidate.from_sdp(
+        //     '6815297761 1 udp 659136 1.2.3.4 31102 typ host generation 0 ufrag b7l3')
+        const bits = sdp.split(' ');
+        if (bits.length < 8) {
+            throw new Error('SDP does not have enough properties');
+        }
+        // 固定ワード
+        const kwargs = {
+            foundation: bits[0],
+            component: Number(bits[1]),
+            transport: bits[2],
+            priority: Number(bits[3]),
+            host: bits[4],
+            port: Number(bits[5]),
+            type: bits[7]
+        };
+        for (let i = 8, il = bits.length - 1; i < il; i += 2) {
+            if (bits[i] === 'raddr') {
+                kwargs['related_address'] = bits[i + 1];
+            }
+            else if (bits[i] === 'rport') {
+                kwargs['related_port'] = Number(bits[i + 1]);
+            }
+            else if (bits[i] === 'tcptype') {
+                kwargs['tcptype'] = bits[i + 1];
+            }
+            else if (bits[i] === 'generation') {
+                kwargs['generation'] = Number(bits[i + 1]);
+            }
+            else if (bits[i] === 'ufrag') {
+                kwargs['ufrag'] = bits[i + 1];
+            }
+        }
+        const { foundation, component, transport, priority, host, port, type } = kwargs;
+        return new Candidate(foundation, component, transport, priority, host, port, type, kwargs['related_address'], kwargs['related_port'], kwargs['tcptype'], kwargs['generation'], kwargs['ufrag']);
+    }
+    canPairWith(other) {
+        // """
+        // A local candidate is paired with a remote candidate if and only if
+        // the two candidates have the same component ID and have the same IP
+        // address version.
+        // """
+        const a = (0, node_net_1.isIPv4)(this.host);
+        const b = (0, node_net_1.isIPv4)(other.host);
+        return (this.component === other.component &&
+            this.transport.toLowerCase() === other.transport.toLowerCase() &&
+            canPairTcpCandidates(this, other) &&
+            a === b);
+    }
+    toSdp() {
+        let sdp = `${this.foundation} ${this.component} ${this.transport} ${this.priority} ${this.host} ${this.port} typ ${this.type}`;
+        if (this.relatedAddress)
+            sdp += ` raddr ${this.relatedAddress}`;
+        if (this.relatedPort != undefined)
+            sdp += ` rport ${this.relatedPort}`;
+        if (this.tcptype)
+            sdp += ` tcptype ${this.tcptype}`;
+        if (this.generation != undefined)
+            sdp += ` generation ${this.generation}`;
+        if (this.ufrag != undefined)
+            sdp += ` ufrag ${this.ufrag}`;
+        return sdp;
+    }
+}
+exports.Candidate = Candidate;
+const UDP_TYPE_PREFERENCE = {
+    host: 126,
+    prflx: 110,
+    srflx: 100,
+    relay: 0
+};
+const TCP_TYPE_PREFERENCE = {
+    host: 105,
+    prflx: 90,
+    srflx: 80,
+    relay: 0
+};
+const ACTIVE_PASSIVE_DIRECTION_PREFERENCE = {
+    active: 6,
+    passive: 4,
+    so: 2
+};
+const REFLEXIVE_DIRECTION_PREFERENCE = {
+    active: 4,
+    passive: 2,
+    so: 6
+};
+function normalizeTransport(transport) {
+    return transport?.toLowerCase() ?? 'udp';
+}
+function normalizeTcpType(tcptype) {
+    switch (tcptype) {
+        case 'active':
+        case 'passive':
+        case 'so':
+            return tcptype;
+        default:
+            return undefined;
+    }
+}
+function canPairTcpCandidates(local, remote) {
+    if (normalizeTransport(local.transport) !== 'tcp') {
+        return true;
+    }
+    const localType = normalizeTcpType(local.tcptype);
+    const remoteType = normalizeTcpType(remote.tcptype);
+    if (!localType || !remoteType) {
+        return false;
+    }
+    return ((localType === 'active' && remoteType === 'passive') ||
+        (localType === 'passive' && remoteType === 'active') ||
+        (localType === 'so' && remoteType === 'so'));
+}
+function candidateLocalPreference({ candidateType, transport = 'udp', tcptype, otherPreference = 8191 }) {
+    if (normalizeTransport(transport) !== 'tcp') {
+        return otherPreference;
+    }
+    const tcpType = normalizeTcpType(tcptype) ?? 'active';
+    const directionPreference = candidateType === 'srflx' || candidateType === 'prflx'
+        ? REFLEXIVE_DIRECTION_PREFERENCE[tcpType]
+        : ACTIVE_PASSIVE_DIRECTION_PREFERENCE[tcpType];
+    return (1 << 13) * directionPreference + otherPreference;
+}
+function candidateTypePreference(candidateType, transport = 'udp') {
+    const table = normalizeTransport(transport) === 'tcp'
+        ? TCP_TYPE_PREFERENCE
+        : UDP_TYPE_PREFERENCE;
+    return table[candidateType] ?? 0;
+}
+function candidateFoundation(candidateType, candidateTransport, baseAddress, server) {
+    // """
+    // See RFC 5245 - 4.1.1.3. Computing Foundations
+    // """
+    //The candidates from different STUN or TURN servers have different foundations (RFC 8445, section 5.1.1.3)
+    const key = server === undefined
+        ? `${candidateType}|${candidateTransport}|${baseAddress}`
+        : `${candidateType}|${candidateTransport}|${baseAddress}|${server}`;
+    return (0, node_crypto_1.createHash)('md5').update(key, 'ascii').digest('hex').slice(7);
+}
+// priorityを決める
+function candidatePriority(candidateType, options = 65535) {
+    const candidateComponent = 1;
+    // See RFC 5245 - 4.1.2.1. Recommended Formula
+    const transport = typeof options === 'number' ? 'udp' : normalizeTransport(options.transport);
+    const localPref = typeof options === 'number'
+        ? options
+        : (options.localPreference ??
+            candidateLocalPreference({
+                candidateType,
+                transport,
+                tcptype: options.tcptype,
+                otherPreference: options.otherPreference
+            }));
+    const typePref = candidateTypePreference(candidateType, transport);
+    return ((1 << 24) * typePref + (1 << 8) * localPref + (256 - candidateComponent));
+}
+function remoteTcpTypeForIncoming(localTcpType) {
+    switch (localTcpType) {
+        case 'passive':
+            return 'active';
+        case 'active':
+            return 'passive';
+        default:
+            return 'so';
+    }
+}

package/dist/cjs/lib/ice/dns/lookup.d.ts

@@ -0,0 +1,16 @@
+import * as worker_thread from 'node:worker_threads';
+import { MulticastDns } from './mdns.js';
+export declare class MdnsLookup {
+    cache: Map<string, Promise<string>>;
+    mdnsInstance: MulticastDns;
+    constructor();
+    lookup(host: string): Promise<string>;
+    close(): void;
+}
+export declare class DnsLookup {
+    thread: worker_thread.Worker;
+    cache: Map<string, Promise<string>>;
+    constructor();
+    lookup(host: string): Promise<string>;
+    close(): Promise<number>;
+}

package/dist/cjs/lib/ice/dns/lookup.js

@@ -0,0 +1,133 @@
+"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.DnsLookup = exports.MdnsLookup = void 0;
+const worker_thread = __importStar(require("node:worker_threads"));
+const mdns_js_1 = require("./mdns.js");
+class MdnsLookup {
+    constructor() {
+        this.cache = new Map();
+        this.mdnsInstance = new mdns_js_1.MulticastDns();
+        this.mdnsInstance.setMaxListeners(50);
+    }
+    lookup(host) {
+        return new Promise((r, f) => {
+            const cleanup = () => {
+                this.mdnsInstance.removeListener('response', l);
+                clearTimeout(timeout);
+            };
+            const timeout = setTimeout(() => {
+                cleanup();
+                f(new Error('No mDNS response'));
+            }, 10000);
+            const l = (answers) => {
+                const a = answers.find((answer) => answer.type === 'A' &&
+                    answer.name.toLowerCase() === host.toLowerCase());
+                if (!a) {
+                    return;
+                }
+                cleanup();
+                r(a.data);
+            };
+            this.mdnsInstance.on('response', l);
+            this.mdnsInstance.query(host, 'A').catch((error) => {
+                cleanup();
+                f(error);
+            });
+        });
+    }
+    close() {
+        this.mdnsInstance.destroy();
+    }
+}
+exports.MdnsLookup = MdnsLookup;
+class DnsLookup {
+    constructor() {
+        this.cache = new Map();
+        const lookupWorkerFunction = () => {
+            const worker_thread = global.require('worker_threads');
+            const { lookup } = global.require('dns');
+            const dnsLookup = (host) => lookup(host, (err, address, family) => {
+                const res = {
+                    err: err?.message,
+                    address,
+                    family,
+                    host
+                };
+                worker_thread.parentPort?.postMessage(res);
+                process.exit();
+            });
+            worker_thread.parentPort?.on('message', (message) => {
+                const { host } = message;
+                dnsLookup(host);
+            });
+        };
+        const lookupEval = `(${lookupWorkerFunction})()`;
+        this.thread = new worker_thread.Worker(lookupEval, {
+            eval: true
+        });
+        this.thread.setMaxListeners(100);
+    }
+    async lookup(host) {
+        let cached = this.cache.get(host);
+        if (cached) {
+            return cached;
+        }
+        cached = new Promise((r, f) => {
+            const exitListener = (exitCode) => f(new Error(`dns.lookup thread exited unexpectedly: ${exitCode}`));
+            const threadMessageListener = (result) => {
+                if (result.host !== host) {
+                    return;
+                }
+                this.thread.removeListener('message', threadMessageListener);
+                this.thread.removeListener('exit', exitListener);
+                if (!result.address)
+                    return f(new Error(result.err || 'dns.lookup thread unknown error'));
+                r(result.address);
+            };
+            this.thread.on('message', threadMessageListener);
+            this.thread.on('exit', exitListener);
+            this.thread.postMessage({
+                host
+            });
+        });
+        this.cache.set(host, cached);
+        return cached;
+    }
+    close() {
+        return this.thread.terminate();
+    }
+}
+exports.DnsLookup = DnsLookup;

package/dist/cjs/lib/ice/dns/mdns.d.ts

@@ -0,0 +1,38 @@
+import { type RemoteInfo } from 'node:dgram';
+import { EventEmitter } from 'node:events';
+/**
+ * A record of an mDNS answer
+ */
+export interface MdnsAnswer {
+    name: string;
+    type: 'A' | 'AAAA' | number;
+    ttl: number;
+    data: string | Buffer;
+}
+/**
+ * The answers (and additional records) of an mDNS response; undefined when the packet is a query or malformed
+ */
+export declare function parseMdnsResponse(packet: Buffer): MdnsAnswer[] | undefined;
+/**
+ * A query of one name: no id, no flags, one question of class IN
+ */
+export declare function encodeMdnsQuery(name: string, type: 'A' | 'AAAA'): Buffer;
+/**
+ * A client of multicast DNS (RFC 6762) that only queries: it joins the group on port 5353 (shared with the other
+ * responders of the host) and emits the answers of every response it hears
+ */
+export declare class MulticastDns extends EventEmitter<{
+    response: [MdnsAnswer[], RemoteInfo];
+    error: [Error];
+}> {
+    #private;
+    constructor();
+    /**
+     * Sends a query of a name to the group
+     */
+    query(name: string, type?: 'A' | 'AAAA'): Promise<void>;
+    /**
+     * Leaves the group and closes the socket
+     */
+    destroy(): void;
+}

package/dist/cjs/lib/ice/dns/mdns.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MulticastDns = void 0;
+exports.parseMdnsResponse = parseMdnsResponse;
+exports.encodeMdnsQuery = encodeMdnsQuery;
+const node_dgram_1 = require("node:dgram");
+const node_events_1 = require("node:events");
+const multicastAddress = '224.0.0.251';
+const multicastPort = 5353;
+const typeCodes = { A: 1, AAAA: 28 };
+//A name as DNS labels: each label prefixed with its length, then a zero
+function encodeName(name) {
+    const parts = name.replace(/\.$/, '').split('.').map((label) => {
+        const bytes = Buffer.from(label, 'utf8');
+        return Buffer.concat([Buffer.from([bytes.length]), bytes]);
+    });
+    return Buffer.concat([...parts, Buffer.from([0])]);
+}
+//A name at an offset, following the compression pointers (RFC 1035 section 4.1.4); the offset after it
+function decodeName(packet, start) {
+    const labels = [];
+    let offset = start;
+    let end = -1;
+    for (let jumps = 0; jumps < 64; jumps++) {
+        const length = packet[offset];
+        if (length === undefined)
+            throw new Error('truncated name');
+        if (length === 0) {
+            offset++;
+            break;
+        }
+        if ((length & 0xc0) === 0xc0) {
+            if (end < 0)
+                end = offset + 2;
+            offset = ((length & 0x3f) << 8) | packet[offset + 1];
+            continue;
+        }
+        labels.push(packet.toString('utf8', offset + 1, offset + 1 + length));
+        offset += 1 + length;
+    }
+    return [labels.join('.'), end < 0 ? offset : end];
+}
+function formatAddress(type, data) {
+    if (type === typeCodes.A && data.length === 4)
+        return Array.from(data).join('.');
+    if (type === typeCodes.AAAA && data.length === 16) {
+        const groups = [];
+        for (let i = 0; i < 16; i += 2)
+            groups.push(data.readUInt16BE(i).toString(16));
+        return groups.join(':');
+    }
+    return data;
+}
+/**
+ * The answers (and additional records) of an mDNS response; undefined when the packet is a query or malformed
+ */
+function parseMdnsResponse(packet) {
+    try {
+        if (packet.length < 12 || !(packet[2] & 0x80))
+            return undefined;
+        const questions = packet.readUInt16BE(4);
+        const records = packet.readUInt16BE(6) + packet.readUInt16BE(8) + packet.readUInt16BE(10);
+        let offset = 12;
+        for (let i = 0; i < questions; i++)
+            offset = decodeName(packet, offset)[1] + 4;
+        const answers = [];
+        for (let i = 0; i < records; i++) {
+            const [name, next] = decodeName(packet, offset);
+            const type = packet.readUInt16BE(next);
+            const ttl = packet.readUInt32BE(next + 4);
+            const length = packet.readUInt16BE(next + 8);
+            const data = packet.subarray(next + 10, next + 10 + length);
+            offset = next + 10 + length;
+            const known = type === typeCodes.A ? 'A' : type === typeCodes.AAAA ? 'AAAA' : undefined;
+            answers.push({ name, type: known ?? type, ttl, data: formatAddress(type, data) });
+        }
+        return answers;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * A query of one name: no id, no flags, one question of class IN
+ */
+function encodeMdnsQuery(name, type) {
+    const header = Buffer.alloc(12);
+    header.writeUInt16BE(1, 4);
+    const question = Buffer.alloc(4);
+    question.writeUInt16BE(typeCodes[type], 0);
+    question.writeUInt16BE(1, 2);
+    return Buffer.concat([header, encodeName(name), question]);
+}
+/**
+ * A client of multicast DNS (RFC 6762) that only queries: it joins the group on port 5353 (shared with the other
+ * responders of the host) and emits the answers of every response it hears
+ */
+class MulticastDns extends node_events_1.EventEmitter {
+    #socket;
+    #ready;
+    constructor() {
+        super();
+        this.#socket = (0, node_dgram_1.createSocket)({ type: 'udp4', reuseAddr: true });
+        this.#socket.on('error', (error) => void this.emit('error', error));
+        this.#socket.on('message', (message, remote) => {
+            const answers = parseMdnsResponse(message);
+            if (answers?.length)
+                this.emit('response', answers, remote);
+        });
+        this.#ready = new Promise((resolve) => {
+            this.#socket.bind(multicastPort, () => {
+                try {
+                    this.#socket.addMembership(multicastAddress);
+                    this.#socket.setMulticastTTL(255);
+                    this.#socket.setMulticastLoopback(true);
+                }
+                catch (error) {
+                    this.emit('error', error);
+                }
+                resolve();
+            });
+        });
+    }
+    /**
+     * Sends a query of a name to the group
+     */
+    async query(name, type = 'A') {
+        await this.#ready;
+        await new Promise((resolve, reject) => {
+            this.#socket.send(encodeMdnsQuery(name, type), multicastPort, multicastAddress, (error) => error ? reject(error) : resolve());
+        });
+    }
+    /**
+     * Leaves the group and closes the socket
+     */
+    destroy() {
+        try {
+            this.#socket.close();
+        }
+        catch {
+            //Already closed
+        }
+    }
+}
+exports.MulticastDns = MulticastDns;

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

@@ -0,0 +1,24 @@
+import type { Address } from './imports/common.js';
+import type { Message } from './stun/message.js';
+export declare class TransactionError extends Error {
+    response?: Message;
+    addr?: Address;
+}
+export declare class TransactionFailed extends TransactionError {
+    response: Message;
+    addr: Address;
+    constructor(response: Message, addr: Address);
+    get str(): string;
+}
+export declare class TransactionTimeout extends TransactionError {
+    get str(): string;
+}
+/**
+ * The request target is an IP literal of a different family than the socket
+ * that would carry it, so it can never be delivered.
+ */
+export declare class AddressFamilyMismatch extends Error {
+    addr: Address;
+    socketFamily: 4 | 6;
+    constructor(addr: Address, socketFamily: 4 | 6);
+}

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddressFamilyMismatch = exports.TransactionTimeout = exports.TransactionFailed = exports.TransactionError = void 0;
+class TransactionError extends Error {
+}
+exports.TransactionError = TransactionError;
+class TransactionFailed extends TransactionError {
+    constructor(response, addr) {
+        super();
+        this.response = response;
+        this.addr = addr;
+    }
+    get str() {
+        let out = 'STUN transaction failed';
+        const attribute = this.response.getAttributeValue('ERROR-CODE');
+        if (attribute) {
+            const [code, msg] = attribute;
+            out += ` (${code} - ${msg})`;
+        }
+        return out;
+    }
+}
+exports.TransactionFailed = TransactionFailed;
+class TransactionTimeout extends TransactionError {
+    get str() {
+        return 'STUN transaction timed out';
+    }
+}
+exports.TransactionTimeout = TransactionTimeout;
+/**
+ * The request target is an IP literal of a different family than the socket
+ * that would carry it, so it can never be delivered.
+ */
+class AddressFamilyMismatch extends Error {
+    constructor(addr, socketFamily) {
+        super(`cannot reach ${addr[0]}:${addr[1]} from an IPv${socketFamily} socket`);
+        this.addr = addr;
+        this.socketFamily = socketFamily;
+    }
+}
+exports.AddressFamilyMismatch = AddressFamilyMismatch;

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

@@ -0,0 +1,17 @@
+import { Event } from './imports/common.js';
+export declare function randomString(length: number): string;
+export declare function randomTransactionId(): NonSharedBuffer;
+export declare function bufferXor(a: Buffer, b: Buffer): Buffer;
+export declare function difference<T>(x: Set<T>, y: Set<T>): Set<T>;
+export declare class PQueue<T> {
+    private queue;
+    private wait;
+    put(v: Promise<T>): void;
+    get(): Promise<T>;
+}
+export declare const cancelable: <T>(ex: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void, onCancel: Event<[any]>) => Promise<void>) => {
+    awaitable: Promise<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+};
+export type Cancelable<T> = ReturnType<typeof cancelable<T>>;

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

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cancelable = exports.PQueue = void 0;
+exports.randomString = randomString;
+exports.randomTransactionId = randomTransactionId;
+exports.bufferXor = bufferXor;
+exports.difference = difference;
+const node_crypto_1 = require("node:crypto");
+const common_js_1 = require("./imports/common.js");
+function randomString(length) {
+    return (0, node_crypto_1.randomBytes)(length).toString('hex').substring(0, length);
+}
+function randomTransactionId() {
+    return (0, node_crypto_1.randomBytes)(12);
+}
+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 difference(x, y) {
+    return new Set([...x].filter((e) => !y.has(e)));
+}
+// infinite size queue
+class PQueue {
+    constructor() {
+        this.queue = [];
+        this.wait = new common_js_1.Event();
+    }
+    put(v) {
+        this.queue.push(v);
+        if (this.queue.length === 1) {
+            this.wait.execute(v);
+        }
+    }
+    get() {
+        const v = this.queue.shift();
+        if (!v) {
+            return new Promise((r) => {
+                this.wait.subscribe((v) => {
+                    void this.queue.shift();
+                    r(v);
+                });
+            });
+        }
+        return v;
+    }
+}
+exports.PQueue = PQueue;
+const cancelable = (ex) => {
+    let resolve;
+    let reject;
+    const p = new Promise((r, f) => {
+        resolve = r;
+        reject = f;
+    });
+    p.then(() => {
+        onCancel.execute(undefined);
+        onCancel.complete();
+    }).catch((e) => {
+        onCancel.execute(e ?? new Error());
+        onCancel.complete();
+    });
+    const onCancel = new common_js_1.Event();
+    ex(resolve, reject, onCancel).catch(() => { });
+    return { awaitable: p, resolve, reject };
+};
+exports.cancelable = cancelable;