@remotion/renderer 4.0.0-imgloading.2 → 4.0.0-lambda.1

package/dist/browser/WebWorker.d.ts

@@ -0,0 +1,96 @@
+/**
+ * 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.
+ */
+import { Protocol } from 'devtools-protocol';
+import { CDPSession } from './Connection';
+import { ConsoleMessageType } from './ConsoleMessage';
+import { EvaluateHandleFn, SerializableOrJSHandle } from './EvalTypes';
+import { EventEmitter } from './EventEmitter';
+import { ExecutionContext } from './ExecutionContext';
+import { JSHandle } from './JSHandle';
+/**
+ * @internal
+ */
+export declare type ConsoleAPICalledCallback = (eventType: ConsoleMessageType, handles: JSHandle[], trace: Protocol.Runtime.StackTrace) => void;
+/**
+ * @internal
+ */
+export declare type ExceptionThrownCallback = (details: Protocol.Runtime.ExceptionDetails) => void;
+/**
+ * The WebWorker class represents a
+ * {@link https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API | WebWorker}.
+ *
+ * @remarks
+ * The events `workercreated` and `workerdestroyed` are emitted on the page
+ * object to signal the worker lifecycle.
+ *
+ * @example
+ * ```js
+ * page.on('workercreated', worker => console.log('Worker created: ' + worker.url()));
+ * page.on('workerdestroyed', worker => console.log('Worker destroyed: ' + worker.url()));
+ *
+ * console.log('Current workers:');
+ * for (const worker of page.workers()) {
+ *   console.log('  ' + worker.url());
+ * }
+ * ```
+ *
+ * @public
+ */
+export declare class WebWorker extends EventEmitter {
+    #private;
+    /**
+     *
+     * @internal
+     */
+    constructor(client: CDPSession, url: string, consoleAPICalled: ConsoleAPICalledCallback, exceptionThrown: ExceptionThrownCallback);
+    /**
+     * @returns The URL of this web worker.
+     */
+    url(): string;
+    /**
+     * Returns the ExecutionContext the WebWorker runs in
+     * @returns The ExecutionContext the web worker runs in.
+     */
+    executionContext(): Promise<ExecutionContext>;
+    /**
+     * If the function passed to the `worker.evaluate` returns a Promise, then
+     * `worker.evaluate` would wait for the promise to resolve and return its
+     * value. If the function passed to the `worker.evaluate` returns a
+     * non-serializable value, then `worker.evaluate` resolves to `undefined`.
+     * DevTools Protocol also supports transferring some additional values that
+     * are not serializable by `JSON`: `-0`, `NaN`, `Infinity`, `-Infinity`, and
+     * bigint literals.
+     * Shortcut for `await worker.executionContext()).evaluate(pageFunction, ...args)`.
+     *
+     * @param pageFunction - Function to be evaluated in the worker context.
+     * @param args - Arguments to pass to `pageFunction`.
+     * @returns Promise which resolves to the return value of `pageFunction`.
+     */
+    evaluate<ReturnType>(pageFunction: Function | string, ...args: any[]): Promise<ReturnType>;
+    /**
+     * The only difference between `worker.evaluate` and `worker.evaluateHandle`
+     * is that `worker.evaluateHandle` returns in-page object (JSHandle). If the
+     * function passed to the `worker.evaluateHandle` returns a `Promise`, then
+     * `worker.evaluateHandle` would wait for the promise to resolve and return
+     * its value. Shortcut for
+     * `await worker.executionContext()).evaluateHandle(pageFunction, ...args)`
+     *
+     * @param pageFunction - Function to be evaluated in the page context.
+     * @param args - Arguments to pass to `pageFunction`.
+     * @returns Promise which resolves to the return value of `pageFunction`.
+     */
+    evaluateHandle<HandlerType extends JSHandle = JSHandle>(pageFunction: EvaluateHandleFn, ...args: SerializableOrJSHandle[]): Promise<JSHandle>;
+}

package/dist/browser/WebWorker.js

