@remotion/renderer 4.0.357 → 4.0.358

package/package/dist/browser/NetworkManager.js

@@ -0,0 +1,246 @@
+"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 _NetworkManager_instances, _NetworkManager_client, _NetworkManager_frameManager, _NetworkManager_networkEventManager, _NetworkManager_indent, _NetworkManager_logLevel, _NetworkManager_onRequestWillBeSent, _NetworkManager_onRequestPaused, _NetworkManager_patchRequestEventHeaders, _NetworkManager_onRequest, _NetworkManager_onRequestServedFromCache, _NetworkManager_handleRequestRedirect, _NetworkManager_emitResponseEvent, _NetworkManager_onResponseReceived, _NetworkManager_onResponseReceivedExtraInfo, _NetworkManager_forgetRequest, _NetworkManager_onLoadingFinished, _NetworkManager_emitLoadingFinished, _NetworkManager_onLoadingFailed, _NetworkManager_emitLoadingFailed;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkManager = exports.NetworkManagerEmittedEvents = void 0;
+const EventEmitter_1 = require("./EventEmitter");
+const handle_failed_resource_1 = require("./handle-failed-resource");
+const HTTPRequest_1 = require("./HTTPRequest");
+const HTTPResponse_1 = require("./HTTPResponse");
+const NetworkEventManager_1 = require("./NetworkEventManager");
+exports.NetworkManagerEmittedEvents = {
+    Request: Symbol('NetworkManager.Request'),
+};
+class NetworkManager extends EventEmitter_1.EventEmitter {
+    constructor(client, frameManager, indent, logLevel) {
+        super();
+        _NetworkManager_instances.add(this);
+        _NetworkManager_client.set(this, void 0);
+        _NetworkManager_frameManager.set(this, void 0);
+        _NetworkManager_networkEventManager.set(this, new NetworkEventManager_1.NetworkEventManager());
+        _NetworkManager_indent.set(this, void 0);
+        _NetworkManager_logLevel.set(this, void 0);
+        __classPrivateFieldSet(this, _NetworkManager_client, client, "f");
+        __classPrivateFieldSet(this, _NetworkManager_frameManager, frameManager, "f");
+        __classPrivateFieldSet(this, _NetworkManager_indent, indent, "f");
+        __classPrivateFieldSet(this, _NetworkManager_logLevel, logLevel, "f");
+        __classPrivateFieldGet(this, _NetworkManager_client, "f").on('Fetch.requestPaused', __classPrivateFieldGet(this, _NetworkManager_instances, "m", _NetworkManager_onRequestPaused).bind(this));
+        __classPrivateFieldGet(this, _NetworkManager_client, "f").on('Network.requestWillBeSent', __classPrivateFieldGet(this, _NetworkManager_instances, "m", _NetworkManager_onRequestWillBeSent).bind(this));
+        __classPrivateFieldGet(this, _NetworkManager_client, "f").on('Network.requestServedFromCache', __classPrivateFieldGet(this, _NetworkManager_instances, "m", _NetworkManager_onRequestServedFromCache).bind(this));
+        __classPrivateFieldGet(this, _NetworkManager_client, "f").on('Network.responseReceived', __classPrivateFieldGet(this, _NetworkManager_instances, "m", _NetworkManager_onResponseReceived).bind(this));
+        __classPrivateFieldGet(this, _NetworkManager_client, "f").on('Network.loadingFinished', __classPrivateFieldGet(this, _NetworkManager_instances, "m", _NetworkManager_onLoadingFinished).bind(this));
+        __classPrivateFieldGet(this, _NetworkManager_client, "f").on('Network.loadingFailed', __classPrivateFieldGet(this, _NetworkManager_instances, "m", _NetworkManager_onLoadingFailed).bind(this));
+        __classPrivateFieldGet(this, _NetworkManager_client, "f").on('Network.responseReceivedExtraInfo', __classPrivateFieldGet(this, _NetworkManager_instances, "m", _NetworkManager_onResponseReceivedExtraInfo).bind(this));
+    }
+    async initialize() {
+        await __classPrivateFieldGet(this, _NetworkManager_client, "f").send('Network.enable');
+    }
+}
+exports.NetworkManager = NetworkManager;
+_NetworkManager_client = new WeakMap(), _NetworkManager_frameManager = new WeakMap(), _NetworkManager_networkEventManager = new WeakMap(), _NetworkManager_indent = new WeakMap(), _NetworkManager_logLevel = new WeakMap(), _NetworkManager_instances = new WeakSet(), _NetworkManager_onRequestWillBeSent = function _NetworkManager_onRequestWillBeSent(event) {
+    __classPrivateFieldGet(this, _NetworkManager_instances, "m", _NetworkManager_onRequest).call(this, event, undefined);
+}, _NetworkManager_onRequestPaused = function _NetworkManager_onRequestPaused(event) {
+    const { networkId: networkRequestId, requestId: fetchRequestId } = event;
+    if (!networkRequestId) {
+        return;
+    }
+    const requestWillBeSentEvent = (() => {
+        const _requestWillBeSentEvent = __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").getRequestWillBeSent(networkRequestId);
+        // redirect requests have the same `requestId`,
+        if (_requestWillBeSentEvent &&
+            (_requestWillBeSentEvent.request.url !== event.request.url ||
+                _requestWillBeSentEvent.request.method !== event.request.method)) {
+            __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").forgetRequestWillBeSent(networkRequestId);
+            return;
+        }
+        return _requestWillBeSentEvent;
+    })();
+    if (requestWillBeSentEvent) {
+        __classPrivateFieldGet(this, _NetworkManager_instances, "m", _NetworkManager_patchRequestEventHeaders).call(this, requestWillBeSentEvent, event);
+        __classPrivateFieldGet(this, _NetworkManager_instances, "m", _NetworkManager_onRequest).call(this, requestWillBeSentEvent, fetchRequestId);
+    }
+    else {
+        __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").storeRequestPaused(networkRequestId, event);
+    }
+}, _NetworkManager_patchRequestEventHeaders = function _NetworkManager_patchRequestEventHeaders(requestWillBeSentEvent, requestPausedEvent) {
+    requestWillBeSentEvent.request.headers = {
+        ...requestWillBeSentEvent.request.headers,
+        // includes extra headers, like: Accept, Origin
+        ...requestPausedEvent.request.headers,
+    };
+}, _NetworkManager_onRequest = function _NetworkManager_onRequest(event, fetchRequestId) {
+    if (event.redirectResponse) {
+        // We want to emit a response and requestfinished for the
+        // redirectResponse, but we can't do so unless we have a
+        // responseExtraInfo ready to pair it up with. If we don't have any
+        // responseExtraInfos saved in our queue, they we have to wait until
+        // the next one to emit response and requestfinished, *and* we should
+        // also wait to emit this Request too because it should come after the
+        // response/requestfinished.
+        let redirectResponseExtraInfo = null;
+        if (event.redirectHasExtraInfo) {
+            redirectResponseExtraInfo = __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f")
+                .getResponseExtraInfo(event.requestId)
+                .shift();
+            if (!redirectResponseExtraInfo) {
+                __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").queueRedirectInfo(event.requestId, {
+                    event,
+                    fetchRequestId,
+                });
+                return;
+            }
+        }
+        const _request = __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").getRequest(event.requestId);
+        // If we connect late to the target, we could have missed the
+        // requestWillBeSent event.
+        if (_request) {
+            __classPrivateFieldGet(this, _NetworkManager_instances, "m", _NetworkManager_handleRequestRedirect).call(this, _request, event.redirectResponse, redirectResponseExtraInfo);
+        }
+    }
+    const frame = event.frameId
+        ? __classPrivateFieldGet(this, _NetworkManager_frameManager, "f").frame(event.frameId)
+        : null;
+    const request = new HTTPRequest_1.HTTPRequest(frame, event);
+    __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").storeRequest(event.requestId, request);
+    this.emit(exports.NetworkManagerEmittedEvents.Request, request);
+}, _NetworkManager_onRequestServedFromCache = function _NetworkManager_onRequestServedFromCache(event) {
+    const request = __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").getRequest(event.requestId);
+    if (request) {
+        request._fromMemoryCache = true;
+    }
+}, _NetworkManager_handleRequestRedirect = function _NetworkManager_handleRequestRedirect(request, responsePayload, extraInfo) {
+    const response = new HTTPResponse_1.HTTPResponse(responsePayload, extraInfo);
+    request._response = response;
+    __classPrivateFieldGet(this, _NetworkManager_instances, "m", _NetworkManager_forgetRequest).call(this, request, false);
+}, _NetworkManager_emitResponseEvent = function _NetworkManager_emitResponseEvent(responseReceived, extraInfo) {
+    const request = __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").getRequest(responseReceived.requestId);
+    // FileUpload sends a response without a matching request.
+    if (!request) {
+        return;
+    }
+    const response = new HTTPResponse_1.HTTPResponse(responseReceived.response, extraInfo);
+    request._response = response;
+}, _NetworkManager_onResponseReceived = function _NetworkManager_onResponseReceived(event) {
+    const request = __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").getRequest(event.requestId);
+    let extraInfo = null;
+    if (request && !request._fromMemoryCache && event.hasExtraInfo) {
+        extraInfo = __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f")
+            .getResponseExtraInfo(event.requestId)
+            .shift();
+        if (!extraInfo) {
+            // Wait until we get the corresponding ExtraInfo event.
+            __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").queueEventGroup(event.requestId, {
+                responseReceivedEvent: event,
+            });
+            return;
+        }
+    }
+    __classPrivateFieldGet(this, _NetworkManager_instances, "m", _NetworkManager_emitResponseEvent).call(this, event, extraInfo);
+}, _NetworkManager_onResponseReceivedExtraInfo = function _NetworkManager_onResponseReceivedExtraInfo(event) {
+    // We may have skipped a redirect response/request pair due to waiting for
+    // this ExtraInfo event. If so, continue that work now that we have the
+    // request.
+    const redirectInfo = __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").takeQueuedRedirectInfo(event.requestId);
+    if (redirectInfo) {
+        __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f")
+            .getResponseExtraInfo(event.requestId)
+            .push(event);
+        __classPrivateFieldGet(this, _NetworkManager_instances, "m", _NetworkManager_onRequest).call(this, redirectInfo.event, redirectInfo.fetchRequestId);
+        return;
+    }
+    // We may have skipped response and loading events because we didn't have
+    // this ExtraInfo event yet. If so, emit those events now.
+    const queuedEvents = __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").getQueuedEventGroup(event.requestId);
+    if (queuedEvents) {
+        __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").forgetQueuedEventGroup(event.requestId);
+        __classPrivateFieldGet(this, _NetworkManager_instances, "m", _NetworkManager_emitResponseEvent).call(this, queuedEvents.responseReceivedEvent, event);
+        if (queuedEvents.loadingFinishedEvent) {
+            __classPrivateFieldGet(this, _NetworkManager_instances, "m", _NetworkManager_emitLoadingFinished).call(this, queuedEvents.loadingFinishedEvent);
+        }
+        if (queuedEvents.loadingFailedEvent) {
+            __classPrivateFieldGet(this, _NetworkManager_instances, "m", _NetworkManager_emitLoadingFailed).call(this, queuedEvents.loadingFailedEvent);
+        }
+        return;
+    }
+    // Wait until we get another event that can use this ExtraInfo event.
+    __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").getResponseExtraInfo(event.requestId).push(event);
+}, _NetworkManager_forgetRequest = function _NetworkManager_forgetRequest(request, events) {
+    const requestId = request._requestId;
+    __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").forgetRequest(requestId);
+    if (events) {
+        __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").forget(requestId);
+    }
+}, _NetworkManager_onLoadingFinished = function _NetworkManager_onLoadingFinished(event) {
+    // If the response event for this request is still waiting on a
+    // corresponding ExtraInfo event, then wait to emit this event too.
+    const queuedEvents = __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").getQueuedEventGroup(event.requestId);
+    if (queuedEvents) {
+        queuedEvents.loadingFinishedEvent = event;
+    }
+    else {
+        __classPrivateFieldGet(this, _NetworkManager_instances, "m", _NetworkManager_emitLoadingFinished).call(this, event);
+    }
+}, _NetworkManager_emitLoadingFinished = function _NetworkManager_emitLoadingFinished(event) {
+    const request = __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").getRequest(event.requestId);
+    // For certain requestIds we never receive requestWillBeSent event.
+    // @see https://crbug.com/750469
+    if (!request) {
+        return;
+    }
+    __classPrivateFieldGet(this, _NetworkManager_instances, "m", _NetworkManager_forgetRequest).call(this, request, true);
+}, _NetworkManager_onLoadingFailed = function _NetworkManager_onLoadingFailed(event) {
+    // If the response event for this request is still waiting on a
+    // corresponding ExtraInfo event, then wait to emit this event too.
+    const queuedEvents = __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").getQueuedEventGroup(event.requestId);
+    if (queuedEvents) {
+        queuedEvents.loadingFailedEvent = event;
+    }
+    else {
+        __classPrivateFieldGet(this, _NetworkManager_instances, "m", _NetworkManager_emitLoadingFailed).call(this, event);
+    }
+}, _NetworkManager_emitLoadingFailed = function _NetworkManager_emitLoadingFailed(event) {
+    const request = __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").getRequest(event.requestId);
+    // For certain requestIds we never receive requestWillBeSent event.
+    // @see https://crbug.com/750469
+    if (!request) {
+        return;
+    }
+    if (event.canceled) {
+        __classPrivateFieldGet(this, _NetworkManager_instances, "m", _NetworkManager_forgetRequest).call(this, request, true);
+        return;
+    }
+    const extraInfo = __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").getResponseExtraInfo(event.requestId);
+    (0, handle_failed_resource_1.handleFailedResource)({
+        extraInfo,
+        event,
+        indent: __classPrivateFieldGet(this, _NetworkManager_indent, "f"),
+        logLevel: __classPrivateFieldGet(this, _NetworkManager_logLevel, "f"),
+        request,
+    });
+    __classPrivateFieldGet(this, _NetworkManager_instances, "m", _NetworkManager_forgetRequest).call(this, request, true);
+};

