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

package/dist/browser/NetworkManager.d.ts

@@ -0,0 +1,34 @@
+/**
+ * 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.
+ */
+import type { Commands } from './devtools-commands';
+import { EventEmitter } from './EventEmitter';
+import type { Frame } from './FrameManager';
+export declare const NetworkManagerEmittedEvents: {
+    readonly Request: symbol;
+};
+interface CDPSession extends EventEmitter {
+    send<T extends keyof Commands>(method: T, ...paramArgs: Commands[T]['paramsType']): Promise<Commands[T]['returnType']>;
+}
+interface FrameManager {
+    frame(frameId: string): Frame | null;
+}
+export declare class NetworkManager extends EventEmitter {
+    #private;
+    constructor(client: CDPSession, frameManager: FrameManager);
+    initialize(): Promise<void>;
+    numRequestsInProgress(): number;
+}
+export {};

package/dist/browser/NetworkManager.js

@@ -0,0 +1,231 @@
+"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_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 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) {
+        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());
+        __classPrivateFieldSet(this, _NetworkManager_client, client, "f");
+        __classPrivateFieldSet(this, _NetworkManager_frameManager, frameManager, "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');
+    }
+    numRequestsInProgress() {
+        return __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").numRequestsInProgress();
+    }
+}
+exports.NetworkManager = NetworkManager;
+_NetworkManager_client = new WeakMap(), _NetworkManager_frameManager = new WeakMap(), _NetworkManager_networkEventManager = 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")
+                .responseExtraInfo(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;
+    }
+    __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").responseExtraInfo(responseReceived.requestId);
+    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")
+            .responseExtraInfo(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").responseExtraInfo(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").responseExtraInfo(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;
+    }
+    __classPrivateFieldGet(this, _NetworkManager_instances, "m", _NetworkManager_forgetRequest).call(this, request, true);
+};

package/dist/browser/NodeWebSocketTransport.d.ts

@@ -0,0 +1,17 @@
+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 {
+    #private;
+    static create(urlString: string): Promise<NodeWebSocketTransport>;
+    onmessage?: (message: string) => void;
+    onclose?: () => void;
+    constructor(ws: WS);
+    send(message: string): void;
+    close(): void;
+}
+export {};

package/dist/browser/NodeWebSocketTransport.js

@@ -0,0 +1,87 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _NodeWebSocketTransport_ws;
+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 dns_1 = require("dns");
+const url_1 = require("url");
+const ws_types_1 = require("../ws/ws-types");
+class NodeWebSocketTransport {
+    constructor(ws) {
+        _NodeWebSocketTransport_ws.set(this, void 0);
+        __classPrivateFieldSet(this, _NodeWebSocketTransport_ws, ws, "f");
+        __classPrivateFieldGet(this, _NodeWebSocketTransport_ws, "f").addEventListener('message', (event) => {
+            if (this.onmessage) {
+                this.onmessage.call(null, event.data);
+            }
+        });
+        __classPrivateFieldGet(this, _NodeWebSocketTransport_ws, "f").addEventListener('close', () => {
+            if (this.onclose) {
+                this.onclose.call(null);
+            }
+        });
+        // Silently ignore all errors - we don't know what to do with them.
+        __classPrivateFieldGet(this, _NodeWebSocketTransport_ws, "f").addEventListener('error', () => undefined);
+    }
+    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 url_1.URL(urlString);
+        if (url.hostname === 'localhost') {
+            const { address } = await 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,
+                headers: {
+                    'User-Agent': `Remotion CLI`,
+                },
+            });
+            ws.addEventListener('open', () => {
+                return resolve(new NodeWebSocketTransport(ws));
+            });
+            ws.addEventListener('error', reject);
+        });
+    }
+    send(message) {
+        __classPrivateFieldGet(this, _NodeWebSocketTransport_ws, "f").send(message);
+    }
+    close() {
+        __classPrivateFieldGet(this, _NodeWebSocketTransport_ws, "f").close();
+    }
+}
+exports.NodeWebSocketTransport = NodeWebSocketTransport;
+_NodeWebSocketTransport_ws = new WeakMap();

package/dist/browser/Product.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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 type Product = 'chrome' | 'firefox';