@@ -0,0 +1,122 @@
+"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 _WebWorker_client, _WebWorker_url, _WebWorker_executionContextPromise, _WebWorker_executionContextCallback;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebWorker = void 0;
+const EventEmitter_1 = require("./EventEmitter");
+const ExecutionContext_1 = require("./ExecutionContext");
+const JSHandle_1 = require("./JSHandle");
+const util_1 = require("./util");
+/**
+ * The WebWorker class represents a
+ * {@link https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API | WebWorker}.
+ *
+ * @remarks
+ * The events `workercreated` and `workerdestroyed` are emitted on the page
+ * object to signal the worker lifecycle.
+ *
+ * @example
+ * ```js
+ * page.on('workercreated', worker => console.log('Worker created: ' + worker.url()));
+ * page.on('workerdestroyed', worker => console.log('Worker destroyed: ' + worker.url()));
+ *
+ * console.log('Current workers:');
+ * for (const worker of page.workers()) {
+ *   console.log('  ' + worker.url());
+ * }
+ * ```
+ *
+ * @public
+ */
+class WebWorker extends EventEmitter_1.EventEmitter {
+    /**
+     *
+     * @internal
+     */
+    constructor(client, url, consoleAPICalled, exceptionThrown) {
+        super();
+        _WebWorker_client.set(this, void 0);
+        _WebWorker_url.set(this, void 0);
+        _WebWorker_executionContextPromise.set(this, void 0);
+        _WebWorker_executionContextCallback.set(this, void 0);
+        __classPrivateFieldSet(this, _WebWorker_client, client, "f");
+        __classPrivateFieldSet(this, _WebWorker_url, url, "f");
+        __classPrivateFieldSet(this, _WebWorker_executionContextPromise, new Promise((x) => {
+            __classPrivateFieldSet(this, _WebWorker_executionContextCallback, x, "f");
+        }), "f");
+        let jsHandleFactory;
+        __classPrivateFieldGet(this, _WebWorker_client, "f").once('Runtime.executionContextCreated', async (event) => {
+            // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+            jsHandleFactory = (remoteObject) => {
+                return new JSHandle_1.JSHandle(executionContext, client, remoteObject);
+            };
+            const executionContext = new ExecutionContext_1.ExecutionContext(client, event.context);
+            __classPrivateFieldGet(this, _WebWorker_executionContextCallback, "f").call(this, executionContext);
+        });
+        // This might fail if the target is closed before we receive all execution contexts.
+        __classPrivateFieldGet(this, _WebWorker_client, "f").send('Runtime.enable').catch(util_1.debugError);
+        __classPrivateFieldGet(this, _WebWorker_client, "f").on('Runtime.consoleAPICalled', (event) => {
+            return consoleAPICalled(event.type, event.args.map(jsHandleFactory), event.stackTrace);
+        });
+        __classPrivateFieldGet(this, _WebWorker_client, "f").on('Runtime.exceptionThrown', (exception) => {
+            return exceptionThrown(exception.exceptionDetails);
+        });
+    }
+    /**
+     * @returns The URL of this web worker.
+     */
+    url() {
+        return __classPrivateFieldGet(this, _WebWorker_url, "f");
+    }
+    /**
+     * Returns the ExecutionContext the WebWorker runs in
+     * @returns The ExecutionContext the web worker runs in.
+     */
+    async executionContext() {
+        return __classPrivateFieldGet(this, _WebWorker_executionContextPromise, "f");
+    }
+    /**
+     * If the function passed to the `worker.evaluate` returns a Promise, then
+     * `worker.evaluate` would wait for the promise to resolve and return its
+     * value. If the function passed to the `worker.evaluate` returns a
+     * non-serializable value, then `worker.evaluate` resolves to `undefined`.
+     * DevTools Protocol also supports transferring some additional values that
+     * are not serializable by `JSON`: `-0`, `NaN`, `Infinity`, `-Infinity`, and
+     * bigint literals.
+     * Shortcut for `await worker.executionContext()).evaluate(pageFunction, ...args)`.
+     *
+     * @param pageFunction - Function to be evaluated in the worker context.
+     * @param args - Arguments to pass to `pageFunction`.
+     * @returns Promise which resolves to the return value of `pageFunction`.
+     */
+    async evaluate(pageFunction, ...args) {
+        return (await __classPrivateFieldGet(this, _WebWorker_executionContextPromise, "f")).evaluate(pageFunction, ...args);
+    }
+    /**
+     * The only difference between `worker.evaluate` and `worker.evaluateHandle`
+     * is that `worker.evaluateHandle` returns in-page object (JSHandle). If the
+     * function passed to the `worker.evaluateHandle` returns a `Promise`, then
+     * `worker.evaluateHandle` would wait for the promise to resolve and return
+     * its value. Shortcut for
+     * `await worker.executionContext()).evaluateHandle(pageFunction, ...args)`
+     *
+     * @param pageFunction - Function to be evaluated in the page context.
+     * @param args - Arguments to pass to `pageFunction`.
+     * @returns Promise which resolves to the return value of `pageFunction`.
+     */
+    async evaluateHandle(pageFunction, ...args) {
+        return (await __classPrivateFieldGet(this, _WebWorker_executionContextPromise, "f")).evaluateHandle(pageFunction, ...args);
+    }
+}
+exports.WebWorker = WebWorker;
+_WebWorker_client = new WeakMap(), _WebWorker_url = new WeakMap(), _WebWorker_executionContextPromise = new WeakMap(), _WebWorker_executionContextCallback = new WeakMap();

