@remotion/renderer 3.0.31 → 3.1.0

package/dist/browser/Page.js

@@ -1,283 +0,0 @@
-"use strict";
-/**
- * Copyright 2017 Google Inc. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _Page_instances, _Page_closed, _Page_client, _Page_target, _Page_timeoutSettings, _Page_frameManager, _Page_pageBindings, _Page_initialize, _Page_onTargetCrashed, _Page_onLogEntryAdded, _Page_onConsoleAPI, _Page_onBindingCalled, _Page_addConsoleMessage;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Page = void 0;
-const assert_1 = require("./assert");
-const ConsoleMessage_1 = require("./ConsoleMessage");
-const EventEmitter_1 = require("./EventEmitter");
-const FrameManager_1 = require("./FrameManager");
-const JSHandle_1 = require("./JSHandle");
-const TaskQueue_1 = require("./TaskQueue");
-const TimeoutSettings_1 = require("./TimeoutSettings");
-const util_1 = require("./util");
-class Page extends EventEmitter_1.EventEmitter {
-    constructor(client, target, browser) {
-        super();
-        _Page_instances.add(this);
-        _Page_closed.set(this, false);
-        _Page_client.set(this, void 0);
-        _Page_target.set(this, void 0);
-        _Page_timeoutSettings.set(this, new TimeoutSettings_1.TimeoutSettings());
-        _Page_frameManager.set(this, void 0);
-        _Page_pageBindings.set(this, new Map());
-        __classPrivateFieldSet(this, _Page_client, client, "f");
-        __classPrivateFieldSet(this, _Page_target, target, "f");
-        __classPrivateFieldSet(this, _Page_frameManager, new FrameManager_1.FrameManager(client, this, __classPrivateFieldGet(this, _Page_timeoutSettings, "f")), "f");
-        this.screenshotTaskQueue = new TaskQueue_1.TaskQueue();
-        this.browser = browser;
-        client.on('Target.attachedToTarget', (event) => {
-            switch (event.targetInfo.type) {
-                case 'iframe':
-                    break;
-                case 'worker':
-                    break;
-                default:
-                    // If we don't detach from service workers, they will never die.
-                    // We still want to attach to workers for emitting events.
-                    // We still want to attach to iframes so sessions may interact with them.
-                    // We detach from all other types out of an abundance of caution.
-                    // See https://source.chromium.org/chromium/chromium/src/+/main:content/browser/devtools/devtools_agent_host_impl.cc?ss=chromium&q=f:devtools%20-f:out%20%22::kTypePage%5B%5D%22
-                    // for the complete list of available types.
-                    client
-                        .send('Target.detachFromTarget', {
-                        sessionId: event.sessionId,
-                    })
-                        .catch((err) => console.log(err));
-            }
-        });
-        client.on('Runtime.consoleAPICalled', (event) => {
-            return __classPrivateFieldGet(this, _Page_instances, "m", _Page_onConsoleAPI).call(this, event);
-        });
-        client.on('Runtime.bindingCalled', (event) => {
-            return __classPrivateFieldGet(this, _Page_instances, "m", _Page_onBindingCalled).call(this, event);
-        });
-        client.on('Inspector.targetCrashed', () => {
-            return __classPrivateFieldGet(this, _Page_instances, "m", _Page_onTargetCrashed).call(this);
-        });
-        client.on('Log.entryAdded', (event) => {
-            return __classPrivateFieldGet(this, _Page_instances, "m", _Page_onLogEntryAdded).call(this, event);
-        });
-    }
-    static async _create(client, target, defaultViewport, browser) {
-        const page = new Page(client, target, browser);
-        await __classPrivateFieldGet(page, _Page_instances, "m", _Page_initialize).call(page);
-        await page.setViewport(defaultViewport);
-        return page;
-    }
-    /**
-     * Listen to page events.
-     */
-    // Note: this method exists to define event typings and handle
-    // proper wireup of cooperative request interception. Actual event listening and
-    // dispatching is delegated to EventEmitter.
-    on(eventName, handler) {
-        return super.on(eventName, handler);
-    }
-    once(eventName, handler) {
-        // Note: this method only exists to define the types; we delegate the impl
-        // to EventEmitter.
-        return super.once(eventName, handler);
-    }
-    off(eventName, handler) {
-        return super.off(eventName, handler);
-    }
-    /**
-     * @returns A target this page was created from.
-     */
-    target() {
-        return __classPrivateFieldGet(this, _Page_target, "f");
-    }
-    _client() {
-        return __classPrivateFieldGet(this, _Page_client, "f");
-    }
-    /**
-     * @returns The page's main frame.
-     * @remarks
-     * Page is guaranteed to have a main frame which persists during navigations.
-     */
-    mainFrame() {
-        return __classPrivateFieldGet(this, _Page_frameManager, "f").mainFrame();
-    }
-    setViewport(viewport) {
-        return __classPrivateFieldGet(this, _Page_client, "f").send('Emulation.setDeviceMetricsOverride', {
-            mobile: false,
-            width: viewport.width,
-            height: viewport.height,
-            deviceScaleFactor: viewport.deviceScaleFactor,
-            screenOrientation: {
-                angle: 0,
-                type: 'portraitPrimary',
-            },
-        });
-    }
-    setDefaultNavigationTimeout(timeout) {
-        __classPrivateFieldGet(this, _Page_timeoutSettings, "f").setDefaultNavigationTimeout(timeout);
-    }
-    setDefaultTimeout(timeout) {
-        __classPrivateFieldGet(this, _Page_timeoutSettings, "f").setDefaultTimeout(timeout);
-    }
-    async evaluateHandle(pageFunction, ...args) {
-        const context = await this.mainFrame().executionContext();
-        return context.evaluateHandle(pageFunction, ...args);
-    }
-    url() {
-        return this.mainFrame().url();
-    }
-    goto(url, options = {}) {
-        return __classPrivateFieldGet(this, _Page_frameManager, "f").mainFrame().goto(url, options);
-    }
-    async bringToFront() {
-        await __classPrivateFieldGet(this, _Page_client, "f").send('Page.bringToFront');
-    }
-    evaluate(pageFunction, ...args) {
-        return __classPrivateFieldGet(this, _Page_frameManager, "f").mainFrame().evaluate(pageFunction, ...args);
-    }
-    async evaluateOnNewDocument(pageFunction, ...args) {
-        const source = (0, util_1.evaluationString)(pageFunction, ...args);
-        await __classPrivateFieldGet(this, _Page_client, "f").send('Page.addScriptToEvaluateOnNewDocument', {
-            source,
-        });
-    }
-    async close(options = { runBeforeUnload: undefined }) {
-        const connection = __classPrivateFieldGet(this, _Page_client, "f").connection();
-        (0, assert_1.assert)(connection, 'Protocol error: Connection closed. Most likely the page has been closed.');
-        const runBeforeUnload = Boolean(options.runBeforeUnload);
-        if (runBeforeUnload) {
-            await __classPrivateFieldGet(this, _Page_client, "f").send('Page.close');
-        }
-        else {
-            await connection.send('Target.closeTarget', {
-                targetId: __classPrivateFieldGet(this, _Page_target, "f")._targetId,
-            });
-            await __classPrivateFieldGet(this, _Page_target, "f")._isClosedPromise;
-        }
-    }
-    isClosed() {
-        return __classPrivateFieldGet(this, _Page_closed, "f");
-    }
-    waitForFunction(browser, pageFunction, ...args) {
-        return this.mainFrame().waitForFunction(browser, pageFunction, ...args);
-    }
-}
-exports.Page = Page;
-_Page_closed = new WeakMap(), _Page_client = new WeakMap(), _Page_target = new WeakMap(), _Page_timeoutSettings = new WeakMap(), _Page_frameManager = new WeakMap(), _Page_pageBindings = new WeakMap(), _Page_instances = new WeakSet(), _Page_initialize = async function _Page_initialize() {
-    await Promise.all([
-        __classPrivateFieldGet(this, _Page_frameManager, "f").initialize(),
-        __classPrivateFieldGet(this, _Page_client, "f").send('Target.setAutoAttach', {
-            autoAttach: true,
-            waitForDebuggerOnStart: false,
-            flatten: true,
-        }),
-        __classPrivateFieldGet(this, _Page_client, "f").send('Performance.enable'),
-        __classPrivateFieldGet(this, _Page_client, "f").send('Log.enable'),
-    ]);
-}, _Page_onTargetCrashed = function _Page_onTargetCrashed() {
-    this.emit('error', new Error('Page crashed!'));
-}, _Page_onLogEntryAdded = function _Page_onLogEntryAdded(event) {
-    const { level, text, args, source, url, lineNumber } = event.entry;
-    if (args) {
-        args.map((arg) => {
-            return (0, util_1.releaseObject)(__classPrivateFieldGet(this, _Page_client, "f"), arg);
-        });
-    }
-    if (source !== 'worker') {
-        this.emit("console" /* PageEmittedEvents.Console */, new ConsoleMessage_1.ConsoleMessage(level, text, [], [{ url, lineNumber }]));
-    }
-}, _Page_onConsoleAPI = function _Page_onConsoleAPI(event) {
-    if (event.executionContextId === 0) {
-        return;
-    }
-    const context = __classPrivateFieldGet(this, _Page_frameManager, "f").executionContextById(event.executionContextId, __classPrivateFieldGet(this, _Page_client, "f"));
-    const values = event.args.map((arg) => {
-        return (0, JSHandle_1._createJSHandle)(context, arg);
-    });
-    __classPrivateFieldGet(this, _Page_instances, "m", _Page_addConsoleMessage).call(this, event.type, values, event.stackTrace);
-}, _Page_onBindingCalled = async function _Page_onBindingCalled(event) {
-    let payload;
-    try {
-        payload = JSON.parse(event.payload);
-    }
-    catch (_a) {
-        // The binding was either called by something in the page or it was
-        // called before our wrapper was initialized.
-        return;
-    }
-    const { type, name, seq, args } = payload;
-    if (type !== 'exposedFun' || !__classPrivateFieldGet(this, _Page_pageBindings, "f").has(name)) {
-        return;
-    }
-    let expression = null;
-    try {
-        const pageBinding = __classPrivateFieldGet(this, _Page_pageBindings, "f").get(name);
-        (0, assert_1.assert)(pageBinding);
-        const result = await pageBinding(...args);
-        expression = (0, util_1.pageBindingDeliverResultString)(name, seq, result);
-    }
-    catch (_error) {
-        if ((0, util_1.isErrorLike)(_error)) {
-            expression = (0, util_1.pageBindingDeliverErrorString)(name, seq, _error.message, _error.stack);
-        }
-        else {
-            expression = (0, util_1.pageBindingDeliverErrorValueString)(name, seq, _error);
-        }
-    }
-    __classPrivateFieldGet(this, _Page_client, "f").send('Runtime.evaluate', {
-        expression,
-        contextId: event.executionContextId,
-    });
-}, _Page_addConsoleMessage = function _Page_addConsoleMessage(eventType, args, stackTrace) {
-    if (!this.listenerCount("console" /* PageEmittedEvents.Console */)) {
-        args.forEach((arg) => {
-            return arg.dispose();
-        });
-        return;
-    }
-    const textTokens = [];
-    for (const arg of args) {
-        const remoteObject = arg._remoteObject;
-        if (remoteObject.objectId) {
-            textTokens.push(arg.toString());
-        }
-        else {
-            textTokens.push((0, util_1.valueFromRemoteObject)(remoteObject));
-        }
-    }
-    const stackTraceLocations = [];
-    if (stackTrace) {
-        for (const callFrame of stackTrace.callFrames) {
-            stackTraceLocations.push({
-                url: callFrame.url,
-                lineNumber: callFrame.lineNumber,
-                columnNumber: callFrame.columnNumber,
-            });
-        }
-    }
-    const message = new ConsoleMessage_1.ConsoleMessage(eventType, textTokens.join(' '), args, stackTraceLocations);
-    this.emit("console" /* PageEmittedEvents.Console */, message);
-};

