msw 0.33.3 → 0.36.1

package/native/lib/index.js

@@ -6,6 +6,8 @@ var XMLHttpRequest = require('@mswjs/interceptors/lib/interceptors/XMLHttpReques
 var chalk = require('chalk');
 var require$$0 = require('events');
 var interceptors = require('@mswjs/interceptors');
+var cookies = require('@mswjs/cookies');
+var getCleanUrl = require('@mswjs/interceptors/lib/utils/getCleanUrl');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -50,7 +52,7 @@ function __awaiter(thisArg, _arguments, P, generator) {
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
-var lib$4 = {exports: {}};
+var lib$3 = {exports: {}};
 
 (function (module, exports) {
 (function (global, factory) {
@@ -73,9 +75,9 @@ var lib$4 = {exports: {}};
   Object.defineProperty(exports, '__esModule', { value: true });
 
 })));
-}(lib$4, lib$4.exports));
+}(lib$3, lib$3.exports));
 
-var lib$3 = {};
+var lib$2 = {};
 
 var StrictEventEmitter$1 = {};
 
@@ -101,7 +103,7 @@ var __spreadArrays = (commonjsGlobal && commonjsGlobal.__spreadArrays) || functi
 };
 StrictEventEmitter$1.__esModule = true;
 StrictEventEmitter$1.StrictEventEmitter = void 0;