package/package/dist/browser/NodeWebSocketTransport.d.ts

@@ -0,0 +1,19 @@
+import type { WS } from '../ws/ws-types';
+interface ConnectionTransport {
+    send(message: string): void;
+    close(): void;
+    onmessage?: (message: string) => void;
+    onclose?: () => void;
+}
+export declare class NodeWebSocketTransport implements ConnectionTransport {
+    static create(urlString: string): Promise<NodeWebSocketTransport>;
+    websocket: WS;
+    onmessage?: (message: string) => void;
+    onclose?: () => void;
+    constructor(ws: WS);
+    send(message: string): void;
+    close(): void;
+    forgetEventLoop(): void;
+    rememberEventLoop(): void;
+}
+export {};

package/package/dist/browser/NodeWebSocketTransport.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeWebSocketTransport = void 0;
+/**
+ * Copyright 2018 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 node_dns_1 = require("node:dns");
+const node_url_1 = require("node:url");
+const ws_types_1 = require("../ws/ws-types");
+class NodeWebSocketTransport {
+    static async create(urlString) {
+        // Starting in Node 17, IPv6 is favoured over IPv4 due to a change
+        // in a default option:
+        // - https://github.com/nodejs/node/issues/40537,
+        // Due to this, for Firefox, we must parse and resolve the `localhost` hostname
+        // manually with the previous behavior according to:
+        // - https://nodejs.org/api/dns.html#dnslookuphostname-options-callback
+        // because of https://bugzilla.mozilla.org/show_bug.cgi?id=1769994.
+        const url = new node_url_1.URL(urlString);
+        if (url.hostname === 'localhost') {
+            const { address } = await node_dns_1.promises.lookup(url.hostname, { verbatim: false });
+            url.hostname = address;
+        }
+        return new Promise((resolve, reject) => {
+            const ws = new ws_types_1.ws(url, [], {
+                followRedirects: true,
+                perMessageDeflate: false,
+                maxPayload: 1024 * 1024 * 1024, // 1024Mb
+                headers: {
+                    'User-Agent': `Remotion CLI`,
+                },
+            });
+            ws.addEventListener('open', () => {
+                return resolve(new NodeWebSocketTransport(ws));
+            });
+            ws.addEventListener('error', reject);
+        });
+    }
+    constructor(ws) {
+        this.websocket = ws;
+        this.websocket.addEventListener('message', (event) => {
+            if (this.onmessage) {
+                this.onmessage.call(null, event.data);
+            }
+        });
+        this.websocket.addEventListener('close', () => {
+            if (this.onclose) {
+                this.onclose.call(null);
+            }
+        });
+        // Silently ignore all errors - we don't know what to do with them.
+        this.websocket.addEventListener('error', () => undefined);
+    }
+    send(message) {
+        this.websocket.send(message);
+    }
+    close() {
+        this.websocket.close();
+    }
+    forgetEventLoop() {
+        // @ts-expect-error
+        this.websocket._socket.unref();
+    }
+    rememberEventLoop() {
+        // @ts-expect-error
+        this.websocket._socket.ref();
+    }
+}
+exports.NodeWebSocketTransport = NodeWebSocketTransport;

package/package/dist/browser/PuppeteerViewport.d.ts

@@ -0,0 +1,5 @@
+export interface Viewport {
+    width: number;
+    height: number;
+    deviceScaleFactor: number;
+}

package/package/dist/browser/PuppeteerViewport.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package/dist/browser/ScreenshotOptions.js

@@ -0,0 +1 @@
+"use strict";

package/package/dist/browser/Target.d.ts

@@ -0,0 +1,72 @@
+/**
+ * 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 { BrowserLog } from '../browser-log';
+import type { LogLevel } from '../log-level';
+import type { BrowserContext, HeadlessBrowser } from './Browser';
+import { OnLog, Page } from './BrowserPage';
+import type { CDPSession } from './Connection';
+import type { TargetInfo } from './devtools-types';
+import type { Viewport } from './PuppeteerViewport';
+import type { SourceMapGetter } from './source-map-getter';
+export declare class Target {
+    #private;
+    _initializedPromise: Promise<boolean> | null;
+    _initializedCallback: (x: boolean) => void;
+    _isClosedPromise: Promise<void>;
+    _closedCallback: () => void;
+    _isInitialized: boolean;
+    _targetId: string;
+    constructor(targetInfo: TargetInfo, browserContext: BrowserContext, sessionFactory: () => Promise<CDPSession>, defaultViewport: Viewport);
+    /**
+     * Creates a Chrome Devtools Protocol session attached to the target.
+     */
+    createCDPSession(): Promise<CDPSession>;
+    _getTargetInfo(): TargetInfo;
+    /**
+     * If the target is not of type `"page"` or `"background_page"`, returns `null`.
+     */
+    page({ sourceMapGetter, logLevel, indent, pageIndex, onBrowserLog, onLog, }: {
+        sourceMapGetter: SourceMapGetter;
+        logLevel: LogLevel;
+        indent: boolean;
+        pageIndex: number;
+        onBrowserLog: null | ((log: BrowserLog) => void);
+        onLog: OnLog;
+    }): Promise<Page | null>;
+    expectPage(): Promise<Page | null>;
+    url(): string;
+    /**
+     * Identifies what kind of target this is.
+     *
+     * @remarks
+     *
+     * See {@link https://developer.chrome.com/extensions/background_pages | docs} for more info about background pages.
+     */
+    type(): 'page' | 'background_page' | 'service_worker' | 'shared_worker' | 'other' | 'browser' | 'webview';
+    /**
+     * Get the browser the target belongs to.
+     */
+    browser(): HeadlessBrowser;
+    /**
+     * Get the browser context the target belongs to.
+     */
+    browserContext(): BrowserContext;
+    /**
+     * Get the target that opened this target. Top-level targets return `null`.
+     */
+    opener(): Target | undefined;
+    _targetInfoChanged(targetInfo: TargetInfo): void;
+}

