mphttpx 1.0.6 → 1.0.7

package/dist/index.esm.js

@@ -1,13 +1,24 @@
+/** @internal */
 const polyfill = Symbol("isPolyfill");
 /* eslint-disable no-prototype-builtins */
-const g = (typeof globalThis !== "undefined" && globalThis) ||
+/** @internal */ const g = (typeof globalThis !== "undefined" && globalThis) ||
     (typeof self !== "undefined" && self) ||
     // @ts-ignore eslint-disable-next-line no-undef
     (typeof global !== "undefined" && global) ||
     {};
+/** @internal */
+class MPException extends Error {
+    constructor(message, name) {
+        super();
+        this.message = message !== null && message !== void 0 ? message : this.message;
+        this.name = name !== null && name !== void 0 ? name : this.name;
+    }
+}
+/** @internal */
 function isObjectType(name, value) {
     return Object.prototype.toString.call(value) === `[object ${name}]`;
 }
+/** @internal */
 function isPolyfillType(name, value) {
     return !!value
         && typeof value === "object"
@@ -20,22 +31,18 @@ function isPolyfillType(name, value) {
         && Array.isArray(value.isPolyfill.hierarchy)
         && value.isPolyfill.hierarchy.indexOf(name) > -1;
 }
-class MPException extends Error {
-    constructor(message, name) {
-        super();
-        this.message = message !== null && message !== void 0 ? message : this.message;
-        this.name = name !== null && name !== void 0 ? name : this.name;
-    }
-}
-function defineStringTag(targetFunc, stringTag) {
+/** @internal */
+function dfStringTag(targetFunc, stringTag) {
     Object.defineProperty(targetFunc.prototype, Symbol.toStringTag, {
         configurable: true,
         value: stringTag,
     });
 }
+/** @internal */
 function objectValues(obj) {
     return Object.keys(obj).map(key => obj[key]);
 }
+/** @internal */
 function objectEntries(obj) {
     return Object.keys(obj).map(key => [key, obj[key]]);
 }
@@ -52,7 +59,7 @@ class TextEncoderP {
     toString() { return "[object TextEncoder]"; }
     get isPolyfill() { return { symbol: polyfill, hierarchy: ["TextEncoder"] }; }
 }
-defineStringTag(TextEncoderP, "TextEncoder");
+dfStringTag(TextEncoderP, "TextEncoder");
 function encodeText(input, destination) {
     const HAS_DESTINATION = typeof destination !== "undefined";
     let pos = 0;
@@ -283,7 +290,7 @@ class TextDecoderP {
     toString() { return "[object TextDecoder]"; }
     get isPolyfill() { return { symbol: polyfill, hierarchy: ["TextDecoder"] }; }
 }
-defineStringTag(TextDecoderP, "TextDecoder");
+dfStringTag(TextDecoderP, "TextDecoder");
 /** @internal */ const _bomSeen = Symbol();
 /** @internal */ const _partial = Symbol();
 /** @internal */
@@ -302,38 +309,174 @@ function getBytesPerSequence(byte) {
 }
 const TextDecoderE = g["TextDecoder"] || TextDecoderP;
 
-var _a$9, _b$2, _c$1, _d$1, _e$1, _f$1;
 /** @internal */
-const state$g = Symbol( /* "EventState" */);
+const state$g = Symbol( /* "BlobState" */);
+class BlobP {
+    constructor(blobParts = [], options) {
+        if (!Array.isArray(blobParts)) {
+            throw new TypeError("First argument to Blob constructor must be an Array.");
+        }
+        let encoder = null;
+        let chunks = blobParts.reduce((chunks, part) => {
+            if (isPolyfillType("Blob", part)) {
+                chunks.push(part[state$g][_buffer]);
+            }
+            else if (part instanceof ArrayBuffer || ArrayBuffer.isView(part)) {
+                chunks.push(BufferSource_toUint8Array(part));
+            }
+            else {
+                if (!encoder) {
+                    encoder = new TextEncoderP();
+                }
+                chunks.push(encoder.encode(String(part)));
+            }
+            return chunks;
+        }, []);
+        this[state$g] = new BlobState(concat(chunks));
+        const that = this[state$g];
+        that.size = that[_buffer].length;
+        let rawType = (options === null || options === void 0 ? void 0 : options.type) || "";
+        that.type = /[^\u0020-\u007E]/.test(rawType) ? "" : rawType.toLowerCase();
+    }
+    get size() { return this[state$g].size; }
+    get type() { return this[state$g].type; }
+    arrayBuffer() {
+        return Promise.resolve(clone(this[state$g][_buffer].buffer).buffer);
+    }
+    bytes() {
+        return Promise.resolve(clone(this[state$g][_buffer].buffer));
+    }
+    slice(start, end, contentType) {
+        let sliced = this[state$g][_buffer].slice(start !== null && start !== void 0 ? start : 0, end !== null && end !== void 0 ? end : this[state$g][_buffer].length);
+        return new BlobP([sliced], { type: contentType !== null && contentType !== void 0 ? contentType : "" });
+    }
+    stream() {
+        throw new ReferenceError("ReadableStream is not defined");
+    }
+    text() {
+        let decoder = new TextDecoderP();
+        return Promise.resolve(decoder.decode(this[state$g][_buffer]));
+    }
+    toString() { return "[object Blob]"; }
+    get isPolyfill() { return { symbol: polyfill, hierarchy: ["Blob"] }; }
+}
+dfStringTag(BlobP, "Blob");
+/** @internal */
+const _buffer = Symbol();
+/** @internal */
+class BlobState {
+    constructor(buffer) {
+        this.size = 0;
+        this.type = "";
+        this[_buffer] = buffer;
+    }
+}
+/** @internal */
+function Blob_toUint8Array(blob) {
+    return blob[state$g][_buffer];
+}
+function BufferSource_toUint8Array(buf) {
+    return buf instanceof ArrayBuffer
+        ? new Uint8Array(buf)
+        : new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+}
+function clone(buf) {
+    let sourceArray = BufferSource_toUint8Array(buf);
+    let cloneArray = new Uint8Array(new ArrayBuffer(sourceArray.byteLength));
+    cloneArray.set(sourceArray);
+    return cloneArray;
+}
+function concat(chunks) {
+    let totalByteLength = chunks.reduce((acc, cur) => acc + cur.byteLength, 0);
+    let result = new Uint8Array(totalByteLength);
+    chunks.reduce((offset, chunk) => {
+        result.set(chunk, offset);
+        return offset + chunk.byteLength;
+    }, 0);
+    return result;
+}
+/** @internal */
+function Uint8Array_toBase64(input) {
+    let byteToCharMap = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+    let output = [];
+    for (var i = 0; i < input.length; i += 3) {
+        let byte1 = input[i];
+        let haveByte2 = i + 1 < input.length;
+        let byte2 = haveByte2 ? input[i + 1] : 0;
+        let haveByte3 = i + 2 < input.length;
+        let byte3 = haveByte3 ? input[i + 2] : 0;
+        let outByte1 = byte1 >> 2;
+        let outByte2 = ((byte1 & 0x03) << 4) | (byte2 >> 4);
+        let outByte3 = ((byte2 & 0x0F) << 2) | (byte3 >> 6);
+        let outByte4 = byte3 & 0x3F;
+        if (!haveByte3) {
+            outByte4 = 64;
+            if (!haveByte2) {
+                outByte3 = 64;
+            }
+        }
+        output.push(byteToCharMap[outByte1], byteToCharMap[outByte2], byteToCharMap[outByte3], byteToCharMap[outByte4]);
+    }
+    return output.join("");
+}
+const BlobE = g["Blob"] || BlobP;
+
+/** @internal */
+const state$f = Symbol( /* "FileState" */);
+class FileP extends BlobP {
+    constructor(fileBits, fileName, options) {
+        super(fileBits, options);
+        this[state$f] = new FileState();
+        this[state$f].lastModified = +((options === null || options === void 0 ? void 0 : options.lastModified) ? new Date(options.lastModified) : new Date());
+        this[state$f].name = fileName.replace(/\//g, ":");
+    }
+    get lastModified() { return this[state$f].lastModified; }
+    get name() { return this[state$f].name; }
+    get webkitRelativePath() { return ""; }
+    toString() { return "[object File]"; }
+    get isPolyfill() { return { symbol: polyfill, hierarchy: ["File", "Blob"] }; }
+}
+dfStringTag(FileP, "File");
+/** @internal */
+class FileState {
+    constructor() {
+        this.lastModified = 0;
+        this.name = "";
+    }
+}
+const FileE = g["Blob"] ? g["File"] : FileP;
+
+var _a$9, _b$2, _c$1, _d$1, _e$1;
+/** @internal */ const state$e = Symbol( /* "EventState" */);
 class EventP {
     constructor(type, eventInitDict) {
-        this[state$g] = new EventState();
-        const that = this[state$g];
+        this[state$e] = new EventState();
+        const that = this[state$e];
         that.type = String(type);
         that.bubbles = !!(eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.bubbles);
         that.cancelable = !!(eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.cancelable);
         that.composed = !!(eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.composed);
         Object.defineProperty(this, "isTrusted", {
             enumerable: true,
-            get: (function isTrusted() { return this[state$g][_isTrusted]; }).bind(this),
+            get: (function isTrusted() { return this[state$e][_isTrusted]; }).bind(this),
         });
     }
-    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; }
+    get type() { return this[state$e].type; }
+    get bubbles() { return this[state$e].bubbles; }
+    get cancelable() { return this[state$e].cancelable; }
+    get composed() { return this[state$e].composed; }
+    get target() { return this[state$e].target; }
+    get currentTarget() { return this[state$e].currentTarget; }
+    get eventPhase() { return this[state$e].eventPhase; }
+    get srcElement() { return this[state$e].target; }
+    get cancelBubble() { return this[state$e].cancelBubble; }
+    set cancelBubble(value) { this[state$e].cancelBubble = value; }
+    get defaultPrevented() { return this[state$e].defaultPrevented; }
+    get returnValue() { return this[state$e].returnValue; }
     set returnValue(value) { if (!value) {
         this.preventDefault();
     } }
-    get timeStamp() { return this[state$g].timeStamp; }
+    get timeStamp() { return this[state$e].timeStamp; }
     composedPath() {
         let path = !!this.target ? [this.target] : [];
         if (!!this.currentTarget && this.currentTarget !== this.target)
@@ -341,7 +484,7 @@ class EventP {
         return path;
     }
     initEvent(type, bubbles, cancelable) {
-        const that = this[state$g];
+        const that = this[state$e];
         if (that[_dispatched])
             return;
         that.type = String(type);
@@ -349,7 +492,7 @@ class EventP {
         that.cancelable = !!cancelable;
     }
     preventDefault() {
-        const that = this[state$g];
+        const that = this[state$e];
         if (that[_passive]) {
             console.warn(`Ignoring 'preventDefault()' call on event of type '${this.type}' from a listener registered as 'passive'.`);
             return;
@@ -361,7 +504,7 @@ class EventP {
         }
     }
     stopImmediatePropagation() {
-        this[state$g][_stopImmediatePropagationCalled] = true;
+        this[state$e][_stopImmediatePropagationCalled] = true;
         this.cancelBubble = true;
     }
     stopPropagation() {
@@ -378,13 +521,13 @@ const properties$2 = {
 };
 Object.defineProperties(EventP, properties$2);
 Object.defineProperties(EventP.prototype, properties$2);
-defineStringTag(EventP, "Event");
-/** @internal */ const _TimeStamp = Symbol();
-const _isTrusted = Symbol();
-const _passive = Symbol();
-const _dispatched = Symbol();
-const _preventDefaultCalled = Symbol();
-const _stopImmediatePropagationCalled = Symbol();
+dfStringTag(EventP, "Event");
+/** @internal */ const _timeStamp = (new Date()).getTime();
+/** @internal */ const _isTrusted = Symbol();
+/** @internal */ const _passive = Symbol();
+/** @internal */ const _dispatched = Symbol();
+/** @internal */ const _preventDefaultCalled = Symbol();
+/** @internal */ const _stopImmediatePropagationCalled = Symbol();
 /** @internal */
 class EventState {
     constructor() {
@@ -398,33 +541,81 @@ class EventState {
         this.cancelBubble = false;
         this.defaultPrevented = false;
         this.returnValue = true;
-        this.timeStamp = (new Date()).getTime() - EventState[_TimeStamp];
+        this.timeStamp = (new Date()).getTime() - _timeStamp;
+        this[_a$9] = false;
         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();
+_a$9 = _isTrusted, _b$2 = _passive, _c$1 = _dispatched, _d$1 = _preventDefaultCalled, _e$1 = _stopImmediatePropagationCalled;
+/** @internal */
+function Event_setTrusted(event, isTrusted) {
+    Object.defineProperty(event[state$e], _isTrusted, {
+        value: isTrusted,
+        writable: true,
+        enumerable: true,
+        configurable: true,
+    });
+}
+const passive$1 = 0;
+const dispatched$2 = 1;
+const preventDefaultCalled$1 = 2;
+const stopImmediatePropagationCalled$1 = 3;
+/** @internal */
+function Event_getEtField(event, field) {
+    const s = event[state$e];
+    switch (field) {
+        case passive$1:
+            return s[_passive];
+        case dispatched$2:
+            return s[_dispatched];
+        case preventDefaultCalled$1:
+            return s[_preventDefaultCalled];
+        case stopImmediatePropagationCalled$1:
+            return s[_stopImmediatePropagationCalled];
+    }
+}
+/** @internal */
+function Event_setEtField(event, field, value) {
+    const s = event[state$e];
+    switch (field) {
+        case passive$1:
+            s[_passive] = value;
+            break;
+        case dispatched$2:
+            s[_dispatched] = value;
+            break;
+        case preventDefaultCalled$1:
+            s[_preventDefaultCalled] = value;
+            break;
+        case stopImmediatePropagationCalled$1:
+            s[_stopImmediatePropagationCalled] = value;
+            break;
+    }
+}
+/** @internal */
 function createInnerEvent(target, type, eventInitDict, isTrusted = true) {
     let event = new EventP(type, eventInitDict);
-    event[state$g].target = target;
-    event[state$g][_isTrusted] = isTrusted;
+    event[state$e].target = target;
+    event[state$e][_isTrusted] = isTrusted;
     return event;
 }
 const EventE = g["EventTarget"] ? g["Event"] : EventP;
 
 var _a$8;
-/** @internal */
-const state$f = Symbol( /* "EventTargetState" */);
+const passive = 0;
+const dispatched$1 = 1;
+const preventDefaultCalled = 2;
+const stopImmediatePropagationCalled = 3;
+/** @internal */ const state$d = Symbol( /* "EventTargetState" */);
 class EventTargetP {
     constructor() {
-        this[state$f] = new EventTargetState(this);
+        this[state$d] = new EventTargetState(this);
     }
     addEventListener(type, callback, options) {
-        const that = this[state$f];
+        const that = this[state$d];
         const executor = new Executor(type, callback);
         executor.options.capture = typeof options === "boolean" ? options : !!(options === null || options === void 0 ? void 0 : options.capture);
         if (!that[_executors].some(x => x.equals(executor))) {
@@ -434,7 +625,7 @@ class EventTargetP {
                 executor.options.passive = !!passive;
                 if (signal) {
                     executor.options.signal = signal;
-                    reply.call(that, signal, executor);
+                    reply(this, signal, executor);
                 }
             }
             that[_executors].push(executor);
@@ -449,12 +640,12 @@ class EventTargetP {
         if (!(event instanceof EventP)) {
             throw new TypeError("EventTarget.dispatchEvent: Argument 1 does not implement interface Event.");
         }
-        event[state$g].target = this;
-        Object.defineProperty(event[state$g], _isTrusted, { value: false, configurable: true, enumerable: true, writable: true });
-        return fire.call(this[state$f], event);
+        Event_setTrusted(event, false);
+        event[state$e].target = this;
+        return EventTarget_fire(this, event);
     }
     removeEventListener(type, callback, options) {
-        const that = this[state$f];
+        const that = this[state$d];
         const executor = new Executor(type, callback);
         executor.options.capture = typeof options === "boolean" ? options : !!(options === null || options === void 0 ? void 0 : options.capture);
         if (that[_executors].some(x => x.equals(executor))) {
@@ -464,7 +655,7 @@ class EventTargetP {
     toString() { return "[object EventTarget]"; }
     get isPolyfill() { return { symbol: polyfill, hierarchy: ["EventTarget"] }; }
 }
-defineStringTag(EventTargetP, "EventTarget");
+dfStringTag(EventTargetP, "EventTarget");
 /** @internal */
 const _executors = Symbol();
 /** @internal */
@@ -475,35 +666,37 @@ class EventTargetState {
     }
 }
 _a$8 = _executors;
-function fire(event) {
-    const s = event[state$g];
+/** @internal */
+function EventTarget_fire(target, event) {
+    const that = target[state$d];
+    const s = event[state$e];
     if (!event.target)
-        s.target = this.target;
-    s.currentTarget = this.target;
+        s.target = target;
+    s.currentTarget = target;
     s.eventPhase = EventP.AT_TARGET;
-    s[_dispatched] = true;
+    Event_setEtField(event, dispatched$1, true);
     let onceIndexes = [];
-    for (let i = 0; i < this[_executors].length; ++i) {
-        let executor = this[_executors][i];
+    for (let i = 0; i < that[_executors].length; ++i) {
+        let executor = that[_executors][i];
         if (executor.type !== event.type)
             continue;
-        s[_passive] = !!executor.options.passive;
+        Event_setEtField(event, passive, !!executor.options.passive);
         if (executor.options.once)
             onceIndexes.push(i);
         let { callback: cb } = executor;
         try {
             if (typeof cb === "function")
-                cb.call(this.target, event);
+                cb.call(target, event);
         }
         catch (e) {
             console.error(e);
         }
-        s[_passive] = false;
-        if (s[_stopImmediatePropagationCalled])
+        Event_setEtField(event, passive, false);
+        if (Event_getEtField(event, stopImmediatePropagationCalled))
             break;
     }
     if (onceIndexes.length > 0) {
-        this[_executors] = this[_executors].reduce((acc, cur, index) => {
+        that[_executors] = that[_executors].reduce((acc, cur, index) => {
             if (onceIndexes.indexOf(index) === -1)
                 acc.push(cur);
             return acc;
@@ -511,19 +704,24 @@ function fire(event) {
     }
     s.currentTarget = null;
     s.eventPhase = EventP.NONE;
-    s[_dispatched] = false;
-    return !(event.cancelable && s[_preventDefaultCalled]);
+    Event_setEtField(event, dispatched$1, false);
+    return !(event.cancelable && Event_getEtField(event, preventDefaultCalled));
+}
+/** @internal */
+function EventTarget_count(target) {
+    return target[state$d][_executors].length;
 }
-function reply(signal, executor) {
+function reply(target, signal, executor) {
+    const s = target[state$d];
     const onAbort = () => {
-        this[_executors] = this[_executors].filter(x => !x.equals(executor));
+        s[_executors] = s[_executors].filter(x => !x.equals(executor));
         signal.removeEventListener("abort", onAbort);
     };
     try {
         signal.addEventListener("abort", onAbort);
     }
     catch (e) {
-        console.error(e);
+        console.warn(e);
     }
 }
 /** @internal */
@@ -552,64 +750,41 @@ function extract(cb) {
 function isEventListenerObject(cb) {
     return !!cb && "handleEvent" in cb && typeof cb.handleEvent === "function";
 }
-function attachFn(type, cb, listener) {
+/** @internal */
+function attachFn(target, type, cb, listener) {
     if (typeof cb === "function") {
-        this.addEventListener(type, listener);
+        target.addEventListener(type, listener);
     }
     else {
-        this.removeEventListener(type, listener);
+        target.removeEventListener(type, listener);
     }
 }
-function executeFn(cb, ev) {
+/** @internal */
+function executeFn(target, cb, ev) {
     if (typeof cb === "function")
-        cb.call(this, ev);
+        cb.call(target, ev);
 }
 const EventTargetE = g["EventTarget"] || EventTargetP;
 
 /** @internal */
-const state$e = Symbol( /* "CustomEventState" */);
-class CustomEventP extends EventP {
-    constructor(type, eventInitDict) {
-        var _a;
-        super(type, eventInitDict);
-        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;
-    }
-    get detail() { return this[state$e].detail; }
-    initCustomEvent(type, bubbles, cancelable, detail) {
-        if (this[state$g][_dispatched])
-            return;
-        this.initEvent(type, bubbles, cancelable);
-        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");
-/** @internal */
-class CustomEventState {
-}
-const CustomEventE = g["EventTarget"] ? g["CustomEvent"] : CustomEventP;
-
-/** @internal */
-const state$d = Symbol( /* "ProgressEventState" */);
+const state$c = Symbol( /* "ProgressEventState" */);
 class ProgressEventP extends EventP {
     constructor(type, eventInitDict) {
         var _a, _b;
         super(type, eventInitDict);
-        this[state$d] = new ProgressEventState();
-        const that = this[state$d];
+        this[state$c] = new ProgressEventState();
+        const that = this[state$c];
         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); }
+    get lengthComputable() { return getValue(this[state$c].lengthComputable); }
+    get loaded() { return getValue(this[state$c].loaded); }
+    get total() { return getValue(this[state$c].total); }
     toString() { return "[object ProgressEvent]"; }
     get isPolyfill() { return { symbol: polyfill, hierarchy: ["ProgressEvent", "Event"] }; }
 }
-defineStringTag(ProgressEventP, "ProgressEvent");
+dfStringTag(ProgressEventP, "ProgressEvent");
 /** @internal */
 class ProgressEventState {
     constructor() {
@@ -623,234 +798,97 @@ function getValue(val) {
 }
 function createInnerProgressEvent(target, type, { lengthComputable = false, loaded = 0, total = 0, } = {}) {
     let 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;
+    event[state$c].lengthComputable = lengthComputable;
+    event[state$c].loaded = loaded;
+    event[state$c].total = total;
+    event[state$e].target = target;
+    Event_setTrusted(event, true);
     return event;
 }
+/** @internal */
 function emitProcessEvent(target, type, loaded = 0, total = 0) {
     let event = createInnerProgressEvent(target, type, {
         lengthComputable: () => { return getValue(total) > 0; },
         loaded,
         total,
     });
-    fire.call(target[state$f], event);
+    EventTarget_fire(target, event);
 }
 const ProgressEventE = g["EventTarget"] ? g["ProgressEvent"] : ProgressEventP;
 
+var _a$7;
 /** @internal */
-const state$c = Symbol( /* "BlobState" */);
-class BlobP {
-    constructor(blobParts = [], options) {
-        if (!Array.isArray(blobParts)) {
-            throw new TypeError("First argument to Blob constructor must be an Array.");
-        }
-        let encoder = null;
-        let chunks = blobParts.reduce((chunks, part) => {
-            if (isPolyfillType("Blob", part)) {
-                chunks.push(part[state$c][_u8array]);
-            }
-            else if (part instanceof ArrayBuffer || ArrayBuffer.isView(part)) {
-                chunks.push(convert$1(part));
-            }
-            else {
-                if (!encoder) {
-                    encoder = new TextEncoderP();
-                }
-                chunks.push(encoder.encode(String(part)));
-            }
-            return chunks;
-        }, []);
-        this[state$c] = new BlobState(concat(chunks));
-        const that = this[state$c];
-        that.size = that[_u8array].length;
-        let rawType = (options === null || options === void 0 ? void 0 : options.type) || "";
-        that.type = /[^\u0020-\u007E]/.test(rawType) ? "" : rawType.toLowerCase();
+const state$b = Symbol( /* "FileReaderState" */);
+class FileReaderP extends EventTargetP {
+    constructor() {
+        super();
+        this[state$b] = new FileReaderState(this);
     }
-    get size() { return this[state$c].size; }
-    get type() { return this[state$c].type; }
-    arrayBuffer() {
-        return Promise.resolve(clone(this[state$c][_u8array].buffer).buffer);
+    get readyState() { return this[state$b].readyState; }
+    get result() { return this[state$b].result; }
+    get error() { return this[state$b].error; }
+    abort() {
+        if (this.readyState === FileReaderP.LOADING) {
+            this[state$b].readyState = FileReaderP.DONE;
+            this[state$b].result = null;
+            emitProcessEvent(this, "abort");
+        }
     }
-    bytes() {
-        return Promise.resolve(clone(this[state$c][_u8array].buffer));
+    readAsArrayBuffer(blob) {
+        read$1(this, "readAsArrayBuffer", blob, () => {
+            this[state$b].result = Blob_toUint8Array(blob).buffer.slice(0);
+        });
     }
-    slice(start, end, contentType) {
-        let sliced = this[state$c][_u8array].slice(start !== null && start !== void 0 ? start : 0, end !== null && end !== void 0 ? end : this[state$c][_u8array].length);
-        return new BlobP([sliced], { type: contentType !== null && contentType !== void 0 ? contentType : "" });
+    readAsBinaryString(blob) {
+        read$1(this, "readAsBinaryString", blob, () => {
+            this[state$b].result = Blob_toUint8Array(blob).reduce((acc, cur) => {
+                acc += String.fromCharCode(cur);
+                return acc;
+            }, "");
+        });
     }
-    stream() {
-        throw new ReferenceError("ReadableStream is not defined");
+    readAsDataURL(blob) {
+        read$1(this, "readAsDataURL", blob, () => {
+            this[state$b].result = "data:" + (blob.type || "application/octet-stream") + ";base64," + Uint8Array_toBase64(Blob_toUint8Array(blob));
+        });
     }
-    text() {
-        let decoder = new TextDecoderP();
-        return Promise.resolve(decoder.decode(this[state$c][_u8array]));
+    readAsText(blob, encoding) {
+        read$1(this, "readAsText", blob, () => {
+            this[state$b].result = (new TextDecoderP(encoding)).decode(Blob_toUint8Array(blob));
+        });
     }
-    toString() { return "[object Blob]"; }
-    get isPolyfill() { return { symbol: polyfill, hierarchy: ["Blob"] }; }
+    get onabort() { return this[state$b].onabort; }
+    set onabort(value) { this[state$b].onabort = value; attach$1(this, "abort"); }
+    get onerror() { return this[state$b].onerror; }
+    set onerror(value) { this[state$b].onerror = value; attach$1(this, "error"); }
+    get onload() { return this[state$b].onload; }
+    set onload(value) { this[state$b].onload = value; attach$1(this, "load"); }
+    get onloadend() { return this[state$b].onloadend; }
+    set onloadend(value) { this[state$b].onloadend = value; attach$1(this, "loadend"); }
+    get onloadstart() { return this[state$b].onloadstart; }
+    set onloadstart(value) { this[state$b].onloadstart = value; attach$1(this, "loadstart"); }
+    get onprogress() { return this[state$b].onprogress; }
+    set onprogress(value) { this[state$b].onprogress = value; attach$1(this, "progress"); }
+    toString() { return "[object FileReader]"; }
+    get isPolyfill() { return { symbol: polyfill, hierarchy: ["FileReader", "EventTarget"] }; }
 }
-defineStringTag(BlobP, "Blob");
+const properties$1 = {
+    EMPTY: { value: 0, enumerable: true },
+    LOADING: { value: 1, enumerable: true },
+    DONE: { value: 2, enumerable: true },
+};
+Object.defineProperties(FileReaderP, properties$1);
+Object.defineProperties(FileReaderP.prototype, properties$1);
+dfStringTag(FileReaderP, "FileReader");
 /** @internal */
-const _u8array = Symbol();
-/** @internal */
-class BlobState {
-    constructor(buffer) {
-        this.size = 0;
-        this.type = "";
-        this[_u8array] = buffer;
-    }
-    toUint8Array() {
-        return this[_u8array];
-    }
-    toArrayBuffer() {
-        return this[_u8array].buffer;
-    }
-}
-function u8array2base64(input) {
-    let byteToCharMap = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
-    let output = [];
-    for (var i = 0; i < input.length; i += 3) {
-        let byte1 = input[i];
-        let haveByte2 = i + 1 < input.length;
-        let byte2 = haveByte2 ? input[i + 1] : 0;
-        let haveByte3 = i + 2 < input.length;
-        let byte3 = haveByte3 ? input[i + 2] : 0;
-        let outByte1 = byte1 >> 2;
-        let outByte2 = ((byte1 & 0x03) << 4) | (byte2 >> 4);
-        let outByte3 = ((byte2 & 0x0F) << 2) | (byte3 >> 6);
-        let outByte4 = byte3 & 0x3F;
-        if (!haveByte3) {
-            outByte4 = 64;
-            if (!haveByte2) {
-                outByte3 = 64;
-            }
-        }
-        output.push(byteToCharMap[outByte1], byteToCharMap[outByte2], byteToCharMap[outByte3], byteToCharMap[outByte4]);
-    }
-    return output.join("");
-}
-function convert$1(buf) {
-    return buf instanceof ArrayBuffer
-        ? new Uint8Array(buf)
-        : new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
-}
-function clone(buf) {
-    let sourceArray = convert$1(buf);
-    let cloneArray = new Uint8Array(new ArrayBuffer(sourceArray.byteLength));
-    cloneArray.set(sourceArray);
-    return cloneArray;
-}
-function concat(chunks) {
-    let totalByteLength = chunks.reduce((acc, cur) => acc + cur.byteLength, 0);
-    let result = new Uint8Array(totalByteLength);
-    chunks.reduce((offset, chunk) => {
-        result.set(chunk, offset);
-        return offset + chunk.byteLength;
-    }, 0);
-    return result;
-}
-const BlobE = g["Blob"] || BlobP;
-
-/** @internal */
-const state$b = Symbol( /* "FileState" */);
-class FileP extends BlobP {
-    constructor(fileBits, fileName, options) {
-        super(fileBits, options);
-        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, ":");
-    }
-    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");
-/** @internal */
-class FileState {
-    constructor() {
-        this.lastModified = 0;
-        this.name = "";
-    }
-}
-const FileE = g["Blob"] ? g["File"] : FileP;
-
-var _a$7;
-/** @internal */
-const state$a = Symbol( /* "FileReaderState" */);
-class FileReaderP extends EventTargetP {
-    constructor() {
-        super();
-        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$a].readyState = FileReaderP.DONE;
-            this[state$a].result = null;
-            emitProcessEvent(this, "abort");
-        }
-    }
-    readAsArrayBuffer(blob) {
-        read$1.call(this[state$a], "readAsArrayBuffer", blob, () => {
-            this[state$a].result = blob[state$c].toArrayBuffer().slice(0);
-        });
-    }
-    readAsBinaryString(blob) {
-        read$1.call(this[state$a], "readAsBinaryString", blob, () => {
-            this[state$a].result = blob[state$c].toUint8Array().reduce((acc, cur) => {
-                acc += String.fromCharCode(cur);
-                return acc;
-            }, "");
-        });
-    }
-    readAsDataURL(blob) {
-        read$1.call(this[state$a], "readAsDataURL", blob, () => {
-            this[state$a].result = "data:" + blob.type + ";base64," + u8array2base64(blob[state$c].toUint8Array());
-        });
-    }
-    readAsText(blob, encoding) {
-        read$1.call(this[state$a], "readAsText", blob, () => {
-            this[state$a].result = (new TextDecoderP(encoding)).decode(blob[state$c].toUint8Array());
-        });
-    }
-    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"] }; }
-}
-const properties$1 = {
-    EMPTY: { value: 0, enumerable: true },
-    LOADING: { value: 1, enumerable: true },
-    DONE: { value: 2, enumerable: true },
-};
-Object.defineProperties(FileReaderP, properties$1);
-Object.defineProperties(FileReaderP.prototype, properties$1);
-defineStringTag(FileReaderP, "FileReader");
-/** @internal */
-const _handlers$3 = Symbol();
+const _handlers$3 = Symbol();
 /** @internal */
 class FileReaderState {
     constructor(target) {
         this.readyState = FileReaderP.EMPTY;
         this.result = null;
         this.error = null;
-        this[_a$7] = getHandlers$3.call(this);
+        this[_a$7] = getHandlers$3(this);
         this.onabort = null;
         this.onerror = null;
         this.onload = null;
@@ -861,50 +899,51 @@ class FileReaderState {
     }
 }
 _a$7 = _handlers$3;
-function read$1(kind, blob, setResult) {
+function read$1(reader, 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;
-    emitProcessEvent(this.target, "loadstart", 0, blob.size);
+    const s = reader[state$b];
+    s.error = null;
+    s.readyState = FileReaderP.LOADING;
+    emitProcessEvent(s.target, "loadstart", 0, blob.size);
     setTimeout(() => {
-        if (this.readyState === FileReaderP.LOADING) {
-            this.readyState = FileReaderP.DONE;
+        if (s.readyState === FileReaderP.LOADING) {
+            s.readyState = FileReaderP.DONE;
             try {
                 setResult();
-                emitProcessEvent(this.target, "load", blob.size, blob.size);
+                emitProcessEvent(s.target, "load", blob.size, blob.size);
             }
             catch (e) {
-                this.result = null;
-                this.error = e;
-                emitProcessEvent(this.target, "error", 0, blob.size);
+                s.result = null;
+                s.error = e;
+                emitProcessEvent(s.target, "error", 0, blob.size);
             }
         }
-        emitProcessEvent(this.target, "loadend", !!this.result ? blob.size : 0, blob.size);
+        emitProcessEvent(s.target, "loadend", !!s.result ? blob.size : 0, blob.size);
     });
 }
-function attach$1(type) {
+function attach$1(reader, type) {
+    const s = reader[state$b];
     const fnName = ("on" + type);
-    const cb = this[fnName];
-    const listener = this[_handlers$3][fnName];
-    attachFn.call(this.target, type, cb, listener);
+    const cb = s[fnName];
+    const listener = s[_handlers$3][fnName];
+    attachFn(reader, type, cb, listener);
 }
-function getHandlers$3() {
+function getHandlers$3(s) {
     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); },
+        onabort: (ev) => { executeFn(s.target, s.onabort, ev); },
+        onerror: (ev) => { executeFn(s.target, s.onerror, ev); },
+        onload: (ev) => { executeFn(s.target, s.onload, ev); },
+        onloadend: (ev) => { executeFn(s.target, s.onloadend, ev); },
+        onloadstart: (ev) => { executeFn(s.target, s.onloadstart, ev); },
+        onprogress: (ev) => { executeFn(s.target, s.onprogress, ev); },
     };
 }
 const FileReaderE = g["Blob"] ? g["FileReader"] : FileReaderP;
 
 var _a$6;
-/** @internal */
-const state$9 = Symbol( /* "FormDataState" */);
+/** @internal */ const state$a = Symbol( /* "FormDataState" */);
 class FormDataP {
     constructor(form, submitter) {
         if (form !== void 0) {
@@ -913,21 +952,21 @@ class FormDataP {
         if (!!submitter) {
             throw new TypeError("Failed to construct 'FormData': parameter 2 is not of type 'HTMLElement'.");
         }
-        this[state$9] = new FormDataState();
+        this[state$a] = new FormDataState();
     }
     append(name, value, filename) {
-        this[state$9][_formData].push(normalizeArgs(name, value, filename));
+        this[state$a][_formData].push(normalizeArgs(name, value, filename));
     }
     delete(name) {
         let result = [];
         name = String(name);
-        each(this[state$9][_formData], entry => {
+        each(this[state$a][_formData], entry => {
             entry[0] !== name && result.push(entry);
         });
-        this[state$9][_formData] = result;
+        this[state$a][_formData] = result;
     }
     get(name) {
-        let entries = this[state$9][_formData];
+        let entries = this[state$a][_formData];
         name = String(name);
         for (let i = 0; i < entries.length; ++i) {
             if (entries[i][0] === name) {
@@ -939,15 +978,15 @@ class FormDataP {
     getAll(name) {
         let result = [];
         name = String(name);
-        each(this[state$9][_formData], data => {
+        each(this[state$a][_formData], data => {
             data[0] === name && result.push(data[1]);
         });
         return result;
     }
     has(name) {
         name = String(name);
-        for (let i = 0; i < this[state$9][_formData].length; ++i) {
-            if (this[state$9][_formData][i][0] === name) {
+        for (let i = 0; i < this[state$a][_formData].length; ++i) {
+            if (this[state$a][_formData][i][0] === name) {
                 return true;
             }
         }
@@ -958,27 +997,28 @@ class FormDataP {
         let result = [];
         let args = normalizeArgs(name, value, filename);
         let replace = true;
-        each(this[state$9][_formData], data => {
+        each(this[state$a][_formData], data => {
             data[0] === name
                 ? replace && (replace = !result.push(args))
                 : result.push(data);
         });
         replace && result.push(args);
-        this[state$9][_formData] = result;
+        this[state$a][_formData] = result;
     }
     forEach(callbackfn, thisArg) {
-        for (let [name, value] of this) {
-            callbackfn.call(thisArg, value, name, thisArg);
+        for (let i = 0; i < this[state$a][_formData].length; ++i) {
+            let pair = this[state$a][_formData][i];
+            callbackfn.call(thisArg, pair[1], pair[0], thisArg);
         }
     }
     entries() {
-        return this[state$9][_formData].values();
+        return this[state$a][_formData].values();
     }
     keys() {
-        return this[state$9][_formData].map(x => x[0]).values();
+        return this[state$a][_formData].map(x => x[0]).values();
     }
     values() {
-        return this[state$9][_formData].map(x => x[1]).values();
+        return this[state$a][_formData].map(x => x[1]).values();
     }
     [Symbol.iterator]() {
         return this.entries();
@@ -986,7 +1026,7 @@ class FormDataP {
     toString() { return "[object FormData]"; }
     get isPolyfill() { return { symbol: polyfill, hierarchy: ["FormData"] }; }
 }
-defineStringTag(FormDataP, "FormData");
+dfStringTag(FormDataP, "FormData");
 /** @internal */
 const _formData = Symbol();
 /** @internal */
@@ -994,25 +1034,27 @@ class FormDataState {
     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[_formData].values()) {
-            if (typeof value === "string") {
-                chunks.push(p + escape(normalizeLinefeeds(name)) + `"\r\n\r\n${normalizeLinefeeds(value)}\r\n`);
-            }
-            else {
-                chunks.push(p + escape(normalizeLinefeeds(name)) + `"; filename="${escape(value.name)}"\r\nContent-Type: ${value.type || "application/octet-stream"}\r\n\r\n`, value, `\r\n`);
-            }
+}
+_a$6 = _formData;
+/** @internal */
+function FormData_toBlob(formData) {
+    const boundary = "----formdata-polyfill-" + Math.random();
+    const p = `--${boundary}\r\nContent-Disposition: form-data; name="`;
+    let chunks = [];
+    for (let i = 0; i < formData[state$a][_formData].length; ++i) {
+        let pair = formData[state$a][_formData][i];
+        let name = pair[0];
+        let value = pair[1];
+        if (typeof value === "string") {
+            chunks.push(p + escape(normalizeLinefeeds(name)) + `"\r\n\r\n${normalizeLinefeeds(value)}\r\n`);
+        }
+        else {
+            chunks.push(p + escape(normalizeLinefeeds(name)) + `"; filename="${escape(value.name)}"\r\nContent-Type: ${value.type || "application/octet-stream"}\r\n\r\n`, value, `\r\n`);
         }
-        chunks.push(`--${boundary}--`);
-        return new BlobP(chunks, {
-            type: "multipart/form-data; boundary=" + boundary,
-        });
     }
+    chunks.push(`--${boundary}--`);
+    return new BlobP(chunks, { type: "multipart/form-data; boundary=" + boundary });
 }
-_a$6 = _formData;
 function normalizeArgs(name, value, filename) {
     if (isPolyfillType("Blob", value)) {
         filename = filename !== undefined
@@ -1042,6 +1084,7 @@ function escape(str) {
  * Parses multipart/form-data binary data, supporting restoration of text fields and files
  * @param body - Text in multipart/form-data format (including boundaries and data)
  * @returns Parsed FormData object (text fields as strings, files as File objects)
+ * @internal
  */
 function createFormDataFromBody(body, errMsg = "Failed to fetch") {
     const formData = new FormDataP();
@@ -1121,25 +1164,29 @@ const FormDataE = g["FormData"] || FormDataP;
 
 var _a$5;
 /** @internal */
-const state$8 = Symbol( /* "URLSearchParamsState" */);
+const state$9 = Symbol( /* "URLSearchParamsState" */);
 class URLSearchParamsP {
     constructor(init) {
         let search = init || "";
         if (isObjectType("URLSearchParams", search)) {
             search = search.toString();
         }
-        this[state$8] = new URLSearchParamsState();
-        this[state$8][_urlspDict] = parseToDict(search);
+        this[state$9] = new URLSearchParamsState();
+        this[state$9][_urlspDict] = parseToDict(search);
     }
     get size() {
-        return objectValues(this[state$8][_urlspDict]).reduce((acc, cur) => acc + cur.length, 0);
+        return objectValues(this[state$9][_urlspDict]).reduce((acc, cur) => acc + cur.length, 0);
     }
     append(name, value) {
-        appendTo(this[state$8][_urlspDict], name, value);
+        appendTo(this[state$9][_urlspDict], name, value);
     }
     delete(name, value) {
         let dict = {};
-        for (let [key, values] of objectEntries(this[state$8][_urlspDict])) {
+        let pairs = objectEntries(this[state$9][_urlspDict]);
+        for (let i = 0; i < pairs.length; ++i) {
+            let pair = pairs[i];
+            let key = pair[0];
+            let values = pair[1];
             if (key === name) {
                 if (value !== undefined) {
                     let vals = values.filter(x => x !== ("" + value));
@@ -1150,46 +1197,47 @@ class URLSearchParamsP {
             }
             Object.assign(dict, { [key]: values });
         }
-        this[state$8][_urlspDict] = dict;
+        this[state$9][_urlspDict] = dict;
     }
     get(name) {
         var _b;
-        return this.has(name) ? (_b = this[state$8][_urlspDict][name][0]) !== null && _b !== void 0 ? _b : null : null;
+        return this.has(name) ? (_b = this[state$9][_urlspDict][name][0]) !== null && _b !== void 0 ? _b : null : null;
     }
     getAll(name) {
-        return this.has(name) ? this[state$8][_urlspDict][name].slice(0) : [];
+        return this.has(name) ? this[state$9][_urlspDict][name].slice(0) : [];
     }
     has(name, value) {
-        if (hasOwnProperty(this[state$8][_urlspDict], name)) {
+        if (hasOwnProperty(this[state$9][_urlspDict], name)) {
             if (value !== undefined) {
-                return this[state$8][_urlspDict][name].indexOf(("" + value)) > -1;
+                return this[state$9][_urlspDict][name].indexOf(("" + value)) > -1;
             }
             return true;
         }
         return false;
     }
     set(name, value) {
-        this[state$8][_urlspDict][name] = ["" + value];
+        this[state$9][_urlspDict][name] = ["" + value];
     }
     sort() {
-        const that = this[state$8];
+        const that = this[state$9];
         let keys = Object.keys(that[_urlspDict]);
         keys.sort();
         let dict = {};
-        for (let key of keys) {
+        for (let i = 0; i < keys.length; ++i) {
+            let key = keys[i];
             Object.assign(dict, { [key]: that[_urlspDict][key] });
         }
         that[_urlspDict] = dict;
     }
     forEach(callbackfn, thisArg) {
-        objectEntries(this[state$8][_urlspDict]).forEach(([key, values]) => {
+        objectEntries(this[state$9][_urlspDict]).forEach(([key, values]) => {
             values.forEach(value => {
                 callbackfn.call(thisArg, value, key, this);
             });
         });
     }
     entries() {
-        return objectEntries(this[state$8][_urlspDict])
+        return objectEntries(this[state$9][_urlspDict])
             .map(([key, values]) => {
             return values.map(value => {
                 return [key, value];
@@ -1199,19 +1247,24 @@ class URLSearchParamsP {
             .values();
     }
     keys() {
-        return Object.keys(this[state$8][_urlspDict]).values();
+        return Object.keys(this[state$9][_urlspDict]).values();
     }
     values() {
-        return objectValues(this[state$8][_urlspDict]).reduce(flatCb, []).values();
+        return objectValues(this[state$9][_urlspDict]).reduce(flatCb, []).values();
     }
     [Symbol.iterator]() {
         return this.entries();
     }
     toString() {
         let query = [];
-        for (let [key, values] of objectEntries(this[state$8][_urlspDict])) {
+        let pairs = objectEntries(this[state$9][_urlspDict]);
+        for (let i = 0; i < pairs.length; ++i) {
+            let pair = pairs[i];
+            let key = pair[0];
+            let values = pair[1];
             let name = encode$1(key);
-            for (let val of values) {
+            for (let j = 0; j < values.length; ++j) {
+                let val = values[j];
                 query.push(name + "=" + encode$1(val));
             }
         }
@@ -1219,7 +1272,7 @@ class URLSearchParamsP {
     }
     get isPolyfill() { return { symbol: polyfill, hierarchy: ["URLSearchParams"] }; }
 }
-defineStringTag(URLSearchParamsP, "URLSearchParams");
+dfStringTag(URLSearchParamsP, "URLSearchParams");
 /** @internal */
 const _urlspDict = Symbol();
 /** @internal */
@@ -1245,7 +1298,9 @@ function parseToDict(search) {
             }
         }
         else {
-            for (let key in search) {
+            let keys = Object.keys(search);
+            for (let i = 0; i < keys.length; ++i) {
+                let key = keys[i];
                 if (search.hasOwnProperty(key)) {
                     appendTo(dict, key, search[key]);
                 }
@@ -1303,7 +1358,8 @@ function hasOwnProperty(obj, prop) {
     return Object.prototype.hasOwnProperty.call(obj, prop);
 }
 function flatCb(acc, cur) {
-    for (let item of cur) {
+    for (let i = 0; i < cur.length; ++i) {
+        let item = cur[i];
         acc.push(item);
     }
     return acc;
@@ -1312,36 +1368,39 @@ const URLSearchParamsE = g["URLSearchParams"] || URLSearchParamsP;
 
 var _a$4;
 /** @internal */
-const state$7 = Symbol( /* "AbortSignalState" */);
+const state$8 = Symbol( /* "AbortSignalState" */);
 class AbortSignalP extends EventTargetP {
     static abort(reason) {
-        let signal = createAbortSignalP();
-        abort.call(signal[state$7], reason, false);
+        let signal = createAbortSignal();
+        AbortSignal_abort(signal, reason, false);
         return signal;
     }
     static any(signals) {
-        let signal = createAbortSignalP();
+        let signal = createAbortSignal();
         let abortedSignal = signals.find(x => x.aborted);
         if (abortedSignal) {
-            abort.call(signal[state$7], abortedSignal.reason, false);
+            AbortSignal_abort(signal, abortedSignal.reason, false);
         }
         else {
+            let _signals = Array.from(signals);
             function abortFn(ev) {
-                for (let sig of signals) {
+                for (let i = 0; i < _signals.length; ++i) {
+                    let sig = _signals[i];
                     sig.removeEventListener("abort", abortFn);
                 }
-                abort.call(signal[state$7], this.reason, true, ev.isTrusted);
+                AbortSignal_abort(signal, this.reason, true, ev.isTrusted);
             }
-            for (let sig of signals) {
+            for (let i = 0; i < _signals.length; ++i) {
+                let sig = _signals[1];
                 sig.addEventListener("abort", abortFn);
             }
         }
         return signal;
     }
     static timeout(milliseconds) {
-        let signal = createAbortSignalP();
+        let signal = createAbortSignal();
         setTimeout(() => {
-            abort.call(signal[state$7], new MPException("signal timed out", "TimeoutError"));
+            AbortSignal_abort(signal, new MPException("signal timed out", "TimeoutError"));
         }, milliseconds);
         return signal;
     }
@@ -1350,24 +1409,24 @@ class AbortSignalP extends EventTargetP {
             throw new TypeError("Failed to construct 'AbortSignal': Illegal constructor");
         }
         super();
-        this[state$7] = new AbortSignalState(this);
+        this[state$8] = new AbortSignalState(this);
     }
-    get aborted() { return this[state$7].aborted; }
-    get reason() { return this[state$7].reason; }
+    get aborted() { return this[state$8].aborted; }
+    get reason() { return this[state$8].reason; }
     throwIfAborted() {
         if (this.aborted) {
             throw this.reason;
         }
     }
-    get onabort() { return this[state$7].onabort; }
+    get onabort() { return this[state$8].onabort; }
     set onabort(value) {
-        this[state$7].onabort = value;
-        attachFn.call(this, "abort", value, this[state$7][_handlers$2].onabort);
+        this[state$8].onabort = value;
+        attachFn(this, "abort", value, this[state$8][_handlers$2].onabort);
     }
     toString() { return "[object AbortSignal]"; }
     get isPolyfill() { return { symbol: polyfill, hierarchy: ["AbortSignal", "EventTarget"] }; }
 }
-defineStringTag(AbortSignalP, "AbortSignal");
+dfStringTag(AbortSignalP, "AbortSignal");
 /** @internal */
 const _handlers$2 = Symbol();
 /** @internal */
@@ -1375,526 +1434,159 @@ class AbortSignalState {
     constructor(target) {
         this.aborted = false;
         this.reason = undefined;
-        this[_a$4] = getHandlers$2.call(this);
+        this[_a$4] = getHandlers$2(this);
         this.onabort = null;
         this.target = target;
     }
 }
 _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"));
+/** @internal */
+function AbortSignal_abort(signal, reason, notify = true, isTrusted = true) {
+    const s = signal[state$8];
+    if (!s.aborted) {
+        s.aborted = true;
+        s.reason = reason !== null && reason !== void 0 ? reason : (new MPException("signal is aborted without reason", "AbortError"));
         if (notify) {
-            let evt = createInnerEvent(this.target, "abort", undefined, isTrusted);
-            fire.call(this.target[state$f], evt);
+            let evt = createInnerEvent(signal, "abort", undefined, isTrusted);
+            EventTarget_fire(signal, evt);
         }
     }
 }
-function getHandlers$2() {
+function getHandlers$2(s) {
     return {
-        onabort: (ev) => { executeFn.call(this.target, this.onabort, ev); },
+        onabort: (ev) => { executeFn(s.target, s.onabort, ev); },
     };
 }
-function createAbortSignalP() {
-    let instance = Object.create(AbortSignalP.prototype);
-    instance[state$f] = new EventTargetState(instance);
-    instance[state$7] = new AbortSignalState(instance);
-    return instance;
+/** @internal */
+function createAbortSignal() {
+    let signal = Object.create(AbortSignalP.prototype);
+    signal[state$d] = new EventTargetState(signal);
+    signal[state$8] = new AbortSignalState(signal);
+    return signal;
 }
 const AbortSignalE = g["AbortSignal"] || AbortSignalP;
 
+var _a$3, _b$1;
 /** @internal */
-const state$6 = Symbol( /* "AbortControllerState" */);
-class AbortControllerP {
+const state$7 = Symbol( /* "BodyState" */);
+class BodyImpl {
     constructor() {
-        this[state$6] = new AbortControllerState();
+        if (new.target === BodyImpl) {
+            throw new TypeError("Failed to construct 'Body': Illegal constructor");
+        }
+        this[state$7] = new BodyState();
     }
-    get signal() { return this[state$6].signal; }
-    abort(reason) {
-        abort.call(this[state$6].signal[state$7], reason);
+    get body() {
+        if (!this[state$7][_body]) {
+            return null;
+        }
+        throw new ReferenceError("ReadableStream is not defined");
     }
-    toString() { return "[object AbortController]"; }
-    get isPolyfill() { return { symbol: polyfill, hierarchy: ["AbortController"] }; }
+    get bodyUsed() { return this[state$7].bodyUsed; }
+    ;
+    arrayBuffer() {
+        const kind = "arrayBuffer";
+        return consumed(this, kind) || read(this, kind);
+    }
+    blob() {
+        const kind = "blob";
+        return consumed(this, kind) || read(this, kind);
+    }
+    bytes() {
+        const kind = "bytes";
+        return consumed(this, kind) || read(this, kind);
+    }
+    formData() {
+        const kind = "formData";
+        return consumed(this, kind) || read(this, kind);
+    }
+    json() {
+        const kind = "json";
+        return consumed(this, kind) || read(this, kind);
+    }
+    text() {
+        const kind = "text";
+        return consumed(this, kind) || read(this, kind);
+    }
+    toString() { return "[object Body]"; }
+    get isPolyfill() { return { symbol: polyfill, hierarchy: ["Body"] }; }
 }
-defineStringTag(AbortControllerP, "AbortController");
+dfStringTag(BodyImpl, "Body");
+/** @internal */ const _name = Symbol();
+/** @internal */ const _body = Symbol();
 /** @internal */
-class AbortControllerState {
+class BodyState {
     constructor() {
-        this.signal = createAbortSignalP();
+        this.bodyUsed = false;
+        this[_a$3] = "Body";
+        this[_b$1] = "";
     }
 }
-const AbortControllerE = g["AbortController"] || AbortControllerP;
-
-var _a$3;
+_a$3 = _name, _b$1 = _body;
 /** @internal */
-const state$5 = Symbol( /* "XMLHttpRequestEventTargetState" */);
-class XMLHttpRequestEventTargetP extends EventTargetP {
-    constructor() {
-        if (new.target === XMLHttpRequestEventTargetP) {
-            throw new TypeError("Failed to construct 'XMLHttpRequestEventTarget': Illegal constructor");
+function Body_init(body, payload, headers) {
+    if (isObjectType("ReadableStream", payload)) {
+        throw new ReferenceError("ReadableStream is not defined");
+    }
+    body[state$7][_body] = convert(payload, type => {
+        if (headers && !headers.get("Content-Type")) {
+            headers.set("Content-Type", type);
         }
-        super();
-        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");
 /** @internal */
-const _handlers$1 = Symbol();
-/** @internal */
-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;
-    }
+function Body_setName(body, name) {
+    body[state$7][_name] = name;
 }
-_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);
+/** @internal */
+function Body_setBodyUsed(body, bodyUsed) {
+    body[state$7].bodyUsed = bodyUsed;
 }
-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); },
-    };
+/** @internal */
+function Body_toPayload(body) {
+    return body[state$7][_body];
 }
-
-class XMLHttpRequestUploadP extends XMLHttpRequestEventTargetP {
-    constructor() {
-        if (new.target === XMLHttpRequestUploadP) {
-            throw new TypeError("Failed to construct 'XMLHttpRequestUpload': Illegal constructor");
+function read(body, kind) {
+    return new Promise((resolve, reject) => {
+        try {
+            resolve(readSync(body, kind));
         }
-        super();
-    }
-    toString() { return "[object XMLHttpRequestUpload]"; }
-    get isPolyfill() { return { symbol: polyfill, hierarchy: ["XMLHttpRequestUpload", "XMLHttpRequestEventTarget", "EventTarget"] }; }
-}
-defineStringTag(XMLHttpRequestUploadP, "XMLHttpRequestUpload");
-function createXMLHttpRequestUploadP() {
-    let instance = Object.create(XMLHttpRequestUploadP.prototype);
-    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
-            (typeof xhs !== u && typeof (xhs === null || xhs === void 0 ? void 0 : xhs[r]) === f && xhs) || // 小红书
-            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;
-    const err = {
-        errMsg,
-        errno,
-        exception: {
-            retryCount: 0,
-            reasons: [{ errMsg, errno }],
-        },
-        useHttpDNS: false,
-    };
-    Promise.resolve(err)
-        .then(err => { try {
-        if (options.fail) {
-            options.fail(err);
+        catch (e) {
+            reject(e);
         }
+    });
+}
+function readSync(body, kind) {
+    const payload = body[state$7][_body];
+    if (kind === "arrayBuffer") {
+        return convertBack("arraybuffer", payload);
     }
-    catch (e) {
-        console.warn(e);
-    } })
-        .then(() => { if (options.complete) {
-        options.complete(err);
-    } });
-    throw new ReferenceError("request is not defined");
-};
-
-var _a$2, _b$1, _c, _d, _e, _f, _g, _h, _j, _k;
-/** @internal */
-const state$4 = Symbol( /* "XMLHttpRequestState" */);
-class XMLHttpRequestP extends XMLHttpRequestEventTargetP {
-    constructor() {
-        super();
-        this[state$4] = new XMLHttpRequestState(this);
+    else if (kind === "blob") {
+        return convertBack("blob", payload);
     }
-    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$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$4].status; }
-    get statusText() {
-        if (this.readyState === XMLHttpRequestP.UNSENT || this.readyState === XMLHttpRequestP.OPENED)
-            return "";
-        return this[state$4].statusText || statusTextMap(this.status);
+    else if (kind === "bytes") {
+        let arrayBuffer = convertBack("arraybuffer", payload);
+        return new Uint8Array(arrayBuffer);
     }
-    get timeout() { return this[state$4].timeout; }
-    set timeout(value) { this[state$4].timeout = value; }
-    get upload() {
-        const that = this[state$4];
-        if (!that.upload) {
-            that.upload = createXMLHttpRequestUploadP();
-        }
-        return that.upload;
-    }
-    get withCredentials() { return this[state$4].withCredentials; }
-    set withCredentials(value) { this[state$4].withCredentials = value; }
-    abort() {
-        clearRequest.call(this[state$4]);
-    }
-    getAllResponseHeaders() {
-        if (!this[state$4][_responseHeaders])
-            return "";
-        return objectEntries(this[state$4][_responseHeaders] || {}).map(([k, v]) => `${k}: ${v}\r\n`).join("");
-    }
-    getResponseHeader(name) {
-        var _l, _m;
-        if (!this[state$4][_responseHeaders])
-            return null;
-        let nameKey = name.toLowerCase();
-        return (_m = (_l = objectEntries(this[state$4][_responseHeaders] || {}).find(x => x[0].toLowerCase() === nameKey)) === null || _l === void 0 ? void 0 : _l[1]) !== null && _m !== void 0 ? _m : null;
-    }
-    open(...args) {
-        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 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) {
-            let _username = String(username !== null && username !== void 0 ? username : "");
-            let _password = String(password !== null && password !== void 0 ? password : "");
-            if (_username.length > 0 || _password.length > 0) {
-                let 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.`);
-        }
-    }
-    send(body) {
-        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");
-        }
-        that[_inAfterOpenBeforeSend] = false;
-        const allowsRequestBody = that[_method] !== "GET" && that[_method] !== "HEAD";
-        const processHeaders = allowsRequestBody && Object.keys(that[_requestHeaders]).map(x => x.toLowerCase()).indexOf("content-type") === -1;
-        const upload = that.upload;
-        const processContentLength = upload && upload[state$f][_executors].length > 0;
-        let headers = processHeaders ? Object.assign({}, that[_requestHeaders]) : that[_requestHeaders];
-        let contentLength = zero;
-        let data = convert(body, processHeaders ? v => { assignRequestHeader(headers, "Content-Type", v); } : void 0, processContentLength ? v => { contentLength = v; } : void 0);
-        let options = {
-            url: that[_requestURL],
-            method: that[_method],
-            header: headers,
-            data,
-            dataType: that.responseType === "json" ? "json" : normalizeDataType(that.responseType),
-            responseType: normalizeDataType(that.responseType),
-            success: requestSuccess.bind(that),
-            fail: requestFail.bind(that),
-            complete: requestComplete.bind(that),
-        };
-        if (that.withCredentials) {
-            options.withCredentials = true;
-            options.enableCookie = true;
-        }
-        that[_requestTask] = request(options);
-        emitProcessEvent(this, "loadstart");
-        if (processContentLength) {
-            const hasRequestBody = allowsRequestBody && (typeof data === "string" ? data.length > 0 : data.byteLength > 0);
-            if (hasRequestBody) {
-                emitProcessEvent(upload, "loadstart", 0, contentLength);
-            }
-            setTimeout(() => {
-                const _aborted = that[_inAfterOpenBeforeSend] || that.readyState !== XMLHttpRequestP.OPENED;
-                const _contentLength = _aborted ? 0 : contentLength;
-                if (_aborted) {
-                    emitProcessEvent(upload, "abort");
-                }
-                else {
-                    if (hasRequestBody) {
-                        emitProcessEvent(upload, "load", _contentLength, _contentLength);
-                    }
-                }
-                if (_aborted || hasRequestBody) {
-                    emitProcessEvent(upload, "loadend", _contentLength, _contentLength);
-                }
-            });
-        }
-        checkRequestTimeout.call(that);
-    }
-    setRequestHeader(name, value) {
-        assignRequestHeader(this[state$4][_requestHeaders], name, value);
-    }
-    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);
+    else if (kind === "formData") {
+        let text = convertBack("text", payload);
+        return createFormDataFromBody(text);
     }
-    toString() { return "[object XMLHttpRequest]"; }
-    get isPolyfill() { return { symbol: polyfill, hierarchy: ["XMLHttpRequest", "XMLHttpRequestEventTarget", "EventTarget"] }; }
-}
-const properties = {
-    UNSENT: { value: 0, enumerable: true },
-    OPENED: { value: 1, enumerable: true },
-    HEADERS_RECEIVED: { value: 2, enumerable: true },
-    LOADING: { value: 3, enumerable: true },
-    DONE: { value: 4, enumerable: true },
-};
-Object.defineProperties(XMLHttpRequestP, properties);
-Object.defineProperties(XMLHttpRequestP.prototype, properties);
-defineStringTag(XMLHttpRequestP, "XMLHttpRequest");
-/** @internal */ const _handlers = Symbol();
-/** @internal */ const _inAfterOpenBeforeSend = Symbol();
-/** @internal */ const _resetPending = Symbol();
-/** @internal */ const _timeoutId = Symbol();
-/** @internal */ const _requestURL = Symbol();
-/** @internal */ const _method = Symbol();
-/** @internal */ const _requestHeaders = Symbol();
-const _responseHeaders = Symbol();
-/** @internal */ const _responseContentLength = Symbol();
-/** @internal */ const _requestTask = Symbol();
-/** @internal */
-class XMLHttpRequestState {
-    constructor(target) {
-        this.readyState = XMLHttpRequestP.UNSENT;
-        this.response = "";
-        this.responseType = "";
-        this.responseURL = "";
-        this.status = 0;
-        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] = zero;
-        this[_k] = null;
-        this.target = target;
+    else if (kind === "json") {
+        return convertBack("json", payload);
     }
-}
-_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;
-    let lengthStr = this.target.getResponseHeader("Content-Length");
-    this[_responseContentLength] = () => { return lengthStr ? parseInt(lengthStr) : 0; };
-    if (this.readyState === XMLHttpRequestP.OPENED) {
-        setReadyStateAndNotify.call(this, XMLHttpRequestP.HEADERS_RECEIVED);
-        setReadyStateAndNotify.call(this, XMLHttpRequestP.LOADING);
-        setTimeout(() => {
-            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");
-                }
-            }
-        });
+    else {
+        return convertBack("text", payload);
     }
 }
-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 });
+function consumed(body, kind) {
+    const s = body[state$7];
+    if (!s[_body])
         return;
+    if (s.bodyUsed) {
+        return Promise.reject(new TypeError(`TypeError: Failed to execute '${kind}' on '${s[_name]}': body stream already read`));
     }
-    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(() => {
-            const requestTask = this[_requestTask];
-            if (requestTask) {
-                requestTask.abort();
-            }
-            if (delay) {
-                emitProcessEvent(this.target, "abort");
-            }
-            if (delay && !requestTask) {
-                emitProcessEvent(this.target, "loadend");
-            }
-        });
-    }
-    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);
-    }
-}
-function resetXHR() {
-    this[_resetPending] = false;
-    resetRequestTimeout.call(this);
-    this.response = "";
-    this.responseURL = "";
-    this.status = 0;
-    this.statusText = "";
-    this[_requestHeaders] = {};
-    this[_responseHeaders] = null;
-    this[_responseContentLength] = zero;
-}
-function resetRequestTimeout() {
-    if (this[_timeoutId]) {
-        clearTimeout(this[_timeoutId]);
-        this[_timeoutId] = 0;
-    }
-}
-function setReadyStateAndNotify(value) {
-    let hasChanged = value !== this.readyState;
-    this.readyState = value;
-    if (hasChanged) {
-        let evt = createInnerEvent(this.target, "readystatechange");
-        fire.call(this.target[state$f], evt);
-    }
-}
-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"];
-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) {
-    let nameKey = name.toLowerCase();
-    for (let key of Object.keys(headers)) {
-        if (key.toLowerCase() === nameKey) {
-            headers[key] = value;
-            return;
-        }
-    }
-    Object.assign(headers, { [name]: value });
-    return;
+    s.bodyUsed = true;
 }
 const encode = (str) => {
     const encoder = new TextEncoderP();
@@ -1904,6 +1596,7 @@ const decode = (buf) => {
     let decoder = new TextDecoderP();
     return decoder.decode(buf);
 };
+/** @internal */
 function convert(body, setContentType, setContentLength) {
     let result;
     if (typeof body === "string") {
@@ -1925,14 +1618,14 @@ function convert(body, setContentType, setContentLength) {
         result = body.buffer.slice(body.byteOffset, body.byteOffset + body.byteLength);
     }
     else if (isPolyfillType("Blob", body)) {
-        result = body[state$c].toArrayBuffer().slice(0);
+        result = Blob_toUint8Array(body).buffer.slice(0);
         if (setContentType && body.type) {
             setContentType(body.type);
         }
     }
     else if (isPolyfillType("FormData", body)) {
-        let blob = body[state$9].toBlob();
-        result = blob[state$c].toArrayBuffer();
+        let blob = FormData_toBlob(body);
+        result = Blob_toUint8Array(blob).buffer;
         if (setContentType) {
             setContentType(blob.type);
         }
@@ -1944,12 +1637,11 @@ function convert(body, setContentType, setContentLength) {
         result = String(body);
     }
     if (setContentLength) {
-        setContentLength(() => {
-            return (typeof result === "string" ? encode(result) : result).byteLength;
-        });
+        setContentLength(() => (typeof result === "string" ? encode(result) : result).byteLength);
     }
     return result;
 }
+/** @internal */
 function convertBack(type, data) {
     let temp = !!data ? (typeof data !== "string" && !(data instanceof ArrayBuffer) ? JSON.stringify(data) : data) : "";
     if (!type || type === "text") {
@@ -1968,189 +1660,13 @@ function convertBack(type, data) {
         return temp;
     }
 }
-const zero = () => 0;
-const statusMessages = {
-    100: "Continue",
-    101: "Switching Protocols",
-    102: "Processing",
-    103: "Early Hints",
-    200: "OK",
-    201: "Created",
-    202: "Accepted",
-    203: "Non-Authoritative Information",
-    204: "No Content",
-    205: "Reset Content",
-    206: "Partial Content",
-    207: "Multi-Status",
-    208: "Already Reported",
-    226: "IM Used",
-    300: "Multiple Choices",
-    301: "Moved Permanently",
-    302: "Found",
-    303: "See Other",
-    304: "Not Modified",
-    307: "Temporary Redirect",
-    308: "Permanent Redirect",
-    400: "Bad Request",
-    401: "Unauthorized",
-    402: "Payment Required",
-    403: "Forbidden",
-    404: "Not Found",
-    405: "Method Not Allowed",
-    406: "Not Acceptable",
-    407: "Proxy Authentication Required",
-    408: "Request Timeout",
-    409: "Conflict",
-    410: "Gone",
-    411: "Length Required",
-    412: "Precondition Failed",
-    413: "Content Too Large",
-    414: "URI Too Long",
-    415: "Unsupported Media Type",
-    416: "Range Not Satisfiable",
-    417: "Expectation Failed",
-    418: "I'm a teapot",
-    421: "Misdirected Request",
-    422: "Unprocessable Entity",
-    423: "Locked",
-    424: "Failed Dependency",
-    425: "Too Early",
-    426: "Upgrade Required",
-    428: "Precondition Required",
-    429: "Too Many Requests",
-    431: "Request Header Fields Too Large",
-    451: "Unavailable For Legal Reasons",
-    500: "Internal Server Error",
-    501: "Not Implemented",
-    502: "Bad Gateway",
-    503: "Service Unavailable",
-    504: "Gateway Timeout",
-    505: "HTTP Version Not Supported",
-    506: "Variant Also Negotiates",
-    507: "Insufficient Storage",
-    508: "Loop Detected",
-    510: "Not Extended",
-    511: "Network Authentication Required"
-};
-function statusTextMap(val) {
-    return statusMessages[val] || "unknown";
-}
-const XMLHttpRequestE = (typeof XMLHttpRequest !== "undefined" && XMLHttpRequest) || XMLHttpRequestP;
-
-var _a$1, _b;
-/** @internal */
-const state$3 = Symbol( /* "BodyState" */);
-class BodyP {
-    constructor() {
-        if (new.target === BodyP) {
-            throw new TypeError("Failed to construct 'Body': Illegal constructor");
-        }
-        this[state$3] = new BodyState();
-    }
-    get body() {
-        if (!this[state$3][_body]) {
-            return null;
-        }
-        throw new ReferenceError("ReadableStream is not defined");
-    }
-    get bodyUsed() { return this[state$3].bodyUsed; }
-    ;
-    arrayBuffer() {
-        const kind = "arrayBuffer";
-        return consumed.call(this[state$3], kind) || read.call(this[state$3], kind);
-    }
-    blob() {
-        const kind = "blob";
-        return consumed.call(this[state$3], kind) || read.call(this[state$3], kind);
-    }
-    bytes() {
-        const kind = "bytes";
-        return consumed.call(this[state$3], kind) || read.call(this[state$3], kind);
-    }
-    formData() {
-        const kind = "formData";
-        return consumed.call(this[state$3], kind) || read.call(this[state$3], kind);
-    }
-    json() {
-        const kind = "json";
-        return consumed.call(this[state$3], kind) || read.call(this[state$3], kind);
-    }
-    text() {
-        const kind = "text";
-        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();
-/** @internal */
-class BodyState {
-    constructor() {
-        this.bodyUsed = false;
-        this[_a$1] = "Body";
-        this[_b] = "";
-    }
-}
-_a$1 = _name, _b = _body;
-function initFn(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);
-        }
-    });
-}
-function read(kind) {
-    return new Promise((resolve, reject) => {
-        try {
-            resolve(readSync.call(this, kind));
-        }
-        catch (e) {
-            reject(e);
-        }
-    });
-}
-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;
+var _a$2;
 /** @internal */
-const state$2 = Symbol( /* "HeadersState" */);
+const state$6 = Symbol( /* "HeadersState" */);
 class HeadersP {
     constructor(init) {
-        this[state$2] = new HeadersState();
+        this[state$6] = new HeadersState();
         if (isObjectType("Headers", init)) {
             init.forEach((value, name) => {
                 this.append(name, value);
@@ -2176,18 +1692,18 @@ class HeadersP {
     append(name, value) {
         var _b;
         let key = normalizeName(name, "append");
-        value = normalizeValue(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]);
+        let newValue = normalizeValue(value);
+        let oldValue = (_b = this[state$6][_headersMap].get(key)) === null || _b === void 0 ? void 0 : _b[1];
+        this[state$6][_headersMap].set(key, ["" + name, oldValue ? `${oldValue}, ${newValue}` : newValue]);
     }
     delete(name) {
         let key = normalizeName(name, "delete");
-        this[state$2][_headersMap].delete(key);
+        this[state$6][_headersMap].delete(key);
     }
     get(name) {
         var _b, _c;
         let key = normalizeName(name, "get");
-        return (_c = (_b = this[state$2][_headersMap].get(key)) === null || _b === void 0 ? void 0 : _b[1]) !== null && _c !== void 0 ? _c : null;
+        return (_c = (_b = this[state$6][_headersMap].get(key)) === null || _b === void 0 ? void 0 : _b[1]) !== null && _c !== void 0 ? _c : null;
     }
     getSetCookie() {
         let value = this.get("Set-Cookie");
@@ -2195,11 +1711,11 @@ class HeadersP {
     }
     has(name) {
         let key = normalizeName(name, "has");
-        return this[state$2][_headersMap].has(key);
+        return this[state$6][_headersMap].has(key);
     }
     set(name, value) {
         let key = normalizeName(name, "set");
-        this[state$2][_headersMap].set(key, ["" + name, normalizeValue(value)]);
+        this[state$6][_headersMap].set(key, ["" + name, normalizeValue(value)]);
     }
     forEach(callbackfn, thisArg) {
         Array.from(this.entries()).forEach(([name, value]) => {
@@ -2207,7 +1723,7 @@ class HeadersP {
         });
     }
     entries() {
-        return this[state$2][_headersMap].values();
+        return this[state$6][_headersMap].values();
     }
     keys() {
         return Array.from(this.entries()).map(pair => pair[0]).values();
@@ -2221,16 +1737,74 @@ class HeadersP {
     toString() { return "[object Headers]"; }
     get isPolyfill() { return { symbol: polyfill, hierarchy: ["Headers"] }; }
 }
-defineStringTag(HeadersP, "Headers");
+dfStringTag(HeadersP, "Headers");
 /** @internal */
 const _headersMap = Symbol();
 /** @internal */
 class HeadersState {
     constructor() {
-        this[_a] = new Map();
+        this[_a$2] = new SimpleMap();
     }
 }
-_a = _headersMap;
+_a$2 = _headersMap;
+/** @internal */
+class SimpleMap {
+    constructor() {
+        this.array = [];
+    }
+    get(key) {
+        for (let i = 0; i < this.array.length; ++i) {
+            let pair = this.array[i];
+            if (pair[0] === key) {
+                return pair[1];
+            }
+        }
+    }
+    set(key, value) {
+        let index = -1;
+        for (let i = 0; i < this.array.length; ++i) {
+            let pair = this.array[i];
+            if (pair[0] === key) {
+                pair[1] = value;
+                index = i;
+                break;
+            }
+        }
+        if (index === -1) {
+            this.array.push([key, value]);
+        }
+        return this.array;
+    }
+    has(key) {
+        for (let i = 0; i < this.array.length; ++i) {
+            let pair = this.array[i];
+            if (pair[0] === key) {
+                return true;
+            }
+        }
+        return false;
+    }
+    delete(key) {
+        let index = -1;
+        let array = [];
+        for (let i = 0; i < this.array.length; ++i) {
+            let pair = this.array[i];
+            if (pair[0] === key) {
+                index = i;
+                continue;
+            }
+            array.push(pair);
+        }
+        if (index > -1) {
+            this.array = array;
+        }
+        return index > -1;
+    }
+    values() {
+        return this.array.map(x => x[1]).values();
+    }
+}
+/** @internal */
 function normalizeName(name, kind = "") {
     if (typeof name !== "string") {
         name = String(name);
@@ -2242,12 +1816,14 @@ function normalizeName(name, kind = "") {
     }
     return name.toLowerCase();
 }
+/** @internal */
 function normalizeValue(value) {
     if (typeof value !== "string") {
         value = String(value);
     }
     return value;
 }
+/** @internal */
 function parseHeaders(rawHeaders) {
     let headers = new HeadersP();
     let preProcessedHeaders = rawHeaders.replace(/\r?\n[\t ]+/g, " ");
@@ -2274,13 +1850,34 @@ function parseHeaders(rawHeaders) {
 const HeadersE = g["Headers"] || HeadersP;
 
 /** @internal */
-const state$1 = Symbol( /* "RequestState" */);
-class RequestP extends BodyP {
+const state$5 = Symbol( /* "AbortControllerState" */);
+class AbortControllerP {
+    constructor() {
+        this[state$5] = new AbortControllerState();
+    }
+    get signal() { return this[state$5].signal; }
+    abort(reason) {
+        AbortSignal_abort(this[state$5].signal, reason);
+    }
+    toString() { return "[object AbortController]"; }
+    get isPolyfill() { return { symbol: polyfill, hierarchy: ["AbortController"] }; }
+}
+dfStringTag(AbortControllerP, "AbortController");
+/** @internal */
+class AbortControllerState {
+    constructor() {
+        this.signal = createAbortSignal();
+    }
+}
+const AbortControllerE = g["AbortController"] || AbortControllerP;
+
+/** @internal */ const state$4 = Symbol( /* "RequestState" */);
+class RequestP extends BodyImpl {
     constructor(input, init) {
         super();
-        this[state$1] = new RequestState();
-        const that = this[state$1];
-        this[state$3][_name] = "Request";
+        Body_setName(this, "Request");
+        this[state$4] = new RequestState();
+        const that = this[state$4];
         let options = init !== null && init !== void 0 ? init : {};
         let body = options.body;
         if (isPolyfillType("Request", input)) {
@@ -2293,15 +1890,15 @@ class RequestP extends BodyP {
             }
             that.method = input.method;
             that.mode = input.mode;
-            let inputSignal = input[state$1].signal;
+            let inputSignal = input[state$4].signal;
             if (inputSignal) {
                 that.signal = inputSignal;
             }
             that.url = input.url;
-            let _input = input;
-            if (!body && _input[state$3][_body] !== null) {
-                body = _input[state$3][_body];
-                _input[state$3].bodyUsed = true;
+            let payload = Body_toPayload(input);
+            if (!body && payload !== null) {
+                body = payload;
+                Body_setBodyUsed(input, true);
             }
         }
         else {
@@ -2325,7 +1922,7 @@ class RequestP extends BodyP {
         if ((this.method === "GET" || this.method === "HEAD") && body) {
             throw new TypeError("Failed to construct 'Request': Request with GET/HEAD method cannot have body.");
         }
-        initFn.call(this[state$3], body, this.headers);
+        Body_init(this, 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
@@ -2342,153 +1939,707 @@ class RequestP extends BodyP {
             }
         }
     }
-    get cache() { return this[state$1].cache; }
-    get credentials() { return this[state$1].credentials; }
-    get destination() { return this[state$1].destination; }
+    get cache() { return this[state$4].cache; }
+    get credentials() { return this[state$4].credentials; }
+    get destination() { return this[state$4].destination; }
     get headers() {
-        const that = this[state$1];
+        const that = this[state$4];
         if (!that.headers) {
             that.headers = new HeadersP();
         }
-        return that.headers;
+        return that.headers;
+    }
+    get integrity() { return this[state$4].integrity; }
+    get keepalive() { return this[state$4].keepalive; }
+    get method() { return this[state$4].method; }
+    get mode() { return this[state$4].mode; }
+    get redirect() { return this[state$4].redirect; }
+    get referrer() { return this[state$4].referrer; }
+    get referrerPolicy() { return this[state$4].referrerPolicy; }
+    get signal() {
+        const that = this[state$4];
+        if (!that.signal) {
+            that.signal = (new AbortControllerP()).signal;
+        }
+        return that.signal;
+    }
+    get url() { return this[state$4].url; }
+    clone() {
+        var _a;
+        return new RequestP(this, { body: (_a = Body_toPayload(this)) !== null && _a !== void 0 ? _a : null });
+    }
+    toString() { return "[object Request]"; }
+    get isPolyfill() { return { symbol: polyfill, hierarchy: ["Request", "Body"] }; }
+}
+dfStringTag(RequestP, "Request");
+/** @internal */
+class RequestState {
+    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 = "";
+    }
+}
+// HTTP methods whose capitalization should be normalized
+const methods = ["CONNECT", "DELETE", "GET", "HEAD", "OPTIONS", "PATCH", "POST", "PUT", "TRACE"];
+/** @internal */
+function normalizeMethod(method) {
+    let upcased = method.toUpperCase();
+    return methods.indexOf(upcased) > -1 ? upcased : method;
+}
+const RequestE = g["Request"] || RequestP;
+
+/** @internal */ const state$3 = Symbol( /* "ResponseState" */);
+class ResponseP extends BodyImpl {
+    constructor(body, init) {
+        super();
+        Body_setName(this, "Response");
+        this[state$3] = new ResponseState();
+        const that = this[state$3];
+        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) {
+            that.headers = new HeadersP(options.headers);
+        }
+        that.ok = this.status >= 200 && this.status < 300;
+        that.status = status;
+        that.statusText = options.statusText === undefined ? "" : "" + options.statusText;
+        Body_init(this, body, this.headers);
+    }
+    get headers() {
+        const that = this[state$3];
+        if (!that.headers) {
+            that.headers = new HeadersP();
+        }
+        return that.headers;
+    }
+    get ok() { return this[state$3].ok; }
+    get redirected() { return this[state$3].redirected; }
+    get status() { return this[state$3].status; }
+    get statusText() { return this[state$3].statusText; }
+    get type() { return this[state$3].type; }
+    get url() { return this[state$3].url; }
+    clone() {
+        let response = new ResponseP(Body_toPayload(this), {
+            headers: new HeadersP(this.headers),
+            status: this.status,
+            statusText: this.statusText,
+        });
+        response[state$3].url = this.url;
+        return response;
+    }
+    static json(data, init) {
+        return new ResponseP(JSON.stringify(data), init);
+    }
+    static error() {
+        let response = new ResponseP(null, { status: 200, statusText: "" });
+        response[state$3].ok = false;
+        response[state$3].status = 0;
+        response[state$3].type = "error";
+        return response;
+    }
+    static redirect(url, status = 301) {
+        if ([301, 302, 303, 307, 308].indexOf(status) === -1) {
+            throw new RangeError("Failed to execute 'redirect' on 'Response': Invalid status code");
+        }
+        return new ResponseP(null, { status, headers: { location: String(url) } });
+    }
+    toString() { return "[object Response]"; }
+    get isPolyfill() { return { symbol: polyfill, hierarchy: ["Response", "Body"] }; }
+}
+dfStringTag(ResponseP, "Response");
+/** @internal */
+class ResponseState {
+    constructor() {
+        this.ok = true;
+        this.redirected = false;
+        this.status = 200;
+        this.statusText = "";
+        this.type = "default";
+        this.url = "";
+    }
+}
+const ResponseE = g["Response"] || ResponseP;
+
+var _a$1;
+/** @internal */ const state$2 = Symbol( /* "XMLHttpRequestEventTargetState" */);
+class XMLHttpRequestEventTargetP extends EventTargetP {
+    constructor() {
+        if (new.target === XMLHttpRequestEventTargetP) {
+            throw new TypeError("Failed to construct 'XMLHttpRequestEventTarget': Illegal constructor");
+        }
+        super();
+        this[state$2] = new XMLHttpRequestEventTargetState(this);
+    }
+    get onabort() { return this[state$2].onabort; }
+    set onabort(value) { this[state$2].onabort = value; attach(this, "abort"); }
+    get onerror() { return this[state$2].onerror; }
+    set onerror(value) { this[state$2].onerror = value; attach(this, "error"); }
+    get onload() { return this[state$2].onload; }
+    set onload(value) { this[state$2].onload = value; attach(this, "load"); }
+    get onloadend() { return this[state$2].onloadend; }
+    set onloadend(value) { this[state$2].onloadend = value; attach(this, "loadend"); }
+    get onloadstart() { return this[state$2].onloadstart; }
+    set onloadstart(value) { this[state$2].onloadstart = value; attach(this, "loadstart"); }
+    get onprogress() { return this[state$2].onprogress; }
+    set onprogress(value) { this[state$2].onprogress = value; attach(this, "progress"); }
+    get ontimeout() { return this[state$2].ontimeout; }
+    set ontimeout(value) { this[state$2].ontimeout = value; attach(this, "timeout"); }
+    toString() { return "[object XMLHttpRequestEventTarget]"; }
+    get isPolyfill() { return { symbol: polyfill, hierarchy: ["XMLHttpRequestEventTarget", "EventTarget"] }; }
+}
+dfStringTag(XMLHttpRequestEventTargetP, "XMLHttpRequestEventTarget");
+/** @internal */
+const _handlers$1 = Symbol();
+/** @internal */
+class XMLHttpRequestEventTargetState {
+    /**
+     * @param _target XMLHttpRequestEventTarget
+     */
+    constructor(_target) {
+        this[_a$1] = getHandlers$1(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;
+    }
+}
+_a$1 = _handlers$1;
+function attach(target, type) {
+    const s = target[state$2];
+    const fnName = ("on" + type);
+    const cb = s[fnName];
+    const listener = s[_handlers$1][fnName];
+    attachFn(target, type, cb, listener);
+}
+function getHandlers$1(s) {
+    return {
+        onabort: (ev) => { executeFn(s.target, s.onabort, ev); },
+        onerror: (ev) => { executeFn(s.target, s.onerror, ev); },
+        onload: (ev) => { executeFn(s.target, s.onload, ev); },
+        onloadend: (ev) => { executeFn(s.target, s.onloadend, ev); },
+        onloadstart: (ev) => { executeFn(s.target, s.onloadstart, ev); },
+        onprogress: (ev) => { executeFn(s.target, s.onprogress, ev); },
+        ontimeout: (ev) => { executeFn(s.target, s.ontimeout, ev); },
+    };
+}
+
+class XMLHttpRequestUploadP extends XMLHttpRequestEventTargetP {
+    constructor() {
+        if (new.target === XMLHttpRequestUploadP) {
+            throw new TypeError("Failed to construct 'XMLHttpRequestUpload': Illegal constructor");
+        }
+        super();
+    }
+    toString() { return "[object XMLHttpRequestUpload]"; }
+    get isPolyfill() { return { symbol: polyfill, hierarchy: ["XMLHttpRequestUpload", "XMLHttpRequestEventTarget", "EventTarget"] }; }
+}
+dfStringTag(XMLHttpRequestUploadP, "XMLHttpRequestUpload");
+/** @internal */
+function createXMLHttpRequestUpload() {
+    let upload = Object.create(XMLHttpRequestUploadP.prototype);
+    upload[state$d] = new EventTargetState(upload);
+    upload[state$2] = new XMLHttpRequestEventTargetState(upload);
+    return upload;
+}
+
+// @ts-nocheck
+/** @internal */
+const mp$2 = (() => {
+    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
+            (typeof xhs !== u && typeof (xhs === null || xhs === void 0 ? void 0 : xhs[r]) === f && xhs) || // 小红书
+            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$2 ? mp$2.request : function errorRequest(options) {
+    const errMsg = "NOT_SUPPORTED_ERR";
+    const errno = 9;
+    const err = {
+        errMsg,
+        errno,
+        exception: {
+            retryCount: 0,
+            reasons: [{ errMsg, errno }],
+        },
+        useHttpDNS: false,
+    };
+    Promise.resolve(err)
+        .then(err => { try {
+        if (options.fail) {
+            options.fail(err);
+        }
+    }
+    catch (e) {
+        console.error(e);
+    } })
+        .then(() => { if (options.complete) {
+        options.complete(err);
+    } });
+    throw new ReferenceError("request is not defined");
+};
+
+var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+const mp$1 = { request: request };
+const setRequest = (request) => { mp$1.request = request; };
+/** @internal */ const state$1 = Symbol( /* "XMLHttpRequestState" */);
+class XMLHttpRequestP extends XMLHttpRequestEventTargetP {
+    constructor() {
+        super();
+        this[state$1] = new XMLHttpRequestState(this);
+    }
+    get readyState() { return this[state$1].readyState; }
+    get response() { return this[state$1].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 = normalizeResponseType(value); }
+    get responseURL() { return this[state$1].responseURL; }
+    get responseXML() { return null; }
+    get status() { return this[state$1].status; }
+    get statusText() {
+        if (this.readyState === XMLHttpRequestP.UNSENT || this.readyState === XMLHttpRequestP.OPENED)
+            return "";
+        return this[state$1].statusText || statusTextMap(this.status);
+    }
+    get timeout() { return this[state$1].timeout; }
+    set timeout(value) { this[state$1].timeout = value > 0 ? value : 0; }
+    get upload() {
+        const that = this[state$1];
+        if (!that.upload) {
+            that.upload = createXMLHttpRequestUpload();
+        }
+        return that.upload;
+    }
+    get withCredentials() { return this[state$1].withCredentials; }
+    set withCredentials(value) { this[state$1].withCredentials = !!value; }
+    abort() {
+        clearRequest(this);
+    }
+    getAllResponseHeaders() {
+        if (!this[state$1][_responseHeaders])
+            return "";
+        return Array.from(this[state$1][_responseHeaders].entries()).map(([k, v]) => `${k}: ${v}\r\n`).join("");
+    }
+    getResponseHeader(name) {
+        if (!this[state$1][_responseHeaders])
+            return null;
+        return this[state$1][_responseHeaders].get(name);
+    }
+    open(...args) {
+        const [method, url, async = true, username = null, password = null] = args;
+        const that = this[state$1];
+        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 not supported because of its detrimental effects to the end user's experience.");
+        }
+        clearRequest(this, false);
+        that[_method] = normalizeMethod(method);
+        that[_requestURL] = String(url);
+        if (username !== null || password !== null) {
+            let _username = String(username !== null && username !== void 0 ? username : "");
+            let _password = String(password !== null && password !== void 0 ? password : "");
+            if (_username.length > 0 || _password.length > 0) {
+                let auth = `Basic ${Uint8Array_toBase64((new TextEncoderP()).encode(_username + ":" + _password))}`;
+                this.setRequestHeader("Authorization", auth);
+            }
+        }
+        that[_inAfterOpenBeforeSend] = true;
+        setReadyStateAndNotify(this, XMLHttpRequestP.OPENED);
+    }
+    overrideMimeType(mime) {
+        if (this[state$1][_inAfterOpenBeforeSend]) {
+            console.warn(`XMLHttpRequest.overrideMimeType('${mime}') is not implemented: The method will have no effect on response parsing.`);
+        }
+    }
+    send(body) {
+        const that = this[state$1];
+        if (!that[_inAfterOpenBeforeSend] || that.readyState !== XMLHttpRequestP.OPENED) {
+            throw new MPException("Failed to execute 'send' on 'XMLHttpRequest': The object's state must be OPENED.", "InvalidStateError");
+        }
+        that[_inAfterOpenBeforeSend] = false;
+        const allowsRequestBody = that[_method] !== "GET" && that[_method] !== "HEAD";
+        const processHeaders = allowsRequestBody && !that[_requestHeaders].has("Content-Type");
+        const upload = that.upload;
+        const processContentLength = upload && EventTarget_count(upload) > 0;
+        let headers = () => Array.from(that[_requestHeaders].entries())
+            .reduce((acc, cur) => { acc[cur[0]] = cur[1]; return acc; }, {});
+        let contentLength = zero;
+        const processHeadersFn = processHeaders ? (v) => { that[_requestHeaders].set("Content-Type", v); } : void 0;
+        const processContentLengthFn = processContentLength ? (v) => { contentLength = v; } : void 0;
+        let data = body;
+        try {
+            data = convert(body, processHeadersFn, processContentLengthFn);
+        }
+        catch (e) {
+            console.warn(e);
+        }
+        let options = {
+            url: that[_requestURL],
+            method: that[_method],
+            header: headers(),
+            data,
+            dataType: that.responseType === "json" ? "json" : normalizeDataType(that.responseType),
+            responseType: normalizeDataType(that.responseType),
+            withCredentials: that.withCredentials,
+            success: requestSuccess.bind(this),
+            fail: requestFail.bind(this),
+            complete: requestComplete.bind(this),
+        };
+        that[_requestTask] = mp$1.request(options);
+        emitProcessEvent(this, "loadstart");
+        if (processContentLength) {
+            const hasRequestBody = allowsRequestBody && !!data;
+            if (hasRequestBody) {
+                emitProcessEvent(upload, "loadstart", 0, contentLength);
+            }
+            setTimeout(() => {
+                const _aborted = that[_inAfterOpenBeforeSend] || that.readyState !== XMLHttpRequestP.OPENED;
+                const _contentLength = _aborted ? 0 : contentLength;
+                if (_aborted) {
+                    emitProcessEvent(upload, "abort");
+                }
+                else {
+                    if (hasRequestBody) {
+                        emitProcessEvent(upload, "load", _contentLength, _contentLength);
+                    }
+                }
+                if (_aborted || hasRequestBody) {
+                    emitProcessEvent(upload, "loadend", _contentLength, _contentLength);
+                }
+            });
+        }
+        checkRequestTimeout(this);
     }
-    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;
+    setRequestHeader(name, value) {
+        this[state$1][_requestHeaders].append(name, value);
     }
-    get url() { return this[state$1].url; }
-    clone() {
-        var _a;
-        return new RequestP(this, { body: (_a = this[state$3][_body]) !== null && _a !== void 0 ? _a : null });
+    get onreadystatechange() { return this[state$1].onreadystatechange; }
+    set onreadystatechange(value) {
+        this[state$1].onreadystatechange = value;
+        attachFn(this, "readystatechange", value, this[state$1][_handlers].onreadystatechange);
     }
-    toString() { return "[object Request]"; }
-    get isPolyfill() { return { symbol: polyfill, hierarchy: ["Request", "Body"] }; }
+    toString() { return "[object XMLHttpRequest]"; }
+    get isPolyfill() { return { symbol: polyfill, hierarchy: ["XMLHttpRequest", "XMLHttpRequestEventTarget", "EventTarget"] }; }
 }
-defineStringTag(RequestP, "Request");
+const properties = {
+    UNSENT: { value: 0, enumerable: true },
+    OPENED: { value: 1, enumerable: true },
+    HEADERS_RECEIVED: { value: 2, enumerable: true },
+    LOADING: { value: 3, enumerable: true },
+    DONE: { value: 4, enumerable: true },
+};
+Object.defineProperties(XMLHttpRequestP, properties);
+Object.defineProperties(XMLHttpRequestP.prototype, properties);
+dfStringTag(XMLHttpRequestP, "XMLHttpRequest");
+/** @internal */ const _handlers = Symbol();
+/** @internal */ const _inAfterOpenBeforeSend = Symbol();
+/** @internal */ const _resetPending = Symbol();
+/** @internal */ const _timeoutId = Symbol();
+/** @internal */ const _requestURL = Symbol();
+/** @internal */ const _method = Symbol();
+/** @internal */ const _requestHeaders = Symbol();
+/** @internal */ const _responseHeaders = Symbol();
+/** @internal */ const _responseContentLength = Symbol();
+/** @internal */ const _requestTask = Symbol();
 /** @internal */
-class RequestState {
-    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 = "";
+class XMLHttpRequestState {
+    constructor(target) {
+        this.readyState = XMLHttpRequestP.UNSENT;
+        this.response = "";
+        this.responseType = "";
+        this.responseURL = "";
+        this.status = 0;
+        this.statusText = "";
+        this.timeout = 0;
+        this.withCredentials = false;
+        this[_a] = getHandlers(this);
+        this.onreadystatechange = null;
+        this[_b] = false;
+        this[_c] = false;
+        this[_d] = 0;
+        this[_e] = "";
+        this[_f] = "GET";
+        this[_g] = new HeadersP();
+        this[_h] = null;
+        this[_j] = zero;
+        this[_k] = null;
+        this.target = target;
     }
 }
-const RequestE = g["Request"] || RequestP;
-
-/** @internal */
-const state = Symbol( /* "ResponseState" */);
-class ResponseP extends BodyP {
-    constructor(body, init) {
-        super();
-        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) {
-            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() {
-        let response = new ResponseP(this[state$3][_body], {
-            headers: new HeadersP(this.headers),
-            status: this.status,
-            statusText: this.statusText,
+_a = _handlers, _b = _inAfterOpenBeforeSend, _c = _resetPending, _d = _timeoutId, _e = _requestURL, _f = _method, _g = _requestHeaders, _h = _responseHeaders, _j = _responseContentLength, _k = _requestTask;
+function requestSuccess({ statusCode, header, data }) {
+    const s = this[state$1];
+    s.responseURL = s[_requestURL];
+    s.status = statusCode;
+    s[_responseHeaders] = new HeadersP(header);
+    let lengthStr = s[_responseHeaders].get("Content-Length");
+    s[_responseContentLength] = () => { return lengthStr ? parseInt(lengthStr) : 0; };
+    if (s.readyState === XMLHttpRequestP.OPENED) {
+        setReadyStateAndNotify(this, XMLHttpRequestP.HEADERS_RECEIVED);
+        setReadyStateAndNotify(this, XMLHttpRequestP.LOADING);
+        setTimeout(() => {
+            if (!s[_inAfterOpenBeforeSend]) {
+                let l = s[_responseContentLength];
+                try {
+                    s.response = convertBack(s.responseType, data);
+                    emitProcessEvent(this, "load", l, l);
+                }
+                catch (e) {
+                    console.error(e);
+                    emitProcessEvent(this, "error");
+                }
+            }
         });
-        response[state].url = this.url;
-        return response;
     }
-    static json(data, init) {
-        return new Response(JSON.stringify(data), init);
+}
+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;
     }
-    static error() {
-        let response = new ResponseP(null, { status: 200, statusText: "" });
-        response[state].ok = false;
-        response[state].status = 0;
-        response[state].type = "error";
-        return response;
+    const s = this[state$1];
+    s.status = 0;
+    s.statusText = "errMsg" in err ? err.errMsg : "errorMessage" in err ? err.errorMessage : "";
+    if (!s[_inAfterOpenBeforeSend] && s.readyState !== XMLHttpRequestP.UNSENT && s.readyState !== XMLHttpRequestP.DONE) {
+        emitProcessEvent(this, "error");
+        resetRequestTimeout(this);
     }
-    static redirect(url, status = 301) {
-        if ([301, 302, 303, 307, 308].indexOf(status) === -1) {
-            throw new RangeError("Failed to execute 'redirect' on 'Response': Invalid status code");
+}
+function requestComplete() {
+    const s = this[state$1];
+    s[_requestTask] = null;
+    if (!s[_inAfterOpenBeforeSend] && (s.readyState === XMLHttpRequestP.OPENED || s.readyState === XMLHttpRequestP.LOADING)) {
+        setReadyStateAndNotify(this, XMLHttpRequestP.DONE);
+    }
+    setTimeout(() => {
+        if (!s[_inAfterOpenBeforeSend]) {
+            let l = s[_responseContentLength];
+            emitProcessEvent(this, "loadend", l, l);
+        }
+    });
+}
+function clearRequest(xhr, delay = true) {
+    const s = xhr[state$1];
+    const timerFn = delay ? setTimeout : (f) => { f(); };
+    s[_resetPending] = true;
+    if (s[_requestTask] && s.readyState !== XMLHttpRequestP.DONE) {
+        if (delay) {
+            setReadyStateAndNotify(xhr, XMLHttpRequestP.DONE);
         }
-        return new Response(null, { status, headers: { location: String(url) } });
+        timerFn(() => {
+            const requestTask = s[_requestTask];
+            if (requestTask) {
+                requestTask.abort();
+            }
+            if (delay) {
+                emitProcessEvent(xhr, "abort");
+            }
+            if (delay && !requestTask) {
+                emitProcessEvent(xhr, "loadend");
+            }
+        });
     }
-    toString() { return "[object Response]"; }
-    get isPolyfill() { return { symbol: polyfill, hierarchy: ["Response", "Body"] }; }
+    timerFn(() => {
+        if (s[_resetPending]) {
+            if (delay) {
+                s.readyState = XMLHttpRequestP.UNSENT;
+            }
+            resetXHR(xhr);
+        }
+    });
 }
-defineStringTag(ResponseP, "Response");
-/** @internal */
-class ResponseState {
-    constructor() {
-        this.ok = true;
-        this.redirected = false;
-        this.status = 200;
-        this.statusText = "";
-        this.type = "default";
-        this.url = "";
+function checkRequestTimeout(xhr) {
+    const s = xhr[state$1];
+    if (s.timeout) {
+        s[_timeoutId] = setTimeout(() => {
+            if (!s.status && s.readyState !== XMLHttpRequestP.DONE) {
+                if (s[_requestTask])
+                    s[_requestTask].abort();
+                setReadyStateAndNotify(xhr, XMLHttpRequestP.DONE);
+                emitProcessEvent(xhr, "timeout");
+            }
+        }, s.timeout);
+    }
+}
+function resetXHR(xhr) {
+    const s = xhr[state$1];
+    s[_resetPending] = false;
+    resetRequestTimeout(xhr);
+    s.response = "";
+    s.responseURL = "";
+    s.status = 0;
+    s.statusText = "";
+    s[_requestHeaders] = new HeadersP();
+    s[_responseHeaders] = null;
+    s[_responseContentLength] = zero;
+}
+function resetRequestTimeout(xhr) {
+    const s = xhr[state$1];
+    if (s[_timeoutId]) {
+        clearTimeout(s[_timeoutId]);
+        s[_timeoutId] = 0;
+    }
+}
+function setReadyStateAndNotify(xhr, value) {
+    const s = xhr[state$1];
+    let hasChanged = value !== s.readyState;
+    s.readyState = value;
+    if (hasChanged) {
+        let evt = createInnerEvent(xhr, "readystatechange");
+        EventTarget_fire(xhr, evt);
     }
 }
-const ResponseE = g["Response"] || ResponseP;
+function getHandlers(s) {
+    return {
+        onreadystatechange: (ev) => { executeFn(s.target, s.onreadystatechange, ev); },
+    };
+}
+const responseTypes = ["", "text", "json", "arraybuffer", "blob", "document"];
+function normalizeResponseType(responseType) {
+    return responseTypes.indexOf(responseType) > -1 ? responseType : "";
+}
+function normalizeDataType(responseType) {
+    return (responseType === "blob" || responseType === "arraybuffer") ? "arraybuffer" : "text";
+}
+function getAllResponseHeaders(xhr) {
+    return xhr instanceof XMLHttpRequestP
+        ? xhr[state$1][_responseHeaders]
+        : parseHeaders(xhr.getAllResponseHeaders() || "");
+}
+const zero = () => 0;
+const statusMessages = {
+    100: "Continue",
+    101: "Switching Protocols",
+    102: "Processing",
+    103: "Early Hints",
+    200: "OK",
+    201: "Created",
+    202: "Accepted",
+    203: "Non-Authoritative Information",
+    204: "No Content",
+    205: "Reset Content",
+    206: "Partial Content",
+    207: "Multi-Status",
+    208: "Already Reported",
+    226: "IM Used",
+    300: "Multiple Choices",
+    301: "Moved Permanently",
+    302: "Found",
+    303: "See Other",
+    304: "Not Modified",
+    307: "Temporary Redirect",
+    308: "Permanent Redirect",
+    400: "Bad Request",
+    401: "Unauthorized",
+    402: "Payment Required",
+    403: "Forbidden",
+    404: "Not Found",
+    405: "Method Not Allowed",
+    406: "Not Acceptable",
+    407: "Proxy Authentication Required",
+    408: "Request Timeout",
+    409: "Conflict",
+    410: "Gone",
+    411: "Length Required",
+    412: "Precondition Failed",
+    413: "Content Too Large",
+    414: "URI Too Long",
+    415: "Unsupported Media Type",
+    416: "Range Not Satisfiable",
+    417: "Expectation Failed",
+    418: "I'm a teapot",
+    421: "Misdirected Request",
+    422: "Unprocessable Entity",
+    423: "Locked",
+    424: "Failed Dependency",
+    425: "Too Early",
+    426: "Upgrade Required",
+    428: "Precondition Required",
+    429: "Too Many Requests",
+    431: "Request Header Fields Too Large",
+    451: "Unavailable For Legal Reasons",
+    500: "Internal Server Error",
+    501: "Not Implemented",
+    502: "Bad Gateway",
+    503: "Service Unavailable",
+    504: "Gateway Timeout",
+    505: "HTTP Version Not Supported",
+    506: "Variant Also Negotiates",
+    507: "Insufficient Storage",
+    508: "Loop Detected",
+    510: "Not Extended",
+    511: "Network Authentication Required"
+};
+function statusTextMap(val) {
+    return statusMessages[val] || "unknown";
+}
+const XMLHttpRequestE = (typeof XMLHttpRequest !== "undefined" && XMLHttpRequest) || XMLHttpRequestP;
 
+const mp = { XMLHttpRequest: XMLHttpRequestE };
+const setXMLHttpRequest = (XHR) => { mp.XMLHttpRequest = XHR; };
 function fetchP(input, init) {
     if (new.target === fetchP) {
         throw new TypeError("fetch is not a constructor");
     }
     return new Promise(function (resolve, reject) {
         const request = new RequestP(input, init);
-        const signal = request[state$1].signal;
+        const signal = request[state$4].signal;
         if (signal && signal.aborted) {
             return reject(signal.reason);
         }
-        let xhr = new XMLHttpRequestE();
+        let xhr = new mp.XMLHttpRequest();
         xhr.onload = function () {
             let options = {
-                headers: xhr instanceof XMLHttpRequestP ? (new HeadersP(xhr[state$4][_responseHeaders] || undefined)) : parseHeaders(xhr.getAllResponseHeaders() || ""),
+                headers: getAllResponseHeaders(xhr),
                 status: xhr.status,
                 statusText: xhr.statusText,
             };
             setTimeout(() => {
                 let response = new ResponseP(xhr.response, options);
-                response[state].url = xhr.responseURL;
+                response[state$3].url = xhr.responseURL;
                 resolve(response);
             });
         };
@@ -2542,7 +2693,7 @@ function fetchP(input, init) {
                 }
             };
         }
-        xhr.send(request[state$3][_body]);
+        xhr.send(Body_toPayload(request));
     });
 }
 function isObjectHeaders(val) {
@@ -2550,4 +2701,30 @@ function isObjectHeaders(val) {
 }
 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 };
+const dispatched = 1;
+/** @internal */
+const state = Symbol( /* "CustomEventState" */);
+class CustomEventP extends EventP {
+    constructor(type, eventInitDict) {
+        var _a;
+        super(type, eventInitDict);
+        this[state] = new CustomEventState();
+        this[state].detail = (_a = eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.detail) !== null && _a !== void 0 ? _a : null;
+    }
+    get detail() { return this[state].detail; }
+    initCustomEvent(type, bubbles, cancelable, detail) {
+        if (Event_getEtField(this, dispatched))
+            return;
+        this.initEvent(type, bubbles, cancelable);
+        this[state].detail = detail !== null && detail !== void 0 ? detail : null;
+    }
+    toString() { return "[object CustomEvent]"; }
+    get isPolyfill() { return { symbol: polyfill, hierarchy: ["CustomEvent", "Event"] }; }
+}
+dfStringTag(CustomEventP, "CustomEvent");
+/** @internal */
+class CustomEventState {
+}
+const CustomEventE = g["EventTarget"] ? g["CustomEvent"] : CustomEventP;
+
+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, setRequest, setXMLHttpRequest };