@remotion/renderer 4.0.536 → 4.0.538

package/dist/browser/Connection.js

@@ -1,4 +1,16 @@
 "use strict";
+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 __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 _Connection_instances, _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;
 /**
@@ -23,22 +35,22 @@ const ConnectionEmittedEvents = {
     Disconnected: Symbol('Connection.Disconnected'),
 };
 class Connection extends EventEmitter_1.EventEmitter {
-    transport;
-    #lastId = 0;
-    #sessions = new Map();
-    #closed = false;
-    #callbacks = new Map();
     constructor(transport) {
         super();
+        _Connection_instances.add(this);
+        _Connection_lastId.set(this, 0);
+        _Connection_sessions.set(this, new Map());
+        _Connection_closed.set(this, false);
+        _Connection_callbacks.set(this, new Map());
         this.transport = transport;
-        this.transport.onmessage = this.#onMessage.bind(this);
-        this.transport.onclose = this.#onClose.bind(this);
+        this.transport.onmessage = __classPrivateFieldGet(this, _Connection_instances, "m", _Connection_onMessage).bind(this);
+        this.transport.onclose = __classPrivateFieldGet(this, _Connection_instances, "m", _Connection_onClose).bind(this);
     }
     static fromSession(session) {
         return session.connection();
     }
     session(sessionId) {
-        return this.#sessions.get(sessionId) || null;
+        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
@@ -50,7 +62,7 @@ class Connection extends EventEmitter_1.EventEmitter {
         const params = paramArgs.length ? paramArgs[0] : undefined;
         const id = this._rawSend({ method, params });
         return new Promise((resolve, reject) => {
-            this.#callbacks.set(id, {
+            __classPrivateFieldGet(this, _Connection_callbacks, "f").set(id, {
                 resolve,
                 reject,
                 method,
@@ -59,76 +71,14 @@ class Connection extends EventEmitter_1.EventEmitter {
         });
     }
     _rawSend(message) {
-        const id = ++this.#lastId;
+        var _a;
+        const id = __classPrivateFieldSet(this, _Connection_lastId, (_a = __classPrivateFieldGet(this, _Connection_lastId, "f"), ++_a), "f");
         const stringifiedMessage = JSON.stringify({ ...message, id });
         this.transport.send(stringifiedMessage);
         return id;
     }
-    #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);
-            this.#sessions.set(sessionId, session);
-            this.emit('sessionattached', session);
-            const parentSession = this.#sessions.get(object.sessionId);
-            if (parentSession) {
-                parentSession.emit('sessionattached', session);
-            }
-        }
-        else if (object.method === 'Target.detachedFromTarget') {
-            const session = this.#sessions.get(object.params.sessionId);
-            if (session) {
-                session._onClosed();
-                this.#sessions.delete(object.params.sessionId);
-                this.emit('sessiondetached', session);
-                const parentSession = this.#sessions.get(object.sessionId);
-                if (parentSession) {
-                    parentSession.emit('sessiondetached', session);
-                }
-            }
-        }
-        if (object.sessionId) {
-            const session = this.#sessions.get(object.sessionId);
-            if (session) {
-                session._onMessage(object, message.length);
-            }
-        }
-        else if (object.id) {
-            const callback = this.#callbacks.get(object.id);
-            // Callbacks could be all rejected if someone has called `.dispose()`.
-            if (callback) {
-                this.#callbacks.delete(object.id);
-                if (object.error) {
-                    callback.reject(createProtocolError(callback.method, object));
-                }
-                else {
-                    callback.resolve({ value: object.result, size: message.length });
-                }
-            }
-        }
-        else {
-            this.emit(object.method, object.params);
-        }
-    }
-    #onClose() {
-        if (this.#closed) {
-            return;
-        }
-        this.transport.onmessage = undefined;
-        this.transport.onclose = undefined;
-        for (const callback of this.#callbacks.values()) {
-            callback.reject(rewriteError(new Errors_1.ProtocolError(), `Protocol error (${callback.method}): Target closed. https://www.remotion.dev/docs/target-closed`));
-        }
-        this.#callbacks.clear();
-        for (const session of this.#sessions.values()) {
-            session._onClosed();
-        }
-        this.#sessions.clear();
-        this.emit(ConnectionEmittedEvents.Disconnected);
-    }
     dispose() {
-        this.#onClose();
+        __classPrivateFieldGet(this, _Connection_instances, "m", _Connection_onClose).call(this);
         this.transport.close();
     }
     /**
@@ -140,7 +90,7 @@ class Connection extends EventEmitter_1.EventEmitter {
             targetId: targetInfo.targetId,
             flatten: true,
         });
-        const session = this.#sessions.get(sessionId);
+        const session = __classPrivateFieldGet(this, _Connection_sessions, "f").get(sessionId);
         if (!session) {
             throw new Error('CDPSession creation failed.');
         }
@@ -148,42 +98,104 @@ class Connection extends EventEmitter_1.EventEmitter {
     }
 }
 exports.Connection = Connection;
+_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, message.length);
+        }
+    }
+    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.method, object));
+            }
+            else {
+                callback.resolve({ value: object.result, size: message.length });
+            }
+        }
+    }
+    else {
+        this.emit(object.method, object.params);
+    }
+}, _Connection_onClose = function _Connection_onClose() {
+    if (__classPrivateFieldGet(this, _Connection_closed, "f")) {
+        return;
+    }
+    this.transport.onmessage = undefined;
+    this.transport.onclose = undefined;
+    for (const callback of __classPrivateFieldGet(this, _Connection_callbacks, "f").values()) {
+        callback.reject(rewriteError(new Errors_1.ProtocolError(), `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 {
-    #sessionId;
-    #targetType;
-    #callbacks = new Map();
-    #connection;
     constructor(connection, targetType, sessionId) {
         super();
-        this.#connection = connection;
-        this.#targetType = targetType;
-        this.#sessionId = sessionId;
+        _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 this.#connection;
+        return __classPrivateFieldGet(this, _CDPSession_connection, "f");
     }
     send(method, ...paramArgs) {
-        if (!this.#connection) {
-            return Promise.reject(new Error(`Protocol error (${method}): Session closed. Most likely the ${this.#targetType} has been closed.`));
+        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 = this.#connection._rawSend({
-            sessionId: this.#sessionId,
+        const id = __classPrivateFieldGet(this, _CDPSession_connection, "f")._rawSend({
+            sessionId: __classPrivateFieldGet(this, _CDPSession_sessionId, "f"),
             method,
             params,
         });
         return new Promise((resolve, reject) => {
-            if (this.#callbacks.size > 100) {
-                for (const callback of this.#callbacks.values()) {
+            if (__classPrivateFieldGet(this, _CDPSession_callbacks, "f").size > 100) {
+                for (const callback of __classPrivateFieldGet(this, _CDPSession_callbacks, "f").values()) {
                     logger_1.Log.info({ indent: false, logLevel: 'info' }, callback.method + JSON.stringify(callback.params));
                 }
                 throw new Error('Leak detected: Too many callbacks');
             }
-            this.#callbacks.set(id, {
+            __classPrivateFieldGet(this, _CDPSession_callbacks, "f").set(id, {
                 resolve,
                 reject,
                 method,
@@ -192,9 +204,9 @@ class CDPSession extends EventEmitter_1.EventEmitter {
         });
     }
     _onMessage(object, size) {
-        const callback = object.id ? this.#callbacks.get(object.id) : undefined;
+        const callback = object.id ? __classPrivateFieldGet(this, _CDPSession_callbacks, "f").get(object.id) : undefined;
         if (object.id && callback) {
-            this.#callbacks.delete(object.id);
+            __classPrivateFieldGet(this, _CDPSession_callbacks, "f").delete(object.id);
             if (object.error) {
                 callback.reject(createProtocolError(callback.method, object));
             }
@@ -207,18 +219,19 @@ class CDPSession extends EventEmitter_1.EventEmitter {
         }
     }
     _onClosed() {
-        this.#connection = undefined;
-        for (const callback of this.#callbacks.values()) {
+        __classPrivateFieldSet(this, _CDPSession_connection, undefined, "f");
+        for (const callback of __classPrivateFieldGet(this, _CDPSession_callbacks, "f").values()) {
             callback.reject(rewriteError(new Errors_1.ProtocolError(), `Protocol error (${callback.method}): Target closed. https://www.remotion.dev/docs/target-closed`));
         }
-        this.#callbacks.clear();
+        __classPrivateFieldGet(this, _CDPSession_callbacks, "f").clear();
         this.emit(exports.CDPSessionEmittedEvents.Disconnected);
     }
     id() {
-        return this.#sessionId;
+        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(method, object) {
     let message = `Protocol error (${method}): ${object.error.message}`;
     if ('data' in object.error) {

package/dist/browser/ConsoleMessage.d.ts

@@ -29,7 +29,7 @@ export declare class ConsoleMessage {
     previewString: string;
     logLevel: LogLevel;
     tag: string | null;
-    constructor({ type, text, args, stackTraceLocations, previewString, logLevel, tag }: {
+    constructor({ type, text, args, stackTraceLocations, previewString, logLevel, tag, }: {
         type: ConsoleMessageType;
         text: string;
         args: JSHandle[];

package/dist/browser/ConsoleMessage.js

@@ -14,27 +14,34 @@
  * 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 {
-    type;
-    text;
-    args;
-    previewString;
-    #stackTraceLocations;
-    logLevel;
-    tag;
     constructor({ type, text, args, stackTraceLocations, previewString, logLevel, tag, }) {
+        _ConsoleMessage_stackTraceLocations.set(this, void 0);
         this.type = type;
         this.text = text;
         this.args = args;
         this.previewString = previewString;
-        this.#stackTraceLocations = stackTraceLocations;
+        __classPrivateFieldSet(this, _ConsoleMessage_stackTraceLocations, stackTraceLocations, "f");
         this.logLevel = logLevel;
         this.tag = tag;
     }
     stackTrace() {
-        return this.#stackTraceLocations;
+        return __classPrivateFieldGet(this, _ConsoleMessage_stackTraceLocations, "f");
     }
 }
 exports.ConsoleMessage = ConsoleMessage;
+_ConsoleMessage_stackTraceLocations = new WeakMap();

package/dist/browser/DOMWorld.d.ts

@@ -29,7 +29,7 @@ export declare class DOMWorld {
     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, timeout, pageFunction, title }: {
+    waitForFunction({ browser, timeout, pageFunction, title, }: {
         browser: HeadlessBrowser;
         timeout: number | null;
         pageFunction: Function | string;

package/dist/browser/DOMWorld.js

@@ -14,62 +14,74 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+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 __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 _DOMWorld_frame, _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 {
-    #frame;
-    #contextPromise = null;
-    #contextResolveCallback = null;
-    #detached = false;
-    #waitTasks = new Set();
     get _waitTasks() {
-        return this.#waitTasks;
+        return __classPrivateFieldGet(this, _DOMWorld_waitTasks, "f");
     }
     constructor(frame) {
+        _DOMWorld_frame.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.
-        this.#frame = frame;
+        __classPrivateFieldSet(this, _DOMWorld_frame, frame, "f");
         this._setContext(null);
     }
     frame() {
-        return this.#frame;
+        return __classPrivateFieldGet(this, _DOMWorld_frame, "f");
     }
     _setContext(context) {
         var _a;
         if (context) {
-            (0, assert_1.assert)(this.#contextResolveCallback, 'Execution Context has already been set.');
-            (_a = this.#contextResolveCallback) === null || _a === void 0 ? void 0 : _a.call(null, context);
-            this.#contextResolveCallback = null;
+            (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 {
-            this.#contextPromise = new Promise((fulfill) => {
-                this.#contextResolveCallback = fulfill;
-            });
+            __classPrivateFieldSet(this, _DOMWorld_contextPromise, new Promise((fulfill) => {
+                __classPrivateFieldSet(this, _DOMWorld_contextResolveCallback, fulfill, "f");
+            }), "f");
         }
     }
     _hasContext() {
-        return !this.#contextResolveCallback;
+        return !__classPrivateFieldGet(this, _DOMWorld_contextResolveCallback, "f");
     }
     _detach() {
-        this.#detached = true;
+        __classPrivateFieldSet(this, _DOMWorld_detached, true, "f");
         for (const waitTask of this._waitTasks) {
             waitTask.terminate(new Error('waitForFunction failed: frame got detached.'));
         }
     }
     executionContext() {
-        if (this.#detached) {
-            throw new Error(`Execution context is not available in detached frame "${this.#frame.url()}" (are you trying to evaluate?)`);
+        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 (this.#contextPromise === null) {
+        if (__classPrivateFieldGet(this, _DOMWorld_contextPromise, "f") === null) {
             throw new Error(`Execution content promise is missing`);
         }
-        return this.#contextPromise;
+        return __classPrivateFieldGet(this, _DOMWorld_contextPromise, "f");
     }
     async evaluateHandle(pageFunction, ...args) {
         const context = await this.executionContext();
@@ -91,78 +103,80 @@ class DOMWorld {
     }
 }
 exports.DOMWorld = DOMWorld;
+_DOMWorld_frame = new WeakMap(), _DOMWorld_contextPromise = new WeakMap(), _DOMWorld_contextResolveCallback = new WeakMap(), _DOMWorld_detached = new WeakMap(), _DOMWorld_waitTasks = new WeakMap();
 const noop = () => undefined;
 class WaitTask {
-    #domWorld;
-    #timeout;
-    #predicateBody;
-    #args;
-    #runCount = 0;
-    #resolve = noop;
-    #reject = noop;
-    #timeoutTimer;
-    #terminated = false;
-    #browser;
-    promise;
     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'));
+        };
+        this.onBrowserCloseSilent = () => {
+            return this.terminate(null);
+        };
         function getPredicateBody(predicateBody) {
             if ((0, util_1.isString)(predicateBody)) {
                 return `return (${predicateBody});`;
             }
             return `return (${predicateBody})(...args);`;
         }
-        this.#domWorld = options.domWorld;
-        this.#timeout = options.timeout;
-        this.#predicateBody = getPredicateBody(options.predicateBody);
-        this.#args = options.args;
-        this.#runCount = 0;
-        this.#domWorld._waitTasks.add(this);
+        __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) => {
-            this.#resolve = resolve;
-            this.#reject = 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`);
-            this.#timeoutTimer = setTimeout(() => {
-                return this.#reject(timeoutError);
-            }, options.timeout);
+            __classPrivateFieldSet(this, _WaitTask_timeoutTimer, setTimeout(() => {
+                return __classPrivateFieldGet(this, _WaitTask_reject, "f").call(this, timeoutError);
+            }, options.timeout), "f");
         }
-        this.#browser = options.browser;
-        this.#browser.on("closed" /* BrowserEmittedEvents.Closed */, this.onBrowserClose);
-        this.#browser.on("closed-silent" /* BrowserEmittedEvents.ClosedSilent */, this.onBrowserCloseSilent);
+        __classPrivateFieldSet(this, _WaitTask_browser, options.browser, "f");
+        __classPrivateFieldGet(this, _WaitTask_browser, "f").on("closed" /* BrowserEmittedEvents.Closed */, this.onBrowserClose);
+        __classPrivateFieldGet(this, _WaitTask_browser, "f").on("closed-silent" /* BrowserEmittedEvents.ClosedSilent */, this.onBrowserCloseSilent);
         this.rerun();
     }
