msw 0.40.1 → 0.41.1

package/lib/esm/matchRequestUrl-deps.js

@@ -1,992 +0,0 @@
-import { c as commonjsGlobal, l as lib$1, s as status, b as set, e as delay, f as fetch, j as jsonParse } from './fetch-deps.js';
-import { getCleanUrl } from '@mswjs/interceptors/lib/utils/getCleanUrl';
-
-/*! *****************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-
-function __rest(s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-}
-
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
-
-var lib = {};
-
-var invariant$1 = {};
-
-var format$1 = {};
-
-Object.defineProperty(format$1, "__esModule", { value: true });
-format$1.format = void 0;
-var POSITIONALS_EXP = /(%?)(%([sdjo]))/g;
-function serializePositional(positional, flag) {
-    switch (flag) {
-        // Strings.
-        case 's':
-            return positional;
-        // Digits.
-        case 'd':
-        case 'i':
-            return Number(positional);
-        // JSON.
-        case 'j':
-            return JSON.stringify(positional);
-        // Objects.
-        case 'o': {
-            // Preserve stings to prevent extra quotes around them.
-            if (typeof positional === 'string') {
-                return positional;
-            }
-            var json = JSON.stringify(positional);
-            // If the positional isn't serializable, return it as-is.
-            if (json === '{}' || json === '[]' || /^\[object .+?\]$/.test(json)) {
-                return positional;
-            }
-            return json;
-        }
-    }
-}
-function format(message) {
-    var positionals = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        positionals[_i - 1] = arguments[_i];
-    }
-    if (positionals.length === 0) {
-        return message;
-    }
-    var positionalIndex = 0;
-    var formattedMessage = message.replace(POSITIONALS_EXP, function (match, isEscaped, _, flag) {
-        var positional = positionals[positionalIndex];
-        var value = serializePositional(positional, flag);
-        if (!isEscaped) {
-            positionalIndex++;
-            return value;
-        }
-        return match;
-    });
-    // Append unresolved positionals to string as-is.
-    if (positionalIndex < positionals.length) {
-        formattedMessage += " " + positionals.slice(positionalIndex).join(' ');
-    }
-    formattedMessage = formattedMessage.replace(/%{2,2}/g, '%');
-    return formattedMessage;
-}
-format$1.format = format;
-
-var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __spreadArray = (commonjsGlobal && commonjsGlobal.__spreadArray) || function (to, from) {
-    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
-        to[j] = from[i];
-    return to;
-};
-Object.defineProperty(invariant$1, "__esModule", { value: true });
-invariant$1.invariant = invariant$1.InvariantError = void 0;
-var format_1 = format$1;
-var STACK_FRAMES_TO_IGNORE = 2;
-var InvariantError = /** @class */ (function (_super) {
-    __extends(InvariantError, _super);
-    function InvariantError(message) {
-        var positionals = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            positionals[_i - 1] = arguments[_i];
-        }
-        var _this = _super.call(this, message) || this;
-        _this.name = 'Invariant Violation';
-        _this.message = format_1.format.apply(void 0, __spreadArray([message], positionals));
-        if (_this.stack) {
-            var nextStack = _this.stack.split('\n');
-            nextStack.splice(1, STACK_FRAMES_TO_IGNORE);
-            _this.stack = nextStack.join('\n');
-        }
-        return _this;
-    }
-    return InvariantError;
-}(Error));
-invariant$1.InvariantError = InvariantError;
-function invariant(predicate, message) {
-    var positionals = [];
-    for (var _i = 2; _i < arguments.length; _i++) {
-        positionals[_i - 2] = arguments[_i];
-    }
-    if (!predicate) {
-        throw new (InvariantError.bind.apply(InvariantError, __spreadArray([void 0, message], positionals)))();
-    }
-}
-invariant$1.invariant = invariant;
-
-(function (exports) {
-var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(invariant$1, exports);
-__exportStar(format$1, exports);
-}(lib));
-
-const LIBRARY_PREFIX = '[MSW]';
-/**
- * Formats a given message by appending the library's prefix string.
- */
-function formatMessage(message, ...positionals) {
-    const interpolatedMessage = lib.format(message, ...positionals);
-    return `${LIBRARY_PREFIX} ${interpolatedMessage}`;
-}
-/**
- * Prints a library-specific warning.
- */
-function warn(message, ...positionals) {
-    console.warn(formatMessage(message, ...positionals));
-}
-/**
- * Prints a library-specific error.
- */
-function error(message, ...positionals) {
-    console.error(formatMessage(message, ...positionals));
-}
-const devUtils = {
-    formatMessage,
-    warn,
-    error,
-};
-
-class NetworkError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'NetworkError';
-    }
-}
-
-/**
- * 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]);
-    };
-}
-
-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$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,
-        };
-    }
-}
-/**
- * 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$1.Headers(),
-        body: null,
-        // Setting "passthrough" to true will signal the response pipeline
-        // to perform this intercepted request as-is.
-        passthrough: true,
-        once: false,
-    };
-}
-
-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.
- */
-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'))
-        .map((chunk) => chunk.trimStart().replace(/\r\n$/, ''));
-    if (!fields.length) {
-        return undefined;
-    }
-    const parsedBody = {};
-    try {
-        for (const field of fields) {
-            const [contentHeaders, ...rest] = field.split('\r\n\r\n');
-            const contentBody = rest.join('\r\n\r\n');
-            const { contentType, filename, name } = parseContentHeaders(contentHeaders);
-            const value = filename === undefined
-                ? contentBody
-                : new File([contentBody], filename, { type: contentType });
-            const parsedValue = parsedBody[name];
-            if (parsedValue === undefined) {
-                parsedBody[name] = value;
-            }
-            else if (Array.isArray(parsedValue)) {
-                parsedBody[name] = [...parsedValue, value];
-            }
-            else {
-                parsedBody[name] = [parsedValue, value];
-            }
-        }
-        return parsedBody;
-    }
-    catch (error) {
-        return undefined;
-    }
-}
-
-/**
- * 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;
-}
-
-/**
- * Returns a relative URL if the given request URL is relative to the current origin.
- * Otherwise returns an absolute URL.
- */
-const getPublicUrlFromRequest = (request) => {
-    return request.referrer.startsWith(request.url.origin)
-        ? request.url.pathname
-        : new URL(request.url.pathname, `${request.url.protocol}//${request.url.host}`).href;
-};
-
-var StatusCodeColor;
-(function (StatusCodeColor) {
-    StatusCodeColor["Success"] = "#69AB32";
-    StatusCodeColor["Warning"] = "#F0BB4B";
-    StatusCodeColor["Danger"] = "#E95F5D";
-})(StatusCodeColor || (StatusCodeColor = {}));
-/**
- * Returns a HEX color for a given response status code number.
- */
-function getStatusCodeColor(status) {
-    if (status < 300) {
-        return StatusCodeColor.Success;
-    }
-    if (status < 400) {
-        return StatusCodeColor.Warning;
-    }
-    return StatusCodeColor.Danger;
-}
-
-/**
- * Returns a timestamp string in a "HH:MM:SS" format.
- */
-function getTimestamp() {
-    const now = new Date();
-    return [now.getHours(), now.getMinutes(), now.getSeconds()]
-        .map(String)
-        .map((chunk) => chunk.slice(0, 2))
-        .map((chunk) => chunk.padStart(2, '0'))
-        .join(':');
-}
-
-/**
- * Formats a mocked request for introspection in browser's console.
- */
-function prepareRequest(request) {
-    return Object.assign(Object.assign({}, request), { headers: request.headers.all() });
-}
-
-/**
- * Formats a mocked response for introspection in the browser's console.
- */
-function prepareResponse(res) {
-    const responseHeaders = lib$1.objectToHeaders(res.headers);
-    return Object.assign(Object.assign({}, res), { 
-        // Parse a response JSON body for preview in the logs
-        body: parseBody(res.body, responseHeaders) });
-}
-
-/**
- * Tokenize input string.
- */
-function lexer(str) {
-    var tokens = [];
-    var i = 0;
-    while (i < str.length) {
-        var char = str[i];
-        if (char === "*" || char === "+" || char === "?") {
-            tokens.push({ type: "MODIFIER", index: i, value: str[i++] });
-            continue;
-        }
-        if (char === "\\") {
-            tokens.push({ type: "ESCAPED_CHAR", index: i++, value: str[i++] });
-            continue;
-        }
-        if (char === "{") {
-            tokens.push({ type: "OPEN", index: i, value: str[i++] });
-            continue;
-        }
-        if (char === "}") {
-            tokens.push({ type: "CLOSE", index: i, value: str[i++] });
-            continue;
-        }
-        if (char === ":") {
-            var name = "";
-            var j = i + 1;
-            while (j < str.length) {
-                var code = str.charCodeAt(j);
-                if (
-                // `0-9`
-                (code >= 48 && code <= 57) ||
-                    // `A-Z`
-                    (code >= 65 && code <= 90) ||
-                    // `a-z`
-                    (code >= 97 && code <= 122) ||
-                    // `_`
-                    code === 95) {
-                    name += str[j++];
-                    continue;
-                }
-                break;
-            }
-            if (!name)
-                throw new TypeError("Missing parameter name at " + i);
-            tokens.push({ type: "NAME", index: i, value: name });
-            i = j;
-            continue;
-        }
-        if (char === "(") {
-            var count = 1;
-            var pattern = "";
-            var j = i + 1;
-            if (str[j] === "?") {
-                throw new TypeError("Pattern cannot start with \"?\" at " + j);
-            }
-            while (j < str.length) {
-                if (str[j] === "\\") {
-                    pattern += str[j++] + str[j++];
-                    continue;
-                }
-                if (str[j] === ")") {
-                    count--;
-                    if (count === 0) {
-                        j++;
-                        break;
-                    }
-                }
-                else if (str[j] === "(") {
-                    count++;
-                    if (str[j + 1] !== "?") {
-                        throw new TypeError("Capturing groups are not allowed at " + j);
-                    }
-                }
-                pattern += str[j++];
-            }
-            if (count)
-                throw new TypeError("Unbalanced pattern at " + i);
-            if (!pattern)
-                throw new TypeError("Missing pattern at " + i);
-            tokens.push({ type: "PATTERN", index: i, value: pattern });
-            i = j;
-            continue;
-        }
-        tokens.push({ type: "CHAR", index: i, value: str[i++] });
-    }
-    tokens.push({ type: "END", index: i, value: "" });
-    return tokens;
-}
-/**
- * Parse a string for the raw tokens.
- */
-function parse(str, options) {
-    if (options === void 0) { options = {}; }
-    var tokens = lexer(str);
-    var _a = options.prefixes, prefixes = _a === void 0 ? "./" : _a;
-    var defaultPattern = "[^" + escapeString(options.delimiter || "/#?") + "]+?";
-    var result = [];
-    var key = 0;
-    var i = 0;
-    var path = "";
-    var tryConsume = function (type) {
-        if (i < tokens.length && tokens[i].type === type)
-            return tokens[i++].value;
-    };
-    var mustConsume = function (type) {
-        var value = tryConsume(type);
-        if (value !== undefined)
-            return value;
-        var _a = tokens[i], nextType = _a.type, index = _a.index;
-        throw new TypeError("Unexpected " + nextType + " at " + index + ", expected " + type);
-    };
-    var consumeText = function () {
-        var result = "";
-        var value;
-        // tslint:disable-next-line
-        while ((value = tryConsume("CHAR") || tryConsume("ESCAPED_CHAR"))) {
-            result += value;
-        }
-        return result;
-    };
-    while (i < tokens.length) {
-        var char = tryConsume("CHAR");
-        var name = tryConsume("NAME");
-        var pattern = tryConsume("PATTERN");
-        if (name || pattern) {
-            var prefix = char || "";
-            if (prefixes.indexOf(prefix) === -1) {
-                path += prefix;
-                prefix = "";
-            }
-            if (path) {
-                result.push(path);
-                path = "";
-            }
-            result.push({
-                name: name || key++,
-                prefix: prefix,
-                suffix: "",
-                pattern: pattern || defaultPattern,
-                modifier: tryConsume("MODIFIER") || ""
-            });
-            continue;
-        }
-        var value = char || tryConsume("ESCAPED_CHAR");
-        if (value) {
-            path += value;
-            continue;
-        }
-        if (path) {
-            result.push(path);
-            path = "";
-        }
-        var open = tryConsume("OPEN");
-        if (open) {
-            var prefix = consumeText();
-            var name_1 = tryConsume("NAME") || "";
-            var pattern_1 = tryConsume("PATTERN") || "";
-            var suffix = consumeText();
-            mustConsume("CLOSE");
-            result.push({
-                name: name_1 || (pattern_1 ? key++ : ""),
-                pattern: name_1 && !pattern_1 ? defaultPattern : pattern_1,
-                prefix: prefix,
-                suffix: suffix,
-                modifier: tryConsume("MODIFIER") || ""
-            });
-            continue;
-        }
-        mustConsume("END");
-    }
-    return result;
-}
-/**
- * Create path match function from `path-to-regexp` spec.
- */
-function match(str, options) {
-    var keys = [];
-    var re = pathToRegexp(str, keys, options);
-    return regexpToFunction(re, keys, options);
-}
-/**
- * Create a path match function from `path-to-regexp` output.
- */
-function regexpToFunction(re, keys, options) {
-    if (options === void 0) { options = {}; }
-    var _a = options.decode, decode = _a === void 0 ? function (x) { return x; } : _a;
-    return function (pathname) {
-        var m = re.exec(pathname);
-        if (!m)
-            return false;
-        var path = m[0], index = m.index;
-        var params = Object.create(null);
-        var _loop_1 = function (i) {
-            // tslint:disable-next-line
-            if (m[i] === undefined)
-                return "continue";
-            var key = keys[i - 1];
-            if (key.modifier === "*" || key.modifier === "+") {
-                params[key.name] = m[i].split(key.prefix + key.suffix).map(function (value) {
-                    return decode(value, key);
-                });
-            }
-            else {
-                params[key.name] = decode(m[i], key);
-            }
-        };
-        for (var i = 1; i < m.length; i++) {
-            _loop_1(i);
-        }
-        return { path: path, index: index, params: params };
-    };
-}
-/**
- * Escape a regular expression string.
- */
-function escapeString(str) {
-    return str.replace(/([.+*?=^!:${}()[\]|/\\])/g, "\\$1");
-}
-/**
- * Get the flags for a regexp from the options.
- */
-function flags(options) {
-    return options && options.sensitive ? "" : "i";
-}
-/**
- * Pull out keys from a regexp.
- */
-function regexpToRegexp(path, keys) {
-    if (!keys)
-        return path;
-    var groupsRegex = /\((?:\?<(.*?)>)?(?!\?)/g;
-    var index = 0;
-    var execResult = groupsRegex.exec(path.source);
-    while (execResult) {
-        keys.push({
-            // Use parenthesized substring match if available, index otherwise
-            name: execResult[1] || index++,
-            prefix: "",
-            suffix: "",
-            modifier: "",
-            pattern: ""
-        });
-        execResult = groupsRegex.exec(path.source);
-    }
-    return path;
-}
-/**
- * Transform an array into a regexp.
- */
-function arrayToRegexp(paths, keys, options) {
-    var parts = paths.map(function (path) { return pathToRegexp(path, keys, options).source; });
-    return new RegExp("(?:" + parts.join("|") + ")", flags(options));
-}
-/**
- * Create a path regexp from string input.
- */
-function stringToRegexp(path, keys, options) {
-    return tokensToRegexp(parse(path, options), keys, options);
-}
-/**
- * Expose a function for taking tokens and returning a RegExp.
- */
-function tokensToRegexp(tokens, keys, options) {
-    if (options === void 0) { options = {}; }
-    var _a = options.strict, strict = _a === void 0 ? false : _a, _b = options.start, start = _b === void 0 ? true : _b, _c = options.end, end = _c === void 0 ? true : _c, _d = options.encode, encode = _d === void 0 ? function (x) { return x; } : _d;
-    var endsWith = "[" + escapeString(options.endsWith || "") + "]|$";
-    var delimiter = "[" + escapeString(options.delimiter || "/#?") + "]";
-    var route = start ? "^" : "";
-    // Iterate over the tokens and create our regexp string.
-    for (var _i = 0, tokens_1 = tokens; _i < tokens_1.length; _i++) {
-        var token = tokens_1[_i];
-        if (typeof token === "string") {
-            route += escapeString(encode(token));
-        }
-        else {
-            var prefix = escapeString(encode(token.prefix));
-            var suffix = escapeString(encode(token.suffix));
-            if (token.pattern) {
-                if (keys)
-                    keys.push(token);
-                if (prefix || suffix) {
-                    if (token.modifier === "+" || token.modifier === "*") {
-                        var mod = token.modifier === "*" ? "?" : "";
-                        route += "(?:" + prefix + "((?:" + token.pattern + ")(?:" + suffix + prefix + "(?:" + token.pattern + "))*)" + suffix + ")" + mod;
-                    }
-                    else {
-                        route += "(?:" + prefix + "(" + token.pattern + ")" + suffix + ")" + token.modifier;
-                    }
-                }
-                else {
-                    route += "(" + token.pattern + ")" + token.modifier;
-                }
-            }
-            else {
-                route += "(?:" + prefix + suffix + ")" + token.modifier;
-            }
-        }
-    }
-    if (end) {
-        if (!strict)
-            route += delimiter + "?";
-        route += !options.endsWith ? "$" : "(?=" + endsWith + ")";
-    }
-    else {
-        var endToken = tokens[tokens.length - 1];
-        var isEndDelimited = typeof endToken === "string"
-            ? delimiter.indexOf(endToken[endToken.length - 1]) > -1
-            : // tslint:disable-next-line
-                endToken === undefined;
-        if (!strict) {
-            route += "(?:" + delimiter + "(?=" + endsWith + "))?";
-        }
-        if (!isEndDelimited) {
-            route += "(?=" + delimiter + "|" + endsWith + ")";
-        }
-    }
-    return new RegExp(route, flags(options));
-}
-/**
- * Normalize the given path string, returning a regular expression.
- *
- * An empty array can be passed in for the keys, which will hold the
- * placeholder key descriptions. For example, using `/user/:id`, `keys` will
- * contain `[{ name: 'id', delimiter: '/', optional: false, repeat: false }]`.
- */
-function pathToRegexp(path, keys, options) {
-    if (path instanceof RegExp)
-        return regexpToRegexp(path, keys);
-    if (Array.isArray(path))
-        return arrayToRegexp(path, keys, options);
-    return stringToRegexp(path, keys, options);
-}
-
-const REDUNDANT_CHARACTERS_EXP = /[\?|#].*$/g;
-function getSearchParams(path) {
-    return new URL(`/${path}`, 'http://localhost').searchParams;
-}
-/**
- * Removes query parameters and hashes from a given URL string.
- */
-function cleanUrl(path) {
-    return path.replace(REDUNDANT_CHARACTERS_EXP, '');
-}
-
-/**
- * Determines if the given URL string is an absolute URL.
- */
-function isAbsoluteUrl(url) {
-    return /^([a-z][a-z\d\+\-\.]*:)?\/\//i.test(url);
-}
-
-/**
- * Returns an absolute URL based on the given path.
- */
-function getAbsoluteUrl(path, baseUrl) {
-    // already absolute URL
-    if (isAbsoluteUrl(path)) {
-        return path;
-    }
-    // Ignore path with pattern start with *
-    if (path.startsWith('*')) {
-        return path;
-    }
-    // Resolve a relative request URL against a given custom "baseUrl"
-    // or the document baseURI (in the case of browser/browser-like environments).
-    const origin = baseUrl || (typeof document !== 'undefined' && document.baseURI);
-    return origin
-        ? // Encode and decode the path to preserve escaped characters.
-            decodeURI(new URL(encodeURI(path), origin).href)
-        : path;
-}
-
-/**
- * Normalizes a given request handler path:
- * - Preserves RegExp.
- * - Removes query parameters and hashes.
- * - Rebases relative URLs against the "baseUrl" or the current location.
- * - Preserves relative URLs in Node.js, unless specified otherwise.
- */
-function normalizePath(path, baseUrl) {
-    // RegExp paths do not need normalization.
-    if (path instanceof RegExp) {
-        return path;
-    }
-    const maybeAbsoluteUrl = getAbsoluteUrl(path, baseUrl);
-    return cleanUrl(maybeAbsoluteUrl);
-}
-
-/**
- * Coerce a path supported by MSW into a path
- * supported by "path-to-regexp".
- */
-function coercePath(path) {
-    return (path
-        /**
-         * Replace wildcards ("*") with unnamed capturing groups
-         * because "path-to-regexp" doesn't support wildcards.
-         * Ignore path parameter' modifiers (i.e. ":name*").
-         */
-        .replace(/([:a-zA-Z_-]*)(\*{1,2})+/g, (_, parameterName, wildcard) => {
-        const expression = '(.*)';
-        if (!parameterName) {
-            return expression;
-        }
-        return parameterName.startsWith(':')
-            ? `${parameterName}${wildcard}`
-            : `${parameterName}${expression}`;
-    })
-        /**
-         * Escape the port so that "path-to-regexp" can match
-         * absolute URLs including port numbers.
-         */
-        .replace(/([^\/])(:)(?=\d+)/, '$1\\$2')
-        /**
-         * Escape the protocol so that "path-to-regexp" could match
-         * absolute URL.
-         * @see https://github.com/pillarjs/path-to-regexp/issues/259
-         */
-        .replace(/^([^\/]+)(:)(?=\/\/)/, '$1\\$2'));
-}
-/**
- * Returns the result of matching given request URL against a mask.
- */
-function matchRequestUrl(url, path, baseUrl) {
-    const normalizedPath = normalizePath(path, baseUrl);
-    const cleanPath = typeof normalizedPath === 'string'
-        ? coercePath(normalizedPath)
-        : normalizedPath;
-    const cleanUrl = getCleanUrl(url);
-    const result = match(cleanPath, { decode: decodeURIComponent })(cleanUrl);
-    const params = (result && result.params) || {};
-    return {
-        matches: result !== false,
-        params,
-    };
-}
-
-export { NetworkError as N, RequestHandler as R, __awaiter as _, parseBody as a, defaultResponse as b, createResponseComposition as c, devUtils as d, defaultContext as e, compose as f, getPublicUrlFromRequest as g, cleanUrl as h, getSearchParams as i, prepareRequest as j, prepareResponse as k, getStatusCodeColor as l, matchRequestUrl as m, getTimestamp as n, __rest as o, passthrough as p, response as r };