package/dist/browser/compat.d.ts

@@ -1,2 +0,0 @@
-declare let puppeteerDirname: string;
-export { puppeteerDirname };

package/dist/browser/compat.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.puppeteerDirname = void 0;
-const path_1 = require("path");
-let puppeteerDirname;
-exports.puppeteerDirname = puppeteerDirname;
-try {
-    // In some environments, like esbuild, this will throw an error.
-    // We suppress the error since the bundled binary is not expected
-    // to be used or installed in this case and, therefore, the
-    // root directory does not have to be known.
-    exports.puppeteerDirname = puppeteerDirname = (0, path_1.dirname)(require.resolve('./compat'));
-}
-catch (error) {
-    // Fallback to __dirname.
-    exports.puppeteerDirname = puppeteerDirname = __dirname;
-}

package/dist/browser/environment.d.ts

@@ -1,16 +0,0 @@
-/**
- * Copyright 2020 Google Inc. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-export declare const isNode: boolean;

package/dist/browser/environment.js

@@ -1,19 +0,0 @@
-"use strict";
-/**
- * Copyright 2020 Google Inc. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isNode = void 0;
-exports.isNode = Boolean(typeof process !== 'undefined' && process.version);

package/dist/browser/ws.d.ts

@@ -1,287 +0,0 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-import { EventEmitter } from 'events';
-import type { Agent, ClientRequest, ClientRequestArgs, IncomingMessage, OutgoingHttpHeaders, Server as HTTPServer } from 'http';
-import type { Server as HTTPSServer } from 'https';
-import type { Duplex, DuplexOptions } from 'stream';
-import type { SecureContextOptions } from 'tls';
-import type { URL } from 'url';
-import type { ZlibOptions } from 'zlib';
-declare class WebSocket extends EventEmitter {
-    /** The connection is not yet open. */
-    static readonly CONNECTING: 0;
-    /** The connection is open and ready to communicate. */
-    static readonly OPEN: 1;
-    /** The connection is in the process of closing. */
-    static readonly CLOSING: 2;
-    /** The connection is closed. */
-    static readonly CLOSED: 3;
-    binaryType: 'nodebuffer' | 'arraybuffer' | 'fragments';
-    readonly bufferedAmount: number;
-    readonly extensions: string;
-    /** Indicates whether the websocket is paused */
-    readonly isPaused: boolean;
-    readonly protocol: string;
-    /** The current state of the connection */
-    readonly readyState: typeof WebSocket.CONNECTING | typeof WebSocket.OPEN | typeof WebSocket.CLOSING | typeof WebSocket.CLOSED;
-    readonly url: string;
-    /** The connection is not yet open. */
-    readonly CONNECTING: 0;
-    /** The connection is open and ready to communicate. */
-    readonly OPEN: 1;
-    /** The connection is in the process of closing. */
-    readonly CLOSING: 2;
-    /** The connection is closed. */
-    readonly CLOSED: 3;
-    onopen: ((event: WebSocket.Event) => void) | null;
-    onerror: ((event: WebSocket.ErrorEvent) => void) | null;
-    onclose: ((event: WebSocket.CloseEvent) => void) | null;
-    onmessage: ((event: WebSocket.MessageEvent) => void) | null;
-    constructor(address: null);
-    constructor(address: string | URL, options?: WebSocket.ClientOptions | ClientRequestArgs);
-    constructor(address: string | URL, protocols?: string | string[], options?: WebSocket.ClientOptions | ClientRequestArgs);
-    close(code?: number, data?: string | Buffer): void;
-    ping(data?: any, mask?: boolean, cb?: (err: Error) => void): void;
-    pong(data?: any, mask?: boolean, cb?: (err: Error) => void): void;
-    send(data: any, cb?: (err?: Error) => void): void;
-    send(data: any, options: {
-        mask?: boolean | undefined;
-        binary?: boolean | undefined;
-        compress?: boolean | undefined;
-        fin?: boolean | undefined;
-    }, cb?: (err?: Error) => void): void;
-    terminate(): void;
-    /**
-     * Pause the websocket causing it to stop emitting events. Some events can still be
-     * emitted after this is called, until all buffered data is consumed. This method
-     * is a noop if the ready state is `CONNECTING` or `CLOSED`.
-     */
-    pause(): void;
-    /**
-     * Make a paused socket resume emitting events. This method is a noop if the ready
-     * state is `CONNECTING` or `CLOSED`.
-     */
-    resume(): void;
-    addEventListener(method: 'message', cb: (event: WebSocket.MessageEvent) => void, options?: WebSocket.EventListenerOptions): void;
-    addEventListener(method: 'close', cb: (event: WebSocket.CloseEvent) => void, options?: WebSocket.EventListenerOptions): void;
-    addEventListener(method: 'error', cb: (event: WebSocket.ErrorEvent) => void, options?: WebSocket.EventListenerOptions): void;
-    addEventListener(method: 'open', cb: (event: WebSocket.Event) => void, options?: WebSocket.EventListenerOptions): void;
-    removeEventListener(method: 'message', cb: (event: WebSocket.MessageEvent) => void): void;
-    removeEventListener(method: 'close', cb: (event: WebSocket.CloseEvent) => void): void;
-    removeEventListener(method: 'error', cb: (event: WebSocket.ErrorEvent) => void): void;
-    removeEventListener(method: 'open', cb: (event: WebSocket.Event) => void): void;
-    on(event: 'close', listener: (this: WebSocket, code: number, reason: Buffer) => void): this;
-    on(event: 'error', listener: (this: WebSocket, err: Error) => void): this;
-    on(event: 'upgrade', listener: (this: WebSocket, request: IncomingMessage) => void): this;
-    on(event: 'message', listener: (this: WebSocket, data: WebSocket.RawData, isBinary: boolean) => void): this;
-    on(event: 'open', listener: (this: WebSocket) => void): this;
-    on(event: 'ping' | 'pong', listener: (this: WebSocket, data: Buffer) => void): this;
-    on(event: 'unexpected-response', listener: (this: WebSocket, request: ClientRequest, response: IncomingMessage) => void): this;
-    on(event: string | symbol, listener: (this: WebSocket, ...args: any[]) => void): this;
-    once(event: 'close', listener: (this: WebSocket, code: number, reason: Buffer) => void): this;
-    once(event: 'error', listener: (this: WebSocket, err: Error) => void): this;
-    once(event: 'upgrade', listener: (this: WebSocket, request: IncomingMessage) => void): this;
-    once(event: 'message', listener: (this: WebSocket, data: WebSocket.RawData, isBinary: boolean) => void): this;
-    once(event: 'open', listener: (this: WebSocket) => void): this;
-    once(event: 'ping' | 'pong', listener: (this: WebSocket, data: Buffer) => void): this;
-    once(event: 'unexpected-response', listener: (this: WebSocket, request: ClientRequest, response: IncomingMessage) => void): this;
-    once(event: string | symbol, listener: (this: WebSocket, ...args: any[]) => void): this;
-    off(event: 'close', listener: (this: WebSocket, code: number, reason: Buffer) => void): this;
-    off(event: 'error', listener: (this: WebSocket, err: Error) => void): this;
-    off(event: 'upgrade', listener: (this: WebSocket, request: IncomingMessage) => void): this;
-    off(event: 'message', listener: (this: WebSocket, data: WebSocket.RawData, isBinary: boolean) => void): this;
-    off(event: 'open', listener: (this: WebSocket) => void): this;
-    off(event: 'ping' | 'pong', listener: (this: WebSocket, data: Buffer) => void): this;
-    off(event: 'unexpected-response', listener: (this: WebSocket, request: ClientRequest, response: IncomingMessage) => void): this;
-    off(event: string | symbol, listener: (this: WebSocket, ...args: any[]) => void): this;
-    addListener(event: 'close', listener: (code: number, reason: Buffer) => void): this;
-    addListener(event: 'error', listener: (err: Error) => void): this;
-    addListener(event: 'upgrade', listener: (request: IncomingMessage) => void): this;
-    addListener(event: 'message', listener: (data: WebSocket.RawData, isBinary: boolean) => void): this;
-    addListener(event: 'open', listener: () => void): this;
-    addListener(event: 'ping' | 'pong', listener: (data: Buffer) => void): this;
-    addListener(event: 'unexpected-response', listener: (request: ClientRequest, response: IncomingMessage) => void): this;
-    addListener(event: string | symbol, listener: (...args: any[]) => void): this;
-    removeListener(event: 'close', listener: (code: number, reason: Buffer) => void): this;
-    removeListener(event: 'error', listener: (err: Error) => void): this;
-    removeListener(event: 'upgrade', listener: (request: IncomingMessage) => void): this;
-    removeListener(event: 'message', listener: (data: WebSocket.RawData, isBinary: boolean) => void): this;
-    removeListener(event: 'open', listener: () => void): this;
-    removeListener(event: 'ping' | 'pong', listener: (data: Buffer) => void): this;
-    removeListener(event: 'unexpected-response', listener: (request: ClientRequest, response: IncomingMessage) => void): this;
-    removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
-}
-declare const WebSocketAlias: typeof WebSocket;
-declare type WebSocketAlias = WebSocket;
-declare namespace WebSocket {
-    /**
-     * Data represents the raw message payload received over the WebSocket.
-     */
-    type RawData = Buffer | ArrayBuffer | Buffer[];
-    /**
-     * Data represents the message payload received over the WebSocket.
-     */
-    type Data = string | Buffer | ArrayBuffer | Buffer[];
-    /**
-     * CertMeta represents the accepted types for certificate & key data.
-     */
-    type CertMeta = string | string[] | Buffer | Buffer[];
-    /**
-     * VerifyClientCallbackSync is a synchronous callback used to inspect the
-     * incoming message. The return value (boolean) of the function determines
-     * whether or not to accept the handshake.
-     */
-    type VerifyClientCallbackSync = (info: {
-        origin: string;
-        secure: boolean;
-        req: IncomingMessage;
-    }) => boolean;
-    /**
-     * VerifyClientCallbackAsync is an asynchronous callback used to inspect the
-     * incoming message. The return value (boolean) of the function determines
-     * whether or not to accept the handshake.
-     */
-    type VerifyClientCallbackAsync = (info: {
-        origin: string;
-        secure: boolean;
-        req: IncomingMessage;
-    }, callback: (res: boolean, code?: number, message?: string, headers?: OutgoingHttpHeaders) => void) => void;
-    interface ClientOptions extends SecureContextOptions {
-        protocol?: string | undefined;
-        followRedirects?: boolean | undefined;
-        generateMask?(mask: Buffer): void;
-        handshakeTimeout?: number | undefined;
-        maxRedirects?: number | undefined;
-        perMessageDeflate?: boolean | PerMessageDeflateOptions | undefined;
-        localAddress?: string | undefined;
-        protocolVersion?: number | undefined;
-        headers?: {
-            [key: string]: string;
-        } | undefined;
-        origin?: string | undefined;
-        agent?: Agent | undefined;
-        host?: string | undefined;
-        family?: number | undefined;
-        checkServerIdentity?(servername: string, cert: CertMeta): boolean;
-        rejectUnauthorized?: boolean | undefined;
-        maxPayload?: number | undefined;
-        skipUTF8Validation?: boolean | undefined;
-    }
-    interface PerMessageDeflateOptions {
-        serverNoContextTakeover?: boolean | undefined;
-        clientNoContextTakeover?: boolean | undefined;
-        serverMaxWindowBits?: number | undefined;
-        clientMaxWindowBits?: number | undefined;
-        zlibDeflateOptions?: {
-            flush?: number | undefined;
-            finishFlush?: number | undefined;
-            chunkSize?: number | undefined;
-            windowBits?: number | undefined;
-            level?: number | undefined;
-            memLevel?: number | undefined;
-            strategy?: number | undefined;
-            dictionary?: Buffer | Buffer[] | DataView | undefined;
-            info?: boolean | undefined;
-        } | undefined;
-        zlibInflateOptions?: ZlibOptions | undefined;
-        threshold?: number | undefined;
-        concurrencyLimit?: number | undefined;
-    }
-    interface Event {
-        type: string;
-        target: WebSocket;
-    }
-    interface ErrorEvent {
-        error: any;
-        message: string;
-        type: string;
-        target: WebSocket;
-    }
-    interface CloseEvent {
-        wasClean: boolean;
-        code: number;
-        reason: string;
-        type: string;
-        target: WebSocket;
-    }
-    interface MessageEvent {
-        data: Data;
-        type: string;
-        target: WebSocket;
-    }
-    interface EventListenerOptions {
-        once?: boolean | undefined;
-    }
-    interface ServerOptions {
-        host?: string | undefined;
-        port?: number | undefined;
-        backlog?: number | undefined;
-        server?: HTTPServer | HTTPSServer | undefined;
-        verifyClient?: VerifyClientCallbackAsync | VerifyClientCallbackSync | undefined;
-        handleProtocols?: (protocols: Set<string>, request: IncomingMessage) => string | false;
-        path?: string | undefined;
-        noServer?: boolean | undefined;
-        clientTracking?: boolean | undefined;
-        perMessageDeflate?: boolean | PerMessageDeflateOptions | undefined;
-        maxPayload?: number | undefined;
-        skipUTF8Validation?: boolean | undefined;
-        WebSocket?: typeof WebSocket.WebSocket | undefined;
-    }
-    interface AddressInfo {
-        address: string;
-        family: string;
-        port: number;
-    }
-    class Server<T extends WebSocket = WebSocket> extends EventEmitter {
-        options: ServerOptions;
-        path: string;
-        clients: Set<T>;
-        constructor(options?: ServerOptions, callback?: () => void);
-        address(): AddressInfo | string;
-        close(cb?: (err?: Error) => void): void;
-        handleUpgrade(request: IncomingMessage, socket: Duplex, upgradeHead: Buffer, callback: (client: T, request: IncomingMessage) => void): void;
-        shouldHandle(request: IncomingMessage): boolean | Promise<boolean>;
-        on(event: 'connection', cb: (this: Server<T>, socket: T, request: IncomingMessage) => void): this;
-        on(event: 'error', cb: (this: Server<T>, error: Error) => void): this;
-        on(event: 'headers', cb: (this: Server<T>, headers: string[], request: IncomingMessage) => void): this;
-        on(event: 'close' | 'listening', cb: (this: Server<T>) => void): this;
-        on(event: string | symbol, listener: (this: Server<T>, ...args: any[]) => void): this;
-        once(event: 'connection', cb: (this: Server<T>, socket: T, request: IncomingMessage) => void): this;
-        once(event: 'error', cb: (this: Server<T>, error: Error) => void): this;
-        once(event: 'headers', cb: (this: Server<T>, headers: string[], request: IncomingMessage) => void): this;
-        once(event: 'close' | 'listening', cb: (this: Server<T>) => void): this;
-        once(event: string | symbol, listener: (this: Server<T>, ...args: any[]) => void): this;
-        off(event: 'connection', cb: (this: Server<T>, socket: T, request: IncomingMessage) => void): this;
-        off(event: 'error', cb: (this: Server<T>, error: Error) => void): this;
-        off(event: 'headers', cb: (this: Server<T>, headers: string[], request: IncomingMessage) => void): this;
-        off(event: 'close' | 'listening', cb: (this: Server<T>) => void): this;
-        off(event: string | symbol, listener: (this: Server<T>, ...args: any[]) => void): this;
-        addListener(event: 'connection', cb: (client: T, request: IncomingMessage) => void): this;
-        addListener(event: 'error', cb: (err: Error) => void): this;
-        addListener(event: 'headers', cb: (headers: string[], request: IncomingMessage) => void): this;
-        addListener(event: 'close' | 'listening', cb: () => void): this;
-        addListener(event: string | symbol, listener: (...args: any[]) => void): this;
-        removeListener(event: 'connection', cb: (client: T) => void): this;
-        removeListener(event: 'error', cb: (err: Error) => void): this;
-        removeListener(event: 'headers', cb: (headers: string[], request: IncomingMessage) => void): this;
-        removeListener(event: 'close' | 'listening', cb: () => void): this;
-        removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
-    }
-    const WebSocketServer: typeof Server;
-    interface WebSocketServer extends Server {
-    }
-    const WebSocket: typeof WebSocketAlias;
-    interface WebSocket extends WebSocketAlias {
-    }
-    function createWebSocketStream(websocket: WebSocket, options?: DuplexOptions): Duplex;
-}
-declare module 'ws' {
-    export = WebSocket;
-}
-export {};

