msw 0.39.1 → 0.40.1

package/node/lib/index.js

@@ -1938,7 +1938,7 @@ chalk.stderr.supportsColor = stderrColor;
 
 var source = chalk;
 
-var lib$3 = {exports: {}};
+var lib$4 = {exports: {}};
 
 (function (module, exports) {
 (function (global, factory) {
@@ -1961,9 +1961,9 @@ var lib$3 = {exports: {}};
   Object.defineProperty(exports, '__esModule', { value: true });
 
 })));
-}(lib$3, lib$3.exports));
+}(lib$4, lib$4.exports));
 
-var lib$2 = {};
+var lib$3 = {};
 
 var StrictEventEmitter$1 = {};
 
@@ -2033,7 +2033,7 @@ exports.__esModule = true;
 exports.StrictEventEmitter = void 0;
 var StrictEventEmitter_1 = StrictEventEmitter$1;
 __createBinding(exports, StrictEventEmitter_1, "StrictEventEmitter");
-}(lib$2));
+}(lib$3));
 
 function use(currentHandlers, ...handlers) {
     currentHandlers.unshift(...handlers);
@@ -2047,221 +2047,7 @@ function resetHandlers(initialHandlers, ...nextHandlers) {
     return nextHandlers.length > 0 ? [...nextHandlers] : [...initialHandlers];
 }
 
-/*!
- * cookie
- * Copyright(c) 2012-2014 Roman Shtylman
- * Copyright(c) 2015 Douglas Christopher Wilson
- * MIT Licensed
- */
-
-/**
- * Module exports.
- * @public
- */
-
-var parse_1 = parse$2;
-var serialize_1 = serialize;
-
-/**
- * Module variables.
- * @private
- */
-
-var decode = decodeURIComponent;
-var encode = encodeURIComponent;
-
-/**
- * RegExp to match field-content in RFC 7230 sec 3.2
- *
- * field-content = field-vchar [ 1*( SP / HTAB ) field-vchar ]
- * field-vchar   = VCHAR / obs-text
- * obs-text      = %x80-FF
- */
-
-var fieldContentRegExp = /^[\u0009\u0020-\u007e\u0080-\u00ff]+$/;
-
-/**
- * Parse a cookie header.
- *
- * Parse the given cookie header string into an object
- * The object has the various cookies as keys(names) => values
- *
- * @param {string} str
- * @param {object} [options]
- * @return {object}
- * @public
- */
-
-function parse$2(str, options) {
-  if (typeof str !== 'string') {
-    throw new TypeError('argument str must be a string');
-  }
-
-  var obj = {};
-  var opt = options || {};
-  var pairs = str.split(';');
-  var dec = opt.decode || decode;
-
-  for (var i = 0; i < pairs.length; i++) {
-    var pair = pairs[i];
-    var index = pair.indexOf('=');
-
-    // skip things that don't look like key=value
-    if (index < 0) {
-      continue;
-    }
-
-    var key = pair.substring(0, index).trim();
-
-    // only assign once
-    if (undefined == obj[key]) {
-      var val = pair.substring(index + 1, pair.length).trim();
-
-      // quoted values
-      if (val[0] === '"') {
-        val = val.slice(1, -1);
-      }
-
-      obj[key] = tryDecode(val, dec);
-    }
-  }
-
-  return obj;
-}
-
-/**
- * Serialize data into a cookie header.
- *
- * Serialize the a name value pair into a cookie string suitable for
- * http headers. An optional options object specified cookie parameters.
- *
- * serialize('foo', 'bar', { httpOnly: true })
- *   => "foo=bar; httpOnly"
- *
- * @param {string} name
- * @param {string} val
- * @param {object} [options]
- * @return {string}
- * @public
- */
-
-function serialize(name, val, options) {
-  var opt = options || {};
-  var enc = opt.encode || encode;
-
-  if (typeof enc !== 'function') {
-    throw new TypeError('option encode is invalid');
-  }
-
-  if (!fieldContentRegExp.test(name)) {
-    throw new TypeError('argument name is invalid');
-  }
-
-  var value = enc(val);
-
-  if (value && !fieldContentRegExp.test(value)) {
-    throw new TypeError('argument val is invalid');
-  }
-
-  var str = name + '=' + value;
-
-  if (null != opt.maxAge) {
-    var maxAge = opt.maxAge - 0;
-
-    if (isNaN(maxAge) || !isFinite(maxAge)) {
-      throw new TypeError('option maxAge is invalid')
-    }
-
-    str += '; Max-Age=' + Math.floor(maxAge);
-  }
-
-  if (opt.domain) {
-    if (!fieldContentRegExp.test(opt.domain)) {
-      throw new TypeError('option domain is invalid');
-    }
-
-    str += '; Domain=' + opt.domain;
-  }
-
-  if (opt.path) {
-    if (!fieldContentRegExp.test(opt.path)) {
-      throw new TypeError('option path is invalid');
-    }
-
-    str += '; Path=' + opt.path;
-  }
-
-  if (opt.expires) {
-    if (typeof opt.expires.toUTCString !== 'function') {
-      throw new TypeError('option expires is invalid');
-    }
-
-    str += '; Expires=' + opt.expires.toUTCString();
-  }
-
-  if (opt.httpOnly) {
-    str += '; HttpOnly';
-  }
-
-  if (opt.secure) {
-    str += '; Secure';
-  }
-
-  if (opt.sameSite) {
-    var sameSite = typeof opt.sameSite === 'string'
-      ? opt.sameSite.toLowerCase() : opt.sameSite;
-
-    switch (sameSite) {
-      case true:
-        str += '; SameSite=Strict';
-        break;
-      case 'lax':
-        str += '; SameSite=Lax';
-        break;
-      case 'strict':
-        str += '; SameSite=Strict';
-        break;
-      case 'none':
-        str += '; SameSite=None';
-        break;
-      default:
-        throw new TypeError('option sameSite is invalid');
-    }
-  }
-
-  return str;
-}
-
-/**
- * Try decoding a string using a decoding function.
- *
- * @param {string} str
- * @param {function} decode
- * @private
- */
-
-function tryDecode(str, decode) {
-  try {
-    return decode(str);
-  } catch (e) {
-    return str;
-  }
-}
-
-/**
- * Parses a given value into a JSON.
- * Does not throw an exception on an invalid JSON string.
- */
-function jsonParse(value) {
-    try {
-        return JSON.parse(value);
-    }
-    catch (error) {
-        return undefined;
-    }
-}
-
-var lib$1 = {};
+var lib$2 = {};
 
 var Headers = {};
 
@@ -2788,46 +2574,457 @@ 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));
+}(lib$2));
 
