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

package/dist/browser/fetch.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 getFetch: () => Promise<typeof fetch>;

package/dist/browser/fetch.js

@@ -0,0 +1,46 @@
+"use strict";
+/**
+ * Copyright 2020 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFetch = void 0;
+/* Use the global version if we're in the browser, else load the node-fetch module. */
+const getFetch = async () => {
+    return globalThis.fetch || (await Promise.resolve().then(() => __importStar(require('cross-fetch')))).fetch;
+};
+exports.getFetch = getFetch;

package/dist/browser/find-up.d.ts

@@ -0,0 +1,4 @@
+export declare const findUpStop: unique symbol;
+export declare function findUpMultiple(name: string): Promise<string[]>;
+export declare function findUpMultipleSync(name: string, options?: {}): string[];
+export declare function findUpSync(name: string, options?: {}): string;

package/dist/browser/find-up.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findUpSync = exports.findUpMultipleSync = exports.findUpMultiple = exports.findUpStop = void 0;
+const locate_path_1 = require("locate-path");
+const node_path_1 = __importDefault(require("node:path"));
+const node_url_1 = require("node:url");
+const toPath = (urlOrPath) => urlOrPath instanceof node_url_1.URL ? (0, node_url_1.fileURLToPath)(urlOrPath) : urlOrPath;
+exports.findUpStop = Symbol('findUpStop');
+async function findUpMultiple(name) {
+    let directory = node_path_1.default.resolve('');
+    const { root } = node_path_1.default.parse(directory);
+    const stopAt = node_path_1.default.resolve(directory, root);
+    const limit = Number.POSITIVE_INFINITY;
+    const paths = [name].flat();
+    const runMatcher = async (locateOptions) => {
+        if (typeof name !== 'function') {
+            return (0, locate_path_1.locatePath)(paths, locateOptions);
+        }
+        const foundPath = await name(locateOptions.cwd);
+        if (typeof foundPath === 'string') {
+            return (0, locate_path_1.locatePath)([foundPath], locateOptions);
+        }
+        return foundPath;
+    };
+    const matches = [];
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        // eslint-disable-next-line no-await-in-loop
+        const foundPath = await runMatcher({ ...options, cwd: directory });
+        if (foundPath === exports.findUpStop) {
+            break;
+        }
+        if (foundPath) {
+            matches.push(node_path_1.default.resolve(directory, foundPath));
+        }
+        if (directory === stopAt || matches.length >= limit) {
+            break;
+        }
+        directory = node_path_1.default.dirname(directory);
+    }
+    return matches;
+}
+exports.findUpMultiple = findUpMultiple;
+function findUpMultipleSync(name, options = {}) {
+    let directory = node_path_1.default.resolve('');
+    const { root } = node_path_1.default.parse(directory);
+    const stopAt = root;
+    const limit = Number.POSITIVE_INFINITY;
+    const paths = [name].flat();
+    const runMatcher = () => {
+        if (typeof name !== 'function') {
+            return (0, locate_path_1.locatePathSync)(paths);
+        }
+        const foundPath = name(locateOptions.cwd);
+        if (typeof foundPath === 'string') {
+            return (0, locate_path_1.locatePathSync)([foundPath], locateOptions);
+        }
+        return foundPath;
+    };
+    const matches = [];
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const foundPath = runMatcher({ ...options, cwd: directory });
+        if (foundPath === exports.findUpStop) {
+            break;
+        }
+        if (foundPath) {
+            matches.push(node_path_1.default.resolve(directory, foundPath));
+        }
+        if (directory === stopAt || matches.length >= limit) {
+            break;
+        }
+        directory = node_path_1.default.dirname(directory);
+    }
+    return matches;
+}
+exports.findUpMultipleSync = findUpMultipleSync;
+function findUpSync(name, options = {}) {
+    const matches = findUpMultipleSync(name, { ...options, limit: 1 });
+    return matches[0];
+}
+exports.findUpSync = findUpSync;

package/dist/browser/get-download-destination.d.ts

@@ -0,0 +1 @@
+export declare const getDownloadsCacheDir: () => string;

