@mswjs/interceptors 0.32.2 → 0.33.1

package/lib/browser/chunk-NU2MPFD6.mjs

@@ -0,0 +1,142 @@
+import {
+  RequestController,
+  emitAsync,
+  handleRequest
+} from "./chunk-7A4UJNSW.mjs";
+import {
+  IS_PATCHED_MODULE
+} from "./chunk-GGUENBDN.mjs";
+import {
+  Interceptor,
+  createRequestId
+} from "./chunk-QED3Q6Z2.mjs";
+
+// src/interceptors/fetch/index.ts
+import { invariant } from "outvariant";
+import { DeferredPromise } from "@open-draft/deferred-promise";
+
+// src/utils/canParseUrl.ts
+function canParseUrl(url) {
+  try {
+    new URL(url);
+    return true;
+  } catch (_error) {
+    return false;
+  }
+}
+
+// src/interceptors/fetch/index.ts
+var _FetchInterceptor = class extends Interceptor {
+  constructor() {
+    super(_FetchInterceptor.symbol);
+  }
+  checkEnvironment() {
+    return typeof globalThis !== "undefined" && typeof globalThis.fetch !== "undefined";
+  }
+  async setup() {
+    const pureFetch = globalThis.fetch;
+    invariant(
+      !pureFetch[IS_PATCHED_MODULE],
+      'Failed to patch the "fetch" module: already patched.'
+    );
+    globalThis.fetch = async (input, init) => {
+      const requestId = createRequestId();
+      const resolvedInput = typeof input === "string" && typeof location !== "undefined" && !canParseUrl(input) ? new URL(input, location.origin) : input;
+      const request = new Request(resolvedInput, init);
+      const responsePromise = new DeferredPromise();
+      const controller = new RequestController(request);
+      this.logger.info("[%s] %s", request.method, request.url);
+      this.logger.info("awaiting for the mocked response...");
+      this.logger.info(
+        'emitting the "request" event for %s listener(s)...',
+        this.emitter.listenerCount("request")
+      );
+      const isRequestHandled = await handleRequest({
+        request,
+        requestId,
+        emitter: this.emitter,
+        controller,
+        onResponse: async (response) => {
+          this.logger.info("received mocked response!", {
+            response
+          });
+          if (this.emitter.listenerCount("response") > 0) {
+            this.logger.info('emitting the "response" event...');
+            await emitAsync(this.emitter, "response", {
+              // Clone the mocked response for the "response" event listener.
+              // This way, the listener can read the response and not lock its body
+              // for the actual fetch consumer.
+              response: response.clone(),
+              isMockedResponse: true,
+              request,
+              requestId
+            });
+          }
+          Object.defineProperty(response, "url", {
+            writable: false,
+            enumerable: true,
+            configurable: false,
+            value: request.url
+          });
+          responsePromise.resolve(response);
+        },
+        onRequestError: (response) => {
+          this.logger.info("request has errored!", { response });
+          responsePromise.reject(createNetworkError(response));
+        },
+        onError: (error) => {
+          this.logger.info("request has been aborted!", { error });
+          responsePromise.reject(error);
+        }
+      });
+      if (isRequestHandled) {
+        this.logger.info("request has been handled, returning mock promise...");
+        return responsePromise;
+      }
+      this.logger.info(
+        "no mocked response received, performing request as-is..."
+      );
+      return pureFetch(request).then((response) => {
+        this.logger.info("original fetch performed", response);
+        if (this.emitter.listenerCount("response") > 0) {
+          this.logger.info('emitting the "response" event...');
+          const responseClone = response.clone();
+          this.emitter.emit("response", {
+            response: responseClone,
+            isMockedResponse: false,
+            request,
+            requestId
+          });
+        }
+        return response;
+      });
+    };
+    Object.defineProperty(globalThis.fetch, IS_PATCHED_MODULE, {
+      enumerable: true,
+      configurable: true,
+      value: true
+    });
+    this.subscriptions.push(() => {
+      Object.defineProperty(globalThis.fetch, IS_PATCHED_MODULE, {
+        value: void 0
+      });
+      globalThis.fetch = pureFetch;
+      this.logger.info(
+        'restored native "globalThis.fetch"!',
+        globalThis.fetch.name
+      );
+    });
+  }
+};
+var FetchInterceptor = _FetchInterceptor;
+FetchInterceptor.symbol = Symbol("fetch");
+function createNetworkError(cause) {
+  return Object.assign(new TypeError("Failed to fetch"), {
+    cause
+  });
+}
+
+export {
+  FetchInterceptor
+};
+//# sourceMappingURL=chunk-NU2MPFD6.mjs.map