package/dist/browser/assert.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Copyright 2020 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Asserts that the given value is truthy.
+ * @param value - some conditional statement
+ * @param message - the error message to throw if the value is not truthy.
+ */
+export declare const assert: (value: unknown, message?: string) => asserts value;

package/dist/browser/assert.js

@@ -0,0 +1,29 @@
+"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 });
+exports.assert = void 0;
+/**
+ * Asserts that the given value is truthy.
+ * @param value - some conditional statement
+ * @param message - the error message to throw if the value is not truthy.
+ */
+const assert = (value, message) => {
+    if (!value) {
+        throw new Error(message);
+    }
+};
+exports.assert = assert;

package/dist/browser/compat.d.ts

@@ -0,0 +1,2 @@
+declare let puppeteerDirname: string;
+export { puppeteerDirname };

package/dist/browser/compat.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.puppeteerDirname = void 0;
+const path_1 = require("path");
+let puppeteerDirname;
+exports.puppeteerDirname = puppeteerDirname;
+try {
+    // In some environments, like esbuild, this will throw an error.
+    // We suppress the error since the bundled binary is not expected
+    // to be used or installed in this case and, therefore, the
+    // root directory does not have to be known.
+    exports.puppeteerDirname = puppeteerDirname = (0, path_1.dirname)(require.resolve('./compat'));
+}
+catch (error) {
+    // Fallback to __dirname.
+    exports.puppeteerDirname = puppeteerDirname = __dirname;
+}

package/dist/browser/create-browser-fetcher.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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 { Product } from './Product';
+export declare function downloadBrowser(product: Product): Promise<void>;

package/dist/browser/create-browser-fetcher.js