package/dist/browser/get-download-destination.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDownloadsCacheDir = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const getDownloadsCacheDir = () => {
+    const cwd = process.cwd();
+    let dir = cwd;
+    for (;;) {
+        try {
+            if (fs_1.default.statSync(path_1.default.join(dir, 'package.json')).isFile()) {
+                break;
+            }
+            // eslint-disable-next-line no-empty
+        }
+        catch (e) { }
+        const parent = path_1.default.dirname(dir);
+        if (dir === parent) {
+            dir = undefined;
+            break;
+        }
+        dir = parent;
+    }
+    if (!dir) {
+        return path_1.default.resolve(cwd, '.remotion');
+    }
+    if (process.versions.pnp === '1') {
+        return path_1.default.resolve(dir, '.pnp/.remotion');
+    }
+    if (process.versions.pnp === '3') {
+        return path_1.default.resolve(dir, '.yarn/.remotion');
+    }
+    return path_1.default.resolve(dir, 'node_modules/.remotion');
+};
+exports.getDownloadsCacheDir = getDownloadsCacheDir;

package/dist/browser/mitt/index.d.ts

@@ -0,0 +1,22 @@
+export declare type EventType = string | symbol;
+export declare type Handler<T = any> = (event?: T) => void;
+declare type WildcardHandler = (type: EventType, event?: any) => void;
+declare type EventHandlerList = Array<Handler>;
+declare type WildCardEventHandlerList = Array<WildcardHandler>;
+declare type EventHandlerMap = Map<EventType, EventHandlerList | WildCardEventHandlerList>;
+export interface Emitter {
+    all: EventHandlerMap;
+    on<T = any>(type: EventType, handler: Handler<T>): void;
+    on(type: '*', handler: WildcardHandler): void;
+    off<T = any>(type: EventType, handler: Handler<T>): void;
+    off(type: '*', handler: WildcardHandler): void;
+    emit<T = any>(type: EventType, event?: T): void;
+    emit(type: '*', event?: any): void;
+}
+/**
+ * Mitt: Tiny (~200b) functional event emitter / pubsub.
+ * @name mitt
+ * @returns {Mitt}
+ */
+export default function mitt(all?: EventHandlerMap): Emitter;
+export {};

package/dist/browser/mitt/index.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Mitt: Tiny (~200b) functional event emitter / pubsub.
+ * @name mitt
+ * @returns {Mitt}
+ */
+function mitt(all) {
+    all = all || new Map();
+    return {
+        /**
+         * A Map of event names to registered handler functions.
+         */
+        all,
+        /**
+         * Register an event handler for the given type.
+         * @param {string|symbol} type Type of event to listen for, or `"*"` for all events
+         * @param {Function} handler Function to call in response to given event
+         * @memberOf mitt
+         */
+        on(type, handler) {
+            const handlers = all === null || all === void 0 ? void 0 : all.get(type);
+            const added = handlers === null || handlers === void 0 ? void 0 : handlers.push(handler);
+            if (!added) {
+                all === null || all === void 0 ? void 0 : all.set(type, [handler]);
+            }
+        },
+        off(type, handler) {
+            const handlers = all === null || all === void 0 ? void 0 : all.get(type);
+            if (handlers) {
+                // eslint-disable-next-line no-bitwise
+                handlers.splice(handlers.indexOf(handler) >>> 0, 1);
+            }
+        },
+        emit(type, evt) {
+            ((all === null || all === void 0 ? void 0 : all.get(type)) || [])
+                .slice()
+                .forEach((handler) => {
+                handler(evt);
+            });
+            ((all === null || all === void 0 ? void 0 : all.get('*')) || [])
+                .slice()
+                .forEach((handler) => {
+                handler(type, evt);
+            });
+        },
+    };
+}
+exports.default = mitt;

package/dist/browser/node.d.ts

@@ -0,0 +1,2 @@
+import { PuppeteerNode } from './PuppeteerNode';
+export declare const puppeteer: PuppeteerNode;

