msw 0.28.2 → 0.29.0

package/lib/esm/index.js

@@ -1,15 +1,20 @@
 export { i as context } from './index-deps.js';
-import { c as createCommonjsModule, a as commonjsGlobal, l as lib$2, j as jsonParse, i as isNodeProcess } from './fetch-deps.js';
-import { _ as __awaiter, g as getPublicUrlFromRequest, p as parseBody, N as NetworkError } from './RequestHandler-deps.js';
-export { R as RequestHandler, b as compose, c as createResponseComposition, a as defaultContext, d as defaultResponse, m as matchRequestUrl, r as response } from './RequestHandler-deps.js';
+import { c as commonjsGlobal, l as lib$4, i as isNodeProcess, j as jsonParse } from './fetch-deps.js';
+import { _ as __awaiter$2, p as parseBody, g as getPublicUrlFromRequest, N as NetworkError, a as getCleanUrl } from './RequestHandler-deps.js';
+export { R as RequestHandler, e as compose, c as createResponseComposition, b as defaultContext, d as defaultResponse, m as matchRequestUrl, r as response } from './RequestHandler-deps.js';
+import { p as parse_1 } from './xml-deps.js';
+import { i as isStringEqual, R as RestHandler } from './rest-deps.js';
+export { a as RESTMethods, R as RestHandler, r as rest, b as restContext } from './rest-deps.js';
 import { p as parseGraphQLRequest, G as GraphQLHandler } from './graphql-deps.js';
 export { G as GraphQLHandler, g as graphql, a as graphqlContext } from './graphql-deps.js';
-import { R as RestHandler, i as isStringEqual } from './rest-deps.js';
-export { a as RESTMethods, R as RestHandler, r as rest, b as restContext } from './rest-deps.js';
-import { p as parse_1$1 } from './xml-deps.js';
 import { m as mergeRight } from './errors-deps.js';
+import require$$1 from 'debug';
+
+var lib$3 = {};
+
+var StrictEventEmitter$1 = {};
 
-// Copyright Joyent, Inc. and other Node contributors.
+var events = {exports: {}};
 
 var R = typeof Reflect === 'object' ? Reflect : null;
 var ReflectApply = R && typeof R.apply === 'function'
@@ -43,8 +48,8 @@ var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {
 function EventEmitter() {
   EventEmitter.init.call(this);
 }
-var events = EventEmitter;
-var once_1 = once;
+events.exports = EventEmitter;
+events.exports.once = once;
 
 // Backwards-compat with node 0.10.x
 EventEmitter.EventEmitter = EventEmitter;
@@ -484,10 +489,8 @@ function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
     throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
   }
 }
-events.once = once_1;
 
-var StrictEventEmitter_1 = createCommonjsModule(function (module, exports) {
-var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
+var __extends$1 = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
     var extendStatics = function (d, b) {
         extendStatics = Object.setPrototypeOf ||
             ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
@@ -507,11 +510,11 @@ var __spreadArrays = (commonjsGlobal && commonjsGlobal.__spreadArrays) || functi
             r[k] = a[j];
     return r;
 };
-exports.__esModule = true;
-exports.StrictEventEmitter = void 0;
-
+StrictEventEmitter$1.__esModule = true;
+StrictEventEmitter$1.StrictEventEmitter = void 0;
+var events_1 = events.exports;
 var StrictEventEmitter = /** @class */ (function (_super) {
-    __extends(StrictEventEmitter, _super);
+    __extends$1(StrictEventEmitter, _super);
     function StrictEventEmitter() {
         return _super.call(this) || this;
     }
@@ -538,11 +541,10 @@ var StrictEventEmitter = /** @class */ (function (_super) {
         return _super.prototype.removeListener.call(this, event.toString(), listener);
     };
     return StrictEventEmitter;
-}(events.EventEmitter));
-exports.StrictEventEmitter = StrictEventEmitter;
-});
+}(events_1.EventEmitter));
+StrictEventEmitter$1.StrictEventEmitter = StrictEventEmitter;
 
-var lib = createCommonjsModule(function (module, exports) {
+(function (exports) {
 var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
@@ -552,16 +554,21 @@ var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Obj
 }));
 exports.__esModule = true;
 exports.StrictEventEmitter = void 0;
-
+var StrictEventEmitter_1 = StrictEventEmitter$1;
 __createBinding(exports, StrictEventEmitter_1, "StrictEventEmitter");
-});
+}(lib$3));
+
+var lib$2 = {};
 
+var until$1 = {};
+
+Object.defineProperty(until$1, "__esModule", { value: true });
 /**
  * Gracefully handles a given Promise factory.
  * @example
  * cosnt [error, data] = await until(() => asyncAction())
  */
