rebrowser-playwright-core 1.47.100 → 1.49.0

package/lib/server/firefox/ffNetworkManager.js

@@ -161,7 +161,7 @@ const causeToResourceType = {
   TYPE_XSLT: 'other',
   TYPE_BEACON: 'other',
   TYPE_FETCH: 'fetch',
-  TYPE_IMAGESET: 'images',
+  TYPE_IMAGESET: 'image',
   TYPE_WEB_MANIFEST: 'manifest'
 };
 const internalCauseToResourceType = {

package/lib/server/firefox/ffPage.js

@@ -121,11 +121,11 @@ class FFPage {
     const frame = this._page._frameManager.frame(auxData.frameId);
     if (!frame) return;
     const delegate = new _ffExecutionContext.FFExecutionContext(this._session, executionContextId);
-    let worldName;
-    if (auxData.name === UTILITY_WORLD_NAME) worldName = 'utility';else if (!auxData.name) worldName = 'main';else return;
+    let worldName = null;
+    if (auxData.name === UTILITY_WORLD_NAME) worldName = 'utility';else if (!auxData.name) worldName = 'main';
     const context = new dom.FrameExecutionContext(delegate, frame, worldName);
     context[contextDelegateSymbol] = delegate;
-    frame._contextCreated(worldName, context);
+    if (worldName) frame._contextCreated(worldName, context);
     this._contextIdToContext.set(executionContextId, context);
   }
   _onExecutionContextDestroyed(payload) {
@@ -360,6 +360,9 @@ class FFPage {
     });
     return success;
   }