package/lib/browser/chunk-NU2MPFD6.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/interceptors/fetch/index.ts","../../src/utils/canParseUrl.ts"],"sourcesContent":["import { invariant } from 'outvariant'\nimport { DeferredPromise } from '@open-draft/deferred-promise'\nimport { HttpRequestEventMap, IS_PATCHED_MODULE } from '../../glossary'\nimport { Interceptor } from '../../Interceptor'\nimport { RequestController } from '../../RequestController'\nimport { emitAsync } from '../../utils/emitAsync'\nimport { handleRequest } from '../../utils/handleRequest'\nimport { canParseUrl } from '../../utils/canParseUrl'\nimport { createRequestId } from '../../createRequestId'\n\nexport class FetchInterceptor extends Interceptor<HttpRequestEventMap> {\n  static symbol = Symbol('fetch')\n\n  constructor() {\n    super(FetchInterceptor.symbol)\n  }\n\n  protected checkEnvironment() {\n    return (\n      typeof globalThis !== 'undefined' &&\n      typeof globalThis.fetch !== 'undefined'\n    )\n  }\n\n  protected async setup() {\n    const pureFetch = globalThis.fetch\n\n    invariant(\n      !(pureFetch as any)[IS_PATCHED_MODULE],\n      'Failed to patch the \"fetch\" module: already patched.'\n    )\n\n    globalThis.fetch = async (input, init) => {\n      const requestId = createRequestId()\n\n      /**\n       * @note Resolve potentially relative request URL\n       * against the present `location`. This is mainly\n       * for native `fetch` in JSDOM.\n       * @see https://github.com/mswjs/msw/issues/1625\n       */\n      const resolvedInput =\n        typeof input === 'string' &&\n        typeof location !== 'undefined' &&\n        !canParseUrl(input)\n          ? new URL(input, location.origin)\n          : input\n\n      const request = new Request(resolvedInput, init)\n      const responsePromise = new DeferredPromise<Response>()\n      const controller = new RequestController(request)\n\n      this.logger.info('[%s] %s', request.method, request.url)\n      this.logger.info('awaiting for the mocked response...')\n\n      this.logger.info(\n        'emitting the \"request\" event for %s listener(s)...',\n        this.emitter.listenerCount('request')\n      )\n\n      const isRequestHandled = await handleRequest({\n        request,\n        requestId,\n        emitter: this.emitter,\n        controller,\n        onResponse: async (response) => {\n          this.logger.info('received mocked response!', {\n            response,\n          })\n\n          if (this.emitter.listenerCount('response') > 0) {\n            this.logger.info('emitting the \"response\" event...')\n\n            // Await the response listeners to finish before resolving\n            // the response promise. This ensures all your logic finishes\n            // before the interceptor resolves the pending response.\n            await emitAsync(this.emitter, 'response', {\n              // Clone the mocked response for the \"response\" event listener.\n              // This way, the listener can read the response and not lock its body\n              // for the actual fetch consumer.\n              response: response.clone(),\n              isMockedResponse: true,\n              request,\n              requestId,\n            })\n          }\n\n          // Set the \"response.url\" property to equal the intercepted request URL.\n          Object.defineProperty(response, 'url', {\n            writable: false,\n            enumerable: true,\n            configurable: false,\n            value: request.url,\n          })\n\n          responsePromise.resolve(response)\n        },\n        onRequestError: (response) => {\n          this.logger.info('request has errored!', { response })\n          responsePromise.reject(createNetworkError(response))\n        },\n        onError: (error) => {\n          this.logger.info('request has been aborted!', { error })\n          responsePromise.reject(error)\n        },\n      })\n\n      if (isRequestHandled) {\n        this.logger.info('request has been handled, returning mock promise...')\n        return responsePromise\n      }\n\n      this.logger.info(\n        'no mocked response received, performing request as-is...'\n      )\n\n      return pureFetch(request).then((response) => {\n        this.logger.info('original fetch performed', response)\n\n        if (this.emitter.listenerCount('response') > 0) {\n          this.logger.info('emitting the \"response\" event...')\n\n          const responseClone = response.clone()\n\n          this.emitter.emit('response', {\n            response: responseClone,\n            isMockedResponse: false,\n            request,\n            requestId,\n          })\n        }\n\n        return response\n      })\n    }\n\n    Object.defineProperty(globalThis.fetch, IS_PATCHED_MODULE, {\n      enumerable: true,\n      configurable: true,\n      value: true,\n    })\n\n    this.subscriptions.push(() => {\n      Object.defineProperty(globalThis.fetch, IS_PATCHED_MODULE, {\n        value: undefined,\n      })\n\n      globalThis.fetch = pureFetch\n\n      this.logger.info(\n        'restored native \"globalThis.fetch\"!',\n        globalThis.fetch.name\n      )\n    })\n  }\n}\n\nfunction createNetworkError(cause: unknown) {\n  return Object.assign(new TypeError('Failed to fetch'), {\n    cause,\n  })\n}\n","/**\n * Returns a boolean indicating whether the given URL string\n * can be parsed into a `URL` instance.\n * A substitute for `URL.canParse()` for Node.js 18.\n */\nexport function canParseUrl(url: string): boolean {\n  try {\n    new URL(url)\n    return true\n  } catch (_error) {\n    return false\n  }\n}\n"],"mappings":"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","names":[]}

package/lib/browser/chunk-VRKVKT62.js

@@ -0,0 +1,196 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunkFXSPMSSQjs = require('./chunk-FXSPMSSQ.js');
+
+// src/RequestController.ts
+var _outvariant = require('outvariant');
+var _deferredpromise = require('@open-draft/deferred-promise');
+
+// src/InterceptorError.ts
+var InterceptorError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InterceptorError";
+    Object.setPrototypeOf(this, InterceptorError.prototype);
+  }
+};
+
+// src/RequestController.ts
+var kRequestHandled = Symbol("kRequestHandled");
+var kResponsePromise = Symbol("kResponsePromise");
+var RequestController = class {
+  constructor(request) {
+    this.request = request;
+    this[kRequestHandled] = false;
+    this[kResponsePromise] = new (0, _deferredpromise.DeferredPromise)();
+  }
+  /**
+   * Respond to this request with the given `Response` instance.
+   * @example
+   * controller.respondWith(new Response())
+   * controller.respondWith(Response.json({ id }))
+   * controller.respondWith(Response.error())
+   */
+  respondWith(response) {
+    _outvariant.invariant.as(
+      InterceptorError,
+      !this[kRequestHandled],
+      'Failed to respond to the "%s %s" request: the "request" event has already been handled.',
+      this.request.method,
+      this.request.url
+    );
+    this[kRequestHandled] = true;
+    this[kResponsePromise].resolve(response);
+  }
+  /**
+   * Error this request with the given error.
+   * @example
+   * controller.errorWith()
+   * controller.errorWith(new Error('Oops!'))
+   */
+  errorWith(error) {
+    _outvariant.invariant.as(
+      InterceptorError,
+      !this[kRequestHandled],
+      'Failed to error the "%s %s" request: the "request" event has already been handled.',
+      this.request.method,
+      this.request.url
+    );
+    this[kRequestHandled] = true;
+    this[kResponsePromise].resolve(error);
+  }
+};
+kResponsePromise, kRequestHandled;
+
+// src/utils/emitAsync.ts
+async function emitAsync(emitter, eventName, ...data) {
+  const listners = emitter.listeners(eventName);
+  if (listners.length === 0) {
+    return;
+  }
+  for (const listener of listners) {
+    await listener.apply(emitter, data);
+  }
+}
+
+// src/utils/handleRequest.ts
+
+var _until = require('@open-draft/until');
+
+// src/utils/isNodeLikeError.ts
+function isNodeLikeError(error) {
+  if (error == null) {
+    return false;
+  }
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  return "code" in error && "errno" in error;
+}
+
+// src/utils/handleRequest.ts
+async function handleRequest(options) {
+  const handleResponse = (response) => {
+    if (response instanceof Error) {
+      options.onError(response);
+    } else if (_chunkFXSPMSSQjs.isResponseError.call(void 0, response)) {
+      options.onRequestError(response);
+    } else {
+      options.onResponse(response);
+    }
+    return true;
+  };
+  const handleResponseError = (error) => {
+    if (error instanceof InterceptorError) {
+      throw result.error;
+    }
+    if (isNodeLikeError(error)) {
+      options.onError(error);
+      return true;
+    }
+    if (error instanceof Response) {
+      return handleResponse(error);
+    }
+    return false;
+  };
+  options.emitter.once("request", ({ requestId: pendingRequestId }) => {
+    if (pendingRequestId !== options.requestId) {
+      return;
+    }
+    if (options.controller[kResponsePromise].state === "pending") {
+      options.controller[kResponsePromise].resolve(void 0);
+    }
+  });
+  const requestAbortPromise = new (0, _deferredpromise.DeferredPromise)();
+  if (options.request.signal) {
+    options.request.signal.addEventListener(
+      "abort",
+      () => {
+        requestAbortPromise.reject(options.request.signal.reason);
+      },
+      { once: true }
+    );
+  }
+  const result = await _until.until.call(void 0, async () => {
+    const requestListtenersPromise = emitAsync(options.emitter, "request", {
+      requestId: options.requestId,
+      request: options.request,
+      controller: options.controller
+    });
+    await Promise.race([
+      // Short-circuit the request handling promise if the request gets aborted.
+      requestAbortPromise,
+      requestListtenersPromise,
+      options.controller[kResponsePromise]
+    ]);
+    const mockedResponse = await options.controller[kResponsePromise];
+    return mockedResponse;
+  });
+  if (requestAbortPromise.state === "rejected") {
+    options.onError(requestAbortPromise.rejectionReason);
+    return true;
+  }
+  if (result.error) {
+    if (handleResponseError(result.error)) {
+      return true;
+    }
+    if (options.emitter.listenerCount("unhandledException") > 0) {
+      const unhandledExceptionController = new RequestController(
+        options.request
+      );
+      await emitAsync(options.emitter, "unhandledException", {
+        error: result.error,
+        request: options.request,
+        requestId: options.requestId,
+        controller: unhandledExceptionController
+      }).then(() => {
+        if (unhandledExceptionController[kResponsePromise].state === "pending") {
+          unhandledExceptionController[kResponsePromise].resolve(void 0);
+        }
+      });
+      const nextResult = await _until.until.call(void 0, 
+        () => unhandledExceptionController[kResponsePromise]
+      );
+      if (nextResult.error) {
+        return handleResponseError(nextResult.error);
+      }
+      if (nextResult.data) {
+        return handleResponse(nextResult.data);
+      }
+    }
+    options.onResponse(_chunkFXSPMSSQjs.createServerErrorResponse.call(void 0, result.error));
+    return true;
+  }
+  if (result.data) {
+    return handleResponse(result.data);
+  }
+  return false;
+}
+
+
+
+
+
+exports.RequestController = RequestController; exports.emitAsync = emitAsync; exports.handleRequest = handleRequest;
+//# sourceMappingURL=chunk-VRKVKT62.js.map

package/lib/browser/chunk-VRKVKT62.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/RequestController.ts","../../src/InterceptorError.ts","../../src/utils/emitAsync.ts","../../src/utils/handleRequest.ts","../../src/utils/isNodeLikeError.ts"],"names":["DeferredPromise"],"mappings":"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","sourcesContent":["import { invariant } from 'outvariant'\nimport { DeferredPromise } from '@open-draft/deferred-promise'\nimport { InterceptorError } from './InterceptorError'\n\nconst kRequestHandled = Symbol('kRequestHandled')\nexport const kResponsePromise = Symbol('kResponsePromise')\n\nexport class RequestController {\n  /**\n   * Internal response promise.\n   * Available only for the library internals to grab the\n   * response instance provided by the developer.\n   * @note This promise cannot be rejected. It's either infinitely\n   * pending or resolved with whichever Response was passed to `respondWith()`.\n   */\n  [kResponsePromise]: DeferredPromise<Response | Error | undefined>;\n\n  /**\n   * Internal flag indicating if this request has been handled.\n   * @note The response promise becomes \"fulfilled\" on the next tick.\n   */\n  [kRequestHandled]: boolean\n\n  constructor(private request: Request) {\n    this[kRequestHandled] = false\n    this[kResponsePromise] = new DeferredPromise()\n  }\n\n  /**\n   * Respond to this request with the given `Response` instance.\n   * @example\n   * controller.respondWith(new Response())\n   * controller.respondWith(Response.json({ id }))\n   * controller.respondWith(Response.error())\n   */\n  public respondWith(response: Response): void {\n    invariant.as(\n      InterceptorError,\n      !this[kRequestHandled],\n      'Failed to respond to the \"%s %s\" request: the \"request\" event has already been handled.',\n      this.request.method,\n      this.request.url\n    )\n\n    this[kRequestHandled] = true\n    this[kResponsePromise].resolve(response)\n\n    /**\n     * @note The request conrtoller doesn't do anything\n     * apart from letting the interceptor await the response\n     * provided by the developer through the response promise.\n     * Each interceptor implements the actual respondWith/errorWith\n     * logic based on that interceptor's needs.\n     */\n  }\n\n  /**\n   * Error this request with the given error.\n   * @example\n   * controller.errorWith()\n   * controller.errorWith(new Error('Oops!'))\n   */\n  public errorWith(error?: Error): void {\n    invariant.as(\n      InterceptorError,\n      !this[kRequestHandled],\n      'Failed to error the \"%s %s\" request: the \"request\" event has already been handled.',\n      this.request.method,\n      this.request.url\n    )\n\n    this[kRequestHandled] = true\n\n    /**\n     * @note Resolve the response promise, not reject.\n     * This helps us differentiate between unhandled exceptions\n     * and intended errors (\"errorWith\") while waiting for the response.\n     */\n    this[kResponsePromise].resolve(error)\n  }\n}\n","export class InterceptorError extends Error {\n  constructor(message?: string) {\n    super(message)\n    this.name = 'InterceptorError'\n    Object.setPrototypeOf(this, InterceptorError.prototype)\n  }\n}\n","import { Emitter, EventMap } from 'strict-event-emitter'\n\n/**\n * Emits an event on the given emitter but executes\n * the listeners sequentially. This accounts for asynchronous\n * listeners (e.g. those having \"sleep\" and handling the request).\n */\nexport async function emitAsync<\n  Events extends EventMap,\n  EventName extends keyof Events\n>(\n  emitter: Emitter<Events>,\n  eventName: EventName,\n  ...data: Events[EventName]\n): Promise<void> {\n  const listners = emitter.listeners(eventName)\n\n  if (listners.length === 0) {\n    return\n  }\n\n  for (const listener of listners) {\n    await listener.apply(emitter, data)\n  }\n}\n","import type { Emitter } from 'strict-event-emitter'\nimport { DeferredPromise } from '@open-draft/deferred-promise'\nimport { until } from '@open-draft/until'\nimport type { HttpRequestEventMap } from '../glossary'\nimport { emitAsync } from './emitAsync'\nimport { kResponsePromise, RequestController } from '../RequestController'\nimport {\n  createServerErrorResponse,\n  isResponseError,\n  ResponseError,\n} from './responseUtils'\nimport { InterceptorError } from '../InterceptorError'\nimport { isNodeLikeError } from './isNodeLikeError'\n\ninterface HandleRequestOptions {\n  requestId: string\n  request: Request\n  emitter: Emitter<HttpRequestEventMap>\n  controller: RequestController\n\n  /**\n   * Called when the request has been handled\n   * with the given `Response` instance.\n   */\n  onResponse: (response: Response) => void\n\n  /**\n   * Called when the request has been handled\n   * with the given `Response.error()` instance.\n   */\n  onRequestError: (response: ResponseError) => void\n\n  /**\n   * Called when an unhandled error happens during the\n   * request handling. This is never a thrown error/response.\n   */\n  onError: (error: unknown) => void\n}\n\n/**\n * @returns {Promise<boolean>} Indicates whether the request has been handled.\n */\nexport async function handleRequest(\n  options: HandleRequestOptions\n): Promise<boolean> {\n  const handleResponse = (response: Response | Error): true => {\n    if (response instanceof Error) {\n      options.onError(response)\n    }\n\n    // Handle \"Response.error()\" instances.\n    else if (isResponseError(response)) {\n      options.onRequestError(response)\n    } else {\n      options.onResponse(response)\n    }\n\n    return true\n  }\n\n  const handleResponseError = (error: unknown): boolean => {\n    // Forward the special interceptor error instances\n    // to the developer. These must not be handled in any way.\n    if (error instanceof InterceptorError) {\n      throw result.error\n    }\n\n    // Support mocking Node.js-like errors.\n    if (isNodeLikeError(error)) {\n      options.onError(error)\n      return true\n    }\n\n    // Handle thrown responses.\n    if (error instanceof Response) {\n      return handleResponse(error)\n    }\n\n    return false\n  }\n\n  // Add the last \"request\" listener to check if the request\n  // has been handled in any way. If it hasn't, resolve the\n  // response promise with undefined.\n  options.emitter.once('request', ({ requestId: pendingRequestId }) => {\n    if (pendingRequestId !== options.requestId) {\n      return\n    }\n\n    if (options.controller[kResponsePromise].state === 'pending') {\n      options.controller[kResponsePromise].resolve(undefined)\n    }\n  })\n\n  const requestAbortPromise = new DeferredPromise<void, unknown>()\n\n  /**\n   * @note `signal` is not always defined in React Native.\n   */\n  if (options.request.signal) {\n    options.request.signal.addEventListener(\n      'abort',\n      () => {\n        requestAbortPromise.reject(options.request.signal.reason)\n      },\n      { once: true }\n    )\n  }\n\n  const result = await until(async () => {\n    // Emit the \"request\" event and wait until all the listeners\n    // for that event are finished (e.g. async listeners awaited).\n    // By the end of this promise, the developer cannot affect the\n    // request anymore.\n    const requestListtenersPromise = emitAsync(options.emitter, 'request', {\n      requestId: options.requestId,\n      request: options.request,\n      controller: options.controller,\n    })\n\n    await Promise.race([\n      // Short-circuit the request handling promise if the request gets aborted.\n      requestAbortPromise,\n      requestListtenersPromise,\n      options.controller[kResponsePromise],\n    ])\n\n    // The response promise will settle immediately once\n    // the developer calls either \"respondWith\" or \"errorWith\".\n    const mockedResponse = await options.controller[kResponsePromise]\n    return mockedResponse\n  })\n\n  // Handle the request being aborted while waiting for the request listeners.\n  if (requestAbortPromise.state === 'rejected') {\n    options.onError(requestAbortPromise.rejectionReason)\n    return true\n  }\n\n  if (result.error) {\n    // Handle the error during the request listener execution.\n    // These can be thrown responses or request errors.\n    if (handleResponseError(result.error)) {\n      return true\n    }\n\n    // If the developer has added \"unhandledException\" listeners,\n    // allow them to handle the error. They can translate it to a\n    // mocked response, network error, or forward it as-is.\n    if (options.emitter.listenerCount('unhandledException') > 0) {\n      // Create a new request controller just for the unhandled exception case.\n      // This is needed because the original controller might have been already\n      // interacted with (e.g. \"respondWith\" or \"errorWith\" called on it).\n      const unhandledExceptionController = new RequestController(\n        options.request\n      )\n\n      await emitAsync(options.emitter, 'unhandledException', {\n        error: result.error,\n        request: options.request,\n        requestId: options.requestId,\n        controller: unhandledExceptionController,\n      }).then(() => {\n        // If all the \"unhandledException\" listeners have finished\n        // but have not handled the response in any way, preemptively\n        // resolve the pending response promise from the new controller.\n        // This prevents it from hanging forever.\n        if (\n          unhandledExceptionController[kResponsePromise].state === 'pending'\n        ) {\n          unhandledExceptionController[kResponsePromise].resolve(undefined)\n        }\n      })\n\n      const nextResult = await until(\n        () => unhandledExceptionController[kResponsePromise]\n      )\n\n      /**\n       * @note Handle the result of the unhandled controller\n       * in the same way as the original request controller.\n       * The exception here is that thrown errors within the\n       * \"unhandledException\" event do NOT result in another\n       * emit of the same event. They are forwarded as-is.\n       */\n      if (nextResult.error) {\n        return handleResponseError(nextResult.error)\n      }\n\n      if (nextResult.data) {\n        return handleResponse(nextResult.data)\n      }\n    }\n\n    // Otherwise, coerce unhandled exceptions to a 500 Internal Server Error response.\n    options.onResponse(createServerErrorResponse(result.error))\n    return true\n  }\n\n  /**\n   * Handle a mocked Response instance.\n   * @note That this can also be an Error in case\n   * the developer called \"errorWith\". This differentiates\n   * unhandled exceptions from intended errors.\n   */\n  if (result.data) {\n    return handleResponse(result.data)\n  }\n\n  // In all other cases, consider the request unhandled.\n  // The interceptor must perform it as-is.\n  return false\n}\n","export function isNodeLikeError(\n  error: unknown\n): error is NodeJS.ErrnoException {\n  if (error == null) {\n    return false\n  }\n\n  if (!(error instanceof Error)) {\n    return false\n  }\n\n  return 'code' in error && 'errno' in error\n}\n"]}

package/lib/browser/glossary-7d7adb4b.d.ts

@@ -0,0 +1,66 @@
+import { DeferredPromise } from '@open-draft/deferred-promise';
+
+declare const kRequestHandled: unique symbol;
+declare const kResponsePromise: unique symbol;
+declare class RequestController {
+    private request;
+    /**
+     * Internal response promise.
+     * Available only for the library internals to grab the
+     * response instance provided by the developer.
+     * @note This promise cannot be rejected. It's either infinitely
+     * pending or resolved with whichever Response was passed to `respondWith()`.
+     */
+    [kResponsePromise]: DeferredPromise<Response | Error | undefined>;
+    /**
+     * Internal flag indicating if this request has been handled.
+     * @note The response promise becomes "fulfilled" on the next tick.
+     */
+    [kRequestHandled]: boolean;
+    constructor(request: Request);
+    /**
+     * Respond to this request with the given `Response` instance.
+     * @example
+     * controller.respondWith(new Response())
+     * controller.respondWith(Response.json({ id }))
+     * controller.respondWith(Response.error())
+     */
+    respondWith(response: Response): void;
+    /**
+     * Error this request with the given error.
+     * @example
+     * controller.errorWith()
+     * controller.errorWith(new Error('Oops!'))
+     */
+    errorWith(error?: Error): void;
+}
+
+declare const IS_PATCHED_MODULE: unique symbol;
+type RequestCredentials = 'omit' | 'include' | 'same-origin';
+type HttpRequestEventMap = {
+    request: [
+        args: {
+            request: Request;
+            requestId: string;
+            controller: RequestController;
+        }
+    ];
+    response: [
+        args: {
+            response: Response;
+            isMockedResponse: boolean;
+            request: Request;
+            requestId: string;
+        }
+    ];
+    unhandledException: [
+        args: {
+            error: unknown;
+            request: Request;
+            requestId: string;
+            controller: RequestController;
+        }
+    ];
+};
+
+export { HttpRequestEventMap as H, IS_PATCHED_MODULE as I, RequestCredentials as R };

package/lib/browser/index.d.ts

@@ -1,4 +1,4 @@
-export { H as HttpRequestEventMap, I as IS_PATCHED_MODULE, R as RequestCredentials } from './glossary-1c204f45.js';
+export { H as HttpRequestEventMap, I as IS_PATCHED_MODULE, R as RequestCredentials } from './glossary-7d7adb4b.js';
 import { I as Interceptor, E as ExtractEventNames } from './Interceptor-af98b768.js';
 export { c as INTERNAL_REQUEST_ID_HEADER_NAME, a as InterceptorEventMap, e as InterceptorReadyState, b as InterceptorSubscription, d as deleteGlobalSymbol, g as getGlobalSymbol } from './Interceptor-af98b768.js';
 import { EventMap, Listener } from 'strict-event-emitter';

package/lib/browser/index.js

@@ -5,7 +5,7 @@ var _chunkLK6DILFKjs = require('./chunk-LK6DILFK.js');
 
 
 
-var _chunk2CRB3JAQjs = require('./chunk-2CRB3JAQ.js');
+var _chunkFXSPMSSQjs = require('./chunk-FXSPMSSQ.js');
 
 
 
@@ -75,5 +75,5 @@ function getCleanUrl(url, isAbsolute = true) {
 
 
 
-exports.BatchInterceptor = BatchInterceptor; exports.INTERNAL_REQUEST_ID_HEADER_NAME = _chunkTIPR373Rjs.INTERNAL_REQUEST_ID_HEADER_NAME; exports.IS_PATCHED_MODULE = _chunk2CRB3JAQjs.IS_PATCHED_MODULE; exports.Interceptor = _chunkTIPR373Rjs.Interceptor; exports.InterceptorReadyState = _chunkTIPR373Rjs.InterceptorReadyState; exports.createRequestId = _chunkTIPR373Rjs.createRequestId; exports.decodeBuffer = _chunkLK6DILFKjs.decodeBuffer; exports.deleteGlobalSymbol = _chunkTIPR373Rjs.deleteGlobalSymbol; exports.encodeBuffer = _chunkLK6DILFKjs.encodeBuffer; exports.getCleanUrl = getCleanUrl; exports.getGlobalSymbol = _chunkTIPR373Rjs.getGlobalSymbol; exports.isResponseWithoutBody = _chunk2CRB3JAQjs.isResponseWithoutBody;
+exports.BatchInterceptor = BatchInterceptor; exports.INTERNAL_REQUEST_ID_HEADER_NAME = _chunkTIPR373Rjs.INTERNAL_REQUEST_ID_HEADER_NAME; exports.IS_PATCHED_MODULE = _chunkFXSPMSSQjs.IS_PATCHED_MODULE; exports.Interceptor = _chunkTIPR373Rjs.Interceptor; exports.InterceptorReadyState = _chunkTIPR373Rjs.InterceptorReadyState; exports.createRequestId = _chunkTIPR373Rjs.createRequestId; exports.decodeBuffer = _chunkLK6DILFKjs.decodeBuffer; exports.deleteGlobalSymbol = _chunkTIPR373Rjs.deleteGlobalSymbol; exports.encodeBuffer = _chunkLK6DILFKjs.encodeBuffer; exports.getCleanUrl = getCleanUrl; exports.getGlobalSymbol = _chunkTIPR373Rjs.getGlobalSymbol; exports.isResponseWithoutBody = _chunkFXSPMSSQjs.isResponseWithoutBody;
 //# sourceMappingURL=index.js.map

package/lib/browser/index.mjs

@@ -5,7 +5,7 @@ import {
 import {
   IS_PATCHED_MODULE,
   isResponseWithoutBody
-} from "./chunk-OMISYKWR.mjs";
+} from "./chunk-GGUENBDN.mjs";
 import {
   INTERNAL_REQUEST_ID_HEADER_NAME,
   Interceptor,

package/lib/browser/interceptors/XMLHttpRequest/index.d.ts

@@ -1,13 +1,9 @@
 import { Emitter } from 'strict-event-emitter';
-import { a as InteractiveRequest, H as HttpRequestEventMap } from '../../glossary-1c204f45.js';
+import { H as HttpRequestEventMap } from '../../glossary-7d7adb4b.js';
 import { I as Interceptor } from '../../Interceptor-af98b768.js';
 import '@open-draft/deferred-promise';
 import '@open-draft/logger';
 
-type XMLHttpRequestEventListener = (args: {
-    request: InteractiveRequest;
-    requestId: string;
-}) => Promise<void> | void;
 type XMLHttpRequestEmitter = Emitter<HttpRequestEventMap>;
 declare class XMLHttpRequestInterceptor extends Interceptor<HttpRequestEventMap> {
     static interceptorSymbol: symbol;
@@ -16,4 +12,4 @@ declare class XMLHttpRequestInterceptor extends Interceptor<HttpRequestEventMap>
     protected setup(): void;
 }
 
-export { XMLHttpRequestEmitter, XMLHttpRequestEventListener, XMLHttpRequestInterceptor };
+export { XMLHttpRequestEmitter, XMLHttpRequestInterceptor };

package/lib/browser/interceptors/XMLHttpRequest/index.js

@@ -1,11 +1,11 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunkPSX5J3RFjs = require('../../chunk-PSX5J3RF.js');
+var _chunk7GVJEW45js = require('../../chunk-7GVJEW45.js');
 require('../../chunk-LK6DILFK.js');
-require('../../chunk-MQJ3JOOK.js');
-require('../../chunk-2CRB3JAQ.js');
+require('../../chunk-VRKVKT62.js');
+require('../../chunk-FXSPMSSQ.js');
 require('../../chunk-TIPR373R.js');
 
 
-exports.XMLHttpRequestInterceptor = _chunkPSX5J3RFjs.XMLHttpRequestInterceptor;
+exports.XMLHttpRequestInterceptor = _chunk7GVJEW45js.XMLHttpRequestInterceptor;
 //# sourceMappingURL=index.js.map

package/lib/browser/interceptors/XMLHttpRequest/index.mjs

@@ -1,9 +1,9 @@
 import {
   XMLHttpRequestInterceptor
-} from "../../chunk-732REFPX.mjs";
+} from "../../chunk-5ETVT6GU.mjs";
 import "../../chunk-6HYIRFX2.mjs";
-import "../../chunk-OUWBQF3Z.mjs";
-import "../../chunk-OMISYKWR.mjs";
+import "../../chunk-7A4UJNSW.mjs";
+import "../../chunk-GGUENBDN.mjs";
 import "../../chunk-QED3Q6Z2.mjs";
 export {
   XMLHttpRequestInterceptor

package/lib/browser/interceptors/fetch/index.d.ts

@@ -1,4 +1,4 @@
-import { H as HttpRequestEventMap } from '../../glossary-1c204f45.js';
+import { H as HttpRequestEventMap } from '../../glossary-7d7adb4b.js';
 import { I as Interceptor } from '../../Interceptor-af98b768.js';
 import '@open-draft/deferred-promise';
 import '@open-draft/logger';

package/lib/browser/interceptors/fetch/index.js

@@ -1,10 +1,10 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunkWBHIW62Pjs = require('../../chunk-WBHIW62P.js');
-require('../../chunk-MQJ3JOOK.js');
-require('../../chunk-2CRB3JAQ.js');
+var _chunk6MBJUL74js = require('../../chunk-6MBJUL74.js');
+require('../../chunk-VRKVKT62.js');
+require('../../chunk-FXSPMSSQ.js');
 require('../../chunk-TIPR373R.js');
 
 
-exports.FetchInterceptor = _chunkWBHIW62Pjs.FetchInterceptor;
+exports.FetchInterceptor = _chunk6MBJUL74js.FetchInterceptor;
 //# sourceMappingURL=index.js.map

package/lib/browser/interceptors/fetch/index.mjs

@@ -1,8 +1,8 @@
 import {
   FetchInterceptor
-} from "../../chunk-MAEPOYB6.mjs";
-import "../../chunk-OUWBQF3Z.mjs";
-import "../../chunk-OMISYKWR.mjs";
+} from "../../chunk-NU2MPFD6.mjs";
+import "../../chunk-7A4UJNSW.mjs";
+import "../../chunk-GGUENBDN.mjs";
 import "../../chunk-QED3Q6Z2.mjs";
 export {
   FetchInterceptor

package/lib/browser/presets/browser.d.ts

@@ -1,6 +1,6 @@
 import { FetchInterceptor } from '../interceptors/fetch/index.js';
 import { XMLHttpRequestInterceptor } from '../interceptors/XMLHttpRequest/index.js';
-import '../glossary-1c204f45.js';
+import '../glossary-7d7adb4b.js';
 import '@open-draft/deferred-promise';
 import '../Interceptor-af98b768.js';
 import '@open-draft/logger';

package/lib/browser/presets/browser.js

@@ -1,18 +1,18 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunkPSX5J3RFjs = require('../chunk-PSX5J3RF.js');
+var _chunk7GVJEW45js = require('../chunk-7GVJEW45.js');
 require('../chunk-LK6DILFK.js');
 
 
-var _chunkWBHIW62Pjs = require('../chunk-WBHIW62P.js');
-require('../chunk-MQJ3JOOK.js');
-require('../chunk-2CRB3JAQ.js');
+var _chunk6MBJUL74js = require('../chunk-6MBJUL74.js');
+require('../chunk-VRKVKT62.js');
+require('../chunk-FXSPMSSQ.js');
 require('../chunk-TIPR373R.js');
 
 // src/presets/browser.ts
 var browser_default = [
-  new (0, _chunkWBHIW62Pjs.FetchInterceptor)(),
-  new (0, _chunkPSX5J3RFjs.XMLHttpRequestInterceptor)()
+  new (0, _chunk6MBJUL74js.FetchInterceptor)(),
+  new (0, _chunk7GVJEW45js.XMLHttpRequestInterceptor)()
 ];
 
 

package/lib/browser/presets/browser.mjs

@@ -1,12 +1,12 @@
 import {
   XMLHttpRequestInterceptor
-} from "../chunk-732REFPX.mjs";
+} from "../chunk-5ETVT6GU.mjs";
 import "../chunk-6HYIRFX2.mjs";
 import {
   FetchInterceptor
-} from "../chunk-MAEPOYB6.mjs";
-import "../chunk-OUWBQF3Z.mjs";
-import "../chunk-OMISYKWR.mjs";
+} from "../chunk-NU2MPFD6.mjs";
+import "../chunk-7A4UJNSW.mjs";
+import "../chunk-GGUENBDN.mjs";
 import "../chunk-QED3Q6Z2.mjs";
 
 // src/presets/browser.ts

package/lib/node/{BatchInterceptor-2badedde.d.ts → BatchInterceptor-13d40c95.d.ts}

@@ -1,5 +1,5 @@
 import { EventMap, Listener } from 'strict-event-emitter';
-import { f as Interceptor, E as ExtractEventNames } from './Interceptor-88ee47c0.js';
+import { f as Interceptor, E as ExtractEventNames } from './Interceptor-a31b1217.js';
 
 interface BatchInterceptorOptions<InterceptorList extends ReadonlyArray<Interceptor<any>>> {
     name: string;