rebrowser-playwright-core 1.47.100 → 1.49.0

package/lib/server/dom.js

@@ -225,17 +225,21 @@ class ElementHandle extends js.JSHandle {
     // Allow 1x1 elements. Compensate for rounding errors by comparing with 0.99 instead.
     const filtered = quads.map(quad => intersectQuadWithViewport(quad)).filter(quad => computeQuadArea(quad) > 0.99);
     if (!filtered.length) return 'error:notinviewport';
-    // Return the middle point of the first quad.
-    const result = {
-      x: 0,
-      y: 0
-    };
-    for (const point of filtered[0]) {
-      result.x += point.x / 4;
-      result.y += point.y / 4;
+    if (this._page._browserContext._browser.options.name === 'firefox') {
+      // Firefox internally uses integer coordinates, so 8.x is converted to 8 or 9 when clicking.
+      //
+      // This does not work nicely for small elements. For example, 1x1 square with corners
+      // (8;8) and (9;9) is targeted when clicking at (8;8) but not when clicking at (9;9).
+      // So, clicking at (8.x;8.y) will sometimes click at (9;9) and miss the target.
+      //
+      // Therefore, we try to find an integer point within a quad to make sure we click inside the element.
+      for (const quad of filtered) {
+        const integerPoint = findIntegerPointInsideQuad(quad);
+        if (integerPoint) return integerPoint;
+      }
     }
-    compensateHalfIntegerRoundingError(result);
-    return result;
+    // Return the middle point of the first quad.
+    return quadMiddlePoint(filtered[0]);
   }
   async _offsetPoint(offset) {
     const [box, border] = await Promise.all([this.boundingBox(), this.evaluateInUtility(([injected, node]) => injected.getElementBorderWidth(node), {}).catch(e => {})]);
@@ -253,7 +257,7 @@ class ElementHandle extends js.JSHandle {
     const waitTime = [0, 20, 100, 100, 500];
     while (progress.isRunning()) {
       if (retry) {
-        progress.log(`retrying ${actionName} action${options.trial ? ' (trial run)' : ''}, attempt #${retry}`);
+        progress.log(`retrying ${actionName} action${options.trial ? ' (trial run)' : ''}`);
         const timeout = waitTime[Math.min(retry - 1, waitTime.length - 1)];
         if (timeout) {
           progress.log(`  waiting ${timeout}ms`);
@@ -263,7 +267,7 @@ class ElementHandle extends js.JSHandle {
       } else {
         progress.log(`attempting ${actionName} action${options.trial ? ' (trial run)' : ''}`);
       }
-      if (!options.skipLocatorHandlersCheckpoint && !options.force) await this._frame._page.performLocatorHandlersCheckpoint(progress);
+      if (!options.skipActionPreChecks && !options.force) await this._frame._page.performActionPreChecks(progress);
       const result = await action(retry);
       ++retry;
       if (result === 'error:notvisible') {
@@ -294,7 +298,7 @@ class ElementHandle extends js.JSHandle {
   }
   async _retryPointerAction(progress, actionName, waitForEnabled, action, options) {
     // Note: do not perform locator handlers checkpoint to avoid moving the mouse in the middle of a drag operation.
-    const skipLocatorHandlersCheckpoint = actionName === 'move and up';
+    const skipActionPreChecks = actionName === 'move and up';
     return await this._retryAction(progress, actionName, async retry => {
       // By default, we scroll with protocol method to reveal the action point.
       // However, that might not work to scroll from under position:sticky elements
@@ -314,7 +318,7 @@ class ElementHandle extends js.JSHandle {
       return await this._performPointerAction(progress, actionName, waitForEnabled, action, forceScrollOptions, options);
     }, {
       ...options,
-      skipLocatorHandlersCheckpoint
+      skipActionPreChecks
     });
   }
   async _performPointerAction(progress, actionName, waitForEnabled, action, forceScrollOptions, options) {
@@ -367,7 +371,7 @@ class ElementHandle extends js.JSHandle {
     if (typeof maybePoint === 'string') return maybePoint;
     const point = roundPoint(maybePoint);
     progress.metadata.point = point;
-    await progress.beforeInputAction(this);
+    await this.instrumentation.onBeforeInputAction(this, progress.metadata);
     let hitTargetInterceptionHandle;
     if (force) {
       progress.log(`  forcing action`);
@@ -433,9 +437,16 @@ class ElementHandle extends js.JSHandle {
     progress.log('  navigations have finished');
     return 'done';
   }
+  async _markAsTargetElement(metadata) {
+    if (!metadata.id) return;
+    await this.evaluateInUtility(([injected, node, callId]) => {
+      if (node.nodeType === 1 /* Node.ELEMENT_NODE */) injected.markTargetElements(new Set([node]), callId);
+    }, metadata.id);
+  }
   async hover(metadata, options) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
+      await this._markAsTargetElement(metadata);
       const result = await this._hover(progress, options);
       return assertDone(throwRetargetableDOMError(result));
     }, this._page._timeoutSettings.timeout(options));
@@ -449,6 +460,7 @@ class ElementHandle extends js.JSHandle {
   async click(metadata, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
+      await this._markAsTargetElement(metadata);
       const result = await this._click(progress, {
         ...options,
         waitAfter: !options.noWaitAfter
@@ -462,6 +474,7 @@ class ElementHandle extends js.JSHandle {
   async dblclick(metadata, options) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
+      await this._markAsTargetElement(metadata);
       const result = await this._dblclick(progress, options);
       return assertDone(throwRetargetableDOMError(result));
     }, this._page._timeoutSettings.timeout(options));
@@ -475,6 +488,7 @@ class ElementHandle extends js.JSHandle {
   async tap(metadata, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
+      await this._markAsTargetElement(metadata);
       const result = await this._tap(progress, options);
       return assertDone(throwRetargetableDOMError(result));
     }, this._page._timeoutSettings.timeout(options));
@@ -488,6 +502,7 @@ class ElementHandle extends js.JSHandle {
   async selectOption(metadata, elements, values, options) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
+      await this._markAsTargetElement(metadata);
       const result = await this._selectOption(progress, elements, values, options);
       return throwRetargetableDOMError(result);
     }, this._page._timeoutSettings.timeout(options));
@@ -495,7 +510,7 @@ class ElementHandle extends js.JSHandle {
   async _selectOption(progress, elements, values, options) {
     let resultingOptions = [];
     await this._retryAction(progress, 'select option', async () => {
-      await progress.beforeInputAction(this);
+      await this.instrumentation.onBeforeInputAction(this, progress.metadata);
       if (!options.force) progress.log(`  waiting for element to be visible and enabled`);
       const optionsToSelect = [...elements, ...values];
       const result = await this.evaluateInUtility(async ([injected, node, {
@@ -523,6 +538,7 @@ class ElementHandle extends js.JSHandle {
   async fill(metadata, value, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
+      await this._markAsTargetElement(metadata);
       const result = await this._fill(progress, value, options);
       assertDone(throwRetargetableDOMError(result));
     }, this._page._timeoutSettings.timeout(options));
@@ -530,7 +546,7 @@ class ElementHandle extends js.JSHandle {
   async _fill(progress, value, options) {
     progress.log(`  fill("${value}")`);
     return await this._retryAction(progress, 'fill', async () => {
-      await progress.beforeInputAction(this);
+      await this.instrumentation.onBeforeInputAction(this, progress.metadata);
       if (!options.force) progress.log('  waiting for element to be visible, enabled and editable');
       const result = await this.evaluateInUtility(async ([injected, node, {
         value,
@@ -578,6 +594,7 @@ class ElementHandle extends js.JSHandle {
     const inputFileItems = await (0, _fileUploadUtils.prepareFilesForUpload)(this._frame, params);
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
+      await this._markAsTargetElement(metadata);
       const result = await this._setInputFiles(progress, inputFileItems);
       return assertDone(throwRetargetableDOMError(result));
     }, this._page._timeoutSettings.timeout(params));
@@ -607,7 +624,7 @@ class ElementHandle extends js.JSHandle {
     });
     if (result === 'error:notconnected' || !result.asElement()) return 'error:notconnected';
     const retargeted = result.asElement();
-    await progress.beforeInputAction(this);
+    await this.instrumentation.onBeforeInputAction(this, progress.metadata);
     progress.throwIfAborted(); // Avoid action that has side-effects.
     if (localPaths || localDirectory) {
       const localPathsOrDirectory = localDirectory ? [localDirectory] : localPaths;
@@ -628,6 +645,7 @@ class ElementHandle extends js.JSHandle {
   async focus(metadata) {
     const controller = new _progress.ProgressController(metadata, this);
     await controller.run(async progress => {
+      await this._markAsTargetElement(metadata);
       const result = await this._focus(progress);
       return assertDone(throwRetargetableDOMError(result));
     }, 0);
@@ -643,13 +661,14 @@ class ElementHandle extends js.JSHandle {
   async type(metadata, text, options) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
+      await this._markAsTargetElement(metadata);
       const result = await this._type(progress, text, options);
       return assertDone(throwRetargetableDOMError(result));
     }, this._page._timeoutSettings.timeout(options));
   }
   async _type(progress, text, options) {
     progress.log(`elementHandle.type("${text}")`);
-    await progress.beforeInputAction(this);
+    await this.instrumentation.onBeforeInputAction(this, progress.metadata);
     const result = await this._focus(progress, true /* resetSelectionIfNotFocused */);
     if (result !== 'done') return result;
     progress.throwIfAborted(); // Avoid action that has side-effects.
@@ -659,13 +678,14 @@ class ElementHandle extends js.JSHandle {
   async press(metadata, key, options) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
+      await this._markAsTargetElement(metadata);
       const result = await this._press(progress, key, options);
       return assertDone(throwRetargetableDOMError(result));
     }, this._page._timeoutSettings.timeout(options));
   }
   async _press(progress, key, options) {
     progress.log(`elementHandle.press("${key}")`);
-    await progress.beforeInputAction(this);
+    await this.instrumentation.onBeforeInputAction(this, progress.metadata);
     return this._page._frameManager.waitForSignalsCreatedBy(progress, !options.noWaitAfter, async () => {
       const result = await this._focus(progress, true /* resetSelectionIfNotFocused */);
       if (result !== 'done') return result;
@@ -693,6 +713,7 @@ class ElementHandle extends js.JSHandle {
       const result = await this.evaluateInUtility(([injected, node]) => injected.elementState(node, 'checked'), {});
       return throwRetargetableDOMError(result);
     };
+    await this._markAsTargetElement(progress.metadata);
     if ((await isChecked()) === state) return 'done';
     const result = await this._click(progress, {
       ...options,
@@ -706,6 +727,9 @@ class ElementHandle extends js.JSHandle {
   async boundingBox() {
     return this._page._delegate.getBoundingBox(this);
   }
+  async ariaSnapshot() {
+    return await this.evaluateInUtility(([injected, element]) => injected.ariaSnapshot(element), {});
+  }
   async screenshot(metadata, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(progress => this._page._screenshotter.screenshotElement(progress, this, options), this._page._timeoutSettings.timeout(options));
@@ -825,21 +849,40 @@ function roundPoint(point) {
     y: (point.y * 100 | 0) / 100
   };
 }
-function compensateHalfIntegerRoundingError(point) {
-  // Firefox internally uses integer coordinates, so 8.5 is converted to 9 when clicking.
-  //
-  // This does not work nicely for small elements. For example, 1x1 square with corners
-  // (8;8) and (9;9) is targeted when clicking at (8;8) but not when clicking at (9;9).
-  // So, clicking at (8.5;8.5) will effectively click at (9;9) and miss the target.
-  //
-  // Therefore, we skew half-integer values from the interval (8.49, 8.51) towards
-  // (8.47, 8.49) that is rounded towards 8. This means clicking at (8.5;8.5) will
-  // be replaced with (8.48;8.48) and will effectively click at (8;8).
-  //
-  // Other browsers use float coordinates, so this change should not matter.
-  const remainderX = point.x - Math.floor(point.x);
-  if (remainderX > 0.49 && remainderX < 0.51) point.x -= 0.02;
-  const remainderY = point.y - Math.floor(point.y);
-  if (remainderY > 0.49 && remainderY < 0.51) point.y -= 0.02;
+function quadMiddlePoint(quad) {
+  const result = {
+    x: 0,
+    y: 0
+  };
+  for (const point of quad) {
+    result.x += point.x / 4;
+    result.y += point.y / 4;
+  }
+  return result;
+}
+function triangleArea(p1, p2, p3) {
+  return Math.abs(p1.x * (p2.y - p3.y) + p2.x * (p3.y - p1.y) + p3.x * (p1.y - p2.y)) / 2;
+}
+function isPointInsideQuad(point, quad) {
+  const area1 = triangleArea(point, quad[0], quad[1]) + triangleArea(point, quad[1], quad[2]) + triangleArea(point, quad[2], quad[3]) + triangleArea(point, quad[3], quad[0]);
+  const area2 = triangleArea(quad[0], quad[1], quad[2]) + triangleArea(quad[1], quad[2], quad[3]);
+  // Check that point is inside the quad.
+  if (Math.abs(area1 - area2) > 0.1) return false;
+  // Check that point is not on the right/bottom edge, because clicking
+  // there does not actually click the element.
+  return point.x < Math.max(quad[0].x, quad[1].x, quad[2].x, quad[3].x) && point.y < Math.max(quad[0].y, quad[1].y, quad[2].y, quad[3].y);
+}
+function findIntegerPointInsideQuad(quad) {
+  // Try all four rounding directions of the middle point.
+  const point = quadMiddlePoint(quad);
+  point.x = Math.floor(point.x);
+  point.y = Math.floor(point.y);
+  if (isPointInsideQuad(point, quad)) return point;
+  point.x += 1;
+  if (isPointInsideQuad(point, quad)) return point;
+  point.y += 1;
+  if (isPointInsideQuad(point, quad)) return point;
+  point.x -= 1;
+  if (isPointInsideQuad(point, quad)) return point;
 }
 const kUnableToAdoptErrorMessage = exports.kUnableToAdoptErrorMessage = 'Unable to adopt element handle from a different document';

package/lib/server/download.js

@@ -39,15 +39,22 @@ class Download {
     this.url = url;
     this._suggestedFilename = suggestedFilename;
     page._browserContext._downloads.add(this);
-    if (suggestedFilename !== undefined) this._page.emit(_page.Page.Events.Download, this);
+    if (suggestedFilename !== undefined) this._fireDownloadEvent();
+  }
+  page() {
+    return this._page;
   }
   _filenameSuggested(suggestedFilename) {
     (0, _utils.assert)(this._suggestedFilename === undefined);
     this._suggestedFilename = suggestedFilename;
-    this._page.emit(_page.Page.Events.Download, this);
+    this._fireDownloadEvent();
   }
   suggestedFilename() {
     return this._suggestedFilename;
   }
+  _fireDownloadEvent() {
+    this._page.instrumentation.onDownload(this._page, this);
+    this._page.emit(_page.Page.Events.Download, this);
+  }
 }
 exports.Download = Download;

package/lib/server/fetch.js

@@ -4,10 +4,10 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.GlobalAPIRequestContext = exports.BrowserContextAPIRequestContext = exports.APIRequestContext = void 0;
+exports.createProxyAgent = createProxyAgent;
 var _http = _interopRequireDefault(require("http"));
 var _https = _interopRequireDefault(require("https"));
 var _stream = require("stream");
-var _url = _interopRequireDefault(require("url"));
 var _zlib = _interopRequireDefault(require("zlib"));
 var _timeoutSettings = require("../common/timeoutSettings");
 var _userAgent = require("../utils/userAgent");
@@ -20,8 +20,8 @@ var _happyEyeballs = require("../utils/happy-eyeballs");
 var _instrumentation = require("./instrumentation");
 var _progress = require("./progress");
 var _tracing = require("./trace/recorder/tracing");
-var _network = require("./network");
 var _socksClientCertificatesInterceptor = require("./socksClientCertificatesInterceptor");
+var _tls = require("tls");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 /**
  * Copyright (c) Microsoft Corporation.
@@ -71,7 +71,7 @@ class APIRequestContext extends _instrumentation.SdkObject {
     return uid;
   }
   async fetch(params, metadata) {
-    var _params$method, _defaults$clientCerti;
+    var _params$method;
     const defaults = this._defaultOptions();
     const headers = {
       'user-agent': defaults.userAgent,
@@ -90,8 +90,10 @@ class APIRequestContext extends _instrumentation.SdkObject {
         value
       } of params.headers) setHeader(headers, name, value);
     }
-    const requestUrl = new URL(params.url, defaults.baseURL);
-    if (params.params) {
+    const requestUrl = new URL((0, _utils.constructURLBasedOnBaseURL)(defaults.baseURL, params.url));
+    if (params.encodedParams) {
+      requestUrl.search = params.encodedParams;
+    } else if (params.params) {
       for (const {
         name,
         value
@@ -102,23 +104,9 @@ class APIRequestContext extends _instrumentation.SdkObject {
     const method = ((_params$method = params.method) === null || _params$method === void 0 ? void 0 : _params$method.toUpperCase()) || 'GET';
     const proxy = defaults.proxy;
     let agent;
-    // When `clientCertificates` is present, we set the `proxy` property to our own socks proxy
-    // for the browser to use. However, we don't need it here, because we already respect
-    // `clientCertificates` when fetching from Node.js.
-    if (proxy && !((_defaults$clientCerti = defaults.clientCertificates) !== null && _defaults$clientCerti !== void 0 && _defaults$clientCerti.length) && proxy.server !== 'per-context' && !shouldBypassProxy(requestUrl, proxy.bypass)) {
-      var _proxyOpts$protocol;
-      const proxyOpts = _url.default.parse(proxy.server);
-      if ((_proxyOpts$protocol = proxyOpts.protocol) !== null && _proxyOpts$protocol !== void 0 && _proxyOpts$protocol.startsWith('socks')) {
-        agent = new _utilsBundle.SocksProxyAgent({
-          host: proxyOpts.hostname,
-          port: proxyOpts.port || undefined
-        });
-      } else {
-        if (proxy.username) proxyOpts.auth = `${proxy.username}:${proxy.password || ''}`;
-        // TODO: We should use HttpProxyAgent conditional on proxyOpts.protocol instead of always using CONNECT method.
-        agent = new _utilsBundle.HttpsProxyAgent(proxyOpts);
-      }
-    }
+    // We skip 'per-context' in order to not break existing users. 'per-context' was previously used to
+    // workaround an upstream Chromium bug. Can be removed in the future.
+    if (proxy && proxy.server !== 'per-context' && !shouldBypassProxy(requestUrl, proxy.bypass)) agent = createProxyAgent(proxy);
     const timeout = defaults.timeoutSettings.timeout(params);
     const deadline = timeout && (0, _utils.monotonicTime)() + timeout;
     const options = {
@@ -190,6 +178,7 @@ class APIRequestContext extends _instrumentation.SdkObject {
       try {
         return await this._sendRequest(progress, url, options, postData);
       } catch (e) {
+        e = (0, _socksClientCertificatesInterceptor.rewriteOpenSSLErrorIfNeeded)(e);
         if (maxRetries === 0) throw e;
         if (i === maxRetries || options.deadline && (0, _utils.monotonicTime)() + backoff > options.deadline) throw new Error(`Failed after ${i + 1} attempt(s): ${e}`);
         // Retry on connection reset only.
@@ -227,8 +216,33 @@ class APIRequestContext extends _instrumentation.SdkObject {
         ...options,
         agent
       };
+      const startAt = (0, _utils.monotonicTime)();
+      let reusedSocketAt;
+      let dnsLookupAt;
+      let tcpConnectionAt;
+      let tlsHandshakeAt;
+      let requestFinishAt;
+      let serverIPAddress;
+      let serverPort;
+      let securityDetails;
+      const listeners = [];
       const request = requestConstructor(url, requestOptions, async response => {
+        const responseAt = (0, _utils.monotonicTime)();
         const notifyRequestFinished = body => {
+          var _tlsHandshakeAt;
+          const endAt = (0, _utils.monotonicTime)();
+          // spec: http://www.softwareishard.com/blog/har-12-spec/#timings
+          const connectEnd = (_tlsHandshakeAt = tlsHandshakeAt) !== null && _tlsHandshakeAt !== void 0 ? _tlsHandshakeAt : tcpConnectionAt;
+          const timings = {
+            send: requestFinishAt - startAt,
+            wait: responseAt - requestFinishAt,
+            receive: endAt - responseAt,
+            dns: dnsLookupAt ? dnsLookupAt - startAt : -1,
+            connect: connectEnd ? connectEnd - startAt : -1,
+            // "If [ssl] is defined then the time is also included in the connect field "
+            ssl: tlsHandshakeAt ? tlsHandshakeAt - tcpConnectionAt : -1,
+            blocked: reusedSocketAt ? reusedSocketAt - startAt : -1
+          };
           const requestFinishedEvent = {
             requestEvent,
             httpVersion: response.httpVersion,
@@ -237,7 +251,11 @@ class APIRequestContext extends _instrumentation.SdkObject {
             headers: response.headers,
             rawHeaders: response.rawHeaders,
             cookies,
-            body
+            body,
+            timings,
+            serverIPAddress,
+            serverPort,
+            securityDetails
           };
           this.emit(APIRequestContext.Events.RequestFinished, requestFinishedEvent);
         };
@@ -363,13 +381,59 @@ class APIRequestContext extends _instrumentation.SdkObject {
         body.on('data', chunk => chunks.push(chunk));
         body.on('end', notifyBodyFinished);
       });
-      request.on('error', error => reject((0, _socksClientCertificatesInterceptor.rewriteOpenSSLErrorIfNeeded)(error)));
-      const disposeListener = () => {
+      request.on('error', reject);
+      listeners.push(_utils.eventsHelper.addEventListener(this, APIRequestContext.Events.Dispose, () => {
         reject(new Error('Request context disposed.'));
         request.destroy();
-      };
-      this.on(APIRequestContext.Events.Dispose, disposeListener);
-      request.on('close', () => this.off(APIRequestContext.Events.Dispose, disposeListener));
+      }));
+      request.on('close', () => _utils.eventsHelper.removeEventListeners(listeners));
+      request.on('socket', socket => {
+        var _tcpConnectionAt, _tcpConnectionAt3;
+        if (request.reusedSocket) {
+          reusedSocketAt = (0, _utils.monotonicTime)();
+          return;
+        }
+
+        // happy eyeballs don't emit lookup and connect events, so we use our custom ones
+        const happyEyeBallsTimings = (0, _happyEyeballs.timingForSocket)(socket);
+        dnsLookupAt = happyEyeBallsTimings.dnsLookupAt;
+        (_tcpConnectionAt = tcpConnectionAt) !== null && _tcpConnectionAt !== void 0 ? _tcpConnectionAt : tcpConnectionAt = happyEyeBallsTimings.tcpConnectionAt;
+
+        // non-happy-eyeballs sockets
+        listeners.push(_utils.eventsHelper.addEventListener(socket, 'lookup', () => {
+          dnsLookupAt = (0, _utils.monotonicTime)();
+        }), _utils.eventsHelper.addEventListener(socket, 'connect', () => {
+          var _tcpConnectionAt2;
+          (_tcpConnectionAt2 = tcpConnectionAt) !== null && _tcpConnectionAt2 !== void 0 ? _tcpConnectionAt2 : tcpConnectionAt = (0, _utils.monotonicTime)();
+        }), _utils.eventsHelper.addEventListener(socket, 'secureConnect', () => {
+          tlsHandshakeAt = (0, _utils.monotonicTime)();
+          if (socket instanceof _tls.TLSSocket) {
+            var _socket$getProtocol;
+            const peerCertificate = socket.getPeerCertificate();
+            securityDetails = {
+              protocol: (_socket$getProtocol = socket.getProtocol()) !== null && _socket$getProtocol !== void 0 ? _socket$getProtocol : undefined,
+              subjectName: peerCertificate.subject.CN,
+              validFrom: new Date(peerCertificate.valid_from).getTime() / 1000,
+              validTo: new Date(peerCertificate.valid_to).getTime() / 1000,
+              issuer: peerCertificate.issuer.CN
+            };
+          }
+        }));
+
+        // when using socks proxy, having the socket means the connection got established
+        if (agent instanceof _utilsBundle.SocksProxyAgent) (_tcpConnectionAt3 = tcpConnectionAt) !== null && _tcpConnectionAt3 !== void 0 ? _tcpConnectionAt3 : tcpConnectionAt = (0, _utils.monotonicTime)();
+        serverIPAddress = socket.remoteAddress;
+        serverPort = socket.remotePort;
+      });
+      request.on('finish', () => {
+        requestFinishAt = (0, _utils.monotonicTime)();
+      });
+
+      // http proxy
+      request.on('proxyConnect', () => {
+        var _tcpConnectionAt4;
+        (_tcpConnectionAt4 = tcpConnectionAt) !== null && _tcpConnectionAt4 !== void 0 ? _tcpConnectionAt4 : tcpConnectionAt = (0, _utils.monotonicTime)();
+      });
       progress.log(`→ ${options.method} ${url.toString()}`);
       if (options.headers) {
         for (const [name, value] of Object.entries(options.headers)) progress.log(`  ${name}: ${value}`);
@@ -470,7 +534,6 @@ class GlobalAPIRequestContext extends APIRequestContext {
       let url = proxy === null || proxy === void 0 ? void 0 : proxy.server.trim();
       if (!/^\w+:\/\//.test(url)) url = 'http://' + url;
       proxy.server = url;
-      if (options.clientCertificates) throw new Error('Cannot specify both proxy and clientCertificates');
     }
     if (options.storageState) {
       this._origins = options.storageState.origins;
@@ -515,6 +578,15 @@ class GlobalAPIRequestContext extends APIRequestContext {
   }
 }
 exports.GlobalAPIRequestContext = GlobalAPIRequestContext;
+function createProxyAgent(proxy) {
+  var _proxyURL$protocol;
+  const proxyURL = new URL(proxy.server);
+  if ((_proxyURL$protocol = proxyURL.protocol) !== null && _proxyURL$protocol !== void 0 && _proxyURL$protocol.startsWith('socks')) return new _utilsBundle.SocksProxyAgent(proxyURL);
+  if (proxy.username) proxyURL.username = proxy.username;
+  if (proxy.password) proxyURL.password = proxy.password;
+  // TODO: We should use HttpProxyAgent conditional on proxyURL.protocol instead of always using CONNECT method.
+  return new _utilsBundle.HttpsProxyAgent(proxyURL);
+}
 function toHeadersArray(rawHeaders) {
   const result = [];
   for (let i = 0; i < rawHeaders.length; i += 2) result.push({
@@ -525,26 +597,9 @@ function toHeadersArray(rawHeaders) {
 }
 const redirectStatus = [301, 302, 303, 307, 308];
 function parseCookie(header) {
-  const pairs = header.split(';').filter(s => s.trim().length > 0).map(p => {
-    let key = '';
-    let value = '';
-    const separatorPos = p.indexOf('=');
-    if (separatorPos === -1) {
-      // If only a key is specified, the value is left undefined.
-      key = p.trim();
-    } else {
-      // Otherwise we assume that the key is the element before the first `=`
-      key = p.slice(0, separatorPos).trim();
-      // And the value is the rest of the string.
-      value = p.slice(separatorPos + 1).trim();
-    }
-    return [key, value];
-  });
-  if (!pairs.length) return null;
-  const [name, value] = pairs[0];
+  const raw = (0, _cookieStore.parseRawCookie)(header);
+  if (!raw) return null;
   const cookie = {
-    name,
-    value,
     domain: '',
     path: '',
     expires: -1,
@@ -552,55 +607,9 @@ function parseCookie(header) {
     secure: false,
     // From https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie/SameSite
     // The cookie-sending behavior if SameSite is not specified is SameSite=Lax.
-    sameSite: 'Lax'
+    sameSite: 'Lax',
+    ...raw
   };
-  for (let i = 1; i < pairs.length; i++) {
-    const [name, value] = pairs[i];
-    switch (name.toLowerCase()) {
-      case 'expires':
-        const expiresMs = +new Date(value);
-        // https://datatracker.ietf.org/doc/html/rfc6265#section-5.2.1
-        if (isFinite(expiresMs)) {
-          if (expiresMs <= 0) cookie.expires = 0;else cookie.expires = Math.min(expiresMs / 1000, _network.kMaxCookieExpiresDateInSeconds);
-        }
-        break;
-      case 'max-age':
-        const maxAgeSec = parseInt(value, 10);
-        if (isFinite(maxAgeSec)) {
-          // From https://datatracker.ietf.org/doc/html/rfc6265#section-5.2.2
-          // If delta-seconds is less than or equal to zero (0), let expiry-time
-          // be the earliest representable date and time.
-          if (maxAgeSec <= 0) cookie.expires = 0;else cookie.expires = Math.min(Date.now() / 1000 + maxAgeSec, _network.kMaxCookieExpiresDateInSeconds);
-        }
-        break;
-      case 'domain':
-        cookie.domain = value.toLocaleLowerCase() || '';
-        if (cookie.domain && !cookie.domain.startsWith('.') && cookie.domain.includes('.')) cookie.domain = '.' + cookie.domain;
-        break;
-      case 'path':
-        cookie.path = value || '';
-        break;
-      case 'secure':
-        cookie.secure = true;
-        break;
-      case 'httponly':
-        cookie.httpOnly = true;
-        break;
-      case 'samesite':
-        switch (value.toLowerCase()) {
-          case 'none':
-            cookie.sameSite = 'None';
-            break;
-          case 'lax':
-            cookie.sameSite = 'Lax';
-            break;
-          case 'strict':
-            cookie.sameSite = 'Strict';
-            break;
-        }
-        break;
-    }
-  }
   return cookie;
 }
 function serializePostData(params, headers) {

package/lib/server/firefox/ffBrowser.js

@@ -53,7 +53,8 @@ class FFBrowser extends _browser.Browser {
       browser._defaultContext = new FFBrowserContext(browser, undefined, options.persistent);
       promises.push(browser._defaultContext._initialize());
     }
-    if (options.proxy) promises.push(browser.session.send('Browser.setBrowserProxy', toJugglerProxyOptions(options.proxy)));
+    const proxy = options.originalLaunchOptions.proxyOverride || options.proxy;
+    if (proxy) promises.push(browser.session.send('Browser.setBrowserProxy', toJugglerProxyOptions(proxy)));
     await Promise.all(promises);
     return browser;
   }
@@ -205,7 +206,7 @@ class FFBrowserContext extends _browserContext.BrowserContext {
       browserContextId,
       bypassCSP: true
     }));
-    if (this._options.ignoreHTTPSErrors) promises.push(this._browser.session.send('Browser.setIgnoreHTTPSErrors', {
+    if (this._options.ignoreHTTPSErrors || this._options.internalIgnoreHTTPSErrors) promises.push(this._browser.session.send('Browser.setIgnoreHTTPSErrors', {
       browserContextId,
       ignoreHTTPSErrors: true
     }));
@@ -255,10 +256,11 @@ class FFBrowserContext extends _browserContext.BrowserContext {
         });
       }));
     }
-    if (this._options.proxy) {
+    const proxy = this._options.proxyOverride || this._options.proxy;
+    if (proxy) {
       promises.push(this._browser.session.send('Browser.setContextProxy', {
         browserContextId: this._browserContextId,
-        ...toJugglerProxyOptions(this._options.proxy)
+        ...toJugglerProxyOptions(proxy)
       }));
     }
     await Promise.all(promises);

package/lib/server/firefox/ffExecutionContext.js

@@ -52,18 +52,6 @@ class FFExecutionContext {
     checkException(payload.exceptionDetails);
     return payload.result.objectId;
   }
-  rawCallFunctionNoReply(func, ...args) {
-    this._session.send('Runtime.callFunction', {
-      functionDeclaration: func.toString(),
-      args: args.map(a => a instanceof js.JSHandle ? {
-        objectId: a._objectId
-      } : {
-        value: a
-      }),
-      returnByValue: true,
-      executionContextId: this._executionContextId
-    }).catch(() => {});
-  }
   async evaluateWithArguments(expression, returnByValue, utilityScript, values, objectIds) {
     const payload = await this._session.send('Runtime.callFunction', {
       functionDeclaration: expression,
@@ -101,9 +89,6 @@ class FFExecutionContext {
       objectId
     });
   }
-  objectCount(objectId) {
-    throw new Error('Method not implemented in Firefox.');
-  }
 }
 exports.FFExecutionContext = FFExecutionContext;
 function checkException(exceptionDetails) {