@@ -0,0 +1,140 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadBrowser = void 0;
+const https_1 = __importDefault(require("https"));
+const progress_1 = __importDefault(require("progress"));
+const node_1 = require("./node");
+const revisions_1 = require("./revisions");
+const supportedProducts = {
+    chrome: 'Chromium',
+    firefox: 'Firefox Nightly',
+};
+async function downloadBrowser(product) {
+    const browserFetcher = node_1.puppeteer.createBrowserFetcher({
+        product,
+        path: null,
+        platform: null,
+    });
+    const revision = await getRevision();
+    await fetchBinary(revision);
+    async function getRevision() {
+        if (product === 'chrome') {
+            return Promise.resolve(revisions_1.PUPPETEER_REVISIONS.chromium);
+        }
+        if (product === 'firefox') {
+            node_1.puppeteer._preferredRevision = revisions_1.PUPPETEER_REVISIONS.firefox;
+            try {
+                return await getFirefoxNightlyVersion();
+            }
+            catch (error) {
+                console.error(error);
+                process.exit(1);
+            }
+        }
+        throw new Error(`Unsupported product ${product}`);
+    }
+    function fetchBinary(_revision) {
+        const revisionInfo = browserFetcher.revisionInfo(_revision);
+        // Do nothing if the revision is already downloaded.
+        if (revisionInfo.local) {
+            logPolitely(`${supportedProducts[product]} is already in ${revisionInfo.folderPath}; skipping download.`);
+            return;
+        }
+        function onSuccess(localRevisions) {
+            logPolitely(`${supportedProducts[product]} (${revisionInfo.revision}) downloaded to ${revisionInfo.folderPath}`);
+            localRevisions = localRevisions.filter((__revision) => {
+                return __revision !== revisionInfo.revision;
+            });
+            const cleanupOldVersions = localRevisions.map((__revision) => {
+                return browserFetcher.remove(__revision);
+            });
+            Promise.all([...cleanupOldVersions]);
+        }
+        function onError(error) {
+            console.error(`ERROR: Failed to set up ${supportedProducts[product]} r${_revision}! Set "PUPPETEER_SKIP_DOWNLOAD" env variable to skip download.`);
+            console.error(error);
+            process.exit(1);
+        }
+        let progressBar = null;
+        let lastDownloadedBytes = 0;
+        function onProgress(downloadedBytes, totalBytes) {
+            if (!progressBar) {
+                progressBar = new progress_1.default(`Downloading ${supportedProducts[product]} r${_revision} - ${toMegabytes(totalBytes)} [:bar] :percent :etas `, {
+                    complete: '=',
+                    incomplete: ' ',
+                    width: 20,
+                    total: totalBytes,
+                });
+            }
+            const delta = downloadedBytes - lastDownloadedBytes;
+            lastDownloadedBytes = downloadedBytes;
+            progressBar.tick(delta);
+        }
+        return browserFetcher
+            .download(revisionInfo.revision, onProgress)
+            .then(() => {
+            return browserFetcher.localRevisions();
+        })
+            .then(onSuccess)
+            .catch(onError);
+    }
+    function toMegabytes(bytes) {
+        const mb = bytes / 1024 / 1024;
+        return `${Math.round(mb * 10) / 10} Mb`;
+    }
+    function getFirefoxNightlyVersion() {
+        const firefoxVersionsUrl = 'https://product-details.mozilla.org/1.0/firefox_versions.json';
+        const requestOptions = {};
+        const promise = new Promise((resolve, reject) => {
+            let data = '';
+            logPolitely(`Requesting latest Firefox Nightly version from ${firefoxVersionsUrl}`);
+            https_1.default
+                .get(firefoxVersionsUrl, requestOptions, (r) => {
+                if (r.statusCode && r.statusCode >= 400) {
+                    return reject(new Error(`Got status code ${r.statusCode}`));
+                }
+                r.on('data', (chunk) => {
+                    data += chunk;
+                });
+                r.on('end', () => {
+                    try {
+                        const versions = JSON.parse(data);
+                        return resolve(versions.FIREFOX_NIGHTLY);
+                    }
+                    catch (_a) {
+                        return reject(new Error('Firefox version not found'));
+                    }
+                });
+            })
+                .on('error', reject);
+        });
+        return promise;
+    }
+}
+exports.downloadBrowser = downloadBrowser;
+function logPolitely(toBeLogged) {
+    const logLevel = process.env.npm_config_loglevel || '';
+    const logLevelDisplay = ['silent', 'error', 'warn'].indexOf(logLevel) > -1;
+    // eslint-disable-next-line no-console
+    if (!logLevelDisplay) {
+        console.log(toBeLogged);
+    }
+}

package/dist/browser/dialog.d.ts

@@ -0,0 +1,70 @@
+/**
+ * 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 { Protocol } from 'devtools-protocol';
+import { CDPSession } from './Connection';
+/**
+ * Dialog instances are dispatched by the {@link Page} via the `dialog` event.
+ *
+ * @remarks
+ *
+ * @example
+ * ```js
+ * const puppeteer = require('puppeteer');
+ *
+ * (async () => {
+ *   const browser = await puppeteer.launch();
+ *   const page = await browser.newPage();
+ *   page.on('dialog', async dialog => {
+ *     console.log(dialog.message());
+ *     await dialog.dismiss();
+ *     await browser.close();
+ *   });
+ *   page.evaluate(() => alert('1'));
+ * })();
+ * ```
+ * @public
+ */
+export declare class Dialog {
+    #private;
+    /**
+     * @internal
+     */
+    constructor(client: CDPSession, type: Protocol.Page.DialogType, message: string, defaultValue?: string);
+    /**
+     * @returns The type of the dialog.
+     */
+    type(): Protocol.Page.DialogType;
+    /**
+     * @returns The message displayed in the dialog.
+     */
+    message(): string;
+    /**
+     * @returns The default value of the prompt, or an empty string if the dialog
+     * is not a `prompt`.
+     */
+    defaultValue(): string;
+    /**
+     * @param promptText - optional text that will be entered in the dialog
+     * prompt. Has no effect if the dialog's type is not `prompt`.
+     *
+     * @returns A promise that resolves when the dialog has been accepted.
+     */
+    accept(promptText?: string): Promise<void>;
+    /**
+     * @returns A promise which will resolve once the dialog has been dismissed
+     */
+    dismiss(): Promise<void>;
+}

