@mswjs/interceptors 0.19.4 → 0.19.5

package/lib/interceptors/XMLHttpRequest/XMLHttpRequestOverride.js

@@ -8,78 +8,24 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createXMLHttpRequestOverride = void 0;
-var until_1 = require("@open-draft/until");
-var web_fetch_1 = require("@remix-run/web-fetch");
-var headers_polyfill_1 = require("headers-polyfill");
-var parseJson_1 = require("../../utils/parseJson");
-var createEvent_1 = require("./utils/createEvent");
-var bufferUtils_1 = require("../../utils/bufferUtils");
-var createResponse_1 = require("./utils/createResponse");
-var concatArrayBuffer_1 = require("./utils/concatArrayBuffer");
-var toInteractiveRequest_1 = require("../../utils/toInteractiveRequest");
-var uuid_1 = require("../../utils/uuid");
-var isDomParserSupportedType_1 = require("./utils/isDomParserSupportedType");
-var createXMLHttpRequestOverride = function (options) {
+const until_1 = require("@open-draft/until");
+const web_fetch_1 = require("@remix-run/web-fetch");
+const headers_polyfill_1 = require("headers-polyfill");
+const parseJson_1 = require("../../utils/parseJson");
+const createEvent_1 = require("./utils/createEvent");
+const bufferUtils_1 = require("../../utils/bufferUtils");
+const createResponse_1 = require("./utils/createResponse");
+const concatArrayBuffer_1 = require("./utils/concatArrayBuffer");
+const toInteractiveRequest_1 = require("../../utils/toInteractiveRequest");
+const uuid_1 = require("../../utils/uuid");
+const isDomParserSupportedType_1 = require("./utils/isDomParserSupportedType");
+const createXMLHttpRequestOverride = (options) => {
     var _a;
-    var XMLHttpRequest = options.XMLHttpRequest, emitter = options.emitter, log = options.log;
-    return _a = /** @class */ (function () {
-            function XMLHttpRequestOverride() {
+    const { XMLHttpRequest, emitter, log } = options;
+    return _a = class XMLHttpRequestOverride {
+            constructor() {
                 // Collection of events modified by `addEventListener`/`removeEventListener` calls.
                 this._events = [];
                 this.log = log;
@@ -111,7 +57,7 @@ var createXMLHttpRequestOverride = function (options) {
                 this._responseBuffer = new Uint8Array();
                 this._responseHeaders = new headers_polyfill_1.Headers();
             }
-            XMLHttpRequestOverride.prototype.setReadyState = function (nextState) {
+            setReadyState(nextState) {
                 if (nextState === this.readyState) {
                     return;
                 }
@@ -121,36 +67,25 @@ var createXMLHttpRequestOverride = function (options) {
                     this.log('triggering readystate change...');
                     this.trigger('readystatechange');
                 }
-            };
+            }
             /**
              * Triggers both direct callback and attached event listeners
              * for the given event.
              */
-            XMLHttpRequestOverride.prototype.trigger = function (eventName, options) {
-                var e_1, _a;
+            trigger(eventName, options) {
                 this.log('trigger "%s" (%d)', eventName, this.readyState);
                 this.log('resolve listener for event "%s"', eventName);
-                var callback = this["on" + eventName];
+                const callback = this[`on${eventName}`];
                 callback === null || callback === void 0 ? void 0 : callback.call(this, (0, createEvent_1.createEvent)(this, eventName, options));
-                try {
-                    for (var _b = __values(this._events), _c = _b.next(); !_c.done; _c = _b.next()) {
-                        var event_1 = _c.value;
-                        if (event_1.name === eventName) {
-                            log('calling mock event listener "%s" (%d)', eventName, this.readyState);
-                            event_1.listener.call(this, (0, createEvent_1.createEvent)(this, eventName, options));
-                        }
+                for (const event of this._events) {
+                    if (event.name === eventName) {
+                        log('calling mock event listener "%s" (%d)', eventName, this.readyState);
+                        event.listener.call(this, (0, createEvent_1.createEvent)(this, eventName, options));
                     }
                 }
-                catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                finally {
-                    try {
-                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-                    }
-                    finally { if (e_1) throw e_1.error; }
-                }
                 return this;
-            };
-            XMLHttpRequestOverride.prototype.reset = function () {
+            }
+            reset() {
                 this.log('reset');
                 this.setReadyState(this.UNSENT);
                 this.status = 0;
@@ -158,35 +93,30 @@ var createXMLHttpRequestOverride = function (options) {
                 this._responseBuffer = new Uint8Array();
                 this._requestHeaders = new headers_polyfill_1.Headers();
                 this._responseHeaders = new headers_polyfill_1.Headers();
-            };
-            XMLHttpRequestOverride.prototype.open = function (method, url, async, user, password) {
-                if (async === void 0) { async = true; }
-                return __awaiter(this, void 0, void 0, function () {
-                    return __generator(this, function (_a) {
-                        this.log = this.log.extend("request " + method + " " + url);
-                        this.log('open', { method: method, url: url, async: async, user: user, password: password });
-                        this.reset();
-                        this.setReadyState(this.OPENED);
-                        if (typeof url === 'undefined') {
-                            this.url = method;
-                            this.method = 'GET';
-                        }
-                        else {
-                            this.url = url;
-                            this.method = method;
-                            this.async = async;
-                            this.user = user;
-                            this.password = password;
-                        }
-                        return [2 /*return*/];
-                    });
+            }
+            open(method, url, async = true, user, password) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    this.log = this.log.extend(`request ${method} ${url}`);
+                    this.log('open', { method, url, async, user, password });
+                    this.reset();
+                    this.setReadyState(this.OPENED);
+                    if (typeof url === 'undefined') {
+                        this.url = method;
+                        this.method = 'GET';
+                    }
+                    else {
+                        this.url = url;
+                        this.method = method;
+                        this.async = async;
+                        this.user = user;
+                        this.password = password;
+                    }
                 });
-            };
-            XMLHttpRequestOverride.prototype.send = function (data) {
-                var _this = this;
+            }
+            send(data) {
                 this.log('send %s %s', this.method, this.url);
-                var requestBuffer = typeof data === 'string' ? (0, bufferUtils_1.encodeBuffer)(data) : data;
-                var url;
+                const requestBuffer = typeof data === 'string' ? (0, bufferUtils_1.encodeBuffer)(data) : data;
+                let url;
                 try {
                     url = new URL(this.url);
                 }
@@ -198,176 +128,157 @@ var createXMLHttpRequestOverride = function (options) {
                 }
                 this.log('request headers', this._requestHeaders);
                 // Create an intercepted request instance exposed to the request intercepting middleware.
-                var requestId = (0, uuid_1.uuidv4)();
-                var capturedRequest = new web_fetch_1.Request(url, {
+                const requestId = (0, uuid_1.uuidv4)();
+                const capturedRequest = new web_fetch_1.Request(url, {
                     method: this.method,
                     headers: this._requestHeaders,
                     credentials: this.withCredentials ? 'include' : 'omit',
                     body: requestBuffer,
                 });
-                var interactiveRequest = (0, toInteractiveRequest_1.toInteractiveRequest)(capturedRequest);
+                const interactiveRequest = (0, toInteractiveRequest_1.toInteractiveRequest)(capturedRequest);
                 this.log('emitting the "request" event for %d listener(s)...', emitter.listenerCount('request'));
                 emitter.emit('request', interactiveRequest, requestId);
                 this.log('awaiting mocked response...');
-                Promise.resolve((0, until_1.until)(function () { return __awaiter(_this, void 0, void 0, function () {
-                    var _a, mockedResponse;
-                    return __generator(this, function (_b) {
-                        switch (_b.label) {
-                            case 0: return [4 /*yield*/, emitter.untilIdle('request', function (_a) {
-                                    var _b = __read(_a.args, 2), pendingRequestId = _b[1];
-                                    return pendingRequestId === requestId;
-                                })];
-                            case 1:
-                                _b.sent();
-                                this.log('all request listeners have been resolved!');
-                                return [4 /*yield*/, interactiveRequest.respondWith.invoked()];
-                            case 2:
-                                _a = __read.apply(void 0, [_b.sent(), 1]), mockedResponse = _a[0];
-                                this.log('event.respondWith called with:', mockedResponse);
-                                return [2 /*return*/, mockedResponse];
-                        }
+                Promise.resolve((0, until_1.until)(() => __awaiter(this, void 0, void 0, function* () {
+                    yield emitter.untilIdle('request', ({ args: [, pendingRequestId] }) => {
+                        return pendingRequestId === requestId;
                     });
-                }); })).then(function (_a) {
-                    var _b, _c;
-                    var _d = __read(_a, 2), middlewareException = _d[0], mockedResponse = _d[1];
+                    this.log('all request listeners have been resolved!');
+                    const [mockedResponse] = yield interactiveRequest.respondWith.invoked();
+                    this.log('event.respondWith called with:', mockedResponse);
+                    return mockedResponse;
+                }))).then(([middlewareException, mockedResponse]) => {
+                    var _a, _b;
                     // When the request middleware throws an exception, error the request.
                     // This cancels the request and is similar to a network error.
                     if (middlewareException) {
-                        _this.log('middleware function threw an exception!', middlewareException);
+                        this.log('middleware function threw an exception!', middlewareException);
                         // Mark the request as complete.
-                        _this.setReadyState(_this.DONE);
+                        this.setReadyState(this.DONE);
                         // No way to propagate the actual error message.
-                        _this.trigger('error');
+                        this.trigger('error');
                         // Emit the "loadend" event to notify that the request has settled.
                         // In this case, there's been an error with the request so
                         // we must not emit the "load" event.
-                        _this.trigger('loadend');
+                        this.trigger('loadend');
                         // Abort must not be called when request fails!
                         // this.abort()
                         return;
                     }
                     // Forward request headers modified in the "request" listener.
-                    _this._requestHeaders = new headers_polyfill_1.Headers(capturedRequest.headers);
+                    this._requestHeaders = new headers_polyfill_1.Headers(capturedRequest.headers);
                     // Return a mocked response, if provided in the middleware.
                     if (mockedResponse) {
-                        var responseClone_1 = mockedResponse.clone();
-                        _this.log('received mocked response', mockedResponse);
-                        _this.status = (_b = mockedResponse.status) !== null && _b !== void 0 ? _b : 200;
-                        _this.statusText = mockedResponse.statusText || 'OK';
-                        _this.log('set response status', _this.status, _this.statusText);
-                        _this._responseHeaders = new headers_polyfill_1.Headers(mockedResponse.headers || {});
-                        _this.log('set response headers', _this._responseHeaders);
-                        _this.log('response type', _this.responseType);
-                        _this.responseURL = _this.url;
-                        var totalLength_1 = _this._responseHeaders.has('Content-Length')
-                            ? Number(_this._responseHeaders.get('Content-Length'))
+                        const responseClone = mockedResponse.clone();
+                        this.log('received mocked response', mockedResponse);
+                        this.status = (_a = mockedResponse.status) !== null && _a !== void 0 ? _a : 200;
+                        this.statusText = mockedResponse.statusText || 'OK';
+                        this.log('set response status', this.status, this.statusText);
+                        this._responseHeaders = new headers_polyfill_1.Headers(mockedResponse.headers || {});
+                        this.log('set response headers', this._responseHeaders);
+                        this.log('response type', this.responseType);
+                        this.responseURL = this.url;
+                        const totalLength = this._responseHeaders.has('Content-Length')
+                            ? Number(this._responseHeaders.get('Content-Length'))
                             : undefined;
                         // Trigger a loadstart event to indicate the initialization of the fetch.
-                        _this.trigger('loadstart', { loaded: 0, total: totalLength_1 });
+                        this.trigger('loadstart', { loaded: 0, total: totalLength });
                         // Mark that response headers has been received
                         // and trigger a ready state event to reflect received headers
                         // in a custom "onreadystatechange" callback.
-                        _this.setReadyState(_this.HEADERS_RECEIVED);
-                        _this.setReadyState(_this.LOADING);
-                        var closeResponseStream_1 = function () {
+                        this.setReadyState(this.HEADERS_RECEIVED);
+                        this.setReadyState(this.LOADING);
+                        const closeResponseStream = () => {
                             /**
                              * Explicitly mark the request as done so its response never hangs.
                              * @see https://github.com/mswjs/interceptors/issues/13
                              */
-                            _this.setReadyState(_this.DONE);
+                            this.setReadyState(this.DONE);
                             // Always trigger the "load" event because at this point
                             // the request has been performed successfully.
-                            _this.trigger('load', {
-                                loaded: _this._responseBuffer.byteLength,
-                                total: totalLength_1,
+                            this.trigger('load', {
+                                loaded: this._responseBuffer.byteLength,
+                                total: totalLength,
                             });
                             // Trigger a loadend event to indicate the fetch has completed.
-                            _this.trigger('loadend', {
-                                loaded: _this._responseBuffer.byteLength,
-                                total: totalLength_1,
+                            this.trigger('loadend', {
+                                loaded: this._responseBuffer.byteLength,
+                                total: totalLength,
                             });
-                            emitter.emit('response', responseClone_1, capturedRequest, requestId);
+                            emitter.emit('response', responseClone, capturedRequest, requestId);
                         };
                         if (mockedResponse.body) {
-                            var reader_1 = mockedResponse.body.getReader();
-                            var readNextChunk_1 = function () { return __awaiter(_this, void 0, void 0, function () {
-                                var _a, value, done;
-                                return __generator(this, function (_b) {
-                                    switch (_b.label) {
-                                        case 0: return [4 /*yield*/, reader_1.read()];
-                                        case 1:
-                                            _a = _b.sent(), value = _a.value, done = _a.done;
-                                            if (done) {
-                                                closeResponseStream_1();
-                                                return [2 /*return*/];
-                                            }
-                                            if (value) {
-                                                this._responseBuffer = (0, concatArrayBuffer_1.concatArrayBuffer)(this._responseBuffer, value);
-                                                this.trigger('progress', {
-                                                    loaded: this._responseBuffer.byteLength,
-                                                    total: totalLength_1,
-                                                });
-                                            }
-                                            readNextChunk_1();
-                                            return [2 /*return*/];
-                                    }
-                                });
-                            }); };
-                            readNextChunk_1();
+                            const reader = mockedResponse.body.getReader();
+                            const readNextChunk = () => __awaiter(this, void 0, void 0, function* () {
+                                const { value, done } = yield reader.read();
+                                if (done) {
+                                    closeResponseStream();
+                                    return;
+                                }
+                                if (value) {
+                                    this._responseBuffer = (0, concatArrayBuffer_1.concatArrayBuffer)(this._responseBuffer, value);
+                                    this.trigger('progress', {
+                                        loaded: this._responseBuffer.byteLength,
+                                        total: totalLength,
+                                    });
+                                }
+                                readNextChunk();
+                            });
+                            readNextChunk();
                         }
                         else {
-                            closeResponseStream_1();
+                            closeResponseStream();
                         }
                     }
                     else {
-                        _this.log('no mocked response received!');
+                        this.log('no mocked response received!');
                         // Perform an original request, when the request middleware returned no mocked response.
-                        var originalRequest_1 = new XMLHttpRequest();
-                        _this.log('opening an original request %s %s', _this.method, _this.url);
-                        originalRequest_1.open(_this.method, _this.url, (_c = _this.async) !== null && _c !== void 0 ? _c : true, _this.user, _this.password);
-                        originalRequest_1.addEventListener('readystatechange', function () {
+                        const originalRequest = new XMLHttpRequest();
+                        this.log('opening an original request %s %s', this.method, this.url);
+                        originalRequest.open(this.method, this.url, (_b = this.async) !== null && _b !== void 0 ? _b : true, this.user, this.password);
+                        originalRequest.addEventListener('readystatechange', () => {
                             // Forward the original response headers to the patched instance
                             // immediately as they are received.
-                            if (originalRequest_1.readyState === XMLHttpRequest.HEADERS_RECEIVED) {
-                                var responseHeaders = originalRequest_1.getAllResponseHeaders();
-                                _this.log('original response headers:\n', responseHeaders);
-                                _this._responseHeaders = (0, headers_polyfill_1.stringToHeaders)(responseHeaders);
-                                _this.log('original response headers (normalized)', _this._responseHeaders);
+                            if (originalRequest.readyState === XMLHttpRequest.HEADERS_RECEIVED) {
+                                const responseHeaders = originalRequest.getAllResponseHeaders();
+                                this.log('original response headers:\n', responseHeaders);
+                                this._responseHeaders = (0, headers_polyfill_1.stringToHeaders)(responseHeaders);
+                                this.log('original response headers (normalized)', this._responseHeaders);
                             }
                         });
-                        originalRequest_1.addEventListener('loadstart', function () {
+                        originalRequest.addEventListener('loadstart', () => {
                             // Forward the response type to the patched instance immediately.
                             // Response type affects how response reading properties are resolved.
-                            _this.responseType = originalRequest_1.responseType;
+                            this.responseType = originalRequest.responseType;
                         });
-                        originalRequest_1.addEventListener('progress', function () {
-                            _this._responseBuffer = (0, concatArrayBuffer_1.concatArrayBuffer)(_this._responseBuffer, (0, bufferUtils_1.encodeBuffer)(originalRequest_1.responseText));
+                        originalRequest.addEventListener('progress', () => {
+                            this._responseBuffer = (0, concatArrayBuffer_1.concatArrayBuffer)(this._responseBuffer, (0, bufferUtils_1.encodeBuffer)(originalRequest.responseText));
                         });
-                        originalRequest_1.addEventListener('load', function () {
-                            _this.status = originalRequest_1.status;
-                            _this.statusText = originalRequest_1.statusText;
-                            _this.responseURL = originalRequest_1.responseURL;
-                            _this.log('received original response', _this.status, _this.statusText);
+                        originalRequest.addEventListener('load', () => {
+                            this.status = originalRequest.status;
+                            this.statusText = originalRequest.statusText;
+                            this.responseURL = originalRequest.responseURL;
+                            this.log('received original response', this.status, this.statusText);
                             // Explicitly mark the mocked request instance as done
                             // so the response never hangs.
-                            _this.setReadyState(_this.DONE);
-                            _this.log('set mock request readyState to DONE');
-                            _this.log('original response body:', _this.response);
-                            _this.log('original response finished!');
+                            this.setReadyState(this.DONE);
+                            this.log('set mock request readyState to DONE');
+                            this.log('original response body:', this.response);
+                            this.log('original response finished!');
                         });
                         // Update the patched instance on the "loadend" event
                         // because it fires when the request settles (succeeds/errors).
-                        originalRequest_1.addEventListener('loadend', function () {
-                            _this.log('original "loadend"');
-                            emitter.emit('response', (0, createResponse_1.createResponse)(originalRequest_1, _this._responseBuffer), capturedRequest, requestId);
+                        originalRequest.addEventListener('loadend', () => {
+                            this.log('original "loadend"');
+                            emitter.emit('response', (0, createResponse_1.createResponse)(originalRequest, this._responseBuffer), capturedRequest, requestId);
                         });
-                        _this.propagateHeaders(originalRequest_1, _this._requestHeaders);
+                        this.propagateHeaders(originalRequest, this._requestHeaders);
                         // Assign callbacks and event listeners from the intercepted XHR instance
                         // to the original XHR instance.
-                        _this.propagateCallbacks(originalRequest_1);
-                        _this.propagateListeners(originalRequest_1);
-                        if (_this.async) {
-                            originalRequest_1.timeout = _this.timeout;
+                        this.propagateCallbacks(originalRequest);
+                        this.propagateListeners(originalRequest);
+                        if (this.async) {
+                            originalRequest.timeout = this.timeout;
                         }
                         /**
                          * @note Set the intercepted request ID on the original request
@@ -375,120 +286,107 @@ var createXMLHttpRequestOverride = function (options) {
                          * to process it once again. This happens when bypassing XMLHttpRequest
                          * because it's polyfilled with "http.ClientRequest" in JSDOM.
                          */
-                        originalRequest_1.setRequestHeader('X-Request-Id', requestId);
-                        _this.log('send', data);
-                        originalRequest_1.send(data);
+                        originalRequest.setRequestHeader('X-Request-Id', requestId);
+                        this.log('send', data);
+                        originalRequest.send(data);
                     }
                 });
-            };
-            Object.defineProperty(XMLHttpRequestOverride.prototype, "responseText", {
-                get: function () {
-                    this.log('responseText()');
-                    return (0, bufferUtils_1.decodeBuffer)(this._responseBuffer);
-                },
-                enumerable: false,
-                configurable: true
-            });
-            Object.defineProperty(XMLHttpRequestOverride.prototype, "response", {
-                get: function () {
-                    switch (this.responseType) {
-                        case 'json': {
-                            this.log('resolving response body as JSON');
-                            return (0, parseJson_1.parseJson)(this.responseText);
-                        }
-                        case 'arraybuffer': {
-                            this.log('resolving response body as ArrayBuffer');
-                            return (0, bufferUtils_1.toArrayBuffer)(this._responseBuffer);
-                        }
-                        case 'blob': {
-                            var mimeType = this.getResponseHeader('content-type') || 'text/plain';
-                            this.log('resolving response body as blog (%s)', mimeType);
-                            return new Blob([this.responseText], { type: mimeType });
-                        }
-                        case 'document': {
-                            this.log('resolving response body as XML');
-                            return this.responseXML;
-                        }
-                        default: {
-                            return this.responseText;
-                        }
+            }
+            get responseText() {
+                this.log('responseText()');
+                return (0, bufferUtils_1.decodeBuffer)(this._responseBuffer);
+            }
+            get response() {
+                switch (this.responseType) {
+                    case 'json': {
+                        this.log('resolving response body as JSON');
+                        return (0, parseJson_1.parseJson)(this.responseText);
+                    }
+                    case 'arraybuffer': {
+                        this.log('resolving response body as ArrayBuffer');
+                        return (0, bufferUtils_1.toArrayBuffer)(this._responseBuffer);
+                    }
+                    case 'blob': {
+                        const mimeType = this.getResponseHeader('content-type') || 'text/plain';
+                        this.log('resolving response body as blog (%s)', mimeType);
+                        return new Blob([this.responseText], { type: mimeType });
                     }
-                },
-                enumerable: false,
-                configurable: true
-            });
-            Object.defineProperty(XMLHttpRequestOverride.prototype, "responseXML", {
-                get: function () {
-                    var contentType = this.getResponseHeader('content-type') || '';
-                    this.log('responseXML() %s', contentType);
-                    if (typeof DOMParser === 'undefined') {
-                        console.warn('Cannot retrieve XMLHttpRequest response body as XML: DOMParser is not defined. You are likely using an environment that is not browser or does not polyfill browser globals correctly.');
-                        return null;
+                    case 'document': {
+                        this.log('resolving response body as XML');
+                        return this.responseXML;
                     }
-                    if ((0, isDomParserSupportedType_1.isDomParserSupportedType)(contentType)) {
-                        this.log('response content-type is XML, parsing...');
-                        return new DOMParser().parseFromString(this.responseText, contentType);
+                    default: {
+                        return this.responseText;
                     }
-                    this.log('response content type is not XML, returning null...');
+                }
+            }
+            get responseXML() {
+                const contentType = this.getResponseHeader('content-type') || '';
+                this.log('responseXML() %s', contentType);
+                if (typeof DOMParser === 'undefined') {
+                    console.warn('Cannot retrieve XMLHttpRequest response body as XML: DOMParser is not defined. You are likely using an environment that is not browser or does not polyfill browser globals correctly.');
                     return null;
-                },
-                enumerable: false,
-                configurable: true
-            });
-            XMLHttpRequestOverride.prototype.abort = function () {
+                }
+                if ((0, isDomParserSupportedType_1.isDomParserSupportedType)(contentType)) {
+                    this.log('response content-type is XML, parsing...');
+                    return new DOMParser().parseFromString(this.responseText, contentType);
+                }
+                this.log('response content type is not XML, returning null...');
+                return null;
+            }
+            abort() {
                 this.log('abort()');
                 if (this.readyState > this.UNSENT && this.readyState < this.DONE) {
                     this.reset();
                     this.trigger('abort');
                 }
-            };
-            XMLHttpRequestOverride.prototype.dispatchEvent = function () {
+            }
+            dispatchEvent() {
                 return false;
-            };
-            XMLHttpRequestOverride.prototype.setRequestHeader = function (name, value) {
+            }
+            setRequestHeader(name, value) {
                 this.log('setRequestHeader() "%s" to "%s"', name, value);
                 this._requestHeaders.append(name, value);
-            };
-            XMLHttpRequestOverride.prototype.getResponseHeader = function (name) {
+            }
+            getResponseHeader(name) {
                 this.log('getResponseHeader() "%s"', name);
                 if (this.readyState < this.HEADERS_RECEIVED) {
                     this.log('cannot return a header: headers not received (state: %s)', this.readyState);
                     return null;
                 }
-                var headerValue = this._responseHeaders.get(name);
+                const headerValue = this._responseHeaders.get(name);
                 this.log('resolved response header "%s" to "%s"', name, headerValue, this._responseHeaders);
                 return headerValue;
-            };
-            XMLHttpRequestOverride.prototype.getAllResponseHeaders = function () {
+            }
+            getAllResponseHeaders() {
                 this.log('getAllResponseHeaders()');
                 if (this.readyState < this.HEADERS_RECEIVED) {
                     this.log('cannot return headers: headers not received (state: %s)', this.readyState);
                     return '';
                 }
                 return (0, headers_polyfill_1.headersToString)(this._responseHeaders);
-            };
-            XMLHttpRequestOverride.prototype.addEventListener = function (event, listener) {
+            }
+            addEventListener(event, listener) {
                 this.log('addEventListener', event, listener);
                 this._events.push({
                     name: event,
-                    listener: listener,
+                    listener,
                 });
-            };
-            XMLHttpRequestOverride.prototype.removeEventListener = function (event, listener) {
+            }
+            removeEventListener(event, listener) {
                 this.log('removeEventListener', name, listener);
-                this._events = this._events.filter(function (storedEvent) {
+                this._events = this._events.filter((storedEvent) => {
                     return storedEvent.name !== event && storedEvent.listener !== listener;
                 });
-            };
-            XMLHttpRequestOverride.prototype.overrideMimeType = function () { };
+            }
+            overrideMimeType() { }
             /**
              * Propagates mock XMLHttpRequest instance callbacks
              * to the given XMLHttpRequest instance.
              */
-            XMLHttpRequestOverride.prototype.propagateCallbacks = function (request) {
-                var e_2, _a;
+            propagateCallbacks(request) {
                 this.log('propagating request callbacks to the original request');
-                var callbackNames = [
+                const callbackNames = [
                     'abort',
                     'onerror',
                     'ontimeout',
@@ -498,23 +396,13 @@ var createXMLHttpRequestOverride = function (options) {
                     'onprogress',
                     'onreadystatechange',
                 ];
-                try {
-                    for (var callbackNames_1 = __values(callbackNames), callbackNames_1_1 = callbackNames_1.next(); !callbackNames_1_1.done; callbackNames_1_1 = callbackNames_1.next()) {
-                        var callbackName = callbackNames_1_1.value;
-                        var callback = this[callbackName];
-                        if (callback) {
-                            request[callbackName] = this[callbackName];
-                            this.log('propagated the "%s" callback', callbackName, callback);
-                        }
+                for (const callbackName of callbackNames) {
+                    const callback = this[callbackName];
+                    if (callback) {
+                        request[callbackName] = this[callbackName];
+                        this.log('propagated the "%s" callback', callbackName, callback);
                     }
                 }
-                catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                finally {
-                    try {
-                        if (callbackNames_1_1 && !callbackNames_1_1.done && (_a = callbackNames_1.return)) _a.call(callbackNames_1);
-                    }
-                    finally { if (e_2) throw e_2.error; }
-                }
                 request.onabort = this.abort;
                 request.onerror = this.onerror;
                 request.ontimeout = this.ontimeout;
@@ -523,38 +411,25 @@ var createXMLHttpRequestOverride = function (options) {
                 request.onloadend = this.onloadend;
                 request.onprogress = this.onprogress;
                 request.onreadystatechange = this.onreadystatechange;
-            };
+            }
             /**
              * Propagates the mock XMLHttpRequest instance listeners
              * to the given XMLHttpRequest instance.
              */
-            XMLHttpRequestOverride.prototype.propagateListeners = function (request) {
+            propagateListeners(request) {
                 this.log('propagating request listeners (%d) to the original request', this._events.length, this._events);
-                this._events.forEach(function (_a) {
-                    var name = _a.name, listener = _a.listener;
+                this._events.forEach(({ name, listener }) => {
                     request.addEventListener(name, listener);
                 });
-            };
-            XMLHttpRequestOverride.prototype.propagateHeaders = function (request, headers) {
-                var e_3, _a;
+            }
+            propagateHeaders(request, headers) {
                 this.log('propagating request headers to the original request', headers);
-                try {
-                    for (var headers_1 = __values(headers), headers_1_1 = headers_1.next(); !headers_1_1.done; headers_1_1 = headers_1.next()) {
-                        var _b = __read(headers_1_1.value, 2), headerName = _b[0], headerValue = _b[1];
-                        this.log('setting "%s" (%s) header on the original request', headerName, headerValue);
-                        request.setRequestHeader(headerName, headerValue);
-                    }
+                for (const [headerName, headerValue] of headers) {
+                    this.log('setting "%s" (%s) header on the original request', headerName, headerValue);
+                    request.setRequestHeader(headerName, headerValue);
                 }
-                catch (e_3_1) { e_3 = { error: e_3_1 }; }
-                finally {
-                    try {
-                        if (headers_1_1 && !headers_1_1.done && (_a = headers_1.return)) _a.call(headers_1);
-                    }
-                    finally { if (e_3) throw e_3.error; }
-                }
-            };
-            return XMLHttpRequestOverride;
-        }()),
+            }
+        },
         /* Request state */
         _a.UNSENT = 0,
         _a.OPENED = 1,