msw 2.13.6 → 2.14.0

package/lib/iife/index.js

@@ -14652,1282 +14652,1282 @@ ${operationTypes.join("\n")}
     }
   };
 
-  // src/core/utils/internal/getCallFrame.ts
-  var SOURCE_FRAME = /[/\\]msw[/\\]src[/\\](.+)/;
-  var BUILD_FRAME = /(node_modules)?[/\\]lib[/\\](core|browser|node|native|iife)[/\\]|^[^/\\]*$/;
-  function getCallFrame(error3) {
-    const stack = error3.stack;
-    if (!stack) {
-      return;
-    }
-    const frames = stack.split("\n").slice(1);
-    const declarationFrame = frames.find((frame) => {
-      return !(SOURCE_FRAME.test(frame) || BUILD_FRAME.test(frame));
-    });
-    if (!declarationFrame) {
-      return;
-    }
-    const declarationPath = declarationFrame.replace(/\s*at [^()]*\(([^)]+)\)/, "$1").replace(/^@/, "");
-    return declarationPath;
+  // node_modules/.pnpm/set-cookie-parser@3.1.0/node_modules/set-cookie-parser/lib/set-cookie.js
+  var defaultParseOptions = {
+    decodeValues: true,
+    map: false,
+    silent: false,
+    split: "auto"
+    // auto = split strings but not arrays
+  };
+  function isForbiddenKey(key) {
+    return typeof key !== "string" || key in {};
   }
