msw 0.30.0 → 0.30.1

package/lib/esm/index.js

@@ -1,5 +1,5 @@
 export { i as context } from './index-deps.js';
-import { c as commonjsGlobal, p as parse_1, l as lib$4, i as isNodeProcess, j as jsonParse } from './fetch-deps.js';
+import { c as commonjsGlobal, p as parse_1, l as lib$7, 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 { i as isStringEqual, R as RestHandler } from './rest-deps.js';
@@ -7,81 +7,81 @@ export { a as RESTMethods, R as RestHandler, r as rest, b as restContext } from
 import { t as tryCatch, p as parseGraphQLRequest, G as GraphQLHandler } from './graphql-deps.js';
 export { G as GraphQLHandler, g as graphql, a as graphqlContext } from './graphql-deps.js';
 import { m as mergeRight } from './errors-deps.js';
-import require$$1 from 'debug';
+import require$$2 from 'debug';
 import './xml-deps.js';
 
-var lib$3 = {};
+var lib$6 = {};
 
-var StrictEventEmitter$1 = {};
+var StrictEventEmitter$3 = {};
 
-var events = {exports: {}};
+var events$1 = {exports: {}};
 
-var R = typeof Reflect === 'object' ? Reflect : null;
-var ReflectApply = R && typeof R.apply === 'function'
-  ? R.apply
+var R$1 = typeof Reflect === 'object' ? Reflect : null;
+var ReflectApply$1 = R$1 && typeof R$1.apply === 'function'
+  ? R$1.apply
   : function ReflectApply(target, receiver, args) {
     return Function.prototype.apply.call(target, receiver, args);
   };
 
-var ReflectOwnKeys;
-if (R && typeof R.ownKeys === 'function') {
-  ReflectOwnKeys = R.ownKeys;
+var ReflectOwnKeys$1;
+if (R$1 && typeof R$1.ownKeys === 'function') {
+  ReflectOwnKeys$1 = R$1.ownKeys;
 } else if (Object.getOwnPropertySymbols) {
-  ReflectOwnKeys = function ReflectOwnKeys(target) {
+  ReflectOwnKeys$1 = function ReflectOwnKeys(target) {
     return Object.getOwnPropertyNames(target)
       .concat(Object.getOwnPropertySymbols(target));
   };
 } else {
-  ReflectOwnKeys = function ReflectOwnKeys(target) {
+  ReflectOwnKeys$1 = function ReflectOwnKeys(target) {
     return Object.getOwnPropertyNames(target);
   };
 }
 
-function ProcessEmitWarning(warning) {
+function ProcessEmitWarning$1(warning) {
   if (console && console.warn) console.warn(warning);
 }
 
-var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {
+var NumberIsNaN$1 = Number.isNaN || function NumberIsNaN(value) {
   return value !== value;
 };
 
-function EventEmitter() {
-  EventEmitter.init.call(this);
+function EventEmitter$1() {
+  EventEmitter$1.init.call(this);
 }
-events.exports = EventEmitter;
-events.exports.once = once;
+events$1.exports = EventEmitter$1;
+events$1.exports.once = once$1;
 
 // Backwards-compat with node 0.10.x
-EventEmitter.EventEmitter = EventEmitter;
+EventEmitter$1.EventEmitter = EventEmitter$1;
 
-EventEmitter.prototype._events = undefined;
-EventEmitter.prototype._eventsCount = 0;
-EventEmitter.prototype._maxListeners = undefined;
+EventEmitter$1.prototype._events = undefined;
+EventEmitter$1.prototype._eventsCount = 0;
+EventEmitter$1.prototype._maxListeners = undefined;
 
 // By default EventEmitters will print a warning if more than 10 listeners are
 // added to it. This is a useful default which helps finding memory leaks.
-var defaultMaxListeners = 10;
+var defaultMaxListeners$1 = 10;
 
-function checkListener(listener) {
+function checkListener$1(listener) {
   if (typeof listener !== 'function') {
     throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
   }
 }
 
-Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
+Object.defineProperty(EventEmitter$1, 'defaultMaxListeners', {
   enumerable: true,
   get: function() {
-    return defaultMaxListeners;
+    return defaultMaxListeners$1;
   },
   set: function(arg) {
-    if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {
+    if (typeof arg !== 'number' || arg < 0 || NumberIsNaN$1(arg)) {
       throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + '.');
     }
-    defaultMaxListeners = arg;
+    defaultMaxListeners$1 = arg;
   }
 });
 
-EventEmitter.init = function() {
+EventEmitter$1.init = function() {
 
   if (this._events === undefined ||
       this._events === Object.getPrototypeOf(this)._events) {
@@ -94,25 +94,25 @@ EventEmitter.init = function() {
 
 // Obviously not all Emitters should be limited to 10. This function allows
 // that to be increased. Set to zero for unlimited.
-EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
-  if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {
+EventEmitter$1.prototype.setMaxListeners = function setMaxListeners(n) {
+  if (typeof n !== 'number' || n < 0 || NumberIsNaN$1(n)) {
     throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + '.');
   }
   this._maxListeners = n;
   return this;
 };
 
-function _getMaxListeners(that) {
+function _getMaxListeners$1(that) {
   if (that._maxListeners === undefined)
-    return EventEmitter.defaultMaxListeners;
+    return EventEmitter$1.defaultMaxListeners;
   return that._maxListeners;
 }
 
-EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
-  return _getMaxListeners(this);
+EventEmitter$1.prototype.getMaxListeners = function getMaxListeners() {
+  return _getMaxListeners$1(this);
 };
 
-EventEmitter.prototype.emit = function emit(type) {
+EventEmitter$1.prototype.emit = function emit(type) {
   var args = [];
   for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
   var doError = (type === 'error');
@@ -145,23 +145,23 @@ EventEmitter.prototype.emit = function emit(type) {
     return false;
 
   if (typeof handler === 'function') {
-    ReflectApply(handler, this, args);
+    ReflectApply$1(handler, this, args);
   } else {
     var len = handler.length;
-    var listeners = arrayClone(handler, len);
+    var listeners = arrayClone$1(handler, len);
     for (var i = 0; i < len; ++i)
-      ReflectApply(listeners[i], this, args);
+      ReflectApply$1(listeners[i], this, args);
   }
 
   return true;
 };
 
-function _addListener(target, type, listener, prepend) {
+function _addListener$1(target, type, listener, prepend) {
   var m;
   var events;
   var existing;
 
-  checkListener(listener);
+  checkListener$1(listener);
 
   events = target._events;
   if (events === undefined) {
@@ -198,7 +198,7 @@ function _addListener(target, type, listener, prepend) {
     }
 
     // Check for listener leak
-    m = _getMaxListeners(target);
+    m = _getMaxListeners$1(target);
     if (m > 0 && existing.length > m && !existing.warned) {
       existing.warned = true;
       // No error code for this since it is a Warning
@@ -211,25 +211,25 @@ function _addListener(target, type, listener, prepend) {
       w.emitter = target;
       w.type = type;
       w.count = existing.length;
-      ProcessEmitWarning(w);
+      ProcessEmitWarning$1(w);
     }
   }
 
   return target;
 }
 
-EventEmitter.prototype.addListener = function addListener(type, listener) {
-  return _addListener(this, type, listener, false);
+EventEmitter$1.prototype.addListener = function addListener(type, listener) {
+  return _addListener$1(this, type, listener, false);
 };
 
-EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+EventEmitter$1.prototype.on = EventEmitter$1.prototype.addListener;
 
-EventEmitter.prototype.prependListener =
+EventEmitter$1.prototype.prependListener =
     function prependListener(type, listener) {
-      return _addListener(this, type, listener, true);
+      return _addListener$1(this, type, listener, true);
     };
 
-function onceWrapper() {
+function onceWrapper$1() {
   if (!this.fired) {
     this.target.removeListener(this.type, this.wrapFn);
     this.fired = true;
@@ -239,33 +239,33 @@ function onceWrapper() {
   }
 }
 
-function _onceWrap(target, type, listener) {
+function _onceWrap$1(target, type, listener) {
   var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };
-  var wrapped = onceWrapper.bind(state);
+  var wrapped = onceWrapper$1.bind(state);
   wrapped.listener = listener;
   state.wrapFn = wrapped;
   return wrapped;
 }
 
-EventEmitter.prototype.once = function once(type, listener) {
-  checkListener(listener);
-  this.on(type, _onceWrap(this, type, listener));
+EventEmitter$1.prototype.once = function once(type, listener) {
+  checkListener$1(listener);
+  this.on(type, _onceWrap$1(this, type, listener));
   return this;
 };
 
-EventEmitter.prototype.prependOnceListener =
+EventEmitter$1.prototype.prependOnceListener =
     function prependOnceListener(type, listener) {
-      checkListener(listener);
-      this.prependListener(type, _onceWrap(this, type, listener));
+      checkListener$1(listener);
+      this.prependListener(type, _onceWrap$1(this, type, listener));
       return this;
     };
 
 // Emits a 'removeListener' event if and only if the listener was removed.
-EventEmitter.prototype.removeListener =
+EventEmitter$1.prototype.removeListener =
     function removeListener(type, listener) {
       var list, events, position, i, originalListener;
 
-      checkListener(listener);
+      checkListener$1(listener);
 
       events = this._events;
       if (events === undefined)
@@ -300,7 +300,7 @@ EventEmitter.prototype.removeListener =
         if (position === 0)
           list.shift();
         else {
-          spliceOne(list, position);
+          spliceOne$1(list, position);
         }
 
         if (list.length === 1)
@@ -313,9 +313,9 @@ EventEmitter.prototype.removeListener =
       return this;
     };
 
-EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+EventEmitter$1.prototype.off = EventEmitter$1.prototype.removeListener;
 
-EventEmitter.prototype.removeAllListeners =
+EventEmitter$1.prototype.removeAllListeners =
     function removeAllListeners(type) {
       var listeners, events, i;
 
@@ -366,7 +366,7 @@ EventEmitter.prototype.removeAllListeners =
       return this;
     };
 
-function _listeners(target, type, unwrap) {
+function _listeners$1(target, type, unwrap) {
   var events = target._events;
 
   if (events === undefined)
@@ -380,27 +380,27 @@ function _listeners(target, type, unwrap) {
     return unwrap ? [evlistener.listener || evlistener] : [evlistener];
 
   return unwrap ?
-    unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
+    unwrapListeners$1(evlistener) : arrayClone$1(evlistener, evlistener.length);
 }
 
-EventEmitter.prototype.listeners = function listeners(type) {
-  return _listeners(this, type, true);
+EventEmitter$1.prototype.listeners = function listeners(type) {
+  return _listeners$1(this, type, true);
 };
 
-EventEmitter.prototype.rawListeners = function rawListeners(type) {
-  return _listeners(this, type, false);
+EventEmitter$1.prototype.rawListeners = function rawListeners(type) {
+  return _listeners$1(this, type, false);
 };
 
-EventEmitter.listenerCount = function(emitter, type) {
+EventEmitter$1.listenerCount = function(emitter, type) {
   if (typeof emitter.listenerCount === 'function') {
     return emitter.listenerCount(type);
   } else {
-    return listenerCount.call(emitter, type);
+    return listenerCount$1.call(emitter, type);
   }
 };
 
-EventEmitter.prototype.listenerCount = listenerCount;
-function listenerCount(type) {
+EventEmitter$1.prototype.listenerCount = listenerCount$1;
+function listenerCount$1(type) {
   var events = this._events;
 
   if (events !== undefined) {
@@ -416,24 +416,24 @@ function listenerCount(type) {
   return 0;
 }
 
-EventEmitter.prototype.eventNames = function eventNames() {
-  return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
+EventEmitter$1.prototype.eventNames = function eventNames() {
+  return this._eventsCount > 0 ? ReflectOwnKeys$1(this._events) : [];
 };
 
-function arrayClone(arr, n) {
+function arrayClone$1(arr, n) {
   var copy = new Array(n);
   for (var i = 0; i < n; ++i)
     copy[i] = arr[i];
   return copy;
 }
 
-function spliceOne(list, index) {
+function spliceOne$1(list, index) {
   for (; index + 1 < list.length; index++)
     list[index] = list[index + 1];
   list.pop();
 }
 
-function unwrapListeners(arr) {
+function unwrapListeners$1(arr) {
   var ret = new Array(arr.length);
   for (var i = 0; i < ret.length; ++i) {
     ret[i] = arr[i].listener || arr[i];
@@ -441,7 +441,7 @@ function unwrapListeners(arr) {
   return ret;
 }
 
-function once(emitter, name) {
+function once$1(emitter, name) {
   return new Promise(function (resolve, reject) {
     function errorListener(err) {
       emitter.removeListener(name, resolver);
@@ -454,20 +454,20 @@ function once(emitter, name) {
       }
       resolve([].slice.call(arguments));
     }
-    eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
+    eventTargetAgnosticAddListener$1(emitter, name, resolver, { once: true });
     if (name !== 'error') {
-      addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
+      addErrorHandlerIfEventEmitter$1(emitter, errorListener, { once: true });
     }
   });
 }
 
-function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
+function addErrorHandlerIfEventEmitter$1(emitter, handler, flags) {
   if (typeof emitter.on === 'function') {
-    eventTargetAgnosticAddListener(emitter, 'error', handler, flags);
+    eventTargetAgnosticAddListener$1(emitter, 'error', handler, flags);
   }
 }
 
-function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
+function eventTargetAgnosticAddListener$1(emitter, name, listener, flags) {
   if (typeof emitter.on === 'function') {
     if (flags.once) {
       emitter.once(name, listener);
@@ -490,7 +490,7 @@ function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
   }
 }
 
-var __extends$1 = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
+var __extends$2 = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
     var extendStatics = function (d, b) {
         extendStatics = Object.setPrototypeOf ||
             ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
@@ -503,18 +503,18 @@ var __extends$1 = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
-var __spreadArrays = (commonjsGlobal && commonjsGlobal.__spreadArrays) || function () {
+var __spreadArrays$1 = (commonjsGlobal && commonjsGlobal.__spreadArrays) || function () {
     for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
     for (var r = Array(s), k = 0, i = 0; i < il; i++)
         for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
             r[k] = a[j];
     return r;
 };
-StrictEventEmitter$1.__esModule = true;
-StrictEventEmitter$1.StrictEventEmitter = void 0;
-var events_1 = events.exports;
-var StrictEventEmitter = /** @class */ (function (_super) {
-    __extends$1(StrictEventEmitter, _super);
+StrictEventEmitter$3.__esModule = true;
+StrictEventEmitter$3.StrictEventEmitter = void 0;
+var events_1$1 = events$1.exports;
+var StrictEventEmitter$2 = /** @class */ (function (_super) {
+    __extends$2(StrictEventEmitter, _super);
     function StrictEventEmitter() {
         return _super.call(this) || this;
     }
@@ -532,7 +532,7 @@ var StrictEventEmitter = /** @class */ (function (_super) {
         for (var _i = 1; _i < arguments.length; _i++) {
             data[_i - 1] = arguments[_i];
         }
-        return _super.prototype.emit.apply(this, __spreadArrays([event.toString()], data));
+        return _super.prototype.emit.apply(this, __spreadArrays$1([event.toString()], data));
     };
     StrictEventEmitter.prototype.addListener = function (event, listener) {
         return _super.prototype.addListener.call(this, event.toString(), listener);
@@ -541,8 +541,8 @@ var StrictEventEmitter = /** @class */ (function (_super) {
         return _super.prototype.removeListener.call(this, event.toString(), listener);
     };
     return StrictEventEmitter;
-}(events_1.EventEmitter));
-StrictEventEmitter$1.StrictEventEmitter = StrictEventEmitter;
+}(events_1$1.EventEmitter));
+StrictEventEmitter$3.StrictEventEmitter = StrictEventEmitter$2;
 
 (function (exports) {
 var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -554,21 +554,21 @@ var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Obj
 }));
 exports.__esModule = true;
 exports.StrictEventEmitter = void 0;
-var StrictEventEmitter_1 = StrictEventEmitter$1;
+var StrictEventEmitter_1 = StrictEventEmitter$3;
 __createBinding(exports, StrictEventEmitter_1, "StrictEventEmitter");
-}(lib$3));
+}(lib$6));
 
-var lib$2 = {};
+var lib$5 = {};
 
-var until$1 = {};
+var until$2 = {};
 
-Object.defineProperty(until$1, "__esModule", { value: true });
+Object.defineProperty(until$2, "__esModule", { value: true });
 /**
  * Gracefully handles a given Promise factory.
  * @example
  * cosnt [error, data] = await until(() => asyncAction())
  */
-until$1.until = async (promise) => {
+until$2.until = async (promise) => {
     try {
         const data = await promise().catch((error) => {
             throw error;
@@ -580,9 +580,9 @@ until$1.until = async (promise) => {
     }
 };
 
-Object.defineProperty(lib$2, "__esModule", { value: true });
-var until_1$1 = until$1;
-var until = lib$2.until = until_1$1.until;
+Object.defineProperty(lib$5, "__esModule", { value: true });
+var until_1$2 = until$2;
+var until$1 = lib$5.until = until_1$2.until;
 
 /**
  * Attempts to resolve a Service Worker instance from a given registration,
@@ -639,7 +639,7 @@ const getWorkerInstance = (url, options = {}, findWorker) => __awaiter$2(void 0,
         });
     }
     // When the Service Worker wasn't found, register it anew and return the reference.
-    const [error, instance] = yield until(() => __awaiter$2(void 0, void 0, void 0, function* () {
+    const [error, instance] = yield until$1(() => __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,
@@ -711,7 +711,7 @@ const createBroadcastChannel = (event) => {
     };
 };
 
-var lib$1 = {};
+var lib$4 = {};
 
 var CookieStore = {};
 
@@ -1082,7 +1082,7 @@ 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));
+}(lib$4));
 
 function getAllCookies() {
     return parse_1(document.cookie);
@@ -1115,8 +1115,8 @@ function getRequestCookies(request) {
 
 function setRequestCookies(request) {
     var _a;
-    lib$1.store.hydrate();
-    request.cookies = Object.assign(Object.assign({}, getRequestCookies(request)), Array.from((_a = lib$1.store.get(Object.assign(Object.assign({}, request), { url: request.url.toString() }))) === null || _a === void 0 ? void 0 : _a.entries()).reduce((cookies, [name, { value }]) => Object.assign(cookies, { [name]: value }), {}));
+    lib$4.store.hydrate();
+    request.cookies = Object.assign(Object.assign({}, getRequestCookies(request)), Array.from((_a = lib$4.store.get(Object.assign(Object.assign({}, request), { url: request.url.toString() }))) === null || _a === void 0 ? void 0 : _a.entries()).reduce((cookies, [name, { value }]) => Object.assign(cookies, { [name]: value }), {}));
     request.headers.set('cookie', Object.entries(request.cookies)
         .map(([name, value]) => `${name}=${value}`)
         .join('; '));
@@ -1156,7 +1156,7 @@ function parseWorkerRequest(rawRequest) {
         destination: rawRequest.destination,
         body: pruneGetRequestBody(rawRequest),
         bodyUsed: rawRequest.bodyUsed,
-        headers: new lib$4.Headers(rawRequest.headers),
+        headers: new lib$7.Headers(rawRequest.headers),
     };
     // Set document cookies on the request.
     setRequestCookies(request);
@@ -1442,8 +1442,8 @@ Read more: https://mswjs.io/docs/getting-started/mocks\
 }
 
 function readResponseCookies(request, response) {
-    lib$1.store.add(Object.assign(Object.assign({}, request), { url: request.url.toString() }), response);
-    lib$1.store.persist();
+    lib$4.store.add(Object.assign(Object.assign({}, request), { url: request.url.toString() }), response);
+    lib$4.store.persist();
 }
 
 function handleRequest(request, handlers, options, emitter, handleRequestOptions) {
@@ -1576,7 +1576,7 @@ function deferNetworkRequestsUntil(predicatePromise) {
     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(() => {
+        until$1(() => predicatePromise).then(() => {
             window.XMLHttpRequest.prototype.send = originalXhrSend;
             this.send(...args);
         });
@@ -1584,7 +1584,7 @@ function deferNetworkRequestsUntil(predicatePromise) {
     // 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);
+        yield until$1(() => predicatePromise);
         window.fetch = originalFetch;
         return window.fetch(...args);
     });
@@ -1667,7 +1667,7 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
                 window.clearInterval(context.keepAliveInterval);
             });
             // Check if the active Service Worker is the latest published one
-            const [integrityError] = yield until(() => requestIntegrityCheck(context, worker));
+            const [integrityError] = yield until$1(() => requestIntegrityCheck(context, worker));
             if (integrityError) {
                 console.error(`\
 [MSW] Detected outdated Service Worker: ${integrityError.message}
@@ -1761,13 +1761,561 @@ function prepareStartHandler(handler, context) {
     };
 }
 
-var lib = {};
+var lib$3 = {};
 
 var createInterceptor$1 = {};
 
+var lib$2 = {};
+
+var StrictEventEmitter$1 = {};
+
+var events = {exports: {}};
+
+var R = typeof Reflect === 'object' ? Reflect : null;
+var ReflectApply = R && typeof R.apply === 'function'
+  ? R.apply
+  : function ReflectApply(target, receiver, args) {
+    return Function.prototype.apply.call(target, receiver, args);
+  };
+
+var ReflectOwnKeys;
+if (R && typeof R.ownKeys === 'function') {
+  ReflectOwnKeys = R.ownKeys;
+} else if (Object.getOwnPropertySymbols) {
+  ReflectOwnKeys = function ReflectOwnKeys(target) {
+    return Object.getOwnPropertyNames(target)
+      .concat(Object.getOwnPropertySymbols(target));
+  };
+} else {
+  ReflectOwnKeys = function ReflectOwnKeys(target) {
+    return Object.getOwnPropertyNames(target);
+  };
+}
+
+function ProcessEmitWarning(warning) {
+  if (console && console.warn) console.warn(warning);
+}
+
+var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {
+  return value !== value;
+};
+
+function EventEmitter() {
+  EventEmitter.init.call(this);
+}
+events.exports = EventEmitter;
+events.exports.once = once;
+
+// Backwards-compat with node 0.10.x
+EventEmitter.EventEmitter = EventEmitter;
+
+EventEmitter.prototype._events = undefined;
+EventEmitter.prototype._eventsCount = 0;
+EventEmitter.prototype._maxListeners = undefined;
+
+// By default EventEmitters will print a warning if more than 10 listeners are
+// added to it. This is a useful default which helps finding memory leaks.
+var defaultMaxListeners = 10;
+
+function checkListener(listener) {
+  if (typeof listener !== 'function') {
+    throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
+  }
+}
+
+Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
+  enumerable: true,
+  get: function() {
+    return defaultMaxListeners;
+  },
+  set: function(arg) {
+    if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {
+      throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + '.');
+    }
+    defaultMaxListeners = arg;
+  }
+});
+
+EventEmitter.init = function() {
+
+  if (this._events === undefined ||
+      this._events === Object.getPrototypeOf(this)._events) {
+    this._events = Object.create(null);
+    this._eventsCount = 0;
+  }
+
+  this._maxListeners = this._maxListeners || undefined;
+};
+
+// Obviously not all Emitters should be limited to 10. This function allows
+// that to be increased. Set to zero for unlimited.
+EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
+  if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {
+    throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + '.');
+  }
+  this._maxListeners = n;
+  return this;
+};
+
+function _getMaxListeners(that) {
+  if (that._maxListeners === undefined)
+    return EventEmitter.defaultMaxListeners;
+  return that._maxListeners;
+}
+
+EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
+  return _getMaxListeners(this);
+};
+
+EventEmitter.prototype.emit = function emit(type) {
+  var args = [];
+  for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
+  var doError = (type === 'error');
+
+  var events = this._events;
+  if (events !== undefined)
+    doError = (doError && events.error === undefined);
+  else if (!doError)
+    return false;
+
+  // If there is no 'error' event listener then throw.
+  if (doError) {
+    var er;
+    if (args.length > 0)
+      er = args[0];
+    if (er instanceof Error) {
+      // Note: The comments on the `throw` lines are intentional, they show
+      // up in Node's output if this results in an unhandled exception.
+      throw er; // Unhandled 'error' event
+    }
+    // At least give some kind of context to the user
+    var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));
+    err.context = er;
+    throw err; // Unhandled 'error' event
+  }
+
+  var handler = events[type];
+
+  if (handler === undefined)
+    return false;
+
+  if (typeof handler === 'function') {
+    ReflectApply(handler, this, args);
+  } else {
+    var len = handler.length;
+    var listeners = arrayClone(handler, len);
+    for (var i = 0; i < len; ++i)
+      ReflectApply(listeners[i], this, args);
+  }
+
+  return true;
+};
+
+function _addListener(target, type, listener, prepend) {
+  var m;
+  var events;
+  var existing;
+
+  checkListener(listener);
+
+  events = target._events;
+  if (events === undefined) {
+    events = target._events = Object.create(null);
+    target._eventsCount = 0;
+  } else {
+    // To avoid recursion in the case that type === "newListener"! Before
+    // adding it to the listeners, first emit "newListener".
+    if (events.newListener !== undefined) {
+      target.emit('newListener', type,
+                  listener.listener ? listener.listener : listener);
+
+      // Re-assign `events` because a newListener handler could have caused the
+      // this._events to be assigned to a new object
+      events = target._events;
+    }
+    existing = events[type];
+  }
+
+  if (existing === undefined) {
+    // Optimize the case of one listener. Don't need the extra array object.
+    existing = events[type] = listener;
+    ++target._eventsCount;
+  } else {
+    if (typeof existing === 'function') {
+      // Adding the second element, need to change to array.
+      existing = events[type] =
+        prepend ? [listener, existing] : [existing, listener];
+      // If we've already got an array, just append.
+    } else if (prepend) {
+      existing.unshift(listener);
+    } else {
+      existing.push(listener);
+    }
+
+    // Check for listener leak
+    m = _getMaxListeners(target);
+    if (m > 0 && existing.length > m && !existing.warned) {
+      existing.warned = true;
+      // No error code for this since it is a Warning
+      // eslint-disable-next-line no-restricted-syntax
+      var w = new Error('Possible EventEmitter memory leak detected. ' +
+                          existing.length + ' ' + String(type) + ' listeners ' +
+                          'added. Use emitter.setMaxListeners() to ' +
+                          'increase limit');
+      w.name = 'MaxListenersExceededWarning';
+      w.emitter = target;
+      w.type = type;
+      w.count = existing.length;
+      ProcessEmitWarning(w);
+    }
+  }
+
+  return target;
+}
+
+EventEmitter.prototype.addListener = function addListener(type, listener) {
+  return _addListener(this, type, listener, false);
+};
+
+EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+
+EventEmitter.prototype.prependListener =
+    function prependListener(type, listener) {
+      return _addListener(this, type, listener, true);
+    };
+
+function onceWrapper() {
+  if (!this.fired) {
+    this.target.removeListener(this.type, this.wrapFn);
+    this.fired = true;
+    if (arguments.length === 0)
+      return this.listener.call(this.target);
+    return this.listener.apply(this.target, arguments);
+  }
+}
+
+function _onceWrap(target, type, listener) {
+  var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };
+  var wrapped = onceWrapper.bind(state);
+  wrapped.listener = listener;
+  state.wrapFn = wrapped;
+  return wrapped;
+}
+
+EventEmitter.prototype.once = function once(type, listener) {
+  checkListener(listener);
+  this.on(type, _onceWrap(this, type, listener));
+  return this;
+};
+
+EventEmitter.prototype.prependOnceListener =
+    function prependOnceListener(type, listener) {
+      checkListener(listener);
+      this.prependListener(type, _onceWrap(this, type, listener));
+      return this;
+    };
+
+// Emits a 'removeListener' event if and only if the listener was removed.
+EventEmitter.prototype.removeListener =
+    function removeListener(type, listener) {
+      var list, events, position, i, originalListener;
+
+      checkListener(listener);
+
+      events = this._events;
+      if (events === undefined)
+        return this;
+
+      list = events[type];
+      if (list === undefined)
+        return this;
+
+      if (list === listener || list.listener === listener) {
+        if (--this._eventsCount === 0)
+          this._events = Object.create(null);
+        else {
+          delete events[type];
+          if (events.removeListener)
+            this.emit('removeListener', type, list.listener || listener);
+        }
+      } else if (typeof list !== 'function') {
+        position = -1;
+
+        for (i = list.length - 1; i >= 0; i--) {
+          if (list[i] === listener || list[i].listener === listener) {
+            originalListener = list[i].listener;
+            position = i;
+            break;
+          }
+        }
+
+        if (position < 0)
+          return this;
+
+        if (position === 0)
+          list.shift();
+        else {
+          spliceOne(list, position);
+        }
+
+        if (list.length === 1)
+          events[type] = list[0];
+
+        if (events.removeListener !== undefined)
+          this.emit('removeListener', type, originalListener || listener);
+      }
+
+      return this;
+    };
+
+EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+
+EventEmitter.prototype.removeAllListeners =
+    function removeAllListeners(type) {
+      var listeners, events, i;
+
+      events = this._events;
+      if (events === undefined)
+        return this;
+
+      // not listening for removeListener, no need to emit
+      if (events.removeListener === undefined) {
+        if (arguments.length === 0) {
+          this._events = Object.create(null);
+          this._eventsCount = 0;
+        } else if (events[type] !== undefined) {
+          if (--this._eventsCount === 0)
+            this._events = Object.create(null);
+          else
+            delete events[type];
+        }
+        return this;
+      }
+
+      // emit removeListener for all listeners on all events
+      if (arguments.length === 0) {
+        var keys = Object.keys(events);
+        var key;
+        for (i = 0; i < keys.length; ++i) {
+          key = keys[i];
+          if (key === 'removeListener') continue;
+          this.removeAllListeners(key);
+        }
+        this.removeAllListeners('removeListener');
+        this._events = Object.create(null);
+        this._eventsCount = 0;
+        return this;
+      }
+
+      listeners = events[type];
+
+      if (typeof listeners === 'function') {
+        this.removeListener(type, listeners);
+      } else if (listeners !== undefined) {
+        // LIFO order
+        for (i = listeners.length - 1; i >= 0; i--) {
+          this.removeListener(type, listeners[i]);
+        }
+      }
+
+      return this;
+    };
+
+function _listeners(target, type, unwrap) {
+  var events = target._events;
+
+  if (events === undefined)
+    return [];
+
+  var evlistener = events[type];
+  if (evlistener === undefined)
+    return [];
+
+  if (typeof evlistener === 'function')
+    return unwrap ? [evlistener.listener || evlistener] : [evlistener];
+
+  return unwrap ?
+    unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
+}
+
+EventEmitter.prototype.listeners = function listeners(type) {
+  return _listeners(this, type, true);
+};
+
+EventEmitter.prototype.rawListeners = function rawListeners(type) {
+  return _listeners(this, type, false);
+};
+
+EventEmitter.listenerCount = function(emitter, type) {
+  if (typeof emitter.listenerCount === 'function') {
+    return emitter.listenerCount(type);
+  } else {
+    return listenerCount.call(emitter, type);
+  }
+};
+
+EventEmitter.prototype.listenerCount = listenerCount;
+function listenerCount(type) {
+  var events = this._events;
+
+  if (events !== undefined) {
+    var evlistener = events[type];
+
+    if (typeof evlistener === 'function') {
+      return 1;
+    } else if (evlistener !== undefined) {
+      return evlistener.length;
+    }
+  }
+
+  return 0;
+}
+
+EventEmitter.prototype.eventNames = function eventNames() {
+  return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
+};
+
+function arrayClone(arr, n) {
+  var copy = new Array(n);
+  for (var i = 0; i < n; ++i)
+    copy[i] = arr[i];
+  return copy;
+}
+
+function spliceOne(list, index) {
+  for (; index + 1 < list.length; index++)
+    list[index] = list[index + 1];
+  list.pop();
+}
+
+function unwrapListeners(arr) {
+  var ret = new Array(arr.length);
+  for (var i = 0; i < ret.length; ++i) {
+    ret[i] = arr[i].listener || arr[i];
+  }
+  return ret;
+}
+
+function once(emitter, name) {
+  return new Promise(function (resolve, reject) {
+    function errorListener(err) {
+      emitter.removeListener(name, resolver);
+      reject(err);
+    }
+
+    function resolver() {
+      if (typeof emitter.removeListener === 'function') {
+        emitter.removeListener('error', errorListener);
+      }
+      resolve([].slice.call(arguments));
+    }
+    eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
+    if (name !== 'error') {
+      addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
+    }
+  });
+}
+
+function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
+  if (typeof emitter.on === 'function') {
+    eventTargetAgnosticAddListener(emitter, 'error', handler, flags);
+  }
+}
+
+function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
+  if (typeof emitter.on === 'function') {
+    if (flags.once) {
+      emitter.once(name, listener);
+    } else {
+      emitter.on(name, listener);
+    }
+  } else if (typeof emitter.addEventListener === 'function') {
+    // EventTarget does not have `error` event semantics like Node
+    // EventEmitters, we do not listen for `error` events here.
+    emitter.addEventListener(name, function wrapListener(arg) {
+      // IE does not have builtin `{ once: true }` support so we
+      // have to do it manually.
+      if (flags.once) {
+        emitter.removeEventListener(name, wrapListener);
+      }
+      listener(arg);
+    });
+  } else {
+    throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
+  }
+}
+
+var __extends$1 = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __spreadArrays = (commonjsGlobal && commonjsGlobal.__spreadArrays) || function () {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
+StrictEventEmitter$1.__esModule = true;
+StrictEventEmitter$1.StrictEventEmitter = void 0;
+var events_1 = events.exports;
+var StrictEventEmitter = /** @class */ (function (_super) {
+    __extends$1(StrictEventEmitter, _super);
+    function StrictEventEmitter() {
+        return _super.call(this) || this;
+    }
+    StrictEventEmitter.prototype.on = function (event, listener) {
+        return _super.prototype.on.call(this, event.toString(), listener);
+    };
+    StrictEventEmitter.prototype.once = function (event, listener) {
+        return _super.prototype.on.call(this, event.toString(), listener);
+    };
+    StrictEventEmitter.prototype.off = function (event, listener) {
+        return _super.prototype.off.call(this, event.toString(), listener);
+    };
+    StrictEventEmitter.prototype.emit = function (event) {
+        var data = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            data[_i - 1] = arguments[_i];
+        }
+        return _super.prototype.emit.apply(this, __spreadArrays([event.toString()], data));
+    };
+    StrictEventEmitter.prototype.addListener = function (event, listener) {
+        return _super.prototype.addListener.call(this, event.toString(), listener);
+    };
+    StrictEventEmitter.prototype.removeListener = function (event, listener) {
+        return _super.prototype.removeListener.call(this, event.toString(), listener);
+    };
+    return StrictEventEmitter;
+}(events_1.EventEmitter));
+StrictEventEmitter$1.StrictEventEmitter = StrictEventEmitter;
+
+(function (exports) {
+var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+exports.__esModule = true;
+exports.StrictEventEmitter = void 0;
+var StrictEventEmitter_1 = StrictEventEmitter$1;
+__createBinding(exports, StrictEventEmitter_1, "StrictEventEmitter");
+}(lib$2));
+
 Object.defineProperty(createInterceptor$1, "__esModule", { value: true });
 createInterceptor$1.createInterceptor = void 0;
-var strict_event_emitter_1 = lib$3;
+var strict_event_emitter_1 = lib$2;
 function createInterceptor(options) {
     var observer = new strict_event_emitter_1.StrictEventEmitter();
     var cleanupFns = [];
@@ -1809,10 +2357,554 @@ __exportStar(createInterceptor$1, exports);
 var getCleanUrl_1 = getCleanUrl;
 Object.defineProperty(exports, "getCleanUrl", { enumerable: true, get: function () { return getCleanUrl_1.getCleanUrl; } });
 //# sourceMappingURL=index.js.map
-}(lib));
+}(lib$3));
 
 var fetch = {};
 
+var lib$1 = {};
+
+var Headers = {};
+
+var normalizeHeaderName$1 = {};
+
+Object.defineProperty(normalizeHeaderName$1, "__esModule", { value: true });
+normalizeHeaderName$1.normalizeHeaderName = void 0;
+var HEADERS_INVALID_CHARACTERS = /[^a-z0-9\-#$%&'*+.^_`|~]/i;
+function normalizeHeaderName(name) {
+    if (typeof name !== 'string') {
+        name = String(name);
+    }
+    if (HEADERS_INVALID_CHARACTERS.test(name) || name.trim() === '') {
+        throw new TypeError('Invalid character in header field name');
+    }
+    return name.toLowerCase();
+}
+normalizeHeaderName$1.normalizeHeaderName = normalizeHeaderName;
+
+var normalizeHeaderValue$1 = {};
+
+Object.defineProperty(normalizeHeaderValue$1, "__esModule", { value: true });
+normalizeHeaderValue$1.normalizeHeaderValue = void 0;
+function normalizeHeaderValue(value) {
+    if (typeof value !== 'string') {
+        value = String(value);
+    }
+    return value;
+}
+normalizeHeaderValue$1.normalizeHeaderValue = normalizeHeaderValue;
+
+var __generator$2 = (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 __read$4 = (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;
+};
+var __values$1 = (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.");
+};
+Object.defineProperty(Headers, "__esModule", { value: true });
+var normalizeHeaderName_1 = normalizeHeaderName$1;
+var normalizeHeaderValue_1 = normalizeHeaderValue$1;
+var HeadersPolyfill = /** @class */ (function () {
+    function HeadersPolyfill(init) {
+        var _this = this;
+        // Normalized header {"name":"a, b"} storage.
+        this._headers = {};
+        // Keeps the mapping between the raw header name
+        // and the normalized header name to ease the lookup.
+        this._names = new Map();
+        /**
+         * @note Cannot check if the `init` is an instance of the `Headers`
+         * because that class is only defined in the browser.
+         */
+        if (['Headers', 'HeadersPolyfill'].includes(init === null || init === void 0 ? void 0 : init.constructor.name) ||
+            init instanceof HeadersPolyfill) {
+            var initialHeaders = init;
+            initialHeaders.forEach(function (value, name) {
+                _this.append(name, value);
+            }, this);
+        }
+        else if (Array.isArray(init)) {
+            init.forEach(function (_a) {
+                var _b = __read$4(_a, 2), name = _b[0], value = _b[1];
+                _this.append(name, Array.isArray(value) ? value.join(', ') : value);
+            });
+        }
+        else if (init) {
+            Object.getOwnPropertyNames(init).forEach(function (name) {
+                var value = init[name];
+                _this.append(name, Array.isArray(value) ? value.join(', ') : value);
+            });
+        }
+    }
+    HeadersPolyfill.prototype[Symbol.iterator] = function () {
+        return this.entries();
+    };
+    HeadersPolyfill.prototype.keys = function () {
+        var _a, _b, name_1, e_1_1;
+        var e_1, _c;
+        return __generator$2(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    _d.trys.push([0, 5, 6, 7]);
+                    _a = __values$1(Object.keys(this._headers)), _b = _a.next();
+                    _d.label = 1;
+                case 1:
+                    if (!!_b.done) return [3 /*break*/, 4];
+                    name_1 = _b.value;
+                    return [4 /*yield*/, name_1];
+                case 2:
+                    _d.sent();
+                    _d.label = 3;
+                case 3:
+                    _b = _a.next();
+                    return [3 /*break*/, 1];
+                case 4: return [3 /*break*/, 7];
+                case 5:
+                    e_1_1 = _d.sent();
+                    e_1 = { error: e_1_1 };
+                    return [3 /*break*/, 7];
+                case 6:
+                    try {
+                        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                    return [7 /*endfinally*/];
+                case 7: return [2 /*return*/];
+            }
+        });
+    };
+    HeadersPolyfill.prototype.values = function () {
+        var _a, _b, value, e_2_1;
+        var e_2, _c;
+        return __generator$2(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    _d.trys.push([0, 5, 6, 7]);
+                    _a = __values$1(Object.values(this._headers)), _b = _a.next();
+                    _d.label = 1;
+                case 1:
+                    if (!!_b.done) return [3 /*break*/, 4];
+                    value = _b.value;
+                    return [4 /*yield*/, value];
+                case 2:
+                    _d.sent();
+                    _d.label = 3;
+                case 3:
+                    _b = _a.next();
+                    return [3 /*break*/, 1];
+                case 4: return [3 /*break*/, 7];
+                case 5:
+                    e_2_1 = _d.sent();
+                    e_2 = { error: e_2_1 };
+                    return [3 /*break*/, 7];
+                case 6:
+                    try {
+                        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                    return [7 /*endfinally*/];
+                case 7: return [2 /*return*/];
+            }
+        });
+    };
+    HeadersPolyfill.prototype.entries = function () {
+        var _a, _b, name_2, e_3_1;
+        var e_3, _c;
+        return __generator$2(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    _d.trys.push([0, 5, 6, 7]);
+                    _a = __values$1(Object.keys(this._headers)), _b = _a.next();
+                    _d.label = 1;
+                case 1:
+                    if (!!_b.done) return [3 /*break*/, 4];
+                    name_2 = _b.value;
+                    return [4 /*yield*/, [name_2, this.get(name_2)]];
+                case 2:
+                    _d.sent();
+                    _d.label = 3;
+                case 3:
+                    _b = _a.next();
+                    return [3 /*break*/, 1];
+                case 4: return [3 /*break*/, 7];
+                case 5:
+                    e_3_1 = _d.sent();
+                    e_3 = { error: e_3_1 };
+                    return [3 /*break*/, 7];
+                case 6:
+                    try {
+                        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                    }
+                    finally { if (e_3) throw e_3.error; }
+                    return [7 /*endfinally*/];
+                case 7: return [2 /*return*/];
+            }
+        });
+    };
+    /**
+     * Returns a `ByteString` sequence of all the values of a header with a given name.
+     */
+    HeadersPolyfill.prototype.get = function (name) {
+        return this._headers[normalizeHeaderName_1.normalizeHeaderName(name)] || null;
+    };
+    /**
+     * Sets a new value for an existing header inside a `Headers` object, or adds the header if it does not already exist.
+     */
+    HeadersPolyfill.prototype.set = function (name, value) {
+        var normalizedName = normalizeHeaderName_1.normalizeHeaderName(name);
+        this._headers[normalizedName] = normalizeHeaderValue_1.normalizeHeaderValue(value);
+        this._names.set(normalizedName, name);
+    };
+    /**
+     * Appends a new value onto an existing header inside a `Headers` object, or adds the header if it does not already exist.
+     */
+    HeadersPolyfill.prototype.append = function (name, value) {
+        var resolvedValue = this.has(name) ? this.get(name) + ", " + value : value;
+        this.set(name, resolvedValue);
+    };
+    /**
+     * Deletes a header from the `Headers` object.
+     */
+    HeadersPolyfill.prototype.delete = function (name) {
+        if (!this.has(name)) {
+            return this;
+        }
+        var normalizedName = normalizeHeaderName_1.normalizeHeaderName(name);
+        delete this._headers[normalizedName];
+        this._names.delete(normalizedName);
+        return this;
+    };
+    /**
+     * Returns the object of all the normalized headers.
+     */
+    HeadersPolyfill.prototype.all = function () {
+        return this._headers;
+    };
+    /**
+     * Returns the object of all the raw headers.
+     */
+    HeadersPolyfill.prototype.raw = function () {
+        var _this = this;
+        return Object.entries(this._headers).reduce(function (headers, _a) {
+            var _b = __read$4(_a, 2), name = _b[0], value = _b[1];
+            headers[_this._names.get(name)] = value;
+            return headers;
+        }, {});
+    };
+    /**
+     * Returns a boolean stating whether a `Headers` object contains a certain header.
+     */
+    HeadersPolyfill.prototype.has = function (name) {
+        return this._headers.hasOwnProperty(normalizeHeaderName_1.normalizeHeaderName(name));
+    };
+    /**
+     * Traverses the `Headers` object,
+     * calling the given callback for each header.
+     */
+    HeadersPolyfill.prototype.forEach = function (callback, thisArg) {
+        for (var name_3 in this._headers) {
+            if (this._headers.hasOwnProperty(name_3)) {
+                callback.call(thisArg, this._headers[name_3], name_3, this);
+            }
+        }
+    };
+    return HeadersPolyfill;
+}());
+Headers.default = HeadersPolyfill;
+
+var headersToString$1 = {};
+
+var headersToList$1 = {};
+
+Object.defineProperty(headersToList$1, "__esModule", { value: true });
+headersToList$1.headersToList = void 0;
+function headersToList(headers) {
+    var headersList = [];
+    headers.forEach(function (value, name) {
+        var resolvedValue = value.includes(',')
+            ? value.split(',').map(function (value) { return value.trim(); })
+            : value;
+        headersList.push([name, resolvedValue]);
+    });
+    return headersList;
+}
+headersToList$1.headersToList = headersToList;
+
+var __read$3 = (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(headersToString$1, "__esModule", { value: true });
+headersToString$1.headersToString = void 0;
+var headersToList_1 = headersToList$1;
+/**
+ * Converts a given `Headers` instance to its string representation.
+ */
+function headersToString(headers) {
+    var list = headersToList_1.headersToList(headers);
+    var lines = list.map(function (_a) {
+        var _b = __read$3(_a, 2), name = _b[0], value = _b[1];
+        var values = [].concat(value);
+        return name + ": " + values.join(', ');
+    });
+    return lines.join('\r\n');
+}
+headersToString$1.headersToString = headersToString;
+
+var headersToObject$1 = {};
+
+Object.defineProperty(headersToObject$1, "__esModule", { value: true });
+headersToObject$1.headersToObject = void 0;
+// List of headers that cannot have multiple values,
+// while potentially having a comma in their single value.
+var singleValueHeaders = ['user-agent'];
+/**
+ * Converts a given `Headers` instance into a plain object.
+ * Respects headers with multiple values.
+ */
+function headersToObject(headers) {
+    var headersObject = {};
+    headers.forEach(function (value, name) {
+        var isMultiValue = !singleValueHeaders.includes(name.toLowerCase()) && value.includes(',');
+        headersObject[name] = isMultiValue
+            ? value.split(',').map(function (s) { return s.trim(); })
+            : value;
+    });
+    return headersObject;
+}
+headersToObject$1.headersToObject = headersToObject;
+
+var stringToHeaders$1 = {};
+
+Object.defineProperty(stringToHeaders$1, "__esModule", { value: true });
+stringToHeaders$1.stringToHeaders = void 0;
+var Headers_1$2 = Headers;
+/**
+ * Converts a string representation of headers (i.e. from XMLHttpRequest)
+ * to a new `Headers` instance.
+ */
+function stringToHeaders(str) {
+    var lines = str.trim().split(/[\r\n]+/);
+    return lines.reduce(function (headers, line) {
+        var parts = line.split(': ');
+        var name = parts.shift();
+        var value = parts.join(': ');
+        headers.append(name, value);
+        return headers;
+    }, new Headers_1$2.default());
+}
+stringToHeaders$1.stringToHeaders = stringToHeaders;
+
+var listToHeaders$1 = {};
+
+var __read$2 = (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(listToHeaders$1, "__esModule", { value: true });
+listToHeaders$1.listToHeaders = void 0;
+var Headers_1$1 = Headers;
+function listToHeaders(list) {
+    var headers = new Headers_1$1.default();
+    list.forEach(function (_a) {
+        var _b = __read$2(_a, 2), name = _b[0], value = _b[1];
+        var values = [].concat(value);
+        values.forEach(function (value) {
+            headers.append(name, value);
+        });
+    });
+    return headers;
+}
+listToHeaders$1.listToHeaders = listToHeaders;
+
+var objectToHeaders$1 = {};
+
+var reduceHeadersObject$1 = {};
+
+Object.defineProperty(reduceHeadersObject$1, "__esModule", { value: true });
+reduceHeadersObject$1.reduceHeadersObject = void 0;
+/**
+ * Reduces given headers object instnace.
+ */
+function reduceHeadersObject(headers, reducer, initialState) {
+    return Object.keys(headers).reduce(function (nextHeaders, name) {
+        return reducer(nextHeaders, name, headers[name]);
+    }, initialState);
+}
+reduceHeadersObject$1.reduceHeadersObject = reduceHeadersObject;
+
+Object.defineProperty(objectToHeaders$1, "__esModule", { value: true });
+objectToHeaders$1.objectToHeaders = void 0;
+var Headers_1 = Headers;
+var reduceHeadersObject_1$1 = reduceHeadersObject$1;
+/**
+ * Converts a given headers object to a new `Headers` instance.
+ */
+function objectToHeaders(headersObject) {
+    return reduceHeadersObject_1$1.reduceHeadersObject(headersObject, function (headers, name, value) {
+        var values = [].concat(value).filter(Boolean);
+        values.forEach(function (value) {
+            headers.append(name, value);
+        });
+        return headers;
+    }, new Headers_1.default());
+}
+objectToHeaders$1.objectToHeaders = objectToHeaders;
+
+var flattenHeadersList$1 = {};
+
+var __read$1 = (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(flattenHeadersList$1, "__esModule", { value: true });
+flattenHeadersList$1.flattenHeadersList = void 0;
+function flattenHeadersList(list) {
+    return list.map(function (_a) {
+        var _b = __read$1(_a, 2), name = _b[0], values = _b[1];
+        return [name, [].concat(values).join('; ')];
+    });
+}
+flattenHeadersList$1.flattenHeadersList = flattenHeadersList;
+
+var flattenHeadersObject$1 = {};
+
+Object.defineProperty(flattenHeadersObject$1, "__esModule", { value: true });
+flattenHeadersObject$1.flattenHeadersObject = void 0;
+var reduceHeadersObject_1 = reduceHeadersObject$1;
+function flattenHeadersObject(headersObject) {
+    return reduceHeadersObject_1.reduceHeadersObject(headersObject, function (headers, name, value) {
+        headers[name] = [].concat(value).join('; ');
+        return headers;
+    }, {});
+}
+flattenHeadersObject$1.flattenHeadersObject = flattenHeadersObject;
+
+(function (exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flattenHeadersObject = exports.flattenHeadersList = exports.reduceHeadersObject = exports.objectToHeaders = exports.listToHeaders = exports.stringToHeaders = exports.headersToObject = exports.headersToList = exports.headersToString = exports.Headers = void 0;
+var Headers_1 = Headers;
+Object.defineProperty(exports, "Headers", { enumerable: true, get: function () { return Headers_1.default; } });
+var headersToString_1 = headersToString$1;
+Object.defineProperty(exports, "headersToString", { enumerable: true, get: function () { return headersToString_1.headersToString; } });
+var headersToList_1 = headersToList$1;
+Object.defineProperty(exports, "headersToList", { enumerable: true, get: function () { return headersToList_1.headersToList; } });
+var headersToObject_1 = headersToObject$1;
+Object.defineProperty(exports, "headersToObject", { enumerable: true, get: function () { return headersToObject_1.headersToObject; } });
+var stringToHeaders_1 = stringToHeaders$1;
+Object.defineProperty(exports, "stringToHeaders", { enumerable: true, get: function () { return stringToHeaders_1.stringToHeaders; } });
+var listToHeaders_1 = listToHeaders$1;
+Object.defineProperty(exports, "listToHeaders", { enumerable: true, get: function () { return listToHeaders_1.listToHeaders; } });
+var objectToHeaders_1 = objectToHeaders$1;
+Object.defineProperty(exports, "objectToHeaders", { enumerable: true, get: function () { return objectToHeaders_1.objectToHeaders; } });
+var reduceHeadersObject_1 = reduceHeadersObject$1;
+Object.defineProperty(exports, "reduceHeadersObject", { enumerable: true, get: function () { return reduceHeadersObject_1.reduceHeadersObject; } });
+var flattenHeadersList_1 = flattenHeadersList$1;
+Object.defineProperty(exports, "flattenHeadersList", { enumerable: true, get: function () { return flattenHeadersList_1.flattenHeadersList; } });
+var flattenHeadersObject_1 = flattenHeadersObject$1;
+Object.defineProperty(exports, "flattenHeadersObject", { enumerable: true, get: function () { return flattenHeadersObject_1.flattenHeadersObject; } });
+}(lib$1));
+
+var toIsoResponse$1 = {};
+
+Object.defineProperty(toIsoResponse$1, "__esModule", { value: true });
+toIsoResponse$1.toIsoResponse = void 0;
+var headers_utils_1$2 = lib$1;
+/**
+ * Converts a given mocked response object into an isomorphic response.
+ */
+function toIsoResponse(response) {
+    return {
+        status: response.status || 200,
+        statusText: response.statusText || 'OK',
+        headers: headers_utils_1$2.objectToHeaders(response.headers || {}),
+        body: response.body,
+    };
+}
+toIsoResponse$1.toIsoResponse = toIsoResponse;
+
 var __assign = (commonjsGlobal && commonjsGlobal.__assign) || function () {
     __assign = Object.assign || function(t) {
         for (var s, i = 1, n = arguments.length; i < n; i++) {
@@ -1862,8 +2954,9 @@ var __generator$1 = (commonjsGlobal && commonjsGlobal.__generator) || function (
 };
 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 headers_utils_1$1 = lib$1;
+var toIsoResponse_1$1 = toIsoResponse$1;
+var debug$1 = require$$2('fetch');
 var interceptFetch = function (observer, resolver) {
     var pureFetch = window.fetch;
     debug$1('replacing "window.fetch"...');
@@ -1894,7 +2987,7 @@ var interceptFetch = function (observer, resolver) {
                     response = _b.sent();
                     debug$1('mocked response', response);
                     if (response) {
-                        isomorphicResponse = normalizeMockedResponse(response);
+                        isomorphicResponse = toIsoResponse_1$1.toIsoResponse(response);
                         debug$1('derived isomorphic response', isomorphicResponse);
                         observer.emit('response', isoRequest, isomorphicResponse);
                         return [2 /*return*/, new Response(response.body, __assign(__assign({}, isomorphicResponse), { 
@@ -1929,14 +3022,6 @@ var interceptFetch = function (observer, resolver) {
     };
 };
 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;
@@ -1960,6 +3045,32 @@ var XMLHttpRequest = {};
 
 var XMLHttpRequestOverride = {};
 
+var lib = {};
+
+var until = {};
+
+Object.defineProperty(until, "__esModule", { value: true });
+/**
+ * Gracefully handles a given Promise factory.
+ * @example
+ * cosnt [error, data] = await until(() => asyncAction())
+ */
+until.until = async (promise) => {
+    try {
+        const data = await promise().catch((error) => {
+            throw error;
+        });
+        return [null, data];
+    }
+    catch (error) {
+        return [error, null];
+    }
+};
+
+Object.defineProperty(lib, "__esModule", { value: true });
+var until_1$1 = until;
+lib.until = until_1$1.until;
+
 var domParser = {};
 
 var entities = {};
@@ -4600,13 +5711,14 @@ 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 until_1 = lib;
+var headers_utils_1 = lib$1;
 var xmldom_1 = domParser;
 var parseJson_1 = parseJson$1;
+var toIsoResponse_1 = toIsoResponse$1;
 var bufferFrom_1 = bufferFrom$1;
 var createEvent_1 = createEvent$1;
-var createDebug = require$$1;
+var createDebug = require$$2;
 var createXMLHttpRequestOverride = function (options) {
     var _a;
     var pureXMLHttpRequest = options.pureXMLHttpRequest, observer = options.observer, resolver = options.resolver;
@@ -4800,12 +5912,7 @@ var createXMLHttpRequestOverride = function (options) {
                         _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,
-                        });
+                        observer.emit('response', isoRequest, toIsoResponse_1.toIsoResponse(mockedResponse));
                     }
                     else {
                         debug('no mocked response received!');
@@ -4989,7 +6096,7 @@ XMLHttpRequestOverride.createXMLHttpRequestOverride = createXMLHttpRequestOverri
 Object.defineProperty(XMLHttpRequest, "__esModule", { value: true });
 var interceptXMLHttpRequest_1 = XMLHttpRequest.interceptXMLHttpRequest = void 0;
 var XMLHttpRequestOverride_1 = XMLHttpRequestOverride;
-var debug = require$$1('XHR');
+var debug = require$$2('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.
@@ -5065,7 +6172,7 @@ function parseIsomorphicRequest(request) {
 }
 
 function createFallbackRequestListener(context, options) {
-    const interceptor = lib.createInterceptor({
+    const interceptor = lib$3.createInterceptor({
         modules: [interceptFetch_1, interceptXMLHttpRequest_1],
         resolver(request) {
             return __awaiter$2(this, void 0, void 0, function* () {
@@ -5136,7 +6243,7 @@ function setupWorker(...requestHandlers) {
         worker: null,
         registration: null,
         requestHandlers: [...requestHandlers],
-        emitter: new lib$3.StrictEventEmitter(),
+        emitter: new lib$6.StrictEventEmitter(),
         workerChannel: {
             on(eventType, callback) {
                 context.events.addListener(navigator.serviceWorker, 'message', (event) => {