@remotion/renderer 4.0.0-fastlambda.8 → 4.0.0-lambda.3

package/dist/browser/BrowserRunner.js

@@ -0,0 +1,308 @@
+"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.
+ */
+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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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 _BrowserRunner_product, _BrowserRunner_executablePath, _BrowserRunner_processArguments, _BrowserRunner_userDataDir, _BrowserRunner_isTempUserDataDir, _BrowserRunner_closed, _BrowserRunner_listeners, _BrowserRunner_processClosing;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowserRunner = void 0;
+const childProcess = __importStar(require("child_process"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const readline = __importStar(require("readline"));
+const util_1 = require("util");
+const delete_directory_1 = require("../delete-directory");
+const assert_1 = require("./assert");
+const Connection_1 = require("./Connection");
+const Errors_1 = require("./Errors");
+const NodeWebSocketTransport_1 = require("./NodeWebSocketTransport");
+const util_2 = require("./util");
+const renameAsync = (0, util_1.promisify)(fs.rename);
+const unlinkAsync = (0, util_1.promisify)(fs.unlink);
+const PROCESS_ERROR_EXPLANATION = `Puppeteer was unable to kill the process which ran the browser binary.
+ This means that, on future Puppeteer launches, Puppeteer might not be able to launch the browser.
+ Please check your open processes and ensure that the browser processes that Puppeteer launched have been killed.
+ If you think this is a bug, please report it on the Puppeteer issue tracker.`;
+class BrowserRunner {
+    constructor({ product, executablePath, processArguments, userDataDir, isTempUserDataDir, }) {
+        _BrowserRunner_product.set(this, void 0);
+        _BrowserRunner_executablePath.set(this, void 0);
+        _BrowserRunner_processArguments.set(this, void 0);
+        _BrowserRunner_userDataDir.set(this, void 0);
+        _BrowserRunner_isTempUserDataDir.set(this, void 0);
+        _BrowserRunner_closed.set(this, true);
+        _BrowserRunner_listeners.set(this, []);
+        _BrowserRunner_processClosing.set(this, void 0);
+        __classPrivateFieldSet(this, _BrowserRunner_product, product, "f");
+        __classPrivateFieldSet(this, _BrowserRunner_executablePath, executablePath, "f");
+        __classPrivateFieldSet(this, _BrowserRunner_processArguments, processArguments, "f");
+        __classPrivateFieldSet(this, _BrowserRunner_userDataDir, userDataDir, "f");
+        __classPrivateFieldSet(this, _BrowserRunner_isTempUserDataDir, isTempUserDataDir, "f");
+    }
+    start(options) {
+        var _a, _b;
+        const { handleSIGINT, handleSIGTERM, handleSIGHUP, dumpio, env, pipe } = options;
+        let stdio;
+        if (pipe) {
+            if (dumpio) {
+                stdio = ['ignore', 'pipe', 'pipe', 'pipe', 'pipe'];
+            }
+            else {
+                stdio = ['ignore', 'ignore', 'ignore', 'pipe', 'pipe'];
+            }
+        }
+        else if (dumpio) {
+            stdio = ['pipe', 'pipe', 'pipe'];
+        }
+        else {
+            stdio = ['pipe', 'ignore', 'pipe'];
+        }
+        (0, assert_1.assert)(!this.proc, 'This process has previously been started.');
+        this.proc = childProcess.spawn(__classPrivateFieldGet(this, _BrowserRunner_executablePath, "f"), __classPrivateFieldGet(this, _BrowserRunner_processArguments, "f"), {
+            // On non-windows platforms, `detached: true` makes child process a
+            // leader of a new process group, making it possible to kill child
+            // process tree with `.kill(-pid)` command. @see
+            // https://nodejs.org/api/child_process.html#child_process_options_detached
+            detached: process.platform !== 'win32',
+            env,
+            stdio,
+        });
+        if (dumpio) {
+            (_a = this.proc.stderr) === null || _a === void 0 ? void 0 : _a.pipe(process.stderr);
+            (_b = this.proc.stdout) === null || _b === void 0 ? void 0 : _b.pipe(process.stdout);
+        }
+        __classPrivateFieldSet(this, _BrowserRunner_closed, false, "f");
+        __classPrivateFieldSet(this, _BrowserRunner_processClosing, new Promise((fulfill, reject) => {
+            this.proc.once('exit', async () => {
+                __classPrivateFieldSet(this, _BrowserRunner_closed, true, "f");
+                // Cleanup as processes exit.
+                if (__classPrivateFieldGet(this, _BrowserRunner_isTempUserDataDir, "f")) {
+                    try {
+                        await (0, delete_directory_1.deleteDirectory)(__classPrivateFieldGet(this, _BrowserRunner_userDataDir, "f"));
+                        fulfill();
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                }
+                else {
+                    if (__classPrivateFieldGet(this, _BrowserRunner_product, "f") === 'firefox') {
+                        try {
+                            // When an existing user profile has been used remove the user
+                            // preferences file and restore possibly backuped preferences.
+                            await unlinkAsync(path.join(__classPrivateFieldGet(this, _BrowserRunner_userDataDir, "f"), 'user.js'));
+                            const prefsBackupPath = path.join(__classPrivateFieldGet(this, _BrowserRunner_userDataDir, "f"), 'prefs.js.puppeteer');
+                            if (fs.existsSync(prefsBackupPath)) {
+                                const prefsPath = path.join(__classPrivateFieldGet(this, _BrowserRunner_userDataDir, "f"), 'prefs.js');
+                                await unlinkAsync(prefsPath);
+                                await renameAsync(prefsBackupPath, prefsPath);
+                            }
+                        }
+                        catch (error) {
+                            reject(error);
+                        }
+                    }
+                    fulfill();
+                }
+            });
+        }), "f");
+        __classPrivateFieldSet(this, _BrowserRunner_listeners, [(0, util_2.addEventListener)(process, 'exit', this.kill.bind(this))], "f");
+        if (handleSIGINT) {
+            __classPrivateFieldGet(this, _BrowserRunner_listeners, "f").push((0, util_2.addEventListener)(process, 'SIGINT', () => {
+                this.kill();
+                process.exit(130);
+            }));
+        }
+        if (handleSIGTERM) {
+            __classPrivateFieldGet(this, _BrowserRunner_listeners, "f").push((0, util_2.addEventListener)(process, 'SIGTERM', this.close.bind(this)));
+        }
+        if (handleSIGHUP) {
+            __classPrivateFieldGet(this, _BrowserRunner_listeners, "f").push((0, util_2.addEventListener)(process, 'SIGHUP', this.close.bind(this)));
+        }
+    }
+    close() {
+        if (__classPrivateFieldGet(this, _BrowserRunner_closed, "f")) {
+            return Promise.resolve();
+        }
+        if (__classPrivateFieldGet(this, _BrowserRunner_isTempUserDataDir, "f")) {
+            this.kill();
+        }
+        else if (this.connection) {
+            // Attempt to close the browser gracefully
+            this.connection.send('Browser.close').catch(() => {
+                this.kill();
+            });
+        }
+        // Cleanup this listener last, as that makes sure the full callback runs. If we
+        // perform this earlier, then the previous function calls would not happen.
+        (0, util_2.removeEventListeners)(__classPrivateFieldGet(this, _BrowserRunner_listeners, "f"));
+        return __classPrivateFieldGet(this, _BrowserRunner_processClosing, "f");
+    }
+    kill() {
+        var _a;
+        // If the process failed to launch (for example if the browser executable path
+        // is invalid), then the process does not get a pid assigned. A call to
+        // `proc.kill` would error, as the `pid` to-be-killed can not be found.
+        if (((_a = this.proc) === null || _a === void 0 ? void 0 : _a.pid) && pidExists(this.proc.pid)) {
+            const { proc } = this;
+            try {
+                if (process.platform === 'win32') {
+                    childProcess.exec(`taskkill /pid ${this.proc.pid} /T /F`, (error) => {
+                        if (error) {
+                            // taskkill can fail to kill the process e.g. due to missing permissions.
+                            // Let's kill the process via Node API. This delays killing of all child
+                            // processes of `this.proc` until the main Node.js process dies.
+                            proc.kill();
+                        }
+                    });
+                }
+                else {
+                    // on linux the process group can be killed with the group id prefixed with
+                    // a minus sign. The process group id is the group leader's pid.
+                    const processGroupId = -this.proc.pid;
+                    try {
+                        process.kill(processGroupId, 'SIGKILL');
+                    }
+                    catch (error) {
+                        // Killing the process group can fail due e.g. to missing permissions.
+                        // Let's kill the process via Node API. This delays killing of all child
+                        // processes of `this.proc` until the main Node.js process dies.
+                        proc.kill('SIGKILL');
+                    }
+                }
+            }
+            catch (error) {
+                throw new Error(`${PROCESS_ERROR_EXPLANATION}\nError cause: ${(0, util_2.isErrorLike)(error) ? error.stack : error}`);
+            }
+        }
+        // Attempt to remove temporary profile directory to avoid littering.
+        try {
+            if (__classPrivateFieldGet(this, _BrowserRunner_isTempUserDataDir, "f")) {
+                fs.rmSync(__classPrivateFieldGet(this, _BrowserRunner_userDataDir, "f"), { recursive: true, force: true });
+            }
+        }
+        catch (error) { }
+        // Cleanup this listener last, as that makes sure the full callback runs. If we
+        // perform this earlier, then the previous function calls would not happen.
+        (0, util_2.removeEventListeners)(__classPrivateFieldGet(this, _BrowserRunner_listeners, "f"));
+    }
+    async setupConnection(options) {
+        (0, assert_1.assert)(this.proc, 'BrowserRunner not started.');
+        const { timeout, preferredRevision } = options;
+        const browserWSEndpoint = await waitForWSEndpoint(this.proc, timeout, preferredRevision);
+        const transport = await NodeWebSocketTransport_1.NodeWebSocketTransport.create(browserWSEndpoint);
+        this.connection = new Connection_1.Connection(browserWSEndpoint, transport);
+        return this.connection;
+    }
+}
+exports.BrowserRunner = BrowserRunner;
+_BrowserRunner_product = new WeakMap(), _BrowserRunner_executablePath = new WeakMap(), _BrowserRunner_processArguments = new WeakMap(), _BrowserRunner_userDataDir = new WeakMap(), _BrowserRunner_isTempUserDataDir = new WeakMap(), _BrowserRunner_closed = new WeakMap(), _BrowserRunner_listeners = new WeakMap(), _BrowserRunner_processClosing = new WeakMap();
+function waitForWSEndpoint(browserProcess, timeout, preferredRevision) {
+    (0, assert_1.assert)(browserProcess.stderr, '`browserProcess` does not have stderr.');
+    const rl = readline.createInterface(browserProcess.stderr);
+    let stderr = '';
+    return new Promise((resolve, reject) => {
+        const listeners = [
+            (0, util_2.addEventListener)(rl, 'line', onLine),
+            (0, util_2.addEventListener)(rl, 'close', () => {
+                return onClose();
+            }),
+            (0, util_2.addEventListener)(browserProcess, 'exit', () => {
+                return onClose();
+            }),
+            (0, util_2.addEventListener)(browserProcess, 'error', (error) => {
+                return onClose(error);
+            }),
+        ];
+        const timeoutId = timeout ? setTimeout(onTimeout, timeout) : 0;
+        function onClose(error) {
+            cleanup();
+            reject(new Error([
+                'Failed to launch the browser process!' +
+                    (error ? ' ' + error.message : ''),
+                stderr,
+                '',
+                'TROUBLESHOOTING: https://github.com/puppeteer/puppeteer/blob/main/docs/troubleshooting.md',
+                '',
+            ].join('\n')));
+        }
+        function onTimeout() {
+            cleanup();
+            reject(new Errors_1.TimeoutError(`Timed out after ${timeout} ms while trying to connect to the browser! Only Chrome at revision r${preferredRevision} is guaranteed to work.`));
+        }
+        function onLine(line) {
+            stderr += line + '\n';
+            const match = line.match(/^DevTools listening on (ws:\/\/.*)$/);
+            if (!match) {
+                return;
+            }
+            cleanup();
+            // The RegExp matches, so this will obviously exist.
+            resolve(match[1]);
+        }
+        function cleanup() {
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+            (0, util_2.removeEventListeners)(listeners);
+        }
+    });
+}
+function pidExists(pid) {
+    try {
+        return process.kill(pid, 0);
+    }
+    catch (error) {
+        if ((0, util_2.isErrnoException)(error)) {
+            if (error.code && error.code === 'ESRCH') {
+                return false;
+            }
+        }
+        throw error;
+    }
+}

package/dist/browser/Connection.d.ts

@@ -0,0 +1,49 @@
+import { Protocol } from 'devtools-protocol';
+import { ProtocolMapping } from 'devtools-protocol/types/protocol-mapping';
+import { ConnectionTransport } from './ConnectionTransport';
+import { EventEmitter } from './EventEmitter';
+export declare class Connection extends EventEmitter {
+    #private;
+    constructor(url: string, transport: ConnectionTransport);
+    static fromSession(session: CDPSession): Connection | undefined;
+    get _closed(): boolean;
+    /**
+     * @param sessionId - The session id
+     * @returns The current CDP session if it exists
+     */
+    session(sessionId: string): CDPSession | null;
+    url(): string;
+    send<T extends keyof ProtocolMapping.Commands>(method: T, ...paramArgs: ProtocolMapping.Commands[T]['paramsType']): Promise<ProtocolMapping.Commands[T]['returnType']>;
+    _rawSend(message: Record<string, unknown>): number;
+    dispose(): void;
+    /**
+     * @param targetInfo - The target info
+     * @returns The CDP session that is created
+     */
+    createSession(targetInfo: Protocol.Target.TargetInfo): Promise<CDPSession>;
+}
+interface CDPSessionOnMessageObject {
+    id?: number;
+    method: string;
+    params: Record<string, unknown>;
+    error: {
+        message: string;
+        data: any;
+        code: number;
+    };
+    result?: any;
+}
+export declare const CDPSessionEmittedEvents: {
+    readonly Disconnected: symbol;
+};
+export declare class CDPSession extends EventEmitter {
+    #private;
+    constructor(connection: Connection, targetType: string, sessionId: string);
+    connection(): Connection | undefined;
+    send<T extends keyof ProtocolMapping.Commands>(method: T, ...paramArgs: ProtocolMapping.Commands[T]['paramsType']): Promise<ProtocolMapping.Commands[T]['returnType']>;
+    _onMessage(object: CDPSessionOnMessageObject): void;
+    detach(): Promise<void>;
+    _onClosed(): void;
+    id(): string;
+}
+export {};

package/dist/browser/Connection.js

@@ -0,0 +1,262 @@
+"use strict";
+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 _Connection_instances, _Connection_url, _Connection_transport, _Connection_lastId, _Connection_sessions, _Connection_closed, _Connection_callbacks, _Connection_onMessage, _Connection_onClose, _CDPSession_sessionId, _CDPSession_targetType, _CDPSession_callbacks, _CDPSession_connection;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CDPSession = exports.CDPSessionEmittedEvents = exports.Connection = void 0;
+/**
+ * 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.
+ */
+const assert_1 = require("./assert");
+const Errors_1 = require("./Errors");
+const EventEmitter_1 = require("./EventEmitter");
+const ConnectionEmittedEvents = {
+    Disconnected: Symbol('Connection.Disconnected'),
+};
+class Connection extends EventEmitter_1.EventEmitter {
+    constructor(url, transport) {
+        super();
+        _Connection_instances.add(this);
+        _Connection_url.set(this, void 0);
+        _Connection_transport.set(this, void 0);
+        _Connection_lastId.set(this, 0);
+        _Connection_sessions.set(this, new Map());
+        _Connection_closed.set(this, false);
+        _Connection_callbacks.set(this, new Map());
+        __classPrivateFieldSet(this, _Connection_url, url, "f");
+        __classPrivateFieldSet(this, _Connection_transport, transport, "f");
+        __classPrivateFieldGet(this, _Connection_transport, "f").onmessage = __classPrivateFieldGet(this, _Connection_instances, "m", _Connection_onMessage).bind(this);
+        __classPrivateFieldGet(this, _Connection_transport, "f").onclose = __classPrivateFieldGet(this, _Connection_instances, "m", _Connection_onClose).bind(this);
+    }
+    static fromSession(session) {
+        return session.connection();
+    }
+    get _closed() {
+        return __classPrivateFieldGet(this, _Connection_closed, "f");
+    }
+    /**
+     * @param sessionId - The session id
+     * @returns The current CDP session if it exists
+     */
+    session(sessionId) {
+        return __classPrivateFieldGet(this, _Connection_sessions, "f").get(sessionId) || null;
+    }
+    url() {
+        return __classPrivateFieldGet(this, _Connection_url, "f");
+    }
+    send(method, ...paramArgs) {
+        // There is only ever 1 param arg passed, but the Protocol defines it as an
+        // array of 0 or 1 items See this comment:
+        // https://github.com/ChromeDevTools/devtools-protocol/pull/113#issuecomment-412603285
+        // which explains why the protocol defines the params this way for better
+        // type-inference.
+        // So now we check if there are any params or not and deal with them accordingly.
+        const params = paramArgs.length ? paramArgs[0] : undefined;
+        const id = this._rawSend({ method, params });
+        return new Promise((resolve, reject) => {
+            __classPrivateFieldGet(this, _Connection_callbacks, "f").set(id, {
+                resolve,
+                reject,
+                error: new Errors_1.ProtocolError(),
+                method,
+            });
+        });
+    }
+    _rawSend(message) {
+        var _a;
+        const id = __classPrivateFieldSet(this, _Connection_lastId, (_a = __classPrivateFieldGet(this, _Connection_lastId, "f"), ++_a), "f");
+        const stringifiedMessage = JSON.stringify({ ...message, id });
+        __classPrivateFieldGet(this, _Connection_transport, "f").send(stringifiedMessage);
+        return id;
+    }
+    dispose() {
+        __classPrivateFieldGet(this, _Connection_instances, "m", _Connection_onClose).call(this);
+        __classPrivateFieldGet(this, _Connection_transport, "f").close();
+    }
+    /**
+     * @param targetInfo - The target info
+     * @returns The CDP session that is created
+     */
+    async createSession(targetInfo) {
+        const { sessionId } = await this.send('Target.attachToTarget', {
+            targetId: targetInfo.targetId,
+            flatten: true,
+        });
+        const session = __classPrivateFieldGet(this, _Connection_sessions, "f").get(sessionId);
+        if (!session) {
+            throw new Error('CDPSession creation failed.');
+        }
+        return session;
+    }
+}
+exports.Connection = Connection;
+_Connection_url = new WeakMap(), _Connection_transport = new WeakMap(), _Connection_lastId = new WeakMap(), _Connection_sessions = new WeakMap(), _Connection_closed = new WeakMap(), _Connection_callbacks = new WeakMap(), _Connection_instances = new WeakSet(), _Connection_onMessage = function _Connection_onMessage(message) {
+    const object = JSON.parse(message);
+    if (object.method === 'Target.attachedToTarget') {
+        const { sessionId } = object.params;
+        const session = new CDPSession(this, object.params.targetInfo.type, sessionId);
+        __classPrivateFieldGet(this, _Connection_sessions, "f").set(sessionId, session);
+        this.emit('sessionattached', session);
+        const parentSession = __classPrivateFieldGet(this, _Connection_sessions, "f").get(object.sessionId);
+        if (parentSession) {
+            parentSession.emit('sessionattached', session);
+        }
+    }
+    else if (object.method === 'Target.detachedFromTarget') {
+        const session = __classPrivateFieldGet(this, _Connection_sessions, "f").get(object.params.sessionId);
+        if (session) {
+            session._onClosed();
+            __classPrivateFieldGet(this, _Connection_sessions, "f").delete(object.params.sessionId);
+            this.emit('sessiondetached', session);
+            const parentSession = __classPrivateFieldGet(this, _Connection_sessions, "f").get(object.sessionId);
+            if (parentSession) {
+                parentSession.emit('sessiondetached', session);
+            }
+        }
+    }
+    if (object.sessionId) {
+        const session = __classPrivateFieldGet(this, _Connection_sessions, "f").get(object.sessionId);
+        if (session) {
+            session._onMessage(object);
+        }
+    }
+    else if (object.id) {
+        const callback = __classPrivateFieldGet(this, _Connection_callbacks, "f").get(object.id);
+        // Callbacks could be all rejected if someone has called `.dispose()`.
+        if (callback) {
+            __classPrivateFieldGet(this, _Connection_callbacks, "f").delete(object.id);
+            if (object.error) {
+                callback.reject(createProtocolError(callback.error, callback.method, object));
+            }
+            else {
+                callback.resolve(object.result);
+            }
+        }
+    }
+    else {
+        this.emit(object.method, object.params);
+    }
+}, _Connection_onClose = function _Connection_onClose() {
+    if (__classPrivateFieldGet(this, _Connection_closed, "f")) {
+        return;
+    }
+    __classPrivateFieldGet(this, _Connection_transport, "f").onmessage = undefined;
+    __classPrivateFieldGet(this, _Connection_transport, "f").onclose = undefined;
+    for (const callback of __classPrivateFieldGet(this, _Connection_callbacks, "f").values()) {
+        callback.reject(rewriteError(callback.error, `Protocol error (${callback.method}): Target closed.`));
+    }
+    __classPrivateFieldGet(this, _Connection_callbacks, "f").clear();
+    for (const session of __classPrivateFieldGet(this, _Connection_sessions, "f").values()) {
+        session._onClosed();
+    }
+    __classPrivateFieldGet(this, _Connection_sessions, "f").clear();
+    this.emit(ConnectionEmittedEvents.Disconnected);
+};
+exports.CDPSessionEmittedEvents = {
+    Disconnected: Symbol('CDPSession.Disconnected'),
+};
+class CDPSession extends EventEmitter_1.EventEmitter {
+    constructor(connection, targetType, sessionId) {
+        super();
+        _CDPSession_sessionId.set(this, void 0);
+        _CDPSession_targetType.set(this, void 0);
+        _CDPSession_callbacks.set(this, new Map());
+        _CDPSession_connection.set(this, void 0);
+        __classPrivateFieldSet(this, _CDPSession_connection, connection, "f");
+        __classPrivateFieldSet(this, _CDPSession_targetType, targetType, "f");
+        __classPrivateFieldSet(this, _CDPSession_sessionId, sessionId, "f");
+    }
+    connection() {
+        return __classPrivateFieldGet(this, _CDPSession_connection, "f");
+    }
+    send(method, ...paramArgs) {
+        if (!__classPrivateFieldGet(this, _CDPSession_connection, "f")) {
+            return Promise.reject(new Error(`Protocol error (${method}): Session closed. Most likely the ${__classPrivateFieldGet(this, _CDPSession_targetType, "f")} has been closed.`));
+        }
+        // See the comment in Connection#send explaining why we do this.
+        const params = paramArgs.length ? paramArgs[0] : undefined;
+        const id = __classPrivateFieldGet(this, _CDPSession_connection, "f")._rawSend({
+            sessionId: __classPrivateFieldGet(this, _CDPSession_sessionId, "f"),
+            method,
+            params,
+        });
+        return new Promise((resolve, reject) => {
+            __classPrivateFieldGet(this, _CDPSession_callbacks, "f").set(id, {
+                resolve,
+                reject,
+                error: new Errors_1.ProtocolError(),
+                method,
+            });
+        });
+    }
+    _onMessage(object) {
+        const callback = object.id ? __classPrivateFieldGet(this, _CDPSession_callbacks, "f").get(object.id) : undefined;
+        if (object.id && callback) {
+            __classPrivateFieldGet(this, _CDPSession_callbacks, "f").delete(object.id);
+            if (object.error) {
+                callback.reject(createProtocolError(callback.error, callback.method, object));
+            }
+            else {
+                callback.resolve(object.result);
+            }
+        }
+        else {
+            (0, assert_1.assert)(!object.id);
+            this.emit(object.method, object.params);
+        }
+    }
+    async detach() {
+        if (!__classPrivateFieldGet(this, _CDPSession_connection, "f")) {
+            throw new Error(`Session already detached. Most likely the ${__classPrivateFieldGet(this, _CDPSession_targetType, "f")} has been closed.`);
+        }
+        await __classPrivateFieldGet(this, _CDPSession_connection, "f").send('Target.detachFromTarget', {
+            sessionId: __classPrivateFieldGet(this, _CDPSession_sessionId, "f"),
+        });
+    }
+    _onClosed() {
+        for (const callback of __classPrivateFieldGet(this, _CDPSession_callbacks, "f").values()) {
+            callback.reject(rewriteError(callback.error, `Protocol error (${callback.method}): Target closed.`));
+        }
+        __classPrivateFieldGet(this, _CDPSession_callbacks, "f").clear();
+        __classPrivateFieldSet(this, _CDPSession_connection, undefined, "f");
+        this.emit(exports.CDPSessionEmittedEvents.Disconnected);
+    }
+    id() {
+        return __classPrivateFieldGet(this, _CDPSession_sessionId, "f");
+    }
+}
+exports.CDPSession = CDPSession;
+_CDPSession_sessionId = new WeakMap(), _CDPSession_targetType = new WeakMap(), _CDPSession_callbacks = new WeakMap(), _CDPSession_connection = new WeakMap();
+function createProtocolError(error, method, object) {
+    let message = `Protocol error (${method}): ${object.error.message}`;
+    if ('data' in object.error) {
+        message += ` ${object.error.data}`;
+    }
+    return rewriteError(error, message, object.error.message);
+}
+function rewriteError(error, message, originalMessage) {
+    error.message = message;
+    error.originalMessage = originalMessage !== null && originalMessage !== void 0 ? originalMessage : error.originalMessage;
+    return error;
+}

package/dist/browser/ConnectionTransport.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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 interface ConnectionTransport {
+    send(message: string): void;
+    close(): void;
+    onmessage?: (message: string) => void;
+    onclose?: () => void;
+}

package/dist/browser/ConnectionTransport.js

@@ -0,0 +1,17 @@
+"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 });