@nativescript/canvas-polyfill 1.0.0-beta.1 → 1.0.0-beta.13

package/async/xhr/TNSXMLHttpRequest.js

@@ -1,35 +1,4 @@
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from) {
-    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
-        to[j] = from[i];
-    return to;
-};
-var _a, _b;
+var _a, _b, _c;
 import { Http } from '../http/http';
 import { HttpError, ProgressEvent } from '../http/http-request-common';
 import { FileManager } from '../file/file';
@@ -44,7 +13,7 @@ var XMLHttpRequestResponseType;
     XMLHttpRequestResponseType["arraybuffer"] = "arraybuffer";
     XMLHttpRequestResponseType["blob"] = "blob";
 })(XMLHttpRequestResponseType || (XMLHttpRequestResponseType = {}));
-var statuses = {
+const statuses = {
     100: 'Continue',
     101: 'Switching Protocols',
     200: 'OK',
@@ -93,37 +62,30 @@ var Status;
     Status[Status["LOADING"] = 200] = "LOADING";
     Status[Status["DONE"] = 200] = "DONE";
 })(Status || (Status = {}));
-var TNSXMLHttpRequestUpload = /** @class */ (function () {
-    function TNSXMLHttpRequestUpload(req) {
+export class TNSXMLHttpRequestUpload {
+    constructor(req) {
         this._listeners = new Map();
         this._request = req;
     }
-    TNSXMLHttpRequestUpload.prototype.addEventListener = function (eventName, handler) {
-        var handlers = this._listeners.get(eventName) || [];
+    addEventListener(eventName, handler) {
+        const handlers = this._listeners.get(eventName) || [];
         handlers.push(handler);
         this._listeners.set(eventName, handlers);
-    };
-    TNSXMLHttpRequestUpload.prototype.removeEventListener = function (eventName, toDetach) {
-        var handlers = this._listeners.get(eventName) || [];
-        handlers = handlers.filter(function (handler) { return handler !== toDetach; });
+    }
+    removeEventListener(eventName, toDetach) {
+        let handlers = this._listeners.get(eventName) || [];
+        handlers = handlers.filter(handler => handler !== toDetach);
         this._listeners.set(eventName, handlers);
-    };
-    TNSXMLHttpRequestUpload.prototype._emitEvent = function (eventName) {
-        var _this = this;
-        var args = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            args[_i - 1] = arguments[_i];
-        }
-        var handlers = this._listeners.get(eventName) || [];
-        handlers.forEach(function (handler) {
-            handler.apply.apply(handler, __spreadArray([_this], args));
+    }
+    _emitEvent(eventName, ...args) {
+        const handlers = this._listeners.get(eventName) || [];
+        handlers.forEach(handler => {
+            handler.apply(this, ...args);
         });
-    };
-    return TNSXMLHttpRequestUpload;
-}());
-export { TNSXMLHttpRequestUpload };
-var TNSXMLHttpRequest = /** @class */ (function () {
-    function TNSXMLHttpRequest() {
+    }
+}
+export class TNSXMLHttpRequest {
+    constructor() {
         this.UNSENT = 0;
         this.OPENED = 1;
         this.HEADERS_RECEIVED = 2;
@@ -150,109 +112,63 @@ var TNSXMLHttpRequest = /** @class */ (function () {
         this._http = new Http();
         this._upload = new TNSXMLHttpRequestUpload(this);
     }
-    Object.defineProperty(TNSXMLHttpRequest.prototype, "readyState", {
-        get: function () {
-            return this._readyState;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(TNSXMLHttpRequest.prototype, "response", {
-        get: function () {
-            return this._response;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(TNSXMLHttpRequest.prototype, "responseType", {
-        get: function () {
-            return this._responseType;
-        },
-        set: function (value) {
-            this._didUserSetResponseType = true;
-            if (value === XMLHttpRequestResponseType.empty ||
-                value in XMLHttpRequestResponseType) {
-                this._responseType = value;
-            }
-            else {
-                throw new Error("Response type of '" + value + "' not supported.");
-            }
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(TNSXMLHttpRequest.prototype, "responseText", {
-        get: function () {
-            if (this._responseType === XMLHttpRequestResponseType.text ||
-                this._responseType === XMLHttpRequestResponseType.json) {
-                return this._responseText;
-            }
-            return null;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(TNSXMLHttpRequest.prototype, "responseURL", {
-        get: function () {
-            return this._responseURL;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(TNSXMLHttpRequest.prototype, "status", {
-        get: function () {
-            return this._status;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(TNSXMLHttpRequest.prototype, "statusText", {
-        get: function () {
-            if (this._readyState === this.UNSENT ||
-                this._readyState === this.OPENED) {
-                return '';
-            }
-            return statuses[this.status];
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(TNSXMLHttpRequest.prototype, "upload", {
-        get: function () {
-            return this._upload;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(TNSXMLHttpRequest.prototype, "responseXML", {
-        get: function () {
-            var header = this.getResponseHeader('Content-Type') ||
-                this.getResponseHeader('content-type');
-            var contentType = header && header.toLowerCase();
-            if (this.isTextContentType(contentType)) {
-                if (this._responseType === XMLHttpRequestResponseType.document) {
-                    return this.responseText;
-                }
-            }
+    get readyState() {
+        return this._readyState;
+    }
+    get response() {
+        return this._response;
+    }
+    get responseType() {
+        return this._responseType;
+    }
+    get responseText() {
+        if (this._responseType === XMLHttpRequestResponseType.text ||
+            this._responseType === XMLHttpRequestResponseType.json) {
+            return this._responseText;
+        }
+        return null;
+    }
+    get responseURL() {
+        return this._responseURL;
+    }
+    get status() {
+        return this._status;
+    }
+    get statusText() {
+        if (this._readyState === this.UNSENT ||
+            this._readyState === this.OPENED) {
             return '';
-        },
-        enumerable: false,
-        configurable: true
-    });
-    TNSXMLHttpRequest.prototype.isTextContentType = function (contentType) {
-        var result = false;
-        for (var i = 0; i < this.textTypes.length; i++) {
+        }
+        return statuses[this.status];
+    }
+    get upload() {
+        return this._upload;
+    }
+    get responseXML() {
+        const header = this.getResponseHeader('Content-Type') ||
+            this.getResponseHeader('content-type');
+        const contentType = header && header.toLowerCase();
+        if (this.isTextContentType(contentType)) {
+            if (this._responseType === XMLHttpRequestResponseType.document) {
+                return this.responseText;
+            }
+        }
+        return '';
+    }
+    isTextContentType(contentType) {
+        let result = false;
+        for (let i = 0; i < this.textTypes.length; i++) {
             if (contentType.toLowerCase().indexOf(this.textTypes[i]) >= 0) {
                 result = true;
                 break;
             }
         }
         return result;
-    };
-    TNSXMLHttpRequest.prototype._setResponseType = function () {
-        var header = this.getResponseHeader('Content-Type') ||
+    }
+    _setResponseType() {
+        const header = this.getResponseHeader('Content-Type') ||
             this.getResponseHeader('content-type');
-        var contentType = header && header.toLowerCase();
+        const contentType = header && header.toLowerCase();
         if (contentType) {
             if (contentType.indexOf('application/json') >= 0 ||
                 contentType.indexOf('+json') >= 0) {
@@ -269,31 +185,29 @@ var TNSXMLHttpRequest = /** @class */ (function () {
         else {
             this._responseType = XMLHttpRequestResponseType.text;
         }
-    };
-    TNSXMLHttpRequest.prototype.getAllResponseHeaders = function () {
+    }
+    getAllResponseHeaders() {
         if (this._readyState < 2) {
             return '';
         }
-        var result = '';
+        let result = '';
         if (typeof this._headers === 'object') {
-            var keys = Object.keys(this._headers);
-            for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
-                var key = keys_1[_i];
+            const keys = Object.keys(this._headers);
+            for (let key of keys) {
                 result += key + ': ' + this._headers[key] + '\r\n';
             }
         }
         return result.substr(0, result.length - 2);
-    };
-    TNSXMLHttpRequest.prototype.getResponseHeader = function (header) {
+    }
+    getResponseHeader(header) {
         if (typeof header === 'string' &&
             this._readyState > 1 &&
             this._headers) {
             header = header.toLowerCase();
             if (typeof this._headers === 'object') {
-                var keys = Object.keys(this._headers);
-                for (var _i = 0, keys_2 = keys; _i < keys_2.length; _i++) {
-                    var key = keys_2[_i];
-                    var item = key.toLowerCase();
+                const keys = Object.keys(this._headers);
+                for (let key of keys) {
+                    const item = key.toLowerCase();
                     if (item === header) {
                         return this._headers[key];
                     }
@@ -302,11 +216,20 @@ var TNSXMLHttpRequest = /** @class */ (function () {
             return null;
         }
         return null;
-    };
-    TNSXMLHttpRequest.prototype.overrideMimeType = function (mime) {
-    };
-    TNSXMLHttpRequest.prototype._addToStringOnResponse = function () {
-        var _this = this;
+    }
+    overrideMimeType(mime) {
+    }
+    set responseType(value) {
+        this._didUserSetResponseType = true;
+        if (value === XMLHttpRequestResponseType.empty ||
+            value in XMLHttpRequestResponseType) {
+            this._responseType = value;
+        }
+        else {
+            throw new Error(`Response type of '${value}' not supported.`);
+        }
+    }
+    _addToStringOnResponse() {
         // Add toString() method to ease debugging and
         // make Angular2 response.text() method work properly.
         if (isNullOrUndefined(this.response)) {
@@ -320,23 +243,23 @@ var TNSXMLHttpRequest = /** @class */ (function () {
                 configurable: true,
                 enumerable: false,
                 writable: true,
-                value: function () { return _this.responseText; },
+                value: () => this.responseText,
             });
         }
-    };
-    TNSXMLHttpRequest.prototype._toJSString = function (data) {
-        var encodings = ['UTF-8', 'US-ASCII', 'ISO-8859-1', null];
-        var value;
-        var count = encodings.length;
-        for (var i = 0; i < count; i++) {
-            var encodingType = encodings[i];
+    }
+    _toJSString(data) {
+        const encodings = ['UTF-8', 'US-ASCII', 'ISO-8859-1', null];
+        let value;
+        const count = encodings.length;
+        for (let i = 0; i < count; i++) {
+            let encodingType = encodings[i];
             // let java decide :D
             if (encodingType === null) {
                 value = (new java.lang.String(data)).toString();
                 break;
             }
             try {
-                var encoding = java.nio.charset.Charset.forName(encodingType);
+                let encoding = java.nio.charset.Charset.forName(encodingType);
                 value = (new java.lang.String(data, encoding)).toString();
                 break;
             }
@@ -344,34 +267,30 @@ var TNSXMLHttpRequest = /** @class */ (function () {
             }
         }
         return value;
-    };
-    TNSXMLHttpRequest.prototype.open = function (method, url, async, username, password) {
-        if (async === void 0) { async = true; }
-        if (username === void 0) { username = null; }
-        if (password === void 0) { password = null; }
+    }
+    open(method, url, async = true, username = null, password = null) {
         this._headers = {};
         this._responseURL = '';
         this._httpContent = null;
         this._request = {
-            method: method,
-            url: url,
-            async: async,
-            username: username,
-            password: password,
+            method,
+            url,
+            async,
+            username,
+            password,
         };
         this._updateReadyStateChange(this.OPENED);
-    };
-    TNSXMLHttpRequest.prototype.setRequestHeader = function (header, value) {
+    }
+    setRequestHeader(header, value) {
         if (this._readyState !== this.OPENED) {
             throw new Error("Failed to execute 'setRequestHeader' on 'XMLHttpRequest': The object's state must be OPENED.");
         }
         if (typeof this._headers === 'object') {
             this._headers[header] = value;
         }
-    };
-    TNSXMLHttpRequest.prototype.send = function (body) {
-        var _this = this;
-        if (body === void 0) { body = null; }
+    }
+    send(body = null) {
+        var _d, _e, _f;
         if (this._readyState !== this.OPENED) {
             throw new Error("Failed to execute 'send' on 'XMLHttpRequest': The object's state must be OPENED");
         }
@@ -381,7 +300,7 @@ var TNSXMLHttpRequest = /** @class */ (function () {
         if (typeof this._request.method === 'string' &&
             this._request.method.toLowerCase() === 'get' &&
             typeof this._request.url === 'string' && !this._request.url.startsWith('http')) {
-            var path = void 0;
+            let path;
             if (this._request.url.startsWith('file://')) {
                 path = this._request.url.replace('file://', '');
             }
@@ -391,58 +310,61 @@ var TNSXMLHttpRequest = /** @class */ (function () {
             else if (this._request.url.startsWith('/')) {
                 path = this._request.url;
             }
-            var responseURL_1 = "file://" + path;
-            var contentLength_1 = -1;
-            var file = fsFile.fromPath(path);
+            else if (this._request.url.startsWith('blob:nativescript')) {
+                path = (_f = (_e = (_d = URL) === null || _d === void 0 ? void 0 : _d.InternalAccessor) === null || _e === void 0 ? void 0 : _e.getPath) === null || _f === void 0 ? void 0 : _f.call(_e, this._request.url);
+            }
+            const responseURL = `file://${path}`;
+            let contentLength = -1;
+            const file = fsFile.fromPath(path);
             if (fsFile.exists(path)) {
-                contentLength_1 = file.size;
+                contentLength = file.size;
             }
             this._lastProgress = {
-                lengthComputable: contentLength_1 > -1,
+                lengthComputable: contentLength > -1,
                 loaded: 0,
-                total: contentLength_1,
+                total: contentLength,
                 target: this,
             };
-            var startEvent = new ProgressEvent('loadstart', this._lastProgress);
+            const startEvent = new ProgressEvent('loadstart', this._lastProgress);
             if (this.onloadstart) {
                 this.onloadstart(startEvent);
             }
             this.emitEvent('loadstart', startEvent);
             this._updateReadyStateChange(this.LOADING);
-            FileManager.readFile(path, {}, function (error, data) {
+            FileManager.readFile(path, {}, (error, data) => {
                 if (error) {
-                    var errorEvent = new ProgressEvent('error', _this._lastProgress);
-                    _this._responseText = error.message;
-                    if (_this.onerror) {
-                        _this.onerror(errorEvent);
-                    }
-                    _this.emitEvent('error', errorEvent);
-                    var loadendEvent = new ProgressEvent('loadend', _this._lastProgress);
-                    if (_this.onloadend) {
-                        _this.onloadend(loadendEvent);
-                    }
-                    _this.emitEvent('loadend', loadendEvent);
-                    _this._updateReadyStateChange(_this.DONE);
+                    const errorEvent = new ProgressEvent('error', this._lastProgress);
+                    this._responseText = error.message;
+                    if (this.onerror) {
+                        this.onerror(errorEvent);
+                    }
+                    this.emitEvent('error', errorEvent);
+                    const loadendEvent = new ProgressEvent('loadend', this._lastProgress);
+                    if (this.onloadend) {
+                        this.onloadend(loadendEvent);
+                    }
+                    this.emitEvent('loadend', loadendEvent);
+                    this._updateReadyStateChange(this.DONE);
                 }
                 else {
-                    if (!_this._didUserSetResponseType) {
-                        _this._setResponseType();
+                    if (!this._didUserSetResponseType) {
+                        this._setResponseType();
                     }
-                    _this._status = 200;
-                    _this._httpContent = data;
-                    _this._responseURL = responseURL_1;
-                    if (_this.responseType === XMLHttpRequestResponseType.json) {
+                    this._status = 200;
+                    this._httpContent = data;
+                    this._responseURL = responseURL;
+                    if (this.responseType === XMLHttpRequestResponseType.json) {
                         try {
                             if (global.isAndroid) {
-                                _this._responseText = _this._toJSString(data);
-                                _this._response = JSON.parse(_this._responseText);
+                                this._responseText = this._toJSString(data);
+                                this._response = JSON.parse(this._responseText);
                             }
                             else {
-                                _this._responseText = NSString.alloc().initWithDataEncoding(data, NSUTF8StringEncoding);
-                                if (!_this._responseText) {
-                                    _this._responseText = NSString.alloc().initWithDataEncoding(data, NSISOLatin1StringEncoding);
+                                this._responseText = NSString.alloc().initWithDataEncoding(data, NSUTF8StringEncoding);
+                                if (!this._responseText) {
+                                    this._responseText = NSString.alloc().initWithDataEncoding(data, NSISOLatin1StringEncoding);
                                 }
-                                _this._response = JSON.parse(_this._responseText);
+                                this._response = JSON.parse(this._responseText);
                             }
                         }
                         catch (e) {
@@ -450,62 +372,62 @@ var TNSXMLHttpRequest = /** @class */ (function () {
                             // this should probably be caught before the promise resolves
                         }
                     }
-                    else if (_this.responseType === XMLHttpRequestResponseType.text) {
+                    else if (this.responseType === XMLHttpRequestResponseType.text) {
                         if (global.isIOS) {
-                            var code = NSUTF8StringEncoding; // long:4
-                            var encodedString = NSString.alloc().initWithDataEncoding(data, code);
+                            let code = NSUTF8StringEncoding; // long:4
+                            let encodedString = NSString.alloc().initWithDataEncoding(data, code);
                             // If UTF8 string encoding fails try with ISO-8859-1
                             if (!encodedString) {
                                 code = NSISOLatin1StringEncoding; // long:5
                                 encodedString = NSString.alloc().initWithDataEncoding(data, code);
                             }
-                            _this._responseText = _this._response = encodedString.toString();
+                            this._responseText = this._response = encodedString.toString();
                         }
                         else {
-                            var response = _this._toJSString(data);
-                            _this._responseText = _this._response = response
+                            const response = this._toJSString(data);
+                            this._responseText = this._response = response
                                 ? response.toString()
                                 : '';
                         }
                     }
-                    else if (_this.responseType === XMLHttpRequestResponseType.document) {
+                    else if (this.responseType === XMLHttpRequestResponseType.document) {
                         if (global.isIOS) {
-                            var code = NSUTF8StringEncoding; // long:4
-                            var encodedString = NSString.alloc().initWithDataEncoding(data, code);
+                            let code = NSUTF8StringEncoding; // long:4
+                            let encodedString = NSString.alloc().initWithDataEncoding(data, code);
                             // If UTF8 string encoding fails try with ISO-8859-1
                             if (!encodedString) {
                                 code = NSISOLatin1StringEncoding; // long:5
                                 encodedString = NSString.alloc().initWithDataEncoding(data, code);
                             }
-                            _this._responseText = _this._response = encodedString.toString();
+                            this._responseText = this._response = encodedString.toString();
                         }
                         else {
-                            var response = _this._toJSString(data);
-                            _this._responseText = _this._response = response
+                            let response = this._toJSString(data);
+                            this._responseText = this._response = response
                                 ? response
                                 : '';
                         }
                     }
-                    else if (_this.responseType === XMLHttpRequestResponseType.arraybuffer) {
+                    else if (this.responseType === XMLHttpRequestResponseType.arraybuffer) {
                         if (global.isIOS) {
-                            _this._response = interop.bufferFromData(data);
+                            this._response = interop.bufferFromData(data);
                         }
                         else {
-                            _this._response = ArrayBuffer.from(java.nio.ByteBuffer.wrap(data));
+                            this._response = ArrayBuffer.from(java.nio.ByteBuffer.wrap(data));
                         }
                     }
-                    else if (_this.responseType === XMLHttpRequestResponseType.blob) {
-                        var buffer = void 0;
+                    else if (this.responseType === XMLHttpRequestResponseType.blob) {
+                        let buffer;
                         if (global.isIOS) {
                             buffer = interop.bufferFromData(data);
                         }
                         else {
-                            var buf = java.nio.ByteBuffer.wrap(data);
+                            const buf = java.nio.ByteBuffer.wrap(data);
                             buffer = ArrayBuffer.from(buf);
                         }
-                        _this._response = new Blob([buffer]);
+                        this._response = new Blob([buffer]);
                     }
-                    var size = 0;
+                    let size = 0;
                     if (global.isIOS) {
                         if (data instanceof NSData) {
                             size = data.length;
@@ -514,75 +436,75 @@ var TNSXMLHttpRequest = /** @class */ (function () {
                     else {
                         size = data ? data.length : 0;
                     }
-                    _this._lastProgress = {
-                        lengthComputable: contentLength_1 > -1,
+                    this._lastProgress = {
+                        lengthComputable: contentLength > -1,
                         loaded: size,
-                        total: contentLength_1,
-                        target: _this,
+                        total: contentLength,
+                        target: this,
                     };
-                    var progressEvent = new ProgressEvent('progress', _this._lastProgress);
-                    if (_this.onprogress) {
-                        _this.onprogress(progressEvent);
-                    }
-                    _this.emitEvent('progress', progressEvent);
-                    _this._addToStringOnResponse();
-                    var loadEvent = new ProgressEvent('load', _this._lastProgress);
-                    if (_this.onload) {
-                        _this.onload(loadEvent);
-                    }
-                    _this.emitEvent('load', loadEvent);
-                    var loadendEvent = new ProgressEvent('loadend', _this._lastProgress);
-                    if (_this.onloadend) {
-                        _this.onloadend(loadendEvent);
-                    }
-                    _this.emitEvent('loadend', loadendEvent);
-                    _this._updateReadyStateChange(_this.DONE);
+                    const progressEvent = new ProgressEvent('progress', this._lastProgress);
+                    if (this.onprogress) {
+                        this.onprogress(progressEvent);
+                    }
+                    this.emitEvent('progress', progressEvent);
+                    this._addToStringOnResponse();
+                    const loadEvent = new ProgressEvent('load', this._lastProgress);
+                    if (this.onload) {
+                        this.onload(loadEvent);
+                    }
+                    this.emitEvent('load', loadEvent);
+                    const loadendEvent = new ProgressEvent('loadend', this._lastProgress);
+                    if (this.onloadend) {
+                        this.onloadend(loadendEvent);
+                    }
+                    this.emitEvent('loadend', loadendEvent);
+                    this._updateReadyStateChange(this.DONE);
                 }
             });
             return;
         }
-        var method = this._request.method.toLowerCase();
-        var request = {
+        const method = this._request.method.toLowerCase();
+        const request = {
             content: body,
             method: this._request.method,
             url: this._request.url,
             headers: this._headers,
-            onLoading: function () {
-                if (_this.onloadstart) {
-                    _this.onloadstart();
+            onLoading: () => {
+                if (this.onloadstart) {
+                    this.onloadstart();
                 }
-                var contentLength = -1;
-                if (typeof _this._headers === 'object') {
-                    if (_this._headers['Content-Length']) {
+                let contentLength = -1;
+                if (typeof this._headers === 'object') {
+                    if (this._headers['Content-Length']) {
                         contentLength =
-                            parseInt(_this._headers['Content-Length'], 10) || -1;
+                            parseInt(this._headers['Content-Length'], 10) || -1;
                     }
-                    if (_this._headers['content-length']) {
+                    if (this._headers['content-length']) {
                         contentLength =
-                            parseInt(_this._headers['content-length'], 10) || -1;
+                            parseInt(this._headers['content-length'], 10) || -1;
                     }
                 }
-                _this._lastProgress = {
+                this._lastProgress = {
                     lengthComputable: contentLength > -1,
                     loaded: 0,
                     total: contentLength,
-                    target: _this,
+                    target: this,
                 };
-                var loadStartEvent = new ProgressEvent('loadstart', _this._lastProgress);
-                if (_this._upload && (method === 'post' || method === 'put')) {
-                    _this._upload._emitEvent('loadstart', loadStartEvent);
+                const loadStartEvent = new ProgressEvent('loadstart', this._lastProgress);
+                if (this._upload && (method === 'post' || method === 'put')) {
+                    this._upload._emitEvent('loadstart', loadStartEvent);
                 }
-                _this.emitEvent('loadstart', loadStartEvent);
-                _this._updateReadyStateChange(_this.LOADING);
+                this.emitEvent('loadstart', loadStartEvent);
+                this._updateReadyStateChange(this.LOADING);
             },
-            onHeaders: function (event) {
+            onHeaders: (event) => {
                 if (!isNaN(event.status)) {
-                    _this._status = event.status;
+                    this._status = event.status;
                 }
                 if (event.headers) {
-                    _this._headers = event.headers;
+                    this._headers = event.headers;
                 }
-                _this._updateReadyStateChange(_this.HEADERS_RECEIVED);
+                this._updateReadyStateChange(this.HEADERS_RECEIVED);
             },
         };
         // TODO: ideally we could avoid wiring up progress since it's chatty
@@ -590,14 +512,14 @@ var TNSXMLHttpRequest = /** @class */ (function () {
         // right now for brevity since GET requests are for more frequent than others,
         // just enabling for post and put temporarily
         if (method === 'post' || method === 'put') {
-            request.onProgress = function (event) {
-                _this._lastProgress = __assign(__assign({}, (_this._lastProgress || {})), event);
+            request.onProgress = (event) => {
+                this._lastProgress = Object.assign(Object.assign({}, (this._lastProgress || {})), event);
                 if (event.loaded > 0) {
-                    var progressEvent = new ProgressEvent('progress', _this._lastProgress);
-                    if (_this._upload && (method === 'post' || method === 'put')) {
-                        _this._upload._emitEvent('progress', progressEvent);
+                    const progressEvent = new ProgressEvent('progress', this._lastProgress);
+                    if (this._upload && (method === 'post' || method === 'put')) {
+                        this._upload._emitEvent('progress', progressEvent);
                     }
-                    _this.emitEvent('progress', progressEvent);
+                    this.emitEvent('progress', progressEvent);
                 }
             };
         }
@@ -606,268 +528,256 @@ var TNSXMLHttpRequest = /** @class */ (function () {
         }
         this._currentRequest = this._http.request(request);
         this._currentRequest
-            .then(function (res) {
-            if (!_this._didUserSetResponseType) {
-                _this._setResponseType();
-            }
-            _this._status = res.statusCode;
-            _this._httpContent = res.content;
-            _this._responseURL = res.url;
-            if (_this.responseType === XMLHttpRequestResponseType.json) {
+            .then((res) => {
+            if (!this._didUserSetResponseType) {
+                this._setResponseType();
+            }
+            this._status = res.statusCode;
+            this._httpContent = res.content;
+            this._responseURL = res.url;
+            if (this.responseType === XMLHttpRequestResponseType.json) {
                 if (typeof res.content === 'string') {
-                    _this._responseText = res.content;
+                    this._responseText = res.content;
                     try {
-                        _this._response = JSON.parse(_this.responseText);
+                        this._response = JSON.parse(this.responseText);
                     }
                     catch (err) {
                         // this should probably be caught before the promise resolves
                     }
                 }
                 else if (typeof res.content === 'object') {
-                    _this._response = res.content;
-                    _this._responseText = res.responseText;
+                    this._response = res.content;
+                    this._responseText = res.responseText;
                 }
                 else {
                     if (global.isIOS) {
                         if (res.content instanceof NSData) {
-                            var code = NSUTF8StringEncoding; // long:4
-                            var encodedString = NSString.alloc().initWithDataEncoding(res.content, code);
+                            let code = NSUTF8StringEncoding; // long:4
+                            let encodedString = NSString.alloc().initWithDataEncoding(res.content, code);
                             // If UTF8 string encoding fails try with ISO-8859-1
                             if (!encodedString) {
                                 code = NSISOLatin1StringEncoding; // long:5
                                 encodedString = NSString.alloc().initWithDataEncoding(res.content, code);
                             }
-                            _this._responseText = encodedString.toString();
-                            _this._response = JSON.parse(_this._responseText);
+                            this._responseText = encodedString.toString();
+                            this._response = JSON.parse(this._responseText);
                         }
                     }
                     else {
                         if (res.content instanceof java.nio.ByteBuffer) {
-                            _this._responseText = _this._toJSString(res.content.array());
-                            _this._response = JSON.parse(_this._responseText);
+                            this._responseText = this._toJSString(res.content.array());
+                            this._response = JSON.parse(this._responseText);
                         }
                     }
                 }
             }
-            else if (_this.responseType === XMLHttpRequestResponseType.text) {
+            else if (this.responseType === XMLHttpRequestResponseType.text) {
                 if (typeof res.content === 'string') {
-                    _this._responseText = res.content;
+                    this._responseText = res.content;
                 }
                 else if (typeof res.content === 'object') {
-                    _this._responseText = JSON.stringify(res.content); // Stringify or build manually 🧐
+                    this._responseText = JSON.stringify(res.content); // Stringify or build manually 🧐
                 }
                 else {
                     if (global.isIOS) {
                         if (res.content instanceof NSData) {
-                            var code = NSUTF8StringEncoding; // long:4
-                            var encodedString = NSString.alloc().initWithDataEncoding(res.content, code);
+                            let code = NSUTF8StringEncoding; // long:4
+                            let encodedString = NSString.alloc().initWithDataEncoding(res.content, code);
                             // If UTF8 string encoding fails try with ISO-8859-1
                             if (!encodedString) {
                                 code = NSISOLatin1StringEncoding; // long:5
                                 encodedString = NSString.alloc().initWithDataEncoding(res.content, code);
                             }
-                            _this._responseText = _this._response = encodedString.toString();
+                            this._responseText = this._response = encodedString.toString();
                         }
                     }
                     else {
                         if (res.content instanceof java.nio.ByteBuffer) {
-                            _this._responseText = _this._response = _this._toJSString(res.content.array());
+                            this._responseText = this._response = this._toJSString(res.content.array());
                         }
                     }
                 }
-                _this._response = _this._responseText;
+                this._response = this._responseText;
             }
-            else if (_this.responseType === XMLHttpRequestResponseType.document) {
+            else if (this.responseType === XMLHttpRequestResponseType.document) {
                 if (typeof res.content === 'string') {
-                    _this._responseText = res.content;
+                    this._responseText = res.content;
                 }
                 else {
                     if (global.isIOS) {
                         if (res.content instanceof NSData) {
-                            var code = NSUTF8StringEncoding; // long:4
-                            var encodedString = NSString.alloc().initWithDataEncoding(res.content, code);
+                            let code = NSUTF8StringEncoding; // long:4
+                            let encodedString = NSString.alloc().initWithDataEncoding(res.content, code);
                             // If UTF8 string encoding fails try with ISO-8859-1
                             if (!encodedString) {
                                 code = NSISOLatin1StringEncoding; // long:5
                                 encodedString = NSString.alloc().initWithDataEncoding(res.content, code);
                             }
-                            _this._responseText = _this._response = encodedString.toString();
+                            this._responseText = this._response = encodedString.toString();
                         }
                     }
                     else {
                         if (res.content instanceof java.nio.ByteBuffer) {
-                            _this._responseText = _this._response = _this._toJSString(res.content.array());
+                            this._responseText = this._response = this._toJSString(res.content.array());
                         }
                     }
                 }
             }
-            else if (_this.responseType === XMLHttpRequestResponseType.arraybuffer) {
+            else if (this.responseType === XMLHttpRequestResponseType.arraybuffer) {
                 if (global.isIOS) {
-                    _this._response = interop.bufferFromData(res.content);
+                    this._response = interop.bufferFromData(res.content);
                 }
                 else {
-                    _this._response = ArrayBuffer.from(res.content);
+                    this._response = ArrayBuffer.from(res.content);
                 }
             }
-            else if (_this.responseType === XMLHttpRequestResponseType.blob) {
-                var buffer = ArrayBuffer.from(res.content);
-                _this._response = new Blob([buffer]);
+            else if (this.responseType === XMLHttpRequestResponseType.blob) {
+                const buffer = ArrayBuffer.from(res.content);
+                this._response = new Blob([buffer]);
             }
-            _this._addToStringOnResponse();
-            if (_this.onload) {
-                _this.onload();
+            this._addToStringOnResponse();
+            if (this.onload) {
+                this.onload();
             }
-            var loadEvent = new ProgressEvent('load', _this._lastProgress);
-            if (_this._upload && (method === 'post' || method === 'put')) {
-                _this._upload._emitEvent('load', loadEvent);
+            const loadEvent = new ProgressEvent('load', this._lastProgress);
+            if (this._upload && (method === 'post' || method === 'put')) {
+                this._upload._emitEvent('load', loadEvent);
             }
-            _this.emitEvent('load', loadEvent);
-            if (_this.onloadend) {
-                _this.onloadend();
+            this.emitEvent('load', loadEvent);
+            if (this.onloadend) {
+                this.onloadend();
             }
-            var loadendEvent = new ProgressEvent('loadend', _this._lastProgress);
-            if (_this._upload && (method === 'post' || method === 'put')) {
-                _this._upload._emitEvent('loadend', loadendEvent);
+            const loadendEvent = new ProgressEvent('loadend', this._lastProgress);
+            if (this._upload && (method === 'post' || method === 'put')) {
+                this._upload._emitEvent('loadend', loadendEvent);
             }
-            _this.emitEvent('loadend', loadendEvent);
-            _this._updateReadyStateChange(_this.DONE);
+            this.emitEvent('loadend', loadendEvent);
+            this._updateReadyStateChange(this.DONE);
         })
-            .catch(function (error) {
-            var type = error.type;
-            var method = _this._request.method.toLowerCase();
+            .catch((error) => {
+            const type = error.type;
+            const method = this._request.method.toLowerCase();
             switch (type) {
                 case HttpError.Cancelled:
-                    if (_this.onabort) {
-                        _this.onabort();
+                    if (this.onabort) {
+                        this.onabort();
                     }
-                    var abortEvent = new ProgressEvent('abort', _this._lastProgress);
-                    if (_this._upload &&
+                    const abortEvent = new ProgressEvent('abort', this._lastProgress);
+                    if (this._upload &&
                         (method === 'post' || method === 'put')) {
-                        _this._upload._emitEvent('abort', abortEvent);
+                        this._upload._emitEvent('abort', abortEvent);
                     }
-                    _this.emitEvent('abort', abortEvent);
-                    if (_this.onloadend) {
-                        _this.onloadend();
+                    this.emitEvent('abort', abortEvent);
+                    if (this.onloadend) {
+                        this.onloadend();
                     }
-                    var _loadendEvent = new ProgressEvent('loadend', _this._lastProgress);
-                    if (_this._upload &&
+                    const _loadendEvent = new ProgressEvent('loadend', this._lastProgress);
+                    if (this._upload &&
                         (method === 'post' || method === 'put')) {
-                        _this._upload._emitEvent('loadend', _loadendEvent);
+                        this._upload._emitEvent('loadend', _loadendEvent);
                     }
-                    _this.emitEvent('loadend', _loadendEvent);
-                    if (_this._readyState === _this.UNSENT ||
-                        _this._readyState === _this.OPENED ||
-                        _this._readyState === _this.DONE) {
-                        _this._updateReadyStateChange(_this.UNSENT);
+                    this.emitEvent('loadend', _loadendEvent);
+                    if (this._readyState === this.UNSENT ||
+                        this._readyState === this.OPENED ||
+                        this._readyState === this.DONE) {
+                        this._updateReadyStateChange(this.UNSENT);
                     }
                     else {
-                        _this._updateReadyStateChange(_this.DONE);
+                        this._updateReadyStateChange(this.DONE);
                     }
-                    _this._currentRequest = null;
+                    this._currentRequest = null;
                     break;
                 case HttpError.Timeout:
-                    if (_this.ontimeout) {
-                        _this.ontimeout();
+                    if (this.ontimeout) {
+                        this.ontimeout();
                     }
-                    var timeoutEvent = new ProgressEvent('timeout', _this._lastProgress);
-                    if (_this._upload &&
+                    const timeoutEvent = new ProgressEvent('timeout', this._lastProgress);
+                    if (this._upload &&
                         (method === 'post' || method === 'put')) {
-                        _this._upload._emitEvent('timeout', timeoutEvent);
+                        this._upload._emitEvent('timeout', timeoutEvent);
                     }
-                    _this.emitEvent('timeout', timeoutEvent);
+                    this.emitEvent('timeout', timeoutEvent);
                     break;
                 case HttpError.Error:
-                    if (_this.onerror) {
-                        _this.onerror(error.message);
+                    if (this.onerror) {
+                        this.onerror(error.message);
                     }
-                    var errorEvent = new ProgressEvent('error', _this._lastProgress);
-                    if (_this._upload &&
+                    const errorEvent = new ProgressEvent('error', this._lastProgress);
+                    if (this._upload &&
                         (method === 'post' || method === 'put')) {
-                        _this._upload._emitEvent('error', errorEvent);
+                        this._upload._emitEvent('error', errorEvent);
                     }
-                    _this.emitEvent('error', errorEvent);
-                    if (_this.onloadend) {
-                        _this.onloadend();
+                    this.emitEvent('error', errorEvent);
+                    if (this.onloadend) {
+                        this.onloadend();
                     }
-                    var loadendEvent = new ProgressEvent('loadend', _this._lastProgress);
-                    if (_this._upload &&
+                    const loadendEvent = new ProgressEvent('loadend', this._lastProgress);
+                    if (this._upload &&
                         (method === 'post' || method === 'put')) {
-                        _this._upload._emitEvent('loadend', loadendEvent);
+                        this._upload._emitEvent('loadend', loadendEvent);
                     }
-                    _this.emitEvent('loadend', loadendEvent);
+                    this.emitEvent('loadend', loadendEvent);
                     break;
             }
-            _this._updateReadyStateChange(_this.DONE);
+            this._updateReadyStateChange(this.DONE);
         });
-    };
-    TNSXMLHttpRequest.prototype.abort = function () {
+    }
+    abort() {
         if (this._currentRequest) {
             this._currentRequest.cancel();
         }
-    };
-    TNSXMLHttpRequest.prototype.addEventListener = function (eventName, handler) {
-        var handlers = this._listeners.get(eventName) || [];
+    }
+    addEventListener(eventName, handler) {
+        const handlers = this._listeners.get(eventName) || [];
         handlers.push(handler);
         this._listeners.set(eventName, handlers);
-    };
-    TNSXMLHttpRequest.prototype.removeEventListener = function (eventName, toDetach) {
-        var handlers = this._listeners.get(eventName) || [];
-        handlers = handlers.filter(function (handler) { return handler !== toDetach; });
+    }
+    removeEventListener(eventName, toDetach) {
+        let handlers = this._listeners.get(eventName) || [];
+        handlers = handlers.filter((handler) => handler !== toDetach);
         this._listeners.set(eventName, handlers);
-    };
-    TNSXMLHttpRequest.prototype.emitEvent = function (eventName) {
-        var _this = this;
-        var args = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            args[_i - 1] = arguments[_i];
-        }
-        var handlers = this._listeners.get(eventName) || [];
-        handlers.forEach(function (handler) {
-            handler.apply.apply(handler, __spreadArray([_this], args));
+    }
+    emitEvent(eventName, ...args) {
+        const handlers = this._listeners.get(eventName) || [];
+        handlers.forEach((handler) => {
+            handler.apply(this, ...args);
         });
-    };
-    TNSXMLHttpRequest.prototype.dispatchEvent = function (event) {
+    }
+    dispatchEvent(event) {
         return false;
-    };
-    TNSXMLHttpRequest.prototype._updateReadyStateChange = function (state) {
+    }
+    _updateReadyStateChange(state) {
         this._readyState = state;
         if (this.onreadystatechange) {
             this.onreadystatechange();
         }
-    };
-    return TNSXMLHttpRequest;
-}());
-export { TNSXMLHttpRequest };
-var FormData = /** @class */ (function () {
-    function FormData() {
+    }
+}
+export class FormData {
+    constructor() {
         this._data = new Map();
     }
-    FormData.prototype.append = function (name, value) {
+    append(name, value) {
         this._data.set(name, value);
-    };
-    FormData.prototype.toString = function () {
-        var arr = new Array();
+    }
+    toString() {
+        let arr = new Array();
         this._data.forEach(function (value, name, map) {
-            arr.push(encodeURIComponent(name) + "=" + encodeURIComponent(value));
+            arr.push(`${encodeURIComponent(name)}=${encodeURIComponent(value)}`);
         });
         return arr.join("&");
-    };
-    return FormData;
-}());
-export { FormData };
-var Blob = /** @class */ (function () {
-    function Blob(chunks, opts) {
-        if (chunks === void 0) { chunks = []; }
-        if (opts === void 0) { opts = {}; }
-        this[_c] = "Blob";
-        var dataChunks = [];
-        for (var _i = 0, chunks_1 = chunks; _i < chunks_1.length; _i++) {
-            var chunk = chunks_1[_i];
+    }
+}
+export class Blob {
+    constructor(chunks = [], opts = {}) {
+        this[_a] = "Blob";
+        const dataChunks = [];
+        for (const chunk of chunks) {
             if (chunk instanceof Blob) {
                 dataChunks.push(chunk._buffer);
             }
             else if (typeof chunk === "string") {
-                var textEncoder = new TextEncoder();
+                const textEncoder = new TextEncoder();
                 dataChunks.push(textEncoder.encode(chunk));
             }
             else if (chunk instanceof DataView) {
@@ -879,15 +789,15 @@ var Blob = /** @class */ (function () {
                     : chunk.slice(0)));
             }
             else {
-                var textEncoder = new TextEncoder();
+                const textEncoder = new TextEncoder();
                 dataChunks.push(textEncoder.encode(String(chunk)));
             }
         }
-        var size = dataChunks.reduce(function (size, chunk) { return size + chunk.byteLength; }, 0);
-        var buffer = new Uint8Array(size);
-        var offset = 0;
-        for (var i = 0; i < dataChunks.length; i++) {
-            var chunk = dataChunks[i];
+        const size = dataChunks.reduce((size, chunk) => size + chunk.byteLength, 0);
+        const buffer = new Uint8Array(size);
+        let offset = 0;
+        for (let i = 0; i < dataChunks.length; i++) {
+            const chunk = dataChunks[i];
             buffer.set(chunk, offset);
             offset += chunk.byteLength;
         }
@@ -901,109 +811,74 @@ var Blob = /** @class */ (function () {
             this._type = this._type.toLowerCase();
         }
     }
-    Object.defineProperty(Blob.prototype, "size", {
-        get: function () {
-            return this._size;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Blob.prototype, "type", {
-        get: function () {
-            return this._type;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Blob.prototype.arrayBuffer = function () {
+    get size() {
+        return this._size;
+    }
+    get type() {
+        return this._type;
+    }
+    arrayBuffer() {
         return Promise.resolve(this._buffer);
-    };
-    Blob.prototype.text = function () {
-        var textDecoder = new TextDecoder();
+    }
+    text() {
+        const textDecoder = new TextDecoder();
         return Promise.resolve(textDecoder.decode(this._buffer));
-    };
-    Blob.prototype.slice = function (start, end, type) {
-        var slice = this._buffer.slice(start || 0, end || this._buffer.length);
+    }
+    slice(start, end, type) {
+        const slice = this._buffer.slice(start || 0, end || this._buffer.length);
         return new Blob([slice], { type: type });
-    };
-    Blob.prototype.stream = function () {
+    }
+    stream() {
         throw new Error("stream is currently not supported");
-    };
-    Blob.prototype.toString = function () {
+    }
+    toString() {
         return "[object Blob]";
-    };
-    var _c;
-    _c = Symbol.toStringTag;
-    // Note: only for use by XHR
-    Blob.InternalAccessor = /** @class */ (function () {
-        function class_1() {
-        }
-        class_1.getBuffer = function (blob) {
-            return blob._buffer;
-        };
-        return class_1;
-    }());
-    return Blob;
-}());
-export { Blob };
-var File = /** @class */ (function (_super) {
-    __extends(File, _super);
-    function File(chunks, name, opts) {
-        if (opts === void 0) { opts = {}; }
-        var _this = _super.call(this, chunks, opts) || this;
-        _this[_a] = "File";
-        _this._name = name.replace(/\//g, ":");
-        _this._lastModified =
+    }
+}
+_a = Symbol.toStringTag;
+// Note: only for use by XHR
+Blob.InternalAccessor = class {
+    static getBuffer(blob) {
+        return blob._buffer;
+    }
+};
+export class File extends Blob {
+    constructor(chunks, name, opts = {}) {
+        super(chunks, opts);
+        this[_b] = "File";
+        this._name = name.replace(/\//g, ":");
+        this._lastModified =
             opts.lastModified
                 ? new Date(opts.lastModified).valueOf()
                 : Date.now();
-        return _this;
     }
-    Object.defineProperty(File.prototype, "name", {
-        get: function () {
-            return this._name;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(File.prototype, "lastModified", {
-        get: function () {
-            return this._lastModified;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    File.prototype.toString = function () {
+    get name() {
+        return this._name;
+    }
+    get lastModified() {
+        return this._lastModified;
+    }
+    toString() {
         return "[object File]";
-    };
-    return File;
-}(Blob));
-export { File };
-_a = Symbol.toStringTag;
-var FileReader = /** @class */ (function () {
-    function FileReader() {
+    }
+}
+_b = Symbol.toStringTag;
+export class FileReader {
+    constructor() {
         this.EMPTY = 0;
         this.LOADING = 1;
         this.DONE = 2;
         this._listeners = new Map();
-        this[_b] = "FileReader";
+        this[_c] = "FileReader";
         //
     }
-    Object.defineProperty(FileReader.prototype, "readyState", {
-        get: function () {
-            return this._readyState;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(FileReader.prototype, "result", {
-        get: function () {
-            return this._result;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    FileReader.prototype._array2base64 = function (input) {
+    get readyState() {
+        return this._readyState;
+    }
+    get result() {
+        return this._result;
+    }
+    _array2base64(input) {
         var byteToCharMap = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
         var output = [];
         for (var i = 0; i < input.length; i += 3) {
@@ -1025,67 +900,59 @@ var FileReader = /** @class */ (function () {
             output.push(byteToCharMap[outByte1], byteToCharMap[outByte2], byteToCharMap[outByte3], byteToCharMap[outByte4]);
         }
         return output.join("");
-    };
-    FileReader.prototype._read = function (blob, kind) {
-        var _this = this;
+    }
+    _read(blob, kind) {
         if (!(blob instanceof Blob)) {
-            throw new TypeError("Failed to execute '" + kind + "' on 'FileReader': parameter 1 is not of type 'Blob'.");
+            throw new TypeError(`Failed to execute '${kind}' on 'FileReader': parameter 1 is not of type 'Blob'.`);
         }
         this._result = "";
-        setTimeout(function () {
-            _this._readyState = _this.LOADING;
-            _this.emitEvent("load");
-            _this.emitEvent("loadend");
+        setTimeout(() => {
+            this._readyState = this.LOADING;
+            this.emitEvent("load");
+            this.emitEvent("loadend");
         });
-    };
-    FileReader.prototype.emitEvent = function (eventName) {
-        var _this = this;
-        var args = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            args[_i - 1] = arguments[_i];
-        }
+    }
+    emitEvent(eventName, ...args) {
         if (isFunction(this["on" + eventName])) {
-            this["on" + eventName].apply(this, args);
+            this["on" + eventName](...args);
         }
-        var handlers = this._listeners.get(eventName) || [];
-        handlers.forEach(function (handler) {
-            handler.apply(void 0, __spreadArray([_this], args));
+        let handlers = this._listeners.get(eventName) || [];
+        handlers.forEach((handler) => {
+            handler(this, ...args);
         });
-    };
-    FileReader.prototype.addEventListener = function (eventName, handler) {
+    }
+    addEventListener(eventName, handler) {
         if (["abort", "error", "load", "loadend", "loadstart", "progress"].indexOf(eventName) === -1) {
             throw new Error("Event not supported: " + eventName);
         }
-        var handlers = this._listeners.get(eventName) || [];
+        let handlers = this._listeners.get(eventName) || [];
         handlers.push(handler);
         this._listeners.set(eventName, handlers);
-    };
-    FileReader.prototype.removeEventListener = function (eventName, toDetach) {
-        var handlers = this._listeners.get(eventName) || [];
-        handlers = handlers.filter(function (handler) { return handler !== toDetach; });
+    }
+    removeEventListener(eventName, toDetach) {
+        let handlers = this._listeners.get(eventName) || [];
+        handlers = handlers.filter((handler) => handler !== toDetach);
         this._listeners.set(eventName, handlers);
-    };
-    FileReader.prototype.readAsDataURL = function (blob) {
+    }
+    readAsDataURL(blob) {
         this._read(blob, "readAsDataURL");
-        this._result = "data:" + blob.type + ";base64," + this._array2base64(Blob.InternalAccessor.getBuffer(blob));
-    };
-    FileReader.prototype.readAsText = function (blob) {
+        this._result = `data:${blob.type};base64,${this._array2base64(Blob.InternalAccessor.getBuffer(blob))}`;
+    }
+    readAsText(blob) {
         this._read(blob, "readAsText");
-        var textDecoder = new TextDecoder();
+        const textDecoder = new TextDecoder();
         this._result = textDecoder.decode(Blob.InternalAccessor.getBuffer(blob));
-    };
-    FileReader.prototype.readAsArrayBuffer = function (blob) {
+    }
+    readAsArrayBuffer(blob) {
         this._read(blob, "readAsArrayBuffer");
         this._result = Blob.InternalAccessor.getBuffer(blob).buffer.slice(0);
-    };
-    FileReader.prototype.abort = function () {
+    }
+    abort() {
         //
-    };
-    FileReader.prototype.toString = function () {
+    }
+    toString() {
         return "[object FileReader]";
-    };
-    return FileReader;
-}());
-export { FileReader };
-_b = Symbol.toStringTag;
+    }
+}
+_c = Symbol.toStringTag;
 //# sourceMappingURL=TNSXMLHttpRequest.js.map