@4players/odin-plugin-web 1.0.0-alpha.20 → 1.0.0-alpha.21

package/lib/plugin/token.js

@@ -1,66 +0,0 @@
-import { TokenClaimsSchema, failure, fromBase64Url, success, } from '@4players/odin-common';
-export class Token {
-    static parse(token) {
-        const segments = token.split('.');
-        if (segments.length !== 3)
-            return failure('expected three segments');
-        const body = fromBase64Url(segments[1]);
-        if (body.type === 'Failure') {
-            return failure(`invalid token; ${body.reason}`);
-        }
-        let json;
-        try {
-            json = JSON.parse(body.value);
-        }
-        catch (reason) {
-            return failure(`invalid token; ${reason}`);
-        }
-        const parsed = TokenClaimsSchema.safeParse(json);
-        if (parsed.success === false) {
-            return failure(`invalid token; ${parsed.error}`);
-        }
-        return success(new Token(token, parsed.data));
-    }
-    constructor(text, claims) {
-        this.text = text;
-        this.claims = claims;
-        if (claims.ups !== undefined) {
-            const upstream = Token.parse(claims.ups);
-            if (upstream.type === 'Success') {
-                this._Upstream = upstream.value;
-            }
-            else {
-                console.error(`upstream in token can not be parsed; ${upstream.reason}`);
-            }
-        }
-    }
-    get timeLeft() {
-        if (this.claims.exp === undefined)
-            return Infinity;
-        return this.claims.exp * 1000 - Date.now();
-    }
-    get upstream() {
-        return this._Upstream;
-    }
-    get defaultRoomId() {
-        if (Array.isArray(this.claims.rid)) {
-            return this.claims.rid.length === 1 ? this.claims.rid[0] : undefined;
-        }
-        else {
-            return this.claims.rid;
-        }
-    }
-    hasAudience(audience) {
-        if (this.claims.aud === undefined)
-            return true;
-        if (Array.isArray(this.claims.aud)) {
-            return this.claims.aud.includes(audience);
-        }
-        else {
-            return this.claims.aud === audience;
-        }
-    }
-    toString() {
-        return this.text;
-    }
-}

package/lib/plugin/webrtc/mainConnection.d.ts

@@ -1,53 +0,0 @@
-import { MainCommands, MainNotifications, Result } from '@4players/odin-common';
-import { type MainConnection, type DatagramHandler, ConnectionStatus } from '../mainConnection';
-import { Token } from '../token';
-import { RpcConnection, TypedRpcConnection } from '../rpcConnection';
-import { Transport } from '../index';
-export declare class WebRtcMainConnection implements MainConnection {
-    readonly id: number;
-    readonly address: string;
-    readonly url: URL;
-    readonly onDatagram: DatagramHandler;
-    readonly connection: TypedRpcConnection<MainCommands, MainNotifications>;
-    readonly webRtc: RTCPeerConnection;
-    static create(id: number, address: string, onDatagram: DatagramHandler, signal: AbortSignal): Promise<Result<MainConnection>>;
-    private readonly _AudioChannel;
-    private readonly _PeerIdMap;
-    private _PeriodicHealthCheck;
-    private _WebRtcIceTimeout;
-    private _WebRtcTimeout;
-    private _ClosePromise;
-    private _LocalVideos;
-    private _RemoteVideos;
-    private _Negotiation;
-    private _ResolveOffer?;
-    private _awaitingRemoteTracks;
-    get transport(): Transport;
-    get closePromise(): Promise<"closed">;
-    get closeSignal(): AbortSignal;
-    get closed(): boolean;
-    get status(): ConnectionStatus;
-    waitForConnected(): Promise<void>;
-    private constructor();
-    close(): void;
-    joinRoom(token: Token, roomId: string, userData: Uint8Array, position: [number, number, number]): Promise<Result<RpcConnection> | 'closed'>;
-    getReconnectToken(peerId: number): Promise<Result<Token>>;
-    sendDatagram(datagram: Uint8Array): void;
-    healthCheck(): Promise<boolean>;
-    private _Request;
-    private _readWebRtcUpdate;
-    private _SendOffer;
-    private _OnWebRtcStatusChanged;
-    private _OnWebRtcUpdate;
-    private _UpdateRemoteSdp;
-    private _AddIceCandidate;
-    private _OnIceCandidate;
-    private ensureTransceivers;
-    startLocalVideo(mediaId: number, track: MediaStreamTrack): Promise<void>;
-    stopLocalVideo(mediaId: number): void;
-    startRemoteVideo(mediaId: number): Promise<MediaStreamTrack>;
-    stopRemoteVideo(mediaId: number): void;
-    private onTrack;
-    requestNegotiation(waitForAnswer: boolean): void;
-    private _CleanUp;
-}