package/dist/browser/Product.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/PuppeteerNode.d.ts

@@ -0,0 +1,40 @@
+/**
+ * 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 { Browser } from './Browser';
+import type { BrowserConnectOptions } from './BrowserConnector';
+import type { BrowserFetcherOptions } from './BrowserFetcher';
+import { BrowserFetcher } from './BrowserFetcher';
+import type { ProductLauncher } from './Launcher';
+import type { BrowserLaunchArgumentOptions, LaunchOptions } from './LaunchOptions';
+import type { Product } from './Product';
+interface PuppeteerLaunchOptions extends LaunchOptions, BrowserLaunchArgumentOptions, BrowserConnectOptions {
+    product?: Product;
+    extraPrefsFirefox?: Record<string, unknown>;
+}
+export declare class PuppeteerNode {
+    #private;
+    _preferredRevision: string;
+    constructor(settings: {
+        preferredRevision: string;
+        productName?: Product;
+    });
+    launch(options: PuppeteerLaunchOptions): Promise<Browser>;
+    executablePath(channel?: string): string;
+    get _launcher(): ProductLauncher;
+    get product(): string;
+    createBrowserFetcher(options: BrowserFetcherOptions): BrowserFetcher;
+}
+export {};

package/dist/browser/PuppeteerNode.js

@@ -0,0 +1,74 @@
+"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 __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 _PuppeteerNode_lazyLauncher, _PuppeteerNode_productName;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PuppeteerNode = void 0;
+const BrowserFetcher_1 = require("./BrowserFetcher");
+const Launcher_1 = require("./Launcher");
+const revisions_1 = require("./revisions");
+class PuppeteerNode {
+    constructor(settings) {
+        _PuppeteerNode_lazyLauncher.set(this, void 0);
+        _PuppeteerNode_productName.set(this, void 0);
+        const { preferredRevision, productName } = settings;
+        __classPrivateFieldSet(this, _PuppeteerNode_productName, productName, "f");
+        this._preferredRevision = preferredRevision;
+        this.launch = this.launch.bind(this);
+        this.executablePath = this.executablePath.bind(this);
+        this.createBrowserFetcher = this.createBrowserFetcher.bind(this);
+    }
+    launch(options) {
+        if (options.product) {
+            __classPrivateFieldSet(this, _PuppeteerNode_productName, options.product, "f");
+        }
+        return this._launcher.launch(options);
+    }
+    executablePath(channel) {
+        return this._launcher.executablePath(channel);
+    }
+    get _launcher() {
+        if (!__classPrivateFieldGet(this, _PuppeteerNode_lazyLauncher, "f") ||
+            __classPrivateFieldGet(this, _PuppeteerNode_lazyLauncher, "f").product !== __classPrivateFieldGet(this, _PuppeteerNode_productName, "f")) {
+            switch (__classPrivateFieldGet(this, _PuppeteerNode_productName, "f")) {
+                case 'chrome':
+                default:
+                    this._preferredRevision = revisions_1.PUPPETEER_REVISIONS.chromium;
+            }
+            __classPrivateFieldSet(this, _PuppeteerNode_lazyLauncher, new Launcher_1.ChromeLauncher(this._preferredRevision), "f");
+        }
+        return __classPrivateFieldGet(this, _PuppeteerNode_lazyLauncher, "f");
+    }
+    get product() {
+        return this._launcher.product;
+    }
+    createBrowserFetcher(options) {
+        return new BrowserFetcher_1.BrowserFetcher(options);
+    }
+}
+exports.PuppeteerNode = PuppeteerNode;
+_PuppeteerNode_lazyLauncher = new WeakMap(), _PuppeteerNode_productName = new WeakMap();

package/dist/browser/PuppeteerViewport.d.ts

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

package/dist/browser/Target.d.ts

@@ -0,0 +1,61 @@
+/**
+ * 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 type { Browser, BrowserContext } from './Browser';
+import { Page } from './BrowserPage';
+import type { CDPSession } from './Connection';
+import type { TargetInfo } from './devtools-types';
+import type { Viewport } from './PuppeteerViewport';
+export declare class Target {
+    #private;
+    _initializedPromise: Promise<boolean>;
+    _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(): 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(): Browser;
+    /**
+     * 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;
+}