package/dist/browser/node.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.puppeteer = void 0;
+const PuppeteerNode_1 = require("./PuppeteerNode");
+const revisions_1 = require("./revisions");
+exports.puppeteer = new PuppeteerNode_1.PuppeteerNode({
+    preferredRevision: revisions_1.PUPPETEER_REVISIONS.chromium,
+    productName: undefined,
+});

package/dist/browser/page.d.ts

@@ -0,0 +1,78 @@
+/**
+ * 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 { CDPSession } from './Connection';
+import { ConsoleMessage } from './ConsoleMessage';
+import { EvaluateFn, EvaluateFnReturnType, EvaluateHandleFn, SerializableOrJSHandle, UnwrapPromiseLike } from './EvalTypes';
+import { EventEmitter } from './EventEmitter';
+import { Frame } from './FrameManager';
+import { HTTPResponse } from './HTTPResponse';
+import { JSHandle } from './JSHandle';
+import { PuppeteerLifeCycleEvent } from './LifecycleWatcher';
+import { Viewport } from './PuppeteerViewport';
+import { Target } from './Target';
+import { TaskQueue } from './TaskQueue';
+interface WaitForOptions {
+    timeout?: number;
+    waitUntil?: PuppeteerLifeCycleEvent | PuppeteerLifeCycleEvent[];
+}
+export declare const enum PageEmittedEvents {
+    Console = "console",
+    Error = "error"
+}
+interface PageEventObject {
+    console: ConsoleMessage;
+    error: Error;
+}
+export declare class Page extends EventEmitter {
+    #private;
+    static _create(client: CDPSession, target: Target, defaultViewport: Viewport): Promise<Page>;
+    screenshotTaskQueue: TaskQueue;
+    constructor(client: CDPSession, target: Target);
+    /**
+     * Listen to page events.
+     */
+    on<K extends keyof PageEventObject>(eventName: K, handler: (event: PageEventObject[K]) => void): EventEmitter;
+    once<K extends keyof PageEventObject>(eventName: K, handler: (event: PageEventObject[K]) => void): EventEmitter;
+    off<K extends keyof PageEventObject>(eventName: K, handler: (event: PageEventObject[K]) => void): EventEmitter;
+    /**
+     * @returns A target this page was created from.
+     */
+    target(): Target;
+    _client(): CDPSession;
+    /**
+     * @returns The page's main frame.
+     * @remarks
+     * Page is guaranteed to have a main frame which persists during navigations.
+     */
+    mainFrame(): Frame;
+    setViewport(viewport: Viewport): Promise<void>;
+    setDefaultNavigationTimeout(timeout: number): void;
+    setDefaultTimeout(timeout: number): void;
+    evaluateHandle<HandlerType extends JSHandle = JSHandle>(pageFunction: EvaluateHandleFn, ...args: SerializableOrJSHandle[]): Promise<HandlerType>;
+    url(): string;
+    goto(url: string, options?: WaitForOptions & {
+        referer?: string;
+    }): Promise<HTTPResponse | null>;
+    bringToFront(): Promise<void>;
+    evaluate<T extends EvaluateFn>(pageFunction: T, ...args: SerializableOrJSHandle[]): Promise<UnwrapPromiseLike<EvaluateFnReturnType<T>>>;
+    evaluateOnNewDocument(pageFunction: Function | string, ...args: unknown[]): Promise<void>;
+    close(options?: {
+        runBeforeUnload?: boolean;
+    }): Promise<void>;
+    isClosed(): boolean;
+    waitForFunction(pageFunction: Function | string, ...args: SerializableOrJSHandle[]): Promise<JSHandle>;
+}
+export {};

package/dist/browser/page.js