package/lib/plugin/webrtc/mainConnection.js

@@ -1,455 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { MainCommandsRpc, MainNotificationsRpc, assert, extendUrl, failure, success, fail, } from '@4players/odin-common';
-import { ConnectionStatus, } from '../mainConnection';
-import { Token } from '../token';
-import { RpcConnection, TypedRpcConnection } from '../rpcConnection';
-import { connect } from './websocket';
-import { HealthCheckTimeout, logger, MainConnectionPingInterval, WebRtcIceTimeout, WebRtcTimeout, } from '../config';
-import { Transport } from '../index';
-export class WebRtcMainConnection {
-    static create(id, address, onDatagram, signal) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (signal.aborted)
-                return failure('aborted');
-            let url;
-            try {
-                url = new URL(`wss://${address}`);
-            }
-            catch (error) {
-                return fail(`address in token(${address}) can not be parsed; ${error}`);
-            }
-            const webSocketUrl = extendUrl(url, 'main');
-            if (webSocketUrl.type !== 'Success')
-                return webSocketUrl;
-            const webSocket = yield connect(webSocketUrl.value, signal);
-            if (webSocket.type !== 'Success')
-                return webSocket;
-            const connection = new TypedRpcConnection(new RpcConnection(webSocket.value), MainCommandsRpc, MainNotificationsRpc);
-            try {
-                return success(new WebRtcMainConnection(id, address, url, onDatagram, connection, new RTCPeerConnection()));
-            }
-            catch (reason) {
-                connection.close();
-                return failure(`unable to create webrtc connection; ${reason}`);
-            }
-        });
-    }
-    get transport() {
-        return Transport.H3;
-    }
-    get closePromise() {
-        return this._ClosePromise;
-    }
-    get closeSignal() {
-        return this.connection.closeSignal;
-    }
-    get closed() {
-        return this.connection.closed;
-    }
-    get status() {
-        switch (this.webRtc.connectionState) {
-            case 'connected':
-                return ConnectionStatus.Connected;
-            case 'failed':
-            case 'closed':
-                return ConnectionStatus.Closed;
-            default:
-                return ConnectionStatus.Connecting;
-        }
-    }
-    waitForConnected() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => {
-                const onConnectionStateChanged = () => {
-                    const status = this.status;
-                    if (status === ConnectionStatus.Connecting)
-                        return;
-                    this.webRtc.removeEventListener('connectionstatechange', onConnectionStateChanged);
-                    if (status === ConnectionStatus.Connected) {
-                        resolve();
-                    }
-                    else {
-                        reject(new Error('connection closed'));
-                    }
-                };
-                this.webRtc.addEventListener('connectionstatechange', onConnectionStateChanged);
-                onConnectionStateChanged();
-            });
-        });
-    }
-    constructor(id, address, url, onDatagram, connection, webRtc) {
-        this.id = id;
-        this.address = address;
-        this.url = url;
-        this.onDatagram = onDatagram;
-        this.connection = connection;
-        this.webRtc = webRtc;
-        this._PeerIdMap = new WeakMap();
-        this._LocalVideos = new Map();
-        this._RemoteVideos = new Map();
-        this._Negotiation = { requested: false, running: false };
-        this._awaitingRemoteTracks = new Map();
-        logger.info(['Connection', 'WebRTC'], 'WebRtcMainConnection.constructor()');
-        this.closeSignal.addEventListener('abort', () => this._CleanUp(), {
-            once: true,
-        });
-        this._ClosePromise = new Promise((accept) => {
-            this.closeSignal.addEventListener('abort', () => {
-                logger.debug(['Connection', 'WebRTC'], 'WebRtcMainConnection.constructor(): _ClosePromise aborted');
-                accept('closed');
-            }, {
-                once: true,
-            });
-        });
-        this._AudioChannel = this.webRtc.createDataChannel('audio', {
-            id: 2,
-            negotiated: true,
-            ordered: false,
-            maxRetransmits: 0,
-        });
-        this._AudioChannel.binaryType = 'arraybuffer';
-        this._AudioChannel.onmessage = (event) => onDatagram(this.id, new Uint8Array(event.data));
-        this.webRtc.onicecandidate = this._OnIceCandidate.bind(this);
-        this.webRtc.onconnectionstatechange = () => this._OnWebRtcStatusChanged();
-        this.webRtc.ontrack = this.onTrack.bind(this);
-        this._SendOffer();
-        if (MainConnectionPingInterval !== undefined) {
-            this._PeriodicHealthCheck = setInterval(() => this.healthCheck(), MainConnectionPingInterval);
-        }
-        this._readWebRtcUpdate();
-    }
-    close() {
-        console.debug('MainConnection close(): ', this._PeerIdMap);
-        logger.log(['WebRTC', 'Connection'], 'MainConnection close(): ', this._PeerIdMap);
-        this.connection.close();
-    }
-    joinRoom(token, roomId, userData, position) {
-        return __awaiter(this, void 0, void 0, function* () {
-            logger.info(['Connection', 'WebRTC'], 'WebRtcMainConnection.joinRoom()');
-            const response = yield this.connection.request('JoinRoom', {
-                token: String(token),
-                room_id: roomId,
-                user_data: userData,
-                position,
-            });
-            if (response === 'closed' || response.type === 'Failure')
-                return response;
-            const responseValue = response.value;
-            if (!('token' in responseValue)) {
-                return failure('JoinRoom responded without token');
-            }
-            const url = extendUrl(this.url, `room?token=${responseValue.token}`);
-            if (url.type === 'Failure')
-                return url;
-            const webSocket = yield connect(url.value, this.closeSignal);
-            if (webSocket.type === 'Success') {
-                this._PeerIdMap.set(webSocket.value, responseValue.peer_id);
-                return success(new RpcConnection(webSocket.value));
-            }
-            else {
-                return webSocket;
-            }
-        });
-    }
-    getReconnectToken(peerId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this._Request('RequestReconnectToken', {
-                peer_id: peerId,
-            });
-            if (response.type === 'Failure')
-                return response;
-            return Token.parse(response.value);
-        });
-    }
-    sendDatagram(datagram) {
-        if (this._AudioChannel.readyState === 'open') {
-            this._AudioChannel.send(datagram);
-        }
-    }
-    healthCheck() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this._Request('Ping', {}, HealthCheckTimeout);
-            const success = response !== 'timeout' && response.type === 'Success';
-            if (!success)
-                this.close();
-            return success;
-        });
-    }
-    _Request(name, properties, timeout) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const result = yield (timeout === undefined
-                ? this.connection.request(name, properties)
-                : this.connection.request(name, properties, timeout));
-            if (result === 'closed')
-                return failure('connection lost');
-            return result;
-        });
-    }
-    _readWebRtcUpdate() {
-        return __awaiter(this, void 0, void 0, function* () {
-            while (true) {
-                const event = yield this.connection.recv();
-                if (event === 'closed')
-                    break;
-                if (event.name === 'WebRtcUpdate') {
-                    this._OnWebRtcUpdate(event.properties);
-                }
-            }
-            this.close();
-        });
-    }
-    _SendOffer() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            this.ensureTransceivers();
-            try {
-                const offer = yield this.webRtc.createOffer();
-                assert(offer.type === 'offer' && offer.sdp, 'Generated broken webrtc offer');
-                yield this.webRtc.setLocalDescription(offer);
-                const sdp = (_a = offer.sdp) !== null && _a !== void 0 ? _a : '';
-                const media_map = [];
-                for (const [media_id, { transceiver }] of this._LocalVideos) {
-                    media_map.push([media_id, transceiver.mid]);
-                }
-                logger.info(['Connection', 'WebRTC'], 'WebRtcMainConnection._sendOffer(): media_map', media_map);
-                yield this._Request('WebRtcUpdate', {
-                    kind: 'Sdp',
-                    type: 'Offer',
-                    sdp,
-                    media_map,
-                });
-            }
-            catch (_b) {
-                logger.error(['Connection', 'WebRTC'], 'WebRtcMainConnection._sendOffer(): Failed creating an offer');
-            }
-        });
-    }
-    _OnWebRtcStatusChanged() {
-        logger.info(['WebRTC', 'Connection'], `WebRtcMainConnection._OnWebRtcStatusChanged(): ${this.webRtc.connectionState}`);
-        switch (this.webRtc.connectionState) {
-            case 'closed':
-            case 'failed':
-                this.close();
-                break;
-            case 'connected':
-                clearTimeout(this._WebRtcIceTimeout);
-                this._WebRtcIceTimeout = undefined;
-                clearTimeout(this._WebRtcTimeout);
-                this._WebRtcTimeout = undefined;
-                break;
-            case 'disconnected':
-                if (typeof MainConnectionPingInterval !== 'undefined') {
-                    this.healthCheck().then();
-                }
-            // falls through
-            default:
-                if (this._WebRtcIceTimeout === undefined) {
-                    // Gets removed after successfully connected
-                    this._WebRtcIceTimeout = setTimeout(() => {
-                        logger.info(['WebRTC', 'Connection'], 'WebRtcMainConnection._OnWebRtcStatusChanged(): _WebRtcIceTimeout was reached');
-                        this.webRtc.restartIce();
-                        this._WebRtcIceTimeout = undefined;
-                    }, WebRtcIceTimeout);
-                }
-                // Gets removed after successfully connected
-                if (this._WebRtcTimeout === undefined) {
-                    this._WebRtcTimeout = setTimeout(() => {
-                        logger.info(['WebRTC', 'Connection'], 'WebRtcMainConnection._OnWebRtcStatusChanged(): _WebRtcTimeout was reached');
-                        this.close();
-                    }, WebRtcTimeout);
-                }
-                break;
-        }
-    }
-    _OnWebRtcUpdate(update) {
-        switch (update.kind) {
-            case 'Sdp':
-                this._UpdateRemoteSdp(update);
-                break;
-            case 'Trickle':
-                this._AddIceCandidate(update);
-                break;
-            case 'TrickleFinished':
-                this.webRtc.addIceCandidate(undefined);
-                break;
-        }
-    }
-    _UpdateRemoteSdp(update) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            logger.info(['WebRTC', 'Connection', 'Video'], 'WebRtcMainConnection._UpdateRemoteSdp(): update.media_map, this._RemoteVideos', update.media_map, this._RemoteVideos);
-            let remoteChanged = false;
-            for (const [media_id, mid] of update.media_map) {
-                const entry = this._RemoteVideos.get(media_id);
-                if ((entry === null || entry === void 0 ? void 0 : entry.state) === 'Requested') {
-                    remoteChanged = true;
-                    this._RemoteVideos.set(media_id, {
-                        state: 'Mapped',
-                        mid,
-                        promise: entry.promise,
-                    });
-                }
-            }
-            const type = update.type === 'Answer' ? 'answer' : 'offer';
-            // Set runnig to false
-            logger.info(['WebRTC', 'Connection', 'Video'], 'WebRtcMainConnection._UpdateRemoteSdp(): remoteChanged: ', remoteChanged);
-            (_a = this._ResolveOffer) === null || _a === void 0 ? void 0 : _a.call(this, true);
-            yield this.webRtc.setRemoteDescription({ type, sdp: update.sdp });
-        });
-    }
-    _AddIceCandidate(candidate) {
-        var _a, _b, _c;
-        const candidateInit = {
-            candidate: candidate.candidate,
-            sdpMid: (_a = candidate.spd_mid) !== null && _a !== void 0 ? _a : undefined,
-            sdpMLineIndex: (_b = candidate.spd_mline_index) !== null && _b !== void 0 ? _b : undefined,
-            usernameFragment: (_c = candidate.username_fragment) !== null && _c !== void 0 ? _c : undefined,
-        };
-        // HACK/TODO(max): find out why the server is not sending sdpMid or sdpMLineIndex
-        if (candidateInit.sdpMid === undefined &&
-            candidateInit.sdpMLineIndex === undefined) {
-            candidateInit.sdpMid = '0';
-        }
-        this.webRtc.addIceCandidate(candidateInit);
-    }
-    _OnIceCandidate(event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (event.candidate) {
-                const { candidate, sdpMid, sdpMLineIndex, usernameFragment } = event.candidate;
-                this._Request('WebRtcUpdate', {
-                    kind: 'Trickle',
-                    candidate,
-                    spd_mid: sdpMid !== null && sdpMid !== void 0 ? sdpMid : undefined,
-                    spd_mline_index: sdpMLineIndex !== null && sdpMLineIndex !== void 0 ? sdpMLineIndex : undefined,
-                    username_fragment: usernameFragment !== null && usernameFragment !== void 0 ? usernameFragment : undefined,
-                });
-            }
-            else {
-                this._Request('WebRtcUpdate', { kind: 'TrickleFinished' });
-            }
-        });
-    }
-    ensureTransceivers() {
-        const needed = this._LocalVideos.size + this._RemoteVideos.size;
-        const available = this.webRtc.getTransceivers().length;
-        for (let i = available; i < needed; i++) {
-            this.webRtc.addTransceiver('video');
-        }
-    }
-    startLocalVideo(mediaId, track) {
-        return __awaiter(this, void 0, void 0, function* () {
-            assert(!this._LocalVideos.has(mediaId), `No LocalVideo with mediaID ${mediaId}`);
-            logger.debug(['WebRTC', 'Connection', 'Video'], 'WebRtcMainConnection.startLocalVideo(): ', mediaId);
-            let transceiver = this.webRtc
-                .getTransceivers()
-                .find((transceiver) => transceiver.sender.track === track);
-            if (transceiver) {
-                logger.debug(['WebRTC', 'Connection', 'Video'], 'WebRtcMainConnection.startLocalVideo(): Transceiver found -> replaceTrack.');
-                yield transceiver.sender.replaceTrack(track);
-            }
-            else {
-                const sender = this.webRtc.addTrack(track);
-                transceiver = this.webRtc
-                    .getTransceivers()
-                    .find((transceiver) => transceiver.sender === sender);
-                assert(transceiver, '');
-            }
-            this._LocalVideos.set(mediaId, { transceiver });
-            this.requestNegotiation(false);
-        });
-    }
-    stopLocalVideo(mediaId) {
-        const localVideo = this._LocalVideos.get(mediaId);
-        if (!localVideo)
-            return;
-        localVideo.transceiver.sender.track.enabled = false;
-        this._LocalVideos.delete(mediaId);
-        this.requestNegotiation(false);
-    }
-    startRemoteVideo(mediaId) {
-        logger.debug(['WebRTC', 'Connection', 'Video'], 'WebRtcMainConnection.startRemoteVideo()');
-        this.requestNegotiation(true);
-        return new Promise((resolve, reject) => {
-            this._RemoteVideos.set(mediaId, {
-                state: 'Requested',
-                promise: { resolve, reject },
-            });
-        });
-    }
-    stopRemoteVideo(mediaId) {
-        const video = this._RemoteVideos.get(mediaId);
-        if (!video)
-            return;
-        this._RemoteVideos.delete(mediaId);
-        if (video.state !== 'Active') {
-            video.promise.reject(new Error('video stopped'));
-        }
-        this.requestNegotiation(false);
-    }
-    onTrack(event) {
-        // If there was no entry found, store the track until a remote Video was started.
-        // When starting a remote Video, check if there is already a track available.
-        logger.debug(['WebRTC', 'Connection', 'Video'], 'WebRtcMainConnection.onTrack(): RemoteVideos: ', this._RemoteVideos);
-        const entry = Array.from(this._RemoteVideos).find((video) => {
-            return (video[1].state === 'Mapped' && video[1].mid === event.transceiver.mid);
-        });
-        logger.debug(['WebRTC', 'Connection', 'Video'], 'WebRtcMainConnection.onTrack(): Found the RemoteVideo', entry);
-        if (entry === undefined) {
-            logger.warn(['WebRTC', 'Connection', 'Video'], `WebRtcMainConnection.onTrack(): Unexpected track(mid: ${event.transceiver.mid})`);
-            return;
-        }
-        const [media_id, video] = entry;
-        assert(video.state === 'Mapped', '');
-        this._RemoteVideos.set(media_id, {
-            state: 'Active',
-            transceiver: event.transceiver,
-        });
-        event.track.onended = () => logger.debug(['WebRTC', 'Connection', 'Video'], `WebRtcMainConnection.onTrack(): Track ended ${event.transceiver.mid}`, entry);
-        video.promise.resolve(event.track);
-    }
-    requestNegotiation(waitForAnswer) {
-        logger.debug(['WebRTC', 'Connection', 'Video'], 'WebRtcMainConnection.requestNegotiation():');
-        this._Negotiation.requested = true;
-        if (this._Negotiation.running)
-            return;
-        this._Negotiation.running = true;
-        setTimeout(() => __awaiter(this, void 0, void 0, function* () {
-            this._Negotiation.requested = false;
-            try {
-                yield this._SendOffer();
-                if (waitForAnswer) {
-                    yield new Promise((resolve) => {
-                        this._ResolveOffer = resolve;
-                    });
-                }
-            }
-            finally {
-                logger.debug(['WebRTC', 'Connection', 'Video'], 'WebRtcMainConnection.requestNegotiation(): Finally');
-                this._Negotiation.running = false;
-                // @TODO Check if the retry is still needed.
-                const retry = Array.from(this._RemoteVideos).find((video) => {
-                    return video[1].state === 'Requested';
-                });
-                if (this._Negotiation.requested) {
-                    this.requestNegotiation(waitForAnswer);
-                }
-            }
-        }));
-    }
-    _CleanUp() {
-        console.debug(`${this.url} closed`);
-        this.connection.close();
-        this.webRtc.close();
-        clearInterval(this._PeriodicHealthCheck);
-        clearTimeout(this._WebRtcIceTimeout);
-        clearTimeout(this._WebRtcTimeout);
-    }
-}

