@remotion/renderer 4.0.405 → 4.0.407

package/dist/browser/Connection.js

@@ -1,16 +1,4 @@
 "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;
 /**
@@ -35,22 +23,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 = __classPrivateFieldGet(this, _Connection_instances, "m", _Connection_onMessage).bind(this);
-        this.transport.onclose = __classPrivateFieldGet(this, _Connection_instances, "m", _Connection_onClose).bind(this);
+        this.transport.onmessage = this.#onMessage.bind(this);
+        this.transport.onclose = this.#onClose.bind(this);
     }
     static fromSession(session) {
         return session.connection();
     }
     session(sessionId) {
-        return __classPrivateFieldGet(this, _Connection_sessions, "f").get(sessionId) || null;
+        return this.#sessions.get(sessionId) || null;
     }
     send(method, ...paramArgs) {
         // There is only ever 1 param arg passed, but the Protocol defines it as an
@@ -63,7 +51,7 @@ class Connection extends EventEmitter_1.EventEmitter {
         const id = this._rawSend({ method, params });
         return new Promise((resolve, reject) => {
             var _a;
-            __classPrivateFieldGet(this, _Connection_callbacks, "f").set(id, {
+            this.#callbacks.set(id, {
                 resolve,
                 reject,
                 method,
@@ -74,14 +62,79 @@ class Connection extends EventEmitter_1.EventEmitter {
         });
     }
     _rawSend(message) {
-        var _a;
-        const id = __classPrivateFieldSet(this, _Connection_lastId, (_a = __classPrivateFieldGet(this, _Connection_lastId, "f"), ++_a), "f");
+        const id = ++this.#lastId;
         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 if (callback.returnSize) {
+                    callback.resolve({ value: object.result, size: message.length });
+                }
+                else {
+                    callback.resolve(object.result);
+                }
+            }
+        }
+        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() {
-        __classPrivateFieldGet(this, _Connection_instances, "m", _Connection_onClose).call(this);
+        this.#onClose();
         this.transport.close();
     }
     /**
@@ -93,7 +146,7 @@ class Connection extends EventEmitter_1.EventEmitter {
             targetId: targetInfo.targetId,
             flatten: true,
         });
-        const session = __classPrivateFieldGet(this, _Connection_sessions, "f").get(sessionId);
+        const session = this.#sessions.get(sessionId);
         if (!session) {
             throw new Error('CDPSession creation failed.');
         }
@@ -101,108 +154,43 @@ 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 if (callback.returnSize) {
-                callback.resolve({ value: object.result, size: message.length });
-            }
-            else {
-                callback.resolve(object.result);
-            }
-        }
-    }
-    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();
-        _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");
+        this.#connection = connection;
+        this.#targetType = targetType;
+        this.#sessionId = sessionId;
     }
     connection() {
-        return __classPrivateFieldGet(this, _CDPSession_connection, "f");
+        return this.#connection;
     }
     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.`));
+        if (!this.#connection) {
+            return Promise.reject(new Error(`Protocol error (${method}): Session closed. Most likely the ${this.#targetType} 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"),
+        const id = this.#connection._rawSend({
+            sessionId: this.#sessionId,
             method,
             params,
         });
         return new Promise((resolve, reject) => {
             var _a;
-            if (__classPrivateFieldGet(this, _CDPSession_callbacks, "f").size > 100) {
-                for (const callback of __classPrivateFieldGet(this, _CDPSession_callbacks, "f").values()) {
+            if (this.#callbacks.size > 100) {
+                for (const callback of this.#callbacks.values()) {
                     logger_1.Log.info({ indent: false, logLevel: 'info' }, callback.fn);
                 }
                 throw new Error('Leak detected: Too many callbacks');
             }
-            __classPrivateFieldGet(this, _CDPSession_callbacks, "f").set(id, {
+            this.#callbacks.set(id, {
                 resolve,
                 reject,
                 method,
@@ -213,9 +201,9 @@ class CDPSession extends EventEmitter_1.EventEmitter {
         });
     }
     _onMessage(object, size) {
-        const callback = object.id ? __classPrivateFieldGet(this, _CDPSession_callbacks, "f").get(object.id) : undefined;
+        const callback = object.id ? this.#callbacks.get(object.id) : undefined;
         if (object.id && callback) {
-            __classPrivateFieldGet(this, _CDPSession_callbacks, "f").delete(object.id);
+            this.#callbacks.delete(object.id);
             if (object.error) {
                 callback.reject(createProtocolError(callback.method, object));
             }
@@ -231,19 +219,18 @@ class CDPSession extends EventEmitter_1.EventEmitter {
         }
     }
     _onClosed() {
-        __classPrivateFieldSet(this, _CDPSession_connection, undefined, "f");
-        for (const callback of __classPrivateFieldGet(this, _CDPSession_callbacks, "f").values()) {
+        this.#connection = 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`));
         }
-        __classPrivateFieldGet(this, _CDPSession_callbacks, "f").clear();
+        this.#callbacks.clear();
         this.emit(exports.CDPSessionEmittedEvents.Disconnected);
     }
     id() {
-        return __classPrivateFieldGet(this, _CDPSession_sessionId, "f");
+        return this.#sessionId;
     }
 }
 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,34 +14,27 @@
  * 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;
-        __classPrivateFieldSet(this, _ConsoleMessage_stackTraceLocations, stackTraceLocations, "f");
+        this.#stackTraceLocations = stackTraceLocations;
         this.logLevel = logLevel;
         this.tag = tag;
     }
     stackTrace() {
-        return __classPrivateFieldGet(this, _ConsoleMessage_stackTraceLocations, "f");
+        return this.#stackTraceLocations;
     }
 }
 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,74 +14,62 @@
  * 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 __classPrivateFieldGet(this, _DOMWorld_waitTasks, "f");
+        return this.#waitTasks;
     }
     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.
-        __classPrivateFieldSet(this, _DOMWorld_frame, frame, "f");
+        this.#frame = frame;
         this._setContext(null);
     }
     frame() {
-        return __classPrivateFieldGet(this, _DOMWorld_frame, "f");
+        return this.#frame;
     }
     _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");
+            (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;
             for (const waitTask of this._waitTasks) {
                 waitTask.rerun();
             }
         }
         else {
-            __classPrivateFieldSet(this, _DOMWorld_contextPromise, new Promise((fulfill) => {
-                __classPrivateFieldSet(this, _DOMWorld_contextResolveCallback, fulfill, "f");
-            }), "f");
+            this.#contextPromise = new Promise((fulfill) => {
+                this.#contextResolveCallback = fulfill;
+            });
         }
     }
     _hasContext() {
-        return !__classPrivateFieldGet(this, _DOMWorld_contextResolveCallback, "f");
+        return !this.#contextResolveCallback;
     }
     _detach() {
-        __classPrivateFieldSet(this, _DOMWorld_detached, true, "f");
+        this.#detached = true;
         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 (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_contextPromise, "f") === null) {
+        if (this.#contextPromise === null) {
             throw new Error(`Execution content promise is missing`);
         }
-        return __classPrivateFieldGet(this, _DOMWorld_contextPromise, "f");
+        return this.#contextPromise;
     }
     async evaluateHandle(pageFunction, ...args) {
         const context = await this.executionContext();
@@ -103,82 +91,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);`;
         }
-        __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.#domWorld = options.domWorld;
+        this.#timeout = options.timeout;
+        this.#predicateBody = getPredicateBody(options.predicateBody);
+        this.#args = options.args;
+        this.#runCount = 0;
+        this.#domWorld._waitTasks.add(this);
         this.promise = new Promise((resolve, reject) => {
-            __classPrivateFieldSet(this, _WaitTask_resolve, resolve, "f");
-            __classPrivateFieldSet(this, _WaitTask_reject, reject, "f");
+            this.#resolve = resolve;
+            this.#reject = reject;
         });
         // 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 __classPrivateFieldGet(this, _WaitTask_reject, "f").call(this, timeoutError);
-            }, options.timeout), "f");
+            this.#timeoutTimer = setTimeout(() => {
+                return this.#reject(timeoutError);
+            }, options.timeout);
         }
-        __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.#browser = options.browser;
+        this.#browser.on("closed" /* BrowserEmittedEvents.Closed */, this.onBrowserClose);
+        this.#browser.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) {
-        __classPrivateFieldSet(this, _WaitTask_terminated, true, "f");
+        this.#terminated = true;
         if (error) {
-            __classPrivateFieldGet(this, _WaitTask_reject, "f").call(this, error);
+            this.#reject(error);
         }