-function parseContentHeaders(headersString) {
-    var _a, _b;
-    const headers = lib$1.stringToHeaders(headersString);
-    const contentType = headers.get('content-type') || 'text/plain';
-    const disposition = headers.get('content-disposition');
-    if (!disposition) {
-        throw new Error('"Content-Disposition" header is required.');
-    }
-    const directives = disposition.split(';').reduce((acc, chunk) => {
-        const [name, ...rest] = chunk.trim().split('=');
-        acc[name] = rest.join('=');
-        return acc;
-    }, {});
-    const name = (_a = directives.name) === null || _a === void 0 ? void 0 : _a.slice(1, -1);
-    const filename = (_b = directives.filename) === null || _b === void 0 ? void 0 : _b.slice(1, -1);
-    return {
-        name,
-        filename,
-        contentType,
-    };
-}
 /**
- * Parses a given string as a multipart/form-data.
- * Does not throw an exception on an invalid multipart string.
+ * Composes a given list of functions into a new function that
+ * executes from right to left.
  */
-function parseMultipartData(data, headers) {
-    const contentType = headers === null || headers === void 0 ? void 0 : headers.get('content-type');
-    if (!contentType) {
-        return undefined;
-    }
-    const [, ...directives] = contentType.split(/; */);
-    const boundary = directives
-        .filter((d) => d.startsWith('boundary='))
-        .map((s) => s.replace(/^boundary=/, ''))[0];
-    if (!boundary) {
-        return undefined;
-    }
-    const boundaryRegExp = new RegExp(`--+${boundary}`);
+function compose(...fns) {
+    return (...args) => {
+        return fns.reduceRight((leftFn, rightFn) => {
+            return leftFn instanceof Promise
+                ? Promise.resolve(leftFn).then(rightFn)
+                : rightFn(leftFn);
+        }, args[0]);
+    };
+}
+
+class NetworkError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'NetworkError';
+    }
+}
+
+const defaultResponse = {
+    status: 200,
+    statusText: 'OK',
+    body: null,
+    delay: 0,
+    once: false,
+    passthrough: false,
+};
+const defaultResponseTransformers = [];
+function createResponseComposition(responseOverrides, defaultTransformers = defaultResponseTransformers) {
+    return (...transformers) => __awaiter(this, void 0, void 0, function* () {
+        const initialResponse = Object.assign({}, defaultResponse, {
+            headers: new lib$2.Headers({
+                'x-powered-by': 'msw',
+            }),
+        }, responseOverrides);
+        const resolvedTransformers = [
+            ...defaultTransformers,
+            ...transformers,
+        ].filter(Boolean);
+        const resolvedResponse = resolvedTransformers.length > 0
+            ? compose(...resolvedTransformers)(initialResponse)
+            : initialResponse;
+        return resolvedResponse;
+    });
+}
+const response = Object.assign(createResponseComposition(), {
+    once: createResponseComposition({ once: true }),
+    networkError(message) {
+        throw new NetworkError(message);
+    },
+});
+
+const BUILD_FRAME = /(node_modules)?[\/\\]lib[\/\\](umd|esm|iief|cjs)[\/\\]|^[^\/\\]*$/;
+/**
+ * Return the stack trace frame of a function's invocation.
+ */
+function getCallFrame(error) {
+    // In <IE11, new Error may return an undefined stack
+    const stack = error.stack;
+    if (!stack) {
+        return;
+    }
+    const frames = stack.split('\n').slice(1);
+    // Get the first frame that doesn't reference the library's internal trace.
+    // Assume that frame is the invocation frame.
+    const declarationFrame = frames.find((frame) => {
+        return !BUILD_FRAME.test(frame);
+    });
+    if (!declarationFrame) {
+        return;
+    }
+    // Extract file reference from the stack frame.
+    const declarationPath = declarationFrame
+        .replace(/\s*at [^()]*\(([^)]+)\)/, '$1')
+        .replace(/^@/, '');
+    return declarationPath;
+}
+
+/**
+ * Determines if the given function is an iterator.
+ */
+function isIterable(fn) {
+    if (!fn) {
+        return false;
+    }
+    return typeof fn[Symbol.iterator] == 'function';
+}
+
+var statuses = {
+	"100": "Continue",
+	"101": "Switching Protocols",
+	"102": "Processing",
+	"103": "Early Hints",
+	"200": "OK",
+	"201": "Created",
+	"202": "Accepted",
+	"203": "Non-Authoritative Information",
+	"204": "No Content",
+	"205": "Reset Content",
+	"206": "Partial Content",
+	"207": "Multi-Status",
+	"208": "Already Reported",
+	"226": "IM Used",
+	"300": "Multiple Choices",
+	"301": "Moved Permanently",
+	"302": "Found",
+	"303": "See Other",
+	"304": "Not Modified",
+	"305": "Use Proxy",
+	"307": "Temporary Redirect",
+	"308": "Permanent Redirect",
+	"400": "Bad Request",
+	"401": "Unauthorized",
+	"402": "Payment Required",
+	"403": "Forbidden",
+	"404": "Not Found",
+	"405": "Method Not Allowed",
+	"406": "Not Acceptable",
+	"407": "Proxy Authentication Required",
+	"408": "Request Timeout",
+	"409": "Conflict",
+	"410": "Gone",
+	"411": "Length Required",
+	"412": "Precondition Failed",
+	"413": "Payload Too Large",
+	"414": "URI Too Long",
+	"415": "Unsupported Media Type",
+	"416": "Range Not Satisfiable",
+	"417": "Expectation Failed",
+	"418": "I'm a Teapot",
+	"421": "Misdirected Request",
+	"422": "Unprocessable Entity",
+	"423": "Locked",
+	"424": "Failed Dependency",
+	"425": "Too Early",
+	"426": "Upgrade Required",
+	"428": "Precondition Required",
+	"429": "Too Many Requests",
+	"431": "Request Header Fields Too Large",
+	"451": "Unavailable For Legal Reasons",
+	"500": "Internal Server Error",
+	"501": "Not Implemented",
+	"502": "Bad Gateway",
+	"503": "Service Unavailable",
+	"504": "Gateway Timeout",
+	"505": "HTTP Version Not Supported",
+	"506": "Variant Also Negotiates",
+	"507": "Insufficient Storage",
+	"508": "Loop Detected",
+	"509": "Bandwidth Limit Exceeded",
+	"510": "Not Extended",
+	"511": "Network Authentication Required"
+};
+
+/**
+ * Sets a response status code and text.
+ * @example
+ * res(ctx.status(301))
+ * res(ctx.status(400, 'Custom status text'))
+ * @see {@link https://mswjs.io/docs/api/context/status `ctx.status()`}
+ */
+const status = (statusCode, statusText) => {
+    return (res) => {
+        res.status = statusCode;
+        res.statusText =
+            statusText || statuses[String(statusCode)];
+        return res;
+    };
+};
+
+/**
+ * Sets one or multiple response headers.
+ * @example
+ * ctx.set('Content-Type', 'text/plain')
+ * ctx.set({
+ *   'Accept': 'application/javascript',
+ *   'Content-Type': "text/plain"
+ * })
+ * @see {@link https://mswjs.io/docs/api/context/set `ctx.set()`}
+ */
+function set(...args) {
+    return (res) => {
+        const [name, value] = args;
+        if (typeof name === 'string') {
+            res.headers.append(name, value);
+        }
+        else {
+            const headers = lib$2.objectToHeaders(name);
+            headers.forEach((value, name) => {
+                res.headers.append(name, value);
+            });
+        }
+        return res;
+    };
+}
+
+const SET_TIMEOUT_MAX_ALLOWED_INT = 2147483647;
+const MIN_SERVER_RESPONSE_TIME = 100;
+const MAX_SERVER_RESPONSE_TIME = 400;
+const NODE_SERVER_RESPONSE_TIME = 5;
+const getRandomServerResponseTime = () => {
+    if (lib$4.exports.isNodeProcess()) {
+        return NODE_SERVER_RESPONSE_TIME;
+    }
+    return Math.floor(Math.random() * (MAX_SERVER_RESPONSE_TIME - MIN_SERVER_RESPONSE_TIME) +
+        MIN_SERVER_RESPONSE_TIME);
+};
+/**
+ * Delays the response by the given duration (ms).
+ * @example
+ * res(ctx.delay(1200)) // delay response by 1200ms
+ * res(ctx.delay()) // emulate realistic server response time
+ * res(ctx.delay('infinite')) // delay response infinitely
+ * @see {@link https://mswjs.io/docs/api/context/delay `ctx.delay()`}
+ */
+const delay = (durationOrMode) => {
+    return (res) => {
+        let delayTime;
+        if (typeof durationOrMode === 'string') {
+            switch (durationOrMode) {
+                case 'infinite': {
+                    // Using `Infinity` as a delay value executes the response timeout immediately.
+                    // Instead, use the maximum allowed integer for `setTimeout`.
+                    delayTime = SET_TIMEOUT_MAX_ALLOWED_INT;
+                    break;
+                }
+                case 'real': {
+                    delayTime = getRandomServerResponseTime();
+                    break;
+                }
+                default: {
+                    throw new Error(`Failed to delay a response: unknown delay mode "${durationOrMode}". Please make sure you provide one of the supported modes ("real", "infinite") or a number to "ctx.delay".`);
+                }
+            }
+        }
+        else if (typeof durationOrMode === 'undefined') {
+            // Use random realistic server response time when no explicit delay duration was provided.
+            delayTime = getRandomServerResponseTime();
+        }
+        else {
+            // Guard against passing values like `Infinity` or `Number.MAX_VALUE`
+            // as the response delay duration. They don't produce the result you may expect.
+            if (durationOrMode > SET_TIMEOUT_MAX_ALLOWED_INT) {
+                throw new Error(`Failed to delay a response: provided delay duration (${durationOrMode}) exceeds the maximum allowed duration for "setTimeout" (${SET_TIMEOUT_MAX_ALLOWED_INT}). This will cause the response to be returned immediately. Please use a number within the allowed range to delay the response by exact duration, or consider the "infinite" delay mode to delay the response indefinitely.`);
+            }
+            delayTime = durationOrMode;
+        }
+        res.delay = delayTime;
+        return res;
+    };
+};
+
+const useFetch = lib$4.exports.isNodeProcess() ? require('node-fetch') : window.fetch;
+const augmentRequestInit = (requestInit) => {
+    const headers = new lib$2.Headers(requestInit.headers);
+    headers.set('x-msw-bypass', 'true');
+    return Object.assign(Object.assign({}, requestInit), { headers: headers.all() });
+};
+const createFetchRequestParameters = (input) => {
+    const { body, method } = input;
+    const requestParameters = Object.assign(Object.assign({}, input), { body: undefined });
+    if (['GET', 'HEAD'].includes(method)) {
+        return requestParameters;
+    }
+    if (typeof body === 'object' ||
+        typeof body === 'number' ||
+        typeof body === 'boolean') {
+        requestParameters.body = JSON.stringify(body);
+    }
+    else {
+        requestParameters.body = body;
+    }
+    return requestParameters;
+};
+/**
+ * Performs a bypassed request inside a request handler.
+ * @example
+ * const originalResponse = await ctx.fetch(req)
+ * @see {@link https://mswjs.io/docs/api/context/fetch `ctx.fetch()`}
+ */
+const fetch = (input, requestInit = {}) => {
+    if (typeof input === 'string') {
+        return useFetch(input, augmentRequestInit(requestInit));
+    }
+    const requestParameters = createFetchRequestParameters(input);
+    const derivedRequestInit = augmentRequestInit(requestParameters);
+    return useFetch(input.url.href, derivedRequestInit);
+};
+
+const defaultContext = {
+    status,
+    set,
+    delay,
+    fetch,
+};
+class RequestHandler {
+    constructor(options) {
+        this.shouldSkip = false;
+        this.ctx = options.ctx || defaultContext;
+        this.resolver = options.resolver;
+        const callFrame = getCallFrame(new Error());
+        this.info = Object.assign(Object.assign({}, options.info), { callFrame });
+    }
+    /**
+     * Parse the captured request to extract additional information from it.
+     * Parsed result is then exposed to other methods of this request handler.
+     */
+    parse(_request, _resolutionContext) {
+        return null;
+    }
+    /**
+     * Test if this handler matches the given request.
+     */
+    test(request, resolutionContext) {
+        return this.predicate(request, this.parse(request, resolutionContext), resolutionContext);
+    }
+    /**
+     * Derive the publicly exposed request (`req`) instance of the response resolver
+     * from the captured request and its parsed result.
+     */
+    getPublicRequest(request, _parsedResult) {
+        return request;
+    }
+    markAsSkipped(shouldSkip = true) {
+        this.shouldSkip = shouldSkip;
+    }
+    /**
+     * Execute this request handler and produce a mocked response
+     * using the given resolver function.
+     */
+    run(request, resolutionContext) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.shouldSkip) {
+                return null;
+            }
+            const parsedResult = this.parse(request, resolutionContext);
+            const shouldIntercept = this.predicate(request, parsedResult, resolutionContext);
+            if (!shouldIntercept) {
+                return null;
+            }
+            const publicRequest = this.getPublicRequest(request, parsedResult);
+            // Create a response extraction wrapper around the resolver
+            // since it can be both an async function and a generator.
+            const executeResolver = this.wrapResolver(this.resolver);
+            const mockedResponse = yield executeResolver(publicRequest, response, this.ctx);
+            return this.createExecutionResult(parsedResult, publicRequest, mockedResponse);
+        });
+    }
+    wrapResolver(resolver) {
+        return (req, res, ctx) => __awaiter(this, void 0, void 0, function* () {
+            const result = this.resolverGenerator || (yield resolver(req, res, ctx));
+            if (isIterable(result)) {
+                const { value, done } = result[Symbol.iterator]().next();
+                const nextResponse = yield value;
+                // If the generator is done and there is no next value,
+                // return the previous generator's value.
+                if (!nextResponse && done) {
+                    return this.resolverGeneratorResult;
+                }
+                if (!this.resolverGenerator) {
+                    this.resolverGenerator = result;
+                }
+                this.resolverGeneratorResult = nextResponse;
+                return nextResponse;
+            }
+            return result;
+        });
+    }
+    createExecutionResult(parsedResult, request, response) {
+        return {
+            handler: this,
+            parsedResult: parsedResult || null,
+            request,
+            response: response || null,
+        };
+    }
+}
+/**
+ * Bypass this intercepted request.
+ * This will make a call to the actual endpoint requested.
+ */
+function passthrough() {
+    // Constructing a dummy "101 Continue" mocked response
+    // to keep the return type of the resolver consistent.
+    return {
+        status: 101,
+        statusText: 'Continue',
+        headers: new lib$2.Headers(),
+        body: null,
+        // Setting "passthrough" to true will signal the response pipeline
+        // to perform this intercepted request as-is.
+        passthrough: true,
+        once: false,
+    };
+}
+
+/**
+ * Parses a given value into a JSON.
+ * Does not throw an exception on an invalid JSON string.
+ */
+function jsonParse(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch (error) {
+        return undefined;
+    }
+}
+
+function parseContentHeaders(headersString) {
+    var _a, _b;
+    const headers = lib$2.stringToHeaders(headersString);
+    const contentType = headers.get('content-type') || 'text/plain';
+    const disposition = headers.get('content-disposition');
+    if (!disposition) {
+        throw new Error('"Content-Disposition" header is required.');
+    }
+    const directives = disposition.split(';').reduce((acc, chunk) => {
+        const [name, ...rest] = chunk.trim().split('=');
+        acc[name] = rest.join('=');
+        return acc;
+    }, {});
+    const name = (_a = directives.name) === null || _a === void 0 ? void 0 : _a.slice(1, -1);
+    const filename = (_b = directives.filename) === null || _b === void 0 ? void 0 : _b.slice(1, -1);
+    return {
+        name,
+        filename,
+        contentType,
+    };
+}
+/**
+ * Parses a given string as a multipart/form-data.
+ * Does not throw an exception on an invalid multipart string.
+ */
+function parseMultipartData(data, headers) {
+    const contentType = headers === null || headers === void 0 ? void 0 : headers.get('content-type');
+    if (!contentType) {
+        return undefined;
+    }
+    const [, ...directives] = contentType.split(/; */);
+    const boundary = directives
+        .filter((d) => d.startsWith('boundary='))
+        .map((s) => s.replace(/^boundary=/, ''))[0];
+    if (!boundary) {
+        return undefined;
+    }
+    const boundaryRegExp = new RegExp(`--+${boundary}`);
     const fields = data
         .split(boundaryRegExp)
         .filter((chunk) => chunk.startsWith('\r\n') && chunk.endsWith('\r\n'))
@@ -2862,30 +3059,231 @@ function parseMultipartData(data, headers) {
     }
 }
 
