msw 0.27.2 → 0.29.0

package/lib/esm/fetch-deps.js

@@ -80,113 +80,360 @@ const status = (statusCode, statusText) => {
     };
 };
 
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+var lib = {};
+
+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;
-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();
+}
+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 = (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$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;
+};
+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.");
+};
+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;
-        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$3(_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$3(_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;
+Headers.default = HeadersPolyfill;
+
+var headersToString$1 = {};
 
-var Headers_1 = /*#__PURE__*/Object.defineProperty({
-	Headers: Headers_2
-}, '__esModule', {value: true});
+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 (v) { return v.trim(); })
+            ? value.split(',').map(function (value) { return value.trim(); })
             : value;
         headersList.push([name, resolvedValue]);
     });
     return headersList;
 }
-var headersToList_2 = headersToList;
+headersToList$1.headersToList = headersToList;
+
+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(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$2(_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 headersToList_1 = /*#__PURE__*/Object.defineProperty({
-	headersToList: headersToList_2
-}, '__esModule', {value: true});
+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'];
@@ -204,12 +451,13 @@ function headersToObject(headers) {
     });
     return headersObject;
 }
-var headersToObject_2 = headersToObject;
+headersToObject$1.headersToObject = headersToObject;
 
-var headersToObject_1 = /*#__PURE__*/Object.defineProperty({
-	headersToObject: headersToObject_2
-}, '__esModule', {value: true});
+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.
@@ -222,18 +470,35 @@ function stringToHeaders(str) {
         var value = parts.join(': ');
         headers.append(name, value);
         return headers;
-    }, new Headers());
+    }, new Headers_1$2.default());
 }
-var stringToHeaders_2 = stringToHeaders;
+stringToHeaders$1.stringToHeaders = stringToHeaders;
 
-var stringToHeaders_1 = /*#__PURE__*/Object.defineProperty({
-	stringToHeaders: stringToHeaders_2
-}, '__esModule', {value: true});
+var listToHeaders$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(listToHeaders$1, "__esModule", { value: true });
+listToHeaders$1.listToHeaders = void 0;
+var Headers_1$1 = Headers;
 function listToHeaders(list) {
-    var headers = new Headers();
+    var headers = new Headers_1$1.default();
     list.forEach(function (_a) {
-        var name = _a[0], value = _a[1];
+        var _b = __read$1(_a, 2), name = _b[0], value = _b[1];
         var values = [].concat(value);
         values.forEach(function (value) {
             headers.append(name, value);
@@ -241,12 +506,14 @@ function listToHeaders(list) {
     });
     return headers;
 }
-var listToHeaders_2 = listToHeaders;
+listToHeaders$1.listToHeaders = listToHeaders;
+
+var objectToHeaders$1 = {};
 
-var listToHeaders_1 = /*#__PURE__*/Object.defineProperty({
-	listToHeaders: listToHeaders_2
-}, '__esModule', {value: true});
+var reduceHeadersObject$1 = {};
 
+Object.defineProperty(reduceHeadersObject$1, "__esModule", { value: true });
+reduceHeadersObject$1.reduceHeadersObject = void 0;
 /**
  * Reduces given headers object instnace.
  */
@@ -255,71 +522,91 @@ function reduceHeadersObject(headers, reducer, initialState) {
         return reducer(nextHeaders, name, headers[name]);
     }, initialState);
 }
-var reduceHeadersObject_2 = reduceHeadersObject;
-
-var reduceHeadersObject_1 = /*#__PURE__*/Object.defineProperty({
-	reduceHeadersObject: reduceHeadersObject_2
-}, '__esModule', {value: true});
+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(obj) {
-    return reduceHeadersObject_1.reduceHeadersObject(obj, function (headers, name, value) {
-        var values = [].concat(value);
+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());
+    }, new Headers_1.default());
 }
-var objectToHeaders_2 = objectToHeaders;
+objectToHeaders$1.objectToHeaders = objectToHeaders;
 
-var objectToHeaders_1 = /*#__PURE__*/Object.defineProperty({
-	objectToHeaders: objectToHeaders_2
-}, '__esModule', {value: true});
+var flattenHeadersList$1 = {};
 
+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(flattenHeadersList$1, "__esModule", { value: true });
+flattenHeadersList$1.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;
+flattenHeadersList$1.flattenHeadersList = flattenHeadersList;
 
-var flattenHeadersList_1 = /*#__PURE__*/Object.defineProperty({
-	flattenHeadersList: flattenHeadersList_2
-}, '__esModule', {value: true});
+var flattenHeadersObject$1 = {};
 
-function flattenHeadersObject(obj) {
-    return reduceHeadersObject_1.reduceHeadersObject(obj, function (headers, name, value) {
+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;
     }, {});
 }
-var flattenHeadersObject_2 = flattenHeadersObject;
-
-var flattenHeadersObject_1 = /*#__PURE__*/Object.defineProperty({
-	flattenHeadersObject: flattenHeadersObject_2
-}, '__esModule', {value: true});
-
-var Headers$2 = Headers_1.Headers;
-
-var headersToList$1 = headersToList_1.headersToList;
-
-headersToObject_1.headersToObject;
-
-var stringToHeaders$1 = stringToHeaders_1.stringToHeaders;
-
-var listToHeaders$1 = listToHeaders_1.listToHeaders;
-
-var objectToHeaders$1 = objectToHeaders_1.objectToHeaders;
-
-reduceHeadersObject_1.reduceHeadersObject;
-
-flattenHeadersList_1.flattenHeadersList;
-
-flattenHeadersObject_1.flattenHeadersObject;
+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));
 
 /**
  * Sets one or multiple response headers.
@@ -332,7 +619,7 @@ function set(...args) {
             res.headers.append(name, value);
         }
         else {
-            const headers = objectToHeaders$1(name);
+            const headers = lib.objectToHeaders(name);
             headers.forEach((value, name) => {
                 res.headers.append(name, value);
             });
@@ -446,9 +733,9 @@ const delay = (durationOrMode) => {
 
 const useFetch = isNodeProcess() ? require('node-fetch') : window.fetch;
 const augmentRequestInit = (requestInit) => {
-    const headers = new Headers$2(requestInit.headers);
+    const headers = new lib.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;
@@ -475,4 +762,4 @@ const fetch = (input, requestInit = {}) => {
     return useFetch(input.url.href, derivedRequestInit);
 };
 
-export { Headers$2 as H, set as a, json as b, stringToHeaders$1 as c, delay as d, fetch as f, headersToList$1 as h, isNodeProcess as i, jsonParse as j, listToHeaders$1 as l, status as s };
+export { set as a, json as b, commonjsGlobal as c, delay as d, fetch as f, isNodeProcess as i, jsonParse as j, lib as l, status as s };