msw 0.0.0-fetch.rc-19 → 0.0.0-fetch.rc-21

package/lib/iife/index.js

@@ -504,20 +504,20 @@ var MockServiceWorker = (() => {
 
   // src/core/handlers/RequestHandler.ts
   var RequestHandler = class {
-    constructor(options) {
-      this.resolver = options.resolver;
-      this.once = options.once || false;
+    constructor(args) {
+      this.resolver = args.resolver;
+      this.options = args.options;
       const callFrame = getCallFrame(new Error());
-      this.info = __spreadProps(__spreadValues({}, options.info), {
+      this.info = __spreadProps(__spreadValues({}, args.info), {
         callFrame
       });
       this.isUsed = false;
     }
     /**
-     * Parse the captured request to extract additional information from it.
+     * Parse the intercepted request to extract additional information from it.
      * Parsed result is then exposed to other methods of this request handler.
      */
-    parse(_request, _resolutionContext) {
+    parse(_args) {
       return __async(this, null, function* () {
         return {};
       });
@@ -525,53 +525,61 @@ var MockServiceWorker = (() => {
     /**
      * Test if this handler matches the given request.
      */
-    test(request, resolutionContext) {
+    test(args) {
       return __async(this, null, function* () {
-        return this.predicate(
-          request,
-          yield this.parse(request.clone(), resolutionContext),
-          resolutionContext
-        );
+        const parsedResult = yield this.parse({
+          request: args.request,
+          resolutionContext: args.resolutionContext
+        });
+        return this.predicate({
+          request: args.request,
+          parsedResult,
+          resolutionContext: args.resolutionContext
+        });
       });
     }
-    extendInfo(_request, _parsedResult) {
+    extendResolverArgs(_args) {
       return {};
     }
     /**
      * Execute this request handler and produce a mocked response
      * using the given resolver function.
      */
-    run(request, resolutionContext) {
+    run(args) {
       return __async(this, null, function* () {
-        if (this.isUsed && this.once) {
+        var _a3;
+        if (this.isUsed && ((_a3 = this.options) == null ? void 0 : _a3.once)) {
           return null;
         }
-        const mainRequestRef = request.clone();
+        const mainRequestRef = args.request.clone();
         this.isUsed = true;
-        const parsedResult = yield this.parse(
-          mainRequestRef.clone(),
-          resolutionContext
-        );
-        const shouldInterceptRequest = this.predicate(
-          mainRequestRef.clone(),
+        const parsedResult = yield this.parse({
+          request: args.request,
+          resolutionContext: args.resolutionContext
+        });
+        const shouldInterceptRequest = this.predicate({
+          request: args.request,
           parsedResult,
-          resolutionContext
-        );
+          resolutionContext: args.resolutionContext
+        });
         if (!shouldInterceptRequest) {
           return null;
         }
         const executeResolver = this.wrapResolver(this.resolver);
-        const resolverExtras = this.extendInfo(request, parsedResult);
+        const resolverExtras = this.extendResolverArgs({
+          request: args.request,
+          parsedResult
+        });
         const mockedResponse = yield executeResolver(__spreadProps(__spreadValues({}, resolverExtras), {
-          request
+          request: args.request
         }));
-        const executionResult = this.createExecutionResult(
+        const executionResult = this.createExecutionResult({
           // Pass the cloned request to the result so that logging
           // and other consumers could read its body once more.
-          mainRequestRef,
-          parsedResult,
-          mockedResponse
-        );
+          request: mainRequestRef,
+          response: mockedResponse,
+          parsedResult
+        });
         return executionResult;
       });
     }
@@ -603,12 +611,12 @@ var MockServiceWorker = (() => {
         return result;
       });
     }
-    createExecutionResult(request, parsedResult, response) {
+    createExecutionResult(args) {
       return {
         handler: this,
-        parsedResult,
-        request,
-        response
+        request: args.request,
+        response: args.response,
+        parsedResult: args.parsedResult
       };
     }
   };
@@ -635,7 +643,21 @@ var MockServiceWorker = (() => {
     return [now.getHours(), now.getMinutes(), now.getSeconds()].map(String).map((chunk) => chunk.slice(0, 2)).map((chunk) => chunk.padStart(2, "0")).join(":");
   }
 
-  // node_modules/.pnpm/headers-polyfill@3.2.3/node_modules/headers-polyfill/lib/index.mjs
+  // src/core/utils/logging/serializeRequest.ts
+  function serializeRequest(request) {
+    return __async(this, null, function* () {
+      const requestClone = request.clone();
+      const requestText = yield requestClone.text();
+      return {
+        url: new URL(request.url),
+        method: request.method,
+        headers: Object.fromEntries(request.headers.entries()),
+        body: requestText
+      };
+    });
+  }
+
+  // node_modules/.pnpm/@bundled-es-modules+statuses@1.0.1/node_modules/@bundled-es-modules/statuses/index-esm.js
   var __create = Object.create;
   var __defProp2 = Object.defineProperty;
   var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
@@ -654,1476 +676,1286 @@ var MockServiceWorker = (() => {
     return to;
   };
   var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps2(
+    // 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 ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
     mod
   ));
-  var require_set_cookie = __commonJS({
-    "node_modules/set-cookie-parser/lib/set-cookie.js"(exports, module) {
+  var require_codes = __commonJS({
+    "node_modules/statuses/codes.json"(exports, module) {
+      module.exports = {
+        "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",
+        "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",
+        "509": "Bandwidth Limit Exceeded",
+        "510": "Not Extended",
+        "511": "Network Authentication Required"
+      };
+    }
+  });
+  var require_statuses = __commonJS({
+    "node_modules/statuses/index.js"(exports, module) {
       "use strict";
-      var defaultParseOptions = {
-        decodeValues: true,
-        map: false,
-        silent: false
+      var codes = require_codes();
+      module.exports = status2;
+      status2.message = codes;
+      status2.code = createMessageToStatusCodeMap(codes);
+      status2.codes = createStatusCodeList(codes);
+      status2.redirect = {
+        300: true,
+        301: true,
+        302: true,
+        303: true,
+        305: true,
+        307: true,
+        308: true
       };
-      function isNonEmptyString(str) {
-        return typeof str === "string" && !!str.trim();
+      status2.empty = {
+        204: true,
+        205: true,
+        304: true
+      };
+      status2.retry = {
+        502: true,
+        503: true,
+        504: true
+      };
+      function createMessageToStatusCodeMap(codes2) {
+        var map = {};
+        Object.keys(codes2).forEach(function forEachCode(code) {
+          var message3 = codes2[code];
+          var status3 = Number(code);
+          map[message3.toLowerCase()] = status3;
+        });
+        return map;
       }
-      function parseString(setCookieValue, options) {
-        var parts = setCookieValue.split(";").filter(isNonEmptyString);
-        var nameValuePairStr = parts.shift();
-        var parsed = parseNameValuePair(nameValuePairStr);
-        var name = parsed.name;
-        var value = parsed.value;
-        options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions;
-        try {
-          value = options.decodeValues ? decodeURIComponent(value) : value;
-        } catch (e) {
-          console.error(
-            "set-cookie-parser encountered an error while decoding a cookie with value '" + value + "'. Set options.decodeValues to false to disable this feature.",
-            e
-          );
-        }
-        var cookie = {
-          name,
-          value
-        };
-        parts.forEach(function(part) {
-          var sides = part.split("=");
-          var key = sides.shift().trimLeft().toLowerCase();
-          var value2 = sides.join("=");
-          if (key === "expires") {
-            cookie.expires = new Date(value2);
-          } else if (key === "max-age") {
-            cookie.maxAge = parseInt(value2, 10);
-          } else if (key === "secure") {
-            cookie.secure = true;
-          } else if (key === "httponly") {
-            cookie.httpOnly = true;
-          } else if (key === "samesite") {
-            cookie.sameSite = value2;
-          } else {
-            cookie[key] = value2;
-          }
+      function createStatusCodeList(codes2) {
+        return Object.keys(codes2).map(function mapCode(code) {
+          return Number(code);
         });
-        return cookie;
       }
-      function parseNameValuePair(nameValuePairStr) {
-        var name = "";
-        var value = "";
-        var nameValueArr = nameValuePairStr.split("=");
-        if (nameValueArr.length > 1) {
-          name = nameValueArr.shift();
-          value = nameValueArr.join("=");
-        } else {
-          value = nameValuePairStr;
+      function getStatusCode(message3) {
+        var msg = message3.toLowerCase();
+        if (!Object.prototype.hasOwnProperty.call(status2.code, msg)) {
+          throw new Error('invalid status message: "' + message3 + '"');
         }
-        return { name, value };
+        return status2.code[msg];
       }
-      function parse3(input, options) {
-        options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions;
-        if (!input) {
-          if (!options.map) {
-            return [];
-          } else {
-            return {};
-          }
+      function getStatusMessage(code) {
+        if (!Object.prototype.hasOwnProperty.call(status2.message, code)) {
+          throw new Error("invalid status code: " + code);
         }
-        if (input.headers) {
-          if (typeof input.headers.getSetCookie === "function") {
-            input = input.headers.getSetCookie();
-          } else if (input.headers["set-cookie"]) {
-            input = input.headers["set-cookie"];
-          } else {
-            var sch = input.headers[Object.keys(input.headers).find(function(key) {
-              return key.toLowerCase() === "set-cookie";
-            })];
-            if (!sch && input.headers.cookie && !options.silent) {
-              console.warn(
-                "Warning: set-cookie-parser appears to have been called on a request object. It is designed to parse Set-Cookie headers from responses, not Cookie headers from requests. Set the option {silent: true} to suppress this warning."
-              );
-            }
-            input = sch;
-          }
+        return status2.message[code];
+      }
+      function status2(code) {
+        if (typeof code === "number") {
+          return getStatusMessage(code);
         }
-        if (!Array.isArray(input)) {
-          input = [input];
+        if (typeof code !== "string") {
+          throw new TypeError("code must be a number or string");
         }
-        options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions;
-        if (!options.map) {
-          return input.filter(isNonEmptyString).map(function(str) {
-            return parseString(str, options);
-          });
-        } else {
-          var cookies = {};
-          return input.filter(isNonEmptyString).reduce(function(cookies2, str) {
-            var cookie = parseString(str, options);
-            cookies2[cookie.name] = cookie;
-            return cookies2;
-          }, cookies);
+        var n = parseInt(code, 10);
+        if (!isNaN(n)) {
+          return getStatusMessage(n);
         }
+        return getStatusCode(code);
       }
-      function splitCookiesString2(cookiesString) {
-        if (Array.isArray(cookiesString)) {
-          return cookiesString;
-        }
-        if (typeof cookiesString !== "string") {
-          return [];
-        }
-        var cookiesStrings = [];
-        var pos = 0;
-        var start;
-        var ch;
-        var lastComma;
-        var nextStart;
-        var cookiesSeparatorFound;
-        function skipWhitespace() {
-          while (pos < cookiesString.length && /\s/.test(cookiesString.charAt(pos))) {
-            pos += 1;
+    }
+  });
+  var import_statuses = __toESM(require_statuses(), 1);
+  var source_default = import_statuses.default;
+
+  // src/core/utils/logging/serializeResponse.ts
+  var { message } = source_default;
+  function serializeResponse(response) {
+    return __async(this, null, function* () {
+      const responseClone = response.clone();
+      const responseText = yield responseClone.text();
+      const responseStatus = responseClone.status || 200;
+      const responseStatusText = responseClone.statusText || message[responseStatus] || "OK";
+      return {
+        status: responseStatus,
+        statusText: responseStatusText,
+        headers: Object.fromEntries(responseClone.headers.entries()),
+        body: responseText
+      };
+    });
+  }
+
+  // node_modules/.pnpm/path-to-regexp@6.2.1/node_modules/path-to-regexp/dist.es2015/index.js
+  function lexer(str) {
+    var tokens = [];
+    var i = 0;
+    while (i < str.length) {
+      var char = str[i];
+      if (char === "*" || char === "+" || char === "?") {
+        tokens.push({ type: "MODIFIER", index: i, value: str[i++] });
+        continue;
+      }
+      if (char === "\\") {
+        tokens.push({ type: "ESCAPED_CHAR", index: i++, value: str[i++] });
+        continue;
+      }
+      if (char === "{") {
+        tokens.push({ type: "OPEN", index: i, value: str[i++] });
+        continue;
+      }
+      if (char === "}") {
+        tokens.push({ type: "CLOSE", index: i, value: str[i++] });
+        continue;
+      }
+      if (char === ":") {
+        var name = "";
+        var j = i + 1;
+        while (j < str.length) {
+          var code = str.charCodeAt(j);
+          if (
+            // `0-9`
+            code >= 48 && code <= 57 || // `A-Z`
+            code >= 65 && code <= 90 || // `a-z`
+            code >= 97 && code <= 122 || // `_`
+            code === 95
+          ) {
+            name += str[j++];
+            continue;
           }
-          return pos < cookiesString.length;
+          break;
         }
-        function notSpecialChar() {
-          ch = cookiesString.charAt(pos);
-          return ch !== "=" && ch !== ";" && ch !== ",";
+        if (!name)
+          throw new TypeError("Missing parameter name at ".concat(i));
+        tokens.push({ type: "NAME", index: i, value: name });
+        i = j;
+        continue;
+      }
+      if (char === "(") {
+        var count = 1;
+        var pattern = "";
+        var j = i + 1;
+        if (str[j] === "?") {
+          throw new TypeError('Pattern cannot start with "?" at '.concat(j));
         }
-        while (pos < cookiesString.length) {
-          start = pos;
-          cookiesSeparatorFound = false;
-          while (skipWhitespace()) {
-            ch = cookiesString.charAt(pos);
-            if (ch === ",") {
-              lastComma = pos;
-              pos += 1;
-              skipWhitespace();
-              nextStart = pos;
-              while (pos < cookiesString.length && notSpecialChar()) {
-                pos += 1;
-              }
-              if (pos < cookiesString.length && cookiesString.charAt(pos) === "=") {
-                cookiesSeparatorFound = true;
-                pos = nextStart;
-                cookiesStrings.push(cookiesString.substring(start, lastComma));
-                start = pos;
-              } else {
-                pos = lastComma + 1;
-              }
-            } else {
-              pos += 1;
-            }
+        while (j < str.length) {
+          if (str[j] === "\\") {
+            pattern += str[j++] + str[j++];
+            continue;
           }
-          if (!cookiesSeparatorFound || pos >= cookiesString.length) {
-            cookiesStrings.push(cookiesString.substring(start, cookiesString.length));
+          if (str[j] === ")") {
+            count--;
+            if (count === 0) {
+              j++;
+              break;
+            }
+          } else if (str[j] === "(") {
+            count++;
+            if (str[j + 1] !== "?") {
+              throw new TypeError("Capturing groups are not allowed at ".concat(j));
+            }
           }
+          pattern += str[j++];
         }
-        return cookiesStrings;
+        if (count)
+          throw new TypeError("Unbalanced pattern at ".concat(i));
+        if (!pattern)
+          throw new TypeError("Missing pattern at ".concat(i));
+        tokens.push({ type: "PATTERN", index: i, value: pattern });
+        i = j;
+        continue;
       }
-      module.exports = parse3;
-      module.exports.parse = parse3;
-      module.exports.parseString = parseString;
-      module.exports.splitCookiesString = splitCookiesString2;
-    }
-  });
-  var import_set_cookie_parser = __toESM(require_set_cookie());
-  var HEADERS_INVALID_CHARACTERS = /[^a-z0-9\-#$%&'*+.^_`|~]/i;
-  function normalizeHeaderName(name) {
-    if (typeof name !== "string") {
-      name = String(name);
-    }
-    if (HEADERS_INVALID_CHARACTERS.test(name) || name.trim() === "") {
-      throw new TypeError("Invalid character in header field name");
+      tokens.push({ type: "CHAR", index: i, value: str[i++] });
     }
-    return name.toLowerCase();
+    tokens.push({ type: "END", index: i, value: "" });
+    return tokens;
   }
-  function normalizeHeaderValue(value) {
-    if (typeof value !== "string") {
-      value = String(value);
+  function parse(str, options) {
+    if (options === void 0) {
+      options = {};
     }
-    return value;
-  }
-  var NORMALIZED_HEADERS = Symbol("normalizedHeaders");
-  var RAW_HEADER_NAMES = Symbol("rawHeaderNames");
-  var HEADER_VALUE_DELIMITER = ", ";
-  var _a;
-  var _b;
-  var HeadersPolyfill = class {
-    constructor(init) {
-      this[_a] = {};
-      this[_b] = /* @__PURE__ */ new Map();
-      if (["Headers", "HeadersPolyfill"].includes(init == null ? void 0 : init.constructor.name) || init instanceof HeadersPolyfill) {
-        const initialHeaders = init;
-        initialHeaders.forEach((value, name) => {
-          this.append(name, value);
-        }, this);
-      } else if (Array.isArray(init)) {
-        init.forEach(([name, value]) => {
-          this.append(
-            name,
-            Array.isArray(value) ? value.join(HEADER_VALUE_DELIMITER) : value
-          );
-        });
-      } else if (init) {
-        Object.getOwnPropertyNames(init).forEach((name) => {
-          const value = init[name];
-          this.append(
-            name,
-            Array.isArray(value) ? value.join(HEADER_VALUE_DELIMITER) : value
-          );
-        });
+    var tokens = lexer(str);
+    var _a3 = options.prefixes, prefixes = _a3 === void 0 ? "./" : _a3;
+    var defaultPattern = "[^".concat(escapeString(options.delimiter || "/#?"), "]+?");
+    var result = [];
+    var key = 0;
+    var i = 0;
+    var path = "";
+    var tryConsume = function(type) {
+      if (i < tokens.length && tokens[i].type === type)
+        return tokens[i++].value;
+    };
+    var mustConsume = function(type) {
+      var value2 = tryConsume(type);
+      if (value2 !== void 0)
+        return value2;
+      var _a4 = tokens[i], nextType = _a4.type, index = _a4.index;
+      throw new TypeError("Unexpected ".concat(nextType, " at ").concat(index, ", expected ").concat(type));
+    };
+    var consumeText = function() {
+      var result2 = "";
+      var value2;
+      while (value2 = tryConsume("CHAR") || tryConsume("ESCAPED_CHAR")) {
+        result2 += value2;
       }
-    }
-    [(_a = NORMALIZED_HEADERS, _b = RAW_HEADER_NAMES, Symbol.iterator)]() {
-      return this.entries();
-    }
-    *keys() {
-      for (const name of Object.keys(this[NORMALIZED_HEADERS])) {
-        yield name;
+      return result2;
+    };
+    while (i < tokens.length) {
+      var char = tryConsume("CHAR");
+      var name = tryConsume("NAME");
+      var pattern = tryConsume("PATTERN");
+      if (name || pattern) {
+        var prefix = char || "";
+        if (prefixes.indexOf(prefix) === -1) {
+          path += prefix;
+          prefix = "";
+        }
+        if (path) {
+          result.push(path);
+          path = "";
+        }
+        result.push({
+          name: name || key++,
+          prefix,
+          suffix: "",
+          pattern: pattern || defaultPattern,
+          modifier: tryConsume("MODIFIER") || ""
+        });
+        continue;
       }
-    }
-    *values() {
-      for (const value of Object.values(this[NORMALIZED_HEADERS])) {
-        yield value;
+      var value = char || tryConsume("ESCAPED_CHAR");
+      if (value) {
+        path += value;
+        continue;
       }
-    }
-    *entries() {
-      for (const name of Object.keys(this[NORMALIZED_HEADERS])) {
-        yield [name, this.get(name)];
+      if (path) {
+        result.push(path);
+        path = "";
       }
-    }
-    get(name) {
-      var _a3;
-      return (_a3 = this[NORMALIZED_HEADERS][normalizeHeaderName(name)]) != null ? _a3 : null;
-    }
-    set(name, value) {
-      const normalizedName = normalizeHeaderName(name);
-      this[NORMALIZED_HEADERS][normalizedName] = normalizeHeaderValue(value);
-      this[RAW_HEADER_NAMES].set(normalizedName, name);
-    }
-    append(name, value) {
-      const normalizedName = normalizeHeaderName(name);
-      let resolvedValue = this.has(normalizedName) ? `${this.get(normalizedName)}, ${value}` : value;
-      this.set(name, resolvedValue);
-    }
-    delete(name) {
-      if (!this.has(name)) {
-        return;
+      var open = tryConsume("OPEN");
+      if (open) {
+        var prefix = consumeText();
+        var name_1 = tryConsume("NAME") || "";
+        var pattern_1 = tryConsume("PATTERN") || "";
+        var suffix = consumeText();
+        mustConsume("CLOSE");
+        result.push({
+          name: name_1 || (pattern_1 ? key++ : ""),
+          pattern: name_1 && !pattern_1 ? defaultPattern : pattern_1,
+          prefix,
+          suffix,
+          modifier: tryConsume("MODIFIER") || ""
+        });
+        continue;
       }
-      const normalizedName = normalizeHeaderName(name);
-      delete this[NORMALIZED_HEADERS][normalizedName];
-      this[RAW_HEADER_NAMES].delete(normalizedName);
+      mustConsume("END");
     }
-    all() {
-      return this[NORMALIZED_HEADERS];
+    return result;
+  }
+  function match(str, options) {
+    var keys = [];
+    var re = pathToRegexp(str, keys, options);
+    return regexpToFunction(re, keys, options);
+  }
+  function regexpToFunction(re, keys, options) {
+    if (options === void 0) {
+      options = {};
     }
-    raw() {
-      const rawHeaders = {};
-      for (const [name, value] of this.entries()) {
-        rawHeaders[this[RAW_HEADER_NAMES].get(name)] = value;
+    var _a3 = options.decode, decode = _a3 === void 0 ? function(x) {
+      return x;
+    } : _a3;
+    return function(pathname) {
+      var m = re.exec(pathname);
+      if (!m)
+        return false;
+      var path = m[0], index = m.index;
+      var params = /* @__PURE__ */ Object.create(null);
+      var _loop_1 = function(i2) {
+        if (m[i2] === void 0)
+          return "continue";
+        var key = keys[i2 - 1];
+        if (key.modifier === "*" || key.modifier === "+") {
+          params[key.name] = m[i2].split(key.prefix + key.suffix).map(function(value) {
+            return decode(value, key);
+          });
+        } else {
+          params[key.name] = decode(m[i2], key);
+        }
+      };
+      for (var i = 1; i < m.length; i++) {
+        _loop_1(i);
       }
-      return rawHeaders;
+      return { path, index, params };
+    };
+  }
+  function escapeString(str) {
+    return str.replace(/([.+*?=^!:${}()[\]|/\\])/g, "\\$1");
+  }
+  function flags(options) {
+    return options && options.sensitive ? "" : "i";
+  }
+  function regexpToRegexp(path, keys) {
+    if (!keys)
+      return path;
+    var groupsRegex = /\((?:\?<(.*?)>)?(?!\?)/g;
+    var index = 0;
+    var execResult = groupsRegex.exec(path.source);
+    while (execResult) {
+      keys.push({
+        // Use parenthesized substring match if available, index otherwise
+        name: execResult[1] || index++,
+        prefix: "",
+        suffix: "",
+        modifier: "",
+        pattern: ""
+      });
+      execResult = groupsRegex.exec(path.source);
     }
-    has(name) {
-      return this[NORMALIZED_HEADERS].hasOwnProperty(normalizeHeaderName(name));
+    return path;
+  }
+  function arrayToRegexp(paths, keys, options) {
+    var parts = paths.map(function(path) {
+      return pathToRegexp(path, keys, options).source;
+    });
+    return new RegExp("(?:".concat(parts.join("|"), ")"), flags(options));
+  }
+  function stringToRegexp(path, keys, options) {
+    return tokensToRegexp(parse(path, options), keys, options);
+  }
+  function tokensToRegexp(tokens, keys, options) {
+    if (options === void 0) {
+      options = {};
     }
-    forEach(callback, thisArg) {
-      for (const name in this[NORMALIZED_HEADERS]) {
-        if (this[NORMALIZED_HEADERS].hasOwnProperty(name)) {
-          callback.call(thisArg, this[NORMALIZED_HEADERS][name], name, this);
+    var _a3 = options.strict, strict = _a3 === void 0 ? false : _a3, _b2 = options.start, start = _b2 === void 0 ? true : _b2, _c = options.end, end = _c === void 0 ? true : _c, _d = options.encode, encode = _d === void 0 ? function(x) {
+      return x;
+    } : _d, _e = options.delimiter, delimiter = _e === void 0 ? "/#?" : _e, _f = options.endsWith, endsWith = _f === void 0 ? "" : _f;
+    var endsWithRe = "[".concat(escapeString(endsWith), "]|$");
+    var delimiterRe = "[".concat(escapeString(delimiter), "]");
+    var route = start ? "^" : "";
+    for (var _i = 0, tokens_1 = tokens; _i < tokens_1.length; _i++) {
+      var token = tokens_1[_i];
+      if (typeof token === "string") {
+        route += escapeString(encode(token));
+      } else {
+        var prefix = escapeString(encode(token.prefix));
+        var suffix = escapeString(encode(token.suffix));
+        if (token.pattern) {
+          if (keys)
+            keys.push(token);
+          if (prefix || suffix) {
+            if (token.modifier === "+" || token.modifier === "*") {
+              var mod = token.modifier === "*" ? "?" : "";
+              route += "(?:".concat(prefix, "((?:").concat(token.pattern, ")(?:").concat(suffix).concat(prefix, "(?:").concat(token.pattern, "))*)").concat(suffix, ")").concat(mod);
+            } else {
+              route += "(?:".concat(prefix, "(").concat(token.pattern, ")").concat(suffix, ")").concat(token.modifier);
+            }
+          } else {
+            if (token.modifier === "+" || token.modifier === "*") {
+              route += "((?:".concat(token.pattern, ")").concat(token.modifier, ")");
+            } else {
+              route += "(".concat(token.pattern, ")").concat(token.modifier);
+            }
+          }
+        } else {
+          route += "(?:".concat(prefix).concat(suffix, ")").concat(token.modifier);
         }
       }
     }
-    getSetCookie() {
-      const setCookieHeader = this.get("set-cookie");
-      if (setCookieHeader === null) {
-        return [];
+    if (end) {
+      if (!strict)
+        route += "".concat(delimiterRe, "?");
+      route += !options.endsWith ? "$" : "(?=".concat(endsWithRe, ")");
+    } else {
+      var endToken = tokens[tokens.length - 1];
+      var isEndDelimited = typeof endToken === "string" ? delimiterRe.indexOf(endToken[endToken.length - 1]) > -1 : endToken === void 0;
+      if (!strict) {
+        route += "(?:".concat(delimiterRe, "(?=").concat(endsWithRe, "))?");
       }
-      if (setCookieHeader === "") {
-        return [""];
+      if (!isEndDelimited) {
+        route += "(?=".concat(delimiterRe, "|").concat(endsWithRe, ")");
       }
-      return (0, import_set_cookie_parser.splitCookiesString)(setCookieHeader);
     }
-  };
-  var singleValueHeaders = ["user-agent"];
-  function headersToObject(headers) {
-    const headersObject = {};
-    headers.forEach((value, name) => {
-      const isMultiValue = !singleValueHeaders.includes(name.toLowerCase()) && value.includes(",");
-      headersObject[name] = isMultiValue ? value.split(",").map((s) => s.trim()) : value;
-    });
-    return headersObject;
+    return new RegExp(route, flags(options));
   }
-  function stringToHeaders(str) {
-    const lines = str.trim().split(/[\r\n]+/);
-    return lines.reduce((headers, line) => {
-      if (line.trim() === "") {
-        return headers;
-      }
-      const parts = line.split(": ");
-      const name = parts.shift();
-      const value = parts.join(": ");
-      headers.append(name, value);
-      return headers;
-    }, new HeadersPolyfill());
-  }
-  function reduceHeadersObject(headers, reducer, initialState) {
-    return Object.keys(headers).reduce((nextHeaders, name) => {
-      return reducer(nextHeaders, name, headers[name]);
-    }, initialState);
-  }
-  function flattenHeadersObject(headersObject) {
-    return reduceHeadersObject(
-      headersObject,
-      (headers, name, value) => {
-        headers[name] = [].concat(value).join(", ");
-        return headers;
-      },
-      {}
-    );
+  function pathToRegexp(path, keys, options) {
+    if (path instanceof RegExp)
+      return regexpToRegexp(path, keys);
+    if (Array.isArray(path))
+      return arrayToRegexp(path, keys, options);
+    return stringToRegexp(path, keys, options);
   }
 
-  // src/core/utils/logging/serializeRequest.ts
-  function serializeRequest(request) {
-    return __async(this, null, function* () {
-      const requestClone = request.clone();
-      const requestText = yield requestClone.text();
-      return {
-        url: new URL(request.url),
-        method: request.method,
-        headers: headersToObject(request.headers),
-        body: requestText
-      };
-    });
+  // node_modules/.pnpm/is-node-process@1.2.0/node_modules/is-node-process/lib/index.mjs
+  function isNodeProcess() {
+    if (typeof navigator !== "undefined" && navigator.product === "ReactNative") {
+      return true;
+    }
+    if (typeof process !== "undefined") {
+      const type = process.type;
+      if (type === "renderer" || type === "worker") {
+        return false;
+      }
+      return !!(process.versions && process.versions.node);
+    }
+    return false;
   }
 
-  // node_modules/.pnpm/@bundled-es-modules+statuses@1.0.1/node_modules/@bundled-es-modules/statuses/index-esm.js
-  var __create2 = Object.create;
+  // node_modules/.pnpm/@open-draft+logger@0.3.0/node_modules/@open-draft/logger/lib/index.mjs
   var __defProp3 = Object.defineProperty;
-  var __getOwnPropDesc3 = Object.getOwnPropertyDescriptor;
-  var __getOwnPropNames3 = Object.getOwnPropertyNames;
-  var __getProtoOf2 = Object.getPrototypeOf;
-  var __hasOwnProp3 = Object.prototype.hasOwnProperty;
-  var __commonJS2 = (cb, mod) => function __require() {
-    return mod || (0, cb[__getOwnPropNames3(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-  };
-  var __copyProps3 = (to, from, except, desc) => {
-    if (from && typeof from === "object" || typeof from === "function") {
-      for (let key of __getOwnPropNames3(from))
-        if (!__hasOwnProp3.call(to, key) && key !== except)
-          __defProp3(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc3(from, key)) || desc.enumerable });
-    }
-    return to;
+  var __export2 = (target, all) => {
+    for (var name in all)
+      __defProp3(target, name, { get: all[name], enumerable: true });
   };
-  var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps3(
-    // 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 ? __defProp3(target, "default", { value: mod, enumerable: true }) : target,
-    mod
-  ));
-  var require_codes = __commonJS2({
-    "node_modules/statuses/codes.json"(exports, module) {
-      module.exports = {
-        "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",
-        "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",
-        "509": "Bandwidth Limit Exceeded",
-        "510": "Not Extended",
-        "511": "Network Authentication Required"
-      };
-    }
+  var colors_exports = {};
+  __export2(colors_exports, {
+    blue: () => blue,
+    gray: () => gray,
+    green: () => green,
+    red: () => red,
+    yellow: () => yellow
   });
-  var require_statuses = __commonJS2({
-    "node_modules/statuses/index.js"(exports, module) {
-      "use strict";
-      var codes = require_codes();
-      module.exports = status2;
-      status2.message = codes;
-      status2.code = createMessageToStatusCodeMap(codes);
-      status2.codes = createStatusCodeList(codes);
-      status2.redirect = {
-        300: true,
-        301: true,
-        302: true,
-        303: true,
-        305: true,
-        307: true,
-        308: true
-      };
-      status2.empty = {
-        204: true,
-        205: true,
-        304: true
-      };
-      status2.retry = {
-        502: true,
-        503: true,
-        504: true
-      };
-      function createMessageToStatusCodeMap(codes2) {
-        var map = {};
-        Object.keys(codes2).forEach(function forEachCode(code) {
-          var message3 = codes2[code];
-          var status3 = Number(code);
-          map[message3.toLowerCase()] = status3;
-        });
-        return map;
-      }
-      function createStatusCodeList(codes2) {
-        return Object.keys(codes2).map(function mapCode(code) {
-          return Number(code);
-        });
+  function yellow(text) {
+    return `\x1B[33m${text}\x1B[0m`;
+  }
+  function blue(text) {
+    return `\x1B[34m${text}\x1B[0m`;
+  }
+  function gray(text) {
+    return `\x1B[90m${text}\x1B[0m`;
+  }
+  function red(text) {
+    return `\x1B[31m${text}\x1B[0m`;
+  }
+  function green(text) {
+    return `\x1B[32m${text}\x1B[0m`;
+  }
+  var IS_NODE = isNodeProcess();
+  var Logger = class {
+    constructor(name) {
+      __publicField(this, "prefix");
+      this.name = name;
+      this.prefix = `[${this.name}]`;
+      const LOGGER_NAME = getVariable("DEBUG");
+      const LOGGER_LEVEL = getVariable("LOG_LEVEL");
+      const isLoggingEnabled = LOGGER_NAME === "1" || LOGGER_NAME === "true" || typeof LOGGER_NAME !== "undefined" && this.name.startsWith(LOGGER_NAME);
+      if (isLoggingEnabled) {
+        this.debug = isDefinedAndNotEquals(LOGGER_LEVEL, "debug") ? noop : this.debug;
+        this.info = isDefinedAndNotEquals(LOGGER_LEVEL, "info") ? noop : this.info;
+        this.success = isDefinedAndNotEquals(LOGGER_LEVEL, "success") ? noop : this.success;
+        this.warning = isDefinedAndNotEquals(LOGGER_LEVEL, "warning") ? noop : this.warning;
+        this.error = isDefinedAndNotEquals(LOGGER_LEVEL, "error") ? noop : this.error;
+      } else {
+        this.info = noop;
+        this.success = noop;
+        this.warning = noop;
+        this.error = noop;
+        this.only = noop;
       }
-      function getStatusCode(message3) {
-        var msg = message3.toLowerCase();
-        if (!Object.prototype.hasOwnProperty.call(status2.code, msg)) {
-          throw new Error('invalid status message: "' + message3 + '"');
+    }
+    extend(domain) {
+      return new Logger(`${this.name}:${domain}`);
+    }
+    /**
+     * Print a debug message.
+     * @example
+     * logger.debug('no duplicates found, creating a document...')
+     */
+    debug(message3, ...positionals) {
+      this.logEntry({
+        level: "debug",
+        message: gray(message3),
+        positionals,
+        prefix: this.prefix,
+        colors: {
+          prefix: "gray"
         }
-        return status2.code[msg];
-      }
-      function getStatusMessage(code) {
-        if (!Object.prototype.hasOwnProperty.call(status2.message, code)) {
-          throw new Error("invalid status code: " + code);
+      });
+    }
+    /**
+     * Print an info message.
+     * @example
+     * logger.info('start parsing...')
+     */
+    info(message3, ...positionals) {
+      this.logEntry({
+        level: "info",
+        message: message3,
+        positionals,
+        prefix: this.prefix,
+        colors: {
+          prefix: "blue"
         }
-        return status2.message[code];
-      }
-      function status2(code) {
-        if (typeof code === "number") {
-          return getStatusMessage(code);
+      });
+      const performance2 = new PerformanceEntry();
+      return (message22, ...positionals2) => {
+        performance2.measure();
+        this.logEntry({
+          level: "info",
+          message: `${message22} ${gray(`${performance2.deltaTime}ms`)}`,
+          positionals: positionals2,
+          prefix: this.prefix,
+          colors: {
+            prefix: "blue"
+          }
+        });
+      };
+    }
+    /**
+     * Print a success message.
+     * @example
+     * logger.success('successfully created document')
+     */
+    success(message3, ...positionals) {
+      this.logEntry({
+        level: "info",
+        message: message3,
+        positionals,
+        prefix: `\u2714 ${this.prefix}`,
+        colors: {
+          timestamp: "green",
+          prefix: "green"
         }
-        if (typeof code !== "string") {
-          throw new TypeError("code must be a number or string");
+      });
+    }
+    /**
+     * Print a warning.
+     * @example
+     * logger.warning('found legacy document format')
+     */
+    warning(message3, ...positionals) {
+      this.logEntry({
+        level: "warning",
+        message: message3,
+        positionals,
+        prefix: `\u26A0 ${this.prefix}`,
+        colors: {
+          timestamp: "yellow",
+          prefix: "yellow"
         }
-        var n = parseInt(code, 10);
-        if (!isNaN(n)) {
-          return getStatusMessage(n);
+      });
+    }
+    /**
+     * Print an error message.
+     * @example
+     * logger.error('something went wrong')
+     */
+    error(message3, ...positionals) {
+      this.logEntry({
+        level: "error",
+        message: message3,
+        positionals,
+        prefix: `\u2716 ${this.prefix}`,
+        colors: {
+          timestamp: "red",
+          prefix: "red"
         }
-        return getStatusCode(code);
-      }
+      });
     }
-  });
-  var import_statuses = __toESM2(require_statuses(), 1);
-  var source_default = import_statuses.default;
-
-  // src/core/utils/logging/serializeResponse.ts
-  var { message } = source_default;
-  function serializeResponse(response) {
-    return __async(this, null, function* () {
-      const responseClone = response.clone();
-      const responseText = yield responseClone.text();
-      const responseStatus = responseClone.status || 200;
-      const responseStatusText = responseClone.statusText || message[responseStatus] || "OK";
+    /**
+     * Execute the given callback only when the logging is enabled.
+     * This is skipped in its entirety and has no runtime cost otherwise.
+     * This executes regardless of the log level.
+     * @example
+     * logger.only(() => {
+     *   logger.info('additional info')
+     * })
+     */
+    only(callback) {
+      callback();
+    }
+    createEntry(level, message3) {
       return {
-        status: responseStatus,
-        statusText: responseStatusText,
-        headers: headersToObject(responseClone.headers),
-        body: responseText
+        timestamp: /* @__PURE__ */ new Date(),
+        level,
+        message: message3
       };
-    });
-  }
-
-  // node_modules/.pnpm/path-to-regexp@6.2.1/node_modules/path-to-regexp/dist.es2015/index.js
-  function lexer(str) {
-    var tokens = [];
-    var i = 0;
-    while (i < str.length) {
-      var char = str[i];
-      if (char === "*" || char === "+" || char === "?") {
-        tokens.push({ type: "MODIFIER", index: i, value: str[i++] });
-        continue;
-      }
-      if (char === "\\") {
-        tokens.push({ type: "ESCAPED_CHAR", index: i++, value: str[i++] });
-        continue;
-      }
-      if (char === "{") {
-        tokens.push({ type: "OPEN", index: i, value: str[i++] });
-        continue;
-      }
-      if (char === "}") {
-        tokens.push({ type: "CLOSE", index: i, value: str[i++] });
-        continue;
-      }
-      if (char === ":") {
-        var name = "";
-        var j = i + 1;
-        while (j < str.length) {
-          var code = str.charCodeAt(j);
-          if (
-            // `0-9`
-            code >= 48 && code <= 57 || // `A-Z`
-            code >= 65 && code <= 90 || // `a-z`
-            code >= 97 && code <= 122 || // `_`
-            code === 95
-          ) {
-            name += str[j++];
-            continue;
-          }
-          break;
+    }
+    logEntry(args) {
+      const {
+        level,
+        message: message3,
+        prefix,
+        colors: customColors,
+        positionals = []
+      } = args;
+      const entry = this.createEntry(level, message3);
+      const timestampColor = (customColors == null ? void 0 : customColors.timestamp) || "gray";
+      const prefixColor = (customColors == null ? void 0 : customColors.prefix) || "gray";
+      const colorize = {
+        timestamp: colors_exports[timestampColor],
+        prefix: colors_exports[prefixColor]
+      };
+      const write = this.getWriter(level);
+      write(
+        [colorize.timestamp(this.formatTimestamp(entry.timestamp))].concat(prefix != null ? colorize.prefix(prefix) : []).concat(serializeInput(message3)).join(" "),
+        ...positionals.map(serializeInput)
+      );
+    }
+    formatTimestamp(timestamp) {
+      return `${timestamp.toLocaleTimeString(
+        "en-GB"
+      )}:${timestamp.getMilliseconds()}`;
+    }
+    getWriter(level) {
+      switch (level) {
+        case "debug":
+        case "success":
+        case "info": {
+          return log;
         }
-        if (!name)
-          throw new TypeError("Missing parameter name at ".concat(i));
-        tokens.push({ type: "NAME", index: i, value: name });
-        i = j;
-        continue;
-      }
-      if (char === "(") {
-        var count = 1;
-        var pattern = "";
-        var j = i + 1;
-        if (str[j] === "?") {
-          throw new TypeError('Pattern cannot start with "?" at '.concat(j));
+        case "warning": {
+          return warn2;
         }
-        while (j < str.length) {
-          if (str[j] === "\\") {
-            pattern += str[j++] + str[j++];
-            continue;
-          }
-          if (str[j] === ")") {
-            count--;
-            if (count === 0) {
-              j++;
-              break;
-            }
-          } else if (str[j] === "(") {
-            count++;
-            if (str[j + 1] !== "?") {
-              throw new TypeError("Capturing groups are not allowed at ".concat(j));
-            }
-          }
-          pattern += str[j++];
+        case "error": {
+          return error2;
         }
-        if (count)
-          throw new TypeError("Unbalanced pattern at ".concat(i));
-        if (!pattern)
-          throw new TypeError("Missing pattern at ".concat(i));
-        tokens.push({ type: "PATTERN", index: i, value: pattern });
-        i = j;
-        continue;
       }
-      tokens.push({ type: "CHAR", index: i, value: str[i++] });
     }
-    tokens.push({ type: "END", index: i, value: "" });
-    return tokens;
+  };
+  var PerformanceEntry = class {
+    constructor() {
+      __publicField(this, "startTime");
+      __publicField(this, "endTime");
+      __publicField(this, "deltaTime");
+      this.startTime = performance.now();
+    }
+    measure() {
+      this.endTime = performance.now();
+      const deltaTime = this.endTime - this.startTime;
+      this.deltaTime = deltaTime.toFixed(2);
+    }
+  };
+  var noop = () => void 0;
+  function log(message3, ...positionals) {
+    if (IS_NODE) {
+      process.stdout.write(format(message3, ...positionals) + "\n");
+      return;
+    }
+    console.log(message3, ...positionals);
   }
-  function parse(str, options) {
-    if (options === void 0) {
-      options = {};
+  function warn2(message3, ...positionals) {
+    if (IS_NODE) {
+      process.stderr.write(format(message3, ...positionals) + "\n");
+      return;
     }
-    var tokens = lexer(str);
-    var _a3 = options.prefixes, prefixes = _a3 === void 0 ? "./" : _a3;
-    var defaultPattern = "[^".concat(escapeString(options.delimiter || "/#?"), "]+?");
-    var result = [];
-    var key = 0;
-    var i = 0;
-    var path = "";
-    var tryConsume = function(type) {
-      if (i < tokens.length && tokens[i].type === type)
-        return tokens[i++].value;
-    };
-    var mustConsume = function(type) {
-      var value2 = tryConsume(type);
-      if (value2 !== void 0)
-        return value2;
-      var _a4 = tokens[i], nextType = _a4.type, index = _a4.index;
-      throw new TypeError("Unexpected ".concat(nextType, " at ").concat(index, ", expected ").concat(type));
-    };
-    var consumeText = function() {
-      var result2 = "";
-      var value2;
-      while (value2 = tryConsume("CHAR") || tryConsume("ESCAPED_CHAR")) {
-        result2 += value2;
-      }
-      return result2;
-    };
-    while (i < tokens.length) {
-      var char = tryConsume("CHAR");
-      var name = tryConsume("NAME");
-      var pattern = tryConsume("PATTERN");
-      if (name || pattern) {
-        var prefix = char || "";
-        if (prefixes.indexOf(prefix) === -1) {
-          path += prefix;
-          prefix = "";
-        }
-        if (path) {
-          result.push(path);
-          path = "";
-        }
-        result.push({
-          name: name || key++,
-          prefix,
-          suffix: "",
-          pattern: pattern || defaultPattern,
-          modifier: tryConsume("MODIFIER") || ""
-        });
-        continue;
-      }
-      var value = char || tryConsume("ESCAPED_CHAR");
-      if (value) {
-        path += value;
-        continue;
-      }
-      if (path) {
-        result.push(path);
-        path = "";
-      }
-      var open = tryConsume("OPEN");
-      if (open) {
-        var prefix = consumeText();
-        var name_1 = tryConsume("NAME") || "";
-        var pattern_1 = tryConsume("PATTERN") || "";
-        var suffix = consumeText();
-        mustConsume("CLOSE");
-        result.push({
-          name: name_1 || (pattern_1 ? key++ : ""),
-          pattern: name_1 && !pattern_1 ? defaultPattern : pattern_1,
-          prefix,
-          suffix,
-          modifier: tryConsume("MODIFIER") || ""
-        });
-        continue;
-      }
-      mustConsume("END");
+    console.warn(message3, ...positionals);
+  }
+  function error2(message3, ...positionals) {
+    if (IS_NODE) {
+      process.stderr.write(format(message3, ...positionals) + "\n");
+      return;
     }
-    return result;
+    console.error(message3, ...positionals);
   }
-  function match(str, options) {
-    var keys = [];
-    var re = pathToRegexp(str, keys, options);
-    return regexpToFunction(re, keys, options);
+  function getVariable(variableName) {
+    var _a3;
+    if (IS_NODE) {
+      return process.env[variableName];
+    }
+    return (_a3 = globalThis[variableName]) == null ? void 0 : _a3.toString();
   }
-  function regexpToFunction(re, keys, options) {
-    if (options === void 0) {
-      options = {};
+  function isDefinedAndNotEquals(value, expected) {
+    return value !== void 0 && value !== expected;
+  }
+  function serializeInput(message3) {
+    if (typeof message3 === "undefined") {
+      return "undefined";
     }
-    var _a3 = options.decode, decode = _a3 === void 0 ? function(x) {
-      return x;
-    } : _a3;
-    return function(pathname) {
-      var m = re.exec(pathname);
-      if (!m)
-        return false;
-      var path = m[0], index = m.index;
-      var params = /* @__PURE__ */ Object.create(null);
-      var _loop_1 = function(i2) {
-        if (m[i2] === void 0)
-          return "continue";
-        var key = keys[i2 - 1];
-        if (key.modifier === "*" || key.modifier === "+") {
-          params[key.name] = m[i2].split(key.prefix + key.suffix).map(function(value) {
-            return decode(value, key);
-          });
-        } else {
-          params[key.name] = decode(m[i2], key);
-        }
-      };
-      for (var i = 1; i < m.length; i++) {
-        _loop_1(i);
-      }
-      return { path, index, params };
-    };
-  }
-  function escapeString(str) {
-    return str.replace(/([.+*?=^!:${}()[\]|/\\])/g, "\\$1");
-  }
-  function flags(options) {
-    return options && options.sensitive ? "" : "i";
-  }
-  function regexpToRegexp(path, keys) {
-    if (!keys)
-      return path;
-    var groupsRegex = /\((?:\?<(.*?)>)?(?!\?)/g;
-    var index = 0;
-    var execResult = groupsRegex.exec(path.source);
-    while (execResult) {
-      keys.push({
-        // Use parenthesized substring match if available, index otherwise
-        name: execResult[1] || index++,
-        prefix: "",
-        suffix: "",
-        modifier: "",
-        pattern: ""
-      });
-      execResult = groupsRegex.exec(path.source);
+    if (message3 === null) {
+      return "null";
     }
-    return path;
-  }
-  function arrayToRegexp(paths, keys, options) {
-    var parts = paths.map(function(path) {
-      return pathToRegexp(path, keys, options).source;
-    });
-    return new RegExp("(?:".concat(parts.join("|"), ")"), flags(options));
+    if (typeof message3 === "string") {
+      return message3;
+    }
+    if (typeof message3 === "object") {
+      return JSON.stringify(message3);
+    }
+    return message3.toString();
   }
-  function stringToRegexp(path, keys, options) {
-    return tokensToRegexp(parse(path, options), keys, options);
+
+  // node_modules/.pnpm/@mswjs+interceptors@0.25.1/node_modules/@mswjs/interceptors/lib/node/chunk-RGYCLCLK.mjs
+  function nextTick(callback) {
+    setTimeout(callback, 0);
   }
-  function tokensToRegexp(tokens, keys, options) {
-    if (options === void 0) {
-      options = {};
+  var AsyncEventEmitter = class extends Emitter {
+    constructor() {
+      super();
+      this.logger = new Logger("async-event-emitter");
+      this.queue = /* @__PURE__ */ new Map();
+      this.readyState = "ACTIVE";
     }
-    var _a3 = options.strict, strict = _a3 === void 0 ? false : _a3, _b2 = options.start, start = _b2 === void 0 ? true : _b2, _c = options.end, end = _c === void 0 ? true : _c, _d = options.encode, encode = _d === void 0 ? function(x) {
-      return x;
-    } : _d, _e = options.delimiter, delimiter = _e === void 0 ? "/#?" : _e, _f = options.endsWith, endsWith = _f === void 0 ? "" : _f;
-    var endsWithRe = "[".concat(escapeString(endsWith), "]|$");
-    var delimiterRe = "[".concat(escapeString(delimiter), "]");
-    var route = start ? "^" : "";
-    for (var _i = 0, tokens_1 = tokens; _i < tokens_1.length; _i++) {
-      var token = tokens_1[_i];
-      if (typeof token === "string") {
-        route += escapeString(encode(token));
-      } else {
-        var prefix = escapeString(encode(token.prefix));
-        var suffix = escapeString(encode(token.suffix));
-        if (token.pattern) {
-          if (keys)
-            keys.push(token);
-          if (prefix || suffix) {
-            if (token.modifier === "+" || token.modifier === "*") {
-              var mod = token.modifier === "*" ? "?" : "";
-              route += "(?:".concat(prefix, "((?:").concat(token.pattern, ")(?:").concat(suffix).concat(prefix, "(?:").concat(token.pattern, "))*)").concat(suffix, ")").concat(mod);
-            } else {
-              route += "(?:".concat(prefix, "(").concat(token.pattern, ")").concat(suffix, ")").concat(token.modifier);
-            }
-          } else {
-            if (token.modifier === "+" || token.modifier === "*") {
-              route += "((?:".concat(token.pattern, ")").concat(token.modifier, ")");
-            } else {
-              route += "(".concat(token.pattern, ")").concat(token.modifier);
-            }
-          }
-        } else {
-          route += "(?:".concat(prefix).concat(suffix, ")").concat(token.modifier);
-        }
+    on(eventName, listener) {
+      const logger = this.logger.extend("on");
+      logger.info('adding "%s" listener...', eventName);
+      if (this.readyState === "DEACTIVATED") {
+        logger.info("the emitter is destroyed, skipping!");
+        return this;
       }
+      return super.on(eventName, (...args) => __async(this, null, function* () {
+        const queue = this.openListenerQueue(eventName);
+        logger.info('awaiting the "%s" listener...', eventName);
+        queue.push({
+          args,
+          done: new Promise((resolve, reject) => __async(this, null, function* () {
+            try {
+              yield listener(...args);
+              resolve();
+              logger.info('"%s" listener has resolved!', eventName);
+            } catch (error3) {
+              logger.info('"%s" listener has rejected!', error3);
+              reject(error3);
+            }
+          }))
+        });
+      }));
     }
-    if (end) {
-      if (!strict)
-        route += "".concat(delimiterRe, "?");
-      route += !options.endsWith ? "$" : "(?=".concat(endsWithRe, ")");
-    } else {
-      var endToken = tokens[tokens.length - 1];
-      var isEndDelimited = typeof endToken === "string" ? delimiterRe.indexOf(endToken[endToken.length - 1]) > -1 : endToken === void 0;
-      if (!strict) {
-        route += "(?:".concat(delimiterRe, "(?=").concat(endsWithRe, "))?");
+    emit(eventName, ...data) {
+      const logger = this.logger.extend("emit");
+      logger.info('emitting "%s" event...', eventName);
+      if (this.readyState === "DEACTIVATED") {
+        logger.info("the emitter is destroyed, skipping!");
+        return false;
       }
-      if (!isEndDelimited) {
-        route += "(?=".concat(delimiterRe, "|").concat(endsWithRe, ")");
+      if (this.isInternalEventName(eventName)) {
+        return super.emit(eventName, ...data);
       }
+      this.openListenerQueue(eventName);
+      logger.info('appending a one-time cleanup "%s" listener...', eventName);
+      this.once(eventName, () => {
+        nextTick(() => {
+          this.queue.delete(eventName);
+          logger.info('cleaned up "%s" listeners queue!', eventName);
+        });
+      });
+      return super.emit(eventName, ...data);
     }
-    return new RegExp(route, flags(options));
-  }
-  function pathToRegexp(path, keys, options) {
-    if (path instanceof RegExp)
-      return regexpToRegexp(path, keys);
-    if (Array.isArray(path))
-      return arrayToRegexp(path, keys, options);
-    return stringToRegexp(path, keys, options);
-  }
-
-  // node_modules/.pnpm/is-node-process@1.2.0/node_modules/is-node-process/lib/index.mjs
-  function isNodeProcess() {
-    if (typeof navigator !== "undefined" && navigator.product === "ReactNative") {
-      return true;
+    /**
+     * Returns a promise that resolves when all the listeners for the given event
+     * has been called. Awaits asynchronous listeners.
+     * If the event has no listeners, resolves immediately.
+     */
+    untilIdle(eventName, filter = () => true) {
+      return __async(this, null, function* () {
+        const listenersQueue = this.queue.get(eventName) || [];
+        yield Promise.all(
+          listenersQueue.filter(filter).map(({ done }) => done)
+        ).finally(() => {
+          this.queue.delete(eventName);
+        });
+      });
     }
-    if (typeof process !== "undefined") {
-      const type = process.type;
-      if (type === "renderer" || type === "worker") {
-        return false;
+    openListenerQueue(eventName) {
+      const logger = this.logger.extend("openListenerQueue");
+      logger.info('opening "%s" listeners queue...', eventName);
+      const queue = this.queue.get(eventName);
+      if (!queue) {
+        logger.info("no queue found, creating one...");
+        this.queue.set(eventName, []);
+        return [];
       }
-      return !!(process.versions && process.versions.node);
+      logger.info("returning an exising queue:", queue);
+      return queue;
+    }
+    removeAllListeners(eventName) {
+      const logger = this.logger.extend("removeAllListeners");
+      logger.info("event:", eventName);
+      if (eventName) {
+        this.queue.delete(eventName);
+        logger.info(
+          'cleared the "%s" listeners queue!',
+          eventName,
+          this.queue.get(eventName)
+        );
+      } else {
+        this.queue.clear();
+        logger.info("cleared the listeners queue!", this.queue);
+      }
+      return super.removeAllListeners(eventName);
+    }
+    activate() {
+      const logger = this.logger.extend("activate");
+      this.readyState = "ACTIVE";
+      logger.info("set state to:", this.readyState);
+    }
+    /**
+     * Deactivate this event emitter.
+     * Deactivated emitter can no longer emit and listen to events
+     * and needs to be activated again in order to do so.
+     */
+    deactivate() {
+      const logger = this.logger.extend("deactivate");
+      logger.info("removing all listeners...");
+      this.removeAllListeners();
+      this.readyState = "DEACTIVATED";
+      logger.info("set state to:", this.readyState);
+    }
+    isInternalEventName(eventName) {
+      return eventName === "newListener" || eventName === "removeListener";
     }
-    return false;
-  }
-
-  // node_modules/.pnpm/@open-draft+logger@0.3.0/node_modules/@open-draft/logger/lib/index.mjs
-  var __defProp4 = Object.defineProperty;
-  var __export2 = (target, all) => {
-    for (var name in all)
-      __defProp4(target, name, { get: all[name], enumerable: true });
   };
-  var colors_exports = {};
-  __export2(colors_exports, {
-    blue: () => blue,
-    gray: () => gray,
-    green: () => green,
-    red: () => red,
-    yellow: () => yellow
-  });
-  function yellow(text) {
-    return `\x1B[33m${text}\x1B[0m`;
-  }
-  function blue(text) {
-    return `\x1B[34m${text}\x1B[0m`;
-  }
-  function gray(text) {
-    return `\x1B[90m${text}\x1B[0m`;
+  function getGlobalSymbol(symbol) {
+    return (
+      // @ts-ignore https://github.com/Microsoft/TypeScript/issues/24587
+      globalThis[symbol] || void 0
+    );
   }
-  function red(text) {
-    return `\x1B[31m${text}\x1B[0m`;
+  function setGlobalSymbol(symbol, value) {
+    globalThis[symbol] = value;
   }
-  function green(text) {
-    return `\x1B[32m${text}\x1B[0m`;
+  function deleteGlobalSymbol(symbol) {
+    delete globalThis[symbol];
   }
-  var IS_NODE = isNodeProcess();
-  var Logger = class {
-    constructor(name) {
-      __publicField(this, "prefix");
-      this.name = name;
-      this.prefix = `[${this.name}]`;
-      const LOGGER_NAME = getVariable("DEBUG");
-      const LOGGER_LEVEL = getVariable("LOG_LEVEL");
-      const isLoggingEnabled = LOGGER_NAME === "1" || LOGGER_NAME === "true" || typeof LOGGER_NAME !== "undefined" && this.name.startsWith(LOGGER_NAME);
-      if (isLoggingEnabled) {
-        this.debug = isDefinedAndNotEquals(LOGGER_LEVEL, "debug") ? noop : this.debug;
-        this.info = isDefinedAndNotEquals(LOGGER_LEVEL, "info") ? noop : this.info;
-        this.success = isDefinedAndNotEquals(LOGGER_LEVEL, "success") ? noop : this.success;
-        this.warning = isDefinedAndNotEquals(LOGGER_LEVEL, "warning") ? noop : this.warning;
-        this.error = isDefinedAndNotEquals(LOGGER_LEVEL, "error") ? noop : this.error;
-      } else {
-        this.info = noop;
-        this.success = noop;
-        this.warning = noop;
-        this.error = noop;
-        this.only = noop;
-      }
-    }
-    extend(domain) {
-      return new Logger(`${this.name}:${domain}`);
+  var Interceptor = class {
+    constructor(symbol) {
+      this.symbol = symbol;
+      this.readyState = "INACTIVE";
+      this.emitter = new AsyncEventEmitter();
+      this.subscriptions = [];
+      this.logger = new Logger(symbol.description);
+      this.emitter.setMaxListeners(0);
+      this.logger.info("constructing the interceptor...");
     }
     /**
-     * Print a debug message.
-     * @example
-     * logger.debug('no duplicates found, creating a document...')
+     * Determine if this interceptor can be applied
+     * in the current environment.
      */
-    debug(message3, ...positionals) {
-      this.logEntry({
-        level: "debug",
-        message: gray(message3),
-        positionals,
-        prefix: this.prefix,
-        colors: {
-          prefix: "gray"
-        }
-      });
+    checkEnvironment() {
+      return true;
     }
     /**
-     * Print an info message.
-     * @example
-     * logger.info('start parsing...')
+     * Apply this interceptor to the current process.
+     * Returns an already running interceptor instance if it's present.
      */
-    info(message3, ...positionals) {
-      this.logEntry({
-        level: "info",
-        message: message3,
-        positionals,
-        prefix: this.prefix,
-        colors: {
-          prefix: "blue"
-        }
-      });
-      const performance2 = new PerformanceEntry();
-      return (message22, ...positionals2) => {
-        performance2.measure();
-        this.logEntry({
-          level: "info",
-          message: `${message22} ${gray(`${performance2.deltaTime}ms`)}`,
-          positionals: positionals2,
-          prefix: this.prefix,
-          colors: {
-            prefix: "blue"
-          }
-        });
-      };
+    apply() {
+      const logger = this.logger.extend("apply");
+      logger.info("applying the interceptor...");
+      if (this.readyState === "APPLIED") {
+        logger.info("intercepted already applied!");
+        return;
+      }
+      const shouldApply = this.checkEnvironment();
+      if (!shouldApply) {
+        logger.info("the interceptor cannot be applied in this environment!");
+        return;
+      }
+      this.readyState = "APPLYING";
+      this.emitter.activate();
+      logger.info("activated the emiter!", this.emitter.readyState);
+      const runningInstance = this.getInstance();
+      if (runningInstance) {
+        logger.info("found a running instance, reusing...");
+        this.on = (event, listener) => {
+          logger.info('proxying the "%s" listener', event);
+          runningInstance.emitter.addListener(event, listener);
+          this.subscriptions.push(() => {
+            runningInstance.emitter.removeListener(event, listener);
+            logger.info('removed proxied "%s" listener!', event);
+          });
+        };
+        this.readyState = "APPLIED";
+        return;
+      }
+      logger.info("no running instance found, setting up a new instance...");
+      this.setup();
+      this.setInstance();
+      this.readyState = "APPLIED";
     }
     /**
-     * Print a success message.
-     * @example
-     * logger.success('successfully created document')
+     * Setup the module augments and stubs necessary for this interceptor.
+     * This method is not run if there's a running interceptor instance
+     * to prevent instantiating an interceptor multiple times.
      */
-    success(message3, ...positionals) {
-      this.logEntry({
-        level: "info",
-        message: message3,
-        positionals,
-        prefix: `\u2714 ${this.prefix}`,
-        colors: {
-          timestamp: "green",
-          prefix: "green"
-        }
-      });
+    setup() {
     }
     /**
-     * Print a warning.
-     * @example
-     * logger.warning('found legacy document format')
+     * Listen to the interceptor's public events.
      */
-    warning(message3, ...positionals) {
-      this.logEntry({
-        level: "warning",
-        message: message3,
-        positionals,
-        prefix: `\u26A0 ${this.prefix}`,
-        colors: {
-          timestamp: "yellow",
-          prefix: "yellow"
-        }
-      });
+    on(eventName, listener) {
+      const logger = this.logger.extend("on");
+      if (this.readyState === "DISPOSING" || this.readyState === "DISPOSED") {
+        logger.info("cannot listen to events, already disposed!");
+        return;
+      }
+      logger.info('adding "%s" event listener:', eventName, listener.name);
+      this.emitter.on(eventName, listener);
     }
     /**
-     * Print an error message.
-     * @example
-     * logger.error('something went wrong')
+     * Disposes of any side-effects this interceptor has introduced.
      */
-    error(message3, ...positionals) {
-      this.logEntry({
-        level: "error",
-        message: message3,
-        positionals,
-        prefix: `\u2716 ${this.prefix}`,
-        colors: {
-          timestamp: "red",
-          prefix: "red"
+    dispose() {
+      const logger = this.logger.extend("dispose");
+      if (this.readyState === "DISPOSED") {
+        logger.info("cannot dispose, already disposed!");
+        return;
+      }
+      logger.info("disposing the interceptor...");
+      this.readyState = "DISPOSING";
+      if (!this.getInstance()) {
+        logger.info("no interceptors running, skipping dispose...");
+        return;
+      }
+      this.clearInstance();
+      logger.info("global symbol deleted:", getGlobalSymbol(this.symbol));
+      if (this.subscriptions.length > 0) {
+        logger.info("disposing of %d subscriptions...", this.subscriptions.length);
+        for (const dispose of this.subscriptions) {
+          dispose();
         }
-      });
-    }
-    /**
-     * Execute the given callback only when the logging is enabled.
-     * This is skipped in its entirety and has no runtime cost otherwise.
-     * This executes regardless of the log level.
-     * @example
-     * logger.only(() => {
-     *   logger.info('additional info')
-     * })
-     */
-    only(callback) {
-      callback();
+        this.subscriptions = [];
+        logger.info("disposed of all subscriptions!", this.subscriptions.length);
+      }
+      this.emitter.deactivate();
+      logger.info("destroyed the listener!");
+      this.readyState = "DISPOSED";
     }
-    createEntry(level, message3) {
-      return {
-        timestamp: /* @__PURE__ */ new Date(),
-        level,
-        message: message3
-      };
+    getInstance() {
+      var _a3;
+      const instance = getGlobalSymbol(this.symbol);
+      this.logger.info("retrieved global instance:", (_a3 = instance == null ? void 0 : instance.constructor) == null ? void 0 : _a3.name);
+      return instance;
     }
-    logEntry(args) {
-      const {
-        level,
-        message: message3,
-        prefix,
-        colors: customColors,
-        positionals = []
-      } = args;
-      const entry = this.createEntry(level, message3);
-      const timestampColor = (customColors == null ? void 0 : customColors.timestamp) || "gray";
-      const prefixColor = (customColors == null ? void 0 : customColors.prefix) || "gray";
-      const colorize = {
-        timestamp: colors_exports[timestampColor],
-        prefix: colors_exports[prefixColor]
-      };
-      const write = this.getWriter(level);
-      write(
-        [colorize.timestamp(this.formatTimestamp(entry.timestamp))].concat(prefix != null ? colorize.prefix(prefix) : []).concat(serializeInput(message3)).join(" "),
-        ...positionals.map(serializeInput)
-      );
+    setInstance() {
+      setGlobalSymbol(this.symbol, this);
+      this.logger.info("set global instance!", this.symbol.description);
     }
-    formatTimestamp(timestamp) {
-      return `${timestamp.toLocaleTimeString(
-        "en-GB"
-      )}:${timestamp.getMilliseconds()}`;
-    }
-    getWriter(level) {
-      switch (level) {
-        case "debug":
-        case "success":
-        case "info": {
-          return log;
-        }
-        case "warning": {
-          return warn2;
-        }
-        case "error": {
-          return error2;
-        }
-      }
+    clearInstance() {
+      deleteGlobalSymbol(this.symbol);
+      this.logger.info("cleared global instance!", this.symbol.description);
     }
   };
-  var PerformanceEntry = class {
-    constructor() {
-      __publicField(this, "startTime");
-      __publicField(this, "endTime");
-      __publicField(this, "deltaTime");
-      this.startTime = performance.now();
-    }
-    measure() {
-      this.endTime = performance.now();
-      const deltaTime = this.endTime - this.startTime;
-      this.deltaTime = deltaTime.toFixed(2);
+
+  // node_modules/.pnpm/@mswjs+interceptors@0.25.1/node_modules/@mswjs/interceptors/lib/node/chunk-VS3GJPUE.mjs
+  var BatchInterceptor = class extends Interceptor {
+    constructor(options) {
+      BatchInterceptor.symbol = Symbol(options.name);
+      super(BatchInterceptor.symbol);
+      this.interceptors = options.interceptors;
     }
-  };
-  var noop = () => void 0;
-  function log(message3, ...positionals) {
-    if (IS_NODE) {
-      process.stdout.write(format(message3, ...positionals) + "\n");
-      return;
+    setup() {
+      const logger = this.logger.extend("setup");
+      logger.info("applying all %d interceptors...", this.interceptors.length);
+      for (const interceptor of this.interceptors) {
+        logger.info('applying "%s" interceptor...', interceptor.constructor.name);
+        interceptor.apply();
+        logger.info("adding interceptor dispose subscription");
+        this.subscriptions.push(() => interceptor.dispose());
+      }
     }
-    console.log(message3, ...positionals);
-  }
-  function warn2(message3, ...positionals) {
-    if (IS_NODE) {
-      process.stderr.write(format(message3, ...positionals) + "\n");
-      return;
+    on(event, listener) {
+      this.interceptors.forEach((interceptor) => {
+        interceptor.on(event, listener);
+      });
     }
-    console.warn(message3, ...positionals);
+  };
+
+  // node_modules/.pnpm/@mswjs+interceptors@0.25.1/node_modules/@mswjs/interceptors/lib/node/chunk-7II4SWKS.mjs
+  var encoder = new TextEncoder();
+
+  // node_modules/.pnpm/@mswjs+interceptors@0.25.1/node_modules/@mswjs/interceptors/lib/node/chunk-GFH37L5D.mjs
+  var IS_PATCHED_MODULE = Symbol("isPatchedModule");
+
+  // node_modules/.pnpm/@mswjs+interceptors@0.25.1/node_modules/@mswjs/interceptors/lib/node/index.mjs
+  function getCleanUrl(url, isAbsolute = true) {
+    return [isAbsolute && url.origin, url.pathname].filter(Boolean).join("");
   }
-  function error2(message3, ...positionals) {
-    if (IS_NODE) {
-      process.stderr.write(format(message3, ...positionals) + "\n");
-      return;
-    }
-    console.error(message3, ...positionals);
+
+  // src/core/utils/url/cleanUrl.ts
+  var REDUNDANT_CHARACTERS_EXP = /[\?|#].*$/g;
+  function getSearchParams(path) {
+    return new URL(`/${path}`, "http://localhost").searchParams;
   }
-  function getVariable(variableName) {
-    var _a3;
-    if (IS_NODE) {
-      return process.env[variableName];
-    }
-    return (_a3 = globalThis[variableName]) == null ? void 0 : _a3.toString();
+  function cleanUrl(path) {
+    return path.replace(REDUNDANT_CHARACTERS_EXP, "");
   }
-  function isDefinedAndNotEquals(value, expected) {
-    return value !== void 0 && value !== expected;
+
+  // src/core/utils/url/isAbsoluteUrl.ts
+  function isAbsoluteUrl(url) {
+    return /^([a-z][a-z\d\+\-\.]*:)?\/\//i.test(url);
   }
-  function serializeInput(message3) {
-    if (typeof message3 === "undefined") {
-      return "undefined";
-    }
-    if (message3 === null) {
-      return "null";
-    }
-    if (typeof message3 === "string") {
-      return message3;
+
+  // src/core/utils/url/getAbsoluteUrl.ts
+  function getAbsoluteUrl(path, baseUrl) {
+    if (isAbsoluteUrl(path)) {
+      return path;
     }
-    if (typeof message3 === "object") {
-      return JSON.stringify(message3);
+    if (path.startsWith("*")) {
+      return path;
     }
-    return message3.toString();
+    const origin = baseUrl || typeof document !== "undefined" && document.baseURI;
+    return origin ? (
+      // Encode and decode the path to preserve escaped characters.
+      decodeURI(new URL(encodeURI(path), origin).href)
+    ) : path;
   }
 
-  // node_modules/.pnpm/@mswjs+interceptors@0.25.1/node_modules/@mswjs/interceptors/lib/node/chunk-RGYCLCLK.mjs
-  function nextTick(callback) {
-    setTimeout(callback, 0);
-  }
-  var AsyncEventEmitter = class extends Emitter {
-    constructor() {
-      super();
-      this.logger = new Logger("async-event-emitter");
-      this.queue = /* @__PURE__ */ new Map();
-      this.readyState = "ACTIVE";
-    }
-    on(eventName, listener) {
-      const logger = this.logger.extend("on");
-      logger.info('adding "%s" listener...', eventName);
-      if (this.readyState === "DEACTIVATED") {
-        logger.info("the emitter is destroyed, skipping!");
-        return this;
-      }
-      return super.on(eventName, (...args) => __async(this, null, function* () {
-        const queue = this.openListenerQueue(eventName);
-        logger.info('awaiting the "%s" listener...', eventName);
-        queue.push({
-          args,
-          done: new Promise((resolve, reject) => __async(this, null, function* () {
-            try {
-              yield listener(...args);
-              resolve();
-              logger.info('"%s" listener has resolved!', eventName);
-            } catch (error3) {
-              logger.info('"%s" listener has rejected!', error3);
-              reject(error3);
-            }
-          }))
-        });
-      }));
+  // src/core/utils/matching/normalizePath.ts
+  function normalizePath(path, baseUrl) {
+    if (path instanceof RegExp) {
+      return path;
     }
-    emit(eventName, ...data) {
-      const logger = this.logger.extend("emit");
-      logger.info('emitting "%s" event...', eventName);
-      if (this.readyState === "DEACTIVATED") {
-        logger.info("the emitter is destroyed, skipping!");
-        return false;
-      }
-      if (this.isInternalEventName(eventName)) {
-        return super.emit(eventName, ...data);
+    const maybeAbsoluteUrl = getAbsoluteUrl(path, baseUrl);
+    return cleanUrl(maybeAbsoluteUrl);
+  }
+
+  // src/core/utils/matching/matchRequestUrl.ts
+  function coercePath(path) {
+    return path.replace(
+      /([:a-zA-Z_-]*)(\*{1,2})+/g,
+      (_, parameterName, wildcard) => {
+        const expression = "(.*)";
+        if (!parameterName) {
+          return expression;
+        }
+        return parameterName.startsWith(":") ? `${parameterName}${wildcard}` : `${parameterName}${expression}`;
       }
-      this.openListenerQueue(eventName);
-      logger.info('appending a one-time cleanup "%s" listener...', eventName);
-      this.once(eventName, () => {
-        nextTick(() => {
-          this.queue.delete(eventName);
-          logger.info('cleaned up "%s" listeners queue!', eventName);
-        });
-      });
-      return super.emit(eventName, ...data);
+    ).replace(/([^\/])(:)(?=\d+)/, "$1\\$2").replace(/^([^\/]+)(:)(?=\/\/)/, "$1\\$2");
+  }
+  function matchRequestUrl(url, path, baseUrl) {
+    const normalizedPath = normalizePath(path, baseUrl);
+    const cleanPath = typeof normalizedPath === "string" ? coercePath(normalizedPath) : normalizedPath;
+    const cleanUrl2 = getCleanUrl(url);
+    const result = match(cleanPath, { decode: decodeURIComponent })(cleanUrl2);
+    const params = result && result.params || {};
+    return {
+      matches: result !== false,
+      params
+    };
+  }
+
+  // src/core/utils/request/getPublicUrlFromRequest.ts
+  function getPublicUrlFromRequest(request) {
+    if (typeof location === "undefined") {
+      return request.url;
     }
-    /**
-     * Returns a promise that resolves when all the listeners for the given event
-     * has been called. Awaits asynchronous listeners.
-     * If the event has no listeners, resolves immediately.
-     */
-    untilIdle(eventName, filter = () => true) {
-      return __async(this, null, function* () {
-        const listenersQueue = this.queue.get(eventName) || [];
-        yield Promise.all(
-          listenersQueue.filter(filter).map(({ done }) => done)
-        ).finally(() => {
-          this.queue.delete(eventName);
-        });
-      });
-    }
-    openListenerQueue(eventName) {
-      const logger = this.logger.extend("openListenerQueue");
-      logger.info('opening "%s" listeners queue...', eventName);
-      const queue = this.queue.get(eventName);
-      if (!queue) {
-        logger.info("no queue found, creating one...");
-        this.queue.set(eventName, []);
-        return [];
-      }
-      logger.info("returning an exising queue:", queue);
-      return queue;
-    }
-    removeAllListeners(eventName) {
-      const logger = this.logger.extend("removeAllListeners");
-      logger.info("event:", eventName);
-      if (eventName) {
-        this.queue.delete(eventName);
-        logger.info(
-          'cleared the "%s" listeners queue!',
-          eventName,
-          this.queue.get(eventName)
-        );
-      } else {
-        this.queue.clear();
-        logger.info("cleared the listeners queue!", this.queue);
-      }
-      return super.removeAllListeners(eventName);
-    }
-    activate() {
-      const logger = this.logger.extend("activate");
-      this.readyState = "ACTIVE";
-      logger.info("set state to:", this.readyState);
-    }
-    /**
-     * Deactivate this event emitter.
-     * Deactivated emitter can no longer emit and listen to events
-     * and needs to be activated again in order to do so.
-     */
-    deactivate() {
-      const logger = this.logger.extend("deactivate");
-      logger.info("removing all listeners...");
-      this.removeAllListeners();
-      this.readyState = "DEACTIVATED";
-      logger.info("set state to:", this.readyState);
-    }
-    isInternalEventName(eventName) {
-      return eventName === "newListener" || eventName === "removeListener";
+    const url = new URL(request.url);
+    return url.origin === location.origin ? url.pathname : url.origin + url.pathname;
+  }
+
+  // node_modules/.pnpm/@bundled-es-modules+cookie@2.0.0/node_modules/@bundled-es-modules/cookie/index-esm.js
+  var __create2 = Object.create;
+  var __defProp4 = Object.defineProperty;
+  var __getOwnPropDesc3 = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames3 = Object.getOwnPropertyNames;
+  var __getProtoOf2 = Object.getPrototypeOf;
+  var __hasOwnProp3 = Object.prototype.hasOwnProperty;
+  var __commonJS2 = (cb, mod) => function __require() {
+    return mod || (0, cb[__getOwnPropNames3(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  var __copyProps3 = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames3(from))
+        if (!__hasOwnProp3.call(to, key) && key !== except)
+          __defProp4(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc3(from, key)) || desc.enumerable });
     }
+    return to;
   };
-  function getGlobalSymbol(symbol) {
-    return (
-      // @ts-ignore https://github.com/Microsoft/TypeScript/issues/24587
-      globalThis[symbol] || void 0
-    );
-  }
-  function setGlobalSymbol(symbol, value) {
-    globalThis[symbol] = value;
-  }
-  function deleteGlobalSymbol(symbol) {
-    delete globalThis[symbol];
-  }
-  var Interceptor = class {
-    constructor(symbol) {
-      this.symbol = symbol;
-      this.readyState = "INACTIVE";
-      this.emitter = new AsyncEventEmitter();
-      this.subscriptions = [];
-      this.logger = new Logger(symbol.description);
-      this.emitter.setMaxListeners(0);
-      this.logger.info("constructing the interceptor...");
-    }
-    /**
-     * Determine if this interceptor can be applied
-     * in the current environment.
-     */
-    checkEnvironment() {
-      return true;
-    }
-    /**
-     * Apply this interceptor to the current process.
-     * Returns an already running interceptor instance if it's present.
-     */
-    apply() {
-      const logger = this.logger.extend("apply");
-      logger.info("applying the interceptor...");
-      if (this.readyState === "APPLIED") {
-        logger.info("intercepted already applied!");
-        return;
+  var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps3(
+    // 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 ? __defProp4(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+  var require_cookie = __commonJS2({
+    "node_modules/cookie/index.js"(exports) {
+      "use strict";
+      exports.parse = parse3;
+      exports.serialize = serialize;
+      var __toString = Object.prototype.toString;
+      var fieldContentRegExp = /^[\u0009\u0020-\u007e\u0080-\u00ff]+$/;
+      function parse3(str, options) {
+        if (typeof str !== "string") {
+          throw new TypeError("argument str must be a string");
+        }
+        var obj = {};
+        var opt = options || {};
+        var dec = opt.decode || decode;
+        var index = 0;
+        while (index < str.length) {
+          var eqIdx = str.indexOf("=", index);
+          if (eqIdx === -1) {
+            break;
+          }
+          var endIdx = str.indexOf(";", index);
+          if (endIdx === -1) {
+            endIdx = str.length;
+          } else if (endIdx < eqIdx) {
+            index = str.lastIndexOf(";", eqIdx - 1) + 1;
+            continue;
+          }
+          var key = str.slice(index, eqIdx).trim();
+          if (void 0 === obj[key]) {
+            var val = str.slice(eqIdx + 1, endIdx).trim();
+            if (val.charCodeAt(0) === 34) {
+              val = val.slice(1, -1);
+            }
+            obj[key] = tryDecode(val, dec);
+          }
+          index = endIdx + 1;
+        }
+        return obj;
       }
-      const shouldApply = this.checkEnvironment();
-      if (!shouldApply) {
-        logger.info("the interceptor cannot be applied in this environment!");
-        return;
+      function serialize(name, val, options) {
+        var opt = options || {};
+        var enc = opt.encode || encode;
+        if (typeof enc !== "function") {
+          throw new TypeError("option encode is invalid");
+        }
+        if (!fieldContentRegExp.test(name)) {
+          throw new TypeError("argument name is invalid");
+        }
+        var value = enc(val);
+        if (value && !fieldContentRegExp.test(value)) {
+          throw new TypeError("argument val is invalid");
+        }
+        var str = name + "=" + value;
+        if (null != opt.maxAge) {
+          var maxAge = opt.maxAge - 0;
+          if (isNaN(maxAge) || !isFinite(maxAge)) {
+            throw new TypeError("option maxAge is invalid");
+          }
+          str += "; Max-Age=" + Math.floor(maxAge);
+        }
+        if (opt.domain) {
+          if (!fieldContentRegExp.test(opt.domain)) {
+            throw new TypeError("option domain is invalid");
+          }
+          str += "; Domain=" + opt.domain;
+        }
+        if (opt.path) {
+          if (!fieldContentRegExp.test(opt.path)) {
+            throw new TypeError("option path is invalid");
+          }
+          str += "; Path=" + opt.path;
+        }
+        if (opt.expires) {
+          var expires = opt.expires;
+          if (!isDate(expires) || isNaN(expires.valueOf())) {
+            throw new TypeError("option expires is invalid");
+          }
+          str += "; Expires=" + expires.toUTCString();
+        }
+        if (opt.httpOnly) {
+          str += "; HttpOnly";
+        }
+        if (opt.secure) {
+          str += "; Secure";
+        }
+        if (opt.priority) {
+          var priority = typeof opt.priority === "string" ? opt.priority.toLowerCase() : opt.priority;
+          switch (priority) {
+            case "low":
+              str += "; Priority=Low";
+              break;
+            case "medium":
+              str += "; Priority=Medium";
+              break;
+            case "high":
+              str += "; Priority=High";
+              break;
+            default:
+              throw new TypeError("option priority is invalid");
+          }
+        }
+        if (opt.sameSite) {
+          var sameSite = typeof opt.sameSite === "string" ? opt.sameSite.toLowerCase() : opt.sameSite;
+          switch (sameSite) {
+            case true:
+              str += "; SameSite=Strict";
+              break;
+            case "lax":
+              str += "; SameSite=Lax";
+              break;
+            case "strict":
+              str += "; SameSite=Strict";
+              break;
+            case "none":
+              str += "; SameSite=None";
+              break;
+            default:
+              throw new TypeError("option sameSite is invalid");
+          }
+        }
+        return str;
       }
-      this.readyState = "APPLYING";
-      this.emitter.activate();
-      logger.info("activated the emiter!", this.emitter.readyState);
-      const runningInstance = this.getInstance();
-      if (runningInstance) {
-        logger.info("found a running instance, reusing...");
-        this.on = (event, listener) => {
-          logger.info('proxying the "%s" listener', event);
-          runningInstance.emitter.addListener(event, listener);
-          this.subscriptions.push(() => {
-            runningInstance.emitter.removeListener(event, listener);
-            logger.info('removed proxied "%s" listener!', event);
-          });
-        };
-        this.readyState = "APPLIED";
-        return;
+      function decode(str) {
+        return str.indexOf("%") !== -1 ? decodeURIComponent(str) : str;
       }
-      logger.info("no running instance found, setting up a new instance...");
-      this.setup();
-      this.setInstance();
-      this.readyState = "APPLIED";
-    }
-    /**
-     * Setup the module augments and stubs necessary for this interceptor.
-     * This method is not run if there's a running interceptor instance
-     * to prevent instantiating an interceptor multiple times.
-     */
-    setup() {
-    }
-    /**
-     * Listen to the interceptor's public events.
-     */
-    on(eventName, listener) {
-      const logger = this.logger.extend("on");
-      if (this.readyState === "DISPOSING" || this.readyState === "DISPOSED") {
-        logger.info("cannot listen to events, already disposed!");
-        return;
+      function encode(val) {
+        return encodeURIComponent(val);
       }
-      logger.info('adding "%s" event listener:', eventName, listener.name);
-      this.emitter.on(eventName, listener);
-    }
-    /**
-     * Disposes of any side-effects this interceptor has introduced.
-     */
-    dispose() {
-      const logger = this.logger.extend("dispose");
-      if (this.readyState === "DISPOSED") {
-        logger.info("cannot dispose, already disposed!");
-        return;
-      }
-      logger.info("disposing the interceptor...");
-      this.readyState = "DISPOSING";
-      if (!this.getInstance()) {
-        logger.info("no interceptors running, skipping dispose...");
-        return;
-      }
-      this.clearInstance();
-      logger.info("global symbol deleted:", getGlobalSymbol(this.symbol));
-      if (this.subscriptions.length > 0) {
-        logger.info("disposing of %d subscriptions...", this.subscriptions.length);
-        for (const dispose of this.subscriptions) {
-          dispose();
-        }
-        this.subscriptions = [];
-        logger.info("disposed of all subscriptions!", this.subscriptions.length);
-      }
-      this.emitter.deactivate();
-      logger.info("destroyed the listener!");
-      this.readyState = "DISPOSED";
-    }
-    getInstance() {
-      var _a3;
-      const instance = getGlobalSymbol(this.symbol);
-      this.logger.info("retrieved global instance:", (_a3 = instance == null ? void 0 : instance.constructor) == null ? void 0 : _a3.name);
-      return instance;
-    }
-    setInstance() {
-      setGlobalSymbol(this.symbol, this);
-      this.logger.info("set global instance!", this.symbol.description);
-    }
-    clearInstance() {
-      deleteGlobalSymbol(this.symbol);
-      this.logger.info("cleared global instance!", this.symbol.description);
-    }
-  };
-
-  // node_modules/.pnpm/@mswjs+interceptors@0.25.1/node_modules/@mswjs/interceptors/lib/node/chunk-VS3GJPUE.mjs
-  var BatchInterceptor = class extends Interceptor {
-    constructor(options) {
-      BatchInterceptor.symbol = Symbol(options.name);
-      super(BatchInterceptor.symbol);
-      this.interceptors = options.interceptors;
-    }
-    setup() {
-      const logger = this.logger.extend("setup");
-      logger.info("applying all %d interceptors...", this.interceptors.length);
-      for (const interceptor of this.interceptors) {
-        logger.info('applying "%s" interceptor...', interceptor.constructor.name);
-        interceptor.apply();
-        logger.info("adding interceptor dispose subscription");
-        this.subscriptions.push(() => interceptor.dispose());
+      function isDate(val) {
+        return __toString.call(val) === "[object Date]" || val instanceof Date;
       }
-    }
-    on(event, listener) {
-      this.interceptors.forEach((interceptor) => {
-        interceptor.on(event, listener);
-      });
-    }
-  };
-
-  // node_modules/.pnpm/@mswjs+interceptors@0.25.1/node_modules/@mswjs/interceptors/lib/node/chunk-7II4SWKS.mjs
-  var encoder = new TextEncoder();
-
-  // node_modules/.pnpm/@mswjs+interceptors@0.25.1/node_modules/@mswjs/interceptors/lib/node/chunk-GFH37L5D.mjs
-  var IS_PATCHED_MODULE = Symbol("isPatchedModule");
-
-  // node_modules/.pnpm/@mswjs+interceptors@0.25.1/node_modules/@mswjs/interceptors/lib/node/index.mjs
-  function getCleanUrl(url, isAbsolute = true) {
-    return [isAbsolute && url.origin, url.pathname].filter(Boolean).join("");
-  }
-
-  // src/core/utils/url/cleanUrl.ts
-  var REDUNDANT_CHARACTERS_EXP = /[\?|#].*$/g;
-  function getSearchParams(path) {
-    return new URL(`/${path}`, "http://localhost").searchParams;
-  }
-  function cleanUrl(path) {
-    return path.replace(REDUNDANT_CHARACTERS_EXP, "");
-  }
-
-  // src/core/utils/url/isAbsoluteUrl.ts
-  function isAbsoluteUrl(url) {
-    return /^([a-z][a-z\d\+\-\.]*:)?\/\//i.test(url);
-  }
-
-  // src/core/utils/url/getAbsoluteUrl.ts
-  function getAbsoluteUrl(path, baseUrl) {
-    if (isAbsoluteUrl(path)) {
-      return path;
-    }
-    if (path.startsWith("*")) {
-      return path;
-    }
-    const origin = baseUrl || typeof document !== "undefined" && document.baseURI;
-    return origin ? (
-      // Encode and decode the path to preserve escaped characters.
-      decodeURI(new URL(encodeURI(path), origin).href)
-    ) : path;
-  }
-
-  // src/core/utils/matching/normalizePath.ts
-  function normalizePath(path, baseUrl) {
-    if (path instanceof RegExp) {
-      return path;
-    }
-    const maybeAbsoluteUrl = getAbsoluteUrl(path, baseUrl);
-    return cleanUrl(maybeAbsoluteUrl);
-  }
-
-  // src/core/utils/matching/matchRequestUrl.ts
-  function coercePath(path) {
-    return path.replace(
-      /([:a-zA-Z_-]*)(\*{1,2})+/g,
-      (_, parameterName, wildcard) => {
-        const expression = "(.*)";
-        if (!parameterName) {
-          return expression;
+      function tryDecode(str, decode2) {
+        try {
+          return decode2(str);
+        } catch (e) {
+          return str;
         }
-        return parameterName.startsWith(":") ? `${parameterName}${wildcard}` : `${parameterName}${expression}`;
       }
-    ).replace(/([^\/])(:)(?=\d+)/, "$1\\$2").replace(/^([^\/]+)(:)(?=\/\/)/, "$1\\$2");
-  }
-  function matchRequestUrl(url, path, baseUrl) {
-    const normalizedPath = normalizePath(path, baseUrl);
-    const cleanPath = typeof normalizedPath === "string" ? coercePath(normalizedPath) : normalizedPath;
-    const cleanUrl2 = getCleanUrl(url);
-    const result = match(cleanPath, { decode: decodeURIComponent })(cleanUrl2);
-    const params = result && result.params || {};
-    return {
-      matches: result !== false,
-      params
-    };
-  }
-
-  // src/core/utils/request/getPublicUrlFromRequest.ts
-  function getPublicUrlFromRequest(request) {
-    if (typeof location === "undefined") {
-      return request.url;
     }
-    const url = new URL(request.url);
-    return url.origin === location.origin ? url.pathname : url.origin + url.pathname;
-  }
+  });
+  var import_cookie = __toESM2(require_cookie(), 1);
+  var source_default2 = import_cookie.default;
 
-  // node_modules/.pnpm/@bundled-es-modules+cookie@2.0.0/node_modules/@bundled-es-modules/cookie/index-esm.js
+  // node_modules/.pnpm/@mswjs+cookies@1.0.0/node_modules/@mswjs/cookies/lib/index.mjs
   var __create3 = Object.create;
   var __defProp5 = Object.defineProperty;
   var __getOwnPropDesc4 = Object.getOwnPropertyDescriptor;
@@ -2142,243 +1974,74 @@ var MockServiceWorker = (() => {
     return to;
   };
   var __toESM3 = (mod, isNodeMode, target) => (target = mod != null ? __create3(__getProtoOf3(mod)) : {}, __copyProps4(
-    // 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 ? __defProp5(target, "default", { value: mod, enumerable: true }) : target,
     mod
   ));
-  var require_cookie = __commonJS3({
-    "node_modules/cookie/index.js"(exports) {
+  var require_set_cookie = __commonJS3({
+    "node_modules/set-cookie-parser/lib/set-cookie.js"(exports, module) {
       "use strict";
-      exports.parse = parse3;
-      exports.serialize = serialize;
-      var __toString = Object.prototype.toString;
-      var fieldContentRegExp = /^[\u0009\u0020-\u007e\u0080-\u00ff]+$/;
-      function parse3(str, options) {
-        if (typeof str !== "string") {
-          throw new TypeError("argument str must be a string");
-        }
-        var obj = {};
-        var opt = options || {};
-        var dec = opt.decode || decode;
-        var index = 0;
-        while (index < str.length) {
-          var eqIdx = str.indexOf("=", index);
-          if (eqIdx === -1) {
-            break;
+      var defaultParseOptions = {
+        decodeValues: true,
+        map: false,
+        silent: false
+      };
+      function isNonEmptyString(str) {
+        return typeof str === "string" && !!str.trim();
+      }
+      function parseString(setCookieValue, options) {
+        var parts = setCookieValue.split(";").filter(isNonEmptyString);
+        var nameValue = parts.shift().split("=");
+        var name = nameValue.shift();
+        var value = nameValue.join("=");
+        options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions;
+        var cookie = {
+          name,
+          value: options.decodeValues ? decodeURIComponent(value) : value
+        };
+        parts.forEach(function(part) {
+          var sides = part.split("=");
+          var key = sides.shift().trimLeft().toLowerCase();
+          var value2 = sides.join("=");
+          if (key === "expires") {
+            cookie.expires = new Date(value2);
+          } else if (key === "max-age") {
+            cookie.maxAge = parseInt(value2, 10);
+          } else if (key === "secure") {
+            cookie.secure = true;
+          } else if (key === "httponly") {
+            cookie.httpOnly = true;
+          } else if (key === "samesite") {
+            cookie.sameSite = value2;
+          } else {
+            cookie[key] = value2;
           }
-          var endIdx = str.indexOf(";", index);
-          if (endIdx === -1) {
-            endIdx = str.length;
-          } else if (endIdx < eqIdx) {
-            index = str.lastIndexOf(";", eqIdx - 1) + 1;
-            continue;
+        });
+        return cookie;
+      }
+      function parse3(input, options) {
+        options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions;
+        if (!input) {
+          if (!options.map) {
+            return [];
+          } else {
+            return {};
           }
-          var key = str.slice(index, eqIdx).trim();
-          if (void 0 === obj[key]) {
-            var val = str.slice(eqIdx + 1, endIdx).trim();
-            if (val.charCodeAt(0) === 34) {
-              val = val.slice(1, -1);
-            }
-            obj[key] = tryDecode(val, dec);
+        }
+        if (input.headers && input.headers["set-cookie"]) {
+          input = input.headers["set-cookie"];
+        } else if (input.headers) {
+          var sch = input.headers[Object.keys(input.headers).find(function(key) {
+            return key.toLowerCase() === "set-cookie";
+          })];
+          if (!sch && input.headers.cookie && !options.silent) {
+            console.warn(
+              "Warning: set-cookie-parser appears to have been called on a request object. It is designed to parse Set-Cookie headers from responses, not Cookie headers from requests. Set the option {silent: true} to suppress this warning."
+            );
           }
-          index = endIdx + 1;
+          input = sch;
         }
-        return obj;
-      }
-      function serialize(name, val, options) {
-        var opt = options || {};
-        var enc = opt.encode || encode;
-        if (typeof enc !== "function") {
-          throw new TypeError("option encode is invalid");
-        }
-        if (!fieldContentRegExp.test(name)) {
-          throw new TypeError("argument name is invalid");
-        }
-        var value = enc(val);
-        if (value && !fieldContentRegExp.test(value)) {
-          throw new TypeError("argument val is invalid");
-        }
-        var str = name + "=" + value;
-        if (null != opt.maxAge) {
-          var maxAge = opt.maxAge - 0;
-          if (isNaN(maxAge) || !isFinite(maxAge)) {
-            throw new TypeError("option maxAge is invalid");
-          }
-          str += "; Max-Age=" + Math.floor(maxAge);
-        }
-        if (opt.domain) {
-          if (!fieldContentRegExp.test(opt.domain)) {
-            throw new TypeError("option domain is invalid");
-          }
-          str += "; Domain=" + opt.domain;
-        }
-        if (opt.path) {
-          if (!fieldContentRegExp.test(opt.path)) {
-            throw new TypeError("option path is invalid");
-          }
-          str += "; Path=" + opt.path;
-        }
-        if (opt.expires) {
-          var expires = opt.expires;
-          if (!isDate(expires) || isNaN(expires.valueOf())) {
-            throw new TypeError("option expires is invalid");
-          }
-          str += "; Expires=" + expires.toUTCString();
-        }
-        if (opt.httpOnly) {
-          str += "; HttpOnly";
-        }
-        if (opt.secure) {
-          str += "; Secure";
-        }
-        if (opt.priority) {
-          var priority = typeof opt.priority === "string" ? opt.priority.toLowerCase() : opt.priority;
-          switch (priority) {
-            case "low":
-              str += "; Priority=Low";
-              break;
-            case "medium":
-              str += "; Priority=Medium";
-              break;
-            case "high":
-              str += "; Priority=High";
-              break;
-            default:
-              throw new TypeError("option priority is invalid");
-          }
-        }
-        if (opt.sameSite) {
-          var sameSite = typeof opt.sameSite === "string" ? opt.sameSite.toLowerCase() : opt.sameSite;
-          switch (sameSite) {
-            case true:
-              str += "; SameSite=Strict";
-              break;
-            case "lax":
-              str += "; SameSite=Lax";
-              break;
-            case "strict":
-              str += "; SameSite=Strict";
-              break;
-            case "none":
-              str += "; SameSite=None";
-              break;
-            default:
-              throw new TypeError("option sameSite is invalid");
-          }
-        }
-        return str;
-      }
-      function decode(str) {
-        return str.indexOf("%") !== -1 ? decodeURIComponent(str) : str;
-      }
-      function encode(val) {
-        return encodeURIComponent(val);
-      }
-      function isDate(val) {
-        return __toString.call(val) === "[object Date]" || val instanceof Date;
-      }
-      function tryDecode(str, decode2) {
-        try {
-          return decode2(str);
-        } catch (e) {
-          return str;
-        }
-      }
-    }
-  });
-  var import_cookie = __toESM3(require_cookie(), 1);
-  var source_default2 = import_cookie.default;
-
-  // node_modules/.pnpm/@mswjs+cookies@1.0.0/node_modules/@mswjs/cookies/lib/index.mjs
-  var __create4 = Object.create;
-  var __defProp6 = Object.defineProperty;
-  var __getOwnPropDesc5 = Object.getOwnPropertyDescriptor;
-  var __getOwnPropNames5 = Object.getOwnPropertyNames;
-  var __getProtoOf4 = Object.getPrototypeOf;
-  var __hasOwnProp5 = Object.prototype.hasOwnProperty;
-  var __commonJS4 = (cb, mod) => function __require() {
-    return mod || (0, cb[__getOwnPropNames5(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-  };
-  var __copyProps5 = (to, from, except, desc) => {
-    if (from && typeof from === "object" || typeof from === "function") {
-      for (let key of __getOwnPropNames5(from))
-        if (!__hasOwnProp5.call(to, key) && key !== except)
-          __defProp6(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc5(from, key)) || desc.enumerable });
-    }
-    return to;
-  };
-  var __toESM4 = (mod, isNodeMode, target) => (target = mod != null ? __create4(__getProtoOf4(mod)) : {}, __copyProps5(
-    isNodeMode || !mod || !mod.__esModule ? __defProp6(target, "default", { value: mod, enumerable: true }) : target,
-    mod
-  ));
-  var require_set_cookie2 = __commonJS4({
-    "node_modules/set-cookie-parser/lib/set-cookie.js"(exports, module) {
-      "use strict";
-      var defaultParseOptions = {
-        decodeValues: true,
-        map: false,
-        silent: false
-      };
-      function isNonEmptyString(str) {
-        return typeof str === "string" && !!str.trim();
-      }
-      function parseString(setCookieValue, options) {
-        var parts = setCookieValue.split(";").filter(isNonEmptyString);
-        var nameValue = parts.shift().split("=");
-        var name = nameValue.shift();
-        var value = nameValue.join("=");
-        options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions;
-        var cookie = {
-          name,
-          value: options.decodeValues ? decodeURIComponent(value) : value
-        };
-        parts.forEach(function(part) {
-          var sides = part.split("=");
-          var key = sides.shift().trimLeft().toLowerCase();
-          var value2 = sides.join("=");
-          if (key === "expires") {
-            cookie.expires = new Date(value2);
-          } else if (key === "max-age") {
-            cookie.maxAge = parseInt(value2, 10);
-          } else if (key === "secure") {
-            cookie.secure = true;
-          } else if (key === "httponly") {
-            cookie.httpOnly = true;
-          } else if (key === "samesite") {
-            cookie.sameSite = value2;
-          } else {
-            cookie[key] = value2;
-          }
-        });
-        return cookie;
-      }
-      function parse3(input, options) {
-        options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions;
-        if (!input) {
-          if (!options.map) {
-            return [];
-          } else {
-            return {};
-          }
-        }
-        if (input.headers && input.headers["set-cookie"]) {
-          input = input.headers["set-cookie"];
-        } else if (input.headers) {
-          var sch = input.headers[Object.keys(input.headers).find(function(key) {
-            return key.toLowerCase() === "set-cookie";
-          })];
-          if (!sch && input.headers.cookie && !options.silent) {
-            console.warn(
-              "Warning: set-cookie-parser appears to have been called on a request object. It is designed to parse Set-Cookie headers from responses, not Cookie headers from requests. Set the option {silent: true} to suppress this warning."
-            );
-          }
-          input = sch;
-        }
-        if (!Array.isArray(input)) {
-          input = [input];
+        if (!Array.isArray(input)) {
+          input = [input];
         }
         options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions;
         if (!options.map) {
@@ -2455,7 +2118,7 @@ var MockServiceWorker = (() => {
       module.exports.splitCookiesString = splitCookiesString;
     }
   });
-  var import_set_cookie_parser2 = __toESM4(require_set_cookie2());
+  var import_set_cookie_parser = __toESM3(require_set_cookie());
   var PERSISTENCY_KEY = "MSW_COOKIE_STORE";
   function supportsLocalStorage() {
     try {
@@ -2485,7 +2148,7 @@ var MockServiceWorker = (() => {
         return;
       }
       const now = Date.now();
-      const parsedResponseCookies = (0, import_set_cookie_parser2.parse)(responseCookies).map(
+      const parsedResponseCookies = (0, import_set_cookie_parser.parse)(responseCookies).map(
         (_a3) => {
           var _b2 = _a3, { maxAge } = _b2, cookie = __objRest(_b2, ["maxAge"]);
           return __spreadProps(__spreadValues({}, cookie), {
@@ -2508,7 +2171,7 @@ var MockServiceWorker = (() => {
           if (typeof document === "undefined") {
             return originCookies;
           }
-          const documentCookies = (0, import_set_cookie_parser2.parse)(document.cookie);
+          const documentCookies = (0, import_set_cookie_parser.parse)(document.cookie);
           documentCookies.forEach((cookie) => {
             originCookies.set(cookie.name, cookie);
           });
@@ -2657,7 +2320,7 @@ Invalid value has been removed from localStorage to prevent subsequent failed pa
           method
         },
         resolver,
-        once: options == null ? void 0 : options.once
+        options
       });
       this.checkRedundantQueryParameters();
     }
@@ -2679,46 +2342,47 @@ Invalid value has been removed from localStorage to prevent subsequent failed pa
         `Found a redundant usage of query parameters in the request handler URL for "${method} ${path}". Please match against a path instead and access query parameters in the response resolver function using "req.url.searchParams".`
       );
     }
-    parse(request, resolutionContext) {
+    parse(args) {
       return __async(this, null, function* () {
-        const url = new URL(request.url);
+        var _a3;
+        const url = new URL(args.request.url);
         const match2 = matchRequestUrl(
           url,
           this.info.path,
-          resolutionContext == null ? void 0 : resolutionContext.baseUrl
+          (_a3 = args.resolutionContext) == null ? void 0 : _a3.baseUrl
         );
-        const cookies = getAllRequestCookies(request);
+        const cookies = getAllRequestCookies(args.request);
         return {
           match: match2,
           cookies
         };
       });
     }
-    predicate(request, parsedResult) {
-      const hasMatchingMethod = this.matchMethod(request.method);
-      const hasMatchingUrl = parsedResult.match.matches;
+    predicate(args) {
+      const hasMatchingMethod = this.matchMethod(args.request.method);
+      const hasMatchingUrl = args.parsedResult.match.matches;
       return hasMatchingMethod && hasMatchingUrl;
     }
     matchMethod(actualMethod) {
       return this.info.method instanceof RegExp ? this.info.method.test(actualMethod) : isStringEqual(this.info.method, actualMethod);
     }
-    extendInfo(_request, parsedResult) {
+    extendResolverArgs(args) {
       var _a3;
       return {
-        params: ((_a3 = parsedResult.match) == null ? void 0 : _a3.params) || {},
-        cookies: parsedResult.cookies
+        params: ((_a3 = args.parsedResult.match) == null ? void 0 : _a3.params) || {},
+        cookies: args.parsedResult.cookies
       };
     }
-    log(request, response) {
+    log(args) {
       return __async(this, null, function* () {
-        const publicUrl = getPublicUrlFromRequest(request);
-        const loggedRequest = yield serializeRequest(request);
-        const loggedResponse = yield serializeResponse(response);
+        const publicUrl = getPublicUrlFromRequest(args.request);
+        const loggedRequest = yield serializeRequest(args.request);
+        const loggedResponse = yield serializeResponse(args.response);
         const statusColor = getStatusCodeColor(loggedResponse.status);
         console.groupCollapsed(
           devUtils.formatMessage("%s %s %s (%c%s%c)"),
           getTimestamp(),
-          request.method,
+          args.request.method,
           publicUrl,
           `color:${statusColor}`,
           `${loggedResponse.status} ${loggedResponse.statusText}`,
@@ -2749,7 +2413,7 @@ Invalid value has been removed from localStorage to prevent subsequent failed pa
     options: createHttpHandler("OPTIONS" /* OPTIONS */)
   };
 
-  // node_modules/.pnpm/graphql@16.8.0/node_modules/graphql/jsutils/devAssert.mjs
+  // node_modules/.pnpm/graphql@16.8.1/node_modules/graphql/jsutils/devAssert.mjs
   function devAssert(condition, message3) {
     const booleanCondition = Boolean(condition);
     if (!booleanCondition) {
@@ -2757,12 +2421,12 @@ Invalid value has been removed from localStorage to prevent subsequent failed pa
     }
   }
 
-  // node_modules/.pnpm/graphql@16.8.0/node_modules/graphql/jsutils/isObjectLike.mjs
+  // node_modules/.pnpm/graphql@16.8.1/node_modules/graphql/jsutils/isObjectLike.mjs
   function isObjectLike(value) {
     return typeof value == "object" && value !== null;
   }
 
-  // node_modules/.pnpm/graphql@16.8.0/node_modules/graphql/jsutils/invariant.mjs
+  // node_modules/.pnpm/graphql@16.8.1/node_modules/graphql/jsutils/invariant.mjs
   function invariant2(condition, message3) {
     const booleanCondition = Boolean(condition);
     if (!booleanCondition) {
@@ -2772,7 +2436,7 @@ Invalid value has been removed from localStorage to prevent subsequent failed pa
     }
   }
 
-  // node_modules/.pnpm/graphql@16.8.0/node_modules/graphql/language/location.mjs
+  // node_modules/.pnpm/graphql@16.8.1/node_modules/graphql/language/location.mjs
   var LineRegExp = /\r\n|[\n\r]/g;
   function getLocation(source, position) {
     let lastLineStart = 0;
@@ -2791,7 +2455,7 @@ Invalid value has been removed from localStorage to prevent subsequent failed pa
     };
   }
 
-  // node_modules/.pnpm/graphql@16.8.0/node_modules/graphql/language/printLocation.mjs
+  // node_modules/.pnpm/graphql@16.8.1/node_modules/graphql/language/printLocation.mjs
   function printLocation(location2) {
     return printSourceLocation(
       location2.source,
@@ -2838,7 +2502,7 @@ Invalid value has been removed from localStorage to prevent subsequent failed pa
     return existingLines.map(([prefix, line]) => prefix.padStart(padLen) + (line ? " " + line : "")).join("\n");
   }
 
-  // node_modules/.pnpm/graphql@16.8.0/node_modules/graphql/error/GraphQLError.mjs
+  // node_modules/.pnpm/graphql@16.8.1/node_modules/graphql/error/GraphQLError.mjs
   function toNormalizedOptions(args) {
     const firstArg = args[0];
     if (firstArg == null || "kind" in firstArg || "length" in firstArg) {
@@ -2987,7 +2651,7 @@ Invalid value has been removed from localStorage to prevent subsequent failed pa
     return array === void 0 || array.length === 0 ? void 0 : array;
   }
 
-  // node_modules/.pnpm/graphql@16.8.0/node_modules/graphql/error/syntaxError.mjs
+  // node_modules/.pnpm/graphql@16.8.1/node_modules/graphql/error/syntaxError.mjs
   function syntaxError(source, position, description) {
     return new GraphQLError(`Syntax Error: ${description}`, {
       source,
@@ -2995,7 +2659,7 @@ Invalid value has been removed from localStorage to prevent subsequent failed pa
     });
   }
 
-  // node_modules/.pnpm/graphql@16.8.0/node_modules/graphql/language/ast.mjs
+  // node_modules/.pnpm/graphql@16.8.1/node_modules/graphql/language/ast.mjs
   var Location = class {
     /**
      * The character offset at which this Node begins.
@@ -3161,7 +2825,7 @@ Invalid value has been removed from localStorage to prevent subsequent failed pa
     OperationTypeNode2["SUBSCRIPTION"] = "subscription";
   })(OperationTypeNode || (OperationTypeNode = {}));
 
-  // node_modules/.pnpm/graphql@16.8.0/node_modules/graphql/language/directiveLocation.mjs
+  // node_modules/.pnpm/graphql@16.8.1/node_modules/graphql/language/directiveLocation.mjs
   var DirectiveLocation;
   (function(DirectiveLocation2) {
     DirectiveLocation2["QUERY"] = "QUERY";
@@ -3185,7 +2849,7 @@ Invalid value has been removed from localStorage to prevent subsequent failed pa
     DirectiveLocation2["INPUT_FIELD_DEFINITION"] = "INPUT_FIELD_DEFINITION";
   })(DirectiveLocation || (DirectiveLocation = {}));
 
-  // node_modules/.pnpm/graphql@16.8.0/node_modules/graphql/language/kinds.mjs
+  // node_modules/.pnpm/graphql@16.8.1/node_modules/graphql/language/kinds.mjs
   var Kind;
   (function(Kind2) {
     Kind2["NAME"] = "Name";
@@ -3233,7 +2897,7 @@ Invalid value has been removed from localStorage to prevent subsequent failed pa
     Kind2["INPUT_OBJECT_TYPE_EXTENSION"] = "InputObjectTypeExtension";
   })(Kind || (Kind = {}));
 
-  // node_modules/.pnpm/graphql@16.8.0/node_modules/graphql/language/characterClasses.mjs
+  // node_modules/.pnpm/graphql@16.8.1/node_modules/graphql/language/characterClasses.mjs
   function isWhiteSpace(code) {
     return code === 9 || code === 32;
   }
@@ -3251,7 +2915,7 @@ Invalid value has been removed from localStorage to prevent subsequent failed pa
     return isLetter(code) || isDigit(code) || code === 95;
   }
 
-  // node_modules/.pnpm/graphql@16.8.0/node_modules/graphql/language/blockString.mjs
+  // node_modules/.pnpm/graphql@16.8.1/node_modules/graphql/language/blockString.mjs
   function dedentBlockStringLines(lines) {
     var _firstNonEmptyLine2;
     let commonIndent = Number.MAX_SAFE_INTEGER;
@@ -3283,7 +2947,7 @@ Invalid value has been removed from localStorage to prevent subsequent failed pa
     return i;
   }
 
-  // node_modules/.pnpm/graphql@16.8.0/node_modules/graphql/language/tokenKind.mjs
+  // node_modules/.pnpm/graphql@16.8.1/node_modules/graphql/language/tokenKind.mjs
   var TokenKind;
   (function(TokenKind2) {
     TokenKind2["SOF"] = "<SOF>";
@@ -3310,7 +2974,7 @@ Invalid value has been removed from localStorage to prevent subsequent failed pa
     TokenKind2["COMMENT"] = "Comment";
   })(TokenKind || (TokenKind = {}));
 
-  // node_modules/.pnpm/graphql@16.8.0/node_modules/graphql/language/lexer.mjs
+  // node_modules/.pnpm/graphql@16.8.1/node_modules/graphql/language/lexer.mjs
   var Lexer = class {
     /**
      * The previously focused non-ignored token.
@@ -3811,7 +3475,7 @@ Invalid value has been removed from localStorage to prevent subsequent failed pa
     );
   }
 
-  // node_modules/.pnpm/graphql@16.8.0/node_modules/graphql/jsutils/inspect.mjs
+  // node_modules/.pnpm/graphql@16.8.1/node_modules/graphql/jsutils/inspect.mjs
   var MAX_ARRAY_LENGTH = 10;
   var MAX_RECURSIVE_DEPTH = 2;
   function inspect(value) {
@@ -3894,7 +3558,7 @@ Invalid value has been removed from localStorage to prevent subsequent failed pa
     return tag;
   }
 
-  // node_modules/.pnpm/graphql@16.8.0/node_modules/graphql/jsutils/instanceOf.mjs
+  // node_modules/.pnpm/graphql@16.8.1/node_modules/graphql/jsutils/instanceOf.mjs
   var instanceOf = (
     /* c8 ignore next 6 */
     // FIXME: https://github.com/graphql/graphql-js/issues/2317
@@ -3931,7 +3595,7 @@ spurious results.`);
     }
   );
 
-  // node_modules/.pnpm/graphql@16.8.0/node_modules/graphql/language/source.mjs
+  // node_modules/.pnpm/graphql@16.8.1/node_modules/graphql/language/source.mjs
   var Source = class {
     constructor(body, name = "GraphQL request", locationOffset = {
       line: 1,
@@ -3958,7 +3622,7 @@ spurious results.`);
     return instanceOf(source, Source);
   }
 
-  // node_modules/.pnpm/graphql@16.8.0/node_modules/graphql/language/parser.mjs
+  // node_modules/.pnpm/graphql@16.8.1/node_modules/graphql/language/parser.mjs
   function parse2(source, options) {
     const parser = new Parser(source, options);
     return parser.parseDocument();
@@ -4809,411 +4473,836 @@ spurious results.`);
             return this.parseInputObjectTypeExtension();
         }
       }
-      throw this.unexpected(keywordToken);
+      throw this.unexpected(keywordToken);
+    }
+    /**
+     * ```
+     * SchemaExtension :
+     *  - extend schema Directives[Const]? { OperationTypeDefinition+ }
+     *  - extend schema Directives[Const]
+     * ```
+     */
+    parseSchemaExtension() {
+      const start = this._lexer.token;
+      this.expectKeyword("extend");
+      this.expectKeyword("schema");
+      const directives = this.parseConstDirectives();
+      const operationTypes = this.optionalMany(
+        TokenKind.BRACE_L,
+        this.parseOperationTypeDefinition,
+        TokenKind.BRACE_R
+      );
+      if (directives.length === 0 && operationTypes.length === 0) {
+        throw this.unexpected();
+      }
+      return this.node(start, {
+        kind: Kind.SCHEMA_EXTENSION,
+        directives,
+        operationTypes
+      });
+    }
+    /**
+     * ScalarTypeExtension :
+     *   - extend scalar Name Directives[Const]
+     */
+    parseScalarTypeExtension() {
+      const start = this._lexer.token;
+      this.expectKeyword("extend");
+      this.expectKeyword("scalar");
+      const name = this.parseName();
+      const directives = this.parseConstDirectives();
+      if (directives.length === 0) {
+        throw this.unexpected();
+      }
+      return this.node(start, {
+        kind: Kind.SCALAR_TYPE_EXTENSION,
+        name,
+        directives
+      });
+    }
+    /**
+     * ObjectTypeExtension :
+     *  - extend type Name ImplementsInterfaces? Directives[Const]? FieldsDefinition
+     *  - extend type Name ImplementsInterfaces? Directives[Const]
+     *  - extend type Name ImplementsInterfaces
+     */
+    parseObjectTypeExtension() {
+      const start = this._lexer.token;
+      this.expectKeyword("extend");
+      this.expectKeyword("type");
+      const name = this.parseName();
+      const interfaces = this.parseImplementsInterfaces();
+      const directives = this.parseConstDirectives();
+      const fields = this.parseFieldsDefinition();
+      if (interfaces.length === 0 && directives.length === 0 && fields.length === 0) {
+        throw this.unexpected();
+      }
+      return this.node(start, {
+        kind: Kind.OBJECT_TYPE_EXTENSION,
+        name,
+        interfaces,
+        directives,
+        fields
+      });
+    }
+    /**
+     * InterfaceTypeExtension :
+     *  - extend interface Name ImplementsInterfaces? Directives[Const]? FieldsDefinition
+     *  - extend interface Name ImplementsInterfaces? Directives[Const]
+     *  - extend interface Name ImplementsInterfaces
+     */
+    parseInterfaceTypeExtension() {
+      const start = this._lexer.token;
+      this.expectKeyword("extend");
+      this.expectKeyword("interface");
+      const name = this.parseName();
+      const interfaces = this.parseImplementsInterfaces();
+      const directives = this.parseConstDirectives();
+      const fields = this.parseFieldsDefinition();
+      if (interfaces.length === 0 && directives.length === 0 && fields.length === 0) {
+        throw this.unexpected();
+      }
+      return this.node(start, {
+        kind: Kind.INTERFACE_TYPE_EXTENSION,
+        name,
+        interfaces,
+        directives,
+        fields
+      });
+    }
+    /**
+     * UnionTypeExtension :
+     *   - extend union Name Directives[Const]? UnionMemberTypes
+     *   - extend union Name Directives[Const]
+     */
+    parseUnionTypeExtension() {
+      const start = this._lexer.token;
+      this.expectKeyword("extend");
+      this.expectKeyword("union");
+      const name = this.parseName();
+      const directives = this.parseConstDirectives();
+      const types = this.parseUnionMemberTypes();
+      if (directives.length === 0 && types.length === 0) {
+        throw this.unexpected();
+      }
+      return this.node(start, {
+        kind: Kind.UNION_TYPE_EXTENSION,
+        name,
+        directives,
+        types
+      });
+    }
+    /**
+     * EnumTypeExtension :
+     *   - extend enum Name Directives[Const]? EnumValuesDefinition
+     *   - extend enum Name Directives[Const]
+     */
+    parseEnumTypeExtension() {
+      const start = this._lexer.token;
+      this.expectKeyword("extend");
+      this.expectKeyword("enum");
+      const name = this.parseName();
+      const directives = this.parseConstDirectives();
+      const values = this.parseEnumValuesDefinition();
+      if (directives.length === 0 && values.length === 0) {
+        throw this.unexpected();
+      }
+      return this.node(start, {
+        kind: Kind.ENUM_TYPE_EXTENSION,
+        name,
+        directives,
+        values
+      });
+    }
+    /**
+     * InputObjectTypeExtension :
+     *   - extend input Name Directives[Const]? InputFieldsDefinition
+     *   - extend input Name Directives[Const]
+     */
+    parseInputObjectTypeExtension() {
+      const start = this._lexer.token;
+      this.expectKeyword("extend");
+      this.expectKeyword("input");
+      const name = this.parseName();
+      const directives = this.parseConstDirectives();
+      const fields = this.parseInputFieldsDefinition();
+      if (directives.length === 0 && fields.length === 0) {
+        throw this.unexpected();
+      }
+      return this.node(start, {
+        kind: Kind.INPUT_OBJECT_TYPE_EXTENSION,
+        name,
+        directives,
+        fields
+      });
+    }
+    /**
+     * ```
+     * DirectiveDefinition :
+     *   - Description? directive @ Name ArgumentsDefinition? `repeatable`? on DirectiveLocations
+     * ```
+     */
+    parseDirectiveDefinition() {
+      const start = this._lexer.token;
+      const description = this.parseDescription();
+      this.expectKeyword("directive");
+      this.expectToken(TokenKind.AT);
+      const name = this.parseName();
+      const args = this.parseArgumentDefs();
+      const repeatable = this.expectOptionalKeyword("repeatable");
+      this.expectKeyword("on");
+      const locations = this.parseDirectiveLocations();
+      return this.node(start, {
+        kind: Kind.DIRECTIVE_DEFINITION,
+        description,
+        name,
+        arguments: args,
+        repeatable,
+        locations
+      });
+    }
+    /**
+     * DirectiveLocations :
+     *   - `|`? DirectiveLocation
+     *   - DirectiveLocations | DirectiveLocation
+     */
+    parseDirectiveLocations() {
+      return this.delimitedMany(TokenKind.PIPE, this.parseDirectiveLocation);
+    }
+    /*
+     * DirectiveLocation :
+     *   - ExecutableDirectiveLocation
+     *   - TypeSystemDirectiveLocation
+     *
+     * ExecutableDirectiveLocation : one of
+     *   `QUERY`
+     *   `MUTATION`
+     *   `SUBSCRIPTION`
+     *   `FIELD`
+     *   `FRAGMENT_DEFINITION`
+     *   `FRAGMENT_SPREAD`
+     *   `INLINE_FRAGMENT`
+     *
+     * TypeSystemDirectiveLocation : one of
+     *   `SCHEMA`
+     *   `SCALAR`
+     *   `OBJECT`
+     *   `FIELD_DEFINITION`
+     *   `ARGUMENT_DEFINITION`
+     *   `INTERFACE`
+     *   `UNION`
+     *   `ENUM`
+     *   `ENUM_VALUE`
+     *   `INPUT_OBJECT`
+     *   `INPUT_FIELD_DEFINITION`
+     */
+    parseDirectiveLocation() {
+      const start = this._lexer.token;
+      const name = this.parseName();
+      if (Object.prototype.hasOwnProperty.call(DirectiveLocation, name.value)) {
+        return name;
+      }
+      throw this.unexpected(start);
+    }
+    // Core parsing utility functions
+    /**
+     * Returns a node that, if configured to do so, sets a "loc" field as a
+     * location object, used to identify the place in the source that created a
+     * given parsed object.
+     */
+    node(startToken, node) {
+      if (this._options.noLocation !== true) {
+        node.loc = new Location(
+          startToken,
+          this._lexer.lastToken,
+          this._lexer.source
+        );
+      }
+      return node;
+    }
+    /**
+     * Determines if the next token is of a given kind
+     */
+    peek(kind) {
+      return this._lexer.token.kind === kind;
+    }
+    /**
+     * If the next token is of the given kind, return that token after advancing the lexer.
+     * Otherwise, do not change the parser state and throw an error.
+     */
+    expectToken(kind) {
+      const token = this._lexer.token;
+      if (token.kind === kind) {
+        this.advanceLexer();
+        return token;
+      }
+      throw syntaxError(
+        this._lexer.source,
+        token.start,
+        `Expected ${getTokenKindDesc(kind)}, found ${getTokenDesc(token)}.`
+      );
+    }
+    /**
+     * If the next token is of the given kind, return "true" after advancing the lexer.
+     * Otherwise, do not change the parser state and return "false".
+     */
+    expectOptionalToken(kind) {
+      const token = this._lexer.token;
+      if (token.kind === kind) {
+        this.advanceLexer();
+        return true;
+      }
+      return false;
+    }
+    /**
+     * If the next token is a given keyword, advance the lexer.
+     * Otherwise, do not change the parser state and throw an error.
+     */
+    expectKeyword(value) {
+      const token = this._lexer.token;
+      if (token.kind === TokenKind.NAME && token.value === value) {
+        this.advanceLexer();
+      } else {
+        throw syntaxError(
+          this._lexer.source,
+          token.start,
+          `Expected "${value}", found ${getTokenDesc(token)}.`
+        );
+      }
+    }
+    /**
+     * If the next token is a given keyword, return "true" after advancing the lexer.
+     * Otherwise, do not change the parser state and return "false".
+     */
+    expectOptionalKeyword(value) {
+      const token = this._lexer.token;
+      if (token.kind === TokenKind.NAME && token.value === value) {
+        this.advanceLexer();
+        return true;
+      }
+      return false;
+    }
+    /**
+     * Helper function for creating an error when an unexpected lexed token is encountered.
+     */
+    unexpected(atToken) {
+      const token = atToken !== null && atToken !== void 0 ? atToken : this._lexer.token;
+      return syntaxError(
+        this._lexer.source,
+        token.start,
+        `Unexpected ${getTokenDesc(token)}.`
+      );
+    }
+    /**
+     * Returns a possibly empty list of parse nodes, determined by the parseFn.
+     * This list begins with a lex token of openKind and ends with a lex token of closeKind.
+     * Advances the parser to the next lex token after the closing token.
+     */
+    any(openKind, parseFn, closeKind) {
+      this.expectToken(openKind);
+      const nodes = [];
+      while (!this.expectOptionalToken(closeKind)) {
+        nodes.push(parseFn.call(this));
+      }
+      return nodes;
+    }
+    /**
+     * Returns a list of parse nodes, determined by the parseFn.
+     * It can be empty only if open token is missing otherwise it will always return non-empty list
+     * that begins with a lex token of openKind and ends with a lex token of closeKind.
+     * Advances the parser to the next lex token after the closing token.
+     */
+    optionalMany(openKind, parseFn, closeKind) {
+      if (this.expectOptionalToken(openKind)) {
+        const nodes = [];
+        do {
+          nodes.push(parseFn.call(this));
+        } while (!this.expectOptionalToken(closeKind));
+        return nodes;
+      }
+      return [];
+    }
+    /**
+     * Returns a non-empty list of parse nodes, determined by the parseFn.
+     * This list begins with a lex token of openKind and ends with a lex token of closeKind.
+     * Advances the parser to the next lex token after the closing token.
+     */
+    many(openKind, parseFn, closeKind) {
+      this.expectToken(openKind);
+      const nodes = [];
+      do {
+        nodes.push(parseFn.call(this));
+      } while (!this.expectOptionalToken(closeKind));
+      return nodes;
+    }
+    /**
+     * Returns a non-empty list of parse nodes, determined by the parseFn.
+     * This list may begin with a lex token of delimiterKind followed by items separated by lex tokens of tokenKind.
+     * Advances the parser to the next lex token after last item in the list.
+     */
+    delimitedMany(delimiterKind, parseFn) {
+      this.expectOptionalToken(delimiterKind);
+      const nodes = [];
+      do {
+        nodes.push(parseFn.call(this));
+      } while (this.expectOptionalToken(delimiterKind));
+      return nodes;
+    }
+    advanceLexer() {
+      const { maxTokens } = this._options;
+      const token = this._lexer.advance();
+      if (maxTokens !== void 0 && token.kind !== TokenKind.EOF) {
+        ++this._tokenCounter;
+        if (this._tokenCounter > maxTokens) {
+          throw syntaxError(
+            this._lexer.source,
+            token.start,
+            `Document contains more that ${maxTokens} tokens. Parsing aborted.`
+          );
+        }
+      }
+    }
+  };
+  function getTokenDesc(token) {
+    const value = token.value;
+    return getTokenKindDesc(token.kind) + (value != null ? ` "${value}"` : "");
+  }
+  function getTokenKindDesc(kind) {
+    return isPunctuatorTokenKind(kind) ? `"${kind}"` : kind;
+  }
+
+  // src/core/utils/internal/jsonParse.ts
+  function jsonParse(value) {
+    try {
+      return JSON.parse(value);
+    } catch (error3) {
+      return void 0;
+    }
+  }
+
+  // node_modules/.pnpm/headers-polyfill@4.0.1/node_modules/headers-polyfill/lib/index.mjs
+  var __create4 = Object.create;
+  var __defProp6 = Object.defineProperty;
+  var __getOwnPropDesc5 = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames5 = Object.getOwnPropertyNames;
+  var __getProtoOf4 = Object.getPrototypeOf;
+  var __hasOwnProp5 = Object.prototype.hasOwnProperty;
+  var __commonJS4 = (cb, mod) => function __require() {
+    return mod || (0, cb[__getOwnPropNames5(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  var __copyProps5 = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames5(from))
+        if (!__hasOwnProp5.call(to, key) && key !== except)
+          __defProp6(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc5(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toESM4 = (mod, isNodeMode, target) => (target = mod != null ? __create4(__getProtoOf4(mod)) : {}, __copyProps5(
+    // 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 ? __defProp6(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+  var require_set_cookie2 = __commonJS4({
+    "node_modules/set-cookie-parser/lib/set-cookie.js"(exports, module) {
+      "use strict";
+      var defaultParseOptions = {
+        decodeValues: true,
+        map: false,
+        silent: false
+      };
+      function isNonEmptyString(str) {
+        return typeof str === "string" && !!str.trim();
+      }
+      function parseString(setCookieValue, options) {
+        var parts = setCookieValue.split(";").filter(isNonEmptyString);
+        var nameValuePairStr = parts.shift();
+        var parsed = parseNameValuePair(nameValuePairStr);
+        var name = parsed.name;
+        var value = parsed.value;
+        options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions;
+        try {
+          value = options.decodeValues ? decodeURIComponent(value) : value;
+        } catch (e) {
+          console.error(
+            "set-cookie-parser encountered an error while decoding a cookie with value '" + value + "'. Set options.decodeValues to false to disable this feature.",
+            e
+          );
+        }
+        var cookie = {
+          name,
+          value
+        };
+        parts.forEach(function(part) {
+          var sides = part.split("=");
+          var key = sides.shift().trimLeft().toLowerCase();
+          var value2 = sides.join("=");
+          if (key === "expires") {
+            cookie.expires = new Date(value2);
+          } else if (key === "max-age") {
+            cookie.maxAge = parseInt(value2, 10);
+          } else if (key === "secure") {
+            cookie.secure = true;
+          } else if (key === "httponly") {
+            cookie.httpOnly = true;
+          } else if (key === "samesite") {
+            cookie.sameSite = value2;
+          } else {
+            cookie[key] = value2;
+          }
+        });
+        return cookie;
+      }
+      function parseNameValuePair(nameValuePairStr) {
+        var name = "";
+        var value = "";
+        var nameValueArr = nameValuePairStr.split("=");
+        if (nameValueArr.length > 1) {
+          name = nameValueArr.shift();
+          value = nameValueArr.join("=");
+        } else {
+          value = nameValuePairStr;
+        }
+        return { name, value };
+      }
+      function parse3(input, options) {
+        options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions;
+        if (!input) {
+          if (!options.map) {
+            return [];
+          } else {
+            return {};
+          }
+        }
+        if (input.headers) {
+          if (typeof input.headers.getSetCookie === "function") {
+            input = input.headers.getSetCookie();
+          } else if (input.headers["set-cookie"]) {
+            input = input.headers["set-cookie"];
+          } else {
+            var sch = input.headers[Object.keys(input.headers).find(function(key) {
+              return key.toLowerCase() === "set-cookie";
+            })];
+            if (!sch && input.headers.cookie && !options.silent) {
+              console.warn(
+                "Warning: set-cookie-parser appears to have been called on a request object. It is designed to parse Set-Cookie headers from responses, not Cookie headers from requests. Set the option {silent: true} to suppress this warning."
+              );
+            }
+            input = sch;
+          }
+        }
+        if (!Array.isArray(input)) {
+          input = [input];
+        }
+        options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions;
+        if (!options.map) {
+          return input.filter(isNonEmptyString).map(function(str) {
+            return parseString(str, options);
+          });
+        } else {
+          var cookies = {};
+          return input.filter(isNonEmptyString).reduce(function(cookies2, str) {
+            var cookie = parseString(str, options);
+            cookies2[cookie.name] = cookie;
+            return cookies2;
+          }, cookies);
+        }
+      }
+      function splitCookiesString2(cookiesString) {
+        if (Array.isArray(cookiesString)) {
+          return cookiesString;
+        }
+        if (typeof cookiesString !== "string") {
+          return [];
+        }
+        var cookiesStrings = [];
+        var pos = 0;
+        var start;
+        var ch;
+        var lastComma;
+        var nextStart;
+        var cookiesSeparatorFound;
+        function skipWhitespace() {
+          while (pos < cookiesString.length && /\s/.test(cookiesString.charAt(pos))) {
+            pos += 1;
+          }
+          return pos < cookiesString.length;
+        }
+        function notSpecialChar() {
+          ch = cookiesString.charAt(pos);
+          return ch !== "=" && ch !== ";" && ch !== ",";
+        }
+        while (pos < cookiesString.length) {
+          start = pos;
+          cookiesSeparatorFound = false;
+          while (skipWhitespace()) {
+            ch = cookiesString.charAt(pos);
+            if (ch === ",") {
+              lastComma = pos;
+              pos += 1;
+              skipWhitespace();
+              nextStart = pos;
+              while (pos < cookiesString.length && notSpecialChar()) {
+                pos += 1;
+              }
+              if (pos < cookiesString.length && cookiesString.charAt(pos) === "=") {
+                cookiesSeparatorFound = true;
+                pos = nextStart;
+                cookiesStrings.push(cookiesString.substring(start, lastComma));
+                start = pos;
+              } else {
+                pos = lastComma + 1;
+              }
+            } else {
+              pos += 1;
+            }
+          }
+          if (!cookiesSeparatorFound || pos >= cookiesString.length) {
+            cookiesStrings.push(cookiesString.substring(start, cookiesString.length));
+          }
+        }
+        return cookiesStrings;
+      }
+      module.exports = parse3;
+      module.exports.parse = parse3;
+      module.exports.parseString = parseString;
+      module.exports.splitCookiesString = splitCookiesString2;
     }
-    /**
-     * ```
-     * SchemaExtension :
-     *  - extend schema Directives[Const]? { OperationTypeDefinition+ }
-     *  - extend schema Directives[Const]
-     * ```
-     */
-    parseSchemaExtension() {
-      const start = this._lexer.token;
-      this.expectKeyword("extend");
-      this.expectKeyword("schema");
-      const directives = this.parseConstDirectives();
-      const operationTypes = this.optionalMany(
-        TokenKind.BRACE_L,
-        this.parseOperationTypeDefinition,
-        TokenKind.BRACE_R
-      );
-      if (directives.length === 0 && operationTypes.length === 0) {
-        throw this.unexpected();
-      }
-      return this.node(start, {
-        kind: Kind.SCHEMA_EXTENSION,
-        directives,
-        operationTypes
-      });
+  });
+  var import_set_cookie_parser2 = __toESM4(require_set_cookie2());
+  var HEADERS_INVALID_CHARACTERS = /[^a-z0-9\-#$%&'*+.^_`|~]/i;
+  function normalizeHeaderName(name) {
+    if (HEADERS_INVALID_CHARACTERS.test(name) || name.trim() === "") {
+      throw new TypeError("Invalid character in header field name");
     }
-    /**
-     * ScalarTypeExtension :
-     *   - extend scalar Name Directives[Const]
-     */
-    parseScalarTypeExtension() {
-      const start = this._lexer.token;
-      this.expectKeyword("extend");
-      this.expectKeyword("scalar");
-      const name = this.parseName();
-      const directives = this.parseConstDirectives();
-      if (directives.length === 0) {
-        throw this.unexpected();
-      }
-      return this.node(start, {
-        kind: Kind.SCALAR_TYPE_EXTENSION,
-        name,
-        directives
-      });
+    return name.trim().toLowerCase();
+  }
+  var charCodesToRemove = [
+    String.fromCharCode(10),
+    String.fromCharCode(13),
+    String.fromCharCode(9),
+    String.fromCharCode(32)
+  ];
+  var HEADER_VALUE_REMOVE_REGEXP = new RegExp(
+    `(^[${charCodesToRemove.join("")}]|$[${charCodesToRemove.join("")}])`,
+    "g"
+  );
+  function normalizeHeaderValue(value) {
+    const nextValue = value.replace(HEADER_VALUE_REMOVE_REGEXP, "");
+    return nextValue;
+  }
+  function isValidHeaderName(value) {
+    if (typeof value !== "string") {
+      return false;
     }
-    /**
-     * ObjectTypeExtension :
-     *  - extend type Name ImplementsInterfaces? Directives[Const]? FieldsDefinition
-     *  - extend type Name ImplementsInterfaces? Directives[Const]
-     *  - extend type Name ImplementsInterfaces
-     */
-    parseObjectTypeExtension() {
-      const start = this._lexer.token;
-      this.expectKeyword("extend");
-      this.expectKeyword("type");
-      const name = this.parseName();
-      const interfaces = this.parseImplementsInterfaces();
-      const directives = this.parseConstDirectives();
-      const fields = this.parseFieldsDefinition();
-      if (interfaces.length === 0 && directives.length === 0 && fields.length === 0) {
-        throw this.unexpected();
-      }
-      return this.node(start, {
-        kind: Kind.OBJECT_TYPE_EXTENSION,
-        name,
-        interfaces,
-        directives,
-        fields
-      });
+    if (value.length === 0) {
+      return false;
     }
-    /**
-     * InterfaceTypeExtension :
-     *  - extend interface Name ImplementsInterfaces? Directives[Const]? FieldsDefinition
-     *  - extend interface Name ImplementsInterfaces? Directives[Const]
-     *  - extend interface Name ImplementsInterfaces
-     */
-    parseInterfaceTypeExtension() {
-      const start = this._lexer.token;
-      this.expectKeyword("extend");
-      this.expectKeyword("interface");
-      const name = this.parseName();
-      const interfaces = this.parseImplementsInterfaces();
-      const directives = this.parseConstDirectives();
-      const fields = this.parseFieldsDefinition();
-      if (interfaces.length === 0 && directives.length === 0 && fields.length === 0) {
-        throw this.unexpected();
+    for (let i = 0; i < value.length; i++) {
+      const character = value.charCodeAt(i);
+      if (character > 127 || !isToken(character)) {
+        return false;
       }
-      return this.node(start, {
-        kind: Kind.INTERFACE_TYPE_EXTENSION,
-        name,
-        interfaces,
-        directives,
-        fields
-      });
     }
-    /**
-     * UnionTypeExtension :
-     *   - extend union Name Directives[Const]? UnionMemberTypes
-     *   - extend union Name Directives[Const]
-     */
-    parseUnionTypeExtension() {
-      const start = this._lexer.token;
-      this.expectKeyword("extend");
-      this.expectKeyword("union");
-      const name = this.parseName();
-      const directives = this.parseConstDirectives();
-      const types = this.parseUnionMemberTypes();
-      if (directives.length === 0 && types.length === 0) {
-        throw this.unexpected();
-      }
-      return this.node(start, {
-        kind: Kind.UNION_TYPE_EXTENSION,
-        name,
-        directives,
-        types
-      });
+    return true;
+  }
+  function isToken(value) {
+    return ![
+      127,
+      32,
+      "(",
+      ")",
+      "<",
+      ">",
+      "@",
+      ",",
+      ";",
+      ":",
+      "\\",
+      '"',
+      "/",
+      "[",
+      "]",
+      "?",
+      "=",
+      "{",
+      "}"
+    ].includes(value);
+  }
+  function isValidHeaderValue(value) {
+    if (typeof value !== "string") {
+      return false;
     }
-    /**
-     * EnumTypeExtension :
-     *   - extend enum Name Directives[Const]? EnumValuesDefinition
-     *   - extend enum Name Directives[Const]
-     */
-    parseEnumTypeExtension() {
-      const start = this._lexer.token;
-      this.expectKeyword("extend");
-      this.expectKeyword("enum");
-      const name = this.parseName();
-      const directives = this.parseConstDirectives();
-      const values = this.parseEnumValuesDefinition();
-      if (directives.length === 0 && values.length === 0) {
-        throw this.unexpected();
-      }
-      return this.node(start, {
-        kind: Kind.ENUM_TYPE_EXTENSION,
-        name,
-        directives,
-        values
-      });
+    if (value.trim() !== value) {
+      return false;
     }
-    /**
-     * InputObjectTypeExtension :
-     *   - extend input Name Directives[Const]? InputFieldsDefinition
-     *   - extend input Name Directives[Const]
-     */
-    parseInputObjectTypeExtension() {
-      const start = this._lexer.token;
-      this.expectKeyword("extend");
-      this.expectKeyword("input");
-      const name = this.parseName();
-      const directives = this.parseConstDirectives();
-      const fields = this.parseInputFieldsDefinition();
-      if (directives.length === 0 && fields.length === 0) {
-        throw this.unexpected();
+    for (let i = 0; i < value.length; i++) {
+      const character = value.charCodeAt(i);
+      if (
+        // NUL.
+        character === 0 || // HTTP newline bytes.
+        character === 10 || character === 13
+      ) {
+        return false;
       }
-      return this.node(start, {
-        kind: Kind.INPUT_OBJECT_TYPE_EXTENSION,
-        name,
-        directives,
-        fields
-      });
-    }
-    /**
-     * ```
-     * DirectiveDefinition :
-     *   - Description? directive @ Name ArgumentsDefinition? `repeatable`? on DirectiveLocations
-     * ```
-     */
-    parseDirectiveDefinition() {
-      const start = this._lexer.token;
-      const description = this.parseDescription();
-      this.expectKeyword("directive");
-      this.expectToken(TokenKind.AT);
-      const name = this.parseName();
-      const args = this.parseArgumentDefs();
-      const repeatable = this.expectOptionalKeyword("repeatable");
-      this.expectKeyword("on");
-      const locations = this.parseDirectiveLocations();
-      return this.node(start, {
-        kind: Kind.DIRECTIVE_DEFINITION,
-        description,
-        name,
-        arguments: args,
-        repeatable,
-        locations
-      });
-    }
-    /**
-     * DirectiveLocations :
-     *   - `|`? DirectiveLocation
-     *   - DirectiveLocations | DirectiveLocation
-     */
-    parseDirectiveLocations() {
-      return this.delimitedMany(TokenKind.PIPE, this.parseDirectiveLocation);
     }
-    /*
-     * DirectiveLocation :
-     *   - ExecutableDirectiveLocation
-     *   - TypeSystemDirectiveLocation
-     *
-     * ExecutableDirectiveLocation : one of
-     *   `QUERY`
-     *   `MUTATION`
-     *   `SUBSCRIPTION`
-     *   `FIELD`
-     *   `FRAGMENT_DEFINITION`
-     *   `FRAGMENT_SPREAD`
-     *   `INLINE_FRAGMENT`
-     *
-     * TypeSystemDirectiveLocation : one of
-     *   `SCHEMA`
-     *   `SCALAR`
-     *   `OBJECT`
-     *   `FIELD_DEFINITION`
-     *   `ARGUMENT_DEFINITION`
-     *   `INTERFACE`
-     *   `UNION`
-     *   `ENUM`
-     *   `ENUM_VALUE`
-     *   `INPUT_OBJECT`
-     *   `INPUT_FIELD_DEFINITION`
-     */
-    parseDirectiveLocation() {
-      const start = this._lexer.token;
-      const name = this.parseName();
-      if (Object.prototype.hasOwnProperty.call(DirectiveLocation, name.value)) {
-        return name;
+    return true;
+  }
+  var NORMALIZED_HEADERS = Symbol("normalizedHeaders");
+  var RAW_HEADER_NAMES = Symbol("rawHeaderNames");
+  var HEADER_VALUE_DELIMITER = ", ";
+  var _a;
+  var _b;
+  var Headers2 = class _Headers {
+    constructor(init) {
+      this[_a] = {};
+      this[_b] = /* @__PURE__ */ new Map();
+      if (["Headers", "HeadersPolyfill"].includes(init == null ? void 0 : init.constructor.name) || init instanceof _Headers) {
+        const initialHeaders = init;
+        initialHeaders.forEach((value, name) => {
+          this.append(name, value);
+        }, this);
+      } else if (Array.isArray(init)) {
+        init.forEach(([name, value]) => {
+          this.append(
+            name,
+            Array.isArray(value) ? value.join(HEADER_VALUE_DELIMITER) : value
+          );
+        });
+      } else if (init) {
+        Object.getOwnPropertyNames(init).forEach((name) => {
+          const value = init[name];
+          this.append(
+            name,
+            Array.isArray(value) ? value.join(HEADER_VALUE_DELIMITER) : value
+          );
+        });
       }
-      throw this.unexpected(start);
     }
-    // Core parsing utility functions
-    /**
-     * Returns a node that, if configured to do so, sets a "loc" field as a
-     * location object, used to identify the place in the source that created a
-     * given parsed object.
-     */
-    node(startToken, node) {
-      if (this._options.noLocation !== true) {
-        node.loc = new Location(
-          startToken,
-          this._lexer.lastToken,
-          this._lexer.source
-        );
-      }
-      return node;
+    [(_a = NORMALIZED_HEADERS, _b = RAW_HEADER_NAMES, Symbol.iterator)]() {
+      return this.entries();
     }
-    /**
-     * Determines if the next token is of a given kind
-     */
-    peek(kind) {
-      return this._lexer.token.kind === kind;
+    *keys() {
+      for (const [name] of this.entries()) {
+        yield name;
+      }
     }
-    /**
-     * If the next token is of the given kind, return that token after advancing the lexer.
-     * Otherwise, do not change the parser state and throw an error.
-     */
-    expectToken(kind) {
-      const token = this._lexer.token;
-      if (token.kind === kind) {
-        this.advanceLexer();
-        return token;
+    *values() {
+      for (const [, value] of this.entries()) {
+        yield value;
       }
-      throw syntaxError(
-        this._lexer.source,
-        token.start,
-        `Expected ${getTokenKindDesc(kind)}, found ${getTokenDesc(token)}.`
-      );
     }
-    /**
-     * If the next token is of the given kind, return "true" after advancing the lexer.
-     * Otherwise, do not change the parser state and return "false".
-     */
-    expectOptionalToken(kind) {
-      const token = this._lexer.token;
-      if (token.kind === kind) {
-        this.advanceLexer();
-        return true;
+    *entries() {
+      let sortedKeys = Object.keys(this[NORMALIZED_HEADERS]).sort(
+        (a, b) => a.localeCompare(b)
+      );
+      for (const name of sortedKeys) {
+        if (name === "set-cookie") {
+          for (const value of this.getSetCookie()) {
+            yield [name, value];
+          }
+        } else {
+          yield [name, this.get(name)];
+        }
       }
-      return false;
     }
     /**
-     * If the next token is a given keyword, advance the lexer.
-     * Otherwise, do not change the parser state and throw an error.
+     * Returns a boolean stating whether a `Headers` object contains a certain header.
      */
-    expectKeyword(value) {
-      const token = this._lexer.token;
-      if (token.kind === TokenKind.NAME && token.value === value) {
-        this.advanceLexer();
-      } else {
-        throw syntaxError(
-          this._lexer.source,
-          token.start,
-          `Expected "${value}", found ${getTokenDesc(token)}.`
-        );
+    has(name) {
+      if (!isValidHeaderName(name)) {
+        throw new TypeError(`Invalid header name "${name}"`);
       }
+      return this[NORMALIZED_HEADERS].hasOwnProperty(normalizeHeaderName(name));
     }
     /**
-     * If the next token is a given keyword, return "true" after advancing the lexer.
-     * Otherwise, do not change the parser state and return "false".
+     * Returns a `ByteString` sequence of all the values of a header with a given name.
      */
-    expectOptionalKeyword(value) {
-      const token = this._lexer.token;
-      if (token.kind === TokenKind.NAME && token.value === value) {
-        this.advanceLexer();
-        return true;
+    get(name) {
+      var _a3;
+      if (!isValidHeaderName(name)) {
+        throw TypeError(`Invalid header name "${name}"`);
       }
-      return false;
+      return (_a3 = this[NORMALIZED_HEADERS][normalizeHeaderName(name)]) != null ? _a3 : null;
     }
     /**
-     * Helper function for creating an error when an unexpected lexed token is encountered.
+     * Sets a new value for an existing header inside a `Headers` object, or adds the header if it does not already exist.
      */
-    unexpected(atToken) {
-      const token = atToken !== null && atToken !== void 0 ? atToken : this._lexer.token;
-      return syntaxError(
-        this._lexer.source,
-        token.start,
-        `Unexpected ${getTokenDesc(token)}.`
-      );
+    set(name, value) {
+      if (!isValidHeaderName(name) || !isValidHeaderValue(value)) {
+        return;
+      }
+      const normalizedName = normalizeHeaderName(name);
+      const normalizedValue = normalizeHeaderValue(value);
+      this[NORMALIZED_HEADERS][normalizedName] = normalizeHeaderValue(normalizedValue);
+      this[RAW_HEADER_NAMES].set(normalizedName, name);
     }
     /**
-     * Returns a possibly empty list of parse nodes, determined by the parseFn.
-     * This list begins with a lex token of openKind and ends with a lex token of closeKind.
-     * Advances the parser to the next lex token after the closing token.
+     * Appends a new value onto an existing header inside a `Headers` object, or adds the header if it does not already exist.
      */
-    any(openKind, parseFn, closeKind) {
-      this.expectToken(openKind);
-      const nodes = [];
-      while (!this.expectOptionalToken(closeKind)) {
-        nodes.push(parseFn.call(this));
+    append(name, value) {
+      if (!isValidHeaderName(name) || !isValidHeaderValue(value)) {
+        return;
       }
-      return nodes;
+      const normalizedName = normalizeHeaderName(name);
+      const normalizedValue = normalizeHeaderValue(value);
+      let resolvedValue = this.has(normalizedName) ? `${this.get(normalizedName)}, ${normalizedValue}` : normalizedValue;
+      this.set(name, resolvedValue);
     }
     /**
-     * Returns a list of parse nodes, determined by the parseFn.
-     * It can be empty only if open token is missing otherwise it will always return non-empty list
-     * that begins with a lex token of openKind and ends with a lex token of closeKind.
-     * Advances the parser to the next lex token after the closing token.
+     * Deletes a header from the `Headers` object.
      */
-    optionalMany(openKind, parseFn, closeKind) {
-      if (this.expectOptionalToken(openKind)) {
-        const nodes = [];
-        do {
-          nodes.push(parseFn.call(this));
-        } while (!this.expectOptionalToken(closeKind));
-        return nodes;
+    delete(name) {
+      if (!isValidHeaderName(name)) {
+        return;
       }
-      return [];
+      if (!this.has(name)) {
+        return;
+      }
+      const normalizedName = normalizeHeaderName(name);
+      delete this[NORMALIZED_HEADERS][normalizedName];
+      this[RAW_HEADER_NAMES].delete(normalizedName);
     }
     /**
-     * Returns a non-empty list of parse nodes, determined by the parseFn.
-     * This list begins with a lex token of openKind and ends with a lex token of closeKind.
-     * Advances the parser to the next lex token after the closing token.
+     * Traverses the `Headers` object,
+     * calling the given callback for each header.
      */
-    many(openKind, parseFn, closeKind) {
-      this.expectToken(openKind);
-      const nodes = [];
-      do {
-        nodes.push(parseFn.call(this));
-      } while (!this.expectOptionalToken(closeKind));
-      return nodes;
+    forEach(callback, thisArg) {
+      for (const [name, value] of this.entries()) {
+        callback.call(thisArg, value, name, this);
+      }
     }
     /**
-     * Returns a non-empty list of parse nodes, determined by the parseFn.
-     * This list may begin with a lex token of delimiterKind followed by items separated by lex tokens of tokenKind.
-     * Advances the parser to the next lex token after last item in the list.
+     * Returns an array containing the values
+     * of all Set-Cookie headers associated
+     * with a response
      */
-    delimitedMany(delimiterKind, parseFn) {
-      this.expectOptionalToken(delimiterKind);
-      const nodes = [];
-      do {
-        nodes.push(parseFn.call(this));
-      } while (this.expectOptionalToken(delimiterKind));
-      return nodes;
-    }
-    advanceLexer() {
-      const { maxTokens } = this._options;
-      const token = this._lexer.advance();
-      if (maxTokens !== void 0 && token.kind !== TokenKind.EOF) {
-        ++this._tokenCounter;
-        if (this._tokenCounter > maxTokens) {
-          throw syntaxError(
-            this._lexer.source,
-            token.start,
-            `Document contains more that ${maxTokens} tokens. Parsing aborted.`
-          );
-        }
+    getSetCookie() {
+      const setCookieHeader = this.get("set-cookie");
+      if (setCookieHeader === null) {
+        return [];
       }
+      if (setCookieHeader === "") {
+        return [""];
+      }
+      return (0, import_set_cookie_parser2.splitCookiesString)(setCookieHeader);
     }
   };
-  function getTokenDesc(token) {
-    const value = token.value;
-    return getTokenKindDesc(token.kind) + (value != null ? ` "${value}"` : "");
-  }
-  function getTokenKindDesc(kind) {
-    return isPunctuatorTokenKind(kind) ? `"${kind}"` : kind;
-  }
-
-  // src/core/utils/internal/jsonParse.ts
-  function jsonParse(value) {
-    try {
-      return JSON.parse(value);
-    } catch (error3) {
-      return void 0;
-    }
+  function stringToHeaders(str) {
+    const lines = str.trim().split(/[\r\n]+/);
+    return lines.reduce((headers, line) => {
+      if (line.trim() === "") {
+        return headers;
+      }
+      const parts = line.split(": ");
+      const name = parts.shift();
+      const value = parts.join(": ");
+      headers.append(name, value);
+      return headers;
+    }, new Headers2());
   }
 
   // src/core/utils/internal/parseMultipartData.ts
@@ -5406,7 +5495,7 @@ spurious results.`);
     return typeof value === "object" && "kind" in value && "definitions" in value;
   }
   var GraphQLHandler = class extends RequestHandler {
-    constructor(operationType, operationName, endpoint, resolver) {
+    constructor(operationType, operationName, endpoint, resolver, options) {
       let resolvedOperationName = operationName;
       if (isDocumentNode(operationName)) {
         const parsedNode = parseDocumentNode(operationName);
@@ -5429,47 +5518,53 @@ spurious results.`);
           operationType,
           operationName: resolvedOperationName
         },
-        resolver
+        resolver,
+        options
       });
       this.endpoint = endpoint;
     }
-    parse(request) {
+    parse(args) {
       return __async(this, null, function* () {
-        return parseGraphQLRequest(request).catch((error3) => {
+        return parseGraphQLRequest(args.request).catch((error3) => {
           console.error(error3);
           return void 0;
         });
       });
     }
-    predicate(request, parsedResult) {
-      if (!parsedResult) {
+    predicate(args) {
+      if (!args.parsedResult) {
         return false;
       }
-      if (!parsedResult.operationName && this.info.operationType !== "all") {
-        const publicUrl = getPublicUrlFromRequest(request);
-        devUtils.warn(`Failed to intercept a GraphQL request at "${request.method} ${publicUrl}": anonymous GraphQL operations are not supported.
+      if (!args.parsedResult.operationName && this.info.operationType !== "all") {
+        const publicUrl = getPublicUrlFromRequest(args.request);
+        devUtils.warn(`Failed to intercept a GraphQL request at "${args.request.method} ${publicUrl}": anonymous GraphQL operations are not supported.
 
 Consider naming this operation or using "graphql.operation()" request handler to intercept GraphQL requests regardless of their operation name/type. Read more: https://mswjs.io/docs/api/graphql/operation`);
         return false;
       }
-      const hasMatchingUrl = matchRequestUrl(new URL(request.url), this.endpoint);
-      const hasMatchingOperationType = this.info.operationType === "all" || parsedResult.operationType === this.info.operationType;
-      const hasMatchingOperationName = this.info.operationName instanceof RegExp ? this.info.operationName.test(parsedResult.operationName || "") : parsedResult.operationName === this.info.operationName;
+      const hasMatchingUrl = matchRequestUrl(
+        new URL(args.request.url),
+        this.endpoint
+      );
+      const hasMatchingOperationType = this.info.operationType === "all" || args.parsedResult.operationType === this.info.operationType;
+      const hasMatchingOperationName = this.info.operationName instanceof RegExp ? this.info.operationName.test(args.parsedResult.operationName || "") : args.parsedResult.operationName === this.info.operationName;
       return hasMatchingUrl.matches && hasMatchingOperationType && hasMatchingOperationName;
     }
-    extendInfo(_request, parsedResult) {
+    extendResolverArgs(args) {
+      var _a3, _b2, _c;
       return {
-        query: (parsedResult == null ? void 0 : parsedResult.query) || "",
-        operationName: (parsedResult == null ? void 0 : parsedResult.operationName) || "",
-        variables: (parsedResult == null ? void 0 : parsedResult.variables) || {}
+        query: ((_a3 = args.parsedResult) == null ? void 0 : _a3.query) || "",
+        operationName: ((_b2 = args.parsedResult) == null ? void 0 : _b2.operationName) || "",
+        variables: ((_c = args.parsedResult) == null ? void 0 : _c.variables) || {}
       };
     }
-    log(request, response, parsedRequest) {
+    log(args) {
       return __async(this, null, function* () {
-        const loggedRequest = yield serializeRequest(request);
-        const loggedResponse = yield serializeResponse(response);
+        var _a3, _b2, _c, _d;
+        const loggedRequest = yield serializeRequest(args.request);
+        const loggedResponse = yield serializeResponse(args.response);
         const statusColor = getStatusCodeColor(loggedResponse.status);
-        const requestInfo = (parsedRequest == null ? void 0 : parsedRequest.operationName) ? `${parsedRequest == null ? void 0 : parsedRequest.operationType} ${parsedRequest == null ? void 0 : parsedRequest.operationName}` : `anonymous ${parsedRequest == null ? void 0 : parsedRequest.operationType}`;
+        const requestInfo = ((_a3 = args.parsedResult) == null ? void 0 : _a3.operationName) ? `${(_b2 = args.parsedResult) == null ? void 0 : _b2.operationType} ${(_c = args.parsedResult) == null ? void 0 : _c.operationName}` : `anonymous ${(_d = args.parsedResult) == null ? void 0 : _d.operationType}`;
         console.groupCollapsed(
           devUtils.formatMessage("%s %s (%c%s%c)"),
           getTimestamp(),
@@ -5488,8 +5583,14 @@ Consider naming this operation or using "graphql.operation()" request handler to
 
   // src/core/graphql.ts
   function createScopedGraphQLHandler(operationType, url) {
-    return (operationName, resolver) => {
-      return new GraphQLHandler(operationType, operationName, url, resolver);
+    return (operationName, resolver, options = {}) => {
+      return new GraphQLHandler(
+        operationType,
+        operationName,
+        url,
+        resolver,
+        options
+      );
     };
   }
   function createGraphQLOperationHandler(url) {
@@ -5499,32 +5600,39 @@ Consider naming this operation or using "graphql.operation()" request handler to
   }
   var standardGraphQLHandlers = {
     /**
-     * Captures any GraphQL operation, regardless of its name, under the current scope.
-     * @example
-     * graphql.operation(() => {
-     *   return HttpResponse.json({ data: { name: 'John' } })
-     * })
-     * @see {@link https://mswjs.io/docs/api/graphql/operation `graphql.operation()`}
-     */
-    operation: createGraphQLOperationHandler("*"),
-    /**
-     * Captures a GraphQL query by a given name.
+     * Intercepts a GraphQL query by a given name.
+     *
      * @example
      * graphql.query('GetUser', () => {
      *   return HttpResponse.json({ data: { user: { name: 'John' } } })
      * })
-     * @see {@link https://mswjs.io/docs/api/graphql/query `graphql.query()`}
+     *
+     * @see {@link https://mswjs.io/docs/api/graphql#graphqlqueryqueryname-resolver `graphql.query()` API reference}
      */
     query: createScopedGraphQLHandler("query", "*"),
     /**
-     * Captures a GraphQL mutation by a given name.
+     * Intercepts a GraphQL mutation by its name.
+     *
      * @example
      * graphql.mutation('SavePost', () => {
      *   return HttpResponse.json({ data: { post: { id: 'abc-123 } } })
      * })
-     * @see {@link https://mswjs.io/docs/api/graphql/mutation `graphql.mutation()`}
+     *
+     * @see {@link https://mswjs.io/docs/api/graphql#graphqlmutationmutationname-resolver `graphql.query()` API reference}
+     *
+     */
+    mutation: createScopedGraphQLHandler("mutation", "*"),
+    /**
+     * Intercepts any GraphQL operation, regardless of its type or name.
+     *
+     * @example
+     * graphql.operation(() => {
+     *   return HttpResponse.json({ data: { name: 'John' } })
+     * })
+     *
+     * @see {@link https://mswjs.io/docs/api/graphql#graphloperationresolver `graphql.operation()` API reference}
      */
-    mutation: createScopedGraphQLHandler("mutation", "*")
+    operation: createGraphQLOperationHandler("*")
   };
   function createGraphQLLink(url) {
     return {
@@ -5534,6 +5642,15 @@ Consider naming this operation or using "graphql.operation()" request handler to
     };
   }
   var graphql = __spreadProps(__spreadValues({}, standardGraphQLHandlers), {
+    /**
+     * Intercepts GraphQL operations scoped by the given URL.
+     *
+     * @example
+     * const github = graphql.link('https://api.github.com/graphql')
+     * github.query('GetRepo', resolver)
+     *
+     * @see {@link https://mswjs.io/docs/api/graphql#graphqllinkurl `graphql.link()` API reference}
+     */
     link: createGraphQLLink
   });
 
@@ -5554,7 +5671,7 @@ Consider naming this operation or using "graphql.operation()" request handler to
     let matchingHandler = null;
     let result = null;
     for (const handler of handlers) {
-      result = yield handler.run(request, resolutionContext);
+      result = yield handler.run({ request, resolutionContext });
       if (result !== null) {
         matchingHandler = handler;
       }
@@ -5565,7 +5682,7 @@ Consider naming this operation or using "graphql.operation()" request handler to
     if (matchingHandler) {
       return {
         handler: matchingHandler,
-        parsedRequest: result == null ? void 0 : result.parsedResult,
+        parsedResult: result == null ? void 0 : result.parsedResult,
         response: result == null ? void 0 : result.response
       };
     }
@@ -5776,7 +5893,7 @@ ${handlers.map((handler) => `  \u2022 ${handler.info.header}`).join("\n")}`;
         const requestHeader = parsedGraphQLQuery ? getGraphQLRequestHeader(parsedGraphQLQuery) : `${request.method} ${publicUrl}`;
         const handlerSuggestion = generateHandlerSuggestion();
         const messageTemplate = [
-          `captured a request without a matching request handler:`,
+          `intercepted a request without a matching request handler:`,
           `  \u2022 ${requestHeader}`,
           handlerSuggestion,
           `If you still wish to intercept this unhandled request, please create a request handler for it.
@@ -6034,53 +6151,16 @@ Read more: https://mswjs.io/docs/getting-started/mocks`
 
   // src/core/bypass.ts
   function bypass(input, init) {
-    return __async(this, null, function* () {
-      if (isRequest(input)) {
-        invariant(
-          !input.bodyUsed,
-          'Failed to create a bypassed request to "%s %s": given request instance already has its body read. Make sure to clone the intercepted request if you wish to read its body before bypassing it.',
-          input.method,
-          input.url
-        );
-      }
-      const url = isRequest(input) ? input.url : input.toString();
-      const resolvedInit = typeof init !== "undefined" ? init : yield getRequestInit(input);
-      const headers = new HeadersPolyfill(resolvedInit.headers);
-      headers.set("x-msw-intention", "bypass");
-      resolvedInit.headers = headers;
-      return [url, resolvedInit];
-    });
-  }
-  function isRequest(input) {
-    return typeof input === "object" && input.constructor.name === "Request" && "clone" in input && typeof input.clone === "function";
-  }
-  function getRequestInit(input) {
-    return __async(this, null, function* () {
-      if (!isRequest(input)) {
-        return {};
-      }
-      const init = {
-        // Set each request init property explicitly
-        // to prevent leaking internal properties of whichever
-        // Request polyfill provided as the input.
-        mode: input.mode,
-        method: input.method,
-        cache: input.cache,
-        headers: input.headers,
-        credentials: input.credentials,
-        signal: input.signal,
-        referrerPolicy: input.referrerPolicy,
-        referrer: input.referrer,
-        redirect: input.redirect,
-        integrity: input.integrity,
-        keepalive: input.keepalive
-      };
-      if (init.method !== "HEAD" && input.method !== "GET") {
-        init.body = yield input.clone().arrayBuffer();
-        init.duplex = input.duplex;
-      }
-      return init;
-    });
+    const request = input instanceof Request ? input : new Request(input, init);
+    invariant(
+      !request.bodyUsed,
+      'Failed to create a bypassed request to "%s %s": given request instance already has its body read. Make sure to clone the intercepted request if you wish to read its body before bypassing it.',
+      request.method,
+      request.url
+    );
+    const requestClone = request.clone();
+    requestClone.headers.set("x-msw-intention", "bypass");
+    return requestClone;
   }
 
   // src/core/passthrough.ts
@@ -6259,7 +6339,7 @@ Learn more about creating the Service Worker script: https://mswjs.io/docs/cli/i
     return {
       status: response.status,
       statusText: response.statusText,
-      headers: flattenHeadersObject(headersToObject(response.headers))
+      headers: Object.fromEntries(response.headers.entries())
     };
   }
 
@@ -6284,7 +6364,7 @@ Learn more about creating the Service Worker script: https://mswjs.io/docs/cli/i
               messageChannel.postMessage("NOT_FOUND");
             },
             onMockedResponse(_0, _1) {
-              return __async(this, arguments, function* (response, { handler, parsedRequest }) {
+              return __async(this, arguments, function* (response, { handler, parsedResult }) {
                 const responseClone = response.clone();
                 const responseInit = toResponseInit(response);
                 const responseStream = responseClone.body;
@@ -6299,7 +6379,11 @@ Learn more about creating the Service Worker script: https://mswjs.io/docs/cli/i
                 );
                 if (!options.quiet) {
                   context.emitter.once("response:mocked", ({ response: response2 }) => {
-                    handler.log(requestCloneForLogs, response2, parsedRequest);
+                    handler.log({
+                      request: requestCloneForLogs,
+                      response: response2,
+                      parsedResult
+                    });
                   });
                 }
               });
@@ -6342,9 +6426,9 @@ This exception has been gracefully handled as a 500 response, however, it's stro
       const { payload: actualChecksum } = yield context.events.once(
         "INTEGRITY_CHECK_RESPONSE"
       );
-      if (actualChecksum !== "e2d8525b2d1bdadf89a15ae5a2619512") {
+      if (actualChecksum !== "0877fcdc026242810f5bfde0d7178db4") {
         throw new Error(
-          `Currently active Service Worker (${actualChecksum}) is behind the latest published one (${"e2d8525b2d1bdadf89a15ae5a2619512"}).`
+          `Currently active Service Worker (${actualChecksum}) is behind the latest published one (${"0877fcdc026242810f5bfde0d7178db4"}).`
         );
       }
       return serviceWorker;
@@ -7813,10 +7897,14 @@ If this message still persists after updating, please report an issue: https://g
         options,
         context.emitter,
         {
-          onMockedResponse(_, { handler, parsedRequest }) {
+          onMockedResponse(_, { handler, parsedResult }) {
             if (!options.quiet) {
               context.emitter.once("response:mocked", ({ response: response2 }) => {
-                handler.log(requestCloneForLogs, response2, parsedRequest);
+                handler.log({
+                  request: requestCloneForLogs,
+                  response: response2,
+                  parsedResult
+                });
               });
             }
           }