@inboxsdk/core 1.1.6 → 1.1.8

package/src/injected-js/xhr-proxy-factory.js

@@ -1,40 +1,15 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = XHRProxyFactory;
-var _has = _interopRequireDefault(require("lodash/has"));
-var _noop = _interopRequireDefault(require("lodash/noop"));
-var _each = _interopRequireDefault(require("lodash/each"));
-var _filter = _interopRequireDefault(require("lodash/filter"));
-var _includes = _interopRequireDefault(require("lodash/includes"));
-var _once = _interopRequireDefault(require("lodash/once"));
-var _assert = _interopRequireDefault(require("assert"));
-var _events = _interopRequireDefault(require("events"));
-var _querystring = require("querystring");
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable prefer-rest-params */
+import has from 'lodash/has';
+import noop from 'lodash/noop';
+import each from 'lodash/each';
+import filter from 'lodash/filter';
+import includes from 'lodash/includes';
+import once from 'lodash/once';
+import assert from 'assert';
+import EventEmitter from 'events';
+import { parse as deparam } from 'querystring';
 const WARNING_TIMEOUT = 60 * 1000;
-
-/**
- * Object with information about the connection in progress. Its fields are
- * populated as the connection goes on. The object is passed as the first
- * argument to all of the wrappers. The object is mutable so the wrappers can
- * add properties to it.
- *
- * @typedef {Object} XHRProxyConnectionDetails
- * @property {string} method
- * @property {string} url
- * @property {Object} params - parameters decoded from the URL
- * @property {Object} headers - request headers set on the XHR
- * @property {string} responseType
- * @property {string} originalSendBody - data passed to send method
- * @property {number} status - HTTP response status
- * @property {string} [originalResponseText] - Is not set if responseType is set
- *  to a value besides 'text'.
- * @property {string} [modifiedResponseText]
- */
-
 /**
  * Creates a drop-in replacement for the XMLHttpRequest constructor that can
  * have wrappers which may log or modify server responses. See
@@ -45,442 +20,519 @@ const WARNING_TIMEOUT = 60 * 1000;
  * @param {Object} [opts] - Can specify a logError function
  * @returns {function} wrapped XMLHttpRequest-like constructor
  */