package/dist/browser/ws.js

@@ -1,21 +0,0 @@
-"use strict";
-/* eslint-disable @typescript-eslint/no-shadow */
-/* eslint-disable @typescript-eslint/no-empty-interface */
-/* eslint-disable no-redeclare */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable lines-between-class-members */
-/* eslint-disable no-dupe-class-members */
-// Type definitions for ws 8.5
-// Project: https://github.com/websockets/ws
-// Definitions by: Paul Loyd <https://github.com/loyd>
-//                 Margus Lamp <https://github.com/mlamp>
-//                 Philippe D'Alva <https://github.com/TitaneBoy>
-//                 reduckted <https://github.com/reduckted>
-//                 teidesu <https://github.com/teidesu>
-//                 Bartosz Wojtkowiak <https://github.com/wojtkowiak>
-//                 Kyle Hensel <https://github.com/k-yle>
-//                 Samuel Skeen <https://github.com/cwadrupldijjit>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-Object.defineProperty(exports, "__esModule", { value: true });
-/// <reference types="node" />
-const events_1 = require("events");

package/dist/cancel.d.ts

@@ -1,7 +0,0 @@
-declare type Callback = () => void;
-export declare type CancelSignal = (callback: Callback) => void;
-export declare const makeCancelSignal: () => {
-    cancelSignal: CancelSignal;
-    cancel: () => void;
-};
-export {};