-
-  // src/core/utils/internal/isIterable.ts
-  function isIterable(fn) {
-    if (!fn) {
-      return false;
-    }
-    return Reflect.has(fn, Symbol.iterator) || Reflect.has(fn, Symbol.asyncIterator);
+  function createNullObj() {
+    return /* @__PURE__ */ Object.create(null);
   }
-
-  // node_modules/.pnpm/@open-draft+deferred-promise@2.2.0/node_modules/@open-draft/deferred-promise/build/index.mjs
-  function createDeferredExecutor() {
-    const executor = (resolve, reject) => {
-      executor.state = "pending";
-      executor.resolve = (data) => {
-        if (executor.state !== "pending") {
-          return;
-        }
-        executor.result = data;
-        const onFulfilled = (value) => {
-          executor.state = "fulfilled";
-          return value;
-        };
-        return resolve(
-          data instanceof Promise ? data : Promise.resolve(data).then(onFulfilled)
-        );
-      };
-      executor.reject = (reason) => {
-        if (executor.state !== "pending") {
-          return;
-        }
-        queueMicrotask(() => {
-          executor.state = "rejected";
-        });
-        return reject(executor.rejectionReason = reason);
-      };
-    };
-    return executor;
+  function isNonEmptyString(str) {
+    return typeof str === "string" && !!str.trim();
   }
-  var DeferredPromise = class extends Promise {
-    #executor;
-    resolve;
-    reject;
-    constructor(executor = null) {
-      const deferredExecutor = createDeferredExecutor();
-      super((originalResolve, originalReject) => {
-        deferredExecutor(originalResolve, originalReject);
-        executor?.(deferredExecutor.resolve, deferredExecutor.reject);
-      });
-      this.#executor = deferredExecutor;
-      this.resolve = this.#executor.resolve;
-      this.reject = this.#executor.reject;
-    }
-    get state() {
-      return this.#executor.state;
-    }
-    get rejectionReason() {
-      return this.#executor.rejectionReason;
+  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;
+    if (isForbiddenKey(name)) {
+      return null;
     }
-    then(onFulfilled, onRejected) {
-      return this.#decorate(super.then(onFulfilled, onRejected));
+    try {
+      value = options.decodeValues ? decodeURIComponent(value) : value;
+    } catch (e) {
+      console.error(
+        "set-cookie-parser: failed to decode cookie value. Set options.decodeValues=false to disable decoding.",
+        e
+      );
     }
-    catch(onRejected) {
-      return this.#decorate(super.catch(onRejected));
+    var cookie2 = createNullObj();
+    cookie2.name = name;
+    cookie2.value = value;
+    parts.forEach(function(part) {
+      var sides = part.split("=");
+      var key = sides.shift().trimLeft().toLowerCase();
+      if (isForbiddenKey(key)) {
+        return;
+      }
+      var value2 = sides.join("=");
+      if (key === "expires") {
+        cookie2.expires = new Date(value2);
+      } else if (key === "max-age") {
+        var n = parseInt(value2, 10);
+        if (!Number.isNaN(n)) cookie2.maxAge = n;
+      } else if (key === "secure") {
+        cookie2.secure = true;
+      } else if (key === "httponly") {
+        cookie2.httpOnly = true;
+      } else if (key === "samesite") {
+        cookie2.sameSite = value2;
+      } else if (key === "partitioned") {
+        cookie2.partitioned = true;
+      } else if (key) {
+        cookie2[key] = value2;
+      }
+    });
+    return cookie2;
+  }
+  function parseNameValuePair(nameValuePairStr) {
+    var name = "";
+    var value = "";
+    var nameValueArr = nameValuePairStr.split("=");
+    if (nameValueArr.length > 1) {
+      name = nameValueArr.shift();
+      value = nameValueArr.join("=");
+    } else {
+      value = nameValuePairStr;
     }
-    finally(onfinally) {
-      return this.#decorate(super.finally(onfinally));
+    return { name, value };
+  }
+  function parseSetCookie(input, options) {
+    options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions;
+    if (!input) {
+      if (!options.map) {
+        return [];
+      } else {
+        return createNullObj();
+      }
     }
-    #decorate(promise) {
-      return Object.defineProperties(promise, {
-        resolve: { configurable: true, value: this.resolve },
-        reject: { configurable: true, value: this.reject }
-      });
+    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;
+      }
     }
-  };
-
-  // node_modules/.pnpm/@mswjs+interceptors@0.41.3/node_modules/@mswjs/interceptors/lib/browser/getRawRequest-BTaNLFr0.mjs
-  var IS_PATCHED_MODULE = Symbol("isPatchedModule");
-  var InterceptorError = class InterceptorError2 extends Error {
-    constructor(message4) {
-      super(message4);
-      this.name = "InterceptorError";
-      Object.setPrototypeOf(this, InterceptorError2.prototype);
+    var split = options.split;
+    var isArray = Array.isArray(input);
+    if (split === "auto") {
+      split = !isArray;
     }
-  };
-  var RequestController = class RequestController2 {
-    static {
-      this.PENDING = 0;
+    if (!isArray) {
+      input = [input];
     }
-    static {
-      this.PASSTHROUGH = 1;
+    input = input.filter(isNonEmptyString);
+    if (split) {
+      input = input.map(splitCookiesString).flat();
     }
-    static {
-      this.RESPONSE = 2;
+    if (!options.map) {
+      return input.map(function(str) {
+        return parseString(str, options);
+      }).filter(Boolean);
+    } else {
+      var cookies = createNullObj();
+      return input.reduce(function(cookies2, str) {
+        var cookie2 = parseString(str, options);
+        if (cookie2 && !isForbiddenKey(cookie2.name)) {
+          cookies2[cookie2.name] = cookie2;
+        }
+        return cookies2;
+      }, cookies);
     }
-    static {
-      this.ERROR = 3;
+  }
+  function splitCookiesString(cookiesString) {
+    if (Array.isArray(cookiesString)) {
+      return cookiesString;
     }
-    constructor(request, source) {
-      this.request = request;
-      this.source = source;
-      this.readyState = RequestController2.PENDING;
-      this.handled = new DeferredPromise();
+    if (typeof cookiesString !== "string") {
+      return [];
     }
-    get #handled() {
-      return this.handled;
+    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;
     }
-    /**
-    * Perform this request as-is.
-    */
-    async passthrough() {
-      invariant.as(InterceptorError, this.readyState === RequestController2.PENDING, 'Failed to passthrough the "%s %s" request: the request has already been handled', this.request.method, this.request.url);
-      this.readyState = RequestController2.PASSTHROUGH;
-      await this.source.passthrough();
-      this.#handled.resolve();
+    function notSpecialChar() {
+      ch = cookiesString.charAt(pos);
+      return ch !== "=" && ch !== ";" && ch !== ",";
     }
-    /**
-    * Respond to this request with the given `Response` instance.
-    *
-    * @example
-    * controller.respondWith(new Response())
-    * controller.respondWith(Response.json({ id }))
-    * controller.respondWith(Response.error())
-    */
-    respondWith(response) {
-      invariant.as(InterceptorError, this.readyState === RequestController2.PENDING, 'Failed to respond to the "%s %s" request with "%d %s": the request has already been handled (%d)', this.request.method, this.request.url, response.status, response.statusText || "OK", this.readyState);
-      this.readyState = RequestController2.RESPONSE;
-      this.#handled.resolve();
-      this.source.respondWith(response);
-    }
-    /**
-    * Error this request with the given reason.
-    *
-    * @example
-    * controller.errorWith()
-    * controller.errorWith(new Error('Oops!'))
-    * controller.errorWith({ message: 'Oops!'})
-    */
-    errorWith(reason) {
-      invariant.as(InterceptorError, this.readyState === RequestController2.PENDING, 'Failed to error the "%s %s" request with "%s": the request has already been handled (%d)', this.request.method, this.request.url, reason?.toString(), this.readyState);
-      this.readyState = RequestController2.ERROR;
-      this.source.errorWith(reason);
-      this.#handled.resolve();
-    }
-  };
-  function canParseUrl(url) {
-    try {
-      new URL(url);
-      return true;
-    } catch (_error) {
-      return false;
-    }
-  }
-  function getValueBySymbol(symbolName, source) {
-    const symbol = Object.getOwnPropertySymbols(source).find((symbol$1) => {
-      return symbol$1.description === symbolName;
-    });
-    if (symbol) return Reflect.get(source, symbol);
-  }
-  var FetchResponse = class FetchResponse2 extends Response {
-    static {
-      this.STATUS_CODES_WITHOUT_BODY = [
-        101,
-        103,
-        204,
-        205,
-        304
-      ];
-    }
-    static {
-      this.STATUS_CODES_WITH_REDIRECT = [
-        301,
-        302,
-        303,
-        307,
-        308
-      ];
-    }
-    static isConfigurableStatusCode(status) {
-      return status >= 200 && status <= 599;
-    }
-    static isRedirectResponse(status) {
-      return FetchResponse2.STATUS_CODES_WITH_REDIRECT.includes(status);
-    }
-    /**
-    * Returns a boolean indicating whether the given response status
-    * code represents a response that can have a body.
-    */
-    static isResponseWithBody(status) {
-      return !FetchResponse2.STATUS_CODES_WITHOUT_BODY.includes(status);
-    }
-    static setUrl(url, response) {
-      if (!url || url === "about:" || !canParseUrl(url)) return;
-      const state = getValueBySymbol("state", response);
-      if (state) state.urlList.push(new URL(url));
-      else Object.defineProperty(response, "url", {
-        value: url,
-        enumerable: true,
-        configurable: true,
-        writable: false
-      });
-    }
-    /**
-    * Parses the given raw HTTP headers into a Fetch API `Headers` instance.
-    */
-    static parseRawHeaders(rawHeaders) {
-      const headers = new Headers();
-      for (let line = 0; line < rawHeaders.length; line += 2) headers.append(rawHeaders[line], rawHeaders[line + 1]);
-      return headers;
-    }
-    constructor(body, init = {}) {
-      const status = init.status ?? 200;
-      const safeStatus = FetchResponse2.isConfigurableStatusCode(status) ? status : 200;
-      const finalBody = FetchResponse2.isResponseWithBody(status) ? body : null;
-      super(finalBody, {
-        status: safeStatus,
-        statusText: init.statusText,
-        headers: init.headers
-      });
-      if (status !== safeStatus) {
-        const state = getValueBySymbol("state", this);
-        if (state) state.status = status;
-        else Object.defineProperty(this, "status", {
-          value: status,
-          enumerable: true,
-          configurable: true,
-          writable: false
-        });
+    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;
+        }
       }
-      FetchResponse2.setUrl(init.url, this);
-    }
-  };
-  var kRawRequest = Symbol("kRawRequest");
-  function setRawRequest(request, rawRequest) {
-    Reflect.set(request, kRawRequest, rawRequest);
-  }
-
-  // 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;
+      if (!cookiesSeparatorFound || pos >= cookiesString.length) {
+        cookiesStrings.push(cookiesString.substring(start, cookiesString.length));
       }
-      return !!(process.versions && process.versions.node);
     }
-    return false;
+    return cookiesStrings;
   }
+  parseSetCookie.parseSetCookie = parseSetCookie;
+  parseSetCookie.parse = parseSetCookie;
+  parseSetCookie.parseString = parseString;
+  parseSetCookie.splitCookiesString = splitCookiesString;
 
-  // node_modules/.pnpm/@open-draft+logger@0.3.0/node_modules/@open-draft/logger/lib/index.mjs
-  var __defProp2 = Object.defineProperty;
-  var __export2 = (target, all) => {
-    for (var name in all)
-      __defProp2(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`;
+  // node_modules/.pnpm/headers-polyfill@5.0.1/node_modules/headers-polyfill/lib/index.mjs
+  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");
+    return name.trim().toLowerCase();
   }
-  function blue(text) {
-    return `\x1B[34m${text}\x1B[0m`;
+  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) {
+    return value.replace(HEADER_VALUE_REMOVE_REGEXP, "");
   }
-  function gray(text) {
-    return `\x1B[90m${text}\x1B[0m`;
+  function isValidHeaderName(value) {
+    if (typeof value !== "string") return false;
+    if (value.length === 0) return false;
+    for (let i = 0; i < value.length; i++) {
+      const character = value.charCodeAt(i);
+      if (character > 127 || !isToken(character)) return false;
+    }
+    return true;
   }
-  function red(text) {
-    return `\x1B[31m${text}\x1B[0m`;
+  function isToken(value) {
+    return ![
+      127,
+      32,
+      "(",
+      ")",
+      "<",
+      ">",
+      "@",
+      ",",
+      ";",
+      ":",
+      "\\",
+      '"',
+      "/",
+      "[",
+      "]",
+      "?",
+      "=",
+      "{",
+      "}"
+    ].includes(value);
   }
-  function green(text) {
-    return `\x1B[32m${text}\x1B[0m`;
+  function isValidHeaderValue(value) {
+    if (typeof value !== "string") return false;
+    if (value.trim() !== value) return false;
+    for (let i = 0; i < value.length; i++) {
+      const character = value.charCodeAt(i);
+      if (character === 0 || character === 10 || character === 13) return false;
+    }
+    return true;
   }
-  var IS_NODE = isNodeProcess();
-  var Logger = class {
-    constructor(name) {
-      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;
-      }
+  var _Symbol$toStringTag;
+  var NORMALIZED_HEADERS = Symbol("normalizedHeaders");
+  var RAW_HEADER_NAMES = Symbol("rawHeaderNames");
+  var HEADER_VALUE_DELIMITER = ", ";
+  var Headers2 = class Headers3 {
+    constructor(init) {
+      this[NORMALIZED_HEADERS] = {};
+      this[RAW_HEADER_NAMES] = /* @__PURE__ */ new Map();
+      this[_Symbol$toStringTag] = "Headers";
+      if (["Headers", "HeadersPolyfill"].includes(init?.constructor?.name) || init instanceof Headers3 || typeof globalThis.Headers !== "undefined" && init instanceof globalThis.Headers) init.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);
+      });
     }
-    prefix;
-    extend(domain) {
-      return new Logger(`${this.name}:${domain}`);
+    [(_Symbol$toStringTag = Symbol.toStringTag, Symbol.iterator)]() {
+      return this.entries();
     }
-    /**
-     * Print a debug message.
-     * @example
-     * logger.debug('no duplicates found, creating a document...')
-     */
-    debug(message4, ...positionals) {
-      this.logEntry({
-        level: "debug",
-        message: gray(message4),
-        positionals,
-        prefix: this.prefix,
-        colors: {
-          prefix: "gray"
-        }
-      });
+    *keys() {
+      for (const [name] of this.entries()) yield name;
     }
-    /**
-     * Print an info message.
-     * @example
-     * logger.info('start parsing...')
-     */
-    info(message4, ...positionals) {
-      this.logEntry({
-        level: "info",
-        message: message4,
-        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"
-          }
-        });
-      };
+    *values() {
+      for (const [, value] of this.entries()) yield value;
     }
-    /**
-     * Print a success message.
-     * @example
-     * logger.success('successfully created document')
-     */
-    success(message4, ...positionals) {
-      this.logEntry({
-        level: "info",
-        message: message4,
-        positionals,
-        prefix: `\u2714 ${this.prefix}`,
-        colors: {
-          timestamp: "green",
-          prefix: "green"
-        }
-      });
+    *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)];
     }
     /**
-     * Print a warning.
-     * @example
-     * logger.warning('found legacy document format')
-     */
-    warning(message4, ...positionals) {
-      this.logEntry({
-        level: "warning",
-        message: message4,
-        positionals,
-        prefix: `\u26A0 ${this.prefix}`,
-        colors: {
-          timestamp: "yellow",
-          prefix: "yellow"
-        }
-      });
+    * Returns a boolean stating whether a `Headers` object contains a certain header.
+    */
+    has(name) {
+      if (!isValidHeaderName(name)) throw new TypeError(`Invalid header name "${name}"`);
+      return this[NORMALIZED_HEADERS].hasOwnProperty(normalizeHeaderName(name));
     }
     /**
-     * Print an error message.
-     * @example
-     * logger.error('something went wrong')
-     */
-    error(message4, ...positionals) {
-      this.logEntry({
-        level: "error",
-        message: message4,
-        positionals,
-        prefix: `\u2716 ${this.prefix}`,
-        colors: {
-          timestamp: "red",
-          prefix: "red"
-        }
-      });
+    * Returns a `ByteString` sequence of all the values of a header with a given name.
+    */
+    get(name) {
+      if (!isValidHeaderName(name)) throw TypeError(`Invalid header name "${name}"`);
+      return this[NORMALIZED_HEADERS][normalizeHeaderName(name)] ?? null;
     }
     /**
-     * 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, message4) {
-      return {
-        timestamp: /* @__PURE__ */ new Date(),
-        level,
-        message: message4
-      };
-    }
-    logEntry(args) {
-      const {
-        level,
-        message: message4,
-        prefix,
-        colors: customColors,
-        positionals = []
-      } = args;
-      const entry = this.createEntry(level, message4);
-      const timestampColor = customColors?.timestamp || "gray";
-      const prefixColor = 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(message4)).join(" "),
-        ...positionals.map(serializeInput)
-      );
-    }
-    formatTimestamp(timestamp) {
-      return `${timestamp.toLocaleTimeString(
-        "en-GB"
-      )}:${timestamp.getMilliseconds()}`;
+    * Sets a new value for an existing header inside a `Headers` object, or adds the header if it does not already exist.
+    */
+    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);
     }
-    getWriter(level) {
-      switch (level) {
-        case "debug":
-        case "success":
-        case "info": {
-          return log;
-        }
-        case "warning": {
-          return warn2;
-        }
-        case "error": {
-          return error2;
-        }
-      }
+    /**
+    * Appends a new value onto an existing header inside a `Headers` object, or adds the header if it does not already exist.
+    */
+    append(name, value) {
+      if (!isValidHeaderName(name) || !isValidHeaderValue(value)) return;
+      const normalizedName = normalizeHeaderName(name);
+      const normalizedValue = normalizeHeaderValue(value);
+      let resolvedValue = this.has(normalizedName) ? `${this.get(normalizedName)}, ${normalizedValue}` : normalizedValue;
+      this.set(name, resolvedValue);
     }
-  };
-  var PerformanceEntry = class {
-    startTime;
-    endTime;
-    deltaTime;
-    constructor() {
-      this.startTime = performance.now();
+    /**
+    * Deletes a header from the `Headers` object.
+    */
+    delete(name) {
+      if (!isValidHeaderName(name)) return;
+      if (!this.has(name)) return;
+      const normalizedName = normalizeHeaderName(name);
+      delete this[NORMALIZED_HEADERS][normalizedName];
+      this[RAW_HEADER_NAMES].delete(normalizedName);
     }
-    measure() {
-      this.endTime = performance.now();
-      const deltaTime = this.endTime - this.startTime;
-      this.deltaTime = deltaTime.toFixed(2);
+    /**
+    * Traverses the `Headers` object,
+    * calling the given callback for each header.
+    */
+    forEach(callback, thisArg) {
+      for (const [name, value] of this.entries()) callback.call(thisArg, value, name, this);
     }
-  };
-  var noop = () => void 0;
-  function log(message4, ...positionals) {
-    if (IS_NODE) {
-      process.stdout.write(format(message4, ...positionals) + "\n");
-      return;
+    /**
+    * Returns an array containing the values
+    * of all Set-Cookie headers associated
+    * with a response
+    */
+    getSetCookie() {
+      const setCookieHeader = this.get("set-cookie");
+      if (setCookieHeader === null) return [];
+      if (setCookieHeader === "") return [""];
+      return splitCookiesString(setCookieHeader);
     }
-    console.log(message4, ...positionals);
+  };
+  function stringToHeaders(str) {
+    return str.trim().split(/[\r\n]+/).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());
   }
-  function warn2(message4, ...positionals) {
-    if (IS_NODE) {
-      process.stderr.write(format(message4, ...positionals) + "\n");
+
+  // src/core/utils/internal/getCallFrame.ts
+  var SOURCE_FRAME = /[/\\]msw[/\\]src[/\\](.+)/;
+  var BUILD_FRAME = /(node_modules)?[/\\]lib[/\\](core|browser|node|native|iife)[/\\]|^[^/\\]*$/;
+  function getCallFrame(error3) {
+    const stack = error3.stack;
+    if (!stack) {
       return;
     }
-    console.warn(message4, ...positionals);
-  }
-  function error2(message4, ...positionals) {
-    if (IS_NODE) {
-      process.stderr.write(format(message4, ...positionals) + "\n");
+    const frames = stack.split("\n").slice(1);
+    const declarationFrame = frames.find((frame) => {
+      return !(SOURCE_FRAME.test(frame) || BUILD_FRAME.test(frame));
+    });
+    if (!declarationFrame) {
       return;
     }
-    console.error(message4, ...positionals);
+    const declarationPath = declarationFrame.replace(/\s*at [^()]*\(([^)]+)\)/, "$1").replace(/^@/, "");
+    return declarationPath;
   }
-  function getVariable(variableName) {
-    if (IS_NODE) {
-      return process.env[variableName];
+
+  // src/core/utils/internal/isIterable.ts
+  function isIterable(fn) {
+    if (!fn) {
+      return false;
     }
-    return globalThis[variableName]?.toString();
+    return Reflect.has(fn, Symbol.iterator) || Reflect.has(fn, Symbol.asyncIterator);
   }
-  function isDefinedAndNotEquals(value, expected) {
-    return value !== void 0 && value !== expected;
+
+  // node_modules/.pnpm/@open-draft+deferred-promise@2.2.0/node_modules/@open-draft/deferred-promise/build/index.mjs
+  function createDeferredExecutor() {
+    const executor = (resolve, reject) => {
+      executor.state = "pending";
+      executor.resolve = (data) => {
+        if (executor.state !== "pending") {
+          return;
+        }
+        executor.result = data;
+        const onFulfilled = (value) => {
+          executor.state = "fulfilled";
+          return value;
+        };
+        return resolve(
+          data instanceof Promise ? data : Promise.resolve(data).then(onFulfilled)
+        );
+      };
+      executor.reject = (reason) => {
+        if (executor.state !== "pending") {
+          return;
+        }
+        queueMicrotask(() => {
+          executor.state = "rejected";
+        });
+        return reject(executor.rejectionReason = reason);
+      };
+    };
+    return executor;
   }
-  function serializeInput(message4) {
-    if (typeof message4 === "undefined") {
-      return "undefined";
+  var DeferredPromise = class extends Promise {
+    #executor;
+    resolve;
+    reject;
+    constructor(executor = null) {
+      const deferredExecutor = createDeferredExecutor();
+      super((originalResolve, originalReject) => {
+        deferredExecutor(originalResolve, originalReject);
+        executor?.(deferredExecutor.resolve, deferredExecutor.reject);
+      });
+      this.#executor = deferredExecutor;
+      this.resolve = this.#executor.resolve;
+      this.reject = this.#executor.reject;
     }
-    if (message4 === null) {
-      return "null";
+    get state() {
+      return this.#executor.state;
     }
-    if (typeof message4 === "string") {
-      return message4;
+    get rejectionReason() {
+      return this.#executor.rejectionReason;
     }
-    if (typeof message4 === "object") {
-      return JSON.stringify(message4);
+    then(onFulfilled, onRejected) {
+      return this.#decorate(super.then(onFulfilled, onRejected));
     }
-    return message4.toString();
-  }
+    catch(onRejected) {
+      return this.#decorate(super.catch(onRejected));
+    }
+    finally(onfinally) {
+      return this.#decorate(super.finally(onfinally));
+    }
+    #decorate(promise) {
+      return Object.defineProperties(promise, {
+        resolve: { configurable: true, value: this.resolve },
+        reject: { configurable: true, value: this.reject }
+      });
+    }
+  };
 
-  // node_modules/.pnpm/strict-event-emitter@0.5.1/node_modules/strict-event-emitter/lib/index.mjs
-  var MemoryLeakError = class extends Error {
-    constructor(emitter, type, count) {
-      super(
-        `Possible EventEmitter memory leak detected. ${count} ${type.toString()} listeners added. Use emitter.setMaxListeners() to increase limit`
-      );
-      this.emitter = emitter;
-      this.type = type;
-      this.count = count;
-      this.name = "MaxListenersExceededWarning";
+  // node_modules/.pnpm/@mswjs+interceptors@0.41.3/node_modules/@mswjs/interceptors/lib/browser/getRawRequest-BTaNLFr0.mjs
+  var IS_PATCHED_MODULE = Symbol("isPatchedModule");
+  var InterceptorError = class InterceptorError2 extends Error {
+    constructor(message4) {
+      super(message4);
+      this.name = "InterceptorError";
+      Object.setPrototypeOf(this, InterceptorError2.prototype);
     }
   };
-  var _Emitter = class {
-    static listenerCount(emitter, eventName) {
-      return emitter.listenerCount(eventName);
+  var RequestController = class RequestController2 {
+    static {
+      this.PENDING = 0;
     }
-    constructor() {
-      this.events = /* @__PURE__ */ new Map();
-      this.maxListeners = _Emitter.defaultMaxListeners;
-      this.hasWarnedAboutPotentialMemoryLeak = false;
+    static {
+      this.PASSTHROUGH = 1;
     }
-    _emitInternalEvent(internalEventName, eventName, listener) {
-      this.emit(
-        internalEventName,
-        ...[eventName, listener]
-      );
+    static {
+      this.RESPONSE = 2;
     }
-    _getListeners(eventName) {
-      return Array.prototype.concat.apply([], this.events.get(eventName)) || [];
+    static {
+      this.ERROR = 3;
+    }
+    constructor(request, source) {
+      this.request = request;
+      this.source = source;
+      this.readyState = RequestController2.PENDING;
+      this.handled = new DeferredPromise();
+    }
+    get #handled() {
+      return this.handled;
+    }
+    /**
+    * Perform this request as-is.
+    */
+    async passthrough() {
+      invariant.as(InterceptorError, this.readyState === RequestController2.PENDING, 'Failed to passthrough the "%s %s" request: the request has already been handled', this.request.method, this.request.url);
+      this.readyState = RequestController2.PASSTHROUGH;
+      await this.source.passthrough();
+      this.#handled.resolve();
+    }
+    /**
+    * Respond to this request with the given `Response` instance.
+    *
+    * @example
+    * controller.respondWith(new Response())
+    * controller.respondWith(Response.json({ id }))
+    * controller.respondWith(Response.error())
+    */
+    respondWith(response) {
+      invariant.as(InterceptorError, this.readyState === RequestController2.PENDING, 'Failed to respond to the "%s %s" request with "%d %s": the request has already been handled (%d)', this.request.method, this.request.url, response.status, response.statusText || "OK", this.readyState);
+      this.readyState = RequestController2.RESPONSE;
+      this.#handled.resolve();
+      this.source.respondWith(response);
+    }
+    /**
+    * Error this request with the given reason.
+    *
+    * @example
+    * controller.errorWith()
+    * controller.errorWith(new Error('Oops!'))
+    * controller.errorWith({ message: 'Oops!'})
+    */
+    errorWith(reason) {
+      invariant.as(InterceptorError, this.readyState === RequestController2.PENDING, 'Failed to error the "%s %s" request with "%s": the request has already been handled (%d)', this.request.method, this.request.url, reason?.toString(), this.readyState);
+      this.readyState = RequestController2.ERROR;
+      this.source.errorWith(reason);
+      this.#handled.resolve();
+    }
+  };
+  function canParseUrl(url) {
+    try {
+      new URL(url);
+      return true;
+    } catch (_error) {
+      return false;
+    }
+  }
+  function getValueBySymbol(symbolName, source) {
+    const symbol = Object.getOwnPropertySymbols(source).find((symbol$1) => {
+      return symbol$1.description === symbolName;
+    });
+    if (symbol) return Reflect.get(source, symbol);
+  }
+  var FetchResponse = class FetchResponse2 extends Response {
+    static {
+      this.STATUS_CODES_WITHOUT_BODY = [
+        101,
+        103,
+        204,
+        205,
+        304
+      ];
     }
-    _removeListener(listeners, listener) {
-      const index = listeners.indexOf(listener);
-      if (index > -1) {
-        listeners.splice(index, 1);
-      }
-      return [];
+    static {
+      this.STATUS_CODES_WITH_REDIRECT = [
+        301,
+        302,
+        303,
+        307,
+        308
+      ];
     }
-    _wrapOnceListener(eventName, listener) {
-      const onceListener = (...data) => {
-        this.removeListener(eventName, onceListener);
-        return listener.apply(this, data);
-      };
-      Object.defineProperty(onceListener, "name", { value: listener.name });
-      return onceListener;
+    static isConfigurableStatusCode(status) {
+      return status >= 200 && status <= 599;
     }
-    setMaxListeners(maxListeners) {
-      this.maxListeners = maxListeners;
-      return this;
+    static isRedirectResponse(status) {
+      return FetchResponse2.STATUS_CODES_WITH_REDIRECT.includes(status);
     }
     /**
-     * Returns the current max listener value for the `Emitter` which is
-     * either set by `emitter.setMaxListeners(n)` or defaults to
-     * `Emitter.defaultMaxListeners`.
-     */
-    getMaxListeners() {
-      return this.maxListeners;
+    * Returns a boolean indicating whether the given response status
+    * code represents a response that can have a body.
+    */
+    static isResponseWithBody(status) {
+      return !FetchResponse2.STATUS_CODES_WITHOUT_BODY.includes(status);
     }
-    /**
-     * Returns an array listing the events for which the emitter has registered listeners.
-     * The values in the array will be strings or Symbols.
-     */
-    eventNames() {
-      return Array.from(this.events.keys());
+    static setUrl(url, response) {
+      if (!url || url === "about:" || !canParseUrl(url)) return;
+      const state = getValueBySymbol("state", response);
+      if (state) state.urlList.push(new URL(url));
+      else Object.defineProperty(response, "url", {
+        value: url,
+        enumerable: true,
+        configurable: true,
+        writable: false
+      });
     }
     /**
-     * Synchronously calls each of the listeners registered for the event named `eventName`,
-     * in the order they were registered, passing the supplied arguments to each.
-     * Returns `true` if the event has listeners, `false` otherwise.
-     *
-     * @example
-     * const emitter = new Emitter<{ hello: [string] }>()
-     * emitter.emit('hello', 'John')
-     */
-    emit(eventName, ...data) {
-      const listeners = this._getListeners(eventName);
-      listeners.forEach((listener) => {
-        listener.apply(this, data);
-      });
-      return listeners.length > 0;
+    * Parses the given raw HTTP headers into a Fetch API `Headers` instance.
+    */
+    static parseRawHeaders(rawHeaders) {
+      const headers = new Headers();
+      for (let line = 0; line < rawHeaders.length; line += 2) headers.append(rawHeaders[line], rawHeaders[line + 1]);
+      return headers;
     }
-    addListener(eventName, listener) {
-      this._emitInternalEvent("newListener", eventName, listener);
-      const nextListeners = this._getListeners(eventName).concat(listener);
-      this.events.set(eventName, nextListeners);
-      if (this.maxListeners > 0 && this.listenerCount(eventName) > this.maxListeners && !this.hasWarnedAboutPotentialMemoryLeak) {
-        this.hasWarnedAboutPotentialMemoryLeak = true;
-        const memoryLeakWarning = new MemoryLeakError(
-          this,
-          eventName,
-          this.listenerCount(eventName)
-        );
-        console.warn(memoryLeakWarning);
+    constructor(body, init = {}) {
+      const status = init.status ?? 200;
+      const safeStatus = FetchResponse2.isConfigurableStatusCode(status) ? status : 200;
+      const finalBody = FetchResponse2.isResponseWithBody(status) ? body : null;
+      super(finalBody, {
+        status: safeStatus,
+        statusText: init.statusText,
+        headers: init.headers
+      });
+      if (status !== safeStatus) {
+        const state = getValueBySymbol("state", this);
+        if (state) state.status = status;
+        else Object.defineProperty(this, "status", {
+          value: status,
+          enumerable: true,
+          configurable: true,
+          writable: false
+        });
       }
-      return this;
+      FetchResponse2.setUrl(init.url, this);
     }
-    on(eventName, listener) {
-      return this.addListener(eventName, listener);
+  };
+  var kRawRequest = Symbol("kRawRequest");
+  function setRawRequest(request, rawRequest) {
+    Reflect.set(request, kRawRequest, rawRequest);
+  }
+
+  // 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;
     }
-    once(eventName, listener) {
-      return this.addListener(
-        eventName,
-        this._wrapOnceListener(eventName, listener)
-      );
+    if (typeof process !== "undefined") {
+      const type = process.type;
+      if (type === "renderer" || type === "worker") {
+        return false;
+      }
+      return !!(process.versions && process.versions.node);
     }
-    prependListener(eventName, listener) {
-      const listeners = this._getListeners(eventName);
-      if (listeners.length > 0) {
-        const nextListeners = [listener].concat(listeners);
-        this.events.set(eventName, nextListeners);
+    return false;
+  }
+
+  // node_modules/.pnpm/@open-draft+logger@0.3.0/node_modules/@open-draft/logger/lib/index.mjs
+  var __defProp2 = Object.defineProperty;
+  var __export2 = (target, all) => {
+    for (var name in all)
+      __defProp2(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 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) {
+      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.events.set(eventName, listeners.concat(listener));
+        this.info = noop;
+        this.success = noop;
+        this.warning = noop;
+        this.error = noop;
+        this.only = noop;
       }
-      return this;
-    }
-    prependOnceListener(eventName, listener) {
-      return this.prependListener(
-        eventName,
-        this._wrapOnceListener(eventName, listener)
-      );
     }
-    removeListener(eventName, listener) {
-      const listeners = this._getListeners(eventName);
-      if (listeners.length > 0) {
-        this._removeListener(listeners, listener);
-        this.events.set(eventName, listeners);
-        this._emitInternalEvent("removeListener", eventName, listener);
-      }
-      return this;
+    prefix;
+    extend(domain) {
+      return new Logger(`${this.name}:${domain}`);
     }
     /**
-     * Alias for `emitter.removeListener()`.
-     *
+     * Print a debug message.
      * @example
-     * emitter.off('hello', listener)
+     * logger.debug('no duplicates found, creating a document...')
      */
-    off(eventName, listener) {
-      return this.removeListener(eventName, listener);
-    }
-    removeAllListeners(eventName) {
-      if (eventName) {
-        this.events.delete(eventName);
-      } else {
-        this.events.clear();
-      }
-      return this;
+    debug(message4, ...positionals) {
+      this.logEntry({
+        level: "debug",
+        message: gray(message4),
+        positionals,
+        prefix: this.prefix,
+        colors: {
+          prefix: "gray"
+        }
+      });
     }
     /**
-     * Returns a copy of the array of listeners for the event named `eventName`.
+     * Print an info message.
+     * @example
+     * logger.info('start parsing...')
      */
-    listeners(eventName) {
-      return Array.from(this._getListeners(eventName));
+    info(message4, ...positionals) {
+      this.logEntry({
+        level: "info",
+        message: message4,
+        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"
+          }
+        });
+      };
     }
     /**
-     * Returns the number of listeners listening to the event named `eventName`.
+     * Print a success message.
+     * @example
+     * logger.success('successfully created document')
      */
-    listenerCount(eventName) {
-      return this._getListeners(eventName).length;
-    }
-    rawListeners(eventName) {
-      return this.listeners(eventName);
-    }
-  };
-  var Emitter2 = _Emitter;
-  Emitter2.defaultMaxListeners = 10;
-
-  // node_modules/.pnpm/@mswjs+interceptors@0.41.3/node_modules/@mswjs/interceptors/lib/browser/createRequestId-DQcIlohW.mjs
-  var INTERNAL_REQUEST_ID_HEADER_NAME = "x-interceptors-internal-request-id";
-  function getGlobalSymbol(symbol) {
-    return globalThis[symbol] || void 0;
-  }
-  function setGlobalSymbol(symbol, value) {
-    globalThis[symbol] = value;
-  }
-  function deleteGlobalSymbol(symbol) {
-    delete globalThis[symbol];
-  }
-  var InterceptorReadyState = /* @__PURE__ */ (function(InterceptorReadyState$1) {
-    InterceptorReadyState$1["INACTIVE"] = "INACTIVE";
-    InterceptorReadyState$1["APPLYING"] = "APPLYING";
-    InterceptorReadyState$1["APPLIED"] = "APPLIED";
-    InterceptorReadyState$1["DISPOSING"] = "DISPOSING";
-    InterceptorReadyState$1["DISPOSED"] = "DISPOSED";
-    return InterceptorReadyState$1;
-  })({});
-  var Interceptor = class {
-    constructor(symbol) {
-      this.symbol = symbol;
-      this.readyState = InterceptorReadyState.INACTIVE;
-      this.emitter = new Emitter2();
-      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;
+    success(message4, ...positionals) {
+      this.logEntry({
+        level: "info",
+        message: message4,
+        positionals,
+        prefix: `\u2714 ${this.prefix}`,
+        colors: {
+          timestamp: "green",
+          prefix: "green"
+        }
+      });
     }
     /**
-    * 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 === InterceptorReadyState.APPLIED) {
-        logger.info("intercepted already applied!");
-        return;
-      }
-      if (!this.checkEnvironment()) {
-        logger.info("the interceptor cannot be applied in this environment!");
-        return;
-      }
-      this.readyState = InterceptorReadyState.APPLYING;
-      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);
-          });
-          return this;
-        };
-        this.readyState = InterceptorReadyState.APPLIED;
-        return;
-      }
-      logger.info("no running instance found, setting up a new instance...");
-      this.setup();
-      this.setInstance();
-      this.readyState = InterceptorReadyState.APPLIED;
+     * Print a warning.
+     * @example
+     * logger.warning('found legacy document format')
+     */
+    warning(message4, ...positionals) {
+      this.logEntry({
+        level: "warning",
+        message: message4,
+        positionals,
+        prefix: `\u26A0 ${this.prefix}`,
+        colors: {
+          timestamp: "yellow",
+          prefix: "yellow"
+        }
+      });
     }
     /**
-    * 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() {
+     * Print an error message.
+     * @example
+     * logger.error('something went wrong')
+     */
+    error(message4, ...positionals) {
+      this.logEntry({
+        level: "error",
+        message: message4,
+        positionals,
+        prefix: `\u2716 ${this.prefix}`,
+        colors: {
+          timestamp: "red",
+          prefix: "red"
+        }
+      });
     }
     /**
-    * Listen to the interceptor's public events.
-    */
-    on(event, listener) {
-      const logger = this.logger.extend("on");
-      if (this.readyState === InterceptorReadyState.DISPOSING || this.readyState === InterceptorReadyState.DISPOSED) {
-        logger.info("cannot listen to events, already disposed!");
-        return this;
-      }
-      logger.info('adding "%s" event listener:', event, listener);
-      this.emitter.on(event, listener);
-      return this;
+     * 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();
     }
-    once(event, listener) {
-      this.emitter.once(event, listener);
-      return this;
+    createEntry(level, message4) {
+      return {
+        timestamp: /* @__PURE__ */ new Date(),
+        level,
+        message: message4
+      };
     }
-    off(event, listener) {
-      this.emitter.off(event, listener);
-      return this;
+    logEntry(args) {
+      const {
+        level,
+        message: message4,
+        prefix,
+        colors: customColors,
+        positionals = []
+      } = args;
+      const entry = this.createEntry(level, message4);
+      const timestampColor = customColors?.timestamp || "gray";
+      const prefixColor = 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(message4)).join(" "),
+        ...positionals.map(serializeInput)
+      );
     }
-    removeAllListeners(event) {
-      this.emitter.removeAllListeners(event);
-      return this;
+    formatTimestamp(timestamp) {
+      return `${timestamp.toLocaleTimeString(
+        "en-GB"
+      )}:${timestamp.getMilliseconds()}`;
     }
-    /**
-    * Disposes of any side-effects this interceptor has introduced.
-    */
-    dispose() {
-      const logger = this.logger.extend("dispose");
-      if (this.readyState === InterceptorReadyState.DISPOSED) {
-        logger.info("cannot dispose, already disposed!");
-        return;
-      }
-      logger.info("disposing the interceptor...");
-      this.readyState = InterceptorReadyState.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);
+    getWriter(level) {
+      switch (level) {
+        case "debug":
+        case "success":
+        case "info": {
+          return log;
+        }
+        case "warning": {
+          return warn2;
+        }
+        case "error": {
+          return error2;
+        }
       }
-      this.emitter.removeAllListeners();
-      logger.info("destroyed the listener!");
-      this.readyState = InterceptorReadyState.DISPOSED;
     }
-    getInstance() {
-      const instance = getGlobalSymbol(this.symbol);
-      this.logger.info("retrieved global instance:", instance?.constructor?.name);
-      return instance;
+  };
+  var PerformanceEntry = class {
+    startTime;
+    endTime;
+    deltaTime;
+    constructor() {
+      this.startTime = performance.now();
     }
-    setInstance() {
-      setGlobalSymbol(this.symbol, this);
-      this.logger.info("set global instance!", this.symbol.description);
+    measure() {
+      this.endTime = performance.now();
+      const deltaTime = this.endTime - this.startTime;
+      this.deltaTime = deltaTime.toFixed(2);
     }
-    clearInstance() {
-      deleteGlobalSymbol(this.symbol);
-      this.logger.info("cleared global instance!", this.symbol.description);
+  };
+  var noop = () => void 0;
+  function log(message4, ...positionals) {
+    if (IS_NODE) {
+      process.stdout.write(format(message4, ...positionals) + "\n");
+      return;
     }
-  };
-  function createRequestId() {
-    return Math.random().toString(16).slice(2);
+    console.log(message4, ...positionals);
   }
-
-  // node_modules/.pnpm/@mswjs+interceptors@0.41.3/node_modules/@mswjs/interceptors/lib/browser/bufferUtils-BiiO6HZv.mjs
-  var encoder = new TextEncoder();
-  function encodeBuffer(text) {
-    return encoder.encode(text);
+  function warn2(message4, ...positionals) {
+    if (IS_NODE) {
+      process.stderr.write(format(message4, ...positionals) + "\n");
+      return;
+    }
+    console.warn(message4, ...positionals);
   }
-  function decodeBuffer(buffer, encoding) {
-    return new TextDecoder(encoding).decode(buffer);
+  function error2(message4, ...positionals) {
+    if (IS_NODE) {
+      process.stderr.write(format(message4, ...positionals) + "\n");
+      return;
+    }
+    console.error(message4, ...positionals);
   }
-  function toArrayBuffer(array) {
-    return array.buffer.slice(array.byteOffset, array.byteOffset + array.byteLength);
+  function getVariable(variableName) {
+    if (IS_NODE) {
+      return process.env[variableName];
+    }
+    return globalThis[variableName]?.toString();
   }
-
-  // node_modules/.pnpm/@mswjs+interceptors@0.41.3/node_modules/@mswjs/interceptors/lib/browser/resolveWebSocketUrl-C83-x9iE.mjs
-  function resolveWebSocketUrl(url) {
-    if (typeof url === "string") return resolveWebSocketUrl(new URL(url, typeof location !== "undefined" ? location.href : void 0));
-    if (url.protocol === "http:") url.protocol = "ws:";
-    else if (url.protocol === "https:") url.protocol = "wss:";
-    if (url.protocol !== "ws:" && url.protocol !== "wss:")
-      throw new SyntaxError(`Failed to construct 'WebSocket': The URL's scheme must be either 'http', 'https', 'ws', or 'wss'. '${url.protocol}' is not allowed.`);
-    if (url.hash !== "") throw new SyntaxError(`Failed to construct 'WebSocket': The URL contains a fragment identifier ('${url.hash}'). Fragment identifiers are not allowed in WebSocket URLs.`);
-    return url.href;
+  function isDefinedAndNotEquals(value, expected) {
+    return value !== void 0 && value !== expected;
   }
-
-  // node_modules/.pnpm/@mswjs+interceptors@0.41.3/node_modules/@mswjs/interceptors/lib/browser/index.mjs
-  var BatchInterceptor = class BatchInterceptor2 extends Interceptor {
-    constructor(options) {
-      BatchInterceptor2.symbol = Symbol(options.name);
-      super(BatchInterceptor2.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());
-      }
-    }
-    on(event, listener) {
-      for (const interceptor of this.interceptors) interceptor.on(event, listener);
-      return this;
+  function serializeInput(message4) {
+    if (typeof message4 === "undefined") {
+      return "undefined";
     }
-    once(event, listener) {
-      for (const interceptor of this.interceptors) interceptor.once(event, listener);
-      return this;
+    if (message4 === null) {
+      return "null";
     }
-    off(event, listener) {
-      for (const interceptor of this.interceptors) interceptor.off(event, listener);
-      return this;
+    if (typeof message4 === "string") {
+      return message4;
     }
-    removeAllListeners(event) {
-      for (const interceptors of this.interceptors) interceptors.removeAllListeners(event);
-      return this;
+    if (typeof message4 === "object") {
+      return JSON.stringify(message4);
     }
-  };
-  function getCleanUrl(url, isAbsolute = true) {
-    return [isAbsolute && url.origin, url.pathname].filter(Boolean).join("");
+    return message4.toString();
   }
 
-  // src/shims/statuses.ts
-  var allStatuses = __toESM(require_statuses(), 1);
-  var statuses = allStatuses.default || allStatuses;
-  var message = statuses.message;
-  var statuses_default = statuses;
-
-  // node_modules/.pnpm/set-cookie-parser@3.1.0/node_modules/set-cookie-parser/lib/set-cookie.js
-  var defaultParseOptions = {
-    decodeValues: true,
-    map: false,
-    silent: false,
-    split: "auto"
-    // auto = split strings but not arrays
+  // node_modules/.pnpm/strict-event-emitter@0.5.1/node_modules/strict-event-emitter/lib/index.mjs
+  var MemoryLeakError = class extends Error {
+    constructor(emitter, type, count) {
+      super(
+        `Possible EventEmitter memory leak detected. ${count} ${type.toString()} listeners added. Use emitter.setMaxListeners() to increase limit`
+      );
+      this.emitter = emitter;
+      this.type = type;
+      this.count = count;
+      this.name = "MaxListenersExceededWarning";
+    }
   };
-  function isForbiddenKey(key) {
-    return typeof key !== "string" || key in {};
-  }
-  function createNullObj() {
-    return /* @__PURE__ */ Object.create(null);
-  }
-  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;
-    if (isForbiddenKey(name)) {
-      return null;
+  var _Emitter = class {
+    static listenerCount(emitter, eventName) {
+      return emitter.listenerCount(eventName);
     }
-    try {
-      value = options.decodeValues ? decodeURIComponent(value) : value;
-    } catch (e) {
-      console.error(
-        "set-cookie-parser: failed to decode cookie value. Set options.decodeValues=false to disable decoding.",
-        e
+    constructor() {
+      this.events = /* @__PURE__ */ new Map();
+      this.maxListeners = _Emitter.defaultMaxListeners;
+      this.hasWarnedAboutPotentialMemoryLeak = false;
+    }
+    _emitInternalEvent(internalEventName, eventName, listener) {
+      this.emit(
+        internalEventName,
+        ...[eventName, listener]
       );
     }
-    var cookie2 = createNullObj();
-    cookie2.name = name;
-    cookie2.value = value;
-    parts.forEach(function(part) {
-      var sides = part.split("=");
-      var key = sides.shift().trimLeft().toLowerCase();
-      if (isForbiddenKey(key)) {
-        return;
-      }
-      var value2 = sides.join("=");
-      if (key === "expires") {
-        cookie2.expires = new Date(value2);
-      } else if (key === "max-age") {
-        var n = parseInt(value2, 10);
-        if (!Number.isNaN(n)) cookie2.maxAge = n;
-      } else if (key === "secure") {
-        cookie2.secure = true;
-      } else if (key === "httponly") {
-        cookie2.httpOnly = true;
-      } else if (key === "samesite") {
-        cookie2.sameSite = value2;
-      } else if (key === "partitioned") {
-        cookie2.partitioned = true;
-      } else if (key) {
-        cookie2[key] = value2;
-      }
-    });
-    return cookie2;
-  }
-  function parseNameValuePair(nameValuePairStr) {
-    var name = "";
-    var value = "";
-    var nameValueArr = nameValuePairStr.split("=");
-    if (nameValueArr.length > 1) {
-      name = nameValueArr.shift();
-      value = nameValueArr.join("=");
-    } else {
-      value = nameValuePairStr;
+    _getListeners(eventName) {
+      return Array.prototype.concat.apply([], this.events.get(eventName)) || [];
     }
-    return { name, value };
-  }
-  function parseSetCookie(input, options) {
-    options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions;
-    if (!input) {
-      if (!options.map) {
-        return [];
-      } else {
-        return createNullObj();
+    _removeListener(listeners, listener) {
+      const index = listeners.indexOf(listener);
+      if (index > -1) {
+        listeners.splice(index, 1);
       }
+      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;
+    _wrapOnceListener(eventName, listener) {
+      const onceListener = (...data) => {
+        this.removeListener(eventName, onceListener);
+        return listener.apply(this, data);
+      };
+      Object.defineProperty(onceListener, "name", { value: listener.name });
+      return onceListener;
+    }
+    setMaxListeners(maxListeners) {
+      this.maxListeners = maxListeners;
+      return this;
+    }
+    /**
+     * Returns the current max listener value for the `Emitter` which is
+     * either set by `emitter.setMaxListeners(n)` or defaults to
+     * `Emitter.defaultMaxListeners`.
+     */
+    getMaxListeners() {
+      return this.maxListeners;
+    }
+    /**
+     * Returns an array listing the events for which the emitter has registered listeners.
+     * The values in the array will be strings or Symbols.
+     */
+    eventNames() {
+      return Array.from(this.events.keys());
+    }
+    /**
+     * Synchronously calls each of the listeners registered for the event named `eventName`,
+     * in the order they were registered, passing the supplied arguments to each.
+     * Returns `true` if the event has listeners, `false` otherwise.
+     *
+     * @example
+     * const emitter = new Emitter<{ hello: [string] }>()
+     * emitter.emit('hello', 'John')
+     */
+    emit(eventName, ...data) {
+      const listeners = this._getListeners(eventName);
+      listeners.forEach((listener) => {
+        listener.apply(this, data);
+      });
+      return listeners.length > 0;
+    }
+    addListener(eventName, listener) {
+      this._emitInternalEvent("newListener", eventName, listener);
+      const nextListeners = this._getListeners(eventName).concat(listener);
+      this.events.set(eventName, nextListeners);
+      if (this.maxListeners > 0 && this.listenerCount(eventName) > this.maxListeners && !this.hasWarnedAboutPotentialMemoryLeak) {
+        this.hasWarnedAboutPotentialMemoryLeak = true;
+        const memoryLeakWarning = new MemoryLeakError(
+          this,
+          eventName,
+          this.listenerCount(eventName)
+        );
+        console.warn(memoryLeakWarning);
       }
+      return this;
     }
-    var split = options.split;
-    var isArray = Array.isArray(input);
-    if (split === "auto") {
-      split = !isArray;
+    on(eventName, listener) {
+      return this.addListener(eventName, listener);
     }
-    if (!isArray) {
-      input = [input];
+    once(eventName, listener) {
+      return this.addListener(
+        eventName,
+        this._wrapOnceListener(eventName, listener)
+      );
     }
-    input = input.filter(isNonEmptyString);
-    if (split) {
-      input = input.map(splitCookiesString).flat();
+    prependListener(eventName, listener) {
+      const listeners = this._getListeners(eventName);
+      if (listeners.length > 0) {
+        const nextListeners = [listener].concat(listeners);
+        this.events.set(eventName, nextListeners);
+      } else {
+        this.events.set(eventName, listeners.concat(listener));
+      }
+      return this;
     }
-    if (!options.map) {
-      return input.map(function(str) {
-        return parseString(str, options);
-      }).filter(Boolean);
-    } else {
-      var cookies = createNullObj();
-      return input.reduce(function(cookies2, str) {
-        var cookie2 = parseString(str, options);
-        if (cookie2 && !isForbiddenKey(cookie2.name)) {
-          cookies2[cookie2.name] = cookie2;
-        }
-        return cookies2;
-      }, cookies);
+    prependOnceListener(eventName, listener) {
+      return this.prependListener(
+        eventName,
+        this._wrapOnceListener(eventName, listener)
+      );
     }
-  }
-  function splitCookiesString(cookiesString) {
-    if (Array.isArray(cookiesString)) {
-      return cookiesString;
+    removeListener(eventName, listener) {
+      const listeners = this._getListeners(eventName);
+      if (listeners.length > 0) {
+        this._removeListener(listeners, listener);
+        this.events.set(eventName, listeners);
+        this._emitInternalEvent("removeListener", eventName, listener);
+      }
+      return this;
     }
-    if (typeof cookiesString !== "string") {
-      return [];
+    /**
+     * Alias for `emitter.removeListener()`.
+     *
+     * @example
+     * emitter.off('hello', listener)
+     */
+    off(eventName, listener) {
+      return this.removeListener(eventName, listener);
     }
-    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;
+    removeAllListeners(eventName) {
+      if (eventName) {
+        this.events.delete(eventName);
+      } else {
+        this.events.clear();
       }
-      return pos < cookiesString.length;
+      return this;
     }
-    function notSpecialChar() {
-      ch = cookiesString.charAt(pos);
-      return ch !== "=" && ch !== ";" && ch !== ",";
+    /**
+     * Returns a copy of the array of listeners for the event named `eventName`.
+     */
+    listeners(eventName) {
+      return Array.from(this._getListeners(eventName));
     }
-    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));
-      }
+    /**
+     * Returns the number of listeners listening to the event named `eventName`.
+     */
+    listenerCount(eventName) {
+      return this._getListeners(eventName).length;
     }
-    return cookiesStrings;
-  }
-  parseSetCookie.parseSetCookie = parseSetCookie;
-  parseSetCookie.parse = parseSetCookie;
-  parseSetCookie.parseString = parseString;
-  parseSetCookie.splitCookiesString = splitCookiesString;
-
-  // node_modules/.pnpm/headers-polyfill@5.0.1/node_modules/headers-polyfill/lib/index.mjs
-  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");
-    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) {
-    return value.replace(HEADER_VALUE_REMOVE_REGEXP, "");
-  }
-  function isValidHeaderName(value) {
-    if (typeof value !== "string") return false;
-    if (value.length === 0) return false;
-    for (let i = 0; i < value.length; i++) {
-      const character = value.charCodeAt(i);
-      if (character > 127 || !isToken(character)) return false;
+    rawListeners(eventName) {
+      return this.listeners(eventName);
     }
-    return true;
+  };
+  var Emitter2 = _Emitter;
+  Emitter2.defaultMaxListeners = 10;
+
+  // node_modules/.pnpm/@mswjs+interceptors@0.41.3/node_modules/@mswjs/interceptors/lib/browser/createRequestId-DQcIlohW.mjs
+  var INTERNAL_REQUEST_ID_HEADER_NAME = "x-interceptors-internal-request-id";
+  function getGlobalSymbol(symbol) {
+    return globalThis[symbol] || void 0;
   }
-  function isToken(value) {
-    return ![
-      127,
-      32,
-      "(",
-      ")",
-      "<",
-      ">",
-      "@",
-      ",",
-      ";",
-      ":",
-      "\\",
-      '"',
-      "/",
-      "[",
-      "]",
-      "?",
-      "=",
-      "{",
-      "}"
-    ].includes(value);
+  function setGlobalSymbol(symbol, value) {
+    globalThis[symbol] = value;
   }
-  function isValidHeaderValue(value) {
-    if (typeof value !== "string") return false;
-    if (value.trim() !== value) return false;
-    for (let i = 0; i < value.length; i++) {
-      const character = value.charCodeAt(i);
-      if (character === 0 || character === 10 || character === 13) return false;
-    }
-    return true;
+  function deleteGlobalSymbol(symbol) {
+    delete globalThis[symbol];
   }
-  var _Symbol$toStringTag;
-  var NORMALIZED_HEADERS = Symbol("normalizedHeaders");
-  var RAW_HEADER_NAMES = Symbol("rawHeaderNames");
-  var HEADER_VALUE_DELIMITER = ", ";
-  var Headers2 = class Headers3 {
-    constructor(init) {
-      this[NORMALIZED_HEADERS] = {};
-      this[RAW_HEADER_NAMES] = /* @__PURE__ */ new Map();
-      this[_Symbol$toStringTag] = "Headers";
-      if (["Headers", "HeadersPolyfill"].includes(init?.constructor?.name) || init instanceof Headers3 || typeof globalThis.Headers !== "undefined" && init instanceof globalThis.Headers) init.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);
-      });
-    }
-    [(_Symbol$toStringTag = Symbol.toStringTag, Symbol.iterator)]() {
-      return this.entries();
-    }
-    *keys() {
-      for (const [name] of this.entries()) yield name;
-    }
-    *values() {
-      for (const [, value] of this.entries()) yield value;
-    }
-    *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)];
+  var InterceptorReadyState = /* @__PURE__ */ (function(InterceptorReadyState$1) {
+    InterceptorReadyState$1["INACTIVE"] = "INACTIVE";
+    InterceptorReadyState$1["APPLYING"] = "APPLYING";
+    InterceptorReadyState$1["APPLIED"] = "APPLIED";
+    InterceptorReadyState$1["DISPOSING"] = "DISPOSING";
+    InterceptorReadyState$1["DISPOSED"] = "DISPOSED";
+    return InterceptorReadyState$1;
+  })({});
+  var Interceptor = class {
+    constructor(symbol) {
+      this.symbol = symbol;
+      this.readyState = InterceptorReadyState.INACTIVE;
+      this.emitter = new Emitter2();
+      this.subscriptions = [];
+      this.logger = new Logger(symbol.description);
+      this.emitter.setMaxListeners(0);
+      this.logger.info("constructing the interceptor...");
     }
     /**
-    * Returns a boolean stating whether a `Headers` object contains a certain header.
+    * Determine if this interceptor can be applied
+    * in the current environment.
     */
-    has(name) {
-      if (!isValidHeaderName(name)) throw new TypeError(`Invalid header name "${name}"`);
-      return this[NORMALIZED_HEADERS].hasOwnProperty(normalizeHeaderName(name));
+    checkEnvironment() {
+      return true;
     }
     /**
-    * Returns a `ByteString` sequence of all the values of a header with a given name.
+    * Apply this interceptor to the current process.
+    * Returns an already running interceptor instance if it's present.
     */
-    get(name) {
-      if (!isValidHeaderName(name)) throw TypeError(`Invalid header name "${name}"`);
-      return this[NORMALIZED_HEADERS][normalizeHeaderName(name)] ?? null;
+    apply() {
+      const logger = this.logger.extend("apply");
+      logger.info("applying the interceptor...");
+      if (this.readyState === InterceptorReadyState.APPLIED) {
+        logger.info("intercepted already applied!");
+        return;
+      }
+      if (!this.checkEnvironment()) {
+        logger.info("the interceptor cannot be applied in this environment!");
+        return;
+      }
+      this.readyState = InterceptorReadyState.APPLYING;
+      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);
+          });
+          return this;
+        };
+        this.readyState = InterceptorReadyState.APPLIED;
+        return;
+      }
+      logger.info("no running instance found, setting up a new instance...");
+      this.setup();
+      this.setInstance();
+      this.readyState = InterceptorReadyState.APPLIED;
     }
     /**
-    * Sets a new value for an existing header inside a `Headers` object, or adds the header if it does not already exist.
+    * 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.
     */
-    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);
+    setup() {
     }
     /**
-    * Appends a new value onto an existing header inside a `Headers` object, or adds the header if it does not already exist.
+    * Listen to the interceptor's public events.
     */
-    append(name, value) {
-      if (!isValidHeaderName(name) || !isValidHeaderValue(value)) return;
-      const normalizedName = normalizeHeaderName(name);
-      const normalizedValue = normalizeHeaderValue(value);
-      let resolvedValue = this.has(normalizedName) ? `${this.get(normalizedName)}, ${normalizedValue}` : normalizedValue;
-      this.set(name, resolvedValue);
+    on(event, listener) {
+      const logger = this.logger.extend("on");
+      if (this.readyState === InterceptorReadyState.DISPOSING || this.readyState === InterceptorReadyState.DISPOSED) {
+        logger.info("cannot listen to events, already disposed!");
+        return this;
+      }
+      logger.info('adding "%s" event listener:', event, listener);
+      this.emitter.on(event, listener);
+      return this;
     }
-    /**
-    * Deletes a header from the `Headers` object.
-    */
-    delete(name) {
-      if (!isValidHeaderName(name)) return;
-      if (!this.has(name)) return;
-      const normalizedName = normalizeHeaderName(name);
-      delete this[NORMALIZED_HEADERS][normalizedName];
-      this[RAW_HEADER_NAMES].delete(normalizedName);
+    once(event, listener) {
+      this.emitter.once(event, listener);
+      return this;
     }
-    /**
-    * Traverses the `Headers` object,
-    * calling the given callback for each header.
-    */
-    forEach(callback, thisArg) {
-      for (const [name, value] of this.entries()) callback.call(thisArg, value, name, this);
+    off(event, listener) {
+      this.emitter.off(event, listener);
+      return this;
+    }
+    removeAllListeners(event) {
+      this.emitter.removeAllListeners(event);
+      return this;
     }
     /**
-    * Returns an array containing the values
-    * of all Set-Cookie headers associated
-    * with a response
+    * Disposes of any side-effects this interceptor has introduced.
     */
-    getSetCookie() {
-      const setCookieHeader = this.get("set-cookie");
-      if (setCookieHeader === null) return [];
-      if (setCookieHeader === "") return [""];
-      return splitCookiesString(setCookieHeader);
+    dispose() {
+      const logger = this.logger.extend("dispose");
+      if (this.readyState === InterceptorReadyState.DISPOSED) {
+        logger.info("cannot dispose, already disposed!");
+        return;
+      }
+      logger.info("disposing the interceptor...");
+      this.readyState = InterceptorReadyState.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.removeAllListeners();
+      logger.info("destroyed the listener!");
+      this.readyState = InterceptorReadyState.DISPOSED;
+    }
+    getInstance() {
+      const instance = getGlobalSymbol(this.symbol);
+      this.logger.info("retrieved global instance:", instance?.constructor?.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);
     }
   };
-  function stringToHeaders(str) {
-    return str.trim().split(/[\r\n]+/).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());
+  function createRequestId() {
+    return Math.random().toString(16).slice(2);
+  }
+
+  // node_modules/.pnpm/@mswjs+interceptors@0.41.3/node_modules/@mswjs/interceptors/lib/browser/bufferUtils-BiiO6HZv.mjs
+  var encoder = new TextEncoder();
+  function encodeBuffer(text) {
+    return encoder.encode(text);
+  }
+  function decodeBuffer(buffer, encoding) {
+    return new TextDecoder(encoding).decode(buffer);
+  }
+  function toArrayBuffer(array) {
+    return array.buffer.slice(array.byteOffset, array.byteOffset + array.byteLength);
+  }
+
+  // node_modules/.pnpm/@mswjs+interceptors@0.41.3/node_modules/@mswjs/interceptors/lib/browser/resolveWebSocketUrl-C83-x9iE.mjs
+  function resolveWebSocketUrl(url) {
+    if (typeof url === "string") return resolveWebSocketUrl(new URL(url, typeof location !== "undefined" ? location.href : void 0));
+    if (url.protocol === "http:") url.protocol = "ws:";
+    else if (url.protocol === "https:") url.protocol = "wss:";
+    if (url.protocol !== "ws:" && url.protocol !== "wss:")
+      throw new SyntaxError(`Failed to construct 'WebSocket': The URL's scheme must be either 'http', 'https', 'ws', or 'wss'. '${url.protocol}' is not allowed.`);
+    if (url.hash !== "") throw new SyntaxError(`Failed to construct 'WebSocket': The URL contains a fragment identifier ('${url.hash}'). Fragment identifiers are not allowed in WebSocket URLs.`);
+    return url.href;
+  }
+
+  // node_modules/.pnpm/@mswjs+interceptors@0.41.3/node_modules/@mswjs/interceptors/lib/browser/index.mjs
+  var BatchInterceptor = class BatchInterceptor2 extends Interceptor {
+    constructor(options) {
+      BatchInterceptor2.symbol = Symbol(options.name);
+      super(BatchInterceptor2.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());
+      }
+    }
+    on(event, listener) {
+      for (const interceptor of this.interceptors) interceptor.on(event, listener);
+      return this;
+    }
+    once(event, listener) {
+      for (const interceptor of this.interceptors) interceptor.once(event, listener);
+      return this;
+    }
+    off(event, listener) {
+      for (const interceptor of this.interceptors) interceptor.off(event, listener);
+      return this;
+    }
+    removeAllListeners(event) {
+      for (const interceptors of this.interceptors) interceptors.removeAllListeners(event);
+      return this;
+    }
+  };
+  function getCleanUrl(url, isAbsolute = true) {
+    return [isAbsolute && url.origin, url.pathname].filter(Boolean).join("");
   }
 
+  // src/shims/statuses.ts
+  var allStatuses = __toESM(require_statuses(), 1);
+  var statuses = allStatuses.default || allStatuses;
+  var message = statuses.message;
+  var statuses_default = statuses;
+
   // src/core/utils/HttpResponse/decorators.ts
   var { message: message2 } = statuses_default;
   var kSetCookie = Symbol("kSetCookie");
@@ -15957,17 +15957,12 @@ ${operationTypes.join("\n")}
         enumerable: false,
         writable: false
       });
-      if (typeof document !== "undefined") {
-        const responseCookiePairs = Headers2.prototype.getSetCookie.call(
-          init.headers
-        );
-        for (const cookieString of responseCookiePairs) {
-          document.cookie = cookieString;
-        }
-      }
     }
     return response;
   }
+  function getRawSetCookie(response) {
+    return Reflect.get(response, kSetCookie);
+  }
 
   // src/core/HttpResponse.ts
   var bodyType = Symbol("bodyType");
@@ -16249,6 +16244,9 @@ ${operationTypes.join("\n")}
         throw errorOrResponse;
       });
       const mockedResponse = await mockedResponsePromise;
+      if (mockedResponse) {
+        forwardResponseCookies(mockedResponse);
+      }
       const executionResult = this.createExecutionResult({
         // Pass the cloned request to the result so that logging
         // and other consumers could read its body once more.
@@ -16291,6 +16289,21 @@ ${operationTypes.join("\n")}
       };
     }
   };
+  function forwardResponseCookies(response) {
+    if (typeof document === "undefined") {
+      return;
+    }
+    const responseCookies = getRawSetCookie(response);
+    if (!responseCookies) {
+      return;
+    }
+    const allResponseCookies = Headers2.prototype.getSetCookie.call(
+      new Headers([["set-cookie", responseCookies]])
+    );
+    for (const cookieString of allResponseCookies) {
+      document.cookie = cookieString;
+    }
+  }
 
   // node_modules/.pnpm/path-to-regexp@6.3.0/node_modules/path-to-regexp/dist.es2015/index.js
   function lexer(str) {
@@ -16975,7 +16988,7 @@ ${operationTypes.join("\n")}
         ...connection,
         params: parsedResult.match.params || {}
       };
-      if (resolutionContext?.[kAutoConnect]) {
+      if (resolutionContext?.[kAutoConnect] ?? true) {
         if (this[kConnect](resolvedConnection)) {
           return resolvedConnection;
         }
@@ -17075,12 +17088,40 @@ ${operationTypes.join("\n")}
     };
   }
 
+  // src/core/utils/internal/attachSiblingHandlers.ts
+  var kSiblingHandlers = Symbol("kSiblingHandlers");
+  function attachSiblingHandlers(owner, siblings) {
+    invariant(
+      getSiblingHandlers(owner).length === 0,
+      'Failed to merge handlers: the owner "%s" handler is already merged',
+      owner.kind
+    );
+    Object.defineProperty(owner, kSiblingHandlers, {
+      value: siblings,
+      enumerable: false,
+      writable: false,
+      configurable: false
+    });
+    return owner;
+  }
+  function getSiblingHandlers(owner) {
+    return Reflect.get(owner, kSiblingHandlers) || [];
+  }
+
   // src/core/experimental/handlers-controller.ts
   function groupHandlersByKind(handlers) {
     const groups = {};
+    const pushUnique = (kind, handler) => {
+      const bucket = groups[kind] ||= [];
+      if (!bucket.includes(handler)) {
+        bucket.push(handler);
+      }
+    };
     for (const handler of handlers) {
-      ;
-      (groups[handler.kind] ||= []).push(handler);
+      pushUnique(handler.kind, handler);
+      for (const sibling of getSiblingHandlers(handler)) {
+        pushUnique(sibling.kind, sibling);
+      }
     }
     return groups;
   }
@@ -17115,9 +17156,11 @@ ${operationTypes.join("\n")}
         return;
       }
       const { handlers } = this.getState();
-      for (let i = nextHandlers.length - 1; i >= 0; i--) {
-        const handler = nextHandlers[i];
-        handlers[handler.kind] = handlers[handler.kind] ? [handler, ...handlers[handler.kind]] : [handler];
+      const overrides = groupHandlersByKind(nextHandlers);
+      for (const kind in overrides) {
+        const overridesForKind = overrides[kind];
+        const existingForKind = handlers[kind];
+        handlers[kind] = existingForKind ? [...overridesForKind, ...existingForKind] : overridesForKind;
       }
       this.setState({ handlers });
     }
@@ -20938,17 +20981,20 @@ Consider naming this operation or using "graphql.operation()" request handler to
       typeof url
     );
     const clientManager = new WebSocketClientManager(webSocketChannel);
+    const upgradeHandler = http.get(({ request }) => {
+      return request.headers.get("upgrade")?.toLowerCase() === "websocket" && matchRequestUrl(new URL(resolveWebSocketUrl(request.url)), url).matches;
+    }, ws.onUpgrade);
     return {
       get clients() {
         return clientManager.clients;
       },
       addEventListener(event, listener) {
-        const handler = new WebSocketHandler(url);
-        handler[kEmitter].on("connection", async ({ client }) => {
+        const webSocketHandler = new WebSocketHandler(url);
+        webSocketHandler[kEmitter].on("connection", async ({ client }) => {
           await clientManager.addConnection(client);
         });
-        handler[kEmitter].on(event, listener);
-        return handler;
+        webSocketHandler[kEmitter].on(event, listener);
+        return attachSiblingHandlers(webSocketHandler, [upgradeHandler]);
       },
       broadcast(data) {
         this.broadcastExcept([], data);
@@ -20963,8 +21009,27 @@ Consider naming this operation or using "graphql.operation()" request handler to
       }
     };
   }
+  var WEBSOCKET_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
   var ws = {
-    link: createWebSocketLinkHandler
+    link: createWebSocketLinkHandler,
+    async onUpgrade({ request }) {
+      const key = request.headers.get("sec-websocket-key");
+      if (!key) {
+        return;
+      }
+      const keyBytes = new TextEncoder().encode(key + WEBSOCKET_GUID);
+      const digest = await crypto.subtle.digest("SHA-1", keyBytes);
+      const acceptValue = btoa(String.fromCharCode(...new Uint8Array(digest)));
+      new WebSocket(resolveWebSocketUrl(request.url));
+      return new FetchResponse(null, {
+        status: 101,
+        headers: {
+          upgrade: "websocket",
+          connection: "upgrade",
+          "sec-websocket-accept": acceptValue
+        }
+      });
+    }
   };
 
   // src/core/delay.ts
@@ -21729,7 +21794,7 @@ Read more: https://mswjs.io/docs/http/intercepting-requests`;
 
   // src/core/utils/request/storeResponseCookies.ts
   async function storeResponseCookies(request, response) {
-    const responseCookies = Reflect.get(response, kSetCookie);
+    const responseCookies = getRawSetCookie(response);
     if (responseCookies) {
       await cookieStore.setCookie(responseCookies, request.url);
     }
@@ -22551,8 +22616,9 @@ Read more: https://mswjs.io/docs/http/intercepting-requests`;
         this.passthrough();
         return null;
       }
+      const responseCloneForLogs = resolutionContext?.quiet ? null : response.clone();
       await storeResponseCookies(request, response);
-      this.respondWith(response.clone());
+      this.respondWith(response);
       this.events.emit(
         new RequestEvent("request:end", {
           requestId,
@@ -22562,7 +22628,7 @@ Read more: https://mswjs.io/docs/http/intercepting-requests`;
       if (!resolutionContext?.quiet) {
         handler.log({
           request: requestCloneForLogs,
-          response,
+          response: responseCloneForLogs,
           parsedResult
         });
       }