-        __classPrivateFieldGet(this, _WaitTask_instances, "m", _WaitTask_cleanup).call(this);
+        this.#cleanup();
     }
     async rerun() {
-        var _a;
-        const runCount = __classPrivateFieldSet(this, _WaitTask_runCount, (_a = __classPrivateFieldGet(this, _WaitTask_runCount, "f"), ++_a), "f");
+        const runCount = ++this.#runCount;
         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")) {
+        const context = await this.#domWorld.executionContext();
+        if (this.#terminated || runCount !== this.#runCount) {
             return;
         }
-        if (__classPrivateFieldGet(this, _WaitTask_terminated, "f") || runCount !== __classPrivateFieldGet(this, _WaitTask_runCount, "f")) {
+        if (this.#terminated || runCount !== this.#runCount) {
             return;
         }
         try {
-            success = await context.evaluateHandle(waitForPredicatePageFunction, __classPrivateFieldGet(this, _WaitTask_predicateBody, "f"), __classPrivateFieldGet(this, _WaitTask_timeout, "f"), ...__classPrivateFieldGet(this, _WaitTask_args, "f"));
+            success = await context.evaluateHandle(waitForPredicatePageFunction, this.#predicateBody, this.#timeout, ...this.#args);
         }
         catch (error_) {
             error = error_;
         }
-        if (__classPrivateFieldGet(this, _WaitTask_terminated, "f") || runCount !== __classPrivateFieldGet(this, _WaitTask_runCount, "f")) {
+        if (this.#terminated || runCount !== this.#runCount) {
             if (success) {
                 await success.dispose();
             }
@@ -188,7 +174,7 @@ class WaitTask {
         // 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")
+            (await this.#domWorld
                 .evaluate((s) => {
                 return !s;
             }, success)
@@ -222,28 +208,28 @@ class WaitTask {
             if (error.message.includes('Cannot find context with specified id')) {
                 return;
             }
-            __classPrivateFieldGet(this, _WaitTask_reject, "f").call(this, error);
+            this.#reject(error);
         }
         else {
             if (!success) {
                 throw new Error('Assertion: result handle is not available');
             }
-            __classPrivateFieldGet(this, _WaitTask_resolve, "f").call(this, success);
+            this.#resolve(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"));
+        this.#cleanup();
     }
-    __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');
+    #cleanup() {
+        if (this.#timeoutTimer !== undefined) {
+            clearTimeout(this.#timeoutTimer);
+        }
+        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_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,9 +27,7 @@ class TimeoutError extends CustomError {
 }
 exports.TimeoutError = TimeoutError;
 class ProtocolError extends CustomError {
-    constructor() {
-        super(...arguments);
-        this.originalMessage = '';
-    }
+    code;
+    originalMessage = '';
 }
 exports.ProtocolError = ProtocolError;