msw 0.40.1 → 0.41.1

package/lib/esm/index.js

@@ -1,1729 +1,2109 @@
-export { i as context } from './index-deps.js';
-import { c as commonjsGlobal, p as parse_1, l as lib$2, a as lib$3, j as jsonParse } from './fetch-deps.js';
-import { _ as __awaiter, d as devUtils, p as passthrough, a as parseBody, g as getPublicUrlFromRequest, N as NetworkError } from './matchRequestUrl-deps.js';
-export { R as RequestHandler, h as cleanUrl, f as compose, c as createResponseComposition, e as defaultContext, b as defaultResponse, m as matchRequestUrl, r as response } from './matchRequestUrl-deps.js';
-import { store } from '@mswjs/cookies';
-import { i as isStringEqual, R as RestHandler } from './rest-deps.js';
-export { a as RESTMethods, R as RestHandler, r as rest, b as restContext } from './rest-deps.js';
-import { t as tryCatch, p as parseGraphQLRequest, G as GraphQLHandler } from './graphql-deps.js';
-export { G as GraphQLHandler, g as graphql, a as graphqlContext } from './graphql-deps.js';
-import { m as mergeRight } from './errors-deps.js';
-import { createInterceptor } from '@mswjs/interceptors';
-import { interceptFetch } from '@mswjs/interceptors/lib/interceptors/fetch';
-import { interceptXMLHttpRequest } from '@mswjs/interceptors/lib/interceptors/XMLHttpRequest';
-import './xml-deps.js';
-import '@mswjs/interceptors/lib/utils/getCleanUrl';
-
-var lib$1 = {};
-
-var StrictEventEmitter$1 = {};
-
-var events = {exports: {}};
-
-var R = typeof Reflect === 'object' ? Reflect : null;
-var ReflectApply = R && typeof R.apply === 'function'
-  ? R.apply
-  : function ReflectApply(target, receiver, args) {
-    return Function.prototype.apply.call(target, receiver, args);
-  };
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw new Error('Dynamic require of "' + x + '" is not supported');
+});
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
 
-var ReflectOwnKeys;
-if (R && typeof R.ownKeys === 'function') {
-  ReflectOwnKeys = R.ownKeys;
-} else if (Object.getOwnPropertySymbols) {
-  ReflectOwnKeys = function ReflectOwnKeys(target) {
-    return Object.getOwnPropertyNames(target)
-      .concat(Object.getOwnPropertySymbols(target));
-  };
-} else {
-  ReflectOwnKeys = function ReflectOwnKeys(target) {
-    return Object.getOwnPropertyNames(target);
-  };
-}
+// node_modules/tsup/assets/esm_shims.js
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+  }
+});
 
-function ProcessEmitWarning(warning) {
-  if (console && console.warn) console.warn(warning);
-}
+// node_modules/outvariant/lib/format.js
+var require_format = __commonJS({
+  "node_modules/outvariant/lib/format.js"(exports) {
+    "use strict";
+    init_esm_shims();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.format = void 0;
+    var POSITIONALS_EXP = /(%?)(%([sdjo]))/g;
+    function serializePositional(positional, flag) {
+      switch (flag) {
+        case "s":
+          return positional;
+        case "d":
+        case "i":
+          return Number(positional);
+        case "j":
+          return JSON.stringify(positional);
+        case "o": {
+          if (typeof positional === "string") {
+            return positional;
+          }
+          var json2 = JSON.stringify(positional);
+          if (json2 === "{}" || json2 === "[]" || /^\[object .+?\]$/.test(json2)) {
+            return positional;
+          }
+          return json2;
+        }
+      }
+    }
+    function format2(message) {
+      var positionals = [];
+      for (var _i = 1; _i < arguments.length; _i++) {
+        positionals[_i - 1] = arguments[_i];
+      }
+      if (positionals.length === 0) {
+        return message;
+      }
+      var positionalIndex = 0;
+      var formattedMessage = message.replace(POSITIONALS_EXP, function(match2, isEscaped, _, flag) {
+        var positional = positionals[positionalIndex];
+        var value = serializePositional(positional, flag);
+        if (!isEscaped) {
+          positionalIndex++;
+          return value;
+        }
+        return match2;
+      });
+      if (positionalIndex < positionals.length) {
+        formattedMessage += " " + positionals.slice(positionalIndex).join(" ");
+      }
+      formattedMessage = formattedMessage.replace(/%{2,2}/g, "%");
+      return formattedMessage;
+    }
+    exports.format = format2;
+  }
+});
+
+// node_modules/outvariant/lib/invariant.js
+var require_invariant = __commonJS({
+  "node_modules/outvariant/lib/invariant.js"(exports) {
+    "use strict";
+    init_esm_shims();
+    var __extends = exports && exports.__extends || function() {
+      var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+          d2.__proto__ = b2;
+        } || function(d2, b2) {
+          for (var p in b2)
+            if (Object.prototype.hasOwnProperty.call(b2, p))
+              d2[p] = b2[p];
+        };
+        return extendStatics(d, b);
+      };
+      return function(d, b) {
+        if (typeof b !== "function" && b !== null)
+          throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() {
+          this.constructor = d;
+        }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+      };
+    }();
+    var __spreadArray = exports && exports.__spreadArray || function(to, from) {
+      for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+        to[j] = from[i];
+      return to;
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.invariant = exports.InvariantError = void 0;
+    var format_1 = require_format();
+    var STACK_FRAMES_TO_IGNORE = 2;
+    var InvariantError = function(_super) {
+      __extends(InvariantError2, _super);
+      function InvariantError2(message) {
+        var positionals = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+          positionals[_i - 1] = arguments[_i];
+        }
+        var _this = _super.call(this, message) || this;
+        _this.name = "Invariant Violation";
+        _this.message = format_1.format.apply(void 0, __spreadArray([message], positionals));
+        if (_this.stack) {
+          var nextStack = _this.stack.split("\n");
+          nextStack.splice(1, STACK_FRAMES_TO_IGNORE);
+          _this.stack = nextStack.join("\n");
+        }
+        return _this;
+      }
+      return InvariantError2;
+    }(Error);
+    exports.InvariantError = InvariantError;
+    function invariant(predicate, message) {
+      var positionals = [];
+      for (var _i = 2; _i < arguments.length; _i++) {
+        positionals[_i - 2] = arguments[_i];
+      }
+      if (!predicate) {
+        throw new (InvariantError.bind.apply(InvariantError, __spreadArray([void 0, message], positionals)))();
+      }
+    }
+    exports.invariant = invariant;
+  }
+});
+
+// node_modules/outvariant/lib/index.js
+var require_lib = __commonJS({
+  "node_modules/outvariant/lib/index.js"(exports) {
+    "use strict";
+    init_esm_shims();
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      Object.defineProperty(o, k2, { enumerable: true, get: function() {
+        return m[k];
+      } });
+    } : function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m)
+        if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
+          __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __exportStar(require_invariant(), exports);
+    __exportStar(require_format(), exports);
+  }
+});
 
