msw 0.34.0 → 0.36.2

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 });
-
-  /**
-   * 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 dist = {};
 
-  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,9 +22894,12 @@ 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);
-      return origin ? new URL(path, origin).href : path;
+      // 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)
+          : path;
   }
 
   /**
@@ -22533,12 +22918,48 @@ 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
+          /**
+           * Replace wildcards ("*") with unnamed capturing groups
+           * because "path-to-regexp" doesn't support wildcards.
+           * Ignore path parameter' modifiers (i.e. ":name*").
+           */
+          .replace(/([:a-zA-Z_-]*)(\*{1,2})+/g, (_, parameterName, wildcard) => {
+          const expression = '(.*)';
+          if (!parameterName) {
+              return expression;
+          }
+          return parameterName.startsWith(':')
+              ? `${parameterName}${wildcard}`
+              : `${parameterName}${expression}`;
+      })
+          /**
+           * 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'));
+  }
   /**
    * 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,
+      };
   }
 
   /**
@@ -22587,18 +23008,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;
@@ -22631,7 +23055,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 });
       }
       /**
@@ -22758,21 +23182,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);
@@ -22781,7 +23193,10 @@ ${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);
+          return matchesMethod && parsedResult.matches;
       }
       log(request, response) {
           const publicUrl = getPublicUrlFromRequest(request);
@@ -22815,6 +23230,7 @@ ${queryParams
       delay,
       fetch: fetch$1,
       data,
+      extensions,
       errors,
       cookie,
   };
@@ -22861,10 +23277,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\
       `);
@@ -22874,7 +23290,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 &&
@@ -22884,7 +23300,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);
@@ -22909,10 +23328,10 @@ Consider naming this operation or using "graphql.operation" request handler to i
           graphql: [],
       });
   }
-  function getScoreForRestHandler() {
+  function getRestHandlerScore() {
       return (request, handler) => {
           const { path, method } = handler.info;
-          if (path instanceof RegExp) {
+          if (path instanceof RegExp || method instanceof RegExp) {
               return Infinity;
           }
           const hasSameMethod = isStringEqual(request.method, method);
@@ -22923,12 +23342,15 @@ Consider naming this operation or using "graphql.operation" request handler to i
           return score - methodScoreDelta;
       };
   }
-  function getScoreForGraphQLHandler(parsedQuery) {
+  function getGraphQLHandlerScore(parsedQuery) {
       return (_, handler) => {
           if (typeof parsedQuery.operationName === 'undefined') {
               return Infinity;
           }
           const { operationType, operationName } = handler.info;
+          if (typeof operationName !== 'string') {
+              return Infinity;
+          }
           const hasSameOperationType = parsedQuery.operationType === operationType;
           // Always treat a handler with the same operation type as a more similar one.
           const operationTypeScoreDelta = hasSameOperationType ? TYPE_MATCH_DELTA : 0;
@@ -22938,16 +23360,12 @@ Consider naming this operation or using "graphql.operation" request handler to i
   }
   function getSuggestedHandler(request, handlers, getScore) {
       const suggestedHandlers = handlers
-          .reduce((acc, handler) => {
+          .reduce((suggestions, handler) => {
           const score = getScore(request, handler);
-          return acc.concat([[score, handler]]);
+          return suggestions.concat([[score, handler]]);
       }, [])
-          .sort(([leftScore], [rightScore]) => {
-          return leftScore - rightScore;
-      })
-          .filter(([score]) => {
-          return score <= MAX_MATCH_SCORE;
-      })
+          .sort(([leftScore], [rightScore]) => leftScore - rightScore)
+          .filter(([score]) => score <= MAX_MATCH_SCORE)
           .slice(0, MAX_SUGGESTION_COUNT)
           .map(([, handler]) => handler);
       return suggestedHandlers;
@@ -22977,8 +23395,8 @@ ${handlers.map((handler) => `  • ${handler.info.header}`).join('\n')}`;
           ? handlerGroups.graphql
           : handlerGroups.rest;
       const suggestedHandlers = getSuggestedHandler(request, relevantHandlers, parsedGraphQLQuery
-          ? getScoreForGraphQLHandler(parsedGraphQLQuery)
-          : getScoreForRestHandler());
+          ? getGraphQLHandlerScore(parsedGraphQLQuery)
+          : getRestHandlerScore());
       const handlerSuggestion = suggestedHandlers.length > 0
           ? getSuggestedHandlersMessage(suggestedHandlers)
           : '';
@@ -22998,8 +23416,10 @@ Read more: https://mswjs.io/docs/getting-started/mocks\
       const message = messageTemplate.join('\n\n');
       switch (strategy) {
           case 'error': {
+              // Print a developer-friendly error.
               devUtils.error('Error: %s', message);
-              break;
+              // Throw an exception to halt request processing and not perform the original request.
+              throw new Error(devUtils.formatMessage('Cannot bypass a request when using the "error" strategy for the "onUnhandledRequest" option.'));
           }
           case 'warn': {
               devUtils.warn('Warning: %s', message);
@@ -23042,7 +23462,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;
@@ -23129,8 +23554,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;
       });
@@ -23279,16 +23704,14 @@ If this message still persists after updating, please report an issue: https://g
   }
 
   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;
+          /**
+           * Signal the Service Worker to disable mocking for this client.
+           * Use this an an explicit way to stop the mocking, while preserving
+           * the worker-client relation. Does not affect the worker's lifecycle.
+           */
           context.workerChannel.send('MOCK_DEACTIVATE');
-          context.events.removeAllListeners();
-          context.emitter.removeAllListeners();
           window.clearInterval(context.keepAliveInterval);
           printStopMessage({ quiet: (_a = context.startOptions) === null || _a === void 0 ? void 0 : _a.quiet });
       };
@@ -24401,15 +24824,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];
@@ -24450,9 +24874,179 @@ If this message still persists after updating, please report an issue: https://g
 
   var domParser = {};
 
