@remotion/renderer 4.0.0-defer.6 → 4.0.0-esm.17

package/dist/browser/JSHandle.js

@@ -0,0 +1,90 @@
+"use strict";
+/**
+ * Copyright 2019 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 _JSHandle_client, _JSHandle_disposed, _JSHandle_context, _JSHandle_remoteObject;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ElementHandle = exports.JSHandle = exports._createJSHandle = void 0;
+const util_1 = require("./util");
+function _createJSHandle(context, remoteObject) {
+    const frame = context.frame();
+    if (remoteObject.subtype === 'node' && frame) {
+        return new ElementHandle(context, context._client, remoteObject);
+    }
+    return new JSHandle(context, context._client, remoteObject);
+}
+exports._createJSHandle = _createJSHandle;
+class JSHandle {
+    constructor(context, client, remoteObject) {
+        _JSHandle_client.set(this, void 0);
+        _JSHandle_disposed.set(this, false);
+        _JSHandle_context.set(this, void 0);
+        _JSHandle_remoteObject.set(this, void 0);
+        __classPrivateFieldSet(this, _JSHandle_context, context, "f");
+        __classPrivateFieldSet(this, _JSHandle_client, client, "f");
+        __classPrivateFieldSet(this, _JSHandle_remoteObject, remoteObject, "f");
+    }
+    get _disposed() {
+        return __classPrivateFieldGet(this, _JSHandle_disposed, "f");
+    }
+    get _remoteObject() {
+        return __classPrivateFieldGet(this, _JSHandle_remoteObject, "f");
+    }
+    get _context() {
+        return __classPrivateFieldGet(this, _JSHandle_context, "f");
+    }
+    executionContext() {
+        return __classPrivateFieldGet(this, _JSHandle_context, "f");
+    }
+    evaluateHandle(pageFunction, ...args) {
+        return this.executionContext().evaluateHandle(pageFunction, this, ...args);
+    }
+    asElement() {
+        return null;
+    }
+    async dispose() {
+        if (__classPrivateFieldGet(this, _JSHandle_disposed, "f")) {
+            return;
+        }
+        __classPrivateFieldSet(this, _JSHandle_disposed, true, "f");
+        await (0, util_1.releaseObject)(__classPrivateFieldGet(this, _JSHandle_client, "f"), __classPrivateFieldGet(this, _JSHandle_remoteObject, "f"));
+    }
+    toString() {
+        if (__classPrivateFieldGet(this, _JSHandle_remoteObject, "f").objectId) {
+            const type = __classPrivateFieldGet(this, _JSHandle_remoteObject, "f").subtype || __classPrivateFieldGet(this, _JSHandle_remoteObject, "f").type;
+            return 'JSHandle@' + type;
+        }
+        return 'JSHandle:' + (0, util_1.valueFromRemoteObject)(__classPrivateFieldGet(this, _JSHandle_remoteObject, "f"));
+    }
+}
+exports.JSHandle = JSHandle;
+_JSHandle_client = new WeakMap(), _JSHandle_disposed = new WeakMap(), _JSHandle_context = new WeakMap(), _JSHandle_remoteObject = new WeakMap();
+class ElementHandle extends JSHandle {
+    asElement() {
+        return this;
+    }
+}
+exports.ElementHandle = ElementHandle;

package/dist/browser/LaunchOptions.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 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.
+ */
+import type { BrowserConnectOptions } from './BrowserConnector';
+import type { Product } from './Product';
+export interface BrowserLaunchArgumentOptions {
+    headless?: boolean | 'chrome';
+    userDataDir?: string;
+    devtools?: boolean;
+    debuggingPort?: number;
+    args: string[];
+}
+export interface LaunchOptions {
+    executablePath?: string;
+    timeout?: number;
+    dumpio?: boolean;
+    env?: Record<string, string | undefined>;
+    pipe?: boolean;
+    product?: Product;
+}
+export declare type PuppeteerNodeLaunchOptions = BrowserLaunchArgumentOptions & LaunchOptions & BrowserConnectOptions;

package/dist/browser/LaunchOptions.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 });

package/dist/browser/Launcher.d.ts