package/dist/browser/dialog.js

@@ -0,0 +1,114 @@
+"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 _Dialog_client, _Dialog_type, _Dialog_message, _Dialog_defaultValue, _Dialog_handled;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dialog = void 0;
+const assert_1 = require("./assert");
+/**
+ * Dialog instances are dispatched by the {@link Page} via the `dialog` event.
+ *
+ * @remarks
+ *
+ * @example
+ * ```js
+ * const puppeteer = require('puppeteer');
+ *
+ * (async () => {
+ *   const browser = await puppeteer.launch();
+ *   const page = await browser.newPage();
+ *   page.on('dialog', async dialog => {
+ *     console.log(dialog.message());
+ *     await dialog.dismiss();
+ *     await browser.close();
+ *   });
+ *   page.evaluate(() => alert('1'));
+ * })();
+ * ```
+ * @public
+ */
+class Dialog {
+    /**
+     * @internal
+     */
+    constructor(client, type, message, defaultValue = '') {
+        _Dialog_client.set(this, void 0);
+        _Dialog_type.set(this, void 0);
+        _Dialog_message.set(this, void 0);
+        _Dialog_defaultValue.set(this, void 0);
+        _Dialog_handled.set(this, false);
+        __classPrivateFieldSet(this, _Dialog_client, client, "f");
+        __classPrivateFieldSet(this, _Dialog_type, type, "f");
+        __classPrivateFieldSet(this, _Dialog_message, message, "f");
+        __classPrivateFieldSet(this, _Dialog_defaultValue, defaultValue, "f");
+    }
+    /**
+     * @returns The type of the dialog.
+     */
+    type() {
+        return __classPrivateFieldGet(this, _Dialog_type, "f");
+    }
+    /**
+     * @returns The message displayed in the dialog.
+     */
+    message() {
+        return __classPrivateFieldGet(this, _Dialog_message, "f");
+    }
+    /**
+     * @returns The default value of the prompt, or an empty string if the dialog
+     * is not a `prompt`.
+     */
+    defaultValue() {
+        return __classPrivateFieldGet(this, _Dialog_defaultValue, "f");
+    }
+    /**
+     * @param promptText - optional text that will be entered in the dialog
+     * prompt. Has no effect if the dialog's type is not `prompt`.
+     *
+     * @returns A promise that resolves when the dialog has been accepted.
+     */
+    async accept(promptText) {
+        (0, assert_1.assert)(!__classPrivateFieldGet(this, _Dialog_handled, "f"), 'Cannot accept dialog which is already handled!');
+        __classPrivateFieldSet(this, _Dialog_handled, true, "f");
+        await __classPrivateFieldGet(this, _Dialog_client, "f").send('Page.handleJavaScriptDialog', {
+            accept: true,
+            promptText,
+        });
+    }
+    /**
+     * @returns A promise which will resolve once the dialog has been dismissed
+     */
+    async dismiss() {
+        (0, assert_1.assert)(!__classPrivateFieldGet(this, _Dialog_handled, "f"), 'Cannot dismiss dialog which is already handled!');
+        __classPrivateFieldSet(this, _Dialog_handled, true, "f");
+        await __classPrivateFieldGet(this, _Dialog_client, "f").send('Page.handleJavaScriptDialog', {
+            accept: false,
+        });
+    }
+}
+exports.Dialog = Dialog;
+_Dialog_client = new WeakMap(), _Dialog_type = new WeakMap(), _Dialog_message = new WeakMap(), _Dialog_defaultValue = new WeakMap(), _Dialog_handled = new WeakMap();

package/dist/browser/environment.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 const isNode: boolean;

package/dist/browser/environment.js

@@ -0,0 +1,19 @@
+"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 });
+exports.isNode = void 0;
+exports.isNode = Boolean(typeof process !== 'undefined' && process.version);