-  var entities = {};
+  var conventions$2 = {};
+
+  /**
+   * "Shallow freezes" an object to render it immutable.
+   * Uses `Object.freeze` if available,
+   * otherwise the immutability is only in the type.
+   *
+   * Is used to create "enum like" objects.
+   *
+   * @template T
+   * @param {T} object the object to freeze
+   * @param {Pick<ObjectConstructor, 'freeze'> = Object} oc `Object` by default,
+   * 				allows to inject custom object constructor for tests
+   * @returns {Readonly<T>}
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/freeze
+   */
+  function freeze(object, oc) {
+  	if (oc === undefined) {
+  		oc = Object;
+  	}
+  	return oc && typeof oc.freeze === 'function' ? oc.freeze(object) : object
+  }
+
+  /**
+   * All mime types that are allowed as input to `DOMParser.parseFromString`
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMParser/parseFromString#Argument02 MDN
+   * @see https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#domparsersupportedtype WHATWG HTML Spec
+   * @see DOMParser.prototype.parseFromString
+   */
+  var MIME_TYPE = freeze({
+  	/**
+  	 * `text/html`, the only mime type that triggers treating an XML document as HTML.
+  	 *
+  	 * @see DOMParser.SupportedType.isHTML
+  	 * @see https://www.iana.org/assignments/media-types/text/html IANA MimeType registration
+  	 * @see https://en.wikipedia.org/wiki/HTML Wikipedia
+  	 * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMParser/parseFromString MDN
+  	 * @see https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#dom-domparser-parsefromstring WHATWG HTML Spec
+  	 */
+  	HTML: 'text/html',
+
+  	/**
+  	 * Helper method to check a mime type if it indicates an HTML document
+  	 *
+  	 * @param {string} [value]
+  	 * @returns {boolean}
+  	 *
+  	 * @see https://www.iana.org/assignments/media-types/text/html IANA MimeType registration
+  	 * @see https://en.wikipedia.org/wiki/HTML Wikipedia
+  	 * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMParser/parseFromString MDN
+  	 * @see https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#dom-domparser-parsefromstring 	 */
+  	isHTML: function (value) {
+  		return value === MIME_TYPE.HTML
+  	},
+
+  	/**
+  	 * `application/xml`, the standard mime type for XML documents.
+  	 *
+  	 * @see https://www.iana.org/assignments/media-types/application/xml IANA MimeType registration
+  	 * @see https://tools.ietf.org/html/rfc7303#section-9.1 RFC 7303
+  	 * @see https://en.wikipedia.org/wiki/XML_and_MIME Wikipedia
+  	 */
+  	XML_APPLICATION: 'application/xml',
+
+  	/**
+  	 * `text/html`, an alias for `application/xml`.
+  	 *
+  	 * @see https://tools.ietf.org/html/rfc7303#section-9.2 RFC 7303
+  	 * @see https://www.iana.org/assignments/media-types/text/xml IANA MimeType registration
+  	 * @see https://en.wikipedia.org/wiki/XML_and_MIME Wikipedia
+  	 */
+  	XML_TEXT: 'text/xml',
+
+  	/**
+  	 * `application/xhtml+xml`, indicates an XML document that has the default HTML namespace,
+  	 * but is parsed as an XML document.
+  	 *
+  	 * @see https://www.iana.org/assignments/media-types/application/xhtml+xml IANA MimeType registration
+  	 * @see https://dom.spec.whatwg.org/#dom-domimplementation-createdocument WHATWG DOM Spec
+  	 * @see https://en.wikipedia.org/wiki/XHTML Wikipedia
+  	 */
+  	XML_XHTML_APPLICATION: 'application/xhtml+xml',
+
+  	/**
+  	 * `image/svg+xml`,
+  	 *
+  	 * @see https://www.iana.org/assignments/media-types/image/svg+xml IANA MimeType registration
+  	 * @see https://www.w3.org/TR/SVG11/ W3C SVG 1.1
+  	 * @see https://en.wikipedia.org/wiki/Scalable_Vector_Graphics Wikipedia
+  	 */
+  	XML_SVG_IMAGE: 'image/svg+xml',
+  });
+
+  /**
+   * Namespaces that are used in this code base.
+   *
+   * @see http://www.w3.org/TR/REC-xml-names
+   */
+  var NAMESPACE$3 = freeze({
+  	/**
+  	 * The XHTML namespace.
+  	 *
+  	 * @see http://www.w3.org/1999/xhtml
+  	 */
+  	HTML: 'http://www.w3.org/1999/xhtml',
+
+  	/**
+  	 * Checks if `uri` equals `NAMESPACE.HTML`.
+  	 *
+  	 * @param {string} [uri]
+  	 *
+  	 * @see NAMESPACE.HTML
+  	 */
+  	isHTML: function (uri) {
+  		return uri === NAMESPACE$3.HTML
+  	},
+
+  	/**
+  	 * The SVG namespace.
+  	 *
+  	 * @see http://www.w3.org/2000/svg
+  	 */
+  	SVG: 'http://www.w3.org/2000/svg',
+
+  	/**
+  	 * The `xml:` namespace.
+  	 *
+  	 * @see http://www.w3.org/XML/1998/namespace
+  	 */
+  	XML: 'http://www.w3.org/XML/1998/namespace',
+
+  	/**
+  	 * The `xmlns:` namespace
+  	 *
+  	 * @see https://www.w3.org/2000/xmlns/
+  	 */
+  	XMLNS: 'http://www.w3.org/2000/xmlns/',
+  });
+
+  conventions$2.freeze = freeze;
+  conventions$2.MIME_TYPE = MIME_TYPE;
+  conventions$2.NAMESPACE = NAMESPACE$3;
+
+  var entities$1 = {};
+
+  (function (exports) {
+  var freeze = conventions$2.freeze;
+
+  /**
+   * The entities that are predefined in every XML document.
+   *
+   * @see https://www.w3.org/TR/2006/REC-xml11-20060816/#sec-predefined-ent W3C XML 1.1
+   * @see https://www.w3.org/TR/2008/REC-xml-20081126/#sec-predefined-ent W3C XML 1.0
+   * @see https://en.wikipedia.org/wiki/List_of_XML_and_HTML_character_entity_references#Predefined_entities_in_XML Wikipedia
+   */
+  exports.XML_ENTITIES = freeze({amp:'&', apos:"'", gt:'>', lt:'<', quot:'"'});
 
-  entities.entityMap = {
+  /**
+   * A map of currently 241 entities that are detected in an HTML document.
+   * They contain all entries from `XML_ENTITIES`.
+   *
+   * @see XML_ENTITIES
+   * @see DOMParser.parseFromString
+   * @see DOMImplementation.prototype.createHTMLDocument
+   * @see https://html.spec.whatwg.org/#named-character-references WHATWG HTML(5) Spec
+   * @see https://www.w3.org/TR/xml-entity-names/ W3C XML Entity Names
+   * @see https://www.w3.org/TR/html4/sgml/entities.html W3C HTML4/SGML
+   * @see https://en.wikipedia.org/wiki/List_of_XML_and_HTML_character_entity_references#Character_entity_references_in_HTML Wikipedia (HTML)
+   * @see https://en.wikipedia.org/wiki/List_of_XML_and_HTML_character_entity_references#Entities_representing_special_characters_in_XHTML Wikpedia (XHTML)
+   */
+  exports.HTML_ENTITIES = freeze({
          lt: '<',
          gt: '>',
          amp: '&',
@@ -24694,10 +25288,19 @@ If this message still persists after updating, please report an issue: https://g
          clubs: "♣",
          hearts: "♥",
          diams: "♦"
-  };
+  });
+
+  /**
+   * @deprecated use `HTML_ENTITIES` instead
+   * @see HTML_ENTITIES
+   */
+  exports.entityMap = exports.HTML_ENTITIES;
+  }(entities$1));
 
   var sax$1 = {};
 
