@mswjs/interceptors 0.25.1 → 0.25.3

package/lib/node/{BatchInterceptor-c841b068.d.ts → BatchInterceptor-9785c567.d.ts}

@@ -1,5 +1,5 @@
 import { EventMap, Listener } from 'strict-event-emitter';
-import { e as Interceptor, E as ExtractEventNames } from './Interceptor-738f79c5.js';
+import { e as Interceptor, E as ExtractEventNames } from './Interceptor-7a701c1f.js';
 
 interface BatchInterceptorOptions<InterceptorList extends ReadonlyArray<Interceptor<any>>> {
     name: string;
@@ -15,7 +15,10 @@ declare class BatchInterceptor<InterceptorList extends ReadonlyArray<Interceptor
     private interceptors;
     constructor(options: BatchInterceptorOptions<InterceptorList>);
     protected setup(): void;
-    on<EventName extends ExtractEventNames<Events>>(event: EventName, listener: Listener<Events[EventName]>): void;
+    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 | undefined): this;
 }
 
 export { BatchInterceptorOptions as B, ExtractEventMapType as E, BatchInterceptor as a };

package/lib/node/Interceptor-7a701c1f.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, IS_PATCHED_MODULE as I, RequestCredentials as R, InterceptorEventMap as a, InterceptorSubscription as b, InterceptorReadyState as c, deleteGlobalSymbol as d, Interceptor as e, InteractiveRequest as f, getGlobalSymbol as g };

package/lib/node/RemoteHttpInterceptor.d.ts

@@ -1,8 +1,9 @@
 import { ChildProcess } from 'child_process';
-import { e as Interceptor, H as HttpRequestEventMap } from './Interceptor-738f79c5.js';
-import { a as BatchInterceptor } from './BatchInterceptor-c841b068.js';
+import { e as Interceptor, H as HttpRequestEventMap } from './Interceptor-7a701c1f.js';
+import { a as BatchInterceptor } from './BatchInterceptor-9785c567.js';
 import { ClientRequestInterceptor } from './interceptors/ClientRequest/index.js';
 import { XMLHttpRequestInterceptor } from './interceptors/XMLHttpRequest/index.js';
+import '@open-draft/deferred-promise';
 import '@open-draft/logger';
 import 'strict-event-emitter';
 import 'http';

package/lib/node/RemoteHttpInterceptor.js

@@ -1,29 +1,31 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunkMVPEJK4Vjs = require('./chunk-MVPEJK4V.js');
+var _chunkUF7QIAQ5js = require('./chunk-UF7QIAQ5.js');
 
 
-var _chunk3MYUI4B2js = require('./chunk-3MYUI4B2.js');
+var _chunkNCHFM2TBjs = require('./chunk-NCHFM2TB.js');
 
 
-var _chunkE6YC337Qjs = require('./chunk-E6YC337Q.js');
+var _chunkJCWVLTP7js = require('./chunk-JCWVLTP7.js');
 require('./chunk-3LFH2WCF.js');
+require('./chunk-OGN3ZR35.js');
 require('./chunk-VQ4DZOBB.js');
 
 
-var _chunkZJOF5MEZjs = require('./chunk-ZJOF5MEZ.js');
 
+var _chunk5PTPJLB7js = require('./chunk-5PTPJLB7.js');
 
-var _chunkXYZRP5S2js = require('./chunk-XYZRP5S2.js');
+
+var _chunk3XFLRXRYjs = require('./chunk-3XFLRXRY.js');
 
 // src/RemoteHttpInterceptor.ts