@@ -0,0 +1,15 @@
+import { Browser } from './Browser';
+import type { PuppeteerNodeLaunchOptions } from './LaunchOptions';
+import type { Product } from './Product';
+export interface ProductLauncher {
+    launch(object: PuppeteerNodeLaunchOptions): Promise<Browser>;
+    executablePath: (path?: any) => string;
+    product: Product;
+}
+export declare class ChromeLauncher implements ProductLauncher {
+    _preferredRevision: string;
+    constructor(preferredRevision: string);
+    launch(options: PuppeteerNodeLaunchOptions): Promise<Browser>;
+    executablePath(): string;
+    get product(): Product;
+}

package/dist/browser/Launcher.js

@@ -0,0 +1,144 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChromeLauncher = 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 fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const assert_1 = require("./assert");
+const Browser_1 = require("./Browser");
+const BrowserFetcher_1 = require("./BrowserFetcher");
+const BrowserRunner_1 = require("./BrowserRunner");
+const mkdtempAsync = fs.promises.mkdtemp;
+const tmpDir = () => {
+    return process.env.PUPPETEER_TMP_DIR || os.tmpdir();
+};
+class ChromeLauncher {
+    constructor(preferredRevision) {
+        this._preferredRevision = preferredRevision;
+    }
+    async launch(options) {
+        const { args = [], dumpio = false, executablePath, pipe = false, env = process.env, defaultViewport, timeout = 60000, debuggingPort, } = options;
+        const chromeArguments = args;
+        if (!chromeArguments.some((argument) => {
+            return argument.startsWith('--remote-debugging-');
+        })) {
+            if (pipe) {
+                (0, assert_1.assert)(!debuggingPort, 'Browser should be launched with either pipe or debugging port - not both.');
+                chromeArguments.push('--remote-debugging-pipe');
+            }
+            else {
+                chromeArguments.push(`--remote-debugging-port=${debuggingPort || 0}`);
+            }
+        }
+        // Check for the user data dir argument, which will always be set even
+        // with a custom directory specified via the userDataDir option.
+        const userDataDir = await mkdtempAsync(path.join(tmpDir(), 'puppeteer_dev_chrome_profile-'));
+        chromeArguments.push(`--user-data-dir=${userDataDir}`);
+        let chromeExecutable = executablePath;
+        if (!chromeExecutable) {
+            const { missingText, executablePath: exPath } = resolveExecutablePath(this);
+            if (missingText) {
+                throw new Error(missingText);
+            }
+            chromeExecutable = exPath;
+        }
+        const runner = new BrowserRunner_1.BrowserRunner({
+            executablePath: chromeExecutable,
+            processArguments: chromeArguments,
+            userDataDir,
+        });
+        runner.start({
+            dumpio,
+            env,
+            pipe: false,
+        });
+        let browser;
+        try {
+            const connection = await runner.setupConnection({
+                timeout,
+                preferredRevision: this._preferredRevision,
+            });
+            browser = await Browser_1.Browser._create({
+                connection,
+                contextIds: [],
+                defaultViewport,
+                closeCallback: runner.close.bind(runner),
+            });
+        }
+        catch (error) {
+            runner.kill();
+            throw error;
+        }
+        try {
+            await browser.waitForTarget((t) => {
+                return t.type() === 'page';
+            }, { timeout });
+        }
+        catch (error) {
+            await browser.close(false);
+            throw error;
+        }
+        return browser;
+    }
+    executablePath() {
+        const results = resolveExecutablePath(this);
+        return results.executablePath;
+    }
+    get product() {
+        return 'chrome';
+    }
+}
+exports.ChromeLauncher = ChromeLauncher;
+function resolveExecutablePath(launcher) {
+    const { product, _preferredRevision } = launcher;
+    const browserFetcher = new BrowserFetcher_1.BrowserFetcher({
+        product,
+        path: null,
+        platform: null,
+    });
+    const revisionInfo = browserFetcher.revisionInfo(_preferredRevision);
+    const firefoxHelp = `Run \`PUPPETEER_PRODUCT=firefox npm install\` to download a supported Firefox browser binary.`;
+    const chromeHelp = `Run \`npm install\` to download the correct Chromium revision (${launcher._preferredRevision}).`;
+    const missingText = revisionInfo.local
+        ? undefined
+        : `Could not find expected browser (${product}) locally. ${product === 'chrome' ? chromeHelp : firefoxHelp}`;
+    return { executablePath: revisionInfo.executablePath, missingText };
+}