+  async requestGC() {
+    await this._session.send('Heap.collectGarbage');
+  }
   async addInitScript(initScript, worldName) {
     this._initScripts.push({
       initScript,

package/lib/server/firefox/firefox.js

@@ -92,19 +92,8 @@ class Firefox extends _browserType.BrowserType {
   }
 }
 exports.Firefox = Firefox;
-class JugglerReadyState {
-  constructor() {
-    this._jugglerPromise = new _utils.ManualPromise();
-  }
+class JugglerReadyState extends _browserType.BrowserReadyState {
   onBrowserOutput(message) {
-    if (message.includes('Juggler listening to the pipe')) this._jugglerPromise.resolve();
-  }
-  onBrowserExit() {
-    // Unblock launch when browser prematurely exits.
-    this._jugglerPromise.resolve();
-  }
-  async waitUntilReady() {
-    await this._jugglerPromise;
-    return {};
+    if (message.includes('Juggler listening to the pipe')) this._wsEndpoint.resolve(undefined);
   }
 }

package/lib/server/frameSelectors.js

@@ -165,7 +165,7 @@ class FrameSelectors {
 exports.FrameSelectors = FrameSelectors;
 async function adoptIfNeeded(handle, context) {
   if (handle._context === context) return handle;
-  const adopted = handle._page._delegate.adoptElementHandle(handle, context);
+  const adopted = await handle._page._delegate.adoptElementHandle(handle, context);
   handle.dispose();
   return adopted;
 }

package/lib/server/frames.js

@@ -22,7 +22,6 @@ var _selectorParser = require("../utils/isomorphic/selectorParser");
 var _frameSelectors = require("./frameSelectors");
 var _errors = require("./errors");
 var _fileUploadUtils = require("./fileUploadUtils");
-var _crExecutionContext = require("./chromium/crExecutionContext");
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 /**
@@ -61,7 +60,6 @@ class FrameManager {
     this._webSockets = new Map();
     this._openedDialogs = new Set();
     this._closeAllOpeningDialogs = false;
-    this._isolatedContext = undefined;
     this._page = page;
     this._mainFrame = undefined;
   }
@@ -197,6 +195,11 @@ class FrameManager {
   frameCommittedSameDocumentNavigation(frameId, url) {
     const frame = this._frames.get(frameId);
     if (!frame) return;
+    const pending = frame.pendingDocument();
+    if (pending && pending.documentId === undefined && pending.request === undefined) {
+      // WebKit has notified about the same-document navigation being requested, so clear it.
+      frame.setPendingDocument(undefined);
+    }
     frame._url = url;
     const navigationEvent = {
       url,
@@ -429,7 +432,8 @@ class Frame extends _instrumentation.SdkObject {
     if (this._inflightRequests.size === 0) this._startNetworkIdleTimer();
     this._page.mainFrame()._recalculateNetworkIdle(this);
     this._onLifecycleEvent('commit');
-    this._isolatedContext = undefined;
+    const crSession = (this._page._delegate._sessions.get(this._id) || this._page._delegate._mainFrameSession)._client;
+    crSession.emit('Runtime.executionContextsCleared');
   }
   setPendingDocument(documentInfo) {
     this._pendingDocument = documentInfo;
@@ -584,43 +588,29 @@ class Frame extends _instrumentation.SdkObject {
   async frameElement() {
     return this._page._delegate.getFrameElement(this);
   }
-  _context(world) {
-    if (process.env['REBROWSER_PATCHES_RUNTIME_FIX_MODE'] !== '0') {
-      // rebrowser-patches: use only utility context, create it on demand and cache
-      if (this._isolatedContext !== undefined) {
-        return Promise.resolve(this._isolatedContext);
-      }
-      const utilityWorldName = process.env['REBROWSER_PATCHES_UTILITY_WORLD_NAME'] !== '0' ? process.env['REBROWSER_PATCHES_UTILITY_WORLD_NAME'] || 'util' : '__playwright_utility_world__';
-      return this._page._delegate._mainFrameSession._client.send('Page.createIsolatedWorld', {
-        frameId: this._id,
-        grantUniveralAccess: true,
-        worldName: utilityWorldName
-      }).then(createIsolatedWorldResult => {
-        const contextPayload = {
-          id: createIsolatedWorldResult.executionContextId,
-          name: utilityWorldName,
-          auxData: {
-            frameId: this._id,
-            isDefault: false
-          }
-        };
-        const delegate = new _crExecutionContext.CRExecutionContext(this._page._delegate._mainFrameSession._client, contextPayload);
-        this._isolatedContext = new dom.FrameExecutionContext(delegate, this, 'utility');
-        return this._isolatedContext;
-      }).catch(error => {
-        if (error.message.includes('No frame for given id found')) {
-          // ignore, frame is already gone
-          return {
-            destroyedReason: 'Frame was detached'
-          };
-        }
-        _debugLogger.debugLogger.log('error', error);
-        console.error('[rebrowser-patches][frames._context] cannot create utility world, error:', error);
+  _context(world, useContextPromise = false) {
+    if (process.env['REBROWSER_PATCHES_RUNTIME_FIX_MODE'] === '0' || this._contextData.get(world).context || useContextPromise) {
+      return this._contextData.get(world).contextPromise.then(contextOrDestroyedReason => {
+        if (contextOrDestroyedReason instanceof js.ExecutionContext) return contextOrDestroyedReason;
+        throw new Error(contextOrDestroyedReason.destroyedReason);
       });
     }
-    return this._contextData.get(world).contextPromise.then(contextOrDestroyedReason => {
-      if (contextOrDestroyedReason instanceof js.ExecutionContext) return contextOrDestroyedReason;
-      throw new Error(contextOrDestroyedReason.destroyedReason);
+    const crSession = (this._page._delegate._sessions.get(this._id) || this._page._delegate._mainFrameSession)._client;
+    return crSession.__re__emitExecutionContext({
+      world,
+      targetId: this._id,
+      frame: this
+    }).then(() => {
+      return this._context(world, true);
+    }).catch(error => {
+      if (error.message.includes('No frame for given id found')) {
+        // ignore, frame is already gone
+        return {
+          destroyedReason: 'Frame was detached'
+        };
+      }
+      _debugLogger.debugLogger.log('error', error);
+      console.error('[rebrowser-patches][frames._context] cannot get world, error:', error);
     });
   }
   _mainContext() {
@@ -659,14 +649,15 @@ class Frame extends _instrumentation.SdkObject {
     if (!['attached', 'detached', 'visible', 'hidden'].includes(state)) throw new Error(`state: expected one of (attached|detached|visible|hidden)`);
     return controller.run(async progress => {
       progress.log(`waiting for ${this._asLocator(selector)}${state === 'attached' ? '' : ' to be ' + state}`);
-      return await this.waitForSelectorInternal(progress, selector, options, scope);
+      return await this.waitForSelectorInternal(progress, selector, true, options, scope);
     }, this._page._timeoutSettings.timeout(options));
   }
-  async waitForSelectorInternal(progress, selector, options, scope) {
+  async waitForSelectorInternal(progress, selector, performActionPreChecks, options, scope) {
     const {
       state = 'visible'
     } = options;
     const promise = this.retryWithProgressAndTimeouts(progress, [0, 20, 50, 100, 100, 500], async continuePolling => {
+      if (performActionPreChecks) await this._page.performActionPreChecks(progress);
       const resolved = await this.selectors.resolveInjectedForSelector(selector, options, scope);
       progress.throwIfAborted();
       if (!resolved) {
@@ -677,6 +668,7 @@ class Frame extends _instrumentation.SdkObject {
         info,
         root
       }) => {
+        if (root && !root.isConnected) throw injected.createStacklessError('Element is not attached to the DOM');
         const elements = injected.querySelectorAll(info.parsed, root || document);
         const element = elements[0];
         const visible = element ? injected.utils.isElementVisible(element) : false;
@@ -800,11 +792,10 @@ class Frame extends _instrumentation.SdkObject {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
       await this.raceNavigationAction(progress, options, async () => {
-        var _this$_page$_delegate, _this$_page$_delegate2;
         const waitUntil = options.waitUntil === undefined ? 'load' : options.waitUntil;
         progress.log(`setting frame content, waiting until "${waitUntil}"`);
         const tag = `--playwright--set--content--${this._id}--${++this._setContentCounter}--`;
-        const context = (_this$_page$_delegate = (_this$_page$_delegate2 = this._page._delegate).useMainWorldForSetContent) !== null && _this$_page$_delegate !== void 0 && _this$_page$_delegate.call(_this$_page$_delegate2) ? await this._mainContext() : await this._utilityContext();
+        const context = await this._utilityContext();
         const lifecyclePromise = new Promise((resolve, reject) => {
           this._page._frameManager._consoleMessageTags.set(tag, () => {
             // Clear lifecycle right after document.open() - see 'tag' below.
@@ -983,19 +974,21 @@ class Frame extends _instrumentation.SdkObject {
     // Retry upon all other errors.
     return false;
   }
-  async _retryWithProgressIfNotConnected(progress, selector, strict, performLocatorHandlersCheckpoint, action) {
+  async _retryWithProgressIfNotConnected(progress, selector, strict, performActionPreChecks, action) {
     progress.log(`waiting for ${this._asLocator(selector)}`);
     return this.retryWithProgressAndTimeouts(progress, [0, 20, 50, 100, 100, 500], async continuePolling => {
-      if (performLocatorHandlersCheckpoint) await this._page.performLocatorHandlersCheckpoint(progress);
+      if (performActionPreChecks) await this._page.performActionPreChecks(progress);
       const resolved = await this.selectors.resolveInjectedForSelector(selector, {
         strict
       });
       progress.throwIfAborted();
       if (!resolved) return continuePolling;
       const result = await resolved.injected.evaluateHandle((injected, {
-        info
+        info,
+        callId
       }) => {
         const elements = injected.querySelectorAll(info.parsed, document);
+        if (callId) injected.markTargetElements(new Set(elements), callId);
         const element = elements[0];
         let log = '';
         if (elements.length > 1) {
@@ -1010,7 +1003,8 @@ class Frame extends _instrumentation.SdkObject {
           element
         };
       }, {
-        info: resolved.info
+        info: resolved.info,
+        callId: progress.metadata.id
       });
       const {
         log,
@@ -1039,7 +1033,7 @@ class Frame extends _instrumentation.SdkObject {
     });
   }
   async rafrafTimeoutScreenshotElementWithProgress(progress, selector, timeout, options) {
-    return await this._retryWithProgressIfNotConnected(progress, selector, true /* strict */, true /* performLocatorHandlersCheckpoint */, async handle => {
+    return await this._retryWithProgressIfNotConnected(progress, selector, true /* strict */, true /* performActionPreChecks */, async handle => {
       await handle._frame.rafrafTimeout(timeout);
       return await this._page._screenshotter.screenshotElement(progress, handle, options);
     });
@@ -1047,7 +1041,7 @@ class Frame extends _instrumentation.SdkObject {
   async click(metadata, selector, options) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performLocatorHandlersCheckpoint */, handle => handle._click(progress, {
+      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performActionPreChecks */, handle => handle._click(progress, {
         ...options,
         waitAfter: !options.noWaitAfter
       })));
@@ -1056,13 +1050,13 @@ class Frame extends _instrumentation.SdkObject {
   async dblclick(metadata, selector, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performLocatorHandlersCheckpoint */, handle => handle._dblclick(progress, options)));
+      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performActionPreChecks */, handle => handle._dblclick(progress, options)));
     }, this._page._timeoutSettings.timeout(options));
   }
   async dragAndDrop(metadata, source, target, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     await controller.run(async progress => {
-      dom.assertDone(await this._retryWithProgressIfNotConnected(progress, source, options.strict, !options.force /* performLocatorHandlersCheckpoint */, async handle => {
+      dom.assertDone(await this._retryWithProgressIfNotConnected(progress, source, options.strict, !options.force /* performActionPreChecks */, async handle => {
         return handle._retryPointerAction(progress, 'move and down', false, async point => {
           await this._page.mouse.move(point.x, point.y);
           await this._page.mouse.down();
@@ -1074,7 +1068,7 @@ class Frame extends _instrumentation.SdkObject {
         });
       }));
       // Note: do not perform locator handlers checkpoint to avoid moving the mouse in the middle of a drag operation.
-      dom.assertDone(await this._retryWithProgressIfNotConnected(progress, target, options.strict, false /* performLocatorHandlersCheckpoint */, async handle => {
+      dom.assertDone(await this._retryWithProgressIfNotConnected(progress, target, options.strict, false /* performActionPreChecks */, async handle => {
         return handle._retryPointerAction(progress, 'move and up', false, async point => {
           await this._page.mouse.move(point.x, point.y);
           await this._page.mouse.up();
@@ -1091,25 +1085,25 @@ class Frame extends _instrumentation.SdkObject {
     if (!this._page._browserContext._options.hasTouch) throw new Error('The page does not support tap. Use hasTouch context option to enable touch support.');
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performLocatorHandlersCheckpoint */, handle => handle._tap(progress, options)));
+      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performActionPreChecks */, handle => handle._tap(progress, options)));
     }, this._page._timeoutSettings.timeout(options));
   }
   async fill(metadata, selector, value, options) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performLocatorHandlersCheckpoint */, handle => handle._fill(progress, value, options)));
+      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performActionPreChecks */, handle => handle._fill(progress, value, options)));
     }, this._page._timeoutSettings.timeout(options));
   }
   async focus(metadata, selector, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     await controller.run(async progress => {
-      dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true /* performLocatorHandlersCheckpoint */, handle => handle._focus(progress)));
+      dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true /* performActionPreChecks */, handle => handle._focus(progress)));
     }, this._page._timeoutSettings.timeout(options));
   }
   async blur(metadata, selector, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     await controller.run(async progress => {
-      dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true /* performLocatorHandlersCheckpoint */, handle => handle._blur(progress)));
+      dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true /* performActionPreChecks */, handle => handle._blur(progress)));
     }, this._page._timeoutSettings.timeout(options));
   }
   async textContent(metadata, selector, options = {}, scope) {
@@ -1209,44 +1203,44 @@ class Frame extends _instrumentation.SdkObject {
   async hover(metadata, selector, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performLocatorHandlersCheckpoint */, handle => handle._hover(progress, options)));
+      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performActionPreChecks */, handle => handle._hover(progress, options)));
     }, this._page._timeoutSettings.timeout(options));
   }
   async selectOption(metadata, selector, elements, values, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      return await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performLocatorHandlersCheckpoint */, handle => handle._selectOption(progress, elements, values, options));
