@checkly/playwright-core 1.51.17-beta.2 → 1.54.2-beta.0

package/lib/server/network.js

@@ -1,76 +1,82 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var network_exports = {};
+__export(network_exports, {
+  Request: () => Request,
+  Response: () => Response,
+  Route: () => Route,
+  WebSocket: () => WebSocket,
+  filterCookies: () => filterCookies,
+  isLocalHostname: () => isLocalHostname,
+  kMaxCookieExpiresDateInSeconds: () => kMaxCookieExpiresDateInSeconds,
+  mergeHeaders: () => mergeHeaders,
+  parseURL: () => parseURL,
+  rewriteCookies: () => rewriteCookies,
+  singleHeader: () => singleHeader,
+  statusText: () => statusText,
+  stripFragmentFromUrl: () => stripFragmentFromUrl
 });
-exports.WebSocket = exports.Route = exports.Response = exports.Request = void 0;
-exports.filterCookies = filterCookies;
-exports.kMaxCookieExpiresDateInSeconds = void 0;
-exports.mergeHeaders = mergeHeaders;
-exports.parseURL = parseURL;
-exports.rewriteCookies = rewriteCookies;
-exports.singleHeader = singleHeader;
-exports.statusText = statusText;
-exports.stripFragmentFromUrl = stripFragmentFromUrl;
-var _utils = require("../utils");
-var _browserContext = require("./browserContext");
-var _fetch = require("./fetch");
-var _instrumentation = require("./instrumentation");
-var _manualPromise = require("../utils/isomorphic/manualPromise");
-/**
- * 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.
- */
-
+module.exports = __toCommonJS(network_exports);
+var import_utils = require("../utils");
+var import_browserContext = require("./browserContext");
+var import_fetch = require("./fetch");
+var import_instrumentation = require("./instrumentation");
+var import_manualPromise = require("../utils/isomorphic/manualPromise");
 function filterCookies(cookies, urls) {
-  const parsedURLs = urls.map(s => new URL(s));
-  // Chromiums's cookies are missing sameSite when it is 'None'
-  return cookies.filter(c => {
-    if (!parsedURLs.length) return true;
+  const parsedURLs = urls.map((s) => new URL(s));
+  return cookies.filter((c) => {
+    if (!parsedURLs.length)
+      return true;
     for (const parsedURL of parsedURLs) {
       let domain = c.domain;
-      if (!domain.startsWith('.')) domain = '.' + domain;
-      if (!('.' + parsedURL.hostname).endsWith(domain)) continue;
-      if (!parsedURL.pathname.startsWith(c.path)) continue;
-      if (parsedURL.protocol !== 'https:' && parsedURL.hostname !== 'localhost' && c.secure) continue;
+      if (!domain.startsWith("."))
+        domain = "." + domain;
+      if (!("." + parsedURL.hostname).endsWith(domain))
+        continue;
+      if (!parsedURL.pathname.startsWith(c.path))
+        continue;
+      if (parsedURL.protocol !== "https:" && !isLocalHostname(parsedURL.hostname) && c.secure)
+        continue;
       return true;
     }
     return false;
   });
 }
-
-// Rollover to 5-digit year:
-// 253402300799 == Fri, 31 Dec 9999 23:59:59 +0000 (UTC)
-// 253402300800 == Sat,  1 Jan 1000 00:00:00 +0000 (UTC)
-const kMaxCookieExpiresDateInSeconds = exports.kMaxCookieExpiresDateInSeconds = 253402300799;
+function isLocalHostname(hostname) {
+  return hostname === "localhost" || hostname.endsWith(".localhost");
+}
+const kMaxCookieExpiresDateInSeconds = 253402300799;
 function rewriteCookies(cookies) {
-  return cookies.map(c => {
-    (0, _utils.assert)(c.url || c.domain && c.path, 'Cookie should have a url or a domain/path pair');
-    (0, _utils.assert)(!(c.url && c.domain), 'Cookie should have either url or domain');
-    (0, _utils.assert)(!(c.url && c.path), 'Cookie should have either url or path');
-    (0, _utils.assert)(!(c.expires && c.expires < 0 && c.expires !== -1), 'Cookie should have a valid expires, only -1 or a positive number for the unix timestamp in seconds is allowed');
-    (0, _utils.assert)(!(c.expires && c.expires > 0 && c.expires > kMaxCookieExpiresDateInSeconds), 'Cookie should have a valid expires, only -1 or a positive number for the unix timestamp in seconds is allowed');
-    const copy = {
-      ...c
-    };
+  return cookies.map((c) => {
+    (0, import_utils.assert)(c.url || c.domain && c.path, "Cookie should have a url or a domain/path pair");
+    (0, import_utils.assert)(!(c.url && c.domain), "Cookie should have either url or domain");
+    (0, import_utils.assert)(!(c.url && c.path), "Cookie should have either url or path");
+    (0, import_utils.assert)(!(c.expires && c.expires < 0 && c.expires !== -1), "Cookie should have a valid expires, only -1 or a positive number for the unix timestamp in seconds is allowed");
+    (0, import_utils.assert)(!(c.expires && c.expires > 0 && c.expires > kMaxCookieExpiresDateInSeconds), "Cookie should have a valid expires, only -1 or a positive number for the unix timestamp in seconds is allowed");
+    const copy = { ...c };
     if (copy.url) {
-      (0, _utils.assert)(copy.url !== 'about:blank', `Blank page can not have cookie "${c.name}"`);
-      (0, _utils.assert)(!copy.url.startsWith('data:'), `Data URL page can not have cookie "${c.name}"`);
+      (0, import_utils.assert)(copy.url !== "about:blank", `Blank page can not have cookie "${c.name}"`);
+      (0, import_utils.assert)(!copy.url.startsWith("data:"), `Data URL page can not have cookie "${c.name}"`);
       const url = new URL(copy.url);
       copy.domain = url.hostname;
-      copy.path = url.pathname.substring(0, url.pathname.lastIndexOf('/') + 1);
-      copy.secure = url.protocol === 'https:';
+      copy.path = url.pathname.substring(0, url.pathname.lastIndexOf("/") + 1);
+      copy.secure = url.protocol === "https:";
     }
     return copy;
   });
@@ -83,38 +89,29 @@ function parseURL(url) {
   }
 }
 function stripFragmentFromUrl(url) {
-  if (!url.includes('#')) return url;
-  return url.substring(0, url.indexOf('#'));
+  if (!url.includes("#"))
+    return url;
+  return url.substring(0, url.indexOf("#"));
 }
-class Request extends _instrumentation.SdkObject {
+class Request extends import_instrumentation.SdkObject {
   constructor(context, frame, serviceWorker, redirectedFrom, documentId, url, resourceType, method, postData, headers) {
-    super(frame || context, 'request');
+    super(frame || context, "request");
     this._response = null;
-    this._redirectedFrom = void 0;
     this._redirectedTo = null;
-    this._documentId = void 0;
-    this._isFavicon = void 0;
     this._failureText = null;
-    this._url = void 0;
-    this._resourceType = void 0;
-    this._method = void 0;
-    this._postData = void 0;
-    this._headers = void 0;
-    this._headersMap = new Map();
+    this._headersMap = /* @__PURE__ */ new Map();
     this._frame = null;
     this._serviceWorker = null;
-    this._context = void 0;
-    this._rawRequestHeadersPromise = new _manualPromise.ManualPromise();
-    this._waitForResponsePromise = new _manualPromise.ManualPromise();
+    this._rawRequestHeadersPromise = new import_manualPromise.ManualPromise();
+    this._waitForResponsePromise = new import_manualPromise.ManualPromise();
     this._responseEndTiming = -1;
-    this._overrides = void 0;
-    this._bodySize = void 0;
-    (0, _utils.assert)(!url.startsWith('data:'), 'Data urls should not fire requests');
+    (0, import_utils.assert)(!url.startsWith("data:"), "Data urls should not fire requests");
     this._context = context;
     this._frame = frame;
     this._serviceWorker = serviceWorker;
     this._redirectedFrom = redirectedFrom;
-    if (redirectedFrom) redirectedFrom._redirectedTo = this;
+    if (redirectedFrom)
+      redirectedFrom._redirectedTo = this;
     this._documentId = documentId;
     this._url = stripFragmentFromUrl(url);
     this._resourceType = resourceType;
@@ -122,55 +119,49 @@ class Request extends _instrumentation.SdkObject {
     this._postData = postData;
     this._headers = headers;
     this._updateHeadersMap();
-    this._isFavicon = url.endsWith('/favicon.ico') || !!(redirectedFrom !== null && redirectedFrom !== void 0 && redirectedFrom._isFavicon);
+    this._isFavicon = url.endsWith("/favicon.ico") || !!redirectedFrom?._isFavicon;
   }
   _setFailureText(failureText) {
     this._failureText = failureText;
     this._waitForResponsePromise.resolve(null);
   }
-  _setOverrides(overrides) {
-    this._overrides = overrides;
+  _applyOverrides(overrides) {
+    this._overrides = { ...this._overrides, ...overrides };
     this._updateHeadersMap();
+    return this._overrides;
   }
   _updateHeadersMap() {
-    for (const {
-      name,
-      value
-    } of this.headers()) this._headersMap.set(name.toLowerCase(), value);
+    for (const { name, value } of this.headers())
+      this._headersMap.set(name.toLowerCase(), value);
   }
-  _hasOverrides() {
-    return !!this._overrides;
+  overrides() {
+    return this._overrides;
   }
   url() {
-    var _this$_overrides;
-    return ((_this$_overrides = this._overrides) === null || _this$_overrides === void 0 ? void 0 : _this$_overrides.url) || this._url;
+    return this._overrides?.url || this._url;
   }
   resourceType() {
     return this._resourceType;
   }
   method() {
-    var _this$_overrides2;
-    return ((_this$_overrides2 = this._overrides) === null || _this$_overrides2 === void 0 ? void 0 : _this$_overrides2.method) || this._method;
+    return this._overrides?.method || this._method;
   }
   postDataBuffer() {
-    var _this$_overrides3;
-    return ((_this$_overrides3 = this._overrides) === null || _this$_overrides3 === void 0 ? void 0 : _this$_overrides3.postData) || this._postData;
+    return this._overrides?.postData || this._postData;
   }
   headers() {
-    var _this$_overrides4;
-    return ((_this$_overrides4 = this._overrides) === null || _this$_overrides4 === void 0 ? void 0 : _this$_overrides4.headers) || this._headers;
+    return this._overrides?.headers || this._headers;
   }
   headerValue(name) {
     return this._headersMap.get(name);
   }
-
   // "null" means no raw headers available - we'll use provisional headers as raw headers.
   setRawRequestHeaders(headers) {
-    if (!this._rawRequestHeadersPromise.isDone()) this._rawRequestHeadersPromise.resolve(headers || this._headers);
+    if (!this._rawRequestHeadersPromise.isDone())
+      this._rawRequestHeadersPromise.resolve(headers || this._headers);
   }
   async rawRequestHeaders() {
-    var _this$_overrides5;
-    return ((_this$_overrides5 = this._overrides) === null || _this$_overrides5 === void 0 ? void 0 : _this$_overrides5.headers) || this._rawRequestHeadersPromise;
+    return this._overrides?.headers || this._rawRequestHeadersPromise;
   }
   response() {
     return this._waitForResponsePromise;
@@ -198,158 +189,163 @@ class Request extends _instrumentation.SdkObject {
     return this._redirectedFrom;
   }
   failure() {
-    if (this._failureText === null) return null;
+    if (this._failureText === null)
+      return null;
     return {
       errorText: this._failureText
     };
   }
-
   // TODO(bidi): remove once post body is available.
   _setBodySize(size) {
     this._bodySize = size;
   }
   bodySize() {
-    var _this$postDataBuffer;
-    return this._bodySize || ((_this$postDataBuffer = this.postDataBuffer()) === null || _this$postDataBuffer === void 0 ? void 0 : _this$postDataBuffer.length) || 0;
+    return this._bodySize || this.postDataBuffer()?.length || 0;
   }
   async requestHeadersSize() {
-    let headersSize = 4; // 4 = 2 spaces + 2 line breaks (GET /path \r\n)
+    let headersSize = 4;
     headersSize += this.method().length;
     headersSize += new URL(this.url()).pathname.length;
-    headersSize += 8; // httpVersion
+    headersSize += 8;
     const headers = await this.rawRequestHeaders();
-    for (const header of headers) headersSize += header.name.length + header.value.length + 4; // 4 = ': ' + '\r\n'
+    for (const header of headers)
+      headersSize += header.name.length + header.value.length + 4;
     return headersSize;
   }
 }
-exports.Request = Request;
-class Route extends _instrumentation.SdkObject {
+class Route extends import_instrumentation.SdkObject {
   constructor(request, delegate) {
-    super(request._frame || request._context, 'route');
-    this._request = void 0;
-    this._delegate = void 0;
+    super(request._frame || request._context, "route");
     this._handled = false;
+    this._futureHandlers = [];
     this._request = request;
     this._delegate = delegate;
     this._request._context.addRouteInFlight(this);
   }
+  handle(handlers) {
+    this._futureHandlers = [...handlers];
+    this.continue({ isFallback: true }).catch(() => {
+    });
+  }
+  async removeHandler(handler) {
+    this._futureHandlers = this._futureHandlers.filter((h) => h !== handler);
+    if (handler === this._currentHandler) {
+      await this.continue({ isFallback: true }).catch(() => {
+      });
+      return;
+    }
+  }
   request() {
     return this._request;
   }
-  async abort(errorCode = 'failed') {
+  async abort(errorCode = "failed") {
     this._startHandling();
-    this._request._context.emit(_browserContext.BrowserContext.Events.RequestAborted, this._request);
+    this._request._context.emit(import_browserContext.BrowserContext.Events.RequestAborted, this._request);
     await this._delegate.abort(errorCode);
     this._endHandling();
   }
-  async redirectNavigationRequest(url) {
+  redirectNavigationRequest(url) {
     this._startHandling();
-    (0, _utils.assert)(this._request.isNavigationRequest());
-    this._request.frame().redirectNavigation(url, this._request._documentId, this._request.headerValue('referer'));
+    (0, import_utils.assert)(this._request.isNavigationRequest());
+    this._request.frame().redirectNavigation(url, this._request._documentId, this._request.headerValue("referer"));
+    this._endHandling();
   }
   async fulfill(overrides) {
     this._startHandling();
     let body = overrides.body;
     let isBase64 = overrides.isBase64 || false;
-    if (body === undefined) {
+    if (body === void 0) {
       if (overrides.fetchResponseUid) {
-        const buffer = this._request._context.fetchRequest.fetchResponses.get(overrides.fetchResponseUid) || _fetch.APIRequestContext.findResponseBody(overrides.fetchResponseUid);
-        (0, _utils.assert)(buffer, 'Fetch response has been disposed');
-        body = buffer.toString('base64');
+        const buffer = this._request._context.fetchRequest.fetchResponses.get(overrides.fetchResponseUid) || import_fetch.APIRequestContext.findResponseBody(overrides.fetchResponseUid);
+        (0, import_utils.assert)(buffer, "Fetch response has been disposed");
+        body = buffer.toString("base64");
         isBase64 = true;
       } else {
-        body = '';
+        body = "";
         isBase64 = false;
       }
     }
-    const headers = [...(overrides.headers || [])];
+    const headers = [...overrides.headers || []];
     this._maybeAddCorsHeaders(headers);
-    this._request._context.emit(_browserContext.BrowserContext.Events.RequestFulfilled, this._request);
+    this._request._context.emit(import_browserContext.BrowserContext.Events.RequestFulfilled, this._request);
     await this._delegate.fulfill({
       status: overrides.status || 200,
       headers,
-      body: body,
+      body,
       isBase64
     });
     this._endHandling();
   }
-
   // See https://github.com/microsoft/playwright/issues/12929
   _maybeAddCorsHeaders(headers) {
-    const origin = this._request.headerValue('origin');
-    if (!origin) return;
+    const origin = this._request.headerValue("origin");
+    if (!origin)
+      return;
     const requestUrl = new URL(this._request.url());
-    if (!requestUrl.protocol.startsWith('http')) return;
-    if (requestUrl.origin === origin.trim()) return;
-    const corsHeader = headers.find(({
-      name
-    }) => name === 'access-control-allow-origin');
-    if (corsHeader) return;
-    headers.push({
-      name: 'access-control-allow-origin',
-      value: origin
-    });
-    headers.push({
-      name: 'access-control-allow-credentials',
-      value: 'true'
-    });
-    headers.push({
-      name: 'vary',
-      value: 'Origin'
-    });
+    if (!requestUrl.protocol.startsWith("http"))
+      return;
+    if (requestUrl.origin === origin.trim())
+      return;
+    const corsHeader = headers.find(({ name }) => name === "access-control-allow-origin");
+    if (corsHeader)
+      return;
+    headers.push({ name: "access-control-allow-origin", value: origin });
+    headers.push({ name: "access-control-allow-credentials", value: "true" });
+    headers.push({ name: "vary", value: "Origin" });
   }
   async continue(overrides) {
-    this._startHandling();
     if (overrides.url) {
       const newUrl = new URL(overrides.url);
       const oldUrl = new URL(this._request.url());
-      if (oldUrl.protocol !== newUrl.protocol) throw new Error('New URL must have same protocol as overridden URL');
+      if (oldUrl.protocol !== newUrl.protocol)
+        throw new Error("New URL must have same protocol as overridden URL");
+    }
+    if (overrides.headers)
+      overrides.headers = overrides.headers?.filter((header) => header.name.toLowerCase() !== "cookie");
+    overrides = this._request._applyOverrides(overrides);
+    const nextHandler = this._futureHandlers.shift();
+    if (nextHandler) {
+      this._currentHandler = nextHandler;
+      nextHandler(this, this._request);
+      return;
     }
-    this._request._setOverrides(overrides);
-    if (!overrides.isFallback) this._request._context.emit(_browserContext.BrowserContext.Events.RequestContinued, this._request);
+    if (!overrides.isFallback)
+      this._request._context.emit(import_browserContext.BrowserContext.Events.RequestContinued, this._request);
+    this._startHandling();
     await this._delegate.continue(overrides);
     this._endHandling();
   }
   _startHandling() {
-    (0, _utils.assert)(!this._handled, 'Route is already handled!');
+    (0, import_utils.assert)(!this._handled, "Route is already handled!");
     this._handled = true;
+    this._currentHandler = void 0;
   }
   _endHandling() {
+    this._futureHandlers = [];
+    this._currentHandler = void 0;
     this._request._context.removeRouteInFlight(this);
   }
 }
-exports.Route = Route;
-class Response extends _instrumentation.SdkObject {
-  constructor(request, status, statusText, headers, timing, getResponseBodyCallback, fromServiceWorker, httpVersion) {
-    super(request.frame() || request._context, 'response');
-    this._request = void 0;
+class Response extends import_instrumentation.SdkObject {
+  constructor(request, status, statusText2, headers, timing, getResponseBodyCallback, fromServiceWorker, httpVersion) {
+    super(request.frame() || request._context, "response");
     this._contentPromise = null;
-    this._finishedPromise = new _manualPromise.ManualPromise();
-    this._status = void 0;
-    this._statusText = void 0;
-    this._url = void 0;
-    this._headers = void 0;
-    this._headersMap = new Map();
-    this._getResponseBodyCallback = void 0;
-    this._timing = void 0;
-    this._serverAddrPromise = new _manualPromise.ManualPromise();
-    this._securityDetailsPromise = new _manualPromise.ManualPromise();
-    this._rawResponseHeadersPromise = new _manualPromise.ManualPromise();
-    this._httpVersion = void 0;
-    this._fromServiceWorker = void 0;
-    this._encodedBodySizePromise = new _manualPromise.ManualPromise();
-    this._transferSizePromise = new _manualPromise.ManualPromise();
-    this._responseHeadersSizePromise = new _manualPromise.ManualPromise();
+    this._finishedPromise = new import_manualPromise.ManualPromise();
+    this._headersMap = /* @__PURE__ */ new Map();
+    this._serverAddrPromise = new import_manualPromise.ManualPromise();
+    this._securityDetailsPromise = new import_manualPromise.ManualPromise();
+    this._rawResponseHeadersPromise = new import_manualPromise.ManualPromise();
+    this._encodedBodySizePromise = new import_manualPromise.ManualPromise();
+    this._transferSizePromise = new import_manualPromise.ManualPromise();
+    this._responseHeadersSizePromise = new import_manualPromise.ManualPromise();
     this._request = request;
     this._timing = timing;
     this._status = status;
-    this._statusText = statusText;
+    this._statusText = statusText2;
     this._url = request.url();
     this._headers = headers;
-    for (const {
-      name,
-      value
-    } of this._headers) this._headersMap.set(name.toLowerCase(), value);
+    for (const { name, value } of this._headers)
+      this._headersMap.set(name.toLowerCase(), value);
     this._getResponseBodyCallback = getResponseBodyCallback;
     this._request._setResponse(this);
     this._httpVersion = httpVersion;
@@ -363,8 +359,8 @@ class Response extends _instrumentation.SdkObject {
   }
   _requestFinished(responseEndTiming) {
     this._request._responseEndTiming = Math.max(responseEndTiming, this._timing.responseStart);
-    // Set start time equal to end when request is served from memory cache.
-    if (this._timing.requestStart === -1) this._timing.requestStart = this._request._responseEndTiming;
+    if (this._timing.requestStart === -1)
+      this._timing.requestStart = this._request._responseEndTiming;
     this._finishedPromise.resolve();
   }
   _setHttpVersion(httpVersion) {
@@ -388,10 +384,10 @@ class Response extends _instrumentation.SdkObject {
   async rawResponseHeaders() {
     return this._rawResponseHeadersPromise;
   }
-
   // "null" means no raw headers available - we'll use provisional headers as raw headers.
   setRawResponseHeaders(headers) {
-    if (!this._rawResponseHeadersPromise.isDone()) this._rawResponseHeadersPromise.resolve(headers || this._headers);
+    if (!this._rawResponseHeadersPromise.isDone())
+      this._rawResponseHeadersPromise.resolve(headers || this._headers);
   }
   setTransferSize(size) {
     this._transferSizePromise.resolve(size);
@@ -406,15 +402,16 @@ class Response extends _instrumentation.SdkObject {
     return this._timing;
   }
   async serverAddr() {
-    return (await this._serverAddrPromise) || null;
+    return await this._serverAddrPromise || null;
   }
   async securityDetails() {
-    return (await this._securityDetailsPromise) || null;
+    return await this._securityDetailsPromise || null;
   }
   body() {
     if (!this._contentPromise) {
       this._contentPromise = this._finishedPromise.then(async () => {
-        if (this._status >= 300 && this._status <= 399) throw new Error('Response body is unavailable for redirect responses');
+        if (this._status >= 300 && this._status <= 399)
+          throw new Error("Response body is unavailable for redirect responses");
         return this._getResponseBodyCallback();
       });
     }
@@ -427,9 +424,12 @@ class Response extends _instrumentation.SdkObject {
     return this._request.frame();
   }
   httpVersion() {
-    if (!this._httpVersion) return 'HTTP/1.1';
-    if (this._httpVersion === 'http/1.1') return 'HTTP/1.1';
-    if (this._httpVersion === 'h2') return 'HTTP/2.0';
+    if (!this._httpVersion)
+      return "HTTP/1.1";
+    if (this._httpVersion === "http/1.1")
+      return "HTTP/1.1";
+    if (this._httpVersion === "h2")
+      return "HTTP/2.0";
     return this._httpVersion;
   }
   fromServiceWorker() {
@@ -437,16 +437,16 @@ class Response extends _instrumentation.SdkObject {
   }
   async responseHeadersSize() {
     const availableSize = await this._responseHeadersSizePromise;
-    if (availableSize !== null) return availableSize;
-
-    // Fallback to calculating it manually.
-    let headersSize = 4; // 4 = 2 spaces + 2 line breaks (HTTP/1.1 200 Ok\r\n)
-    headersSize += 8; // httpVersion;
-    headersSize += 3; // statusCode;
+    if (availableSize !== null)
+      return availableSize;
+    let headersSize = 4;
+    headersSize += 8;
+    headersSize += 3;
     headersSize += this.statusText().length;
     const headers = await this._rawResponseHeadersPromise;
-    for (const header of headers) headersSize += header.name.length + header.value.length + 4; // 4 = ': ' + '\r\n'
-    headersSize += 2; // '\r\n'
+    for (const header of headers)
+      headersSize += header.name.length + header.value.length + 4;
+    headersSize += 2;
     return headersSize;
   }
   async sizes() {
@@ -454,15 +454,12 @@ class Response extends _instrumentation.SdkObject {
     const responseHeadersSize = await this.responseHeadersSize();
     let encodedBodySize = await this._encodedBodySizePromise;
     if (encodedBodySize === null) {
-      var _headers$find;
-      // Fallback to calculating it manually.
       const headers = await this._rawResponseHeadersPromise;
-      const contentLength = (_headers$find = headers.find(h => h.name.toLowerCase() === 'content-length')) === null || _headers$find === void 0 ? void 0 : _headers$find.value;
+      const contentLength = headers.find((h) => h.name.toLowerCase() === "content-length")?.value;
       encodedBodySize = contentLength ? +contentLength : 0;
     }
     let transferSize = await this._transferSizePromise;
     if (transferSize === null) {
-      // Fallback to calculating it manually.
       transferSize = responseHeadersSize + encodedBodySize;
     }
     return {
@@ -474,19 +471,23 @@ class Response extends _instrumentation.SdkObject {
     };
   }
 }
-exports.Response = Response;
-class WebSocket extends _instrumentation.SdkObject {
+class WebSocket extends import_instrumentation.SdkObject {
   constructor(parent, url) {
-    super(parent, 'ws');
-    this._url = void 0;
+    super(parent, "ws");
     this._notified = false;
     this._url = url;
   }
+  static {
+    this.Events = {
+      Close: "close",
+      SocketError: "socketerror",
+      FrameReceived: "framereceived",
+      FrameSent: "framesent"
+    };
+  }
   markAsNotified() {
-    // Sometimes we get "onWebSocketRequest" twice, at least in Chromium.
-    // Perhaps websocket is restarted because of chrome.webRequest extensions api?
-    // Or maybe the handshake response was a redirect?
-    if (this._notified) return false;
+    if (this._notified)
+      return false;
     this._notified = true;
     return true;
   }
@@ -494,16 +495,10 @@ class WebSocket extends _instrumentation.SdkObject {
     return this._url;
   }
   frameSent(opcode, data) {
-    this.emit(WebSocket.Events.FrameSent, {
-      opcode,
-      data
-    });
+    this.emit(WebSocket.Events.FrameSent, { opcode, data });
   }
   frameReceived(opcode, data) {
-    this.emit(WebSocket.Events.FrameReceived, {
-      opcode,
-      data
-    });
+    this.emit(WebSocket.Events.FrameReceived, { opcode, data });
   }
   error(errorMessage) {
     this.emit(WebSocket.Events.SocketError, errorMessage);
@@ -512,106 +507,107 @@ class WebSocket extends _instrumentation.SdkObject {
     this.emit(WebSocket.Events.Close);
   }
 }
-exports.WebSocket = WebSocket;
-WebSocket.Events = {
-  Close: 'close',
-  SocketError: 'socketerror',
-  FrameReceived: 'framereceived',
-  FrameSent: 'framesent'
-};
-// List taken from https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml with extra 306 and 418 codes.
 const STATUS_TEXTS = {
-  '100': 'Continue',
-  '101': 'Switching Protocols',
-  '102': 'Processing',
-  '103': 'Early Hints',
-  '200': 'OK',
-  '201': 'Created',
-  '202': 'Accepted',
-  '203': 'Non-Authoritative Information',
-  '204': 'No Content',
-  '205': 'Reset Content',
-  '206': 'Partial Content',
-  '207': 'Multi-Status',
-  '208': 'Already Reported',
-  '226': 'IM Used',
-  '300': 'Multiple Choices',
-  '301': 'Moved Permanently',
-  '302': 'Found',
-  '303': 'See Other',
-  '304': 'Not Modified',
-  '305': 'Use Proxy',
-  '306': 'Switch Proxy',
-  '307': 'Temporary Redirect',
-  '308': 'Permanent Redirect',
-  '400': 'Bad Request',
-  '401': 'Unauthorized',
-  '402': 'Payment Required',
-  '403': 'Forbidden',
-  '404': 'Not Found',
-  '405': 'Method Not Allowed',
-  '406': 'Not Acceptable',
-  '407': 'Proxy Authentication Required',
-  '408': 'Request Timeout',
-  '409': 'Conflict',
-  '410': 'Gone',
-  '411': 'Length Required',
-  '412': 'Precondition Failed',
-  '413': 'Payload Too Large',
-  '414': 'URI Too Long',
-  '415': 'Unsupported Media Type',
-  '416': 'Range Not Satisfiable',
-  '417': 'Expectation Failed',
-  '418': 'I\'m a teapot',
-  '421': 'Misdirected Request',
-  '422': 'Unprocessable Entity',
-  '423': 'Locked',
-  '424': 'Failed Dependency',
-  '425': 'Too Early',
-  '426': 'Upgrade Required',
-  '428': 'Precondition Required',
-  '429': 'Too Many Requests',
-  '431': 'Request Header Fields Too Large',
-  '451': 'Unavailable For Legal Reasons',
-  '500': 'Internal Server Error',
-  '501': 'Not Implemented',
-  '502': 'Bad Gateway',
-  '503': 'Service Unavailable',
-  '504': 'Gateway Timeout',
-  '505': 'HTTP Version Not Supported',
-  '506': 'Variant Also Negotiates',
-  '507': 'Insufficient Storage',
-  '508': 'Loop Detected',
-  '510': 'Not Extended',
-  '511': 'Network Authentication Required'
+  "100": "Continue",
+  "101": "Switching Protocols",
+  "102": "Processing",
+  "103": "Early Hints",
+  "200": "OK",
+  "201": "Created",
+  "202": "Accepted",
+  "203": "Non-Authoritative Information",
+  "204": "No Content",
+  "205": "Reset Content",
+  "206": "Partial Content",
+  "207": "Multi-Status",
+  "208": "Already Reported",
+  "226": "IM Used",
+  "300": "Multiple Choices",
+  "301": "Moved Permanently",
+  "302": "Found",
+  "303": "See Other",
+  "304": "Not Modified",
+  "305": "Use Proxy",
+  "306": "Switch Proxy",
+  "307": "Temporary Redirect",
+  "308": "Permanent Redirect",
+  "400": "Bad Request",
+  "401": "Unauthorized",
+  "402": "Payment Required",
+  "403": "Forbidden",
+  "404": "Not Found",
+  "405": "Method Not Allowed",
+  "406": "Not Acceptable",
+  "407": "Proxy Authentication Required",
+  "408": "Request Timeout",
+  "409": "Conflict",
+  "410": "Gone",
+  "411": "Length Required",
+  "412": "Precondition Failed",
+  "413": "Payload Too Large",
+  "414": "URI Too Long",
+  "415": "Unsupported Media Type",
+  "416": "Range Not Satisfiable",
+  "417": "Expectation Failed",
+  "418": "I'm a teapot",
+  "421": "Misdirected Request",
+  "422": "Unprocessable Entity",
+  "423": "Locked",
+  "424": "Failed Dependency",
+  "425": "Too Early",
+  "426": "Upgrade Required",
+  "428": "Precondition Required",
+  "429": "Too Many Requests",
+  "431": "Request Header Fields Too Large",
+  "451": "Unavailable For Legal Reasons",
+  "500": "Internal Server Error",
+  "501": "Not Implemented",
+  "502": "Bad Gateway",
+  "503": "Service Unavailable",
+  "504": "Gateway Timeout",
+  "505": "HTTP Version Not Supported",
+  "506": "Variant Also Negotiates",
+  "507": "Insufficient Storage",
+  "508": "Loop Detected",
+  "510": "Not Extended",
+  "511": "Network Authentication Required"
 };
 function statusText(status) {
-  return STATUS_TEXTS[String(status)] || 'Unknown';
+  return STATUS_TEXTS[String(status)] || "Unknown";
 }
 function singleHeader(name, value) {
-  return [{
-    name,
-    value
-  }];
+  return [{ name, value }];
 }
 function mergeHeaders(headers) {
-  const lowerCaseToValue = new Map();
-  const lowerCaseToOriginalCase = new Map();
+  const lowerCaseToValue = /* @__PURE__ */ new Map();
+  const lowerCaseToOriginalCase = /* @__PURE__ */ new Map();
   for (const h of headers) {
-    if (!h) continue;
-    for (const {
-      name,
-      value
-    } of h) {
+    if (!h)
+      continue;
+    for (const { name, value } of h) {
       const lower = name.toLowerCase();
       lowerCaseToOriginalCase.set(lower, name);
       lowerCaseToValue.set(lower, value);
     }
   }
   const result = [];
-  for (const [lower, value] of lowerCaseToValue) result.push({
-    name: lowerCaseToOriginalCase.get(lower),
-    value
-  });
+  for (const [lower, value] of lowerCaseToValue)
+    result.push({ name: lowerCaseToOriginalCase.get(lower), value });
   return result;
-}
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Request,
+  Response,
+  Route,
+  WebSocket,
+  filterCookies,
+  isLocalHostname,
+  kMaxCookieExpiresDateInSeconds,
+  mergeHeaders,
+  parseURL,
+  rewriteCookies,
+  singleHeader,
+  statusText,
+  stripFragmentFromUrl
+});