mphttpx 1.0.1 → 1.0.3

package/dist/index.cjs.js

@@ -1,7 +1,6 @@
 'use strict';
 
 const polyfill = Symbol("isPolyfill");
-const state$9 = Symbol("INTERNAL_STATE");
 /* eslint-disable no-prototype-builtins */
 const g = (typeof globalThis !== "undefined" && globalThis) ||
     (typeof self !== "undefined" && self) ||
@@ -21,13 +20,13 @@ function isPolyfillType(name, value) {
         && value.isPolyfill.symbol === polyfill
         && "hierarchy" in value.isPolyfill
         && Array.isArray(value.isPolyfill.hierarchy)
-        && value.isPolyfill.hierarchy.includes(name);
+        && value.isPolyfill.hierarchy.indexOf(name) > -1;
 }
 class MPException extends Error {
     constructor(message, name) {
         super();
-        this.message = message ?? this.message;
-        this.name = name ?? this.name;
+        this.message = message !== null && message !== void 0 ? message : this.message;
+        this.name = name !== null && name !== void 0 ? name : this.name;
     }
 }
 function defineStringTag(targetFunc, stringTag) {
@@ -36,6 +35,12 @@ function defineStringTag(targetFunc, stringTag) {
         value: stringTag,
     });
 }
+function objectValues(obj) {
+    return Object.keys(obj).map(key => obj[key]);
+}
+function objectEntries(obj) {
+    return Object.keys(obj).map(key => [key, obj[key]]);
+}
 
 class TextEncoderP {
     get encoding() { return "utf-8"; }
@@ -136,21 +141,22 @@ function encodeText(input, destination) {
 }
 const TextEncoderE = g["TextEncoder"] || TextEncoderP;
 
-const state$8 = Symbol("TextDecoderState");
+var _a$a, _b$3;
+const state$h = Symbol( /* "TextDecoderState" */);
 class TextDecoderP {
     constructor(utfLabel = "utf-8", { fatal = false, ignoreBOM = false } = {}) {
-        if (!UTF8Labels.includes(utfLabel.toLowerCase())) {
+        if (UTF8Labels.indexOf(utfLabel.toLowerCase()) === -1) {
             throw new RangeError("TextDecoder: The encoding label provided ('" + utfLabel + "') is invalid.");
         }
-        this[state$8] = new TextDecoderState();
-        this[state$8].fatal = fatal;
-        this[state$8].ignoreBOM = ignoreBOM;
+        this[state$h] = new TextDecoderState();
+        this[state$h].fatal = fatal;
+        this[state$h].ignoreBOM = ignoreBOM;
     }
-    [state$8];
     get encoding() { return "utf-8"; }
-    get fatal() { return this[state$8].fatal; }
-    get ignoreBOM() { return this[state$8].ignoreBOM; }
+    get fatal() { return this[state$h].fatal; }
+    get ignoreBOM() { return this[state$h].ignoreBOM; }
     decode(buffer, { stream = false } = {}) {
+        const that = this[state$h];
         let buf;
         if (typeof buffer !== "undefined") {
             if (buffer instanceof Uint8Array) {
@@ -164,28 +170,28 @@ class TextDecoderP {
             }
         }
         else {
-            if (this[state$8]._partial.length > 0) {
+            if (that[_partial].length > 0) {
                 if (this.fatal) {
                     throw new TypeError("TextDecoder: Incomplete UTF-8 sequence.");
                 }
                 else {
-                    this[state$8]._partial = [];
+                    that[_partial] = [];
                 }
             }
             return "";
         }
-        if (!this[state$8]._bomSeen && this.ignoreBOM && buf.length >= 3) {
+        if (!that[_bomSeen] && this.ignoreBOM && buf.length >= 3) {
             if (buf[0] === 0xef && buf[1] === 0xbb && buf[2] === 0xbf) {
                 buf = buf.subarray(3);
-                this[state$8]._bomSeen = true;
+                that[_bomSeen] = true;
             }
         }
-        if (this[state$8]._partial.length > 0) {
-            let merged = new Uint8Array(this[state$8]._partial.length + buf.length);
-            merged.set(this[state$8]._partial, 0);
-            merged.set(buf, this[state$8]._partial.length);
+        if (that[_partial].length > 0) {
+            let merged = new Uint8Array(that[_partial].length + buf.length);
+            merged.set(that[_partial], 0);
+            merged.set(buf, that[_partial].length);
             buf = merged;
-            this[state$8]._partial = [];
+            that[_partial] = [];
         }
         let end = buf.length;
         let res = [];
@@ -202,7 +208,7 @@ class TextDecoderP {
                 }
                 i--;
             }
-            this[state$8]._partial = Array.from(buf.slice(end)); // save tail
+            that[_partial] = Array.from(buf.slice(end)); // save tail
             buf = buf.slice(0, end);
         }
         let i = 0;
@@ -279,128 +285,155 @@ class TextDecoderP {
     get isPolyfill() { return { symbol: polyfill, hierarchy: ["TextDecoder"] }; }
 }
 defineStringTag(TextDecoderP, "TextDecoder");
+const _bomSeen = Symbol();
+const _partial = Symbol();
 class TextDecoderState {
-    fatal = false;
-    ignoreBOM = false;
-    _bomSeen = false;
-    _partial = [];
+    constructor() {
+        this.fatal = false;
+        this.ignoreBOM = false;
+        this[_a$a] = false;
+        this[_b$3] = [];
+    }
 }
+_a$a = _bomSeen, _b$3 = _partial;
 const UTF8Labels = ["utf-8", "utf8", "unicode-1-1-utf-8"];
 function getBytesPerSequence(byte) {
     return (byte > 0xEF) ? 4 : (byte > 0xDF) ? 3 : (byte > 0xBF) ? 2 : 1;
 }
 const TextDecoderE = g["TextDecoder"] || TextDecoderP;
 
+var _a$9, _b$2, _c$1, _d$1, _e$1, _f$1;
+const state$g = Symbol( /* "EventState" */);
 class EventP {
-    static NONE = 0;
-    static CAPTURING_PHASE = 1;
-    static AT_TARGET = 2;
-    static BUBBLING_PHASE = 3;
     constructor(type, eventInitDict) {
-        this[state$9] = new EventState();
-        this[state$9].type = String(type);
-        this[state$9].bubbles = !!eventInitDict?.bubbles;
-        this[state$9].cancelable = !!eventInitDict?.cancelable;
-        this[state$9].composed = !!eventInitDict?.composed;
-    }
-    [state$9];
-    get type() { return this[state$9].type; }
-    get bubbles() { return this[state$9].bubbles; }
-    get cancelable() { return this[state$9].cancelable; }
-    get composed() { return this[state$9].composed; }
-    get target() { return this[state$9].target; }
-    get currentTarget() { return this[state$9].currentTarget; }
-    get eventPhase() { return this[state$9].eventPhase; }
-    NONE = EventP.NONE;
-    CAPTURING_PHASE = EventP.CAPTURING_PHASE;
-    AT_TARGET = EventP.AT_TARGET;
-    BUBBLING_PHASE = EventP.BUBBLING_PHASE;
-    get srcElement() { return this[state$9].target; }
-    cancelBubble = false;
-    get defaultPrevented() { return this[state$9].defaultPrevented; }
-    get returnValue() { return this[state$9].returnValue; }
+        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);
+    }
+    get type() { return this[state$g].type; }
+    get bubbles() { return this[state$g].bubbles; }
+    get cancelable() { return this[state$g].cancelable; }
+    get composed() { return this[state$g].composed; }
+    get target() { return this[state$g].target; }
+    get currentTarget() { return this[state$g].currentTarget; }
+    get eventPhase() { return this[state$g].eventPhase; }
+    get srcElement() { return this[state$g].target; }
+    get cancelBubble() { return this[state$g].cancelBubble; }
+    set cancelBubble(value) { this[state$g].cancelBubble = value; }
+    get defaultPrevented() { return this[state$g].defaultPrevented; }
+    get returnValue() { return this[state$g].returnValue; }
     set returnValue(value) { if (!value) {
         this.preventDefault();
     } }
-    get isTrusted() { return this[state$9].isTrusted; }
-    get timeStamp() { return this[state$9].timeStamp; }
+    get isTrusted() { return this[state$g][_isTrusted]; }
+    get timeStamp() { return this[state$g].timeStamp; }
     composedPath() {
         const path = !!this.target ? [this.target] : [];
         if (!!this.currentTarget && this.currentTarget !== this.target)
             path.push(this.currentTarget);
         return path;
     }
-    initEvent = (type, bubbles, cancelable) => {
-        if (this[state$9]._dispatched)
+    initEvent(type, bubbles, cancelable) {
+        const that = this[state$g];
+        if (that[_dispatched])
             return;
-        this[state$9].type = String(type);
-        this[state$9].bubbles = !!bubbles;
-        this[state$9].cancelable = !!cancelable;
-    };
-    preventDefault = () => {
-        if (this[state$9]._passive) {
+        that.type = String(type);
+        that.bubbles = !!bubbles;
+        that.cancelable = !!cancelable;
+    }
+    preventDefault() {
+        const that = this[state$g];
+        if (that[_passive]) {
             console.warn(`Ignoring 'preventDefault()' call on event of type '${this.type}' from a listener registered as 'passive'.`);
             return;
         }
         if (this.cancelable) {
-            this[state$9]._preventDefaultCalled = true;
-            this[state$9].defaultPrevented = true;
-            this[state$9].returnValue = false;
+            that[_preventDefaultCalled] = true;
+            that.defaultPrevented = true;
+            that.returnValue = false;
         }
-    };
-    stopImmediatePropagation = () => {
-        this[state$9]._stopImmediatePropagationCalled = true;
+    }
+    stopImmediatePropagation() {
+        this[state$g][_stopImmediatePropagationCalled] = true;
         this.cancelBubble = true;
-    };
+    }
     stopPropagation() {
         this.cancelBubble = true;
     }
     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;
 defineStringTag(EventP, "Event");
+const _TimeStamp = Symbol();
+const _isTrusted = Symbol();
+const _passive = Symbol();
+const _dispatched = Symbol();
+const _preventDefaultCalled = Symbol();
+const _stopImmediatePropagationCalled = Symbol();
 class EventState {
-    static TimeStamp = (new Date()).getTime();
-    type = "";
-    bubbles = false;
-    cancelable = false;
-    composed = false;
-    target = null;
-    currentTarget = null;
-    eventPhase = EventP.NONE;
-    defaultPrevented = false;
-    returnValue = true;
-    isTrusted = false;
-    timeStamp = (new Date()).getTime() - EventState.TimeStamp;
-    _passive = false;
-    _dispatched = false;
-    _preventDefaultCalled = false;
-    _stopImmediatePropagationCalled = false;
+    constructor() {
+        this.type = "";
+        this.bubbles = false;
+        this.cancelable = false;
+        this.composed = false;
+        this.target = null;
+        this.currentTarget = null;
+        this.eventPhase = EventP.NONE;
+        this.cancelBubble = false;
+        this.defaultPrevented = false;
+        this.returnValue = true;
+        this.timeStamp = (new Date()).getTime() - EventState[_TimeStamp];
+        this[_b$2] = false;
+        this[_c$1] = false;
+        this[_d$1] = false;
+        this[_e$1] = false;
+        this[_f$1] = false;
+    }
+}
+_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);
+    event[state$g].target = target;
+    event[state$g][_isTrusted] = isTrusted;
+    return event;
 }
 const EventE = g["EventTarget"] ? g["Event"] : EventP;
 
-const state$7 = Symbol("EventTargetState");
+var _a$8;
+const state$f = Symbol( /* "EventTargetState" */);
 class EventTargetP {
     constructor() {
-        this[state$7] = new EventTargetState(this);
+        this[state$f] = new EventTargetState(this);
     }
-    [state$7];
     addEventListener(type, callback, options) {
+        const that = this[state$f];
         const executor = new Executor(type, callback);
-        executor.options.capture = typeof options === "boolean" ? options : !!options?.capture;
-        if (!this[state$7].executors.some(x => x.equals(executor))) {
+        executor.options.capture = typeof options === "boolean" ? options : !!(options === null || options === void 0 ? void 0 : options.capture);
+        if (!that[_executors].some(x => x.equals(executor))) {
             if (typeof options === "object") {
                 const { once, passive, signal } = options;
                 executor.options.once = !!once;
                 executor.options.passive = !!passive;
                 if (signal) {
                     executor.options.signal = signal;
-                    this[state$7].reply(signal, executor);
+                    reply.call(that, signal, executor);
                 }
             }
-            this[state$7].executors.push(executor);
+            that[_executors].push(executor);
             const f = (v) => !!v.options.capture ? 0 : 1;
-            this[state$7].executors = this[state$7].executors.sort((a, b) => f(a) - f(b));
+            that[_executors] = that[_executors].sort((a, b) => f(a) - f(b));
         }
     }
     dispatchEvent(event) {
@@ -410,104 +443,104 @@ class EventTargetP {
         if (!(event instanceof EventP)) {
             throw new TypeError("EventTarget.dispatchEvent: Argument 1 does not implement interface Event.");
         }
-        const s = event[state$9];
+        const s = event[state$g];
         s.target = this;
-        s.isTrusted = false;
-        return this[state$7].fire(event);
+        s[_isTrusted] = false;
+        return fire.call(this[state$f], event);
     }
     removeEventListener(type, callback, options) {
+        const that = this[state$f];
         const executor = new Executor(type, callback);
-        executor.options.capture = typeof options === "boolean" ? options : !!options?.capture;
-        if (this[state$7].executors.some(x => x.equals(executor))) {
-            this[state$7].executors = this[state$7].executors.filter(x => !x.equals(executor));
+        executor.options.capture = typeof options === "boolean" ? options : !!(options === null || options === void 0 ? void 0 : options.capture);
+        if (that[_executors].some(x => x.equals(executor))) {
+            that[_executors] = that[_executors].filter(x => !x.equals(executor));
         }
     }
     toString() { return "[object EventTarget]"; }
     get isPolyfill() { return { symbol: polyfill, hierarchy: ["EventTarget"] }; }
 }
 defineStringTag(EventTargetP, "EventTarget");
+const _executors = Symbol();
 class EventTargetState {
     constructor(target) {
+        this[_a$8] = [];
         this.target = target;
     }
-    target;
-    executors = [];
-    fire(event) {
-        const s = event[state$9];
-        if (!event.target)
-            s.target = this.target;
-        s.currentTarget = this.target;
-        s.eventPhase = EventP.AT_TARGET;
-        s._dispatched = true;
-        const onceIndexes = [];
-        for (let i = 0; i < this.executors.length; ++i) {
-            const executor = this.executors[i];
-            if (executor.type !== event.type)
-                continue;
-            s._passive = !!executor.options.passive;
-            if (executor.options.once)
-                onceIndexes.push(i);
-            try {
-                const { callback: cb } = executor;
-                if (typeof cb === "function")
-                    cb.call(this.target, event);
-            }
-            catch (e) {
-                console.error(e);
-            }
-            s._passive = false;
-            if (s._stopImmediatePropagationCalled)
-                break;
-        }
-        if (onceIndexes.length > 0) {
-            this.executors = this.executors.reduce((acc, cur, index) => {
-                if (!onceIndexes.includes(index))
-                    acc.push(cur);
-                return acc;
-            }, []);
-        }
-        s.currentTarget = null;
-        s.eventPhase = EventP.NONE;
-        s._dispatched = false;
-        return !(event.cancelable && s._preventDefaultCalled);
-    }
-    reply(signal, executor) {
+}
+_a$8 = _executors;
+function fire(event) {
+    const s = event[state$g];
+    if (!event.target)
+        s.target = this.target;
+    s.currentTarget = this.target;
+    s.eventPhase = EventP.AT_TARGET;
+    s[_dispatched] = true;
+    const onceIndexes = [];
+    for (let i = 0; i < this[_executors].length; ++i) {
+        const 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;
         try {
-            const onAbort = () => {
-                this.executors = this.executors.filter(x => !x.equals(executor));
-                signal.removeEventListener("abort", onAbort);
-            };
-            signal.addEventListener("abort", onAbort);
+            if (typeof cb === "function")
+                cb.call(this.target, event);
         }
         catch (e) {
             console.error(e);
         }
+        s[_passive] = false;
+        if (s[_stopImmediatePropagationCalled])
+            break;
     }
+    if (onceIndexes.length > 0) {
+        this[_executors] = this[_executors].reduce((acc, cur, index) => {
+            if (onceIndexes.indexOf(index) === -1)
+                acc.push(cur);
+            return acc;
+        }, []);
+    }
+    s.currentTarget = null;
+    s.eventPhase = EventP.NONE;
+    s[_dispatched] = false;
+    return !(event.cancelable && s[_preventDefaultCalled]);
 }
-class Executor {
-    static extract(cb) {
-        if (typeof cb === "function") {
-            return cb;
-        }
-        else if (isEventListenerObject(cb)) {
-            return cb.handleEvent;
-        }
-        else {
-            return cb;
-        }
+function reply(signal, executor) {
+    const onAbort = () => {
+        this[_executors] = this[_executors].filter(x => !x.equals(executor));
+        signal.removeEventListener("abort", onAbort);
+    };
+    try {
+        signal.addEventListener("abort", onAbort);
+    }
+    catch (e) {
+        console.error(e);
     }
+}
+class Executor {
     constructor(type, callback) {
+        this.options = {};
         this.type = String(type);
-        this.callback = Executor.extract(callback);
+        this.callback = extract(callback);
     }
-    type;
-    callback;
-    options = {};
     equals(executor) {
         return Object.is(this.type, executor.type) && Object.is(this.callback, executor.callback)
             && Object.is(this.options.capture, executor.options.capture);
     }
 }
+function extract(cb) {
+    if (typeof cb === "function") {
+        return cb;
+    }
+    else if (isEventListenerObject(cb)) {
+        return cb.handleEvent;
+    }
+    else {
+        return cb;
+    }
+}
 function isEventListenerObject(cb) {
     return !!cb && "handleEvent" in cb && typeof cb.handleEvent === "function";
 }
@@ -525,54 +558,77 @@ function executeFn(cb, ev) {
 }
 const EventTargetE = g["EventTarget"] || EventTargetP;
 
-const state$6 = Symbol("CustomEventState");
+const state$e = Symbol( /* "CustomEventState" */);
 class CustomEventP extends EventP {
     constructor(type, eventInitDict) {
+        var _a;
         super(type, eventInitDict);
-        this[state$6] = new CustomEventState();
-        this[state$6].detail = eventInitDict?.detail ?? null;
+        this[state$e] = new CustomEventState();
+        this[state$e].detail = (_a = eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.detail) !== null && _a !== void 0 ? _a : null;
     }
-    [state$6];
-    get detail() { return this[state$6].detail; }
+    get detail() { return this[state$e].detail; }
     initCustomEvent(type, bubbles, cancelable, detail) {
-        if (this[state$9]._dispatched)
+        if (this[state$g][_dispatched])
             return;
         this.initEvent(type, bubbles, cancelable);
-        this[state$6].detail = detail ?? null;
+        this[state$e].detail = detail !== null && detail !== void 0 ? detail : null;
     }
     toString() { return "[object CustomEvent]"; }
     get isPolyfill() { return { symbol: polyfill, hierarchy: ["CustomEvent", "Event"] }; }
 }
 defineStringTag(CustomEventP, "CustomEvent");
 class CustomEventState {
-    detail;
 }
 const CustomEventE = g["EventTarget"] ? g["CustomEvent"] : CustomEventP;
 
-const state$5 = Symbol("ProgressEventState");
+const state$d = Symbol( /* "ProgressEventState" */);
 class ProgressEventP extends EventP {
     constructor(type, eventInitDict) {
+        var _a, _b;
         super(type, eventInitDict);
-        this[state$5] = new ProgressEventState();
-        this[state$5].lengthComputable = !!eventInitDict?.lengthComputable;
-        this[state$5].loaded = eventInitDict?.loaded ?? 0;
-        this[state$5].total = eventInitDict?.total ?? 0;
-    }
-    [state$5];
-    get lengthComputable() { return this[state$5].lengthComputable; }
-    get loaded() { return this[state$5].loaded; }
-    get total() { return this[state$5].total; }
+        this[state$d] = new ProgressEventState();
+        const that = this[state$d];
+        that.lengthComputable = !!(eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.lengthComputable);
+        that.loaded = (_a = eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.loaded) !== null && _a !== void 0 ? _a : 0;
+        that.total = (_b = eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.total) !== null && _b !== void 0 ? _b : 0;
+    }
+    get lengthComputable() { return getValue(this[state$d].lengthComputable); }
+    get loaded() { return getValue(this[state$d].loaded); }
+    get total() { return getValue(this[state$d].total); }
     toString() { return "[object ProgressEvent]"; }
     get isPolyfill() { return { symbol: polyfill, hierarchy: ["ProgressEvent", "Event"] }; }
 }
 defineStringTag(ProgressEventP, "ProgressEvent");
 class ProgressEventState {
-    lengthComputable = false;
-    loaded = 0;
-    total = 0;
+    constructor() {
+        this.lengthComputable = false;
+        this.loaded = 0;
+        this.total = 0;
+    }
+}
+function getValue(val) {
+    return typeof val === "function" ? val() : val;
+}
+function createInnerProgressEvent(target, type, { lengthComputable = false, loaded = 0, total = 0, } = {}) {
+    const event = new ProgressEventP(type);
+    event[state$d].lengthComputable = lengthComputable;
+    event[state$d].loaded = loaded;
+    event[state$d].total = total;
+    event[state$g].target = target;
+    event[state$g][_isTrusted] = true;
+    return event;
+}
+function emitProcessEvent(target, type, loaded = 0, total = 0) {
+    const event = createInnerProgressEvent(target, type, {
+        lengthComputable: () => { return getValue(total) > 0; },
+        loaded,
+        total,
+    });
+    fire.call(target[state$f], event);
 }
 const ProgressEventE = g["EventTarget"] ? g["ProgressEvent"] : ProgressEventP;
 
+const state$c = Symbol( /* "BlobState" */);
 class BlobP {
     constructor(blobParts = [], options) {
         if (!Array.isArray(blobParts)) {
@@ -581,7 +637,7 @@ class BlobP {
         let encoder = null;
         let chunks = blobParts.reduce((chunks, part) => {
             if (isPolyfillType("Blob", part)) {
-                chunks.push(part[state$9]._u8array);
+                chunks.push(part[state$c][_u8array]);
             }
             else if (part instanceof ArrayBuffer || ArrayBuffer.isView(part)) {
                 chunks.push(convert$1(part));
@@ -594,42 +650,42 @@ class BlobP {
             }
             return chunks;
         }, []);
-        this[state$9] = new BlobState(concat(chunks));
-        this[state$9].size = this[state$9]._u8array.length;
-        const rawType = options?.type || "";
-        this[state$9].type = /[^\u0020-\u007E]/.test(rawType) ? "" : rawType.toLowerCase();
-    }
-    [state$9];
-    get size() { return this[state$9].size; }
-    get type() { return this[state$9].type; }
+        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) || "";
+        that.type = /[^\u0020-\u007E]/.test(rawType) ? "" : rawType.toLowerCase();
+    }
+    get size() { return this[state$c].size; }
+    get type() { return this[state$c].type; }
     arrayBuffer() {
-        return Promise.resolve(clone(this[state$9]._u8array.buffer).buffer);
+        return Promise.resolve(clone(this[state$c][_u8array].buffer).buffer);
     }
     bytes() {
-        return Promise.resolve(clone(this[state$9]._u8array.buffer));
+        return Promise.resolve(clone(this[state$c][_u8array].buffer));
     }
     slice(start, end, contentType) {
-        const sliced = this[state$9]._u8array.slice(start ?? 0, end ?? this[state$9]._u8array.length);
-        return new BlobP([sliced], { type: 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);
+        return new BlobP([sliced], { type: contentType !== null && contentType !== void 0 ? contentType : "" });
     }
     stream() {
         throw new ReferenceError("ReadableStream is not defined");
     }
     text() {
         const decoder = new TextDecoderP();
-        return Promise.resolve(decoder.decode(this[state$9]._u8array));
+        return Promise.resolve(decoder.decode(this[state$c][_u8array]));
     }
     toString() { return "[object Blob]"; }
     get isPolyfill() { return { symbol: polyfill, hierarchy: ["Blob"] }; }
 }
 defineStringTag(BlobP, "Blob");
+const _u8array = Symbol();
 class BlobState {
     constructor(buffer) {
-        this._u8array = buffer;
+        this.size = 0;
+        this.type = "";
+        this[_u8array] = buffer;
     }
-    size = 0;
-    type = "";
-    _u8array;
 }
 function u8array2base64(input) {
     let byteToCharMap = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
@@ -676,151 +732,151 @@ function concat(chunks) {
 }
 const BlobE = g["Blob"] || BlobP;
 
-const state$4 = Symbol("FileState");
+const state$b = Symbol( /* "FileState" */);
 class FileP extends BlobP {
     constructor(fileBits, fileName, options) {
         super(fileBits, options);
-        this[state$4] = new FileState();
-        this[state$4].lastModified = +(options?.lastModified ? new Date(options.lastModified) : new Date());
-        this[state$4].name = fileName.replace(/\//g, ":");
+        this[state$b] = new FileState();
+        this[state$b].lastModified = +((options === null || options === void 0 ? void 0 : options.lastModified) ? new Date(options.lastModified) : new Date());
+        this[state$b].name = fileName.replace(/\//g, ":");
     }
-    [state$4];
-    get lastModified() { return this[state$4].lastModified; }
-    get name() { return this[state$4].name; }
+    get lastModified() { return this[state$b].lastModified; }
+    get name() { return this[state$b].name; }
     get webkitRelativePath() { return ""; }
     toString() { return "[object File]"; }
     get isPolyfill() { return { symbol: polyfill, hierarchy: ["File", "Blob"] }; }
 }
 defineStringTag(FileP, "File");
 class FileState {
-    lastModified = 0;
-    name = "";
+    constructor() {
+        this.lastModified = 0;
+        this.name = "";
+    }
 }
 const FileE = g["Blob"] ? g["File"] : FileP;
 
-const state$3 = Symbol("FileReaderState");
+var _a$7;
+const state$a = Symbol( /* "FileReaderState" */);
 class FileReaderP extends EventTargetP {
-    static EMPTY = 0;
-    static LOADING = 1;
-    static DONE = 2;
     constructor() {
         super();
-        this[state$3] = new FileReaderState(this);
-    }
-    [state$3];
-    get readyState() { return this[state$3].readyState; }
-    get result() { return this[state$3].result; }
-    EMPTY = 0;
-    LOADING = 1;
-    DONE = 2;
-    get error() { return this[state$3].error; }
+        this.EMPTY = 0;
+        this.LOADING = 1;
+        this.DONE = 2;
+        this.readAsArrayBuffer = (blob) => {
+            read$1.call(this[state$a], "readAsArrayBuffer", blob, () => {
+                this[state$a].result = blob[state$c][_u8array].buffer.slice(0);
+            });
+        };
+        this.readAsBinaryString = (blob) => {
+            read$1.call(this[state$a], "readAsBinaryString", blob, () => {
+                this[state$a].result = blob[state$c][_u8array].reduce((acc, cur) => {
+                    acc += String.fromCharCode(cur);
+                    return acc;
+                }, "");
+            });
+        };
+        this.readAsDataURL = (blob) => {
+            read$1.call(this[state$a], "readAsDataURL", blob, () => {
+                this[state$a].result = "data:" + blob.type + ";base64," + u8array2base64(blob[state$c][_u8array]);
+            });
+        };
+        this.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] = new FileReaderState(this);
+    }
+    get readyState() { return this[state$a].readyState; }
+    get result() { return this[state$a].result; }
+    get error() { return this[state$a].error; }
     abort() {
         if (this.readyState === FileReaderP.LOADING) {
-            this[state$3].readyState = FileReaderP.DONE;
-            this[state$3].result = null;
-            this[state$3].emitProcessEvent("abort");
-        }
-    }
-    readAsArrayBuffer = (blob) => {
-        this[state$3].read("readAsArrayBuffer", blob, () => {
-            this[state$3].result = blob[state$9]._u8array.buffer.slice(0);
-        });
-    };
-    readAsBinaryString = (blob) => {
-        this[state$3].read("readAsBinaryString", blob, () => {
-            this[state$3].result = blob[state$9]._u8array.reduce((acc, cur) => {
-                acc += String.fromCharCode(cur);
-                return acc;
-            }, "");
-        });
-    };
-    readAsDataURL = (blob) => {
-        this[state$3].read("readAsDataURL", blob, () => {
-            this[state$3].result = "data:" + blob.type + ";base64," + u8array2base64(blob[state$9]._u8array);
-        });
-    };
-    readAsText = (blob, encoding) => {
-        this[state$3].read("readAsText", blob, () => {
-            this[state$3].result = (new TextDecoderP(encoding)).decode(blob[state$9]._u8array);
-        });
-    };
-    get onabort() { return this[state$3].onabort; }
-    set onabort(value) { this[state$3].onabort = value; this[state$3].attach("abort"); }
-    get onerror() { return this[state$3].onerror; }
-    set onerror(value) { this[state$3].onerror = value; this[state$3].attach("error"); }
-    get onload() { return this[state$3].onload; }
-    set onload(value) { this[state$3].onload = value; this[state$3].attach("load"); }
-    get onloadend() { return this[state$3].onloadend; }
-    set onloadend(value) { this[state$3].onloadend = value; this[state$3].attach("loadend"); }
-    get onloadstart() { return this[state$3].onloadstart; }
-    set onloadstart(value) { this[state$3].onloadstart = value; this[state$3].attach("loadstart"); }
-    get onprogress() { return this[state$3].onprogress; }
-    set onprogress(value) { this[state$3].onprogress = value; this[state$3].attach("progress"); }
+            this[state$a].readyState = FileReaderP.DONE;
+            this[state$a].result = null;
+            emitProcessEvent(this, "abort");
+        }
+    }
+    get onabort() { return this[state$a].onabort; }
+    set onabort(value) { this[state$a].onabort = value; attach$1.call(this[state$a], "abort"); }
+    get onerror() { return this[state$a].onerror; }
+    set onerror(value) { this[state$a].onerror = value; attach$1.call(this[state$a], "error"); }
+    get onload() { return this[state$a].onload; }
+    set onload(value) { this[state$a].onload = value; attach$1.call(this[state$a], "load"); }
+    get onloadend() { return this[state$a].onloadend; }
+    set onloadend(value) { this[state$a].onloadend = value; attach$1.call(this[state$a], "loadend"); }
+    get onloadstart() { return this[state$a].onloadstart; }
+    set onloadstart(value) { this[state$a].onloadstart = value; attach$1.call(this[state$a], "loadstart"); }
+    get onprogress() { return this[state$a].onprogress; }
+    set onprogress(value) { this[state$a].onprogress = value; attach$1.call(this[state$a], "progress"); }
     toString() { return "[object FileReader]"; }
     get isPolyfill() { return { symbol: polyfill, hierarchy: ["FileReader", "EventTarget"] }; }
 }
+FileReaderP.EMPTY = 0;
+FileReaderP.LOADING = 1;
+FileReaderP.DONE = 2;
 defineStringTag(FileReaderP, "FileReader");
+const _handlers$3 = Symbol();
 class FileReaderState {
     constructor(target) {
+        this.readyState = FileReaderP.EMPTY;
+        this.result = null;
+        this.error = null;
+        this[_a$7] = getHandlers$3.call(this);
+        this.onabort = null;
+        this.onerror = null;
+        this.onload = null;
+        this.onloadend = null;
+        this.onloadstart = null;
+        this.onprogress = null;
         this.target = target;
     }
-    target;
-    readyState = FileReaderP.EMPTY;
-    result = null;
-    error = null;
-    read(kind, blob, setResult) {
-        if (!isPolyfillType("Blob", blob)) {
-            throw new TypeError("Failed to execute '" + kind + "' on 'FileReader': parameter 1 is not of type 'Blob'.");
-        }
-        this.error = null;
-        this.readyState = FileReaderP.LOADING;
-        this.emitProcessEvent("loadstart", 0, blob.size);
-        setTimeout(() => {
-            if (this.readyState === FileReaderP.LOADING) {
-                this.readyState = FileReaderP.DONE;
-                try {
-                    setResult();
-                    this.emitProcessEvent("load", blob.size, blob.size);
-                }
-                catch (e) {
-                    this.result = null;
-                    this.error = e;
-                    this.emitProcessEvent("error", 0, blob.size);
-                }
-            }
-            this.emitProcessEvent("loadend", !!this.result ? blob.size : 0, blob.size);
-        });
+}
+_a$7 = _handlers$3;
+function read$1(kind, blob, setResult) {
+    if (!isPolyfillType("Blob", blob)) {
+        throw new TypeError("Failed to execute '" + kind + "' on 'FileReader': parameter 1 is not of type 'Blob'.");
     }
-    emitProcessEvent(type, loaded = 0, total = 0) {
-        const event = new ProgressEventP(type, {
-            lengthComputable: total > 0,
-            loaded,
-            total,
-        });
-        event[state$9].target = this.target;
-        event[state$9].isTrusted = true;
-        this.target[state$7].fire(event);
-    }
-    attach(type) {
-        const cb = this[("on" + type)];
-        const listener = this[("_on" + type)];
-        attachFn.call(this.target, type, cb, listener);
-    }
-    onabort = null;
-    _onabort = (ev) => { executeFn.call(this.target, this.onabort, ev); };
-    onerror = null;
-    _onerror = (ev) => { executeFn.call(this.target, this.onerror, ev); };
-    onload = null;
-    _onload = (ev) => { executeFn.call(this.target, this.onload, ev); };
-    onloadend = null;
-    _onloadend = (ev) => { executeFn.call(this.target, this.onloadend, ev); };
-    onloadstart = null;
-    _onloadstart = (ev) => { executeFn.call(this.target, this.onloadstart, ev); };
-    onprogress = null;
-    _onprogress = (ev) => { executeFn.call(this.target, this.onprogress, ev); };
+    this.error = null;
+    this.readyState = FileReaderP.LOADING;
+    emitProcessEvent(this.target, "loadstart", 0, blob.size);
+    setTimeout(() => {
+        if (this.readyState === FileReaderP.LOADING) {
+            this.readyState = FileReaderP.DONE;
+            try {
+                setResult();
+                emitProcessEvent(this.target, "load", blob.size, blob.size);
+            }
+            catch (e) {
+                this.result = null;
+                this.error = e;
+                emitProcessEvent(this.target, "error", 0, blob.size);
+            }
+        }
+        emitProcessEvent(this.target, "loadend", !!this.result ? blob.size : 0, blob.size);
+    });
+}
+function attach$1(type) {
+    const fnName = ("on" + type);
+    const cb = this[fnName];
+    const listener = this[_handlers$3][fnName];
+    attachFn.call(this.target, type, cb, listener);
+}
+function getHandlers$3() {
+    return {
+        onabort: (ev) => { executeFn.call(this.target, this.onabort, ev); },
+        onerror: (ev) => { executeFn.call(this.target, this.onerror, ev); },
+        onload: (ev) => { executeFn.call(this.target, this.onload, ev); },
+        onloadend: (ev) => { executeFn.call(this.target, this.onloadend, ev); },
+        onloadstart: (ev) => { executeFn.call(this.target, this.onloadstart, ev); },
+        onprogress: (ev) => { executeFn.call(this.target, this.onprogress, ev); },
+    };
 }
 const FileReaderE = g["Blob"] ? g["FileReader"] : FileReaderP;
 
+var _a$6;
+const state$9 = Symbol( /* "FormDataState" */);
 class FormDataP {
     constructor(form, submitter) {
         if (form !== void 0) {
@@ -831,20 +887,19 @@ class FormDataP {
         }
         this[state$9] = new FormDataState();
     }
-    [state$9];
     append(name, value, filename) {
-        this[state$9]._data.push(normalizeArgs(name, value, filename));
+        this[state$9][_formData].push(normalizeArgs(name, value, filename));
     }
     delete(name) {
         const result = [];
         name = String(name);
-        each(this[state$9]._data, entry => {
+        each(this[state$9][_formData], entry => {
             entry[0] !== name && result.push(entry);
         });
-        this[state$9]._data = result;
+        this[state$9][_formData] = result;
     }
     get(name) {
-        const entries = this[state$9]._data;
+        const entries = this[state$9][_formData];
         name = String(name);
         for (let i = 0; i < entries.length; ++i) {
             if (entries[i][0] === name) {
@@ -856,15 +911,15 @@ class FormDataP {
     getAll(name) {
         const result = [];
         name = String(name);
-        each(this[state$9]._data, data => {
+        each(this[state$9][_formData], data => {
             data[0] === name && result.push(data[1]);
         });
         return result;
     }
     has(name) {
         name = String(name);
-        for (let i = 0; i < this[state$9]._data.length; ++i) {
-            if (this[state$9]._data[i][0] === name) {
+        for (let i = 0; i < this[state$9][_formData].length; ++i) {
+            if (this[state$9][_formData][i][0] === name) {
                 return true;
             }
         }
@@ -875,13 +930,13 @@ class FormDataP {
         const result = [];
         const args = normalizeArgs(name, value, filename);
         let replace = true;
-        each(this[state$9]._data, data => {
+        each(this[state$9][_formData], data => {
             data[0] === name
                 ? replace && (replace = !result.push(args))
                 : result.push(data);
         });
         replace && result.push(args);
-        this[state$9]._data = result;
+        this[state$9][_formData] = result;
     }
     forEach(callbackfn, thisArg) {
         for (const [name, value] of this) {
@@ -889,13 +944,13 @@ class FormDataP {
         }
     }
     entries() {
-        return this[state$9]._data.values();
+        return this[state$9][_formData].values();
     }
     keys() {
-        return this[state$9]._data.map(x => x[0]).values();
+        return this[state$9][_formData].map(x => x[0]).values();
     }
     values() {
-        return this[state$9]._data.map(x => x[1]).values();
+        return this[state$9][_formData].map(x => x[1]).values();
     }
     [Symbol.iterator]() {
         return this.entries();
@@ -904,13 +959,16 @@ class FormDataP {
     get isPolyfill() { return { symbol: polyfill, hierarchy: ["FormData"] }; }
 }
 defineStringTag(FormDataP, "FormData");
+const _formData = Symbol();
 class FormDataState {
-    _data = [];
+    constructor() {
+        this[_a$6] = [];
+    }
     toBlob() {
         const boundary = "----formdata-polyfill-" + Math.random();
         const p = `--${boundary}\r\nContent-Disposition: form-data; name="`;
         let chunks = [];
-        for (const [name, value] of this._data.values()) {
+        for (const [name, value] of this[_formData].values()) {
             if (typeof value === "string") {
                 chunks.push(p + escape(normalizeLinefeeds(name)) + `"\r\n\r\n${normalizeLinefeeds(value)}\r\n`);
             }
@@ -924,6 +982,7 @@ class FormDataState {
         });
     }
 }
+_a$6 = _formData;
 function normalizeArgs(name, value, filename) {
     if (isPolyfillType("Blob", value)) {
         filename = filename !== undefined
@@ -954,7 +1013,7 @@ function escape(str) {
  * @param body - Text in multipart/form-data format (including boundaries and data)
  * @returns Parsed FormData object (text fields as strings, files as File objects)
  */
-function createFormData(body) {
+function createFormDataFromBody(body, errMsg = "Failed to fetch") {
     const formData = new FormDataP();
     if (typeof body !== "string" || body.trim() === "") {
         return formData;
@@ -963,7 +1022,7 @@ function createFormData(body) {
     const firstLineEnd = body.indexOf("\r\n");
     if (firstLineEnd === -1) {
         // Invalid multipart format: Missing line break in header
-        throw new TypeError("Failed to fetch");
+        throw new TypeError(errMsg);
     }
     const boundary = body.substring(2, firstLineEnd).trim();
     if (!boundary) {
@@ -977,7 +1036,7 @@ function createFormData(body) {
     });
     if (parts.length === 0) {
         // Invalid multipart format: No parts found
-        throw new TypeError("Failed to fetch");
+        throw new TypeError(errMsg);
     }
     // 3. Parse each part
     parts.forEach(part => {
@@ -985,7 +1044,7 @@ function createFormData(body) {
         const separatorIndex = part.indexOf("\r\n\r\n");
         if (separatorIndex === -1) {
             // Invalid part format: Missing header-content separator
-            throw new TypeError("Failed to fetch");
+            throw new TypeError(errMsg);
         }
         // Extract header (Content-Disposition and Content-Type)
         const headerRaw = part.substring(0, separatorIndex).trim();
@@ -996,7 +1055,7 @@ function createFormData(body) {
         const contentTypeMatch = headerRaw.match(/Content-Type: ([^\r\n]+)/); // MIME type (optional)
         if (!nameMatch || !nameMatch[1]) {
             // Invalid part format: Missing field name
-            throw new TypeError("Failed to fetch");
+            throw new TypeError(errMsg);
         }
         const fieldName = nameMatch[1];
         const isFile = !!filenameMatch; // Whether it's a file field
@@ -1017,7 +1076,7 @@ function createFormData(body) {
             }
             catch (e) {
                 // `Failed to process file field "${fieldName}": ${(e as Error).message}`
-                throw new TypeError("Failed to fetch");
+                throw new TypeError(errMsg);
             }
         }
         else {
@@ -1030,25 +1089,26 @@ function createFormData(body) {
 }
 const FormDataE = g["FormData"] || FormDataP;
 
+var _a$5;
+const state$8 = Symbol( /* "URLSearchParamsState" */);
 class URLSearchParamsP {
     constructor(init) {
         let search = init || "";
         if (isObjectType("URLSearchParams", search)) {
             search = search.toString();
         }
-        this[state$9] = new URLSearchParamsState();
-        this[state$9]._dict = parseToDict(search);
+        this[state$8] = new URLSearchParamsState();
+        this[state$8][_urlspDict] = parseToDict(search);
     }
-    [state$9];
     get size() {
-        return Object.values(this[state$9]._dict).reduce((acc, cur) => acc + cur.length, 0);
+        return objectValues(this[state$8][_urlspDict]).reduce((acc, cur) => acc + cur.length, 0);
     }
     append(name, value) {
-        appendTo(this[state$9]._dict, name, value);
+        appendTo(this[state$8][_urlspDict], name, value);
     }
     delete(name, value) {
         let dict = {};
-        for (let [key, values] of Object.entries(this[state$9]._dict)) {
+        for (let [key, values] of objectEntries(this[state$8][_urlspDict])) {
             if (key === name) {
                 if (value !== undefined) {
                     let vals = values.filter(x => x !== ("" + value));
@@ -1059,64 +1119,66 @@ class URLSearchParamsP {
             }
             Object.assign(dict, { [key]: values });
         }
-        this[state$9]._dict = dict;
+        this[state$8][_urlspDict] = dict;
     }
     get(name) {
-        return this.has(name) ? this[state$9]._dict[name][0] ?? null : null;
+        var _b;
+        return this.has(name) ? (_b = this[state$8][_urlspDict][name][0]) !== null && _b !== void 0 ? _b : null : null;
     }
     getAll(name) {
-        return this.has(name) ? this[state$9]._dict[name].slice(0) : [];
+        return this.has(name) ? this[state$8][_urlspDict][name].slice(0) : [];
     }
     has(name, value) {
-        if (hasOwnProperty(this[state$9]._dict, name)) {
+        if (hasOwnProperty(this[state$8][_urlspDict], name)) {
             if (value !== undefined) {
-                return this[state$9]._dict[name].includes(("" + value));
+                return this[state$8][_urlspDict][name].indexOf(("" + value)) > -1;
             }
             return true;
         }
         return false;
     }
     set(name, value) {
-        this[state$9]._dict[name] = ["" + value];
+        this[state$8][_urlspDict][name] = ["" + value];
     }
     sort() {
-        let keys = Object.keys(this[state$9]._dict);
+        const that = this[state$8];
+        let keys = Object.keys(that[_urlspDict]);
         keys.sort();
         let dict = {};
         for (let key of keys) {
-            Object.assign(dict, { [key]: this[state$9]._dict[key] });
+            Object.assign(dict, { [key]: that[_urlspDict][key] });
         }
-        this[state$9]._dict = dict;
+        that[_urlspDict] = dict;
     }
     forEach(callbackfn, thisArg) {
-        Object.entries(this[state$9]._dict).forEach(([key, values]) => {
+        objectEntries(this[state$8][_urlspDict]).forEach(([key, values]) => {
             values.forEach(value => {
                 callbackfn.call(thisArg, value, key, this);
             });
         });
     }
     entries() {
-        return Object.entries(this[state$9]._dict)
+        return objectEntries(this[state$8][_urlspDict])
             .map(([key, values]) => {
             return values.map(value => {
                 return [key, value];
             });
         })
-            .flat()
+            .reduce(flatCb, [])
             .values();
     }
     keys() {
-        return Object.keys(this[state$9]._dict).values();
+        return Object.keys(this[state$8][_urlspDict]).values();
     }
     values() {
-        return Object.values(this[state$9]._dict).flat().values();
+        return objectValues(this[state$8][_urlspDict]).reduce(flatCb, []).values();
     }
     [Symbol.iterator]() {
         return this.entries();
     }
     toString() {
         let query = [];
-        for (let [key, values] of Object.entries(this[state$9]._dict)) {
+        for (let [key, values] of objectEntries(this[state$8][_urlspDict])) {
             let name = encode$1(key);
             for (let val of values) {
                 query.push(name + "=" + encode$1(val));
@@ -1127,9 +1189,13 @@ class URLSearchParamsP {
     get isPolyfill() { return { symbol: polyfill, hierarchy: ["URLSearchParams"] }; }
 }
 defineStringTag(URLSearchParamsP, "URLSearchParams");
+const _urlspDict = Symbol();
 class URLSearchParamsState {
-    _dict = {};
+    constructor() {
+        this[_a$5] = {};
+    }
 }
+_a$5 = _urlspDict;
 function parseToDict(search) {
     let dict = {};
     if (typeof search === "object") {
@@ -1203,26 +1269,34 @@ function decode$1(str) {
 function hasOwnProperty(obj, prop) {
     return Object.prototype.hasOwnProperty.call(obj, prop);
 }
+function flatCb(acc, cur) {
+    for (const item of cur) {
+        acc.push(item);
+    }
+    return acc;
+}
 const URLSearchParamsE = g["URLSearchParams"] || URLSearchParamsP;
 
+var _a$4;
+const state$7 = Symbol( /* "AbortSignalState" */);
 class AbortSignalP extends EventTargetP {
     static abort(reason) {
         const signal = createAbortSignalP();
-        signal[state$9].abort(reason, false);
+        abort.call(signal[state$7], reason, false);
         return signal;
     }
     static any(signals) {
         const signal = createAbortSignalP();
         const abortedSignal = signals.find(x => x.aborted);
         if (abortedSignal) {
-            signal[state$9].abort(abortedSignal.reason, false);
+            abort.call(signal[state$7], abortedSignal.reason, false);
         }
         else {
             function abortFn(ev) {
                 for (const sig of signals) {
                     sig.removeEventListener("abort", abortFn);
                 }
-                signal[state$9].abort(this.reason, true, ev.isTrusted);
+                abort.call(signal[state$7], this.reason, true, ev.isTrusted);
             }
             for (const sig of signals) {
                 sig.addEventListener("abort", abortFn);
@@ -1233,7 +1307,7 @@ class AbortSignalP extends EventTargetP {
     static timeout(milliseconds) {
         const signal = createAbortSignalP();
         setTimeout(() => {
-            signal[state$9].abort(new MPException("signal timed out", "TimeoutError"));
+            abort.call(signal[state$7], new MPException("signal timed out", "TimeoutError"));
         }, milliseconds);
         return signal;
     }
@@ -1242,153 +1316,140 @@ class AbortSignalP extends EventTargetP {
             throw new TypeError("Failed to construct 'AbortSignal': Illegal constructor");
         }
         super();
-        this[state$9] = new AbortSignalState(this);
+        this[state$7] = new AbortSignalState(this);
     }
-    [state$9];
-    get aborted() { return this[state$9].aborted; }
-    get reason() { return this[state$9].reason; }
+    get aborted() { return this[state$7].aborted; }
+    get reason() { return this[state$7].reason; }
     throwIfAborted() {
         if (this.aborted) {
             throw this.reason;
         }
     }
-    get onabort() { return this[state$9].onabort; }
+    get onabort() { return this[state$7].onabort; }
     set onabort(value) {
-        this[state$9].onabort = value;
-        attachFn.call(this, "abort", value, this[state$9]._onabort);
+        this[state$7].onabort = value;
+        attachFn.call(this, "abort", value, this[state$7][_handlers$2].onabort);
     }
     toString() { return "[object AbortSignal]"; }
     get isPolyfill() { return { symbol: polyfill, hierarchy: ["AbortSignal", "EventTarget"] }; }
 }
 defineStringTag(AbortSignalP, "AbortSignal");
+const _handlers$2 = Symbol();
 class AbortSignalState {
     constructor(target) {
+        this.aborted = false;
+        this.reason = undefined;
+        this[_a$4] = getHandlers$2.call(this);
+        this.onabort = null;
         this.target = target;
     }
-    target;
-    aborted = false;
-    reason = undefined;
-    abort(reason, notify = true, isTrusted = true) {
-        if (!this.aborted) {
-            this.aborted = true;
-            this.reason = reason ?? (new MPException("signal is aborted without reason", "AbortError"));
-            if (notify) {
-                const evt = new EventP("abort");
-                evt[state$9].target = this.target;
-                evt[state$9].isTrusted = isTrusted;
-                this.target[state$7].fire(evt);
-            }
+}
+_a$4 = _handlers$2;
+function abort(reason, notify = true, isTrusted = true) {
+    if (!this.aborted) {
+        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);
+            fire.call(this.target[state$f], evt);
         }
     }
-    onabort = null;
-    _onabort = (ev) => { executeFn.call(this.target, this.onabort, ev); };
+}
+function getHandlers$2() {
+    return {
+        onabort: (ev) => { executeFn.call(this.target, this.onabort, ev); },
+    };
 }
 function createAbortSignalP() {
     const instance = Object.create(AbortSignalP.prototype);
-    instance[state$7] = new EventTargetState(instance);
-    instance[state$9] = new AbortSignalState(instance);
+    instance[state$f] = new EventTargetState(instance);
+    instance[state$7] = new AbortSignalState(instance);
     return instance;
 }
 const AbortSignalE = g["AbortSignal"] || AbortSignalP;
 
-const state$2 = Symbol("AbortControllerState");
+const state$6 = Symbol( /* "AbortControllerState" */);
 class AbortControllerP {
     constructor() {
-        this[state$2] = new AbortControllerState();
+        this[state$6] = new AbortControllerState();
     }
-    [state$2];
-    get signal() { return this[state$2].signal; }
+    get signal() { return this[state$6].signal; }
     abort(reason) {
-        this[state$2].signal[state$9].abort(reason);
+        abort.call(this[state$6].signal[state$7], reason);
     }
     toString() { return "[object AbortController]"; }
     get isPolyfill() { return { symbol: polyfill, hierarchy: ["AbortController"] }; }
 }
 defineStringTag(AbortControllerP, "AbortController");
 class AbortControllerState {
-    signal = createAbortSignalP();
+    constructor() {
+        this.signal = createAbortSignalP();
+    }
 }
 const AbortControllerE = g["AbortController"] || AbortControllerP;
 
-// @ts-nocheck
-const mp = (() => {
-    let u = "undefined", r = "request", f = "function";
-    let mp;
-    mp =
-        (typeof wx !== u && typeof wx?.[r] === f && wx) || // 微信
-            (typeof my !== u && typeof my?.[r] === f && my) || // 支付宝
-            (typeof qq !== u && typeof qq?.[r] === f && qq) || // QQ
-            (typeof jd !== u && typeof jd?.[r] === f && jd) || // 京东
-            (typeof swan !== u && typeof swan?.[r] === f && swan) || // 百度
-            (typeof tt !== u && typeof tt?.[r] === f && tt) || // 抖音 | 飞书
-            (typeof ks !== u && typeof ks?.[r] === f && ks) || // 快手
-            (typeof qh !== u && typeof qh?.[r] === f && qh) || // 360
-            undefined;
-    if (typeof g["XMLHttpRequest"] === f && typeof g["fetch"] === f) {
-        return;
-    }
-    if (mp === undefined)
-        mp =
-            (typeof uni !== u && typeof uni?.[r] === f && uni) || // UniApp
-                (typeof Taro !== u && typeof Taro?.[r] === f && Taro) || // Taro
-                undefined;
-    return mp;
-})();
-
+var _a$3;
+const state$5 = Symbol( /* "XMLHttpRequestEventTargetState" */);
 class XMLHttpRequestEventTargetP extends EventTargetP {
     constructor() {
         if (new.target === XMLHttpRequestEventTargetP) {
             throw new TypeError("Failed to construct 'XMLHttpRequestEventTarget': Illegal constructor");
         }
         super();
-        this[state$9] = new XMLHttpRequestEventTargetState(this);
-    }
-    [state$9];
-    get onabort() { return this[state$9].onabort; }
-    set onabort(value) { this[state$9].onabort = value; this[state$9].attach("abort"); }
-    get onerror() { return this[state$9].onerror; }
-    set onerror(value) { this[state$9].onerror = value; this[state$9].attach("error"); }
-    get onload() { return this[state$9].onload; }
-    set onload(value) { this[state$9].onload = value; this[state$9].attach("load"); }
-    get onloadend() { return this[state$9].onloadend; }
-    set onloadend(value) { this[state$9].onloadend = value; this[state$9].attach("loadend"); }
-    get onloadstart() { return this[state$9].onloadstart; }
-    set onloadstart(value) { this[state$9].onloadstart = value; this[state$9].attach("loadstart"); }
-    get onprogress() { return this[state$9].onprogress; }
-    set onprogress(value) { this[state$9].onprogress = value; this[state$9].attach("progress"); }
-    get ontimeout() { return this[state$9].ontimeout; }
-    set ontimeout(value) { this[state$9].ontimeout = value; this[state$9].attach("timeout"); }
+        this[state$5] = new XMLHttpRequestEventTargetState(this);
+    }
+    get onabort() { return this[state$5].onabort; }
+    set onabort(value) { this[state$5].onabort = value; attach.call(this[state$5], "abort"); }
+    get onerror() { return this[state$5].onerror; }
+    set onerror(value) { this[state$5].onerror = value; attach.call(this[state$5], "error"); }
+    get onload() { return this[state$5].onload; }
+    set onload(value) { this[state$5].onload = value; attach.call(this[state$5], "load"); }
+    get onloadend() { return this[state$5].onloadend; }
+    set onloadend(value) { this[state$5].onloadend = value; attach.call(this[state$5], "loadend"); }
+    get onloadstart() { return this[state$5].onloadstart; }
+    set onloadstart(value) { this[state$5].onloadstart = value; attach.call(this[state$5], "loadstart"); }
+    get onprogress() { return this[state$5].onprogress; }
+    set onprogress(value) { this[state$5].onprogress = value; attach.call(this[state$5], "progress"); }
+    get ontimeout() { return this[state$5].ontimeout; }
+    set ontimeout(value) { this[state$5].ontimeout = value; attach.call(this[state$5], "timeout"); }
     toString() { return "[object XMLHttpRequestEventTarget]"; }
     get isPolyfill() { return { symbol: polyfill, hierarchy: ["XMLHttpRequestEventTarget", "EventTarget"] }; }
 }
 defineStringTag(XMLHttpRequestEventTargetP, "XMLHttpRequestEventTarget");
+const _handlers$1 = Symbol();
 class XMLHttpRequestEventTargetState {
     /**
      * @param _target XMLHttpRequestEventTargetP
      */
     constructor(_target) {
+        this[_a$3] = getHandlers$1.call(this);
+        this.onabort = null;
+        this.onerror = null;
+        this.onload = null;
+        this.onloadend = null;
+        this.onloadstart = null;
+        this.onprogress = null;
+        this.ontimeout = null;
         this.target = _target;
     }
-    target;
-    attach(type) {
-        const cb = this[("on" + type)];
-        const listener = this[("_on" + type)];
-        attachFn.call(this.target, type, cb, listener);
-    }
-    onabort = null;
-    _onabort = (ev) => { executeFn.call(this.target, this.onabort, ev); };
-    onerror = null;
-    _onerror = (ev) => { executeFn.call(this.target, this.onerror, ev); };
-    onload = null;
-    _onload = (ev) => { executeFn.call(this.target, this.onload, ev); };
-    onloadend = null;
-    _onloadend = (ev) => { executeFn.call(this.target, this.onloadend, ev); };
-    onloadstart = null;
-    _onloadstart = (ev) => { executeFn.call(this.target, this.onloadstart, ev); };
-    onprogress = null;
-    _onprogress = (ev) => { executeFn.call(this.target, this.onprogress, ev); };
-    ontimeout = null;
-    _ontimeout = (ev) => { executeFn.call(this.target, this.ontimeout, ev); };
+}
+_a$3 = _handlers$1;
+function attach(type) {
+    const fnName = ("on" + type);
+    const cb = this[fnName];
+    const listener = this[_handlers$1][fnName];
+    attachFn.call(this.target, type, cb, listener);
+}
+function getHandlers$1() {
+    return {
+        onabort: (ev) => { executeFn.call(this.target, this.onabort, ev); },
+        onerror: (ev) => { executeFn.call(this.target, this.onerror, ev); },
+        onload: (ev) => { executeFn.call(this.target, this.onload, ev); },
+        onloadend: (ev) => { executeFn.call(this.target, this.onloadend, ev); },
+        onloadstart: (ev) => { executeFn.call(this.target, this.onloadstart, ev); },
+        onprogress: (ev) => { executeFn.call(this.target, this.onprogress, ev); },
+        ontimeout: (ev) => { executeFn.call(this.target, this.ontimeout, ev); },
+    };
 }
 
 class XMLHttpRequestUploadP extends XMLHttpRequestEventTargetP {
@@ -1404,11 +1465,36 @@ class XMLHttpRequestUploadP extends XMLHttpRequestEventTargetP {
 defineStringTag(XMLHttpRequestUploadP, "XMLHttpRequestUpload");
 function createXMLHttpRequestUploadP() {
     const instance = Object.create(XMLHttpRequestUploadP.prototype);
-    instance[state$7] = new EventTargetState(instance);
-    instance[state$9] = new XMLHttpRequestEventTargetState(instance);
+    instance[state$f] = new EventTargetState(instance);
+    instance[state$5] = new XMLHttpRequestEventTargetState(instance);
     return instance;
 }
 
+// @ts-nocheck
+const mp = (() => {
+    let u = "undefined", r = "request", f = "function";
+    let mp;
+    mp =
+        (typeof wx !== u && typeof (wx === null || wx === void 0 ? void 0 : wx[r]) === f && wx) || // 微信
+            (typeof my !== u && typeof (my === null || my === void 0 ? void 0 : my[r]) === f && my) || // 支付宝
+            (typeof qq !== u && typeof (qq === null || qq === void 0 ? void 0 : qq[r]) === f && qq) || // QQ
+            (typeof jd !== u && typeof (jd === null || jd === void 0 ? void 0 : jd[r]) === f && jd) || // 京东
+            (typeof swan !== u && typeof (swan === null || swan === void 0 ? void 0 : swan[r]) === f && swan) || // 百度
+            (typeof tt !== u && typeof (tt === null || tt === void 0 ? void 0 : tt[r]) === f && tt) || // 抖音 | 飞书
+            (typeof ks !== u && typeof (ks === null || ks === void 0 ? void 0 : ks[r]) === f && ks) || // 快手
+            (typeof qh !== u && typeof (qh === null || qh === void 0 ? void 0 : qh[r]) === f && qh) || // 360
+            undefined;
+    if (typeof g["XMLHttpRequest"] === f) {
+        return;
+    }
+    if (mp === undefined)
+        mp =
+            (typeof uni !== u && typeof (uni === null || uni === void 0 ? void 0 : uni[r]) === f && uni) || // UniApp
+                (typeof Taro !== u && typeof (Taro === null || Taro === void 0 ? void 0 : Taro[r]) === f && Taro) || // Taro
+                undefined;
+    return mp;
+})();
+
 const request = mp ? mp.request : function errorRequest(options) {
     const errMsg = "NOT_SUPPORTED_ERR";
     const errno = 9;
@@ -1422,300 +1508,319 @@ const request = mp ? mp.request : function errorRequest(options) {
         useHttpDNS: false,
     };
     Promise.resolve(err)
-        .then(err => { if (options.fail) {
-        options.fail(err);
+        .then(err => { try {
+        if (options.fail) {
+            options.fail(err);
+        }
+    }
+    catch (e) {
+        console.warn(e);
     } })
-        .finally(() => { if (options.complete) {
+        .then(() => { if (options.complete) {
         options.complete(err);
     } });
     throw new ReferenceError("request is not defined");
 };
 
-const state$1 = Symbol("XMLHttpRequestState");
+var _a$2, _b$1, _c, _d, _e, _f, _g, _h, _j, _k;
+const state$4 = Symbol( /* "XMLHttpRequestState" */);
 class XMLHttpRequestP extends XMLHttpRequestEventTargetP {
-    static UNSENT = 0;
-    static OPENED = 1;
-    static HEADERS_RECEIVED = 2;
-    static LOADING = 3;
-    static DONE = 4;
     constructor() {
         super();
-        this[state$1] = new XMLHttpRequestState(this);
-    }
-    [state$1];
-    UNSENT = 0;
-    OPENED = 1;
-    HEADERS_RECEIVED = 2;
-    LOADING = 3;
-    DONE = 4;
-    get readyState() { return this[state$1].readyState; }
-    get response() { return this[state$1].response; }
+        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; }
+    get response() { return this[state$4].response; }
     get responseText() { return (!this.responseType || this.responseType === "text") ? this.response : ""; }
-    get responseType() { return this[state$1].responseType; }
-    set responseType(value) { this[state$1].responseType = value; }
-    get responseURL() { return this[state$1].responseURL; }
+    get responseType() { return this[state$4].responseType; }
+    set responseType(value) { this[state$4].responseType = value; }
+    get responseURL() { return this[state$4].responseURL; }
     get responseXML() { return null; }
-    get status() { return this[state$1].status; }
+    get status() { return this[state$4].status; }
     get statusText() {
         if (this.readyState === XMLHttpRequestP.UNSENT || this.readyState === XMLHttpRequestP.OPENED)
             return "";
-        return this[state$1].statusText || statusTextMap(this.status);
+        return this[state$4].statusText || statusTextMap(this.status);
     }
-    get timeout() { return this[state$1].timeout; }
-    set timeout(value) { this[state$1].timeout = value; }
-    get upload() { return this[state$1].upload; }
-    get withCredentials() { return this[state$1].withCredentials; }
-    set withCredentials(value) { this[state$1].withCredentials = value; }
+    get timeout() { return this[state$4].timeout; }
+    set timeout(value) { this[state$4].timeout = value; }
+    get upload() { return this[state$4].upload; }
+    get withCredentials() { return this[state$4].withCredentials; }
+    set withCredentials(value) { this[state$4].withCredentials = value; }
     abort() {
-        this[state$1].clearRequest();
+        clearRequest.call(this[state$4]);
     }
     getAllResponseHeaders() {
-        if (!this[state$1]._resHeaders)
+        if (!this[state$4][_responseHeaders])
             return "";
-        return Object.entries(this[state$1]._resHeaders || {}).map(([k, v]) => `${k}: ${v}\r\n`).join("");
+        return objectEntries(this[state$4][_responseHeaders] || {}).map(([k, v]) => `${k}: ${v}\r\n`).join("");
     }
     getResponseHeader(name) {
-        if (!this[state$1]._resHeaders)
+        var _l, _m;
+        if (!this[state$4][_responseHeaders])
             return null;
-        return Object.entries(this[state$1]._resHeaders || {}).find(x => x[0].toLowerCase() === name.toLowerCase())?.[1] ?? null;
+        const 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) {
         const [method, url, async = true, username = null, password = null] = args;
+        const that = this[state$4];
         if (args.length < 2) {
             throw new TypeError(`Failed to execute 'open' on 'XMLHttpRequest': 2 arguments required, but only ${args.length} present.`);
         }
         if (!async) {
-            console.warn("Synchronous XMLHttpRequest is deprecated because of its detrimental effects to the end user's experience.");
+            console.warn("Synchronous XMLHttpRequest is not supported because of its detrimental effects to the end user's experience.");
+        }
+        clearRequest.call(that, false);
+        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 : "");
+            if (_username.length > 0 || _password.length > 0) {
+                const auth = `Basic ${u8array2base64((new TextEncoderP()).encode(_username + ":" + _password))}`;
+                this.setRequestHeader("Authorization", auth);
+            }
+        }
+        that[_inAfterOpenBeforeSend] = true;
+        setReadyStateAndNotify.call(that, XMLHttpRequestP.OPENED);
+    }
+    overrideMimeType(mime) {
+        if (this[state$4][_inAfterOpenBeforeSend]) {
+            console.warn(`XMLHttpRequest.overrideMimeType(${mime}) is not implemented: The method will have no effect on response parsing.`);
         }
-        this[state$1].clearRequest(false);
-        this[state$1]._method = normalizeMethod(method);
-        this[state$1]._reqURL = String(url);
-        this[state$1]._reqCanSend = true;
-        this[state$1].setReadyStateAndNotify(XMLHttpRequestP.OPENED);
     }
-    overrideMimeType(mime) { }
     send(body) {
-        if (!this[state$1]._reqCanSend || this.readyState !== XMLHttpRequestP.OPENED) {
+        const that = this[state$4];
+        if (!that[_inAfterOpenBeforeSend] || that.readyState !== XMLHttpRequestP.OPENED) {
             throw new MPException("Failed to execute 'send' on 'XMLHttpRequest': The object's state must be OPENED.", "InvalidStateError");
         }
-        this[state$1]._reqCanSend = false;
-        this[state$1].execRequest(body);
-        this[state$1].checkRequestTimeout();
-    }
-    setRequestHeader(name, value) {
-        assignRequestHeader(this[state$1]._reqHeaders, name, value);
-    }
-    get onreadystatechange() { return this[state$1].onreadystatechange; }
-    set onreadystatechange(value) {
-        this[state$1].onreadystatechange = value;
-        attachFn.call(this, "readystatechange", value, this[state$1]._onreadystatechange);
-    }
-    toString() { return "[object XMLHttpRequest"; }
-    get isPolyfill() { return { symbol: polyfill, hierarchy: ["XMLHttpRequest", "XMLHttpRequestEventTarget", "EventTarget"] }; }
-}
-defineStringTag(XMLHttpRequestP, "XMLHttpRequest");
-class XMLHttpRequestState {
-    constructor(target) {
-        this.target = target;
-        this.upload = createXMLHttpRequestUploadP();
-    }
-    target;
-    readyState = XMLHttpRequestP.UNSENT;
-    response = "";
-    responseType = "";
-    responseURL = "";
-    status = 0;
-    statusText = "";
-    timeout = 0;
-    upload;
-    withCredentials = false;
-    _reqCanSend = false;
-    _resetPending = false;
-    _timeoutId = 0;
-    _reqURL = "";
-    _method = "GET";
-    _reqHeaders = { Accept: "*/*" };
-    _resHeaders = null;
-    _resContLen = 0;
-    _requestTask = null;
-    execRequest(body) {
-        const allowsRequestBody = !["GET", "HEAD"].includes(this._method);
-        const contentTypeExists = Object.keys(this._reqHeaders).map(x => x.toLowerCase()).includes("Content-Type".toLowerCase());
-        const processHeaders = allowsRequestBody && !contentTypeExists;
-        const processContentLength = this.upload[state$7].executors.length > 0;
-        let headers = { ...this._reqHeaders };
+        that[_inAfterOpenBeforeSend] = false;
+        const allowsRequestBody = ["GET", "HEAD"].indexOf(that[_method]) === -1;
+        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;
-        let data = convert(body, processHeaders ? v => { headers["Content-Type"] = v; } : void 0, processContentLength ? v => { contentLength = v; } : void 0);
-        this._requestTask = request({
-            url: this._reqURL,
-            method: this._method,
+        let data = convert(body, processHeaders ? v => { assignRequestHeader(headers, "Content-Type", v); } : void 0, processContentLength ? v => { contentLength = v; } : void 0);
+        that[_requestTask] = request({
+            url: that[_requestURL],
+            method: that[_method],
             header: headers,
             data,
-            dataType: this.responseType === "json" ? "json" : "text",
-            responseType: this.responseType === "arraybuffer" ? "arraybuffer" : "text",
-            success: this.requestSuccess.bind(this),
-            fail: this.requestFail.bind(this),
-            complete: this.requestComplete.bind(this),
+            dataType: that.responseType === "json" ? "json" : normalizeDataType(that.responseType),
+            responseType: normalizeDataType(that.responseType),
+            success: requestSuccess.bind(that),
+            fail: requestFail.bind(that),
+            complete: requestComplete.bind(that),
         });
-        this.emitProcessEvent("loadstart");
+        emitProcessEvent(this, "loadstart");
         if (processContentLength) {
-            const hasRequestBody = allowsRequestBody && contentLength > 0;
+            const hasRequestBody = allowsRequestBody && (typeof data === "string" ? data.length > 0 : data.byteLength > 0);
             if (hasRequestBody) {
-                this.emitProcessEvent("loadstart", 0, contentLength, this.upload);
+                emitProcessEvent(that.upload, "loadstart", 0, contentLength);
             }
             setTimeout(() => {
-                const _aborted = this._reqCanSend || this.readyState !== XMLHttpRequestP.OPENED;
+                const _aborted = that[_inAfterOpenBeforeSend] || that.readyState !== XMLHttpRequestP.OPENED;
                 const _contentLength = _aborted ? 0 : contentLength;
                 if (_aborted) {
-                    this.emitProcessEvent("abort", 0, 0, this.upload);
+                    emitProcessEvent(that.upload, "abort");
                 }
                 else {
                     if (hasRequestBody) {
-                        this.emitProcessEvent("load", _contentLength, _contentLength, this.upload);
+                        emitProcessEvent(that.upload, "load", _contentLength, _contentLength);
                     }
                 }
                 if (_aborted || hasRequestBody) {
-                    this.emitProcessEvent("loadend", _contentLength, _contentLength, this.upload);
+                    emitProcessEvent(that.upload, "loadend", _contentLength, _contentLength);
                 }
             });
         }
+        checkRequestTimeout.call(that);
     }
-    requestSuccess({ statusCode, header, data }) {
-        this.responseURL = this._reqURL;
-        this.status = statusCode;
-        this._resHeaders = header;
-        this._resContLen = parseInt(this.target.getResponseHeader("Content-Length") || "0");
-        if (this.readyState === XMLHttpRequestP.OPENED) {
-            this.setReadyStateAndNotify(XMLHttpRequestP.HEADERS_RECEIVED);
-            this.setReadyStateAndNotify(XMLHttpRequestP.LOADING);
-            setTimeout(() => {
-                if (!this._reqCanSend) {
-                    let l = this._resContLen;
-                    try {
-                        this.response = convertBack(this.responseType, data);
-                        this.emitProcessEvent("load", l, l);
-                    }
-                    catch (e) {
-                        console.error(e);
-                        this.emitProcessEvent("error");
-                    }
-                }
-            });
-        }
+    setRequestHeader(name, value) {
+        assignRequestHeader(this[state$4][_requestHeaders], name, value);
     }
-    requestFail(err) {
-        // Alipay Mini Programs
-        // error: 14 --- JSON parse data error
-        // error: 19 --- http status error
-        // At this point, the error data object will contain three pieces of information
-        // returned from the server: status, headers, and data.
-        // In the browser's XMLHttpRequest, these two errors (Error 14 and Error 19)
-        // differ from those in Alipay Mini Programs and should instead return normally.
-        // Therefore, this scenario is also handled here as a successful request response.
-        if ("status" in err) {
-            this.requestSuccess({ statusCode: err.status, header: err.headers, data: err.data });
-            return;
-        }
+    get onreadystatechange() { return this[state$4].onreadystatechange; }
+    set onreadystatechange(value) {
+        this[state$4].onreadystatechange = value;
+        attachFn.call(this, "readystatechange", value, this[state$4][_handlers].onreadystatechange);
+    }
+    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;
+defineStringTag(XMLHttpRequestP, "XMLHttpRequest");
+const _handlers = Symbol();
+const _inAfterOpenBeforeSend = Symbol();
+const _resetPending = Symbol();
+const _timeoutId = Symbol();
+const _requestURL = Symbol();
+const _method = Symbol();
+const _requestHeaders = Symbol();
+const _responseHeaders = Symbol();
+const _responseContentLength = Symbol();
+const _requestTask = Symbol();
+class XMLHttpRequestState {
+    constructor(target) {
+        this.readyState = XMLHttpRequestP.UNSENT;
+        this.response = "";
+        this.responseType = "";
+        this.responseURL = "";
         this.status = 0;
-        this.statusText = "errMsg" in err ? err.errMsg : "errorMessage" in err ? err.errorMessage : "";
-        if (!this._reqCanSend && this.readyState !== XMLHttpRequestP.UNSENT && this.readyState !== XMLHttpRequestP.DONE) {
-            this.emitProcessEvent("error");
-            this.resetRequestTimeout();
-        }
+        this.statusText = "";
+        this.timeout = 0;
+        this.withCredentials = false;
+        this[_a$2] = getHandlers.call(this);
+        this.onreadystatechange = null;
+        this[_b$1] = false;
+        this[_c] = false;
+        this[_d] = 0;
+        this[_e] = "";
+        this[_f] = "GET";
+        this[_g] = { Accept: "*/*" };
+        this[_h] = null;
+        this[_j] = 0;
+        this[_k] = null;
+        this.target = target;
+        this.upload = createXMLHttpRequestUploadP();
     }
-    requestComplete() {
-        this._requestTask = null;
-        if (!this._reqCanSend && (this.readyState === XMLHttpRequestP.OPENED || this.readyState === XMLHttpRequestP.LOADING)) {
-            this.setReadyStateAndNotify(XMLHttpRequestP.DONE);
-        }
+}
+_a$2 = _handlers, _b$1 = _inAfterOpenBeforeSend, _c = _resetPending, _d = _timeoutId, _e = _requestURL, _f = _method, _g = _requestHeaders, _h = _responseHeaders, _j = _responseContentLength, _k = _requestTask;
+function requestSuccess({ statusCode, header, data }) {
+    this.responseURL = this[_requestURL];
+    this.status = statusCode;
+    this[_responseHeaders] = header;
+    const lengthStr = this.target.getResponseHeader("Content-Length");
+    this[_responseContentLength] = () => { return lengthStr ? parseInt(lengthStr) : 0; };
+    if (this.readyState === XMLHttpRequestP.OPENED) {
+        setReadyStateAndNotify.call(this, XMLHttpRequestP.HEADERS_RECEIVED);
+        setReadyStateAndNotify.call(this, XMLHttpRequestP.LOADING);
         setTimeout(() => {
-            if (!this._reqCanSend) {
-                let l = this._resContLen;
-                this.emitProcessEvent("loadend", l, l);
+            if (!this[_inAfterOpenBeforeSend]) {
+                let l = this[_responseContentLength];
+                try {
+                    this.response = convertBack(this.responseType, data);
+                    emitProcessEvent(this.target, "load", l, l);
+                }
+                catch (e) {
+                    console.error(e);
+                    emitProcessEvent(this.target, "error");
+                }
             }
         });
     }
-    clearRequest(delay = true) {
-        const timerFn = delay ? setTimeout : (f) => { f(); };
-        this._resetPending = true;
-        if (this._requestTask && this.readyState !== XMLHttpRequestP.DONE) {
-            if (delay) {
-                this.setReadyStateAndNotify(XMLHttpRequestP.DONE);
-            }
-            timerFn(() => {
-                const requestTask = this._requestTask;
-                if (requestTask) {
-                    requestTask.abort();
-                }
-                if (delay) {
-                    this.emitProcessEvent("abort");
-                }
-                if (delay && !requestTask) {
-                    this.emitProcessEvent("loadend");
-                }
-            });
+}
+function requestFail(err) {
+    // Alipay Mini Programs
+    // error: 14 --- JSON parse data error
+    // error: 19 --- http status error
+    // At this point, the error data object will contain three pieces of information
+    // returned from the server: status, headers, and data.
+    // In the browser's XMLHttpRequest, these two errors (Error 14 and Error 19)
+    // differ from those in Alipay Mini Programs and should instead return normally.
+    // Therefore, this scenario is also handled here as a successful request response.
+    if ("status" in err) {
+        requestSuccess.call(this, { statusCode: err.status, header: err.headers, data: err.data });
+        return;
+    }
+    this.status = 0;
+    this.statusText = "errMsg" in err ? err.errMsg : "errorMessage" in err ? err.errorMessage : "";
+    if (!this[_inAfterOpenBeforeSend] && this.readyState !== XMLHttpRequestP.UNSENT && this.readyState !== XMLHttpRequestP.DONE) {
+        emitProcessEvent(this.target, "error");
+        resetRequestTimeout.call(this);
+    }
+}
+function requestComplete() {
+    this[_requestTask] = null;
+    if (!this[_inAfterOpenBeforeSend] && (this.readyState === XMLHttpRequestP.OPENED || this.readyState === XMLHttpRequestP.LOADING)) {
+        setReadyStateAndNotify.call(this, XMLHttpRequestP.DONE);
+    }
+    setTimeout(() => {
+        if (!this[_inAfterOpenBeforeSend]) {
+            let l = this[_responseContentLength];
+            emitProcessEvent(this.target, "loadend", l, l);
+        }
+    });
+}
+function clearRequest(delay = true) {
+    const timerFn = delay ? setTimeout : (f) => { f(); };
+    this[_resetPending] = true;
+    if (this[_requestTask] && this.readyState !== XMLHttpRequestP.DONE) {
+        if (delay) {
+            setReadyStateAndNotify.call(this, XMLHttpRequestP.DONE);
         }
         timerFn(() => {
-            if (this._resetPending) {
-                if (delay) {
-                    this.readyState = XMLHttpRequestP.UNSENT;
-                }
-                this.resetXHR();
+            const requestTask = this[_requestTask];
+            if (requestTask) {
+                requestTask.abort();
+            }
+            if (delay) {
+                emitProcessEvent(this.target, "abort");
+            }
+            if (delay && !requestTask) {
+                emitProcessEvent(this.target, "loadend");
             }
         });
     }
-    checkRequestTimeout() {
-        if (this.timeout) {
-            this._timeoutId = setTimeout(() => {
-                if (!this.status && this.readyState !== XMLHttpRequestP.DONE) {
-                    if (this._requestTask)
-                        this._requestTask.abort();
-                    this.setReadyStateAndNotify(XMLHttpRequestP.DONE);
-                    this.emitProcessEvent("timeout");
-                }
-            }, this.timeout);
+    timerFn(() => {
+        if (this[_resetPending]) {
+            if (delay) {
+                this.readyState = XMLHttpRequestP.UNSENT;
+            }
+            resetXHR.call(this);
         }
+    });
+}
+function checkRequestTimeout() {
+    if (this.timeout) {
+        this[_timeoutId] = setTimeout(() => {
+            if (!this.status && this.readyState !== XMLHttpRequestP.DONE) {
+                if (this[_requestTask])
+                    this[_requestTask].abort();
+                setReadyStateAndNotify.call(this, XMLHttpRequestP.DONE);
+                emitProcessEvent(this.target, "timeout");
+            }
+        }, this.timeout);
     }
-    resetXHR() {
-        this._resetPending = false;
-        this.resetRequestTimeout();
-        this.response = "";
-        this.responseURL = "";
-        this.status = 0;
-        this.statusText = "";
-        this._reqHeaders = {};
-        this._resHeaders = null;
-        this._resContLen = 0;
-    }
-    resetRequestTimeout() {
-        if (this._timeoutId) {
-            clearTimeout(this._timeoutId);
-            this._timeoutId = 0;
-        }
-    }
-    emitProcessEvent(type, loaded = 0, total = 0, target) {
-        const _target = target ?? this.target;
-        const _event = new ProgressEventP(type, {
-            lengthComputable: total > 0,
-            loaded,
-            total,
-        });
-        _event[state$9].target = _target;
-        _event[state$9].isTrusted = true;
-        _target[state$7].fire(_event);
+}
+function resetXHR() {
+    this[_resetPending] = false;
+    resetRequestTimeout.call(this);
+    this.response = "";
+    this.responseURL = "";
+    this.status = 0;
+    this.statusText = "";
+    this[_requestHeaders] = {};
+    this[_responseHeaders] = null;
+    this[_responseContentLength] = 0;
+}
+function resetRequestTimeout() {
+    if (this[_timeoutId]) {
+        clearTimeout(this[_timeoutId]);
+        this[_timeoutId] = 0;
     }
-    setReadyStateAndNotify(value) {
-        const hasChanged = value !== this.readyState;
-        this.readyState = value;
-        if (hasChanged) {
-            const evt = new EventP("readystatechange");
-            evt[state$9].target = this.target;
-            evt[state$9].isTrusted = true;
-            this.target[state$7].fire(evt);
-        }
+}
+function setReadyStateAndNotify(value) {
+    const hasChanged = value !== this.readyState;
+    this.readyState = value;
+    if (hasChanged) {
+        const evt = createInnerEvent(this.target, "readystatechange");
+        fire.call(this.target[state$f], evt);
     }
-    onreadystatechange = null;
-    _onreadystatechange = (ev) => { executeFn.call(this.target, this.onreadystatechange, ev); };
+}
+function getHandlers() {
+    return {
+        onreadystatechange: (ev) => { executeFn.call(this.target, this.onreadystatechange, ev); },
+    };
 }
 // HTTP methods whose capitalization should be normalized
 const methods = ["CONNECT", "DELETE", "GET", "HEAD", "OPTIONS", "PATCH", "POST", "PUT", "TRACE"];
@@ -1723,9 +1828,13 @@ function normalizeMethod(method) {
     let upcased = method.toUpperCase();
     return methods.indexOf(upcased) > -1 ? upcased : method;
 }
+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)) {
-        if (key.toLowerCase() === name.toLowerCase()) {
+        if (key.toLowerCase() === nameKey) {
             headers[key] = value;
             return;
         }
@@ -1762,14 +1871,14 @@ function convert(body, setContentType, setContentLength) {
         result = body.buffer.slice(body.byteOffset, body.byteOffset + body.byteLength);
     }
     else if (isPolyfillType("Blob", body)) {
-        result = body[state$9]._u8array.buffer.slice(0);
+        result = body[state$c][_u8array].buffer.slice(0);
         if (setContentType && body.type) {
             setContentType(body.type);
         }
     }
     else if (isPolyfillType("FormData", body)) {
         const blob = body[state$9].toBlob();
-        result = blob[state$9]._u8array.buffer;
+        result = blob[state$c][_u8array].buffer;
         if (setContentType) {
             setContentType(blob.type);
         }
@@ -1781,7 +1890,12 @@ function convert(body, setContentType, setContentLength) {
         result = String(body);
     }
     if (setContentLength) {
-        setContentLength((typeof result === "string" ? encode(result) : result).byteLength);
+        if (typeof result === "string") {
+            setContentLength(() => { return encode(result).byteLength; });
+        }
+        else {
+            setContentLength(result.byteLength);
+        }
     }
     return result;
 }
@@ -1869,109 +1983,119 @@ const statusMessages = {
 function statusTextMap(val) {
     return statusMessages[val] || "unknown";
 }
-const XMLHttpRequestE = !mp ? g["XMLHttpRequest"] : XMLHttpRequestP;
+const XMLHttpRequestE = (typeof XMLHttpRequest !== "undefined" && XMLHttpRequest) || XMLHttpRequestP;
 
-const state = Symbol("BodyState");
+var _a$1, _b;
+const state$3 = Symbol( /* "BodyState" */);
 class BodyP {
     constructor() {
         if (new.target === BodyP) {
             throw new TypeError("Failed to construct 'Body': Illegal constructor");
         }
-        this[state] = new BodyState();
+        this[state$3] = new BodyState();
     }
-    [state];
     get body() {
-        if (!this[state]._body) {
+        if (!this[state$3][_body]) {
             return null;
         }
         throw new ReferenceError("ReadableStream is not defined");
     }
-    get bodyUsed() { return this[state].bodyUsed; }
+    get bodyUsed() { return this[state$3].bodyUsed; }
     ;
     arrayBuffer() {
         const kind = "arrayBuffer";
-        return this[state].consumed(kind) || this[state].read(kind);
+        return consumed.call(this[state$3], kind) || read.call(this[state$3], kind);
     }
     blob() {
         const kind = "blob";
-        return this[state].consumed(kind) || this[state].read(kind);
+        return consumed.call(this[state$3], kind) || read.call(this[state$3], kind);
     }
     bytes() {
         const kind = "bytes";
-        return this[state].consumed(kind) || this[state].read(kind);
+        return consumed.call(this[state$3], kind) || read.call(this[state$3], kind);
     }
     formData() {
         const kind = "formData";
-        return this[state].consumed(kind) || this[state].read(kind);
+        return consumed.call(this[state$3], kind) || read.call(this[state$3], kind);
     }
     json() {
         const kind = "json";
-        return this[state].consumed(kind) || this[state].read(kind);
+        return consumed.call(this[state$3], kind) || read.call(this[state$3], kind);
     }
     text() {
         const kind = "text";
-        return this[state].consumed(kind) || this[state].read(kind);
+        return consumed.call(this[state$3], kind) || read.call(this[state$3], kind);
     }
     toString() { return "[object Body]"; }
     get isPolyfill() { return { symbol: polyfill, hierarchy: ["Body"] }; }
 }
 defineStringTag(BodyP, "Body");
+const _name = Symbol();
+const _body = Symbol();
 class BodyState {
-    bodyUsed = false;
-    _name = "Body";
-    _body = "";
-    init(body, headers) {
-        if (isObjectType("ReadableStream", body)) {
-            throw new ReferenceError("ReadableStream is not defined");
-        }
-        this._body = convert(body, type => {
-            if (headers && !headers.get("Content-Type")) {
-                headers.set("Content-Type", type);
-            }
-        });
+    constructor() {
+        this.bodyUsed = false;
+        this[_a$1] = "Body";
+        this[_b] = "";
     }
-    read(kind) {
-        return new Promise((resolve, reject) => {
-            try {
-                if (kind === "arrayBuffer") {
-                    resolve(convertBack("arraybuffer", this._body));
-                }
-                else if (kind === "blob") {
-                    resolve(convertBack("blob", this._body));
-                }
-                else if (kind === "bytes") {
-                    let arrayBuffer = convertBack("arraybuffer", this._body);
-                    resolve(new Uint8Array(arrayBuffer));
-                }
-                else if (kind === "formData") {
-                    let text = convertBack("text", this._body);
-                    resolve(createFormData(text));
-                }
-                else if (kind === "json") {
-                    resolve(convertBack("json", this._body));
-                }
-                else {
-                    resolve(convertBack("text", this._body));
-                }
-            }
-            catch (e) {
-                reject(e);
-            }
-        });
+}
+_a$1 = _name, _b = _body;
+function initFn(body, headers) {
+    if (isObjectType("ReadableStream", body)) {
+        throw new ReferenceError("ReadableStream is not defined");
     }
-    consumed(kind) {
-        if (!this._body)
-            return;
-        if (this.bodyUsed) {
-            return Promise.reject(new TypeError(`TypeError: Failed to execute '${kind}' on '${this._name}': body stream already read`));
+    this[_body] = convert(body, type => {
+        if (headers && !headers.get("Content-Type")) {
+            headers.set("Content-Type", type);
+        }
+    });
+}
+function read(kind) {
+    return new Promise((resolve, reject) => {
+        try {
+            resolve(readSync.call(this, kind));
+        }
+        catch (e) {
+            reject(e);
         }
-        this.bodyUsed = true;
+    });
+}
+function readSync(kind) {
+    if (kind === "arrayBuffer") {
+        return convertBack("arraybuffer", this[_body]);
+    }
+    else if (kind === "blob") {
+        return convertBack("blob", this[_body]);
+    }
+    else if (kind === "bytes") {
+        let arrayBuffer = convertBack("arraybuffer", this[_body]);
+        return new Uint8Array(arrayBuffer);
+    }
+    else if (kind === "formData") {
+        let text = convertBack("text", this[_body]);
+        return createFormDataFromBody(text);
+    }
+    else if (kind === "json") {
+        return convertBack("json", this[_body]);
+    }
+    else {
+        return convertBack("text", this[_body]);
     }
 }
+function consumed(kind) {
+    if (!this[_body])
+        return;
+    if (this.bodyUsed) {
+        return Promise.reject(new TypeError(`TypeError: Failed to execute '${kind}' on '${this[_name]}': body stream already read`));
+    }
+    this.bodyUsed = true;
+}
 
+var _a;
+const state$2 = Symbol( /* "HeadersState" */);
 class HeadersP {
     constructor(init) {
-        this[state$9] = new HeadersState();
+        this[state$2] = new HeadersState();
         if (isObjectType("Headers", init)) {
             init.forEach((value, name) => {
                 this.append(name, value);
@@ -1989,25 +2113,26 @@ class HeadersP {
             });
         }
         else if (init) {
-            Object.entries(init).forEach(([name, value]) => {
+            objectEntries(init).forEach(([name, value]) => {
                 this.append(name, value);
             });
         }
     }
-    [state$9];
     append(name, value) {
+        var _b;
         let key = normalizeName(name, "append");
         value = normalizeValue(value);
-        let oldValue = this[state$9]._map.get(key)?.[1];
-        this[state$9]._map.set(key, ["" + name, oldValue ? `${oldValue}, ${value}` : value]);
+        let oldValue = (_b = this[state$2][_headersMap].get(key)) === null || _b === void 0 ? void 0 : _b[1];
+        this[state$2][_headersMap].set(key, ["" + name, oldValue ? `${oldValue}, ${value}` : value]);
     }
     delete(name) {
         let key = normalizeName(name, "delete");
-        this[state$9]._map.delete(key);
+        this[state$2][_headersMap].delete(key);
     }
     get(name) {
+        var _b, _c;
         let key = normalizeName(name, "get");
-        return this[state$9]._map.get(key)?.[1] ?? null;
+        return (_c = (_b = this[state$2][_headersMap].get(key)) === null || _b === void 0 ? void 0 : _b[1]) !== null && _c !== void 0 ? _c : null;
     }
     getSetCookie() {
         let value = this.get("Set-Cookie");
@@ -2015,11 +2140,11 @@ class HeadersP {
     }
     has(name) {
         let key = normalizeName(name, "has");
-        return this[state$9]._map.has(key);
+        return this[state$2][_headersMap].has(key);
     }
     set(name, value) {
         let key = normalizeName(name, "set");
-        this[state$9]._map.set(key, ["" + name, normalizeValue(value)]);
+        this[state$2][_headersMap].set(key, ["" + name, normalizeValue(value)]);
     }
     forEach(callbackfn, thisArg) {
         Array.from(this.entries()).forEach(([name, value]) => {
@@ -2027,7 +2152,7 @@ class HeadersP {
         });
     }
     entries() {
-        return this[state$9]._map.values();
+        return this[state$2][_headersMap].values();
     }
     keys() {
         return Array.from(this.entries()).map(pair => pair[0]).values();
@@ -2042,9 +2167,13 @@ class HeadersP {
     get isPolyfill() { return { symbol: polyfill, hierarchy: ["Headers"] }; }
 }
 defineStringTag(HeadersP, "Headers");
+const _headersMap = Symbol();
 class HeadersState {
-    _map = new Map();
+    constructor() {
+        this[_a] = new Map();
+    }
 }
+_a = _headersMap;
 function normalizeName(name, kind = "") {
     if (typeof name !== "string") {
         name = String(name);
@@ -2062,142 +2191,186 @@ function normalizeValue(value) {
     }
     return value;
 }
+function parseHeaders(rawHeaders) {
+    let headers = new HeadersP();
+    let preProcessedHeaders = rawHeaders.replace(/\r?\n[\t ]+/g, " ");
+    preProcessedHeaders
+        .split("\r")
+        .map(function (header) {
+        return header.indexOf("\n") === 0 ? header.substring(1, header.length) : header;
+    })
+        .forEach(function (line) {
+        let parts = line.split(":");
+        let key = parts.shift().trim();
+        if (key) {
+            let value = parts.join(":").trim();
+            try {
+                headers.append(key, value);
+            }
+            catch (error) {
+                console.warn("Response " + error.message);
+            }
+        }
+    });
+    return headers;
+}
 const HeadersE = g["Headers"] || HeadersP;
 
+const state$1 = Symbol( /* "RequestState" */);
 class RequestP extends BodyP {
     constructor(input, init) {
         super();
-        this[state$9] = new RequestState();
-        this[state]._name = "Request";
-        let options = init ?? {};
+        this[state$1] = new RequestState();
+        const that = this[state$1];
+        this[state$3][_name] = "Request";
+        let options = init !== null && init !== void 0 ? init : {};
         let body = options.body;
         if (isPolyfillType("Request", input)) {
             if (input.bodyUsed) {
                 throw new TypeError("Failed to construct 'Request': Cannot construct a Request with a Request object that has already been used.");
             }
-            this[state$9].credentials = input.credentials;
+            that.credentials = input.credentials;
             if (!options.headers) {
-                this[state$9].headers = new HeadersP(input.headers);
+                that.headers = new HeadersP(input.headers);
             }
-            this[state$9].method = input.method;
-            this[state$9].mode = input.mode;
-            this[state$9].signal = input.signal;
-            this[state$9].url = input.url;
+            that.method = input.method;
+            that.mode = input.mode;
+            that.signal = input.signal;
+            that.url = input.url;
             let _input = input;
-            if (!body && _input[state]._body !== null) {
-                body = _input[state]._body;
-                _input[state].bodyUsed = true;
+            if (!body && _input[state$3][_body] !== null) {
+                body = _input[state$3][_body];
+                _input[state$3].bodyUsed = true;
             }
         }
         else {
-            this[state$9].url = String(input);
+            that.url = String(input);
         }
         if (options.credentials) {
-            this[state$9].credentials = options.credentials;
+            that.credentials = options.credentials;
         }
         if (options.headers) {
-            this[state$9].headers = new HeadersP(options.headers);
+            that.headers = new HeadersP(options.headers);
         }
         if (options.method) {
-            this[state$9].method = normalizeMethod(options.method);
+            that.method = normalizeMethod(options.method);
         }
         if (options.mode) {
-            this[state$9].mode = options.mode;
+            that.mode = options.mode;
         }
         if (options.signal) {
-            this[state$9].signal = options.signal;
+            that.signal = options.signal;
         }
         if ((this.method === "GET" || this.method === "HEAD") && body) {
             throw new TypeError("Failed to construct 'Request': Request with GET/HEAD method cannot have body.");
         }
-        this[state].init(body, this.headers);
+        initFn.call(this[state$3], body, this.headers);
         if (this.method === "GET" || this.method === "HEAD") {
             if (options.cache === "no-store" || options.cache === "no-cache") {
                 // Search for a '_' parameter in the query string
                 let reParamSearch = /([?&])_=[^&]*/;
                 if (reParamSearch.test(this.url)) {
                     // If it already exists then set the value with the current time
-                    this[state$9].url = this.url.replace(reParamSearch, "$1_=" + (new Date()).getTime());
+                    that.url = this.url.replace(reParamSearch, "$1_=" + (new Date()).getTime());
                 }
                 else {
                     // Otherwise add a new '_' parameter to the end with the current time
                     let reQueryString = /\?/;
-                    this[state$9].url += (reQueryString.test(this.url) ? "&" : "?") + "_=" + (new Date()).getTime();
+                    that.url += (reQueryString.test(this.url) ? "&" : "?") + "_=" + (new Date()).getTime();
                 }
             }
         }
     }
-    [state$9];
-    get cache() { return this[state$9].cache; }
-    get credentials() { return this[state$9].credentials; }
-    get destination() { return this[state$9].destination; }
-    get headers() { return this[state$9].headers; }
-    get integrity() { return this[state$9].integrity; }
-    get keepalive() { return this[state$9].keepalive; }
-    get method() { return this[state$9].method; }
-    get mode() { return this[state$9].mode; }
-    get redirect() { return this[state$9].redirect; }
-    get referrer() { return this[state$9].referrer; }
-    get referrerPolicy() { return this[state$9].referrerPolicy; }
-    get signal() { return this[state$9].signal; }
-    get url() { return this[state$9].url; }
+    get cache() { return this[state$1].cache; }
+    get credentials() { return this[state$1].credentials; }
+    get destination() { return this[state$1].destination; }
+    get headers() {
+        const that = this[state$1];
+        if (!that.headers) {
+            that.headers = new HeadersP();
+        }
+        return that.headers;
+    }
+    get integrity() { return this[state$1].integrity; }
+    get keepalive() { return this[state$1].keepalive; }
+    get method() { return this[state$1].method; }
+    get mode() { return this[state$1].mode; }
+    get redirect() { return this[state$1].redirect; }
+    get referrer() { return this[state$1].referrer; }
+    get referrerPolicy() { return this[state$1].referrerPolicy; }
+    get signal() {
+        const that = this[state$1];
+        if (!that.signal) {
+            that.signal = (new AbortControllerP()).signal;
+        }
+        return that.signal;
+    }
+    get url() { return this[state$1].url; }
     clone() {
-        return new RequestP(this, { body: this[state]._body ?? null });
+        var _a;
+        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"] }; }
 }
 defineStringTag(RequestP, "Request");
 class RequestState {
-    cache = "default";
-    credentials = "same-origin";
-    destination = "";
-    headers = new HeadersP();
-    integrity = "";
-    keepalive = false;
-    method = "GET";
-    mode = "cors";
-    redirect = "follow";
-    referrer = "about:client";
-    referrerPolicy = "";
-    signal = (new AbortControllerP()).signal;
-    url = "";
+    constructor() {
+        this.cache = "default";
+        this.credentials = "same-origin";
+        this.destination = "";
+        this.integrity = "";
+        this.keepalive = false;
+        this.method = "GET";
+        this.mode = "cors";
+        this.redirect = "follow";
+        this.referrer = "about:client";
+        this.referrerPolicy = "";
+        this.url = "";
+    }
 }
 const RequestE = g["Request"] || RequestP;
 
+const state = Symbol( /* "ResponseState" */);
 class ResponseP extends BodyP {
     constructor(body, init) {
         super();
-        this[state$9] = new ResponseState();
-        this[state]._name = "Response";
-        let options = init ?? {};
+        this[state] = new ResponseState();
+        const that = this[state];
+        this[state$3][_name] = "Response";
+        let options = init !== null && init !== void 0 ? init : {};
         let status = options.status === undefined ? 200 : options.status;
         if (status < 200 || status > 500) {
             throw new RangeError(`Failed to construct 'Response': The status provided (${+status}) is outside the range [200, 599].`);
         }
         if (options.headers) {
-            this[state$9].headers = new HeadersP(options.headers);
-        }
-        this[state$9].ok = this.status >= 200 && this.status < 300;
-        this[state$9].status = status;
-        this[state$9].statusText = options.statusText === undefined ? "" : "" + options.statusText;
-        this[state].init(body, this.headers);
-    }
-    [state$9];
-    get headers() { return this[state$9].headers; }
-    get ok() { return this[state$9].ok; }
-    get redirected() { return this[state$9].redirected; }
-    get status() { return this[state$9].status; }
-    get statusText() { return this[state$9].statusText; }
-    get type() { return this[state$9].type; }
-    get url() { return this[state$9].url; }
+            that.headers = new HeadersP(options.headers);
+        }
+        that.ok = this.status >= 200 && this.status < 300;
+        that.status = status;
+        that.statusText = options.statusText === undefined ? "" : "" + options.statusText;
+        initFn.call(this[state$3], body, this.headers);
+    }
+    get headers() {
+        const that = this[state];
+        if (!that.headers) {
+            that.headers = new HeadersP();
+        }
+        return that.headers;
+    }
+    get ok() { return this[state].ok; }
+    get redirected() { return this[state].redirected; }
+    get status() { return this[state].status; }
+    get statusText() { return this[state].statusText; }
+    get type() { return this[state].type; }
+    get url() { return this[state].url; }
     clone() {
-        const response = new ResponseP(this[state]._body, {
+        const response = new ResponseP(this[state$3][_body], {
             headers: new HeadersP(this.headers),
             status: this.status,
             statusText: this.statusText,
         });
-        response[state$9].url = this.url;
+        response[state].url = this.url;
         return response;
     }
     static json(data, init) {
@@ -2205,9 +2378,9 @@ class ResponseP extends BodyP {
     }
     static error() {
         const response = new ResponseP(null, { status: 200, statusText: "" });
-        response[state$9].ok = false;
-        response[state$9].status = 0;
-        response[state$9].type = "error";
+        response[state].ok = false;
+        response[state].status = 0;
+        response[state].type = "error";
         return response;
     }
     static redirect(url, status = 301) {
@@ -2221,13 +2394,14 @@ class ResponseP extends BodyP {
 }
 defineStringTag(ResponseP, "Response");
 class ResponseState {
-    headers = new HeadersP();
-    ok = true;
-    redirected = false;
-    status = 200;
-    statusText = "";
-    type = "default";
-    url = "";
+    constructor() {
+        this.ok = true;
+        this.redirected = false;
+        this.status = 200;
+        this.statusText = "";
+        this.type = "default";
+        this.url = "";
+    }
 }
 const ResponseE = g["Response"] || ResponseP;
 
@@ -2240,16 +2414,16 @@ function fetchP(input, init) {
         if (request.signal && request.signal.aborted) {
             return reject(request.signal.reason);
         }
-        let xhr = new XMLHttpRequestP();
+        let xhr = new XMLHttpRequestE();
         xhr.onload = function () {
             let options = {
-                headers: new HeadersP(xhr[state$1]._resHeaders || undefined),
+                headers: xhr instanceof XMLHttpRequestP ? (new HeadersP(xhr[state$4][_responseHeaders] || undefined)) : parseHeaders(xhr.getAllResponseHeaders() || ""),
                 status: xhr.status,
                 statusText: xhr.statusText,
             };
             setTimeout(() => {
                 const response = new ResponseP(xhr.response, options);
-                response[state$9].url = xhr.responseURL;
+                response[state].url = xhr.responseURL;
                 resolve(response);
             });
         };
@@ -2278,7 +2452,7 @@ function fetchP(input, init) {
         if (init && isObjectHeaders(init.headers)) {
             let headers = init.headers;
             let names = [];
-            Object.entries(headers).forEach(([name, value]) => {
+            objectEntries(headers).forEach(([name, value]) => {
                 names.push(normalizeName(name));
                 xhr.setRequestHeader(name, normalizeValue(value));
             });
@@ -2303,13 +2477,13 @@ function fetchP(input, init) {
                 }
             };
         }
-        xhr.send(request[state]._body);
+        xhr.send(request[state$3][_body]);
     });
 }
 function isObjectHeaders(val) {
     return typeof val === "object" && !isObjectType("Headers", val);
 }
-const fetchE = !mp ? g["fetch"] : fetchP;
+const fetchE = g["fetch"] || fetchP;
 
 exports.AbortController = AbortControllerE;
 exports.AbortControllerP = AbortControllerP;