mphttpx 1.0.6 → 1.0.7

package/dist/index.cjs.js

@@ -1,15 +1,26 @@
 'use strict';
 
+/** @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"
@@ -22,22 +33,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]]);
 }
@@ -54,7 +61,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;
@@ -285,7 +292,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 */
@@ -304,38 +311,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)
@@ -343,7 +486,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);
@@ -351,7 +494,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;
@@ -363,7 +506,7 @@ class EventP {
         }
     }
     stopImmediatePropagation() {
-        this[state$g][_stopImmediatePropagationCalled] = true;
+        this[state$e][_stopImmediatePropagationCalled] = true;
         this.cancelBubble = true;
     }
     stopPropagation() {
@@ -380,13 +523,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() {
@@ -400,33 +543,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))) {
@@ -436,7 +627,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);
@@ -451,12 +642,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))) {
@@ -466,7 +657,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 */
@@ -477,35 +668,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;
@@ -513,19 +706,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 */
@@ -554,64 +752,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() {
@@ -625,234 +800,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;
@@ -863,50 +901,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) {
@@ -915,21 +954,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) {
@@ -941,15 +980,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;
             }
         }
@@ -960,27 +999,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();
@@ -988,7 +1028,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 */
@@ -996,25 +1036,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
@@ -1044,6 +1086,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();
@@ -1123,25 +1166,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));
@@ -1152,46 +1199,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];
@@ -1201,19 +1249,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));
             }
         }
@@ -1221,7 +1274,7 @@ class URLSearchParamsP {
     }
     get isPolyfill() { return { symbol: polyfill, hierarchy: ["URLSearchParams"] }; }
 }
-defineStringTag(URLSearchParamsP, "URLSearchParams");
+dfStringTag(URLSearchParamsP, "URLSearchParams");
 /** @internal */
 const _urlspDict = Symbol();
 /** @internal */
@@ -1247,7 +1300,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]);
                 }
@@ -1305,7 +1360,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;
@@ -1314,36 +1370,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;
     }
@@ -1352,24 +1411,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 */
@@ -1377,526 +1436,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();
@@ -1906,6 +1598,7 @@ const decode = (buf) => {
     let decoder = new TextDecoderP();
     return decoder.decode(buf);
 };
+/** @internal */
 function convert(body, setContentType, setContentLength) {
     let result;
     if (typeof body === "string") {
@@ -1927,14 +1620,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);
         }
@@ -1946,12 +1639,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") {
@@ -1970,189 +1662,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);
@@ -2178,18 +1694,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");
@@ -2197,11 +1713,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]) => {
@@ -2209,7 +1725,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();
@@ -2223,16 +1739,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);
@@ -2244,12 +1818,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, " ");
@@ -2276,13 +1852,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)) {
@@ -2295,15 +1892,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 {
@@ -2327,7 +1924,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
@@ -2344,153 +1941,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);
             });
         };
@@ -2544,7 +2695,7 @@ function fetchP(input, init) {
                 }
             };
         }
-        xhr.send(request[state$3][_body]);
+        xhr.send(Body_toPayload(request));
     });
 }
 function isObjectHeaders(val) {
@@ -2552,6 +2703,32 @@ function isObjectHeaders(val) {
 }
 const fetchE = g["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;
+
 exports.AbortController = AbortControllerE;
 exports.AbortControllerP = AbortControllerP;
 exports.AbortSignal = AbortSignalE;
@@ -2588,3 +2765,5 @@ exports.XMLHttpRequest = XMLHttpRequestE;
 exports.XMLHttpRequestP = XMLHttpRequestP;
 exports.fetch = fetchE;
 exports.fetchP = fetchP;
+exports.setRequest = setRequest;
+exports.setXMLHttpRequest = setXMLHttpRequest;