-function XHRProxyFactory(XHR, wrappers, opts) {
-  const logError = opts && opts.logError || function (error, label) {
-    setTimeout(function () {
-      // let window.onerror log this
-      throw error;
-    }, 1);
-  };
-  function transformEvent(oldTarget, newTarget, event) {
-    const newEvent = {};
-    Object.keys(event).concat(['bubbles', 'cancelBubble', 'cancelable', 'defaultPrevented', 'preventDefault', 'stopPropagation', 'stopImmediatePropagation', 'lengthComputable', 'loaded', 'total', 'type', 'currentTarget', 'target', 'srcElement', 'NONE', 'CAPTURING_PHASE', 'AT_TARGET', 'BUBBLING_PHASE', 'eventPhase']).filter(name => name in event).forEach(name => {
-      const value = event[name];
-      if (value === oldTarget) {
-        newEvent[name] = newTarget;
-      } else if (typeof value === 'function') {
-        newEvent[name] = value.bind(event);
-      } else {
-        newEvent[name] = value;
-      }
-    });
-    return newEvent;
-  }
-  function wrapEventListener(oldTarget, newTarget, listener) {
-    return function (event) {
-      return listener.call(newTarget, transformEvent(oldTarget, newTarget, event));
-    };
-  }
-  function findApplicableWrappers(wrappers, connection) {
-    return (0, _filter.default)(wrappers, function (wrapper) {
-      try {
-        return wrapper.isRelevantTo(connection);
-      } catch (e) {
-        logError(e);
-      }
-    });
-  }
-  function XHRProxy() {
-    this._wrappers = wrappers;
-    this._listeners = {};
-    this._boundListeners = {};
-    this._events = new _events.default(); // used for internal stuff, not user-visible events
-    this.responseText = '';
-    this._openState = false;
-    if (XHR.bind && XHR.bind.apply) {
-      // call constructor with variable number of arguments
-      this._realxhr = new (XHR.bind.apply(XHR, [null].concat(arguments)))();
-    } else {
-      // Safari's XMLHttpRequest lacks a bind method, but its constructor
-      // doesn't support extra arguments anyway, so don't bother logging an
-      // error here.
-      this._realxhr = new XHR();
+export default function XHRProxyFactory(XHR, wrappers, opts) {
+    const logError = (opts && opts.logError) ||
+        function (error, label) {
+            setTimeout(function () {
+                // let window.onerror log this
+                throw error;
+            }, 1);
+        };
+    function transformEvent(oldTarget, newTarget, event) {
+        const newEvent = {};
+        Object.keys(event)
+            .concat([
+            'bubbles',
+            'cancelBubble',
+            'cancelable',
+            'defaultPrevented',
+            'preventDefault',
+            'stopPropagation',
+            'stopImmediatePropagation',
+            'lengthComputable',
+            'loaded',
+            'total',
+            'type',
+            'currentTarget',
+            'target',
+            'srcElement',
+            'NONE',
+            'CAPTURING_PHASE',
+            'AT_TARGET',
+            'BUBBLING_PHASE',
+            'eventPhase',
+        ])
+            .filter((name) => name in event)
+            .forEach((name) => {
+            const value = event[name];
+            if (value === oldTarget) {
+                newEvent[name] = newTarget;
+            }
+            else if (typeof value === 'function') {
+                newEvent[name] = value.bind(event);
+            }
+            else {
+                newEvent[name] = value;
+            }
+        });
+        return newEvent;
+    }
+    function wrapEventListener(oldTarget, newTarget, listener) {
+        return function (event) {
+            return listener.call(newTarget, transformEvent(oldTarget, newTarget, event));
+        };
+    }
+    function findApplicableWrappers(wrappers, connection) {
+        return filter(wrappers, function (wrapper) {
+            try {
+                return wrapper.isRelevantTo(connection);
+            }
+            catch (e) {
+                logError(e);
+            }
+        });
     }
-    const self = this;
-    const triggerEventListeners = (name, event) => {
-      if (this['on' + name]) {
-        try {
-          wrapEventListener(this._realxhr, this, this['on' + name]).call(this, event);
-        } catch (e) {
-          logError(e, 'XMLHttpRequest event listener error');
+    function XHRProxy() {
+        this._wrappers = wrappers;
+        this._listeners = {};
+        this._boundListeners = {};
+        this._events = new EventEmitter(); // used for internal stuff, not user-visible events
+        this.responseText = '';
+        this._openState = false;
+        if (XHR.bind && XHR.bind.apply) {
+            // call constructor with variable number of arguments
+            this._realxhr = new (XHR.bind.apply(XHR, [null].concat(arguments)))();
+        }
+        else {
+            // Safari's XMLHttpRequest lacks a bind method, but its constructor
+            // doesn't support extra arguments anyway, so don't bother logging an
+            // error here.
+            this._realxhr = new XHR();
         }
-      }
-      (0, _each.default)(this._boundListeners[name], boundListener => {
-        try {
-          boundListener(event);
-        } catch (e) {
-          logError(e, 'XMLHttpRequest event listener error');
+        const self = this;
+        const triggerEventListeners = (name, event) => {
+            if (this['on' + name]) {
+                try {
+                    wrapEventListener(this._realxhr, this, this['on' + name]).call(this, event);
+                }
+                catch (e) {
+                    logError(e, 'XMLHttpRequest event listener error');
+                }
+            }
+            each(this._boundListeners[name], (boundListener) => {
+                try {
+                    boundListener(event);
+                }
+                catch (e) {
+                    logError(e, 'XMLHttpRequest event listener error');
+                }
+            });
+        };
+        const runRscListeners = (event) => {
+            triggerEventListeners('readystatechange', event);
+        };
+        this._fakeRscEvent = function () {
+            runRscListeners(Object.freeze({
+                bubbles: false,
+                cancelBubble: false,
+                cancelable: false,
+                defaultPrevented: false,
+                preventDefault: noop,
+                stopPropagation: noop,
+                stopImmediatePropagation: noop,
+                type: 'readystatechange',
+                currentTarget: this,
+                target: this,
+                srcElement: this,
+                NONE: 0,
+                CAPTURING_PHASE: 1,
+                AT_TARGET: 2,
+                BUBBLING_PHASE: 3,
+                eventPhase: 0,
+            }));
+        };
+        const deliverFinalRsc = (event) => {
+            this.readyState = 4;
+            // Remember the status now before any event handlers are called, just in
+            // case one aborts the request.
+            var wasSuccess = this.status == 200;
+            var progressEvent = Object.assign({}, transformEvent(this._realxhr, this, event), {
+                lengthComputable: false,
+                loaded: 0,
+                total: 0,
+            });
+            var supportsResponseText = !this._realxhr.responseType || this._realxhr.responseType == 'text';
+            if (supportsResponseText) {
+                each(this._activeWrappers, (wrapper) => {
+                    if (wrapper.finalResponseTextLogger) {
+                        try {
+                            wrapper.finalResponseTextLogger(this._connection, this.responseText);
+                        }
+                        catch (e) {
+                            logError(e);
+                        }
+                    }
+                });
+            }
+            runRscListeners(event);
+            if (wasSuccess) {
+                triggerEventListeners('load', progressEvent);
+            }
+            else {
+                triggerEventListeners('error', progressEvent);
+            }
+            triggerEventListeners('loadend', progressEvent);
+            each(this._activeWrappers, (wrapper) => {
+                if (wrapper.afterListeners) {
+                    try {
+                        wrapper.afterListeners(this._connection);
+                    }
+                    catch (e) {
+                        logError(e);
+                    }
+                }
+            });
+        };
+        this._realxhr.addEventListener('readystatechange', (event) => {
+            if (!this._connection) {
+                return;
+            }
+            if (this._realxhr.readyState >= 2) {
+                this._connection.status = this._realxhr.status;
+            }
+            const supportsResponseText = !this._realxhr.responseType || this._realxhr.responseType == 'text';
+            // Process the response text.
+            if (this._realxhr.readyState == 4) {
+                if (supportsResponseText) {
+                    Object.defineProperty(this._connection, 'originalResponseText', {
+                        enumerable: true,
+                        writable: false,
+                        configurable: false,
+                        value: self._realxhr.responseText,
+                    });
+                    each(this._activeWrappers, (wrapper) => {
+                        if (wrapper.originalResponseTextLogger) {
+                            try {
+                                wrapper.originalResponseTextLogger(this._connection, this._connection.originalResponseText);
+                            }
+                            catch (e) {
+                                logError(e);
+                            }
+                        }
+                    });
+                    const finish = once(deliverFinalRsc.bind(null, event));
+                    if (this._connection.async) {
+                        // If the XHR object is re-used for another connection, then we need
+                        // to make sure that our upcoming async calls here do nothing.
+                        // Remember the current connection object, and do nothing in our async
+                        // calls if it no longer matches.
+                        const startConnection = this._connection;
+                        (async () => {
+                            let modifiedResponseText = startConnection.originalResponseText;
+                            startConnection.modifiedResponseText = modifiedResponseText;
+                            for (const responseTextChanger of this._responseTextChangers) {
+                                const longRunWarningTimer = setTimeout(() => {
+                                    console.warn('responseTextChanger is taking too long', responseTextChanger, startConnection);
+                                }, WARNING_TIMEOUT);
+                                try {
+                                    modifiedResponseText = await responseTextChanger(startConnection, modifiedResponseText);
+                                }
+                                finally {
+                                    clearTimeout(longRunWarningTimer);
+                                }
+                                if (typeof modifiedResponseText !== 'string') {
+                                    throw new Error('responseTextChanger returned non-string value ' +
+                                        modifiedResponseText);
+                                }
+                                startConnection.modifiedResponseText = modifiedResponseText;
+                                if (startConnection !== this._connection)
+                                    break;
+                            }
+                            return modifiedResponseText;
+                        })()
+                            .then((modifiedResponseText) => {
+                            if (startConnection === self._connection) {
+                                this.responseText = modifiedResponseText;
+                                finish();
+                            }
+                        }, (err) => {
+                            logError(err);
+                            if (startConnection === this._connection) {
+                                this.responseText = this._realxhr.responseText;
+                                finish();
+                            }
+                        })
+                            .catch(logError);
+                        return;
+                    }
+                    else {
+                        self.responseText = self._realxhr.responseText;
+                    }
+                }
+                else {
+                    self.responseText = '';
+                }
+                deliverFinalRsc(event);
+            }
+            else {
+                if (self._realxhr.readyState == 1 && self.readyState == 1) {
+                    // Delayed open+send just happened. We already delivered an event
+                    // for this, so drop this event.
+                    return;
+                }
+                else if (self._realxhr.readyState >= 3 && supportsResponseText) {
+                    if (self._responseTextChangers.length) {
+                        // If we're going to transform the final response, then we don't
+                        // want to expose any partial untransformed responses and we don't
+                        // want to bother trying to transform partial responses. Only show
+                        // an empty string as the loaded response until the connection is
+                        // done.
+                        self.responseText = '';
+                    }
+                    else {
+                        self.responseText = self._realxhr.responseText;
+                    }
+                }
+                else {
+                    self.responseText = '';
+                }
+                self.readyState = self._realxhr.readyState;
+                runRscListeners(event);
+            }
+        }, false);
+        [
+            'dispatchEvent',
+            'getAllResponseHeaders',
+            'getResponseHeader',
+            'overrideMimeType',
+            'responseType',
+            'responseXML',
+            'responseURL',
+            'status',
+            'statusText',
+            'timeout',
+            'ontimeout',
+            'onloadstart',
+            'onprogress',
+            'onabort',
+            'upload',
+            'withCredentials',
+        ].forEach(function (prop) {
+            Object.defineProperty(self, prop, {
+                enumerable: true,
+                configurable: false,
+                get: function () {
+                    // If we give the original native methods directly, they'll be called
+                    // with `this` as the XHRProxy object, which they aren't made for.
+                    if (typeof self._realxhr[prop] == 'function') {
+                        return self._realxhr[prop].bind(self._realxhr);
+                    }
+                    return self._realxhr[prop];
+                },
+                set: function (v) {
+                    if (typeof v == 'function') {
+                        v = wrapEventListener(this._realxhr, this, v);
+                    }
+                    self._realxhr[prop] = v;
+                },
+            });
+        });
+        Object.defineProperty(self, 'response', {
+            enumerable: true,
+            configurable: false,
+            get: function () {
+                if (!this._realxhr.responseType ||
+                    this._realxhr.responseType == 'text') {
+                    return this.responseText;
+                }
+                else {
+                    // We're not trying to transform non-text responses currently.
+                    return this._realxhr.response;
+                }
+            },
+        });
+        self.readyState = self._realxhr.readyState;
+    }
+    XHRProxy.prototype.abort = function () {
+        // Important: If the request has already been sent, the XHR will change
+        // its readyState to 4 after abort. However, we sometimes asynchronously
+        // delay send calls. If the application has already called send but we
+        // haven't sent off the real call yet, then we need to hurry up and send
+        // something before the abort so that the readyState change happens.
+        if (this._clientStartedSend && !this._realStartedSend) {
+            if (this.readyState != 0 && this._realxhr.readyState == 0) {
+                this._realxhr.open(this._connection.method, this._connection.url);
+            }
+            this._realStartedSend = true;
+            this._realxhr.send();
         }
-      });
+        this._realxhr.abort();
     };
-    const runRscListeners = event => {
-      triggerEventListeners('readystatechange', event);
+    XHRProxy.prototype.setRequestHeader = function (name, value) {
+        var self = this;
+        if (this.readyState != 1) {
+            console.warn('setRequestHeader improperly called at readyState ' + this.readyState);
+        }
+        if (!this._openState) {
+            throw new Error('Can only set headers after open and before send');
+        }
+        this._connection.headers[name] = value;
+        if (this._connection.async && this._requestChangers.length) {
+            this._events.once('realOpen', function () {
+                self._realxhr.setRequestHeader(name, value);
+            });
+        }
+        else {
+            this._realxhr.setRequestHeader(name, value);
+        }
     };
-    this._fakeRscEvent = function () {
-      runRscListeners(Object.freeze({
-        bubbles: false,
-        cancelBubble: false,
-        cancelable: false,
-        defaultPrevented: false,
-        preventDefault: _noop.default,
-        stopPropagation: _noop.default,
-        stopImmediatePropagation: _noop.default,
-        type: 'readystatechange',
-        currentTarget: this,
-        target: this,
-        srcElement: this,
-        NONE: 0,
-        CAPTURING_PHASE: 1,
-        AT_TARGET: 2,
-        BUBBLING_PHASE: 3,
-        eventPhase: 0
-      }));
+    XHRProxy.prototype.addEventListener = function (name, listener) {
+        if (!this._listeners[name]) {
+            this._listeners[name] = [];
+            this._boundListeners[name] = [];
+        }
+        if (!includes(this._listeners[name], listener)) {
+            var boundListener = wrapEventListener(this._realxhr, this, listener);
+            this._listeners[name].push(listener);
+            this._boundListeners[name].push(boundListener);
+            if (!includes(['readystatechange', 'load', 'error', 'loadend'], name)) {
+                // certain listeners are called manually so that the final
+                // call (when readyState==4) can be delayed.
+                this._realxhr.addEventListener(name, boundListener, false);
+            }
+        }
     };
-    const deliverFinalRsc = event => {
-      this.readyState = 4;
-      // Remember the status now before any event handlers are called, just in
-      // case one aborts the request.
-      var wasSuccess = this.status == 200;
-      var progressEvent = Object.assign({}, transformEvent(this._realxhr, this, event), {
-        lengthComputable: false,
-        loaded: 0,
-        total: 0
-      });
-      var supportsResponseText = !this._realxhr.responseType || this._realxhr.responseType == 'text';
-      if (supportsResponseText) {
-        (0, _each.default)(this._activeWrappers, wrapper => {
-          if (wrapper.finalResponseTextLogger) {
-            try {
-              wrapper.finalResponseTextLogger(this._connection, this.responseText);
-            } catch (e) {
-              logError(e);
+    XHRProxy.prototype.removeEventListener = function (name, listener) {
+        if (!this._listeners[name]) {
+            return;
+        }
+        var i = this._listeners[name].indexOf(listener);
+        if (i == -1) {
+            return;
+        }
+        this._listeners[name].splice(i, 1);
+        var boundListener = this._boundListeners[name].splice(i, 1)[0];
+        if (name != 'readystatechange') {
+            this._realxhr.removeEventListener(name, boundListener, false);
+        }
+    };
+    XHRProxy.prototype.open = function (method, url, async) {
+        // Work around MailTrack issue
+        if (!(this instanceof XHRProxy)) {
+            return XHR.prototype.open.apply(this, arguments);
+        }
+        var self = this;
+        this._connection = {
+            method: method,
+            url: url,
+            params: deparam(url.split('?')[1] || ''),
+            headers: {},
+            async: arguments.length < 3 || !!async,
+        };
+        this._clientStartedSend = false;
+        this._realStartedSend = false;
+        this._activeWrappers = findApplicableWrappers(this._wrappers, this._connection);
+        this._responseTextChangers = this._activeWrappers
+            .map(function (wrapper) {
+            return (wrapper.responseTextChanger &&
+                wrapper.responseTextChanger.bind(wrapper));
+        })
+            .filter(Boolean);
+        this.responseText = '';
+        this._openState = true;
+        function finish(method, url) {
+            return self._realxhr.open(method, url, self._connection.async);
+        }
+        if (this._connection.async) {
+            this._requestChangers = this._activeWrappers
+                .map(function (wrapper) {
+                return wrapper.requestChanger && wrapper.requestChanger.bind(wrapper);
+            })
+                .filter(Boolean);
+            if (this._requestChangers.length) {
+                if (this.readyState != 1) {
+                    this.readyState = 1;
+                    this._fakeRscEvent();
+                }
             }
-          }
-        });
-      }
-      runRscListeners(event);
-      if (wasSuccess) {
-        triggerEventListeners('load', progressEvent);
-      } else {
-        triggerEventListeners('error', progressEvent);
-      }
-      triggerEventListeners('loadend', progressEvent);
-      (0, _each.default)(this._activeWrappers, wrapper => {
-        if (wrapper.afterListeners) {
-          try {
-            wrapper.afterListeners(this._connection);
-          } catch (e) {
-            logError(e);
-          }
+            else {
+                finish(method, url);
+            }
+        }
+        else {
+            finish(method, url);
         }
-      });
     };
-    this._realxhr.addEventListener('readystatechange', event => {
-      if (!this._connection) {
-        return;
-      }
-      if (this._realxhr.readyState >= 2) {
-        this._connection.status = this._realxhr.status;
-      }
-      const supportsResponseText = !this._realxhr.responseType || this._realxhr.responseType == 'text';
-
-      // Process the response text.
-      if (this._realxhr.readyState == 4) {
-        if (supportsResponseText) {
-          Object.defineProperty(this._connection, 'originalResponseText', {
+    XHRProxy.prototype.send = function (body) {
+        var self = this;
+        this._clientStartedSend = true;
+        this._openState = false;
+        Object.defineProperty(this._connection, 'originalSendBody', {
             enumerable: true,
             writable: false,
             configurable: false,
-            value: self._realxhr.responseText
-          });
-          (0, _each.default)(this._activeWrappers, wrapper => {
-            if (wrapper.originalResponseTextLogger) {
-              try {
-                wrapper.originalResponseTextLogger(this._connection, this._connection.originalResponseText);
-              } catch (e) {
-                logError(e);
-              }
+            value: body,
+        });
+        this._connection.responseType = this._realxhr.responseType || 'text';
+        each(self._activeWrappers, function (wrapper) {
+            if (wrapper.originalSendBodyLogger) {
+                try {
+                    wrapper.originalSendBodyLogger(self._connection, body);
+                }
+                catch (e) {
+                    logError(e);
+                }
             }
-          });
-          const finish = (0, _once.default)(deliverFinalRsc.bind(null, event));
-          if (this._connection.async) {
+        });
+        function finish(body) {
+            self._realStartedSend = true;
+            self._realxhr.send(body);
+        }
+        if (this._connection.async && this._requestChangers.length) {
             // If the XHR object is re-used for another connection, then we need
             // to make sure that our upcoming async calls here do nothing.
             // Remember the current connection object, and do nothing in our async
-            // calls if it no longer matches.
+            // calls if it no longer matches. Also check for aborts.
             const startConnection = this._connection;
+            const request = {
+                method: this._connection.method,
+                url: this._connection.url,
+                body: body,
+            };
             (async () => {
-              let modifiedResponseText = startConnection.originalResponseText;
-              startConnection.modifiedResponseText = modifiedResponseText;
-              for (let responseTextChanger of this._responseTextChangers) {
-                const longRunWarningTimer = setTimeout(() => {
-                  console.warn('responseTextChanger is taking too long', responseTextChanger, startConnection);
-                }, WARNING_TIMEOUT);
-                try {
-                  modifiedResponseText = await responseTextChanger(startConnection, modifiedResponseText);
-                } finally {
-                  clearTimeout(longRunWarningTimer);
+                let modifiedRequest = request;
+                for (const requestChanger of this._requestChangers) {
+                    const longRunWarningTimer = setTimeout(() => {
+                        console.warn('requestChanger is taking too long', requestChanger, startConnection);
+                    }, WARNING_TIMEOUT);
+                    try {
+                        modifiedRequest = await requestChanger(this._connection, Object.freeze(modifiedRequest));
+                    }
+                    finally {
+                        clearTimeout(longRunWarningTimer);
+                    }
+                    assert(has(modifiedRequest, 'method'), 'modifiedRequest has method');
+                    assert(has(modifiedRequest, 'url'), 'modifiedRequest has url');
+                    assert(has(modifiedRequest, 'body'), 'modifiedRequest has body');
+                    if (startConnection !== this._connection || this._realStartedSend)
+                        break;
                 }
-                if (typeof modifiedResponseText !== 'string') {
-                  throw new Error('responseTextChanger returned non-string value ' + modifiedResponseText);
+                return modifiedRequest;
+            })()
+                .catch((err) => {
+                logError(err);
+                return request;
+            })
+                .then((modifiedRequest) => {
+                if (startConnection === this._connection && !this._realStartedSend) {
+                    this._realxhr.open(modifiedRequest.method, modifiedRequest.url);
+                    this._events.emit('realOpen');
+                    finish(modifiedRequest.body);
                 }
-                startConnection.modifiedResponseText = modifiedResponseText;
-                if (startConnection !== this._connection) break;
-              }
-              return modifiedResponseText;
-            })().then(modifiedResponseText => {
-              if (startConnection === self._connection) {
-                this.responseText = modifiedResponseText;
-                finish();
-              }
-            }, err => {
-              logError(err);
-              if (startConnection === this._connection) {
-                this.responseText = this._realxhr.responseText;
-                finish();
-              }
-            }).catch(logError);
-            return;
-          } else {
-            self.responseText = self._realxhr.responseText;
-          }
-        } else {
-          self.responseText = '';
-        }
-        deliverFinalRsc(event);
-      } else {
-        if (self._realxhr.readyState == 1 && self.readyState == 1) {
-          // Delayed open+send just happened. We already delivered an event
-          // for this, so drop this event.
-          return;
-        } else if (self._realxhr.readyState >= 3 && supportsResponseText) {
-          if (self._responseTextChangers.length) {
-            // If we're going to transform the final response, then we don't
-            // want to expose any partial untransformed responses and we don't
-            // want to bother trying to transform partial responses. Only show
-            // an empty string as the loaded response until the connection is
-            // done.
-            self.responseText = '';
-          } else {
-            self.responseText = self._realxhr.responseText;
-          }
-        } else {
-          self.responseText = '';
+            });
         }
-        self.readyState = self._realxhr.readyState;
-        runRscListeners(event);
-      }
-    }, false);
-    ['dispatchEvent', 'getAllResponseHeaders', 'getResponseHeader', 'overrideMimeType', 'responseType', 'responseXML', 'responseURL', 'status', 'statusText', 'timeout', 'ontimeout', 'onloadstart', 'onprogress', 'onabort', 'upload', 'withCredentials'].forEach(function (prop) {
-      Object.defineProperty(self, prop, {
-        enumerable: true,
-        configurable: false,
-        get: function () {
-          // If we give the original native methods directly, they'll be called
-          // with `this` as the XHRProxy object, which they aren't made for.
-          if (typeof self._realxhr[prop] == 'function') {
-            return self._realxhr[prop].bind(self._realxhr);
-          }
-          return self._realxhr[prop];
-        },
-        set: function (v) {
-          if (typeof v == 'function') {
-            v = wrapEventListener(this._realxhr, this, v);
-          }
-          self._realxhr[prop] = v;
+        else {
+            finish(body);
         }
-      });
-    });
-    Object.defineProperty(self, 'response', {
-      enumerable: true,
-      configurable: false,
-      get: function () {
-        if (!this._realxhr.responseType || this._realxhr.responseType == 'text') {
-          return this.responseText;
-        } else {
-          // We're not trying to transform non-text responses currently.
-          return this._realxhr.response;
-        }
-      }
-    });
-    self.readyState = self._realxhr.readyState;
-  }
-  XHRProxy.prototype.abort = function () {
-    // Important: If the request has already been sent, the XHR will change
-    // its readyState to 4 after abort. However, we sometimes asynchronously
-    // delay send calls. If the application has already called send but we
-    // haven't sent off the real call yet, then we need to hurry up and send
-    // something before the abort so that the readyState change happens.
-    if (this._clientStartedSend && !this._realStartedSend) {
-      if (this.readyState != 0 && this._realxhr.readyState == 0) {
-        this._realxhr.open(this._connection.method, this._connection.url);
-      }
-      this._realStartedSend = true;
-      this._realxhr.send();
-    }
-    this._realxhr.abort();
-  };
-  XHRProxy.prototype.setRequestHeader = function (name, value) {
-    var self = this;
-    if (this.readyState != 1) {
-      console.warn('setRequestHeader improperly called at readyState ' + this.readyState);
-    }
-    if (!this._openState) {
-      throw new Error('Can only set headers after open and before send');
-    }
-    this._connection.headers[name] = value;
-    if (this._connection.async && this._requestChangers.length) {
-      this._events.once('realOpen', function () {
-        self._realxhr.setRequestHeader(name, value);
-      });
-    } else {
-      this._realxhr.setRequestHeader(name, value);
-    }
-  };
-  XHRProxy.prototype.addEventListener = function (name, listener) {
-    if (!this._listeners[name]) {
-      this._listeners[name] = [];
-      this._boundListeners[name] = [];
-    }
-    if (!(0, _includes.default)(this._listeners[name], listener)) {
-      var boundListener = wrapEventListener(this._realxhr, this, listener);
-      this._listeners[name].push(listener);
-      this._boundListeners[name].push(boundListener);
-      if (!(0, _includes.default)(['readystatechange', 'load', 'error', 'loadend'], name)) {
-        // certain listeners are called manually so that the final
-        // call (when readyState==4) can be delayed.
-        this._realxhr.addEventListener(name, boundListener, false);
-      }
-    }
-  };
-  XHRProxy.prototype.removeEventListener = function (name, listener) {
-    if (!this._listeners[name]) {
-      return;
-    }
-    var i = this._listeners[name].indexOf(listener);
-    if (i == -1) {
-      return;
-    }
-    this._listeners[name].splice(i, 1);
-    var boundListener = this._boundListeners[name].splice(i, 1)[0];
-    if (name != 'readystatechange') {
-      this._realxhr.removeEventListener(name, boundListener, false);
-    }
-  };
-  XHRProxy.prototype.open = function (method, url, async) {
-    // Work around MailTrack issue
-    if (!(this instanceof XHRProxy)) {
-      return XHR.prototype.open.apply(this, arguments);
-    }
-    var self = this;
-    this._connection = {
-      method: method,
-      url: url,
-      params: (0, _querystring.parse)(url.split('?')[1] || ''),
-      headers: {},
-      async: arguments.length < 3 || !!async
     };
-    this._clientStartedSend = false;
-    this._realStartedSend = false;
-    this._activeWrappers = findApplicableWrappers(this._wrappers, this._connection);
-    this._responseTextChangers = this._activeWrappers.map(function (wrapper) {
-      return wrapper.responseTextChanger && wrapper.responseTextChanger.bind(wrapper);
-    }).filter(Boolean);
-    this.responseText = '';
-    this._openState = true;
-    function finish(method, url) {
-      return self._realxhr.open(method, url, self._connection.async);
-    }
-    if (this._connection.async) {
-      this._requestChangers = this._activeWrappers.map(function (wrapper) {
-        return wrapper.requestChanger && wrapper.requestChanger.bind(wrapper);
-      }).filter(Boolean);
-      if (this._requestChangers.length) {
-        if (this.readyState != 1) {
-          this.readyState = 1;
-          this._fakeRscEvent();
-        }
-      } else {
-        finish(method, url);
-      }
-    } else {
-      finish(method, url);
-    }
-  };
-  XHRProxy.prototype.send = function (body) {
-    var self = this;
-    this._clientStartedSend = true;
-    this._openState = false;
-    Object.defineProperty(this._connection, 'originalSendBody', {
-      enumerable: true,
-      writable: false,
-      configurable: false,
-      value: body
-    });
-    this._connection.responseType = this._realxhr.responseType || 'text';
-    (0, _each.default)(self._activeWrappers, function (wrapper) {
-      if (wrapper.originalSendBodyLogger) {
-        try {
-          wrapper.originalSendBodyLogger(self._connection, body);
-        } catch (e) {
-          logError(e);
-        }
-      }
-    });
-    function finish(body) {
-      self._realStartedSend = true;
-      self._realxhr.send(body);
-    }
-    if (this._connection.async && this._requestChangers.length) {
-      // If the XHR object is re-used for another connection, then we need
-      // to make sure that our upcoming async calls here do nothing.
-      // Remember the current connection object, and do nothing in our async
-      // calls if it no longer matches. Also check for aborts.
-      const startConnection = this._connection;
-      const request = {
-        method: this._connection.method,
-        url: this._connection.url,
-        body: body
-      };
-      (async () => {
-        let modifiedRequest = request;
-        for (let requestChanger of this._requestChangers) {
-          const longRunWarningTimer = setTimeout(() => {
-            console.warn('requestChanger is taking too long', requestChanger, startConnection);
-          }, WARNING_TIMEOUT);
-          try {
-            modifiedRequest = await requestChanger(this._connection, Object.freeze(modifiedRequest));
-          } finally {
-            clearTimeout(longRunWarningTimer);
-          }
-          (0, _assert.default)((0, _has.default)(modifiedRequest, 'method'), 'modifiedRequest has method');
-          (0, _assert.default)((0, _has.default)(modifiedRequest, 'url'), 'modifiedRequest has url');
-          (0, _assert.default)((0, _has.default)(modifiedRequest, 'body'), 'modifiedRequest has body');
-          if (startConnection !== this._connection || this._realStartedSend) break;
-        }
-        return modifiedRequest;
-      })().catch(err => {
-        logError(err);
-        return request;
-      }).then(modifiedRequest => {
-        if (startConnection === this._connection && !this._realStartedSend) {
-          this._realxhr.open(modifiedRequest.method, modifiedRequest.url);
-          this._events.emit('realOpen');
-          finish(modifiedRequest.body);
-        }
-      });
-    } else {
-      finish(body);
-    }
-  };
-  [XHRProxy, XHRProxy.prototype].forEach(function (obj) {
-    Object.assign(obj, {
-      UNSENT: 0,
-      OPENED: 1,
-      HEADERS_RECEIVED: 2,
-      LOADING: 3,
-      DONE: 4
+    [XHRProxy, XHRProxy.prototype].forEach(function (obj) {
+        Object.assign(obj, {
+            UNSENT: 0,
+            OPENED: 1,
+            HEADERS_RECEIVED: 2,
+            LOADING: 3,
+            DONE: 4,
+        });
     });
-  });
-  return XHRProxy;
-}
+    return XHRProxy;
+}