mphttpx 1.0.1 → 1.0.3

package/dist/index.esm.js

@@ -1,5 +1,4 @@
 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) ||
@@ -19,13 +18,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) {
@@ -34,6 +33,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"; }
@@ -134,21 +139,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) {
@@ -162,28 +168,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 = [];
@@ -200,7 +206,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;
@@ -277,128 +283,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) {
@@ -408,104 +441,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";
 }
@@ -523,54 +556,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)) {
@@ -579,7 +635,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));
@@ -592,42 +648,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+/=";
@@ -674,151 +730,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) {
@@ -829,20 +885,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) {
@@ -854,15 +909,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;
             }
         }
@@ -873,13 +928,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) {
@@ -887,13 +942,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();
@@ -902,13 +957,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`);
             }
@@ -922,6 +980,7 @@ class FormDataState {
         });
     }
 }
+_a$6 = _formData;
 function normalizeArgs(name, value, filename) {
     if (isPolyfillType("Blob", value)) {
         filename = filename !== undefined
@@ -952,7 +1011,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;
@@ -961,7 +1020,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) {
@@ -975,7 +1034,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 => {
@@ -983,7 +1042,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();
@@ -994,7 +1053,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
@@ -1015,7 +1074,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 {
@@ -1028,25 +1087,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));
@@ -1057,64 +1117,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));
@@ -1125,9 +1187,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") {
@@ -1201,26 +1267,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);
@@ -1231,7 +1305,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;
     }
@@ -1240,153 +1314,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 {
@@ -1402,11 +1463,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;
@@ -1420,300 +1506,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"];
@@ -1721,9 +1826,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;
         }
@@ -1760,14 +1869,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);
         }
@@ -1779,7 +1888,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;
 }
@@ -1867,109 +1981,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);
@@ -1987,25 +2111,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");
@@ -2013,11 +2138,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]) => {
@@ -2025,7 +2150,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();
@@ -2040,9 +2165,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);
@@ -2060,142 +2189,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) {
@@ -2203,9 +2376,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) {
@@ -2219,13 +2392,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;
 
@@ -2238,16 +2412,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);
             });
         };
@@ -2276,7 +2450,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));
             });
@@ -2301,12 +2475,12 @@ 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;
 
 export { AbortControllerE as AbortController, AbortControllerP, AbortSignalE as AbortSignal, AbortSignalP, BlobE as Blob, BlobP, CustomEventE as CustomEvent, CustomEventP, EventE as Event, EventP, EventTargetE as EventTarget, EventTargetP, FileE as File, FileP, FileReaderE as FileReader, FileReaderP, FormDataE as FormData, FormDataP, HeadersE as Headers, HeadersP, ProgressEventE as ProgressEvent, ProgressEventP, RequestE as Request, RequestP, ResponseE as Response, ResponseP, TextDecoderE as TextDecoder, TextDecoderP, TextEncoderE as TextEncoder, TextEncoderP, URLSearchParamsE as URLSearchParams, URLSearchParamsP, XMLHttpRequestE as XMLHttpRequest, XMLHttpRequestP, fetchE as fetch, fetchP };