@mswjs/interceptors 0.25.1 → 0.25.2

package/lib/browser/Interceptor-8d5fd4c6.d.ts

@@ -0,0 +1,86 @@
+import { DeferredPromise } from '@open-draft/deferred-promise';
+import { Logger } from '@open-draft/logger';
+import { Emitter, Listener } from 'strict-event-emitter';
+
+declare class RequestController {
+    protected request: Request;
+    responsePromise: DeferredPromise<Response | undefined>;
+    constructor(request: Request);
+    respondWith(response?: Response): void;
+}
+
+type InteractiveRequest = globalThis.Request & {
+    respondWith: RequestController['respondWith'];
+};
+
+declare const IS_PATCHED_MODULE: unique symbol;
+type RequestCredentials = 'omit' | 'include' | 'same-origin';
+type HttpRequestEventMap = {
+    request: [
+        args: {
+            request: InteractiveRequest;
+            requestId: string;
+        }
+    ];
+    response: [
+        args: {
+            response: Response;
+            isMockedResponse: boolean;
+            request: Request;
+            requestId: string;
+        }
+    ];
+};
+
+type InterceptorEventMap = Record<string, any>;
+type InterceptorSubscription = () => void;
+declare function getGlobalSymbol<V>(symbol: Symbol): V | undefined;
+declare function deleteGlobalSymbol(symbol: Symbol): void;
+declare enum InterceptorReadyState {
+    INACTIVE = "INACTIVE",
+    APPLYING = "APPLYING",
+    APPLIED = "APPLIED",
+    DISPOSING = "DISPOSING",
+    DISPOSED = "DISPOSED"
+}
+type ExtractEventNames<Events extends Record<string, any>> = Events extends Record<infer EventName, any> ? EventName : never;
+declare class Interceptor<Events extends InterceptorEventMap> {
+    private readonly symbol;
+    protected emitter: Emitter<Events>;
+    protected subscriptions: Array<InterceptorSubscription>;
+    protected logger: Logger;
+    readyState: InterceptorReadyState;
+    constructor(symbol: symbol);
+    /**
+     * Determine if this interceptor can be applied
+     * in the current environment.
+     */
+    protected checkEnvironment(): boolean;
+    /**
+     * Apply this interceptor to the current process.
+     * Returns an already running interceptor instance if it's present.
+     */
+    apply(): void;
+    /**
+     * Setup the module augments and stubs necessary for this interceptor.
+     * This method is not run if there's a running interceptor instance
+     * to prevent instantiating an interceptor multiple times.
+     */
+    protected setup(): void;
+    /**
+     * Listen to the interceptor's public events.
+     */
+    on<EventName extends ExtractEventNames<Events>>(event: EventName, listener: Listener<Events[EventName]>): this;
+    once<EventName extends ExtractEventNames<Events>>(event: EventName, listener: Listener<Events[EventName]>): this;
+    off<EventName extends ExtractEventNames<Events>>(event: EventName, listener: Listener<Events[EventName]>): this;
+    removeAllListeners<EventName extends ExtractEventNames<Events>>(event?: EventName): this;
+    /**
+     * Disposes of any side-effects this interceptor has introduced.
+     */
+    dispose(): void;
+    private getInstance;
+    private setInstance;
+    private clearInstance;
+}
+
+export { ExtractEventNames as E, HttpRequestEventMap as H, Interceptor as I, RequestCredentials as R, IS_PATCHED_MODULE as a, InterceptorEventMap as b, InterceptorSubscription as c, deleteGlobalSymbol as d, InterceptorReadyState as e, InteractiveRequest as f, getGlobalSymbol as g };

package/lib/browser/{chunk-4CFMDU7Z.js → chunk-CWVY2E3W.js}

@@ -3,133 +3,7 @@ var IS_PATCHED_MODULE = Symbol("isPatchedModule");
 
 // src/Interceptor.ts
 var _logger = require('@open-draft/logger');
-
-// src/utils/AsyncEventEmitter.ts
-
 var _stricteventemitter = require('strict-event-emitter');