-var RemoteHttpInterceptor = class extends _chunkMVPEJK4Vjs.BatchInterceptor {
+var RemoteHttpInterceptor = class extends _chunkUF7QIAQ5js.BatchInterceptor {
   constructor() {
     super({
       name: "remote-interceptor",
       interceptors: [
-        new (0, _chunk3MYUI4B2js.ClientRequestInterceptor)(),
-        new (0, _chunkE6YC337Qjs.XMLHttpRequestInterceptor)()
+        new (0, _chunkNCHFM2TBjs.ClientRequestInterceptor)(),
+        new (0, _chunkJCWVLTP7js.XMLHttpRequestInterceptor)()
       ]
     });
   }
@@ -90,7 +92,7 @@ function requestReviver(key, value) {
       return value;
   }
 }
-var _RemoteHttpResolver = class extends _chunkXYZRP5S2js.Interceptor {
+var _RemoteHttpResolver = class extends _chunk3XFLRXRYjs.Interceptor {
   constructor(options) {
     super(_RemoteHttpResolver.symbol);
     this.process = options.process;
@@ -118,18 +120,17 @@ var _RemoteHttpResolver = class extends _chunkXYZRP5S2js.Interceptor {
         credentials: requestJson.credentials,
         body: requestJson.body
       });
-      const interactiveRequest = _chunkZJOF5MEZjs.toInteractiveRequest.call(void 0, capturedRequest);
-      this.emitter.emit("request", {
+      const { interactiveRequest, requestController } = _chunk5PTPJLB7js.toInteractiveRequest.call(void 0, capturedRequest);
+      this.emitter.once("request", () => {
+        if (requestController.responsePromise.state === "pending") {
+          requestController.respondWith(void 0);
+        }
+      });
+      await _chunk5PTPJLB7js.emitAsync.call(void 0, this.emitter, "request", {
         request: interactiveRequest,
         requestId: requestJson.id
       });
-      await this.emitter.untilIdle(
-        "request",
-        ({ args: [{ requestId: pendingRequestId }] }) => {
-          return pendingRequestId === requestJson.id;
-        }
-      );
-      const [mockedResponse] = await interactiveRequest.respondWith.invoked();
+      const mockedResponse = await requestController.responsePromise;
       if (!mockedResponse) {
         return;
       }

package/lib/node/RemoteHttpInterceptor.mjs

@@ -1,20 +1,22 @@
 import {
   BatchInterceptor
-} from "./chunk-VS3GJPUE.mjs";
+} from "./chunk-UBEFEZXT.mjs";
 import {
   ClientRequestInterceptor
-} from "./chunk-OL7OR4RL.mjs";
+} from "./chunk-MCO3RLQC.mjs";
 import {
   XMLHttpRequestInterceptor
-} from "./chunk-HSCXCLVT.mjs";
+} from "./chunk-FB53TMYN.mjs";
 import "./chunk-7II4SWKS.mjs";
+import "./chunk-3IYIKC3X.mjs";
 import "./chunk-GFH37L5D.mjs";
 import {
+  emitAsync,
   toInteractiveRequest
-} from "./chunk-STA6QBYM.mjs";
+} from "./chunk-YQGTMMOZ.mjs";
 import {
   Interceptor
-} from "./chunk-RGYCLCLK.mjs";
+} from "./chunk-GM3YBSM3.mjs";
 
 // src/RemoteHttpInterceptor.ts
 var RemoteHttpInterceptor = class extends BatchInterceptor {
@@ -118,18 +120,17 @@ var _RemoteHttpResolver = class extends Interceptor {
         credentials: requestJson.credentials,
         body: requestJson.body
       });