+      return await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performActionPreChecks */, handle => handle._selectOption(progress, elements, values, options));
     }, this._page._timeoutSettings.timeout(options));
   }
   async setInputFiles(metadata, selector, params) {
     const inputFileItems = await (0, _fileUploadUtils.prepareFilesForUpload)(this, params);
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, params.strict, true /* performLocatorHandlersCheckpoint */, handle => handle._setInputFiles(progress, inputFileItems)));
+      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, params.strict, true /* performActionPreChecks */, handle => handle._setInputFiles(progress, inputFileItems)));
     }, this._page._timeoutSettings.timeout(params));
   }
   async type(metadata, selector, text, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true /* performLocatorHandlersCheckpoint */, handle => handle._type(progress, text, options)));
+      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true /* performActionPreChecks */, handle => handle._type(progress, text, options)));
     }, this._page._timeoutSettings.timeout(options));
   }
   async press(metadata, selector, key, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true /* performLocatorHandlersCheckpoint */, handle => handle._press(progress, key, options)));
+      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true /* performActionPreChecks */, handle => handle._press(progress, key, options)));
     }, this._page._timeoutSettings.timeout(options));
   }
   async check(metadata, selector, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performLocatorHandlersCheckpoint */, handle => handle._setChecked(progress, true, options)));
