@nativescript/canvas-polyfill 1.0.14-v6 → 1.1.0-alpha.1

package/async/xhr/TNSXMLHttpRequest.js

@@ -1,10 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var http_1 = require("../http/http");
-var http_request_common_1 = require("../http/http-request-common");
-var file_1 = require("../file/file");
-var types_1 = require("@nativescript/core/utils/types");
-var core_1 = require("@nativescript/core");
+var _a, _b, _c;
+import { Http } from '../http/http';
+import { HttpError, ProgressEvent } from '../http/http-request-common';
+import { FileManager } from '../file/file';
+import { isNullOrUndefined, isObject, isFunction } from '@nativescript/core/utils/types';
+import { knownFolders, path as filePath, File as fsFile } from '@nativescript/core';
 var XMLHttpRequestResponseType;
 (function (XMLHttpRequestResponseType) {
     XMLHttpRequestResponseType["empty"] = "";
@@ -14,7 +13,7 @@ var XMLHttpRequestResponseType;
     XMLHttpRequestResponseType["arraybuffer"] = "arraybuffer";
     XMLHttpRequestResponseType["blob"] = "blob";
 })(XMLHttpRequestResponseType || (XMLHttpRequestResponseType = {}));
-var statuses = {
+const statuses = {
     100: 'Continue',
     101: 'Switching Protocols',
     200: 'OK',
@@ -63,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, [_this].concat(args));
+    }
+    _emitEvent(eventName, ...args) {
+        const handlers = this._listeners.get(eventName) || [];
+        handlers.forEach((handler) => {
+            handler.apply(this, ...args);
         });
-    };
-    return TNSXMLHttpRequestUpload;
-}());
-exports.TNSXMLHttpRequestUpload = TNSXMLHttpRequestUpload;
-var TNSXMLHttpRequest = /** @class */ (function () {
-    function TNSXMLHttpRequest() {
+    }
+}
+export class TNSXMLHttpRequest {
+    constructor() {
         this.UNSENT = 0;
         this.OPENED = 1;
         this.HEADERS_RECEIVED = 2;
@@ -108,108 +100,65 @@ var TNSXMLHttpRequest = /** @class */ (function () {
         this._lastProgress = { lengthComputable: false, loaded: 0, total: 0, target: this };
         this._responseURL = '';
         this._listeners = new Map();
+        this._didUserSetResponseType = false;
         this.textTypes = ['text/plain', 'application/xml', 'application/rss+xml', 'text/html', 'text/xml'];
         this._status = Status.UNSENT;
-        this._http = new http_1.Http();
+        this._http = new Http();
         this._upload = new TNSXMLHttpRequestUpload(this);
     }
-    Object.defineProperty(TNSXMLHttpRequest.prototype, "readyState", {
-        get: function () {
-            return this._readyState;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(TNSXMLHttpRequest.prototype, "response", {
-        get: function () {
-            return this._response;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(TNSXMLHttpRequest.prototype, "responseType", {
-        get: function () {
-            return this._responseType;
-        },
-        set: function (value) {
-            if (value === XMLHttpRequestResponseType.empty || value in XMLHttpRequestResponseType) {
-                this._responseType = value;
-            }
-            else {
-                throw new Error("Response type of '" + value + "' not supported.");
-            }
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(TNSXMLHttpRequest.prototype, "responseText", {
-        get: function () {
-            if (this._responseType === XMLHttpRequestResponseType.text || this._responseType === XMLHttpRequestResponseType.json) {
-                return this._responseText;
-            }
-            return null;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(TNSXMLHttpRequest.prototype, "responseURL", {
-        get: function () {
-            return this._responseURL;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(TNSXMLHttpRequest.prototype, "status", {
-        get: function () {
-            return this._status;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(TNSXMLHttpRequest.prototype, "statusText", {
-        get: function () {
-            if (this._readyState === this.UNSENT || this._readyState === this.OPENED) {
-                return '';
-            }
-            return statuses[this.status];
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(TNSXMLHttpRequest.prototype, "upload", {
-        get: function () {
-            return this._upload;
-        },
-        enumerable: true,
-        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: true,
-        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') || this.getResponseHeader('content-type');
-        var contentType = header && header.toLowerCase();
+    }
+    _setResponseType() {
+        const header = this.getResponseHeader('Content-Type') || this.getResponseHeader('content-type');
+        const contentType = header && header.toLowerCase();
         if (contentType) {
             if (contentType.indexOf('application/json') >= 0 || contentType.indexOf('+json') >= 0) {
                 this._responseType = XMLHttpRequestResponseType.json;
@@ -224,29 +173,27 @@ 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];
                     }
@@ -255,74 +202,80 @@ 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 (types_1.isNullOrUndefined(this.response)) {
+        if (isNullOrUndefined(this.response)) {
             return;
         }
         if (this.response instanceof ArrayBuffer) {
             return;
         }
-        if (types_1.isObject(this.response)) {
+        if (isObject(this.response)) {
             Object.defineProperty(this._response, 'toString', {
                 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();
+                //value = new java.lang.String(data).toString();
+                value = com.github.triniwiz.async.Async2.Http.decodeBuffer(data);
                 break;
             }
             try {
-                var encoding = java.nio.charset.Charset.forName(encodingType);
-                value = new java.lang.String(data, encoding).toString();
+                //let encoding = java.nio.charset.Charset.forName(encodingType);
+                //value = new java.lang.String(data, encoding).toString();
+                value = com.github.triniwiz.async.Async2.Http.decodeBuffer(data, encodingType);
                 break;
             }
             catch (e) { }
         }
         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;
         if (this._readyState !== this.OPENED) {
             throw new Error("Failed to execute 'send' on 'XMLHttpRequest': The object's state must be OPENED");
         }
@@ -330,68 +283,72 @@ var TNSXMLHttpRequest = /** @class */ (function () {
             this._headers['Accept'] = '*/*';
         }
         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://', '');
             }
             else if (this._request.url.startsWith('~/')) {
-                path = core_1.path.join(core_1.knownFolders.currentApp().path, this._request.url.replace('~/', ''));
+                path = filePath.join(knownFolders.currentApp().path, this._request.url.replace('~/', ''));
             }
             else if (this._request.url.startsWith('/')) {
                 path = this._request.url;
             }
-            var responseURL_1 = "file://" + path;
-            var contentLength_1 = -1;
-            var file = core_1.File.fromPath(path);
-            if (core_1.File.exists(path)) {
-                contentLength_1 = file.size;
+            else if (this._request.url.startsWith('blob:nativescript')) {
+                path = (_e = (_d = URL === null || URL === void 0 ? void 0 : URL.InternalAccessor) === null || _d === void 0 ? void 0 : _d.getPath) === null || _e === void 0 ? void 0 : _e.call(_d, this._request.url);
+            }
+            const responseURL = `file://${path}`;
+            let contentLength = -1;
+            const file = fsFile.fromPath(path);
+            if (fsFile.exists(path)) {
+                contentLength = file.size;
             }
             this._lastProgress = {
-                lengthComputable: contentLength_1 > -1,
+                lengthComputable: contentLength > -1,
                 loaded: 0,
-                total: contentLength_1,
+                total: contentLength,
                 target: this,
             };
-            var startEvent = new http_request_common_1.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);
-            file_1.FileManager.readFile(path, {}, function (error, data) {
+            FileManager.readFile(path, {}, (error, data) => {
                 if (error) {
-                    var errorEvent = new http_request_common_1.ProgressEvent('error', _this._lastProgress);
-                    _this._responseText = error.message;
-                    if (_this.onerror) {
-                        _this.onerror(errorEvent);
-                    }
-                    _this.emitEvent('error', errorEvent);
-                    var loadendEvent = new http_request_common_1.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.responseType) {
-                        _this._setResponseType();
-                    }
-                    _this._status = 200;
-                    _this._httpContent = data;
-                    _this._responseURL = responseURL_1;
-                    if (_this.responseType === XMLHttpRequestResponseType.json) {
+                    if (!this._didUserSetResponseType) {
+                        this._setResponseType();
+                    }
+                    this._status = 200;
+                    this._httpContent = data;
+                    this._responseURL = responseURL;
+                    let size = 0;
+                    if (this.responseType === XMLHttpRequestResponseType.json) {
                         try {
-                            if (core_1.isAndroid) {
-                                _this._responseText = _this._toJSString(data);
-                                _this._response = JSON.parse(_this._responseText);
+                            if (global.isAndroid) {
+                                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) {
@@ -399,133 +356,135 @@ var TNSXMLHttpRequest = /** @class */ (function () {
                             // this should probably be caught before the promise resolves
                         }
                     }
-                    else if (_this.responseType === XMLHttpRequestResponseType.text) {
-                        if (core_1.isIOS) {
-                            var code = NSUTF8StringEncoding; // long:4
-                            var encodedString = NSString.alloc().initWithDataEncoding(data, code);
+                    else if (this.responseType === XMLHttpRequestResponseType.text) {
+                        if (global.isIOS) {
+                            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 ? response.toString() : '';
+                            const response = this._toJSString(data);
+                            this._responseText = this._response = response ? response.toString() : '';
                         }
                     }
-                    else if (_this.responseType === XMLHttpRequestResponseType.document) {
-                        if (core_1.isIOS) {
-                            var code = NSUTF8StringEncoding; // long:4
-                            var encodedString = NSString.alloc().initWithDataEncoding(data, code);
+                    else if (this.responseType === XMLHttpRequestResponseType.document) {
+                        if (global.isIOS) {
+                            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 ? response : '';
+                            let response = this._toJSString(data);
+                            this._responseText = this._response = response ? response : '';
                         }
                     }
-                    else if (_this.responseType === XMLHttpRequestResponseType.arraybuffer) {
-                        if (core_1.isIOS) {
-                            _this._response = interop.bufferFromData(data);
+                    else if (this.responseType === XMLHttpRequestResponseType.arraybuffer) {
+                        if (global.isIOS) {
+                            this._response = interop.bufferFromData(data);
                         }
                         else {
-                            _this._response = ArrayBuffer.from(java.nio.ByteBuffer.wrap(data));
+                            this._response = ArrayBuffer.from(data);
+                            size = data.byteLength;
                         }
                     }
-                    else if (_this.responseType === XMLHttpRequestResponseType.blob) {
-                        var buffer = void 0;
-                        if (core_1.isIOS) {
+                    else if (this.responseType === XMLHttpRequestResponseType.blob) {
+                        let buffer;
+                        if (global.isIOS) {
                             buffer = interop.bufferFromData(data);
                         }
                         else {
-                            var buf = java.nio.ByteBuffer.wrap(data);
-                            buffer = ArrayBuffer.from(buf);
+                            buffer = ArrayBuffer.from(data);
+                            size = buffer.byteLength;
                         }
-                        _this._response = new Blob([buffer]);
+                        this._response = new Blob([buffer]);
                     }
-                    var size = 0;
-                    if (core_1.isIOS) {
-                        if (data instanceof NSData) {
-                            size = data.length;
+                    if (size === 0) {
+                        if (global.isIOS) {
+                            if (data instanceof NSData) {
+                                size = data.length;
+                            }
+                        }
+                        else {
+                            size = data ? data === null || data === void 0 ? void 0 : data.length : 0;
                         }
                     }
-                    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 http_request_common_1.ProgressEvent('progress', _this._lastProgress);
-                    if (_this.onprogress) {
-                        _this.onprogress(progressEvent);
-                    }
-                    _this.emitEvent('progress', progressEvent);
-                    _this._addToStringOnResponse();
-                    var loadEvent = new http_request_common_1.ProgressEvent('load', _this._lastProgress);
-                    if (_this.onload) {
-                        _this.onload(loadEvent);
-                    }
-                    _this.emitEvent('load', loadEvent);
-                    var loadendEvent = new http_request_common_1.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']) {
-                        contentLength = parseInt(_this._headers['Content-Length'], 10) || -1;
+                let contentLength = -1;
+                if (typeof this._headers === 'object') {
+                    if (this._headers['Content-Length']) {
+                        contentLength = parseInt(this._headers['Content-Length'], 10) || -1;
                     }
-                    if (_this._headers['content-length']) {
-                        contentLength = parseInt(_this._headers['content-length'], 10) || -1;
+                    if (this._headers['content-length']) {
+                        contentLength = 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 http_request_common_1.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
@@ -533,14 +492,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({}, (_this._lastProgress || {}), event);
+            request.onProgress = (event) => {
+                this._lastProgress = Object.assign(Object.assign({}, (this._lastProgress || {})), event);
                 if (event.loaded > 0) {
-                    var progressEvent = new http_request_common_1.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);
                 }
             };
         }
@@ -549,259 +508,249 @@ var TNSXMLHttpRequest = /** @class */ (function () {
         }
         this._currentRequest = this._http.request(request);
         this._currentRequest
-            .then(function (res) {
-            _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 (core_1.isIOS) {
+                    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 (core_1.isIOS) {
+                    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 (core_1.isIOS) {
+                    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) {
-                if (core_1.isIOS) {
-                    _this._response = interop.bufferFromData(res.content);
+            else if (this.responseType === XMLHttpRequestResponseType.arraybuffer) {
+                if (global.isIOS) {
+                    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 http_request_common_1.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 http_request_common_1.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 http_request_common_1.HttpError.Cancelled:
-                    if (_this.onabort) {
-                        _this.onabort();
+                case HttpError.Cancelled:
+                    if (this.onabort) {
+                        this.onabort();
                     }
-                    var abortEvent = new http_request_common_1.ProgressEvent('abort', _this._lastProgress);
-                    if (_this._upload && (method === 'post' || method === 'put')) {
-                        _this._upload._emitEvent('abort', abortEvent);
+                    const abortEvent = new ProgressEvent('abort', this._lastProgress);
+                    if (this._upload && (method === 'post' || method === 'put')) {
+                        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 http_request_common_1.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);
-                    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 http_request_common_1.HttpError.Timeout:
-                    if (_this.ontimeout) {
-                        _this.ontimeout();
+                case HttpError.Timeout:
+                    if (this.ontimeout) {
+                        this.ontimeout();
                     }
-                    var timeoutEvent = new http_request_common_1.ProgressEvent('timeout', _this._lastProgress);
-                    if (_this._upload && (method === 'post' || method === 'put')) {
-                        _this._upload._emitEvent('timeout', timeoutEvent);
+                    const timeoutEvent = new ProgressEvent('timeout', this._lastProgress);
+                    if (this._upload && (method === 'post' || method === 'put')) {
+                        this._upload._emitEvent('timeout', timeoutEvent);
                     }
-                    _this.emitEvent('timeout', timeoutEvent);
+                    this.emitEvent('timeout', timeoutEvent);
                     break;
-                case http_request_common_1.HttpError.Error:
-                    if (_this.onerror) {
-                        _this.onerror(error.message);
+                case HttpError.Error:
+                    if (this.onerror) {
+                        this.onerror(error.message);
                     }
-                    var errorEvent = new http_request_common_1.ProgressEvent('error', _this._lastProgress);
-                    if (_this._upload && (method === 'post' || method === 'put')) {
-                        _this._upload._emitEvent('error', errorEvent);
+                    const errorEvent = new ProgressEvent('error', this._lastProgress);
+                    if (this._upload && (method === 'post' || method === 'put')) {
+                        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 http_request_common_1.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.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, [_this].concat(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;
-}());
-exports.TNSXMLHttpRequest = 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;
-}());
-exports.FormData = FormData;
-var Blob = /** @class */ (function () {
-    function Blob(chunks, opts) {
-        if (chunks === void 0) { chunks = []; }
-        if (opts === void 0) { opts = {}; }
-        this[Symbol.toStringTag] = '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) {
@@ -811,15 +760,15 @@ var Blob = /** @class */ (function () {
                 dataChunks.push(new Uint8Array(ArrayBuffer.isView(chunk) ? chunk.buffer.slice(0) : 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);
+        let 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;
         }
@@ -833,103 +782,71 @@ var Blob = /** @class */ (function () {
             this._type = this._type.toLowerCase();
         }
     }
-    Object.defineProperty(Blob.prototype, "size", {
-        get: function () {
-            return this._size;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Blob.prototype, "type", {
-        get: function () {
-            return this._type;
-        },
-        enumerable: true,
-        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]';
-    };
-    // 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;
-}());
-exports.Blob = 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[Symbol.toStringTag] = '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: true,
-        configurable: true
-    });
-    Object.defineProperty(File.prototype, "lastModified", {
-        get: function () {
-            return this._lastModified;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    File.prototype.toString = function () {
+    }
+}
+_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();
+    }
+    get name() {
+        return this._name;
+    }
+    get lastModified() {
+        return this._lastModified;
+    }
+    toString() {
         return '[object File]';
-    };
-    return File;
-}(Blob));
-exports.File = File;
-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[Symbol.toStringTag] = 'FileReader';
+        this[_c] = 'FileReader';
         //
     }
-    Object.defineProperty(FileReader.prototype, "readyState", {
-        get: function () {
-            return this._readyState;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(FileReader.prototype, "result", {
-        get: function () {
-            return this._result;
-        },
-        enumerable: true,
-        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) {
@@ -951,66 +868,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];
-        }
-        if (types_1.isFunction(this['on' + eventName])) {
-            this['on' + eventName].apply(this, args);
-        }
-        var handlers = this._listeners.get(eventName) || [];
-        handlers.forEach(function (handler) {
-            handler.apply(void 0, [_this].concat(args));
+    }
+    emitEvent(eventName, ...args) {
+        if (isFunction(this['on' + eventName])) {
+            this['on' + eventName](...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;
-}());
-exports.FileReader = FileReader;
+    }
+}
+_c = Symbol.toStringTag;
 //# sourceMappingURL=TNSXMLHttpRequest.js.map