-      const interactiveRequest = toInteractiveRequest(capturedRequest);
-      this.emitter.emit("request", {
+      const { interactiveRequest, requestController } = toInteractiveRequest(capturedRequest);
+      this.emitter.once("request", () => {
+        if (requestController.responsePromise.state === "pending") {
+          requestController.respondWith(void 0);
+        }
+      });
+      await emitAsync(this.emitter, "request", {
         request: interactiveRequest,
         requestId: requestJson.id
       });
-      await this.emitter.untilIdle(
-        "request",
-        ({ args: [{ requestId: pendingRequestId }] }) => {
-          return pendingRequestId === requestJson.id;
-        }
-      );
-      const [mockedResponse] = await interactiveRequest.respondWith.invoked();
+      const mockedResponse = await requestController.responsePromise;
       if (!mockedResponse) {
         return;
       }

package/lib/node/chunk-3IYIKC3X.mjs

@@ -0,0 +1,6 @@
+// src/utils/responseUtils.ts
+var responseStatusCodesWithoutBody = [204, 205, 304];
+
+export {
+  responseStatusCodesWithoutBody
+};

package/lib/node/{chunk-XYZRP5S2.js → chunk-3XFLRXRY.js}

@@ -1,132 +1,6 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});// 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
@@ -151,7 +25,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);
@@ -181,8 +55,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...");
@@ -193,6 +65,7 @@ var Interceptor = class {
           runningInstance.emitter.removeListener(event, listener);
           logger.info('removed proxied "%s" listener!', event);
         });
+        return this;
       };
       this.readyState = "APPLIED" /* APPLIED */;
       return;
@@ -212,14 +85,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.
@@ -246,7 +132,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/node/chunk-5PTPJLB7.js

@@ -0,0 +1,58 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/utils/RequestController.ts
+var _outvariant = require('outvariant');
+var _deferredpromise = require('@open-draft/deferred-promise');
+var RequestController = class {
+  constructor(request) {
+    this.request = request;
+    this.responsePromise = new (0, _deferredpromise.DeferredPromise)();
+  }
+  respondWith(response) {
+    _outvariant.invariant.call(void 0, 
+      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/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/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);
+  }
+}
+
+
+
+
+
+exports.toInteractiveRequest = toInteractiveRequest; exports.uuidv4 = uuidv4; exports.emitAsync = emitAsync;

package/lib/node/{chunk-HSCXCLVT.mjs → chunk-FB53TMYN.mjs}

@@ -3,16 +3,20 @@ import {
   encodeBuffer,
   toArrayBuffer
 } from "./chunk-7II4SWKS.mjs";
+import {
+  responseStatusCodesWithoutBody
+} from "./chunk-3IYIKC3X.mjs";
 import {
   IS_PATCHED_MODULE
 } from "./chunk-GFH37L5D.mjs";
 import {
+  emitAsync,
   toInteractiveRequest,
   uuidv4
-} from "./chunk-STA6QBYM.mjs";
+} from "./chunk-YQGTMMOZ.mjs";
 import {
   Interceptor
-} from "./chunk-RGYCLCLK.mjs";
+} from "./chunk-GM3YBSM3.mjs";
 
 // src/interceptors/XMLHttpRequest/index.ts
 import { invariant as invariant2 } from "outvariant";
@@ -204,9 +208,10 @@ function parseJson(data) {
 }
 
 // src/interceptors/XMLHttpRequest/utils/createResponse.ts
-var statusCodesWithoutBody = [204, 205, 304];
 function createResponse(request, body) {
-  const responseBodyOrNull = statusCodesWithoutBody.includes(request.status) ? null : body;
+  const responseBodyOrNull = responseStatusCodesWithoutBody.includes(
+    request.status
+  ) ? null : body;
   return new Response(responseBodyOrNull, {
     status: request.status,
     statusText: request.statusText,
@@ -654,30 +659,32 @@ function createXMLHttpRequestProxy({
           prototypeDescriptors[propertyName]
         );
       }
-      const requestController = new XMLHttpRequestController(
+      const xhrRequestController = new XMLHttpRequestController(
         originalRequest,
         logger
       );
-      requestController.onRequest = async function({ request, requestId }) {
-        const interactiveRequest = toInteractiveRequest(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 } = toInteractiveRequest(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(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 emitAsync(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;
         });
@@ -686,7 +693,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;
@@ -700,16 +707,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,
@@ -726,7 +733,7 @@ function createXMLHttpRequestProxy({
           requestId
         });
       };
-      return requestController.request;
+      return xhrRequestController.request;
     }
   });
   return XMLHttpRequestProxy;