@@ -0,0 +1,277 @@
+"use strict";
+/**
+ * Copyright 2017 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Page_instances, _Page_closed, _Page_client, _Page_target, _Page_timeoutSettings, _Page_frameManager, _Page_emulationManager, _Page_pageBindings, _Page_initialize, _Page_onTargetCrashed, _Page_onLogEntryAdded, _Page_onConsoleAPI, _Page_onBindingCalled, _Page_addConsoleMessage;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Page = void 0;
+const console_1 = require("console");
+const assert_1 = require("./assert");
+const ConsoleMessage_1 = require("./ConsoleMessage");
+const EmulationManager_1 = require("./EmulationManager");
+const EventEmitter_1 = require("./EventEmitter");
+const FrameManager_1 = require("./FrameManager");
+const JSHandle_1 = require("./JSHandle");
+const TaskQueue_1 = require("./TaskQueue");
+const TimeoutSettings_1 = require("./TimeoutSettings");
+const util_1 = require("./util");
+class Page extends EventEmitter_1.EventEmitter {
+    constructor(client, target) {
+        super();
+        _Page_instances.add(this);
+        _Page_closed.set(this, false);
+        _Page_client.set(this, void 0);
+        _Page_target.set(this, void 0);
+        _Page_timeoutSettings.set(this, new TimeoutSettings_1.TimeoutSettings());
+        _Page_frameManager.set(this, void 0);
+        _Page_emulationManager.set(this, void 0);
+        _Page_pageBindings.set(this, new Map());
+        __classPrivateFieldSet(this, _Page_client, client, "f");
+        __classPrivateFieldSet(this, _Page_target, target, "f");
+        __classPrivateFieldSet(this, _Page_frameManager, new FrameManager_1.FrameManager(client, this, __classPrivateFieldGet(this, _Page_timeoutSettings, "f")), "f");
+        __classPrivateFieldSet(this, _Page_emulationManager, new EmulationManager_1.EmulationManager(client), "f");
+        this.screenshotTaskQueue = new TaskQueue_1.TaskQueue();
+        client.on('Target.attachedToTarget', (event) => {
+            switch (event.targetInfo.type) {
+                case 'iframe':
+                    break;
+                case 'worker':
+                    break;
+                default:
+                    // If we don't detach from service workers, they will never die.
+                    // We still want to attach to workers for emitting events.
+                    // We still want to attach to iframes so sessions may interact with them.
+                    // We detach from all other types out of an abundance of caution.
+                    // See https://source.chromium.org/chromium/chromium/src/+/main:content/browser/devtools/devtools_agent_host_impl.cc?ss=chromium&q=f:devtools%20-f:out%20%22::kTypePage%5B%5D%22
+                    // for the complete list of available types.
+                    client
+                        .send('Target.detachFromTarget', {
+                        sessionId: event.sessionId,
+                    })
+                        .catch(() => console.log(console_1.error));
+            }
+        });
+        client.on('Runtime.consoleAPICalled', (event) => {
+            return __classPrivateFieldGet(this, _Page_instances, "m", _Page_onConsoleAPI).call(this, event);
+        });
+        client.on('Runtime.bindingCalled', (event) => {
+            return __classPrivateFieldGet(this, _Page_instances, "m", _Page_onBindingCalled).call(this, event);
+        });
+        client.on('Inspector.targetCrashed', () => {
+            return __classPrivateFieldGet(this, _Page_instances, "m", _Page_onTargetCrashed).call(this);
+        });
+        client.on('Log.entryAdded', (event) => {
+            return __classPrivateFieldGet(this, _Page_instances, "m", _Page_onLogEntryAdded).call(this, event);
+        });
+    }
+    static async _create(client, target, defaultViewport) {
+        const page = new Page(client, target);
+        await __classPrivateFieldGet(page, _Page_instances, "m", _Page_initialize).call(page);
+        await page.setViewport(defaultViewport);
+        return page;
+    }
+    /**
+     * Listen to page events.
+     */
+    // Note: this method exists to define event typings and handle
+    // proper wireup of cooperative request interception. Actual event listening and
+    // dispatching is delegated to EventEmitter.
+    on(eventName, handler) {
+        return super.on(eventName, handler);
+    }
+    once(eventName, handler) {
+        // Note: this method only exists to define the types; we delegate the impl
+        // to EventEmitter.
+        return super.once(eventName, handler);
+    }
+    off(eventName, handler) {
+        return super.off(eventName, handler);
+    }
+    /**
+     * @returns A target this page was created from.
+     */
+    target() {
+        return __classPrivateFieldGet(this, _Page_target, "f");
+    }
+    _client() {
+        return __classPrivateFieldGet(this, _Page_client, "f");
+    }
+    /**
+     * @returns The page's main frame.
+     * @remarks
+     * Page is guaranteed to have a main frame which persists during navigations.
+     */
+    mainFrame() {
+        return __classPrivateFieldGet(this, _Page_frameManager, "f").mainFrame();
+    }
+    async setViewport(viewport) {
+        await __classPrivateFieldGet(this, _Page_emulationManager, "f").emulateViewport(viewport);
+    }
+    setDefaultNavigationTimeout(timeout) {
+        __classPrivateFieldGet(this, _Page_timeoutSettings, "f").setDefaultNavigationTimeout(timeout);
+    }
+    setDefaultTimeout(timeout) {
+        __classPrivateFieldGet(this, _Page_timeoutSettings, "f").setDefaultTimeout(timeout);
+    }
+    async evaluateHandle(pageFunction, ...args) {
+        const context = await this.mainFrame().executionContext();
+        return context.evaluateHandle(pageFunction, ...args);
+    }
+    url() {
+        return this.mainFrame().url();
+    }
+    goto(url, options = {}) {
+        return __classPrivateFieldGet(this, _Page_frameManager, "f").mainFrame().goto(url, options);
+    }
+    async bringToFront() {
+        await __classPrivateFieldGet(this, _Page_client, "f").send('Page.bringToFront');
+    }
+    evaluate(pageFunction, ...args) {
+        return __classPrivateFieldGet(this, _Page_frameManager, "f").mainFrame().evaluate(pageFunction, ...args);
+    }
+    async evaluateOnNewDocument(pageFunction, ...args) {
+        const source = (0, util_1.evaluationString)(pageFunction, ...args);
+        await __classPrivateFieldGet(this, _Page_client, "f").send('Page.addScriptToEvaluateOnNewDocument', {
+            source,
+        });
+    }
+    async close(options = { runBeforeUnload: undefined }) {
+        const connection = __classPrivateFieldGet(this, _Page_client, "f").connection();
+        (0, assert_1.assert)(connection, 'Protocol error: Connection closed. Most likely the page has been closed.');
+        const runBeforeUnload = Boolean(options.runBeforeUnload);
+        if (runBeforeUnload) {
+            await __classPrivateFieldGet(this, _Page_client, "f").send('Page.close');
+        }
+        else {
+            await connection.send('Target.closeTarget', {
+                targetId: __classPrivateFieldGet(this, _Page_target, "f")._targetId,
+            });
+            await __classPrivateFieldGet(this, _Page_target, "f")._isClosedPromise;
+        }
+    }
+    isClosed() {
+        return __classPrivateFieldGet(this, _Page_closed, "f");
+    }
+    waitForFunction(pageFunction, ...args) {
+        return this.mainFrame().waitForFunction(pageFunction, ...args);
+    }
+}
+exports.Page = Page;
+_Page_closed = new WeakMap(), _Page_client = new WeakMap(), _Page_target = new WeakMap(), _Page_timeoutSettings = new WeakMap(), _Page_frameManager = new WeakMap(), _Page_emulationManager = new WeakMap(), _Page_pageBindings = new WeakMap(), _Page_instances = new WeakSet(), _Page_initialize = async function _Page_initialize() {
+    await Promise.all([
+        __classPrivateFieldGet(this, _Page_frameManager, "f").initialize(),
+        __classPrivateFieldGet(this, _Page_client, "f").send('Target.setAutoAttach', {
+            autoAttach: true,
+            waitForDebuggerOnStart: false,
+            flatten: true,
+        }),
+        __classPrivateFieldGet(this, _Page_client, "f").send('Performance.enable'),
+        __classPrivateFieldGet(this, _Page_client, "f").send('Log.enable'),
+    ]);
+}, _Page_onTargetCrashed = function _Page_onTargetCrashed() {
+    this.emit('error', new Error('Page crashed!'));
+}, _Page_onLogEntryAdded = function _Page_onLogEntryAdded(event) {
+    const { level, text, args, source, url, lineNumber } = event.entry;
+    if (args) {
+        args.map((arg) => {
+            return (0, util_1.releaseObject)(__classPrivateFieldGet(this, _Page_client, "f"), arg);
+        });
+    }
+    if (source !== 'worker') {
+        this.emit("console" /* PageEmittedEvents.Console */, new ConsoleMessage_1.ConsoleMessage(level, text, [], [{ url, lineNumber }]));
+    }
+}, _Page_onConsoleAPI = function _Page_onConsoleAPI(event) {
+    if (event.executionContextId === 0) {
+        return;
+    }
+    const context = __classPrivateFieldGet(this, _Page_frameManager, "f").executionContextById(event.executionContextId, __classPrivateFieldGet(this, _Page_client, "f"));
+    const values = event.args.map((arg) => {
+        return (0, JSHandle_1._createJSHandle)(context, arg);
+    });
+    __classPrivateFieldGet(this, _Page_instances, "m", _Page_addConsoleMessage).call(this, event.type, values, event.stackTrace);
+}, _Page_onBindingCalled = async function _Page_onBindingCalled(event) {
+    let payload;
+    try {
+        payload = JSON.parse(event.payload);
+    }
+    catch (_a) {
+        // The binding was either called by something in the page or it was
+        // called before our wrapper was initialized.
+        return;
+    }
+    const { type, name, seq, args } = payload;
+    if (type !== 'exposedFun' || !__classPrivateFieldGet(this, _Page_pageBindings, "f").has(name)) {
+        return;
+    }
+    let expression = null;
+    try {
+        const pageBinding = __classPrivateFieldGet(this, _Page_pageBindings, "f").get(name);
+        (0, assert_1.assert)(pageBinding);
+        const result = await pageBinding(...args);
+        expression = (0, util_1.pageBindingDeliverResultString)(name, seq, result);
+    }
+    catch (_error) {
+        if ((0, util_1.isErrorLike)(_error)) {
+            expression = (0, util_1.pageBindingDeliverErrorString)(name, seq, _error.message, _error.stack);
+        }
+        else {
+            expression = (0, util_1.pageBindingDeliverErrorValueString)(name, seq, _error);
+        }
+    }
+    __classPrivateFieldGet(this, _Page_client, "f").send('Runtime.evaluate', {
+        expression,
+        contextId: event.executionContextId,
+    });
+}, _Page_addConsoleMessage = function _Page_addConsoleMessage(eventType, args, stackTrace) {
+    if (!this.listenerCount("console" /* PageEmittedEvents.Console */)) {
+        args.forEach((arg) => {
+            return arg.dispose();
+        });
+        return;
+    }
+    const textTokens = [];
+    for (const arg of args) {
+        const remoteObject = arg._remoteObject;
+        if (remoteObject.objectId) {
+            textTokens.push(arg.toString());
+        }
+        else {
+            textTokens.push((0, util_1.valueFromRemoteObject)(remoteObject));
+        }
+    }
+    const stackTraceLocations = [];
+    if (stackTrace) {
+        for (const callFrame of stackTrace.callFrames) {
+            stackTraceLocations.push({
+                url: callFrame.url,
+                lineNumber: callFrame.lineNumber,
+                columnNumber: callFrame.columnNumber,
+            });
+        }
+    }
+    const message = new ConsoleMessage_1.ConsoleMessage(eventType, textTokens.join(' '), args, stackTraceLocations);
+    this.emit("console" /* PageEmittedEvents.Console */, message);
+};

package/dist/browser/pkg-dir.d.ts

@@ -0,0 +1,3 @@
+export declare function packageDirectorySync({ cwd }?: {
+    cwd: any;
+}): any;

package/dist/browser/pkg-dir.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packageDirectorySync = void 0;
+const find_up_1 = require("find-up");
+const path_1 = __importDefault(require("path"));
+function packageDirectorySync({ cwd } = {}) {
+    const filePath = (0, find_up_1.findUpSync)('package.json', { cwd });
+    return filePath && path_1.default.dirname(filePath);
+}
+exports.packageDirectorySync = packageDirectorySync;