msw 0.27.1 → 0.28.2

package/native/lib/index.js

@@ -2,11 +2,11 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var XMLHttpRequest = require('node-request-interceptor/lib/interceptors/XMLHttpRequest');
+var XMLHttpRequest = require('@mswjs/interceptors/lib/interceptors/XMLHttpRequest');
 var os = require('os');
 var tty = require('tty');
 var events_1 = require('events');
-var nodeRequestInterceptor = require('node-request-interceptor');
+var interceptors = require('@mswjs/interceptors');
 var url = require('url');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
@@ -2129,113 +2129,492 @@ function tryDecode(str, decode) {
   }
 }
 
+var StrictEventEmitter_1 = createCommonjsModule(function (module, exports) {
+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) {
+        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;
+};
+exports.__esModule = true;
+exports.StrictEventEmitter = void 0;
+
+var StrictEventEmitter = /** @class */ (function (_super) {
+    __extends(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__default['default'].EventEmitter));
+exports.StrictEventEmitter = StrictEventEmitter;
+});
+
+var lib = createCommonjsModule(function (module, 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;
+
+__createBinding(exports, StrictEventEmitter_1, "StrictEventEmitter");
+});
+
+/**
+ * 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,
+    };
+});
+
+/**
+ * Parses a given string into a JSON.
+ * Does not throw an exception on an invalid JSON string.
+ */
+function jsonParse(str) {
+    try {
+        return JSON.parse(str);
+    }
+    catch (error) {
+        return undefined;
+    }
+}
+
+var normalizeHeaderName_1 = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeHeaderName = void 0;
 var HEADERS_INVALID_CHARACTERS = /[^a-z0-9\-#$%&'*+.^_`|~]/i;
-var Headers$1 = /** @class */ (function () {
-    function Headers(headers) {
+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();
+}
+exports.normalizeHeaderName = normalizeHeaderName;
+});
+
+var normalizeHeaderValue_1 = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeHeaderValue = void 0;
+function normalizeHeaderValue(value) {
+    if (typeof value !== 'string') {
+        value = String(value);
+    }
+    return value;
+}
+exports.normalizeHeaderValue = normalizeHeaderValue;
+});
+
+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 __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;
+};
+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 HeadersPolyfill = /** @class */ (function () {
+    function HeadersPolyfill(init) {
         var _this = this;
-        this.map = {};
-        if ((headers === null || headers === void 0 ? void 0 : headers.constructor.name) === 'Headers') {
-            headers.forEach(function (value, name) {
+        // 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(headers)) {
-            headers.forEach(function (_a) {
-                var name = _a[0], value = _a[1];
+        else if (Array.isArray(init)) {
+            init.forEach(function (_a) {
+                var _b = __read(_a, 2), name = _b[0], value = _b[1];
                 _this.append(name, Array.isArray(value) ? value.join(', ') : value);
             });
         }
-        else if (headers) {
-            Object.getOwnPropertyNames(headers).forEach(function (name) {
-                _this.append(name, headers[name]);
+        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(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    _d.trys.push([0, 5, 6, 7]);
+                    _a = __values(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(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    _d.trys.push([0, 5, 6, 7]);
+                    _a = __values(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(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    _d.trys.push([0, 5, 6, 7]);
+                    _a = __values(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.
      */
-    Headers.prototype.set = function (name, value) {
-        this.map[this.normalizeName(name)] = this.normalizeValue(value);
+    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.
      */
-    Headers.prototype.append = function (name, value) {
-        name = this.normalizeName(name);
-        value = this.normalizeValue(value);
-        this.map[name] = this.has(name) ? this.map[name] + ", " + value : value;
+    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.
      */
-    Headers.prototype.delete = function (name) {
-        delete this.map[this.normalizeName(name)];
+    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 a `ByteString` sequence of all the values of a header with a given name.
+     * Returns the object of all the normalized headers.
      */
-    Headers.prototype.get = function (name) {
-        return this.map[this.normalizeName(name)] || null;
+    HeadersPolyfill.prototype.all = function () {
+        return this._headers;
     };
     /**
-     * Returns the map of all headers in a `Headers` object.
+     * Returns the object of all the raw headers.
      */
-    Headers.prototype.getAllHeaders = function () {
-        return this.map;
+    HeadersPolyfill.prototype.raw = function () {
+        var _this = this;
+        return Object.entries(this._headers).reduce(function (headers, _a) {
+            var _b = __read(_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.
      */
-    Headers.prototype.has = function (name) {
-        return this.map.hasOwnProperty(this.normalizeName(name));
+    HeadersPolyfill.prototype.has = function (name) {
+        return this._headers.hasOwnProperty(normalizeHeaderName_1.normalizeHeaderName(name));
     };
-    Headers.prototype.forEach = function (callback, thisArg) {
-        for (var name_1 in this.map) {
-            if (this.map.hasOwnProperty(name_1)) {
-                callback.call(thisArg, this.map[name_1], name_1, this);
+    /**
+     * 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);
             }
         }
     };
-    Headers.prototype.normalizeName = function (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();
-    };
-    Headers.prototype.normalizeValue = function (value) {
-        if (typeof value !== 'string') {
-            value = String(value);
-        }
-        return value;
-    };
-    return Headers;
+    return HeadersPolyfill;
 }());
-var Headers_2 = Headers$1;
+var _default = HeadersPolyfill;
 
-var Headers_1 = /*#__PURE__*/Object.defineProperty({
-	Headers: Headers_2
+var Headers = /*#__PURE__*/Object.defineProperty({
+	default: _default
 }, '__esModule', {value: true});
 
+var headersToList_1 = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.headersToList = void 0;
 function headersToList(headers) {
     var headersList = [];
     headers.forEach(function (value, name) {
         var resolvedValue = value.includes(',')
-            ? value.split(',').map(function (v) { return v.trim(); })
+            ? value.split(',').map(function (value) { return value.trim(); })
             : value;
         headersList.push([name, resolvedValue]);
     });
     return headersList;
 }
-var headersToList_2 = headersToList;
+exports.headersToList = headersToList;
+});
 
-var headersToList_1 = /*#__PURE__*/Object.defineProperty({
-	headersToList: headersToList_2
-}, '__esModule', {value: true});
+var headersToString_1 = createCommonjsModule(function (module, exports) {
+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(exports, "__esModule", { value: true });
+exports.headersToString = void 0;
 
+/**
+ * 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(_a, 2), name = _b[0], value = _b[1];
+        var values = [].concat(value);
+        return name + ": " + values.join(', ');
+    });
+    return lines.join('\r\n');
+}
+exports.headersToString = headersToString;
+});
+
+var headersToObject_1 = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.headersToObject = void 0;
 // List of headers that cannot have multiple values,
 // while potentially having a comma in their single value.
 var singleValueHeaders = ['user-agent'];
@@ -2253,11 +2632,12 @@ function headersToObject(headers) {
     });
     return headersObject;
 }
-var headersToObject_2 = headersToObject;
+exports.headersToObject = headersToObject;
+});
 
-var headersToObject_1 = /*#__PURE__*/Object.defineProperty({
-	headersToObject: headersToObject_2
-}, '__esModule', {value: true});
+var stringToHeaders_1 = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringToHeaders = void 0;
 
 /**
  * Converts a string representation of headers (i.e. from XMLHttpRequest)
@@ -2271,18 +2651,35 @@ function stringToHeaders(str) {
         var value = parts.join(': ');
         headers.append(name, value);
         return headers;
-    }, new Headers());
+    }, new Headers.default());
 }
-var stringToHeaders_2 = stringToHeaders;
+exports.stringToHeaders = stringToHeaders;
+});
 
-var stringToHeaders_1 = /*#__PURE__*/Object.defineProperty({
-	stringToHeaders: stringToHeaders_2
-}, '__esModule', {value: true});
+var listToHeaders_1 = createCommonjsModule(function (module, exports) {
+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(exports, "__esModule", { value: true });
+exports.listToHeaders = void 0;
 
 function listToHeaders(list) {
-    var headers = new Headers();
+    var headers = new Headers.default();
     list.forEach(function (_a) {
-        var name = _a[0], value = _a[1];
+        var _b = __read(_a, 2), name = _b[0], value = _b[1];
         var values = [].concat(value);
         values.forEach(function (value) {
             headers.append(name, value);
@@ -2290,12 +2687,12 @@ function listToHeaders(list) {
     });
     return headers;
 }
-var listToHeaders_2 = listToHeaders;
-
-var listToHeaders_1 = /*#__PURE__*/Object.defineProperty({
-	listToHeaders: listToHeaders_2
-}, '__esModule', {value: true});
+exports.listToHeaders = listToHeaders;
+});
 
+var reduceHeadersObject_1 = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reduceHeadersObject = void 0;
 /**
  * Reduces given headers object instnace.
  */
@@ -2304,202 +2701,98 @@ function reduceHeadersObject(headers, reducer, initialState) {
         return reducer(nextHeaders, name, headers[name]);
     }, initialState);
 }
-var reduceHeadersObject_2 = reduceHeadersObject;
+exports.reduceHeadersObject = reduceHeadersObject;
+});
+
+var objectToHeaders_1 = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectToHeaders = void 0;
 
-var reduceHeadersObject_1 = /*#__PURE__*/Object.defineProperty({
-	reduceHeadersObject: reduceHeadersObject_2
-}, '__esModule', {value: true});
 
 /**
  * Converts a given headers object to a new `Headers` instance.
  */
-function objectToHeaders(obj) {
-    return reduceHeadersObject_1.reduceHeadersObject(obj, function (headers, name, value) {
-        var values = [].concat(value);
+function objectToHeaders(headersObject) {
+    return reduceHeadersObject_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());
+    }, new Headers.default());
 }
-var objectToHeaders_2 = objectToHeaders;
-
-var objectToHeaders_1 = /*#__PURE__*/Object.defineProperty({
-	objectToHeaders: objectToHeaders_2
-}, '__esModule', {value: true});
+exports.objectToHeaders = objectToHeaders;
+});
 
+var flattenHeadersList_1 = createCommonjsModule(function (module, exports) {
+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(exports, "__esModule", { value: true });
+exports.flattenHeadersList = void 0;
 function flattenHeadersList(list) {
     return list.map(function (_a) {
-        var name = _a[0], values = _a[1];
+        var _b = __read(_a, 2), name = _b[0], values = _b[1];
         return [name, [].concat(values).join('; ')];
     });
 }
-var flattenHeadersList_2 = flattenHeadersList;
+exports.flattenHeadersList = flattenHeadersList;
+});
 
-var flattenHeadersList_1 = /*#__PURE__*/Object.defineProperty({
-	flattenHeadersList: flattenHeadersList_2
-}, '__esModule', {value: true});
+var flattenHeadersObject_1 = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flattenHeadersObject = void 0;
 
-function flattenHeadersObject(obj) {
-    return reduceHeadersObject_1.reduceHeadersObject(obj, function (headers, name, value) {
+function flattenHeadersObject(headersObject) {
+    return reduceHeadersObject_1.reduceHeadersObject(headersObject, function (headers, name, value) {
         headers[name] = [].concat(value).join('; ');
         return headers;
     }, {});
 }
-var flattenHeadersObject_2 = flattenHeadersObject;
-
-var flattenHeadersObject_1 = /*#__PURE__*/Object.defineProperty({
-	flattenHeadersObject: flattenHeadersObject_2
-}, '__esModule', {value: true});
+exports.flattenHeadersObject = flattenHeadersObject;
+});
 
-var Headers$2 = Headers_1.Headers;
+var lib$1 = createCommonjsModule(function (module, 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;
 
-headersToList_1.headersToList;
+Object.defineProperty(exports, "Headers", { enumerable: true, get: function () { return Headers.default; } });
 
-headersToObject_1.headersToObject;
+Object.defineProperty(exports, "headersToString", { enumerable: true, get: function () { return headersToString_1.headersToString; } });
 
-var stringToHeaders$1 = stringToHeaders_1.stringToHeaders;
+Object.defineProperty(exports, "headersToList", { enumerable: true, get: function () { return headersToList_1.headersToList; } });
 
-var listToHeaders$1 = listToHeaders_1.listToHeaders;
+Object.defineProperty(exports, "headersToObject", { enumerable: true, get: function () { return headersToObject_1.headersToObject; } });
 
-var objectToHeaders$1 = objectToHeaders_1.objectToHeaders;
+Object.defineProperty(exports, "stringToHeaders", { enumerable: true, get: function () { return stringToHeaders_1.stringToHeaders; } });
 
-reduceHeadersObject_1.reduceHeadersObject;
+Object.defineProperty(exports, "listToHeaders", { enumerable: true, get: function () { return listToHeaders_1.listToHeaders; } });
 
-flattenHeadersList_1.flattenHeadersList;
+Object.defineProperty(exports, "objectToHeaders", { enumerable: true, get: function () { return objectToHeaders_1.objectToHeaders; } });
 
-var flattenHeadersObject$1 = flattenHeadersObject_1.flattenHeadersObject;
+Object.defineProperty(exports, "reduceHeadersObject", { enumerable: true, get: function () { return reduceHeadersObject_1.reduceHeadersObject; } });
 
-var StrictEventEmitter_1 = createCommonjsModule(function (module, exports) {
-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) {
-        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;
-};
-exports.__esModule = true;
-exports.StrictEventEmitter = void 0;
+Object.defineProperty(exports, "flattenHeadersList", { enumerable: true, get: function () { return flattenHeadersList_1.flattenHeadersList; } });
 
-var StrictEventEmitter = /** @class */ (function (_super) {
-    __extends(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__default['default'].EventEmitter));
-exports.StrictEventEmitter = StrictEventEmitter;
+Object.defineProperty(exports, "flattenHeadersObject", { enumerable: true, get: function () { return flattenHeadersObject_1.flattenHeadersObject; } });
 });
 
-var lib = createCommonjsModule(function (module, 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;
-
-__createBinding(exports, StrictEventEmitter_1, "StrictEventEmitter");
-});
-
-/**
- * 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.response || result.handler.shouldSkip) {
-            return null;
-        }
-        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,
-    };
-});
-
-/**
- * Parses a given string into a JSON.
- * Does not throw an exception on an invalid JSON string.
- */
-function jsonParse(str) {
-    try {
-        return JSON.parse(str);
-    }
-    catch (error) {
-        return undefined;
-    }
-}
-
 function parseContentHeaders(headersString) {
     var _a, _b;
-    const headers = stringToHeaders$1(headersString);
+    const headers = lib$1.stringToHeaders(headersString);
     const contentType = headers.get('content-type') || 'text/plain';
     const disposition = headers.get('content-disposition');
     if (!disposition) {
@@ -2527,7 +2820,7 @@ function parseMultipartData(data, headers) {
     if (!contentType) {
         return undefined;
     }
-    const [, ...directives] = contentType.split('; ');
+    const [, ...directives] = contentType.split(/; */);
     const boundary = directives
         .filter((d) => d.startsWith('boundary='))
         .map((s) => s.replace(/^boundary=/, ''))[0];
@@ -6063,7 +6356,7 @@ function set(...args) {
             res.headers.append(name, value);
         }
         else {
-            const headers = objectToHeaders$1(name);
+            const headers = lib$1.objectToHeaders(name);
             headers.forEach((value, name) => {
                 res.headers.append(name, value);
             });
@@ -6234,9 +6527,9 @@ const errors = (errorsList) => {
 
 const useFetch = isNodeProcess() ? require('node-fetch') : window.fetch;
 const augmentRequestInit = (requestInit) => {
-    const headers = new Headers$2(requestInit.headers);
+    const headers = new lib$1.Headers(requestInit.headers);
     headers.set('x-msw-bypass', 'true');
-    return Object.assign(Object.assign({}, requestInit), { headers: headers.getAllHeaders() });
+    return Object.assign(Object.assign({}, requestInit), { headers: headers.all() });
 };
 const createFetchRequestParameters = (input) => {
     const { body, method } = input;
@@ -6318,14 +6611,14 @@ function getTimestamp() {
  * Formats a mocked request for introspection in browser's console.
  */
 function prepareRequest(request) {
-    return Object.assign(Object.assign({}, request), { headers: request.headers.getAllHeaders() });
+    return Object.assign(Object.assign({}, request), { headers: request.headers.all() });
 }
 
 /**
  * Formats a mocked response for introspection in browser's console.
  */
 function prepareResponse(res) {
-    const responseHeaders = listToHeaders$1(res.headers);
+    const responseHeaders = lib$1.listToHeaders(res.headers);
     return Object.assign(Object.assign({}, res), { 
         // Parse a response JSON body for preview in the logs
         body: parseBody(res.body, responseHeaders) });
@@ -6472,7 +6765,7 @@ const defaultResponseTransformers = [];
 function createResponseComposition(responseOverrides, defaultTransformers = defaultResponseTransformers) {
     return (...transformers) => __awaiter(this, void 0, void 0, function* () {
         const initialResponse = Object.assign({}, defaultResponse, {
-            headers: new Headers$2({
+            headers: new lib$1.Headers({
                 'x-powered-by': 'msw',
             }),
         }, responseOverrides);
@@ -6497,7 +6790,9 @@ const response = Object.assign(createResponseComposition(), {
  * Return the stack trace frame of a function's invocation.
  */
 function getCallFrame() {
-    const frames = new Error().stack.split('\n');
+    // In <IE11, new Error may return an undefined stack
+    const stack = (new Error().stack || '');
+    const frames = stack.split('\n');
     // Get the first frame that doesn't reference the library's internal trace.
     // Assume that frame is the invocation frame.
     const ignoreFrameRegExp = /(node_modules)?[\/\\]lib[\/\\](umd|esm|iief|cjs)[\/\\]|^[^\/\\]*$/;
@@ -6643,7 +6938,7 @@ ${queryParams
         return matchRequestUrl(request.url, this.info.mask);
     }
     getPublicRequest(request, parsedResult) {
-        return Object.assign(Object.assign({}, request), { params: parsedResult.params });
+        return Object.assign(Object.assign({}, request), { params: parsedResult.params || {} });
     }
     predicate(request, parsedResult) {
         return (isStringEqual(this.info.method, request.method) && parsedResult.matches);
@@ -6872,7 +7167,9 @@ function parseString(setCookieValue, options) {
     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.`,
+      "set-cookie-parser encountered an error while decoding a cookie with value '" +
+        value +
+        "'. Set options.decodeValues to false to disable this feature.",
       e
     );
   }
@@ -7150,8 +7447,14 @@ class CookieStore {
         if (persistedCookies) {
             try {
                 const parsedCookies = JSON.parse(persistedCookies);
-                parsedCookies.forEach(([origin, cookie]) => {
-                    this.store.set(origin, new Map(cookie));
+                parsedCookies.forEach(([origin, cookies]) => {
+                    this.store.set(origin, new Map(cookies.map((_a) => {
+                        var [token, _b] = _a, { expires } = _b, cookie = __rest(_b, ["expires"]);
+                        return [
+                            token,
+                            expires === undefined ? cookie : Object.assign(Object.assign({}, cookie), { expires: new Date(expires) })
+                        ];
+                    })));
                 });
             }
             catch (error) {
@@ -7199,7 +7502,7 @@ Invalid value has been removed from localStorage to prevent subsequent failed pa
 exports.default = new CookieStore();
 });
 
-var lib$1 = createCommonjsModule(function (module, exports) {
+var lib$2 = createCommonjsModule(function (module, exports) {
 var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -7241,16 +7544,16 @@ 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$2.store.hydrate();
+    request.cookies = Object.assign(Object.assign({}, getRequestCookies(request)), Array.from((_a = lib$2.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('; '));
 }
 
 function readResponseCookies(request, response) {
-    lib$1.store.add(Object.assign(Object.assign({}, request), { url: request.url.toString() }), response);
-    lib$1.store.persist();
+    lib$2.store.add(Object.assign(Object.assign({}, request), { url: request.url.toString() }), response);
+    lib$2.store.persist();
 }
 
 const DEFAULT_LISTEN_OPTIONS = {
@@ -7260,48 +7563,34 @@ const DEFAULT_LISTEN_OPTIONS = {
  * Creates a `setupServer` API using given request interceptors.
  * Useful to generate identical API using different patches to request issuing modules.
  */
-function createSetupServer(...interceptors) {
+function createSetupServer(...interceptors$1) {
     const emitter = new lib.StrictEventEmitter();
     return function setupServer(...requestHandlers) {
         requestHandlers.forEach((handler) => {
             if (Array.isArray(handler))
                 throw new Error(`[MSW] Failed to call "setupServer" given an Array of request handlers (setupServer([a, b])), expected to receive each handler individually: setupServer(a, b).`);
         });
-        const interceptor = new nodeRequestInterceptor.RequestInterceptor(interceptors);
         // Error when attempting to run this function in a browser environment.
         if (!isNodeProcess()) {
             throw new Error('[MSW] Failed to execute `setupServer` in the environment that is not Node.js (i.e. a browser). Consider using `setupWorker` instead.');
         }
-        // Store the list of request handlers for the current server instance,
-        // so it could be modified at a runtime.
-        let currentHandlers = [...requestHandlers];
-        interceptor.on('response', (request, response) => {
-            var _a;
-            const requestId = (_a = request.headers) === null || _a === void 0 ? void 0 : _a['x-msw-request-id'];
-            if (response.headers['x-powered-by'] === 'msw') {
-                emitter.emit('response:mocked', response, requestId);
-            }
-            else {
-                emitter.emit('response:bypass', response, requestId);
-            }
-        });
-        return {
-            listen(options) {
-                const resolvedOptions = Object.assign({}, DEFAULT_LISTEN_OPTIONS, options);
-                interceptor.use((request) => __awaiter(this, void 0, void 0, function* () {
+        let resolvedOptions = {};
+        const interceptor = interceptors.createInterceptor({
+            modules: interceptors$1,
+            resolver(request) {
+                return __awaiter(this, void 0, void 0, function* () {
                     const requestId = uuidv4();
-                    const requestHeaders = new Headers$2(flattenHeadersObject$1(request.headers || {}));
                     if (request.headers) {
-                        request.headers['x-msw-request-id'] = requestId;
+                        request.headers.set('x-msw-request-id', requestId);
                     }
-                    const requestCookieString = requestHeaders.get('cookie');
+                    const requestCookieString = request.headers.get('cookie');
                     const mockedRequest = {
                         id: requestId,
                         url: request.url,
                         method: request.method,
                         // Parse the request's body based on the "Content-Type" header.
-                        body: parseBody(request.body, requestHeaders),
-                        headers: requestHeaders,
+                        body: parseBody(request.body, request.headers),
+                        headers: request.headers,
                         cookies: {},
                         redirect: 'manual',
                         referrer: '',
@@ -7331,10 +7620,10 @@ function createSetupServer(...interceptors) {
                     const { response, handler } = yield getResponse(mockedRequest, currentHandlers);
                     if (!handler) {
                         emitter.emit('request:unhandled', mockedRequest);
+                        onUnhandledRequest(mockedRequest, currentHandlers, resolvedOptions.onUnhandledRequest);
                     }
                     if (!response) {
                         emitter.emit('request:end', mockedRequest);
-                        onUnhandledRequest(mockedRequest, currentHandlers, resolvedOptions.onUnhandledRequest);
                         return;
                     }
                     emitter.emit('request:match', mockedRequest);
@@ -7343,19 +7632,40 @@ function createSetupServer(...interceptors) {
                         const mockedResponse = {
                             status: response.status,
                             statusText: response.statusText,
-                            headers: response.headers.getAllHeaders(),
+                            headers: response.headers.all(),
                             body: response.body,
                         };
                         // Store all the received response cookies in the virtual cookie store.
                         readResponseCookies(mockedRequest, response);
-                        // the node build will use the timers module to ensure @sinon/fake-timers or jest fake timers
-                        // don't affect this timeout.
+                        // the node build will use the "timers" module to ensure @sinon/fake-timers
+                        // or jest fake timers don't affect this timeout.
                         setTimeout(() => {
                             resolve(mockedResponse);
                         }, (_a = response.delay) !== null && _a !== void 0 ? _a : 0);
                         emitter.emit('request:end', mockedRequest);
                     });
-                }));
+                });
+            },
+        });
+        // Store the list of request handlers for the current server instance,
+        // so it could be modified at a runtime.
+        let currentHandlers = [...requestHandlers];
+        interceptor.on('response', (request, response) => {
+            const requestId = request.headers.get('x-msw-request-id');
+            if (!requestId) {
+                return;
+            }
+            if (response.headers.get('x-powered-by') === 'msw') {
+                emitter.emit('response:mocked', response, requestId);
+            }
+            else {
+                emitter.emit('response:bypass', response, requestId);
+            }
+        });
+        return {
+            listen(options) {
+                resolvedOptions = Object.assign({}, DEFAULT_LISTEN_OPTIONS, options);
+                interceptor.apply();
             },
             use(...handlers) {
                 use(currentHandlers, ...handlers);