+  var NAMESPACE$2 = conventions$2.NAMESPACE;
+
   //[4]   	NameStartChar	   ::=   	":" | [A-Z] | "_" | [a-z] | [#xC0-#xD6] | [#xD8-#xF6] | [#xF8-#x2FF] | [#x370-#x37D] | [#x37F-#x1FFF] | [#x200C-#x200D] | [#x2070-#x218F] | [#x2C00-#x2FEF] | [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | [#x10000-#xEFFFF]
   //[4a]   	NameChar	   ::=   	NameStartChar | "-" | "." | [0-9] | #xB7 | [#x0300-#x036F] | [#x203F-#x2040]
   //[5]   	Name	   ::=   	NameStartChar (NameChar)*
@@ -24815,7 +25418,7 @@ If this message still persists after updating, please report an issue: https://g
   			switch(source.charAt(tagStart+1)){
   			case '/':
   				var end = source.indexOf('>',tagStart+3);
-  				var tagName = source.substring(tagStart+2,end);
+  				var tagName = source.substring(tagStart + 2, end).replace(/[ \t\n\r]+$/g, '');
   				var config = parseStack.pop();
   				if(end<0){
   					
@@ -24888,12 +25491,10 @@ If this message still persists after updating, please report an issue: https://g
   						parseStack.push(el);
   					}
   				}
-  				
-  				
-  				
-  				if(el.uri === 'http://www.w3.org/1999/xhtml' && !el.closed){
+
+  				if (NAMESPACE$2.isHTML(el.uri) && !el.closed) {
   					end = parseHtmlSpecialContent(source,end,el.tagName,entityReplacer,domBuilder);
-  				}else {
+  				} else {
   					end++;
   				}
   			}