-var until_1 = async (promise) => {
+until$1.until = async (promise) => {
     try {
         const data = await promise().catch((error) => {
             throw error;
@@ -573,11 +580,9 @@ var until_1 = async (promise) => {
     }
 };
 
-var until = /*#__PURE__*/Object.defineProperty({
-	until: until_1
-}, '__esModule', {value: true});
-
-var until$1 = until.until;
+Object.defineProperty(lib$2, "__esModule", { value: true });
+var until_1$1 = until$1;
+var until = lib$2.until = until_1$1.until;
 
 /**
  * Attempts to resolve a Service Worker instance from a given registration,
@@ -608,7 +613,7 @@ function getAbsoluteWorkerUrl(relativeUrl) {
  * Returns an active Service Worker instance.
  * When not found, registers a new Service Worker.
  */
-const getWorkerInstance = (url, options = {}, findWorker) => __awaiter(void 0, void 0, void 0, function* () {
+const getWorkerInstance = (url, options = {}, findWorker) => __awaiter$2(void 0, void 0, void 0, function* () {
     // Resolve the absolute Service Worker URL.
     const absoluteWorkerUrl = getAbsoluteWorkerUrl(url);
     const mockRegistrations = yield navigator.serviceWorker
@@ -634,7 +639,7 @@ const getWorkerInstance = (url, options = {}, findWorker) => __awaiter(void 0, v
         });
     }
     // When the Service Worker wasn't found, register it anew and return the reference.
-    const [error, instance] = yield until$1(() => __awaiter(void 0, void 0, void 0, function* () {
+    const [error, instance] = yield until(() => __awaiter$2(void 0, void 0, void 0, function* () {
         const registration = yield navigator.serviceWorker.register(url, options);
         return [
             // Compare existing worker registration by its worker URL,
@@ -662,17 +667,31 @@ Learn more about creating the Service Worker script: https://mswjs.io/docs/cli/i
     return instance;
 });
 
-const activateMocking = (context, options) => __awaiter(void 0, void 0, void 0, function* () {
-    context.workerChannel.send('MOCK_ACTIVATE');
-    return context.events.once('MOCKING_ENABLED').then(() => {
-        if (!(options === null || options === void 0 ? void 0 : options.quiet)) {
-            console.groupCollapsed('%c[MSW] Mocking enabled.', 'color:orangered;font-weight:bold;');
-            console.log('%cDocumentation: %chttps://mswjs.io/docs', 'font-weight:bold', 'font-weight:normal');
-            console.log('Found an issue? https://github.com/mswjs/msw/issues');
-            console.groupEnd();
-        }
+/**
+ * Prints a worker activation message in the browser's console.
+ */
+function printStartMessage(args = {}) {
+    if (args.quiet) {
+        return;
+    }
+    const message = args.message || 'Mocking enabled.';
+    console.groupCollapsed(`%c[MSW] ${message}`, 'color:orangered;font-weight:bold;');
+    console.log('%cDocumentation: %chttps://mswjs.io/docs', 'font-weight:bold', 'font-weight:normal');
+    console.log('Found an issue? https://github.com/mswjs/msw/issues');
+    console.groupEnd();
+}
+
+/**
+ * Signals the worker to enable the interception of requests.
+ */
+function enableMocking(context, options) {
+    return __awaiter$2(this, void 0, void 0, function* () {
+        context.workerChannel.send('MOCK_ACTIVATE');
+        return context.events.once('MOCKING_ENABLED').then(() => {
+            printStartMessage({ quiet: options.quiet });
+        });
     });
-});
+}
 
 /**
  * Creates a communication channel between the client
@@ -692,386 +711,123 @@ const createBroadcastChannel = (event) => {
     };
 };
 
-/**
- * Returns a mocked response for a given request using following request handlers.
- */
-const getResponse = (request, handlers) => __awaiter(void 0, void 0, void 0, function* () {
-    const relevantHandlers = handlers.filter((handler) => {
-        return handler.test(request);
-    });
-    if (relevantHandlers.length === 0) {
-        return {
-            handler: undefined,
-            response: undefined,
-        };
-    }
-    const result = yield relevantHandlers.reduce((acc, handler) => __awaiter(void 0, void 0, void 0, function* () {
-        const previousResults = yield acc;
-        if (!!(previousResults === null || previousResults === void 0 ? void 0 : previousResults.response)) {
-            return acc;
-        }
-        const result = yield handler.run(request);
-        if (result === null || result.handler.shouldSkip) {
-            return null;
-        }
-        if (!result.response) {
-            return {
-                request: result.request,
-                handler: result.handler,
-                response: undefined,
-                parsedResult: result.parsedResult,
-            };
-        }
-        if (result.response.once) {
-            handler.markAsSkipped(true);
-        }
-        return result;
-    }), Promise.resolve(null));
-    // Although reducing a list of relevant request handlers, it's possible
-    // that in the end there will be no handler associted with the request
-    // (i.e. if relevant handlers are fall-through).
-    if (!result) {
-        return {
-            handler: undefined,
-            response: undefined,
-        };
-    }
-    return {
-        handler: result.handler,
-        publicRequest: result.request,
-        parsedRequest: result.parsedResult,
-        response: result.response,
-    };
-});
+var lib$1 = {};
 
-var jsLevenshtein = (function()
-{
-  function _min(d0, d1, d2, bx, ay)
-  {
-    return d0 < d1 || d2 < d1
-        ? d0 > d2
-            ? d2 + 1
-            : d0 + 1
-        : bx === ay
-            ? d1
-            : d1 + 1;
-  }
+var CookieStore = {};
 
-  return function(a, b)
-  {
-    if (a === b) {
-      return 0;
-    }
+var setCookie = {exports: {}};
 
-    if (a.length > b.length) {
-      var tmp = a;
-      a = b;
-      b = tmp;
-    }
+var defaultParseOptions = {
+  decodeValues: true,
+  map: false,
+  silent: false,
+};
 
-    var la = a.length;
-    var lb = b.length;
+function isNonEmptyString(str) {
+  return typeof str === "string" && !!str.trim();
+}
 
-    while (la > 0 && (a.charCodeAt(la - 1) === b.charCodeAt(lb - 1))) {
-      la--;
-      lb--;
-    }
+function parseString(setCookieValue, options) {
+  var parts = setCookieValue.split(";").filter(isNonEmptyString);
+  var nameValue = parts.shift().split("=");
+  var name = nameValue.shift();
+  var value = nameValue.join("="); // everything after the first =, joined by a "=" if there was more than one part
 
-    var offset = 0;
+  options = options
+    ? Object.assign({}, defaultParseOptions, options)
+    : defaultParseOptions;
 
-    while (offset < la && (a.charCodeAt(offset) === b.charCodeAt(offset))) {
-      offset++;
-    }
+  try {
+    value = options.decodeValues ? decodeURIComponent(value) : value; // decode cookie value
+  } catch (e) {
+    console.error(
+      "set-cookie-parser encountered an error while decoding a cookie with value '" +
+        value +
+        "'. Set options.decodeValues to false to disable this feature.",
+      e
+    );
+  }
 
-    la -= offset;
-    lb -= offset;
+  var cookie = {
+    name: name, // grab everything before the first =
+    value: value,
+  };
 
-    if (la === 0 || lb < 3) {
-      return lb;
+  parts.forEach(function (part) {
+    var sides = part.split("=");
+    var key = sides.shift().trimLeft().toLowerCase();
+    var value = sides.join("=");
+    if (key === "expires") {
+      cookie.expires = new Date(value);
+    } else if (key === "max-age") {
+      cookie.maxAge = parseInt(value, 10);
+    } else if (key === "secure") {
+      cookie.secure = true;
+    } else if (key === "httponly") {
+      cookie.httpOnly = true;
+    } else if (key === "samesite") {
+      cookie.sameSite = value;
+    } else {
+      cookie[key] = value;
     }
+  });
 
-    var x = 0;
-    var y;
-    var d0;
-    var d1;
-    var d2;
-    var d3;
-    var dd;
-    var dy;
-    var ay;
-    var bx0;
-    var bx1;
-    var bx2;
-    var bx3;
+  return cookie;
+}
 
-    var vector = [];
+function parse$1(input, options) {
+  options = options
+    ? Object.assign({}, defaultParseOptions, options)
+    : defaultParseOptions;
 
-    for (y = 0; y < la; y++) {
-      vector.push(y + 1);
-      vector.push(a.charCodeAt(offset + y));
+  if (!input) {
+    if (!options.map) {
+      return [];
+    } else {
+      return {};
     }
+  }
 
-    var len = vector.length - 1;
-
-    for (; x < lb - 3;) {
-      bx0 = b.charCodeAt(offset + (d0 = x));
-      bx1 = b.charCodeAt(offset + (d1 = x + 1));
-      bx2 = b.charCodeAt(offset + (d2 = x + 2));
-      bx3 = b.charCodeAt(offset + (d3 = x + 3));
-      dd = (x += 4);
-      for (y = 0; y < len; y += 2) {
-        dy = vector[y];
-        ay = vector[y + 1];
-        d0 = _min(dy, d0, d1, bx0, ay);
-        d1 = _min(d0, d1, d2, bx1, ay);
-        d2 = _min(d1, d2, d3, bx2, ay);
-        dd = _min(d2, d3, dd, bx3, ay);
-        vector[y] = dd;
-        d3 = d2;
-        d2 = d1;
-        d1 = d0;
-        d0 = dy;
-      }
+  if (input.headers && input.headers["set-cookie"]) {
+    // fast-path for node.js (which automatically normalizes header names to lower-case
+    input = input.headers["set-cookie"];
+  } else if (input.headers) {
+    // slow-path for other environments - see #25
+    var sch =
+      input.headers[
+        Object.keys(input.headers).find(function (key) {
+          return key.toLowerCase() === "set-cookie";
+        })
+      ];
+    // warn if called on a request-like object with a cookie header rather than a set-cookie header - see #34, 36
+    if (!sch && input.headers.cookie && !options.silent) {
+      console.warn(
+        "Warning: set-cookie-parser appears to have been called on a request object. It is designed to parse Set-Cookie headers from responses, not Cookie headers from requests. Set the option {silent: true} to suppress this warning."
+      );
     }
+    input = sch;
+  }
+  if (!Array.isArray(input)) {
+    input = [input];
+  }
 
-    for (; x < lb;) {
-      bx0 = b.charCodeAt(offset + (d0 = x));
-      dd = ++x;
-      for (y = 0; y < len; y += 2) {
-        dy = vector[y];
-        vector[y] = dd = _min(dy, d0, dd, bx0, vector[y + 1]);
-        d0 = dy;
-      }
-    }
+  options = options
+    ? Object.assign({}, defaultParseOptions, options)
+    : defaultParseOptions;
 
-    return dd;
-  };
-})();
-
-const MAX_MATCH_SCORE = 3;
-const MAX_SUGGESTION_COUNT = 4;
-const TYPE_MATCH_DELTA = 0.5;
-function groupHandlersByType(handlers) {
-    return handlers.reduce((groups, handler) => {
-        if (handler instanceof RestHandler) {
-            groups.rest.push(handler);
-        }
-        if (handler instanceof GraphQLHandler) {
-            groups.graphql.push(handler);
-        }
-        return groups;
-    }, {
-        rest: [],
-        graphql: [],
-    });
-}
-function getScoreForRestHandler() {
-    return (request, handler) => {
-        const { mask, method } = handler.info;
-        if (mask instanceof RegExp) {
-            return Infinity;
-        }
-        const hasSameMethod = isStringEqual(request.method, method);
-        // Always treat a handler with the same method as a more similar one.
-        const methodScoreDelta = hasSameMethod ? TYPE_MATCH_DELTA : 0;
-        const requestPublicUrl = getPublicUrlFromRequest(request);
-        const score = jsLevenshtein(requestPublicUrl, mask);
-        return score - methodScoreDelta;
-    };
-}
-function getScoreForGraphQLHandler(parsedQuery) {
-    return (_, handler) => {
-        if (typeof parsedQuery.operationName === 'undefined') {
-            return Infinity;
-        }
-        const { operationType, operationName } = handler.info;
-        const hasSameOperationType = parsedQuery.operationType === operationType;
-        // Always treat a handler with the same operation type as a more similar one.
-        const operationTypeScoreDelta = hasSameOperationType ? TYPE_MATCH_DELTA : 0;
-        const score = jsLevenshtein(parsedQuery.operationName, operationName);
-        return score - operationTypeScoreDelta;
-    };
-}
-function getSuggestedHandler(request, handlers, getScore) {
-    const suggestedHandlers = handlers
-        .reduce((acc, handler) => {
-        const score = getScore(request, handler);
-        return acc.concat([[score, handler]]);
-    }, [])
-        .sort(([leftScore], [rightScore]) => {
-        return leftScore - rightScore;
-    })
-        .filter(([score]) => {
-        return score <= MAX_MATCH_SCORE;
-    })
-        .slice(0, MAX_SUGGESTION_COUNT)
-        .map(([, handler]) => handler);
-    return suggestedHandlers;
-}
-function getSuggestedHandlersMessage(handlers) {
-    if (handlers.length > 1) {
-        return `\
-Did you mean to request one of the following resources instead?
-
-${handlers.map((handler) => `  • ${handler.info.header}`).join('\n')}`;
-    }
-    return `Did you mean to request "${handlers[0].info.header}" instead?`;
-}
-function onUnhandledRequest(request, handlers, strategy = 'bypass') {
-    if (typeof strategy === 'function') {
-        strategy(request);
-        return;
-    }
-    const parsedGraphQLQuery = parseGraphQLRequest(request);
-    const handlerGroups = groupHandlersByType(handlers);
-    const relevantHandlers = parsedGraphQLQuery
-        ? handlerGroups.graphql
-        : handlerGroups.rest;
-    const suggestedHandlers = getSuggestedHandler(request, relevantHandlers, parsedGraphQLQuery
-        ? getScoreForGraphQLHandler(parsedGraphQLQuery)
-        : getScoreForRestHandler());
-    const handlerSuggestion = suggestedHandlers.length > 0
-        ? getSuggestedHandlersMessage(suggestedHandlers)
-        : '';
-    const publicUrl = getPublicUrlFromRequest(request);
-    const requestHeader = parsedGraphQLQuery
-        ? `${parsedGraphQLQuery.operationType} ${parsedGraphQLQuery.operationName} (${request.method} ${publicUrl})`
-        : `${request.method} ${publicUrl}`;
-    const messageTemplate = [
-        `captured a request without a matching request handler:`,
-        `  • ${requestHeader}`,
-        handlerSuggestion,
-        `\
-If you still wish to intercept this unhandled request, please create a request handler for it.
-Read more: https://mswjs.io/docs/getting-started/mocks\
-`,
-    ].filter(Boolean);
-    const message = messageTemplate.join('\n\n');
-    switch (strategy) {
-        case 'error': {
-            console.error(`[MSW] Error: ${message}`);
-            break;
-        }
-        case 'warn': {
-            console.warn(`[MSW] Warning: ${message}`);
-            break;
-        }
-        default:
-            return;
-    }
-}
-
-var defaultParseOptions = {
-  decodeValues: true,
-  map: false,
-  silent: false,
-};
-
-function isNonEmptyString(str) {
-  return typeof str === "string" && !!str.trim();
-}
-
-function parseString(setCookieValue, options) {
-  var parts = setCookieValue.split(";").filter(isNonEmptyString);
-  var nameValue = parts.shift().split("=");
-  var name = nameValue.shift();
-  var value = nameValue.join("="); // everything after the first =, joined by a "=" if there was more than one part
-
-  options = options
-    ? Object.assign({}, defaultParseOptions, options)
-    : defaultParseOptions;
-
-  try {
-    value = options.decodeValues ? decodeURIComponent(value) : value; // decode cookie value
-  } catch (e) {
-    console.error(
-      "set-cookie-parser encountered an error while decoding a cookie with value '" +
-        value +
-        "'. Set options.decodeValues to false to disable this feature.",
-      e
-    );
-  }
-
-  var cookie = {
-    name: name, // grab everything before the first =
-    value: value,
-  };
-
-  parts.forEach(function (part) {
-    var sides = part.split("=");
-    var key = sides.shift().trimLeft().toLowerCase();
-    var value = sides.join("=");
-    if (key === "expires") {
-      cookie.expires = new Date(value);
-    } else if (key === "max-age") {
-      cookie.maxAge = parseInt(value, 10);
-    } else if (key === "secure") {
-      cookie.secure = true;
-    } else if (key === "httponly") {
-      cookie.httpOnly = true;
-    } else if (key === "samesite") {
-      cookie.sameSite = value;
-    } else {
-      cookie[key] = value;
-    }
-  });
-
-  return cookie;
-}
-
-function parse(input, options) {
-  options = options
-    ? Object.assign({}, defaultParseOptions, options)
-    : defaultParseOptions;
-
-  if (!input) {
-    if (!options.map) {
-      return [];
-    } else {
-      return {};
-    }
-  }
-
-  if (input.headers && input.headers["set-cookie"]) {
-    // fast-path for node.js (which automatically normalizes header names to lower-case
-    input = input.headers["set-cookie"];
-  } else if (input.headers) {
-    // slow-path for other environments - see #25
-    var sch =
-      input.headers[
-        Object.keys(input.headers).find(function (key) {
-          return key.toLowerCase() === "set-cookie";
-        })
-      ];
-    // warn if called on a request-like object with a cookie header rather than a set-cookie header - see #34, 36
-    if (!sch && input.headers.cookie && !options.silent) {
-      console.warn(
-        "Warning: set-cookie-parser appears to have been called on a request object. It is designed to parse Set-Cookie headers from responses, not Cookie headers from requests. Set the option {silent: true} to suppress this warning."
-      );
-    }
-    input = sch;
-  }
-  if (!Array.isArray(input)) {
-    input = [input];
-  }
-
-  options = options
-    ? Object.assign({}, defaultParseOptions, options)
-    : defaultParseOptions;
-
-  if (!options.map) {
-    return input.filter(isNonEmptyString).map(function (str) {
-      return parseString(str, options);
-    });
-  } else {
-    var cookies = {};
-    return input.filter(isNonEmptyString).reduce(function (cookies, str) {
-      var cookie = parseString(str, options);
-      cookies[cookie.name] = cookie;
-      return cookies;
-    }, cookies);
-  }
-}
+  if (!options.map) {
+    return input.filter(isNonEmptyString).map(function (str) {
+      return parseString(str, options);
+    });
+  } else {
+    var cookies = {};
+    return input.filter(isNonEmptyString).reduce(function (cookies, str) {
+      var cookie = parseString(str, options);
+      cookies[cookie.name] = cookie;
+      return cookies;
+    }, cookies);
+  }
+}
 
 /*
   Set-Cookie header field-values are sometimes comma joined in one string. This splits them without choking on commas
@@ -1157,15 +913,12 @@ function splitCookiesString(cookiesString) {
   return cookiesStrings;
 }
 
-var setCookie = parse;
-var parse_1 = parse;
-var parseString_1 = parseString;
-var splitCookiesString_1 = splitCookiesString;
-setCookie.parse = parse_1;
-setCookie.parseString = parseString_1;
-setCookie.splitCookiesString = splitCookiesString_1;
+setCookie.exports = parse$1;
+setCookie.exports.parse = parse$1;
+setCookie.exports.parseString = parseString;
+setCookie.exports.splitCookiesString = splitCookiesString;
 
-var CookieStore_1 = createCommonjsModule(function (module, exports) {
+(function (exports) {
 var __rest = (commonjsGlobal && commonjsGlobal.__rest) || function (s, e) {
     var t = {};
     for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
@@ -1179,7 +932,7 @@ var __rest = (commonjsGlobal && commonjsGlobal.__rest) || function (s, e) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PERSISTENCY_KEY = void 0;
-
+const set_cookie_parser_1 = setCookie.exports;
 exports.PERSISTENCY_KEY = 'MSW_COOKIE_STORE';
 class CookieStore {
     constructor() {
@@ -1200,12 +953,12 @@ class CookieStore {
             return;
         }
         const now = Date.now();
-        const parsedResponseCookies = setCookie.parse(responseCookies).map((_a) => {
+        const parsedResponseCookies = set_cookie_parser_1.parse(responseCookies).map((_a) => {
             var { maxAge } = _a, cookie = __rest(_a, ["maxAge"]);
             return (Object.assign(Object.assign({}, cookie), { expires: maxAge === undefined
                     ? cookie.expires
                     : new Date(now + maxAge * 1000), maxAge }));
-        }).filter(({ expires }) => expires === undefined || expires.getTime() > now);
+        });
         const prevCookies = this.store.get(requestUrl.origin) || new Map();
         parsedResponseCookies.forEach((cookie) => {
             this.store.set(requestUrl.origin, prevCookies.set(cookie.name, cookie));
@@ -1221,7 +974,7 @@ class CookieStore {
         const originCookies = this.store.get(requestUrl.origin) || new Map();
         switch (request.credentials) {
             case 'include': {
-                const documentCookies = setCookie.parse(document.cookie);
+                const documentCookies = set_cookie_parser_1.parse(document.cookie);
                 documentCookies.forEach((cookie) => {
                     originCookies.set(cookie.name, cookie);
                 });
@@ -1318,21 +1071,21 @@ Invalid value has been removed from localStorage to prevent subsequent failed pa
     }
 }
 exports.default = new CookieStore();
-});
+}(CookieStore));
 
-var lib$1 = createCommonjsModule(function (module, exports) {
+(function (exports) {
 var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PERSISTENCY_KEY = exports.store = void 0;
-
+var CookieStore_1 = CookieStore;
 Object.defineProperty(exports, "store", { enumerable: true, get: function () { return __importDefault(CookieStore_1).default; } });
 Object.defineProperty(exports, "PERSISTENCY_KEY", { enumerable: true, get: function () { return CookieStore_1.PERSISTENCY_KEY; } });
-});
+}(lib$1));
 
 function getAllCookies() {
-    return parse_1$1(document.cookie);
+    return parse_1(document.cookie);
 }
 /**
  * Returns relevant document cookies based on the request `credentials` option.
@@ -1381,6 +1134,10 @@ function pruneGetRequestBody(request) {
     return request.body;
 }
 
+/**
+ * Converts a given request received from the Service Worker
+ * into a `MockedRequest` instance.
+ */
 function parseWorkerRequest(rawRequest) {
     const request = {
         id: rawRequest.id,
@@ -1399,7 +1156,7 @@ function parseWorkerRequest(rawRequest) {
         destination: rawRequest.destination,
         body: pruneGetRequestBody(rawRequest),
         bodyUsed: rawRequest.bodyUsed,
-        headers: new lib$2.Headers(rawRequest.headers),
+        headers: new lib$4.Headers(rawRequest.headers),
     };
     // Set document cookies on the request.
     setRequestCookies(request);
@@ -1408,61 +1165,370 @@ function parseWorkerRequest(rawRequest) {
     return request;
 }
 
-function readResponseCookies(request, response) {
-    lib$1.store.add(Object.assign(Object.assign({}, request), { url: request.url.toString() }), response);
-    lib$1.store.persist();
-}
-
-const createRequestListener = (context, options) => {
-    return (event, message) => __awaiter(void 0, void 0, void 0, function* () {
-        const channel = createBroadcastChannel(event);
-        try {
-            const request = parseWorkerRequest(message.payload);
-            context.emitter.emit('request:start', request);
-            // Set document cookies on the request.
-            setRequestCookies(request);
-            const { response, handler, publicRequest, parsedRequest, } = yield getResponse(request, context.requestHandlers);
-            // Handle a scenario when there is no request handler
-            // found for a given request.
-            if (!handler) {
-                onUnhandledRequest(request, context.requestHandlers, options.onUnhandledRequest);
-                context.emitter.emit('request:unhandled', request);
-                context.emitter.emit('request:end', request);
-                return channel.send({ type: 'MOCK_NOT_FOUND' });
-            }
-            context.emitter.emit('request:match', request);
-            // Handle a scenario when there is a request handler,
-            // but it doesn't return any mocked response.
-            if (!response) {
-                console.warn('[MSW] Expected a mocking resolver function to return a mocked response Object, but got: %s. Original response is going to be used instead.', response);
-                context.emitter.emit('request:end', request);
-                return channel.send({ type: 'MOCK_NOT_FOUND' });
-            }
-            readResponseCookies(request, response);
-            const responseWithSerializedHeaders = Object.assign(Object.assign({}, response), { headers: lib$2.headersToList(response.headers) });
-            if (!options.quiet) {
-                setTimeout(() => {
-                    handler.log(publicRequest, responseWithSerializedHeaders, handler, parsedRequest);
-                }, response.delay);
-            }
-            context.emitter.emit('request:end', request);
-            channel.send({
-                type: 'MOCK_SUCCESS',
-                payload: responseWithSerializedHeaders,
-            });
-        }
-        catch (error) {
-            if (error instanceof NetworkError) {
-                // Treat emulated network error differently,
-                // as it is an intended exception in a request handler.
-                return channel.send({
-                    type: 'NETWORK_ERROR',
-                    payload: {
-                        name: error.name,
-                        message: error.message,
-                    },
-                });
-            }
+/**
+ * Returns a mocked response for a given request using following request handlers.
+ */
+const getResponse = (request, handlers) => __awaiter$2(void 0, void 0, void 0, function* () {
+    const relevantHandlers = handlers.filter((handler) => {
+        return handler.test(request);
+    });
+    if (relevantHandlers.length === 0) {
+        return {
+            handler: undefined,
+            response: undefined,
+        };
+    }
+    const result = yield relevantHandlers.reduce((acc, handler) => __awaiter$2(void 0, void 0, void 0, function* () {
+        const previousResults = yield acc;
+        if (!!(previousResults === null || previousResults === void 0 ? void 0 : previousResults.response)) {
+            return acc;
+        }
+        const result = yield handler.run(request);
+        if (result === null || result.handler.shouldSkip) {
+            return null;
+        }
+        if (!result.response) {
+            return {
+                request: result.request,
+                handler: result.handler,
+                response: undefined,
+                parsedResult: result.parsedResult,
+            };
+        }
+        if (result.response.once) {
+            handler.markAsSkipped(true);
+        }
+        return result;
+    }), Promise.resolve(null));
+    // Although reducing a list of relevant request handlers, it's possible
+    // that in the end there will be no handler associted with the request
+    // (i.e. if relevant handlers are fall-through).
+    if (!result) {
+        return {
+            handler: undefined,
+            response: undefined,
+        };
+    }
+    return {
+        handler: result.handler,
+        publicRequest: result.request,
+        parsedRequest: result.parsedResult,
+        response: result.response,
+    };
+});
+
+var jsLevenshtein = (function()
+{
+  function _min(d0, d1, d2, bx, ay)
+  {
+    return d0 < d1 || d2 < d1
+        ? d0 > d2
+            ? d2 + 1
+            : d0 + 1
+        : bx === ay
+            ? d1
+            : d1 + 1;
+  }
+
+  return function(a, b)
+  {
+    if (a === b) {
+      return 0;
+    }
+
+    if (a.length > b.length) {
+      var tmp = a;
+      a = b;
+      b = tmp;
+    }
+
+    var la = a.length;
+    var lb = b.length;
+
+    while (la > 0 && (a.charCodeAt(la - 1) === b.charCodeAt(lb - 1))) {
+      la--;
+      lb--;
+    }
+
+    var offset = 0;
+
+    while (offset < la && (a.charCodeAt(offset) === b.charCodeAt(offset))) {
+      offset++;
+    }
+
+    la -= offset;
+    lb -= offset;
+
+    if (la === 0 || lb < 3) {
+      return lb;
+    }
+
+    var x = 0;
+    var y;
+    var d0;
+    var d1;
+    var d2;
+    var d3;
+    var dd;
+    var dy;
+    var ay;
+    var bx0;
+    var bx1;
+    var bx2;
+    var bx3;
+
+    var vector = [];
+
+    for (y = 0; y < la; y++) {
+      vector.push(y + 1);
+      vector.push(a.charCodeAt(offset + y));
+    }
+
+    var len = vector.length - 1;
+
+    for (; x < lb - 3;) {
+      bx0 = b.charCodeAt(offset + (d0 = x));
+      bx1 = b.charCodeAt(offset + (d1 = x + 1));
+      bx2 = b.charCodeAt(offset + (d2 = x + 2));
+      bx3 = b.charCodeAt(offset + (d3 = x + 3));
+      dd = (x += 4);
+      for (y = 0; y < len; y += 2) {
+        dy = vector[y];
+        ay = vector[y + 1];
+        d0 = _min(dy, d0, d1, bx0, ay);
+        d1 = _min(d0, d1, d2, bx1, ay);
+        d2 = _min(d1, d2, d3, bx2, ay);
+        dd = _min(d2, d3, dd, bx3, ay);
+        vector[y] = dd;
+        d3 = d2;
+        d2 = d1;
+        d1 = d0;
+        d0 = dy;
+      }
+    }
+
+    for (; x < lb;) {
+      bx0 = b.charCodeAt(offset + (d0 = x));
+      dd = ++x;
+      for (y = 0; y < len; y += 2) {
+        dy = vector[y];
+        vector[y] = dd = _min(dy, d0, dd, bx0, vector[y + 1]);
+        d0 = dy;
+      }
+    }
+
+    return dd;
+  };
+})();
+
+const MAX_MATCH_SCORE = 3;
+const MAX_SUGGESTION_COUNT = 4;
+const TYPE_MATCH_DELTA = 0.5;
+function groupHandlersByType(handlers) {
+    return handlers.reduce((groups, handler) => {
+        if (handler instanceof RestHandler) {
+            groups.rest.push(handler);
+        }
+        if (handler instanceof GraphQLHandler) {
+            groups.graphql.push(handler);
+        }
+        return groups;
+    }, {
+        rest: [],
+        graphql: [],
+    });
+}
+function getScoreForRestHandler() {
+    return (request, handler) => {
+        const { mask, method } = handler.info;
+        if (mask instanceof RegExp) {
+            return Infinity;
+        }
+        const hasSameMethod = isStringEqual(request.method, method);
+        // Always treat a handler with the same method as a more similar one.
+        const methodScoreDelta = hasSameMethod ? TYPE_MATCH_DELTA : 0;
+        const requestPublicUrl = getPublicUrlFromRequest(request);
+        const score = jsLevenshtein(requestPublicUrl, mask);
+        return score - methodScoreDelta;
+    };
+}
+function getScoreForGraphQLHandler(parsedQuery) {
+    return (_, handler) => {
+        if (typeof parsedQuery.operationName === 'undefined') {
+            return Infinity;
+        }
+        const { operationType, operationName } = handler.info;
+        const hasSameOperationType = parsedQuery.operationType === operationType;
+        // Always treat a handler with the same operation type as a more similar one.
+        const operationTypeScoreDelta = hasSameOperationType ? TYPE_MATCH_DELTA : 0;
+        const score = jsLevenshtein(parsedQuery.operationName, operationName);
+        return score - operationTypeScoreDelta;
+    };
+}
+function getSuggestedHandler(request, handlers, getScore) {
+    const suggestedHandlers = handlers
+        .reduce((acc, handler) => {
+        const score = getScore(request, handler);
+        return acc.concat([[score, handler]]);
+    }, [])
+        .sort(([leftScore], [rightScore]) => {
+        return leftScore - rightScore;
+    })
+        .filter(([score]) => {
+        return score <= MAX_MATCH_SCORE;
+    })
+        .slice(0, MAX_SUGGESTION_COUNT)
+        .map(([, handler]) => handler);
+    return suggestedHandlers;
+}
+function getSuggestedHandlersMessage(handlers) {
+    if (handlers.length > 1) {
+        return `\
+Did you mean to request one of the following resources instead?
+
+${handlers.map((handler) => `  • ${handler.info.header}`).join('\n')}`;
+    }
+    return `Did you mean to request "${handlers[0].info.header}" instead?`;
+}
+function onUnhandledRequest(request, handlers, strategy = 'warn') {
+    if (typeof strategy === 'function') {
+        strategy(request);
+        return;
+    }
+    const parsedGraphQLQuery = parseGraphQLRequest(request);
+    const handlerGroups = groupHandlersByType(handlers);
+    const relevantHandlers = parsedGraphQLQuery
+        ? handlerGroups.graphql
+        : handlerGroups.rest;
+    const suggestedHandlers = getSuggestedHandler(request, relevantHandlers, parsedGraphQLQuery
+        ? getScoreForGraphQLHandler(parsedGraphQLQuery)
+        : getScoreForRestHandler());
+    const handlerSuggestion = suggestedHandlers.length > 0
+        ? getSuggestedHandlersMessage(suggestedHandlers)
+        : '';
+    const publicUrl = getPublicUrlFromRequest(request);
+    const requestHeader = parsedGraphQLQuery
+        ? `${parsedGraphQLQuery.operationType} ${parsedGraphQLQuery.operationName} (${request.method} ${publicUrl})`
+        : `${request.method} ${publicUrl}`;
+    const messageTemplate = [
+        `captured a request without a matching request handler:`,
+        `  \u2022 ${requestHeader}`,
+        handlerSuggestion,
+        `\
+If you still wish to intercept this unhandled request, please create a request handler for it.
+Read more: https://mswjs.io/docs/getting-started/mocks\
+`,
+    ].filter(Boolean);
+    const message = messageTemplate.join('\n\n');
+    switch (strategy) {
+        case 'error': {
+            console.error(`[MSW] Error: ${message}`);
+            break;
+        }
+        case 'warn': {
+            console.warn(`[MSW] Warning: ${message}`);
+            break;
+        }
+        case 'bypass':
+            break;
+        default:
+            throw new Error(`[MSW] Failed to react to an unhandled request: unknown strategy "${strategy}". Please provide one of the supported strategies ("bypass", "warn", "error") or a custom callback function.`);
+    }
+}
+
+function readResponseCookies(request, response) {
+    lib$1.store.add(Object.assign(Object.assign({}, request), { url: request.url.toString() }), response);
+    lib$1.store.persist();
+}
+
+function handleRequest(request, handlers, options, emitter, handleRequestOptions) {
+    var _a, _b, _c;
+    return __awaiter$2(this, void 0, void 0, function* () {
+        emitter.emit('request:start', request);
+        // Perform bypassed requests (i.e. issued via "ctx.fetch") as-is.
+        if (request.headers.get('x-msw-bypass')) {
+            emitter.emit('request:end', request);
+            (_a = handleRequestOptions === null || handleRequestOptions === void 0 ? void 0 : handleRequestOptions.onBypassResponse) === null || _a === void 0 ? void 0 : _a.call(handleRequestOptions, request);
+            return;
+        }
+        // Resolve a mocked response from the list of request handlers.
+        const lookupResult = yield getResponse(request, handlers);
+        const { handler, response } = lookupResult;
+        // When there's no handler for the request, consider it unhandled.
+        // Allow the developer to react to such cases.
+        if (!handler) {
+            onUnhandledRequest(request, handlers, options.onUnhandledRequest);
+            emitter.emit('request:unhandled', request);
+            emitter.emit('request:end', request);
+            (_b = handleRequestOptions === null || handleRequestOptions === void 0 ? void 0 : handleRequestOptions.onBypassResponse) === null || _b === void 0 ? void 0 : _b.call(handleRequestOptions, request);
+            return;
+        }
+        // When the handled request returned no mocked response, warn the developer,
+        // as it may be an oversight on their part. Perform the request as-is.
+        if (!response) {
+            console.warn('[MSW] Expected a mocking resolver function to return a mocked response Object, but got: %s. Original response is going to be used instead.', response);
+            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;
+        }
+        // Store all the received response cookies in the virtual cookie store.
+        readResponseCookies(request, response);
+        emitter.emit('request:match', request);
+        return new Promise((resolve) => {
+            var _a, _b, _c;
+            const requiredLookupResult = lookupResult;
+            const transformedResponse = ((_a = handleRequestOptions === null || handleRequestOptions === void 0 ? void 0 : handleRequestOptions.transformResponse) === null || _a === void 0 ? void 0 : _a.call(handleRequestOptions, response)) ||
+                response;
+            (_b = handleRequestOptions === null || handleRequestOptions === void 0 ? void 0 : handleRequestOptions.onMockedResponse) === null || _b === void 0 ? void 0 : _b.call(handleRequestOptions, transformedResponse, requiredLookupResult);
+            setTimeout(() => {
+                var _a;
+                (_a = handleRequestOptions === null || handleRequestOptions === void 0 ? void 0 : handleRequestOptions.onMockedResponseSent) === null || _a === void 0 ? void 0 : _a.call(handleRequestOptions, transformedResponse, requiredLookupResult);
+                emitter.emit('request:end', request);
+                resolve(transformedResponse);
+            }, (_c = response.delay) !== null && _c !== void 0 ? _c : 0);
+        });
+    });
+}
+
+const createRequestListener = (context, options) => {
+    return (event, message) => __awaiter$2(void 0, void 0, void 0, function* () {
+        const channel = createBroadcastChannel(event);
+        try {
+            const request = parseWorkerRequest(message.payload);
+            yield handleRequest(request, context.requestHandlers, options, context.emitter, {
+                transformResponse(response) {
+                    return Object.assign(Object.assign({}, response), { headers: response.headers.all() });
+                },
+                onBypassResponse() {
+                    return channel.send({
+                        type: 'MOCK_NOT_FOUND',
+                    });
+                },
+                onMockedResponse(response) {
+                    channel.send({
+                        type: 'MOCK_SUCCESS',
+                        payload: response,
+                    });
+                },
+                onMockedResponseSent(response, { handler, publicRequest, parsedRequest }) {
+                    if (!options.quiet) {
+                        handler.log(publicRequest, response, handler, parsedRequest);
+                    }
+                },
+            });
+        }
+        catch (error) {
+            if (error instanceof NetworkError) {
+                // Treat emulated network error differently,
+                // as it is an intended exception in a request handler.
+                return channel.send({
+                    type: 'NETWORK_ERROR',
+                    payload: {
+                        name: error.name,
+                        message: error.message,
+                    },
+                });
+            }
             // Treat all the other exceptions in a request handler
             // as unintended, alerting that there is a problem needs fixing.
             channel.send({
@@ -1480,190 +1546,3552 @@ const createRequestListener = (context, options) => {
     });
 };
 
-function requestIntegrityCheck(context, serviceWorker) {
-    return __awaiter(this, void 0, void 0, function* () {
-        // Signal Service Worker to report back its integrity
-        context.workerChannel.send('INTEGRITY_CHECK_REQUEST');
-        const { payload: actualChecksum } = yield context.events.once('INTEGRITY_CHECK_RESPONSE');
-        // Compare the response from the Service Worker and the
-        // global variable set by webpack upon build.
-        if (actualChecksum !== "82ef9b96d8393b6da34527d1d6e19187") {
-            throw new Error(`Currently active Service Worker (${actualChecksum}) is behind the latest published one (${"82ef9b96d8393b6da34527d1d6e19187"}).`);
-        }
-        return serviceWorker;
-    });
+function requestIntegrityCheck(context, serviceWorker) {
+    return __awaiter$2(this, void 0, void 0, function* () {
+        // Signal Service Worker to report back its integrity
+        context.workerChannel.send('INTEGRITY_CHECK_REQUEST');
+        const { payload: actualChecksum } = yield context.events.once('INTEGRITY_CHECK_RESPONSE');
+        // Compare the response from the Service Worker and the
+        // global variable set by Rollup during the build.
+        if (actualChecksum !== "82ef9b96d8393b6da34527d1d6e19187") {
+            throw new Error(`Currently active Service Worker (${actualChecksum}) is behind the latest published one (${"82ef9b96d8393b6da34527d1d6e19187"}).`);
+        }
+        return serviceWorker;
+    });
+}
+
+/**
+ * Intercepts and defers any requests on the page
+ * until the Service Worker instance is ready.
+ * Must only be used in a browser.
+ */
+function deferNetworkRequestsUntil(predicatePromise) {
+    // Defer any `XMLHttpRequest` requests until the Service Worker is ready.
+    const originalXhrSend = window.XMLHttpRequest.prototype.send;
+    window.XMLHttpRequest.prototype.send = function (...args) {
+        // Keep this function synchronous to comply with `XMLHttpRequest.prototype.send`,
+        // because that method is always synchronous.
+        until(() => predicatePromise).then(() => {
+            window.XMLHttpRequest.prototype.send = originalXhrSend;
+            this.send(...args);
+        });
+    };
+    // Defer any `fetch` requests until the Service Worker is ready.
+    const originalFetch = window.fetch;
+    window.fetch = (...args) => __awaiter$2(this, void 0, void 0, function* () {
+        yield until(() => predicatePromise);
+        window.fetch = originalFetch;
+        return window.fetch(...args);
+    });
+}
+
+function createResponseListener(context) {
+    return (_, message) => {
+        var _a;
+        const { payload: responseJson } = message;
+        /**
+         * CORS requests with `mode: "no-cors"` result in "opaque" responses.
+         * That kind of responses cannot be manipulated in JavaScript due
+         * to the security considerations.
+         * @see https://fetch.spec.whatwg.org/#concept-filtered-response-opaque
+         * @see https://github.com/mswjs/msw/issues/529
+         */
+        if ((_a = responseJson.type) === null || _a === void 0 ? void 0 : _a.includes('opaque')) {
+            return;
+        }
+        const response = new Response(responseJson.body || null, responseJson);
+        const isMockedResponse = response.headers.get('x-powered-by') === 'msw';
+        if (isMockedResponse) {
+            context.emitter.emit('response:mocked', response, responseJson.requestId);
+        }
+        else {
+            context.emitter.emit('response:bypass', response, responseJson.requestId);
+        }
+    };
+}
+
+const createStartHandler = (context) => {
+    return function start(options, customOptions) {
+        const startWorkerInstance = () => __awaiter$2(this, void 0, void 0, function* () {
+            // Remove all previously existing event listeners.
+            // This way none of the listeners persists between Fast refresh
+            // of the application's code.
+            context.events.removeAllListeners();
+            // Handle requests signaled by the worker.
+            context.workerChannel.on('REQUEST', createRequestListener(context, options));
+            context.workerChannel.on('RESPONSE', createResponseListener(context));
+            const instance = yield getWorkerInstance(options.serviceWorker.url, options.serviceWorker.options, options.findWorker);
+            const [worker, registration] = instance;
+            if (!worker) {
+                const missingWorkerMessage = (customOptions === null || customOptions === void 0 ? void 0 : customOptions.findWorker)
+                    ? `[MSW] Failed to locate the Service Worker registration using a custom "findWorker" predicate.
+
+Please ensure that the custom predicate properly locates the Service Worker registration at "${options.serviceWorker.url}".
+More details: https://mswjs.io/docs/api/setup-worker/start#findworker
+`
+                    : `[MSW] Failed to locate the Service Worker registration.
+
+This most likely means that the worker script URL "${options.serviceWorker.url}" cannot resolve against the actual public hostname (${location.host}). This may happen if your application runs behind a proxy, or has a dynamic hostname.
+
+Please consider using a custom "serviceWorker.url" option to point to the actual worker script location, or a custom "findWorker" option to resolve the Service Worker registration manually. More details: https://mswjs.io/docs/api/setup-worker/start`;
+                throw new Error(missingWorkerMessage);
+            }
+            context.worker = worker;
+            context.registration = registration;
+            context.events.addListener(window, 'beforeunload', () => {
+                if (worker.state !== 'redundant') {
+                    // Notify the Service Worker that this client has closed.
+                    // Internally, it's similar to disabling the mocking, only
+                    // client close event has a handler that self-terminates
+                    // the Service Worker when there are no open clients.
+                    context.workerChannel.send('CLIENT_CLOSED');
+                }
+                // Make sure we're always clearing the interval - there are reports that not doing this can
+                // cause memory leaks in headless browser environments.
+                window.clearInterval(context.keepAliveInterval);
+            });
+            // Check if the active Service Worker is the latest published one
+            const [integrityError] = yield until(() => requestIntegrityCheck(context, worker));
+            if (integrityError) {
+                console.error(`\
+[MSW] Detected outdated Service Worker: ${integrityError.message}
+
+The mocking is still enabled, but it's highly recommended that you update your Service Worker by running:
+
+$ npx msw init <PUBLIC_DIR>
+
+This is necessary to ensure that the Service Worker is in sync with the library to guarantee its stability.
+If this message still persists after updating, please report an issue: https://github.com/open-draft/msw/issues\
+      `);
+            }
+            yield enableMocking(context, options).catch((err) => {
+                throw new Error(`Failed to enable mocking: ${err === null || err === void 0 ? void 0 : err.message}`);
+            });
+            context.keepAliveInterval = window.setInterval(() => context.workerChannel.send('KEEPALIVE_REQUEST'), 5000);
+            return registration;
+        });
+        const workerRegistration = startWorkerInstance();
+        // Defer any network requests until the Service Worker instance is ready.
+        // This prevents a race condition between the Service Worker registration
+        // and application's runtime requests (i.e. requests on mount).
+        if (options.waitUntilReady) {
+            deferNetworkRequestsUntil(workerRegistration);
+        }
+        return workerRegistration;
+    };
+};
+
+function printStopMessage(args = {}) {
+    if (args.quiet) {
+        return;
+    }
+    console.log('%c[MSW] Mocking disabled.', 'color:orangered;font-weight:bold;');
+}
+
+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;
+        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 });
+    };
+};
+
+function use(currentHandlers, ...handlers) {
+    currentHandlers.unshift(...handlers);
+}
+function restoreHandlers(handlers) {
+    handlers.forEach((handler) => {
+        handler.markAsSkipped(false);
+    });
+}
+function resetHandlers(initialHandlers, ...nextHandlers) {
+    return nextHandlers.length > 0 ? [...nextHandlers] : [...initialHandlers];
+}
+
+const DEFAULT_START_OPTIONS = {
+    serviceWorker: {
+        url: '/mockServiceWorker.js',
+        options: null,
+    },
+    quiet: false,
+    waitUntilReady: true,
+    onUnhandledRequest: 'warn',
+    findWorker(scriptURL, mockServiceWorkerUrl) {
+        return scriptURL === mockServiceWorkerUrl;
+    },
+};
+/**
+ * Returns resolved worker start options, merging the default options
+ * with the given custom options.
+ */
+function resolveStartOptions(initialOptions) {
+    return mergeRight(DEFAULT_START_OPTIONS, initialOptions || {});
+}
+function prepareStartHandler(handler, context) {
+    return (initialOptions) => {
+        context.startOptions = resolveStartOptions(initialOptions);
+        return handler(context.startOptions, initialOptions || {});
+    };
+}
+
+var lib = {};
+
+var createInterceptor$1 = {};
+
+Object.defineProperty(createInterceptor$1, "__esModule", { value: true });
+createInterceptor$1.createInterceptor = void 0;
+var strict_event_emitter_1 = lib$3;
+function createInterceptor(options) {
+    var observer = new strict_event_emitter_1.StrictEventEmitter();
+    var cleanupFns = [];
+    return {
+        apply: function () {
+            cleanupFns = options.modules.map(function (interceptor) {
+                return interceptor(observer, options.resolver);
+            });
+        },
+        on: function (event, listener) {
+            observer.addListener(event, listener);
+        },
+        restore: function () {
+            observer.removeAllListeners();
+            if (cleanupFns.length === 0) {
+                throw new Error("Failed to restore patched modules: no patches found. Did you forget to run \".apply()\"?");
+            }
+            cleanupFns.forEach(function (restore) { return restore(); });
+        },
+    };
+}
+createInterceptor$1.createInterceptor = createInterceptor;
+
+(function (exports) {
+var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCleanUrl = void 0;
+__exportStar(createInterceptor$1, exports);
+/* Utils */
+var getCleanUrl_1 = getCleanUrl;
+Object.defineProperty(exports, "getCleanUrl", { enumerable: true, get: function () { return getCleanUrl_1.getCleanUrl; } });
+//# sourceMappingURL=index.js.map
+}(lib));
+
+var fetch = {};
+
+var __assign = (commonjsGlobal && commonjsGlobal.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter$1 = (commonjsGlobal && commonjsGlobal.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator$1 = (commonjsGlobal && commonjsGlobal.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(fetch, "__esModule", { value: true });
+var interceptFetch_1 = fetch.interceptFetch = void 0;
+var headers_utils_1$1 = lib$4;
+var debug$1 = require$$1('fetch');
+var interceptFetch = function (observer, resolver) {
+    var pureFetch = window.fetch;
+    debug$1('replacing "window.fetch"...');
+    window.fetch = function (input, init) { return __awaiter$1(void 0, void 0, void 0, function () {
+        var ref, url, method, isoRequest, response, isomorphicResponse;
+        var _a;
+        return __generator$1(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    ref = new Request(input, init);
+                    url = typeof input === 'string' ? input : input.url;
+                    method = (init === null || init === void 0 ? void 0 : init.method) || 'GET';
+                    debug$1('[%s] %s', method, url);
+                    _a = {
+                        url: new URL(url, location.origin),
+                        method: method,
+                        headers: new headers_utils_1$1.Headers((init === null || init === void 0 ? void 0 : init.headers) || {})
+                    };
+                    return [4 /*yield*/, ref.text()];
+                case 1:
+                    isoRequest = (_a.body = _b.sent(),
+                        _a);
+                    debug$1('isomorphic request', isoRequest);
+                    observer.emit('request', isoRequest);
+                    debug$1('awaiting for the mocked response...');
+                    return [4 /*yield*/, resolver(isoRequest, ref)];
+                case 2:
+                    response = _b.sent();
+                    debug$1('mocked response', response);
+                    if (response) {
+                        isomorphicResponse = normalizeMockedResponse(response);
+                        debug$1('derived isomorphic response', isomorphicResponse);
+                        observer.emit('response', isoRequest, isomorphicResponse);
+                        return [2 /*return*/, new Response(response.body, __assign(__assign({}, isomorphicResponse), { 
+                                // `Response.headers` cannot be instantiated with the `Headers` polyfill.
+                                // Apparently, it halts if the `Headers` class contains unknown properties
+                                // (i.e. the internal `Headers.map`).
+                                headers: headers_utils_1$1.flattenHeadersObject(response.headers || {}) }))];
+                    }
+                    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;
+                            return __generator$1(this, function (_d) {
+                                switch (_d.label) {
+                                    case 0:
+                                        debug$1('original fetch performed', response);
+                                        _b = (_a = observer).emit;
+                                        _c = ['response',
+                                            isoRequest];
+                                        return [4 /*yield*/, normalizeFetchResponse(response)];
+                                    case 1:
+                                        _b.apply(_a, _c.concat([_d.sent()]));
+                                        return [2 /*return*/, response];
+                                }
+                            });
+                        }); })];
+            }
+        });
+    }); };
+    return function () {
+        debug$1('restoring modules...');
+        window.fetch = pureFetch;
+    };
+};
+interceptFetch_1 = fetch.interceptFetch = interceptFetch;
+function normalizeMockedResponse(response) {
+    return {
+        status: response.status || 200,
+        statusText: response.statusText || 'OK',
+        headers: headers_utils_1$1.objectToHeaders(response.headers || {}),
+        body: response.body,
+    };
+}
+function normalizeFetchResponse(response) {
+    return __awaiter$1(this, void 0, void 0, function () {
+        var _a;
+        return __generator$1(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = {
+                        status: response.status,
+                        statusText: response.statusText,
+                        headers: headers_utils_1$1.objectToHeaders(headers_utils_1$1.headersToObject(response.headers))
+                    };
+                    return [4 /*yield*/, response.text()];
+                case 1: return [2 /*return*/, (_a.body = _b.sent(),
+                        _a)];
+            }
+        });
+    });
+}
+
+var XMLHttpRequest = {};
+
+var XMLHttpRequestOverride = {};
+
+var domParser = {};
+
+var entities = {};
+
+entities.entityMap = {
+       lt: '<',
+       gt: '>',
+       amp: '&',
+       quot: '"',
+       apos: "'",
+       Agrave: "À",
+       Aacute: "Á",
+       Acirc: "Â",
+       Atilde: "Ã",
+       Auml: "Ä",
+       Aring: "Å",
+       AElig: "Æ",
+       Ccedil: "Ç",
+       Egrave: "È",
+       Eacute: "É",
+       Ecirc: "Ê",
+       Euml: "Ë",
+       Igrave: "Ì",
+       Iacute: "Í",
+       Icirc: "Î",
+       Iuml: "Ï",
+       ETH: "Ð",
+       Ntilde: "Ñ",
+       Ograve: "Ò",
+       Oacute: "Ó",
+       Ocirc: "Ô",
+       Otilde: "Õ",
+       Ouml: "Ö",
+       Oslash: "Ø",
+       Ugrave: "Ù",
+       Uacute: "Ú",
+       Ucirc: "Û",
+       Uuml: "Ü",
+       Yacute: "Ý",
+       THORN: "Þ",
+       szlig: "ß",
+       agrave: "à",
+       aacute: "á",
+       acirc: "â",
+       atilde: "ã",
+       auml: "ä",
+       aring: "å",
+       aelig: "æ",
+       ccedil: "ç",
+       egrave: "è",
+       eacute: "é",
+       ecirc: "ê",
+       euml: "ë",
+       igrave: "ì",
+       iacute: "í",
+       icirc: "î",
+       iuml: "ï",
+       eth: "ð",
+       ntilde: "ñ",
+       ograve: "ò",
+       oacute: "ó",
+       ocirc: "ô",
+       otilde: "õ",
+       ouml: "ö",
+       oslash: "ø",
+       ugrave: "ù",
+       uacute: "ú",
+       ucirc: "û",
+       uuml: "ü",
+       yacute: "ý",
+       thorn: "þ",
+       yuml: "ÿ",
+       nbsp: "\u00a0",
+       iexcl: "¡",
+       cent: "¢",
+       pound: "£",
+       curren: "¤",
+       yen: "¥",
+       brvbar: "¦",
+       sect: "§",
+       uml: "¨",
+       copy: "©",
+       ordf: "ª",
+       laquo: "«",
+       not: "¬",
+       shy: "­­",
+       reg: "®",
+       macr: "¯",
+       deg: "°",
+       plusmn: "±",
+       sup2: "²",
+       sup3: "³",
+       acute: "´",
+       micro: "µ",
+       para: "¶",
+       middot: "·",
+       cedil: "¸",
+       sup1: "¹",
+       ordm: "º",
+       raquo: "»",
+       frac14: "¼",
+       frac12: "½",
+       frac34: "¾",
+       iquest: "¿",
+       times: "×",
+       divide: "÷",
+       forall: "∀",
+       part: "∂",
+       exist: "∃",
+       empty: "∅",
+       nabla: "∇",
+       isin: "∈",
+       notin: "∉",
+       ni: "∋",
+       prod: "∏",
+       sum: "∑",
+       minus: "−",
+       lowast: "∗",
+       radic: "√",
+       prop: "∝",
+       infin: "∞",
+       ang: "∠",
+       and: "∧",
+       or: "∨",
+       cap: "∩",
+       cup: "∪",
+       'int': "∫",
+       there4: "∴",
+       sim: "∼",
+       cong: "≅",
+       asymp: "≈",
+       ne: "≠",
+       equiv: "≡",
+       le: "≤",
+       ge: "≥",
+       sub: "⊂",
+       sup: "⊃",
+       nsub: "⊄",
+       sube: "⊆",
+       supe: "⊇",
+       oplus: "⊕",
+       otimes: "⊗",
+       perp: "⊥",
+       sdot: "⋅",
+       Alpha: "Α",
+       Beta: "Β",
+       Gamma: "Γ",
+       Delta: "Δ",
+       Epsilon: "Ε",
+       Zeta: "Ζ",
+       Eta: "Η",
+       Theta: "Θ",
+       Iota: "Ι",
+       Kappa: "Κ",
+       Lambda: "Λ",
+       Mu: "Μ",
+       Nu: "Ν",
+       Xi: "Ξ",
+       Omicron: "Ο",
+       Pi: "Π",
+       Rho: "Ρ",
+       Sigma: "Σ",
+       Tau: "Τ",
+       Upsilon: "Υ",
+       Phi: "Φ",
+       Chi: "Χ",
+       Psi: "Ψ",
+       Omega: "Ω",
+       alpha: "α",
+       beta: "β",
+       gamma: "γ",
+       delta: "δ",
+       epsilon: "ε",
+       zeta: "ζ",
+       eta: "η",
+       theta: "θ",
+       iota: "ι",
+       kappa: "κ",
+       lambda: "λ",
+       mu: "μ",
+       nu: "ν",
+       xi: "ξ",
+       omicron: "ο",
+       pi: "π",
+       rho: "ρ",
+       sigmaf: "ς",
+       sigma: "σ",
+       tau: "τ",
+       upsilon: "υ",
+       phi: "φ",
+       chi: "χ",
+       psi: "ψ",
+       omega: "ω",
+       thetasym: "ϑ",
+       upsih: "ϒ",
+       piv: "ϖ",
+       OElig: "Œ",
+       oelig: "œ",
+       Scaron: "Š",
+       scaron: "š",
+       Yuml: "Ÿ",
+       fnof: "ƒ",
+       circ: "ˆ",
+       tilde: "˜",
+       ensp: " ",
+       emsp: " ",
+       thinsp: " ",
+       zwnj: "‌",
+       zwj: "‍",
+       lrm: "‎",
+       rlm: "‏",
+       ndash: "–",
+       mdash: "—",
+       lsquo: "‘",
+       rsquo: "’",
+       sbquo: "‚",
+       ldquo: "“",
+       rdquo: "”",
+       bdquo: "„",
+       dagger: "†",
+       Dagger: "‡",
+       bull: "•",
+       hellip: "…",
+       permil: "‰",
+       prime: "′",
+       Prime: "″",
+       lsaquo: "‹",
+       rsaquo: "›",
+       oline: "‾",
+       euro: "€",
+       trade: "™",
+       larr: "←",
+       uarr: "↑",
+       rarr: "→",
+       darr: "↓",
+       harr: "↔",
+       crarr: "↵",
+       lceil: "⌈",
+       rceil: "⌉",
+       lfloor: "⌊",
+       rfloor: "⌋",
+       loz: "◊",
+       spades: "♠",
+       clubs: "♣",
+       hearts: "♥",
+       diams: "♦"
+};
+
+var sax$1 = {};
+
+//[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)*
+var nameStartChar = /[A-Z_a-z\xC0-\xD6\xD8-\xF6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/;//\u10000-\uEFFFF
+var nameChar = new RegExp("[\\-\\.0-9"+nameStartChar.source.slice(1,-1)+"\\u00B7\\u0300-\\u036F\\u203F-\\u2040]");
+var tagNamePattern = new RegExp('^'+nameStartChar.source+nameChar.source+'*(?:\:'+nameStartChar.source+nameChar.source+'*)?$');
+//var tagNamePattern = /^[a-zA-Z_][\w\-\.]*(?:\:[a-zA-Z_][\w\-\.]*)?$/
+//var handlers = 'resolveEntity,getExternalSubset,characters,endDocument,endElement,endPrefixMapping,ignorableWhitespace,processingInstruction,setDocumentLocator,skippedEntity,startDocument,startElement,startPrefixMapping,notationDecl,unparsedEntityDecl,error,fatalError,warning,attributeDecl,elementDecl,externalEntityDecl,internalEntityDecl,comment,endCDATA,endDTD,endEntity,startCDATA,startDTD,startEntity'.split(',')
+
+//S_TAG,	S_ATTR,	S_EQ,	S_ATTR_NOQUOT_VALUE
+//S_ATTR_SPACE,	S_ATTR_END,	S_TAG_SPACE, S_TAG_CLOSE
+var S_TAG = 0;//tag name offerring
+var S_ATTR = 1;//attr name offerring 
+var S_ATTR_SPACE=2;//attr name end and space offer
+var S_EQ = 3;//=space?
+var S_ATTR_NOQUOT_VALUE = 4;//attr value(no quot value only)
+var S_ATTR_END = 5;//attr value end and no space(quot end)
+var S_TAG_SPACE = 6;//(attr value end || tag end ) && (space offer)
+var S_TAG_CLOSE = 7;//closed el<el />
+
+/**
+ * Creates an error that will not be caught by XMLReader aka the SAX parser.
+ *
+ * @param {string} message
+ * @param {any?} locator Optional, can provide details about the location in the source
+ * @constructor
+ */
+function ParseError$1(message, locator) {
+	this.message = message;
+	this.locator = locator;
+	if(Error.captureStackTrace) Error.captureStackTrace(this, ParseError$1);
+}
+ParseError$1.prototype = new Error();
+ParseError$1.prototype.name = ParseError$1.name;
+
+function XMLReader$1(){
+	
+}
+
+XMLReader$1.prototype = {
+	parse:function(source,defaultNSMap,entityMap){
+		var domBuilder = this.domBuilder;
+		domBuilder.startDocument();
+		_copy(defaultNSMap ,defaultNSMap = {});
+		parse(source,defaultNSMap,entityMap,
+				domBuilder,this.errorHandler);
+		domBuilder.endDocument();
+	}
+};
+function parse(source,defaultNSMapCopy,entityMap,domBuilder,errorHandler){
+	function fixedFromCharCode(code) {
+		// String.prototype.fromCharCode does not supports
+		// > 2 bytes unicode chars directly
+		if (code > 0xffff) {
+			code -= 0x10000;
+			var surrogate1 = 0xd800 + (code >> 10)
+				, surrogate2 = 0xdc00 + (code & 0x3ff);
+
+			return String.fromCharCode(surrogate1, surrogate2);
+		} else {
+			return String.fromCharCode(code);
+		}
+	}
+	function entityReplacer(a){
+		var k = a.slice(1,-1);
+		if(k in entityMap){
+			return entityMap[k]; 
+		}else if(k.charAt(0) === '#'){
+			return fixedFromCharCode(parseInt(k.substr(1).replace('x','0x')))
+		}else {
+			errorHandler.error('entity not found:'+a);
+			return a;
+		}
+	}
+	function appendText(end){//has some bugs
+		if(end>start){
+			var xt = source.substring(start,end).replace(/&#?\w+;/g,entityReplacer);
+			locator&&position(start);
+			domBuilder.characters(xt,0,end-start);
+			start = end;
+		}
+	}
+	function position(p,m){
+		while(p>=lineEnd && (m = linePattern.exec(source))){
+			lineStart = m.index;
+			lineEnd = lineStart + m[0].length;
+			locator.lineNumber++;
+			//console.log('line++:',locator,startPos,endPos)
+		}
+		locator.columnNumber = p-lineStart+1;
+	}
+	var lineStart = 0;
+	var lineEnd = 0;
+	var linePattern = /.*(?:\r\n?|\n)|.*$/g;
+	var locator = domBuilder.locator;
+	
+	var parseStack = [{currentNSMap:defaultNSMapCopy}];
+	var closeMap = {};
+	var start = 0;
+	while(true){
+		try{
+			var tagStart = source.indexOf('<',start);
+			if(tagStart<0){
+				if(!source.substr(start).match(/^\s*$/)){
+					var doc = domBuilder.doc;
+	    			var text = doc.createTextNode(source.substr(start));
+	    			doc.appendChild(text);
+	    			domBuilder.currentElement = text;
+				}
+				return;
+			}
+			if(tagStart>start){
+				appendText(tagStart);
+			}
+			switch(source.charAt(tagStart+1)){
+			case '/':
+				var end = source.indexOf('>',tagStart+3);
+				var tagName = source.substring(tagStart+2,end);
+				var config = parseStack.pop();
+				if(end<0){
+					
+	        		tagName = source.substring(tagStart+2).replace(/[\s<].*/,'');
+	        		errorHandler.error("end tag name: "+tagName+' is not complete:'+config.tagName);
+	        		end = tagStart+1+tagName.length;
+	        	}else if(tagName.match(/\s</)){
+	        		tagName = tagName.replace(/[\s<].*/,'');
+	        		errorHandler.error("end tag name: "+tagName+' maybe not complete');
+	        		end = tagStart+1+tagName.length;
+				}
+				var localNSMap = config.localNSMap;
+				var endMatch = config.tagName == tagName;
+				var endIgnoreCaseMach = endMatch || config.tagName&&config.tagName.toLowerCase() == tagName.toLowerCase();
+		        if(endIgnoreCaseMach){
+		        	domBuilder.endElement(config.uri,config.localName,tagName);
+					if(localNSMap){
+						for(var prefix in localNSMap){
+							domBuilder.endPrefixMapping(prefix) ;
+						}
+					}
+					if(!endMatch){
+		            	errorHandler.fatalError("end tag name: "+tagName+' is not match the current start tagName:'+config.tagName ); // No known test case
+					}
+		        }else {
+		        	parseStack.push(config);
+		        }
+				
+				end++;
+				break;
+				// end elment
+			case '?':// <?...?>
+				locator&&position(tagStart);
+				end = parseInstruction(source,tagStart,domBuilder);
+				break;
+			case '!':// <!doctype,<![CDATA,<!--
+				locator&&position(tagStart);
+				end = parseDCC(source,tagStart,domBuilder,errorHandler);
+				break;
+			default:
+				locator&&position(tagStart);
+				var el = new ElementAttributes();
+				var currentNSMap = parseStack[parseStack.length-1].currentNSMap;
+				//elStartEnd
+				var end = parseElementStartPart(source,tagStart,el,currentNSMap,entityReplacer,errorHandler);
+				var len = el.length;
+				
+				
+				if(!el.closed && fixSelfClosed(source,end,el.tagName,closeMap)){
+					el.closed = true;
+					if(!entityMap.nbsp){
+						errorHandler.warning('unclosed xml attribute');
+					}
+				}
+				if(locator && len){
+					var locator2 = copyLocator(locator,{});
+					//try{//attribute position fixed
+					for(var i = 0;i<len;i++){
+						var a = el[i];
+						position(a.offset);
+						a.locator = copyLocator(locator,{});
+					}
+					domBuilder.locator = locator2;
+					if(appendElement$1(el,domBuilder,currentNSMap)){
+						parseStack.push(el);
+					}
+					domBuilder.locator = locator;
+				}else {
+					if(appendElement$1(el,domBuilder,currentNSMap)){
+						parseStack.push(el);
+					}
+				}
+				
+				
+				
+				if(el.uri === 'http://www.w3.org/1999/xhtml' && !el.closed){
+					end = parseHtmlSpecialContent(source,end,el.tagName,entityReplacer,domBuilder);
+				}else {
+					end++;
+				}
+			}
+		}catch(e){
+			if (e instanceof ParseError$1) {
+				throw e;
+			}
+			errorHandler.error('element parse error: '+e);
+			end = -1;
+		}
+		if(end>start){
+			start = end;
+		}else {
+			//TODO: 这里有可能sax回退，有位置错误风险
+			appendText(Math.max(tagStart,start)+1);
+		}
+	}
+}
+function copyLocator(f,t){
+	t.lineNumber = f.lineNumber;
+	t.columnNumber = f.columnNumber;
+	return t;
+}
+
+/**
+ * @see #appendElement(source,elStartEnd,el,selfClosed,entityReplacer,domBuilder,parseStack);
+ * @return end of the elementStartPart(end of elementEndPart for selfClosed el)
+ */
+function parseElementStartPart(source,start,el,currentNSMap,entityReplacer,errorHandler){
+
+	/**
+	 * @param {string} qname
+	 * @param {string} value
+	 * @param {number} startIndex
+	 */
+	function addAttribute(qname, value, startIndex) {
+		if (qname in el.attributeNames) errorHandler.fatalError('Attribute ' + qname + ' redefined');
+		el.addValue(qname, value, startIndex);
+	}
+	var attrName;
+	var value;
+	var p = ++start;
+	var s = S_TAG;//status
+	while(true){
+		var c = source.charAt(p);
+		switch(c){
+		case '=':
+			if(s === S_ATTR){//attrName
+				attrName = source.slice(start,p);
+				s = S_EQ;
+			}else if(s === S_ATTR_SPACE){
+				s = S_EQ;
+			}else {
+				//fatalError: equal must after attrName or space after attrName
+				throw new Error('attribute equal must after attrName'); // No known test case
+			}
+			break;
+		case '\'':
+		case '"':
+			if(s === S_EQ || s === S_ATTR //|| s == S_ATTR_SPACE
+				){//equal
+				if(s === S_ATTR){
+					errorHandler.warning('attribute value must after "="');
+					attrName = source.slice(start,p);
+				}
+				start = p+1;
+				p = source.indexOf(c,start);
+				if(p>0){
+					value = source.slice(start,p).replace(/&#?\w+;/g,entityReplacer);
+					addAttribute(attrName, value, start-1);
+					s = S_ATTR_END;
+				}else {
+					//fatalError: no end quot match
+					throw new Error('attribute value no end \''+c+'\' match');
+				}
+			}else if(s == S_ATTR_NOQUOT_VALUE){
+				value = source.slice(start,p).replace(/&#?\w+;/g,entityReplacer);
+				//console.log(attrName,value,start,p)
+				addAttribute(attrName, value, start);
+				//console.dir(el)
+				errorHandler.warning('attribute "'+attrName+'" missed start quot('+c+')!!');
+				start = p+1;
+				s = S_ATTR_END;
+			}else {
+				//fatalError: no equal before
+				throw new Error('attribute value must after "="'); // No known test case
+			}
+			break;
+		case '/':
+			switch(s){
+			case S_TAG:
+				el.setTagName(source.slice(start,p));
+			case S_ATTR_END:
+			case S_TAG_SPACE:
+			case S_TAG_CLOSE:
+				s =S_TAG_CLOSE;
+				el.closed = true;
+			case S_ATTR_NOQUOT_VALUE:
+			case S_ATTR:
+			case S_ATTR_SPACE:
+				break;
+			//case S_EQ:
+			default:
+				throw new Error("attribute invalid close char('/')") // No known test case
+			}
+			break;
+		case ''://end document
+			errorHandler.error('unexpected end of input');
+			if(s == S_TAG){
+				el.setTagName(source.slice(start,p));
+			}
+			return p;
+		case '>':
+			switch(s){
+			case S_TAG:
+				el.setTagName(source.slice(start,p));
+			case S_ATTR_END:
+			case S_TAG_SPACE:
+			case S_TAG_CLOSE:
+				break;//normal
+			case S_ATTR_NOQUOT_VALUE://Compatible state
+			case S_ATTR:
+				value = source.slice(start,p);
+				if(value.slice(-1) === '/'){
+					el.closed  = true;
+					value = value.slice(0,-1);
+				}
+			case S_ATTR_SPACE:
+				if(s === S_ATTR_SPACE){
+					value = attrName;
+				}
+				if(s == S_ATTR_NOQUOT_VALUE){
+					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)){
+						errorHandler.warning('attribute "'+value+'" missed value!! "'+value+'" instead!!');
+					}
+					addAttribute(value, value, start);
+				}
+				break;
+			case S_EQ:
+				throw new Error('attribute value missed!!');
+			}
+//			console.log(tagName,tagNamePattern,tagNamePattern.test(tagName))
+			return p;
+		/*xml space '\x20' | #x9 | #xD | #xA; */
+		case '\u0080':
+			c = ' ';
+		default:
+			if(c<= ' '){//space
+				switch(s){
+				case S_TAG:
+					el.setTagName(source.slice(start,p));//tagName
+					s = S_TAG_SPACE;
+					break;
+				case S_ATTR:
+					attrName = source.slice(start,p);
+					s = S_ATTR_SPACE;
+					break;
+				case S_ATTR_NOQUOT_VALUE:
+					var value = source.slice(start,p).replace(/&#?\w+;/g,entityReplacer);
+					errorHandler.warning('attribute "'+value+'" missed quot(")!!');
+					addAttribute(attrName, value, start);
+				case S_ATTR_END:
+					s = S_TAG_SPACE;
+					break;
+				//case S_TAG_SPACE:
+				//case S_EQ:
+				//case S_ATTR_SPACE:
+				//	void();break;
+				//case S_TAG_CLOSE:
+					//ignore warning
+				}
+			}else {//not space
+//S_TAG,	S_ATTR,	S_EQ,	S_ATTR_NOQUOT_VALUE
+//S_ATTR_SPACE,	S_ATTR_END,	S_TAG_SPACE, S_TAG_CLOSE
+				switch(s){
+				//case S_TAG:void();break;
+				//case S_ATTR:void();break;
+				//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)){
+						errorHandler.warning('attribute "'+attrName+'" missed value!! "'+attrName+'" instead2!!');
+					}
+					addAttribute(attrName, attrName, start);
+					start = p;
+					s = S_ATTR;
+					break;
+				case S_ATTR_END:
+					errorHandler.warning('attribute space is required"'+attrName+'"!!');
+				case S_TAG_SPACE:
+					s = S_ATTR;
+					start = p;
+					break;
+				case S_EQ:
+					s = S_ATTR_NOQUOT_VALUE;
+					start = p;
+					break;
+				case S_TAG_CLOSE:
+					throw new Error("elements closed character '/' and '>' must be connected to");
+				}
+			}
+		}//end outer switch
+		//console.log('p++',p)
+		p++;
+	}
+}
+/**
+ * @return true if has new namespace define
+ */
+function appendElement$1(el,domBuilder,currentNSMap){
+	var tagName = el.tagName;
+	var localNSMap = null;
+	//var currentNSMap = parseStack[parseStack.length-1].currentNSMap;
+	var i = el.length;
+	while(i--){
+		var a = el[i];
+		var qName = a.qName;
+		var value = a.value;
+		var nsp = qName.indexOf(':');
+		if(nsp>0){
+			var prefix = a.prefix = qName.slice(0,nsp);
+			var localName = qName.slice(nsp+1);
+			var nsPrefix = prefix === 'xmlns' && localName;
+		}else {
+			localName = qName;
+			prefix = null;
+			nsPrefix = qName === 'xmlns' && '';
+		}
+		//can not set prefix,because prefix !== ''
+		a.localName = localName ;
+		//prefix == null for no ns prefix attribute 
+		if(nsPrefix !== false){//hack!!
+			if(localNSMap == null){
+				localNSMap = {};
+				//console.log(currentNSMap,0)
+				_copy(currentNSMap,currentNSMap={});
+				//console.log(currentNSMap,1)
+			}
+			currentNSMap[nsPrefix] = localNSMap[nsPrefix] = value;
+			a.uri = 'http://www.w3.org/2000/xmlns/';
+			domBuilder.startPrefixMapping(nsPrefix, value); 
+		}
+	}
+	var i = el.length;
+	while(i--){
+		a = el[i];
+		var prefix = a.prefix;
+		if(prefix){//no prefix attribute has no namespace
+			if(prefix === 'xml'){
+				a.uri = 'http://www.w3.org/XML/1998/namespace';
+			}if(prefix !== 'xmlns'){
+				a.uri = currentNSMap[prefix || ''];
+				
+				//{console.log('###'+a.qName,domBuilder.locator.systemId+'',currentNSMap,a.uri)}
+			}
+		}
+	}
+	var nsp = tagName.indexOf(':');
+	if(nsp>0){
+		prefix = el.prefix = tagName.slice(0,nsp);
+		localName = el.localName = tagName.slice(nsp+1);
+	}else {
+		prefix = null;//important!!
+		localName = el.localName = tagName;
+	}
+	//no prefix element has default namespace
+	var ns = el.uri = currentNSMap[prefix || ''];
+	domBuilder.startElement(ns,localName,tagName,el);
+	//endPrefixMapping and startPrefixMapping have not any help for dom builder
+	//localNSMap = null
+	if(el.closed){
+		domBuilder.endElement(ns,localName,tagName);
+		if(localNSMap){
+			for(prefix in localNSMap){
+				domBuilder.endPrefixMapping(prefix); 
+			}
+		}
+	}else {
+		el.currentNSMap = currentNSMap;
+		el.localNSMap = localNSMap;
+		//parseStack.push(el);
+		return true;
+	}
+}
+function parseHtmlSpecialContent(source,elStartEnd,tagName,entityReplacer,domBuilder){
+	if(/^(?:script|textarea)$/i.test(tagName)){
+		var elEndStart =  source.indexOf('</'+tagName+'>',elStartEnd);
+		var text = source.substring(elStartEnd+1,elEndStart);
+		if(/[&<]/.test(text)){
+			if(/^script$/i.test(tagName)){
+				//if(!/\]\]>/.test(text)){
+					//lexHandler.startCDATA();
+					domBuilder.characters(text,0,text.length);
+					//lexHandler.endCDATA();
+					return elEndStart;
+				//}
+			}//}else{//text area
+				text = text.replace(/&#?\w+;/g,entityReplacer);
+				domBuilder.characters(text,0,text.length);
+				return elEndStart;
+			//}
+			
+		}
+	}
+	return elStartEnd+1;
+}
+function fixSelfClosed(source,elStartEnd,tagName,closeMap){
+	//if(tagName in closeMap){
+	var pos = closeMap[tagName];
+	if(pos == null){
+		//console.log(tagName)
+		pos =  source.lastIndexOf('</'+tagName+'>');
+		if(pos<elStartEnd){//忘记闭合
+			pos = source.lastIndexOf('</'+tagName);
+		}
+		closeMap[tagName] =pos;
+	}
+	return pos<elStartEnd;
+	//} 
+}
+function _copy(source,target){
+	for(var n in source){target[n] = source[n];}
+}
+function parseDCC(source,start,domBuilder,errorHandler){//sure start with '<!'
+	var next= source.charAt(start+2);
+	switch(next){
+	case '-':
+		if(source.charAt(start + 3) === '-'){
+			var end = source.indexOf('-->',start+4);
+			//append comment source.substring(4,end)//<!--
+			if(end>start){
+				domBuilder.comment(source,start+4,end-start-4);
+				return end+3;
+			}else {
+				errorHandler.error("Unclosed comment");
+				return -1;
+			}
+		}else {
+			//error
+			return -1;
+		}
+	default:
+		if(source.substr(start+3,6) == 'CDATA['){
+			var end = source.indexOf(']]>',start+9);
+			domBuilder.startCDATA();
+			domBuilder.characters(source,start+9,end-start-9);
+			domBuilder.endCDATA(); 
+			return end+3;
+		}
+		//<!DOCTYPE
+		//startDTD(java.lang.String name, java.lang.String publicId, java.lang.String systemId) 
+		var matchs = split(source,start);
+		var len = matchs.length;
+		if(len>1 && /!doctype/i.test(matchs[0][0])){
+			var name = matchs[1][0];
+			var pubid = false;
+			var sysid = false;
+			if(len>3){
+				if(/^public$/i.test(matchs[2][0])){
+					pubid = matchs[3][0];
+					sysid = len>4 && matchs[4][0];
+				}else if(/^system$/i.test(matchs[2][0])){
+					sysid = matchs[3][0];
+				}
+			}
+			var lastMatch = matchs[len-1];
+			domBuilder.startDTD(name, pubid, sysid);
+			domBuilder.endDTD();
+			
+			return lastMatch.index+lastMatch[0].length
+		}
+	}
+	return -1;
+}
+
+
+
+function parseInstruction(source,start,domBuilder){
+	var end = source.indexOf('?>',start);
+	if(end){
+		var match = source.substring(start,end).match(/^<\?(\S*)\s*([\s\S]*?)\s*$/);
+		if(match){
+			match[0].length;
+			domBuilder.processingInstruction(match[1], match[2]) ;
+			return end+2;
+		}else {//error
+			return -1;
+		}
+	}
+	return -1;
+}
+
+function ElementAttributes(){
+	this.attributeNames = {};
+}
+ElementAttributes.prototype = {
+	setTagName:function(tagName){
+		if(!tagNamePattern.test(tagName)){
+			throw new Error('invalid tagName:'+tagName)
+		}
+		this.tagName = tagName;
+	},
+	addValue:function(qName, value, offset) {
+		if(!tagNamePattern.test(qName)){
+			throw new Error('invalid attribute:'+qName)
+		}
+		this.attributeNames[qName] = this.length;
+		this[this.length++] = {qName:qName,value:value,offset:offset};
+	},
+	length:0,
+	getLocalName:function(i){return this[i].localName},
+	getLocator:function(i){return this[i].locator},
+	getQName:function(i){return this[i].qName},
+	getURI:function(i){return this[i].uri},
+	getValue:function(i){return this[i].value}
+//	,getIndex:function(uri, localName)){
+//		if(localName){
+//			
+//		}else{
+//			var qName = uri
+//		}
+//	},
+//	getValue:function(){return this.getValue(this.getIndex.apply(this,arguments))},
+//	getType:function(uri,localName){}
+//	getType:function(i){},
+};
+
+
+
+function split(source,start){
+	var match;
+	var buf = [];
+	var reg = /'[^']+'|"[^"]+"|[^\s<>\/=]+=?|(\/?\s*>|<)/g;
+	reg.lastIndex = start;
+	reg.exec(source);//skip <
+	while(match = reg.exec(source)){
+		buf.push(match);
+		if(match[1])return buf;
+	}
+}
+
+sax$1.XMLReader = XMLReader$1;
+sax$1.ParseError = ParseError$1;
+
+var dom = {};
+
+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]));?
+ */
+function _extends(Class,Super){
+	var pt = Class.prototype;
+	if(!(pt instanceof Super)){
+		function t(){}		t.prototype = Super.prototype;
+		t = new t();
+		copy(pt,t);
+		Class.prototype = pt = t;
+	}
+	if(pt.constructor != Class){
+		if(typeof Class != 'function'){
+			console.error("unknow Class:"+Class);
+		}
+		pt.constructor = Class;
+	}
+}
+var htmlns = 'http://www.w3.org/1999/xhtml' ;
+// Node Types
+var NodeType = {};
+var ELEMENT_NODE                = NodeType.ELEMENT_NODE                = 1;
+var ATTRIBUTE_NODE              = NodeType.ATTRIBUTE_NODE              = 2;
+var TEXT_NODE                   = NodeType.TEXT_NODE                   = 3;
+var CDATA_SECTION_NODE          = NodeType.CDATA_SECTION_NODE          = 4;
+var ENTITY_REFERENCE_NODE       = NodeType.ENTITY_REFERENCE_NODE       = 5;
+var ENTITY_NODE                 = NodeType.ENTITY_NODE                 = 6;
+var PROCESSING_INSTRUCTION_NODE = NodeType.PROCESSING_INSTRUCTION_NODE = 7;
+var COMMENT_NODE                = NodeType.COMMENT_NODE                = 8;
+var DOCUMENT_NODE               = NodeType.DOCUMENT_NODE               = 9;
+var DOCUMENT_TYPE_NODE          = NodeType.DOCUMENT_TYPE_NODE          = 10;
+var DOCUMENT_FRAGMENT_NODE      = NodeType.DOCUMENT_FRAGMENT_NODE      = 11;
+var NOTATION_NODE               = NodeType.NOTATION_NODE               = 12;
+
+// ExceptionCode
+var ExceptionCode = {};
+var ExceptionMessage = {};
+ExceptionCode.INDEX_SIZE_ERR              = ((ExceptionMessage[1]="Index size error"),1);
+ExceptionCode.DOMSTRING_SIZE_ERR          = ((ExceptionMessage[2]="DOMString size error"),2);
+var HIERARCHY_REQUEST_ERR       = ExceptionCode.HIERARCHY_REQUEST_ERR       = ((ExceptionMessage[3]="Hierarchy request error"),3);
+ExceptionCode.WRONG_DOCUMENT_ERR          = ((ExceptionMessage[4]="Wrong document"),4);
+ExceptionCode.INVALID_CHARACTER_ERR       = ((ExceptionMessage[5]="Invalid character"),5);
+ExceptionCode.NO_DATA_ALLOWED_ERR         = ((ExceptionMessage[6]="No data allowed"),6);
+ExceptionCode.NO_MODIFICATION_ALLOWED_ERR = ((ExceptionMessage[7]="No modification allowed"),7);
+var NOT_FOUND_ERR               = ExceptionCode.NOT_FOUND_ERR               = ((ExceptionMessage[8]="Not found"),8);
+ExceptionCode.NOT_SUPPORTED_ERR           = ((ExceptionMessage[9]="Not supported"),9);
+var INUSE_ATTRIBUTE_ERR         = ExceptionCode.INUSE_ATTRIBUTE_ERR         = ((ExceptionMessage[10]="Attribute in use"),10);
+//level2
+ExceptionCode.INVALID_STATE_ERR        	= ((ExceptionMessage[11]="Invalid state"),11);
+ExceptionCode.SYNTAX_ERR               	= ((ExceptionMessage[12]="Syntax error"),12);
+ExceptionCode.INVALID_MODIFICATION_ERR 	= ((ExceptionMessage[13]="Invalid modification"),13);
+ExceptionCode.NAMESPACE_ERR           	= ((ExceptionMessage[14]="Invalid namespace"),14);
+ExceptionCode.INVALID_ACCESS_ERR      	= ((ExceptionMessage[15]="Invalid access"),15);
+
+/**
+ * DOM Level 2
+ * Object DOMException
+ * @see http://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113/ecma-script-binding.html
+ * @see http://www.w3.org/TR/REC-DOM-Level-1/ecma-script-language-binding.html
+ */
+function DOMException(code, message) {
+	if(message instanceof Error){
+		var error = message;
+	}else {
+		error = this;
+		Error.call(this, ExceptionMessage[code]);
+		this.message = ExceptionMessage[code];
+		if(Error.captureStackTrace) Error.captureStackTrace(this, DOMException);
+	}
+	error.code = code;
+	if(message) this.message = this.message + ": " + message;
+	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.
+ * The items in the NodeList are accessible via an integral index, starting from 0.
+ */
+function NodeList() {
+}NodeList.prototype = {
+	/**
+	 * The number of nodes in the list. The range of valid child node indices is 0 to length-1 inclusive.
+	 * @standard level1
+	 */
+	length:0, 
+	/**
+	 * Returns the indexth item in the collection. If index is greater than or equal to the number of nodes in the list, this returns null.
+	 * @standard level1
+	 * @param index  unsigned long 
+	 *   Index into the collection.
+	 * @return Node
+	 * 	The node at the indexth position in the NodeList, or null if that is not a valid index. 
+	 */
+	item: function(index) {
+		return this[index] || null;
+	},
+	toString:function(isHTML,nodeFilter){
+		for(var buf = [], i = 0;i<this.length;i++){
+			serializeToString(this[i],buf,isHTML,nodeFilter);
+		}
+		return buf.join('');
+	}
+};
+function LiveNodeList(node,refresh){
+	this._node = node;
+	this._refresh = refresh;
+	_updateLiveList(this);
+}
+function _updateLiveList(list){
+	var inc = list._node._inc || list._node.ownerDocument._inc;
+	if(list._inc != inc){
+		var ls = list._refresh(list._node);
+		//console.log(ls.length)
+		__set__(list,'length',ls.length);
+		copy(ls,list);
+		list._inc = inc;
+	}
+}
+LiveNodeList.prototype.item = function(i){
+	_updateLiveList(this);
+	return this[i];
+};
+
+_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.
+ * NamedNodeMap objects in the DOM are live.
+ * used for attributes or DocumentType entities 
+ */
+function NamedNodeMap() {
+}
+function _findNodeIndex(list,node){
+	var i = list.length;
+	while(i--){
+		if(list[i] === node){return i}
+	}
+}
+
+function _addNamedNode(el,list,newAttr,oldAttr){
+	if(oldAttr){
+		list[_findNodeIndex(list,oldAttr)] = newAttr;
+	}else {
+		list[list.length++] = newAttr;
+	}
+	if(el){
+		newAttr.ownerElement = el;
+		var doc = el.ownerDocument;
+		if(doc){
+			oldAttr && _onRemoveAttribute(doc,el,oldAttr);
+			_onAddAttribute(doc,el,newAttr);
+		}
+	}
+}
+function _removeNamedNode(el,list,attr){
+	//console.log('remove attr:'+attr)
+	var i = _findNodeIndex(list,attr);
+	if(i>=0){
+		var lastIndex = list.length-1;
+		while(i<lastIndex){
+			list[i] = list[++i];
+		}
+		list.length = lastIndex;
+		if(el){
+			var doc = el.ownerDocument;
+			if(doc){
+				_onRemoveAttribute(doc,el,attr);
+				attr.ownerElement = null;
+			}
+		}
+	}else {
+		throw DOMException(NOT_FOUND_ERR,new Error(el.tagName+'@'+attr))
+	}
+}
+NamedNodeMap.prototype = {
+	length:0,
+	item:NodeList.prototype.item,
+	getNamedItem: function(key) {
+//		if(key.indexOf(':')>0 || key == 'xmlns'){
+//			return null;
+//		}
+		//console.log()
+		var i = this.length;
+		while(i--){
+			var attr = this[i];
+			//console.log(attr.nodeName,key)
+			if(attr.nodeName == key){
+				return attr;
+			}
+		}
+	},
+	setNamedItem: function(attr) {
+		var el = attr.ownerElement;
+		if(el && el!=this._ownerElement){
+			throw new DOMException(INUSE_ATTRIBUTE_ERR);
+		}
+		var oldAttr = this.getNamedItem(attr.nodeName);
+		_addNamedNode(this._ownerElement,this,attr,oldAttr);
+		return oldAttr;
+	},
+	/* returns Node */
+	setNamedItemNS: function(attr) {// raises: WRONG_DOCUMENT_ERR,NO_MODIFICATION_ALLOWED_ERR,INUSE_ATTRIBUTE_ERR
+		var el = attr.ownerElement, oldAttr;
+		if(el && el!=this._ownerElement){
+			throw new DOMException(INUSE_ATTRIBUTE_ERR);
+		}
+		oldAttr = this.getNamedItemNS(attr.namespaceURI,attr.localName);
+		_addNamedNode(this._ownerElement,this,attr,oldAttr);
+		return oldAttr;
+	},
+
+	/* returns Node */
+	removeNamedItem: function(key) {
+		var attr = this.getNamedItem(key);
+		_removeNamedNode(this._ownerElement,this,attr);
+		return attr;
+		
+		
+	},// raises: NOT_FOUND_ERR,NO_MODIFICATION_ALLOWED_ERR
+	
+	//for level2
+	removeNamedItemNS:function(namespaceURI,localName){
+		var attr = this.getNamedItemNS(namespaceURI,localName);
+		_removeNamedNode(this._ownerElement,this,attr);
+		return attr;
+	},
+	getNamedItemNS: function(namespaceURI, localName) {
+		var i = this.length;
+		while(i--){
+			var node = this[i];
+			if(node.localName == localName && node.namespaceURI == namespaceURI){
+				return node;
+			}
+		}
+		return null;
+	}
+};
+/**
+ * @see http://www.w3.org/TR/REC-DOM-Level-1/level-one-core.html#ID-102161490
+ */
+function DOMImplementation$1(/* Object */ features) {
+	this._features = {};
+	if (features) {
+		for (var feature in features) {
+			 this._features = features[feature];
+		}
+	}
+}
+DOMImplementation$1.prototype = {
+	hasFeature: function(/* string */ feature, /* string */ version) {
+		var versions = this._features[feature.toLowerCase()];
+		if (versions && (!version || version in versions)) {
+			return true;
+		} else {
+			return false;
+		}
+	},
+	// Introduced in DOM Level 2:
+	createDocument:function(namespaceURI,  qualifiedName, doctype){// raises:INVALID_CHARACTER_ERR,NAMESPACE_ERR,WRONG_DOCUMENT_ERR
+		var doc = new Document();
+		doc.implementation = this;
+		doc.childNodes = new NodeList();
+		doc.doctype = doctype;
+		if(doctype){
+			doc.appendChild(doctype);
+		}
+		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
+		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;
+		return node;
+	}
+};
+
+
+/**
+ * @see http://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113/core.html#ID-1950641247
+ */
+
+function Node() {
+}
+Node.prototype = {
+	firstChild : null,
+	lastChild : null,
+	previousSibling : null,
+	nextSibling : null,
+	attributes : null,
+	parentNode : null,
+	childNodes : null,
+	ownerDocument : null,
+	nodeValue : null,
+	namespaceURI : null,
+	prefix : null,
+	localName : null,
+	// Modified in DOM Level 2:
+	insertBefore:function(newChild, refChild){//raises 
+		return _insertBefore(this,newChild,refChild);
+	},
+	replaceChild:function(newChild, oldChild){//raises 
+		this.insertBefore(newChild,oldChild);
+		if(oldChild){
+			this.removeChild(oldChild);
+		}
+	},
+	removeChild:function(oldChild){
+		return _removeChild(this,oldChild);
+	},
+	appendChild:function(newChild){
+		return this.insertBefore(newChild,null);
+	},
+	hasChildNodes:function(){
+		return this.firstChild != null;
+	},
+	cloneNode:function(deep){
+		return cloneNode(this.ownerDocument||this,this,deep);
+	},
+	// Modified in DOM Level 2:
+	normalize:function(){
+		var child = this.firstChild;
+		while(child){
+			var next = child.nextSibling;
+			if(next && next.nodeType == TEXT_NODE && child.nodeType == TEXT_NODE){
+				this.removeChild(next);
+				child.appendData(next.data);
+			}else {
+				child.normalize();
+				child = next;
+			}
+		}
+	},
+  	// Introduced in DOM Level 2:
+	isSupported:function(feature, version){
+		return this.ownerDocument.implementation.hasFeature(feature,version);
+	},
+    // Introduced in DOM Level 2:
+    hasAttributes:function(){
+    	return this.attributes.length>0;
+    },
+    lookupPrefix:function(namespaceURI){
+    	var el = this;
+    	while(el){
+    		var map = el._nsMap;
+    		//console.dir(map)
+    		if(map){
+    			for(var n in map){
+    				if(map[n] == namespaceURI){
+    					return n;
+    				}
+    			}
+    		}
+    		el = el.nodeType == ATTRIBUTE_NODE?el.ownerDocument : el.parentNode;
+    	}
+    	return null;
+    },
+    // Introduced in DOM Level 3:
+    lookupNamespaceURI:function(prefix){
+    	var el = this;
+    	while(el){
+    		var map = el._nsMap;
+    		//console.dir(map)
+    		if(map){
+    			if(prefix in map){
+    				return map[prefix] ;
+    			}
+    		}
+    		el = el.nodeType == ATTRIBUTE_NODE?el.ownerDocument : el.parentNode;
+    	}
+    	return null;
+    },
+    // Introduced in DOM Level 3:
+    isDefaultNamespace:function(namespaceURI){
+    	var prefix = this.lookupPrefix(namespaceURI);
+    	return prefix == null;
+    }
+};
+
+
+function _xmlEncoder(c){
+	return c == '<' && '&lt;' ||
+         c == '>' && '&gt;' ||
+         c == '&' && '&amp;' ||
+         c == '"' && '&quot;' ||
+         '&#'+c.charCodeAt()+';'
+}
+
+
+copy(NodeType,Node);
+copy(NodeType,Node.prototype);
+
+/**
+ * @param callback return true for continue,false for break
+ * @return boolean true: break visit;
+ */
+function _visitNode(node,callback){
+	if(callback(node)){
+		return true;
+	}
+	if(node = node.firstChild){
+		do{
+			if(_visitNode(node,callback)){return true}
+        }while(node=node.nextSibling)
+    }
+}
+
+
+
+function Document(){
+}
+function _onAddAttribute(doc,el,newAttr){
+	doc && doc._inc++;
+	var ns = newAttr.namespaceURI ;
+	if(ns == 'http://www.w3.org/2000/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/'){
+		//update namespace
+		delete el._nsMap[newAttr.prefix?newAttr.localName:''];
+	}
+}
+function _onUpdateChild(doc,el,newChild){
+	if(doc && doc._inc){
+		doc._inc++;
+		//update childNodes
+		var cs = el.childNodes;
+		if(newChild){
+			cs[cs.length++] = newChild;
+		}else {
+			//console.log(1)
+			var child = el.firstChild;
+			var i = 0;
+			while(child){
+				cs[i++] = child;
+				child =child.nextSibling;
+			}
+			cs.length = i;
+		}
+	}
+}
+
+/**
+ * attributes;
+ * children;
+ * 
+ * writeable properties:
+ * nodeValue,Attr:value,CharacterData:data
+ * prefix
+ */
+function _removeChild(parentNode,child){
+	var previous = child.previousSibling;
+	var next = child.nextSibling;
+	if(previous){
+		previous.nextSibling = next;
+	}else {
+		parentNode.firstChild = next;
+	}
+	if(next){
+		next.previousSibling = previous;
+	}else {
+		parentNode.lastChild = previous;
+	}
+	_onUpdateChild(parentNode.ownerDocument,parentNode);
+	return child;
+}
+/**
+ * preformance key(refChild == null)
+ */
+function _insertBefore(parentNode,newChild,nextChild){
+	var cp = newChild.parentNode;
+	if(cp){
+		cp.removeChild(newChild);//remove and update
+	}
+	if(newChild.nodeType === DOCUMENT_FRAGMENT_NODE){
+		var newFirst = newChild.firstChild;
+		if (newFirst == null) {
+			return newChild;
+		}
+		var newLast = newChild.lastChild;
+	}else {
+		newFirst = newLast = newChild;
+	}
+	var pre = nextChild ? nextChild.previousSibling : parentNode.lastChild;
+
+	newFirst.previousSibling = pre;
+	newLast.nextSibling = nextChild;
+	
+	
+	if(pre){
+		pre.nextSibling = newFirst;
+	}else {
+		parentNode.firstChild = newFirst;
+	}
+	if(nextChild == null){
+		parentNode.lastChild = newLast;
+	}else {
+		nextChild.previousSibling = newLast;
+	}
+	do{
+		newFirst.parentNode = parentNode;
+	}while(newFirst !== newLast && (newFirst= newFirst.nextSibling))
+	_onUpdateChild(parentNode.ownerDocument||parentNode,parentNode);
+	//console.log(parentNode.lastChild.nextSibling == null)
+	if (newChild.nodeType == DOCUMENT_FRAGMENT_NODE) {
+		newChild.firstChild = newChild.lastChild = null;
+	}
+	return newChild;
+}
+function _appendSingleChild(parentNode,newChild){
+	var cp = newChild.parentNode;
+	if(cp){
+		var pre = parentNode.lastChild;
+		cp.removeChild(newChild);//remove and update
+		var pre = parentNode.lastChild;
+	}
+	var pre = parentNode.lastChild;
+	newChild.parentNode = parentNode;
+	newChild.previousSibling = pre;
+	newChild.nextSibling = null;
+	if(pre){
+		pre.nextSibling = newChild;
+	}else {
+		parentNode.firstChild = newChild;
+	}
+	parentNode.lastChild = newChild;
+	_onUpdateChild(parentNode.ownerDocument,parentNode,newChild);
+	return newChild;
+	//console.log("__aa",parentNode.lastChild.nextSibling == null)
+}
+Document.prototype = {
+	//implementation : null,
+	nodeName :  '#document',
+	nodeType :  DOCUMENT_NODE,
+	doctype :  null,
+	documentElement :  null,
+	_inc : 1,
+	
+	insertBefore :  function(newChild, refChild){//raises 
+		if(newChild.nodeType == DOCUMENT_FRAGMENT_NODE){
+			var child = newChild.firstChild;
+			while(child){
+				var next = child.nextSibling;
+				this.insertBefore(child,refChild);
+				child = next;
+			}
+			return newChild;
+		}
+		if(this.documentElement == null && newChild.nodeType == ELEMENT_NODE){
+			this.documentElement = newChild;
+		}
+		
+		return _insertBefore(this,newChild,refChild),(newChild.ownerDocument = this),newChild;
+	},
+	removeChild :  function(oldChild){
+		if(this.documentElement == oldChild){
+			this.documentElement = null;
+		}
+		return _removeChild(this,oldChild);
+	},
+	// Introduced in DOM Level 2:
+	importNode : function(importedNode,deep){
+		return importNode(this,importedNode,deep);
+	},
+	// Introduced in DOM Level 2:
+	getElementById :	function(id){
+		var rtv = null;
+		_visitNode(this.documentElement,function(node){
+			if(node.nodeType == ELEMENT_NODE){
+				if(node.getAttribute('id') == id){
+					rtv = node;
+					return true;
+				}
+			}
+		});
+		return rtv;
+	},
+	
+	getElementsByClassName: function(className) {
+		var pattern = new RegExp("(^|\\s)" + className + "(\\s|$)");
+		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);
+					}
+				}
+			});
+			return ls;
+		});
+	},
+	
+	//document factory method:
+	createElement :	function(tagName){
+		var node = new Element();
+		node.ownerDocument = this;
+		node.nodeName = tagName;
+		node.tagName = tagName;
+		node.childNodes = new NodeList();
+		var attrs	= node.attributes = new NamedNodeMap();
+		attrs._ownerElement = node;
+		return node;
+	},
+	createDocumentFragment :	function(){
+		var node = new DocumentFragment();
+		node.ownerDocument = this;
+		node.childNodes = new NodeList();
+		return node;
+	},
+	createTextNode :	function(data){
+		var node = new Text();
+		node.ownerDocument = this;
+		node.appendData(data);
+		return node;
+	},
+	createComment :	function(data){
+		var node = new Comment();
+		node.ownerDocument = this;
+		node.appendData(data);
+		return node;
+	},
+	createCDATASection :	function(data){
+		var node = new CDATASection();
+		node.ownerDocument = this;
+		node.appendData(data);
+		return node;
+	},
+	createProcessingInstruction :	function(target,data){
+		var node = new ProcessingInstruction();
+		node.ownerDocument = this;
+		node.tagName = node.target = target;
+		node.nodeValue= node.data = data;
+		return node;
+	},
+	createAttribute :	function(name){
+		var node = new Attr();
+		node.ownerDocument	= this;
+		node.name = name;
+		node.nodeName	= name;
+		node.localName = name;
+		node.specified = true;
+		return node;
+	},
+	createEntityReference :	function(name){
+		var node = new EntityReference();
+		node.ownerDocument	= this;
+		node.nodeName	= name;
+		return node;
+	},
+	// Introduced in DOM Level 2:
+	createElementNS :	function(namespaceURI,qualifiedName){
+		var node = new Element();
+		var pl = qualifiedName.split(':');
+		var attrs	= node.attributes = new NamedNodeMap();
+		node.childNodes = new NodeList();
+		node.ownerDocument = this;
+		node.nodeName = qualifiedName;
+		node.tagName = qualifiedName;
+		node.namespaceURI = namespaceURI;
+		if(pl.length == 2){
+			node.prefix = pl[0];
+			node.localName = pl[1];
+		}else {
+			//el.prefix = null;
+			node.localName = qualifiedName;
+		}
+		attrs._ownerElement = node;
+		return node;
+	},
+	// Introduced in DOM Level 2:
+	createAttributeNS :	function(namespaceURI,qualifiedName){
+		var node = new Attr();
+		var pl = qualifiedName.split(':');
+		node.ownerDocument = this;
+		node.nodeName = qualifiedName;
+		node.name = qualifiedName;
+		node.namespaceURI = namespaceURI;
+		node.specified = true;
+		if(pl.length == 2){
+			node.prefix = pl[0];
+			node.localName = pl[1];
+		}else {
+			//el.prefix = null;
+			node.localName = qualifiedName;
+		}
+		return node;
+	}
+};
+_extends(Document,Node);
+
+
+function Element() {
+	this._nsMap = {};
+}Element.prototype = {
+	nodeType : ELEMENT_NODE,
+	hasAttribute : function(name){
+		return this.getAttributeNode(name)!=null;
+	},
+	getAttribute : function(name){
+		var attr = this.getAttributeNode(name);
+		return attr && attr.value || '';
+	},
+	getAttributeNode : function(name){
+		return this.attributes.getNamedItem(name);
+	},
+	setAttribute : function(name, value){
+		var attr = this.ownerDocument.createAttribute(name);
+		attr.value = attr.nodeValue = "" + value;
+		this.setAttributeNode(attr);
+	},
+	removeAttribute : function(name){
+		var attr = this.getAttributeNode(name);
+		attr && this.removeAttributeNode(attr);
+	},
+	
+	//four real opeartion method
+	appendChild:function(newChild){
+		if(newChild.nodeType === DOCUMENT_FRAGMENT_NODE){
+			return this.insertBefore(newChild,null);
+		}else {
+			return _appendSingleChild(this,newChild);
+		}
+	},
+	setAttributeNode : function(newAttr){
+		return this.attributes.setNamedItem(newAttr);
+	},
+	setAttributeNodeNS : function(newAttr){
+		return this.attributes.setNamedItemNS(newAttr);
+	},
+	removeAttributeNode : function(oldAttr){
+		//console.log(this == oldAttr.ownerElement)
+		return this.attributes.removeNamedItem(oldAttr.nodeName);
+	},
+	//get real attribute name,and remove it by removeAttributeNode
+	removeAttributeNS : function(namespaceURI, localName){
+		var old = this.getAttributeNodeNS(namespaceURI, localName);
+		old && this.removeAttributeNode(old);
+	},
+	
+	hasAttributeNS : function(namespaceURI, localName){
+		return this.getAttributeNodeNS(namespaceURI, localName)!=null;
+	},
+	getAttributeNS : function(namespaceURI, localName){
+		var attr = this.getAttributeNodeNS(namespaceURI, localName);
+		return attr && attr.value || '';
+	},
+	setAttributeNS : function(namespaceURI, qualifiedName, value){
+		var attr = this.ownerDocument.createAttributeNS(namespaceURI, qualifiedName);
+		attr.value = attr.nodeValue = "" + value;
+		this.setAttributeNode(attr);
+	},
+	getAttributeNodeNS : function(namespaceURI, localName){
+		return this.attributes.getNamedItemNS(namespaceURI, localName);
+	},
+	
+	getElementsByTagName : function(tagName){
+		return new LiveNodeList(this,function(base){
+			var ls = [];
+			_visitNode(base,function(node){
+				if(node !== base && node.nodeType == ELEMENT_NODE && (tagName === '*' || node.tagName == tagName)){
+					ls.push(node);
+				}
+			});
+			return ls;
+		});
+	},
+	getElementsByTagNameNS : function(namespaceURI, localName){
+		return new LiveNodeList(this,function(base){
+			var ls = [];
+			_visitNode(base,function(node){
+				if(node !== base && node.nodeType === ELEMENT_NODE && (namespaceURI === '*' || node.namespaceURI === namespaceURI) && (localName === '*' || node.localName == localName)){
+					ls.push(node);
+				}
+			});
+			return ls;
+			
+		});
+	}
+};
+Document.prototype.getElementsByTagName = Element.prototype.getElementsByTagName;
+Document.prototype.getElementsByTagNameNS = Element.prototype.getElementsByTagNameNS;
+
+
+_extends(Element,Node);
+function Attr() {
+}Attr.prototype.nodeType = ATTRIBUTE_NODE;
+_extends(Attr,Node);
+
+
+function CharacterData() {
+}CharacterData.prototype = {
+	data : '',
+	substringData : function(offset, count) {
+		return this.data.substring(offset, offset+count);
+	},
+	appendData: function(text) {
+		text = this.data+text;
+		this.nodeValue = this.data = text;
+		this.length = text.length;
+	},
+	insertData: function(offset,text) {
+		this.replaceData(offset,0,text);
+	
+	},
+	appendChild:function(newChild){
+		throw new Error(ExceptionMessage[HIERARCHY_REQUEST_ERR])
+	},
+	deleteData: function(offset, count) {
+		this.replaceData(offset,count,"");
+	},
+	replaceData: function(offset, count, text) {
+		var start = this.data.substring(0,offset);
+		var end = this.data.substring(offset+count);
+		text = start + text + end;
+		this.nodeValue = this.data = text;
+		this.length = text.length;
+	}
+};
+_extends(CharacterData,Node);
+function Text() {
+}Text.prototype = {
+	nodeName : "#text",
+	nodeType : TEXT_NODE,
+	splitText : function(offset) {
+		var text = this.data;
+		var newText = text.substring(offset);
+		text = text.substring(0, offset);
+		this.data = this.nodeValue = text;
+		this.length = text.length;
+		var newNode = this.ownerDocument.createTextNode(newText);
+		if(this.parentNode){
+			this.parentNode.insertBefore(newNode, this.nextSibling);
+		}
+		return newNode;
+	}
+};
+_extends(Text,CharacterData);
+function Comment() {
+}Comment.prototype = {
+	nodeName : "#comment",
+	nodeType : COMMENT_NODE
+};
+_extends(Comment,CharacterData);
+
+function CDATASection() {
+}CDATASection.prototype = {
+	nodeName : "#cdata-section",
+	nodeType : CDATA_SECTION_NODE
+};
+_extends(CDATASection,CharacterData);
+
+
+function DocumentType() {
+}DocumentType.prototype.nodeType = DOCUMENT_TYPE_NODE;
+_extends(DocumentType,Node);
+
+function Notation() {
+}Notation.prototype.nodeType = NOTATION_NODE;
+_extends(Notation,Node);
+
+function Entity() {
+}Entity.prototype.nodeType = ENTITY_NODE;
+_extends(Entity,Node);
+
+function EntityReference() {
+}EntityReference.prototype.nodeType = ENTITY_REFERENCE_NODE;
+_extends(EntityReference,Node);
+
+function DocumentFragment() {
+}DocumentFragment.prototype.nodeName =	"#document-fragment";
+DocumentFragment.prototype.nodeType =	DOCUMENT_FRAGMENT_NODE;
+_extends(DocumentFragment,Node);
+
+
+function ProcessingInstruction() {
+}
+ProcessingInstruction.prototype.nodeType = PROCESSING_INSTRUCTION_NODE;
+_extends(ProcessingInstruction,Node);
+function XMLSerializer(){}
+XMLSerializer.prototype.serializeToString = function(node,isHtml,nodeFilter){
+	return nodeSerializeToString.call(node,isHtml,nodeFilter);
+};
+Node.prototype.toString = nodeSerializeToString;
+function nodeSerializeToString(isHtml,nodeFilter){
+	var buf = [];
+	var refNode = this.nodeType == 9 && this.documentElement || this;
+	var prefix = refNode.prefix;
+	var uri = refNode.namespaceURI;
+	
+	if(uri && prefix == null){
+		//console.log(prefix)
+		var prefix = refNode.lookupPrefix(uri);
+		if(prefix == null){
+			//isHTML = true;
+			var visibleNamespaces=[
+			{namespace:uri,prefix:null}
+			//{namespace:uri,prefix:''}
+			];
+		}
+	}
+	serializeToString(this,buf,isHtml,nodeFilter,visibleNamespaces);
+	//console.log('###',this.nodeType,uri,prefix,buf.join(''))
+	return buf.join('');
+}
+function needNamespaceDefine(node,isHTML, visibleNamespaces) {
+	var prefix = node.prefix||'';
+	var uri = node.namespaceURI;
+	if (!prefix && !uri){
+		return false;
+	}
+	if (prefix === "xml" && uri === "http://www.w3.org/XML/1998/namespace" 
+		|| uri == 'http://www.w3.org/2000/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;
+		}
+	}
+	//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;
+}
+function serializeToString(node,buf,isHTML,nodeFilter,visibleNamespaces){
+	if(nodeFilter){
+		node = nodeFilter(node);
+		if(node){
+			if(typeof node == 'string'){
+				buf.push(node);
+				return;
+			}
+		}else {
+			return;
+		}
+		//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);
+		
+		
+		
+		for(var i=0;i<len;i++){
+			// add namespaces for attributes
+			var attr = attrs.item(i);
+			if (attr.prefix == 'xmlns') {
+				visibleNamespaces.push({ prefix: attr.localName, namespace: attr.value });
+			}else if(attr.nodeName == 'xmlns'){
+				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 , '"');
+				visibleNamespaces.push({ prefix: prefix, namespace:uri });
+			}
+			serializeToString(attr,buf,isHTML,nodeFilter,visibleNamespaces);
+		}
+		// add namespace for current node		
+		if (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 });
+			}
+		}
+		
+		if(child || isHTML && !/^(?:meta|link|img|br|hr|input)$/i.test(nodeName)){
+			buf.push('>');
+			//if is cdata child node
+			if(isHTML && /^script$/i.test(nodeName)){
+				while(child){
+					if(child.data){
+						buf.push(child.data);
+					}else {
+						serializeToString(child,buf,isHTML,nodeFilter,visibleNamespaces);
+					}
+					child = child.nextSibling;
+				}
+			}else
+			{
+				while(child){
+					serializeToString(child,buf,isHTML,nodeFilter,visibleNamespaces);
+					child = child.nextSibling;
+				}
+			}
+			buf.push('</',nodeName,'>');
+		}else {
+			buf.push('/>');
+		}
+		// remove added visible namespaces
+		//visibleNamespaces.length = startVisibleNamespaces;
+		return;
+	case DOCUMENT_NODE:
+	case DOCUMENT_FRAGMENT_NODE:
+		var child = node.firstChild;
+		while(child){
+			serializeToString(child,buf,isHTML,nodeFilter,visibleNamespaces);
+			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), '"');
+	case TEXT_NODE:
+		/**
+		 * The ampersand character (&) and the left angle bracket (<) must not appear in their literal form,
+		 * except when used as markup delimiters, or within a comment, a processing instruction, or a CDATA section.
+		 * If they are needed elsewhere, they must be escaped using either numeric character references or the strings
+		 * `&amp;` and `&lt;` respectively.
+		 * The right angle bracket (>) may be represented using the string " &gt; ", and must, for compatibility,
+		 * be escaped using either `&gt;` or a character reference when it appears in the string `]]>` in content,
+		 * when that string is not marking the end of a CDATA section.
+		 *
+		 * In the content of elements, character data is any string of characters
+		 * which does not contain the start-delimiter of any markup
+		 * and does not include the CDATA-section-close delimiter, `]]>`.
+		 *
+		 * @see https://www.w3.org/TR/xml/#NT-CharData
+		 */
+		return buf.push(node.data
+			.replace(/[<&]/g,_xmlEncoder)
+			.replace(/]]>/g, ']]&gt;')
+		);
+	case CDATA_SECTION_NODE:
+		return buf.push( '<![CDATA[',node.data,']]>');
+	case COMMENT_NODE:
+		return buf.push( "<!--",node.data,"-->");
+	case DOCUMENT_TYPE_NODE:
+		var pubid = node.publicId;
+		var sysid = node.systemId;
+		buf.push('<!DOCTYPE ',node.name);
+		if(pubid){
+			buf.push(' PUBLIC ', pubid);
+			if (sysid && sysid!='.') {
+				buf.push(' ', sysid);
+			}
+			buf.push('>');
+		}else if(sysid && sysid!='.'){
+			buf.push(' SYSTEM ', sysid, '>');
+		}else {
+			var sub = node.internalSubset;
+			if(sub){
+				buf.push(" [",sub,"]");
+			}
+			buf.push(">");
+		}
+		return;
+	case PROCESSING_INSTRUCTION_NODE:
+		return buf.push( "<?",node.target," ",node.data,"?>");
+	case ENTITY_REFERENCE_NODE:
+		return buf.push( '&',node.nodeName,';');
+	//case ENTITY_NODE:
+	//case NOTATION_NODE:
+	default:
+		buf.push('??',node.nodeName);
+	}
+}
+function importNode(doc,node,deep){
+	var node2;
+	switch (node.nodeType) {
+	case ELEMENT_NODE:
+		node2 = node.cloneNode(false);
+		node2.ownerDocument = doc;
+		//var attrs = node2.attributes;
+		//var len = attrs.length;
+		//for(var i=0;i<len;i++){
+			//node2.setAttributeNodeNS(importNode(doc,attrs.item(i),deep));
+		//}
+	case DOCUMENT_FRAGMENT_NODE:
+		break;
+	case ATTRIBUTE_NODE:
+		deep = true;
+		break;
+	//case ENTITY_REFERENCE_NODE:
+	//case PROCESSING_INSTRUCTION_NODE:
+	////case TEXT_NODE:
+	//case CDATA_SECTION_NODE:
+	//case COMMENT_NODE:
+	//	deep = false;
+	//	break;
+	//case DOCUMENT_NODE:
+	//case DOCUMENT_TYPE_NODE:
+	//cannot be imported.
+	//case ENTITY_NODE:
+	//case NOTATION_NODE：
+	//can not hit in level3
+	//default:throw e;
+	}
+	if(!node2){
+		node2 = node.cloneNode(false);//false
+	}
+	node2.ownerDocument = doc;
+	node2.parentNode = null;
+	if(deep){
+		var child = node.firstChild;
+		while(child){
+			node2.appendChild(importNode(doc,child,deep));
+			child = child.nextSibling;
+		}
+	}
+	return node2;
+}
+//
+//var _relationMap = {firstChild:1,lastChild:1,previousSibling:1,nextSibling:1,
+//					attributes:1,childNodes:1,parentNode:1,documentElement:1,doctype,};
+function cloneNode(doc,node,deep){
+	var node2 = new node.constructor();
+	for(var n in node){
+		var v = node[n];
+		if(typeof v != 'object' ){
+			if(v != node2[n]){
+				node2[n] = v;
+			}
+		}
+	}
+	if(node.childNodes){
+		node2.childNodes = new NodeList();
+	}
+	node2.ownerDocument = doc;
+	switch (node2.nodeType) {
+	case ELEMENT_NODE:
+		var attrs	= node.attributes;
+		var attrs2	= node2.attributes = new NamedNodeMap();
+		var len = attrs.length;
+		attrs2._ownerElement = node2;
+		for(var i=0;i<len;i++){
+			node2.setAttributeNode(cloneNode(doc,attrs.item(i),true));
+		}
+		break;	case ATTRIBUTE_NODE:
+		deep = true;
+	}
+	if(deep){
+		var child = node.firstChild;
+		while(child){
+			node2.appendChild(cloneNode(doc,child,deep));
+			child = child.nextSibling;
+		}
+	}
+	return node2;
+}
+
+function __set__(object,key,value){
+	object[key] = value;
+}
+//do dynamic
+try{
+	if(Object.defineProperty){
+		Object.defineProperty(LiveNodeList.prototype,'length',{
+			get:function(){
+				_updateLiveList(this);
+				return this.$$length;
+			}
+		});
+		Object.defineProperty(Node.prototype,'textContent',{
+			get:function(){
+				return getTextContent(this);
+			},
+			set:function(data){
+				switch(this.nodeType){
+				case ELEMENT_NODE:
+				case DOCUMENT_FRAGMENT_NODE:
+					while(this.firstChild){
+						this.removeChild(this.firstChild);
+					}
+					if(data || String(data)){
+						this.appendChild(this.ownerDocument.createTextNode(data));
+					}
+					break;
+				default:
+					//TODO:
+					this.data = data;
+					this.value = data;
+					this.nodeValue = data;
+				}
+			}
+		});
+		
+		function getTextContent(node){
+			switch(node.nodeType){
+			case ELEMENT_NODE:
+			case DOCUMENT_FRAGMENT_NODE:
+				var buf = [];
+				node = node.firstChild;
+				while(node){
+					if(node.nodeType!==7 && node.nodeType !==8){
+						buf.push(getTextContent(node));
+					}
+					node = node.nextSibling;
+				}
+				return buf.join('');
+			default:
+				return node.nodeValue;
+			}
+		}
+		__set__ = function(object,key,value){
+			//console.log(value)
+			object['$$'+key] = value;
+		};
+	}
+}catch(e){//ie8
+}
+
+//if(typeof require == 'function'){
+	dom.Node = Node;
+	dom.DOMException = DOMException;
+	dom.DOMImplementation = DOMImplementation$1;
+	dom.XMLSerializer = XMLSerializer;
+
+function DOMParser(options){
+	this.options = options ||{locator:{}};
 }
 
-/**
- * Intercepts and defers any requests on the page
- * until the Service Worker instance is ready.
- * Must only be used in a browser.
- */
-function deferNetworkRequestsUntil(predicatePromise) {
-    // Defer any `XMLHttpRequest` requests until the Service Worker is ready.
-    const originalXhrSend = window.XMLHttpRequest.prototype.send;
-    window.XMLHttpRequest.prototype.send = function (...args) {
-        // Keep this function synchronous to comply with `XMLHttpRequest.prototype.send`,
-        // because that method is always synchronous.
-        until$1(() => predicatePromise).then(() => {
-            window.XMLHttpRequest.prototype.send = originalXhrSend;
-            this.send(...args);
-        });
-    };
-    // Defer any `fetch` requests until the Service Worker is ready.
-    const originalFetch = window.fetch;
-    window.fetch = (...args) => __awaiter(this, void 0, void 0, function* () {
-        yield until$1(() => predicatePromise);
-        window.fetch = originalFetch;
-        return window.fetch(...args);
-    });
+DOMParser.prototype.parseFromString = function(source,mimeType){
+	var options = this.options;
+	var sax =  new XMLReader();
+	var domBuilder = options.domBuilder || new DOMHandler();//contentHandler and LexicalHandler
+	var errorHandler = options.errorHandler;
+	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':"'"};
+	if(locator){
+		domBuilder.setDocumentLocator(locator);
+	}
+
+	sax.errorHandler = buildErrorHandler(errorHandler,domBuilder,locator);
+	sax.domBuilder = options.domBuilder || domBuilder;
+	if(isHTML){
+		defaultNSMap['']= 'http://www.w3.org/1999/xhtml';
+	}
+	defaultNSMap.xml = defaultNSMap.xml || 'http://www.w3.org/XML/1998/namespace';
+	if(source && typeof source === 'string'){
+		sax.parse(source,defaultNSMap,entityMap);
+	}else {
+		sax.errorHandler.error("invalid doc source");
+	}
+	return domBuilder.doc;
+};
+function buildErrorHandler(errorImpl,domBuilder,locator){
+	if(!errorImpl){
+		if(domBuilder instanceof DOMHandler){
+			return domBuilder;
+		}
+		errorImpl = domBuilder ;
+	}
+	var errorHandler = {};
+	var isCallback = errorImpl instanceof Function;
+	locator = locator||{};
+	function build(key){
+		var fn = errorImpl[key];
+		if(!fn && isCallback){
+			fn = errorImpl.length == 2?function(msg){errorImpl(key,msg);}:errorImpl;
+		}
+		errorHandler[key] = fn && function(msg){
+			fn('[xmldom '+key+']\t'+msg+_locator(locator));
+		}||function(){};
+	}
+	build('warning');
+	build('error');
+	build('fatalError');
+	return errorHandler;
 }
 
-function createResponseListener(context) {
-    return (_, message) => {
-        var _a;
-        const { payload: responseJson } = message;
-        /**
-         * CORS requests with `mode: "no-cors"` result in "opaque" responses.
-         * That kind of responses cannot be manipulated in JavaScript due
-         * to the security considerations.
-         * @see https://fetch.spec.whatwg.org/#concept-filtered-response-opaque
-         * @see https://github.com/mswjs/msw/issues/529
-         */
-        if ((_a = responseJson.type) === null || _a === void 0 ? void 0 : _a.includes('opaque')) {
-            return;
-        }
-        const response = new Response(responseJson.body || null, responseJson);
-        const isMockedResponse = response.headers.get('x-powered-by') === 'msw';
-        if (isMockedResponse) {
-            context.emitter.emit('response:mocked', response, responseJson.requestId);
-        }
-        else {
-            context.emitter.emit('response:bypass', response, responseJson.requestId);
-        }
-    };
+//console.log('#\n\n\n\n\n\n\n####')
+/**
+ * +ContentHandler+ErrorHandler
+ * +LexicalHandler+EntityResolver2
+ * -DeclHandler-DTDHandler
+ *
+ * DefaultHandler:EntityResolver, DTDHandler, ContentHandler, ErrorHandler
+ * DefaultHandler2:DefaultHandler,LexicalHandler, DeclHandler, EntityResolver2
+ * @link http://www.saxproject.org/apidoc/org/xml/sax/helpers/DefaultHandler.html
+ */
+function DOMHandler() {
+    this.cdata = false;
+}
+function position(locator,node){
+	node.lineNumber = locator.lineNumber;
+	node.columnNumber = locator.columnNumber;
+}
+/**
+ * @see org.xml.sax.ContentHandler#startDocument
+ * @link http://www.saxproject.org/apidoc/org/xml/sax/ContentHandler.html
+ */
+DOMHandler.prototype = {
+	startDocument : function() {
+    	this.doc = new DOMImplementation().createDocument(null, null, null);
+    	if (this.locator) {
+        	this.doc.documentURI = this.locator.systemId;
+    	}
+	},
+	startElement:function(namespaceURI, localName, qName, attrs) {
+		var doc = this.doc;
+	    var el = doc.createElementNS(namespaceURI, qName||localName);
+	    var len = attrs.length;
+	    appendElement(this, el);
+	    this.currentElement = el;
+
+		this.locator && position(this.locator,el);
+	    for (var i = 0 ; i < len; i++) {
+	        var namespaceURI = attrs.getURI(i);
+	        var value = attrs.getValue(i);
+	        var qName = attrs.getQName(i);
+			var attr = doc.createAttributeNS(namespaceURI, qName);
+			this.locator &&position(attrs.getLocator(i),attr);
+			attr.value = attr.nodeValue = value;
+			el.setAttributeNode(attr);
+	    }
+	},
+	endElement:function(namespaceURI, localName, qName) {
+		var current = this.currentElement;
+		current.tagName;
+		this.currentElement = current.parentNode;
+	},
+	startPrefixMapping:function(prefix, uri) {
+	},
+	endPrefixMapping:function(prefix) {
+	},
+	processingInstruction:function(target, data) {
+	    var ins = this.doc.createProcessingInstruction(target, data);
+	    this.locator && position(this.locator,ins);
+	    appendElement(this, ins);
+	},
+	ignorableWhitespace:function(ch, start, length) {
+	},
+	characters:function(chars, start, length) {
+		chars = _toString.apply(this,arguments);
+		//console.log(chars)
+		if(chars){
+			if (this.cdata) {
+				var charNode = this.doc.createCDATASection(chars);
+			} else {
+				var charNode = this.doc.createTextNode(chars);
+			}
+			if(this.currentElement){
+				this.currentElement.appendChild(charNode);
+			}else if(/^\s*$/.test(chars)){
+				this.doc.appendChild(charNode);
+				//process xml
+			}
+			this.locator && position(this.locator,charNode);
+		}
+	},
+	skippedEntity:function(name) {
+	},
+	endDocument:function() {
+		this.doc.normalize();
+	},
+	setDocumentLocator:function (locator) {
+	    if(this.locator = locator){// && !('lineNumber' in locator)){
+	    	locator.lineNumber = 0;
+	    }
+	},
+	//LexicalHandler
+	comment:function(chars, start, length) {
+		chars = _toString.apply(this,arguments);
+	    var comm = this.doc.createComment(chars);
+	    this.locator && position(this.locator,comm);
+	    appendElement(this, comm);
+	},
+
+	startCDATA:function() {
+	    //used in characters() methods
+	    this.cdata = true;
+	},
+	endCDATA:function() {
+	    this.cdata = false;
+	},
+
+	startDTD:function(name, publicId, systemId) {
+		var impl = this.doc.implementation;
+	    if (impl && impl.createDocumentType) {
+	        var dt = impl.createDocumentType(name, publicId, systemId);
+	        this.locator && position(this.locator,dt);
+	        appendElement(this, dt);
+	    }
+	},
+	/**
+	 * @see org.xml.sax.ErrorHandler
+	 * @link http://www.saxproject.org/apidoc/org/xml/sax/ErrorHandler.html
+	 */
+	warning:function(error) {
+		console.warn('[xmldom warning]\t'+error,_locator(this.locator));
+	},
+	error:function(error) {
+		console.error('[xmldom error]\t'+error,_locator(this.locator));
+	},
+	fatalError:function(error) {
+		throw new ParseError(error, this.locator);
+	}
+};
+function _locator(l){
+	if(l){
+		return '\n@'+(l.systemId ||'')+'#[line:'+l.lineNumber+',col:'+l.columnNumber+']'
+	}
+}
+function _toString(chars,start,length){
+	if(typeof chars == 'string'){
+		return chars.substr(start,length)
+	}else {//java sax connect width xmldom on rhino(what about: "? && !(chars instanceof String)")
+		if(chars.length >= start+length || start){
+			return new java.lang.String(chars,start,length)+'';
+		}
+		return chars;
+	}
 }
 
-const DEFAULT_START_OPTIONS = {
-    serviceWorker: {
-        url: '/mockServiceWorker.js',
-        options: null,
-    },
-    quiet: false,
-    waitUntilReady: true,
-    onUnhandledRequest: 'bypass',
-    findWorker: (scriptURL, mockServiceWorkerUrl) => scriptURL === mockServiceWorkerUrl,
-};
-const createStart = (context) => {
-    /**
-     * Registers and activates the mock Service Worker.
-     */
-    return function start(options) {
-        const resolvedOptions = mergeRight(DEFAULT_START_OPTIONS, options || {});
-        // Store the start options in the context so that other methods (like `stop`)
-        // could reference them.
-        context.startOptions = resolvedOptions;
-        const startWorkerInstance = () => __awaiter(this, void 0, void 0, function* () {
-            if (!('serviceWorker' in navigator)) {
-                throw new Error(`[MSW] Failed to register a Service Worker: this browser does not support Service Workers (see https://caniuse.com/serviceworkers), or your application is running on an insecure host (consider using HTTPS for custom hostnames).`);
-            }
-            // Remove all previously existing event listeners.
-            // This way none of the listeners persists between Fast refresh
-            // of the application's code.
-            context.events.removeAllListeners();
-            // Handle requests signaled by the worker.
-            context.workerChannel.on('REQUEST', createRequestListener(context, resolvedOptions));
-            context.workerChannel.on('RESPONSE', createResponseListener(context));
-            const instance = yield getWorkerInstance(resolvedOptions.serviceWorker.url, resolvedOptions.serviceWorker.options, resolvedOptions.findWorker);
-            const [worker, registration] = instance;
-            if (!worker) {
-                const missingWorkerMessage = (options === null || options === void 0 ? void 0 : options.findWorker)
-                    ? `[MSW] Failed to locate the Service Worker registration using a custom "findWorker" predicate.
+/*
+ * @link http://www.saxproject.org/apidoc/org/xml/sax/ext/LexicalHandler.html
+ * used method of org.xml.sax.ext.LexicalHandler:
+ *  #comment(chars, start, length)
+ *  #startCDATA()
+ *  #endCDATA()
+ *  #startDTD(name, publicId, systemId)
+ *
+ *
+ * IGNORED method of org.xml.sax.ext.LexicalHandler:
+ *  #endDTD()
+ *  #startEntity(name)
+ *  #endEntity(name)
+ *
+ *
+ * @link http://www.saxproject.org/apidoc/org/xml/sax/ext/DeclHandler.html
+ * IGNORED method of org.xml.sax.ext.DeclHandler
+ * 	#attributeDecl(eName, aName, type, mode, value)
+ *  #elementDecl(name, model)
+ *  #externalEntityDecl(name, publicId, systemId)
+ *  #internalEntityDecl(name, value)
+ * @link http://www.saxproject.org/apidoc/org/xml/sax/ext/EntityResolver2.html
+ * IGNORED method of org.xml.sax.EntityResolver2
+ *  #resolveEntity(String name,String publicId,String baseURI,String systemId)
+ *  #resolveEntity(publicId, systemId)
+ *  #getExternalSubset(name, baseURI)
+ * @link http://www.saxproject.org/apidoc/org/xml/sax/DTDHandler.html
+ * IGNORED method of org.xml.sax.DTDHandler
+ *  #notationDecl(name, publicId, systemId) {};
+ *  #unparsedEntityDecl(name, publicId, systemId, notationName) {};
+ */
+"endDTD,startEntity,endEntity,attributeDecl,elementDecl,externalEntityDecl,internalEntityDecl,resolveEntity,getExternalSubset,notationDecl,unparsedEntityDecl".replace(/\w+/g,function(key){
+	DOMHandler.prototype[key] = function(){return null};
+});
 
-Please ensure that the custom predicate properly locates the Service Worker registration at "${resolvedOptions.serviceWorker.url}".
-More details: https://mswjs.io/docs/api/setup-worker/start#findworker
-`
-                    : `[MSW] Failed to locate the Service Worker registration.
+/* Private static helpers treated below as private instance methods, so don't need to add these to the public API; we might use a Relator to also get rid of non-standard public properties */
+function appendElement (hander,node) {
+    if (!hander.currentElement) {
+        hander.doc.appendChild(node);
+    } else {
+        hander.currentElement.appendChild(node);
+    }
+}//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;
+var DOMImplementation = domParser.DOMImplementation = dom.DOMImplementation;
+domParser.XMLSerializer = dom.XMLSerializer ;
+domParser.DOMParser = DOMParser;
+domParser.__DOMHandler = DOMHandler;
+
+var parseJson$1 = {};
+
+Object.defineProperty(parseJson$1, "__esModule", { value: true });
+parseJson$1.parseJson = void 0;
+/**
+ * Parses a given string into JSON.
+ * Gracefully handles invalid JSON by returning `null`.
+ */
+function parseJson(data) {
+    try {
+        var json = JSON.parse(data);
+        return json;
+    }
+    catch (_) {
+        return null;
+    }
+}
+parseJson$1.parseJson = parseJson;
 
-This most likely means that the worker script URL "${resolvedOptions.serviceWorker.url}" cannot resolve against the actual public hostname (${location.host}). This may happen if your application runs behind a proxy, or has a dynamic hostname.
+var bufferFrom$1 = {};
 
-Please consider using a custom "serviceWorker.url" option to point to the actual worker script location, or a custom "findWorker" option to resolve the Service Worker registration manually. More details: https://mswjs.io/docs/api/setup-worker/start`;
-                throw new Error(missingWorkerMessage);
-            }
-            context.worker = worker;
-            context.registration = registration;
-            context.events.addListener(window, 'beforeunload', () => {
-                if (worker.state !== 'redundant') {
-                    // Notify the Service Worker that this client has closed.
-                    // Internally, it's similar to disabling the mocking, only
-                    // client close event has a handler that self-terminates
-                    // the Service Worker when there are no open clients.
-                    context.workerChannel.send('CLIENT_CLOSED');
-                }
-                // Make sure we're always clearing the interval - there are reports that not doing this can
-                // cause memory leaks in headless browser environments.
-                window.clearInterval(context.keepAliveInterval);
-            });
-            // Check if the active Service Worker is the latest published one
-            const [integrityError] = yield until$1(() => requestIntegrityCheck(context, worker));
-            if (integrityError) {
-                console.error(`\
-[MSW] Detected outdated Service Worker: ${integrityError.message}
+Object.defineProperty(bufferFrom$1, "__esModule", { value: true });
+bufferFrom$1.bufferFrom = void 0;
+/**
+ * Convert a given string into a `Uint8Array`.
+ * We don't use `TextEncoder` because it's unavailable in some environments.
+ */
+function bufferFrom(init) {
+    var encodedString = encodeURIComponent(init);
+    var binaryString = encodedString.replace(/%([0-9A-F]{2})/g, function (_, char) {
+        return String.fromCharCode(('0x' + char));
+    });
+    var buffer = new Uint8Array(binaryString.length);
+    Array.prototype.forEach.call(binaryString, function (char, index) {
+        buffer[index] = char.charCodeAt(0);
+    });
+    return buffer;
+}
+bufferFrom$1.bufferFrom = bufferFrom;
+
+var createEvent$1 = {};
+
+var EventPolyfill$1 = {};
+
+Object.defineProperty(EventPolyfill$1, "__esModule", { value: true });
+EventPolyfill$1.EventPolyfill = void 0;
+var EventPolyfill = /** @class */ (function () {
+    function EventPolyfill(type, options) {
+        this.AT_TARGET = 0;
+        this.BUBBLING_PHASE = 0;
+        this.CAPTURING_PHASE = 0;
+        this.NONE = 0;
+        this.type = '';
+        this.srcElement = null;
+        this.currentTarget = null;
+        this.eventPhase = 0;
+        this.isTrusted = true;
+        this.composed = false;
+        this.cancelable = true;
+        this.defaultPrevented = false;
+        this.bubbles = true;
+        this.lengthComputable = true;
+        this.loaded = 0;
+        this.total = 0;
+        this.cancelBubble = false;
+        this.returnValue = true;
+        this.type = type;
+        this.target = (options === null || options === void 0 ? void 0 : options.target) || null;
+        this.currentTarget = (options === null || options === void 0 ? void 0 : options.currentTarget) || null;
+        this.timeStamp = Date.now();
+    }
+    EventPolyfill.prototype.composedPath = function () {
+        return [];
+    };
+    EventPolyfill.prototype.initEvent = function (type, bubbles, cancelable) {
+        this.type = type;
+        this.bubbles = !!bubbles;
+        this.cancelable = !!cancelable;
+    };
+    EventPolyfill.prototype.preventDefault = function () {
+        this.defaultPrevented = true;
+    };
+    EventPolyfill.prototype.stopPropagation = function () { };
+    EventPolyfill.prototype.stopImmediatePropagation = function () { };
+    return EventPolyfill;
+}());
+EventPolyfill$1.EventPolyfill = EventPolyfill;
 
-The mocking is still enabled, but it's highly recommended that you update your Service Worker by running:
+var ProgressEventPolyfill$1 = {};
 
-$ npx msw init <PUBLIC_DIR>
+var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(ProgressEventPolyfill$1, "__esModule", { value: true });
+ProgressEventPolyfill$1.ProgressEventPolyfill = void 0;
+var EventPolyfill_1$1 = EventPolyfill$1;
+var ProgressEventPolyfill = /** @class */ (function (_super) {
+    __extends(ProgressEventPolyfill, _super);
+    function ProgressEventPolyfill(type, init) {
+        var _this = _super.call(this, type) || this;
+        _this.lengthComputable = (init === null || init === void 0 ? void 0 : init.lengthComputable) || false;
+        _this.composed = (init === null || init === void 0 ? void 0 : init.composed) || false;
+        _this.loaded = (init === null || init === void 0 ? void 0 : init.loaded) || 0;
+        _this.total = (init === null || init === void 0 ? void 0 : init.total) || 0;
+        return _this;
+    }
+    return ProgressEventPolyfill;
+}(EventPolyfill_1$1.EventPolyfill));
+ProgressEventPolyfill$1.ProgressEventPolyfill = ProgressEventPolyfill;
+
+Object.defineProperty(createEvent$1, "__esModule", { value: true });
+createEvent$1.createEvent = void 0;
+var EventPolyfill_1 = EventPolyfill$1;
+var ProgressEventPolyfill_1 = ProgressEventPolyfill$1;
+var SUPPORTS_PROGRESS_EVENT = typeof ProgressEvent !== 'undefined';
+function createEvent(target, type, init) {
+    var progressEvents = [
+        'error',
+        'progress',
+        'loadstart',
+        'loadend',
+        'load',
+        'timeout',
+        'abort',
+    ];
+    /**
+     * `ProgressEvent` is not supported in React Native.
+     * @see https://github.com/mswjs/interceptors/issues/40
+     */
+    var ProgressEventClass = SUPPORTS_PROGRESS_EVENT
+        ? ProgressEvent
+        : ProgressEventPolyfill_1.ProgressEventPolyfill;
+    var event = progressEvents.includes(type)
+        ? new ProgressEventClass(type, {
+            lengthComputable: true,
+            loaded: (init === null || init === void 0 ? void 0 : init.loaded) || 0,
+            total: (init === null || init === void 0 ? void 0 : init.total) || 0,
+        })
+        : new EventPolyfill_1.EventPolyfill(type, {
+            target: target,
+            currentTarget: target,
+        });
+    return event;
+}
+createEvent$1.createEvent = createEvent;
+
+var __awaiter = (commonjsGlobal && commonjsGlobal.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (commonjsGlobal && commonjsGlobal.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __values = (commonjsGlobal && commonjsGlobal.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (commonjsGlobal && commonjsGlobal.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+Object.defineProperty(XMLHttpRequestOverride, "__esModule", { value: true });
+XMLHttpRequestOverride.createXMLHttpRequestOverride = void 0;
+/**
+ * XMLHttpRequest override class.
+ * Inspired by https://github.com/marvinhagemeister/xhr-mocklet.
+ */
+var until_1 = lib$2;
+var headers_utils_1 = lib$4;
+var xmldom_1 = domParser;
+var parseJson_1 = parseJson$1;
+var bufferFrom_1 = bufferFrom$1;
+var createEvent_1 = createEvent$1;
+var createDebug = require$$1;
+var createXMLHttpRequestOverride = function (options) {
+    var _a;
+    var pureXMLHttpRequest = options.pureXMLHttpRequest, observer = options.observer, resolver = options.resolver;
+    var debug = createDebug('XHR');
+    return _a = /** @class */ (function () {
+            function XMLHttpRequestOverride() {
+                // Collection of events modified by `addEventListener`/`removeEventListener` calls.
+                this._events = [];
+                this.UNSENT = 0;
+                this.OPENED = 1;
+                this.HEADERS_RECEIVED = 2;
+                this.LOADING = 3;
+                this.DONE = 4;
+                this.onreadystatechange = null;
+                /* Events */
+                this.onabort = null;
+                this.onerror = null;
+                this.onload = null;
+                this.onloadend = null;
+                this.onloadstart = null;
+                this.onprogress = null;
+                this.ontimeout = null;
+                this.url = '';
+                this.method = 'GET';
+                this.readyState = this.UNSENT;
+                this.withCredentials = false;
+                this.status = 200;
+                this.statusText = 'OK';
+                this.data = '';
+                this.response = '';
+                this.responseType = 'text';
+                this.responseText = '';
+                this.responseXML = null;
+                this.responseURL = '';
+                this.upload = null;
+                this.timeout = 0;
+                this._requestHeaders = new headers_utils_1.Headers();
+                this._responseHeaders = new headers_utils_1.Headers();
+            }
+            XMLHttpRequestOverride.prototype.setReadyState = function (nextState) {
+                if (nextState === this.readyState) {
+                    return;
+                }
+                debug('readyState change %d -> %d', this.readyState, nextState);
+                this.readyState = nextState;
+                if (nextState !== this.UNSENT) {
+                    debug('triggerring readystate change...');
+                    this.trigger('readystatechange');
+                }
+            };
+            /**
+             * Triggers both direct callback and attached event listeners
+             * for the given event.
+             */
+            XMLHttpRequestOverride.prototype.trigger = function (eventName, options) {
+                var e_1, _a;
+                debug('trigger "%s" (%d)', eventName, this.readyState);
+                debug('resolve listener for event "%s"', eventName);
+                // @ts-expect-error XMLHttpRequest class has no index signature.
+                var callback = this["on" + eventName];
+                callback === null || callback === void 0 ? void 0 : callback.call(this, createEvent_1.createEvent(this, eventName, options));
+                try {
+                    for (var _b = __values(this._events), _c = _b.next(); !_c.done; _c = _b.next()) {
+                        var event_1 = _c.value;
+                        if (event_1.name === eventName) {
+                            debug('calling mock event listener "%s" (%d)', eventName, this.readyState);
+                            event_1.listener.call(this, createEvent_1.createEvent(this, eventName, options));
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                return this;
+            };
+            XMLHttpRequestOverride.prototype.reset = function () {
+                debug('reset');
+                this.setReadyState(this.UNSENT);
+                this.status = 200;
+                this.statusText = 'OK';
+                this.data = '';
+                this.response = null;
+                this.responseText = null;
+                this.responseXML = null;
+                this._requestHeaders = new headers_utils_1.Headers();
+                this._responseHeaders = new headers_utils_1.Headers();
+            };
+            XMLHttpRequestOverride.prototype.open = function (method, url, async, user, password) {
+                if (async === void 0) { async = true; }
+                return __awaiter(this, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        debug = createDebug("XHR " + method + " " + url);
+                        debug('open', { method: method, url: url, async: async, user: user, password: password });
+                        this.reset();
+                        this.setReadyState(this.OPENED);
+                        if (typeof url === 'undefined') {
+                            this.url = method;
+                            this.method = 'GET';
+                        }
+                        else {
+                            this.url = url;
+                            this.method = method;
+                            this.async = async;
+                            this.user = user;
+                            this.password = password;
+                        }
+                        return [2 /*return*/];
+                    });
+                });
+            };
+            XMLHttpRequestOverride.prototype.send = function (data) {
+                var _this = this;
+                debug('send %s %s', this.method, this.url);
+                this.data = data || '';
+                var url;
+                try {
+                    url = new URL(this.url);
+                }
+                catch (error) {
+                    // Assume a relative URL, if construction of a new `URL` instance fails.
+                    // Since `XMLHttpRequest` always executed in a DOM-like environment,
+                    // resolve the relative request URL against the current window location.
+                    url = new URL(this.url, window.location.href);
+                }
+                debug('request headers', this._requestHeaders);
+                // Create an intercepted request instance exposed to the request intercepting middleware.
+                var isoRequest = {
+                    url: url,
+                    method: this.method,
+                    body: this.data,
+                    headers: this._requestHeaders,
+                };
+                observer.emit('request', isoRequest);
+                debug('awaiting mocked response...');
+                Promise.resolve(until_1.until(function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+                    return [2 /*return*/, resolver(isoRequest, this)];
+                }); }); })).then(function (_a) {
+                    var _b;
+                    var _c = __read(_a, 2), middlewareException = _c[0], mockedResponse = _c[1];
+                    // When the request middleware throws an exception, error the request.
+                    // This cancels the request and is similar to a network error.
+                    if (middlewareException) {
+                        debug('middleware function threw an exception!', middlewareException);
+                        // No way to propagate the actual error message.
+                        _this.trigger('error');
+                        _this.abort();
+                        return;
+                    }
+                    // Return a mocked response, if provided in the middleware.
+                    if (mockedResponse) {
+                        debug('received mocked response', mockedResponse);
+                        // Trigger a loadstart event to indicate the initialization of the fetch.
+                        _this.trigger('loadstart');
+                        _this.status = mockedResponse.status || 200;
+                        _this.statusText = mockedResponse.statusText || 'OK';
+                        _this._responseHeaders = mockedResponse.headers
+                            ? headers_utils_1.objectToHeaders(mockedResponse.headers)
+                            : new headers_utils_1.Headers();
+                        debug('set response status', _this.status, _this.statusText);
+                        debug('set response headers', _this._responseHeaders);
+                        // Mark that response headers has been received
+                        // and trigger a ready state event to reflect received headers
+                        // in a custom `onreadystatechange` callback.
+                        _this.setReadyState(_this.HEADERS_RECEIVED);
+                        debug('response type', _this.responseType);
+                        _this.response = _this.getResponseBody(mockedResponse.body);
+                        _this.responseText = mockedResponse.body || '';
+                        _this.responseXML = _this.getResponseXML();
+                        debug('set response body', _this.response);
+                        if (mockedResponse.body && _this.response) {
+                            _this.setReadyState(_this.LOADING);
+                            // Presense of the mocked response implies a response body (not null).
+                            // Presense of the coerced `this.response` implies the mocked body is valid.
+                            var bodyBuffer = bufferFrom_1.bufferFrom(mockedResponse.body);
+                            // Trigger a progress event based on the mocked response body.
+                            _this.trigger('progress', {
+                                loaded: bodyBuffer.length,
+                                total: bodyBuffer.length,
+                            });
+                        }
+                        /**
+                         * Explicitly mark the request as done so its response never hangs.
+                         * @see https://github.com/mswjs/interceptors/issues/13
+                         */
+                        _this.setReadyState(_this.DONE);
+                        // Trigger a load event to indicate the fetch has succeeded.
+                        _this.trigger('load');
+                        // Trigger a loadend event to indicate the fetch has completed.
+                        _this.trigger('loadend');
+                        observer.emit('response', isoRequest, {
+                            status: _this.status,
+                            statusText: _this.statusText,
+                            headers: headers_utils_1.objectToHeaders(mockedResponse.headers || {}),
+                            body: mockedResponse.body,
+                        });
+                    }
+                    else {
+                        debug('no mocked response received!');
+                        // Perform an original request, when the request middleware returned no mocked response.
+                        var originalRequest_1 = new pureXMLHttpRequest();
+                        debug('opening an original request %s %s', _this.method, _this.url);
+                        originalRequest_1.open(_this.method, _this.url, (_b = _this.async) !== null && _b !== void 0 ? _b : true, _this.user, _this.password);
+                        // Reflect a successful state of the original request
+                        // on the patched instance.
+                        originalRequest_1.addEventListener('load', function () {
+                            debug('original "onload"');
+                            _this.status = originalRequest_1.status;
+                            _this.statusText = originalRequest_1.statusText;
+                            _this.responseURL = originalRequest_1.responseURL;
+                            _this.responseType = originalRequest_1.responseType;
+                            _this.response = originalRequest_1.response;
+                            _this.responseText = originalRequest_1.responseText;
+                            _this.responseXML = originalRequest_1.responseXML;
+                            debug('set mock request readyState to DONE');
+                            // Explicitly mark the mocked request instance as done
+                            // so the response never hangs.
+                            /**
+                             * @note `readystatechange` listener is called TWICE
+                             * in the case of unhandled request.
+                             */
+                            _this.setReadyState(_this.DONE);
+                            debug('received original response', _this.status, _this.statusText);
+                            debug('original response body:', _this.response);
+                            var responseHeaders = originalRequest_1.getAllResponseHeaders();
+                            debug('original response headers', responseHeaders);
+                            _this._responseHeaders = headers_utils_1.stringToHeaders(responseHeaders);
+                            debug('original response headers (normalized)', _this._responseHeaders);
+                            debug('original response finished');
+                            observer.emit('response', isoRequest, {
+                                status: originalRequest_1.status,
+                                statusText: originalRequest_1.statusText,
+                                headers: _this._responseHeaders,
+                                body: originalRequest_1.response,
+                            });
+                        });
+                        // Assign callbacks and event listeners from the intercepted XHR instance
+                        // to the original XHR instance.
+                        _this.propagateCallbacks(originalRequest_1);
+                        _this.propagateListeners(originalRequest_1);
+                        _this.propagateHeaders(originalRequest_1, _this._requestHeaders);
+                        if (_this.async) {
+                            originalRequest_1.timeout = _this.timeout;
+                        }
+                        debug('send', _this.data);
+                        originalRequest_1.send(_this.data);
+                    }
+                });
+            };
+            XMLHttpRequestOverride.prototype.abort = function () {
+                debug('abort');
+                if (this.readyState > this.UNSENT && this.readyState < this.DONE) {
+                    this.setReadyState(this.UNSENT);
+                    this.trigger('abort');
+                }
+            };
+            XMLHttpRequestOverride.prototype.dispatchEvent = function () {
+                return false;
+            };
+            XMLHttpRequestOverride.prototype.setRequestHeader = function (name, value) {
+                debug('set request header "%s" to "%s"', name, value);
+                this._requestHeaders.append(name, value);
+            };
+            XMLHttpRequestOverride.prototype.getResponseHeader = function (name) {
+                debug('get response header "%s"', name);
+                if (this.readyState < this.HEADERS_RECEIVED) {
+                    debug('cannot return a header: headers not received (state: %s)', this.readyState);
+                    return null;
+                }
+                var headerValue = this._responseHeaders.get(name);
+                debug('resolved response header "%s" to "%s"', name, headerValue, this._responseHeaders);
+                return headerValue;
+            };
+            XMLHttpRequestOverride.prototype.getAllResponseHeaders = function () {
+                debug('get all response headers');
+                if (this.readyState < this.HEADERS_RECEIVED) {
+                    debug('cannot return headers: headers not received (state: %s)', this.readyState);
+                    return '';
+                }
+                return headers_utils_1.headersToString(this._responseHeaders);
+            };
+            XMLHttpRequestOverride.prototype.addEventListener = function (name, listener) {
+                debug('addEventListener', name, listener);
+                this._events.push({
+                    name: name,
+                    listener: listener,
+                });
+            };
+            XMLHttpRequestOverride.prototype.removeEventListener = function (name, listener) {
+                debug('removeEventListener', name, listener);
+                this._events = this._events.filter(function (storedEvent) {
+                    return storedEvent.name !== name && storedEvent.listener !== listener;
+                });
+            };
+            XMLHttpRequestOverride.prototype.overrideMimeType = function () { };
+            /**
+             * Resolves the response based on the `responseType` value.
+             */
+            XMLHttpRequestOverride.prototype.getResponseBody = function (body) {
+                // Handle an improperly set "null" value of the mocked response body.
+                var textBody = body !== null && body !== void 0 ? body : '';
+                debug('coerced response body to', textBody);
+                switch (this.responseType) {
+                    case 'json': {
+                        debug('resolving response body as JSON');
+                        return parseJson_1.parseJson(textBody);
+                    }
+                    case 'blob': {
+                        var blobType = this.getResponseHeader('content-type') || 'text/plain';
+                        debug('resolving response body as Blob', { type: blobType });
+                        return new Blob([textBody], {
+                            type: blobType,
+                        });
+                    }
+                    case 'arraybuffer': {
+                        debug('resolving response body as ArrayBuffer');
+                        var arrayBuffer = bufferFrom_1.bufferFrom(textBody);
+                        return arrayBuffer;
+                    }
+                    default:
+                        return textBody;
+                }
+            };
+            XMLHttpRequestOverride.prototype.getResponseXML = function () {
+                var contentType = this.getResponseHeader('Content-Type');
+                if (contentType === 'application/xml' || contentType === 'text/xml') {
+                    return new xmldom_1.DOMParser().parseFromString(this.responseText, contentType);
+                }
+                return null;
+            };
+            /**
+             * Propagates mock XMLHttpRequest instance callbacks
+             * to the given XMLHttpRequest instance.
+             */
+            XMLHttpRequestOverride.prototype.propagateCallbacks = function (request) {
+                request.onabort = this.abort;
+                request.onerror = this.onerror;
+                request.ontimeout = this.ontimeout;
+                request.onload = this.onload;
+                request.onloadstart = this.onloadstart;
+                request.onloadend = this.onloadend;
+                request.onprogress = this.onprogress;
+                request.onreadystatechange = this.onreadystatechange;
+            };
+            /**
+             * Propagates the mock XMLHttpRequest instance listeners
+             * to the given XMLHttpRequest instance.
+             */
+            XMLHttpRequestOverride.prototype.propagateListeners = function (request) {
+                debug('propagating request listeners (%d) to the original request', this._events.length, this._events);
+                this._events.forEach(function (_a) {
+                    var name = _a.name, listener = _a.listener;
+                    request.addEventListener(name, listener);
+                });
+            };
+            XMLHttpRequestOverride.prototype.propagateHeaders = function (request, headers) {
+                debug('propagating request headers to the original request', headers);
+                // Preserve the request headers casing.
+                Object.entries(headers.raw()).forEach(function (_a) {
+                    var _b = __read(_a, 2), name = _b[0], value = _b[1];
+                    debug('setting "%s" (%s) header on the original request', name, value);
+                    request.setRequestHeader(name, value);
+                });
+            };
+            return XMLHttpRequestOverride;
+        }()),
+        /* Request state */
+        _a.UNSENT = 0,
+        _a.OPENED = 1,
+        _a.HEADERS_RECEIVED = 2,
+        _a.LOADING = 3,
+        _a.DONE = 4,
+        _a;
+};
+XMLHttpRequestOverride.createXMLHttpRequestOverride = createXMLHttpRequestOverride;
+
+Object.defineProperty(XMLHttpRequest, "__esModule", { value: true });
+var interceptXMLHttpRequest_1 = XMLHttpRequest.interceptXMLHttpRequest = void 0;
+var XMLHttpRequestOverride_1 = XMLHttpRequestOverride;
+var debug = require$$1('XHR');
+var pureXMLHttpRequest = 
+// Although executed in node, certain processes emulate the DOM-like environment
+// (i.e. `js-dom` in Jest). The `window` object would be avilable in such environments.
+typeof window === 'undefined' ? undefined : window.XMLHttpRequest;
+/**
+ * Intercepts requests issued via `XMLHttpRequest`.
+ */
+var interceptXMLHttpRequest = function (observer, resolver) {
+    if (pureXMLHttpRequest) {
+        debug('patching "XMLHttpRequest" module...');
+        var XMLHttpRequestOverride = XMLHttpRequestOverride_1.createXMLHttpRequestOverride({
+            pureXMLHttpRequest: pureXMLHttpRequest,
+            observer: observer,
+            resolver: resolver,
+        });
+        window.XMLHttpRequest = XMLHttpRequestOverride;
+    }
+    return function () {
+        if (pureXMLHttpRequest) {
+            debug('restoring modules...');
+            window.XMLHttpRequest = pureXMLHttpRequest;
+        }
+    };
+};
+interceptXMLHttpRequest_1 = XMLHttpRequest.interceptXMLHttpRequest = interceptXMLHttpRequest;
 
-This is necessary to ensure that the Service Worker is in sync with the library to guarantee its stability.
-If this message still persists after updating, please report an issue: https://github.com/open-draft/msw/issues\
-      `);
-            }
-            // Signal the Service Worker to enable requests interception
-            yield activateMocking(context, options).catch((err) => {
-                throw new Error(`Failed to enable mocking: ${err === null || err === void 0 ? void 0 : err.message}`);
+function uuidv4() {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+        const r = (Math.random() * 16) | 0;
+        const v = c == 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}
+
+/**
+ * Converts a given isomorphic request to a `MockedRequest` instance.
+ */
+function parseIsomorphicRequest(request) {
+    const requestId = uuidv4();
+    request.headers.set('x-msw-request-id', requestId);
+    const mockedRequest = {
+        id: requestId,
+        url: request.url,
+        method: request.method,
+        body: parseBody(request.body, request.headers),
+        headers: request.headers,
+        cookies: {},
+        redirect: 'manual',
+        referrer: '',
+        keepalive: false,
+        cache: 'default',
+        mode: 'cors',
+        referrerPolicy: 'no-referrer',
+        integrity: '',
+        destination: 'document',
+        bodyUsed: false,
+        credentials: 'same-origin',
+    };
+    // Set mocked request cookies from the `cookie` header of the original request.
+    // No need to take `credentials` into account, because in Node.js requests are intercepted
+    // _after_ they happen. Request issuer should have already taken care of sending relevant cookies.
+    // Unlike browser, where interception is on the worker level, _before_ the request happens.
+    const requestCookiesString = request.headers.get('cookie');
+    // Attach all the cookies from the virtual cookie store.
+    setRequestCookies(mockedRequest);
+    const requestCookies = requestCookiesString
+        ? parse_1(requestCookiesString)
+        : {};
+    // Merge both direct request cookies and the cookies inherited
+    // from other same-origin requests in the cookie store.
+    mockedRequest.cookies = Object.assign(Object.assign({}, mockedRequest.cookies), requestCookies);
+    return mockedRequest;
+}
+
+function createFallbackRequestListener(context, options) {
+    const interceptor = lib.createInterceptor({
+        modules: [interceptFetch_1, interceptXMLHttpRequest_1],
+        resolver(request) {
+            return __awaiter$2(this, void 0, void 0, function* () {
+                const mockedRequest = parseIsomorphicRequest(request);
+                return handleRequest(mockedRequest, context.requestHandlers, options, context.emitter, {
+                    transformResponse(response) {
+                        return {
+                            status: response.status,
+                            statusText: response.statusText,
+                            headers: response.headers.all(),
+                            body: response.body,
+                        };
+                    },
+                    onMockedResponseSent(response, { handler, publicRequest, parsedRequest }) {
+                        if (!options.quiet) {
+                            handler.log(publicRequest, response, handler, parsedRequest);
+                        }
+                    },
+                });
             });
-            context.keepAliveInterval = window.setInterval(() => context.workerChannel.send('KEEPALIVE_REQUEST'), 5000);
-            return registration;
+        },
+    });
+    interceptor.apply();
+    return interceptor;
+}
+
+function createFallbackStart(context) {
+    return function start(options) {
+        return __awaiter$2(this, void 0, void 0, function* () {
+            context.fallbackInterceptor = createFallbackRequestListener(context, options);
+            printStartMessage({
+                message: 'Mocking enabled (fallback mode).',
+                quiet: options.quiet,
+            });
+            return undefined;
         });
-        const workerRegistration = startWorkerInstance();
-        // Defer any network requests until the Service Worker instance is ready.
-        // This prevents a race condition between the Service Worker registration
-        // and application's runtime requests (i.e. requests on mount).
-        if (resolvedOptions.waitUntilReady) {
-            deferNetworkRequestsUntil(workerRegistration);
-        }
-        return workerRegistration;
     };
-};
+}
 
-const createStop = (context) => {
-    /**
-     * Signal the Service Worker to disable mocking for this client.
-     * Use this an an explicit way to stop the mocking, while preserving
-     * the worker-client relation. Does not affect the worker's lifecycle.
-     */
+function createFallbackStop(context) {
     return function stop() {
-        var _a;
-        context.workerChannel.send('MOCK_DEACTIVATE');
-        context.events.removeAllListeners();
-        context.emitter.removeAllListeners();
-        window.clearInterval(context.keepAliveInterval);
-        if (!((_a = context.startOptions) === null || _a === void 0 ? void 0 : _a.quiet)) {
-            console.log('%c[MSW] Mocking disabled.', 'color:orangered;font-weight:bold;');
-        }
+        var _a, _b;
+        (_a = context.fallbackInterceptor) === null || _a === void 0 ? void 0 : _a.restore();
+        printStopMessage({ quiet: (_b = context.startOptions) === null || _b === void 0 ? void 0 : _b.quiet });
     };
-};
-
-function use(currentHandlers, ...handlers) {
-    currentHandlers.unshift(...handlers);
-}
-function restoreHandlers(handlers) {
-    handlers.forEach((handler) => {
-        handler.markAsSkipped(false);
-    });
-}
-function resetHandlers(initialHandlers, ...nextHandlers) {
-    return nextHandlers.length > 0 ? [...nextHandlers] : [...initialHandlers];
 }
 
 // Declare the list of event handlers on the module's scope
@@ -1680,12 +5108,16 @@ function setupWorker(...requestHandlers) {
         if (Array.isArray(handler))
             throw new Error(`[MSW] Failed to call "setupWorker" given an Array of request handlers (setupWorker([a, b])), expected to receive each handler individually: setupWorker(a, b).`);
     });
+    // Error when attempting to run this function in a Node.js environment.
+    if (isNodeProcess()) {
+        throw new Error('[MSW] Failed to execute `setupWorker` in a non-browser environment. Consider using `setupServer` for Node.js environment instead.');
+    }
     const context = {
         startOptions: undefined,
         worker: null,
         registration: null,
         requestHandlers: [...requestHandlers],
-        emitter: new lib.StrictEventEmitter(),
+        emitter: new lib$3.StrictEventEmitter(),
         workerChannel: {
             on(eventType, callback) {
                 context.events.addListener(navigator.serviceWorker, 'message', (event) => {
@@ -1741,16 +5173,18 @@ function setupWorker(...requestHandlers) {
                 });
             },
         },
+        useFallbackMode: !('serviceWorker' in navigator) || location.protocol === 'file:',
     };
-    // Error when attempting to run this function in a Node.js environment.
-    if (isNodeProcess()) {
-        throw new Error('[MSW] Failed to execute `setupWorker` in a non-browser environment. Consider using `setupServer` for Node.js environment instead.');
-    }
+    const startHandler = context.useFallbackMode
+        ? createFallbackStart(context)
+        : createStartHandler(context);
+    const stopHandler = context.useFallbackMode
+        ? createFallbackStop(context)
+        : createStop(context);
     return {
-        start: createStart(context),
-        stop: createStop(context),
+        start: prepareStartHandler(startHandler, context),
+        stop: stopHandler,
         use(...handlers) {
-            console.log('adding new handlers', handlers);
             use(context.requestHandlers, ...handlers);
         },
         restoreHandlers() {