+      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performActionPreChecks */, handle => handle._setChecked(progress, true, options)));
     }, this._page._timeoutSettings.timeout(options));
   }
   async uncheck(metadata, selector, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performLocatorHandlersCheckpoint */, handle => handle._setChecked(progress, false, options)));
+      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performActionPreChecks */, handle => handle._setChecked(progress, false, options)));
     }, this._page._timeoutSettings.timeout(options));
   }
   async waitForTimeout(metadata, timeout) {
@@ -1255,6 +1249,12 @@ class Frame extends _instrumentation.SdkObject {
       await new Promise(resolve => setTimeout(resolve, timeout));
     });
   }
+  async ariaSnapshot(metadata, selector, options = {}) {
+    const controller = new _progress.ProgressController(metadata, this);
+    return controller.run(async progress => {
+      return await this._retryWithProgressIfNotConnected(progress, selector, true /* strict */, true /* performActionPreChecks */, handle => handle.ariaSnapshot());
+    }, this._page._timeoutSettings.timeout(options));
+  }
   async expect(metadata, selector, options) {
     const result = await this._expectImpl(metadata, selector, options);
     // Library mode special case for the expect errors which are return values, not exceptions.
@@ -1278,7 +1278,7 @@ class Frame extends _instrumentation.SdkObject {
       await new _progress.ProgressController(metadata, this).run(async progress => {
         progress.log(`${metadata.apiName}${timeout ? ` with timeout ${timeout}ms` : ''}`);
         progress.log(`waiting for ${this._asLocator(selector)}`);
-        await this._page.performLocatorHandlersCheckpoint(progress);
+        await this._page.performActionPreChecks(progress);
       }, timeout);
 
       // Step 2: perform one-shot expect check without a timeout.
@@ -1299,7 +1299,7 @@ class Frame extends _instrumentation.SdkObject {
       }
       if (timeout < 0) return {
         matches: options.isNot,
-        log: metadata.log,
+        log: (0, _utils.compressCallLog)(metadata.log),
         timedOut: true,
         received: lastIntermediateResult.received
       };
@@ -1307,7 +1307,7 @@ class Frame extends _instrumentation.SdkObject {
       // Step 3: auto-retry expect with increasing timeouts. Bounded by the total remaining time.
       return await new _progress.ProgressController(metadata, this).run(async progress => {
         return await this.retryWithProgressAndTimeouts(progress, [100, 250, 500, 1000], async continuePolling => {
-          await this._page.performLocatorHandlersCheckpoint(progress);
+          await this._page.performActionPreChecks(progress);
           const {
             matches,
             received
@@ -1330,7 +1330,7 @@ class Frame extends _instrumentation.SdkObject {
       if (js.isJavaScriptErrorInEvaluate(e) || (0, _selectorParser.isInvalidSelectorError)(e)) throw e;
       const result = {
         matches: options.isNot,
-        log: metadata.log
+        log: (0, _utils.compressCallLog)(metadata.log)
       };
       if (lastIntermediateResult.isSet) result.received = lastIntermediateResult.received;
       if (e instanceof _errors.TimeoutError) result.timedOut = true;
@@ -1365,10 +1365,10 @@ class Frame extends _instrumentation.SdkObject {
       callId
     }) => {
       const elements = info ? injected.querySelectorAll(info.parsed, document) : [];
+      if (callId) injected.markTargetElements(new Set(elements), callId);
       const isArray = options.expression === 'to.have.count' || options.expression.endsWith('.array');
       let log = '';
       if (isArray) log = `  locator resolved to ${elements.length} element${elements.length === 1 ? '' : 's'}`;else if (elements.length > 1) throw injected.strictModeViolationError(info.parsed, elements);else if (elements.length) log = `  locator resolved to ${injected.previewNode(elements[0])}`;
-      if (callId) injected.markTargetElements(new Set(elements), callId);
       return {
         log,
         ...(await injected.expect(elements[0], options, elements))
@@ -1686,5 +1686,6 @@ function renderUnexpectedValue(expression, received) {
   if (expression === 'to.be.readonly') return received ? 'readonly' : 'editable';
   if (expression === 'to.be.empty') return received ? 'empty' : 'not empty';
   if (expression === 'to.be.focused') return received ? 'focused' : 'not focused';
+  if (expression === 'to.match.aria') return received ? received.raw : received;
   return received;
 }

package/lib/server/har/harTracer.js

@@ -156,12 +156,22 @@ class HarTracer {
     if (this._started) this._delegate.onEntryStarted(harEntry);
   }
   _onAPIRequestFinished(event) {
+    var _event$body$length, _event$body;
     const harEntry = this._entryForRequest(event.requestEvent);
     if (!harEntry) return;
     harEntry.response.status = event.statusCode;
     harEntry.response.statusText = event.statusMessage;
     harEntry.response.httpVersion = event.httpVersion;
     harEntry.response.redirectURL = event.headers.location || '';
+    if (!this._options.omitServerIP) {
+      harEntry.serverIPAddress = event.serverIPAddress;
+      harEntry._serverPort = event.serverPort;
+    }
+    if (!this._options.omitTiming) {
+      harEntry.timings = event.timings;
+      this._computeHarEntryTotalTime(harEntry);
+    }
+    if (!this._options.omitSecurityDetails) harEntry._securityDetails = event.securityDetails;
     for (let i = 0; i < event.rawHeaders.length; i += 2) {
       harEntry.response.headers.push({
         name: event.rawHeaders[i],
@@ -178,6 +188,7 @@ class HarTracer {
     const contentType = event.headers['content-type'];
     if (contentType) content.mimeType = contentType;
     this._storeResponseContent(event.body, content, 'other');
+    if (!this._options.omitSizes) harEntry.response.bodySize = (_event$body$length = (_event$body = event.body) === null || _event$body === void 0 ? void 0 : _event$body.length) !== null && _event$body$length !== void 0 ? _event$body$length : 0;
     if (this._started) this._delegate.onEntryFinished(harEntry);
   }
   _onRequest(request) {

package/lib/server/index.js

@@ -45,12 +45,6 @@ Object.defineProperty(exports, "installBrowsersForNpmInstall", {
     return _registry.installBrowsersForNpmInstall;
   }
 });
-Object.defineProperty(exports, "installDefaultBrowsersForNpmInstall", {
-  enumerable: true,
-  get: function () {
-    return _registry.installDefaultBrowsersForNpmInstall;
-  }
-});
 Object.defineProperty(exports, "installRootRedirect", {
   enumerable: true,
   get: function () {

package/lib/server/input.js

@@ -189,7 +189,6 @@ class Mouse {
       x,
       y
     };
-    if (this._raw.click) return await this._raw.click(x, y, options);
     const {
       delay = null,
       clickCount = 1

package/lib/server/javascript.js

@@ -55,9 +55,6 @@ class ExecutionContext extends _instrumentation.SdkObject {
   rawEvaluateHandle(expression) {
     return this._raceAgainstContextDestroyed(this._delegate.rawEvaluateHandle(expression));
   }
-  rawCallFunctionNoReply(func, ...args) {
-    this._delegate.rawCallFunctionNoReply(func, ...args);
-  }
   evaluateWithArguments(expression, returnByValue, utilityScript, values, objectIds) {
     return this._raceAgainstContextDestroyed(this._delegate.evaluateWithArguments(expression, returnByValue, utilityScript, values, objectIds));
   }
@@ -85,9 +82,6 @@ class ExecutionContext extends _instrumentation.SdkObject {
     }
     return this._utilityScriptPromise;
   }
-  async objectCount(objectId) {
-    return this._delegate.objectCount(objectId);
-  }
   async doSlowMo() {
     // overridden in FrameExecutionContext
   }
@@ -111,9 +105,6 @@ class JSHandle extends _instrumentation.SdkObject {
     this._preview = this._objectId ? preview || `JSHandle@${this._objectType}` : String(value);
     if (this._objectId && globalThis.leakedJSHandles) globalThis.leakedJSHandles.set(this, new Error('Leaked JSHandle'));
   }
-  callFunctionNoReply(func, arg) {
-    this._context.rawCallFunctionNoReply(func, this, arg);
-  }
   async evaluate(pageFunction, arg) {
     return evaluate(this._context, true /* returnByValue */, pageFunction, this, arg);
   }
@@ -189,10 +180,6 @@ class JSHandle extends _instrumentation.SdkObject {
     this._preview = preview;
     if (this._previewCallback) this._previewCallback(preview);
   }
-  async objectCount() {
-    if (!this._objectId) throw new Error('Can only count objects for a handle that points to the constructor prototype');
-    return this._context.objectCount(this._objectId);
-  }
 }
 exports.JSHandle = JSHandle;
 async function evaluate(context, returnByValue, pageFunction, ...args) {