@remotion/renderer 4.0.0-fastlambda.8 → 4.0.0-forcepublish.7

package/dist/browser/Connection.js

@@ -0,0 +1,242 @@
+"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 _Connection_instances, _Connection_transport, _Connection_lastId, _Connection_sessions, _Connection_closed, _Connection_callbacks, _Connection_onMessage, _Connection_onClose, _CDPSession_sessionId, _CDPSession_targetType, _CDPSession_callbacks, _CDPSession_connection;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CDPSession = exports.CDPSessionEmittedEvents = exports.Connection = void 0;
+/**
+ * Copyright 2017 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const assert_1 = require("./assert");
+const Errors_1 = require("./Errors");
+const EventEmitter_1 = require("./EventEmitter");
+const ConnectionEmittedEvents = {
+    Disconnected: Symbol('Connection.Disconnected'),
+};
+class Connection extends EventEmitter_1.EventEmitter {
+    constructor(transport) {
+        super();
+        _Connection_instances.add(this);
+        _Connection_transport.set(this, void 0);
+        _Connection_lastId.set(this, 0);
+        _Connection_sessions.set(this, new Map());
+        _Connection_closed.set(this, false);
+        _Connection_callbacks.set(this, new Map());
+        __classPrivateFieldSet(this, _Connection_transport, transport, "f");
+        __classPrivateFieldGet(this, _Connection_transport, "f").onmessage = __classPrivateFieldGet(this, _Connection_instances, "m", _Connection_onMessage).bind(this);
+        __classPrivateFieldGet(this, _Connection_transport, "f").onclose = __classPrivateFieldGet(this, _Connection_instances, "m", _Connection_onClose).bind(this);
+    }
+    static fromSession(session) {
+        return session.connection();
+    }
+    session(sessionId) {
+        return __classPrivateFieldGet(this, _Connection_sessions, "f").get(sessionId) || null;
+    }
+    send(method, ...paramArgs) {
+        // There is only ever 1 param arg passed, but the Protocol defines it as an
+        // array of 0 or 1 items See this comment:
+        // https://github.com/ChromeDevTools/devtools-protocol/pull/113#issuecomment-412603285
+        // which explains why the protocol defines the params this way for better
+        // type-inference.
+        // So now we check if there are any params or not and deal with them accordingly.
+        const params = paramArgs.length ? paramArgs[0] : undefined;
+        const id = this._rawSend({ method, params });
+        return new Promise((resolve, reject) => {
+            __classPrivateFieldGet(this, _Connection_callbacks, "f").set(id, {
+                resolve,
+                reject,
+                error: new Errors_1.ProtocolError(),
+                method,
+            });
+        });
+    }
+    _rawSend(message) {
+        var _a;
+        const id = __classPrivateFieldSet(this, _Connection_lastId, (_a = __classPrivateFieldGet(this, _Connection_lastId, "f"), ++_a), "f");
+        const stringifiedMessage = JSON.stringify({ ...message, id });
+        __classPrivateFieldGet(this, _Connection_transport, "f").send(stringifiedMessage);
+        return id;
+    }
+    dispose() {
+        __classPrivateFieldGet(this, _Connection_instances, "m", _Connection_onClose).call(this);
+        __classPrivateFieldGet(this, _Connection_transport, "f").close();
+    }
+    /**
+     * @param targetInfo - The target info
+     * @returns The CDP session that is created
+     */
+    async createSession(targetInfo) {
+        const { sessionId } = await this.send('Target.attachToTarget', {
+            targetId: targetInfo.targetId,
+            flatten: true,
+        });
+        const session = __classPrivateFieldGet(this, _Connection_sessions, "f").get(sessionId);
+        if (!session) {
+            throw new Error('CDPSession creation failed.');
+        }
+        return session;
+    }
+}
+exports.Connection = Connection;
+_Connection_transport = new WeakMap(), _Connection_lastId = new WeakMap(), _Connection_sessions = new WeakMap(), _Connection_closed = new WeakMap(), _Connection_callbacks = new WeakMap(), _Connection_instances = new WeakSet(), _Connection_onMessage = function _Connection_onMessage(message) {
+    const object = JSON.parse(message);
+    if (object.method === 'Target.attachedToTarget') {
+        const { sessionId } = object.params;
+        const session = new CDPSession(this, object.params.targetInfo.type, sessionId);
+        __classPrivateFieldGet(this, _Connection_sessions, "f").set(sessionId, session);
+        this.emit('sessionattached', session);
+        const parentSession = __classPrivateFieldGet(this, _Connection_sessions, "f").get(object.sessionId);
+        if (parentSession) {
+            parentSession.emit('sessionattached', session);
+        }
+    }
+    else if (object.method === 'Target.detachedFromTarget') {
+        const session = __classPrivateFieldGet(this, _Connection_sessions, "f").get(object.params.sessionId);
+        if (session) {
+            session._onClosed();
+            __classPrivateFieldGet(this, _Connection_sessions, "f").delete(object.params.sessionId);
+            this.emit('sessiondetached', session);
+            const parentSession = __classPrivateFieldGet(this, _Connection_sessions, "f").get(object.sessionId);
+            if (parentSession) {
+                parentSession.emit('sessiondetached', session);
+            }
+        }
+    }
+    if (object.sessionId) {
+        const session = __classPrivateFieldGet(this, _Connection_sessions, "f").get(object.sessionId);
+        if (session) {
+            session._onMessage(object);
+        }
+    }
+    else if (object.id) {
+        const callback = __classPrivateFieldGet(this, _Connection_callbacks, "f").get(object.id);
+        // Callbacks could be all rejected if someone has called `.dispose()`.
+        if (callback) {
+            __classPrivateFieldGet(this, _Connection_callbacks, "f").delete(object.id);
+            if (object.error) {
+                callback.reject(createProtocolError(callback.error, callback.method, object));
+            }
+            else {
+                callback.resolve(object.result);
+            }
+        }
+    }
+    else {
+        this.emit(object.method, object.params);
+    }
+}, _Connection_onClose = function _Connection_onClose() {
+    if (__classPrivateFieldGet(this, _Connection_closed, "f")) {
+        return;
+    }
+    __classPrivateFieldGet(this, _Connection_transport, "f").onmessage = undefined;
+    __classPrivateFieldGet(this, _Connection_transport, "f").onclose = undefined;
+    for (const callback of __classPrivateFieldGet(this, _Connection_callbacks, "f").values()) {
+        callback.reject(rewriteError(callback.error, `Protocol error (${callback.method}): Target closed. https://www.remotion.dev/docs/target-closed`));
+    }
+    __classPrivateFieldGet(this, _Connection_callbacks, "f").clear();
+    for (const session of __classPrivateFieldGet(this, _Connection_sessions, "f").values()) {
+        session._onClosed();
+    }
+    __classPrivateFieldGet(this, _Connection_sessions, "f").clear();
+    this.emit(ConnectionEmittedEvents.Disconnected);
+};
+exports.CDPSessionEmittedEvents = {
+    Disconnected: Symbol('CDPSession.Disconnected'),
+};
+class CDPSession extends EventEmitter_1.EventEmitter {
+    constructor(connection, targetType, sessionId) {
+        super();
+        _CDPSession_sessionId.set(this, void 0);
+        _CDPSession_targetType.set(this, void 0);
+        _CDPSession_callbacks.set(this, new Map());
+        _CDPSession_connection.set(this, void 0);
+        __classPrivateFieldSet(this, _CDPSession_connection, connection, "f");
+        __classPrivateFieldSet(this, _CDPSession_targetType, targetType, "f");
+        __classPrivateFieldSet(this, _CDPSession_sessionId, sessionId, "f");
+    }
+    connection() {
+        return __classPrivateFieldGet(this, _CDPSession_connection, "f");
+    }
+    send(method, ...paramArgs) {
+        if (!__classPrivateFieldGet(this, _CDPSession_connection, "f")) {
+            return Promise.reject(new Error(`Protocol error (${method}): Session closed. Most likely the ${__classPrivateFieldGet(this, _CDPSession_targetType, "f")} has been closed.`));
+        }
+        // See the comment in Connection#send explaining why we do this.
+        const params = paramArgs.length ? paramArgs[0] : undefined;
+        const id = __classPrivateFieldGet(this, _CDPSession_connection, "f")._rawSend({
+            sessionId: __classPrivateFieldGet(this, _CDPSession_sessionId, "f"),
+            method,
+            params,
+        });
+        return new Promise((resolve, reject) => {
+            __classPrivateFieldGet(this, _CDPSession_callbacks, "f").set(id, {
+                resolve,
+                reject,
+                error: new Errors_1.ProtocolError(),
+                method,
+            });
+        });
+    }
+    _onMessage(object) {
+        const callback = object.id ? __classPrivateFieldGet(this, _CDPSession_callbacks, "f").get(object.id) : undefined;
+        if (object.id && callback) {
+            __classPrivateFieldGet(this, _CDPSession_callbacks, "f").delete(object.id);
+            if (object.error) {
+                callback.reject(createProtocolError(callback.error, callback.method, object));
+            }
+            else {
+                callback.resolve(object.result);
+            }
+        }
+        else {
+            (0, assert_1.assert)(!object.id);
+            this.emit(object.method, object.params);
+        }
+    }
+    _onClosed() {
+        for (const callback of __classPrivateFieldGet(this, _CDPSession_callbacks, "f").values()) {
+            callback.reject(rewriteError(callback.error, `Protocol error (${callback.method}): Target closed. https://www.remotion.dev/docs/target-closed`));
+        }
+        __classPrivateFieldGet(this, _CDPSession_callbacks, "f").clear();
+        __classPrivateFieldSet(this, _CDPSession_connection, undefined, "f");
+        this.emit(exports.CDPSessionEmittedEvents.Disconnected);
+    }
+    id() {
+        return __classPrivateFieldGet(this, _CDPSession_sessionId, "f");
+    }
+}
+exports.CDPSession = CDPSession;
+_CDPSession_sessionId = new WeakMap(), _CDPSession_targetType = new WeakMap(), _CDPSession_callbacks = new WeakMap(), _CDPSession_connection = new WeakMap();
+function createProtocolError(error, method, object) {
+    let message = `Protocol error (${method}): ${object.error.message}`;
+    if ('data' in object.error) {
+        message += ` ${object.error.data}`;
+    }
+    return rewriteError(error, message, object.error.message);
+}
+function rewriteError(error, message, originalMessage) {
+    error.message = message;
+    error.originalMessage = originalMessage !== null && originalMessage !== void 0 ? originalMessage : error.originalMessage;
+    return error;
+}