package/lib/plugin/webrtc/websocket.d.ts

@@ -1,3 +0,0 @@
-import { Result } from '@4players/odin-common';
-export declare function connect(url: URL, signal: AbortSignal): Promise<Result<WebSocket>>;
-export declare function connectOnce(url: URL, signal: AbortSignal): Promise<Result<WebSocket>>;

package/lib/plugin/webrtc/websocket.js

@@ -1,56 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { ConnectInterval } from '../config';
-import { abortableSleep, failure, success, } from '@4players/odin-common';
-export function connect(url, signal) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const start = performance.now();
-        let connection = failure('no connection was attempted');
-        for (let failures = 0; failures < ConnectInterval.length && !signal.aborted; failures++) {
-            const nextReconnectAt = start + whenToConnect(failures);
-            if ((yield abortableSleep(nextReconnectAt - performance.now(), signal)) ===
-                'aborted') {
-                return failure('aborted');
-            }
-            connection = yield connectOnce(url, signal);
-            if (connection.type === 'Success') {
-                return connection;
-            }
-        }
-        return connection;
-    });
-}
-export function connectOnce(url, signal) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let webSocket;
-        try {
-            webSocket = new WebSocket(url);
-        }
-        catch (reason) {
-            return failure(`unable to create websocket; ${reason}`);
-        }
-        const abort = new AbortController();
-        const onOpen = new Promise((accept) => webSocket.addEventListener('open', () => accept(success(webSocket)), {
-            signal: abort.signal,
-        }));
-        const onClose = new Promise((accept) => webSocket.addEventListener('close', (event) => accept(failure(event.reason)), { signal: abort.signal }));
-        const onAbort = new Promise((accept) => signal.addEventListener('abort', () => accept(failure('aborted')), {
-            signal: abort.signal,
-        }));
-        const result = yield Promise.race([onOpen, onClose, onAbort]);
-        abort.abort();
-        return result;
-    });
-}
-function whenToConnect(failures) {
-    const past_connects = ConnectInterval.slice(0, failures).reduce((a, b) => a + b, 0);
-    const interval = ConnectInterval[failures] * Math.random();
-    return past_connects + interval;
-}