@nativescript/core 9.0.0-next-07-26-2025-16544379102 → 9.0.0-preview.1

package/fetch/index.js

@@ -1,335 +1,301 @@
-(function () {
-    "use strict";
-
-    var support = {
-        searchParams: "URLSearchParams" in global,
-        iterable: "Symbol" in global && "iterator" in Symbol,
-        blob:
-            "FileReader" in global &&
-            "Blob" in global &&
-            (function () {
-                try {
-                    new Blob();
-                    return true;
-                } catch (e) {
-                    return false;
-                }
-            })(),
-        formData: "FormData" in global,
-        arrayBuffer: "ArrayBuffer" in global
-    };
-
-    function isDataView(obj) {
-        return obj && DataView.prototype.isPrototypeOf(obj);
-    }
-
-    if (support.arrayBuffer) {
-        var viewClasses = [
-            "[object Int8Array]",
-            "[object Uint8Array]",
-            "[object Uint8ClampedArray]",
-            "[object Int16Array]",
-            "[object Uint16Array]",
-            "[object Int32Array]",
-            "[object Uint32Array]",
-            "[object Float32Array]",
-            "[object Float64Array]"
-        ];
-
-        var isArrayBufferView =
-            ArrayBuffer.isView ||
-            function (obj) {
-                return (
-                    obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1
-                );
-            };
+const g = (typeof globalThis !== 'undefined' && globalThis) || (typeof self !== 'undefined' && self) || (typeof global !== 'undefined' && global) || {};
+const support = {
+    searchParams: 'URLSearchParams' in g,
+    iterable: 'Symbol' in g && 'iterator' in Symbol,
+    blob: 'FileReader' in g &&
+        'Blob' in g &&
+        (() => {
+            try {
+                new Blob();
+                return true;
+            }
+            catch (e) {
+                return false;
+            }
+        })(),
+    formData: 'FormData' in g,
+    arrayBuffer: 'ArrayBuffer' in g,
+};
+function isDataView(obj) {
+    return obj && DataView.prototype.isPrototypeOf(obj);
+}
+let isArrayBufferView;
+if (support.arrayBuffer) {
+    const viewClasses = ['[object Int8Array]', '[object Uint8Array]', '[object Uint8ClampedArray]', '[object Int16Array]', '[object Uint16Array]', '[object Int32Array]', '[object Uint32Array]', '[object Float32Array]', '[object Float64Array]'];
+    isArrayBufferView =
+        ArrayBuffer.isView ||
+            ((obj) => {
+                return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1;
+            });
+}
+function normalizeName(name) {
+    if (typeof name !== 'string') {
+        name = String(name);
     }
-
-    function normalizeName(name) {
-        if (typeof name !== "string") {
-            name = String(name);
-        }
-        if (/[^a-z0-9\-#$%&'*+.^_`|~]/i.test(name)) {
-            throw new TypeError("Invalid character in header field name");
-        }
-        return name.toLowerCase();
+    if (/[^a-z0-9\-#$%&'*+.^_`|~!]/i.test(name) || name === '') {
+        throw new TypeError('Invalid character in header field name: "' + name + '"');
     }
-
-    function normalizeValue(value) {
-        if (typeof value !== "string") {
-            value = String(value);
-        }
-        return value;
+    return name.toLowerCase();
+}
+function normalizeValue(value) {
+    if (typeof value !== 'string') {
+        value = String(value);
     }
-
-    // Build a destructive iterator for the value list
-    function iteratorFor(items) {
-        var iterator = {
-            next: function () {
-                var value = items.shift();
-                return { done: value === undefined, value: value };
-            }
-        };
-
-        if (support.iterable) {
-            iterator[Symbol.iterator] = function () {
-                return iterator;
-            };
-        }
-
-        return iterator;
+    return value;
+}
+// Build a destructive iterator for the value list
+function iteratorFor(items) {
+    const iterator = {
+        next: () => {
+            const value = items.shift();
+            return { done: value === undefined, value };
+        },
+    };
+    if (support.iterable) {
+        iterator[Symbol.iterator] = () => iterator;
     }
-
-    function Headers(headers) {
+    return iterator;
+}
+export class Headers {
+    constructor(headers) {
         this.map = {};
-
         if (headers instanceof Headers) {
-            headers.forEach(function (value, name) {
+            headers.forEach((value, name) => {
                 this.append(name, value);
-            }, this);
-        } else if (Array.isArray(headers)) {
-            headers.forEach(function (header) {
+            });
+        }
+        else if (Array.isArray(headers)) {
+            headers.forEach((header) => {
+                if (header.length !== 2) {
+                    throw new TypeError('Headers constructor: expected name/value pair to be length 2, found ' + header.length);
+                }
                 this.append(header[0], header[1]);
-            }, this);
-        } else if (headers) {
-            Object.getOwnPropertyNames(headers).forEach(function (name) {
+            });
+        }
+        else if (headers) {
+            Object.getOwnPropertyNames(headers).forEach((name) => {
                 this.append(name, headers[name]);
-            }, this);
+            });
         }
     }
-
-    Headers.prototype.append = function (name, value) {
+    append(name, value) {
         name = normalizeName(name);
         value = normalizeValue(value);
-        var oldValue = this.map[name];
-        this.map[name] = oldValue ? oldValue + ", " + value : value;
-    };
-
-    Headers.prototype["delete"] = function (name) {
+        const oldValue = this.map[name];
+        this.map[name] = oldValue ? oldValue + ', ' + value : value;
+    }
+    delete(name) {
         delete this.map[normalizeName(name)];
-    };
-
-    Headers.prototype.get = function (name) {
+    }
+    get(name) {
         name = normalizeName(name);
         return this.has(name) ? this.map[name] : null;
-    };
-
-    Headers.prototype.has = function (name) {
-        return this.map.hasOwnProperty(normalizeName(name));
-    };
-
-    Headers.prototype.set = function (name, value) {
+    }
+    has(name) {
+        return Object.prototype.hasOwnProperty.call(this.map, normalizeName(name));
+    }
+    set(name, value) {
         this.map[normalizeName(name)] = normalizeValue(value);
-    };
-
-    Headers.prototype.forEach = function (callback, thisArg) {
-        for (var name in this.map) {
-            if (this.map.hasOwnProperty(name)) {
+    }
+    forEach(callback, thisArg) {
+        for (const name in this.map) {
+            if (Object.prototype.hasOwnProperty.call(this.map, name)) {
                 callback.call(thisArg, this.map[name], name, this);
             }
         }
-    };
-
-    Headers.prototype.keys = function () {
-        var items = [];
-        this.forEach(function (value, name) {
-            items.push(name);
-        });
-        return iteratorFor(items);
-    };
-
-    Headers.prototype.values = function () {
-        var items = [];
-        this.forEach(function (value) {
-            items.push(value);
-        });
+    }
+    keys() {
+        const items = [];
+        this.forEach((_, name) => items.push(name));
         return iteratorFor(items);
-    };
-
-    Headers.prototype.entries = function () {
-        var items = [];
-        this.forEach(function (value, name) {
-            items.push([name, value]);
-        });
+    }
+    values() {
+        const items = [];
+        this.forEach((value) => items.push(value));
         return iteratorFor(items);
-    };
-
-    if (support.iterable) {
-        Headers.prototype[Symbol.iterator] = Headers.prototype.entries;
     }
-
-    function consumed(body) {
-        if (body.bodyUsed) {
-            return Promise.reject(new TypeError("Already read"));
-        }
-        body.bodyUsed = true;
+    entries() {
+        const items = [];
+        this.forEach((value, name) => items.push([name, value]));
+        return iteratorFor(items);
     }
-
-    function fileReaderReady(reader) {
-        return new Promise(function (resolve, reject) {
-            reader.onload = function () {
-                resolve(reader.result);
-            };
-            reader.onerror = function () {
-                reject(reader.error);
-            };
-        });
+    [Symbol.iterator]() {
+        return this.entries();
     }
-
-    function readBlobAsArrayBuffer(blob) {
-        var reader = new FileReader();
-        var promise = fileReaderReady(reader);
-        reader.readAsArrayBuffer(blob);
-        return promise;
-    }
-
-    function readBlobAsText(blob) {
-        var reader = new FileReader();
-        var promise = fileReaderReady(reader);
-        reader.readAsText(blob);
-        return promise;
-    }
-
-    function readArrayBufferAsText(buf) {
-        var view = new Uint8Array(buf);
-        var chars = new Array(view.length);
-
-        for (var i = 0; i < view.length; i++) {
-            chars[i] = String.fromCharCode(view[i]);
-        }
-        return chars.join("");
-    }
-
-    function bufferClone(buf) {
-        if (buf.slice) {
-            return buf.slice(0);
-        } else {
-            var view = new Uint8Array(buf.byteLength);
-            view.set(new Uint8Array(buf));
-            return view.buffer;
-        }
-    }
-
-    function Body() {
+}
+// Body mixin
+export class Body {
+    constructor() {
         this.bodyUsed = false;
-
-        this._initBody = function (body) {
-            this._bodyInit = body;
-            if (!body) {
-                this._bodyText = "";
-            } else if (typeof body === "string") {
-                this._bodyText = body;
-            } else if (support.blob && Blob.prototype.isPrototypeOf(body)) {
-                this._bodyBlob = body;
-            } else if (support.formData && FormData.prototype.isPrototypeOf(body)) {
-                this._bodyFormData = body;
-            } else if (
-                support.searchParams &&
-                URLSearchParams.prototype.isPrototypeOf(body)
-            ) {
-                this._bodyText = body.toString();
-            } else if (support.arrayBuffer && support.blob && isDataView(body)) {
-                this._bodyArrayBuffer = bufferClone(body.buffer);
-                // IE 10-11 can't handle a DataView body.
-                this._bodyInit = new Blob([this._bodyArrayBuffer]);
-            } else if (
-                support.arrayBuffer &&
-                (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))
-            ) {
-                this._bodyArrayBuffer = bufferClone(body);
-            } else {
-                this._bodyText = body = Object.prototype.toString.call(body);
+    }
+    _initBody(body) {
+        // Ensure bodyUsed property exists
+        this.bodyUsed = this.bodyUsed;
+        this._bodyInit = body;
+        if (!body) {
+            this._noBody = true;
+            this._bodyText = '';
+        }
+        else if (typeof body === 'string') {
+            this._bodyText = body;
+        }
+        else if (support.blob && Blob.prototype.isPrototypeOf(body)) {
+            this._bodyBlob = body;
+        }
+        else if (support.formData && FormData.prototype.isPrototypeOf(body)) {
+            this._bodyFormData = body;
+        }
+        else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
+            this._bodyText = body.toString();
+        }
+        else if (support.arrayBuffer && support.blob && isDataView(body)) {
+            // @ts-ignore
+            this._bodyArrayBuffer = bufferClone(body.buffer);
+            this._bodyInit = new Blob([this._bodyArrayBuffer]);
+        }
+        else if (support.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))) {
+            this._bodyArrayBuffer = bufferClone(body);
+        }
+        else {
+            this._bodyText = body = Object.prototype.toString.call(body);
+        }
+        // Set Content-Type header if not set
+        if (!this.headers.get('content-type')) {
+            if (typeof body === 'string') {
+                this.headers.set('content-type', 'text/plain;charset=UTF-8');
             }
-
-            if (!this.headers.get("content-type")) {
-                if (typeof body === "string") {
-                    this.headers.set("content-type", "text/plain;charset=UTF-8");
-                } else if (this._bodyBlob && this._bodyBlob.type) {
-                    this.headers.set("content-type", this._bodyBlob.type);
-                } else if (
-                    support.searchParams &&
-                    URLSearchParams.prototype.isPrototypeOf(body)
-                ) {
-                    this.headers.set(
-                        "content-type",
-                        "application/x-www-form-urlencoded;charset=UTF-8"
-                    );
-                }
+            else if (this._bodyBlob && this._bodyBlob.type) {
+                this.headers.set('content-type', this._bodyBlob.type);
             }
-        };
-
-        if (support.blob) {
-            this.blob = function () {
-                var rejected = consumed(this);
-                if (rejected) {
-                    return rejected;
-                }
-
-                if (this._bodyBlob) {
-                    return Promise.resolve(this._bodyBlob);
-                } else if (this._bodyArrayBuffer) {
-                    return Promise.resolve(new Blob([this._bodyArrayBuffer]));
-                } else if (this._bodyFormData) {
-                    throw new Error("could not read FormData body as blob");
-                } else {
-                    return Promise.resolve(new Blob([this._bodyText]));
-                }
-            };
-
-            this.arrayBuffer = function () {
-                if (this._bodyArrayBuffer) {
-                    return consumed(this) || Promise.resolve(this._bodyArrayBuffer);
-                } else {
-                    return this.blob().then(readBlobAsArrayBuffer);
-                }
-            };
+            else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
+                this.headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8');
+            }
+        }
+    }
+    blob() {
+        const rejected = consumed(this);
+        if (rejected) {
+            return rejected;
+        }
+        if (this._bodyBlob) {
+            return Promise.resolve(this._bodyBlob);
+        }
+        else if (this._bodyArrayBuffer) {
+            return Promise.resolve(new Blob([this._bodyArrayBuffer]));
+        }
+        else if (this._bodyFormData) {
+            throw new Error('could not read FormData body as blob');
+        }
+        else {
+            return Promise.resolve(new Blob([this._bodyText]));
         }
-
-        this.text = function () {
-            var rejected = consumed(this);
-            if (rejected) {
-                return rejected;
+    }
+    arrayBuffer() {
+        if (this._bodyArrayBuffer) {
+            const consumedResult = consumed(this);
+            if (consumedResult) {
+                return consumedResult;
             }
-
-            if (this._bodyBlob) {
-                return readBlobAsText(this._bodyBlob);
-            } else if (this._bodyArrayBuffer) {
-                return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer));
-            } else if (this._bodyFormData) {
-                throw new Error("could not read FormData body as text");
-            } else {
-                return Promise.resolve(this._bodyText);
+            else if (ArrayBuffer.isView(this._bodyArrayBuffer)) {
+                return Promise.resolve(this._bodyArrayBuffer.buffer.slice(this._bodyArrayBuffer.byteOffset, this._bodyArrayBuffer.byteOffset + this._bodyArrayBuffer.byteLength));
+            }
+            else {
+                return Promise.resolve(this._bodyArrayBuffer);
             }
-        };
-
-        if (support.formData) {
-            this.formData = function () {
-                return this.text().then(decode);
-            };
         }
-
-        this.json = function () {
-            return this.text().then(JSON.parse);
-        };
-
-        return this;
-    }
-
-    // HTTP methods whose capitalization should be normalized
-    var methods = ["DELETE", "GET", "HEAD", "OPTIONS", "POST", "PUT"];
-
-    function normalizeMethod(method) {
-        var upcased = method.toUpperCase();
-        return methods.indexOf(upcased) > -1 ? upcased : method;
-    }
-
-    function Request(input, options) {
-        options = options || {};
-        var body = options.body;
-
+        else if (support.blob) {
+            // @ts-ignore
+            return this.blob().then(readBlobAsArrayBuffer);
+        }
+        else {
+            throw new Error('could not read as ArrayBuffer');
+        }
+    }
+    text() {
+        const rejected = consumed(this);
+        if (rejected) {
+            return rejected;
+        }
+        if (this._bodyBlob) {
+            return readBlobAsText(this._bodyBlob);
+        }
+        else if (this._bodyArrayBuffer) {
+            return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer));
+        }
+        else if (this._bodyFormData) {
+            throw new Error('could not read FormData body as text');
+        }
+        else {
+            return Promise.resolve(this._bodyText);
+        }
+    }
+    formData() {
+        return this.text().then(decode);
+    }
+    json() {
+        return this.text().then(JSON.parse);
+    }
+}
+// Helper functions for Body
+function consumed(body) {
+    if (body._noBody)
+        return;
+    if (body.bodyUsed) {
+        return Promise.reject(new TypeError('Already read'));
+    }
+    body.bodyUsed = true;
+}
+function fileReaderReady(reader) {
+    return new Promise((resolve, reject) => {
+        reader.onload = () => resolve(reader.result);
+        reader.onerror = () => reject(reader.error);
+    });
+}
+function readBlobAsArrayBuffer(blob) {
+    const reader = new FileReader();
+    const promise = fileReaderReady(reader);
+    reader.readAsArrayBuffer(blob);
+    return promise;
+}
+function readBlobAsText(blob) {
+    const reader = new FileReader();
+    const promise = fileReaderReady(reader);
+    const match = /charset=([A-Za-z0-9_-]+)/.exec(blob.type);
+    const encoding = match ? match[1] : 'utf-8';
+    reader.readAsText(blob, encoding);
+    return promise;
+}
+function readArrayBufferAsText(buf) {
+    const view = new Uint8Array(buf);
+    const chars = new Array(view.length);
+    for (let i = 0; i < view.length; i++) {
+        chars[i] = String.fromCharCode(view[i]);
+    }
+    return chars.join('');
+}
+function bufferClone(buf) {
+    if (buf.slice) {
+        return buf.slice(0);
+    }
+    else {
+        const view = new Uint8Array(buf.byteLength);
+        view.set(new Uint8Array(buf));
+        return view.buffer;
+    }
+}
+// HTTP methods whose capitalization should be normalized
+const methods = ['CONNECT', 'DELETE', 'GET', 'HEAD', 'OPTIONS', 'PATCH', 'POST', 'PUT', 'TRACE'];
+function normalizeMethod(method) {
+    const upcased = method.toUpperCase();
+    return methods.indexOf(upcased) > -1 ? upcased : method;
+}
+export class Request extends Body {
+    constructor(input, options = {}) {
+        super();
+        let body = options.body;
         if (input instanceof Request) {
             if (input.bodyUsed) {
-                throw new TypeError("Already read");
+                throw new TypeError('Already read');
             }
             this.url = input.url;
             this.credentials = input.credentials;
@@ -343,197 +309,221 @@
                 body = input._bodyInit;
                 input.bodyUsed = true;
             }
-        } else {
+        }
+        else {
             this.url = String(input);
         }
-
-        this.credentials = options.credentials || this.credentials || "same-origin";
+        this.credentials = options.credentials || this.credentials || 'same-origin';
         if (options.headers || !this.headers) {
             this.headers = new Headers(options.headers);
         }
-        this.method = normalizeMethod(options.method || this.method || "GET");
+        this.method = normalizeMethod(options.method || this.method || 'GET');
         this.mode = options.mode || this.mode || null;
-        this.signal = options.signal || this.signal;
+        this.signal = options.signal || this.signal || ('AbortController' in g ? new AbortController().signal : undefined);
         this.referrer = null;
-
-        if ((this.method === "GET" || this.method === "HEAD") && body) {
-            throw new TypeError("Body not allowed for GET or HEAD requests");
+        if ((this.method === 'GET' || this.method === 'HEAD') && body) {
+            throw new TypeError('Body not allowed for GET or HEAD requests');
         }
         this._initBody(body);
+        if (this.method === 'GET' || this.method === 'HEAD') {
+            if (options.cache === 'no-store' || options.cache === 'no-cache') {
+                const reParamSearch = /([?&])_=[^&]*/;
+                if (reParamSearch.test(this.url)) {
+                    this.url = this.url.replace(reParamSearch, '$1_=' + new Date().getTime());
+                }
+                else {
+                    const reQueryString = /\?/;
+                    this.url += (reQueryString.test(this.url) ? '&' : '?') + '_=' + new Date().getTime();
+                }
+            }
+        }
     }
-
-    Request.prototype.clone = function () {
+    clone() {
         return new Request(this, { body: this._bodyInit });
-    };
-
-    function decode(body) {
-        var form = new FormData();
-        body
-            .trim()
-            .split("&")
-            .forEach(function (bytes) {
-                if (bytes) {
-                    var split = bytes.split("=");
-                    var name = split.shift().replace(/\+/g, " ");
-                    var value = split.join("=").replace(/\+/g, " ");
-                    form.append(decodeURIComponent(name), decodeURIComponent(value));
-                }
-            });
-        return form;
-    }
-
-    function parseHeaders(rawHeaders) {
-        var headers = new Headers();
-        // Replace instances of \r\n and \n followed by at least one space or horizontal tab with a space
-        // https://tools.ietf.org/html/rfc7230#section-3.2
-        var preProcessedHeaders = rawHeaders.replace(/\r?\n[\t ]+/g, " ");
-        preProcessedHeaders.split(/\r?\n/).forEach(function (line) {
-            var parts = line.split(":");
-            var key = parts.shift().trim();
-            if (key) {
-                var value = parts.join(":").trim();
+    }
+}
+// Decode URL-encoded form data
+function decode(body) {
+    const form = new FormData();
+    body
+        .trim()
+        .split('&')
+        .forEach((bytes) => {
+        if (bytes) {
+            const split = bytes.split('=');
+            const name = split.shift().replace(/\+/g, ' ');
+            const value = split.join('=').replace(/\+/g, ' ');
+            form.append(decodeURIComponent(name), decodeURIComponent(value));
+        }
+    });
+    return form;
+}
+// Parse raw headers string into Headers
+function parseHeaders(rawHeaders) {
+    const headers = new Headers();
+    const preProcessed = rawHeaders.replace(/\r?\n[\t ]+/g, ' ');
+    preProcessed
+        .split('\r')
+        .map((header) => (header.indexOf('\n') === 0 ? header.substr(1) : header))
+        .forEach((line) => {
+        const parts = line.split(':');
+        const key = parts.shift().trim();
+        if (key) {
+            const value = parts.join(':').trim();
+            try {
                 headers.append(key, value);
             }
-        });
-        return headers;
-    }
-
-    Body.call(Request.prototype);
-
-    function Response(bodyInit, options) {
-        if (!options) {
-            options = {};
+            catch (err) {
+                console.warn('Response ' + err.message);
+            }
         }
-
-        this.type = "default";
+    });
+    return headers;
+}
+const redirectStatuses = [301, 302, 303, 307, 308];
+export class Response extends Body {
+    constructor(bodyInit, options = {}) {
+        super();
+        this.type = 'default';
         this.status = options.status === undefined ? 200 : options.status;
+        if (this.status < 200 || this.status > 599) {
+            throw new RangeError(`Failed to construct 'Response': The status provided (${this.status}) is outside the range [200, 599].`);
+        }
         this.ok = this.status >= 200 && this.status < 300;
-        this.statusText = "statusText" in options ? options.statusText : "OK";
+        this.statusText = options.statusText === undefined ? '' : String(options.statusText);
         this.headers = new Headers(options.headers);
-        this.url = options.url || "";
+        this.url = options.url || '';
         this._initBody(bodyInit);
     }
-
-    Body.call(Response.prototype);
-
-    Response.prototype.clone = function () {
+    clone() {
         return new Response(this._bodyInit, {
             status: this.status,
             statusText: this.statusText,
             headers: new Headers(this.headers),
-            url: this.url
+            url: this.url,
         });
-    };
-
-    Response.error = function () {
-        var response = new Response(null, { status: 0, statusText: "" });
-        response.type = "error";
+    }
+    static error() {
+        const response = new Response(null, { status: 200, statusText: '' });
+        response.ok = false;
+        response.status = 0;
+        response.type = 'error';
         return response;
-    };
-
-    var redirectStatuses = [301, 302, 303, 307, 308];
-
-    Response.redirect = function (url, status) {
-        if (redirectStatuses.indexOf(status) === -1) {
-            throw new RangeError("Invalid status code");
-        }
-
-        return new Response(null, { status: status, headers: { location: url } });
-    };
-
-    exports.DOMException = global.DOMException;
-    try {
-        new exports.DOMException();
-    } catch (err) {
-        exports.DOMException = function (message, name) {
+    }
+    static redirect(url, status) {
+        if (!redirectStatuses.includes(status)) {
+            throw new RangeError('Invalid status code');
+        }
+        return new Response(null, { status, headers: { location: url } });
+    }
+}
+// DOMException polyfill
+export let DOMException = g.DOMException;
+try {
+    new g.DOMException();
+}
+catch (err) {
+    DOMException = class {
+        constructor(message, name) {
             this.message = message;
             this.name = name;
-            var error = Error(message);
+            const error = new Error(message);
             this.stack = error.stack;
+        }
+    };
+}
+// fetch function
+export function fetch(input, init) {
+    return new Promise((resolve, reject) => {
+        const request = new Request(input, init);
+        if (request.signal && request.signal.aborted) {
+            return reject(new DOMException('Aborted', 'AbortError'));
+        }
+        const xhr = new XMLHttpRequest();
+        function abortXhr() {
+            xhr.abort();
+        }
+        xhr.onload = function () {
+            const options = {
+                statusText: xhr.statusText,
+                headers: parseHeaders(xhr.getAllResponseHeaders() || ''),
+            };
+            // Local file handling
+            if (request.url.startsWith('file://') && (xhr.status < 200 || xhr.status > 599)) {
+                options.status = 200;
+            }
+            else {
+                options.status = xhr.status;
+            }
+            options.url = 'responseURL' in xhr ? xhr.responseURL : options.headers.get('X-Request-URL');
+            // @ts-ignore
+            const body = 'response' in xhr ? xhr.response : xhr.responseText;
+            setTimeout(() => resolve(new Response(body, options)), 0);
         };
-        exports.DOMException.prototype = Object.create(Error.prototype);
-        exports.DOMException.prototype.constructor = exports.DOMException;
-    }
-
-    function fetch(input, init) {
-        return new Promise(function (resolve, reject) {
-            var request = new Request(input, init);
-
-            if (request.signal && request.signal.aborted) {
-                return reject(new exports.DOMException("Aborted", "AbortError"));
+        xhr.onerror = function () {
+            setTimeout(() => reject(new TypeError('Network request failed')), 0);
+        };
+        xhr.ontimeout = function () {
+            setTimeout(() => reject(new TypeError('Network request timed out')), 0);
+        };
+        xhr.onabort = function () {
+            setTimeout(() => reject(new DOMException('Aborted', 'AbortError')), 0);
+        };
+        function fixUrl(url) {
+            try {
+                return url === '' && g.location.href ? g.location.href : url;
             }
-
-            var xhr = new XMLHttpRequest();
-
-            function abortXhr() {
-                xhr.abort();
+            catch (e) {
+                return url;
             }
-
-            xhr.onload = function () {
-                var options = {
-                    status: xhr.status,
-                    statusText: xhr.statusText,
-                    headers: parseHeaders(xhr.getAllResponseHeaders() || "")
-                };
-                options.url =
-                    "responseURL" in xhr
-                        ? xhr.responseURL
-                        : options.headers.get("X-Request-URL");
-                var body = "response" in xhr ? xhr.response : xhr.responseText;
-                resolve(new Response(body, options));
-            };
-
-            xhr.onerror = function () {
-                reject(new TypeError("Network request failed"));
-            };
-
-            xhr.ontimeout = function () {
-                reject(new TypeError("Network request failed"));
-            };
-
-            xhr.onabort = function () {
-                reject(new exports.DOMException("Aborted", "AbortError"));
-            };
-
-            xhr.open(request.method, request.url, true);
-
-            if (request.credentials === "include") {
-                xhr.withCredentials = true;
-            } else if (request.credentials === "omit") {
-                xhr.withCredentials = false;
+        }
+        xhr.open(request.method, fixUrl(request.url), true);
+        if (request.credentials === 'include') {
+            xhr.withCredentials = true;
+        }
+        else if (request.credentials === 'omit') {
+            xhr.withCredentials = false;
+        }
+        if ('responseType' in xhr) {
+            if (support.blob) {
+                xhr.responseType = 'blob';
             }
-
-            if ("responseType" in xhr && support.blob) {
-                xhr.responseType = "blob";
+            else if (support.arrayBuffer) {
+                xhr.responseType = 'arraybuffer';
             }
-
-            request.headers.forEach(function (value, name) {
-                xhr.setRequestHeader(name, value);
+        }
+        if (init && typeof init.headers === 'object' && !(init.headers instanceof Headers) && !(g.Headers && init.headers instanceof g.Headers)) {
+            const names = [];
+            Object.getOwnPropertyNames(init.headers).forEach((name) => {
+                names.push(normalizeName(name));
+                xhr.setRequestHeader(name, normalizeValue(init.headers[name]));
             });
-
-            if (request.signal) {
-                request.signal.addEventListener("abort", abortXhr);
-
-                xhr.onreadystatechange = function () {
-                    // DONE (success or failure)
-                    if (xhr.readyState === 4) {
-                        request.signal.removeEventListener("abort", abortXhr);
-                    }
-                };
-            }
-
-            xhr.send(
-                typeof request._bodyInit === "undefined" ? null : request._bodyInit
-            );
-        });
-    }
-
-    fetch.polyfill = true;
-
-    exports.Headers = Headers;
-    exports.Request = Request;
-    exports.Response = Response;
-    exports.fetch = fetch;
-
-    Object.defineProperty(exports, "__esModule", { value: true });
-})();
+            request.headers.forEach((value, name) => {
+                if (!names.includes(name)) {
+                    xhr.setRequestHeader(name, value);
+                }
+            });
+        }
+        else {
+            request.headers.forEach((value, name) => xhr.setRequestHeader(name, value));
+        }
+        if (request.signal) {
+            request.signal.addEventListener('abort', abortXhr);
+            xhr.onreadystatechange = function () {
+                if (xhr.readyState === 4) {
+                    request.signal.removeEventListener('abort', abortXhr);
+                }
+            };
+        }
+        xhr.send(typeof request._bodyInit === 'undefined' ? null : request._bodyInit);
+    });
+}
+// Attach polyfill to globals
+fetch.polyfill = true;
+if (!g.fetch) {
+    g.fetch = fetch;
+    g.Headers = Headers;
+    g.Request = Request;
+    g.Response = Response;
+}
+//# sourceMappingURL=index.js.map