-    onBrowserClose = () => {
-        return this.terminate(new Error('Browser was closed'));
-    };
-    onBrowserCloseSilent = () => {
-        return this.terminate(null);
-    };
     terminate(error) {
-        this.#terminated = true;
+        __classPrivateFieldSet(this, _WaitTask_terminated, true, "f");
         if (error) {
-            this.#reject(error);
+            __classPrivateFieldGet(this, _WaitTask_reject, "f").call(this, error);
         }
-        this.#cleanup();
+        __classPrivateFieldGet(this, _WaitTask_instances, "m", _WaitTask_cleanup).call(this);
     }
     async rerun() {
-        const runCount = ++this.#runCount;
+        var _a;
+        const runCount = __classPrivateFieldSet(this, _WaitTask_runCount, (_a = __classPrivateFieldGet(this, _WaitTask_runCount, "f"), ++_a), "f");
         let success = null;
         let error = null;
-        const contextPromise = this.#domWorld.executionContext();
+        const contextPromise = __classPrivateFieldGet(this, _WaitTask_domWorld, "f").executionContext();
         const context = await contextPromise;
-        if (this.#terminated || runCount !== this.#runCount) {
+        if (__classPrivateFieldGet(this, _WaitTask_terminated, "f") || runCount !== __classPrivateFieldGet(this, _WaitTask_runCount, "f")) {
             return;
         }
         try {
-            success = await context.evaluateHandle(waitForPredicatePageFunction, this.#predicateBody, this.#timeout, ...this.#args);
+            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 (this.#terminated || runCount !== this.#runCount) {
+        if (__classPrivateFieldGet(this, _WaitTask_terminated, "f") || runCount !== __classPrivateFieldGet(this, _WaitTask_runCount, "f")) {
             if (success) {
                 await success.dispose();
             }
@@ -174,9 +188,9 @@ class WaitTask {
         if (!error &&
             (success && !success._remoteObject.objectId
                 ? !(0, util_1.valueFromRemoteObject)(success._remoteObject) ||
-                    !this.#domWorld._hasContext() ||
-                    this.#domWorld.executionContext() !== contextPromise
-                : await this.#domWorld
+                    !__classPrivateFieldGet(this, _WaitTask_domWorld, "f")._hasContext() ||
+                    __classPrivateFieldGet(this, _WaitTask_domWorld, "f").executionContext() !== contextPromise
+                : await __classPrivateFieldGet(this, _WaitTask_domWorld, "f")
                     .evaluate((s) => {
                     return !s;
                 }, success)
@@ -189,7 +203,7 @@ class WaitTask {
             await success.dispose();
             return;
         }
-        if (this.#terminated || runCount !== this.#runCount) {
+        if (__classPrivateFieldGet(this, _WaitTask_terminated, "f") || runCount !== __classPrivateFieldGet(this, _WaitTask_runCount, "f")) {
             await (success === null || success === void 0 ? void 0 : success.dispose());
             return;
         }
@@ -214,28 +228,28 @@ class WaitTask {
             if (error.message.includes('Cannot find context with specified id')) {
                 return;
             }
-            this.#reject(error);
+            __classPrivateFieldGet(this, _WaitTask_reject, "f").call(this, error);
         }
         else {
             if (!success) {
                 throw new Error('Assertion: result handle is not available');
             }
-            this.#resolve(success);
-        }
-        this.#cleanup();
-    }
-    #cleanup() {
-        if (this.#timeoutTimer !== undefined) {
-            clearTimeout(this.#timeoutTimer);
+            __classPrivateFieldGet(this, _WaitTask_resolve, "f").call(this, success);
         }
-        this.#browser.off("closed" /* BrowserEmittedEvents.Closed */, this.onBrowserClose);
-        this.#browser.off("closed-silent" /* BrowserEmittedEvents.ClosedSilent */, this.onBrowserCloseSilent);
-        if (this.#domWorld._waitTasks.size > 100) {
-            throw new Error('Leak detected: Too many WaitTasks');
-        }
-        this.#domWorld._waitTasks.delete(this);
+        __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_browser, "f").off("closed-silent" /* BrowserEmittedEvents.ClosedSilent */, this.onBrowserCloseSilent);
+    if (__classPrivateFieldGet(this, _WaitTask_domWorld, "f")._waitTasks.size > 100) {
+        throw new Error('Leak detected: Too many WaitTasks');
+    }
+    __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);

package/dist/browser/Errors.js

@@ -27,7 +27,9 @@ class TimeoutError extends CustomError {
 }
 exports.TimeoutError = TimeoutError;
 class ProtocolError extends CustomError {
-    code;
-    originalMessage = '';
+    constructor() {
+        super(...arguments);
+        this.originalMessage = '';
+    }
 }
 exports.ProtocolError = ProtocolError;