package/dist/browser/LifecycleWatcher.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Copyright 2019 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.
+ */
+import { TimeoutError } from './Errors';
+import type { Frame, FrameManager } from './FrameManager';
+import type { HTTPResponse } from './HTTPResponse';
+export declare type PuppeteerLifeCycleEvent = 'load';
+export declare class LifecycleWatcher {
+    #private;
+    constructor(frameManager: FrameManager, frame: Frame, waitUntil: PuppeteerLifeCycleEvent, timeout: number);
+    navigationResponse(): HTTPResponse | null;
+    sameDocumentNavigationPromise(): Promise<Error | undefined>;
+    newDocumentNavigationPromise(): Promise<Error | undefined>;
+    lifecyclePromise(): Promise<void>;
+    timeoutOrTerminationPromise(): Promise<Error | TimeoutError | undefined>;
+    dispose(): void;
+}

package/dist/browser/LifecycleWatcher.js

@@ -0,0 +1,180 @@
+"use strict";
+/**
+ * Copyright 2019 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 _LifecycleWatcher_instances, _LifecycleWatcher_expectedLifecycle, _LifecycleWatcher_frameManager, _LifecycleWatcher_frame, _LifecycleWatcher_timeout, _LifecycleWatcher_navigationRequest, _LifecycleWatcher_eventListeners, _LifecycleWatcher_sameDocumentNavigationCompleteCallback, _LifecycleWatcher_sameDocumentNavigationPromise, _LifecycleWatcher_lifecycleCallback, _LifecycleWatcher_lifecyclePromise, _LifecycleWatcher_newDocumentNavigationCompleteCallback, _LifecycleWatcher_newDocumentNavigationPromise, _LifecycleWatcher_terminationCallback, _LifecycleWatcher_terminationPromise, _LifecycleWatcher_timeoutPromise, _LifecycleWatcher_maximumTimer, _LifecycleWatcher_hasSameDocumentNavigation, _LifecycleWatcher_newDocumentNavigation, _LifecycleWatcher_swapped, _LifecycleWatcher_onRequest, _LifecycleWatcher_onFrameDetached, _LifecycleWatcher_terminate, _LifecycleWatcher_createTimeoutPromise, _LifecycleWatcher_navigatedWithinDocument, _LifecycleWatcher_navigated, _LifecycleWatcher_frameSwapped, _LifecycleWatcher_checkLifecycleComplete;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LifecycleWatcher = void 0;
+const assert_1 = require("./assert");
+const Connection_1 = require("./Connection");
+const Errors_1 = require("./Errors");
+const FrameManager_1 = require("./FrameManager");
+const NetworkManager_1 = require("./NetworkManager");
+const util_1 = require("./util");
+const puppeteerToProtocolLifecycle = new Map([['load', 'load']]);
+const noop = () => undefined;
+class LifecycleWatcher {
+    constructor(frameManager, frame, waitUntil, timeout) {
+        _LifecycleWatcher_instances.add(this);
+        _LifecycleWatcher_expectedLifecycle.set(this, void 0);
+        _LifecycleWatcher_frameManager.set(this, void 0);
+        _LifecycleWatcher_frame.set(this, void 0);
+        _LifecycleWatcher_timeout.set(this, void 0);
+        _LifecycleWatcher_navigationRequest.set(this, null);
+        _LifecycleWatcher_eventListeners.set(this, void 0);
+        _LifecycleWatcher_sameDocumentNavigationCompleteCallback.set(this, noop);
+        _LifecycleWatcher_sameDocumentNavigationPromise.set(this, new Promise((fulfill) => {
+            __classPrivateFieldSet(this, _LifecycleWatcher_sameDocumentNavigationCompleteCallback, fulfill, "f");
+        }));
+        _LifecycleWatcher_lifecycleCallback.set(this, noop);
+        _LifecycleWatcher_lifecyclePromise.set(this, new Promise((fulfill) => {
+            __classPrivateFieldSet(this, _LifecycleWatcher_lifecycleCallback, fulfill, "f");
+        }));
+        _LifecycleWatcher_newDocumentNavigationCompleteCallback.set(this, noop);
+        _LifecycleWatcher_newDocumentNavigationPromise.set(this, new Promise((fulfill) => {
+            __classPrivateFieldSet(this, _LifecycleWatcher_newDocumentNavigationCompleteCallback, fulfill, "f");
+        }));
+        _LifecycleWatcher_terminationCallback.set(this, noop);
+        _LifecycleWatcher_terminationPromise.set(this, new Promise((fulfill) => {
+            __classPrivateFieldSet(this, _LifecycleWatcher_terminationCallback, fulfill, "f");
+        }));
+        _LifecycleWatcher_timeoutPromise.set(this, void 0);
+        _LifecycleWatcher_maximumTimer.set(this, void 0);
+        _LifecycleWatcher_hasSameDocumentNavigation.set(this, void 0);
+        _LifecycleWatcher_newDocumentNavigation.set(this, void 0);
+        _LifecycleWatcher_swapped.set(this, void 0);
+        const protocolEvent = puppeteerToProtocolLifecycle.get(waitUntil);
+        (0, assert_1.assert)(protocolEvent, 'Unknown value for options.waitUntil: ' + waitUntil);
+        __classPrivateFieldSet(this, _LifecycleWatcher_expectedLifecycle, [waitUntil], "f");
+        __classPrivateFieldSet(this, _LifecycleWatcher_frameManager, frameManager, "f");
+        __classPrivateFieldSet(this, _LifecycleWatcher_frame, frame, "f");
+        __classPrivateFieldSet(this, _LifecycleWatcher_timeout, timeout, "f");
+        __classPrivateFieldSet(this, _LifecycleWatcher_eventListeners, [
+            (0, util_1.addEventListener)(frameManager._client, Connection_1.CDPSessionEmittedEvents.Disconnected, __classPrivateFieldGet(this, _LifecycleWatcher_instances, "m", _LifecycleWatcher_terminate).bind(this, new Error('Navigation failed because browser has disconnected!'))),
+            (0, util_1.addEventListener)(__classPrivateFieldGet(this, _LifecycleWatcher_frameManager, "f"), FrameManager_1.FrameManagerEmittedEvents.LifecycleEvent, __classPrivateFieldGet(this, _LifecycleWatcher_instances, "m", _LifecycleWatcher_checkLifecycleComplete).bind(this)),
+            (0, util_1.addEventListener)(__classPrivateFieldGet(this, _LifecycleWatcher_frameManager, "f"), FrameManager_1.FrameManagerEmittedEvents.FrameNavigatedWithinDocument, __classPrivateFieldGet(this, _LifecycleWatcher_instances, "m", _LifecycleWatcher_navigatedWithinDocument).bind(this)),
+            (0, util_1.addEventListener)(__classPrivateFieldGet(this, _LifecycleWatcher_frameManager, "f"), FrameManager_1.FrameManagerEmittedEvents.FrameNavigated, __classPrivateFieldGet(this, _LifecycleWatcher_instances, "m", _LifecycleWatcher_navigated).bind(this)),
+            (0, util_1.addEventListener)(__classPrivateFieldGet(this, _LifecycleWatcher_frameManager, "f"), FrameManager_1.FrameManagerEmittedEvents.FrameSwapped, __classPrivateFieldGet(this, _LifecycleWatcher_instances, "m", _LifecycleWatcher_frameSwapped).bind(this)),
+            (0, util_1.addEventListener)(__classPrivateFieldGet(this, _LifecycleWatcher_frameManager, "f"), FrameManager_1.FrameManagerEmittedEvents.FrameDetached, __classPrivateFieldGet(this, _LifecycleWatcher_instances, "m", _LifecycleWatcher_onFrameDetached).bind(this)),
+            (0, util_1.addEventListener)(__classPrivateFieldGet(this, _LifecycleWatcher_frameManager, "f").networkManager(), NetworkManager_1.NetworkManagerEmittedEvents.Request, __classPrivateFieldGet(this, _LifecycleWatcher_instances, "m", _LifecycleWatcher_onRequest).bind(this)),
+        ], "f");
+        __classPrivateFieldSet(this, _LifecycleWatcher_timeoutPromise, __classPrivateFieldGet(this, _LifecycleWatcher_instances, "m", _LifecycleWatcher_createTimeoutPromise).call(this), "f");
+        __classPrivateFieldGet(this, _LifecycleWatcher_instances, "m", _LifecycleWatcher_checkLifecycleComplete).call(this);
+    }
+    navigationResponse() {
+        if (!__classPrivateFieldGet(this, _LifecycleWatcher_navigationRequest, "f")) {
+            return null;
+        }
+        const res = __classPrivateFieldGet(this, _LifecycleWatcher_navigationRequest, "f").response();
+        return res;
+    }
+    sameDocumentNavigationPromise() {
+        return __classPrivateFieldGet(this, _LifecycleWatcher_sameDocumentNavigationPromise, "f");
+    }
+    newDocumentNavigationPromise() {
+        return __classPrivateFieldGet(this, _LifecycleWatcher_newDocumentNavigationPromise, "f");
+    }
+    lifecyclePromise() {
+        return __classPrivateFieldGet(this, _LifecycleWatcher_lifecyclePromise, "f");
+    }
+    timeoutOrTerminationPromise() {
+        return Promise.race([__classPrivateFieldGet(this, _LifecycleWatcher_timeoutPromise, "f"), __classPrivateFieldGet(this, _LifecycleWatcher_terminationPromise, "f")]);
+    }
+    dispose() {
+        (0, util_1.removeEventListeners)(__classPrivateFieldGet(this, _LifecycleWatcher_eventListeners, "f"));
+        if (__classPrivateFieldGet(this, _LifecycleWatcher_maximumTimer, "f") !== undefined) {
+            clearTimeout(__classPrivateFieldGet(this, _LifecycleWatcher_maximumTimer, "f"));
+        }
+    }
+}
+exports.LifecycleWatcher = LifecycleWatcher;
+_LifecycleWatcher_expectedLifecycle = new WeakMap(), _LifecycleWatcher_frameManager = new WeakMap(), _LifecycleWatcher_frame = new WeakMap(), _LifecycleWatcher_timeout = new WeakMap(), _LifecycleWatcher_navigationRequest = new WeakMap(), _LifecycleWatcher_eventListeners = new WeakMap(), _LifecycleWatcher_sameDocumentNavigationCompleteCallback = new WeakMap(), _LifecycleWatcher_sameDocumentNavigationPromise = new WeakMap(), _LifecycleWatcher_lifecycleCallback = new WeakMap(), _LifecycleWatcher_lifecyclePromise = new WeakMap(), _LifecycleWatcher_newDocumentNavigationCompleteCallback = new WeakMap(), _LifecycleWatcher_newDocumentNavigationPromise = new WeakMap(), _LifecycleWatcher_terminationCallback = new WeakMap(), _LifecycleWatcher_terminationPromise = new WeakMap(), _LifecycleWatcher_timeoutPromise = new WeakMap(), _LifecycleWatcher_maximumTimer = new WeakMap(), _LifecycleWatcher_hasSameDocumentNavigation = new WeakMap(), _LifecycleWatcher_newDocumentNavigation = new WeakMap(), _LifecycleWatcher_swapped = new WeakMap(), _LifecycleWatcher_instances = new WeakSet(), _LifecycleWatcher_onRequest = function _LifecycleWatcher_onRequest(request) {
+    if (request.frame() !== __classPrivateFieldGet(this, _LifecycleWatcher_frame, "f") || !request.isNavigationRequest()) {
+        return;
+    }
+    __classPrivateFieldSet(this, _LifecycleWatcher_navigationRequest, request, "f");
+}, _LifecycleWatcher_onFrameDetached = function _LifecycleWatcher_onFrameDetached(frame) {
+    if (__classPrivateFieldGet(this, _LifecycleWatcher_frame, "f") === frame) {
+        __classPrivateFieldGet(this, _LifecycleWatcher_terminationCallback, "f").call(null, new Error('Navigating frame was detached'));
+        return;
+    }
+    __classPrivateFieldGet(this, _LifecycleWatcher_instances, "m", _LifecycleWatcher_checkLifecycleComplete).call(this);
+}, _LifecycleWatcher_terminate = function _LifecycleWatcher_terminate(error) {
+    __classPrivateFieldGet(this, _LifecycleWatcher_terminationCallback, "f").call(null, error);
+}, _LifecycleWatcher_createTimeoutPromise = async function _LifecycleWatcher_createTimeoutPromise() {
+    if (!__classPrivateFieldGet(this, _LifecycleWatcher_timeout, "f")) {
+        return new Promise(noop);
+    }
+    const errorMessage = 'Navigation timeout of ' + __classPrivateFieldGet(this, _LifecycleWatcher_timeout, "f") + ' ms exceeded';
+    await new Promise((fulfill) => {
+        __classPrivateFieldSet(this, _LifecycleWatcher_maximumTimer, setTimeout(fulfill, __classPrivateFieldGet(this, _LifecycleWatcher_timeout, "f")), "f");
+    });
+    return new Errors_1.TimeoutError(errorMessage);
+}, _LifecycleWatcher_navigatedWithinDocument = function _LifecycleWatcher_navigatedWithinDocument(frame) {
+    if (frame !== __classPrivateFieldGet(this, _LifecycleWatcher_frame, "f")) {
+        return;
+    }
+    __classPrivateFieldSet(this, _LifecycleWatcher_hasSameDocumentNavigation, true, "f");
+    __classPrivateFieldGet(this, _LifecycleWatcher_instances, "m", _LifecycleWatcher_checkLifecycleComplete).call(this);
+}, _LifecycleWatcher_navigated = function _LifecycleWatcher_navigated(frame) {
+    if (frame !== __classPrivateFieldGet(this, _LifecycleWatcher_frame, "f")) {
+        return;
+    }
+    __classPrivateFieldSet(this, _LifecycleWatcher_newDocumentNavigation, true, "f");
+    __classPrivateFieldGet(this, _LifecycleWatcher_instances, "m", _LifecycleWatcher_checkLifecycleComplete).call(this);
+}, _LifecycleWatcher_frameSwapped = function _LifecycleWatcher_frameSwapped(frame) {
+    if (frame !== __classPrivateFieldGet(this, _LifecycleWatcher_frame, "f")) {
+        return;
+    }
+    __classPrivateFieldSet(this, _LifecycleWatcher_swapped, true, "f");
+    __classPrivateFieldGet(this, _LifecycleWatcher_instances, "m", _LifecycleWatcher_checkLifecycleComplete).call(this);
+}, _LifecycleWatcher_checkLifecycleComplete = function _LifecycleWatcher_checkLifecycleComplete() {
+    // We expect navigation to commit.
+    if (!checkLifecycle(__classPrivateFieldGet(this, _LifecycleWatcher_frame, "f"), __classPrivateFieldGet(this, _LifecycleWatcher_expectedLifecycle, "f"))) {
+        return;
+    }
+    __classPrivateFieldGet(this, _LifecycleWatcher_lifecycleCallback, "f").call(this);
+    if (__classPrivateFieldGet(this, _LifecycleWatcher_hasSameDocumentNavigation, "f")) {
+        __classPrivateFieldGet(this, _LifecycleWatcher_sameDocumentNavigationCompleteCallback, "f").call(this);
+    }
+    if (__classPrivateFieldGet(this, _LifecycleWatcher_swapped, "f") || __classPrivateFieldGet(this, _LifecycleWatcher_newDocumentNavigation, "f")) {
+        __classPrivateFieldGet(this, _LifecycleWatcher_newDocumentNavigationCompleteCallback, "f").call(this);
+    }
+    function checkLifecycle(frame, expectedLifecycle) {
+        for (const event of expectedLifecycle) {
+            if (!frame._lifecycleEvents.has(event)) {
+                return false;
+            }
+        }
+        for (const child of frame.childFrames()) {
+            if (child._hasStartedLoading &&
+                !checkLifecycle(child, expectedLifecycle)) {
+                return false;
+            }
+        }
+        return true;
+    }
+};

package/dist/browser/NetworkEventManager.d.ts

@@ -0,0 +1,33 @@
+import type { LoadingFailedEvent, LoadingFinishedEvent, RequestPausedEvent, RequestWillBeSentEvent, ResponseReceivedEvent, ResponseReceivedExtraInfoEvent } from './devtools-types';
+import type { HTTPRequest } from './HTTPRequest';
+declare type QueuedEventGroup = {
+    responseReceivedEvent: ResponseReceivedEvent;
+    loadingFinishedEvent?: LoadingFinishedEvent;
+    loadingFailedEvent?: LoadingFailedEvent;
+};
+export declare type FetchRequestId = string;
+declare type NetworkRequestId = string;
+declare type RedirectInfo = {
+    event: RequestWillBeSentEvent;
+    fetchRequestId?: FetchRequestId;
+};
+export declare class NetworkEventManager {
+    #private;
+    forget(networkRequestId: NetworkRequestId): void;
+    responseExtraInfo(networkRequestId: NetworkRequestId): ResponseReceivedExtraInfoEvent[];
+    private queuedRedirectInfo;
+    queueRedirectInfo(fetchRequestId: FetchRequestId, redirectInfo: RedirectInfo): void;
+    takeQueuedRedirectInfo(fetchRequestId: FetchRequestId): RedirectInfo | undefined;
+    numRequestsInProgress(): number;
+    storeRequestWillBeSent(networkRequestId: NetworkRequestId, event: RequestWillBeSentEvent): void;
+    getRequestWillBeSent(networkRequestId: NetworkRequestId): RequestWillBeSentEvent | undefined;
+    forgetRequestWillBeSent(networkRequestId: NetworkRequestId): void;
+    storeRequestPaused(networkRequestId: NetworkRequestId, event: RequestPausedEvent): void;
+    getRequest(networkRequestId: NetworkRequestId): HTTPRequest | undefined;
+    storeRequest(networkRequestId: NetworkRequestId, request: HTTPRequest): void;
+    forgetRequest(networkRequestId: NetworkRequestId): void;
+    getQueuedEventGroup(networkRequestId: NetworkRequestId): QueuedEventGroup | undefined;
+    queueEventGroup(networkRequestId: NetworkRequestId, event: QueuedEventGroup): void;
+    forgetQueuedEventGroup(networkRequestId: NetworkRequestId): void;
+}
+export {};

package/dist/browser/NetworkEventManager.js

@@ -0,0 +1,81 @@
+"use strict";
+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 _NetworkEventManager_requestWillBeSentMap, _NetworkEventManager_requestPausedMap, _NetworkEventManager_httpRequestsMap, _NetworkEventManager_responseReceivedExtraInfoMap, _NetworkEventManager_queuedRedirectInfoMap, _NetworkEventManager_queuedEventGroupMap;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkEventManager = void 0;
+class NetworkEventManager {
+    constructor() {
+        _NetworkEventManager_requestWillBeSentMap.set(this, new Map());
+        _NetworkEventManager_requestPausedMap.set(this, new Map());
+        _NetworkEventManager_httpRequestsMap.set(this, new Map());
+        _NetworkEventManager_responseReceivedExtraInfoMap.set(this, new Map());
+        _NetworkEventManager_queuedRedirectInfoMap.set(this, new Map());
+        _NetworkEventManager_queuedEventGroupMap.set(this, new Map());
+    }
+    forget(networkRequestId) {
+        __classPrivateFieldGet(this, _NetworkEventManager_requestWillBeSentMap, "f").delete(networkRequestId);
+        __classPrivateFieldGet(this, _NetworkEventManager_requestPausedMap, "f").delete(networkRequestId);
+        __classPrivateFieldGet(this, _NetworkEventManager_queuedEventGroupMap, "f").delete(networkRequestId);
+        __classPrivateFieldGet(this, _NetworkEventManager_queuedRedirectInfoMap, "f").delete(networkRequestId);
+        __classPrivateFieldGet(this, _NetworkEventManager_responseReceivedExtraInfoMap, "f").delete(networkRequestId);
+    }
+    responseExtraInfo(networkRequestId) {
+        if (!__classPrivateFieldGet(this, _NetworkEventManager_responseReceivedExtraInfoMap, "f").has(networkRequestId)) {
+            __classPrivateFieldGet(this, _NetworkEventManager_responseReceivedExtraInfoMap, "f").set(networkRequestId, []);
+        }
+        return __classPrivateFieldGet(this, _NetworkEventManager_responseReceivedExtraInfoMap, "f").get(networkRequestId);
+    }
+    queuedRedirectInfo(fetchRequestId) {
+        if (!__classPrivateFieldGet(this, _NetworkEventManager_queuedRedirectInfoMap, "f").has(fetchRequestId)) {
+            __classPrivateFieldGet(this, _NetworkEventManager_queuedRedirectInfoMap, "f").set(fetchRequestId, []);
+        }
+        return __classPrivateFieldGet(this, _NetworkEventManager_queuedRedirectInfoMap, "f").get(fetchRequestId);
+    }
+    queueRedirectInfo(fetchRequestId, redirectInfo) {
+        this.queuedRedirectInfo(fetchRequestId).push(redirectInfo);
+    }
+    takeQueuedRedirectInfo(fetchRequestId) {
+        return this.queuedRedirectInfo(fetchRequestId).shift();
+    }
+    numRequestsInProgress() {
+        return [...__classPrivateFieldGet(this, _NetworkEventManager_httpRequestsMap, "f")].filter(([, request]) => {
+            return !request.response();
+        }).length;
+    }
+    storeRequestWillBeSent(networkRequestId, event) {
+        __classPrivateFieldGet(this, _NetworkEventManager_requestWillBeSentMap, "f").set(networkRequestId, event);
+    }
+    getRequestWillBeSent(networkRequestId) {
+        return __classPrivateFieldGet(this, _NetworkEventManager_requestWillBeSentMap, "f").get(networkRequestId);
+    }
+    forgetRequestWillBeSent(networkRequestId) {
+        __classPrivateFieldGet(this, _NetworkEventManager_requestWillBeSentMap, "f").delete(networkRequestId);
+    }
+    storeRequestPaused(networkRequestId, event) {
+        __classPrivateFieldGet(this, _NetworkEventManager_requestPausedMap, "f").set(networkRequestId, event);
+    }
+    getRequest(networkRequestId) {
+        return __classPrivateFieldGet(this, _NetworkEventManager_httpRequestsMap, "f").get(networkRequestId);
+    }
+    storeRequest(networkRequestId, request) {
+        __classPrivateFieldGet(this, _NetworkEventManager_httpRequestsMap, "f").set(networkRequestId, request);
+    }
+    forgetRequest(networkRequestId) {
+        __classPrivateFieldGet(this, _NetworkEventManager_httpRequestsMap, "f").delete(networkRequestId);
+    }
+    getQueuedEventGroup(networkRequestId) {
+        return __classPrivateFieldGet(this, _NetworkEventManager_queuedEventGroupMap, "f").get(networkRequestId);
+    }
+    queueEventGroup(networkRequestId, event) {
+        __classPrivateFieldGet(this, _NetworkEventManager_queuedEventGroupMap, "f").set(networkRequestId, event);
+    }
+    forgetQueuedEventGroup(networkRequestId) {
+        __classPrivateFieldGet(this, _NetworkEventManager_queuedEventGroupMap, "f").delete(networkRequestId);
+    }
+}
+exports.NetworkEventManager = NetworkEventManager;
+_NetworkEventManager_requestWillBeSentMap = new WeakMap(), _NetworkEventManager_requestPausedMap = new WeakMap(), _NetworkEventManager_httpRequestsMap = new WeakMap(), _NetworkEventManager_responseReceivedExtraInfoMap = new WeakMap(), _NetworkEventManager_queuedRedirectInfoMap = new WeakMap(), _NetworkEventManager_queuedEventGroupMap = new WeakMap();