package/dist/browser/ConsoleMessage.d.ts

@@ -0,0 +1,31 @@
+/**
+ * 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 { JSHandle } from './JSHandle';
+export interface ConsoleMessageLocation {
+    url?: string;
+    lineNumber?: number;
+    columnNumber?: number;
+}
+export declare type ConsoleMessageType = 'log' | 'debug' | 'info' | 'error' | 'warning' | 'dir' | 'dirxml' | 'table' | 'trace' | 'clear' | 'startGroup' | 'startGroupCollapsed' | 'endGroup' | 'assert' | 'profile' | 'profileEnd' | 'count' | 'timeEnd' | 'verbose';
+export declare class ConsoleMessage {
+    #private;
+    type: ConsoleMessageType;
+    text: string;
+    args: JSHandle[];
+    constructor(type: ConsoleMessageType, text: string, args: JSHandle[], stackTraceLocations: ConsoleMessageLocation[]);
+    location(): ConsoleMessageLocation;
+    stackTrace(): ConsoleMessageLocation[];
+}

package/dist/browser/ConsoleMessage.js

@@ -0,0 +1,48 @@
+"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 _ConsoleMessage_stackTraceLocations;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleMessage = void 0;
+class ConsoleMessage {
+    constructor(type, text, args, stackTraceLocations) {
+        _ConsoleMessage_stackTraceLocations.set(this, void 0);
+        this.type = type;
+        this.text = text;
+        this.args = args;
+        __classPrivateFieldSet(this, _ConsoleMessage_stackTraceLocations, stackTraceLocations, "f");
+    }
+    location() {
+        var _a;
+        return (_a = __classPrivateFieldGet(this, _ConsoleMessage_stackTraceLocations, "f")[0]) !== null && _a !== void 0 ? _a : {};
+    }
+    stackTrace() {
+        return __classPrivateFieldGet(this, _ConsoleMessage_stackTraceLocations, "f");
+    }
+}
+exports.ConsoleMessage = ConsoleMessage;
+_ConsoleMessage_stackTraceLocations = new WeakMap();

package/dist/browser/DOMWorld.d.ts

@@ -0,0 +1,52 @@
+/**
+ * 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 } from './Browser';
+import type { EvaluateFn, EvaluateFnReturnType, EvaluateHandleFn, SerializableOrJSHandle, UnwrapPromiseLike } from './EvalTypes';
+import type { ExecutionContext } from './ExecutionContext';
+import type { Frame } from './FrameManager';
+import type { JSHandle } from './JSHandle';
+import type { TimeoutSettings } from './TimeoutSettings';
+export declare class DOMWorld {
+    #private;
+    get _waitTasks(): Set<WaitTask>;
+    constructor(frame: Frame, timeoutSettings: TimeoutSettings);
+    frame(): Frame;
+    _setContext(context: ExecutionContext | null): void;
+    _hasContext(): boolean;
+    _detach(): void;
+    executionContext(): Promise<ExecutionContext>;
+    evaluateHandle<HandlerType extends JSHandle = JSHandle>(pageFunction: EvaluateHandleFn, ...args: SerializableOrJSHandle[]): Promise<HandlerType>;
+    evaluate<T extends EvaluateFn>(pageFunction: T, ...args: SerializableOrJSHandle[]): Promise<UnwrapPromiseLike<EvaluateFnReturnType<T>>>;
+    waitForFunction(browser: Browser, pageFunction: Function | string, ...args: SerializableOrJSHandle[]): Promise<JSHandle>;
+    title(): Promise<string>;
+}
+interface WaitTaskOptions {
+    domWorld: DOMWorld;
+    predicateBody: Function | string;
+    title: string;
+    timeout: number;
+    browser: Browser;
+    args: SerializableOrJSHandle[];
+}
+declare class WaitTask {
+    #private;
+    promise: Promise<JSHandle>;
+    constructor(options: WaitTaskOptions);
+    onBrowserClose: () => void;
+    terminate(error: Error): void;
+    rerun(): Promise<void>;
+}
+export {};

package/dist/browser/DOMWorld.js

@@ -0,0 +1,272 @@
+"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 _DOMWorld_frame, _DOMWorld_timeoutSettings, _DOMWorld_contextPromise, _DOMWorld_contextResolveCallback, _DOMWorld_detached, _DOMWorld_waitTasks, _WaitTask_instances, _WaitTask_domWorld, _WaitTask_timeout, _WaitTask_predicateBody, _WaitTask_args, _WaitTask_runCount, _WaitTask_resolve, _WaitTask_reject, _WaitTask_timeoutTimer, _WaitTask_terminated, _WaitTask_browser, _WaitTask_cleanup;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DOMWorld = void 0;
+const assert_1 = require("./assert");
+const Errors_1 = require("./Errors");
+const util_1 = require("./util");
+class DOMWorld {
+    constructor(frame, timeoutSettings) {
+        _DOMWorld_frame.set(this, void 0);
+        _DOMWorld_timeoutSettings.set(this, void 0);
+        _DOMWorld_contextPromise.set(this, null);
+        _DOMWorld_contextResolveCallback.set(this, null);
+        _DOMWorld_detached.set(this, false);
+        _DOMWorld_waitTasks.set(this, new Set());
+        // Keep own reference to client because it might differ from the FrameManager's
+        // client for OOP iframes.
+        __classPrivateFieldSet(this, _DOMWorld_frame, frame, "f");
+        __classPrivateFieldSet(this, _DOMWorld_timeoutSettings, timeoutSettings, "f");
+        this._setContext(null);
+    }
+    get _waitTasks() {
+        return __classPrivateFieldGet(this, _DOMWorld_waitTasks, "f");
+    }
+    frame() {
+        return __classPrivateFieldGet(this, _DOMWorld_frame, "f");
+    }
+    _setContext(context) {
+        var _a;
+        if (context) {
+            (0, assert_1.assert)(__classPrivateFieldGet(this, _DOMWorld_contextResolveCallback, "f"), 'Execution Context has already been set.');
+            (_a = __classPrivateFieldGet(this, _DOMWorld_contextResolveCallback, "f")) === null || _a === void 0 ? void 0 : _a.call(null, context);
+            __classPrivateFieldSet(this, _DOMWorld_contextResolveCallback, null, "f");
+            for (const waitTask of this._waitTasks) {
+                waitTask.rerun();
+            }
+        }
+        else {
+            __classPrivateFieldSet(this, _DOMWorld_contextPromise, new Promise((fulfill) => {
+                __classPrivateFieldSet(this, _DOMWorld_contextResolveCallback, fulfill, "f");
+            }), "f");
+        }
+    }
+    _hasContext() {
+        return !__classPrivateFieldGet(this, _DOMWorld_contextResolveCallback, "f");
+    }
+    _detach() {
+        __classPrivateFieldSet(this, _DOMWorld_detached, true, "f");
+        for (const waitTask of this._waitTasks) {
+            waitTask.terminate(new Error('waitForFunction failed: frame got detached.'));
+        }
+    }
+    executionContext() {
+        if (__classPrivateFieldGet(this, _DOMWorld_detached, "f")) {
+            throw new Error(`Execution context is not available in detached frame "${__classPrivateFieldGet(this, _DOMWorld_frame, "f").url()}" (are you trying to evaluate?)`);
+        }
+        if (__classPrivateFieldGet(this, _DOMWorld_contextPromise, "f") === null) {
+            throw new Error(`Execution content promise is missing`);
+        }
+        return __classPrivateFieldGet(this, _DOMWorld_contextPromise, "f");
+    }
+    async evaluateHandle(pageFunction, ...args) {
+        const context = await this.executionContext();
+        return context.evaluateHandle(pageFunction, ...args);
+    }
+    async evaluate(pageFunction, ...args) {
+        const context = await this.executionContext();
+        return context.evaluate(pageFunction, ...args);
+    }
+    waitForFunction(browser, pageFunction, ...args) {
+        const timeout = __classPrivateFieldGet(this, _DOMWorld_timeoutSettings, "f").timeout();
+        const waitTaskOptions = {
+            domWorld: this,
+            predicateBody: pageFunction,
+            title: 'function',
+            timeout,
+            args,
+            browser,
+        };
+        const waitTask = new WaitTask(waitTaskOptions);
+        return waitTask.promise;
+    }
+    title() {
+        return this.evaluate(() => {
+            return document.title;
+        });
+    }
+}
+exports.DOMWorld = DOMWorld;
+_DOMWorld_frame = new WeakMap(), _DOMWorld_timeoutSettings = new WeakMap(), _DOMWorld_contextPromise = new WeakMap(), _DOMWorld_contextResolveCallback = new WeakMap(), _DOMWorld_detached = new WeakMap(), _DOMWorld_waitTasks = new WeakMap();
+const noop = () => undefined;
+class WaitTask {
+    constructor(options) {
+        _WaitTask_instances.add(this);
+        _WaitTask_domWorld.set(this, void 0);
+        _WaitTask_timeout.set(this, void 0);
+        _WaitTask_predicateBody.set(this, void 0);
+        _WaitTask_args.set(this, void 0);
+        _WaitTask_runCount.set(this, 0);
+        _WaitTask_resolve.set(this, noop);
+        _WaitTask_reject.set(this, noop);
+        _WaitTask_timeoutTimer.set(this, void 0);
+        _WaitTask_terminated.set(this, false);
+        _WaitTask_browser.set(this, void 0);
+        this.onBrowserClose = () => {
+            return this.terminate(new Error('Browser was closed'));
+        };
+        function getPredicateBody(predicateBody) {
+            if ((0, util_1.isString)(predicateBody)) {
+                return `return (${predicateBody});`;
+            }
+            return `return (${predicateBody})(...args);`;
+        }
+        __classPrivateFieldSet(this, _WaitTask_domWorld, options.domWorld, "f");
+        __classPrivateFieldSet(this, _WaitTask_timeout, options.timeout, "f");
+        __classPrivateFieldSet(this, _WaitTask_predicateBody, getPredicateBody(options.predicateBody), "f");
+        __classPrivateFieldSet(this, _WaitTask_args, options.args, "f");
+        __classPrivateFieldSet(this, _WaitTask_runCount, 0, "f");
+        __classPrivateFieldGet(this, _WaitTask_domWorld, "f")._waitTasks.add(this);
+        this.promise = new Promise((resolve, reject) => {
+            __classPrivateFieldSet(this, _WaitTask_resolve, resolve, "f");
+            __classPrivateFieldSet(this, _WaitTask_reject, reject, "f");
+        });
+        // Since page navigation requires us to re-install the pageScript, we should track
+        // timeout on our end.
+        if (options.timeout) {
+            const timeoutError = new Errors_1.TimeoutError(`waiting for ${options.title} failed: timeout ${options.timeout}ms exceeded`);
+            __classPrivateFieldSet(this, _WaitTask_timeoutTimer, setTimeout(() => {
+                return this.terminate(timeoutError);
+            }, options.timeout), "f");
+        }
+        __classPrivateFieldSet(this, _WaitTask_browser, options.browser, "f");
+        __classPrivateFieldGet(this, _WaitTask_browser, "f").on("closed" /* BrowserEmittedEvents.Closed */, this.onBrowserClose);
+        this.rerun();
+    }
+    terminate(error) {
+        __classPrivateFieldSet(this, _WaitTask_terminated, true, "f");
+        __classPrivateFieldGet(this, _WaitTask_reject, "f").call(this, error);
+        __classPrivateFieldGet(this, _WaitTask_instances, "m", _WaitTask_cleanup).call(this);
+    }
+    async rerun() {
+        var _a;
+        const runCount = __classPrivateFieldSet(this, _WaitTask_runCount, (_a = __classPrivateFieldGet(this, _WaitTask_runCount, "f"), ++_a), "f");
+        let success = null;
+        let error = null;
+        const context = await __classPrivateFieldGet(this, _WaitTask_domWorld, "f").executionContext();
+        if (__classPrivateFieldGet(this, _WaitTask_terminated, "f") || runCount !== __classPrivateFieldGet(this, _WaitTask_runCount, "f")) {
+            return;
+        }
+        if (__classPrivateFieldGet(this, _WaitTask_terminated, "f") || runCount !== __classPrivateFieldGet(this, _WaitTask_runCount, "f")) {
+            return;
+        }
+        try {
+            success = await context.evaluateHandle(waitForPredicatePageFunction, __classPrivateFieldGet(this, _WaitTask_predicateBody, "f"), __classPrivateFieldGet(this, _WaitTask_timeout, "f"), ...__classPrivateFieldGet(this, _WaitTask_args, "f"));
+        }
+        catch (error_) {
+            error = error_;
+        }
+        if (__classPrivateFieldGet(this, _WaitTask_terminated, "f") || runCount !== __classPrivateFieldGet(this, _WaitTask_runCount, "f")) {
+            if (success) {
+                await success.dispose();
+            }
+            return;
+        }
+        // Ignore timeouts in pageScript - we track timeouts ourselves.
+        // If the frame's execution context has already changed, `frame.evaluate` will
+        // throw an error - ignore this predicate run altogether.
+        if (!error &&
+            (await __classPrivateFieldGet(this, _WaitTask_domWorld, "f")
+                .evaluate((s) => {
+                return !s;
+            }, success)
+                .catch(() => {
+                return true;
+            }))) {
+            if (!success) {
+                throw new Error('Assertion: result handle is not available');
+            }
+            await success.dispose();
+            return;
+        }
+        if (error) {
+            if (error.message.includes('TypeError: binding is not a function')) {
+                return this.rerun();
+            }
+            // When frame is detached the task should have been terminated by the DOMWorld.
+            // This can fail if we were adding this task while the frame was detached,
+            // so we terminate here instead.
+            if (error.message.includes('Execution context is not available in detached frame')) {
+                this.terminate(new Error('waitForFunction failed: frame got detached.'));
+                return;
+            }
+            // When the page is navigated, the promise is rejected.
+            // We will try again in the new execution context.
+            if (error.message.includes('Execution context was destroyed')) {
+                return;
+            }
+            // We could have tried to evaluate in a context which was already
+            // destroyed.
+            if (error.message.includes('Cannot find context with specified id')) {
+                return;
+            }
+            __classPrivateFieldGet(this, _WaitTask_reject, "f").call(this, error);
+        }
+        else {
+            if (!success) {
+                throw new Error('Assertion: result handle is not available');
+            }
+            __classPrivateFieldGet(this, _WaitTask_resolve, "f").call(this, success);
+        }
+        __classPrivateFieldGet(this, _WaitTask_instances, "m", _WaitTask_cleanup).call(this);
+    }
+}
+_WaitTask_domWorld = new WeakMap(), _WaitTask_timeout = new WeakMap(), _WaitTask_predicateBody = new WeakMap(), _WaitTask_args = new WeakMap(), _WaitTask_runCount = new WeakMap(), _WaitTask_resolve = new WeakMap(), _WaitTask_reject = new WeakMap(), _WaitTask_timeoutTimer = new WeakMap(), _WaitTask_terminated = new WeakMap(), _WaitTask_browser = new WeakMap(), _WaitTask_instances = new WeakSet(), _WaitTask_cleanup = function _WaitTask_cleanup() {
+    if (__classPrivateFieldGet(this, _WaitTask_timeoutTimer, "f") !== undefined) {
+        clearTimeout(__classPrivateFieldGet(this, _WaitTask_timeoutTimer, "f"));
+    }
+    __classPrivateFieldGet(this, _WaitTask_browser, "f").off("closed" /* BrowserEmittedEvents.Closed */, this.onBrowserClose);
+    __classPrivateFieldGet(this, _WaitTask_domWorld, "f")._waitTasks.delete(this);
+};
+function waitForPredicatePageFunction(predicateBody, timeout, ...args) {
+    // eslint-disable-next-line no-new-func
+    const predicate = new Function('...args', predicateBody);
+    let timedOut = false;
+    if (timeout) {
+        setTimeout(() => {
+            timedOut = true;
+        }, timeout);
+    }
+    return new Promise((resolve) => {
+        async function onRaf() {
+            if (timedOut) {
+                resolve(undefined);
+                return;
+            }
+            const success = await predicate(...args);
+            if (success) {
+                resolve(success);
+            }
+            else {
+                requestAnimationFrame(onRaf);
+            }
+        }
+        onRaf();
+    });
+}

package/dist/browser/Errors.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 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.
+ */
+declare class CustomError extends Error {
+    constructor(message?: string);
+}
+export declare class TimeoutError extends CustomError {
+}
+export declare class ProtocolError extends CustomError {
+    code?: number;
+    originalMessage: string;
+}
+export {};