-/**
- * Parses a given request/response body based on the "Content-Type" header.
- */
-function parseBody(body, headers) {
-    var _a;
-    // Return whatever falsey body value is given.
-    if (!body) {
-        return body;
-    }
-    const contentType = ((_a = headers === null || headers === void 0 ? void 0 : headers.get('content-type')) === null || _a === void 0 ? void 0 : _a.toLowerCase()) || '';
-    // If the body has a Multipart Content-Type
-    // parse it into an object.
-    const hasMultipartContent = contentType.startsWith('multipart/form-data');
-    if (hasMultipartContent && typeof body !== 'object') {
-        return parseMultipartData(body.toString(), headers) || body;
-    }
-    // If the intercepted request's body has a JSON Content-Type
-    // parse it into an object.
-    const hasJsonContent = contentType.includes('json');
-    if (hasJsonContent && typeof body !== 'object') {
-        return jsonParse(body.toString()) || body;
-    }
-    // Otherwise leave as-is.
-    return body;
+/**
+ * Parses a given request/response body based on the "Content-Type" header.
+ */
+function parseBody(body, headers) {
+    var _a;
+    // Return whatever falsey body value is given.
+    if (!body) {
+        return body;
+    }
+    const contentType = ((_a = headers === null || headers === void 0 ? void 0 : headers.get('content-type')) === null || _a === void 0 ? void 0 : _a.toLowerCase()) || '';
+    // If the body has a Multipart Content-Type
+    // parse it into an object.
+    const hasMultipartContent = contentType.startsWith('multipart/form-data');
+    if (hasMultipartContent && typeof body !== 'object') {
+        return parseMultipartData(body.toString(), headers) || body;
+    }
+    // If the intercepted request's body has a JSON Content-Type
+    // parse it into an object.
+    const hasJsonContent = contentType.includes('json');
+    if (hasJsonContent && typeof body !== 'object') {
+        return jsonParse(body.toString()) || body;
+    }
+    // Otherwise leave as-is.
+    return body;
+}
+
+/*!
+ * cookie
+ * Copyright(c) 2012-2014 Roman Shtylman
+ * Copyright(c) 2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/**
+ * Module exports.
+ * @public
+ */
+
+var parse_1 = parse$2;
+var serialize_1 = serialize;
+
+/**
+ * Module variables.
+ * @private
+ */
+
+var decode = decodeURIComponent;
+var encode = encodeURIComponent;
+
+/**
+ * RegExp to match field-content in RFC 7230 sec 3.2
+ *
+ * field-content = field-vchar [ 1*( SP / HTAB ) field-vchar ]
+ * field-vchar   = VCHAR / obs-text
+ * obs-text      = %x80-FF
+ */
+
+var fieldContentRegExp = /^[\u0009\u0020-\u007e\u0080-\u00ff]+$/;
+
+/**
+ * Parse a cookie header.
+ *
+ * Parse the given cookie header string into an object
+ * The object has the various cookies as keys(names) => values
+ *
+ * @param {string} str
+ * @param {object} [options]
+ * @return {object}
+ * @public
+ */
+
+function parse$2(str, options) {
+  if (typeof str !== 'string') {
+    throw new TypeError('argument str must be a string');
+  }
+
+  var obj = {};
+  var opt = options || {};
+  var pairs = str.split(';');
+  var dec = opt.decode || decode;
+
+  for (var i = 0; i < pairs.length; i++) {
+    var pair = pairs[i];
+    var index = pair.indexOf('=');
+
+    // skip things that don't look like key=value
+    if (index < 0) {
+      continue;
+    }
+
+    var key = pair.substring(0, index).trim();
+
+    // only assign once
+    if (undefined == obj[key]) {
+      var val = pair.substring(index + 1, pair.length).trim();
+
+      // quoted values
+      if (val[0] === '"') {
+        val = val.slice(1, -1);
+      }
+
+      obj[key] = tryDecode(val, dec);
+    }
+  }
+
+  return obj;
+}
+
+/**
+ * Serialize data into a cookie header.
+ *
+ * Serialize the a name value pair into a cookie string suitable for
+ * http headers. An optional options object specified cookie parameters.
+ *
+ * serialize('foo', 'bar', { httpOnly: true })
+ *   => "foo=bar; httpOnly"
+ *
+ * @param {string} name
+ * @param {string} val
+ * @param {object} [options]
+ * @return {string}
+ * @public
+ */
+
+function serialize(name, val, options) {
+  var opt = options || {};
+  var enc = opt.encode || encode;
+
+  if (typeof enc !== 'function') {
+    throw new TypeError('option encode is invalid');
+  }
+
+  if (!fieldContentRegExp.test(name)) {
+    throw new TypeError('argument name is invalid');
+  }
+
+  var value = enc(val);
+
+  if (value && !fieldContentRegExp.test(value)) {
+    throw new TypeError('argument val is invalid');
+  }
+
+  var str = name + '=' + value;
+
+  if (null != opt.maxAge) {
+    var maxAge = opt.maxAge - 0;
+
+    if (isNaN(maxAge) || !isFinite(maxAge)) {
+      throw new TypeError('option maxAge is invalid')
+    }
+
+    str += '; Max-Age=' + Math.floor(maxAge);
+  }
+
+  if (opt.domain) {
+    if (!fieldContentRegExp.test(opt.domain)) {
+      throw new TypeError('option domain is invalid');
+    }
+
+    str += '; Domain=' + opt.domain;
+  }
+
+  if (opt.path) {
+    if (!fieldContentRegExp.test(opt.path)) {
+      throw new TypeError('option path is invalid');
+    }
+
+    str += '; Path=' + opt.path;
+  }
+
+  if (opt.expires) {
+    if (typeof opt.expires.toUTCString !== 'function') {
+      throw new TypeError('option expires is invalid');
+    }
+
+    str += '; Expires=' + opt.expires.toUTCString();
+  }
+
+  if (opt.httpOnly) {
+    str += '; HttpOnly';
+  }
+
+  if (opt.secure) {
+    str += '; Secure';
+  }
+
+  if (opt.sameSite) {
+    var sameSite = typeof opt.sameSite === 'string'
+      ? opt.sameSite.toLowerCase() : opt.sameSite;
+
+    switch (sameSite) {
+      case true:
+        str += '; SameSite=Strict';
+        break;
+      case 'lax':
+        str += '; SameSite=Lax';
+        break;
+      case 'strict':
+        str += '; SameSite=Strict';
+        break;
+      case 'none':
+        str += '; SameSite=None';
+        break;
+      default:
+        throw new TypeError('option sameSite is invalid');
+    }
+  }
+
+  return str;
+}
+
+/**
+ * Try decoding a string using a decoding function.
+ *
+ * @param {string} str
+ * @param {function} decode
+ * @private
+ */
+
+function tryDecode(str, decode) {
+  try {
+    return decode(str);
+  } catch (e) {
+    return str;
+  }
 }
 
 function getAllCookies() {
@@ -2917,13 +3315,36 @@ function getRequestCookies(request) {
     }
 }
 
+/**
+ * Sets relevant cookies on the request.
+ * Request cookies are taken from the following sources:
+ * - Immediate (own) request cookies (those in the "Cookie" request header);
+ * - From the `document.cookie` based on the request's `credentials` value;
+ * - From the internal cookie store that persists/hydrates cookies in Node.js
+ */
 function setRequestCookies(request) {
     var _a;
+    // Set mocked request cookies from the `cookie` header of the original request.
+    // No need to take `credentials` into account, because in Node.js requests are intercepted
+    // _after_ they happen. Request issuer should have already taken care of sending relevant cookies.
+    // Unlike browser, where interception is on the worker level, _before_ the request happens.
+    const requestCookiesString = request.headers.get('cookie');
     cookies.store.hydrate();
-    request.cookies = Object.assign(Object.assign({}, getRequestCookies(request)), Array.from((_a = cookies.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('; '));
+    const cookiesFromStore = Array.from((_a = cookies.store.get(Object.assign(Object.assign({}, request), { url: request.url.toString() }))) === null || _a === void 0 ? void 0 : _a.entries()).reduce((cookies, [name, { value }]) => {
+        return Object.assign(cookies, { [name.trim()]: value });
+    }, {});
+    const cookiesFromDocument = getRequestCookies(request);
+    const forwardedCookies = Object.assign(Object.assign({}, cookiesFromDocument), cookiesFromStore);
+    // Ensure the persisted (document) cookies are propagated to the request.
+    // Propagated the cookies persisted in the Cookuie Store to the request headers.
+    // This forwards relevant request cookies based on the request's credentials.
+    for (const [name, value] of Object.entries(forwardedCookies)) {
+        request.headers.append('cookie', `${name}=${value}`);
+    }
+    const ownCookies = requestCookiesString
+        ? parse_1(requestCookiesString)
+        : {};
+    request.cookies = Object.assign(Object.assign(Object.assign({}, request.cookies), forwardedCookies), ownCookies);
 }
 
 /**
@@ -2935,6 +3356,7 @@ function parseIsomorphicRequest(request) {
         url: request.url,
         method: request.method,
         body: parseBody(request.body, request.headers),
+        credentials: request.credentials || 'same-origin',
         headers: request.headers,
         cookies: {},
         redirect: 'manual',
@@ -2946,24 +3368,39 @@ function parseIsomorphicRequest(request) {
         integrity: '',
         destination: 'document',
         bodyUsed: false,
-        credentials: 'same-origin',
+        passthrough,
     };
-    // Set mocked request cookies from the `cookie` header of the original request.
-    // No need to take `credentials` into account, because in Node.js requests are intercepted
-    // _after_ they happen. Request issuer should have already taken care of sending relevant cookies.
-    // Unlike browser, where interception is on the worker level, _before_ the request happens.
-    const requestCookiesString = request.headers.get('cookie');
     // Attach all the cookies from the virtual cookie store.
     setRequestCookies(mockedRequest);
-    const requestCookies = requestCookiesString
-        ? parse_1(requestCookiesString)
-        : {};
-    // Merge both direct request cookies and the cookies inherited
-    // from other same-origin requests in the cookie store.
-    mockedRequest.cookies = Object.assign(Object.assign({}, mockedRequest.cookies), requestCookies);
     return mockedRequest;
 }
 
+var lib$1 = {};
+
+var until$1 = {};
+
+Object.defineProperty(until$1, "__esModule", { value: true });
+/**
+ * Gracefully handles a given Promise factory.
+ * @example
+ * cosnt [error, data] = await until(() => asyncAction())
+ */
+until$1.until = async (promise) => {
+    try {
+        const data = await promise().catch((error) => {
+            throw error;
+        });
+        return [null, data];
+    }
+    catch (error) {
+        return [error, null];
+    }
+};
+
+Object.defineProperty(lib$1, "__esModule", { value: true });
+var until_1 = until$1;
+var until = lib$1.until = until_1.until;
+
 /**
  * Returns a mocked response for a given request using following request handlers.
  */
@@ -6702,114 +7139,6 @@ function isStringEqual(actual, expected) {
     return actual.toLowerCase() === expected.toLowerCase();
 }
 
-var statuses = {
-	"100": "Continue",
-	"101": "Switching Protocols",
-	"102": "Processing",
-	"103": "Early Hints",
-	"200": "OK",
-	"201": "Created",
-	"202": "Accepted",
-	"203": "Non-Authoritative Information",
-	"204": "No Content",
-	"205": "Reset Content",
-	"206": "Partial Content",
-	"207": "Multi-Status",
-	"208": "Already Reported",
-	"226": "IM Used",
-	"300": "Multiple Choices",
-	"301": "Moved Permanently",
-	"302": "Found",
-	"303": "See Other",
-	"304": "Not Modified",
-	"305": "Use Proxy",
-	"307": "Temporary Redirect",
-	"308": "Permanent Redirect",
-	"400": "Bad Request",
-	"401": "Unauthorized",
-	"402": "Payment Required",
-	"403": "Forbidden",
-	"404": "Not Found",
-	"405": "Method Not Allowed",
-	"406": "Not Acceptable",
-	"407": "Proxy Authentication Required",
-	"408": "Request Timeout",
-	"409": "Conflict",
-	"410": "Gone",
-	"411": "Length Required",
-	"412": "Precondition Failed",
-	"413": "Payload Too Large",
-	"414": "URI Too Long",
-	"415": "Unsupported Media Type",
-	"416": "Range Not Satisfiable",
-	"417": "Expectation Failed",
-	"418": "I'm a Teapot",
-	"421": "Misdirected Request",
-	"422": "Unprocessable Entity",
-	"423": "Locked",
-	"424": "Failed Dependency",
-	"425": "Too Early",
-	"426": "Upgrade Required",
-	"428": "Precondition Required",
-	"429": "Too Many Requests",
-	"431": "Request Header Fields Too Large",
-	"451": "Unavailable For Legal Reasons",
-	"500": "Internal Server Error",
-	"501": "Not Implemented",
-	"502": "Bad Gateway",
-	"503": "Service Unavailable",
-	"504": "Gateway Timeout",
-	"505": "HTTP Version Not Supported",
-	"506": "Variant Also Negotiates",
-	"507": "Insufficient Storage",
-	"508": "Loop Detected",
-	"509": "Bandwidth Limit Exceeded",
-	"510": "Not Extended",
-	"511": "Network Authentication Required"
-};
-
-/**
- * Sets a response status code and text.
- * @example
- * res(ctx.status(301))
- * res(ctx.status(400, 'Custom status text'))
- * @see {@link https://mswjs.io/docs/api/context/status `ctx.status()`}
- */
-const status = (statusCode, statusText) => {
-    return (res) => {
-        res.status = statusCode;
-        res.statusText =
-            statusText || statuses[String(statusCode)];
-        return res;
-    };
-};
-
-/**
- * Sets one or multiple response headers.
- * @example
- * ctx.set('Content-Type', 'text/plain')
- * ctx.set({
- *   'Accept': 'application/javascript',
- *   'Content-Type': "text/plain"
- * })
- * @see {@link https://mswjs.io/docs/api/context/set `ctx.set()`}
- */
-function set(...args) {
-    return (res) => {
-        const [name, value] = args;
-        if (typeof name === 'string') {
-            res.headers.append(name, value);
-        }
-        else {
-            const headers = lib$1.objectToHeaders(name);
-            headers.forEach((value, name) => {
-                res.headers.append(name, value);
-            });
-        }
-        return res;
-    };
-}
-
 /**
  * Sets a given cookie on the mocked response.
  * @example res(ctx.cookie('name', 'value'))
@@ -6879,95 +7208,39 @@ function mergeRight(left, right) {
 const json = (body) => {
     return (res) => {
         res.headers.set('Content-Type', 'application/json');
-        res.body = JSON.stringify(body);
-        return res;
-    };
-};
-
-/**
- * Sets a given payload as a GraphQL response body.
- * @example
- * res(ctx.data({ user: { firstName: 'John' }}))
- * @see {@link https://mswjs.io/docs/api/context/data `ctx.data()`}
- */
-const data = (payload) => {
-    return (res) => {
-        const prevBody = jsonParse(res.body) || {};
-        const nextBody = mergeRight(prevBody, { data: payload });
-        return json(nextBody)(res);
-    };
-};
-
-/**
- * Sets the GraphQL extensions on a given response.
- * @example
- * res(ctx.extensions({ tracing: { version: 1 }}))
- * @see {@link https://mswjs.io/docs/api/context/extensions `ctx.extensions()`}
- */
-const extensions = (payload) => {
-    return (res) => {
-        const prevBody = jsonParse(res.body) || {};
-        const nextBody = mergeRight(prevBody, { extensions: payload });
-        return json(nextBody)(res);
-    };
-};
-
-const SET_TIMEOUT_MAX_ALLOWED_INT = 2147483647;
-const MIN_SERVER_RESPONSE_TIME = 100;
-const MAX_SERVER_RESPONSE_TIME = 400;
-const NODE_SERVER_RESPONSE_TIME = 5;
-const getRandomServerResponseTime = () => {
-    if (lib$3.exports.isNodeProcess()) {
-        return NODE_SERVER_RESPONSE_TIME;
-    }
-    return Math.floor(Math.random() * (MAX_SERVER_RESPONSE_TIME - MIN_SERVER_RESPONSE_TIME) +
-        MIN_SERVER_RESPONSE_TIME);
-};
-/**
- * Delays the response by the given duration (ms).
- * @example
- * res(ctx.delay(1200)) // delay response by 1200ms
- * res(ctx.delay()) // emulate realistic server response time
- * res(ctx.delay('infinite')) // delay response infinitely
- * @see {@link https://mswjs.io/docs/api/context/delay `ctx.delay()`}
- */
-const delay = (durationOrMode) => {
-    return (res) => {
-        let delayTime;
-        if (typeof durationOrMode === 'string') {
-            switch (durationOrMode) {
-                case 'infinite': {
-                    // Using `Infinity` as a delay value executes the response timeout immediately.
-                    // Instead, use the maximum allowed integer for `setTimeout`.
-                    delayTime = SET_TIMEOUT_MAX_ALLOWED_INT;
-                    break;
-                }
-                case 'real': {
-                    delayTime = getRandomServerResponseTime();
-                    break;
-                }
-                default: {
-                    throw new Error(`Failed to delay a response: unknown delay mode "${durationOrMode}". Please make sure you provide one of the supported modes ("real", "infinite") or a number to "ctx.delay".`);
-                }
-            }
-        }
-        else if (typeof durationOrMode === 'undefined') {
-            // Use random realistic server response time when no explicit delay duration was provided.
-            delayTime = getRandomServerResponseTime();
-        }
-        else {
-            // Guard against passing values like `Infinity` or `Number.MAX_VALUE`
-            // as the response delay duration. They don't produce the result you may expect.
-            if (durationOrMode > SET_TIMEOUT_MAX_ALLOWED_INT) {
-                throw new Error(`Failed to delay a response: provided delay duration (${durationOrMode}) exceeds the maximum allowed duration for "setTimeout" (${SET_TIMEOUT_MAX_ALLOWED_INT}). This will cause the response to be returned immediately. Please use a number within the allowed range to delay the response by exact duration, or consider the "infinite" delay mode to delay the response indefinitely.`);
-            }
-            delayTime = durationOrMode;
-        }
-        res.delay = delayTime;
+        res.body = JSON.stringify(body);
         return res;
     };
 };
 
+/**
+ * Sets a given payload as a GraphQL response body.
+ * @example
+ * res(ctx.data({ user: { firstName: 'John' }}))
+ * @see {@link https://mswjs.io/docs/api/context/data `ctx.data()`}
+ */
+const data = (payload) => {
+    return (res) => {
+        const prevBody = jsonParse(res.body) || {};
+        const nextBody = mergeRight(prevBody, { data: payload });
+        return json(nextBody)(res);
+    };
+};
+
+/**
+ * Sets the GraphQL extensions on a given response.
+ * @example
+ * res(ctx.extensions({ tracing: { version: 1 }}))
+ * @see {@link https://mswjs.io/docs/api/context/extensions `ctx.extensions()`}
+ */
+const extensions = (payload) => {
+    return (res) => {
+        const prevBody = jsonParse(res.body) || {};
+        const nextBody = mergeRight(prevBody, { extensions: payload });
+        return json(nextBody)(res);
+    };
+};
+
 /**
  * Sets a given list of GraphQL errors on the mocked response.
  * @example res(ctx.errors([{ message: 'Unauthorized' }]))
@@ -6984,43 +7257,6 @@ const errors = (errorsList) => {
     };
 };
 
-const useFetch = lib$3.exports.isNodeProcess() ? require('node-fetch') : window.fetch;
-const augmentRequestInit = (requestInit) => {
-    const headers = new lib$1.Headers(requestInit.headers);
-    headers.set('x-msw-bypass', 'true');
-    return Object.assign(Object.assign({}, requestInit), { headers: headers.all() });
-};
-const createFetchRequestParameters = (input) => {
-    const { body, method } = input;
-    const requestParameters = Object.assign(Object.assign({}, input), { body: undefined });
-    if (['GET', 'HEAD'].includes(method)) {
-        return requestParameters;
-    }
-    if (typeof body === 'object' ||
-        typeof body === 'number' ||
-        typeof body === 'boolean') {
-        requestParameters.body = JSON.stringify(body);
-    }
-    else {
-        requestParameters.body = body;
-    }
-    return requestParameters;
-};
-/**
- * Performs a bypassed request inside a request handler.
- * @example
- * const originalResponse = await ctx.fetch(req)
- * @see {@link https://mswjs.io/docs/api/context/fetch `ctx.fetch()`}
- */
-const fetch = (input, requestInit = {}) => {
-    if (typeof input === 'string') {
-        return useFetch(input, augmentRequestInit(requestInit));
-    }
-    const requestParameters = createFetchRequestParameters(input);
-    const derivedRequestInit = augmentRequestInit(requestParameters);
-    return useFetch(input.url.href, derivedRequestInit);
-};
-
 /**
  * Sets a textual response body. Appends a `Content-Type: text/plain`
  * header on the mocked response.
@@ -7092,7 +7328,7 @@ function prepareRequest(request) {
  * Formats a mocked response for introspection in the browser's console.
  */
 function prepareResponse(res) {
-    const responseHeaders = lib$1.objectToHeaders(res.headers);
+    const responseHeaders = lib$2.objectToHeaders(res.headers);
     return Object.assign(Object.assign({}, res), { 
         // Parse a response JSON body for preview in the logs
         body: parseBody(res.body, responseHeaders) });
@@ -7536,184 +7772,6 @@ function matchRequestUrl(url, path, baseUrl) {
     };
 }
 
-/**
- * Composes a given list of functions into a new function that
- * executes from right to left.
- */
-function compose(...fns) {
-    return (...args) => {
-        return fns.reduceRight((leftFn, rightFn) => {
-            return leftFn instanceof Promise
-                ? Promise.resolve(leftFn).then(rightFn)
-                : rightFn(leftFn);
-        }, args[0]);
-    };
-}
-
-class NetworkError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'NetworkError';
-    }
-}
-
-const defaultResponse = {
-    status: 200,
-    statusText: 'OK',
-    body: null,
-    delay: 0,
-    once: false,
-};
-const defaultResponseTransformers = [];
-function createResponseComposition(responseOverrides, defaultTransformers = defaultResponseTransformers) {
-    return (...transformers) => __awaiter(this, void 0, void 0, function* () {
-        const initialResponse = Object.assign({}, defaultResponse, {
-            headers: new lib$1.Headers({
-                'x-powered-by': 'msw',
-            }),
-        }, responseOverrides);
-        const resolvedTransformers = [
-            ...defaultTransformers,
-            ...transformers,
-        ].filter(Boolean);
-        const resolvedResponse = resolvedTransformers.length > 0
-            ? compose(...resolvedTransformers)(initialResponse)
-            : initialResponse;
-        return resolvedResponse;
-    });
-}
-const response = Object.assign(createResponseComposition(), {
-    once: createResponseComposition({ once: true }),
-    networkError(message) {
-        throw new NetworkError(message);
-    },
-});
-
-const BUILD_FRAME = /(node_modules)?[\/\\]lib[\/\\](umd|esm|iief|cjs)[\/\\]|^[^\/\\]*$/;
-/**
- * Return the stack trace frame of a function's invocation.
- */
-function getCallFrame(error) {
-    // In <IE11, new Error may return an undefined stack
-    const stack = error.stack;
-    if (!stack) {
-        return;
-    }
-    const frames = stack.split('\n').slice(1);
-    // Get the first frame that doesn't reference the library's internal trace.
-    // Assume that frame is the invocation frame.
-    const declarationFrame = frames.find((frame) => {
-        return !BUILD_FRAME.test(frame);
-    });
-    if (!declarationFrame) {
-        return;
-    }
-    // Extract file reference from the stack frame.
-    const declarationPath = declarationFrame
-        .replace(/\s*at [^()]*\(([^)]+)\)/, '$1')
-        .replace(/^@/, '');
-    return declarationPath;
-}
-
-/**
- * Determines if the given function is an iterator.
- */
-function isIterable(fn) {
-    if (!fn) {
-        return false;
-    }
-    return typeof fn[Symbol.iterator] == 'function';
-}
-
-const defaultContext = {
-    status,
-    set,
-    delay,
-    fetch,
-};
-class RequestHandler {
-    constructor(options) {
-        this.shouldSkip = false;
-        this.ctx = options.ctx || defaultContext;
-        this.resolver = options.resolver;
-        const callFrame = getCallFrame(new Error());
-        this.info = Object.assign(Object.assign({}, options.info), { callFrame });
-    }
-    /**
-     * Parse the captured request to extract additional information from it.
-     * Parsed result is then exposed to other methods of this request handler.
-     */
-    parse(_request, _resolutionContext) {
-        return null;
-    }
-    /**
-     * Test if this handler matches the given request.
-     */
-    test(request, resolutionContext) {
-        return this.predicate(request, this.parse(request, resolutionContext), resolutionContext);
-    }
-    /**
-     * Derive the publicly exposed request (`req`) instance of the response resolver
-     * from the captured request and its parsed result.
-     */
-    getPublicRequest(request, _parsedResult) {
-        return request;
-    }
-    markAsSkipped(shouldSkip = true) {
-        this.shouldSkip = shouldSkip;
-    }
-    /**
-     * Execute this request handler and produce a mocked response
-     * using the given resolver function.
-     */
-    run(request, resolutionContext) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.shouldSkip) {
-                return null;
-            }
-            const parsedResult = this.parse(request, resolutionContext);
-            const shouldIntercept = this.predicate(request, parsedResult, resolutionContext);
-            if (!shouldIntercept) {
-                return null;
-            }
-            const publicRequest = this.getPublicRequest(request, parsedResult);
-            // Create a response extraction wrapper around the resolver
-            // since it can be both an async function and a generator.
-            const executeResolver = this.wrapResolver(this.resolver);
-            const mockedResponse = yield executeResolver(publicRequest, response, this.ctx);
-            return this.createExecutionResult(parsedResult, publicRequest, mockedResponse);
-        });
-    }
-    wrapResolver(resolver) {
-        return (req, res, ctx) => __awaiter(this, void 0, void 0, function* () {
-            const result = this.resolverGenerator || (yield resolver(req, res, ctx));
-            if (isIterable(result)) {
-                const { value, done } = result[Symbol.iterator]().next();
-                const nextResponse = yield value;
-                // If the generator is done and there is no next value,
-                // return the previous generator's value.
-                if (!nextResponse && done) {
-                    return this.resolverGeneratorResult;
-                }
-                if (!this.resolverGenerator) {
-                    this.resolverGenerator = result;
-                }
-                this.resolverGeneratorResult = nextResponse;
-                return nextResponse;
-            }
-            return result;
-        });
-    }
-    createExecutionResult(parsedResult, request, response) {
-        return {
-            handler: this,
-            parsedResult: parsedResult || null,
-            request,
-            response: response || null,
-        };
-    }
-}
-
 var RESTMethods;
 (function (RESTMethods) {
     RESTMethods["HEAD"] = "HEAD";
@@ -7724,17 +7782,11 @@ var RESTMethods;
     RESTMethods["OPTIONS"] = "OPTIONS";
     RESTMethods["DELETE"] = "DELETE";
 })(RESTMethods || (RESTMethods = {}));