-
-// src/utils/nextTick.ts
-function nextTick(callback) {
-  setTimeout(callback, 0);
-}
-
-// src/utils/AsyncEventEmitter.ts
-var AsyncEventEmitter = class extends _stricteventemitter.Emitter {
-  constructor() {
-    super();
-    this.logger = new (0, _logger.Logger)("async-event-emitter");
-    this.queue = /* @__PURE__ */ new Map();
-    this.readyState = "ACTIVE" /* ACTIVE */;
-  }
-  on(eventName, listener) {
-    const logger = this.logger.extend("on");
-    logger.info('adding "%s" listener...', eventName);
-    if (this.readyState === "DEACTIVATED" /* DEACTIVATED */) {
-      logger.info("the emitter is destroyed, skipping!");
-      return this;
-    }
-    return super.on(eventName, async (...args) => {
-      const queue = this.openListenerQueue(eventName);
-      logger.info('awaiting the "%s" listener...', eventName);
-      queue.push({
-        args,
-        done: new Promise(async (resolve, reject) => {
-          try {
-            await listener(...args);
-            resolve();
-            logger.info('"%s" listener has resolved!', eventName);
-          } catch (error) {
-            logger.info('"%s" listener has rejected!', error);
-            reject(error);
-          }
-        })
-      });
-    });
-  }
-  emit(eventName, ...data) {
-    const logger = this.logger.extend("emit");
-    logger.info('emitting "%s" event...', eventName);
-    if (this.readyState === "DEACTIVATED" /* DEACTIVATED */) {
-      logger.info("the emitter is destroyed, skipping!");
-      return false;
-    }
-    if (this.isInternalEventName(eventName)) {
-      return super.emit(eventName, ...data);
-    }
-    this.openListenerQueue(eventName);
-    logger.info('appending a one-time cleanup "%s" listener...', eventName);
-    this.once(eventName, () => {
-      nextTick(() => {
-        this.queue.delete(eventName);
-        logger.info('cleaned up "%s" listeners queue!', eventName);
-      });
-    });
-    return super.emit(eventName, ...data);
-  }
-  /**
-   * Returns a promise that resolves when all the listeners for the given event
-   * has been called. Awaits asynchronous listeners.
-   * If the event has no listeners, resolves immediately.
-   */
-  async untilIdle(eventName, filter = () => true) {
-    const listenersQueue = this.queue.get(eventName) || [];
-    await Promise.all(
-      listenersQueue.filter(filter).map(({ done }) => done)
-    ).finally(() => {
-      this.queue.delete(eventName);
-    });
-  }
-  openListenerQueue(eventName) {
-    const logger = this.logger.extend("openListenerQueue");
-    logger.info('opening "%s" listeners queue...', eventName);
-    const queue = this.queue.get(eventName);
-    if (!queue) {
-      logger.info("no queue found, creating one...");
-      this.queue.set(eventName, []);
-      return [];
-    }
-    logger.info("returning an exising queue:", queue);
-    return queue;
-  }
-  removeAllListeners(eventName) {
-    const logger = this.logger.extend("removeAllListeners");
-    logger.info("event:", eventName);
-    if (eventName) {
-      this.queue.delete(eventName);
-      logger.info(
-        'cleared the "%s" listeners queue!',
-        eventName,
-        this.queue.get(eventName)
-      );
-    } else {
-      this.queue.clear();
-      logger.info("cleared the listeners queue!", this.queue);
-    }
-    return super.removeAllListeners(eventName);
-  }
-  activate() {
-    const logger = this.logger.extend("activate");
-    this.readyState = "ACTIVE" /* ACTIVE */;
-    logger.info("set state to:", this.readyState);
-  }
-  /**
-   * Deactivate this event emitter.
-   * Deactivated emitter can no longer emit and listen to events
-   * and needs to be activated again in order to do so.
-   */
-  deactivate() {
-    const logger = this.logger.extend("deactivate");
-    logger.info("removing all listeners...");
-    this.removeAllListeners();
-    this.readyState = "DEACTIVATED" /* DEACTIVATED */;
-    logger.info("set state to:", this.readyState);
-  }
-  isInternalEventName(eventName) {
-    return eventName === "newListener" || eventName === "removeListener";
-  }
-};
-
-// src/Interceptor.ts
 function getGlobalSymbol(symbol) {
   return (
     // @ts-ignore https://github.com/Microsoft/TypeScript/issues/24587
@@ -154,7 +28,7 @@ var Interceptor = class {
   constructor(symbol) {
     this.symbol = symbol;
     this.readyState = "INACTIVE" /* INACTIVE */;
-    this.emitter = new AsyncEventEmitter();
+    this.emitter = new (0, _stricteventemitter.Emitter)();
     this.subscriptions = [];
     this.logger = new (0, _logger.Logger)(symbol.description);
     this.emitter.setMaxListeners(0);
@@ -184,8 +58,6 @@ var Interceptor = class {
       return;
     }
     this.readyState = "APPLYING" /* APPLYING */;
-    this.emitter.activate();
-    logger.info("activated the emiter!", this.emitter.readyState);
     const runningInstance = this.getInstance();
     if (runningInstance) {
       logger.info("found a running instance, reusing...");
@@ -196,6 +68,7 @@ var Interceptor = class {
           runningInstance.emitter.removeListener(event, listener);
           logger.info('removed proxied "%s" listener!', event);
         });
+        return this;
       };
       this.readyState = "APPLIED" /* APPLIED */;
       return;
@@ -215,14 +88,27 @@ var Interceptor = class {
   /**
    * Listen to the interceptor's public events.
    */
-  on(eventName, listener) {
+  on(event, listener) {
     const logger = this.logger.extend("on");
     if (this.readyState === "DISPOSING" /* DISPOSING */ || this.readyState === "DISPOSED" /* DISPOSED */) {
       logger.info("cannot listen to events, already disposed!");
-      return;
+      return this;
     }
-    logger.info('adding "%s" event listener:', eventName, listener.name);
-    this.emitter.on(eventName, listener);
+    logger.info('adding "%s" event listener:', event, listener.name);
+    this.emitter.on(event, listener);
+    return this;
+  }
+  once(event, listener) {
+    this.emitter.once(event, listener);
+    return this;
+  }
+  off(event, listener) {
+    this.emitter.off(event, listener);
+    return this;
+  }
+  removeAllListeners(event) {
+    this.emitter.removeAllListeners(event);
+    return this;
   }
   /**
    * Disposes of any side-effects this interceptor has introduced.
@@ -249,7 +135,7 @@ var Interceptor = class {
       this.subscriptions = [];
       logger.info("disposed of all subscriptions!", this.subscriptions.length);
     }
-    this.emitter.deactivate();
+    this.emitter.removeAllListeners();
     logger.info("destroyed the listener!");
     this.readyState = "DISPOSED" /* DISPOSED */;
   }

package/lib/browser/{chunk-VMXB5F2J.mjs → chunk-HXJPKJY3.mjs}

@@ -1,15 +1,16 @@
 import {
+  emitAsync,
   toInteractiveRequest,
   uuidv4
-} from "./chunk-RT3ATOJH.mjs";
+} from "./chunk-KK6APRON.mjs";
 import {
   IS_PATCHED_MODULE,
   Interceptor
-} from "./chunk-GXJLJMOT.mjs";
+} from "./chunk-QPMXOLDO.mjs";
 
 // src/interceptors/fetch/index.ts
-import { DeferredPromise } from "@open-draft/deferred-promise";
 import { invariant } from "outvariant";
+import { DeferredPromise } from "@open-draft/deferred-promise";
 import { until } from "@open-draft/until";
 var _FetchInterceptor = class extends Interceptor {
   constructor() {
@@ -29,14 +30,18 @@ var _FetchInterceptor = class extends Interceptor {
       const requestId = uuidv4();
       const request = new Request(input, init);
       this.logger.info("[%s] %s", request.method, request.url);
-      const interactiveRequest = toInteractiveRequest(request);
+      const { interactiveRequest, requestController } = toInteractiveRequest(request);
       this.logger.info(
         'emitting the "request" event for %d listener(s)...',
         this.emitter.listenerCount("request")
       );
-      this.emitter.emit("request", {
-        request: interactiveRequest,
-        requestId
+      this.emitter.once("request", ({ requestId: pendingRequestId }) => {
+        if (pendingRequestId !== requestId) {
+          return;
+        }
+        if (requestController.responsePromise.state === "pending") {
+          requestController.responsePromise.resolve(void 0);
+        }
       });
       this.logger.info("awaiting for the mocked response...");
       const signal = interactiveRequest.signal;
@@ -49,15 +54,20 @@ var _FetchInterceptor = class extends Interceptor {
         { once: true }
       );
       const resolverResult = await until(async () => {
-        const allListenersResolved = this.emitter.untilIdle(
-          "request",
-          ({ args: [{ requestId: pendingRequestId }] }) => {
-            return pendingRequestId === requestId;
-          }
-        );
-        await Promise.race([requestAborted, allListenersResolved]);
+        const listenersFinished = emitAsync(this.emitter, "request", {
+          request: interactiveRequest,
+          requestId
+        });
+        await Promise.race([
+          requestAborted,
+          // Put the listeners invocation Promise in the same race condition
+          // with the request abort Promise because otherwise awaiting the listeners
+          // would always yield some response (or undefined).
+          listenersFinished,
+          requestController.responsePromise
+        ]);
         this.logger.info("all request listeners have been resolved!");
-        const [mockedResponse2] = await interactiveRequest.respondWith.invoked();
+        const mockedResponse2 = await requestController.responsePromise;
         this.logger.info("event.respondWith called with:", mockedResponse2);
         return mockedResponse2;
       });

package/lib/browser/{chunk-DBFLI5DJ.js → chunk-KITNLK66.js}

@@ -1,17 +1,18 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
 
-var _chunkPCFJD76Xjs = require('./chunk-PCFJD76X.js');
 
+var _chunkX3NRJIZWjs = require('./chunk-X3NRJIZW.js');
 
 
-var _chunk4CFMDU7Zjs = require('./chunk-4CFMDU7Z.js');
+
+var _chunkCWVY2E3Wjs = require('./chunk-CWVY2E3W.js');
 
 // src/interceptors/fetch/index.ts
-var _deferredpromise = require('@open-draft/deferred-promise');
 var _outvariant = require('outvariant');
+var _deferredpromise = require('@open-draft/deferred-promise');
 var _until = require('@open-draft/until');
-var _FetchInterceptor = class extends _chunk4CFMDU7Zjs.Interceptor {
+var _FetchInterceptor = class extends _chunkCWVY2E3Wjs.Interceptor {
   constructor() {
     super(_FetchInterceptor.symbol);
   }
@@ -21,22 +22,26 @@ var _FetchInterceptor = class extends _chunk4CFMDU7Zjs.Interceptor {
   setup() {
     const pureFetch = globalThis.fetch;
     _outvariant.invariant.call(void 0, 
-      !pureFetch[_chunk4CFMDU7Zjs.IS_PATCHED_MODULE],
+      !pureFetch[_chunkCWVY2E3Wjs.IS_PATCHED_MODULE],
       'Failed to patch the "fetch" module: already patched.'
     );
     globalThis.fetch = async (input, init) => {
       var _a;
-      const requestId = _chunkPCFJD76Xjs.uuidv4.call(void 0, );
+      const requestId = _chunkX3NRJIZWjs.uuidv4.call(void 0, );
       const request = new Request(input, init);
       this.logger.info("[%s] %s", request.method, request.url);
-      const interactiveRequest = _chunkPCFJD76Xjs.toInteractiveRequest.call(void 0, request);
+      const { interactiveRequest, requestController } = _chunkX3NRJIZWjs.toInteractiveRequest.call(void 0, request);
       this.logger.info(
         'emitting the "request" event for %d listener(s)...',
         this.emitter.listenerCount("request")
       );
-      this.emitter.emit("request", {
-        request: interactiveRequest,
-        requestId
+      this.emitter.once("request", ({ requestId: pendingRequestId }) => {
+        if (pendingRequestId !== requestId) {
+          return;
+        }
+        if (requestController.responsePromise.state === "pending") {
+          requestController.responsePromise.resolve(void 0);
+        }
       });
       this.logger.info("awaiting for the mocked response...");
       const signal = interactiveRequest.signal;
@@ -49,15 +54,20 @@ var _FetchInterceptor = class extends _chunk4CFMDU7Zjs.Interceptor {
         { once: true }
       );
       const resolverResult = await _until.until.call(void 0, async () => {
-        const allListenersResolved = this.emitter.untilIdle(
-          "request",
-          ({ args: [{ requestId: pendingRequestId }] }) => {
-            return pendingRequestId === requestId;
-          }
-        );
-        await Promise.race([requestAborted, allListenersResolved]);
+        const listenersFinished = _chunkX3NRJIZWjs.emitAsync.call(void 0, this.emitter, "request", {
+          request: interactiveRequest,
+          requestId
+        });
+        await Promise.race([
+          requestAborted,
+          // Put the listeners invocation Promise in the same race condition
+          // with the request abort Promise because otherwise awaiting the listeners
+          // would always yield some response (or undefined).
+          listenersFinished,
+          requestController.responsePromise
+        ]);
         this.logger.info("all request listeners have been resolved!");
-        const [mockedResponse2] = await interactiveRequest.respondWith.invoked();
+        const mockedResponse2 = await requestController.responsePromise;
         this.logger.info("event.respondWith called with:", mockedResponse2);
         return mockedResponse2;
       });
@@ -105,13 +115,13 @@ var _FetchInterceptor = class extends _chunk4CFMDU7Zjs.Interceptor {
         return response;
       });
     };
-    Object.defineProperty(globalThis.fetch, _chunk4CFMDU7Zjs.IS_PATCHED_MODULE, {
+    Object.defineProperty(globalThis.fetch, _chunkCWVY2E3Wjs.IS_PATCHED_MODULE, {
       enumerable: true,
       configurable: true,
       value: true
     });
     this.subscriptions.push(() => {
-      Object.defineProperty(globalThis.fetch, _chunk4CFMDU7Zjs.IS_PATCHED_MODULE, {
+      Object.defineProperty(globalThis.fetch, _chunkCWVY2E3Wjs.IS_PATCHED_MODULE, {
         value: void 0
       });
       globalThis.fetch = pureFetch;

package/lib/browser/chunk-KK6APRON.mjs

@@ -0,0 +1,58 @@
+// src/utils/uuid.ts
+function uuidv4() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
+    const r = Math.random() * 16 | 0;
+    const v = c == "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+
+// src/utils/RequestController.ts
+import { invariant } from "outvariant";
+import { DeferredPromise } from "@open-draft/deferred-promise";
+var RequestController = class {
+  constructor(request) {
+    this.request = request;
+    this.responsePromise = new DeferredPromise();
+  }
+  respondWith(response) {
+    invariant(
+      this.responsePromise.state === "pending",
+      'Failed to respond to "%s %s" request: the "request" event has already been responded to.',
+      this.request.method,
+      this.request.url
+    );
+    this.responsePromise.resolve(response);
+  }
+};
+
+// src/utils/toInteractiveRequest.ts
+function toInteractiveRequest(request) {
+  const requestController = new RequestController(request);
+  Reflect.set(
+    request,
+    "respondWith",
+    requestController.respondWith.bind(requestController)
+  );
+  return {
+    interactiveRequest: request,
+    requestController
+  };
+}
+
+// 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);
+  }
+}
+
+export {
+  uuidv4,
+  toInteractiveRequest,
+  emitAsync
+};

package/lib/browser/{chunk-OSIUQA4X.js → chunk-NMG5MQJJ.js}

@@ -6,11 +6,12 @@ var _chunk3LFH2WCFjs = require('./chunk-3LFH2WCF.js');
 
 
 
-var _chunkPCFJD76Xjs = require('./chunk-PCFJD76X.js');
 
+var _chunkX3NRJIZWjs = require('./chunk-X3NRJIZW.js');
 
 
-var _chunk4CFMDU7Zjs = require('./chunk-4CFMDU7Z.js');
+
+var _chunkCWVY2E3Wjs = require('./chunk-CWVY2E3W.js');
 
 // src/interceptors/XMLHttpRequest/index.ts
 var _outvariant = require('outvariant');
@@ -237,7 +238,7 @@ var XMLHttpRequestController = class {
     this.method = "GET";
     this.url = null;
     this.events = /* @__PURE__ */ new Map();
-    this.requestId = _chunkPCFJD76Xjs.uuidv4.call(void 0, );
+    this.requestId = _chunkX3NRJIZWjs.uuidv4.call(void 0, );
     this.requestHeaders = new Headers();
     this.responseBuffer = new Uint8Array();
     this.request = createProxy(initialRequest, {
@@ -652,30 +653,32 @@ function createXMLHttpRequestProxy({
           prototypeDescriptors[propertyName]
         );
       }
-      const requestController = new XMLHttpRequestController(
+      const xhrRequestController = new XMLHttpRequestController(
         originalRequest,
         logger
       );
-      requestController.onRequest = async function({ request, requestId }) {
-        const interactiveRequest = _chunkPCFJD76Xjs.toInteractiveRequest.call(void 0, request);
-        this.logger.info(
-          'emitting the "request" event for %s listener(s)...',
-          emitter.listenerCount("request")
-        );
-        emitter.emit("request", {
-          request: interactiveRequest,
-          requestId
-        });
+      xhrRequestController.onRequest = async function({ request, requestId }) {
+        const { interactiveRequest, requestController } = _chunkX3NRJIZWjs.toInteractiveRequest.call(void 0, request);
         this.logger.info("awaiting mocked response...");
+        emitter.once("request", ({ requestId: pendingRequestId }) => {
+          if (pendingRequestId !== requestId) {
+            return;
+          }
+          if (requestController.responsePromise.state === "pending") {
+            requestController.respondWith(void 0);
+          }
+        });
         const resolverResult = await _until.until.call(void 0, async () => {
-          await emitter.untilIdle(
-            "request",
-            ({ args: [{ requestId: pendingRequestId }] }) => {
-              return pendingRequestId === requestId;
-            }
+          this.logger.info(
+            'emitting the "request" event for %s listener(s)...',
+            emitter.listenerCount("request")
           );
+          await _chunkX3NRJIZWjs.emitAsync.call(void 0, emitter, "request", {
+            request: interactiveRequest,
+            requestId
+          });
           this.logger.info('all "request" listeners settled!');
-          const [mockedResponse2] = await interactiveRequest.respondWith.invoked();
+          const mockedResponse2 = await requestController.responsePromise;
           this.logger.info("event.respondWith called with:", mockedResponse2);
           return mockedResponse2;
         });
@@ -684,7 +687,7 @@ function createXMLHttpRequestProxy({
             "request listener threw an exception, aborting request...",
             resolverResult.error
           );
-          requestController.errorWith(resolverResult.error);
+          xhrRequestController.errorWith(resolverResult.error);
           return;
         }
         const mockedResponse = resolverResult.data;
@@ -698,16 +701,16 @@ function createXMLHttpRequestProxy({
             this.logger.info(
               "received a network error response, rejecting the request promise..."
             );
-            requestController.errorWith(new TypeError("Network error"));
+            xhrRequestController.errorWith(new TypeError("Network error"));
             return;
           }
-          return requestController.respondWith(mockedResponse);
+          return xhrRequestController.respondWith(mockedResponse);
         }
         this.logger.info(
           "no mocked response received, performing request as-is..."
         );
       };
-      requestController.onResponse = async function({
+      xhrRequestController.onResponse = async function({
         response,
         isMockedResponse,
         request,
@@ -724,14 +727,14 @@ function createXMLHttpRequestProxy({
           requestId
         });
       };
-      return requestController.request;
+      return xhrRequestController.request;
     }
   });
   return XMLHttpRequestProxy;
 }
 
 // src/interceptors/XMLHttpRequest/index.ts
-var _XMLHttpRequestInterceptor = class extends _chunk4CFMDU7Zjs.Interceptor {
+var _XMLHttpRequestInterceptor = class extends _chunkCWVY2E3Wjs.Interceptor {
   constructor() {
     super(_XMLHttpRequestInterceptor.interceptorSymbol);
   }
@@ -743,7 +746,7 @@ var _XMLHttpRequestInterceptor = class extends _chunk4CFMDU7Zjs.Interceptor {
     logger.info('patching "XMLHttpRequest" module...');
     const PureXMLHttpRequest = globalThis.XMLHttpRequest;
     _outvariant.invariant.call(void 0, 
-      !PureXMLHttpRequest[_chunk4CFMDU7Zjs.IS_PATCHED_MODULE],
+      !PureXMLHttpRequest[_chunkCWVY2E3Wjs.IS_PATCHED_MODULE],
       'Failed to patch the "XMLHttpRequest" module: already patched.'
     );
     globalThis.XMLHttpRequest = createXMLHttpRequestProxy({
@@ -754,13 +757,13 @@ var _XMLHttpRequestInterceptor = class extends _chunk4CFMDU7Zjs.Interceptor {
       'native "XMLHttpRequest" module patched!',
       globalThis.XMLHttpRequest.name
     );
-    Object.defineProperty(globalThis.XMLHttpRequest, _chunk4CFMDU7Zjs.IS_PATCHED_MODULE, {
+    Object.defineProperty(globalThis.XMLHttpRequest, _chunkCWVY2E3Wjs.IS_PATCHED_MODULE, {
       enumerable: true,
       configurable: true,
       value: true
     });
     this.subscriptions.push(() => {
-      Object.defineProperty(globalThis.XMLHttpRequest, _chunk4CFMDU7Zjs.IS_PATCHED_MODULE, {
+      Object.defineProperty(globalThis.XMLHttpRequest, _chunkCWVY2E3Wjs.IS_PATCHED_MODULE, {
         value: void 0
       });
       globalThis.XMLHttpRequest = PureXMLHttpRequest;