-var events_1 = require$$0__default['default'];
+var events_1 = require$$0__default["default"];
 var StrictEventEmitter = /** @class */ (function (_super) {
     __extends$1(StrictEventEmitter, _super);
     function StrictEventEmitter() {
@@ -145,7 +147,7 @@ exports.__esModule = true;
 exports.StrictEventEmitter = void 0;
 var StrictEventEmitter_1 = StrictEventEmitter$1;
 __createBinding(exports, StrictEventEmitter_1, "StrictEventEmitter");
-}(lib$3));
+}(lib$2));
 
 function use(currentHandlers, ...handlers) {
     currentHandlers.unshift(...handlers);
@@ -369,19 +371,19 @@ function uuidv4() {
 }
 
 /**
- * Parses a given string into a JSON.
+ * Parses a given value into a JSON.
  * Does not throw an exception on an invalid JSON string.
  */
-function jsonParse(str) {
+function jsonParse(value) {
     try {
-        return JSON.parse(str);
+        return JSON.parse(value);
     }
     catch (error) {
         return undefined;
     }
 }
 
-var lib$2 = {};
+var lib$1 = {};
 
 var Headers = {};
 
@@ -905,11 +907,11 @@ 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$2));
+}(lib$1));
 
 function parseContentHeaders(headersString) {
     var _a, _b;
-    const headers = lib$2.stringToHeaders(headersString);
+    const headers = lib$1.stringToHeaders(headersString);
     const contentType = headers.get('content-type') || 'text/plain';
     const disposition = headers.get('content-disposition');
     if (!disposition) {
@@ -980,403 +982,30 @@ function parseMultipartData(data, headers) {
 }
 
 /**
- * Parses a given request/response body based on the `Content-Type` header.
+ * Parses a given request/response body based on the "Content-Type" header.
  */
 function parseBody(body, headers) {
     // Return whatever falsey body value is given.
     if (!body) {
         return body;
     }
-    const contentType = headers === null || headers === void 0 ? void 0 : headers.get('content-type');
+    const contentType = (headers === null || headers === void 0 ? void 0 : headers.get('content-type')) || '';
     // If the body has a Multipart Content-Type
     // parse it into an object.
-    const hasMultipartContent = contentType === null || contentType === void 0 ? void 0 : contentType.startsWith('multipart/form-data');
+    const hasMultipartContent = contentType.startsWith('multipart/form-data');
     if (hasMultipartContent && typeof body !== 'object') {
-        return parseMultipartData(body, headers) || body;
+        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 === null || contentType === void 0 ? void 0 : contentType.includes('json');
+    const hasJsonContent = contentType.includes('json');
     if (hasJsonContent && typeof body !== 'object') {
-        return jsonParse(body) || body;
+        return jsonParse(body.toString()) || body;
     }
     // Otherwise leave as-is.
     return body;
 }
 
-var lib$1 = {};
-
-var CookieStore = {};
-
-var setCookie = {exports: {}};
-
-var defaultParseOptions = {
-  decodeValues: true,
-  map: false,
-  silent: false,
-};
-
-function isNonEmptyString(str) {
-  return typeof str === "string" && !!str.trim();
-}
-
-function parseString(setCookieValue, options) {
-  var parts = setCookieValue.split(";").filter(isNonEmptyString);
-  var nameValue = parts.shift().split("=");
-  var name = nameValue.shift();
-  var value = nameValue.join("="); // everything after the first =, joined by a "=" if there was more than one part
-
-  options = options
-    ? Object.assign({}, defaultParseOptions, options)
-    : defaultParseOptions;
-
-  try {
-    value = options.decodeValues ? decodeURIComponent(value) : value; // decode cookie value
-  } catch (e) {
-    console.error(
-      "set-cookie-parser encountered an error while decoding a cookie with value '" +
-        value +
-        "'. Set options.decodeValues to false to disable this feature.",
-      e
-    );
-  }
-
-  var cookie = {
-    name: name, // grab everything before the first =
-    value: value,
-  };
-
-  parts.forEach(function (part) {
-    var sides = part.split("=");
-    var key = sides.shift().trimLeft().toLowerCase();
-    var value = sides.join("=");
-    if (key === "expires") {
-      cookie.expires = new Date(value);
-    } else if (key === "max-age") {
-      cookie.maxAge = parseInt(value, 10);
-    } else if (key === "secure") {
-      cookie.secure = true;
-    } else if (key === "httponly") {
-      cookie.httpOnly = true;
-    } else if (key === "samesite") {
-      cookie.sameSite = value;
-    } else {
-      cookie[key] = value;
-    }
-  });
-
-  return cookie;
-}
-
-function parse$1(input, options) {
-  options = options
-    ? Object.assign({}, defaultParseOptions, options)
-    : defaultParseOptions;
-
-  if (!input) {
-    if (!options.map) {
-      return [];
-    } else {
-      return {};
-    }
-  }
-
-  if (input.headers && input.headers["set-cookie"]) {
-    // fast-path for node.js (which automatically normalizes header names to lower-case
-    input = input.headers["set-cookie"];
-  } else if (input.headers) {
-    // slow-path for other environments - see #25
-    var sch =
-      input.headers[
-        Object.keys(input.headers).find(function (key) {
-          return key.toLowerCase() === "set-cookie";
-        })
-      ];
-    // warn if called on a request-like object with a cookie header rather than a set-cookie header - see #34, 36
-    if (!sch && input.headers.cookie && !options.silent) {
-      console.warn(
-        "Warning: set-cookie-parser appears to have been called on a request object. It is designed to parse Set-Cookie headers from responses, not Cookie headers from requests. Set the option {silent: true} to suppress this warning."
-      );
-    }
-    input = sch;
-  }
-  if (!Array.isArray(input)) {
-    input = [input];
-  }
-
-  options = options
-    ? Object.assign({}, defaultParseOptions, options)
-    : defaultParseOptions;
-
-  if (!options.map) {
-    return input.filter(isNonEmptyString).map(function (str) {
-      return parseString(str, options);
-    });
-  } else {
-    var cookies = {};
-    return input.filter(isNonEmptyString).reduce(function (cookies, str) {
-      var cookie = parseString(str, options);
-      cookies[cookie.name] = cookie;
-      return cookies;
-    }, cookies);
-  }
-}
-
-/*
-  Set-Cookie header field-values are sometimes comma joined in one string. This splits them without choking on commas
-  that are within a single set-cookie field-value, such as in the Expires portion.
-
-  This is uncommon, but explicitly allowed - see https://tools.ietf.org/html/rfc2616#section-4.2
-  Node.js does this for every header *except* set-cookie - see https://github.com/nodejs/node/blob/d5e363b77ebaf1caf67cd7528224b651c86815c1/lib/_http_incoming.js#L128
-  React Native's fetch does this for *every* header, including set-cookie.
-
-  Based on: https://github.com/google/j2objc/commit/16820fdbc8f76ca0c33472810ce0cb03d20efe25
-  Credits to: https://github.com/tomball for original and https://github.com/chrusart for JavaScript implementation
-*/
-function splitCookiesString(cookiesString) {
-  if (Array.isArray(cookiesString)) {
-    return cookiesString;
-  }
-  if (typeof cookiesString !== "string") {
-    return [];
-  }
-
-  var cookiesStrings = [];
-  var pos = 0;
-  var start;
-  var ch;
-  var lastComma;
-  var nextStart;
-  var cookiesSeparatorFound;
-
-  function skipWhitespace() {
-    while (pos < cookiesString.length && /\s/.test(cookiesString.charAt(pos))) {
-      pos += 1;
-    }
-    return pos < cookiesString.length;
-  }
-
-  function notSpecialChar() {
-    ch = cookiesString.charAt(pos);
-
-    return ch !== "=" && ch !== ";" && ch !== ",";
-  }
-
-  while (pos < cookiesString.length) {
-    start = pos;
-    cookiesSeparatorFound = false;
-
-    while (skipWhitespace()) {
-      ch = cookiesString.charAt(pos);
-      if (ch === ",") {
-        // ',' is a cookie separator if we have later first '=', not ';' or ','
-        lastComma = pos;
-        pos += 1;
-
-        skipWhitespace();
-        nextStart = pos;
-
-        while (pos < cookiesString.length && notSpecialChar()) {
-          pos += 1;
-        }
-
-        // currently special character
-        if (pos < cookiesString.length && cookiesString.charAt(pos) === "=") {
-          // we found cookies separator
-          cookiesSeparatorFound = true;
-          // pos is inside the next cookie, so back up and return it.
-          pos = nextStart;
-          cookiesStrings.push(cookiesString.substring(start, lastComma));
-          start = pos;
-        } else {
-          // in param ',' or param separator ';',
-          // we continue from that comma
-          pos = lastComma + 1;
-        }
-      } else {
-        pos += 1;
-      }
-    }
-
-    if (!cookiesSeparatorFound || pos >= cookiesString.length) {
-      cookiesStrings.push(cookiesString.substring(start, cookiesString.length));
-    }
-  }
-
-  return cookiesStrings;
-}
-
-setCookie.exports = parse$1;
-setCookie.exports.parse = parse$1;
-setCookie.exports.parseString = parseString;
-setCookie.exports.splitCookiesString = splitCookiesString;
-
-(function (exports) {
-var __rest = (commonjsGlobal && commonjsGlobal.__rest) || function (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;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PERSISTENCY_KEY = void 0;
-const set_cookie_parser_1 = setCookie.exports;
-exports.PERSISTENCY_KEY = 'MSW_COOKIE_STORE';
-const SUPPORTS_LOCAL_STORAGE = typeof localStorage !== 'undefined';
-class CookieStore {
-    constructor() {
-        this.store = new Map();
-    }
-    /**
-     * Sets the given request cookies into the store.
-     * Respects the `request.credentials` policy.
-     */
-    add(request, response) {
-        if (request.credentials === 'omit') {
-            return;
-        }
-        const requestUrl = new URL(request.url);
-        const responseCookies = response.headers.get('set-cookie');
-        if (!responseCookies) {
-            return;
-        }
-        const now = Date.now();
-        const parsedResponseCookies = set_cookie_parser_1.parse(responseCookies).map((_a) => {
-            var { maxAge } = _a, cookie = __rest(_a, ["maxAge"]);
-            return (Object.assign(Object.assign({}, cookie), { expires: maxAge === undefined ? cookie.expires : new Date(now + maxAge * 1000), maxAge }));
-        });
-        const prevCookies = this.store.get(requestUrl.origin) || new Map();
-        parsedResponseCookies.forEach((cookie) => {
-            this.store.set(requestUrl.origin, prevCookies.set(cookie.name, cookie));
-        });
-    }
-    /**
-     * Returns cookies relevant to the given request
-     * and its `request.credentials` policy.
-     */
-    get(request) {
-        this.deleteExpiredCookies();
-        const requestUrl = new URL(request.url);
-        const originCookies = this.store.get(requestUrl.origin) || new Map();
-        switch (request.credentials) {
-            case 'include': {
-                const documentCookies = set_cookie_parser_1.parse(document.cookie);
-                documentCookies.forEach((cookie) => {
-                    originCookies.set(cookie.name, cookie);
-                });
-                return originCookies;
-            }
-            case 'same-origin': {
-                return originCookies;
-            }
-            default:
-                return new Map();
-        }
-    }
-    /**
-     * Returns a collection of all stored cookies.
-     */
-    getAll() {
-        this.deleteExpiredCookies();
-        return this.store;
-    }
-    /**
-     * Deletes all cookies associated with the given request.
-     */
-    deleteAll(request) {
-        const requestUrl = new URL(request.url);
-        this.store.delete(requestUrl.origin);
-    }
-    /**
-     * Clears the entire cookie store.
-     */
-    clear() {
-        this.store.clear();
-    }
-    /**
-     * Hydrates the virtual cookie store from the `localStorage` if defined.
-     */
-    hydrate() {
-        if (!SUPPORTS_LOCAL_STORAGE) {
-            return;
-        }
-        const persistedCookies = localStorage.getItem(exports.PERSISTENCY_KEY);
-        if (persistedCookies) {
-            try {
-                const parsedCookies = JSON.parse(persistedCookies);
-                parsedCookies.forEach(([origin, cookies]) => {
-                    this.store.set(origin, new Map(cookies.map((_a) => {
-                        var [token, _b] = _a, { expires } = _b, cookie = __rest(_b, ["expires"]);
-                        return [
-                            token,
-                            expires === undefined
-                                ? cookie
-                                : Object.assign(Object.assign({}, cookie), { expires: new Date(expires) }),
-                        ];
-                    })));
-                });
-            }
-            catch (error) {
-                console.warn(`
-[virtual-cookie] Failed to parse a stored cookie from the localStorage (key "${exports.PERSISTENCY_KEY}").
-
-Stored value:
-${localStorage.getItem(exports.PERSISTENCY_KEY)}
-
-Thrown exception:
-${error}
-
-Invalid value has been removed from localStorage to prevent subsequent failed parsing attempts.`);
-                localStorage.removeItem(exports.PERSISTENCY_KEY);
-            }
-        }
-    }
-    /**
-     * Persists the current virtual cookies into the `localStorage` if defined,
-     * so they are available on the next page load.
-     */
-    persist() {
-        if (!SUPPORTS_LOCAL_STORAGE) {
-            return;
-        }
-        const serializedCookies = Array.from(this.store.entries()).map(([origin, cookies]) => {
-            return [origin, Array.from(cookies.entries())];
-        });
-        localStorage.setItem(exports.PERSISTENCY_KEY, JSON.stringify(serializedCookies));
-    }
-    deleteExpiredCookies() {
-        const now = Date.now();
-        this.store.forEach((originCookies, origin) => {
-            originCookies.forEach(({ expires, name }) => {
-                if (expires !== undefined && expires.getTime() <= now) {
-                    originCookies.delete(name);
-                }
-            });
-            if (originCookies.size === 0) {
-                this.store.delete(origin);
-            }
-        });
-    }
-}
-exports.default = new CookieStore();
-}(CookieStore));
-
-(function (exports) {
-var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PERSISTENCY_KEY = exports.store = void 0;
-var CookieStore_1 = CookieStore;
-Object.defineProperty(exports, "store", { enumerable: true, get: function () { return __importDefault(CookieStore_1).default; } });
-Object.defineProperty(exports, "PERSISTENCY_KEY", { enumerable: true, get: function () { return CookieStore_1.PERSISTENCY_KEY; } });
-}(lib$1));
-
 function getAllCookies() {
     return parse_1(document.cookie);
 }
@@ -1387,7 +1016,7 @@ function getRequestCookies(request) {
     /**
      * @note No cookies persist on the document in Node.js: no document.
      */
-    if (typeof location === 'undefined') {
+    if (typeof document === 'undefined' || typeof location === 'undefined') {
         return {};
     }
     switch (request.credentials) {
@@ -1408,8 +1037,8 @@ function getRequestCookies(request) {
 
 function setRequestCookies(request) {
     var _a;
-    lib$1.store.hydrate();
-    request.cookies = Object.assign(Object.assign({}, getRequestCookies(request)), Array.from((_a = lib$1.store.get(Object.assign(Object.assign({}, request), { url: request.url.toString() }))) === null || _a === void 0 ? void 0 : _a.entries()).reduce((cookies, [name, { value }]) => Object.assign(cookies, { [name]: value }), {}));
+    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('; '));
@@ -2228,6 +1857,7 @@ function invariant(condition, message) {
 
 // istanbul ignore next (See: 'https://github.com/graphql/graphql-js/issues/2317')
 var nodejsCustomInspectSymbol = typeof Symbol === 'function' && typeof Symbol.for === 'function' ? Symbol.for('nodejs.util.inspect.custom') : undefined;
+var nodejsCustomInspectSymbol$1 = nodejsCustomInspectSymbol;
 
 /**
  * The `defineInspect()` function defines `inspect()` prototype method as alias of `toJSON`
@@ -2238,8 +1868,8 @@ function defineInspect(classObject) {
   typeof fn === 'function' || invariant(0);
   classObject.prototype.inspect = fn; // istanbul ignore else (See: 'https://github.com/graphql/graphql-js/issues/2317')
 
-  if (nodejsCustomInspectSymbol) {
-    classObject.prototype[nodejsCustomInspectSymbol] = fn;
+  if (nodejsCustomInspectSymbol$1) {
+    classObject.prototype[nodejsCustomInspectSymbol$1] = fn;
   }
 }
 
@@ -2482,7 +2112,7 @@ function formatArray(array, seenValues) {
 }
 
 function getCustomFn(object) {
-  var customInspectFn = object[String(nodejsCustomInspectSymbol)];
+  var customInspectFn = object[String(nodejsCustomInspectSymbol$1)];
 
   if (typeof customInspectFn === 'function') {
     return customInspectFn;
@@ -3402,7 +3032,7 @@ function isNameStart(code) {
  * Given a GraphQL source, parses it into a Document.
  * Throws GraphQLError if a syntax error is encountered.
  */
-function parse(source, options) {
+function parse$1(source, options) {
   var parser = new Parser(source, options);
   return parser.parseDocument();
 }
@@ -4921,7 +4551,7 @@ function parseDocumentNode(node) {
 }
 function parseQuery(query) {
     try {
-        const ast = parse(query);
+        const ast = parse$1(query);
         return parseDocumentNode(ast);
     }
     catch (error) {
@@ -5117,7 +4747,7 @@ function set(...args) {
             res.headers.append(name, value);
         }
         else {
-            const headers = lib$2.objectToHeaders(name);
+            const headers = lib$1.objectToHeaders(name);
             headers.forEach((value, name) => {
                 res.headers.append(name, value);
             });
@@ -5214,12 +4844,26 @@ const data = (payload) => {
     };
 };
 
+/**
+ * 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$4.exports.isNodeProcess()) {
+    if (lib$3.exports.isNodeProcess()) {
         return NODE_SERVER_RESPONSE_TIME;
     }
     return Math.floor(Math.random() * (MAX_SERVER_RESPONSE_TIME - MIN_SERVER_RESPONSE_TIME) +
@@ -5286,9 +4930,9 @@ const errors = (errorsList) => {
     };
 };
 
-const useFetch = lib$4.exports.isNodeProcess() ? require('node-fetch') : window.fetch;
+const useFetch = lib$3.exports.isNodeProcess() ? require('node-fetch') : window.fetch;
 const augmentRequestInit = (requestInit) => {
-    const headers = new lib$2.Headers(requestInit.headers);
+    const headers = new lib$1.Headers(requestInit.headers);
     headers.set('x-msw-bypass', 'true');
     return Object.assign(Object.assign({}, requestInit), { headers: headers.all() });
 };
@@ -5298,8 +4942,12 @@ const createFetchRequestParameters = (input) => {
     if (['GET', 'HEAD'].includes(method)) {
         return requestParameters;
     }
-    requestParameters.body =
-        typeof body === 'object' ? JSON.stringify(body) : body;
+    if (typeof body === 'object' || typeof body === 'number') {
+        requestParameters.body = JSON.stringify(body);
+    }
+    else {
+        requestParameters.body = body;
+    }
     return requestParameters;
 };
 /**
@@ -5388,63 +5036,345 @@ function prepareRequest(request) {
  * Formats a mocked response for introspection in the browser's console.
  */
 function prepareResponse(res) {
-    const responseHeaders = lib$2.objectToHeaders(res.headers);
+    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) });
 }
 
-/**
- * Converts a string path to a Regular Expression.
- * Transforms path parameters into named RegExp groups.
- */
-const pathToRegExp = (path) => {
-    const pattern = path
-        // Escape literal dots
-        .replace(/\./g, '\\.')
-        // Escape literal slashes
-        .replace(/\//g, '/')
-        // Escape literal question marks
-        .replace(/\?/g, '\\?')
-        // Ignore trailing slashes
-        .replace(/\/+$/, '')
-        // Replace wildcard with any zero-to-any character sequence
-        .replace(/\*+/g, '.*')
-        // Replace parameters with named capturing groups
-        .replace(/:([^\d|^\/][a-zA-Z0-9_]*(?=(?:\/|\\.)|$))/g, (_, paramName) => `(?<${paramName}>[^\/]+?)`)
-        // Allow optional trailing slash
-        .concat('(\\/|$)');
-    return new RegExp(pattern, 'gi');
-};
-
-/**
- * Matches a given url against a path.
- */
-const match = (path, url) => {
-    const expression = path instanceof RegExp ? path : pathToRegExp(path);
-    const match = expression.exec(url) || false;
-    // Matches in strict mode: match string should equal to input (url)
-    // Otherwise loose matches will be considered truthy:
-    // match('/messages/:id', '/messages/123/users') // true
-    const matches = path instanceof RegExp ? !!match : !!match && match[0] === match.input;
-    return {
-        matches,
-        params: match && matches ? match.groups || null : null,
-    };
-};
-
-var getCleanUrl$1 = {};
-
-Object.defineProperty(getCleanUrl$1, "__esModule", { value: true });
-var getCleanUrl_2 = getCleanUrl$1.getCleanUrl = void 0;
 /**
- * Removes query parameters and hashes from a given URL.
+ * 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 getCleanUrl(url, isAbsolute) {
-    if (isAbsolute === void 0) { isAbsolute = true; }
-    return [isAbsolute && url.origin, url.pathname].filter(Boolean).join('');
+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);
 }
-getCleanUrl_2 = getCleanUrl$1.getCleanUrl = getCleanUrl;
 
 const REDUNDANT_CHARACTERS_EXP = /[\?|#].*$/g;
 function getSearchParams(path) {
@@ -5466,9 +5396,12 @@ function getAbsoluteUrl(path, baseUrl) {
         return path;
     }
     // Resolve a relative request URL against a given custom "baseUrl"
-    // or the current location (in the case of browser/browser-like environments).
-    const origin = baseUrl || (typeof location !== 'undefined' && location.origin);
-    return origin ? new URL(path, origin).href : path;
+    // 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;
 }
 
 /**
@@ -5487,12 +5420,48 @@ function normalizePath(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 protocol so that "path-to-regexp" could match
+         * absolute URL.
+         * @see https://github.com/pillarjs/path-to-regexp/issues/259
+         */
+        .replace(/^([^\/]+)(:)(?=\/\/)/g, '$1\\$2'));
+}
 /**
  * Returns the result of matching given request URL against a mask.
  */
 function matchRequestUrl(url, path, baseUrl) {
     const normalizedPath = normalizePath(path, baseUrl);
-    return match(normalizedPath, getCleanUrl_2(url));
+    const cleanPath = typeof normalizedPath === 'string'
+        ? coercePath(normalizedPath)
+        : normalizedPath;
+    const cleanUrl = getCleanUrl.getCleanUrl(url);
+    const result = match(cleanPath, { decode: decodeURIComponent })(cleanUrl);
+    const params = (result && result.params) || {};
+    return {
+        matches: result !== false,
+        params,
+    };
 }
 
 /**
@@ -5527,7 +5496,7 @@ 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({
+            headers: new lib$1.Headers({
                 'x-powered-by': 'msw',
             }),
         }, responseOverrides);
@@ -5548,18 +5517,21 @@ const response = Object.assign(createResponseComposition(), {
     },
 });
 
+const BUILD_FRAME = /(node_modules)?[\/\\]lib[\/\\](umd|esm|iief|cjs)[\/\\]|^[^\/\\]*$/;
 /**
  * Return the stack trace frame of a function's invocation.
  */
-function getCallFrame() {
+function getCallFrame(error) {
     // In <IE11, new Error may return an undefined stack
-    const stack = (new Error().stack || '');
-    const frames = stack.split('\n');
+    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 ignoreFrameRegExp = /(node_modules)?[\/\\]lib[\/\\](umd|esm|iief|cjs)[\/\\]|^[^\/\\]*$/;
-    const declarationFrame = frames.slice(1).find((frame) => {
-        return !ignoreFrameRegExp.test(frame);
+    const declarationFrame = frames.find((frame) => {
+        return !BUILD_FRAME.test(frame);
     });
     if (!declarationFrame) {
         return;
@@ -5592,7 +5564,7 @@ class RequestHandler {
         this.shouldSkip = false;
         this.ctx = options.ctx || defaultContext;
         this.resolver = options.resolver;
-        const callFrame = getCallFrame();
+        const callFrame = getCallFrame(new Error());
         this.info = Object.assign(Object.assign({}, options.info), { callFrame });
     }
     /**
@@ -5719,21 +5691,9 @@ class RestHandler extends RequestHandler {
             return;
         }
         const searchParams = getSearchParams(path);
-        const queryParams = [];
         searchParams.forEach((_, paramName) => {
-            queryParams.push(paramName);
         });
-        devUtils.warn(`\
-Found a redundant usage of query parameters in the request handler URL for "${method} ${path}". Please match against a path instead, and access query parameters in the response resolver function:
-
-rest.${method.toLowerCase()}("${url}", (req, res, ctx) => {
-  const query = req.url.searchParams
-${queryParams
-            .map((paramName) => `\
-  const ${paramName} = query.get("${paramName}")`)
-            .join('\n')}
-})\
-      `);
+        devUtils.warn(`Found a redundant usage of query parameters in the request handler URL for "${method} ${path}". Please match against a path instead and access query parameters in the response resolver function using "req.url.searchParams".`);
     }
     parse(request, resolutionContext) {
         return matchRequestUrl(request.url, this.info.path, resolutionContext === null || resolutionContext === void 0 ? void 0 : resolutionContext.baseUrl);
@@ -5742,7 +5702,11 @@ ${queryParams
         return Object.assign(Object.assign({}, request), { params: parsedResult.params || {} });
     }
     predicate(request, parsedResult) {
-        return (isStringEqual(this.info.method, request.method) && parsedResult.matches);
+        const matchesMethod = this.info.method instanceof RegExp
+            ? this.info.method.test(request.method)
+            : isStringEqual(this.info.method, request.method);
+        // console.log({ request, matchesMethod, parsedResult })
+        return matchesMethod && parsedResult.matches;
     }
     log(request, response) {
         const publicUrl = getPublicUrlFromRequest(request);
@@ -5776,6 +5740,7 @@ const graphqlContext = {
     delay,
     fetch,
     data,
+    extensions,
     errors,
     cookie,
 };
@@ -5822,10 +5787,10 @@ class GraphQLHandler extends RequestHandler {
         if (!parsedResult) {
             return false;
         }
-        if (!parsedResult.operationName) {
+        if (!parsedResult.operationName && this.info.operationType !== 'all') {
             const publicUrl = getPublicUrlFromRequest(request);
             devUtils.warn(`\
-Failed to intercept a GraphQL request at "${request.method} ${publicUrl}": unnamed GraphQL operations are not supported.
+Failed to intercept a GraphQL request at "${request.method} ${publicUrl}": anonymous GraphQL operations are not supported.
 
 Consider naming this operation or using "graphql.operation" request handler to intercept GraphQL requests regardless of their operation name/type. Read more: https://mswjs.io/docs/api/graphql/operation\
       `);
@@ -5835,7 +5800,7 @@ Consider naming this operation or using "graphql.operation" request handler to i
         const hasMatchingOperationType = this.info.operationType === 'all' ||
             parsedResult.operationType === this.info.operationType;
         const hasMatchingOperationName = this.info.operationName instanceof RegExp
-            ? this.info.operationName.test(parsedResult.operationName)
+            ? this.info.operationName.test(parsedResult.operationName || '')
             : parsedResult.operationName === this.info.operationName;
         return (hasMatchingUrl.matches &&
             hasMatchingOperationType &&
@@ -5845,7 +5810,10 @@ Consider naming this operation or using "graphql.operation" request handler to i
         const loggedRequest = prepareRequest(request);
         const loggedResponse = prepareResponse(response);
         const statusColor = getStatusCodeColor(response.status);
-        console.groupCollapsed(devUtils.formatMessage('%s %s (%c%s%c)'), getTimestamp(), `${parsedRequest === null || parsedRequest === void 0 ? void 0 : parsedRequest.operationType} ${parsedRequest === null || parsedRequest === void 0 ? void 0 : parsedRequest.operationName}`, `color:${statusColor}`, `${response.status} ${response.statusText}`, 'color:inherit');
+        const requestInfo = (parsedRequest === null || parsedRequest === void 0 ? void 0 : parsedRequest.operationName)
+            ? `${parsedRequest === null || parsedRequest === void 0 ? void 0 : parsedRequest.operationType} ${parsedRequest === null || parsedRequest === void 0 ? void 0 : parsedRequest.operationName}`
+            : `anonymous ${parsedRequest === null || parsedRequest === void 0 ? void 0 : parsedRequest.operationType}`;
+        console.groupCollapsed(devUtils.formatMessage('%s %s (%c%s%c)'), getTimestamp(), `${requestInfo}`, `color:${statusColor}`, `${response.status} ${response.statusText}`, 'color:inherit');
         console.log('Request:', loggedRequest);
         console.log('Handler:', this);
         console.log('Response:', loggedResponse);
@@ -5959,8 +5927,10 @@ Read more: https://mswjs.io/docs/getting-started/mocks\
     const message = messageTemplate.join('\n\n');
     switch (strategy) {
         case 'error': {
+            // Print a developer-friendly error.
             devUtils.error('Error: %s', message);
-            break;
+            // Throw an exception to halt request processing and not perform the original request.
+            throw new Error('Cannot bypass a request when using the "error" strategy for the "onUnhandledRequest" option.');
         }
         case 'warn': {
             devUtils.warn('Warning: %s', message);
@@ -5974,8 +5944,8 @@ Read more: https://mswjs.io/docs/getting-started/mocks\
 }
 
 function readResponseCookies(request, response) {
-    lib$1.store.add(Object.assign(Object.assign({}, request), { url: request.url.toString() }), response);
-    lib$1.store.persist();
+    cookies.store.add(Object.assign(Object.assign({}, request), { url: request.url.toString() }), response);
+    cookies.store.persist();
 }
 
 function handleRequest(request, handlers, options, emitter, handleRequestOptions) {
@@ -6003,7 +5973,12 @@ function handleRequest(request, handlers, options, emitter, handleRequestOptions
         // When the handled request returned no mocked response, warn the developer,
         // as it may be an oversight on their part. Perform the request as-is.
         if (!response) {
-            devUtils.warn('Expected a mocking resolver function to return a mocked response Object, but got: %s. Original response is going to be used instead.', response);
+            devUtils.warn(`\
+Expected response resolver to return a mocked response Object, but got %s. The original response is going to be used instead.\
+\n
+  \u2022 %s
+    %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);
             return;
@@ -6027,6 +6002,23 @@ function handleRequest(request, handlers, options, emitter, handleRequestOptions
     });
 }
 
+/**
+ * Pipes all emitted events from one emitter to another.
+ */
+function pipeEvents(source, destination) {
+    const rawEmit = source.emit;
+    // @ts-ignore
+    if (rawEmit._isPiped) {
+        return;
+    }
+    source.emit = function (event, ...data) {
+        destination.emit(event, ...data);
+        return rawEmit.call(this, event, ...data);
+    };
+    // @ts-ignore
+    source.emit._isPiped = true;
+}
+
 const DEFAULT_LISTEN_OPTIONS = {
     onUnhandledRequest: 'warn',
 };
@@ -6035,7 +6027,9 @@ const DEFAULT_LISTEN_OPTIONS = {
  * Useful to generate identical API using different patches to request issuing modules.
  */
 function createSetupServer(...interceptors$1) {
-    const emitter = new lib$3.StrictEventEmitter();
+    const emitter = new lib$2.StrictEventEmitter();
+    const publicEmitter = new lib$2.StrictEventEmitter();
+    pipeEvents(emitter, publicEmitter);
     return function setupServer(...requestHandlers) {
         requestHandlers.forEach((handler) => {
             if (Array.isArray(handler))
@@ -6045,7 +6039,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$4.exports.isNodeProcess()) {
+        if (!lib$3.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 = {};
@@ -6105,11 +6099,20 @@ ${chalk.bold(`${pragma} ${header}`)}
 `);
                 });
             },
-            on(eventType, listener) {
-                emitter.addListener(eventType, listener);
+            events: {
+                on(...args) {
+                    return publicEmitter.on(...args);
+                },
+                removeListener(...args) {
+                    return publicEmitter.removeListener(...args);
+                },
+                removeAllListeners(...args) {
+                    return publicEmitter.removeAllListeners(...args);
+                },
             },
             close() {
                 emitter.removeAllListeners();
+                publicEmitter.removeAllListeners();
                 interceptor.restore();
             },
         };