-const restContext = {
-    set,
-    status,
-    cookie,
+const restContext = Object.assign(Object.assign({}, defaultContext), { cookie,
     body,
     text,
     json,
-    xml,
-    delay,
-    fetch,
-};
+    xml });
 /**
  * Request handler for REST API requests.
  * Provides request matching based on method and URL.
@@ -7805,16 +7857,10 @@ function tryCatch(fn, onException) {
     }
 }
 
-const graphqlContext = {
-    set,
-    status,
-    delay,
-    fetch,
-    data,
+const graphqlContext = Object.assign(Object.assign({}, defaultContext), { data,
     extensions,
     errors,
-    cookie,
-};
+    cookie });
 function isDocumentNode(value) {
     if (value == null) {
         return false;
@@ -8034,17 +8080,24 @@ function readResponseCookies(request, response) {
 }
 
 function handleRequest(request, handlers, options, emitter, handleRequestOptions) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
     return __awaiter(this, void 0, void 0, function* () {
         emitter.emit('request:start', request);
         // Perform bypassed requests (i.e. issued via "ctx.fetch") as-is.
         if (request.headers.get('x-msw-bypass') === 'true') {
             emitter.emit('request:end', request);
-            (_a = handleRequestOptions === null || handleRequestOptions === void 0 ? void 0 : handleRequestOptions.onBypassResponse) === null || _a === void 0 ? void 0 : _a.call(handleRequestOptions, request);
+            (_a = handleRequestOptions === null || handleRequestOptions === void 0 ? void 0 : handleRequestOptions.onPassthroughResponse) === null || _a === void 0 ? void 0 : _a.call(handleRequestOptions, request);
             return;
         }
         // Resolve a mocked response from the list of request handlers.
-        const lookupResult = yield getResponse(request, handlers, handleRequestOptions === null || handleRequestOptions === void 0 ? void 0 : handleRequestOptions.resolutionContext);
+        const [lookupError, lookupResult] = yield until(() => {
+            return getResponse(request, handlers, handleRequestOptions === null || handleRequestOptions === void 0 ? void 0 : handleRequestOptions.resolutionContext);
+        });
+        if (lookupError) {
+            // Allow developers to react to unhandled exceptions in request handlers.
+            emitter.emit('unhandledException', lookupError, request);
+            throw lookupError;
+        }
         const { handler, response } = lookupResult;
         // When there's no handler for the request, consider it unhandled.
         // Allow the developer to react to such cases.
@@ -8052,7 +8105,7 @@ function handleRequest(request, handlers, options, emitter, handleRequestOptions
             onUnhandledRequest(request, handlers, options.onUnhandledRequest);
             emitter.emit('request:unhandled', request);
             emitter.emit('request:end', request);
-            (_b = handleRequestOptions === null || handleRequestOptions === void 0 ? void 0 : handleRequestOptions.onBypassResponse) === null || _b === void 0 ? void 0 : _b.call(handleRequestOptions, request);
+            (_b = handleRequestOptions === null || handleRequestOptions === void 0 ? void 0 : handleRequestOptions.onPassthroughResponse) === null || _b === void 0 ? void 0 : _b.call(handleRequestOptions, request);
             return;
         }
         // When the handled request returned no mocked response, warn the developer,
@@ -8065,7 +8118,14 @@ Expected response resolver to return a mocked response Object, but got %s. The o
     %s\
 `, response, handler.info.header, handler.info.callFrame);
             emitter.emit('request:end', request);
-            (_c = handleRequestOptions === null || handleRequestOptions === void 0 ? void 0 : handleRequestOptions.onBypassResponse) === null || _c === void 0 ? void 0 : _c.call(handleRequestOptions, request);
+            (_c = handleRequestOptions === null || handleRequestOptions === void 0 ? void 0 : handleRequestOptions.onPassthroughResponse) === null || _c === void 0 ? void 0 : _c.call(handleRequestOptions, request);
+            return;
+        }
+        // When the developer explicitly returned "req.passthrough()" do not warn them.
+        // Perform the request as-is.
+        if (response.passthrough) {
+            emitter.emit('request:end', request);
+            (_d = handleRequestOptions === null || handleRequestOptions === void 0 ? void 0 : handleRequestOptions.onPassthroughResponse) === null || _d === void 0 ? void 0 : _d.call(handleRequestOptions, request);
             return;
         }
         // Store all the received response cookies in the virtual cookie store.
@@ -8112,8 +8172,8 @@ const DEFAULT_LISTEN_OPTIONS = {
  * Useful to generate identical API using different patches to request issuing modules.
  */
 function createSetupServer(...interceptors$1) {
-    const emitter = new lib$2.StrictEventEmitter();
-    const publicEmitter = new lib$2.StrictEventEmitter();
+    const emitter = new lib$3.StrictEventEmitter();
+    const publicEmitter = new lib$3.StrictEventEmitter();
     pipeEvents(emitter, publicEmitter);
     return function setupServer(...requestHandlers) {
         requestHandlers.forEach((handler) => {
@@ -8124,7 +8184,7 @@ function createSetupServer(...interceptors$1) {
         // so it could be modified at a runtime.
         let currentHandlers = [...requestHandlers];
         // Error when attempting to run this function in a browser environment.
-        if (!lib$3.exports.isNodeProcess()) {
+        if (!lib$4.exports.isNodeProcess()) {
             throw new Error(devUtils.formatMessage('Failed to execute `setupServer` in the environment that is not Node.js (i.e. a browser). Consider using `setupWorker` instead.'));
         }
         let resolvedOptions = {};