@remotion/renderer 4.0.0-fastlambda.8 → 4.0.0-forcepublish.7

package/dist/browser/BrowserPage.js

@@ -0,0 +1,283 @@
+"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/BrowserRunner.d.ts

@@ -0,0 +1,39 @@
+/**
+ * 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.
+ */
+/// <reference types="node" />
+import * as childProcess from 'child_process';
+import { Connection } from './Connection';
+import type { LaunchOptions } from './LaunchOptions';
+import type { Product } from './Product';
+export declare class BrowserRunner {
+    #private;
+    proc?: childProcess.ChildProcess;
+    connection?: Connection;
+    constructor({ product, executablePath, processArguments, userDataDir, isTempUserDataDir, }: {
+        product: Product;
+        executablePath: string;
+        processArguments: string[];
+        userDataDir: string;
+        isTempUserDataDir?: boolean;
+    });
+    start(options: LaunchOptions): void;
+    close(): Promise<void>;
+    kill(): void;
+    setupConnection(options: {
+        timeout: number;
+        preferredRevision: string;
+    }): Promise<Connection>;
+}

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(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,42 @@
+import type { Commands } from './devtools-commands';
+import type { TargetInfo } from './devtools-types';
+import { EventEmitter } from './EventEmitter';
+import type { NodeWebSocketTransport } from './NodeWebSocketTransport';
+export declare class Connection extends EventEmitter {
+    #private;
+    constructor(transport: NodeWebSocketTransport);
+    static fromSession(session: CDPSession): Connection | undefined;
+    session(sessionId: string): CDPSession | null;
+    send<T extends keyof Commands>(method: T, ...paramArgs: Commands[T]['paramsType']): Promise<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: 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 Commands>(method: T, ...paramArgs: Commands[T]['paramsType']): Promise<Commands[T]['returnType']>;
+    _onMessage(object: CDPSessionOnMessageObject): void;
+    _onClosed(): void;
+    id(): string;
+}
+export {};