@@ -25029,7 +25630,7 @@ If this message still persists after updating, please report an issue: https://g
   					errorHandler.warning('attribute "'+value+'" missed quot(")!');
   					addAttribute(attrName, value.replace(/&#?\w+;/g,entityReplacer), start);
   				}else {
-  					if(currentNSMap[''] !== 'http://www.w3.org/1999/xhtml' || !value.match(/^(?:disabled|checked|selected)$/i)){
+  					if(!NAMESPACE$2.isHTML(currentNSMap['']) || !value.match(/^(?:disabled|checked|selected)$/i)){
   						errorHandler.warning('attribute "'+value+'" missed value!! "'+value+'" instead!!');
   					}
   					addAttribute(value, value, start);
@@ -25077,7 +25678,7 @@ If this message still persists after updating, please report an issue: https://g
   				//case S_ATTR_NOQUOT_VALUE:void();break;
   				case S_ATTR_SPACE:
   					el.tagName;
-  					if(currentNSMap[''] !== 'http://www.w3.org/1999/xhtml' || !attrName.match(/^(?:disabled|checked|selected)$/i)){
+  					if (!NAMESPACE$2.isHTML(currentNSMap['']) || !attrName.match(/^(?:disabled|checked|selected)$/i)) {
   						errorHandler.warning('attribute "'+attrName+'" missed value!! "'+attrName+'" instead2!!');
   					}
   					addAttribute(attrName, attrName, start);
@@ -25136,7 +25737,7 @@ If this message still persists after updating, please report an issue: https://g
   				//console.log(currentNSMap,1)
   			}
   			currentNSMap[nsPrefix] = localNSMap[nsPrefix] = value;
-  			a.uri = 'http://www.w3.org/2000/xmlns/';
+  			a.uri = NAMESPACE$2.XMLNS;
   			domBuilder.startPrefixMapping(nsPrefix, value); 
   		}
   	}
@@ -25146,7 +25747,7 @@ If this message still persists after updating, please report an issue: https://g
   		var prefix = a.prefix;
   		if(prefix){//no prefix attribute has no namespace
   			if(prefix === 'xml'){
-  				a.uri = 'http://www.w3.org/XML/1998/namespace';
+  				a.uri = NAMESPACE$2.XML;
   			}if(prefix !== 'xmlns'){
   				a.uri = currentNSMap[prefix || ''];
   				
@@ -25343,11 +25944,74 @@ If this message still persists after updating, please report an issue: https://g
 
   var dom = {};
 
+  var conventions$1 = conventions$2;
+
+  var NAMESPACE$1 = conventions$1.NAMESPACE;
+
+  /**
+   * A prerequisite for `[].filter`, to drop elements that are empty
+   * @param {string} input
+   * @returns {boolean}
+   */
+  function notEmptyString (input) {
+  	return input !== ''
+  }
+  /**
+   * @see https://infra.spec.whatwg.org/#split-on-ascii-whitespace
+   * @see https://infra.spec.whatwg.org/#ascii-whitespace
+   *
+   * @param {string} input
+   * @returns {string[]} (can be empty)
+   */
+  function splitOnASCIIWhitespace(input) {
+  	// U+0009 TAB, U+000A LF, U+000C FF, U+000D CR, U+0020 SPACE
+  	return input ? input.split(/[\t\n\f\r ]+/).filter(notEmptyString) : []
+  }
+
+  /**
+   * Adds element as a key to current if it is not already present.
+   *
+   * @param {Record<string, boolean | undefined>} current
+   * @param {string} element
+   * @returns {Record<string, boolean | undefined>}
+   */
+  function orderedSetReducer (current, element) {
+  	if (!current.hasOwnProperty(element)) {
+  		current[element] = true;
+  	}
+  	return current;
+  }
+
+  /**
+   * @see https://infra.spec.whatwg.org/#ordered-set
+   * @param {string} input
+   * @returns {string[]}
+   */
+  function toOrderedSet(input) {
+  	if (!input) return [];
+  	var list = splitOnASCIIWhitespace(input);
+  	return Object.keys(list.reduce(orderedSetReducer, {}))
+  }
+
+  /**
+   * Uses `list.indexOf` to implement something like `Array.prototype.includes`,
+   * which we can not rely on being available.
+   *
+   * @param {any[]} list
+   * @returns {function(any): boolean}
+   */
+  function arrayIncludes (list) {
+  	return function(element) {
+  		return list && list.indexOf(element) !== -1;
+  	}
+  }
+
   function copy(src,dest){
   	for(var p in src){
   		dest[p] = src[p];
   	}
   }
+
   /**
   ^\w+\.prototype\.([_\w]+)\s*=\s*((?:.*\{\s*?[\r\n][\s\S]*?^})|\S.*?(?=[;\r\n]));?
   ^\w+\.prototype\.([_\w]+)\s*=\s*(\S.*?(?=[;\r\n]));?
@@ -25367,7 +26031,7 @@ If this message still persists after updating, please report an issue: https://g
   		pt.constructor = Class;
   	}
   }
-  var htmlns = 'http://www.w3.org/1999/xhtml' ;
+
   // Node Types
   var NodeType = {};
   var ELEMENT_NODE                = NodeType.ELEMENT_NODE                = 1;
@@ -25423,6 +26087,7 @@ If this message still persists after updating, please report an issue: https://g
   	return error;
   }DOMException.prototype = Error.prototype;
   copy(ExceptionCode,DOMException);
+
   /**
    * @see http://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113/core.html#ID-536297177
    * The NodeList interface provides the abstraction of an ordered collection of nodes, without defining or constraining how this collection is implemented. NodeList objects in the DOM are live.
@@ -25453,6 +26118,7 @@ If this message still persists after updating, please report an issue: https://g
   		return buf.join('');
   	}
   };
+
   function LiveNodeList(node,refresh){
   	this._node = node;
   	this._refresh = refresh;
@@ -25474,9 +26140,15 @@ If this message still persists after updating, please report an issue: https://g
   };
 
   _extends(LiveNodeList,NodeList);
+
   /**
-   * 
-   * Objects implementing the NamedNodeMap interface are used to represent collections of nodes that can be accessed by name. Note that NamedNodeMap does not inherit from NodeList; NamedNodeMaps are not maintained in any particular order. Objects contained in an object implementing NamedNodeMap may also be accessed by an ordinal index, but this is simply to allow convenient enumeration of the contents of a NamedNodeMap, and does not imply that the DOM specifies an order to these Nodes.
+   * Objects implementing the NamedNodeMap interface are used
+   * to represent collections of nodes that can be accessed by name.
+   * Note that NamedNodeMap does not inherit from NodeList;
+   * NamedNodeMaps are not maintained in any particular order.
+   * Objects contained in an object implementing NamedNodeMap may also be accessed by an ordinal index,
+   * but this is simply to allow convenient enumeration of the contents of a NamedNodeMap,
+   * and does not imply that the DOM specifies an order to these Nodes.
    * NamedNodeMap objects in the DOM are live.
    * used for attributes or DocumentType entities 
    */
@@ -25587,54 +26259,108 @@ If this message still persists after updating, please report an issue: https://g
   		return null;
   	}
   };
+
   /**
-   * @see http://www.w3.org/TR/REC-DOM-Level-1/level-one-core.html#ID-102161490
+   * The DOMImplementation interface represents an object providing methods
+   * which are not dependent on any particular document.
+   * Such an object is returned by the `Document.implementation` property.
+   *
+   * __The individual methods describe the differences compared to the specs.__
+   *
+   * @constructor
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation MDN
+   * @see https://www.w3.org/TR/REC-DOM-Level-1/level-one-core.html#ID-102161490 DOM Level 1 Core (Initial)
+   * @see https://www.w3.org/TR/DOM-Level-2-Core/core.html#ID-102161490 DOM Level 2 Core
+   * @see https://www.w3.org/TR/DOM-Level-3-Core/core.html#ID-102161490 DOM Level 3 Core
+   * @see https://dom.spec.whatwg.org/#domimplementation DOM Living Standard
    */
-  function DOMImplementation$1(/* Object */ features) {
-  	this._features = {};
-  	if (features) {
-  		for (var feature in features) {
-  			 this._features = features[feature];
-  		}
-  	}
+  function DOMImplementation$1() {
   }
+
   DOMImplementation$1.prototype = {
-  	hasFeature: function(/* string */ feature, /* string */ version) {
-  		var versions = this._features[feature.toLowerCase()];
-  		if (versions && (!version || version in versions)) {
+  	/**
+  	 * The DOMImplementation.hasFeature() method returns a Boolean flag indicating if a given feature is supported.
+  	 * The different implementations fairly diverged in what kind of features were reported.
+  	 * The latest version of the spec settled to force this method to always return true, where the functionality was accurate and in use.
+  	 *
+  	 * @deprecated It is deprecated and modern browsers return true in all cases.
+  	 *
+  	 * @param {string} feature
+  	 * @param {string} [version]
+  	 * @returns {boolean} always true
+  	 *
+  	 * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation/hasFeature MDN
+  	 * @see https://www.w3.org/TR/REC-DOM-Level-1/level-one-core.html#ID-5CED94D7 DOM Level 1 Core
+  	 * @see https://dom.spec.whatwg.org/#dom-domimplementation-hasfeature DOM Living Standard
+  	 */
+  	hasFeature: function(feature, version) {
   			return true;
-  		} else {
-  			return false;
-  		}
   	},
-  	// Introduced in DOM Level 2:
-  	createDocument:function(namespaceURI,  qualifiedName, doctype){// raises:INVALID_CHARACTER_ERR,NAMESPACE_ERR,WRONG_DOCUMENT_ERR
+  	/**
+  	 * Creates an XML Document object of the specified type with its document element.
+  	 *
+  	 * __It behaves slightly different from the description in the living standard__:
+  	 * - There is no interface/class `XMLDocument`, it returns a `Document` instance.
+  	 * - `contentType`, `encoding`, `mode`, `origin`, `url` fields are currently not declared.
+  	 * - this implementation is not validating names or qualified names
+  	 *   (when parsing XML strings, the SAX parser takes care of that)
+  	 *
+  	 * @param {string|null} namespaceURI
+  	 * @param {string} qualifiedName
+  	 * @param {DocumentType=null} doctype
+  	 * @returns {Document}
+  	 *
+  	 * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation/createDocument MDN
+  	 * @see https://www.w3.org/TR/DOM-Level-2-Core/core.html#Level-2-Core-DOM-createDocument DOM Level 2 Core (initial)
+  	 * @see https://dom.spec.whatwg.org/#dom-domimplementation-createdocument  DOM Level 2 Core
+  	 *
+  	 * @see https://dom.spec.whatwg.org/#validate-and-extract DOM: Validate and extract
+  	 * @see https://www.w3.org/TR/xml/#NT-NameStartChar XML Spec: Names
+  	 * @see https://www.w3.org/TR/xml-names/#ns-qualnames XML Namespaces: Qualified names
+  	 */
+  	createDocument: function(namespaceURI,  qualifiedName, doctype){
   		var doc = new Document();
   		doc.implementation = this;
   		doc.childNodes = new NodeList();
-  		doc.doctype = doctype;
-  		if(doctype){
+  		doc.doctype = doctype || null;
+  		if (doctype){
   			doc.appendChild(doctype);
   		}
-  		if(qualifiedName){
-  			var root = doc.createElementNS(namespaceURI,qualifiedName);
+  		if (qualifiedName){
+  			var root = doc.createElementNS(namespaceURI, qualifiedName);
   			doc.appendChild(root);
   		}
   		return doc;
   	},
-  	// Introduced in DOM Level 2:
-  	createDocumentType:function(qualifiedName, publicId, systemId){// raises:INVALID_CHARACTER_ERR,NAMESPACE_ERR
+  	/**
+  	 * Returns a doctype, with the given `qualifiedName`, `publicId`, and `systemId`.
+  	 *
+  	 * __This behavior is slightly different from the in the specs__:
+  	 * - this implementation is not validating names or qualified names
+  	 *   (when parsing XML strings, the SAX parser takes care of that)
+  	 *
+  	 * @param {string} qualifiedName
+  	 * @param {string} [publicId]
+  	 * @param {string} [systemId]
+  	 * @returns {DocumentType} which can either be used with `DOMImplementation.createDocument` upon document creation
+  	 * 				  or can be put into the document via methods like `Node.insertBefore()` or `Node.replaceChild()`
+  	 *
+  	 * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation/createDocumentType MDN
+  	 * @see https://www.w3.org/TR/DOM-Level-2-Core/core.html#Level-2-Core-DOM-createDocType DOM Level 2 Core
+  	 * @see https://dom.spec.whatwg.org/#dom-domimplementation-createdocumenttype DOM Living Standard
+  	 *
+  	 * @see https://dom.spec.whatwg.org/#validate-and-extract DOM: Validate and extract
+  	 * @see https://www.w3.org/TR/xml/#NT-NameStartChar XML Spec: Names
+  	 * @see https://www.w3.org/TR/xml-names/#ns-qualnames XML Namespaces: Qualified names
+  	 */
+  	createDocumentType: function(qualifiedName, publicId, systemId){
   		var node = new DocumentType();
   		node.name = qualifiedName;
   		node.nodeName = qualifiedName;
-  		node.publicId = publicId;
-  		node.systemId = systemId;
-  		// Introduced in DOM Level 2:
-  		//readonly attribute DOMString        internalSubset;
-  		
-  		//TODO:..
-  		//  readonly attribute NamedNodeMap     entities;
-  		//  readonly attribute NamedNodeMap     notations;
+  		node.publicId = publicId || '';
+  		node.systemId = systemId || '';
+
   		return node;
   	}
   };
@@ -25773,22 +26499,25 @@ If this message still persists after updating, please report an issue: https://g
 
   function Document(){
   }
+
   function _onAddAttribute(doc,el,newAttr){
   	doc && doc._inc++;
   	var ns = newAttr.namespaceURI ;
-  	if(ns == 'http://www.w3.org/2000/xmlns/'){
+  	if(ns === NAMESPACE$1.XMLNS){
   		//update namespace
   		el._nsMap[newAttr.prefix?newAttr.localName:''] = newAttr.value;
   	}
   }
+
   function _onRemoveAttribute(doc,el,newAttr,remove){
   	doc && doc._inc++;
   	var ns = newAttr.namespaceURI ;
-  	if(ns == 'http://www.w3.org/2000/xmlns/'){
+  	if(ns === NAMESPACE$1.XMLNS){
   		//update namespace
   		delete el._nsMap[newAttr.prefix?newAttr.localName:''];
   	}
   }
+
   function _onUpdateChild(doc,el,newChild){
   	if(doc && doc._inc){
   		doc._inc++;
@@ -25904,8 +26633,8 @@ If this message still persists after updating, please report an issue: https://g
   	doctype :  null,
   	documentElement :  null,
   	_inc : 1,
-  	
-  	insertBefore :  function(newChild, refChild){//raises 
+
+  	insertBefore :  function(newChild, refChild){//raises
   		if(newChild.nodeType == DOCUMENT_FRAGMENT_NODE){
   			var child = newChild.firstChild;
   			while(child){
@@ -25918,7 +26647,7 @@ If this message still persists after updating, please report an issue: https://g
   		if(this.documentElement == null && newChild.nodeType == ELEMENT_NODE){
   			this.documentElement = newChild;
   		}
-  		
+
   		return _insertBefore(this,newChild,refChild),(newChild.ownerDocument = this),newChild;
   	},
   	removeChild :  function(oldChild){
@@ -25944,28 +26673,58 @@ If this message still persists after updating, please report an issue: https://g
   		});
   		return rtv;
   	},
-  	
-  	getElementsByClassName: function(className) {
-  		var pattern = new RegExp("(^|\\s)" + className + "(\\s|$)");
+
+  	/**
+  	 * The `getElementsByClassName` method of `Document` interface returns an array-like object
+  	 * of all child elements which have **all** of the given class name(s).
+  	 *
+  	 * Returns an empty list if `classeNames` is an empty string or only contains HTML white space characters.
+  	 *
+  	 *
+  	 * Warning: This is a live LiveNodeList.
+  	 * Changes in the DOM will reflect in the array as the changes occur.
+  	 * If an element selected by this array no longer qualifies for the selector,
+  	 * it will automatically be removed. Be aware of this for iteration purposes.
+  	 *
+  	 * @param {string} classNames is a string representing the class name(s) to match; multiple class names are separated by (ASCII-)whitespace
+  	 *
+  	 * @see https://developer.mozilla.org/en-US/docs/Web/API/Document/getElementsByClassName
+  	 * @see https://dom.spec.whatwg.org/#concept-getelementsbyclassname
+  	 */
+  	getElementsByClassName: function(classNames) {
+  		var classNamesSet = toOrderedSet(classNames);
   		return new LiveNodeList(this, function(base) {
   			var ls = [];
-  			_visitNode(base.documentElement, function(node) {
-  				if(node !== base && node.nodeType == ELEMENT_NODE) {
-  					if(pattern.test(node.getAttribute('class'))) {
-  						ls.push(node);
+  			if (classNamesSet.length > 0) {
+  				_visitNode(base.documentElement, function(node) {
+  					if(node !== base && node.nodeType === ELEMENT_NODE) {
+  						var nodeClassNames = node.getAttribute('class');
+  						// can be null if the attribute does not exist
+  						if (nodeClassNames) {
+  							// before splitting and iterating just compare them for the most common case
+  							var matches = classNames === nodeClassNames;
+  							if (!matches) {
+  								var nodeClassNamesSet = toOrderedSet(nodeClassNames);
+  								matches = classNamesSet.every(arrayIncludes(nodeClassNamesSet));
+  							}
+  							if(matches) {
+  								ls.push(node);
+  							}
+  						}
   					}
-  				}
-  			});
+  				});
+  			}
   			return ls;
   		});
   	},
-  	
+
   	//document factory method:
   	createElement :	function(tagName){
   		var node = new Element();
   		node.ownerDocument = this;
   		node.nodeName = tagName;
   		node.tagName = tagName;
+  		node.localName = tagName;
   		node.childNodes = new NodeList();
   		var attrs	= node.attributes = new NamedNodeMap();
   		attrs._ownerElement = node;
@@ -26272,36 +27031,49 @@ If this message still persists after updating, please report an issue: https://g
   	//console.log('###',this.nodeType,uri,prefix,buf.join(''))
   	return buf.join('');
   }
-  function needNamespaceDefine(node,isHTML, visibleNamespaces) {
-  	var prefix = node.prefix||'';
+
+  function needNamespaceDefine(node, isHTML, visibleNamespaces) {
+  	var prefix = node.prefix || '';
   	var uri = node.namespaceURI;
-  	if (!prefix && !uri){
+  	// According to [Namespaces in XML 1.0](https://www.w3.org/TR/REC-xml-names/#ns-using) ,
+  	// and more specifically https://www.w3.org/TR/REC-xml-names/#nsc-NoPrefixUndecl :
+  	// > In a namespace declaration for a prefix [...], the attribute value MUST NOT be empty.
+  	// in a similar manner [Namespaces in XML 1.1](https://www.w3.org/TR/xml-names11/#ns-using)
+  	// and more specifically https://www.w3.org/TR/xml-names11/#nsc-NSDeclared :
+  	// > [...] Furthermore, the attribute value [...] must not be an empty string.
+  	// so serializing empty namespace value like xmlns:ds="" would produce an invalid XML document.
+  	if (!uri) {
   		return false;
   	}
-  	if (prefix === "xml" && uri === "http://www.w3.org/XML/1998/namespace" 
-  		|| uri == 'http://www.w3.org/2000/xmlns/'){
+  	if (prefix === "xml" && uri === NAMESPACE$1.XML || uri === NAMESPACE$1.XMLNS) {
   		return false;
   	}
   	
   	var i = visibleNamespaces.length; 
-  	//console.log('@@@@',node.tagName,prefix,uri,visibleNamespaces)
   	while (i--) {
   		var ns = visibleNamespaces[i];
   		// get namespace prefix
-  		//console.log(node.nodeType,node.tagName,ns.prefix,prefix)
-  		if (ns.prefix == prefix){
-  			return ns.namespace != uri;
+  		if (ns.prefix === prefix) {
+  			return ns.namespace !== uri;
   		}
   	}
-  	//console.log(isHTML,uri,prefix=='')
-  	//if(isHTML && prefix ==null && uri == 'http://www.w3.org/1999/xhtml'){
-  	//	return false;
-  	//}
-  	//node.flag = '11111'
-  	//console.error(3,true,node.flag,node.prefix,node.namespaceURI)
   	return true;
   }
+  /**
+   * Well-formed constraint: No < in Attribute Values
+   * The replacement text of any entity referred to directly or indirectly in an attribute value must not contain a <.
+   * @see https://www.w3.org/TR/xml/#CleanAttrVals
+   * @see https://www.w3.org/TR/xml/#NT-AttValue
+   */
+  function addSerializedAttribute(buf, qualifiedName, value) {
+  	buf.push(' ', qualifiedName, '="', value.replace(/[<&"]/g,_xmlEncoder), '"');
+  }
+
   function serializeToString(node,buf,isHTML,nodeFilter,visibleNamespaces){
+  	if (!visibleNamespaces) {
+  		visibleNamespaces = [];
+  	}
+
   	if(nodeFilter){
   		node = nodeFilter(node);
   		if(node){
@@ -26314,20 +27086,40 @@ If this message still persists after updating, please report an issue: https://g
   		}
   		//buf.sort.apply(attrs, attributeSorter);
   	}
+
   	switch(node.nodeType){
   	case ELEMENT_NODE:
-  		if (!visibleNamespaces) visibleNamespaces = [];
-  		visibleNamespaces.length;
   		var attrs = node.attributes;
   		var len = attrs.length;
   		var child = node.firstChild;
   		var nodeName = node.tagName;
   		
-  		isHTML =  (htmlns === node.namespaceURI) ||isHTML; 
-  		buf.push('<',nodeName);
-  		
-  		
-  		
+  		isHTML = NAMESPACE$1.isHTML(node.namespaceURI) || isHTML;
+
+  		var prefixedNodeName = nodeName;
+  		if (!isHTML && !node.prefix && node.namespaceURI) {
+  			var defaultNS;
+  			for (var ai = 0; ai < attrs.length; ai++) {
+  				if (attrs.item(ai).name === 'xmlns') {
+  					defaultNS = attrs.item(ai).value;
+  					break
+  				}
+  			}
+  			if (defaultNS !== node.namespaceURI) {
+  				for (var nsi = visibleNamespaces.length - 1; nsi >= 0; nsi--) {
+  					var namespace = visibleNamespaces[nsi];
+  					if (namespace.namespace === node.namespaceURI) {
+  						if (namespace.prefix) {
+  							prefixedNodeName = namespace.prefix + ':' + nodeName;
+  						}
+  						break
+  					}
+  				}
+  			}
+  		}
+
+  		buf.push('<', prefixedNodeName);
+
   		for(var i=0;i<len;i++){
   			// add namespaces for attributes
   			var attr = attrs.item(i);
@@ -26337,28 +27129,24 @@ If this message still persists after updating, please report an issue: https://g
   				visibleNamespaces.push({ prefix: '', namespace: attr.value });
   			}
   		}
+
   		for(var i=0;i<len;i++){
   			var attr = attrs.item(i);
   			if (needNamespaceDefine(attr,isHTML, visibleNamespaces)) {
   				var prefix = attr.prefix||'';
   				var uri = attr.namespaceURI;
-  				var ns = prefix ? ' xmlns:' + prefix : " xmlns";
-  				buf.push(ns, '="' , uri , '"');
+  				addSerializedAttribute(buf, prefix ? 'xmlns:' + prefix : "xmlns", uri);
   				visibleNamespaces.push({ prefix: prefix, namespace:uri });
   			}
   			serializeToString(attr,buf,isHTML,nodeFilter,visibleNamespaces);
   		}
+
   		// add namespace for current node		
-  		if (needNamespaceDefine(node,isHTML, visibleNamespaces)) {
+  		if (nodeName === prefixedNodeName && needNamespaceDefine(node, isHTML, visibleNamespaces)) {
   			var prefix = node.prefix||'';
   			var uri = node.namespaceURI;
-  			if (uri) {
-  				// Avoid empty namespace value like xmlns:ds=""
-  				// Empty namespace URL will we produce an invalid XML document
-  				var ns = prefix ? ' xmlns:' + prefix : " xmlns";
-  				buf.push(ns, '="' , uri , '"');
-  				visibleNamespaces.push({ prefix: prefix, namespace:uri });
-  			}
+  			addSerializedAttribute(buf, prefix ? 'xmlns:' + prefix : "xmlns", uri);
+  			visibleNamespaces.push({ prefix: prefix, namespace:uri });
   		}
   		
   		if(child || isHTML && !/^(?:meta|link|img|br|hr|input)$/i.test(nodeName)){
@@ -26369,18 +27157,18 @@ If this message still persists after updating, please report an issue: https://g
   					if(child.data){
   						buf.push(child.data);
   					}else {
-  						serializeToString(child,buf,isHTML,nodeFilter,visibleNamespaces);
+  						serializeToString(child, buf, isHTML, nodeFilter, visibleNamespaces.slice());
   					}
   					child = child.nextSibling;
   				}
   			}else
   			{
   				while(child){
-  					serializeToString(child,buf,isHTML,nodeFilter,visibleNamespaces);
+  					serializeToString(child, buf, isHTML, nodeFilter, visibleNamespaces.slice());
   					child = child.nextSibling;
   				}
   			}
-  			buf.push('</',nodeName,'>');
+  			buf.push('</',prefixedNodeName,'>');
   		}else {
   			buf.push('/>');
   		}
@@ -26391,18 +27179,12 @@ If this message still persists after updating, please report an issue: https://g
   	case DOCUMENT_FRAGMENT_NODE:
   		var child = node.firstChild;
   		while(child){
-  			serializeToString(child,buf,isHTML,nodeFilter,visibleNamespaces);
+  			serializeToString(child, buf, isHTML, nodeFilter, visibleNamespaces.slice());
   			child = child.nextSibling;
   		}
   		return;
   	case ATTRIBUTE_NODE:
-  		/**
-  		 * Well-formedness constraint: No < in Attribute Values
-  		 * The replacement text of any entity referred to directly or indirectly in an attribute value must not contain a <.
-  		 * @see https://www.w3.org/TR/xml/#CleanAttrVals
-  		 * @see https://www.w3.org/TR/xml/#NT-AttValue
-  		 */
-  		return buf.push(' ', node.name, '="', node.value.replace(/[<&"]/g,_xmlEncoder), '"');
+  		return addSerializedAttribute(buf, node.name, node.value);
   	case TEXT_NODE:
   		/**
   		 * The ampersand character (&) and the left angle bracket (<) must not appear in their literal form,
@@ -26553,10 +27335,12 @@ If this message still persists after updating, please report an issue: https://g
   				return this.$$length;
   			}
   		});
+
   		Object.defineProperty(Node.prototype,'textContent',{
   			get:function(){
   				return getTextContent(this);
   			},
+
   			set:function(data){
   				switch(this.nodeType){
   				case ELEMENT_NODE:
@@ -26568,8 +27352,8 @@ If this message still persists after updating, please report an issue: https://g
   						this.appendChild(this.ownerDocument.createTextNode(data));
   					}
   					break;
+
   				default:
-  					//TODO:
   					this.data = data;
   					this.value = data;
   					this.nodeValue = data;
@@ -26594,6 +27378,7 @@ If this message still persists after updating, please report an issue: https://g
   				return node.nodeValue;
   			}
   		}
+
   		__set__ = function(object,key,value){
   			//console.log(value)
   			object['$$'+key] = value;
@@ -26603,11 +27388,19 @@ If this message still persists after updating, please report an issue: https://g
   }
 
   //if(typeof require == 'function'){
-  	dom.Node = Node;
+  	dom.DocumentType = DocumentType;
   	dom.DOMException = DOMException;
   	dom.DOMImplementation = DOMImplementation$1;
+  	dom.Element = Element;
+  	dom.Node = Node;
+  	dom.NodeList = NodeList;
   	dom.XMLSerializer = XMLSerializer;
 
+  var conventions = conventions$2;
+  var entities = entities$1;
+
+  var NAMESPACE = conventions.NAMESPACE;
+
   function DOMParser(options){
   	this.options = options ||{locator:{}};
   }
@@ -26620,7 +27413,7 @@ If this message still persists after updating, please report an issue: https://g
   	var locator = options.locator;
   	var defaultNSMap = options.xmlns||{};
   	var isHTML = /\/x?html?$/.test(mimeType);//mimeType.toLowerCase().indexOf('html') > -1;
-    	var entityMap = isHTML?htmlEntity.entityMap:{'lt':'<','gt':'>','amp':'&','quot':'"','apos':"'"};
+    	var entityMap = isHTML ? entities.HTML_ENTITIES : entities.XML_ENTITIES;
   	if(locator){
   		domBuilder.setDocumentLocator(locator);
   	}
@@ -26628,9 +27421,9 @@ If this message still persists after updating, please report an issue: https://g
   	sax.errorHandler = buildErrorHandler(errorHandler,domBuilder,locator);
   	sax.domBuilder = options.domBuilder || domBuilder;
   	if(isHTML){
-  		defaultNSMap['']= 'http://www.w3.org/1999/xhtml';
+  		defaultNSMap[''] = NAMESPACE.HTML;
   	}
-  	defaultNSMap.xml = defaultNSMap.xml || 'http://www.w3.org/XML/1998/namespace';
+  	defaultNSMap.xml = defaultNSMap.xml || NAMESPACE.XML;
   	if(source && typeof source === 'string'){
   		sax.parse(source,defaultNSMap,entityMap);
   	}else {
@@ -26852,7 +27645,6 @@ If this message still persists after updating, please report an issue: https://g
   }//appendChild and setAttributeNS are preformance key
 
   //if(typeof require == 'function'){
-  var htmlEntity = entities;
   var sax = sax$1;
   var XMLReader = sax.XMLReader;
   var ParseError = sax.ParseError;
@@ -27599,6 +28391,23 @@ If this message still persists after updating, please report an issue: https://g
       };
   }
 
+  /**
+   * Pipes all emitted events from one emitter to another.
+   */
+  function pipeEvents(source, destination) {
+      const rawEmit = source.emit;
+      // @ts-ignore
+      if (rawEmit._isPiped) {
+          return;
+      }
+      source.emit = function (event, ...data) {
+          destination.emit(event, ...data);
+          return rawEmit.call(this, event, ...data);
+      };
+      // @ts-ignore
+      source.emit._isPiped = true;
+  }
+
   // Declare the list of event handlers on the module's scope
   // so it persists between Fash refreshes of the application's code.
   let listeners = [];
@@ -27617,12 +28426,15 @@ If this message still persists after updating, please report an issue: https://g
       if (lib$5.exports.isNodeProcess()) {
           throw new Error(devUtils.formatMessage('Failed to execute `setupWorker` in a non-browser environment. Consider using `setupServer` for Node.js environment instead.'));
       }
+      const emitter = new lib$4.StrictEventEmitter();
+      const publicEmitter = new lib$4.StrictEventEmitter();
+      pipeEvents(emitter, publicEmitter);
       const context = {
           startOptions: undefined,
           worker: null,
           registration: null,
           requestHandlers: [...requestHandlers],
-          emitter: new lib$4.StrictEventEmitter(),
+          emitter,
           workerChannel: {
               on(eventType, callback) {
                   context.events.addListener(navigator.serviceWorker, 'message', (event) => {
@@ -27688,7 +28500,12 @@ If this message still persists after updating, please report an issue: https://g
           : createStop(context);
       return {
           start: prepareStartHandler(startHandler, context),
-          stop: stopHandler,
+          stop() {
+              context.events.removeAllListeners();
+              context.emitter.removeAllListeners();
+              publicEmitter.removeAllListeners();
+              stopHandler();
+          },
           use(...handlers) {
               use(context.requestHandlers, ...handlers);
           },
@@ -27715,8 +28532,16 @@ If this message still persists after updating, please report an issue: https://g
                   console.groupEnd();
               });
           },
-          on(eventType, listener) {
-              context.emitter.addListener(eventType, listener);
+          events: {
+              on(...args) {
+                  return publicEmitter.on(...args);
+              },
+              removeListener(...args) {
+                  return publicEmitter.removeListener(...args);
+              },
+              removeAllListeners(...args) {
+                  return publicEmitter.removeAllListeners(...args);
+              },
           },
       };
   }
@@ -27727,6 +28552,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),
@@ -27787,6 +28613,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;
@@ -27802,4 +28629,4 @@ If this message still persists after updating, please report an issue: https://g
   exports.restContext = restContext;
   exports.setupWorker = setupWorker;
 
-})));
+}));