msw 0.35.0 → 0.36.0

package/lib/umd/index.js

@@ -2,7 +2,7 @@
   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
   typeof define === 'function' && define.amd ? define(['exports'], factory) :
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.MockServiceWorker = {}));
-}(this, (function (exports) { 'use strict';
+})(this, (function (exports) { 'use strict';
 
   var statuses = {
   	"100": "Continue",
@@ -652,7 +652,7 @@
    * @public
    */
 
-  var parse_1 = parse$4;
+  var parse_1 = parse$5;
   var serialize_1 = serialize;
 
   /**
@@ -686,7 +686,7 @@
    * @public
    */
 
-  function parse$4(str, options) {
+  function parse$5(str, options) {
     if (typeof str !== 'string') {
       throw new TypeError('argument str must be a string');
     }
@@ -871,12 +871,12 @@
   };
 
   /**
-   * Parses a given string into a JSON.
+   * Parses a given value into a JSON.
    * Does not throw an exception on an invalid JSON string.
    */
-  function jsonParse(str) {
+  function jsonParse(value) {
       try {
-          return JSON.parse(str);
+          return JSON.parse(value);
       }
       catch (error) {
           return undefined;
@@ -942,6 +942,20 @@
       };
   };
 
+  /**
+   * Sets the GraphQL extensions on a given response.
+   * @example
+   * res(ctx.extensions({ tracing: { version: 1 }}))
+   * @see {@link https://mswjs.io/docs/api/context/extensions `ctx.extensions()`}
+   */
+  const extensions = (payload) => {
+      return (res) => {
+          const prevBody = jsonParse(res.body) || {};
+          const nextBody = mergeRight(prevBody, { extensions: payload });
+          return json(nextBody)(res);
+      };
+  };
+
   var lib$5 = {exports: {}};
 
   (function (module, exports) {
@@ -1051,8 +1065,12 @@
       if (['GET', 'HEAD'].includes(method)) {
           return requestParameters;
       }
-      requestParameters.body =
-          typeof body === 'object' ? JSON.stringify(body) : body;
+      if (typeof body === 'object' || typeof body === 'number') {
+          requestParameters.body = JSON.stringify(body);
+      }
+      else {
+          requestParameters.body = body;
+      }
       return requestParameters;
   };
   /**
@@ -1106,6 +1124,7 @@
     cookie: cookie,
     body: body,
     data: data,
+    extensions: extensions,
     delay: delay,
     errors: errors,
     fetch: fetch$1,
@@ -2086,7 +2105,7 @@ Learn more about creating the Service Worker script: https://mswjs.io/docs/cli/i
     return cookie;
   }
 
-  function parse$3(input, options) {
+  function parse$4(input, options) {
     options = options
       ? Object.assign({}, defaultParseOptions, options)
       : defaultParseOptions;
@@ -2224,8 +2243,8 @@ Learn more about creating the Service Worker script: https://mswjs.io/docs/cli/i
     return cookiesStrings;
   }
 
-  setCookie.exports = parse$3;
-  setCookie.exports.parse = parse$3;
+  setCookie.exports = parse$4;
+  setCookie.exports.parse = parse$4;
   setCookie.exports.parseString = parseString;
   setCookie.exports.splitCookiesString = splitCookiesString;
 
@@ -2405,7 +2424,7 @@ Invalid value has been removed from localStorage to prevent subsequent failed pa
       /**
        * @note No cookies persist on the document in Node.js: no document.
        */
-      if (typeof location === 'undefined') {
+      if (typeof document === 'undefined' || typeof location === 'undefined') {
           return {};
       }
       switch (request.credentials) {
@@ -2506,25 +2525,25 @@ Invalid value has been removed from localStorage to prevent subsequent failed pa
   }
 
   /**
-   * Parses a given request/response body based on the `Content-Type` header.
+   * Parses a given request/response body based on the "Content-Type" header.
    */
   function parseBody(body, headers) {
       // Return whatever falsey body value is given.
       if (!body) {
           return body;
       }
-      const contentType = headers === null || headers === void 0 ? void 0 : headers.get('content-type');
+      const contentType = (headers === null || headers === void 0 ? void 0 : headers.get('content-type')) || '';
       // If the body has a Multipart Content-Type
       // parse it into an object.
-      const hasMultipartContent = contentType === null || contentType === void 0 ? void 0 : contentType.startsWith('multipart/form-data');
+      const hasMultipartContent = contentType.startsWith('multipart/form-data');
       if (hasMultipartContent && typeof body !== 'object') {
-          return parseMultipartData(body, headers) || body;
+          return parseMultipartData(body.toString(), headers) || body;
       }
       // If the intercepted request's body has a JSON Content-Type
       // parse it into an object.
-      const hasJsonContent = contentType === null || contentType === void 0 ? void 0 : contentType.includes('json');
+      const hasJsonContent = contentType.includes('json');
       if (hasJsonContent && typeof body !== 'object') {
-          return jsonParse(body) || body;
+          return jsonParse(body.toString()) || body;
       }
       // Otherwise leave as-is.
       return body;
@@ -3826,7 +3845,7 @@ Invalid value has been removed from localStorage to prevent subsequent failed pa
 
   directiveLocation.DirectiveLocation = DirectiveLocation;
 
-  var lexer = {};
+  var lexer$1 = {};
 
   var blockString = {};
 
@@ -3963,11 +3982,11 @@ Invalid value has been removed from localStorage to prevent subsequent failed pa
     return '"""' + result.replace(/"""/g, '\\"""') + '"""';
   }
 
-  Object.defineProperty(lexer, "__esModule", {
+  Object.defineProperty(lexer$1, "__esModule", {
     value: true
   });
-  lexer.isPunctuatorTokenKind = isPunctuatorTokenKind;
-  lexer.Lexer = void 0;
+  lexer$1.isPunctuatorTokenKind = isPunctuatorTokenKind;
+  lexer$1.Lexer = void 0;
 
   var _syntaxError$1 = syntaxError$1;
 
@@ -4049,7 +4068,7 @@ Invalid value has been removed from localStorage to prevent subsequent failed pa
    */
 
 
-  lexer.Lexer = Lexer;
+  lexer$1.Lexer = Lexer;
 
   function isPunctuatorTokenKind(kind) {
     return kind === _tokenKind$3.TokenKind.BANG || kind === _tokenKind$3.TokenKind.DOLLAR || kind === _tokenKind$3.TokenKind.AMP || kind === _tokenKind$3.TokenKind.PAREN_L || kind === _tokenKind$3.TokenKind.PAREN_R || kind === _tokenKind$3.TokenKind.SPREAD || kind === _tokenKind$3.TokenKind.COLON || kind === _tokenKind$3.TokenKind.EQUALS || kind === _tokenKind$3.TokenKind.AT || kind === _tokenKind$3.TokenKind.BRACKET_L || kind === _tokenKind$3.TokenKind.BRACKET_R || kind === _tokenKind$3.TokenKind.BRACE_L || kind === _tokenKind$3.TokenKind.PIPE || kind === _tokenKind$3.TokenKind.BRACE_R;
@@ -4655,7 +4674,7 @@ Invalid value has been removed from localStorage to prevent subsequent failed pa
   Object.defineProperty(parser, "__esModule", {
     value: true
   });
-  parser.parse = parse$2;
+  parser.parse = parse$3;
   parser.parseValue = parseValue;
   parser.parseType = parseType;
   parser.Parser = void 0;
@@ -4672,13 +4691,13 @@ Invalid value has been removed from localStorage to prevent subsequent failed pa
 
   var _directiveLocation$3 = directiveLocation;
 
-  var _lexer$1 = lexer;
+  var _lexer$1 = lexer$1;
 
   /**
    * Given a GraphQL source, parses it into a Document.
    * Throws GraphQLError if a syntax error is encountered.
    */
-  function parse$2(source, options) {
+  function parse$3(source, options) {
     var parser = new Parser(source, options);
     return parser.parseDocument();
   }
@@ -17337,7 +17356,7 @@ Invalid value has been removed from localStorage to prevent subsequent failed pa
 
   var _tokenKind = tokenKind;
 
-  var _lexer = lexer;
+  var _lexer = lexer$1;
 
   var _parser = parser;
 
@@ -20153,7 +20172,7 @@ Invalid value has been removed from localStorage to prevent subsequent failed pa
 
   var _tokenKind = tokenKind;
 
-  var _lexer = lexer;
+  var _lexer = lexer$1;
 
   var _blockString = blockString;
 
@@ -22433,51 +22452,414 @@ Invalid value has been removed from localStorage to prevent subsequent failed pa
           body: parseBody(res.body, responseHeaders) });
   }
 
-  var cjs = {};
-
-  Object.defineProperty(cjs, '__esModule', { value: true });
+  var dist = {};
 
-  /**
-   * Converts a string path to a Regular Expression.
-   * Transforms path parameters into named RegExp groups.
-   */
-  const pathToRegExp = (path) => {
-      const pattern = path
-          // Escape literal dots
-          .replace(/\./g, '\\.')
-          // Escape literal slashes
-          .replace(/\//g, '/')
-          // Escape literal question marks
-          .replace(/\?/g, '\\?')
-          // Ignore trailing slashes
-          .replace(/\/+$/, '')
-          // Replace wildcard with any zero-to-any character sequence
-          .replace(/\*+/g, '.*')
-          // Replace parameters with named capturing groups
-          .replace(/:([^\d|^\/][a-zA-Z0-9_]*(?=(?:\/|\\.)|$))/g, (_, paramName) => `(?<${paramName}>[^\/]+?)`)
-          // Allow optional trailing slash
-          .concat('(\\/|$)');
-      return new RegExp(pattern, 'gi');
-  };
-
-  /**
-   * Matches a given url against a path.
-   */
-  const match = (path, url) => {
-      const expression = path instanceof RegExp ? path : pathToRegExp(path);
-      const match = expression.exec(url) || false;
-      // Matches in strict mode: match string should equal to input (url)
-      // Otherwise loose matches will be considered truthy:
-      // match('/messages/:id', '/messages/123/users') // true
-      const matches = path instanceof RegExp ? !!match : !!match && match[0] === match.input;
-      return {
-          matches,
-          params: match && matches ? match.groups || null : null,
-      };
-  };
-
-  var match_1 = cjs.match = match;
-  cjs.pathToRegExp = pathToRegExp;
+  Object.defineProperty(dist, "__esModule", { value: true });
+  dist.pathToRegexp = dist.tokensToRegexp = dist.regexpToFunction = match_1 = dist.match = dist.tokensToFunction = dist.compile = dist.parse = void 0;
+  /**
+   * Tokenize input string.
+   */
+  function lexer(str) {
+      var tokens = [];
+      var i = 0;
+      while (i < str.length) {
+          var char = str[i];
+          if (char === "*" || char === "+" || char === "?") {
+              tokens.push({ type: "MODIFIER", index: i, value: str[i++] });
+              continue;
+          }
+          if (char === "\\") {
+              tokens.push({ type: "ESCAPED_CHAR", index: i++, value: str[i++] });
+              continue;
+          }
+          if (char === "{") {
+              tokens.push({ type: "OPEN", index: i, value: str[i++] });
+              continue;
+          }
+          if (char === "}") {
+              tokens.push({ type: "CLOSE", index: i, value: str[i++] });
+              continue;
+          }
+          if (char === ":") {
+              var name = "";
+              var j = i + 1;
+              while (j < str.length) {
+                  var code = str.charCodeAt(j);
+                  if (
+                  // `0-9`
+                  (code >= 48 && code <= 57) ||
+                      // `A-Z`
+                      (code >= 65 && code <= 90) ||
+                      // `a-z`
+                      (code >= 97 && code <= 122) ||
+                      // `_`
+                      code === 95) {
+                      name += str[j++];
+                      continue;
+                  }
+                  break;
+              }
+              if (!name)
+                  throw new TypeError("Missing parameter name at " + i);
+              tokens.push({ type: "NAME", index: i, value: name });
+              i = j;
+              continue;
+          }
+          if (char === "(") {
+              var count = 1;
+              var pattern = "";
+              var j = i + 1;
+              if (str[j] === "?") {
+                  throw new TypeError("Pattern cannot start with \"?\" at " + j);
+              }
+              while (j < str.length) {
+                  if (str[j] === "\\") {
+                      pattern += str[j++] + str[j++];
+                      continue;
+                  }
+                  if (str[j] === ")") {
+                      count--;
+                      if (count === 0) {
+                          j++;
+                          break;
+                      }
+                  }
+                  else if (str[j] === "(") {
+                      count++;
+                      if (str[j + 1] !== "?") {
+                          throw new TypeError("Capturing groups are not allowed at " + j);
+                      }
+                  }
+                  pattern += str[j++];
+              }
+              if (count)
+                  throw new TypeError("Unbalanced pattern at " + i);
+              if (!pattern)
+                  throw new TypeError("Missing pattern at " + i);
+              tokens.push({ type: "PATTERN", index: i, value: pattern });
+              i = j;
+              continue;
+          }
+          tokens.push({ type: "CHAR", index: i, value: str[i++] });
+      }
+      tokens.push({ type: "END", index: i, value: "" });
+      return tokens;
+  }
+  /**
+   * Parse a string for the raw tokens.
+   */
+  function parse$2(str, options) {
+      if (options === void 0) { options = {}; }
+      var tokens = lexer(str);
+      var _a = options.prefixes, prefixes = _a === void 0 ? "./" : _a;
+      var defaultPattern = "[^" + escapeString(options.delimiter || "/#?") + "]+?";
+      var result = [];
+      var key = 0;
+      var i = 0;
+      var path = "";
+      var tryConsume = function (type) {
+          if (i < tokens.length && tokens[i].type === type)
+              return tokens[i++].value;
+      };
+      var mustConsume = function (type) {
+          var value = tryConsume(type);
+          if (value !== undefined)
+              return value;
+          var _a = tokens[i], nextType = _a.type, index = _a.index;
+          throw new TypeError("Unexpected " + nextType + " at " + index + ", expected " + type);
+      };
+      var consumeText = function () {
+          var result = "";
+          var value;
+          // tslint:disable-next-line
+          while ((value = tryConsume("CHAR") || tryConsume("ESCAPED_CHAR"))) {
+              result += value;
+          }
+          return result;
+      };
+      while (i < tokens.length) {
+          var char = tryConsume("CHAR");
+          var name = tryConsume("NAME");
+          var pattern = tryConsume("PATTERN");
+          if (name || pattern) {
+              var prefix = char || "";
+              if (prefixes.indexOf(prefix) === -1) {
+                  path += prefix;
+                  prefix = "";
+              }
+              if (path) {
+                  result.push(path);
+                  path = "";
+              }
+              result.push({
+                  name: name || key++,
+                  prefix: prefix,
+                  suffix: "",
+                  pattern: pattern || defaultPattern,
+                  modifier: tryConsume("MODIFIER") || ""
+              });
+              continue;
+          }
+          var value = char || tryConsume("ESCAPED_CHAR");
+          if (value) {
+              path += value;
+              continue;
+          }
+          if (path) {
+              result.push(path);
+              path = "";
+          }
+          var open = tryConsume("OPEN");
+          if (open) {
+              var prefix = consumeText();
+              var name_1 = tryConsume("NAME") || "";
+              var pattern_1 = tryConsume("PATTERN") || "";
+              var suffix = consumeText();
+              mustConsume("CLOSE");
+              result.push({
+                  name: name_1 || (pattern_1 ? key++ : ""),
+                  pattern: name_1 && !pattern_1 ? defaultPattern : pattern_1,
+                  prefix: prefix,
+                  suffix: suffix,
+                  modifier: tryConsume("MODIFIER") || ""
+              });
+              continue;
+          }
+          mustConsume("END");
+      }
+      return result;
+  }
+  dist.parse = parse$2;
+  /**
+   * Compile a string to a template function for the path.
+   */
+  function compile(str, options) {
+      return tokensToFunction(parse$2(str, options), options);
+  }
+  dist.compile = compile;
+  /**
+   * Expose a method for transforming tokens into the path function.
+   */
+  function tokensToFunction(tokens, options) {
+      if (options === void 0) { options = {}; }
+      var reFlags = flags(options);
+      var _a = options.encode, encode = _a === void 0 ? function (x) { return x; } : _a, _b = options.validate, validate = _b === void 0 ? true : _b;
+      // Compile all the tokens into regexps.
+      var matches = tokens.map(function (token) {
+          if (typeof token === "object") {
+              return new RegExp("^(?:" + token.pattern + ")$", reFlags);
+          }
+      });
+      return function (data) {
+          var path = "";
+          for (var i = 0; i < tokens.length; i++) {
+              var token = tokens[i];
+              if (typeof token === "string") {
+                  path += token;
+                  continue;
+              }
+              var value = data ? data[token.name] : undefined;
+              var optional = token.modifier === "?" || token.modifier === "*";
+              var repeat = token.modifier === "*" || token.modifier === "+";
+              if (Array.isArray(value)) {
+                  if (!repeat) {
+                      throw new TypeError("Expected \"" + token.name + "\" to not repeat, but got an array");
+                  }
+                  if (value.length === 0) {
+                      if (optional)
+                          continue;
+                      throw new TypeError("Expected \"" + token.name + "\" to not be empty");
+                  }
+                  for (var j = 0; j < value.length; j++) {
+                      var segment = encode(value[j], token);
+                      if (validate && !matches[i].test(segment)) {
+                          throw new TypeError("Expected all \"" + token.name + "\" to match \"" + token.pattern + "\", but got \"" + segment + "\"");
+                      }
+                      path += token.prefix + segment + token.suffix;
+                  }
+                  continue;
+              }
+              if (typeof value === "string" || typeof value === "number") {
+                  var segment = encode(String(value), token);
+                  if (validate && !matches[i].test(segment)) {
+                      throw new TypeError("Expected \"" + token.name + "\" to match \"" + token.pattern + "\", but got \"" + segment + "\"");
+                  }
+                  path += token.prefix + segment + token.suffix;
+                  continue;
+              }
+              if (optional)
+                  continue;
+              var typeOfMessage = repeat ? "an array" : "a string";
+              throw new TypeError("Expected \"" + token.name + "\" to be " + typeOfMessage);
+          }
+          return path;
+      };
+  }
+  dist.tokensToFunction = tokensToFunction;
+  /**
+   * Create path match function from `path-to-regexp` spec.
+   */
+  function match(str, options) {
+      var keys = [];
+      var re = pathToRegexp(str, keys, options);
+      return regexpToFunction(re, keys, options);
+  }
+  var match_1 = dist.match = match;
+  /**
+   * Create a path match function from `path-to-regexp` output.
+   */
+  function regexpToFunction(re, keys, options) {
+      if (options === void 0) { options = {}; }
+      var _a = options.decode, decode = _a === void 0 ? function (x) { return x; } : _a;
+      return function (pathname) {
+          var m = re.exec(pathname);
+          if (!m)
+              return false;
+          var path = m[0], index = m.index;
+          var params = Object.create(null);
+          var _loop_1 = function (i) {
+              // tslint:disable-next-line
+              if (m[i] === undefined)
+                  return "continue";
+              var key = keys[i - 1];
+              if (key.modifier === "*" || key.modifier === "+") {
+                  params[key.name] = m[i].split(key.prefix + key.suffix).map(function (value) {
+                      return decode(value, key);
+                  });
+              }
+              else {
+                  params[key.name] = decode(m[i], key);
+              }
+          };
+          for (var i = 1; i < m.length; i++) {
+              _loop_1(i);
+          }
+          return { path: path, index: index, params: params };
+      };
+  }
+  dist.regexpToFunction = regexpToFunction;
+  /**
+   * Escape a regular expression string.
+   */
+  function escapeString(str) {
+      return str.replace(/([.+*?=^!:${}()[\]|/\\])/g, "\\$1");
+  }
+  /**
+   * Get the flags for a regexp from the options.
+   */
+  function flags(options) {
+      return options && options.sensitive ? "" : "i";
+  }
+  /**
+   * Pull out keys from a regexp.
+   */
+  function regexpToRegexp(path, keys) {
+      if (!keys)
+          return path;
+      var groupsRegex = /\((?:\?<(.*?)>)?(?!\?)/g;
+      var index = 0;
+      var execResult = groupsRegex.exec(path.source);
+      while (execResult) {
+          keys.push({
+              // Use parenthesized substring match if available, index otherwise
+              name: execResult[1] || index++,
+              prefix: "",
+              suffix: "",
+              modifier: "",
+              pattern: ""
+          });
+          execResult = groupsRegex.exec(path.source);
+      }
+      return path;
+  }
+  /**
+   * Transform an array into a regexp.
+   */
+  function arrayToRegexp(paths, keys, options) {
+      var parts = paths.map(function (path) { return pathToRegexp(path, keys, options).source; });
+      return new RegExp("(?:" + parts.join("|") + ")", flags(options));
+  }
+  /**
+   * Create a path regexp from string input.
+   */
+  function stringToRegexp(path, keys, options) {
+      return tokensToRegexp(parse$2(path, options), keys, options);
+  }
+  /**
+   * Expose a function for taking tokens and returning a RegExp.
+   */
+  function tokensToRegexp(tokens, keys, options) {
+      if (options === void 0) { options = {}; }
+      var _a = options.strict, strict = _a === void 0 ? false : _a, _b = options.start, start = _b === void 0 ? true : _b, _c = options.end, end = _c === void 0 ? true : _c, _d = options.encode, encode = _d === void 0 ? function (x) { return x; } : _d;
+      var endsWith = "[" + escapeString(options.endsWith || "") + "]|$";
+      var delimiter = "[" + escapeString(options.delimiter || "/#?") + "]";
+      var route = start ? "^" : "";
+      // Iterate over the tokens and create our regexp string.
+      for (var _i = 0, tokens_1 = tokens; _i < tokens_1.length; _i++) {
+          var token = tokens_1[_i];
+          if (typeof token === "string") {
+              route += escapeString(encode(token));
+          }
+          else {
+              var prefix = escapeString(encode(token.prefix));
+              var suffix = escapeString(encode(token.suffix));
+              if (token.pattern) {
+                  if (keys)
+                      keys.push(token);
+                  if (prefix || suffix) {
+                      if (token.modifier === "+" || token.modifier === "*") {
+                          var mod = token.modifier === "*" ? "?" : "";
+                          route += "(?:" + prefix + "((?:" + token.pattern + ")(?:" + suffix + prefix + "(?:" + token.pattern + "))*)" + suffix + ")" + mod;
+                      }
+                      else {
+                          route += "(?:" + prefix + "(" + token.pattern + ")" + suffix + ")" + token.modifier;
+                      }
+                  }
+                  else {
+                      route += "(" + token.pattern + ")" + token.modifier;
+                  }
+              }
+              else {
+                  route += "(?:" + prefix + suffix + ")" + token.modifier;
+              }
+          }
+      }
+      if (end) {
+          if (!strict)
+              route += delimiter + "?";
+          route += !options.endsWith ? "$" : "(?=" + endsWith + ")";
+      }
+      else {
+          var endToken = tokens[tokens.length - 1];
+          var isEndDelimited = typeof endToken === "string"
+              ? delimiter.indexOf(endToken[endToken.length - 1]) > -1
+              : // tslint:disable-next-line
+                  endToken === undefined;
+          if (!strict) {
+              route += "(?:" + delimiter + "(?=" + endsWith + "))?";
+          }
+          if (!isEndDelimited) {
+              route += "(?=" + delimiter + "|" + endsWith + ")";
+          }
+      }
+      return new RegExp(route, flags(options));
+  }
+  dist.tokensToRegexp = tokensToRegexp;
+  /**
+   * Normalize the given path string, returning a regular expression.
+   *
+   * An empty array can be passed in for the keys, which will hold the
+   * placeholder key descriptions. For example, using `/user/:id`, `keys` will
+   * contain `[{ name: 'id', delimiter: '/', optional: false, repeat: false }]`.
+   */
+  function pathToRegexp(path, keys, options) {
+      if (path instanceof RegExp)
+          return regexpToRegexp(path, keys);
+      if (Array.isArray(path))
+          return arrayToRegexp(path, keys, options);
+      return stringToRegexp(path, keys, options);
+  }
+  dist.pathToRegexp = pathToRegexp;
 
   var getCleanUrl$1 = {};
 
@@ -22512,8 +22894,8 @@ Invalid value has been removed from localStorage to prevent subsequent failed pa
           return path;
       }
       // Resolve a relative request URL against a given custom "baseUrl"
-      // or the current location (in the case of browser/browser-like environments).
-      const origin = baseUrl || (typeof location !== 'undefined' && location.origin);
+      // or the document baseURI (in the case of browser/browser-like environments).
+      const origin = baseUrl || (typeof document !== 'undefined' && document.baseURI);
       return origin
           ? // Encode and decode the path to preserve escaped characters.
               decodeURI(new URL(encodeURI(path), origin).href)
@@ -22536,12 +22918,40 @@ Invalid value has been removed from localStorage to prevent subsequent failed pa
       return cleanUrl(maybeAbsoluteUrl);
   }
 
+  /**
+   * Coerce a path supported by MSW into a path
+   * supported by "path-to-regexp".
+   */
+  function coercePath(path) {
+      return (path
+          /**
+           * Escape the protocol so that "path-to-regexp" could match
+           * absolute URL.
+           * @see https://github.com/pillarjs/path-to-regexp/issues/259
+           */
+          .replace(/^([^\/]+)(:)(?=\/\/)/g, '$1\\$2')
+          /**
+           * Replace wildcards ("*") with unnamed capturing groups
+           * because "path-to-regexp" doesn't support wildcards.
+           * Ignore path parameter' modifiers (i.e. ":name*").
+           */
+          .replace(/(?<!(^|\/|\*+):[\w]+)(\*{1,2})/g, '(.*)'));
+  }
   /**
    * Returns the result of matching given request URL against a mask.
    */
   function matchRequestUrl(url, path, baseUrl) {
       const normalizedPath = normalizePath(path, baseUrl);
-      return match_1(normalizedPath, getCleanUrl_2(url));
+      const cleanPath = typeof normalizedPath === 'string'
+          ? coercePath(normalizedPath)
+          : normalizedPath;
+      const cleanUrl = getCleanUrl_2(url);
+      const result = match_1(cleanPath, { decode: decodeURIComponent })(cleanUrl);
+      const params = (result && result.params) || {};
+      return {
+          matches: result !== false,
+          params,
+      };
   }
 
   /**
@@ -22590,18 +23000,21 @@ Invalid value has been removed from localStorage to prevent subsequent failed pa
       },
   });
 
+  const BUILD_FRAME = /(node_modules)?[\/\\]lib[\/\\](umd|esm|iief|cjs)[\/\\]|^[^\/\\]*$/;
   /**
    * Return the stack trace frame of a function's invocation.
    */
-  function getCallFrame() {
+  function getCallFrame(error) {
       // In <IE11, new Error may return an undefined stack
-      const stack = (new Error().stack || '');
-      const frames = stack.split('\n');
+      const stack = error.stack;
+      if (!stack) {
+          return;
+      }
+      const frames = stack.split('\n').slice(1);
       // Get the first frame that doesn't reference the library's internal trace.
       // Assume that frame is the invocation frame.
-      const ignoreFrameRegExp = /(node_modules)?[\/\\]lib[\/\\](umd|esm|iief|cjs)[\/\\]|^[^\/\\]*$/;
-      const declarationFrame = frames.slice(1).find((frame) => {
-          return !ignoreFrameRegExp.test(frame);
+      const declarationFrame = frames.find((frame) => {
+          return !BUILD_FRAME.test(frame);
       });
       if (!declarationFrame) {
           return;
@@ -22634,7 +23047,7 @@ Invalid value has been removed from localStorage to prevent subsequent failed pa
           this.shouldSkip = false;
           this.ctx = options.ctx || defaultContext;
           this.resolver = options.resolver;
-          const callFrame = getCallFrame();
+          const callFrame = getCallFrame(new Error());
           this.info = Object.assign(Object.assign({}, options.info), { callFrame });
       }
       /**
@@ -22761,21 +23174,9 @@ Invalid value has been removed from localStorage to prevent subsequent failed pa
               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:
-
-rest.${method.toLowerCase()}("${url}", (req, res, ctx) => {
-  const query = req.url.searchParams
-${queryParams
-            .map((paramName) => `\
-  const ${paramName} = query.get("${paramName}")`)
-            .join('\n')}
-})\
-      `);
+          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 || resolutionContext === void 0 ? void 0 : resolutionContext.baseUrl);
@@ -22784,7 +23185,11 @@ ${queryParams
           return Object.assign(Object.assign({}, request), { params: parsedResult.params || {} });
       }
       predicate(request, parsedResult) {
-          return (isStringEqual(this.info.method, request.method) && parsedResult.matches);
+          const matchesMethod = this.info.method instanceof RegExp
+              ? this.info.method.test(request.method)
+              : isStringEqual(this.info.method, request.method);
+          // console.log({ request, matchesMethod, parsedResult })
+          return matchesMethod && parsedResult.matches;
       }
       log(request, response) {
           const publicUrl = getPublicUrlFromRequest(request);
@@ -22818,6 +23223,7 @@ ${queryParams
       delay,
       fetch: fetch$1,
       data,
+      extensions,
       errors,
       cookie,
   };
@@ -22864,10 +23270,10 @@ ${queryParams
           if (!parsedResult) {
               return false;
           }
-          if (!parsedResult.operationName) {
+          if (!parsedResult.operationName && this.info.operationType !== 'all') {
               const publicUrl = getPublicUrlFromRequest(request);
               devUtils.warn(`\
-Failed to intercept a GraphQL request at "${request.method} ${publicUrl}": unnamed GraphQL operations are not supported.
+Failed to intercept a GraphQL request at "${request.method} ${publicUrl}": anonymous GraphQL operations are not supported.
 
 Consider naming this operation or using "graphql.operation" request handler to intercept GraphQL requests regardless of their operation name/type. Read more: https://mswjs.io/docs/api/graphql/operation\
       `);
@@ -22877,7 +23283,7 @@ Consider naming this operation or using "graphql.operation" request handler to i
           const hasMatchingOperationType = this.info.operationType === 'all' ||
               parsedResult.operationType === this.info.operationType;
           const hasMatchingOperationName = this.info.operationName instanceof RegExp
-              ? this.info.operationName.test(parsedResult.operationName)
+              ? this.info.operationName.test(parsedResult.operationName || '')
               : parsedResult.operationName === this.info.operationName;
           return (hasMatchingUrl.matches &&
               hasMatchingOperationType &&
@@ -22887,7 +23293,10 @@ Consider naming this operation or using "graphql.operation" request handler to i
           const loggedRequest = prepareRequest(request);
           const loggedResponse = prepareResponse(response);
           const statusColor = getStatusCodeColor(response.status);
-          console.groupCollapsed(devUtils.formatMessage('%s %s (%c%s%c)'), getTimestamp(), `${parsedRequest === null || parsedRequest === void 0 ? void 0 : parsedRequest.operationType} ${parsedRequest === null || parsedRequest === void 0 ? void 0 : parsedRequest.operationName}`, `color:${statusColor}`, `${response.status} ${response.statusText}`, 'color:inherit');
+          const requestInfo = (parsedRequest === null || parsedRequest === void 0 ? void 0 : parsedRequest.operationName)
+              ? `${parsedRequest === null || parsedRequest === void 0 ? void 0 : parsedRequest.operationType} ${parsedRequest === null || parsedRequest === void 0 ? void 0 : parsedRequest.operationName}`
+              : `anonymous ${parsedRequest === null || parsedRequest === void 0 ? void 0 : parsedRequest.operationType}`;
+          console.groupCollapsed(devUtils.formatMessage('%s %s (%c%s%c)'), getTimestamp(), `${requestInfo}`, `color:${statusColor}`, `${response.status} ${response.statusText}`, 'color:inherit');
           console.log('Request:', loggedRequest);
           console.log('Handler:', this);
           console.log('Response:', loggedResponse);
@@ -23047,7 +23456,12 @@ Read more: https://mswjs.io/docs/getting-started/mocks\
           // 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 a mocking resolver function to return a mocked response Object, but got: %s. Original response is going to be used instead.', 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.onBypassResponse) === null || _c === void 0 ? void 0 : _c.call(handleRequestOptions, request);
               return;
@@ -23134,8 +23548,8 @@ Read more: https://mswjs.io/docs/getting-started/mocks\
           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 !== "f0a916b13c8acc2b526a03a6d26df85f") {
-              throw new Error(`Currently active Service Worker (${actualChecksum}) is behind the latest published one (${"f0a916b13c8acc2b526a03a6d26df85f"}).`);
+          if (actualChecksum !== "02f4ad4a2797f85668baf196e553d929") {
+              throw new Error(`Currently active Service Worker (${actualChecksum}) is behind the latest published one (${"02f4ad4a2797f85668baf196e553d929"}).`);
           }
           return serviceWorker;
       });
@@ -24404,15 +24818,16 @@ If this message still persists after updating, please report an issue: https://g
                       }
                       debug$1('no mocked response found, bypassing...');
                       return [2 /*return*/, pureFetch(input, init).then(function (response) { return __awaiter$1(void 0, void 0, void 0, function () {
-                              var _a, _b, _c;
+                              var cloneResponse, _a, _b, _c;
                               return __generator$1(this, function (_d) {
                                   switch (_d.label) {
                                       case 0:
-                                          debug$1('original fetch performed', response);
+                                          cloneResponse = response.clone();
+                                          debug$1('original fetch performed', cloneResponse);
                                           _b = (_a = observer).emit;
                                           _c = ['response',
                                               isoRequest];
-                                          return [4 /*yield*/, normalizeFetchResponse(response)];
+                                          return [4 /*yield*/, normalizeFetchResponse(cloneResponse)];
                                       case 1:
                                           _b.apply(_a, _c.concat([_d.sent()]));
                                           return [2 /*return*/, response];
@@ -28131,6 +28546,7 @@ If this message still persists after updating, please report an issue: https://g
       };
   }
   const rest = {
+      all: createRestHandler(/.+/),
       head: createRestHandler(exports.RESTMethods.HEAD),
       get: createRestHandler(exports.RESTMethods.GET),
       post: createRestHandler(exports.RESTMethods.POST),
@@ -28191,6 +28607,7 @@ If this message still persists after updating, please report an issue: https://g
   exports.GraphQLHandler = GraphQLHandler;
   exports.RequestHandler = RequestHandler;
   exports.RestHandler = RestHandler;
+  exports.cleanUrl = cleanUrl;
   exports.compose = compose;
   exports.context = index;
   exports.createResponseComposition = createResponseComposition;
@@ -28206,4 +28623,4 @@ If this message still persists after updating, please report an issue: https://g
   exports.restContext = restContext;
   exports.setupWorker = setupWorker;
 
-})));
+}));