mphttpx 1.0.4 → 1.0.6

package/dist/index.esm.js

@@ -46,7 +46,7 @@ class TextEncoderP {
         return encodeText(input).encoded;
     }
     encodeInto(source, destination) {
-        const result = encodeText(source, destination);
+        let result = encodeText(source, destination);
         return { read: result.read, written: result.written };
     }
     toString() { return "[object TextEncoder]"; }
@@ -140,6 +140,7 @@ function encodeText(input, destination) {
 const TextEncoderE = g["TextEncoder"] || TextEncoderP;
 
 var _a$a, _b$3;
+/** @internal */
 const state$h = Symbol( /* "TextDecoderState" */);
 class TextDecoderP {
     constructor(utfLabel = "utf-8", { fatal = false, ignoreBOM = false } = {}) {
@@ -283,8 +284,9 @@ class TextDecoderP {
     get isPolyfill() { return { symbol: polyfill, hierarchy: ["TextDecoder"] }; }
 }
 defineStringTag(TextDecoderP, "TextDecoder");
-const _bomSeen = Symbol();
-const _partial = Symbol();
+/** @internal */ const _bomSeen = Symbol();
+/** @internal */ const _partial = Symbol();
+/** @internal */
 class TextDecoderState {
     constructor() {
         this.fatal = false;
@@ -301,19 +303,20 @@ function getBytesPerSequence(byte) {
 const TextDecoderE = g["TextDecoder"] || TextDecoderP;
 
 var _a$9, _b$2, _c$1, _d$1, _e$1, _f$1;
+/** @internal */
 const state$g = Symbol( /* "EventState" */);
 class EventP {
     constructor(type, eventInitDict) {
-        this.NONE = EventP.NONE;
-        this.CAPTURING_PHASE = EventP.CAPTURING_PHASE;
-        this.AT_TARGET = EventP.AT_TARGET;
-        this.BUBBLING_PHASE = EventP.BUBBLING_PHASE;
         this[state$g] = new EventState();
         const that = this[state$g];
         that.type = String(type);
         that.bubbles = !!(eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.bubbles);
         that.cancelable = !!(eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.cancelable);
         that.composed = !!(eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.composed);
+        Object.defineProperty(this, "isTrusted", {
+            enumerable: true,
+            get: (function isTrusted() { return this[state$g][_isTrusted]; }).bind(this),
+        });
     }
     get type() { return this[state$g].type; }
     get bubbles() { return this[state$g].bubbles; }
@@ -330,10 +333,9 @@ class EventP {
     set returnValue(value) { if (!value) {
         this.preventDefault();
     } }
-    get isTrusted() { return this[state$g][_isTrusted]; }
     get timeStamp() { return this[state$g].timeStamp; }
     composedPath() {
-        const path = !!this.target ? [this.target] : [];
+        let path = !!this.target ? [this.target] : [];
         if (!!this.currentTarget && this.currentTarget !== this.target)
             path.push(this.currentTarget);
         return path;
@@ -368,17 +370,22 @@ class EventP {
     toString() { return "[object Event]"; }
     get isPolyfill() { return { symbol: polyfill, hierarchy: ["Event"] }; }
 }
-EventP.NONE = 0;
-EventP.CAPTURING_PHASE = 1;
-EventP.AT_TARGET = 2;
-EventP.BUBBLING_PHASE = 3;
+const properties$2 = {
+    NONE: { value: 0, enumerable: true },
+    CAPTURING_PHASE: { value: 1, enumerable: true },
+    AT_TARGET: { value: 2, enumerable: true },
+    BUBBLING_PHASE: { value: 3, enumerable: true },
+};
+Object.defineProperties(EventP, properties$2);
+Object.defineProperties(EventP.prototype, properties$2);
 defineStringTag(EventP, "Event");
-const _TimeStamp = Symbol();
+/** @internal */ const _TimeStamp = Symbol();
 const _isTrusted = Symbol();
 const _passive = Symbol();
 const _dispatched = Symbol();
 const _preventDefaultCalled = Symbol();
 const _stopImmediatePropagationCalled = Symbol();
+/** @internal */
 class EventState {
     constructor() {
         this.type = "";
@@ -402,7 +409,7 @@ class EventState {
 _a$9 = _TimeStamp, _b$2 = _isTrusted, _c$1 = _passive, _d$1 = _dispatched, _e$1 = _preventDefaultCalled, _f$1 = _stopImmediatePropagationCalled;
 EventState[_a$9] = (new Date()).getTime();
 function createInnerEvent(target, type, eventInitDict, isTrusted = true) {
-    const event = new EventP(type, eventInitDict);
+    let event = new EventP(type, eventInitDict);
     event[state$g].target = target;
     event[state$g][_isTrusted] = isTrusted;
     return event;
@@ -410,6 +417,7 @@ function createInnerEvent(target, type, eventInitDict, isTrusted = true) {
 const EventE = g["EventTarget"] ? g["Event"] : EventP;
 
 var _a$8;
+/** @internal */
 const state$f = Symbol( /* "EventTargetState" */);
 class EventTargetP {
     constructor() {
@@ -441,9 +449,8 @@ class EventTargetP {
         if (!(event instanceof EventP)) {
             throw new TypeError("EventTarget.dispatchEvent: Argument 1 does not implement interface Event.");
         }
-        const s = event[state$g];
-        s.target = this;
-        s[_isTrusted] = false;
+        event[state$g].target = this;
+        Object.defineProperty(event[state$g], _isTrusted, { value: false, configurable: true, enumerable: true, writable: true });
         return fire.call(this[state$f], event);
     }
     removeEventListener(type, callback, options) {
@@ -458,7 +465,9 @@ class EventTargetP {
     get isPolyfill() { return { symbol: polyfill, hierarchy: ["EventTarget"] }; }
 }
 defineStringTag(EventTargetP, "EventTarget");
+/** @internal */
 const _executors = Symbol();
+/** @internal */
 class EventTargetState {
     constructor(target) {
         this[_a$8] = [];
@@ -473,15 +482,15 @@ function fire(event) {
     s.currentTarget = this.target;
     s.eventPhase = EventP.AT_TARGET;
     s[_dispatched] = true;
-    const onceIndexes = [];
+    let onceIndexes = [];
     for (let i = 0; i < this[_executors].length; ++i) {
-        const executor = this[_executors][i];
+        let executor = this[_executors][i];
         if (executor.type !== event.type)
             continue;
         s[_passive] = !!executor.options.passive;
         if (executor.options.once)
             onceIndexes.push(i);
-        const { callback: cb } = executor;
+        let { callback: cb } = executor;
         try {
             if (typeof cb === "function")
                 cb.call(this.target, event);
@@ -517,6 +526,7 @@ function reply(signal, executor) {
         console.error(e);
     }
 }
+/** @internal */
 class Executor {
     constructor(type, callback) {
         this.options = {};
@@ -556,6 +566,7 @@ function executeFn(cb, ev) {
 }
 const EventTargetE = g["EventTarget"] || EventTargetP;
 
+/** @internal */
 const state$e = Symbol( /* "CustomEventState" */);
 class CustomEventP extends EventP {
     constructor(type, eventInitDict) {
@@ -575,10 +586,12 @@ class CustomEventP extends EventP {
     get isPolyfill() { return { symbol: polyfill, hierarchy: ["CustomEvent", "Event"] }; }
 }
 defineStringTag(CustomEventP, "CustomEvent");
+/** @internal */
 class CustomEventState {
 }
 const CustomEventE = g["EventTarget"] ? g["CustomEvent"] : CustomEventP;
 
+/** @internal */
 const state$d = Symbol( /* "ProgressEventState" */);
 class ProgressEventP extends EventP {
     constructor(type, eventInitDict) {
@@ -597,6 +610,7 @@ class ProgressEventP extends EventP {
     get isPolyfill() { return { symbol: polyfill, hierarchy: ["ProgressEvent", "Event"] }; }
 }
 defineStringTag(ProgressEventP, "ProgressEvent");
+/** @internal */
 class ProgressEventState {
     constructor() {
         this.lengthComputable = false;
@@ -608,7 +622,7 @@ function getValue(val) {
     return typeof val === "function" ? val() : val;
 }
 function createInnerProgressEvent(target, type, { lengthComputable = false, loaded = 0, total = 0, } = {}) {
-    const event = new ProgressEventP(type);
+    let event = new ProgressEventP(type);
     event[state$d].lengthComputable = lengthComputable;
     event[state$d].loaded = loaded;
     event[state$d].total = total;
@@ -617,7 +631,7 @@ function createInnerProgressEvent(target, type, { lengthComputable = false, load
     return event;
 }
 function emitProcessEvent(target, type, loaded = 0, total = 0) {
-    const event = createInnerProgressEvent(target, type, {
+    let event = createInnerProgressEvent(target, type, {
         lengthComputable: () => { return getValue(total) > 0; },
         loaded,
         total,
@@ -626,6 +640,7 @@ function emitProcessEvent(target, type, loaded = 0, total = 0) {
 }
 const ProgressEventE = g["EventTarget"] ? g["ProgressEvent"] : ProgressEventP;
 
+/** @internal */
 const state$c = Symbol( /* "BlobState" */);
 class BlobP {
     constructor(blobParts = [], options) {
@@ -651,7 +666,7 @@ class BlobP {
         this[state$c] = new BlobState(concat(chunks));
         const that = this[state$c];
         that.size = that[_u8array].length;
-        const rawType = (options === null || options === void 0 ? void 0 : options.type) || "";
+        let rawType = (options === null || options === void 0 ? void 0 : options.type) || "";
         that.type = /[^\u0020-\u007E]/.test(rawType) ? "" : rawType.toLowerCase();
     }
     get size() { return this[state$c].size; }
@@ -663,27 +678,35 @@ class BlobP {
         return Promise.resolve(clone(this[state$c][_u8array].buffer));
     }
     slice(start, end, contentType) {
-        const sliced = this[state$c][_u8array].slice(start !== null && start !== void 0 ? start : 0, end !== null && end !== void 0 ? end : this[state$c][_u8array].length);
+        let sliced = this[state$c][_u8array].slice(start !== null && start !== void 0 ? start : 0, end !== null && end !== void 0 ? end : this[state$c][_u8array].length);
         return new BlobP([sliced], { type: contentType !== null && contentType !== void 0 ? contentType : "" });
     }
     stream() {
         throw new ReferenceError("ReadableStream is not defined");
     }
     text() {
-        const decoder = new TextDecoderP();
+        let decoder = new TextDecoderP();
         return Promise.resolve(decoder.decode(this[state$c][_u8array]));
     }
     toString() { return "[object Blob]"; }
     get isPolyfill() { return { symbol: polyfill, hierarchy: ["Blob"] }; }
 }
 defineStringTag(BlobP, "Blob");
+/** @internal */
 const _u8array = Symbol();
+/** @internal */
 class BlobState {
     constructor(buffer) {
         this.size = 0;
         this.type = "";
         this[_u8array] = buffer;
     }
+    toUint8Array() {
+        return this[_u8array];
+    }
+    toArrayBuffer() {
+        return this[_u8array].buffer;
+    }
 }
 function u8array2base64(input) {
     let byteToCharMap = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
@@ -714,14 +737,14 @@ function convert$1(buf) {
         : new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
 }
 function clone(buf) {
-    const sourceArray = convert$1(buf);
-    const cloneArray = new Uint8Array(new ArrayBuffer(sourceArray.byteLength));
+    let sourceArray = convert$1(buf);
+    let cloneArray = new Uint8Array(new ArrayBuffer(sourceArray.byteLength));
     cloneArray.set(sourceArray);
     return cloneArray;
 }
 function concat(chunks) {
-    const totalByteLength = chunks.reduce((acc, cur) => acc + cur.byteLength, 0);
-    const result = new Uint8Array(totalByteLength);
+    let totalByteLength = chunks.reduce((acc, cur) => acc + cur.byteLength, 0);
+    let result = new Uint8Array(totalByteLength);
     chunks.reduce((offset, chunk) => {
         result.set(chunk, offset);
         return offset + chunk.byteLength;
@@ -730,6 +753,7 @@ function concat(chunks) {
 }
 const BlobE = g["Blob"] || BlobP;
 
+/** @internal */
 const state$b = Symbol( /* "FileState" */);
 class FileP extends BlobP {
     constructor(fileBits, fileName, options) {
@@ -745,6 +769,7 @@ class FileP extends BlobP {
     get isPolyfill() { return { symbol: polyfill, hierarchy: ["File", "Blob"] }; }
 }
 defineStringTag(FileP, "File");
+/** @internal */
 class FileState {
     constructor() {
         this.lastModified = 0;
@@ -754,13 +779,11 @@ class FileState {
 const FileE = g["Blob"] ? g["File"] : FileP;
 
 var _a$7;
+/** @internal */
 const state$a = Symbol( /* "FileReaderState" */);
 class FileReaderP extends EventTargetP {
     constructor() {
         super();
-        this.EMPTY = 0;
-        this.LOADING = 1;
-        this.DONE = 2;
         this[state$a] = new FileReaderState(this);
     }
     get readyState() { return this[state$a].readyState; }
@@ -775,12 +798,12 @@ class FileReaderP extends EventTargetP {
     }
     readAsArrayBuffer(blob) {
         read$1.call(this[state$a], "readAsArrayBuffer", blob, () => {
-            this[state$a].result = blob[state$c][_u8array].buffer.slice(0);
+            this[state$a].result = blob[state$c].toArrayBuffer().slice(0);
         });
     }
     readAsBinaryString(blob) {
         read$1.call(this[state$a], "readAsBinaryString", blob, () => {
-            this[state$a].result = blob[state$c][_u8array].reduce((acc, cur) => {
+            this[state$a].result = blob[state$c].toUint8Array().reduce((acc, cur) => {
                 acc += String.fromCharCode(cur);
                 return acc;
             }, "");
@@ -788,12 +811,12 @@ class FileReaderP extends EventTargetP {
     }
     readAsDataURL(blob) {
         read$1.call(this[state$a], "readAsDataURL", blob, () => {
-            this[state$a].result = "data:" + blob.type + ";base64," + u8array2base64(blob[state$c][_u8array]);
+            this[state$a].result = "data:" + blob.type + ";base64," + u8array2base64(blob[state$c].toUint8Array());
         });
     }
     readAsText(blob, encoding) {
         read$1.call(this[state$a], "readAsText", blob, () => {
-            this[state$a].result = (new TextDecoderP(encoding)).decode(blob[state$c][_u8array]);
+            this[state$a].result = (new TextDecoderP(encoding)).decode(blob[state$c].toUint8Array());
         });
     }
     get onabort() { return this[state$a].onabort; }
@@ -811,11 +834,17 @@ class FileReaderP extends EventTargetP {
     toString() { return "[object FileReader]"; }
     get isPolyfill() { return { symbol: polyfill, hierarchy: ["FileReader", "EventTarget"] }; }
 }
-FileReaderP.EMPTY = 0;
-FileReaderP.LOADING = 1;
-FileReaderP.DONE = 2;
+const properties$1 = {
+    EMPTY: { value: 0, enumerable: true },
+    LOADING: { value: 1, enumerable: true },
+    DONE: { value: 2, enumerable: true },
+};
+Object.defineProperties(FileReaderP, properties$1);
+Object.defineProperties(FileReaderP.prototype, properties$1);
 defineStringTag(FileReaderP, "FileReader");
+/** @internal */
 const _handlers$3 = Symbol();
+/** @internal */
 class FileReaderState {
     constructor(target) {
         this.readyState = FileReaderP.EMPTY;
@@ -874,6 +903,7 @@ function getHandlers$3() {
 const FileReaderE = g["Blob"] ? g["FileReader"] : FileReaderP;
 
 var _a$6;
+/** @internal */
 const state$9 = Symbol( /* "FormDataState" */);
 class FormDataP {
     constructor(form, submitter) {
@@ -889,7 +919,7 @@ class FormDataP {
         this[state$9][_formData].push(normalizeArgs(name, value, filename));
     }
     delete(name) {
-        const result = [];
+        let result = [];
         name = String(name);
         each(this[state$9][_formData], entry => {
             entry[0] !== name && result.push(entry);
@@ -897,7 +927,7 @@ class FormDataP {
         this[state$9][_formData] = result;
     }
     get(name) {
-        const entries = this[state$9][_formData];
+        let entries = this[state$9][_formData];
         name = String(name);
         for (let i = 0; i < entries.length; ++i) {
             if (entries[i][0] === name) {
@@ -907,7 +937,7 @@ class FormDataP {
         return null;
     }
     getAll(name) {
-        const result = [];
+        let result = [];
         name = String(name);
         each(this[state$9][_formData], data => {
             data[0] === name && result.push(data[1]);
@@ -925,8 +955,8 @@ class FormDataP {
     }
     set(name, value, filename) {
         name = String(name);
-        const result = [];
-        const args = normalizeArgs(name, value, filename);
+        let result = [];
+        let args = normalizeArgs(name, value, filename);
         let replace = true;
         each(this[state$9][_formData], data => {
             data[0] === name
@@ -937,7 +967,7 @@ class FormDataP {
         this[state$9][_formData] = result;
     }
     forEach(callbackfn, thisArg) {
-        for (const [name, value] of this) {
+        for (let [name, value] of this) {
             callbackfn.call(thisArg, value, name, thisArg);
         }
     }
@@ -957,7 +987,9 @@ class FormDataP {
     get isPolyfill() { return { symbol: polyfill, hierarchy: ["FormData"] }; }
 }
 defineStringTag(FormDataP, "FormData");
+/** @internal */
 const _formData = Symbol();
+/** @internal */
 class FormDataState {
     constructor() {
         this[_a$6] = [];
@@ -1088,6 +1120,7 @@ function createFormDataFromBody(body, errMsg = "Failed to fetch") {
 const FormDataE = g["FormData"] || FormDataP;
 
 var _a$5;
+/** @internal */
 const state$8 = Symbol( /* "URLSearchParamsState" */);
 class URLSearchParamsP {
     constructor(init) {
@@ -1187,7 +1220,9 @@ class URLSearchParamsP {
     get isPolyfill() { return { symbol: polyfill, hierarchy: ["URLSearchParams"] }; }
 }
 defineStringTag(URLSearchParamsP, "URLSearchParams");
+/** @internal */
 const _urlspDict = Symbol();
+/** @internal */
 class URLSearchParamsState {
     constructor() {
         this[_a$5] = {};
@@ -1210,7 +1245,7 @@ function parseToDict(search) {
             }
         }
         else {
-            for (const key in search) {
+            for (let key in search) {
                 if (search.hasOwnProperty(key)) {
                     appendTo(dict, key, search[key]);
                 }
@@ -1268,7 +1303,7 @@ function hasOwnProperty(obj, prop) {
     return Object.prototype.hasOwnProperty.call(obj, prop);
 }
 function flatCb(acc, cur) {
-    for (const item of cur) {
+    for (let item of cur) {
         acc.push(item);
     }
     return acc;
@@ -1276,34 +1311,35 @@ function flatCb(acc, cur) {
 const URLSearchParamsE = g["URLSearchParams"] || URLSearchParamsP;
 
 var _a$4;
+/** @internal */
 const state$7 = Symbol( /* "AbortSignalState" */);
 class AbortSignalP extends EventTargetP {
     static abort(reason) {
-        const signal = createAbortSignalP();
+        let signal = createAbortSignalP();
         abort.call(signal[state$7], reason, false);
         return signal;
     }
     static any(signals) {
-        const signal = createAbortSignalP();
-        const abortedSignal = signals.find(x => x.aborted);
+        let signal = createAbortSignalP();
+        let abortedSignal = signals.find(x => x.aborted);
         if (abortedSignal) {
             abort.call(signal[state$7], abortedSignal.reason, false);
         }
         else {
             function abortFn(ev) {
-                for (const sig of signals) {
+                for (let sig of signals) {
                     sig.removeEventListener("abort", abortFn);
                 }
                 abort.call(signal[state$7], this.reason, true, ev.isTrusted);
             }
-            for (const sig of signals) {
+            for (let sig of signals) {
                 sig.addEventListener("abort", abortFn);
             }
         }
         return signal;
     }
     static timeout(milliseconds) {
-        const signal = createAbortSignalP();
+        let signal = createAbortSignalP();
         setTimeout(() => {
             abort.call(signal[state$7], new MPException("signal timed out", "TimeoutError"));
         }, milliseconds);
@@ -1332,7 +1368,9 @@ class AbortSignalP extends EventTargetP {
     get isPolyfill() { return { symbol: polyfill, hierarchy: ["AbortSignal", "EventTarget"] }; }
 }
 defineStringTag(AbortSignalP, "AbortSignal");
+/** @internal */
 const _handlers$2 = Symbol();
+/** @internal */
 class AbortSignalState {
     constructor(target) {
         this.aborted = false;
@@ -1348,7 +1386,7 @@ function abort(reason, notify = true, isTrusted = true) {
         this.aborted = true;
         this.reason = reason !== null && reason !== void 0 ? reason : (new MPException("signal is aborted without reason", "AbortError"));
         if (notify) {
-            const evt = createInnerEvent(this.target, "abort", undefined, isTrusted);
+            let evt = createInnerEvent(this.target, "abort", undefined, isTrusted);
             fire.call(this.target[state$f], evt);
         }
     }
@@ -1359,13 +1397,14 @@ function getHandlers$2() {
     };
 }
 function createAbortSignalP() {
-    const instance = Object.create(AbortSignalP.prototype);
+    let instance = Object.create(AbortSignalP.prototype);
     instance[state$f] = new EventTargetState(instance);
     instance[state$7] = new AbortSignalState(instance);
     return instance;
 }
 const AbortSignalE = g["AbortSignal"] || AbortSignalP;
 
+/** @internal */
 const state$6 = Symbol( /* "AbortControllerState" */);
 class AbortControllerP {
     constructor() {
@@ -1379,6 +1418,7 @@ class AbortControllerP {
     get isPolyfill() { return { symbol: polyfill, hierarchy: ["AbortController"] }; }
 }
 defineStringTag(AbortControllerP, "AbortController");
+/** @internal */
 class AbortControllerState {
     constructor() {
         this.signal = createAbortSignalP();
@@ -1387,6 +1427,7 @@ class AbortControllerState {
 const AbortControllerE = g["AbortController"] || AbortControllerP;
 
 var _a$3;
+/** @internal */
 const state$5 = Symbol( /* "XMLHttpRequestEventTargetState" */);
 class XMLHttpRequestEventTargetP extends EventTargetP {
     constructor() {
@@ -1414,7 +1455,9 @@ class XMLHttpRequestEventTargetP extends EventTargetP {
     get isPolyfill() { return { symbol: polyfill, hierarchy: ["XMLHttpRequestEventTarget", "EventTarget"] }; }
 }
 defineStringTag(XMLHttpRequestEventTargetP, "XMLHttpRequestEventTarget");
+/** @internal */
 const _handlers$1 = Symbol();
+/** @internal */
 class XMLHttpRequestEventTargetState {
     /**
      * @param _target XMLHttpRequestEventTargetP
@@ -1462,7 +1505,7 @@ class XMLHttpRequestUploadP extends XMLHttpRequestEventTargetP {
 }
 defineStringTag(XMLHttpRequestUploadP, "XMLHttpRequestUpload");
 function createXMLHttpRequestUploadP() {
-    const instance = Object.create(XMLHttpRequestUploadP.prototype);
+    let instance = Object.create(XMLHttpRequestUploadP.prototype);
     instance[state$f] = new EventTargetState(instance);
     instance[state$5] = new XMLHttpRequestEventTargetState(instance);
     return instance;
@@ -1522,15 +1565,11 @@ const request = mp ? mp.request : function errorRequest(options) {
 };
 
 var _a$2, _b$1, _c, _d, _e, _f, _g, _h, _j, _k;
+/** @internal */
 const state$4 = Symbol( /* "XMLHttpRequestState" */);
 class XMLHttpRequestP extends XMLHttpRequestEventTargetP {
     constructor() {
         super();
-        this.UNSENT = 0;
-        this.OPENED = 1;
-        this.HEADERS_RECEIVED = 2;
-        this.LOADING = 3;
-        this.DONE = 4;
         this[state$4] = new XMLHttpRequestState(this);
     }
     get readyState() { return this[state$4].readyState; }
@@ -1548,7 +1587,13 @@ class XMLHttpRequestP extends XMLHttpRequestEventTargetP {
     }
     get timeout() { return this[state$4].timeout; }
     set timeout(value) { this[state$4].timeout = value; }
-    get upload() { return this[state$4].upload; }
+    get upload() {
+        const that = this[state$4];
+        if (!that.upload) {
+            that.upload = createXMLHttpRequestUploadP();
+        }
+        return that.upload;
+    }
     get withCredentials() { return this[state$4].withCredentials; }
     set withCredentials(value) { this[state$4].withCredentials = value; }
     abort() {
@@ -1563,7 +1608,7 @@ class XMLHttpRequestP extends XMLHttpRequestEventTargetP {
         var _l, _m;
         if (!this[state$4][_responseHeaders])
             return null;
-        const nameKey = name.toLowerCase();
+        let nameKey = name.toLowerCase();
         return (_m = (_l = objectEntries(this[state$4][_responseHeaders] || {}).find(x => x[0].toLowerCase() === nameKey)) === null || _l === void 0 ? void 0 : _l[1]) !== null && _m !== void 0 ? _m : null;
     }
     open(...args) {
@@ -1579,10 +1624,10 @@ class XMLHttpRequestP extends XMLHttpRequestEventTargetP {
         that[_method] = normalizeMethod(method);
         that[_requestURL] = String(url);
         if (username !== null || password !== null) {
-            const _username = String(username !== null && username !== void 0 ? username : "");
-            const _password = String(password !== null && password !== void 0 ? password : "");
+            let _username = String(username !== null && username !== void 0 ? username : "");
+            let _password = String(password !== null && password !== void 0 ? password : "");
             if (_username.length > 0 || _password.length > 0) {
-                const auth = `Basic ${u8array2base64((new TextEncoderP()).encode(_username + ":" + _password))}`;
+                let auth = `Basic ${u8array2base64((new TextEncoderP()).encode(_username + ":" + _password))}`;
                 this.setRequestHeader("Authorization", auth);
             }
         }
@@ -1591,7 +1636,7 @@ class XMLHttpRequestP extends XMLHttpRequestEventTargetP {
     }
     overrideMimeType(mime) {
         if (this[state$4][_inAfterOpenBeforeSend]) {
-            console.warn(`XMLHttpRequest.overrideMimeType(${mime}) is not implemented: The method will have no effect on response parsing.`);
+            console.warn(`XMLHttpRequest.overrideMimeType('${mime}') is not implemented: The method will have no effect on response parsing.`);
         }
     }
     send(body) {
@@ -1600,13 +1645,14 @@ class XMLHttpRequestP extends XMLHttpRequestEventTargetP {
             throw new MPException("Failed to execute 'send' on 'XMLHttpRequest': The object's state must be OPENED.", "InvalidStateError");
         }
         that[_inAfterOpenBeforeSend] = false;
-        const allowsRequestBody = ["GET", "HEAD"].indexOf(that[_method]) === -1;
+        const allowsRequestBody = that[_method] !== "GET" && that[_method] !== "HEAD";
         const processHeaders = allowsRequestBody && Object.keys(that[_requestHeaders]).map(x => x.toLowerCase()).indexOf("content-type") === -1;
-        const processContentLength = that.upload[state$f][_executors].length > 0;
-        let headers = Object.assign({}, that[_requestHeaders]);
-        let contentLength = 0;
+        const upload = that.upload;
+        const processContentLength = upload && upload[state$f][_executors].length > 0;
+        let headers = processHeaders ? Object.assign({}, that[_requestHeaders]) : that[_requestHeaders];
+        let contentLength = zero;
         let data = convert(body, processHeaders ? v => { assignRequestHeader(headers, "Content-Type", v); } : void 0, processContentLength ? v => { contentLength = v; } : void 0);
-        that[_requestTask] = request({
+        let options = {
             url: that[_requestURL],
             method: that[_method],
             header: headers,
@@ -1616,26 +1662,31 @@ class XMLHttpRequestP extends XMLHttpRequestEventTargetP {
             success: requestSuccess.bind(that),
             fail: requestFail.bind(that),
             complete: requestComplete.bind(that),
-        });
+        };
+        if (that.withCredentials) {
+            options.withCredentials = true;
+            options.enableCookie = true;
+        }
+        that[_requestTask] = request(options);
         emitProcessEvent(this, "loadstart");
         if (processContentLength) {
             const hasRequestBody = allowsRequestBody && (typeof data === "string" ? data.length > 0 : data.byteLength > 0);
             if (hasRequestBody) {
-                emitProcessEvent(that.upload, "loadstart", 0, contentLength);
+                emitProcessEvent(upload, "loadstart", 0, contentLength);
             }
             setTimeout(() => {
                 const _aborted = that[_inAfterOpenBeforeSend] || that.readyState !== XMLHttpRequestP.OPENED;
                 const _contentLength = _aborted ? 0 : contentLength;
                 if (_aborted) {
-                    emitProcessEvent(that.upload, "abort");
+                    emitProcessEvent(upload, "abort");
                 }
                 else {
                     if (hasRequestBody) {
-                        emitProcessEvent(that.upload, "load", _contentLength, _contentLength);
+                        emitProcessEvent(upload, "load", _contentLength, _contentLength);
                     }
                 }
                 if (_aborted || hasRequestBody) {
-                    emitProcessEvent(that.upload, "loadend", _contentLength, _contentLength);
+                    emitProcessEvent(upload, "loadend", _contentLength, _contentLength);
                 }
             });
         }
@@ -1652,22 +1703,27 @@ class XMLHttpRequestP extends XMLHttpRequestEventTargetP {
     toString() { return "[object XMLHttpRequest]"; }
     get isPolyfill() { return { symbol: polyfill, hierarchy: ["XMLHttpRequest", "XMLHttpRequestEventTarget", "EventTarget"] }; }
 }
-XMLHttpRequestP.UNSENT = 0;
-XMLHttpRequestP.OPENED = 1;
-XMLHttpRequestP.HEADERS_RECEIVED = 2;
-XMLHttpRequestP.LOADING = 3;
-XMLHttpRequestP.DONE = 4;
+const properties = {
+    UNSENT: { value: 0, enumerable: true },
+    OPENED: { value: 1, enumerable: true },
+    HEADERS_RECEIVED: { value: 2, enumerable: true },
+    LOADING: { value: 3, enumerable: true },
+    DONE: { value: 4, enumerable: true },
+};
+Object.defineProperties(XMLHttpRequestP, properties);
+Object.defineProperties(XMLHttpRequestP.prototype, properties);
 defineStringTag(XMLHttpRequestP, "XMLHttpRequest");
-const _handlers = Symbol();
-const _inAfterOpenBeforeSend = Symbol();
-const _resetPending = Symbol();
-const _timeoutId = Symbol();
-const _requestURL = Symbol();
-const _method = Symbol();
-const _requestHeaders = Symbol();
+/** @internal */ const _handlers = Symbol();
+/** @internal */ const _inAfterOpenBeforeSend = Symbol();
+/** @internal */ const _resetPending = Symbol();
+/** @internal */ const _timeoutId = Symbol();
+/** @internal */ const _requestURL = Symbol();
+/** @internal */ const _method = Symbol();
+/** @internal */ const _requestHeaders = Symbol();
 const _responseHeaders = Symbol();
-const _responseContentLength = Symbol();
-const _requestTask = Symbol();
+/** @internal */ const _responseContentLength = Symbol();
+/** @internal */ const _requestTask = Symbol();
+/** @internal */
 class XMLHttpRequestState {
     constructor(target) {
         this.readyState = XMLHttpRequestP.UNSENT;
@@ -1687,10 +1743,9 @@ class XMLHttpRequestState {
         this[_f] = "GET";
         this[_g] = { Accept: "*/*" };
         this[_h] = null;
-        this[_j] = 0;
+        this[_j] = zero;
         this[_k] = null;
         this.target = target;
-        this.upload = createXMLHttpRequestUploadP();
     }
 }
 _a$2 = _handlers, _b$1 = _inAfterOpenBeforeSend, _c = _resetPending, _d = _timeoutId, _e = _requestURL, _f = _method, _g = _requestHeaders, _h = _responseHeaders, _j = _responseContentLength, _k = _requestTask;
@@ -1698,7 +1753,7 @@ function requestSuccess({ statusCode, header, data }) {
     this.responseURL = this[_requestURL];
     this.status = statusCode;
     this[_responseHeaders] = header;
-    const lengthStr = this.target.getResponseHeader("Content-Length");
+    let lengthStr = this.target.getResponseHeader("Content-Length");
     this[_responseContentLength] = () => { return lengthStr ? parseInt(lengthStr) : 0; };
     if (this.readyState === XMLHttpRequestP.OPENED) {
         setReadyStateAndNotify.call(this, XMLHttpRequestP.HEADERS_RECEIVED);
@@ -1800,7 +1855,7 @@ function resetXHR() {
     this.statusText = "";
     this[_requestHeaders] = {};
     this[_responseHeaders] = null;
-    this[_responseContentLength] = 0;
+    this[_responseContentLength] = zero;
 }
 function resetRequestTimeout() {
     if (this[_timeoutId]) {
@@ -1809,10 +1864,10 @@ function resetRequestTimeout() {
     }
 }
 function setReadyStateAndNotify(value) {
-    const hasChanged = value !== this.readyState;
+    let hasChanged = value !== this.readyState;
     this.readyState = value;
     if (hasChanged) {
-        const evt = createInnerEvent(this.target, "readystatechange");
+        let evt = createInnerEvent(this.target, "readystatechange");
         fire.call(this.target[state$f], evt);
     }
 }
@@ -1831,8 +1886,8 @@ function normalizeDataType(responseType) {
     return (responseType === "blob" || responseType === "arraybuffer") ? "arraybuffer" : "text";
 }
 function assignRequestHeader(headers, name, value) {
-    const nameKey = name.toLowerCase();
-    for (const key of Object.keys(headers)) {
+    let nameKey = name.toLowerCase();
+    for (let key of Object.keys(headers)) {
         if (key.toLowerCase() === nameKey) {
             headers[key] = value;
             return;
@@ -1870,14 +1925,14 @@ function convert(body, setContentType, setContentLength) {
         result = body.buffer.slice(body.byteOffset, body.byteOffset + body.byteLength);
     }
     else if (isPolyfillType("Blob", body)) {
-        result = body[state$c][_u8array].buffer.slice(0);
+        result = body[state$c].toArrayBuffer().slice(0);
         if (setContentType && body.type) {
             setContentType(body.type);
         }
     }
     else if (isPolyfillType("FormData", body)) {
-        const blob = body[state$9].toBlob();
-        result = blob[state$c][_u8array].buffer;
+        let blob = body[state$9].toBlob();
+        result = blob[state$c].toArrayBuffer();
         if (setContentType) {
             setContentType(blob.type);
         }
@@ -1889,12 +1944,9 @@ function convert(body, setContentType, setContentLength) {
         result = String(body);
     }
     if (setContentLength) {
-        if (typeof result === "string") {
-            setContentLength(() => { return encode(result).byteLength; });
-        }
-        else {
-            setContentLength(result.byteLength);
-        }
+        setContentLength(() => {
+            return (typeof result === "string" ? encode(result) : result).byteLength;
+        });
     }
     return result;
 }
@@ -1916,6 +1968,7 @@ function convertBack(type, data) {
         return temp;
     }
 }
+const zero = () => 0;
 const statusMessages = {
     100: "Continue",
     101: "Switching Protocols",
@@ -1985,6 +2038,7 @@ function statusTextMap(val) {
 const XMLHttpRequestE = (typeof XMLHttpRequest !== "undefined" && XMLHttpRequest) || XMLHttpRequestP;
 
 var _a$1, _b;
+/** @internal */
 const state$3 = Symbol( /* "BodyState" */);
 class BodyP {
     constructor() {
@@ -2031,6 +2085,7 @@ class BodyP {
 defineStringTag(BodyP, "Body");
 const _name = Symbol();
 const _body = Symbol();
+/** @internal */
 class BodyState {
     constructor() {
         this.bodyUsed = false;
@@ -2091,6 +2146,7 @@ function consumed(kind) {
 }
 
 var _a;
+/** @internal */
 const state$2 = Symbol( /* "HeadersState" */);
 class HeadersP {
     constructor(init) {
@@ -2166,7 +2222,9 @@ class HeadersP {
     get isPolyfill() { return { symbol: polyfill, hierarchy: ["Headers"] }; }
 }
 defineStringTag(HeadersP, "Headers");
+/** @internal */
 const _headersMap = Symbol();
+/** @internal */
 class HeadersState {
     constructor() {
         this[_a] = new Map();
@@ -2215,6 +2273,7 @@ function parseHeaders(rawHeaders) {
 }
 const HeadersE = g["Headers"] || HeadersP;
 
+/** @internal */
 const state$1 = Symbol( /* "RequestState" */);
 class RequestP extends BodyP {
     constructor(input, init) {
@@ -2234,7 +2293,10 @@ class RequestP extends BodyP {
             }
             that.method = input.method;
             that.mode = input.mode;
-            that.signal = input.signal;
+            let inputSignal = input[state$1].signal;
+            if (inputSignal) {
+                that.signal = inputSignal;
+            }
             that.url = input.url;
             let _input = input;
             if (!body && _input[state$3][_body] !== null) {
@@ -2310,9 +2372,10 @@ class RequestP extends BodyP {
         return new RequestP(this, { body: (_a = this[state$3][_body]) !== null && _a !== void 0 ? _a : null });
     }
     toString() { return "[object Request]"; }
-    get isPolyfill() { return { symbol: polyfill, hierarchy: ["Request"] }; }
+    get isPolyfill() { return { symbol: polyfill, hierarchy: ["Request", "Body"] }; }
 }
 defineStringTag(RequestP, "Request");
+/** @internal */
 class RequestState {
     constructor() {
         this.cache = "default";
@@ -2330,6 +2393,7 @@ class RequestState {
 }
 const RequestE = g["Request"] || RequestP;
 
+/** @internal */
 const state = Symbol( /* "ResponseState" */);
 class ResponseP extends BodyP {
     constructor(body, init) {
@@ -2364,7 +2428,7 @@ class ResponseP extends BodyP {
     get type() { return this[state].type; }
     get url() { return this[state].url; }
     clone() {
-        const response = new ResponseP(this[state$3][_body], {
+        let response = new ResponseP(this[state$3][_body], {
             headers: new HeadersP(this.headers),
             status: this.status,
             statusText: this.statusText,
@@ -2376,7 +2440,7 @@ class ResponseP extends BodyP {
         return new Response(JSON.stringify(data), init);
     }
     static error() {
-        const response = new ResponseP(null, { status: 200, statusText: "" });
+        let response = new ResponseP(null, { status: 200, statusText: "" });
         response[state].ok = false;
         response[state].status = 0;
         response[state].type = "error";
@@ -2389,9 +2453,10 @@ class ResponseP extends BodyP {
         return new Response(null, { status, headers: { location: String(url) } });
     }
     toString() { return "[object Response]"; }
-    get isPolyfill() { return { symbol: polyfill, hierarchy: ["Response"] }; }
+    get isPolyfill() { return { symbol: polyfill, hierarchy: ["Response", "Body"] }; }
 }
 defineStringTag(ResponseP, "Response");
+/** @internal */
 class ResponseState {
     constructor() {
         this.ok = true;
@@ -2409,9 +2474,10 @@ function fetchP(input, init) {
         throw new TypeError("fetch is not a constructor");
     }
     return new Promise(function (resolve, reject) {
-        let request = new RequestP(input, init);
-        if (request.signal && request.signal.aborted) {
-            return reject(request.signal.reason);
+        const request = new RequestP(input, init);
+        const signal = request[state$1].signal;
+        if (signal && signal.aborted) {
+            return reject(signal.reason);
         }
         let xhr = new XMLHttpRequestE();
         xhr.onload = function () {
@@ -2421,7 +2487,7 @@ function fetchP(input, init) {
                 statusText: xhr.statusText,
             };
             setTimeout(() => {
-                const response = new ResponseP(xhr.response, options);
+                let response = new ResponseP(xhr.response, options);
                 response[state].url = xhr.responseURL;
                 resolve(response);
             });
@@ -2448,7 +2514,7 @@ function fetchP(input, init) {
         else if (request.credentials === "omit") {
             xhr.withCredentials = false;
         }
-        if (init && isObjectHeaders(init.headers)) {
+        if (init && typeof init === "object" && isObjectHeaders(init.headers)) {
             let headers = init.headers;
             let names = [];
             objectEntries(headers).forEach(([name, value]) => {
@@ -2466,13 +2532,13 @@ function fetchP(input, init) {
                 xhr.setRequestHeader(name, value);
             });
         }
-        if (request.signal) {
+        if (signal) {
             const abortXHR = () => { xhr.abort(); };
-            request.signal.addEventListener("abort", abortXHR);
+            signal.addEventListener("abort", abortXHR);
             xhr.onreadystatechange = function () {
                 // DONE (success or failure)
                 if (xhr.readyState === 4) {
-                    request.signal.removeEventListener("abort", abortXHR);
+                    signal.removeEventListener("abort", abortXHR);
                 }
             };
         }