-var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {
-  return value !== value;
+// src/index.ts
+init_esm_shims();
+
+// src/context/index.ts
+var context_exports = {};
+__export(context_exports, {
+  body: () => body,
+  cookie: () => cookie,
+  data: () => data,
+  delay: () => delay,
+  errors: () => errors,
+  extensions: () => extensions,
+  fetch: () => fetch,
+  json: () => json,
+  set: () => set,
+  status: () => status,
+  text: () => text,
+  xml: () => xml
+});
+init_esm_shims();
+
+// src/context/status.ts
+init_esm_shims();
+import statuses from "statuses/codes.json";
+var status = (statusCode, statusText) => {
+  return (res) => {
+    res.status = statusCode;
+    res.statusText = statusText || statuses[String(statusCode)];
+    return res;
+  };
 };
 
-function EventEmitter() {
-  EventEmitter.init.call(this);
+// src/context/set.ts
+init_esm_shims();
+import { objectToHeaders } from "headers-polyfill";
+function set(...args) {
+  return (res) => {
+    const [name, value] = args;
+    if (typeof name === "string") {
+      res.headers.append(name, value);
+    } else {
+      const headers = objectToHeaders(name);
+      headers.forEach((value2, name2) => {
+        res.headers.append(name2, value2);
+      });
+    }
+    return res;
+  };
 }
-events.exports = EventEmitter;
-events.exports.once = once;
 
-// Backwards-compat with node 0.10.x
-EventEmitter.EventEmitter = EventEmitter;
+// src/context/cookie.ts
+init_esm_shims();
+import * as cookieUtils from "cookie";
+var cookie = (name, value, options) => {
+  return (res) => {
+    const serializedCookie = cookieUtils.serialize(name, value, options);
+    res.headers.set("Set-Cookie", serializedCookie);
+    if (typeof document !== "undefined") {
+      document.cookie = serializedCookie;
+    }
+    return res;
+  };
+};
 
-EventEmitter.prototype._events = undefined;
-EventEmitter.prototype._eventsCount = 0;
-EventEmitter.prototype._maxListeners = undefined;
+// src/context/body.ts
+init_esm_shims();
+var body = (value) => {
+  return (res) => {
+    res.body = value;
+    return res;
+  };
+};
 
-// By default EventEmitters will print a warning if more than 10 listeners are
-// added to it. This is a useful default which helps finding memory leaks.
-var defaultMaxListeners = 10;
+// src/context/data.ts
+init_esm_shims();
 
-function checkListener(listener) {
-  if (typeof listener !== 'function') {
-    throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
+// src/utils/internal/jsonParse.ts
+init_esm_shims();
+function jsonParse(value) {
+  try {
+    return JSON.parse(value);
+  } catch (error2) {
+    return void 0;
   }
 }
 
-Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
-  enumerable: true,
-  get: function() {
-    return defaultMaxListeners;
-  },
-  set: function(arg) {
-    if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {
-      throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + '.');
+// src/utils/internal/mergeRight.ts
+init_esm_shims();
+
+// src/utils/internal/isObject.ts
+init_esm_shims();
+function isObject(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/utils/internal/mergeRight.ts
+function mergeRight(left, right) {
+  return Object.entries(right).reduce((result, [key, rightValue]) => {
+    const leftValue = result[key];
+    if (Array.isArray(leftValue) && Array.isArray(rightValue)) {
+      result[key] = leftValue.concat(rightValue);
+      return result;
     }
-    defaultMaxListeners = arg;
-  }
-});
+    if (isObject(leftValue) && isObject(rightValue)) {
+      result[key] = mergeRight(leftValue, rightValue);
+      return result;
+    }
+    result[key] = rightValue;
+    return result;
+  }, Object.assign({}, left));
+}
 
-EventEmitter.init = function() {
+// src/context/json.ts
+init_esm_shims();
+var json = (body2) => {
+  return (res) => {
+    res.headers.set("Content-Type", "application/json");
+    res.body = JSON.stringify(body2);
+    return res;
+  };
+};
 
-  if (this._events === undefined ||
-      this._events === Object.getPrototypeOf(this)._events) {
-    this._events = Object.create(null);
-    this._eventsCount = 0;
-  }
+// src/context/data.ts
+var data = (payload) => {
+  return (res) => {
+    const prevBody = jsonParse(res.body) || {};
+    const nextBody = mergeRight(prevBody, { data: payload });
+    return json(nextBody)(res);
+  };
+};
 
-  this._maxListeners = this._maxListeners || undefined;
+// src/context/extensions.ts
+init_esm_shims();
+var extensions = (payload) => {
+  return (res) => {
+    const prevBody = jsonParse(res.body) || {};
+    const nextBody = mergeRight(prevBody, { extensions: payload });
+    return json(nextBody)(res);
+  };
 };
 
-// Obviously not all Emitters should be limited to 10. This function allows
-// that to be increased. Set to zero for unlimited.
-EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
-  if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {
-    throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + '.');
+// src/context/delay.ts
+init_esm_shims();
+import { isNodeProcess } from "is-node-process";
+var SET_TIMEOUT_MAX_ALLOWED_INT = 2147483647;
+var MIN_SERVER_RESPONSE_TIME = 100;
+var MAX_SERVER_RESPONSE_TIME = 400;
+var NODE_SERVER_RESPONSE_TIME = 5;
+var getRandomServerResponseTime = () => {
+  if (isNodeProcess()) {
+    return NODE_SERVER_RESPONSE_TIME;
   }
-  this._maxListeners = n;
-  return this;
+  return Math.floor(Math.random() * (MAX_SERVER_RESPONSE_TIME - MIN_SERVER_RESPONSE_TIME) + MIN_SERVER_RESPONSE_TIME);
+};
+var delay = (durationOrMode) => {
+  return (res) => {
+    let delayTime;
+    if (typeof durationOrMode === "string") {
+      switch (durationOrMode) {
+        case "infinite": {
+          delayTime = SET_TIMEOUT_MAX_ALLOWED_INT;
+          break;
+        }
+        case "real": {
+          delayTime = getRandomServerResponseTime();
+          break;
+        }
+        default: {
+          throw new Error(`Failed to delay a response: unknown delay mode "${durationOrMode}". Please make sure you provide one of the supported modes ("real", "infinite") or a number to "ctx.delay".`);
+        }
+      }
+    } else if (typeof durationOrMode === "undefined") {
+      delayTime = getRandomServerResponseTime();
+    } else {
+      if (durationOrMode > SET_TIMEOUT_MAX_ALLOWED_INT) {
+        throw new Error(`Failed to delay a response: provided delay duration (${durationOrMode}) exceeds the maximum allowed duration for "setTimeout" (${SET_TIMEOUT_MAX_ALLOWED_INT}). This will cause the response to be returned immediately. Please use a number within the allowed range to delay the response by exact duration, or consider the "infinite" delay mode to delay the response indefinitely.`);
+      }
+      delayTime = durationOrMode;
+    }
+    res.delay = delayTime;
+    return res;
+  };
 };
 
-function _getMaxListeners(that) {
-  if (that._maxListeners === undefined)
-    return EventEmitter.defaultMaxListeners;
-  return that._maxListeners;
-}
+// src/context/errors.ts
+init_esm_shims();
+var errors = (errorsList) => {
+  return (res) => {
+    if (errorsList == null) {
+      return res;
+    }
+    const prevBody = jsonParse(res.body) || {};
+    const nextBody = mergeRight(prevBody, { errors: errorsList });
+    return json(nextBody)(res);
+  };
+};
 
-EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
-  return _getMaxListeners(this);
+// src/context/fetch.ts
+init_esm_shims();
+import { isNodeProcess as isNodeProcess2 } from "is-node-process";
+import { Headers } from "headers-polyfill";
+var useFetch = isNodeProcess2() ? __require("node-fetch") : window.fetch;
+var augmentRequestInit = (requestInit) => {
+  const headers = new Headers(requestInit.headers);
+  headers.set("x-msw-bypass", "true");
+  return __spreadProps(__spreadValues({}, requestInit), {
+    headers: headers.all()
+  });
+};
+var createFetchRequestParameters = (input) => {
+  const { body: body2, method } = input;
+  const requestParameters = __spreadProps(__spreadValues({}, input), {
+    body: void 0
+  });
+  if (["GET", "HEAD"].includes(method)) {
+    return requestParameters;
+  }
+  if (typeof body2 === "object" || typeof body2 === "number" || typeof body2 === "boolean") {
+    requestParameters.body = JSON.stringify(body2);
+  } else {
+    requestParameters.body = body2;
+  }
+  return requestParameters;
+};
+var fetch = (input, requestInit = {}) => {
+  if (typeof input === "string") {
+    return useFetch(input, augmentRequestInit(requestInit));
+  }
+  const requestParameters = createFetchRequestParameters(input);
+  const derivedRequestInit = augmentRequestInit(requestParameters);
+  return useFetch(input.url.href, derivedRequestInit);
 };
 
-EventEmitter.prototype.emit = function emit(type) {
-  var args = [];
-  for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
-  var doError = (type === 'error');
+// src/context/text.ts
+init_esm_shims();
+var text = (body2) => {
+  return (res) => {
+    res.headers.set("Content-Type", "text/plain");
+    res.body = body2;
+    return res;
+  };
+};
 
-  var events = this._events;
-  if (events !== undefined)
-    doError = (doError && events.error === undefined);
-  else if (!doError)
-    return false;
+// src/context/xml.ts
+init_esm_shims();
+var xml = (body2) => {
+  return (res) => {
+    res.headers.set("Content-Type", "text/xml");
+    res.body = body2;
+    return res;
+  };
+};
 
-  // If there is no 'error' event listener then throw.
-  if (doError) {
-    var er;
-    if (args.length > 0)
-      er = args[0];
-    if (er instanceof Error) {
-      // Note: The comments on the `throw` lines are intentional, they show
-      // up in Node's output if this results in an unhandled exception.
-      throw er; // Unhandled 'error' event
-    }
-    // At least give some kind of context to the user
-    var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));
-    err.context = er;
-    throw err; // Unhandled 'error' event
-  }
+// src/setupWorker/setupWorker.ts
+init_esm_shims();
+import { isNodeProcess as isNodeProcess3 } from "is-node-process";
+import { StrictEventEmitter } from "strict-event-emitter";
+
+// src/setupWorker/start/createStartHandler.ts
+init_esm_shims();
+import { until as until4 } from "@open-draft/until";
+
+// src/setupWorker/start/utils/getWorkerInstance.ts
+init_esm_shims();
+import { until } from "@open-draft/until";
+
+// src/setupWorker/start/utils/getWorkerByRegistration.ts
+init_esm_shims();
+var getWorkerByRegistration = (registration, absoluteWorkerUrl, findWorker) => {
+  const allStates = [
+    registration.active,
+    registration.installing,
+    registration.waiting
+  ];
+  const existingStates = allStates.filter(Boolean);
+  const mockWorker = existingStates.find((worker) => {
+    return findWorker(worker.scriptURL, absoluteWorkerUrl);
+  });
+  return mockWorker || null;
+};
 
-  var handler = events[type];
+// src/utils/url/getAbsoluteWorkerUrl.ts
+init_esm_shims();
+function getAbsoluteWorkerUrl(relativeUrl) {
+  return new URL(relativeUrl, location.origin).href;
+}
 
-  if (handler === undefined)
-    return false;
+// src/utils/internal/devUtils.ts
+init_esm_shims();
+var import_outvariant = __toESM(require_lib());
+var LIBRARY_PREFIX = "[MSW]";
+function formatMessage(message, ...positionals) {
+  const interpolatedMessage = (0, import_outvariant.format)(message, ...positionals);
+  return `${LIBRARY_PREFIX} ${interpolatedMessage}`;
+}
+function warn(message, ...positionals) {
+  console.warn(formatMessage(message, ...positionals));
+}
+function error(message, ...positionals) {
+  console.error(formatMessage(message, ...positionals));
+}
+var devUtils = {
+  formatMessage,
+  warn,
+  error
+};
 
-  if (typeof handler === 'function') {
-    ReflectApply(handler, this, args);
-  } else {
-    var len = handler.length;
-    var listeners = arrayClone(handler, len);
-    for (var i = 0; i < len; ++i)
-      ReflectApply(listeners[i], this, args);
+// src/setupWorker/start/utils/getWorkerInstance.ts
+var getWorkerInstance = async (url, options = {}, findWorker) => {
+  const absoluteWorkerUrl = getAbsoluteWorkerUrl(url);
+  const mockRegistrations = await navigator.serviceWorker.getRegistrations().then((registrations) => registrations.filter((registration) => getWorkerByRegistration(registration, absoluteWorkerUrl, findWorker)));
+  if (!navigator.serviceWorker.controller && mockRegistrations.length > 0) {
+    location.reload();
+  }
+  const [existingRegistration] = mockRegistrations;
+  if (existingRegistration) {
+    return existingRegistration.update().then(() => {
+      return [
+        getWorkerByRegistration(existingRegistration, absoluteWorkerUrl, findWorker),
+        existingRegistration
+      ];
+    });
   }
+  const [error2, instance] = await until(async () => {
+    const registration = await navigator.serviceWorker.register(url, options);
+    return [
+      getWorkerByRegistration(registration, absoluteWorkerUrl, findWorker),
+      registration
+    ];
+  });
+  if (error2) {
+    const isWorkerMissing = error2.message.includes("(404)");
+    if (isWorkerMissing) {
+      const scopeUrl = new URL((options == null ? void 0 : options.scope) || "/", location.href);
+      throw new Error(devUtils.formatMessage(`Failed to register a Service Worker for scope ('${scopeUrl.href}') with script ('${absoluteWorkerUrl}'): Service Worker script does not exist at the given path.
+
+Did you forget to run "npx msw init <PUBLIC_DIR>"?
 
-  return true;
+Learn more about creating the Service Worker script: https://mswjs.io/docs/cli/init`));
+    }
+    throw new Error(devUtils.formatMessage("Failed to register the Service Worker:\n\n%s", error2.message));
+  }
+  return instance;
 };
 
-function _addListener(target, type, listener, prepend) {
-  var m;
-  var events;
-  var existing;
+// src/setupWorker/start/utils/enableMocking.ts
+init_esm_shims();
 
-  checkListener(listener);
+// src/setupWorker/start/utils/printStartMessage.ts
+init_esm_shims();
+function printStartMessage(args = {}) {
+  if (args.quiet) {
+    return;
+  }
+  const message = args.message || "Mocking enabled.";
+  console.groupCollapsed(`%c${devUtils.formatMessage(message)}`, "color:orangered;font-weight:bold;");
+  console.log("%cDocumentation: %chttps://mswjs.io/docs", "font-weight:bold", "font-weight:normal");
+  console.log("Found an issue? https://github.com/mswjs/msw/issues");
+  if (args.workerUrl) {
+    console.log("Worker script URL:", args.workerUrl);
+  }
+  if (args.workerScope) {
+    console.log("Worker scope:", args.workerScope);
+  }
+  console.groupEnd();
+}
 
-  events = target._events;
-  if (events === undefined) {
-    events = target._events = Object.create(null);
-    target._eventsCount = 0;
-  } else {
-    // To avoid recursion in the case that type === "newListener"! Before
-    // adding it to the listeners, first emit "newListener".
-    if (events.newListener !== undefined) {
-      target.emit('newListener', type,
-                  listener.listener ? listener.listener : listener);
-
-      // Re-assign `events` because a newListener handler could have caused the
-      // this._events to be assigned to a new object
-      events = target._events;
-    }
-    existing = events[type];
+// src/setupWorker/start/utils/enableMocking.ts
+async function enableMocking(context, options) {
+  var _a, _b;
+  context.workerChannel.send("MOCK_ACTIVATE");
+  await context.events.once("MOCKING_ENABLED");
+  if (context.isMockingEnabled) {
+    devUtils.warn(`Found a redundant "worker.start()" call. Note that starting the worker while mocking is already enabled will have no effect. Consider removing this "worker.start()" call.`);
+    return;
   }
+  context.isMockingEnabled = true;
+  printStartMessage({
+    quiet: options.quiet,
+    workerScope: (_a = context.registration) == null ? void 0 : _a.scope,
+    workerUrl: (_b = context.worker) == null ? void 0 : _b.scriptURL
+  });
+}
 
-  if (existing === undefined) {
-    // Optimize the case of one listener. Don't need the extra array object.
-    existing = events[type] = listener;
-    ++target._eventsCount;
-  } else {
-    if (typeof existing === 'function') {
-      // Adding the second element, need to change to array.
-      existing = events[type] =
-        prepend ? [listener, existing] : [existing, listener];
-      // If we've already got an array, just append.
-    } else if (prepend) {
-      existing.unshift(listener);
-    } else {
-      existing.push(listener);
+// src/utils/worker/createRequestListener.ts
+init_esm_shims();
+
+// src/utils/createBroadcastChannel.ts
+init_esm_shims();
+var createBroadcastChannel = (event) => {
+  const port = event.ports[0];
+  return {
+    send(message) {
+      if (port) {
+        port.postMessage(message);
+      }
     }
+  };
+};
 
-    // Check for listener leak
-    m = _getMaxListeners(target);
-    if (m > 0 && existing.length > m && !existing.warned) {
-      existing.warned = true;
-      // No error code for this since it is a Warning
-      // eslint-disable-next-line no-restricted-syntax
-      var w = new Error('Possible EventEmitter memory leak detected. ' +
-                          existing.length + ' ' + String(type) + ' listeners ' +
-                          'added. Use emitter.setMaxListeners() to ' +
-                          'increase limit');
-      w.name = 'MaxListenersExceededWarning';
-      w.emitter = target;
-      w.type = type;
-      w.count = existing.length;
-      ProcessEmitWarning(w);
-    }
+// src/utils/NetworkError.ts
+init_esm_shims();
+var NetworkError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "NetworkError";
   }
+};
 
-  return target;
+// src/utils/request/parseWorkerRequest.ts
+init_esm_shims();
+import { Headers as Headers4 } from "headers-polyfill";
+
+// src/handlers/RequestHandler.ts
+init_esm_shims();
+import { Headers as Headers3 } from "headers-polyfill";
+
+// src/response.ts
+init_esm_shims();
+import { Headers as Headers2 } from "headers-polyfill";
+
+// src/utils/internal/compose.ts
+init_esm_shims();
+function compose(...fns) {
+  return (...args) => {
+    return fns.reduceRight((leftFn, rightFn) => {
+      return leftFn instanceof Promise ? Promise.resolve(leftFn).then(rightFn) : rightFn(leftFn);
+    }, args[0]);
+  };
 }
 
-EventEmitter.prototype.addListener = function addListener(type, listener) {
-  return _addListener(this, type, listener, false);
+// src/response.ts
+var defaultResponse = {
+  status: 200,
+  statusText: "OK",
+  body: null,
+  delay: 0,
+  once: false,
+  passthrough: false
 };
+var defaultResponseTransformers = [];
+function createResponseComposition(responseOverrides, defaultTransformers = defaultResponseTransformers) {
+  return async (...transformers) => {
+    const initialResponse = Object.assign({}, defaultResponse, {
+      headers: new Headers2({
+        "x-powered-by": "msw"
+      })
+    }, responseOverrides);
+    const resolvedTransformers = [
+      ...defaultTransformers,
+      ...transformers
+    ].filter(Boolean);
+    const resolvedResponse = resolvedTransformers.length > 0 ? compose(...resolvedTransformers)(initialResponse) : initialResponse;
+    return resolvedResponse;
+  };
+}
+var response = Object.assign(createResponseComposition(), {
+  once: createResponseComposition({ once: true }),
+  networkError(message) {
+    throw new NetworkError(message);
+  }
+});
 
-EventEmitter.prototype.on = EventEmitter.prototype.addListener;
-
-EventEmitter.prototype.prependListener =
-    function prependListener(type, listener) {
-      return _addListener(this, type, listener, true);
-    };
-
-function onceWrapper() {
-  if (!this.fired) {
-    this.target.removeListener(this.type, this.wrapFn);
-    this.fired = true;
-    if (arguments.length === 0)
-      return this.listener.call(this.target);
-    return this.listener.apply(this.target, arguments);
+// src/utils/internal/getCallFrame.ts
+init_esm_shims();
+var SOURCE_FRAME = /\/msw\/src\/(.+)/;
+var BUILD_FRAME = /(node_modules)?[\/\\]lib[\/\\](umd|esm|iief|cjs)[\/\\]|^[^\/\\]*$/;
+function getCallFrame(error2) {
+  const stack = error2.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;
 }
 
-function _onceWrap(target, type, listener) {
-  var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };
-  var wrapped = onceWrapper.bind(state);
-  wrapped.listener = listener;
-  state.wrapFn = wrapped;
-  return wrapped;
+// src/utils/internal/isIterable.ts
+init_esm_shims();
+function isIterable(fn) {
+  if (!fn) {
+    return false;
+  }
+  return typeof fn[Symbol.iterator] == "function";
 }
 
-EventEmitter.prototype.once = function once(type, listener) {
-  checkListener(listener);
-  this.on(type, _onceWrap(this, type, listener));
-  return this;
+// src/handlers/RequestHandler.ts
+var defaultContext = {
+  status,
+  set,
+  delay,
+  fetch
 };
-
-EventEmitter.prototype.prependOnceListener =
-    function prependOnceListener(type, listener) {
-      checkListener(listener);
-      this.prependListener(type, _onceWrap(this, type, listener));
-      return this;
+var RequestHandler = class {
+  constructor(options) {
+    this.shouldSkip = false;
+    this.ctx = options.ctx || defaultContext;
+    this.resolver = options.resolver;
+    const callFrame = getCallFrame(new Error());
+    this.info = __spreadProps(__spreadValues({}, options.info), {
+      callFrame
+    });
+  }
+  parse(_request, _resolutionContext) {
+    return null;
+  }
+  test(request, resolutionContext) {
+    return this.predicate(request, this.parse(request, resolutionContext), resolutionContext);
+  }
+  getPublicRequest(request, _parsedResult) {
+    return request;
+  }
+  markAsSkipped(shouldSkip = true) {
+    this.shouldSkip = shouldSkip;
+  }
+  async run(request, resolutionContext) {
+    if (this.shouldSkip) {
+      return null;
+    }
+    const parsedResult = this.parse(request, resolutionContext);
+    const shouldIntercept = this.predicate(request, parsedResult, resolutionContext);
+    if (!shouldIntercept) {
+      return null;
+    }
+    const publicRequest = this.getPublicRequest(request, parsedResult);
+    const executeResolver = this.wrapResolver(this.resolver);
+    const mockedResponse = await executeResolver(publicRequest, response, this.ctx);
+    return this.createExecutionResult(parsedResult, publicRequest, mockedResponse);
+  }
+  wrapResolver(resolver) {
+    return async (req, res, ctx) => {
+      const result = this.resolverGenerator || await resolver(req, res, ctx);
+      if (isIterable(result)) {
+        const { value, done } = result[Symbol.iterator]().next();
+        const nextResponse = await value;
+        if (!nextResponse && done) {
+          return this.resolverGeneratorResult;
+        }
+        if (!this.resolverGenerator) {
+          this.resolverGenerator = result;
+        }
+        this.resolverGeneratorResult = nextResponse;
+        return nextResponse;
+      }
+      return result;
     };
+  }
+  createExecutionResult(parsedResult, request, response2) {
+    return {
+      handler: this,
+      parsedResult: parsedResult || null,
+      request,
+      response: response2 || null
+    };
+  }
+};
+function passthrough() {
+  return {
+    status: 101,
+    statusText: "Continue",
+    headers: new Headers3(),
+    body: null,
+    passthrough: true,
+    once: false
+  };
+}
 
-// Emits a 'removeListener' event if and only if the listener was removed.
-EventEmitter.prototype.removeListener =
-    function removeListener(type, listener) {
-      var list, events, position, i, originalListener;
+// src/utils/request/setRequestCookies.ts
+init_esm_shims();
+import * as cookieUtils3 from "cookie";
+import { store } from "@mswjs/cookies";
 
-      checkListener(listener);
+// src/utils/request/getRequestCookies.ts
+init_esm_shims();
+import * as cookieUtils2 from "cookie";
+function getAllCookies() {
+  return cookieUtils2.parse(document.cookie);
+}
+function getRequestCookies(request) {
+  if (typeof document === "undefined" || typeof location === "undefined") {
+    return {};
+  }
+  switch (request.credentials) {
+    case "same-origin": {
+      return location.origin === request.url.origin ? getAllCookies() : {};
+    }
+    case "include": {
+      return getAllCookies();
+    }
+    default: {
+      return {};
+    }
+  }
+}
 
-      events = this._events;
-      if (events === undefined)
-        return this;
+// src/utils/request/setRequestCookies.ts
+function setRequestCookies(request) {
+  var _a;
+  const requestCookiesString = request.headers.get("cookie");
+  store.hydrate();
+  const cookiesFromStore = Array.from((_a = store.get(__spreadProps(__spreadValues({}, request), { url: request.url.toString() }))) == null ? void 0 : _a.entries()).reduce((cookies, [name, { value }]) => {
+    return Object.assign(cookies, { [name.trim()]: value });
+  }, {});
+  const cookiesFromDocument = getRequestCookies(request);
+  const forwardedCookies = __spreadValues(__spreadValues({}, cookiesFromDocument), cookiesFromStore);
+  for (const [name, value] of Object.entries(forwardedCookies)) {
+    request.headers.append("cookie", `${name}=${value}`);
+  }
+  const ownCookies = requestCookiesString ? cookieUtils3.parse(requestCookiesString) : {};
+  request.cookies = __spreadValues(__spreadValues(__spreadValues({}, request.cookies), forwardedCookies), ownCookies);
+}
 
-      list = events[type];
-      if (list === undefined)
-        return this;
+// src/utils/request/parseBody.ts
+init_esm_shims();
+
+// src/utils/internal/parseMultipartData.ts
+init_esm_shims();
+import { stringToHeaders } from "headers-polyfill";
+function parseContentHeaders(headersString) {
+  var _a, _b;
+  const headers = stringToHeaders(headersString);
+  const contentType = headers.get("content-type") || "text/plain";
+  const disposition = headers.get("content-disposition");
+  if (!disposition) {
+    throw new Error('"Content-Disposition" header is required.');
+  }
+  const directives = disposition.split(";").reduce((acc, chunk) => {
+    const [name2, ...rest2] = chunk.trim().split("=");
+    acc[name2] = rest2.join("=");
+    return acc;
+  }, {});
+  const name = (_a = directives.name) == null ? void 0 : _a.slice(1, -1);
+  const filename = (_b = directives.filename) == null ? void 0 : _b.slice(1, -1);
+  return {
+    name,
+    filename,
+    contentType
+  };
+}
+function parseMultipartData(data2, headers) {
+  const contentType = headers == null ? void 0 : headers.get("content-type");
+  if (!contentType) {
+    return void 0;
+  }
+  const [, ...directives] = contentType.split(/; */);
+  const boundary = directives.filter((d) => d.startsWith("boundary=")).map((s) => s.replace(/^boundary=/, ""))[0];
+  if (!boundary) {
+    return void 0;
+  }
+  const boundaryRegExp = new RegExp(`--+${boundary}`);
+  const fields = data2.split(boundaryRegExp).filter((chunk) => chunk.startsWith("\r\n") && chunk.endsWith("\r\n")).map((chunk) => chunk.trimStart().replace(/\r\n$/, ""));
+  if (!fields.length) {
+    return void 0;
+  }
+  const parsedBody = {};
+  try {
+    for (const field of fields) {
+      const [contentHeaders, ...rest2] = field.split("\r\n\r\n");
+      const contentBody = rest2.join("\r\n\r\n");
+      const { contentType: contentType2, filename, name } = parseContentHeaders(contentHeaders);
+      const value = filename === void 0 ? contentBody : new File([contentBody], filename, { type: contentType2 });
+      const parsedValue = parsedBody[name];
+      if (parsedValue === void 0) {
+        parsedBody[name] = value;
+      } else if (Array.isArray(parsedValue)) {
+        parsedBody[name] = [...parsedValue, value];
+      } else {
+        parsedBody[name] = [parsedValue, value];
+      }
+    }
+    return parsedBody;
+  } catch (error2) {
+    return void 0;
+  }
+}
 
-      if (list === listener || list.listener === listener) {
-        if (--this._eventsCount === 0)
-          this._events = Object.create(null);
-        else {
-          delete events[type];
-          if (events.removeListener)
-            this.emit('removeListener', type, list.listener || listener);
-        }
-      } else if (typeof list !== 'function') {
-        position = -1;
-
-        for (i = list.length - 1; i >= 0; i--) {
-          if (list[i] === listener || list[i].listener === listener) {
-            originalListener = list[i].listener;
-            position = i;
-            break;
-          }
-        }
+// src/utils/request/parseBody.ts
+function parseBody(body2, headers) {
+  var _a;
+  if (!body2) {
+    return body2;
+  }
+  const contentType = ((_a = headers == null ? void 0 : headers.get("content-type")) == null ? void 0 : _a.toLowerCase()) || "";
+  const hasMultipartContent = contentType.startsWith("multipart/form-data");
+  if (hasMultipartContent && typeof body2 !== "object") {
+    return parseMultipartData(body2.toString(), headers) || body2;
+  }
+  const hasJsonContent = contentType.includes("json");
+  if (hasJsonContent && typeof body2 !== "object") {
+    return jsonParse(body2.toString()) || body2;
+  }
+  return body2;
+}
 
-        if (position < 0)
-          return this;
+// src/utils/request/pruneGetRequestBody.ts
+init_esm_shims();
 
-        if (position === 0)
-          list.shift();
-        else {
-          spliceOne(list, position);
-        }
+// src/utils/internal/isStringEqual.ts
+init_esm_shims();
+function isStringEqual(actual, expected) {
+  return actual.toLowerCase() === expected.toLowerCase();
+}
 
-        if (list.length === 1)
-          events[type] = list[0];
+// src/utils/request/pruneGetRequestBody.ts
+function pruneGetRequestBody(request) {
+  if (request.method && isStringEqual(request.method, "GET") && request.body === "") {
+    return void 0;
+  }
+  return request.body;
+}
 
-        if (events.removeListener !== undefined)
-          this.emit('removeListener', type, originalListener || listener);
-      }
+// src/utils/request/parseWorkerRequest.ts
+function parseWorkerRequest(rawRequest) {
+  const request = {
+    id: rawRequest.id,
+    cache: rawRequest.cache,
+    credentials: rawRequest.credentials,
+    method: rawRequest.method,
+    url: new URL(rawRequest.url),
+    referrer: rawRequest.referrer,
+    referrerPolicy: rawRequest.referrerPolicy,
+    redirect: rawRequest.redirect,
+    mode: rawRequest.mode,
+    params: {},
+    cookies: {},
+    integrity: rawRequest.integrity,
+    keepalive: rawRequest.keepalive,
+    destination: rawRequest.destination,
+    body: pruneGetRequestBody(rawRequest),
+    bodyUsed: rawRequest.bodyUsed,
+    headers: new Headers4(rawRequest.headers),
+    passthrough
+  };
+  setRequestCookies(request);
+  request.body = parseBody(request.body, request.headers);
+  return request;
+}
 
-      return this;
+// src/utils/handleRequest.ts
+init_esm_shims();
+import { until as until2 } from "@open-draft/until";
+
+// src/utils/getResponse.ts
+init_esm_shims();
+var getResponse = async (request, handlers, resolutionContext) => {
+  const relevantHandlers = handlers.filter((handler) => {
+    return handler.test(request, resolutionContext);
+  });
+  if (relevantHandlers.length === 0) {
+    return {
+      handler: void 0,
+      response: void 0
+    };
+  }
+  const result = await relevantHandlers.reduce(async (executionResult, handler) => {
+    const previousResults = await executionResult;
+    if (!!(previousResults == null ? void 0 : previousResults.response)) {
+      return executionResult;
+    }
+    const result2 = await handler.run(request, resolutionContext);
+    if (result2 === null || result2.handler.shouldSkip) {
+      return null;
+    }
+    if (!result2.response) {
+      return {
+        request: result2.request,
+        handler: result2.handler,
+        response: void 0,
+        parsedResult: result2.parsedResult
+      };
+    }
+    if (result2.response.once) {
+      handler.markAsSkipped(true);
+    }
+    return result2;
+  }, Promise.resolve(null));
+  if (!result) {
+    return {
+      handler: void 0,
+      response: void 0
     };
+  }
+  return {
+    handler: result.handler,
+    publicRequest: result.request,
+    parsedRequest: result.parsedResult,
+    response: result.response
+  };
+};
+
+// src/utils/request/onUnhandledRequest.ts
+init_esm_shims();
+import getStringMatchScore from "js-levenshtein";
+
+// src/utils/internal/parseGraphQLRequest.ts
+init_esm_shims();
+import {
+  parse as parse3
+} from "graphql";
+
+// src/utils/request/getPublicUrlFromRequest.ts
+init_esm_shims();
+var getPublicUrlFromRequest = (request) => {
+  return request.referrer.startsWith(request.url.origin) ? request.url.pathname : new URL(request.url.pathname, `${request.url.protocol}//${request.url.host}`).href;
+};
 
-EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
-
-EventEmitter.prototype.removeAllListeners =
-    function removeAllListeners(type) {
-      var listeners, events, i;
-
-      events = this._events;
-      if (events === undefined)
-        return this;
-
-      // not listening for removeListener, no need to emit
-      if (events.removeListener === undefined) {
-        if (arguments.length === 0) {
-          this._events = Object.create(null);
-          this._eventsCount = 0;
-        } else if (events[type] !== undefined) {
-          if (--this._eventsCount === 0)
-            this._events = Object.create(null);
-          else
-            delete events[type];
+// src/utils/internal/parseGraphQLRequest.ts
+function parseDocumentNode(node) {
+  var _a;
+  const operationDef = node.definitions.find((def) => {
+    return def.kind === "OperationDefinition";
+  });
+  return {
+    operationType: operationDef == null ? void 0 : operationDef.operation,
+    operationName: (_a = operationDef == null ? void 0 : operationDef.name) == null ? void 0 : _a.value
+  };
+}
+function parseQuery(query) {
+  try {
+    const ast = parse3(query);
+    return parseDocumentNode(ast);
+  } catch (error2) {
+    return error2;
+  }
+}
+function extractMultipartVariables(variables, map, files) {
+  const operations = { variables };
+  for (const [key, pathArray] of Object.entries(map)) {
+    if (!(key in files)) {
+      throw new Error(`Given files do not have a key '${key}' .`);
+    }
+    for (const dotPath of pathArray) {
+      const [lastPath, ...reversedPaths] = dotPath.split(".").reverse();
+      const paths = reversedPaths.reverse();
+      let target = operations;
+      for (const path of paths) {
+        if (!(path in target)) {
+          throw new Error(`Property '${paths}' is not in operations.`);
         }
-        return this;
+        target = target[path];
       }
-
-      // emit removeListener for all listeners on all events
-      if (arguments.length === 0) {
-        var keys = Object.keys(events);
-        var key;
-        for (i = 0; i < keys.length; ++i) {
-          key = keys[i];
-          if (key === 'removeListener') continue;
-          this.removeAllListeners(key);
+      target[lastPath] = files[key];
+    }
+  }
+  return operations.variables;
+}
+function getGraphQLInput(request) {
+  var _a, _b;
+  switch (request.method) {
+    case "GET": {
+      const query = request.url.searchParams.get("query");
+      const variables = request.url.searchParams.get("variables") || "";
+      return {
+        query,
+        variables: jsonParse(variables)
+      };
+    }
+    case "POST": {
+      if ((_a = request.body) == null ? void 0 : _a.query) {
+        const { query, variables } = request.body;
+        return {
+          query,
+          variables
+        };
+      }
+      if ((_b = request.body) == null ? void 0 : _b.operations) {
+        const _c = request.body, { operations, map } = _c, files = __objRest(_c, ["operations", "map"]);
+        const parsedOperations = jsonParse(operations) || {};
+        if (!parsedOperations.query) {
+          return null;
         }
-        this.removeAllListeners('removeListener');
-        this._events = Object.create(null);
-        this._eventsCount = 0;
-        return this;
+        const parsedMap = jsonParse(map || "") || {};
+        const variables = parsedOperations.variables ? extractMultipartVariables(parsedOperations.variables, parsedMap, files) : {};
+        return {
+          query: parsedOperations.query,
+          variables
+        };
       }
+    }
+    default:
+      return null;
+  }
+}
+function parseGraphQLRequest(request) {
+  const input = getGraphQLInput(request);
+  if (!input || !input.query) {
+    return void 0;
+  }
+  const { query, variables } = input;
+  const parsedResult = parseQuery(query);
+  if (parsedResult instanceof Error) {
+    const requestPublicUrl = getPublicUrlFromRequest(request);
+    throw new Error(devUtils.formatMessage('Failed to intercept a GraphQL request to "%s %s": cannot parse query. See the error message from the parser below.\n\n%s', request.method, requestPublicUrl, parsedResult.message));
+  }
+  return {
+    operationType: parsedResult.operationType,
+    operationName: parsedResult.operationName,
+    variables
+  };
+}
 
-      listeners = events[type];
+// src/handlers/RestHandler.ts
+init_esm_shims();
 
-      if (typeof listeners === 'function') {
-        this.removeListener(type, listeners);
-      } else if (listeners !== undefined) {
-        // LIFO order
-        for (i = listeners.length - 1; i >= 0; i--) {
-          this.removeListener(type, listeners[i]);
-        }
-      }
+// src/utils/logging/getStatusCodeColor.ts
+init_esm_shims();
+function getStatusCodeColor(status2) {
+  if (status2 < 300) {
+    return "#69AB32" /* Success */;
+  }
+  if (status2 < 400) {
+    return "#F0BB4B" /* Warning */;
+  }
+  return "#E95F5D" /* Danger */;
+}
 
-      return this;
-    };
+// src/utils/logging/getTimestamp.ts
+init_esm_shims();
+function getTimestamp() {
+  const now = new Date();
+  return [now.getHours(), now.getMinutes(), now.getSeconds()].map(String).map((chunk) => chunk.slice(0, 2)).map((chunk) => chunk.padStart(2, "0")).join(":");
+}
 
-function _listeners(target, type, unwrap) {
-  var events = target._events;
+// src/utils/logging/prepareRequest.ts
+init_esm_shims();
+function prepareRequest(request) {
+  return __spreadProps(__spreadValues({}, request), {
+    headers: request.headers.all()
+  });
+}
 
-  if (events === undefined)
-    return [];
+// src/utils/logging/prepareResponse.ts
+init_esm_shims();
+import { objectToHeaders as objectToHeaders2 } from "headers-polyfill";
+function prepareResponse(res) {
+  const responseHeaders = objectToHeaders2(res.headers);
+  return __spreadProps(__spreadValues({}, res), {
+    body: parseBody(res.body, responseHeaders)
+  });
+}
 
-  var evlistener = events[type];
-  if (evlistener === undefined)
-    return [];
+// src/utils/matching/matchRequestUrl.ts
+init_esm_shims();
+import { match } from "path-to-regexp";
+import { getCleanUrl } from "@mswjs/interceptors/lib/utils/getCleanUrl";
 
-  if (typeof evlistener === 'function')
-    return unwrap ? [evlistener.listener || evlistener] : [evlistener];
+// src/utils/matching/normalizePath.ts
+init_esm_shims();
 
-  return unwrap ?
-    unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
+// src/utils/url/cleanUrl.ts
+init_esm_shims();
+var REDUNDANT_CHARACTERS_EXP = /[\?|#].*$/g;
+function getSearchParams(path) {
+  return new URL(`/${path}`, "http://localhost").searchParams;
+}
+function cleanUrl(path) {
+  return path.replace(REDUNDANT_CHARACTERS_EXP, "");
 }
 
-EventEmitter.prototype.listeners = function listeners(type) {
-  return _listeners(this, type, true);
-};
+// src/utils/url/getAbsoluteUrl.ts
+init_esm_shims();
 
-EventEmitter.prototype.rawListeners = function rawListeners(type) {
-  return _listeners(this, type, false);
-};
+// src/utils/url/isAbsoluteUrl.ts
+init_esm_shims();
+function isAbsoluteUrl(url) {
+  return /^([a-z][a-z\d\+\-\.]*:)?\/\//i.test(url);
+}
 
-EventEmitter.listenerCount = function(emitter, type) {
-  if (typeof emitter.listenerCount === 'function') {
-    return emitter.listenerCount(type);
-  } else {
-    return listenerCount.call(emitter, type);
+// src/utils/url/getAbsoluteUrl.ts
+function getAbsoluteUrl(path, baseUrl) {
+  if (isAbsoluteUrl(path)) {
+    return path;
   }
-};
-
-EventEmitter.prototype.listenerCount = listenerCount;
-function listenerCount(type) {
-  var events = this._events;
-
-  if (events !== undefined) {
-    var evlistener = events[type];
+  if (path.startsWith("*")) {
+    return path;
+  }
+  const origin = baseUrl || typeof document !== "undefined" && document.baseURI;
+  return origin ? decodeURI(new URL(encodeURI(path), origin).href) : path;
+}
 
-    if (typeof evlistener === 'function') {
-      return 1;
-    } else if (evlistener !== undefined) {
-      return evlistener.length;
-    }
+// src/utils/matching/normalizePath.ts
+function normalizePath(path, baseUrl) {
+  if (path instanceof RegExp) {
+    return path;
   }
+  const maybeAbsoluteUrl = getAbsoluteUrl(path, baseUrl);
+  return cleanUrl(maybeAbsoluteUrl);
+}
 
-  return 0;
+// src/utils/matching/matchRequestUrl.ts
+function coercePath(path) {
+  return path.replace(/([:a-zA-Z_-]*)(\*{1,2})+/g, (_, parameterName, wildcard) => {
+    const expression = "(.*)";
+    if (!parameterName) {
+      return expression;
+    }
+    return parameterName.startsWith(":") ? `${parameterName}${wildcard}` : `${parameterName}${expression}`;
+  }).replace(/([^\/])(:)(?=\d+)/, "$1\\$2").replace(/^([^\/]+)(:)(?=\/\/)/, "$1\\$2");
+}
+function matchRequestUrl(url, path, baseUrl) {
+  const normalizedPath = normalizePath(path, baseUrl);
+  const cleanPath = typeof normalizedPath === "string" ? coercePath(normalizedPath) : normalizedPath;
+  const cleanUrl2 = getCleanUrl(url);
+  const result = match(cleanPath, { decode: decodeURIComponent })(cleanUrl2);
+  const params = result && result.params || {};
+  return {
+    matches: result !== false,
+    params
+  };
 }
 
-EventEmitter.prototype.eventNames = function eventNames() {
-  return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
+// src/handlers/RestHandler.ts
+var RESTMethods = /* @__PURE__ */ ((RESTMethods2) => {
+  RESTMethods2["HEAD"] = "HEAD";
+  RESTMethods2["GET"] = "GET";
+  RESTMethods2["POST"] = "POST";
+  RESTMethods2["PUT"] = "PUT";
+  RESTMethods2["PATCH"] = "PATCH";
+  RESTMethods2["OPTIONS"] = "OPTIONS";
+  RESTMethods2["DELETE"] = "DELETE";
+  return RESTMethods2;
+})(RESTMethods || {});
+var restContext = __spreadProps(__spreadValues({}, defaultContext), {
+  cookie,
+  body,
+  text,
+  json,
+  xml
+});
+var RestHandler = class extends RequestHandler {
+  constructor(method, path, resolver) {
+    super({
+      info: {
+        header: `${method} ${path}`,
+        path,
+        method
+      },
+      ctx: restContext,
+      resolver
+    });
+    this.checkRedundantQueryParameters();
+  }
+  checkRedundantQueryParameters() {
+    const { method, path } = this.info;
+    if (path instanceof RegExp) {
+      return;
+    }
+    const url = cleanUrl(path);
+    if (url === path) {
+      return;
+    }
+    const searchParams = getSearchParams(path);
+    const queryParams = [];
+    searchParams.forEach((_, paramName) => {
+      queryParams.push(paramName);
+    });
+    devUtils.warn(`Found a redundant usage of query parameters in the request handler URL for "${method} ${path}". Please match against a path instead and access query parameters in the response resolver function using "req.url.searchParams".`);
+  }
+  parse(request, resolutionContext) {
+    return matchRequestUrl(request.url, this.info.path, resolutionContext == null ? void 0 : resolutionContext.baseUrl);
+  }
+  getPublicRequest(request, parsedResult) {
+    return __spreadProps(__spreadValues({}, request), {
+      params: parsedResult.params || {}
+    });
+  }
+  predicate(request, parsedResult) {
+    const matchesMethod = this.info.method instanceof RegExp ? this.info.method.test(request.method) : isStringEqual(this.info.method, request.method);
+    return matchesMethod && parsedResult.matches;
+  }
+  log(request, response2) {
+    const publicUrl = getPublicUrlFromRequest(request);
+    const loggedRequest = prepareRequest(request);
+    const loggedResponse = prepareResponse(response2);
+    const statusColor = getStatusCodeColor(response2.status);
+    console.groupCollapsed(devUtils.formatMessage("%s %s %s (%c%s%c)"), getTimestamp(), request.method, publicUrl, `color:${statusColor}`, `${response2.status} ${response2.statusText}`, "color:inherit");
+    console.log("Request", loggedRequest);
+    console.log("Handler:", {
+      mask: this.info.path,
+      resolver: this.resolver
+    });
+    console.log("Response", loggedResponse);
+    console.groupEnd();
+  }
 };
 
-function arrayClone(arr, n) {
-  var copy = new Array(n);
-  for (var i = 0; i < n; ++i)
-    copy[i] = arr[i];
-  return copy;
-}
-
-function spliceOne(list, index) {
-  for (; index + 1 < list.length; index++)
-    list[index] = list[index + 1];
-  list.pop();
+// src/handlers/GraphQLHandler.ts
+init_esm_shims();
+
+// src/utils/internal/tryCatch.ts
+init_esm_shims();
+function tryCatch(fn, onException) {
+  try {
+    const result = fn();
+    return result;
+  } catch (error2) {
+    onException == null ? void 0 : onException(error2);
+  }
 }
 
-function unwrapListeners(arr) {
-  var ret = new Array(arr.length);
-  for (var i = 0; i < ret.length; ++i) {
-    ret[i] = arr[i].listener || arr[i];
+// src/handlers/GraphQLHandler.ts
+var graphqlContext = __spreadProps(__spreadValues({}, defaultContext), {
+  data,
+  extensions,
+  errors,
+  cookie
+});
+function isDocumentNode(value) {
+  if (value == null) {
+    return false;
   }
-  return ret;
+  return typeof value === "object" && "kind" in value && "definitions" in value;
 }
+var GraphQLHandler = class extends RequestHandler {
+  constructor(operationType, operationName, endpoint, resolver) {
+    let resolvedOperationName = operationName;
+    if (isDocumentNode(operationName)) {
+      const parsedNode = parseDocumentNode(operationName);
+      if (parsedNode.operationType !== operationType) {
+        throw new Error(`Failed to create a GraphQL handler: provided a DocumentNode with a mismatched operation type (expected "${operationType}", but got "${parsedNode.operationType}").`);
+      }
+      if (!parsedNode.operationName) {
+        throw new Error(`Failed to create a GraphQL handler: provided a DocumentNode with no operation name.`);
+      }
+      resolvedOperationName = parsedNode.operationName;
+    }
+    const header = operationType === "all" ? `${operationType} (origin: ${endpoint.toString()})` : `${operationType} ${resolvedOperationName} (origin: ${endpoint.toString()})`;
+    super({
+      info: {
+        header,
+        operationType,
+        operationName: resolvedOperationName
+      },
+      ctx: graphqlContext,
+      resolver
+    });
+    this.endpoint = endpoint;
+  }
+  parse(request) {
+    return tryCatch(() => parseGraphQLRequest(request), (error2) => console.error(error2.message));
+  }
+  getPublicRequest(request, parsedResult) {
+    return __spreadProps(__spreadValues({}, request), {
+      variables: (parsedResult == null ? void 0 : parsedResult.variables) || {}
+    });
+  }
+  predicate(request, parsedResult) {
+    if (!parsedResult) {
+      return false;
+    }
+    if (!parsedResult.operationName && this.info.operationType !== "all") {
+      const publicUrl = getPublicUrlFromRequest(request);
+      devUtils.warn(`Failed to intercept a GraphQL request at "${request.method} ${publicUrl}": anonymous GraphQL operations are not supported.
 
-function once(emitter, name) {
-  return new Promise(function (resolve, reject) {
-    function errorListener(err) {
-      emitter.removeListener(name, resolver);
-      reject(err);
+Consider naming this operation or using "graphql.operation" request handler to intercept GraphQL requests regardless of their operation name/type. Read more: https://mswjs.io/docs/api/graphql/operation      `);
+      return false;
     }
+    const hasMatchingUrl = matchRequestUrl(request.url, this.endpoint);
+    const hasMatchingOperationType = this.info.operationType === "all" || parsedResult.operationType === this.info.operationType;
+    const hasMatchingOperationName = this.info.operationName instanceof RegExp ? this.info.operationName.test(parsedResult.operationName || "") : parsedResult.operationName === this.info.operationName;
+    return hasMatchingUrl.matches && hasMatchingOperationType && hasMatchingOperationName;
+  }
+  log(request, response2, handler, parsedRequest) {
+    const loggedRequest = prepareRequest(request);
+    const loggedResponse = prepareResponse(response2);
+    const statusColor = getStatusCodeColor(response2.status);
+    const requestInfo = (parsedRequest == null ? void 0 : parsedRequest.operationName) ? `${parsedRequest == null ? void 0 : parsedRequest.operationType} ${parsedRequest == null ? void 0 : parsedRequest.operationName}` : `anonymous ${parsedRequest == null ? void 0 : parsedRequest.operationType}`;
+    console.groupCollapsed(devUtils.formatMessage("%s %s (%c%s%c)"), getTimestamp(), `${requestInfo}`, `color:${statusColor}`, `${response2.status} ${response2.statusText}`, "color:inherit");
+    console.log("Request:", loggedRequest);
+    console.log("Handler:", this);
+    console.log("Response:", loggedResponse);
+    console.groupEnd();
+  }
+};
 
-    function resolver() {
-      if (typeof emitter.removeListener === 'function') {
-        emitter.removeListener('error', errorListener);
-      }
-      resolve([].slice.call(arguments));
+// src/utils/request/onUnhandledRequest.ts
+var MAX_MATCH_SCORE = 3;
+var MAX_SUGGESTION_COUNT = 4;
+var TYPE_MATCH_DELTA = 0.5;
+function groupHandlersByType(handlers) {
+  return handlers.reduce((groups, handler) => {
+    if (handler instanceof RestHandler) {
+      groups.rest.push(handler);
     }
-    eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
-    if (name !== 'error') {
-      addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
+    if (handler instanceof GraphQLHandler) {
+      groups.graphql.push(handler);
     }
+    return groups;
+  }, {
+    rest: [],
+    graphql: []
   });
 }
+function getRestHandlerScore() {
+  return (request, handler) => {
+    const { path, method } = handler.info;
+    if (path instanceof RegExp || method instanceof RegExp) {
+      return Infinity;
+    }
+    const hasSameMethod = isStringEqual(request.method, method);
+    const methodScoreDelta = hasSameMethod ? TYPE_MATCH_DELTA : 0;
+    const requestPublicUrl = getPublicUrlFromRequest(request);
+    const score = getStringMatchScore(requestPublicUrl, path);
+    return score - methodScoreDelta;
+  };
+}
+function getGraphQLHandlerScore(parsedQuery) {
+  return (_, handler) => {
+    if (typeof parsedQuery.operationName === "undefined") {
+      return Infinity;
+    }
+    const { operationType, operationName } = handler.info;
+    if (typeof operationName !== "string") {
+      return Infinity;
+    }
+    const hasSameOperationType = parsedQuery.operationType === operationType;
+    const operationTypeScoreDelta = hasSameOperationType ? TYPE_MATCH_DELTA : 0;
+    const score = getStringMatchScore(parsedQuery.operationName, operationName);
+    return score - operationTypeScoreDelta;
+  };
+}
+function getSuggestedHandler(request, handlers, getScore) {
+  const suggestedHandlers = handlers.reduce((suggestions, handler) => {
+    const score = getScore(request, handler);
+    return suggestions.concat([[score, handler]]);
+  }, []).sort(([leftScore], [rightScore]) => leftScore - rightScore).filter(([score]) => score <= MAX_MATCH_SCORE).slice(0, MAX_SUGGESTION_COUNT).map(([, handler]) => handler);
+  return suggestedHandlers;
+}
+function getSuggestedHandlersMessage(handlers) {
+  if (handlers.length > 1) {
+    return `Did you mean to request one of the following resources instead?
 
-function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
-  if (typeof emitter.on === 'function') {
-    eventTargetAgnosticAddListener(emitter, 'error', handler, flags);
+${handlers.map((handler) => `  \u2022 ${handler.info.header}`).join("\n")}`;
   }
+  return `Did you mean to request "${handlers[0].info.header}" instead?`;
 }
-
-function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
-  if (typeof emitter.on === 'function') {
-    if (flags.once) {
-      emitter.once(name, listener);
-    } else {
-      emitter.on(name, listener);
-    }
-  } else if (typeof emitter.addEventListener === 'function') {
-    // EventTarget does not have `error` event semantics like Node
-    // EventEmitters, we do not listen for `error` events here.
-    emitter.addEventListener(name, function wrapListener(arg) {
-      // IE does not have builtin `{ once: true }` support so we
-      // have to do it manually.
-      if (flags.once) {
-        emitter.removeEventListener(name, wrapListener);
+function onUnhandledRequest(request, handlers, strategy = "warn") {
+  const parsedGraphQLQuery = tryCatch(() => parseGraphQLRequest(request));
+  function generateHandlerSuggestion() {
+    const handlerGroups = groupHandlersByType(handlers);
+    const relevantHandlers = parsedGraphQLQuery ? handlerGroups.graphql : handlerGroups.rest;
+    const suggestedHandlers = getSuggestedHandler(request, relevantHandlers, parsedGraphQLQuery ? getGraphQLHandlerScore(parsedGraphQLQuery) : getRestHandlerScore());
+    return suggestedHandlers.length > 0 ? getSuggestedHandlersMessage(suggestedHandlers) : "";
+  }
+  function generateUnhandledRequestMessage() {
+    const publicUrl = getPublicUrlFromRequest(request);
+    const requestHeader = parsedGraphQLQuery ? `${parsedGraphQLQuery.operationType} ${parsedGraphQLQuery.operationName} (${request.method} ${publicUrl})` : `${request.method} ${publicUrl}`;
+    const handlerSuggestion = generateHandlerSuggestion();
+    const messageTemplate = [
+      `captured a request without a matching request handler:`,
+      `  \u2022 ${requestHeader}`,
+      handlerSuggestion,
+      `If you still wish to intercept this unhandled request, please create a request handler for it.
+Read more: https://mswjs.io/docs/getting-started/mocks`
+    ].filter(Boolean);
+    return messageTemplate.join("\n\n");
+  }
+  function applyStrategy(strategy2) {
+    const message = generateUnhandledRequestMessage();
+    switch (strategy2) {
+      case "error": {
+        devUtils.error("Error: %s", message);
+        throw new Error(devUtils.formatMessage('Cannot bypass a request when using the "error" strategy for the "onUnhandledRequest" option.'));
+      }
+      case "warn": {
+        devUtils.warn("Warning: %s", message);
+        break;
       }
-      listener(arg);
+      case "bypass":
+        break;
+      default:
+        throw new Error(devUtils.formatMessage('Failed to react to an unhandled request: unknown strategy "%s". Please provide one of the supported strategies ("bypass", "warn", "error") or a custom callback function as the value of the "onUnhandledRequest" option.', strategy2));
+    }
+  }
+  if (typeof strategy === "function") {
+    strategy(request, {
+      warning: applyStrategy.bind(null, "warn"),
+      error: applyStrategy.bind(null, "error")
     });
-  } else {
-    throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
+    return;
   }
+  applyStrategy(strategy);
 }
 
-var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __spreadArrays = (commonjsGlobal && commonjsGlobal.__spreadArrays) || function () {
-    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
-    for (var r = Array(s), k = 0, i = 0; i < il; i++)
-        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
-            r[k] = a[j];
-    return r;
-};
-StrictEventEmitter$1.__esModule = true;
-StrictEventEmitter$1.StrictEventEmitter = void 0;
-var events_1 = events.exports;
-var StrictEventEmitter = /** @class */ (function (_super) {
-    __extends(StrictEventEmitter, _super);
-    function StrictEventEmitter() {
-        return _super.call(this) || this;
-    }
-    StrictEventEmitter.prototype.on = function (event, listener) {
-        return _super.prototype.on.call(this, event.toString(), listener);
-    };
-    StrictEventEmitter.prototype.once = function (event, listener) {
-        return _super.prototype.on.call(this, event.toString(), listener);
-    };
-    StrictEventEmitter.prototype.off = function (event, listener) {
-        return _super.prototype.off.call(this, event.toString(), listener);
-    };
-    StrictEventEmitter.prototype.emit = function (event) {
-        var data = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            data[_i - 1] = arguments[_i];
-        }
-        return _super.prototype.emit.apply(this, __spreadArrays([event.toString()], data));
-    };
-    StrictEventEmitter.prototype.addListener = function (event, listener) {
-        return _super.prototype.addListener.call(this, event.toString(), listener);
-    };
-    StrictEventEmitter.prototype.removeListener = function (event, listener) {
-        return _super.prototype.removeListener.call(this, event.toString(), listener);
-    };
-    return StrictEventEmitter;
-}(events_1.EventEmitter));
-StrictEventEmitter$1.StrictEventEmitter = StrictEventEmitter;
-
-(function (exports) {
-var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-exports.__esModule = true;
-exports.StrictEventEmitter = void 0;
-var StrictEventEmitter_1 = StrictEventEmitter$1;
-__createBinding(exports, StrictEventEmitter_1, "StrictEventEmitter");
-}(lib$1));
-
-var lib = {};
-
-var until$1 = {};
-
-Object.defineProperty(until$1, "__esModule", { value: true });
-/**
- * Gracefully handles a given Promise factory.
- * @example
- * cosnt [error, data] = await until(() => asyncAction())
- */
-until$1.until = async (promise) => {
+// src/utils/request/readResponseCookies.ts
+init_esm_shims();
+import { store as store2 } from "@mswjs/cookies";
+function readResponseCookies(request, response2) {
+  store2.add(__spreadProps(__spreadValues({}, request), { url: request.url.toString() }), response2);
+  store2.persist();
+}
+
+// src/utils/handleRequest.ts
+async function handleRequest(request, handlers, options, emitter, handleRequestOptions) {
+  var _a, _b, _c, _d;
+  emitter.emit("request:start", request);
+  if (request.headers.get("x-msw-bypass") === "true") {
+    emitter.emit("request:end", request);
+    (_a = handleRequestOptions == null ? void 0 : handleRequestOptions.onPassthroughResponse) == null ? void 0 : _a.call(handleRequestOptions, request);
+    return;
+  }
+  const [lookupError, lookupResult] = await until2(() => {
+    return getResponse(request, handlers, handleRequestOptions == null ? void 0 : handleRequestOptions.resolutionContext);
+  });
+  if (lookupError) {
+    emitter.emit("unhandledException", lookupError, request);
+    throw lookupError;
+  }
+  const { handler, response: response2 } = lookupResult;
+  if (!handler) {
+    onUnhandledRequest(request, handlers, options.onUnhandledRequest);
+    emitter.emit("request:unhandled", request);
+    emitter.emit("request:end", request);
+    (_b = handleRequestOptions == null ? void 0 : handleRequestOptions.onPassthroughResponse) == null ? void 0 : _b.call(handleRequestOptions, request);
+    return;
+  }
+  if (!response2) {
+    devUtils.warn(`Expected response resolver to return a mocked response Object, but got %s. The original response is going to be used instead.
+
+  \u2022 %s
+    %s`, response2, handler.info.header, handler.info.callFrame);
+    emitter.emit("request:end", request);
+    (_c = handleRequestOptions == null ? void 0 : handleRequestOptions.onPassthroughResponse) == null ? void 0 : _c.call(handleRequestOptions, request);
+    return;
+  }
+  if (response2.passthrough) {
+    emitter.emit("request:end", request);
+    (_d = handleRequestOptions == null ? void 0 : handleRequestOptions.onPassthroughResponse) == null ? void 0 : _d.call(handleRequestOptions, request);
+    return;
+  }
+  readResponseCookies(request, response2);
+  emitter.emit("request:match", request);
+  return new Promise((resolve) => {
+    var _a2, _b2, _c2;
+    const requiredLookupResult = lookupResult;
+    const transformedResponse = ((_a2 = handleRequestOptions == null ? void 0 : handleRequestOptions.transformResponse) == null ? void 0 : _a2.call(handleRequestOptions, response2)) || response2;
+    (_b2 = handleRequestOptions == null ? void 0 : handleRequestOptions.onMockedResponse) == null ? void 0 : _b2.call(handleRequestOptions, transformedResponse, requiredLookupResult);
+    setTimeout(() => {
+      var _a3;
+      (_a3 = handleRequestOptions == null ? void 0 : handleRequestOptions.onMockedResponseSent) == null ? void 0 : _a3.call(handleRequestOptions, transformedResponse, requiredLookupResult);
+      emitter.emit("request:end", request);
+      resolve(transformedResponse);
+    }, (_c2 = response2.delay) != null ? _c2 : 0);
+  });
+}
+
+// src/utils/worker/createRequestListener.ts
+var createRequestListener = (context, options) => {
+  return async (event, message) => {
+    const channel = createBroadcastChannel(event);
     try {
-        const data = await promise().catch((error) => {
-            throw error;
+      const request = parseWorkerRequest(message.payload);
+      await handleRequest(request, context.requestHandlers, options, context.emitter, {
+        transformResponse(response2) {
+          return __spreadProps(__spreadValues({}, response2), {
+            headers: response2.headers.all()
+          });
+        },
+        onPassthroughResponse() {
+          return channel.send({
+            type: "MOCK_NOT_FOUND"
+          });
+        },
+        onMockedResponse(response2) {
+          channel.send({
+            type: "MOCK_SUCCESS",
+            payload: response2
+          });
+        },
+        onMockedResponseSent(response2, { handler, publicRequest, parsedRequest }) {
+          if (!options.quiet) {
+            handler.log(publicRequest, response2, handler, parsedRequest);
+          }
+        }
+      });
+    } catch (error2) {
+      if (error2 instanceof NetworkError) {
+        return channel.send({
+          type: "NETWORK_ERROR",
+          payload: {
+            name: error2.name,
+            message: error2.message
+          }
         });
-        return [null, data];
-    }
-    catch (error) {
-        return [error, null];
+      }
+      if (error2 instanceof Error) {
+        channel.send({
+          type: "INTERNAL_ERROR",
+          payload: {
+            status: 500,
+            body: JSON.stringify({
+              errorType: error2.constructor.name,
+              message: error2.message,
+              location: error2.stack
+            })
+          }
+        });
+      }
     }
+  };
 };
 
-Object.defineProperty(lib, "__esModule", { value: true });
-var until_1 = until$1;
-var until = lib.until = until_1.until;
-
-/**
- * Attempts to resolve a Service Worker instance from a given registration,
- * regardless of its state (active, installing, waiting).
- */
-const getWorkerByRegistration = (registration, absoluteWorkerUrl, findWorker) => {
-    const allStates = [
-        registration.active,
-        registration.installing,
-        registration.waiting,
-    ];
-    const existingStates = allStates.filter(Boolean);
-    const mockWorker = existingStates.find((worker) => {
-        return findWorker(worker.scriptURL, absoluteWorkerUrl);
-    });
-    return mockWorker || null;
-};
-
-/**
- * Returns an absolute Service Worker URL based on the given
- * relative URL (known during the registration).
- */
-function getAbsoluteWorkerUrl(relativeUrl) {
-    return new URL(relativeUrl, location.origin).href;
-}
-
-/**
- * Returns an active Service Worker instance.
- * When not found, registers a new Service Worker.
- */
-const getWorkerInstance = (url, options = {}, findWorker) => __awaiter(void 0, void 0, void 0, function* () {
-    // Resolve the absolute Service Worker URL.
-    const absoluteWorkerUrl = getAbsoluteWorkerUrl(url);
-    const mockRegistrations = yield navigator.serviceWorker
-        .getRegistrations()
-        .then((registrations) => registrations.filter((registration) => getWorkerByRegistration(registration, absoluteWorkerUrl, findWorker)));
-    if (!navigator.serviceWorker.controller && mockRegistrations.length > 0) {
-        // Reload the page when it has associated workers, but no active controller.
-        // The absence of a controller can mean either:
-        // - page has no Service Worker associated with it
-        // - page has been hard-reloaded and its workers won't be used until the next reload.
-        // Since we've checked that there are registrations associated with this page,
-        // at this point we are sure it's hard reload that falls into this clause.
-        location.reload();
-    }
-    const [existingRegistration] = mockRegistrations;
-    if (existingRegistration) {
-        // When the Service Worker is registered, update it and return the reference.
-        return existingRegistration.update().then(() => {
-            return [
-                getWorkerByRegistration(existingRegistration, absoluteWorkerUrl, findWorker),
-                existingRegistration,
-            ];
-        });
-    }
-    // When the Service Worker wasn't found, register it anew and return the reference.
-    const [error, instance] = yield until(() => __awaiter(void 0, void 0, void 0, function* () {
-        const registration = yield navigator.serviceWorker.register(url, options);
-        return [
-            // Compare existing worker registration by its worker URL,
-            // to prevent irrelevant workers to resolve here (such as Codesandbox worker).
-            getWorkerByRegistration(registration, absoluteWorkerUrl, findWorker),
-            registration,
-        ];
-    }));
-    // Handle Service Worker registration errors.
-    if (error) {
-        const isWorkerMissing = error.message.includes('(404)');
-        // Produce a custom error message when given a non-existing Service Worker url.
-        // Suggest developers to check their setup.
-        if (isWorkerMissing) {
-            const scopeUrl = new URL((options === null || options === void 0 ? void 0 : options.scope) || '/', location.href);
-            throw new Error(devUtils.formatMessage(`\
-Failed to register a Service Worker for scope ('${scopeUrl.href}') with script ('${absoluteWorkerUrl}'): Service Worker script does not exist at the given path.
-
-Did you forget to run "npx msw init <PUBLIC_DIR>"?
-
-Learn more about creating the Service Worker script: https://mswjs.io/docs/cli/init`));
-        }
-        // Fallback error message for any other registration errors.
-        throw new Error(devUtils.formatMessage('Failed to register the Service Worker:\n\n%s', error.message));
-    }
-    return instance;
-});
-
-/**
- * Prints a worker activation message in the browser's console.
- */
-function printStartMessage(args = {}) {
-    if (args.quiet) {
-        return;
-    }
-    const message = args.message || 'Mocking enabled.';
-    console.groupCollapsed(`%c${devUtils.formatMessage(message)}`, 'color:orangered;font-weight:bold;');
-    console.log('%cDocumentation: %chttps://mswjs.io/docs', 'font-weight:bold', 'font-weight:normal');
-    console.log('Found an issue? https://github.com/mswjs/msw/issues');
-    if (args.workerUrl) {
-        console.log('Worker script URL:', args.workerUrl);
-    }
-    if (args.workerScope) {
-        console.log('Worker scope:', args.workerScope);
-    }
-    console.groupEnd();
-}
-
-/**
- * Signals the worker to enable the interception of requests.
- */
-function enableMocking(context, options) {
-    var _a, _b;
-    return __awaiter(this, void 0, void 0, function* () {
-        context.workerChannel.send('MOCK_ACTIVATE');
-        yield context.events.once('MOCKING_ENABLED');
-        // Warn the developer on multiple "worker.start()" calls.
-        // While this will not affect the worker in any way,
-        // it likely indicates an issue with the developer's code.
-        if (context.isMockingEnabled) {
-            devUtils.warn(`Found a redundant "worker.start()" call. Note that starting the worker while mocking is already enabled will have no effect. Consider removing this "worker.start()" call.`);
-            return;
-        }
-        context.isMockingEnabled = true;
-        printStartMessage({
-            quiet: options.quiet,
-            workerScope: (_a = context.registration) === null || _a === void 0 ? void 0 : _a.scope,
-            workerUrl: (_b = context.worker) === null || _b === void 0 ? void 0 : _b.scriptURL,
-        });
-    });
-}
-
-/**
- * Creates a communication channel between the client
- * and the Service Worker associated with the given event.
- */
-const createBroadcastChannel = (event) => {
-    const port = event.ports[0];
-    return {
-        /**
-         * Sends a text message to the connected Service Worker.
-         */
-        send(message) {
-            if (port) {
-                port.postMessage(message);
-            }
-        },
-    };
-};
+// src/utils/internal/requestIntegrityCheck.ts
+init_esm_shims();
+async function requestIntegrityCheck(context, serviceWorker) {
+  context.workerChannel.send("INTEGRITY_CHECK_REQUEST");
+  const { payload: actualChecksum } = await context.events.once("INTEGRITY_CHECK_RESPONSE");
+  if (actualChecksum !== "02f4ad4a2797f85668baf196e553d929") {
+    throw new Error(`Currently active Service Worker (${actualChecksum}) is behind the latest published one (${"02f4ad4a2797f85668baf196e553d929"}).`);
+  }
+  return serviceWorker;
+}
 
-function getAllCookies() {
-    return parse_1(document.cookie);
-}
-/**
- * Returns relevant document cookies based on the request `credentials` option.
- */
-function getRequestCookies(request) {
-    /**
-     * @note No cookies persist on the document in Node.js: no document.
-     */
-    if (typeof document === 'undefined' || typeof location === 'undefined') {
-        return {};
-    }
-    switch (request.credentials) {
-        case 'same-origin': {
-            // Return document cookies only when requested a resource
-            // from the same origin as the current document.
-            return location.origin === request.url.origin ? getAllCookies() : {};
-        }
-        case 'include': {
-            // Return all document cookies.
-            return getAllCookies();
-        }
-        default: {
-            return {};
-        }
-    }
-}
-
-/**
- * Sets relevant cookies on the request.
- * Request cookies are taken from the following sources:
- * - Immediate (own) request cookies (those in the "Cookie" request header);
- * - From the `document.cookie` based on the request's `credentials` value;
- * - From the internal cookie store that persists/hydrates cookies in Node.js
- */
-function setRequestCookies(request) {
-    var _a;
-    // Set mocked request cookies from the `cookie` header of the original request.
-    // No need to take `credentials` into account, because in Node.js requests are intercepted
-    // _after_ they happen. Request issuer should have already taken care of sending relevant cookies.
-    // Unlike browser, where interception is on the worker level, _before_ the request happens.
-    const requestCookiesString = request.headers.get('cookie');
-    store.hydrate();
-    const cookiesFromStore = Array.from((_a = store.get(Object.assign(Object.assign({}, request), { url: request.url.toString() }))) === null || _a === void 0 ? void 0 : _a.entries()).reduce((cookies, [name, { value }]) => {
-        return Object.assign(cookies, { [name.trim()]: value });
-    }, {});
-    const cookiesFromDocument = getRequestCookies(request);
-    const forwardedCookies = Object.assign(Object.assign({}, cookiesFromDocument), cookiesFromStore);
-    // Ensure the persisted (document) cookies are propagated to the request.
-    // Propagated the cookies persisted in the Cookuie Store to the request headers.
-    // This forwards relevant request cookies based on the request's credentials.
-    for (const [name, value] of Object.entries(forwardedCookies)) {
-        request.headers.append('cookie', `${name}=${value}`);
-    }
-    const ownCookies = requestCookiesString
-        ? parse_1(requestCookiesString)
-        : {};
-    request.cookies = Object.assign(Object.assign(Object.assign({}, request.cookies), forwardedCookies), ownCookies);
-}
-
-/**
- * Ensures that an empty GET request body is always represented as `undefined`.
- */
-function pruneGetRequestBody(request) {
-    if (request.method &&
-        isStringEqual(request.method, 'GET') &&
-        request.body === '') {
-        return undefined;
-    }
-    return request.body;
-}
-
-/**
- * Converts a given request received from the Service Worker
- * into a `MockedRequest` instance.
- */
-function parseWorkerRequest(rawRequest) {
-    const request = {
-        id: rawRequest.id,
-        cache: rawRequest.cache,
-        credentials: rawRequest.credentials,
-        method: rawRequest.method,
-        url: new URL(rawRequest.url),
-        referrer: rawRequest.referrer,
-        referrerPolicy: rawRequest.referrerPolicy,
-        redirect: rawRequest.redirect,
-        mode: rawRequest.mode,
-        params: {},
-        cookies: {},
-        integrity: rawRequest.integrity,
-        keepalive: rawRequest.keepalive,
-        destination: rawRequest.destination,
-        body: pruneGetRequestBody(rawRequest),
-        bodyUsed: rawRequest.bodyUsed,
-        headers: new lib$2.Headers(rawRequest.headers),
-        passthrough,
-    };
-    // Set document cookies on the request.
-    setRequestCookies(request);
-    // Parse the request's body based on the "Content-Type" header.
-    request.body = parseBody(request.body, request.headers);
-    return request;
-}
-
-/**
- * Returns a mocked response for a given request using following request handlers.
- */
-const getResponse = (request, handlers, resolutionContext) => __awaiter(void 0, void 0, void 0, function* () {
-    const relevantHandlers = handlers.filter((handler) => {
-        return handler.test(request, resolutionContext);
-    });
-    if (relevantHandlers.length === 0) {
-        return {
-            handler: undefined,
-            response: undefined,
-        };
-    }
-    const result = yield relevantHandlers.reduce((executionResult, handler) => __awaiter(void 0, void 0, void 0, function* () {
-        const previousResults = yield executionResult;
-        if (!!(previousResults === null || previousResults === void 0 ? void 0 : previousResults.response)) {
-            return executionResult;
-        }
-        const result = yield handler.run(request, resolutionContext);
-        if (result === null || result.handler.shouldSkip) {
-            return null;
-        }
-        if (!result.response) {
-            return {
-                request: result.request,
-                handler: result.handler,
-                response: undefined,
-                parsedResult: result.parsedResult,
-            };
-        }
-        if (result.response.once) {
-            handler.markAsSkipped(true);
-        }
-        return result;
-    }), Promise.resolve(null));
-    // Although reducing a list of relevant request handlers, it's possible
-    // that in the end there will be no handler associted with the request
-    // (i.e. if relevant handlers are fall-through).
-    if (!result) {
-        return {
-            handler: undefined,
-            response: undefined,
-        };
-    }
-    return {
-        handler: result.handler,
-        publicRequest: result.request,
-        parsedRequest: result.parsedResult,
-        response: result.response,
-    };
-});
+// src/utils/deferNetworkRequestsUntil.ts
+init_esm_shims();
+import { until as until3 } from "@open-draft/until";
+function deferNetworkRequestsUntil(predicatePromise) {
+  const originalXhrSend = window.XMLHttpRequest.prototype.send;
+  window.XMLHttpRequest.prototype.send = function(...args) {
+    until3(() => predicatePromise).then(() => {
+      window.XMLHttpRequest.prototype.send = originalXhrSend;
+      this.send(...args);
+    });
+  };
+  const originalFetch = window.fetch;
+  window.fetch = async (...args) => {
+    await until3(() => predicatePromise);
+    window.fetch = originalFetch;
+    return window.fetch(...args);
+  };
+}
 
-var jsLevenshtein = (function()
-{
-  function _min(d0, d1, d2, bx, ay)
-  {
-    return d0 < d1 || d2 < d1
-        ? d0 > d2
-            ? d2 + 1
-            : d0 + 1
-        : bx === ay
-            ? d1
-            : d1 + 1;
-  }
-
-  return function(a, b)
-  {
-    if (a === b) {
-      return 0;
+// src/utils/worker/createResponseListener.ts
+init_esm_shims();
+function createResponseListener(context) {
+  return (_, message) => {
+    var _a;
+    const { payload: responseJson } = message;
+    if ((_a = responseJson.type) == null ? void 0 : _a.includes("opaque")) {
+      return;
     }
-
-    if (a.length > b.length) {
-      var tmp = a;
-      a = b;
-      b = tmp;
+    const response2 = new Response(responseJson.body || null, responseJson);
+    const isMockedResponse = response2.headers.get("x-powered-by") === "msw";
+    if (isMockedResponse) {
+      context.emitter.emit("response:mocked", response2, responseJson.requestId);
+    } else {
+      context.emitter.emit("response:bypass", response2, responseJson.requestId);
     }
+  };
+}
 
-    var la = a.length;
-    var lb = b.length;
+// src/setupWorker/start/utils/validateWorkerScope.ts
+init_esm_shims();
+function validateWorkerScope(registration, options) {
+  if (!(options == null ? void 0 : options.quiet) && !location.href.startsWith(registration.scope)) {
+    devUtils.warn(`Cannot intercept requests on this page because it's outside of the worker's scope ("${registration.scope}"). If you wish to mock API requests on this page, you must resolve this scope issue.
 
-    while (la > 0 && (a.charCodeAt(la - 1) === b.charCodeAt(lb - 1))) {
-      la--;
-      lb--;
-    }
+- (Recommended) Register the worker at the root level ("/") of your application.
+- Set the "Service-Worker-Allowed" response header to allow out-of-scope workers.`);
+  }
+}
 
-    var offset = 0;
+// src/setupWorker/start/createStartHandler.ts
+var createStartHandler = (context) => {
+  return function start(options, customOptions) {
+    const startWorkerInstance = async () => {
+      context.events.removeAllListeners();
+      context.workerChannel.on("REQUEST", createRequestListener(context, options));
+      context.workerChannel.on("RESPONSE", createResponseListener(context));
+      const instance = await getWorkerInstance(options.serviceWorker.url, options.serviceWorker.options, options.findWorker);
+      const [worker, registration] = instance;
+      if (!worker) {
+        const missingWorkerMessage = (customOptions == null ? void 0 : customOptions.findWorker) ? devUtils.formatMessage(`Failed to locate the Service Worker registration using a custom "findWorker" predicate.
 
-    while (offset < la && (a.charCodeAt(offset) === b.charCodeAt(offset))) {
-      offset++;
-    }
+Please ensure that the custom predicate properly locates the Service Worker registration at "%s".
+More details: https://mswjs.io/docs/api/setup-worker/start#findworker
+`, options.serviceWorker.url) : devUtils.formatMessage(`Failed to locate the Service Worker registration.
 
-    la -= offset;
-    lb -= offset;
+This most likely means that the worker script URL "%s" cannot resolve against the actual public hostname (%s). This may happen if your application runs behind a proxy, or has a dynamic hostname.
 
-    if (la === 0 || lb < 3) {
-      return lb;
-    }
+Please consider using a custom "serviceWorker.url" option to point to the actual worker script location, or a custom "findWorker" option to resolve the Service Worker registration manually. More details: https://mswjs.io/docs/api/setup-worker/start`, options.serviceWorker.url, location.host);
+        throw new Error(missingWorkerMessage);
+      }
+      context.worker = worker;
+      context.registration = registration;
+      context.events.addListener(window, "beforeunload", () => {
+        if (worker.state !== "redundant") {
+          context.workerChannel.send("CLIENT_CLOSED");
+        }
+        window.clearInterval(context.keepAliveInterval);
+      });
+      const [integrityError] = await until4(() => requestIntegrityCheck(context, worker));
+      if (integrityError) {
+        devUtils.error(`Detected outdated Service Worker: ${integrityError.message}
 
-    var x = 0;
-    var y;
-    var d0;
-    var d1;
-    var d2;
-    var d3;
-    var dd;
-    var dy;
-    var ay;
-    var bx0;
-    var bx1;
-    var bx2;
-    var bx3;
-
-    var vector = [];
-
-    for (y = 0; y < la; y++) {
-      vector.push(y + 1);
-      vector.push(a.charCodeAt(offset + y));
-    }
+The mocking is still enabled, but it's highly recommended that you update your Service Worker by running:
 
-    var len = vector.length - 1;
-
-    for (; x < lb - 3;) {
-      bx0 = b.charCodeAt(offset + (d0 = x));
-      bx1 = b.charCodeAt(offset + (d1 = x + 1));
-      bx2 = b.charCodeAt(offset + (d2 = x + 2));
-      bx3 = b.charCodeAt(offset + (d3 = x + 3));
-      dd = (x += 4);
-      for (y = 0; y < len; y += 2) {
-        dy = vector[y];
-        ay = vector[y + 1];
-        d0 = _min(dy, d0, d1, bx0, ay);
-        d1 = _min(d0, d1, d2, bx1, ay);
-        d2 = _min(d1, d2, d3, bx2, ay);
-        dd = _min(d2, d3, dd, bx3, ay);
-        vector[y] = dd;
-        d3 = d2;
-        d2 = d1;
-        d1 = d0;
-        d0 = dy;
-      }
-    }
+$ npx msw init <PUBLIC_DIR>
 
-    for (; x < lb;) {
-      bx0 = b.charCodeAt(offset + (d0 = x));
-      dd = ++x;
-      for (y = 0; y < len; y += 2) {
-        dy = vector[y];
-        vector[y] = dd = _min(dy, d0, dd, bx0, vector[y + 1]);
-        d0 = dy;
+This is necessary to ensure that the Service Worker is in sync with the library to guarantee its stability.
+If this message still persists after updating, please report an issue: https://github.com/open-draft/msw/issues      `);
+      }
+      context.keepAliveInterval = window.setInterval(() => context.workerChannel.send("KEEPALIVE_REQUEST"), 5e3);
+      validateWorkerScope(registration, context.startOptions);
+      return registration;
+    };
+    const workerRegistration = startWorkerInstance().then(async (registration) => {
+      const pendingInstance = registration.installing || registration.waiting;
+      if (pendingInstance) {
+        await new Promise((resolve) => {
+          pendingInstance.addEventListener("statechange", () => {
+            if (pendingInstance.state === "activated") {
+              return resolve();
+            }
+          });
+        });
       }
+      await enableMocking(context, options).catch((error2) => {
+        throw new Error(`Failed to enable mocking: ${error2 == null ? void 0 : error2.message}`);
+      });
+      return registration;
+    });
+    if (options.waitUntilReady) {
+      deferNetworkRequestsUntil(workerRegistration);
     }
+    return workerRegistration;
+  };
+};
+
+// src/setupWorker/stop/createStop.ts
+init_esm_shims();
+
+// src/setupWorker/stop/utils/printStopMessage.ts
+init_esm_shims();
+function printStopMessage(args = {}) {
+  if (args.quiet) {
+    return;
+  }
+  console.log(`%c${devUtils.formatMessage("Mocking disabled.")}`, "color:orangered;font-weight:bold;");
+}
 
-    return dd;
+// src/setupWorker/stop/createStop.ts
+var createStop = (context) => {
+  return function stop() {
+    var _a;
+    if (!context.isMockingEnabled) {
+      devUtils.warn('Found a redundant "worker.stop()" call. Note that stopping the worker while mocking already stopped has no effect. Consider removing this "worker.stop()" call.');
+      return;
+    }
+    context.workerChannel.send("MOCK_DEACTIVATE");
+    context.isMockingEnabled = false;
+    window.clearInterval(context.keepAliveInterval);
+    printStopMessage({ quiet: (_a = context.startOptions) == null ? void 0 : _a.quiet });
   };
-})();
-
-const MAX_MATCH_SCORE = 3;
-const MAX_SUGGESTION_COUNT = 4;
-const TYPE_MATCH_DELTA = 0.5;
-function groupHandlersByType(handlers) {
-    return handlers.reduce((groups, handler) => {
-        if (handler instanceof RestHandler) {
-            groups.rest.push(handler);
-        }
-        if (handler instanceof GraphQLHandler) {
-            groups.graphql.push(handler);
-        }
-        return groups;
-    }, {
-        rest: [],
-        graphql: [],
-    });
-}
-function getRestHandlerScore() {
-    return (request, handler) => {
-        const { path, method } = handler.info;
-        if (path instanceof RegExp || method instanceof RegExp) {
-            return Infinity;
-        }
-        const hasSameMethod = isStringEqual(request.method, method);
-        // Always treat a handler with the same method as a more similar one.
-        const methodScoreDelta = hasSameMethod ? TYPE_MATCH_DELTA : 0;
-        const requestPublicUrl = getPublicUrlFromRequest(request);
-        const score = jsLevenshtein(requestPublicUrl, path);
-        return score - methodScoreDelta;
-    };
-}
-function getGraphQLHandlerScore(parsedQuery) {
-    return (_, handler) => {
-        if (typeof parsedQuery.operationName === 'undefined') {
-            return Infinity;
-        }
-        const { operationType, operationName } = handler.info;
-        if (typeof operationName !== 'string') {
-            return Infinity;
-        }
-        const hasSameOperationType = parsedQuery.operationType === operationType;
-        // Always treat a handler with the same operation type as a more similar one.
-        const operationTypeScoreDelta = hasSameOperationType ? TYPE_MATCH_DELTA : 0;
-        const score = jsLevenshtein(parsedQuery.operationName, operationName);
-        return score - operationTypeScoreDelta;
-    };
-}
-function getSuggestedHandler(request, handlers, getScore) {
-    const suggestedHandlers = handlers
-        .reduce((suggestions, handler) => {
-        const score = getScore(request, handler);
-        return suggestions.concat([[score, handler]]);
-    }, [])
-        .sort(([leftScore], [rightScore]) => leftScore - rightScore)
-        .filter(([score]) => score <= MAX_MATCH_SCORE)
-        .slice(0, MAX_SUGGESTION_COUNT)
-        .map(([, handler]) => handler);
-    return suggestedHandlers;
-}
-function getSuggestedHandlersMessage(handlers) {
-    if (handlers.length > 1) {
-        return `\
-Did you mean to request one of the following resources instead?
-
-${handlers.map((handler) => `  • ${handler.info.header}`).join('\n')}`;
-    }
-    return `Did you mean to request "${handlers[0].info.header}" instead?`;
-}
-function onUnhandledRequest(request, handlers, strategy = 'warn') {
-    const parsedGraphQLQuery = tryCatch(() => parseGraphQLRequest(request));
-    function generateHandlerSuggestion() {
-        /**
-         * @note Ignore exceptions during GraphQL request parsing because at this point
-         * we cannot assume the unhandled request is a valid GraphQL request.
-         * If the GraphQL parsing fails, just don't treat it as a GraphQL request.
-         */
-        const handlerGroups = groupHandlersByType(handlers);
-        const relevantHandlers = parsedGraphQLQuery
-            ? handlerGroups.graphql
-            : handlerGroups.rest;
-        const suggestedHandlers = getSuggestedHandler(request, relevantHandlers, parsedGraphQLQuery
-            ? getGraphQLHandlerScore(parsedGraphQLQuery)
-            : getRestHandlerScore());
-        return suggestedHandlers.length > 0
-            ? getSuggestedHandlersMessage(suggestedHandlers)
-            : '';
-    }
-    function generateUnhandledRequestMessage() {
-        const publicUrl = getPublicUrlFromRequest(request);
-        const requestHeader = parsedGraphQLQuery
-            ? `${parsedGraphQLQuery.operationType} ${parsedGraphQLQuery.operationName} (${request.method} ${publicUrl})`
-            : `${request.method} ${publicUrl}`;
-        const handlerSuggestion = generateHandlerSuggestion();
-        const messageTemplate = [
-            `captured a request without a matching request handler:`,
-            `  \u2022 ${requestHeader}`,
-            handlerSuggestion,
-            `\
-If you still wish to intercept this unhandled request, please create a request handler for it.
-Read more: https://mswjs.io/docs/getting-started/mocks\
-`,
-        ].filter(Boolean);
-        return messageTemplate.join('\n\n');
-    }
-    function applyStrategy(strategy) {
-        // Generate handler suggestions only when applying the strategy.
-        // This saves bandwidth for scenarios when developers opt-out
-        // from the default unhandled request handling strategy.
-        const message = generateUnhandledRequestMessage();
-        switch (strategy) {
-            case 'error': {
-                // Print a developer-friendly error.
-                devUtils.error('Error: %s', message);
-                // Throw an exception to halt request processing and not perform the original request.
-                throw new Error(devUtils.formatMessage('Cannot bypass a request when using the "error" strategy for the "onUnhandledRequest" option.'));
-            }
-            case 'warn': {
-                devUtils.warn('Warning: %s', message);
-                break;
-            }
-            case 'bypass':
-                break;
-            default:
-                throw new Error(devUtils.formatMessage('Failed to react to an unhandled request: unknown strategy "%s". Please provide one of the supported strategies ("bypass", "warn", "error") or a custom callback function as the value of the "onUnhandledRequest" option.', strategy));
-        }
-    }
-    if (typeof strategy === 'function') {
-        strategy(request, {
-            warning: applyStrategy.bind(null, 'warn'),
-            error: applyStrategy.bind(null, 'error'),
-        });
-        return;
-    }
-    applyStrategy(strategy);
-}
-
-function readResponseCookies(request, response) {
-    store.add(Object.assign(Object.assign({}, request), { url: request.url.toString() }), response);
-    store.persist();
-}
-
-function handleRequest(request, handlers, options, emitter, handleRequestOptions) {
-    var _a, _b, _c, _d;
-    return __awaiter(this, void 0, void 0, function* () {
-        emitter.emit('request:start', request);
-        // Perform bypassed requests (i.e. issued via "ctx.fetch") as-is.
-        if (request.headers.get('x-msw-bypass') === 'true') {
-            emitter.emit('request:end', request);
-            (_a = handleRequestOptions === null || handleRequestOptions === void 0 ? void 0 : handleRequestOptions.onPassthroughResponse) === null || _a === void 0 ? void 0 : _a.call(handleRequestOptions, request);
-            return;
-        }
-        // Resolve a mocked response from the list of request handlers.
-        const [lookupError, lookupResult] = yield until(() => {
-            return getResponse(request, handlers, handleRequestOptions === null || handleRequestOptions === void 0 ? void 0 : handleRequestOptions.resolutionContext);
-        });
-        if (lookupError) {
-            // Allow developers to react to unhandled exceptions in request handlers.
-            emitter.emit('unhandledException', lookupError, request);
-            throw lookupError;
-        }
-        const { handler, response } = lookupResult;
-        // When there's no handler for the request, consider it unhandled.
-        // Allow the developer to react to such cases.
-        if (!handler) {
-            onUnhandledRequest(request, handlers, options.onUnhandledRequest);
-            emitter.emit('request:unhandled', request);
-            emitter.emit('request:end', request);
-            (_b = handleRequestOptions === null || handleRequestOptions === void 0 ? void 0 : handleRequestOptions.onPassthroughResponse) === null || _b === void 0 ? void 0 : _b.call(handleRequestOptions, request);
-            return;
-        }
-        // When the handled request returned no mocked response, warn the developer,
-        // as it may be an oversight on their part. Perform the request as-is.
-        if (!response) {
-            devUtils.warn(`\
-Expected response resolver to return a mocked response Object, but got %s. The original response is going to be used instead.\
-\n
-  \u2022 %s
-    %s\
-`, response, handler.info.header, handler.info.callFrame);
-            emitter.emit('request:end', request);
-            (_c = handleRequestOptions === null || handleRequestOptions === void 0 ? void 0 : handleRequestOptions.onPassthroughResponse) === null || _c === void 0 ? void 0 : _c.call(handleRequestOptions, request);
-            return;
-        }
-        // When the developer explicitly returned "req.passthrough()" do not warn them.
-        // Perform the request as-is.
-        if (response.passthrough) {
-            emitter.emit('request:end', request);
-            (_d = handleRequestOptions === null || handleRequestOptions === void 0 ? void 0 : handleRequestOptions.onPassthroughResponse) === null || _d === void 0 ? void 0 : _d.call(handleRequestOptions, request);
-            return;
-        }
-        // Store all the received response cookies in the virtual cookie store.
-        readResponseCookies(request, response);
-        emitter.emit('request:match', request);
-        return new Promise((resolve) => {
-            var _a, _b, _c;
-            const requiredLookupResult = lookupResult;
-            const transformedResponse = ((_a = handleRequestOptions === null || handleRequestOptions === void 0 ? void 0 : handleRequestOptions.transformResponse) === null || _a === void 0 ? void 0 : _a.call(handleRequestOptions, response)) ||
-                response;
-            (_b = handleRequestOptions === null || handleRequestOptions === void 0 ? void 0 : handleRequestOptions.onMockedResponse) === null || _b === void 0 ? void 0 : _b.call(handleRequestOptions, transformedResponse, requiredLookupResult);
-            setTimeout(() => {
-                var _a;
-                (_a = handleRequestOptions === null || handleRequestOptions === void 0 ? void 0 : handleRequestOptions.onMockedResponseSent) === null || _a === void 0 ? void 0 : _a.call(handleRequestOptions, transformedResponse, requiredLookupResult);
-                emitter.emit('request:end', request);
-                resolve(transformedResponse);
-            }, (_c = response.delay) !== null && _c !== void 0 ? _c : 0);
-        });
-    });
-}
-
-const createRequestListener = (context, options) => {
-    return (event, message) => __awaiter(void 0, void 0, void 0, function* () {
-        const channel = createBroadcastChannel(event);
-        try {
-            const request = parseWorkerRequest(message.payload);
-            yield handleRequest(request, context.requestHandlers, options, context.emitter, {
-                transformResponse(response) {
-                    return Object.assign(Object.assign({}, response), { headers: response.headers.all() });
-                },
-                onPassthroughResponse() {
-                    return channel.send({
-                        type: 'MOCK_NOT_FOUND',
-                    });
-                },
-                onMockedResponse(response) {
-                    channel.send({
-                        type: 'MOCK_SUCCESS',
-                        payload: response,
-                    });
-                },
-                onMockedResponseSent(response, { handler, publicRequest, parsedRequest }) {
-                    if (!options.quiet) {
-                        handler.log(publicRequest, response, handler, parsedRequest);
-                    }
-                },
-            });
-        }
-        catch (error) {
-            if (error instanceof NetworkError) {
-                // Treat emulated network error differently,
-                // as it is an intended exception in a request handler.
-                return channel.send({
-                    type: 'NETWORK_ERROR',
-                    payload: {
-                        name: error.name,
-                        message: error.message,
-                    },
-                });
-            }
-            // Treat all the other exceptions in a request handler
-            // as unintended, alerting that there is a problem needs fixing.
-            channel.send({
-                type: 'INTERNAL_ERROR',
-                payload: {
-                    status: 500,
-                    body: JSON.stringify({
-                        errorType: error.constructor.name,
-                        message: error.message,
-                        location: error.stack,
-                    }),
-                },
-            });
-        }
-    });
 };
 
-function requestIntegrityCheck(context, serviceWorker) {
-    return __awaiter(this, void 0, void 0, function* () {
-        // Signal Service Worker to report back its integrity
-        context.workerChannel.send('INTEGRITY_CHECK_REQUEST');
-        const { payload: actualChecksum } = yield context.events.once('INTEGRITY_CHECK_RESPONSE');
-        // Compare the response from the Service Worker and the
-        // global variable set by Rollup during the build.
-        if (actualChecksum !== "02f4ad4a2797f85668baf196e553d929") {
-            throw new Error(`Currently active Service Worker (${actualChecksum}) is behind the latest published one (${"02f4ad4a2797f85668baf196e553d929"}).`);
-        }
-        return serviceWorker;
-    });
-}
-
-/**
- * Intercepts and defers any requests on the page
- * until the Service Worker instance is ready.
- * Must only be used in a browser.
- */
-function deferNetworkRequestsUntil(predicatePromise) {
-    // Defer any `XMLHttpRequest` requests until the Service Worker is ready.
-    const originalXhrSend = window.XMLHttpRequest.prototype.send;
-    window.XMLHttpRequest.prototype.send = function (...args) {
-        // Keep this function synchronous to comply with `XMLHttpRequest.prototype.send`,
-        // because that method is always synchronous.
-        until(() => predicatePromise).then(() => {
-            window.XMLHttpRequest.prototype.send = originalXhrSend;
-            this.send(...args);
-        });
-    };
-    // Defer any `fetch` requests until the Service Worker is ready.
-    const originalFetch = window.fetch;
-    window.fetch = (...args) => __awaiter(this, void 0, void 0, function* () {
-        yield until(() => predicatePromise);
-        window.fetch = originalFetch;
-        return window.fetch(...args);
-    });
-}
-
-function createResponseListener(context) {
-    return (_, message) => {
-        var _a;
-        const { payload: responseJson } = message;
-        /**
-         * CORS requests with `mode: "no-cors"` result in "opaque" responses.
-         * That kind of responses cannot be manipulated in JavaScript due
-         * to the security considerations.
-         * @see https://fetch.spec.whatwg.org/#concept-filtered-response-opaque
-         * @see https://github.com/mswjs/msw/issues/529
-         */
-        if ((_a = responseJson.type) === null || _a === void 0 ? void 0 : _a.includes('opaque')) {
-            return;
-        }
-        const response = new Response(responseJson.body || null, responseJson);
-        const isMockedResponse = response.headers.get('x-powered-by') === 'msw';
-        if (isMockedResponse) {
-            context.emitter.emit('response:mocked', response, responseJson.requestId);
-        }
-        else {
-            context.emitter.emit('response:bypass', response, responseJson.requestId);
-        }
-    };
-}
-
-function validateWorkerScope(registration, options) {
-    if (!(options === null || options === void 0 ? void 0 : options.quiet) && !location.href.startsWith(registration.scope)) {
-        devUtils.warn(`\
-Cannot intercept requests on this page because it's outside of the worker's scope ("${registration.scope}"). If you wish to mock API requests on this page, you must resolve this scope issue.
+// src/utils/internal/requestHandlerUtils.ts
+init_esm_shims();
+function use(currentHandlers, ...handlers) {
+  currentHandlers.unshift(...handlers);
+}
+function restoreHandlers(handlers) {
+  handlers.forEach((handler) => {
+    handler.markAsSkipped(false);
+  });
+}
+function resetHandlers(initialHandlers, ...nextHandlers) {
+  return nextHandlers.length > 0 ? [...nextHandlers] : [...initialHandlers];
+}
 
-- (Recommended) Register the worker at the root level ("/") of your application.
-- Set the "Service-Worker-Allowed" response header to allow out-of-scope workers.\
-`);
-    }
-}
-
-const createStartHandler = (context) => {
-    return function start(options, customOptions) {
-        const startWorkerInstance = () => __awaiter(this, void 0, void 0, function* () {
-            // Remove all previously existing event listeners.
-            // This way none of the listeners persists between Fast refresh
-            // of the application's code.
-            context.events.removeAllListeners();
-            // Handle requests signaled by the worker.
-            context.workerChannel.on('REQUEST', createRequestListener(context, options));
-            context.workerChannel.on('RESPONSE', createResponseListener(context));
-            const instance = yield getWorkerInstance(options.serviceWorker.url, options.serviceWorker.options, options.findWorker);
-            const [worker, registration] = instance;
-            if (!worker) {
-                const missingWorkerMessage = (customOptions === null || customOptions === void 0 ? void 0 : customOptions.findWorker)
-                    ? devUtils.formatMessage(`Failed to locate the Service Worker registration using a custom "findWorker" predicate.
+// src/setupWorker/start/utils/prepareStartHandler.ts
+init_esm_shims();
+var DEFAULT_START_OPTIONS = {
+  serviceWorker: {
+    url: "/mockServiceWorker.js",
+    options: null
+  },
+  quiet: false,
+  waitUntilReady: true,
+  onUnhandledRequest: "warn",
+  findWorker(scriptURL, mockServiceWorkerUrl) {
+    return scriptURL === mockServiceWorkerUrl;
+  }
+};
+function resolveStartOptions(initialOptions) {
+  return mergeRight(DEFAULT_START_OPTIONS, initialOptions || {});
+}
+function prepareStartHandler(handler, context) {
+  return (initialOptions) => {
+    context.startOptions = resolveStartOptions(initialOptions);
+    return handler(context.startOptions, initialOptions || {});
+  };
+}
 
-Please ensure that the custom predicate properly locates the Service Worker registration at "%s".
-More details: https://mswjs.io/docs/api/setup-worker/start#findworker
-`, options.serviceWorker.url)
-                    : devUtils.formatMessage(`Failed to locate the Service Worker registration.
+// src/setupWorker/start/createFallbackStart.ts
+init_esm_shims();
+
+// src/utils/worker/createFallbackRequestListener.ts
+init_esm_shims();
+import { createInterceptor } from "@mswjs/interceptors";
+import { interceptFetch } from "@mswjs/interceptors/lib/interceptors/fetch";
+import { interceptXMLHttpRequest } from "@mswjs/interceptors/lib/interceptors/XMLHttpRequest";
+
+// src/utils/request/parseIsomorphicRequest.ts
+init_esm_shims();
+function parseIsomorphicRequest(request) {
+  const mockedRequest = {
+    id: request.id,
+    url: request.url,
+    method: request.method,
+    body: parseBody(request.body, request.headers),
+    credentials: request.credentials || "same-origin",
+    headers: request.headers,
+    cookies: {},
+    redirect: "manual",
+    referrer: "",
+    keepalive: false,
+    cache: "default",
+    mode: "cors",
+    referrerPolicy: "no-referrer",
+    integrity: "",
+    destination: "document",
+    bodyUsed: false,
+    passthrough
+  };
+  setRequestCookies(mockedRequest);
+  return mockedRequest;
+}
 
-This most likely means that the worker script URL "%s" cannot resolve against the actual public hostname (%s). This may happen if your application runs behind a proxy, or has a dynamic hostname.
+// src/utils/worker/createFallbackRequestListener.ts
+function createFallbackRequestListener(context, options) {
+  const interceptor = createInterceptor({
+    modules: [interceptFetch, interceptXMLHttpRequest],
+    async resolver(request) {
+      const mockedRequest = parseIsomorphicRequest(request);
+      return handleRequest(mockedRequest, context.requestHandlers, options, context.emitter, {
+        transformResponse(response2) {
+          return {
+            status: response2.status,
+            statusText: response2.statusText,
+            headers: response2.headers.all(),
+            body: response2.body
+          };
+        },
+        onMockedResponseSent(response2, { handler, publicRequest, parsedRequest }) {
+          if (!options.quiet) {
+            handler.log(publicRequest, response2, handler, parsedRequest);
+          }
+        }
+      });
+    }
+  });
+  interceptor.apply();
+  return interceptor;
+}
 
-Please consider using a custom "serviceWorker.url" option to point to the actual worker script location, or a custom "findWorker" option to resolve the Service Worker registration manually. More details: https://mswjs.io/docs/api/setup-worker/start`, options.serviceWorker.url, location.host);
-                throw new Error(missingWorkerMessage);
-            }
-            context.worker = worker;
-            context.registration = registration;
-            context.events.addListener(window, 'beforeunload', () => {
-                if (worker.state !== 'redundant') {
-                    // Notify the Service Worker that this client has closed.
-                    // Internally, it's similar to disabling the mocking, only
-                    // client close event has a handler that self-terminates
-                    // the Service Worker when there are no open clients.
-                    context.workerChannel.send('CLIENT_CLOSED');
-                }
-                // Make sure we're always clearing the interval - there are reports that not doing this can
-                // cause memory leaks in headless browser environments.
-                window.clearInterval(context.keepAliveInterval);
-            });
-            // Check if the active Service Worker is the latest published one
-            const [integrityError] = yield until(() => requestIntegrityCheck(context, worker));
-            if (integrityError) {
-                devUtils.error(`\
-Detected outdated Service Worker: ${integrityError.message}
+// src/setupWorker/start/createFallbackStart.ts
+function createFallbackStart(context) {
+  return async function start(options) {
+    context.fallbackInterceptor = createFallbackRequestListener(context, options);
+    printStartMessage({
+      message: "Mocking enabled (fallback mode).",
+      quiet: options.quiet
+    });
+    return void 0;
+  };
+}
 
-The mocking is still enabled, but it's highly recommended that you update your Service Worker by running:
+// src/setupWorker/stop/createFallbackStop.ts
+init_esm_shims();
+function createFallbackStop(context) {
+  return function stop() {
+    var _a, _b;
+    (_a = context.fallbackInterceptor) == null ? void 0 : _a.restore();
+    printStopMessage({ quiet: (_b = context.startOptions) == null ? void 0 : _b.quiet });
+  };
+}
 
-$ npx msw init <PUBLIC_DIR>
+// src/utils/internal/pipeEvents.ts
+init_esm_shims();
+function pipeEvents(source, destination) {
+  const rawEmit = source.emit;
+  if (rawEmit._isPiped) {
+    return;
+  }
+  source.emit = function(event, ...data2) {
+    destination.emit(event, ...data2);
+    return rawEmit.call(this, event, ...data2);
+  };
+  source.emit._isPiped = true;
+}
 
-This is necessary to ensure that the Service Worker is in sync with the library to guarantee its stability.
-If this message still persists after updating, please report an issue: https://github.com/open-draft/msw/issues\
-      `);
-            }
-            context.keepAliveInterval = window.setInterval(() => context.workerChannel.send('KEEPALIVE_REQUEST'), 5000);
-            // Warn the user when loading the page that lies outside
-            // of the worker's scope.
-            validateWorkerScope(registration, context.startOptions);
-            return registration;
-        });
-        const workerRegistration = startWorkerInstance().then((registration) => __awaiter(this, void 0, void 0, function* () {
-            const pendingInstance = registration.installing || registration.waiting;
-            // Wait until the worker is activated.
-            // Assume the worker is already activated if there's no pending registration
-            // (i.e. when reloading the page after a successful activation).
-            if (pendingInstance) {
-                yield new Promise((resolve) => {
-                    pendingInstance.addEventListener('statechange', () => {
-                        if (pendingInstance.state === 'activated') {
-                            return resolve();
-                        }
-                    });
-                });
-            }
-            // Print the activation message only after the worker has been activated.
-            yield enableMocking(context, options).catch((error) => {
-                throw new Error(`Failed to enable mocking: ${error === null || error === void 0 ? void 0 : error.message}`);
-            });
-            return registration;
-        }));
-        // Defer any network requests until the Service Worker instance is ready.
-        // This prevents a race condition between the Service Worker registration
-        // and application's runtime requests (i.e. requests on mount).
-        if (options.waitUntilReady) {
-            deferNetworkRequestsUntil(workerRegistration);
-        }
-        return workerRegistration;
-    };
-};
+// src/setupWorker/setupWorker.ts
+var listeners = [];
+function setupWorker(...requestHandlers) {
+  requestHandlers.forEach((handler) => {
+    if (Array.isArray(handler))
+      throw new Error(devUtils.formatMessage('Failed to call "setupWorker" given an Array of request handlers (setupWorker([a, b])), expected to receive each handler individually: setupWorker(a, b).'));
+  });
+  if (isNodeProcess3()) {
+    throw new Error(devUtils.formatMessage("Failed to execute `setupWorker` in a non-browser environment. Consider using `setupServer` for Node.js environment instead."));
+  }
+  const emitter = new StrictEventEmitter();
+  const publicEmitter = new StrictEventEmitter();
+  pipeEvents(emitter, publicEmitter);
+  const context = {
+    isMockingEnabled: false,
+    startOptions: void 0,
+    worker: null,
+    registration: null,
+    requestHandlers: [...requestHandlers],
+    emitter,
+    workerChannel: {
+      on(eventType, callback) {
+        context.events.addListener(navigator.serviceWorker, "message", (event) => {
+          if (event.source !== context.worker) {
+            return;
+          }
+          const message = jsonParse(event.data);
+          if (!message) {
+            return;
+          }
+          if (message.type === eventType) {
+            callback(event, message);
+          }
+        });
+      },
+      send(type) {
+        var _a;
+        (_a = context.worker) == null ? void 0 : _a.postMessage(type);
+      }
+    },
+    events: {
+      addListener(target, eventType, callback) {
+        target.addEventListener(eventType, callback);
+        listeners.push({ eventType, target, callback });
+        return () => {
+          target.removeEventListener(eventType, callback);
+        };
+      },
+      removeAllListeners() {
+        for (const { target, eventType, callback } of listeners) {
+          target.removeEventListener(eventType, callback);
+        }
+        listeners = [];
+      },
+      once(eventType) {
+        const bindings = [];
+        return new Promise((resolve, reject) => {
+          const handleIncomingMessage = (event) => {
+            try {
+              const message = JSON.parse(event.data);
+              if (message.type === eventType) {
+                resolve(message);
+              }
+            } catch (error2) {
+              reject(error2);
+            }
+          };
+          bindings.push(context.events.addListener(navigator.serviceWorker, "message", handleIncomingMessage), context.events.addListener(navigator.serviceWorker, "messageerror", reject));
+        }).finally(() => {
+          bindings.forEach((unbind) => unbind());
+        });
+      }
+    },
+    useFallbackMode: !("serviceWorker" in navigator) || location.protocol === "file:"
+  };
+  const startHandler = context.useFallbackMode ? createFallbackStart(context) : createStartHandler(context);
+  const stopHandler = context.useFallbackMode ? createFallbackStop(context) : createStop(context);
+  return {
+    start: prepareStartHandler(startHandler, context),
+    stop() {
+      context.events.removeAllListeners();
+      context.emitter.removeAllListeners();
+      publicEmitter.removeAllListeners();
+      stopHandler();
+    },
+    use(...handlers) {
+      use(context.requestHandlers, ...handlers);
+    },
+    restoreHandlers() {
+      restoreHandlers(context.requestHandlers);
+    },
+    resetHandlers(...nextHandlers) {
+      context.requestHandlers = resetHandlers(requestHandlers, ...nextHandlers);
+    },
+    printHandlers() {
+      context.requestHandlers.forEach((handler) => {
+        const { header, callFrame } = handler.info;
+        const pragma = handler.info.hasOwnProperty("operationType") ? "[graphql]" : "[rest]";
+        console.groupCollapsed(`${pragma} ${header}`);
+        if (callFrame) {
+          console.log(`Declaration: ${callFrame}`);
+        }
+        console.log("Handler:", handler);
+        if (handler instanceof RestHandler) {
+          console.log("Match:", `https://mswjs.io/repl?path=${handler.info.path}`);
+        }
+        console.groupEnd();
+      });
+    },
+    events: {
+      on(...args) {
+        return publicEmitter.on(...args);
+      },
+      removeListener(...args) {
+        return publicEmitter.removeListener(...args);
+      },
+      removeAllListeners(...args) {
+        return publicEmitter.removeAllListeners(...args);
+      }
+    }
+  };
+}
 
-function printStopMessage(args = {}) {
-    if (args.quiet) {
-        return;
-    }
-    console.log(`%c${devUtils.formatMessage('Mocking disabled.')}`, 'color:orangered;font-weight:bold;');
-}
-
-const createStop = (context) => {
-    return function stop() {
-        var _a;
-        // Warn developers calling "worker.stop()" more times than necessary.
-        // This likely indicates a mistake in their code.
-        if (!context.isMockingEnabled) {
-            devUtils.warn('Found a redundant "worker.stop()" call. Note that stopping the worker while mocking already stopped has no effect. Consider removing this "worker.stop()" call.');
-            return;
-        }
-        /**
-         * Signal the Service Worker to disable mocking for this client.
-         * Use this an an explicit way to stop the mocking, while preserving
-         * the worker-client relation. Does not affect the worker's lifecycle.
-         */
-        context.workerChannel.send('MOCK_DEACTIVATE');
-        context.isMockingEnabled = false;
-        window.clearInterval(context.keepAliveInterval);
-        printStopMessage({ quiet: (_a = context.startOptions) === null || _a === void 0 ? void 0 : _a.quiet });
-    };
+// src/rest.ts
+init_esm_shims();
+function createRestHandler(method) {
+  return (path, resolver) => {
+    return new RestHandler(method, path, resolver);
+  };
+}
+var rest = {
+  all: createRestHandler(/.+/),
+  head: createRestHandler("HEAD" /* HEAD */),
+  get: createRestHandler("GET" /* GET */),
+  post: createRestHandler("POST" /* POST */),
+  put: createRestHandler("PUT" /* PUT */),
+  delete: createRestHandler("DELETE" /* DELETE */),
+  patch: createRestHandler("PATCH" /* PATCH */),
+  options: createRestHandler("OPTIONS" /* OPTIONS */)
 };
 
-function use(currentHandlers, ...handlers) {
-    currentHandlers.unshift(...handlers);
-}
-function restoreHandlers(handlers) {
-    handlers.forEach((handler) => {
-        handler.markAsSkipped(false);
-    });
-}
-function resetHandlers(initialHandlers, ...nextHandlers) {
-    return nextHandlers.length > 0 ? [...nextHandlers] : [...initialHandlers];
-}
-
-const DEFAULT_START_OPTIONS = {
-    serviceWorker: {
-        url: '/mockServiceWorker.js',
-        options: null,
-    },
-    quiet: false,
-    waitUntilReady: true,
-    onUnhandledRequest: 'warn',
-    findWorker(scriptURL, mockServiceWorkerUrl) {
-        return scriptURL === mockServiceWorkerUrl;
-    },
-};
-/**
- * Returns resolved worker start options, merging the default options
- * with the given custom options.
- */
-function resolveStartOptions(initialOptions) {
-    return mergeRight(DEFAULT_START_OPTIONS, initialOptions || {});
-}
-function prepareStartHandler(handler, context) {
-    return (initialOptions) => {
-        context.startOptions = resolveStartOptions(initialOptions);
-        return handler(context.startOptions, initialOptions || {});
-    };
-}
-
-/**
- * Converts a given isomorphic request to a `MockedRequest` instance.
- */
-function parseIsomorphicRequest(request) {
-    const mockedRequest = {
-        id: request.id,
-        url: request.url,
-        method: request.method,
-        body: parseBody(request.body, request.headers),
-        credentials: request.credentials || 'same-origin',
-        headers: request.headers,
-        cookies: {},
-        redirect: 'manual',
-        referrer: '',
-        keepalive: false,
-        cache: 'default',
-        mode: 'cors',
-        referrerPolicy: 'no-referrer',
-        integrity: '',
-        destination: 'document',
-        bodyUsed: false,
-        passthrough,
-    };
-    // Attach all the cookies from the virtual cookie store.
-    setRequestCookies(mockedRequest);
-    return mockedRequest;
-}
-
-function createFallbackRequestListener(context, options) {
-    const interceptor = createInterceptor({
-        modules: [interceptFetch, interceptXMLHttpRequest],
-        resolver(request) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const mockedRequest = parseIsomorphicRequest(request);
-                return handleRequest(mockedRequest, context.requestHandlers, options, context.emitter, {
-                    transformResponse(response) {
-                        return {
-                            status: response.status,
-                            statusText: response.statusText,
-                            headers: response.headers.all(),
-                            body: response.body,
-                        };
-                    },
-                    onMockedResponseSent(response, { handler, publicRequest, parsedRequest }) {
-                        if (!options.quiet) {
-                            handler.log(publicRequest, response, handler, parsedRequest);
-                        }
-                    },
-                });
-            });
-        },
-    });
-    interceptor.apply();
-    return interceptor;
-}
-
-function createFallbackStart(context) {
-    return function start(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            context.fallbackInterceptor = createFallbackRequestListener(context, options);
-            printStartMessage({
-                message: 'Mocking enabled (fallback mode).',
-                quiet: options.quiet,
-            });
-            return undefined;
-        });
-    };
-}
-
-function createFallbackStop(context) {
-    return function stop() {
-        var _a, _b;
-        (_a = context.fallbackInterceptor) === null || _a === void 0 ? void 0 : _a.restore();
-        printStopMessage({ quiet: (_b = context.startOptions) === null || _b === void 0 ? void 0 : _b.quiet });
-    };
-}
-
-/**
- * Pipes all emitted events from one emitter to another.
- */
-function pipeEvents(source, destination) {
-    const rawEmit = source.emit;
-    // @ts-ignore
-    if (rawEmit._isPiped) {
-        return;
-    }
-    source.emit = function (event, ...data) {
-        destination.emit(event, ...data);
-        return rawEmit.call(this, event, ...data);
-    };
-    // @ts-ignore
-    source.emit._isPiped = true;
-}
-
-// Declare the list of event handlers on the module's scope
-// so it persists between Fash refreshes of the application's code.
-let listeners = [];
-/**
- * Creates a new mock Service Worker registration
- * with the given request handlers.
- * @param {RequestHandler[]} requestHandlers List of request handlers
- * @see {@link https://mswjs.io/docs/api/setup-worker `setupWorker`}
- */
-function setupWorker(...requestHandlers) {
-    requestHandlers.forEach((handler) => {
-        if (Array.isArray(handler))
-            throw new Error(devUtils.formatMessage('Failed to call "setupWorker" given an Array of request handlers (setupWorker([a, b])), expected to receive each handler individually: setupWorker(a, b).'));
-    });
-    // Error when attempting to run this function in a Node.js environment.
-    if (lib$3.exports.isNodeProcess()) {
-        throw new Error(devUtils.formatMessage('Failed to execute `setupWorker` in a non-browser environment. Consider using `setupServer` for Node.js environment instead.'));
-    }
-    const emitter = new lib$1.StrictEventEmitter();
-    const publicEmitter = new lib$1.StrictEventEmitter();
-    pipeEvents(emitter, publicEmitter);
-    const context = {
-        // Mocking is not considered enabled until the worker
-        // signals back the successful activation event.
-        isMockingEnabled: false,
-        startOptions: undefined,
-        worker: null,
-        registration: null,
-        requestHandlers: [...requestHandlers],
-        emitter,
-        workerChannel: {
-            on(eventType, callback) {
-                context.events.addListener(navigator.serviceWorker, 'message', (event) => {
-                    // Avoid messages broadcasted from unrelated workers.
-                    if (event.source !== context.worker) {
-                        return;
-                    }
-                    const message = jsonParse(event.data);
-                    if (!message) {
-                        return;
-                    }
-                    if (message.type === eventType) {
-                        callback(event, message);
-                    }
-                });
-            },
-            send(type) {
-                var _a;
-                (_a = context.worker) === null || _a === void 0 ? void 0 : _a.postMessage(type);
-            },
-        },
-        events: {
-            addListener(target, eventType, callback) {
-                target.addEventListener(eventType, callback);
-                listeners.push({ eventType, target, callback });
-                return () => {
-                    target.removeEventListener(eventType, callback);
-                };
-            },
-            removeAllListeners() {
-                for (const { target, eventType, callback } of listeners) {
-                    target.removeEventListener(eventType, callback);
-                }
-                listeners = [];
-            },
-            once(eventType) {
-                const bindings = [];
-                return new Promise((resolve, reject) => {
-                    const handleIncomingMessage = (event) => {
-                        try {
-                            const message = JSON.parse(event.data);
-                            if (message.type === eventType) {
-                                resolve(message);
-                            }
-                        }
-                        catch (error) {
-                            reject(error);
-                        }
-                    };
-                    bindings.push(context.events.addListener(navigator.serviceWorker, 'message', handleIncomingMessage), context.events.addListener(navigator.serviceWorker, 'messageerror', reject));
-                }).finally(() => {
-                    bindings.forEach((unbind) => unbind());
-                });
-            },
-        },
-        useFallbackMode: !('serviceWorker' in navigator) || location.protocol === 'file:',
-    };
-    const startHandler = context.useFallbackMode
-        ? createFallbackStart(context)
-        : createStartHandler(context);
-    const stopHandler = context.useFallbackMode
-        ? createFallbackStop(context)
-        : createStop(context);
-    return {
-        start: prepareStartHandler(startHandler, context),
-        stop() {
-            context.events.removeAllListeners();
-            context.emitter.removeAllListeners();
-            publicEmitter.removeAllListeners();
-            stopHandler();
-        },
-        use(...handlers) {
-            use(context.requestHandlers, ...handlers);
-        },
-        restoreHandlers() {
-            restoreHandlers(context.requestHandlers);
-        },
-        resetHandlers(...nextHandlers) {
-            context.requestHandlers = resetHandlers(requestHandlers, ...nextHandlers);
-        },
-        printHandlers() {
-            context.requestHandlers.forEach((handler) => {
-                const { header, callFrame } = handler.info;
-                const pragma = handler.info.hasOwnProperty('operationType')
-                    ? '[graphql]'
-                    : '[rest]';
-                console.groupCollapsed(`${pragma} ${header}`);
-                if (callFrame) {
-                    console.log(`Declaration: ${callFrame}`);
-                }
-                console.log('Handler:', handler);
-                if (handler instanceof RestHandler) {
-                    console.log('Match:', `https://mswjs.io/repl?path=${handler.info.path}`);
-                }
-                console.groupEnd();
-            });
-        },
-        events: {
-            on(...args) {
-                return publicEmitter.on(...args);
-            },
-            removeListener(...args) {
-                return publicEmitter.removeListener(...args);
-            },
-            removeAllListeners(...args) {
-                return publicEmitter.removeAllListeners(...args);
-            },
-        },
-    };
-}
-
-export { handleRequest, parseIsomorphicRequest, setupWorker };
+// src/graphql.ts
+init_esm_shims();
+import { OperationTypeNode as OperationTypeNode2 } from "graphql";
+function createScopedGraphQLHandler(operationType, url) {
+  return (operationName, resolver) => {
+    return new GraphQLHandler(operationType, operationName, url, resolver);
+  };
+}
+function createGraphQLOperationHandler(url) {
+  return (resolver) => {
+    return new GraphQLHandler("all", new RegExp(".*"), url, resolver);
+  };
+}
+var standardGraphQLHandlers = {
+  operation: createGraphQLOperationHandler("*"),
+  query: createScopedGraphQLHandler(OperationTypeNode2.QUERY, "*"),
+  mutation: createScopedGraphQLHandler(OperationTypeNode2.MUTATION, "*")
+};
+function createGraphQLLink(url) {
+  return {
+    operation: createGraphQLOperationHandler(url),
+    query: createScopedGraphQLHandler(OperationTypeNode2.QUERY, url),
+    mutation: createScopedGraphQLHandler(OperationTypeNode2.MUTATION, url)
+  };
+}
+var graphql = __spreadProps(__spreadValues({}, standardGraphQLHandlers), {
+  link: createGraphQLLink
+});
+export {
+  GraphQLHandler,
+  RESTMethods,
+  RequestHandler,
+  RestHandler,
+  cleanUrl,
+  compose,
+  context_exports as context,
+  createResponseComposition,
+  defaultContext,
+  defaultResponse,
+  graphql,
+  graphqlContext,
+  handleRequest,
+  matchRequestUrl,
+  parseIsomorphicRequest,
+  response,
+  rest,
+  restContext,
+  setupWorker
+};
+//# sourceMappingURL=index.js.map