package/package/dist/browser/Target.js

@@ -0,0 +1,161 @@
+"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 _Target_browserContext, _Target_targetInfo, _Target_sessionFactory, _Target_defaultViewport, _Target_pagePromise;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Target = void 0;
+const BrowserPage_1 = require("./BrowserPage");
+const isPagetTarget = (target) => {
+    return (target.type === 'page' ||
+        target.type === 'background_page' ||
+        target.type === 'webview');
+};
+class Target {
+    constructor(targetInfo, browserContext, sessionFactory, defaultViewport) {
+        _Target_browserContext.set(this, void 0);
+        _Target_targetInfo.set(this, void 0);
+        _Target_sessionFactory.set(this, void 0);
+        _Target_defaultViewport.set(this, void 0);
+        _Target_pagePromise.set(this, void 0);
+        __classPrivateFieldSet(this, _Target_targetInfo, targetInfo, "f");
+        __classPrivateFieldSet(this, _Target_browserContext, browserContext, "f");
+        this._targetId = targetInfo.targetId;
+        __classPrivateFieldSet(this, _Target_sessionFactory, sessionFactory, "f");
+        __classPrivateFieldSet(this, _Target_defaultViewport, defaultViewport, "f");
+        this._initializedPromise = new Promise((fulfill) => {
+            this._initializedCallback = fulfill;
+        }).then((success) => {
+            if (!success) {
+                return false;
+            }
+            const opener = this.opener();
+            if (!opener || !__classPrivateFieldGet(opener, _Target_pagePromise, "f") || this.type() !== 'page') {
+                return true;
+            }
+            return true;
+        });
+        this._isClosedPromise = new Promise((fulfill) => {
+            this._closedCallback = fulfill;
+        });
+        this._isInitialized =
+            !isPagetTarget(__classPrivateFieldGet(this, _Target_targetInfo, "f")) || __classPrivateFieldGet(this, _Target_targetInfo, "f").url !== '';
+        if (this._isInitialized) {
+            this._initializedCallback(true);
+        }
+    }
+    /**
+     * Creates a Chrome Devtools Protocol session attached to the target.
+     */
+    createCDPSession() {
+        return __classPrivateFieldGet(this, _Target_sessionFactory, "f").call(this);
+    }
+    _getTargetInfo() {
+        return __classPrivateFieldGet(this, _Target_targetInfo, "f");
+    }
+    /**
+     * If the target is not of type `"page"` or `"background_page"`, returns `null`.
+     */
+    async page({ sourceMapGetter, logLevel, indent, pageIndex, onBrowserLog, onLog, }) {
+        var _a;
+        if (isPagetTarget(__classPrivateFieldGet(this, _Target_targetInfo, "f")) && !__classPrivateFieldGet(this, _Target_pagePromise, "f")) {
+            __classPrivateFieldSet(this, _Target_pagePromise, __classPrivateFieldGet(this, _Target_sessionFactory, "f").call(this).then((client) => {
+                var _a;
+                return BrowserPage_1.Page._create({
+                    client,
+                    target: this,
+                    defaultViewport: (_a = __classPrivateFieldGet(this, _Target_defaultViewport, "f")) !== null && _a !== void 0 ? _a : null,
+                    browser: this.browser(),
+                    sourceMapGetter,
+                    logLevel,
+                    indent,
+                    pageIndex,
+                    onBrowserLog,
+                    onLog,
+                });
+            }), "f");
+        }
+        return (_a = (await __classPrivateFieldGet(this, _Target_pagePromise, "f"))) !== null && _a !== void 0 ? _a : null;
+    }
+    async expectPage() {
+        var _a;
+        return (_a = (await __classPrivateFieldGet(this, _Target_pagePromise, "f"))) !== null && _a !== void 0 ? _a : null;
+    }
+    url() {
+        return __classPrivateFieldGet(this, _Target_targetInfo, "f").url;
+    }
+    /**
+     * Identifies what kind of target this is.
+     *
+     * @remarks
+     *
+     * See {@link https://developer.chrome.com/extensions/background_pages | docs} for more info about background pages.
+     */
+    type() {
+        const { type } = __classPrivateFieldGet(this, _Target_targetInfo, "f");
+        if (type === 'page' ||
+            type === 'background_page' ||
+            type === 'service_worker' ||
+            type === 'shared_worker' ||
+            type === 'browser' ||
+            type === 'webview') {
+            return type;
+        }
+        return 'other';
+    }
+    /**
+     * Get the browser the target belongs to.
+     */
+    browser() {
+        return __classPrivateFieldGet(this, _Target_browserContext, "f").browser();
+    }
+    /**
+     * Get the browser context the target belongs to.
+     */
+    browserContext() {
+        return __classPrivateFieldGet(this, _Target_browserContext, "f");
+    }
+    /**
+     * Get the target that opened this target. Top-level targets return `null`.
+     */
+    opener() {
+        const { openerId } = __classPrivateFieldGet(this, _Target_targetInfo, "f");
+        if (!openerId) {
+            return;
+        }
+        return this.browser()._targets.get(openerId);
+    }
+    _targetInfoChanged(targetInfo) {
+        __classPrivateFieldSet(this, _Target_targetInfo, targetInfo, "f");
+        if (!this._isInitialized &&
+            (!isPagetTarget(__classPrivateFieldGet(this, _Target_targetInfo, "f")) || __classPrivateFieldGet(this, _Target_targetInfo, "f").url !== '')) {
+            this._isInitialized = true;
+            this._initializedCallback(true);
+        }
+    }
+}
+exports.Target = Target;
+_Target_browserContext = new WeakMap(), _Target_targetInfo = new WeakMap(), _Target_sessionFactory = new WeakMap(), _Target_defaultViewport = new WeakMap(), _Target_pagePromise = new WeakMap();

package/package/dist/browser/TaskQueue.d.ts

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