rebrowser-playwright-core 1.49.0 → 1.52.0

package/lib/server/fetch.js

@@ -1,59 +1,80 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var fetch_exports = {};
+__export(fetch_exports, {
+  APIRequestContext: () => APIRequestContext,
+  BrowserContextAPIRequestContext: () => BrowserContextAPIRequestContext,
+  GlobalAPIRequestContext: () => GlobalAPIRequestContext
 });
-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 _zlib = _interopRequireDefault(require("zlib"));
-var _timeoutSettings = require("../common/timeoutSettings");
-var _userAgent = require("../utils/userAgent");
-var _utils = require("../utils");
-var _utilsBundle = require("../utilsBundle");
-var _browserContext = require("./browserContext");
-var _cookieStore = require("./cookieStore");
-var _formData = require("./formData");
-var _happyEyeballs = require("../utils/happy-eyeballs");
-var _instrumentation = require("./instrumentation");
-var _progress = require("./progress");
-var _tracing = require("./trace/recorder/tracing");
-var _socksClientCertificatesInterceptor = require("./socksClientCertificatesInterceptor");
-var _tls = require("tls");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-/**
- * Copyright (c) Microsoft Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-class APIRequestContext extends _instrumentation.SdkObject {
+module.exports = __toCommonJS(fetch_exports);
+var import_http = __toESM(require("http"));
+var import_https = __toESM(require("https"));
+var import_stream = require("stream");
+var import_tls = require("tls");
+var zlib = __toESM(require("zlib"));
+var import_timeoutSettings = require("./timeoutSettings");
+var import_utils = require("../utils");
+var import_crypto = require("./utils/crypto");
+var import_userAgent = require("./utils/userAgent");
+var import_browserContext = require("./browserContext");
+var import_cookieStore = require("./cookieStore");
+var import_formData = require("./formData");
+var import_instrumentation = require("./instrumentation");
+var import_progress = require("./progress");
+var import_socksClientCertificatesInterceptor = require("./socksClientCertificatesInterceptor");
+var import_happyEyeballs = require("./utils/happyEyeballs");
+var import_tracing = require("./trace/recorder/tracing");
+class APIRequestContext extends import_instrumentation.SdkObject {
+  constructor(parent) {
+    super(parent, "request-context");
+    this.fetchResponses = /* @__PURE__ */ new Map();
+    this.fetchLog = /* @__PURE__ */ new Map();
+    this._activeProgressControllers = /* @__PURE__ */ new Set();
+    APIRequestContext.allInstances.add(this);
+  }
+  static {
+    this.Events = {
+      Dispose: "dispose",
+      Request: "request",
+      RequestFinished: "requestfinished"
+    };
+  }
+  static {
+    this.allInstances = /* @__PURE__ */ new Set();
+  }
   static findResponseBody(guid) {
     for (const request of APIRequestContext.allInstances) {
       const body = request.fetchResponses.get(guid);
-      if (body) return body;
+      if (body)
+        return body;
     }
-    return undefined;
-  }
-  constructor(parent) {
-    super(parent, 'request-context');
-    this.fetchResponses = new Map();
-    this.fetchLog = new Map();
-    this._activeProgressControllers = new Set();
-    this._closeReason = void 0;
-    APIRequestContext.allInstances.add(this);
+    return void 0;
   }
   _disposeImpl() {
     APIRequestContext.allInstances.delete(this);
@@ -66,140 +87,138 @@ class APIRequestContext extends _instrumentation.SdkObject {
     this.fetchLog.delete(fetchUid);
   }
   _storeResponseBody(body) {
-    const uid = (0, _utils.createGuid)();
+    const uid = (0, import_crypto.createGuid)();
     this.fetchResponses.set(uid, body);
     return uid;
   }
   async fetch(params, metadata) {
-    var _params$method;
     const defaults = this._defaultOptions();
     const headers = {
-      'user-agent': defaults.userAgent,
-      'accept': '*/*',
-      'accept-encoding': 'gzip,deflate,br'
+      "user-agent": defaults.userAgent,
+      "accept": "*/*",
+      "accept-encoding": "gzip,deflate,br"
     };
     if (defaults.extraHTTPHeaders) {
-      for (const {
-        name,
-        value
-      } of defaults.extraHTTPHeaders) setHeader(headers, name, value);
+      for (const { name, value } of defaults.extraHTTPHeaders)
+        setHeader(headers, name, value);
     }
     if (params.headers) {
-      for (const {
-        name,
-        value
-      } of params.headers) setHeader(headers, name, value);
+      for (const { name, value } of params.headers)
+        setHeader(headers, name, value);
     }
-    const requestUrl = new URL((0, _utils.constructURLBasedOnBaseURL)(defaults.baseURL, params.url));
+    const requestUrl = new URL((0, import_utils.constructURLBasedOnBaseURL)(defaults.baseURL, params.url));
     if (params.encodedParams) {
       requestUrl.search = params.encodedParams;
     } else if (params.params) {
-      for (const {
-        name,
-        value
-      } of params.params) requestUrl.searchParams.append(name, value);
+      for (const { name, value } of params.params)
+        requestUrl.searchParams.append(name, value);
     }
     const credentials = this._getHttpCredentials(requestUrl);
-    if ((credentials === null || credentials === void 0 ? void 0 : credentials.send) === 'always') setBasicAuthorizationHeader(headers, credentials);
-    const method = ((_params$method = params.method) === null || _params$method === void 0 ? void 0 : _params$method.toUpperCase()) || 'GET';
+    if (credentials?.send === "always")
+      setBasicAuthorizationHeader(headers, credentials);
+    const method = params.method?.toUpperCase() || "GET";
     const proxy = defaults.proxy;
     let agent;
-    // 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);
+    if (proxy?.server !== "per-context")
+      agent = (0, import_utils.createProxyAgent)(proxy, requestUrl);
+    let maxRedirects = params.maxRedirects ?? (defaults.maxRedirects ?? 20);
+    maxRedirects = maxRedirects === 0 ? -1 : maxRedirects;
     const timeout = defaults.timeoutSettings.timeout(params);
-    const deadline = timeout && (0, _utils.monotonicTime)() + timeout;
+    const deadline = timeout && (0, import_utils.monotonicTime)() + timeout;
     const options = {
       method,
       headers,
       agent,
-      maxRedirects: params.maxRedirects === 0 ? -1 : params.maxRedirects === undefined ? 20 : params.maxRedirects,
+      maxRedirects,
       timeout,
       deadline,
-      ...(0, _socksClientCertificatesInterceptor.getMatchingTLSOptionsForOrigin)(this._defaultOptions().clientCertificates, requestUrl.origin),
+      ...(0, import_socksClientCertificatesInterceptor.getMatchingTLSOptionsForOrigin)(this._defaultOptions().clientCertificates, requestUrl.origin),
       __testHookLookup: params.__testHookLookup
     };
-    // rejectUnauthorized = undefined is treated as true in Node.js 12.
-    if (params.ignoreHTTPSErrors || defaults.ignoreHTTPSErrors) options.rejectUnauthorized = false;
+    if (params.ignoreHTTPSErrors || defaults.ignoreHTTPSErrors)
+      options.rejectUnauthorized = false;
     const postData = serializePostData(params, headers);
-    if (postData) setHeader(headers, 'content-length', String(postData.byteLength));
-    const controller = new _progress.ProgressController(metadata, this);
-    const fetchResponse = await controller.run(progress => {
+    if (postData)
+      setHeader(headers, "content-length", String(postData.byteLength));
+    const controller = new import_progress.ProgressController(metadata, this);
+    const fetchResponse = await controller.run((progress) => {
       return this._sendRequestWithRetries(progress, requestUrl, options, postData, params.maxRetries);
     });
     const fetchUid = this._storeResponseBody(fetchResponse.body);
     this.fetchLog.set(fetchUid, controller.metadata.log);
-    if (params.failOnStatusCode && (fetchResponse.status < 200 || fetchResponse.status >= 400)) {
-      let responseText = '';
+    const failOnStatusCode = params.failOnStatusCode !== void 0 ? params.failOnStatusCode : !!defaults.failOnStatusCode;
+    if (failOnStatusCode && (fetchResponse.status < 200 || fetchResponse.status >= 400)) {
+      let responseText = "";
       if (fetchResponse.body.byteLength) {
-        let text = fetchResponse.body.toString('utf8');
-        if (text.length > 1000) text = text.substring(0, 997) + '...';
-        responseText = `\nResponse text:\n${text}`;
+        let text = fetchResponse.body.toString("utf8");
+        if (text.length > 1e3)
+          text = text.substring(0, 997) + "...";
+        responseText = `
+Response text:
+${text}`;
       }
       throw new Error(`${fetchResponse.status} ${fetchResponse.statusText}${responseText}`);
     }
-    return {
-      ...fetchResponse,
-      fetchUid
-    };
+    return { ...fetchResponse, fetchUid };
   }
   _parseSetCookieHeader(responseUrl, setCookie) {
-    if (!setCookie) return [];
+    if (!setCookie)
+      return [];
     const url = new URL(responseUrl);
-    // https://datatracker.ietf.org/doc/html/rfc6265#section-5.1.4
-    const defaultPath = '/' + url.pathname.substr(1).split('/').slice(0, -1).join('/');
+    const defaultPath = "/" + url.pathname.substr(1).split("/").slice(0, -1).join("/");
     const cookies = [];
     for (const header of setCookie) {
-      // Decode cookie value?
       const cookie = parseCookie(header);
-      if (!cookie) continue;
-      // https://datatracker.ietf.org/doc/html/rfc6265#section-5.2.3
-      if (!cookie.domain) cookie.domain = url.hostname;else (0, _utils.assert)(cookie.domain.startsWith('.') || !cookie.domain.includes('.'));
-      if (!(0, _cookieStore.domainMatches)(url.hostname, cookie.domain)) continue;
-      // https://datatracker.ietf.org/doc/html/rfc6265#section-5.2.4
-      if (!cookie.path || !cookie.path.startsWith('/')) cookie.path = defaultPath;
+      if (!cookie)
+        continue;
+      if (!cookie.domain)
+        cookie.domain = url.hostname;
+      else
+        (0, import_utils.assert)(cookie.domain.startsWith(".") || !cookie.domain.includes("."));
+      if (!(0, import_cookieStore.domainMatches)(url.hostname, cookie.domain))
+        continue;
+      if (!cookie.path || !cookie.path.startsWith("/"))
+        cookie.path = defaultPath;
       cookies.push(cookie);
     }
     return cookies;
   }
   async _updateRequestCookieHeader(url, headers) {
-    if (getHeader(headers, 'cookie') !== undefined) return;
+    if (getHeader(headers, "cookie") !== void 0)
+      return;
     const cookies = await this._cookies(url);
     if (cookies.length) {
-      const valueArray = cookies.map(c => `${c.name}=${c.value}`);
-      setHeader(headers, 'cookie', valueArray.join('; '));
+      const valueArray = cookies.map((c) => `${c.name}=${c.value}`);
+      setHeader(headers, "cookie", valueArray.join("; "));
     }
   }
   async _sendRequestWithRetries(progress, url, options, postData, maxRetries) {
-    var _maxRetries;
-    (_maxRetries = maxRetries) !== null && _maxRetries !== void 0 ? _maxRetries : maxRetries = 0;
+    maxRetries ??= 0;
     let backoff = 250;
     for (let i = 0; i <= maxRetries; i++) {
       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.
-        if (e.code !== 'ECONNRESET') throw e;
+        e = (0, import_socksClientCertificatesInterceptor.rewriteOpenSSLErrorIfNeeded)(e);
+        if (maxRetries === 0)
+          throw e;
+        if (i === maxRetries || options.deadline && (0, import_utils.monotonicTime)() + backoff > options.deadline)
+          throw new Error(`Failed after ${i + 1} attempt(s): ${e}`);
+        if (e.code !== "ECONNRESET")
+          throw e;
         progress.log(`  Received ECONNRESET, will retry after ${backoff}ms.`);
-        await new Promise(f => setTimeout(f, backoff));
+        await new Promise((f) => setTimeout(f, backoff));
         backoff *= 2;
       }
     }
-    throw new Error('Unreachable');
+    throw new Error("Unreachable");
   }
   async _sendRequest(progress, url, options, postData) {
-    var _getHeader;
     await this._updateRequestCookieHeader(url, options.headers);
-    const requestCookies = ((_getHeader = getHeader(options.headers, 'cookie')) === null || _getHeader === void 0 ? void 0 : _getHeader.split(';').map(p => {
-      const [name, value] = p.split('=').map(v => v.trim());
-      return {
-        name,
-        value
-      };
-    })) || [];
+    const requestCookies = getHeader(options.headers, "cookie")?.split(";").map((p) => {
+      const [name, value] = p.split("=").map((v) => v.trim());
+      return { name, value };
+    }) || [];
     const requestEvent = {
       url,
       method: options.method,
@@ -209,14 +228,10 @@ class APIRequestContext extends _instrumentation.SdkObject {
     };
     this.emit(APIRequestContext.Events.Request, requestEvent);
     return new Promise((fulfill, reject) => {
-      const requestConstructor = (url.protocol === 'https:' ? _https.default : _http.default).request;
-      // If we have a proxy agent already, do not override it.
-      const agent = options.agent || (url.protocol === 'https:' ? _happyEyeballs.httpsHappyEyeballsAgent : _happyEyeballs.httpHappyEyeballsAgent);
-      const requestOptions = {
-        ...options,
-        agent
-      };
-      const startAt = (0, _utils.monotonicTime)();
+      const requestConstructor = (url.protocol === "https:" ? import_https.default : import_http.default).request;
+      const agent = options.agent || (url.protocol === "https:" ? import_happyEyeballs.httpsHappyEyeballsAgent : import_happyEyeballs.httpHappyEyeballsAgent);
+      const requestOptions = { ...options, agent };
+      const startAt = (0, import_utils.monotonicTime)();
       let reusedSocketAt;
       let dnsLookupAt;
       let tcpConnectionAt;
@@ -226,13 +241,11 @@ class APIRequestContext extends _instrumentation.SdkObject {
       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 request = requestConstructor(url, requestOptions, async (response) => {
+        const responseAt = (0, import_utils.monotonicTime)();
+        const notifyRequestFinished = (body2) => {
+          const endAt = (0, import_utils.monotonicTime)();
+          const connectEnd = tlsHandshakeAt ?? tcpConnectionAt;
           const timings = {
             send: requestFinishAt - startAt,
             wait: responseAt - requestFinishAt,
@@ -247,11 +260,11 @@ class APIRequestContext extends _instrumentation.SdkObject {
             requestEvent,
             httpVersion: response.httpVersion,
             statusCode: response.statusCode || 0,
-            statusMessage: response.statusMessage || '',
+            statusMessage: response.statusMessage || "",
             headers: response.headers,
             rawHeaders: response.rawHeaders,
             cookies,
-            body,
+            body: body2,
             timings,
             serverIPAddress,
             serverPort,
@@ -259,36 +272,31 @@ class APIRequestContext extends _instrumentation.SdkObject {
           };
           this.emit(APIRequestContext.Events.RequestFinished, requestFinishedEvent);
         };
-        progress.log(`← ${response.statusCode} ${response.statusMessage}`);
-        for (const [name, value] of Object.entries(response.headers)) progress.log(`  ${name}: ${value}`);
-        const cookies = this._parseSetCookieHeader(response.url || url.toString(), response.headers['set-cookie']);
+        progress.log(`\u2190 ${response.statusCode} ${response.statusMessage}`);
+        for (const [name, value] of Object.entries(response.headers))
+          progress.log(`  ${name}: ${value}`);
+        const cookies = this._parseSetCookieHeader(response.url || url.toString(), response.headers["set-cookie"]);
         if (cookies.length) {
           try {
             await this._addCookies(cookies);
           } catch (e) {
-            // Cookie value is limited by 4096 characters in the browsers. If setCookies failed,
-            // we try setting each cookie individually just in case only some of them are bad.
-            await Promise.all(cookies.map(c => this._addCookies([c]).catch(() => {})));
+            await Promise.all(cookies.map((c) => this._addCookies([c]).catch(() => {
+            })));
           }
         }
         if (redirectStatus.includes(response.statusCode) && options.maxRedirects >= 0) {
-          var _response$headers$loc;
-          if (!options.maxRedirects) {
-            reject(new Error('Max redirect count exceeded'));
+          if (options.maxRedirects === 0) {
+            reject(new Error("Max redirect count exceeded"));
             request.destroy();
             return;
           }
-          const headers = {
-            ...options.headers
-          };
+          const headers = { ...options.headers };
           removeHeader(headers, `cookie`);
-
-          // HTTP-redirect fetch step 13 (https://fetch.spec.whatwg.org/#http-redirect-fetch)
           const status = response.statusCode;
           let method = options.method;
-          if ((status === 301 || status === 302) && method === 'POST' || status === 303 && !['GET', 'HEAD'].includes(method)) {
-            method = 'GET';
-            postData = undefined;
+          if ((status === 301 || status === 302) && method === "POST" || status === 303 && !["GET", "HEAD"].includes(method)) {
+            method = "GET";
+            postData = void 0;
             removeHeader(headers, `content-encoding`);
             removeHeader(headers, `content-language`);
             removeHeader(headers, `content-length`);
@@ -302,16 +310,12 @@ class APIRequestContext extends _instrumentation.SdkObject {
             maxRedirects: options.maxRedirects - 1,
             timeout: options.timeout,
             deadline: options.deadline,
-            ...(0, _socksClientCertificatesInterceptor.getMatchingTLSOptionsForOrigin)(this._defaultOptions().clientCertificates, url.origin),
+            ...(0, import_socksClientCertificatesInterceptor.getMatchingTLSOptionsForOrigin)(this._defaultOptions().clientCertificates, url.origin),
             __testHookLookup: options.__testHookLookup
           };
-          // rejectUnauthorized = undefined is treated as true in node 12.
-          if (options.rejectUnauthorized === false) redirectOptions.rejectUnauthorized = false;
-
-          // HTTP-redirect fetch step 4: If locationURL is null, then return response.
-          // Best-effort UTF-8 decoding, per spec it's US-ASCII only, but browsers are more lenient.
-          // Node.js parses it as Latin1 via std::v8::String, so we convert it to UTF-8.
-          const locationHeaderValue = Buffer.from((_response$headers$loc = response.headers.location) !== null && _response$headers$loc !== void 0 ? _response$headers$loc : '', 'latin1').toString('utf8');
+          if (options.rejectUnauthorized === false)
+            redirectOptions.rejectUnauthorized = false;
+          const locationHeaderValue = Buffer.from(response.headers.location ?? "", "latin1").toString("utf8");
           if (locationHeaderValue) {
             let locationURL;
             try {
@@ -321,17 +325,18 @@ class APIRequestContext extends _instrumentation.SdkObject {
               request.destroy();
               return;
             }
-            if (headers['host']) headers['host'] = locationURL.host;
+            if (headers["host"])
+              headers["host"] = locationURL.host;
             notifyRequestFinished();
             fulfill(this._sendRequest(progress, locationURL, redirectOptions, postData));
             request.destroy();
             return;
           }
         }
-        if (response.statusCode === 401 && !getHeader(options.headers, 'authorization')) {
-          const auth = response.headers['www-authenticate'];
+        if (response.statusCode === 401 && !getHeader(options.headers, "authorization")) {
+          const auth = response.headers["www-authenticate"];
           const credentials = this._getHttpCredentials(url);
-          if (auth !== null && auth !== void 0 && auth.trim().startsWith('Basic') && credentials) {
+          if (auth?.trim().startsWith("Basic") && credentials) {
             setBasicAuthorizationHeader(options.headers, credentials);
             notifyRequestFinished();
             fulfill(this._sendRequest(progress, url, options, postData));
@@ -339,139 +344,123 @@ class APIRequestContext extends _instrumentation.SdkObject {
             return;
           }
         }
-        response.on('aborted', () => reject(new Error('aborted')));
+        response.on("aborted", () => reject(new Error("aborted")));
         const chunks = [];
         const notifyBodyFinished = () => {
-          const body = Buffer.concat(chunks);
-          notifyRequestFinished(body);
+          const body2 = Buffer.concat(chunks);
+          notifyRequestFinished(body2);
           fulfill({
             url: response.url || url.toString(),
             status: response.statusCode || 0,
-            statusText: response.statusMessage || '',
+            statusText: response.statusMessage || "",
             headers: toHeadersArray(response.rawHeaders),
-            body
+            body: body2
           });
         };
         let body = response;
         let transform;
-        const encoding = response.headers['content-encoding'];
-        if (encoding === 'gzip' || encoding === 'x-gzip') {
-          transform = _zlib.default.createGunzip({
-            flush: _zlib.default.constants.Z_SYNC_FLUSH,
-            finishFlush: _zlib.default.constants.Z_SYNC_FLUSH
+        const encoding = response.headers["content-encoding"];
+        if (encoding === "gzip" || encoding === "x-gzip") {
+          transform = zlib.createGunzip({
+            flush: zlib.constants.Z_SYNC_FLUSH,
+            finishFlush: zlib.constants.Z_SYNC_FLUSH
           });
-        } else if (encoding === 'br') {
-          transform = _zlib.default.createBrotliDecompress({
-            flush: _zlib.default.constants.BROTLI_OPERATION_FLUSH,
-            finishFlush: _zlib.default.constants.BROTLI_OPERATION_FLUSH
+        } else if (encoding === "br") {
+          transform = zlib.createBrotliDecompress({
+            flush: zlib.constants.BROTLI_OPERATION_FLUSH,
+            finishFlush: zlib.constants.BROTLI_OPERATION_FLUSH
           });
-        } else if (encoding === 'deflate') {
-          transform = _zlib.default.createInflate();
+        } else if (encoding === "deflate") {
+          transform = zlib.createInflate();
         }
         if (transform) {
-          // Brotli and deflate decompressors throw if the input stream is empty.
           const emptyStreamTransform = new SafeEmptyStreamTransform(notifyBodyFinished);
-          body = (0, _stream.pipeline)(response, emptyStreamTransform, transform, e => {
-            if (e) reject(new Error(`failed to decompress '${encoding}' encoding: ${e.message}`));
+          body = (0, import_stream.pipeline)(response, emptyStreamTransform, transform, (e) => {
+            if (e)
+              reject(new Error(`failed to decompress '${encoding}' encoding: ${e.message}`));
           });
-          body.on('error', e => reject(new Error(`failed to decompress '${encoding}' encoding: ${e}`)));
+          body.on("error", (e) => reject(new Error(`failed to decompress '${encoding}' encoding: ${e}`)));
         } else {
-          body.on('error', reject);
+          body.on("error", reject);
         }
-        body.on('data', chunk => chunks.push(chunk));
-        body.on('end', notifyBodyFinished);
+        body.on("data", (chunk) => chunks.push(chunk));
+        body.on("end", notifyBodyFinished);
       });
-      request.on('error', reject);
-      listeners.push(_utils.eventsHelper.addEventListener(this, APIRequestContext.Events.Dispose, () => {
-        reject(new Error('Request context disposed.'));
-        request.destroy();
-      }));
-      request.on('close', () => _utils.eventsHelper.removeEventListeners(listeners));
-      request.on('socket', socket => {
-        var _tcpConnectionAt, _tcpConnectionAt3;
+      request.on("error", reject);
+      listeners.push(
+        import_utils.eventsHelper.addEventListener(this, APIRequestContext.Events.Dispose, () => {
+          reject(new Error("Request context disposed."));
+          request.destroy();
+        })
+      );
+      request.on("close", () => import_utils.eventsHelper.removeEventListeners(listeners));
+      request.on("socket", (socket) => {
         if (request.reusedSocket) {
-          reusedSocketAt = (0, _utils.monotonicTime)();
+          reusedSocketAt = (0, import_utils.monotonicTime)();
           return;
         }
-
-        // happy eyeballs don't emit lookup and connect events, so we use our custom ones
-        const happyEyeBallsTimings = (0, _happyEyeballs.timingForSocket)(socket);
+        const happyEyeBallsTimings = (0, import_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)();
+        tcpConnectionAt = happyEyeBallsTimings.tcpConnectionAt;
+        listeners.push(
+          import_utils.eventsHelper.addEventListener(socket, "lookup", () => {
+            dnsLookupAt = (0, import_utils.monotonicTime)();
+          }),
+          import_utils.eventsHelper.addEventListener(socket, "connect", () => {
+            tcpConnectionAt = (0, import_utils.monotonicTime)();
+          }),
+          import_utils.eventsHelper.addEventListener(socket, "secureConnect", () => {
+            tlsHandshakeAt = (0, import_utils.monotonicTime)();
+            if (socket instanceof import_tls.TLSSocket) {
+              const peerCertificate = socket.getPeerCertificate();
+              securityDetails = {
+                protocol: socket.getProtocol() ?? void 0,
+                subjectName: peerCertificate.subject.CN,
+                validFrom: new Date(peerCertificate.valid_from).getTime() / 1e3,
+                validTo: new Date(peerCertificate.valid_to).getTime() / 1e3,
+                issuer: peerCertificate.issuer.CN
+              };
+            }
+          })
+        );
         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)();
+      request.on("finish", () => {
+        requestFinishAt = (0, import_utils.monotonicTime)();
       });
-      progress.log(`→ ${options.method} ${url.toString()}`);
+      progress.log(`\u2192 ${options.method} ${url.toString()}`);
       if (options.headers) {
-        for (const [name, value] of Object.entries(options.headers)) progress.log(`  ${name}: ${value}`);
+        for (const [name, value] of Object.entries(options.headers))
+          progress.log(`  ${name}: ${value}`);
       }
       if (options.deadline) {
         const rejectOnTimeout = () => {
           reject(new Error(`Request timed out after ${options.timeout}ms`));
           request.destroy();
         };
-        const remaining = options.deadline - (0, _utils.monotonicTime)();
+        const remaining = options.deadline - (0, import_utils.monotonicTime)();
         if (remaining <= 0) {
           rejectOnTimeout();
           return;
         }
         request.setTimeout(remaining, rejectOnTimeout);
       }
-      if (postData) request.write(postData);
+      if (postData)
+        request.write(postData);
       request.end();
     });
   }
   _getHttpCredentials(url) {
-    var _this$_defaultOptions, _this$_defaultOptions2;
-    if (!((_this$_defaultOptions = this._defaultOptions().httpCredentials) !== null && _this$_defaultOptions !== void 0 && _this$_defaultOptions.origin) || url.origin.toLowerCase() === ((_this$_defaultOptions2 = this._defaultOptions().httpCredentials) === null || _this$_defaultOptions2 === void 0 || (_this$_defaultOptions2 = _this$_defaultOptions2.origin) === null || _this$_defaultOptions2 === void 0 ? void 0 : _this$_defaultOptions2.toLowerCase())) return this._defaultOptions().httpCredentials;
-    return undefined;
+    if (!this._defaultOptions().httpCredentials?.origin || url.origin.toLowerCase() === this._defaultOptions().httpCredentials?.origin?.toLowerCase())
+      return this._defaultOptions().httpCredentials;
+    return void 0;
   }
 }
-exports.APIRequestContext = APIRequestContext;
-APIRequestContext.Events = {
-  Dispose: 'dispose',
-  Request: 'request',
-  RequestFinished: 'requestfinished'
-};
-APIRequestContext.allInstances = new Set();
-class SafeEmptyStreamTransform extends _stream.Transform {
+class SafeEmptyStreamTransform extends import_stream.Transform {
   constructor(onEmptyStreamCallback) {
     super();
     this._receivedSomeData = false;
-    this._onEmptyStreamCallback = void 0;
     this._onEmptyStreamCallback = onEmptyStreamCallback;
   }
   _transform(chunk, encoding, callback) {
@@ -479,15 +468,17 @@ class SafeEmptyStreamTransform extends _stream.Transform {
     callback(null, chunk);
   }
   _flush(callback) {
-    if (this._receivedSomeData) callback(null);else this._onEmptyStreamCallback();
+    if (this._receivedSomeData)
+      callback(null);
+    else
+      this._onEmptyStreamCallback();
   }
 }
 class BrowserContextAPIRequestContext extends APIRequestContext {
   constructor(context) {
     super(context);
-    this._context = void 0;
     this._context = context;
-    context.once(_browserContext.BrowserContext.Events.Close, () => this._disposeImpl());
+    context.once(import_browserContext.BrowserContext.Events.Close, () => this._disposeImpl());
   }
   tracing() {
     return this._context.tracing;
@@ -500,6 +491,7 @@ class BrowserContextAPIRequestContext extends APIRequestContext {
     return {
       userAgent: this._context._options.userAgent || this._context._browser.userAgent(),
       extraHTTPHeaders: this._context._options.extraHTTPHeaders,
+      failOnStatusCode: void 0,
       httpCredentials: this._context._options.httpCredentials,
       proxy: this._context._options.proxy || this._context._browser.options.proxy,
       timeoutSettings: this._context._timeoutSettings,
@@ -514,43 +506,36 @@ class BrowserContextAPIRequestContext extends APIRequestContext {
   async _cookies(url) {
     return await this._context.cookies(url.toString());
   }
-  async storageState() {
-    return this._context.storageState();
+  async storageState(indexedDB) {
+    return this._context.storageState(indexedDB);
   }
 }
-exports.BrowserContextAPIRequestContext = BrowserContextAPIRequestContext;
 class GlobalAPIRequestContext extends APIRequestContext {
   constructor(playwright, options) {
     super(playwright);
-    this._cookieStore = new _cookieStore.CookieStore();
-    this._options = void 0;
-    this._origins = void 0;
-    this._tracing = void 0;
+    this._cookieStore = new import_cookieStore.CookieStore();
     this.attribution.context = this;
-    const timeoutSettings = new _timeoutSettings.TimeoutSettings();
-    if (options.timeout !== undefined) timeoutSettings.setDefaultTimeout(options.timeout);
-    const proxy = options.proxy;
-    if (proxy !== null && proxy !== void 0 && proxy.server) {
-      let url = proxy === null || proxy === void 0 ? void 0 : proxy.server.trim();
-      if (!/^\w+:\/\//.test(url)) url = 'http://' + url;
-      proxy.server = url;
-    }
+    const timeoutSettings = new import_timeoutSettings.TimeoutSettings();
+    if (options.timeout !== void 0)
+      timeoutSettings.setDefaultTimeout(options.timeout);
     if (options.storageState) {
-      this._origins = options.storageState.origins;
+      this._origins = options.storageState.origins?.map((origin) => ({ indexedDB: [], ...origin }));
       this._cookieStore.addCookies(options.storageState.cookies || []);
     }
-    (0, _browserContext.verifyClientCertificates)(options.clientCertificates);
+    (0, import_browserContext.verifyClientCertificates)(options.clientCertificates);
     this._options = {
       baseURL: options.baseURL,
-      userAgent: options.userAgent || (0, _userAgent.getUserAgent)(),
+      userAgent: options.userAgent || (0, import_userAgent.getUserAgent)(),
       extraHTTPHeaders: options.extraHTTPHeaders,
+      failOnStatusCode: !!options.failOnStatusCode,
       ignoreHTTPSErrors: !!options.ignoreHTTPSErrors,
+      maxRedirects: options.maxRedirects,
       httpCredentials: options.httpCredentials,
       clientCertificates: options.clientCertificates,
-      proxy,
+      proxy: options.proxy,
       timeoutSettings
     };
-    this._tracing = new _tracing.Tracing(this, options.tracesDir);
+    this._tracing = new import_tracing.Tracing(this, options.tracesDir);
   }
   tracing() {
     return this._tracing;
@@ -570,100 +555,86 @@ class GlobalAPIRequestContext extends APIRequestContext {
   async _cookies(url) {
     return this._cookieStore.cookies(url);
   }
-  async storageState() {
+  async storageState(indexedDB = false) {
     return {
       cookies: this._cookieStore.allCookies(),
-      origins: this._origins || []
+      origins: (this._origins || []).map((origin) => ({ ...origin, indexedDB: indexedDB ? origin.indexedDB : [] }))
     };
   }
 }
-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({
-    name: rawHeaders[i],
-    value: rawHeaders[i + 1]
-  });
+  for (let i = 0; i < rawHeaders.length; i += 2)
+    result.push({ name: rawHeaders[i], value: rawHeaders[i + 1] });
   return result;
 }
 const redirectStatus = [301, 302, 303, 307, 308];
 function parseCookie(header) {
-  const raw = (0, _cookieStore.parseRawCookie)(header);
-  if (!raw) return null;
+  const raw = (0, import_cookieStore.parseRawCookie)(header);
+  if (!raw)
+    return null;
   const cookie = {
-    domain: '',
-    path: '',
+    domain: "",
+    path: "",
     expires: -1,
     httpOnly: false,
     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
   };
   return cookie;
 }
 function serializePostData(params, headers) {
-  (0, _utils.assert)((params.postData ? 1 : 0) + (params.jsonData ? 1 : 0) + (params.formData ? 1 : 0) + (params.multipartData ? 1 : 0) <= 1, `Only one of 'data', 'form' or 'multipart' can be specified`);
-  if (params.jsonData !== undefined) {
-    setHeader(headers, 'content-type', 'application/json', true);
-    return Buffer.from(params.jsonData, 'utf8');
+  (0, import_utils.assert)((params.postData ? 1 : 0) + (params.jsonData ? 1 : 0) + (params.formData ? 1 : 0) + (params.multipartData ? 1 : 0) <= 1, `Only one of 'data', 'form' or 'multipart' can be specified`);
+  if (params.jsonData !== void 0) {
+    setHeader(headers, "content-type", "application/json", true);
+    return Buffer.from(params.jsonData, "utf8");
   } else if (params.formData) {
     const searchParams = new URLSearchParams();
-    for (const {
-      name,
-      value
-    } of params.formData) searchParams.append(name, value);
-    setHeader(headers, 'content-type', 'application/x-www-form-urlencoded', true);
-    return Buffer.from(searchParams.toString(), 'utf8');
+    for (const { name, value } of params.formData)
+      searchParams.append(name, value);
+    setHeader(headers, "content-type", "application/x-www-form-urlencoded", true);
+    return Buffer.from(searchParams.toString(), "utf8");
   } else if (params.multipartData) {
-    const formData = new _formData.MultipartFormData();
+    const formData = new import_formData.MultipartFormData();
     for (const field of params.multipartData) {
-      if (field.file) formData.addFileField(field.name, field.file);else if (field.value) formData.addField(field.name, field.value);
+      if (field.file)
+        formData.addFileField(field.name, field.file);
+      else if (field.value)
+        formData.addField(field.name, field.value);
     }
-    setHeader(headers, 'content-type', formData.contentTypeHeader(), true);
+    setHeader(headers, "content-type", formData.contentTypeHeader(), true);
     return formData.finish();
-  } else if (params.postData !== undefined) {
-    setHeader(headers, 'content-type', 'application/octet-stream', true);
+  } else if (params.postData !== void 0) {
+    setHeader(headers, "content-type", "application/octet-stream", true);
     return params.postData;
   }
-  return undefined;
+  return void 0;
 }
 function setHeader(headers, name, value, keepExisting = false) {
-  const existing = Object.entries(headers).find(pair => pair[0].toLowerCase() === name.toLowerCase());
-  if (!existing) headers[name] = value;else if (!keepExisting) headers[existing[0]] = value;
+  const existing = Object.entries(headers).find((pair) => pair[0].toLowerCase() === name.toLowerCase());
+  if (!existing)
+    headers[name] = value;
+  else if (!keepExisting)
+    headers[existing[0]] = value;
 }
 function getHeader(headers, name) {
-  const existing = Object.entries(headers).find(pair => pair[0].toLowerCase() === name.toLowerCase());
-  return existing ? existing[1] : undefined;
+  const existing = Object.entries(headers).find((pair) => pair[0].toLowerCase() === name.toLowerCase());
+  return existing ? existing[1] : void 0;
 }
 function removeHeader(headers, name) {
   delete headers[name];
 }
-function shouldBypassProxy(url, bypass) {
-  if (!bypass) return false;
-  const domains = bypass.split(',').map(s => {
-    s = s.trim();
-    if (!s.startsWith('.')) s = '.' + s;
-    return s;
-  });
-  const domain = '.' + url.hostname;
-  return domains.some(d => domain.endsWith(d));
-}
 function setBasicAuthorizationHeader(headers, credentials) {
-  const {
-    username,
-    password
-  } = credentials;
-  const encoded = Buffer.from(`${username || ''}:${password || ''}`).toString('base64');
-  setHeader(headers, 'authorization', `Basic ${encoded}`);
-}
+  const { username, password } = credentials;
+  const encoded = Buffer.from(`${username || ""}:${password || ""}`).toString("base64");
+  setHeader(headers, "authorization", `Basic ${encoded}`);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  APIRequestContext,
+  BrowserContextAPIRequestContext,
+  GlobalAPIRequestContext
+});