msw 0.20.5 → 0.21.3

package/lib/umd/index.js

@@ -88,11 +88,11 @@
 
   function createCommonjsModule(fn, basedir, module) {
   	return module = {
-  	  path: basedir,
-  	  exports: {},
-  	  require: function (path, base) {
-        return commonjsRequire(path, (base === undefined || base === null) ? module.path : base);
-      }
+  		path: basedir,
+  		exports: {},
+  		require: function (path, base) {
+  			return commonjsRequire(path, (base === undefined || base === null) ? module.path : base);
+  		}
   	}, fn(module, module.exports), module.exports;
   }
 
@@ -574,7 +574,7 @@
   /**
    * Sets the body of the response without any `Content-Type` header.
    * @example
-   * res(body('foo'))
+   * res(body('message'))
    */
   const body = (value) => {
       return (res) => {
@@ -596,16 +596,16 @@
 
   /**
    * Returns a boolean indicating if the current process is running in NodeJS environment.
+   * @see https://github.com/mswjs/msw/pull/255
    */
-  // Please see https://github.com/mswjs/msw/pull/255
   function isNodeProcess() {
+      // Check browser environment.
       if (typeof global !== 'object') {
-          // check browser environment
           return false;
       }
+      // Check nodejs or React Native environment.
       if (Object.prototype.toString.call(global.process) === '[object process]' ||
           navigator.product === 'ReactNative') {
-          // check nodejs or react native environment
           return true;
       }
   }
@@ -634,9 +634,11 @@
   };
 
   /**
-   * Sets the given Object as the JSON body of the response.
+   * Sets the given value as the JSON body of the response.
    * @example
-   * res(json({ foo: 'bar' }))
+   * res(json({ key: 'value' }))
+   * res(json('Some string'))
+   * res(json([1, '2', false, { ok: true }]))
    */
   const json = (body) => {
       return (res) => {
@@ -654,20 +656,21 @@
   };
 
   const useFetch = isNodeProcess() ? require('node-fetch') : window.fetch;
-  const gracefully = (promise) => {
-      return promise.then((res) => {
-          var _a;
-          if ((_a = res.headers.get('content-type')) === null || _a === void 0 ? void 0 : _a.includes('json')) {
-              return res.json();
-          }
-          return res.text();
-      });
-  };
   const augmentRequestInit = (requestInit) => {
       const headers = new lib.Headers(requestInit.headers);
       headers.set('x-msw-bypass', 'true');
       return Object.assign(Object.assign({}, requestInit), { headers: headers.getAllHeaders() });
   };
+  const createFetchRequestParameters = (input) => {
+      const { body, method } = input;
+      const requestParameters = Object.assign(Object.assign({}, input), { body: undefined });
+      if (['GET', 'HEAD'].includes(method)) {
+          return requestParameters;
+      }
+      requestParameters.body =
+          typeof body === 'object' ? JSON.stringify(body) : body;
+      return requestParameters;
+  };
   /**
    * Wrapper around the native `window.fetch()` function that performs
    * a request bypassing MSW. Requests performed using
@@ -676,17 +679,17 @@
   const fetch = (input, requestInit = {}) => {
       // Keep the default `window.fetch()` call signature
       if (typeof input === 'string') {
-          return gracefully(useFetch(input, augmentRequestInit(requestInit)));
+          return useFetch(input, augmentRequestInit(requestInit));
       }
-      const { body } = input;
-      const compliantReq = augmentRequestInit(Object.assign(Object.assign({}, input), { body: typeof body === 'object' ? JSON.stringify(body) : body }));
-      return gracefully(useFetch(input.url.href, compliantReq));
+      const requestParameters = createFetchRequestParameters(input);
+      const compliantRequest = augmentRequestInit(requestParameters);
+      return useFetch(input.url.href, compliantRequest);
   };
 
   /**
    * Sets a given text as a "Cotent-Type: text/plain" body of the response.
    * @example
-   * res(text('Message'))
+   * res(text('message'))
    */
   const text = (body) => {
       return (res) => {
@@ -699,7 +702,7 @@
   /**
    * Sets the given XML as the body of the response.
    * @example
-   * res(xml('<message>Foo</message>'))
+   * res(xml('<key>value</key>'))
    */
   const xml = (body) => {
       return (res) => {
@@ -725,18 +728,18 @@
   });
 
   /*! *****************************************************************************
-  Copyright (c) Microsoft Corporation. All rights reserved.
-  Licensed under the Apache License, Version 2.0 (the "License"); you may not use
-  this file except in compliance with the License. You may obtain a copy of the
-  License at http://www.apache.org/licenses/LICENSE-2.0
+  Copyright (c) Microsoft Corporation.
 
-  THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-  KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
-  WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
-  MERCHANTABLITY OR NON-INFRINGEMENT.
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted.
 
-  See the Apache Version 2.0 License for specific language governing permissions
-  and limitations under the License.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+  PERFORMANCE OF THIS SOFTWARE.
   ***************************************************************************** */
 
   function __awaiter(thisArg, _arguments, P, generator) {
@@ -779,7 +782,7 @@
    * Attempts to resolve a Service Worker instance from a given registration,
    * regardless of its state (active, installing, waiting).
    */
-  const getWorkerByRegistration = (registration, absoluteWorkerUrl) => {
+  const getWorkerByRegistration = (registration, absoluteWorkerUrl, findWorker) => {
       const allStates = [
           registration.active,
           registration.installing,
@@ -787,7 +790,7 @@
       ];
       const existingStates = allStates.filter(Boolean);
       const mockWorker = existingStates.find((worker) => {
-          return worker.scriptURL === absoluteWorkerUrl;
+          return findWorker(worker.scriptURL, absoluteWorkerUrl);
       });
       return mockWorker || null;
   };
@@ -804,13 +807,13 @@
    * Returns an active Service Worker instance.
    * When not found, registers a new Service Worker.
    */
-  const getWorkerInstance = (url, options) => __awaiter(void 0, void 0, void 0, function* () {
-      // Resolve the absolute Service Worker URL
+  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 lib$1.until(() => __awaiter(void 0, void 0, void 0, function* () {
           const registrations = yield navigator.serviceWorker.getRegistrations();
           return registrations.filter((registration) => {
-              return getWorkerByRegistration(registration, absoluteWorkerUrl);
+              return getWorkerByRegistration(registration, absoluteWorkerUrl, findWorker);
           });
       }));
       if (!navigator.serviceWorker.controller && mockRegistrations.length > 0) {
@@ -824,23 +827,25 @@
       }
       const [existingRegistration] = mockRegistrations;
       if (existingRegistration) {
-          // Update existing service worker to ensure it's up-to-date
+          // When the Service Worker is registered, update it and return the reference.
           return existingRegistration.update().then(() => {
               return [
-                  getWorkerByRegistration(existingRegistration, absoluteWorkerUrl),
+                  getWorkerByRegistration(existingRegistration, absoluteWorkerUrl, findWorker),
                   existingRegistration,
               ];
           });
       }
+      // When the Service Worker wasn't found, register it anew and return the reference.
       const [error, instance] = yield lib$1.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),
+              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.
@@ -1018,436 +1023,62 @@ Learn more about creating the Service Worker script: https://mswjs.io/docs/cli/i
       };
   });
 
-  function onUnhandledRequest(request, onUnhandledRequest = 'bypass') {
-      if (typeof onUnhandledRequest === 'function') {
-          onUnhandledRequest(request);
-          return;
-      }
-      const message = `captured a ${request.method} ${request.url} request without a corresponding request handler.`;
-      switch (onUnhandledRequest) {
-          case 'error': {
-              throw new Error(`[MSW] Error: ${message}`);
-          }
-          case 'warn': {
-              console.warn(`[MSW] Warning: ${message}`);
-          }
-          default:
-              return;
-      }
-  }
+  var punycode = createCommonjsModule(function (module, exports) {
+  (function(root) {
 
-  /**
-   * Parses a given string into a JSON.
-   * Does not throw an exception on an invalid JSON string.
-   */
-  function jsonParse(str) {
-      try {
-          return JSON.parse(str);
-      }
-      catch (error) {
-          return undefined;
-      }
-  }
+  	/** Detect free variables */
+  	var freeExports =  exports &&
+  		!exports.nodeType && exports;
+  	var freeModule =  module &&
+  		!module.nodeType && module;
+  	var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal;
+  	if (
+  		freeGlobal.global === freeGlobal ||
+  		freeGlobal.window === freeGlobal ||
+  		freeGlobal.self === freeGlobal
+  	) {
+  		root = freeGlobal;
+  	}
 
-  /**
-   * Returns a parsed JSON from a given valid body string,
-   * otherwise returns a given body string as-is.
-   */
-  function getJsonBody(body) {
-      return jsonParse(body) || body;
-  }
+  	/**
+  	 * The `punycode` object.
+  	 * @name punycode
+  	 * @type Object
+  	 */
+  	var punycode,
 
-  function parseRequestBody(body, headers) {
-      var _a;
-      if (body) {
-          // If the intercepted request's body has a JSON Content-Type
-          // parse it into an object, otherwise leave as-is.
-          const hasJsonContent = (_a = headers === null || headers === void 0 ? void 0 : headers.get('content-type')) === null || _a === void 0 ? void 0 : _a.includes('json');
-          if (hasJsonContent && typeof body !== 'object') {
-              return getJsonBody(body);
-          }
-          return body;
-      }
-      // Return whatever falsey body value is given.
-      return body;
-  }
+  	/** Highest positive signed 32-bit float value */
+  	maxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1
 
-  function getAllCookies() {
-      return parse_1(document.cookie);
-  }
-  /**
-   * Returns relevant document cookies based on the request `credentials` option.
-   */
-  function getRequestCookies(req) {
-      switch (req.credentials) {
-          case 'same-origin': {
-              // Return document cookies only when requested a resource
-              // from the same origin as the current document.
-              return location.origin === req.url.origin ? getAllCookies() : {};
-          }
-          case 'include': {
-              // Return all document cookies.
-              return getAllCookies();
-          }
-          default: {
-              return {};
-          }
-      }
-  }
+  	/** Bootstring parameters */
+  	base = 36,
+  	tMin = 1,
+  	tMax = 26,
+  	skew = 38,
+  	damp = 700,
+  	initialBias = 72,
+  	initialN = 128, // 0x80
+  	delimiter = '-', // '\x2D'
 
-  /**
-   * Performs a case-insensitive comparison of two given strings.
-   */
-  function isStringEqual(actual, expected) {
-      return actual.toLowerCase() === expected.toLowerCase();
-  }
+  	/** Regular expressions */
+  	regexPunycode = /^xn--/,
+  	regexNonASCII = /[^\x20-\x7E]/, // unprintable ASCII chars + non-ASCII chars
+  	regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g, // RFC 3490 separators
 
-  const handleRequestWith = (context, options) => {
-      return (event) => __awaiter(void 0, void 0, void 0, function* () {
-          const channel = createBroadcastChannel(event);
-          try {
-              const message = JSON.parse(event.data, function (key, value) {
-                  if (key === 'url') {
-                      return new URL(value);
-                  }
-                  // Serialize headers
-                  if (key === 'headers') {
-                      return new lib.Headers(value);
-                  }
-                  // Prevent empty fields from presering an empty value.
-                  // It's invalid to perform a GET request with { body: "" }
-                  if (
-                  // Check if we are parsing deeper in `event.data.payload`,
-                  // because this custom JSON parser is invoked for each depth level.
-                  this.method &&
-                      isStringEqual(this.method, 'GET') &&
-                      key === 'body' &&
-                      value === '') {
-                      return undefined;
-                  }
-                  return value;
-              });
-              const { type, payload: req } = message;
-              // Ignore irrelevant worker message types
-              if (type !== 'REQUEST') {
-                  return null;
-              }
-              // Parse the request's body based on the "Content-Type" header.
-              req.body = parseRequestBody(req.body, req.headers);
-              // Set document cookies on the request.
-              req.cookies = getRequestCookies(req);
-              const { response, handler, publicRequest, parsedRequest, } = yield getResponse(req, context.requestHandlers);
-              // Handle a scenario when there is no request handler
-              // found for a given request.
-              if (!handler) {
-                  onUnhandledRequest(req, options.onUnhandledRequest);
-                  return channel.send({ type: 'MOCK_NOT_FOUND' });
-              }
-              // Handle a scenario when there is a request handler,
-              // but it doesn't return any mocked response.
-              if (!response) {
-                  console.warn('[MSW] Expected a mocking resolver function to return a mocked response Object, but got: %s. Original response is going to be used instead.', response);
-                  return channel.send({ type: 'MOCK_NOT_FOUND' });
-              }
-              const responseWithSerializedHeaders = Object.assign(Object.assign({}, response), { headers: lib.headersToList(response.headers) });
-              if (!options.quiet) {
-                  setTimeout(() => {
-                      handler.log(publicRequest, responseWithSerializedHeaders, handler, parsedRequest);
-                  }, response.delay);
-              }
-              channel.send({
-                  type: 'MOCK_SUCCESS',
-                  payload: responseWithSerializedHeaders,
-              });
-          }
-          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,
-                      }),
-                  },
-              });
-          }
-      });
-  };
+  	/** Error messages */
+  	errors = {
+  		'overflow': 'Overflow: input needs wider integers to process',
+  		'not-basic': 'Illegal input >= 0x80 (not a basic code point)',
+  		'invalid-input': 'Invalid input'
+  	},
 
-  function requestIntegrityCheck(context, serviceWorker) {
-      return __awaiter(this, void 0, void 0, function* () {
-          // Signal Service Worker to report back its integrity
-          serviceWorker.postMessage('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 webpack upon build.
-          if (actualChecksum !== "ca2c3cd7453d8c614e2c19db63ede1a1") {
-              throw new Error(`Currently active Service Worker (${actualChecksum}) is behind the latest published one (${"ca2c3cd7453d8c614e2c19db63ede1a1"}).`);
-          }
-          return serviceWorker;
-      });
-  }
+  	/** Convenience shortcuts */
+  	baseMinusTMin = base - tMin,
+  	floor = Math.floor,
+  	stringFromCharCode = String.fromCharCode,
 
-  /**
-   * 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 `XMLHttpRequest` until the Service Worker is ready.
-      const originalXhrSend = window.XMLHttpRequest.prototype.send;
-      window.XMLHttpRequest.prototype.send = function (...args) {
-          lib$1.until(() => predicatePromise).then(() => {
-              window.XMLHttpRequest.prototype.send = originalXhrSend;
-              this.send(...args);
-          });
-      };
-      // Defer `fetch` requests until the Service Worker is ready.
-      const originalFetch = window.fetch;
-      window.fetch = (...args) => __awaiter(this, void 0, void 0, function* () {
-          yield lib$1.until(() => predicatePromise);
-          window.fetch = originalFetch;
-          return window.fetch(...args);
-      });
-  }
-
-  const DEFAULT_START_OPTIONS = {
-      serviceWorker: {
-          url: '/mockServiceWorker.js',
-          options: null,
-      },
-      quiet: false,
-      waitUntilReady: true,
-      onUnhandledRequest: 'bypass',
-  };
-  const createStart = (context) => {
-      /**
-       * Registers and activates the mock Service Worker.
-       */
-      return function start(options) {
-          const resolvedOptions = Object.assign({}, DEFAULT_START_OPTIONS, options);
-          const startWorkerInstance = () => __awaiter(this, void 0, void 0, function* () {
-              if (!('serviceWorker' in navigator)) {
-                  console.error(`[MSW] Failed to register a Service Worker: this browser does not support Service Workers (see https://caniuse.com/serviceworkers), or your application is running on an insecure host (consider using HTTPS for custom hostnames).`);
-                  return null;
-              }
-              // Remove all previously existing event listeners.
-              // This way none of the listeners persists between Fast refresh
-              // of the application's code.
-              context.events.removeAllListeners();
-              context.events.addListener(navigator.serviceWorker, 'message', handleRequestWith(context, resolvedOptions));
-              const [, instance] = yield lib$1.until(() => getWorkerInstance(resolvedOptions.serviceWorker.url, resolvedOptions.serviceWorker.options));
-              if (!instance) {
-                  return null;
-              }
-              const [worker, registration] = instance;
-              if (!worker) {
-                  return null;
-              }
-              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.
-                      worker.postMessage('CLIENT_CLOSED');
-                  }
-              });
-              // Check if the active Service Worker is the latest published one
-              const [integrityError] = yield lib$1.until(() => requestIntegrityCheck(context, worker));
-              if (integrityError) {
-                  console.error(`\
-[MSW] Detected outdated Service Worker: ${integrityError.message}
-
-The mocking is still enabled, but it's highly recommended that you update your Service Worker by running:
-
-$ npx msw init <PUBLIC_DIR>
-
-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\
-      `);
-              }
-              // Signal the Service Worker to enable requests interception
-              const [activationError] = yield lib$1.until(() => activateMocking(context, options));
-              if (activationError) {
-                  console.error('Failed to enable mocking', activationError);
-                  return null;
-              }
-              return registration;
-          });
-          const workerRegistration = startWorkerInstance();
-          // 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 (resolvedOptions.waitUntilReady) {
-              deferNetworkRequestsUntil(workerRegistration);
-          }
-          return workerRegistration;
-      };
-  };
-
-  const createStop = (context) => {
-      /**
-       * 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.
-       */
-      return function stop() {
-          var _a;
-          (_a = context.worker) === null || _a === void 0 ? void 0 : _a.postMessage('MOCK_DEACTIVATE');
-          context.events.removeAllListeners();
-      };
-  };
-
-  function use(currentHandlers, ...handlers) {
-      currentHandlers.unshift(...handlers);
-  }
-  function restoreHandlers(handlers) {
-      handlers.forEach((handler) => {
-          if ('shouldSkip' in handler) {
-              handler.shouldSkip = false;
-          }
-      });
-  }
-  function resetHandlers(initialHandlers, ...nextHandlers) {
-      return nextHandlers.length > 0 ? [...nextHandlers] : [...initialHandlers];
-  }
-
-  // Declare the list of event handlers on the module's scope
-  // so it persists between Fash refreshes of the application's code.
-  let listeners = [];
-  function setupWorker(...requestHandlers) {
-      const context = {
-          worker: null,
-          registration: null,
-          requestHandlers: [...requestHandlers],
-          events: {
-              addListener(target, event, callback) {
-                  target.addEventListener(event, callback);
-                  listeners.push({ event, target, callback });
-                  return () => {
-                      target.removeEventListener(event, callback);
-                  };
-              },
-              removeAllListeners() {
-                  for (const { target, event, callback } of listeners) {
-                      target.removeEventListener(event, callback);
-                  }
-                  listeners = [];
-              },
-              once(type) {
-                  const bindings = [];
-                  return new Promise((resolve, reject) => {
-                      const handleIncomingMessage = (event) => {
-                          try {
-                              const message = JSON.parse(event.data);
-                              if (message.type === type) {
-                                  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());
-                  });
-              },
-          },
-      };
-      // Error when attempting to run this function in a NodeJS environment.
-      if (isNodeProcess()) {
-          throw new Error('[MSW] Failed to execute `setupWorker` in a non-browser environment. Consider using `setupServer` for NodeJS environment instead.');
-      }
-      return {
-          start: createStart(context),
-          stop: createStop(context),
-          use(...handlers) {
-              use(context.requestHandlers, ...handlers);
-          },
-          restoreHandlers() {
-              restoreHandlers(context.requestHandlers);
-          },
-          resetHandlers(...nextHandlers) {
-              context.requestHandlers = resetHandlers(requestHandlers, ...nextHandlers);
-          },
-      };
-  }
-
-  var punycode = createCommonjsModule(function (module, exports) {
-  (function(root) {
-
-  	/** Detect free variables */
-  	var freeExports =  exports &&
-  		!exports.nodeType && exports;
-  	var freeModule =  module &&
-  		!module.nodeType && module;
-  	var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal;
-  	if (
-  		freeGlobal.global === freeGlobal ||
-  		freeGlobal.window === freeGlobal ||
-  		freeGlobal.self === freeGlobal
-  	) {
-  		root = freeGlobal;
-  	}
-
-  	/**
-  	 * The `punycode` object.
-  	 * @name punycode
-  	 * @type Object
-  	 */
-  	var punycode,
-
-  	/** Highest positive signed 32-bit float value */
-  	maxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1
-
-  	/** Bootstring parameters */
-  	base = 36,
-  	tMin = 1,
-  	tMax = 26,
-  	skew = 38,
-  	damp = 700,
-  	initialBias = 72,
-  	initialN = 128, // 0x80
-  	delimiter = '-', // '\x2D'
-
-  	/** Regular expressions */
-  	regexPunycode = /^xn--/,
-  	regexNonASCII = /[^\x20-\x7E]/, // unprintable ASCII chars + non-ASCII chars
-  	regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g, // RFC 3490 separators
-
-  	/** Error messages */
-  	errors = {
-  		'overflow': 'Overflow: input needs wider integers to process',
-  		'not-basic': 'Illegal input >= 0x80 (not a basic code point)',
-  		'invalid-input': 'Invalid input'
-  	},
-
-  	/** Convenience shortcuts */
-  	baseMinusTMin = base - tMin,
-  	floor = Math.floor,
-  	stringFromCharCode = String.fromCharCode,
-
-  	/** Temporary variable */
-  	key;
+  	/** Temporary variable */
+  	key;
 
   	/*--------------------------------------------------------------------------*/
 
@@ -2674,65 +2305,507 @@ If this message still persists after updating, please report an issue: https://g
       srcPath.unshift('');
     }
 
-    if (hasTrailingSlash && (srcPath.join('/').substr(-1) !== '/')) {
-      srcPath.push('');
-    }
+    if (hasTrailingSlash && (srcPath.join('/').substr(-1) !== '/')) {
+      srcPath.push('');
+    }
+
+    var isAbsolute = srcPath[0] === '' ||
+        (srcPath[0] && srcPath[0].charAt(0) === '/');
+
+    // put the host back
+    if (psychotic) {
+      result.hostname = result.host = isAbsolute ? '' :
+                                      srcPath.length ? srcPath.shift() : '';
+      //occationaly the auth can get stuck only in host
+      //this especially happens in cases like
+      //url.resolveObject('mailto:local1@domain1', 'local2@domain2')
+      var authInHost = result.host && result.host.indexOf('@') > 0 ?
+                       result.host.split('@') : false;
+      if (authInHost) {
+        result.auth = authInHost.shift();
+        result.host = result.hostname = authInHost.shift();
+      }
+    }
+
+    mustEndAbs = mustEndAbs || (result.host && srcPath.length);
+
+    if (mustEndAbs && !isAbsolute) {
+      srcPath.unshift('');
+    }
+
+    if (!srcPath.length) {
+      result.pathname = null;
+      result.path = null;
+    } else {
+      result.pathname = srcPath.join('/');
+    }
+
+    //to support request.http
+    if (!util.isNull(result.pathname) || !util.isNull(result.search)) {
+      result.path = (result.pathname ? result.pathname : '') +
+                    (result.search ? result.search : '');
+    }
+    result.auth = relative.auth || result.auth;
+    result.slashes = result.slashes || relative.slashes;
+    result.href = result.format();
+    return result;
+  };
+
+  Url.prototype.parseHost = function() {
+    var host = this.host;
+    var port = portPattern.exec(host);
+    if (port) {
+      port = port[0];
+      if (port !== ':') {
+        this.port = port.substr(1);
+      }
+      host = host.substr(0, host.length - port.length);
+    }
+    if (host) this.hostname = host;
+  };
+
+  /**
+   * Returns a relative URL if the given request URL is relative to the current origin.
+   * Otherwise returns an absolute URL.
+   */
+  const getPublicUrlFromRequest = (request) => {
+      return request.referrer.startsWith(request.url.origin)
+          ? request.url.pathname
+          : format({
+              protocol: request.url.protocol,
+              host: request.url.host,
+              pathname: request.url.pathname,
+          });
+  };
+
+  function onUnhandledRequest(request, onUnhandledRequest = 'bypass') {
+      if (typeof onUnhandledRequest === 'function') {
+          onUnhandledRequest(request);
+          return;
+      }
+      const publicUrl = getPublicUrlFromRequest(request);
+      const message = `captured a ${request.method} ${request.url} request without a corresponding request handler.
+
+  If you wish to intercept this request, consider creating a request handler for it:
+
+  rest.${request.method.toLowerCase()}('${publicUrl}', (req, res, ctx) => {
+    return res(ctx.text('body'))
+  })`;
+      switch (onUnhandledRequest) {
+          case 'error': {
+              throw new Error(`[MSW] Error: ${message}`);
+          }
+          case 'warn': {
+              console.warn(`[MSW] Warning: ${message}`);
+          }
+          default:
+              return;
+      }
+  }
+
+  /**
+   * Parses a given string into a JSON.
+   * Does not throw an exception on an invalid JSON string.
+   */
+  function jsonParse(str) {
+      try {
+          return JSON.parse(str);
+      }
+      catch (error) {
+          return undefined;
+      }
+  }
+
+  /**
+   * Parses a given request/response body based on the `Content-Type` header.
+   */
+  function parseBody(body, headers) {
+      var _a;
+      if (body) {
+          // If the intercepted request's body has a JSON Content-Type
+          // parse it into an object, otherwise leave as-is.
+          const hasJsonContent = (_a = headers === null || headers === void 0 ? void 0 : headers.get('content-type')) === null || _a === void 0 ? void 0 : _a.includes('json');
+          if (hasJsonContent && typeof body !== 'object') {
+              return jsonParse(body) || body;
+          }
+          return body;
+      }
+      // Return whatever falsey body value is given.
+      return body;
+  }
+
+  function getAllCookies() {
+      return parse_1(document.cookie);
+  }
+  /**
+   * Returns relevant document cookies based on the request `credentials` option.
+   */
+  function getRequestCookies(req) {
+      switch (req.credentials) {
+          case 'same-origin': {
+              // Return document cookies only when requested a resource
+              // from the same origin as the current document.
+              return location.origin === req.url.origin ? getAllCookies() : {};
+          }
+          case 'include': {
+              // Return all document cookies.
+              return getAllCookies();
+          }
+          default: {
+              return {};
+          }
+      }
+  }
+
+  /**
+   * Performs a case-insensitive comparison of two given strings.
+   */
+  function isStringEqual(actual, expected) {
+      return actual.toLowerCase() === expected.toLowerCase();
+  }
+
+  const handleRequestWith = (context, options) => {
+      return (event) => __awaiter(void 0, void 0, void 0, function* () {
+          const channel = createBroadcastChannel(event);
+          try {
+              const message = JSON.parse(event.data, function (key, value) {
+                  if (key === 'url') {
+                      return new URL(value);
+                  }
+                  // Serialize headers
+                  if (key === 'headers') {
+                      return new lib.Headers(value);
+                  }
+                  // Prevent empty fields from presering an empty value.
+                  // It's invalid to perform a GET request with { body: "" }
+                  if (
+                  // Check if we are parsing deeper in `event.data.payload`,
+                  // because this custom JSON parser is invoked for each depth level.
+                  this.method &&
+                      isStringEqual(this.method, 'GET') &&
+                      key === 'body' &&
+                      value === '') {
+                      return undefined;
+                  }
+                  return value;
+              });
+              const { type, payload: req } = message;
+              // Ignore irrelevant worker message types
+              if (type !== 'REQUEST') {
+                  return null;
+              }
+              // Parse the request's body based on the "Content-Type" header.
+              req.body = parseBody(req.body, req.headers);
+              // Set document cookies on the request.
+              req.cookies = getRequestCookies(req);
+              const { response, handler, publicRequest, parsedRequest, } = yield getResponse(req, context.requestHandlers);
+              // Handle a scenario when there is no request handler
+              // found for a given request.
+              if (!handler) {
+                  onUnhandledRequest(req, options.onUnhandledRequest);
+                  return channel.send({ type: 'MOCK_NOT_FOUND' });
+              }
+              // Handle a scenario when there is a request handler,
+              // but it doesn't return any mocked response.
+              if (!response) {
+                  console.warn('[MSW] Expected a mocking resolver function to return a mocked response Object, but got: %s. Original response is going to be used instead.', response);
+                  return channel.send({ type: 'MOCK_NOT_FOUND' });
+              }
+              const responseWithSerializedHeaders = Object.assign(Object.assign({}, response), { headers: lib.headersToList(response.headers) });
+              if (!options.quiet) {
+                  setTimeout(() => {
+                      handler.log(publicRequest, responseWithSerializedHeaders, handler, parsedRequest);
+                  }, response.delay);
+              }
+              channel.send({
+                  type: 'MOCK_SUCCESS',
+                  payload: responseWithSerializedHeaders,
+              });
+          }
+          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
+          serviceWorker.postMessage('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 webpack upon build.
+          if (actualChecksum !== "d1e0e502f550d40a34bee90822e4bf98") {
+              throw new Error(`Currently active Service Worker (${actualChecksum}) is behind the latest published one (${"d1e0e502f550d40a34bee90822e4bf98"}).`);
+          }
+          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.
+          lib$1.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 lib$1.until(() => predicatePromise);
+          window.fetch = originalFetch;
+          return window.fetch(...args);
+      });
+  }
+
+  function isObject(obj) {
+      return typeof obj === 'object';
+  }
+  /**
+   * Deeply merges two given objects with the right one
+   * having a priority during property assignment.
+   */
+  function mergeRight(a, b) {
+      const result = Object.assign({}, a);
+      Object.entries(b).forEach(([key, value]) => {
+          const existingValue = result[key];
+          if (Array.isArray(existingValue) && Array.isArray(value)) {
+              result[key] = existingValue.concat(value);
+              return;
+          }
+          if (isObject(existingValue) && isObject(value)) {
+              result[key] = mergeRight(existingValue, value);
+              return;
+          }
+          result[key] = value;
+      });
+      return result;
+  }
+
+  const DEFAULT_START_OPTIONS = {
+      serviceWorker: {
+          url: '/mockServiceWorker.js',
+          options: null,
+      },
+      quiet: false,
+      waitUntilReady: true,
+      onUnhandledRequest: 'bypass',
+      findWorker: (scriptURL, mockServiceWorkerUrl) => scriptURL === mockServiceWorkerUrl,
+  };
+  const createStart = (context) => {
+      /**
+       * Registers and activates the mock Service Worker.
+       */
+      return function start(options) {
+          const resolvedOptions = mergeRight(DEFAULT_START_OPTIONS, options || {});
+          const startWorkerInstance = () => __awaiter(this, void 0, void 0, function* () {
+              if (!('serviceWorker' in navigator)) {
+                  console.error(`[MSW] Failed to register a Service Worker: this browser does not support Service Workers (see https://caniuse.com/serviceworkers), or your application is running on an insecure host (consider using HTTPS for custom hostnames).`);
+                  return null;
+              }
+              // Remove all previously existing event listeners.
+              // This way none of the listeners persists between Fast refresh
+              // of the application's code.
+              context.events.removeAllListeners();
+              context.events.addListener(navigator.serviceWorker, 'message', handleRequestWith(context, resolvedOptions));
+              const [, instance] = yield lib$1.until(() => getWorkerInstance(resolvedOptions.serviceWorker.url, resolvedOptions.serviceWorker.options, resolvedOptions.findWorker));
+              if (!instance) {
+                  return null;
+              }
+              const [worker, registration] = instance;
+              if (!worker) {
+                  if (options === null || options === void 0 ? void 0 : options.findWorker) {
+                      console.error(`\
+[MSW] Failed to locate the Service Worker registration using a custom "findWorker" predicate.
 
-    var isAbsolute = srcPath[0] === '' ||
-        (srcPath[0] && srcPath[0].charAt(0) === '/');
+Please ensure that the custom predicate properly locates the Service Worker registration at "${resolvedOptions.serviceWorker.url}".
+More details: https://mswjs.io/docs/api/setup-worker/start#findworker
+`);
+                  }
+                  else {
+                      console.error(`\
+[MSW] Failed to locate the Service Worker registration.
 
-    // put the host back
-    if (psychotic) {
-      result.hostname = result.host = isAbsolute ? '' :
-                                      srcPath.length ? srcPath.shift() : '';
-      //occationaly the auth can get stuck only in host
-      //this especially happens in cases like
-      //url.resolveObject('mailto:local1@domain1', 'local2@domain2')
-      var authInHost = result.host && result.host.indexOf('@') > 0 ?
-                       result.host.split('@') : false;
-      if (authInHost) {
-        result.auth = authInHost.shift();
-        result.host = result.hostname = authInHost.shift();
-      }
-    }
+This most likely means that the worker script URL "${resolvedOptions.serviceWorker.url}" cannot resolve against the actual public hostname (${location.host}). This may happen if your application runs behind a proxy, or has a dynamic hostname.
 
-    mustEndAbs = mustEndAbs || (result.host && srcPath.length);
+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`);
+                  }
+                  return null;
+              }
+              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.
+                      worker.postMessage('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 lib$1.until(() => requestIntegrityCheck(context, worker));
+              if (integrityError) {
+                  console.error(`\
+[MSW] Detected outdated Service Worker: ${integrityError.message}
 
-    if (mustEndAbs && !isAbsolute) {
-      srcPath.unshift('');
-    }
+The mocking is still enabled, but it's highly recommended that you update your Service Worker by running:
 
-    if (!srcPath.length) {
-      result.pathname = null;
-      result.path = null;
-    } else {
-      result.pathname = srcPath.join('/');
-    }
+$ npx msw init <PUBLIC_DIR>
 
-    //to support request.http
-    if (!util.isNull(result.pathname) || !util.isNull(result.search)) {
-      result.path = (result.pathname ? result.pathname : '') +
-                    (result.search ? result.search : '');
-    }
-    result.auth = relative.auth || result.auth;
-    result.slashes = result.slashes || relative.slashes;
-    result.href = result.format();
-    return result;
+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\
+      `);
+              }
+              // Signal the Service Worker to enable requests interception
+              const [activationError] = yield lib$1.until(() => activateMocking(context, options));
+              if (activationError) {
+                  console.error('Failed to enable mocking', activationError);
+                  return null;
+              }
+              context.keepAliveInterval = window.setInterval(() => worker.postMessage('KEEPALIVE_REQUEST'), 5000);
+              return registration;
+          });
+          const workerRegistration = startWorkerInstance();
+          // 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 (resolvedOptions.waitUntilReady) {
+              deferNetworkRequestsUntil(workerRegistration);
+          }
+          return workerRegistration;
+      };
   };
 
-  Url.prototype.parseHost = function() {
-    var host = this.host;
-    var port = portPattern.exec(host);
-    if (port) {
-      port = port[0];
-      if (port !== ':') {
-        this.port = port.substr(1);
-      }
-      host = host.substr(0, host.length - port.length);
-    }
-    if (host) this.hostname = host;
+  const createStop = (context) => {
+      /**
+       * 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.
+       */
+      return function stop() {
+          var _a;
+          (_a = context.worker) === null || _a === void 0 ? void 0 : _a.postMessage('MOCK_DEACTIVATE');
+          context.events.removeAllListeners();
+          window.clearInterval(context.keepAliveInterval);
+      };
   };
 
+  function use(currentHandlers, ...handlers) {
+      currentHandlers.unshift(...handlers);
+  }
+  function restoreHandlers(handlers) {
+      handlers.forEach((handler) => {
+          if ('shouldSkip' in handler) {
+              handler.shouldSkip = false;
+          }
+      });
+  }
+  function resetHandlers(initialHandlers, ...nextHandlers) {
+      return nextHandlers.length > 0 ? [...nextHandlers] : [...initialHandlers];
+  }
+
+  // Declare the list of event handlers on the module's scope
+  // so it persists between Fash refreshes of the application's code.
+  let listeners = [];
+  function setupWorker(...requestHandlers) {
+      requestHandlers.forEach((handler) => {
+          if (Array.isArray(handler))
+              throw new Error(`[MSW] Failed to call "setupWorker" given an Array of request handlers (setupWorker([a, b])), expected to receive each handler individually: setupWorker(a, b).`);
+      });
+      const context = {
+          worker: null,
+          registration: null,
+          requestHandlers: [...requestHandlers],
+          events: {
+              addListener(target, event, callback) {
+                  target.addEventListener(event, callback);
+                  listeners.push({ event, target, callback });
+                  return () => {
+                      target.removeEventListener(event, callback);
+                  };
+              },
+              removeAllListeners() {
+                  for (const { target, event, callback } of listeners) {
+                      target.removeEventListener(event, callback);
+                  }
+                  listeners = [];
+              },
+              once(type) {
+                  const bindings = [];
+                  return new Promise((resolve, reject) => {
+                      const handleIncomingMessage = (event) => {
+                          try {
+                              const message = JSON.parse(event.data);
+                              if (message.type === type) {
+                                  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());
+                  });
+              },
+          },
+      };
+      // Error when attempting to run this function in a NodeJS environment.
+      if (isNodeProcess()) {
+          throw new Error('[MSW] Failed to execute `setupWorker` in a non-browser environment. Consider using `setupServer` for NodeJS environment instead.');
+      }
+      return {
+          start: createStart(context),
+          stop: createStop(context),
+          use(...handlers) {
+              use(context.requestHandlers, ...handlers);
+          },
+          restoreHandlers() {
+              restoreHandlers(context.requestHandlers);
+          },
+          resetHandlers(...nextHandlers) {
+              context.requestHandlers = resetHandlers(requestHandlers, ...nextHandlers);
+          },
+      };
+  }
+
   /**
    * Formats a mocked request for introspection in browser's console.
    */
@@ -2744,12 +2817,10 @@ If this message still persists after updating, please report an issue: https://g
    * Formats a mocked response for introspection in browser's console.
    */
   function prepareResponse(res) {
-      var _a;
-      const resHeaders = lib.listToHeaders(res.headers);
+      const responseHeaders = lib.listToHeaders(res.headers);
       return Object.assign(Object.assign({}, res), { 
           // Parse a response JSON body for preview in the logs
-          body: ((_a = resHeaders.get('content-type')) === null || _a === void 0 ? void 0 : _a.includes('json')) ? getJsonBody(res.body)
-              : res.body });
+          body: parseBody(res.body, responseHeaders) });
   }
 
   function getTimestamp() {
@@ -2826,10 +2897,10 @@ If this message still persists after updating, please report an issue: https://g
   });
 
   /**
-   * Resolves a relative URL to the absolute URL with the same hostname.
+   * Returns an absolute URL based on the given relative URL, if possible.
    * Ignores regular expressions.
    */
-  const resolveRelativeUrl = (mask) => {
+  const getAbsoluteUrl = (mask) => {
       // Global `location` object doesn't exist in Node.
       // Relative request predicate URL cannot become absolute.
       const hasLocation = typeof location !== 'undefined';
@@ -2840,17 +2911,21 @@ If this message still persists after updating, please report an issue: https://g
 
   /**
    * Converts a given request handler mask into a URL, if given a valid URL string.
-   * Otherwise, returns the mask as-is.
    */
-  function resolveMask(mask) {
-      if (mask instanceof RegExp) {
+  function getUrlByMask(mask) {
+      /**
+       * If a string mask contains an asterisk (wildcard), return it as-is.
+       * Converting a URL-like path string into an actual URL is misleading.
+       * @see https://github.com/mswjs/msw/issues/357
+       */
+      if (mask instanceof RegExp || mask.includes('*')) {
           return mask;
       }
       try {
           // Attempt to create a URL instance out of the mask string.
           // Resolve mask to an absolute URL, because even a valid relative URL
           // cannot be converted into the URL instance (required absolute URL only).
-          return new URL(resolveRelativeUrl(mask));
+          return new URL(getAbsoluteUrl(mask));
       }
       catch (error) {
           // Otherwise, the mask is a path string.
@@ -2863,7 +2938,7 @@ If this message still persists after updating, please report an issue: https://g
           ? getCleanUrl_1.getCleanUrl(resolvedMask)
           : resolvedMask instanceof RegExp
               ? resolvedMask
-              : resolveRelativeUrl(resolvedMask);
+              : getAbsoluteUrl(resolvedMask);
   }
 
   /**
@@ -2871,13 +2946,14 @@ If this message still persists after updating, please report an issue: https://g
    * against a mask.
    */
   function matchRequestUrl(url, mask) {
-      const resolvedMask = resolveMask(mask);
+      const resolvedMask = getUrlByMask(mask);
       const cleanMask = getCleanMask(resolvedMask);
       const cleanRequestUrl = getCleanUrl_1.getCleanUrl(url);
       return match(cleanMask, cleanRequestUrl);
   }
 
   (function (RESTMethods) {
+      RESTMethods["HEAD"] = "HEAD";
       RESTMethods["GET"] = "GET";
       RESTMethods["POST"] = "POST";
       RESTMethods["PUT"] = "PUT";
@@ -2898,7 +2974,7 @@ If this message still persists after updating, please report an issue: https://g
   };
   const createRestHandler = (method) => {
       return (mask, resolver) => {
-          const resolvedMask = resolveMask(mask);
+          const resolvedMask = getUrlByMask(mask);
           return {
               parse(req) {
                   // Match the request during parsing to prevent matching it twice
@@ -2937,14 +3013,7 @@ ${queryParams
 })\
 `);
                   }
-                  const isRelativeRequest = req.referrer.startsWith(req.url.origin);
-                  const publicUrl = isRelativeRequest
-                      ? req.url.pathname
-                      : format({
-                          protocol: req.url.protocol,
-                          host: req.url.host,
-                          pathname: req.url.pathname,
-                      });
+                  const publicUrl = getPublicUrlFromRequest(req);
                   const loggedRequest = prepareRequest(req);
                   const loggedResponse = prepareResponse(res);
                   console.groupCollapsed('[MSW] %s %s %s (%c%s%c)', getTimestamp(), req.method, publicUrl, `color:${getStatusCodeColor(res.status)}`, res.status, 'color:inherit');
@@ -2960,6 +3029,7 @@ ${queryParams
       };
   };
   const rest = {
+      head: createRestHandler(exports.RESTMethods.HEAD),
       get: createRestHandler(exports.RESTMethods.GET),
       post: createRestHandler(exports.RESTMethods.POST),
       put: createRestHandler(exports.RESTMethods.PUT),
@@ -5975,96 +6045,109 @@ ${queryParams
   function parseQuery(query, definitionOperation = 'query') {
       var _a;
       const ast = parse$1(query);
-      const operationDef = ast.definitions.find((def) => def.kind === 'OperationDefinition' &&
-          def.operation === definitionOperation);
+      const operationDef = ast.definitions.find((def) => {
+          return (def.kind === 'OperationDefinition' &&
+              (definitionOperation === 'all' || def.operation === definitionOperation));
+      });
       return {
+          operationType: operationDef === null || operationDef === void 0 ? void 0 : operationDef.operation,
           operationName: (_a = operationDef === null || operationDef === void 0 ? void 0 : operationDef.name) === null || _a === void 0 ? void 0 : _a.value,
       };
   }
-  const createGraphQLHandler = (operationType, mask) => {
-      return (expectedOperation, resolver) => {
-          return {
-              resolver,
-              parse(req) {
-                  var _a;
-                  // According to the GraphQL specification, a GraphQL request can be issued
-                  // using both "GET" and "POST" methods.
-                  switch (req.method) {
-                      case 'GET': {
-                          const query = req.url.searchParams.get('query');
-                          const variablesString = req.url.searchParams.get('variables') || '';
-                          if (!query) {
-                              return null;
-                          }
-                          const variables = variablesString
-                              ? jsonParse(variablesString)
-                              : {};
-                          const { operationName } = parseQuery(query, operationType);
-                          return {
-                              operationType,
-                              operationName,
-                              variables,
-                          };
-                      }
-                      case 'POST': {
-                          if (!((_a = req.body) === null || _a === void 0 ? void 0 : _a.query)) {
-                              return null;
-                          }
-                          const { query, variables } = req.body;
-                          const { operationName } = parseQuery(query, operationType);
-                          return {
-                              operationType,
-                              operationName,
-                              variables,
-                          };
-                      }
-                      default:
+  function graphQLRequestHandler(expectedOperationType, expectedOperationName, mask, resolver) {
+      return {
+          resolver,
+          parse(req) {
+              var _a;
+              // According to the GraphQL specification, a GraphQL request can be issued
+              // using both "GET" and "POST" methods.
+              switch (req.method) {
+                  case 'GET': {
+                      const query = req.url.searchParams.get('query');
+                      const variablesString = req.url.searchParams.get('variables') || '';
+                      if (!query) {
                           return null;
+                      }
+                      const variables = variablesString
+                          ? jsonParse(variablesString)
+                          : {};
+                      const { operationType, operationName } = parseQuery(query, expectedOperationType);
+                      return {
+                          operationType,
+                          operationName,
+                          variables,
+                      };
                   }
-              },
-              getPublicRequest(req, parsed) {
-                  return Object.assign(Object.assign({}, req), { variables: parsed.variables || {} });
-              },
-              predicate(req, parsed) {
-                  if (!parsed || !parsed.operationName) {
-                      return false;
+                  case 'POST': {
+                      if (!((_a = req.body) === null || _a === void 0 ? void 0 : _a.query)) {
+                          return null;
+                      }
+                      const { query, variables } = req.body;
+                      const { operationType, operationName } = parseQuery(query, expectedOperationType);
+                      return {
+                          operationType,
+                          operationName,
+                          variables,
+                      };
                   }
-                  // Match the request URL against a given mask,
-                  // in case of an endpoint-specific request handler.
-                  const hasMatchingMask = matchRequestUrl(req.url, mask);
-                  const isMatchingOperation = expectedOperation instanceof RegExp
-                      ? expectedOperation.test(parsed.operationName)
-                      : expectedOperation === parsed.operationName;
-                  return isMatchingOperation && hasMatchingMask.matches;
-              },
-              defineContext() {
-                  return graphqlContext;
-              },
-              log(req, res, handler, parsed) {
-                  const { operationName } = parsed;
-                  const loggedRequest = prepareRequest(req);
-                  const loggedResponse = prepareResponse(res);
-                  console.groupCollapsed('[MSW] %s %s (%c%s%c)', getTimestamp(), operationName, `color:${getStatusCodeColor(res.status)}`, res.status, 'color:inherit');
-                  console.log('Request:', loggedRequest);
-                  console.log('Handler:', {
-                      operationType,
-                      operationName: expectedOperation,
-                      predicate: handler.predicate,
-                  });
-                  console.log('Response:', loggedResponse);
-                  console.groupEnd();
-              },
-          };
+                  default:
+                      return null;
+              }
+          },
+          getPublicRequest(req, parsed) {
+              return Object.assign(Object.assign({}, req), { variables: parsed.variables || {} });
+          },
+          predicate(req, parsed) {
+              if (!parsed || !parsed.operationName) {
+                  return false;
+              }
+              // Match the request URL against a given mask,
+              // in case of an endpoint-specific request handler.
+              const hasMatchingMask = matchRequestUrl(req.url, mask);
+              const isMatchingOperation = expectedOperationName instanceof RegExp
+                  ? expectedOperationName.test(parsed.operationName)
+                  : expectedOperationName === parsed.operationName;
+              return hasMatchingMask.matches && isMatchingOperation;
+          },
+          defineContext() {
+              return graphqlContext;
+          },
+          log(req, res, handler, parsed) {
+              const { operationType, operationName } = parsed;
+              const loggedRequest = prepareRequest(req);
+              const loggedResponse = prepareResponse(res);
+              console.groupCollapsed('[MSW] %s %s (%c%s%c)', getTimestamp(), operationName, `color:${getStatusCodeColor(res.status)}`, res.status, 'color:inherit');
+              console.log('Request:', loggedRequest);
+              console.log('Handler:', {
+                  operationType,
+                  operationName: expectedOperationName,
+                  predicate: handler.predicate,
+              });
+              console.log('Response:', loggedResponse);
+              console.groupEnd();
+          },
+      };
+  }
+  const createGraphQLScopedHandler = (expectedOperationType, mask) => {
+      return (expectedOperationName, resolver) => {
+          return graphQLRequestHandler(expectedOperationType, expectedOperationName, mask, resolver);
+      };
+  };
+  const createGraphQLOperationHandler = (mask) => {
+      return (resolver) => {
+          return graphQLRequestHandler('all', new RegExp('.*'), mask, resolver);
       };
   };
   const graphqlStandardHandlers = {
-      query: createGraphQLHandler('query', '*'),
-      mutation: createGraphQLHandler('mutation', '*'),
+      operation: createGraphQLOperationHandler('*'),
+      query: createGraphQLScopedHandler('query', '*'),
+      mutation: createGraphQLScopedHandler('mutation', '*'),
   };
   function createGraphQLLink(uri) {
       return {
-          query: createGraphQLHandler('query', uri),
-          mutation: createGraphQLHandler('mutation', uri),
+          operation: createGraphQLOperationHandler(uri),
+          query: createGraphQLScopedHandler('query', uri),
+          mutation: createGraphQLScopedHandler('mutation', uri),
       };
   }
   const graphql = Object.assign(Object.assign({}, graphqlStandardHandlers), { link: createGraphQLLink });