mphttpx 1.0.12 → 1.2.0-beta.1

package/dist/index.cjs.js

@@ -9,13 +9,6 @@
 /** @internal */
 const polyfill = "MPHTTPX";
 /** @internal */
-function Class_setStringTag(targetFunc, stringTag) {
-    Object.defineProperty(targetFunc.prototype, Symbol.toStringTag, {
-        configurable: true,
-        value: stringTag,
-    });
-}
-/** @internal */
 function checkArgsLength(args, required, className, funcName) {
     if (args.length < required) {
         throw new TypeError(`Failed to ${funcName ? ("execute '" + funcName + "' on") : "construct"} '${className}': ${required} argument${required > 1 ? "s" : ""} required, but only ${args.length} present.`);
@@ -36,7 +29,7 @@ function isObjectType(name, value) {
     return Object.prototype.toString.call(value) === `[object ${name}]`;
 }
 /** @internal */
-function isPolyfillType(name, value) {
+function isPolyfillType(name, value, strict = false) {
     return !!value
         && typeof value === "object"
         && "isPolyfill" in value
@@ -46,7 +39,12 @@ function isPolyfillType(name, value) {
         && value.isPolyfill.symbol === polyfill
         && "hierarchy" in value.isPolyfill
         && Array.isArray(value.isPolyfill.hierarchy)
-        && value.isPolyfill.hierarchy.indexOf(name) > -1;
+        && ((index) => strict ? index === 0 : index > -1)(value.isPolyfill.hierarchy.indexOf(name));
+}
+/** @internal */
+function isArrayBuffer(value) {
+    // Mini Program
+    return isObjectType("ArrayBuffer", value) || (!!value && typeof value === "object" && ArrayBuffer.prototype.isPrototypeOf(value));
 }
 
 class TextEncoderP {
@@ -59,16 +57,16 @@ class TextEncoderP {
         const [source, destination] = args;
         checkArgsLength(args, 2, "TextEncoder", "encodeInto");
         let _source = "" + source;
-        if (!(destination instanceof Uint8Array)) {
+        if (!(destination instanceof Uint8Array || isObjectType("Uint8Array", destination))) {
             throw new TypeError("Failed to execute 'encodeInto' on 'TextEncoder': parameter 2 is not of type 'Uint8Array'.");
         }
         let result = encodeText(_source, destination);
         return { read: result.read, written: result.written };
     }
     /** @internal */ toString() { return "[object TextEncoder]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "TextEncoder"; }
     /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["TextEncoder"] }; }
 }
-Class_setStringTag(TextEncoderP, "TextEncoder");
 function encodeText(input, destination) {
     const HAS_DESTINATION = typeof destination !== "undefined";
     let pos = 0;
@@ -165,30 +163,30 @@ function encodeText(input, destination) {
 }
 const TextEncoderE = g["TextEncoder"] || TextEncoderP;
 
-var _a$a, _b$3;
+var _a$b, _b$4;
 /** @internal */
-const state$h = Symbol( /* "TextDecoderState" */);
+const state$k = Symbol( /* "TextDecoderState" */);
 class TextDecoderP {
     constructor(label = "utf-8", { fatal = false, ignoreBOM = false } = {}) {
         let _label = "" + label;
         if (["utf-8", "utf8", "unicode-1-1-utf-8"].indexOf(_label.toLowerCase()) === -1) {
             throw new RangeError(`Failed to construct 'TextDecoder': encoding ('${_label}') not implemented.`);
         }
-        this[state$h] = new TextDecoderState();
-        this[state$h].fatal = !!fatal;
-        this[state$h].ignoreBOM = !!ignoreBOM;
+        this[state$k] = new TextDecoderState();
+        this[state$k].fatal = !!fatal;
+        this[state$k].ignoreBOM = !!ignoreBOM;
     }
     get encoding() { return "utf-8"; }
-    get fatal() { return this[state$h].fatal; }
-    get ignoreBOM() { return this[state$h].ignoreBOM; }
+    get fatal() { return this[state$k].fatal; }
+    get ignoreBOM() { return this[state$k].ignoreBOM; }
     decode(input, { stream = false } = {}) {
-        const s = this[state$h];
+        const s = this[state$k];
         let bytes;
         if (input !== undefined) {
-            if (input instanceof ArrayBuffer) {
+            if (isArrayBuffer(input)) {
                 bytes = new Uint8Array(input);
             }
-            else if (input instanceof Uint8Array) {
+            else if (input instanceof Uint8Array || isObjectType("Uint8Array", input)) {
                 bytes = input;
             }
             else if (ArrayBuffer.isView(input)) {
@@ -311,9 +309,9 @@ class TextDecoderP {
         return res.length > 0x4000 ? buildString(res) : concatString(res);
     }
     /** @internal */ toString() { return "[object TextDecoder]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "TextDecoder"; }
     /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["TextDecoder"] }; }
 }
-Class_setStringTag(TextDecoderP, "TextDecoder");
 /** @internal */ const _bomDone = Symbol();
 /** @internal */ const _partial = Symbol();
 /** @internal */
@@ -321,11 +319,11 @@ class TextDecoderState {
     constructor() {
         this.fatal = false;
         this.ignoreBOM = false;
-        this[_a$a] = 0;
-        this[_b$3] = [];
+        this[_a$b] = 0;
+        this[_b$4] = [];
     }
 }
-_a$a = _bomDone, _b$3 = _partial;
+_a$b = _bomDone, _b$4 = _partial;
 function getBytesPerSequence(byte) {
     return (byte > 0xEF) ? 4 : (byte > 0xDF) ? 3 : (byte > 0xBF) ? 2 : 1;
 }
@@ -346,7 +344,7 @@ const concatString = (res) => {
 const TextDecoderE = g["TextDecoder"] || TextDecoderP;
 
 /** @internal */
-const state$g = Symbol( /* "BlobState" */);
+const state$j = Symbol( /* "BlobState" */);
 class BlobP {
     constructor(blobParts = [], options) {
         if (!(Array.isArray(blobParts) || (blobParts && typeof blobParts === "object" && Symbol.iterator in blobParts))) {
@@ -357,43 +355,43 @@ class BlobP {
         for (let i = 0; i < _blobParts.length; ++i) {
             let chunk = _blobParts[i];
             if (isPolyfillType("Blob", chunk)) {
-                chunks.push(chunk[state$g][_buffer]);
+                chunks.push(chunk[state$j][_buffer]);
             }
-            else if (chunk instanceof ArrayBuffer || ArrayBuffer.isView(chunk)) {
+            else if (isArrayBuffer(chunk) || ArrayBuffer.isView(chunk)) {
                 chunks.push(BufferSource_toUint8Array(chunk));
             }
             else {
                 chunks.push(encode$1("" + chunk));
             }
         }
-        this[state$g] = new BlobState(concat(chunks));
-        const s = this[state$g];
+        this[state$j] = new BlobState(concat(chunks));
+        const s = this[state$j];
         s.size = s[_buffer].length;
         let rawType = "" + ((options === null || options === void 0 ? void 0 : options.type) || "");
         s.type = /[^\u0020-\u007E]/.test(rawType) ? "" : rawType.toLowerCase();
     }
-    get size() { return this[state$g].size; }
-    get type() { return this[state$g].type; }
+    get size() { return this[state$j].size; }
+    get type() { return this[state$j].type; }
     arrayBuffer() {
-        return Promise.resolve(clone(this[state$g][_buffer].buffer).buffer);
+        return Promise.resolve(clone(this[state$j][_buffer].buffer).buffer);
     }
     bytes() {
-        return Promise.resolve(clone(this[state$g][_buffer].buffer));
+        return Promise.resolve(clone(this[state$j][_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); // × WeChat 2.5.0
+        let sliced = this[state$j][_buffer].slice(start !== null && start !== void 0 ? start : 0, end !== null && end !== void 0 ? end : this[state$j][_buffer].length); // × WeChat 2.5.0
         return new BlobP([sliced], { type: "" + (contentType !== null && contentType !== void 0 ? contentType : "") });
     }
     stream() {
         throw new TypeError("Failed to execute 'stream' on 'Blob': method not implemented.");
     }
     text() {
-        return Promise.resolve(decode$1(this[state$g][_buffer]));
+        return Promise.resolve(decode$1(this[state$j][_buffer]));
     }
     /** @internal */ toString() { return "[object Blob]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "Blob"; }
     /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["Blob"] }; }
 }
-Class_setStringTag(BlobP, "Blob");
 /** @internal */
 const _buffer = Symbol();
 /** @internal */
@@ -406,10 +404,10 @@ class BlobState {
 }
 /** @internal */
 function Blob_toUint8Array(blob) {
-    return blob[state$g][_buffer];
+    return blob[state$j][_buffer];
 }
 function BufferSource_toUint8Array(buf) {
-    return buf instanceof ArrayBuffer
+    return isArrayBuffer(buf)
         ? new Uint8Array(buf)
         : new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
 }
@@ -465,23 +463,23 @@ function Uint8Array_toBase64(input) {
 const BlobE = g["Blob"] || BlobP;
 
 /** @internal */
-const state$f = Symbol( /* "FileState" */);
+const state$i = Symbol( /* "FileState" */);
 class FileP extends BlobP {
     constructor(...args) {
         const [fileBits, fileName, options] = args;
         checkArgsLength(args, 2, "File");
         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()) || 0;
-        this[state$f].name = "" + fileName;
+        this[state$i] = new FileState();
+        this[state$i].lastModified = +((options === null || options === void 0 ? void 0 : options.lastModified) ? new Date(options.lastModified) : new Date()) || 0;
+        this[state$i].name = "" + fileName;
     }
-    get lastModified() { return this[state$f].lastModified; }
-    get name() { return this[state$f].name; }
+    get lastModified() { return this[state$i].lastModified; }
+    get name() { return this[state$i].name; }
     get webkitRelativePath() { return ""; }
     /** @internal */ toString() { return "[object File]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "File"; }
     /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["File", "Blob"] }; }
 }
-Class_setStringTag(FileP, "File");
 /** @internal */
 class FileState {
     constructor() {
@@ -491,39 +489,47 @@ class FileState {
 }
 const FileE = g["Blob"] ? g["File"] : FileP;
 
-var _a$9, _b$2, _c$1, _d$1, _e$1;
-/** @internal */ const state$e = Symbol( /* "EventState" */);
+var _a$a, _b$3, _c$1, _d$1, _e$1;
+/** @internal */ const state$h = Symbol( /* "EventState" */);
 class EventP {
+    static get NONE() { return 0; }
+    static get CAPTURING_PHASE() { return 1; }
+    static get AT_TARGET() { return 2; }
+    static get BUBBLING_PHASE() { return 3; }
     constructor(...args) {
         const [type, eventInitDict] = args;
         checkArgsLength(args, 1, new.target.name);
-        this[state$e] = new EventState();
-        const s = this[state$e];
+        this[state$h] = new EventState();
+        const s = this[state$h];
         s.type = "" + type;
         s.bubbles = !!(eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.bubbles);
         s.cancelable = !!(eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.cancelable);
         s.composed = !!(eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.composed);
         Object.defineProperty(this, "isTrusted", {
             enumerable: true,
-            get: (function isTrusted() { return this[state$e][_isTrusted]; }).bind(this),
+            get: (function isTrusted() { return this[state$h][_isTrusted]; }).bind(this),
         });
     }
-    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; }
+    get type() { return this[state$h].type; }
+    get bubbles() { return this[state$h].bubbles; }
+    get cancelable() { return this[state$h].cancelable; }
+    get composed() { return this[state$h].composed; }
+    get target() { return this[state$h].target; }
+    get currentTarget() { return this[state$h].currentTarget; }
+    get eventPhase() { return this[state$h].eventPhase; }
+    get NONE() { return 0; }
+    get CAPTURING_PHASE() { return 1; }
+    get AT_TARGET() { return 2; }
+    get BUBBLING_PHASE() { return 3; }
+    get srcElement() { return this[state$h].target; }
+    get cancelBubble() { return this[state$h].cancelBubble; }
+    set cancelBubble(value) { this[state$h].cancelBubble = !!value; }
+    get defaultPrevented() { return this[state$h].defaultPrevented; }
+    get returnValue() { return this[state$h].returnValue; }
     set returnValue(value) { if (!value) {
         this.preventDefault();
     } }
-    get timeStamp() { return this[state$e].timeStamp; }
+    get timeStamp() { return this[state$h].timeStamp; }
     composedPath() {
         let path = !!this.target ? [this.target] : [];
         if (!!this.currentTarget && this.currentTarget !== this.target)
@@ -533,7 +539,7 @@ class EventP {
     initEvent(...args) {
         const [type, bubbles, cancelable] = args;
         checkArgsLength(args, 1, "Event", "initEvent");
-        const s = this[state$e];
+        const s = this[state$h];
         if (s[_dispatched])
             return;
         s.type = "" + type;
@@ -541,7 +547,7 @@ class EventP {
         s.cancelable = !!cancelable;
     }
     preventDefault() {
-        const s = this[state$e];
+        const s = this[state$h];
         if (s[_passive]) {
             console.warn(`Ignoring 'preventDefault()' call on event of type '${this.type}' from a listener registered as 'passive'.`);
             return;
@@ -553,24 +559,16 @@ class EventP {
         }
     }
     stopImmediatePropagation() {
-        this[state$e][_stopImmediatePropagationCalled] = true;
+        this[state$h][_stopImmediatePropagationCalled] = true;
         this.cancelBubble = true;
     }
     stopPropagation() {
         this.cancelBubble = true;
     }
     /** @internal */ toString() { return "[object Event]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "Event"; }
     /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["Event"] }; }
 }
-const properties$1 = {
-    NONE: { value: 0, enumerable: true },
-    CAPTURING_PHASE: { value: 1, enumerable: true },
-    AT_TARGET: { value: 2, enumerable: true },
-    BUBBLING_PHASE: { value: 3, enumerable: true },
-};
-Object.defineProperties(EventP, properties$1);
-Object.defineProperties(EventP.prototype, properties$1);
-Class_setStringTag(EventP, "Event");
 /** @internal */ const _timeStamp = (new Date()).getTime();
 /** @internal */ const _isTrusted = Symbol();
 /** @internal */ const _passive = Symbol();
@@ -586,22 +584,22 @@ class EventState {
         this.composed = false;
         this.target = null;
         this.currentTarget = null;
-        this.eventPhase = EventP.NONE;
+        this.eventPhase = 0 /* NONE */;
         this.cancelBubble = false;
         this.defaultPrevented = false;
         this.returnValue = true;
         this.timeStamp = (new Date()).getTime() - _timeStamp;
-        this[_a$9] = false;
-        this[_b$2] = false;
+        this[_a$a] = false;
+        this[_b$3] = false;
         this[_c$1] = false;
         this[_d$1] = false;
         this[_e$1] = false;
     }
 }
-_a$9 = _isTrusted, _b$2 = _passive, _c$1 = _dispatched, _d$1 = _preventDefaultCalled, _e$1 = _stopImmediatePropagationCalled;
+_a$a = _isTrusted, _b$3 = _passive, _c$1 = _dispatched, _d$1 = _preventDefaultCalled, _e$1 = _stopImmediatePropagationCalled;
 /** @internal */
 function Event_setTrusted(event, isTrusted) {
-    Object.defineProperty(event[state$e], _isTrusted, {
+    Object.defineProperty(event[state$h], _isTrusted, {
         value: isTrusted,
         writable: true,
         enumerable: true,
@@ -609,16 +607,16 @@ function Event_setTrusted(event, isTrusted) {
     });
 }
 const passive$1 = 0;
-const dispatched$2 = 1;
+const dispatched$3 = 1;
 const preventDefaultCalled$1 = 2;
 const stopImmediatePropagationCalled$1 = 3;
 /** @internal */
 function Event_getEtField(event, field) {
-    const s = event[state$e];
+    const s = event[state$h];
     switch (field) {
         case passive$1:
             return s[_passive];
-        case dispatched$2:
+        case dispatched$3:
             return s[_dispatched];
         case preventDefaultCalled$1:
             return s[_preventDefaultCalled];
@@ -628,12 +626,12 @@ function Event_getEtField(event, field) {
 }
 /** @internal */
 function Event_setEtField(event, field, value) {
-    const s = event[state$e];
+    const s = event[state$h];
     switch (field) {
         case passive$1:
             s[_passive] = value;
             break;
-        case dispatched$2:
+        case dispatched$3:
             s[_dispatched] = value;
             break;
         case preventDefaultCalled$1:
@@ -647,30 +645,30 @@ function Event_setEtField(event, field, value) {
 /** @internal */
 function createInnerEvent(target, type, eventInitDict, isTrusted = true) {
     let event = new EventP(type, eventInitDict);
-    event[state$e].target = target;
-    event[state$e][_isTrusted] = isTrusted;
+    event[state$h].target = target;
+    event[state$h][_isTrusted] = isTrusted;
     return event;
 }
 const EventE = g["EventTarget"] ? g["Event"] : EventP;
 
-var _a$8;
+var _a$9;
 const passive = 0;
-const dispatched$1 = 1;
+const dispatched$2 = 1;
 const preventDefaultCalled = 2;
 const stopImmediatePropagationCalled = 3;
-/** @internal */ const state$d = Symbol( /* "EventTargetState" */);
+/** @internal */ const state$g = Symbol( /* "EventTargetState" */);
 class EventTargetP {
     constructor() {
-        this[state$d] = new EventTargetState(this);
-        this[state$d].name = new.target.name;
+        this[state$g] = new EventTargetState(this);
+        this[state$g].name = new.target.name;
     }
     addEventListener(...args) {
         const [type, callback, options] = args;
-        checkArgsLength(args, 2, this[state$d].name, "addEventListener");
+        checkArgsLength(args, 2, this[state$g].name, "addEventListener");
         if (typeof callback !== "function" && typeof callback !== "object" && typeof callback !== "undefined") {
-            throw new TypeError(`Failed to execute 'addEventListener' on '${this[state$d].name}': parameter 2 is not of type 'Object'.`);
+            throw new TypeError(`Failed to execute 'addEventListener' on '${this[state$g].name}': parameter 2 is not of type 'Object'.`);
         }
-        const s = this[state$d];
+        const s = this[state$g];
         const executor = new Executor(type, callback);
         executor.options.capture = typeof options === "boolean" ? options : !!(options === null || options === void 0 ? void 0 : options.capture);
         if (!s[_executors].some(x => x.equals(executor))) {
@@ -690,21 +688,21 @@ class EventTargetP {
     }
     dispatchEvent(...args) {
         const [event] = args;
-        checkArgsLength(args, 1, this[state$d].name, "dispatchEvent");
+        checkArgsLength(args, 1, this[state$g].name, "dispatchEvent");
         if (!(event instanceof EventP)) {
-            throw new TypeError(`Failed to execute 'dispatchEvent' on '${this[state$d].name}': parameter 1 is not of type 'Event'.`);
+            throw new TypeError(`Failed to execute 'dispatchEvent' on '${this[state$g].name}': parameter 1 is not of type 'Event'.`);
         }
         Event_setTrusted(event, false);
-        event[state$e].target = this;
+        event[state$h].target = this;
         return EventTarget_fire(this, event);
     }
     removeEventListener(...args) {
         const [type, callback, options] = args;
-        checkArgsLength(args, 2, this[state$d].name, "removeEventListener");
+        checkArgsLength(args, 2, this[state$g].name, "removeEventListener");
         if (typeof callback !== "function" && typeof callback !== "object" && typeof callback !== "undefined") {
-            throw new TypeError(`Failed to execute 'removeEventListener' on '${this[state$d].name}': parameter 2 is not of type 'Object'.`);
+            throw new TypeError(`Failed to execute 'removeEventListener' on '${this[state$g].name}': parameter 2 is not of type 'Object'.`);
         }
-        const s = this[state$d];
+        const s = this[state$g];
         const executor = new Executor(type, callback);
         executor.options.capture = typeof options === "boolean" ? options : !!(options === null || options === void 0 ? void 0 : options.capture);
         if (s[_executors].some(x => x.equals(executor))) {
@@ -712,29 +710,29 @@ class EventTargetP {
         }
     }
     /** @internal */ toString() { return "[object EventTarget]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "EventTarget"; }
     /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["EventTarget"] }; }
 }
-Class_setStringTag(EventTargetP, "EventTarget");
 /** @internal */
 const _executors = Symbol();
 /** @internal */
 class EventTargetState {
     constructor(target) {
         this.name = "EventTarget";
-        this[_a$8] = [];
+        this[_a$9] = [];
         this.target = target;
     }
 }
-_a$8 = _executors;
+_a$9 = _executors;
 /** @internal */
 function EventTarget_fire(target, event) {
-    const s = target[state$d];
-    const evs = event[state$e];
+    const s = target[state$g];
+    const evs = event[state$h];
     if (!event.target)
         evs.target = target;
     evs.currentTarget = target;
-    evs.eventPhase = EventP.AT_TARGET;
-    Event_setEtField(event, dispatched$1, true);
+    evs.eventPhase = 2 /* AT_TARGET */;
+    Event_setEtField(event, dispatched$2, true);
     let onceIndexes = [];
     for (let i = 0; i < s[_executors].length; ++i) {
         if (Event_getEtField(event, stopImmediatePropagationCalled))
@@ -763,12 +761,12 @@ function EventTarget_fire(target, event) {
         }, []);
     }
     evs.currentTarget = null;
-    evs.eventPhase = EventP.NONE;
-    Event_setEtField(event, dispatched$1, false);
+    evs.eventPhase = 0 /* NONE */;
+    Event_setEtField(event, dispatched$2, false);
     return !(event.cancelable && Event_getEtField(event, preventDefaultCalled));
 }
 function reply(target, signal, executor) {
-    const s = target[state$d];
+    const s = target[state$g];
     const onAbort = () => {
         s[_executors] = s[_executors].filter(x => !x.equals(executor));
         signal.removeEventListener("abort", onAbort);
@@ -818,13 +816,13 @@ function executeFn(target, cb, ev) {
 const EventTargetE = g["EventTarget"] || EventTargetP;
 
 /** @internal */
-const state$c = Symbol( /* "ProgressEventState" */);
+const state$f = Symbol( /* "ProgressEventState" */);
 class ProgressEventP extends EventP {
     constructor(type, eventInitDict) {
         var _a, _b;
         super(type, eventInitDict);
-        this[state$c] = new ProgressEventState();
-        const s = this[state$c];
+        this[state$f] = new ProgressEventState();
+        const s = this[state$f];
         s.lengthComputable = !!(eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.lengthComputable);
         s.loaded = Number((_a = eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.loaded) !== null && _a !== void 0 ? _a : 0);
         s.total = Number((_b = eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.total) !== null && _b !== void 0 ? _b : 0);
@@ -839,13 +837,13 @@ class ProgressEventP extends EventP {
             throw new TypeError(`Failed to construct 'ProgressEvent': Failed to read the '${errField}' property from 'ProgressEventInit': The provided double value is non-finite.`);
         }
     }
-    get lengthComputable() { return getValue(this[state$c].lengthComputable); }
-    get loaded() { return getValue(this[state$c].loaded); }
-    get total() { return getValue(this[state$c].total); }
+    get lengthComputable() { return getValue(this[state$f].lengthComputable); }
+    get loaded() { return getValue(this[state$f].loaded); }
+    get total() { return getValue(this[state$f].total); }
     /** @internal */ toString() { return "[object ProgressEvent]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "ProgressEvent"; }
     /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["ProgressEvent", "Event"] }; }
 }
-Class_setStringTag(ProgressEventP, "ProgressEvent");
 /** @internal */
 class ProgressEventState {
     constructor() {
@@ -859,10 +857,10 @@ function getValue(val) {
 }
 function createInnerProgressEvent(target, type, { lengthComputable = false, loaded = 0, total = 0, } = {}) {
     let event = new ProgressEventP(type);
-    event[state$c].lengthComputable = lengthComputable;
-    event[state$c].loaded = loaded;
-    event[state$c].total = total;
-    event[state$e].target = target;
+    event[state$f].lengthComputable = lengthComputable;
+    event[state$f].loaded = loaded;
+    event[state$f].total = total;
+    event[state$h].target = target;
     Event_setTrusted(event, true);
     return event;
 }
@@ -875,23 +873,29 @@ function emitProcessEvent(target, type, loaded = 0, total = 0) {
     });
     EventTarget_fire(target, event);
 }
-const ProgressEventE = g["EventTarget"] ? g["ProgressEvent"] : ProgressEventP;
+g["EventTarget"] ? g["ProgressEvent"] : ProgressEventP;
 
-var _a$7;
+var _a$8;
 /** @internal */
-const state$b = Symbol( /* "FileReaderState" */);
+const state$e = Symbol( /* "FileReaderState" */);
 class FileReaderP extends EventTargetP {
+    static get EMPTY() { return 0; }
+    static get LOADING() { return 1; }
+    static get DONE() { return 2; }
     constructor() {
         super();
-        this[state$b] = new FileReaderState(this);
-    }
-    get readyState() { return this[state$b].readyState; }
-    get result() { return this[state$b].result; }
-    get error() { return this[state$b].error; }
+        this[state$e] = new FileReaderState(this);
+    }
+    get readyState() { return this[state$e].readyState; }
+    get result() { return this[state$e].result; }
+    get EMPTY() { return 0; }
+    get LOADING() { return 1; }
+    get DONE() { return 2; }
+    get error() { return this[state$e].error; }
     abort() {
-        if (this.readyState === FileReaderP.LOADING) {
-            const s = this[state$b];
-            s.readyState = FileReaderP.DONE;
+        if (this.readyState === 1 /* LOADING */) {
+            const s = this[state$e];
+            s.readyState = 2 /* DONE */;
             s.result = null;
             s.error = new MPException("An ongoing operation was aborted, typically with a call to abort().", "AbortError");
             emitProcessEvent(this, "abort");
@@ -899,7 +903,7 @@ class FileReaderP extends EventTargetP {
     }
     readAsArrayBuffer(...args) {
         read$1(this, "readAsArrayBuffer", args, blob => {
-            this[state$b].result = Blob_toUint8Array(blob).buffer.slice(0);
+            this[state$e].result = Blob_toUint8Array(blob).buffer.slice(0);
         });
     }
     readAsBinaryString(...args) {
@@ -910,12 +914,12 @@ class FileReaderP extends EventTargetP {
                 let char = buf[i];
                 str.push(String.fromCharCode(char));
             }
-            this[state$b].result = str.join("");
+            this[state$e].result = str.join("");
         });
     }
     readAsDataURL(...args) {
         read$1(this, "readAsDataURL", args, blob => {
-            this[state$b].result = "data:" + (blob.type || "application/octet-stream") + ";base64," + Uint8Array_toBase64(Blob_toUint8Array(blob));
+            this[state$e].result = "data:" + (blob.type || "application/octet-stream") + ";base64," + Uint8Array_toBase64(Blob_toUint8Array(blob));
         });
     }
     readAsText(...args) {
@@ -927,41 +931,34 @@ class FileReaderP extends EventTargetP {
                     console.error(`TypeError: Failed to execute 'readAsText' on 'FileReader': encoding ('${_encoding}') not implemented.`);
                 }
             }
-            this[state$b].result = decode$1(Blob_toUint8Array(blob));
+            this[state$e].result = decode$1(Blob_toUint8Array(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"); }
+    get onabort() { return this[state$e].onabort; }
+    set onabort(value) { this[state$e].onabort = value; attach$2(this, "abort"); }
+    get onerror() { return this[state$e].onerror; }
+    set onerror(value) { this[state$e].onerror = value; attach$2(this, "error"); }
+    get onload() { return this[state$e].onload; }
+    set onload(value) { this[state$e].onload = value; attach$2(this, "load"); }
+    get onloadend() { return this[state$e].onloadend; }
+    set onloadend(value) { this[state$e].onloadend = value; attach$2(this, "loadend"); }
+    get onloadstart() { return this[state$e].onloadstart; }
+    set onloadstart(value) { this[state$e].onloadstart = value; attach$2(this, "loadstart"); }
+    get onprogress() { return this[state$e].onprogress; }
+    set onprogress(value) { this[state$e].onprogress = value; attach$2(this, "progress"); }
     /** @internal */ toString() { return "[object FileReader]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "FileReader"; }
     /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["FileReader", "EventTarget"] }; }
 }
-const properties = {
-    EMPTY: { value: 0, enumerable: true },
-    LOADING: { value: 1, enumerable: true },
-    DONE: { value: 2, enumerable: true },
-};
-Object.defineProperties(FileReaderP, properties);
-Object.defineProperties(FileReaderP.prototype, properties);
-Class_setStringTag(FileReaderP, "FileReader");
 /** @internal */
-const _handlers$3 = Symbol();
+const _handlers$4 = Symbol();
 /** @internal */
 class FileReaderState {
     constructor(target) {
-        this.readyState = FileReaderP.EMPTY;
+        this.readyState = 0 /* EMPTY */;
         this.result = null;
         this.error = null;
-        this[_a$7] = getHandlers$3(this);
+        this[_a$8] = getHandlers$4(this);
         this.onabort = null;
         this.onerror = null;
         this.onload = null;
@@ -971,20 +968,20 @@ class FileReaderState {
         this.target = target;
     }
 }
-_a$7 = _handlers$3;
+_a$8 = _handlers$4;
 function read$1(reader, kind, args, setResult) {
     const [blob] = args;
     checkArgsLength(args, 1, "FileReader", kind);
     if (!isPolyfillType("Blob", blob)) {
         throw new TypeError("Failed to execute '" + kind + "' on 'FileReader': parameter 1 is not of type 'Blob'.");
     }
-    const s = reader[state$b];
+    const s = reader[state$e];
     s.error = null;
-    s.readyState = FileReaderP.LOADING;
+    s.readyState = 1 /* LOADING */;
     emitProcessEvent(s.target, "loadstart", 0, blob.size);
     setTimeout(() => {
-        if (s.readyState === FileReaderP.LOADING) {
-            s.readyState = FileReaderP.DONE;
+        if (s.readyState === 1 /* LOADING */) {
+            s.readyState = 2 /* DONE */;
             try {
                 setResult(blob);
                 emitProcessEvent(s.target, "load", blob.size, blob.size);
@@ -998,14 +995,14 @@ function read$1(reader, kind, args, setResult) {
         emitProcessEvent(s.target, "loadend", !!s.result ? blob.size : 0, blob.size);
     });
 }
-function attach$1(reader, type) {
-    const s = reader[state$b];
+function attach$2(reader, type) {
+    const s = reader[state$e];
     const fnName = ("on" + type);
     const cb = s[fnName];
-    const listener = s[_handlers$3][fnName];
+    const listener = s[_handlers$4][fnName];
     attachFn(reader, type, cb, listener);
 }
-function getHandlers$3(s) {
+function getHandlers$4(s) {
     return {
         onabort: (ev) => { executeFn(s.target, s.onabort, ev); },
         onerror: (ev) => { executeFn(s.target, s.onerror, ev); },
@@ -1017,14 +1014,14 @@ function getHandlers$3(s) {
 }
 const FileReaderE = g["Blob"] ? g["FileReader"] : FileReaderP;
 
-var _a$6;
-/** @internal */ const state$a = Symbol( /* "URLSearchParamsState" */);
+var _a$7;
+/** @internal */ const state$d = Symbol( /* "URLSearchParamsState" */);
 const checkArgsFn$2 = (args, required, funcName) => { checkArgsLength(args, required, "URLSearchParams", funcName); };
 class URLSearchParamsP {
     constructor(init) {
-        this[state$a] = new URLSearchParamsState();
+        this[state$d] = new URLSearchParamsState();
         if (init !== undefined) {
-            if (isObjectType("URLSearchParams", init)) {
+            if (isObjectType("URLSearchParams", init) || isPolyfillType("URLSearchParams", init)) {
                 init.forEach((value, name) => { this.append(name, value); }, this);
             }
             else if (init && typeof init === "object") {
@@ -1070,18 +1067,18 @@ class URLSearchParamsP {
             }
         }
     }
-    get size() { return this[state$a][_urlspArray].length; }
+    get size() { return this[state$d][_urlspArray].length; }
     append(...args) {
         const [name, value] = args;
         checkArgsFn$2(args, 2, "append");
-        this[state$a][_urlspArray].push(["" + name, normalizeValue$1(value)]);
+        this[state$d][_urlspArray].push(["" + name, normalizeValue$1(value)]);
     }
     delete(...args) {
         const [name, value] = args;
         checkArgsFn$2(args, 1, "delete");
         let _name = "" + name;
         let index = -1;
-        let array = this[state$a][_urlspArray];
+        let array = this[state$d][_urlspArray];
         let result = [];
         for (let i = 0; i < array.length; ++i) {
             let item = array[i];
@@ -1095,14 +1092,14 @@ class URLSearchParamsP {
             result.push(item);
         }
         if (index > -1) {
-            this[state$a][_urlspArray] = result;
+            this[state$d][_urlspArray] = result;
         }
     }
     get(...args) {
         const [name] = args;
         checkArgsFn$2(args, 1, "get");
         let _name = "" + name;
-        let array = this[state$a][_urlspArray];
+        let array = this[state$d][_urlspArray];
         for (let i = 0; i < array.length; ++i) {
             let item = array[i];
             if (item[0] === _name) {
@@ -1115,7 +1112,7 @@ class URLSearchParamsP {
         const [name] = args;
         checkArgsFn$2(args, 1, "getAll");
         let _name = "" + name;
-        let array = this[state$a][_urlspArray];
+        let array = this[state$d][_urlspArray];
         let result = [];
         for (let i = 0; i < array.length; ++i) {
             let item = array[i];
@@ -1129,7 +1126,7 @@ class URLSearchParamsP {
         const [name, value] = args;
         checkArgsFn$2(args, 1, "has");
         let _name = "" + name;
-        let array = this[state$a][_urlspArray];
+        let array = this[state$d][_urlspArray];
         for (let i = 0; i < array.length; ++i) {
             let item = array[i];
             if (item[0] === _name) {
@@ -1151,7 +1148,7 @@ class URLSearchParamsP {
         let _name = "" + name;
         let _value = normalizeValue$1(value);
         let index = -1;
-        let array = this[state$a][_urlspArray];
+        let array = this[state$d][_urlspArray];
         let result = [];
         for (let i = 0; i < array.length; ++i) {
             let item = array[i];
@@ -1167,10 +1164,10 @@ class URLSearchParamsP {
         if (index === -1) {
             result.push([_name, _value]);
         }
-        this[state$a][_urlspArray] = result;
+        this[state$d][_urlspArray] = result;
     }
     sort() {
-        this[state$a][_urlspArray].sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
+        this[state$d][_urlspArray].sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
     }
     forEach(...args) {
         const [callbackfn, thisArg] = args;
@@ -1178,26 +1175,26 @@ class URLSearchParamsP {
         if (typeof callbackfn !== "function") {
             throw new TypeError("Failed to execute 'forEach' on 'URLSearchParams': parameter 1 is not of type 'Function'.");
         }
-        let array = this[state$a][_urlspArray];
+        let array = this[state$d][_urlspArray];
         for (let i = 0; i < array.length; ++i) {
             let item = array[i];
             callbackfn.call(thisArg, item[1], item[0], this);
         }
     }
     entries() {
-        return this[state$a][_urlspArray].map(x => [x[0], x[1]]).values();
+        return this[state$d][_urlspArray].map(x => [x[0], x[1]]).values();
     }
     keys() {
-        return this[state$a][_urlspArray].map(x => x[0]).values();
+        return this[state$d][_urlspArray].map(x => x[0]).values();
     }
     values() {
-        return this[state$a][_urlspArray].map(x => x[1]).values();
+        return this[state$d][_urlspArray].map(x => x[1]).values();
     }
     [Symbol.iterator]() {
         return this.entries();
     }
     toString() {
-        let array = this[state$a][_urlspArray];
+        let array = this[state$d][_urlspArray];
         let result = [];
         for (let i = 0; i < array.length; ++i) {
             let item = array[i];
@@ -1205,19 +1202,18 @@ class URLSearchParamsP {
         }
         return result.join("&");
     }
-    /** @internal */
-    get isPolyfill() { return { symbol: polyfill, hierarchy: ["URLSearchParams"] }; }
+    /** @internal */ get [Symbol.toStringTag]() { return "URLSearchParams"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["URLSearchParams"] }; }
 }
-Class_setStringTag(URLSearchParamsP, "URLSearchParams");
 /** @internal */
 const _urlspArray = Symbol();
 /** @internal */
 class URLSearchParamsState {
     constructor() {
-        this[_a$6] = [];
+        this[_a$7] = [];
     }
 }
-_a$6 = _urlspArray;
+_a$7 = _urlspArray;
 function normalizeValue$1(value) {
     return typeof value === "string" ? value : (value !== null && value !== undefined && typeof value.toString === "function"
         ? value.toString()
@@ -1242,8 +1238,8 @@ function decode(str) {
 }
 const URLSearchParamsE = g["URLSearchParams"] || URLSearchParamsP;
 
-var _a$5;
-/** @internal */ const state$9 = Symbol( /* "FormDataState" */);
+var _a$6;
+/** @internal */ const state$c = Symbol( /* "FormDataState" */);
 const checkArgsFn$1 = (args, required, funcName) => { checkArgsLength(args, required, "FormData", funcName); };
 class FormDataP {
     constructor(form, submitter) {
@@ -1257,19 +1253,19 @@ class FormDataP {
                 console.error("TypeError: Failed to construct 'FormData': parameter 1 and parameter 2 not implemented.");
             }
         }
-        this[state$9] = new FormDataState();
+        this[state$c] = new FormDataState();
     }
     append(...args) {
         const [name, value, filename] = args;
         checkArgsFn$1(args, 2, "append");
-        this[state$9][_formData].push(normalizeArgs(name, value, filename));
+        this[state$c][_formData].push(normalizeArgs(name, value, filename));
     }
     delete(...args) {
         const [name] = args;
         checkArgsFn$1(args, 1, "delete");
         let _name = "" + name;
         let index = -1;
-        let array = this[state$9][_formData];
+        let array = this[state$c][_formData];
         let result = [];
         for (let i = 0; i < array.length; ++i) {
             let item = array[i];
@@ -1280,14 +1276,14 @@ class FormDataP {
             result.push(item);
         }
         if (index > -1) {
-            this[state$9][_formData] = result;
+            this[state$c][_formData] = result;
         }
     }
     get(...args) {
         const [name] = args;
         checkArgsFn$1(args, 1, "get");
         let _name = "" + name;
-        let array = this[state$9][_formData];
+        let array = this[state$c][_formData];
         for (let i = 0; i < array.length; ++i) {
             let item = array[i];
             if (item[0] === _name) {
@@ -1300,7 +1296,7 @@ class FormDataP {
         const [name] = args;
         checkArgsFn$1(args, 1, "getAll");
         let _name = "" + name;
-        let array = this[state$9][_formData];
+        let array = this[state$c][_formData];
         let result = [];
         for (let i = 0; i < array.length; ++i) {
             let item = array[i];
@@ -1314,7 +1310,7 @@ class FormDataP {
         const [name] = args;
         checkArgsFn$1(args, 1, "has");
         let _name = "" + name;
-        let array = this[state$9][_formData];
+        let array = this[state$c][_formData];
         for (let i = 0; i < array.length; ++i) {
             let item = array[i];
             if (item[0] === _name) {
@@ -1329,7 +1325,7 @@ class FormDataP {
         let _name = "" + name;
         let _args = normalizeArgs(name, value, filename);
         let index = -1;
-        let array = this[state$9][_formData];
+        let array = this[state$c][_formData];
         let result = [];
         for (let i = 0; i < array.length; ++i) {
             let item = array[i];
@@ -1345,7 +1341,7 @@ class FormDataP {
         if (index === -1) {
             result.push(_args);
         }
-        this[state$9][_formData] = result;
+        this[state$c][_formData] = result;
     }
     forEach(...args) {
         const [callbackfn, thisArg] = args;
@@ -1353,44 +1349,44 @@ class FormDataP {
         if (typeof callbackfn !== "function") {
             throw new TypeError("Failed to execute 'forEach' on 'FormData': parameter 1 is not of type 'Function'.");
         }
-        let array = this[state$9][_formData];
+        let array = this[state$c][_formData];
         for (let i = 0; i < array.length; ++i) {
             let item = array[i];
             callbackfn.call(thisArg, item[1], item[0], thisArg);
         }
     }
     entries() {
-        return this[state$9][_formData].map(x => [x[0], x[1]]).values();
+        return this[state$c][_formData].map(x => [x[0], x[1]]).values();
     }
     keys() {
-        return this[state$9][_formData].map(x => x[0]).values();
+        return this[state$c][_formData].map(x => x[0]).values();
     }
     values() {
-        return this[state$9][_formData].map(x => x[1]).values();
+        return this[state$c][_formData].map(x => x[1]).values();
     }
     [Symbol.iterator]() {
         return this.entries();
     }
     /** @internal */ toString() { return "[object FormData]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "FormData"; }
     /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["FormData"] }; }
 }
-Class_setStringTag(FormDataP, "FormData");
 /** @internal */
 const _formData = Symbol();
 /** @internal */
 class FormDataState {
     constructor() {
-        this[_a$5] = [];
+        this[_a$6] = [];
     }
 }
-_a$5 = _formData;
+_a$6 = _formData;
 /** @internal */
 function FormData_toBlob(formData) {
     const boundary = "----formdata-mphttpx-" + Math.random();
     const p = `--${boundary}\r\nContent-Disposition: form-data; name="`;
     let chunks = [];
-    for (let i = 0; i < formData[state$9][_formData].length; ++i) {
-        let pair = formData[state$9][_formData][i];
+    for (let i = 0; i < formData[state$c][_formData].length; ++i) {
+        let pair = formData[state$c][_formData][i];
         let name = pair[0];
         let value = pair[1];
         if (typeof value === "string") {
@@ -1410,7 +1406,7 @@ function normalizeArgs(name, value, filename) {
             : typeof value.name === "string"
                 ? value.name
                 : "blob";
-        if (value.name !== filename || isObjectType("Blob", value)) {
+        if (value.name !== filename || isObjectType("Blob", value) || isPolyfillType("Blob", value, true)) {
             value = new FileP([value], filename);
         }
         return ["" + name, value];
@@ -1480,15 +1476,15 @@ function createFormDataFromBinaryText(text, boundary) {
 }
 const FormDataE = g["FormData"] || FormDataP;
 
-var _a$4, _b$1;
-/** @internal */ const state$8 = Symbol( /* "HeadersState" */);
+var _a$5, _b$2;
+/** @internal */ const state$b = Symbol( /* "HeadersState" */);
 const checkArgsFn = (args, required, funcName) => { checkArgsLength(args, required, "Headers", funcName); };
 class HeadersP {
     constructor(init) {
-        this[state$8] = new HeadersState();
+        this[state$b] = new HeadersState();
         if (init !== undefined) {
-            if (isObjectType("Headers", init)) {
-                init.forEach((value, name) => { this.append(name, value); }, this);
+            if (isObjectType("Headers", init) || isPolyfillType("Headers", init)) {
+                init.forEach((value, name) => { Headers_append(this, name, value); }, this);
             }
             else if (Array.isArray(init) || (init && typeof init === "object" && Symbol.iterator in init)) {
                 let _init = Array.isArray(init) ? init : Array.from(init);
@@ -1516,58 +1512,27 @@ class HeadersP {
                 }
             }
         }
-        this[state$8][_initialized] = true;
+        this[state$b][_initialized] = true;
     }
     append(...args) {
         const [name, value] = args;
         checkArgsFn(args, 2, "append");
-        let _name = normalizeName(name, throwsFn(this[state$8][_initialized] ? "append" : ""));
+        let _name = normalizeName(name, throwsFn(this[state$b][_initialized] ? "append" : ""));
         let _value = normalizeValue(value);
-        let index = -1;
-        let array = this[state$8][_headersArray];
-        for (let i = 0; i < array.length; ++i) {
-            let item = array[i];
-            if (item[0] === _name) {
-                item[1] = `${item[1]}, ${_value}`;
-                index = i;
-                break;
-            }
-        }
-        if (index === -1) {
-            array.push([_name, _value]);
-        }
+        Headers_append(this, _name, _value);
     }
     delete(...args) {
         const [name] = args;
         checkArgsFn(args, 1, "delete");
         let _name = normalizeName(name, throwsFn("delete"));
-        let index = -1;
-        let array = this[state$8][_headersArray];
-        let result = [];
-        for (let i = 0; i < array.length; ++i) {
-            let item = array[i];
-            if (item[0] === _name) {
-                index = i;
-                continue;
-            }
-            result.push(item);
-        }
-        if (index > -1) {
-            this[state$8][_headersArray] = result;
-        }
+        delete this[state$b][_headersDict][_name];
     }
     get(...args) {
+        var _c;
         const [name] = args;
         checkArgsFn(args, 1, "get");
         let _name = normalizeName(name, throwsFn("get"));
-        let array = this[state$8][_headersArray];
-        for (let i = 0; i < array.length; ++i) {
-            let item = array[i];
-            if (item[0] === _name) {
-                return item[1];
-            }
-        }
-        return null;
+        return (_c = this[state$b][_headersDict][_name]) !== null && _c !== void 0 ? _c : null;
     }
     getSetCookie() {
         let value = this.get("Set-Cookie");
@@ -1577,33 +1542,14 @@ class HeadersP {
         const [name] = args;
         checkArgsFn(args, 1, "has");
         let _name = normalizeName(name, throwsFn("has"));
-        let array = this[state$8][_headersArray];
-        for (let i = 0; i < array.length; ++i) {
-            let item = array[i];
-            if (item[0] === _name) {
-                return true;
-            }
-        }
-        return false;
+        return this[state$b][_headersDict].hasOwnProperty(_name);
     }
     set(...args) {
         const [name, value] = args;
         checkArgsFn(args, 2, "set");
         let _name = normalizeName(name, throwsFn("set"));
         let _value = normalizeValue(value);
-        let index = -1;
-        let array = this[state$8][_headersArray];
-        for (let i = 0; i < array.length; ++i) {
-            let item = array[i];
-            if (item[0] === _name) {
-                item[1] = _value;
-                index = i;
-                break;
-            }
-        }
-        if (index === -1) {
-            array.push([_name, _value]);
-        }
+        this[state$b][_headersDict][_name] = _value;
     }
     forEach(...args) {
         const [callbackfn, thisArg] = args;
@@ -1611,38 +1557,49 @@ class HeadersP {
         if (typeof callbackfn !== "function") {
             throw new TypeError("Failed to execute 'forEach' on 'Headers': parameter 1 is not of type 'Function'.");
         }
-        let array = this[state$8][_headersArray];
-        for (let i = 0; i < array.length; ++i) {
-            let item = array[i];
-            callbackfn.call(thisArg, item[1], item[0], this);
+        let names = Object.getOwnPropertyNames(this[state$b][_headersDict]);
+        for (let i = 0; i < names.length; ++i) {
+            let name = names[i];
+            callbackfn.call(thisArg, this[state$b][_headersDict][name], name, this);
         }
     }
     entries() {
-        return this[state$8][_headersArray].map(x => [x[0], x[1]]).values();
+        let array = [];
+        this.forEach((value, name) => { array.push([name, value]); });
+        return array.values();
     }
     keys() {
-        return this[state$8][_headersArray].map(x => x[0]).values();
+        let array = [];
+        this.forEach((value, name) => { array.push(name); });
+        return array.values();
     }
     values() {
-        return this[state$8][_headersArray].map(x => x[1]).values();
+        let array = [];
+        this.forEach((value, name) => { array.push(value); });
+        return array.values();
     }
     [Symbol.iterator]() {
         return this.entries();
     }
     /** @internal */ toString() { return "[object Headers]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "Headers"; }
     /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["Headers"] }; }
 }
-Class_setStringTag(HeadersP, "Headers");
 /** @internal */ const _initialized = Symbol();
-/** @internal */ const _headersArray = Symbol();
+/** @internal */ const _headersDict = Symbol();
 /** @internal */
 class HeadersState {
     constructor() {
-        this[_a$4] = false;
-        this[_b$1] = [];
+        this[_a$5] = false;
+        this[_b$2] = {};
     }
 }
-_a$4 = _initialized, _b$1 = _headersArray;
+_a$5 = _initialized, _b$2 = _headersDict;
+function Headers_append(headers, name, value) {
+    let dict = headers[state$b][_headersDict];
+    let oldValue = dict[name];
+    dict[name] = oldValue !== undefined ? `${oldValue}, ${value}` : value;
+}
 function throwsFn(kind) {
     return () => {
         throw new TypeError(`Failed to ${kind ? ("execute '" + kind + "' on") : "construct"} 'Headers': Invalid name`);
@@ -1686,23 +1643,23 @@ function parseHeaders(rawHeaders) {
 }
 const HeadersE = g["Headers"] || HeadersP;
 
-var _a$3;
-/** @internal */ const state$7 = Symbol( /* "BodyState" */);
+var _a$4;
+/** @internal */ const state$a = Symbol( /* "BodyState" */);
 class BodyImpl {
     /** @internal */
     constructor() {
         if (new.target === BodyImpl) {
             throw new TypeError("Failed to construct 'Body': Illegal constructor");
         }
-        this[state$7] = new BodyState();
+        this[state$a] = new BodyState();
     }
     get body() {
-        if (!this[state$7][_body]) {
+        if (!this[state$a][_body]) {
             return null;
         }
-        throw new TypeError(`Failed to access 'body' on '${this[state$7].name}': property not implemented.`);
+        throw new TypeError(`Failed to access 'body' on '${this[state$a].name}': property not implemented.`);
     }
-    get bodyUsed() { return this[state$7].bodyUsed; }
+    get bodyUsed() { return this[state$a].bodyUsed; }
     ;
     arrayBuffer() {
         const kind = "arrayBuffer";
@@ -1729,9 +1686,9 @@ class BodyImpl {
         return consumed(this, kind) || read(this, kind);
     }
     /** @internal */ toString() { return "[object Body]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "Body"; }
     /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["Body"] }; }
 }
-Class_setStringTag(BodyImpl, "Body");
 /** @internal */
 const _body = Symbol();
 /** @internal */
@@ -1739,23 +1696,23 @@ class BodyState {
     constructor() {
         this.name = "Body";
         this.bodyUsed = false;
-        this[_a$3] = "";
+        this[_a$4] = "";
     }
 }
-_a$3 = _body;
+_a$4 = _body;
 /** @internal */
 function Body_init(body, payload) {
     const b = body;
     if (isObjectType("ReadableStream", payload)) {
-        throw new TypeError(`Failed to construct '${b[state$7].name}': ReadableStream not implemented.`);
+        throw new TypeError(`Failed to construct '${b[state$a].name}': ReadableStream not implemented.`);
     }
-    b[state$7][_body] = convert(payload, true, type => { if (!b.headers.has("Content-Type")) {
+    b[state$a][_body] = convert(payload, true, type => { if (!b.headers.has("Content-Type")) {
         b.headers.set("Content-Type", type);
     } });
 }
 /** @internal */
 function Body_toPayload(body) {
-    return body[state$7][_body];
+    return body[state$a][_body];
 }
 function read(body, kind) {
     return new Promise((resolve, reject) => {
@@ -1768,7 +1725,7 @@ function read(body, kind) {
     });
 }
 function readSync(body, kind) {
-    const payload = body[state$7][_body];
+    const payload = body[state$a][_body];
     if (kind === "arrayBuffer") {
         return convertBack("arraybuffer", payload);
     }
@@ -1805,7 +1762,7 @@ function readSync(body, kind) {
     }
 }
 function consumed(body, kind) {
-    const s = body[state$7];
+    const s = body[state$a];
     if (!s[_body])
         return;
     if (s.bodyUsed) {
@@ -1822,13 +1779,13 @@ function convert(body, cloneArrayBuffer = true, setContentType, setContentLength
             setContentType("text/plain;charset=UTF-8");
         }
     }
-    else if (isObjectType("URLSearchParams", body)) {
+    else if (isObjectType("URLSearchParams", body) || isPolyfillType("URLSearchParams", body)) {
         result = body.toString();
         if (setContentType) {
             setContentType("application/x-www-form-urlencoded;charset=UTF-8");
         }
     }
-    else if (body instanceof ArrayBuffer) {
+    else if (isArrayBuffer(body)) {
         result = cloneArrayBuffer ? body.slice(0) : body;
     }
     else if (ArrayBuffer.isView(body)) {
@@ -1867,7 +1824,7 @@ function convert(body, cloneArrayBuffer = true, setContentType, setContentLength
 }
 /** @internal */
 function convertBack(type, data) {
-    let temp = !!data ? (typeof data !== "string" && !(data instanceof ArrayBuffer) ? JSON.stringify(data) : data) : "";
+    let temp = !!data ? (typeof data !== "string" && !isArrayBuffer(data) ? JSON.stringify(data) : data) : "";
     if (!type || type === "text") {
         return typeof temp === "string" ? temp : decode$1(temp);
     }
@@ -1875,7 +1832,7 @@ function convertBack(type, data) {
         return JSON.parse(typeof temp === "string" ? temp : decode$1(temp));
     }
     else if (type === "arraybuffer") {
-        return temp instanceof ArrayBuffer ? temp.slice(0) : encode$1(temp).buffer;
+        return isArrayBuffer(temp) ? temp.slice(0) : encode$1(temp).buffer;
     }
     else if (type === "blob") {
         return new BlobP([temp]);
@@ -1885,9 +1842,9 @@ function convertBack(type, data) {
     }
 }
 
-var _a$2;
+var _a$3;
 /** @internal */
-const state$6 = Symbol( /* "AbortSignalState" */);
+const state$9 = Symbol( /* "AbortSignalState" */);
 class AbortSignalP extends EventTargetP {
     static abort(reason) {
         let signal = createAbortSignal();
@@ -1944,40 +1901,40 @@ class AbortSignalP extends EventTargetP {
             throw new TypeError("Failed to construct 'AbortSignal': Illegal constructor");
         }
         super();
-        this[state$6] = new AbortSignalState(this);
+        this[state$9] = new AbortSignalState(this);
     }
-    get aborted() { return this[state$6].aborted; }
-    get reason() { return this[state$6].reason; }
+    get aborted() { return this[state$9].aborted; }
+    get reason() { return this[state$9].reason; }
     throwIfAborted() {
         if (this.aborted) {
             throw this.reason;
         }
     }
-    get onabort() { return this[state$6].onabort; }
+    get onabort() { return this[state$9].onabort; }
     set onabort(value) {
-        this[state$6].onabort = value;
-        attachFn(this, "abort", value, this[state$6][_handlers$2].onabort);
+        this[state$9].onabort = value;
+        attachFn(this, "abort", value, this[state$9][_handlers$3].onabort);
     }
     /** @internal */ toString() { return "[object AbortSignal]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "AbortSignal"; }
     /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["AbortSignal", "EventTarget"] }; }
 }
-Class_setStringTag(AbortSignalP, "AbortSignal");
 /** @internal */
-const _handlers$2 = Symbol();
+const _handlers$3 = Symbol();
 /** @internal */
 class AbortSignalState {
     constructor(target) {
         this.aborted = false;
         this.reason = undefined;
-        this[_a$2] = getHandlers$2(this);
+        this[_a$3] = getHandlers$3(this);
         this.onabort = null;
         this.target = target;
     }
 }
-_a$2 = _handlers$2;
+_a$3 = _handlers$3;
 /** @internal */
 function AbortSignal_abort(signal, reason, notify = true, isTrusted = true) {
-    const s = signal[state$6];
+    const s = signal[state$9];
     if (!s.aborted) {
         s.aborted = true;
         s.reason = reason !== null && reason !== void 0 ? reason : (new MPException("signal is aborted without reason", "AbortError"));
@@ -1987,7 +1944,7 @@ function AbortSignal_abort(signal, reason, notify = true, isTrusted = true) {
         }
     }
 }
-function getHandlers$2(s) {
+function getHandlers$3(s) {
     return {
         onabort: (ev) => { executeFn(s.target, s.onabort, ev); },
     };
@@ -1995,26 +1952,26 @@ function getHandlers$2(s) {
 /** @internal */
 function createAbortSignal() {
     let signal = Object.create(AbortSignalP.prototype);
-    signal[state$d] = new EventTargetState(signal);
-    signal[state$6] = new AbortSignalState(signal);
+    signal[state$g] = new EventTargetState(signal);
+    signal[state$9] = new AbortSignalState(signal);
     return signal;
 }
 const AbortSignalE = g["AbortSignal"] || AbortSignalP;
 
 /** @internal */
-const state$5 = Symbol( /* "AbortControllerState" */);
+const state$8 = Symbol( /* "AbortControllerState" */);
 class AbortControllerP {
     constructor() {
-        this[state$5] = new AbortControllerState();
+        this[state$8] = new AbortControllerState();
     }
-    get signal() { return this[state$5].signal; }
+    get signal() { return this[state$8].signal; }
     abort(reason) {
-        AbortSignal_abort(this[state$5].signal, reason);
+        AbortSignal_abort(this[state$8].signal, reason);
     }
     /** @internal */ toString() { return "[object AbortController]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "AbortController"; }
     /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["AbortController"] }; }
 }
-Class_setStringTag(AbortControllerP, "AbortController");
 /** @internal */
 class AbortControllerState {
     constructor() {
@@ -2023,15 +1980,15 @@ class AbortControllerState {
 }
 const AbortControllerE = g["AbortController"] || AbortControllerP;
 
-/** @internal */ const state$4 = Symbol( /* "RequestState" */);
+/** @internal */ const state$7 = Symbol( /* "RequestState" */);
 class RequestP extends BodyImpl {
     constructor(...args) {
         const [input, init] = args;
         checkArgsLength(args, 1, "Request");
         super();
-        this[state$7].name = "Request";
-        this[state$4] = new RequestState();
-        const s = this[state$4];
+        this[state$a].name = "Request";
+        this[state$7] = new RequestState();
+        const s = this[state$7];
         let _init = init !== null && init !== void 0 ? init : {};
         if (typeof _init !== "object") {
             throw new TypeError("Failed to construct 'Request': The provided value is not of type 'RequestInit'.");
@@ -2048,7 +2005,7 @@ class RequestP extends BodyImpl {
             }
             s.method = input.method;
             s.mode = input.mode;
-            let inputSignal = input[state$4].signal;
+            let inputSignal = input[state$7].signal;
             if (inputSignal) {
                 s.signal = inputSignal;
             }
@@ -2056,7 +2013,7 @@ class RequestP extends BodyImpl {
             let payload = Body_toPayload(input);
             if (!body && payload !== "") {
                 body = payload;
-                input[state$7].bodyUsed = true;
+                input[state$a].bodyUsed = true;
             }
         }
         else {
@@ -2100,31 +2057,31 @@ class RequestP extends BodyImpl {
             }
         }
     }
-    get cache() { return this[state$4].cache; }
-    get credentials() { return this[state$4].credentials; }
-    get destination() { return this[state$4].destination; }
+    get cache() { return this[state$7].cache; }
+    get credentials() { return this[state$7].credentials; }
+    get destination() { return this[state$7].destination; }
     get headers() {
-        const s = this[state$4];
+        const s = this[state$7];
         if (!s.headers) {
             s.headers = new HeadersP();
         }
         return s.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 integrity() { return this[state$7].integrity; }
+    get keepalive() { return this[state$7].keepalive; }
+    get method() { return this[state$7].method; }
+    get mode() { return this[state$7].mode; }
+    get redirect() { return this[state$7].redirect; }
+    get referrer() { return this[state$7].referrer; }
+    get referrerPolicy() { return this[state$7].referrerPolicy; }
     get signal() {
-        const s = this[state$4];
+        const s = this[state$7];
         if (!s.signal) {
             s.signal = (new AbortControllerP()).signal;
         }
         return s.signal;
     }
-    get url() { return this[state$4].url; }
+    get url() { return this[state$7].url; }
     clone() {
         var _a;
         if (this.bodyUsed) {
@@ -2133,9 +2090,9 @@ class RequestP extends BodyImpl {
         return new RequestP(this, { body: (_a = Body_toPayload(this)) !== null && _a !== void 0 ? _a : null });
     }
     /** @internal */ toString() { return "[object Request]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "Request"; }
     /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["Request"] }; }
 }
-Class_setStringTag(RequestP, "Request");
 /** @internal */
 class RequestState {
     constructor() {
@@ -2162,8 +2119,7 @@ function normalizeMethod(method) {
 const RequestE = g["Request"] || RequestP;
 
 // @ts-nocheck
-/** @internal */
-const mp$2 = (() => {
+function getPlatform() {
     let u = "undefined", r = "request", f = "function";
     let mp;
     mp =
@@ -2186,9 +2142,11 @@ const mp$2 = (() => {
                 (typeof Taro !== u && typeof (Taro === null || Taro === void 0 ? void 0 : Taro[r]) === f && Taro) || // Taro
                 undefined;
     return mp;
-})();
+}
+/** @internal */
+const mp$3 = getPlatform();
 
-const request = mp$2 ? mp$2.request : function errorRequest(options) {
+const request = mp$3 ? mp$3.request : function errorRequest(options) {
     const errMsg = "NOT_SUPPORTED_ERR";
     const errno = 9;
     const err = {
@@ -2215,8 +2173,8 @@ const request = mp$2 ? mp$2.request : function errorRequest(options) {
     throw new ReferenceError("request is not defined");
 };
 
-var _a$1;
-/** @internal */ const state$3 = Symbol( /* "XMLHttpRequestEventTargetState" */);
+var _a$2;
+/** @internal */ const state$6 = Symbol( /* "XMLHttpRequestEventTargetState" */);
 class XMLHttpRequestEventTargetP extends EventTargetP {
     /** @internal */
     constructor() {
@@ -2224,35 +2182,35 @@ class XMLHttpRequestEventTargetP extends EventTargetP {
             throw new TypeError("Failed to construct 'XMLHttpRequestEventTarget': Illegal constructor");
         }
         super();
-        this[state$3] = new XMLHttpRequestEventTargetState(this);
-    }
-    get onabort() { return this[state$3].onabort; }
-    set onabort(value) { this[state$3].onabort = value; attach(this, "abort"); }
-    get onerror() { return this[state$3].onerror; }
-    set onerror(value) { this[state$3].onerror = value; attach(this, "error"); }
-    get onload() { return this[state$3].onload; }
-    set onload(value) { this[state$3].onload = value; attach(this, "load"); }
-    get onloadend() { return this[state$3].onloadend; }
-    set onloadend(value) { this[state$3].onloadend = value; attach(this, "loadend"); }
-    get onloadstart() { return this[state$3].onloadstart; }
-    set onloadstart(value) { this[state$3].onloadstart = value; attach(this, "loadstart"); }
-    get onprogress() { return this[state$3].onprogress; }
-    set onprogress(value) { this[state$3].onprogress = value; attach(this, "progress"); }
-    get ontimeout() { return this[state$3].ontimeout; }
-    set ontimeout(value) { this[state$3].ontimeout = value; attach(this, "timeout"); }
+        this[state$6] = new XMLHttpRequestEventTargetState(this);
+    }
+    get onabort() { return this[state$6].onabort; }
+    set onabort(value) { this[state$6].onabort = value; attach$1(this, "abort"); }
+    get onerror() { return this[state$6].onerror; }
+    set onerror(value) { this[state$6].onerror = value; attach$1(this, "error"); }
+    get onload() { return this[state$6].onload; }
+    set onload(value) { this[state$6].onload = value; attach$1(this, "load"); }
+    get onloadend() { return this[state$6].onloadend; }
+    set onloadend(value) { this[state$6].onloadend = value; attach$1(this, "loadend"); }
+    get onloadstart() { return this[state$6].onloadstart; }
+    set onloadstart(value) { this[state$6].onloadstart = value; attach$1(this, "loadstart"); }
+    get onprogress() { return this[state$6].onprogress; }
+    set onprogress(value) { this[state$6].onprogress = value; attach$1(this, "progress"); }
+    get ontimeout() { return this[state$6].ontimeout; }
+    set ontimeout(value) { this[state$6].ontimeout = value; attach$1(this, "timeout"); }
     /** @internal */ toString() { return "[object XMLHttpRequestEventTarget]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "XMLHttpRequestEventTarget"; }
     /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["XMLHttpRequestEventTarget", "EventTarget"] }; }
 }
-Class_setStringTag(XMLHttpRequestEventTargetP, "XMLHttpRequestEventTarget");
 /** @internal */
-const _handlers$1 = Symbol();
+const _handlers$2 = Symbol();
 /** @internal */
 class XMLHttpRequestEventTargetState {
     /**
      * @param _target XMLHttpRequestEventTarget
      */
     constructor(_target) {
-        this[_a$1] = getHandlers$1(this);
+        this[_a$2] = getHandlers$2(this);
         this.onabort = null;
         this.onerror = null;
         this.onload = null;
@@ -2263,15 +2221,15 @@ class XMLHttpRequestEventTargetState {
         this.target = _target;
     }
 }
-_a$1 = _handlers$1;
-function attach(target, type) {
-    const s = target[state$3];
+_a$2 = _handlers$2;
+function attach$1(target, type) {
+    const s = target[state$6];
     const fnName = ("on" + type);
     const cb = s[fnName];
-    const listener = s[_handlers$1][fnName];
+    const listener = s[_handlers$2][fnName];
     attachFn(target, type, cb, listener);
 }
-function getHandlers$1(s) {
+function getHandlers$2(s) {
     return {
         onabort: (ev) => { executeFn(s.target, s.onabort, ev); },
         onerror: (ev) => { executeFn(s.target, s.onerror, ev); },
@@ -2282,14 +2240,6 @@ function getHandlers$1(s) {
         ontimeout: (ev) => { executeFn(s.target, s.ontimeout, ev); },
     };
 }
-/** @internal */
-const XHR_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 },
-};
 const responseTypes = ["", "text", "json", "arraybuffer", "blob", "document"];
 /** @internal */
 function normalizeResponseType(responseType) {
@@ -2372,56 +2322,65 @@ class XMLHttpRequestUploadP extends XMLHttpRequestEventTargetP {
         super();
     }
     /** @internal */ toString() { return "[object XMLHttpRequestUpload]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "XMLHttpRequestUpload"; }
     /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["XMLHttpRequestUpload", "XMLHttpRequestEventTarget", "EventTarget"] }; }
 }
-Class_setStringTag(XMLHttpRequestUploadP, "XMLHttpRequestUpload");
 /** @internal */
 function createXMLHttpRequestUpload() {
     let upload = Object.create(XMLHttpRequestUploadP.prototype);
-    upload[state$d] = new EventTargetState(upload);
-    upload[state$3] = new XMLHttpRequestEventTargetState(upload);
+    upload[state$g] = new EventTargetState(upload);
+    upload[state$6] = new XMLHttpRequestEventTargetState(upload);
     return upload;
 }
 
-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$2 = Symbol( /* "XMLHttpRequestState" */);
+var _a$1, _b$1, _c, _d, _e, _f, _g, _h, _j, _k;
+const mp$2 = { request: request };
+const setRequest = (request) => { mp$2.request = request; };
+/** @internal */ const state$5 = Symbol( /* "XMLHttpRequestState" */);
 class XMLHttpRequestImpl extends XMLHttpRequestEventTargetP {
+    static get UNSENT() { return 0; }
+    static get OPENED() { return 1; }
+    static get HEADERS_RECEIVED() { return 2; }
+    static get LOADING() { return 3; }
+    static get DONE() { return 4; }
     constructor() {
         super();
-        this[state$2] = new XMLHttpRequestState(this);
-    }
-    get readyState() { return this[state$2].readyState; }
-    get response() { return this[state$2].response; }
+        this[state$5] = new XMLHttpRequestState(this);
+    }
+    get UNSENT() { return 0; }
+    get OPENED() { return 1; }
+    get HEADERS_RECEIVED() { return 2; }
+    get LOADING() { return 3; }
+    get DONE() { return 4; }
+    get readyState() { return this[state$5].readyState; }
+    get response() { return this[state$5].response; }
     get responseText() { return (!this.responseType || this.responseType === "text") ? this.response : ""; }
-    get responseType() { return this[state$2].responseType; }
-    set responseType(value) { this[state$2].responseType = normalizeResponseType(value); }
-    get responseURL() { return this[state$2].responseURL; }
+    get responseType() { return this[state$5].responseType; }
+    set responseType(value) { this[state$5].responseType = normalizeResponseType(value); }
+    get responseURL() { return this[state$5].responseURL; }
     get responseXML() { return null; }
-    get status() { return this[state$2].status; }
+    get status() { return this[state$5].status; }
     get statusText() {
-        if (this.readyState === XMLHttpRequestImpl.UNSENT || this.readyState === XMLHttpRequestImpl.OPENED)
+        if (this.readyState === 0 /* UNSENT */ || this.readyState === 1 /* OPENED */)
             return "";
-        return this[state$2].statusText || statusTextMap(this.status);
+        return this[state$5].statusText || statusTextMap(this.status);
     }
-    get timeout() { return this[state$2].timeout; }
-    set timeout(value) { this[state$2].timeout = value > 0 ? value : 0; }
+    get timeout() { return this[state$5].timeout; }
+    set timeout(value) { this[state$5].timeout = value > 0 ? value : 0; }
     get upload() {
-        const s = this[state$2];
+        const s = this[state$5];
         if (!s.upload) {
             s.upload = createXMLHttpRequestUpload();
         }
         return s.upload;
     }
-    get withCredentials() { return this[state$2].withCredentials; }
-    set withCredentials(value) { this[state$2].withCredentials = !!value; }
+    get withCredentials() { return this[state$5].withCredentials; }
+    set withCredentials(value) { this[state$5].withCredentials = !!value; }
     abort() {
         clearRequest(this);
     }
     getAllResponseHeaders() {
-        const headers = this[state$2][_responseHeaders];
+        const headers = this[state$5][_responseHeaders];
         if (!headers)
             return "";
         let result = [];
@@ -2431,9 +2390,9 @@ class XMLHttpRequestImpl extends XMLHttpRequestEventTargetP {
     getResponseHeader(...args) {
         const [name] = args;
         checkArgsLength(args, 1, "XMLHttpRequest", "getResponseHeader");
-        if (!this[state$2][_responseHeaders])
+        if (!this[state$5][_responseHeaders])
             return null;
-        return this[state$2][_responseHeaders].get(name);
+        return this[state$5][_responseHeaders].get(name);
     }
     open(...args) {
         const [method, url, async = true, username = null, password = null] = args;
@@ -2441,7 +2400,7 @@ class XMLHttpRequestImpl extends XMLHttpRequestEventTargetP {
         if (!async) {
             console.warn("Synchronous XMLHttpRequest is not supported because of its detrimental effects to the end user's experience.");
         }
-        const s = this[state$2];
+        const s = this[state$5];
         clearRequest(this, false);
         s[_method] = normalizeMethod(method);
         s[_requestURL] = "" + url;
@@ -2454,18 +2413,18 @@ class XMLHttpRequestImpl extends XMLHttpRequestEventTargetP {
             }
         }
         s[_inAfterOpenBeforeSend] = true;
-        setReadyStateAndNotify(this, XMLHttpRequestImpl.OPENED);
+        setReadyStateAndNotify(this, 1 /* OPENED */);
     }
     overrideMimeType(...args) {
         const [mime] = args;
         checkArgsLength(args, 1, "XMLHttpRequest", "overrideMimeType");
-        if (this[state$2][_inAfterOpenBeforeSend]) {
+        if (this[state$5][_inAfterOpenBeforeSend]) {
             console.error(`TypeError: Failed to execute 'overrideMimeType' on 'XMLHttpRequest': mimeType ('${mime}') not implemented.`);
         }
     }
     send(body) {
-        const s = this[state$2];
-        if (!s[_inAfterOpenBeforeSend] || s.readyState !== XMLHttpRequestImpl.OPENED) {
+        const s = this[state$5];
+        if (!s[_inAfterOpenBeforeSend] || s.readyState !== 1 /* OPENED */) {
             throw new MPException("Failed to execute 'send' on 'XMLHttpRequest': The object's state must be OPENED.", "InvalidStateError");
         }
         s[_inAfterOpenBeforeSend] = false;
@@ -2497,14 +2456,14 @@ class XMLHttpRequestImpl extends XMLHttpRequestEventTargetP {
         };
         // Alipay Mini Program
         options.headers = options.header;
-        s[_requestTask] = mp$1.request(options);
+        s[_requestTask] = mp$2.request(options);
         emitProcessEvent(this, "loadstart");
         if (processContentLength && s.upload) {
             emitProcessEvent(this.upload, "loadstart", 0, contentLength);
         }
         setTimeout(() => {
             if (s.upload) {
-                const _aborted = s[_inAfterOpenBeforeSend] || s.readyState !== XMLHttpRequestImpl.OPENED;
+                const _aborted = s[_inAfterOpenBeforeSend] || s.readyState !== 1 /* OPENED */;
                 const _contentLength = _aborted ? 0 : contentLength;
                 if (_aborted) {
                     emitProcessEvent(this.upload, "abort");
@@ -2524,27 +2483,29 @@ class XMLHttpRequestImpl extends XMLHttpRequestEventTargetP {
     setRequestHeader(...args) {
         const [name, value] = args;
         checkArgsLength(args, 2, "XMLHttpRequest", "setRequestHeader");
-        const s = this[state$2];
-        if (!s[_inAfterOpenBeforeSend] || s.readyState !== XMLHttpRequestImpl.OPENED) {
+        const s = this[state$5];
+        if (!s[_inAfterOpenBeforeSend] || s.readyState !== 1 /* OPENED */) {
             throw new MPException("Failed to execute 'setRequestHeader' on 'XMLHttpRequest': The object's state must be OPENED.", "InvalidStateError");
         }
-        let _name = normalizeName(name, () => {
-            throw new SyntaxError(`Failed to execute 'setRequestHeader' on 'XMLHttpRequest': '${name}' is not a valid HTTP header field name.`);
-        });
-        s[_requestHeaders].append(_name, value);
+        let _name = "" + name;
+        let _value = "" + value;
+        try {
+            s[_requestHeaders].append(_name, _value);
+        }
+        catch (e) {
+            throw new SyntaxError(`Failed to execute 'setRequestHeader' on 'XMLHttpRequest': '${_name}' is not a valid HTTP header field name.`);
+        }
     }
-    get onreadystatechange() { return this[state$2].onreadystatechange; }
+    get onreadystatechange() { return this[state$5].onreadystatechange; }
     set onreadystatechange(value) {
-        this[state$2].onreadystatechange = value;
-        attachFn(this, "readystatechange", value, this[state$2][_handlers].onreadystatechange);
+        this[state$5].onreadystatechange = value;
+        attachFn(this, "readystatechange", value, this[state$5][_handlers$1].onreadystatechange);
     }
     /** @internal */ toString() { return "[object XMLHttpRequest]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "XMLHttpRequest"; }
     /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["XMLHttpRequest", "XMLHttpRequestEventTarget", "EventTarget"] }; }
 }
-Object.defineProperties(XMLHttpRequestImpl, XHR_properties);
-Object.defineProperties(XMLHttpRequestImpl.prototype, XHR_properties);
-Class_setStringTag(XMLHttpRequestImpl, "XMLHttpRequest");
-/** @internal */ const _handlers = Symbol();
+/** @internal */ const _handlers$1 = Symbol();
 /** @internal */ const _inAfterOpenBeforeSend = Symbol();
 /** @internal */ const _resetPending = Symbol();
 /** @internal */ const _timeoutId = Symbol();
@@ -2557,7 +2518,7 @@ Class_setStringTag(XMLHttpRequestImpl, "XMLHttpRequest");
 /** @internal */
 class XMLHttpRequestState {
     constructor(target) {
-        this.readyState = XMLHttpRequestImpl.UNSENT;
+        this.readyState = 0 /* UNSENT */;
         this.response = "";
         this.responseType = "";
         this.responseURL = "";
@@ -2565,9 +2526,9 @@ class XMLHttpRequestState {
         this.statusText = "";
         this.timeout = 0;
         this.withCredentials = false;
-        this[_a] = getHandlers(this);
+        this[_a$1] = getHandlers$1(this);
         this.onreadystatechange = null;
-        this[_b] = false;
+        this[_b$1] = false;
         this[_c] = false;
         this[_d] = 0;
         this[_e] = "";
@@ -2579,8 +2540,8 @@ class XMLHttpRequestState {
         this.target = target;
     }
 }
-_a = _handlers, _b = _inAfterOpenBeforeSend, _c = _resetPending, _d = _timeoutId, _e = _requestURL, _f = _method, _g = _requestHeaders, _h = _responseHeaders, _j = _responseContentLength, _k = _requestTask;
-function getHandlers(s) {
+_a$1 = _handlers$1, _b$1 = _inAfterOpenBeforeSend, _c = _resetPending, _d = _timeoutId, _e = _requestURL, _f = _method, _g = _requestHeaders, _h = _responseHeaders, _j = _responseContentLength, _k = _requestTask;
+function getHandlers$1(s) {
     return {
         onreadystatechange: (ev) => { executeFn(s.target, s.onreadystatechange, ev); },
     };
@@ -2589,15 +2550,15 @@ function normalizeDataType(responseType) {
     return (responseType === "blob" || responseType === "arraybuffer") ? "arraybuffer" : "text";
 }
 function requestSuccess(res) {
-    const s = this[state$2];
+    const s = this[state$5];
     s.responseURL = s[_requestURL];
     s.status = "statusCode" in res ? res.statusCode : "status" in res ? res.status : 200;
-    s[_responseHeaders] = new HeadersP(("header" in res ? res.header : "headers" in res ? res.headers : undefined));
+    s[_responseHeaders] = new HeadersP(("header" in res ? res.header : "headers" in res ? res.headers : {}));
     let lengthStr = s[_responseHeaders].get("Content-Length");
     s[_responseContentLength] = () => { return lengthStr ? parseInt(lengthStr) : 0; };
-    if (s.readyState === XMLHttpRequestImpl.OPENED) {
-        setReadyStateAndNotify(this, XMLHttpRequestImpl.HEADERS_RECEIVED);
-        setReadyStateAndNotify(this, XMLHttpRequestImpl.LOADING);
+    if (s.readyState === 1 /* OPENED */) {
+        setReadyStateAndNotify(this, 2 /* HEADERS_RECEIVED */);
+        setReadyStateAndNotify(this, 3 /* LOADING */);
         setTimeout(() => {
             if (!s[_inAfterOpenBeforeSend]) {
                 let l = s[_responseContentLength];
@@ -2626,23 +2587,23 @@ function requestFail(err) {
         requestSuccess.call(this, {
             statusCode: "statusCode" in err ? err.statusCode : err.status || 0,
             header: "header" in err ? err.header : err.headers || {},
-            data: "data" in err ? err.data : "",
+            data: "data" in err ? err.data || "" : "",
         });
         return;
     }
-    const s = this[state$2];
+    const s = this[state$5];
     s.status = 0;
     s.statusText = "errMsg" in err ? err.errMsg : "errorMessage" in err ? err.errorMessage : "";
-    if (!s[_inAfterOpenBeforeSend] && s.readyState !== XMLHttpRequestImpl.UNSENT && s.readyState !== XMLHttpRequestImpl.DONE) {
+    if (!s[_inAfterOpenBeforeSend] && s.readyState !== 0 /* UNSENT */ && s.readyState !== 4 /* DONE */) {
         emitProcessEvent(this, "error");
         resetRequestTimeout(this);
     }
 }
 function requestComplete() {
-    const s = this[state$2];
+    const s = this[state$5];
     s[_requestTask] = null;
-    if (!s[_inAfterOpenBeforeSend] && (s.readyState === XMLHttpRequestImpl.OPENED || s.readyState === XMLHttpRequestImpl.LOADING)) {
-        setReadyStateAndNotify(this, XMLHttpRequestImpl.DONE);
+    if (!s[_inAfterOpenBeforeSend] && (s.readyState === 1 /* OPENED */ || s.readyState === 3 /* LOADING */)) {
+        setReadyStateAndNotify(this, 4 /* DONE */);
     }
     setTimeout(() => {
         if (!s[_inAfterOpenBeforeSend]) {
@@ -2658,12 +2619,12 @@ function safeAbort(task) {
     }
 }
 function clearRequest(xhr, delay = true) {
-    const s = xhr[state$2];
+    const s = xhr[state$5];
     const timerFn = delay ? setTimeout : (f) => { f(); };
     s[_resetPending] = true;
-    if (s[_requestTask] && s.readyState !== XMLHttpRequestImpl.DONE) {
+    if (s[_requestTask] && s.readyState !== 4 /* DONE */) {
         if (delay) {
-            setReadyStateAndNotify(xhr, XMLHttpRequestImpl.DONE);
+            setReadyStateAndNotify(xhr, 4 /* DONE */);
         }
         timerFn(() => {
             const requestTask = s[_requestTask];
@@ -2681,27 +2642,27 @@ function clearRequest(xhr, delay = true) {
     timerFn(() => {
         if (s[_resetPending]) {
             if (delay) {
-                s.readyState = XMLHttpRequestImpl.UNSENT;
+                s.readyState = 0 /* UNSENT */;
             }
             resetXHR(xhr);
         }
     });
 }
 function checkRequestTimeout(xhr) {
-    const s = xhr[state$2];
+    const s = xhr[state$5];
     if (s.timeout) {
         s[_timeoutId] = setTimeout(() => {
-            if (!s.status && s.readyState !== XMLHttpRequestImpl.DONE) {
+            if (!s.status && s.readyState !== 4 /* DONE */) {
                 if (s[_requestTask])
                     safeAbort(s[_requestTask]);
-                setReadyStateAndNotify(xhr, XMLHttpRequestImpl.DONE);
+                setReadyStateAndNotify(xhr, 4 /* DONE */);
                 emitProcessEvent(xhr, "timeout");
             }
         }, s.timeout);
     }
 }
 function resetXHR(xhr) {
-    const s = xhr[state$2];
+    const s = xhr[state$5];
     s[_resetPending] = false;
     resetRequestTimeout(xhr);
     s.response = "";
@@ -2713,14 +2674,14 @@ function resetXHR(xhr) {
     s[_responseContentLength] = () => 0;
 }
 function resetRequestTimeout(xhr) {
-    const s = xhr[state$2];
+    const s = xhr[state$5];
     if (s[_timeoutId]) {
         clearTimeout(s[_timeoutId]);
         s[_timeoutId] = 0;
     }
 }
 function setReadyStateAndNotify(xhr, value) {
-    const s = xhr[state$2];
+    const s = xhr[state$5];
     let hasChanged = value !== s.readyState;
     s.readyState = value;
     if (hasChanged) {
@@ -2732,13 +2693,13 @@ function setReadyStateAndNotify(xhr, value) {
 const XMLHttpRequestP = XMLHttpRequestImpl;
 const XMLHttpRequestE = (typeof XMLHttpRequest !== "undefined" && XMLHttpRequest) || XMLHttpRequestP;
 
-/** @internal */ const state$1 = Symbol( /* "ResponseState" */);
+/** @internal */ const state$4 = Symbol( /* "ResponseState" */);
 class ResponseP extends BodyImpl {
     constructor(body, init) {
         super();
-        this[state$7].name = "Response";
-        this[state$1] = new ResponseState();
-        const s = this[state$1];
+        this[state$a].name = "Response";
+        this[state$4] = new ResponseState();
+        const s = this[state$4];
         let _init = init !== null && init !== void 0 ? init : {};
         if (typeof _init !== "object") {
             throw new TypeError("Failed to construct 'Response': The provided value is not of type 'ResponseInit'.");
@@ -2756,18 +2717,18 @@ class ResponseP extends BodyImpl {
         Body_init(this, body);
     }
     get headers() {
-        const s = this[state$1];
+        const s = this[state$4];
         if (!s.headers) {
             s.headers = new HeadersP();
         }
         return s.headers;
     }
-    get ok() { return this[state$1].ok; }
-    get redirected() { return this[state$1].redirected; }
-    get status() { return this[state$1].status; }
-    get statusText() { return this[state$1].statusText; }
-    get type() { return this[state$1].type; }
-    get url() { return this[state$1].url; }
+    get ok() { return this[state$4].ok; }
+    get redirected() { return this[state$4].redirected; }
+    get status() { return this[state$4].status; }
+    get statusText() { return this[state$4].statusText; }
+    get type() { return this[state$4].type; }
+    get url() { return this[state$4].url; }
     clone() {
         if (this.bodyUsed) {
             throw new TypeError("Failed to execute 'clone' on 'Response': Response body is already used");
@@ -2777,7 +2738,7 @@ class ResponseP extends BodyImpl {
             status: this.status,
             statusText: this.statusText,
         });
-        response[state$1].url = this.url;
+        response[state$4].url = this.url;
         return response;
     }
     static json(...args) {
@@ -2789,9 +2750,9 @@ class ResponseP extends BodyImpl {
     }
     static error() {
         let response = new ResponseP(null, { status: 200, statusText: "" });
-        response[state$1].ok = false;
-        response[state$1].status = 0;
-        response[state$1].type = "error";
+        response[state$4].ok = false;
+        response[state$4].status = 0;
+        response[state$4].type = "error";
         return response;
     }
     static redirect(...args) {
@@ -2803,9 +2764,9 @@ class ResponseP extends BodyImpl {
         return new ResponseP(null, { status, headers: { location: "" + url } });
     }
     /** @internal */ toString() { return "[object Response]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "Response"; }
     /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["Response"] }; }
 }
-Class_setStringTag(ResponseP, "Response");
 /** @internal */
 class ResponseState {
     constructor() {
@@ -2819,8 +2780,8 @@ class ResponseState {
 }
 const ResponseE = g["Response"] || ResponseP;
 
-const mp = { XMLHttpRequest: XMLHttpRequestE };
-const setXMLHttpRequest = (XHR) => { mp.XMLHttpRequest = XHR; };
+const mp$1 = { XMLHttpRequest: XMLHttpRequestE };
+const setXMLHttpRequest = (XHR) => { mp$1.XMLHttpRequest = XHR; };
 function fetchP(...args) {
     if (new.target === fetchP) {
         throw new TypeError("fetch is not a constructor");
@@ -2829,11 +2790,11 @@ function fetchP(...args) {
     checkArgsLength(args, 1, "Window", "fetch");
     return new Promise((resolve, reject) => {
         const request = new RequestP(input, init);
-        const signal = request[state$4].signal;
+        const signal = request[state$7].signal;
         if (signal && signal.aborted) {
             return reject(signal.reason);
         }
-        let xhr = new mp.XMLHttpRequest();
+        let xhr = new mp$1.XMLHttpRequest();
         xhr.onload = function () {
             let options = {
                 headers: parseHeaders(xhr.getAllResponseHeaders() || ""),
@@ -2847,7 +2808,7 @@ function fetchP(...args) {
             }
             setTimeout(() => {
                 let response = new ResponseP("response" in xhr ? xhr.response : xhr.responseText, options);
-                response[state$1].url = "responseURL" in xhr ? xhr.responseURL : (options.headers.get("X-Request-URL") || "");
+                response[state$4].url = "responseURL" in xhr ? xhr.responseURL : (options.headers.get("X-Request-URL") || "");
                 resolve(response);
             });
         };
@@ -2876,7 +2837,7 @@ function fetchP(...args) {
         if ("responseType" in xhr) {
             xhr.responseType = "arraybuffer";
         }
-        if (init && typeof init === "object" && typeof init.headers === "object" && !isObjectType("Headers", init.headers)) {
+        if (init && typeof init === "object" && typeof init.headers === "object" && !(isObjectType("Headers", init.headers) || isPolyfillType("Headers", init.headers))) {
             let headers = init.headers;
             let names = [];
             Object.getOwnPropertyNames(headers).forEach(name => {
@@ -2898,8 +2859,8 @@ function fetchP(...args) {
             const abortXHR = () => { xhr.abort(); };
             signal.addEventListener("abort", abortXHR);
             xhr.onreadystatechange = function () {
-                // DONE (success or failure)
-                if (xhr.readyState === 4) {
+                // success or failure
+                if (xhr.readyState === 4 /* DONE */) {
                     signal.removeEventListener("abort", abortXHR);
                 }
             };
@@ -2910,34 +2871,346 @@ function fetchP(...args) {
 }
 const fetchE = g["fetch"] || fetchP;
 
-const dispatched = 1;
+const dispatched$1 = 1;
 /** @internal */
-const state = Symbol( /* "CustomEventState" */);
+const state$3 = 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;
+        this[state$3] = new CustomEventState();
+        this[state$3].detail = (_a = eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.detail) !== null && _a !== void 0 ? _a : null;
     }
-    get detail() { return this[state].detail; }
+    get detail() { return this[state$3].detail; }
     initCustomEvent(...args) {
         const [type, bubbles, cancelable, detail] = args;
         checkArgsLength(args, 1, "CustomEvent", "initCustomEvent");
-        if (Event_getEtField(this, dispatched))
+        if (Event_getEtField(this, dispatched$1))
             return;
         this.initEvent(type, bubbles, cancelable);
-        this[state].detail = detail !== null && detail !== void 0 ? detail : null;
+        this[state$3].detail = detail !== null && detail !== void 0 ? detail : null;
     }
     /** @internal */ toString() { return "[object CustomEvent]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "CustomEvent"; }
     /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["CustomEvent", "Event"] }; }
 }
-Class_setStringTag(CustomEventP, "CustomEvent");
 /** @internal */
 class CustomEventState {
 }
 const CustomEventE = g["EventTarget"] ? g["CustomEvent"] : CustomEventP;
 
+/** @internal */
+const state$2 = Symbol( /* "CloseEventState" */);
+class CloseEventP extends EventP {
+    constructor(type, eventInitDict) {
+        var _a;
+        super(type, eventInitDict);
+        this[state$2] = new CloseEventState();
+        const s = this[state$2];
+        let _code = Number((_a = eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.code) !== null && _a !== void 0 ? _a : 0);
+        s.code = isNaN(_code) ? 0 : _code;
+        if ((eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.reason) !== undefined)
+            s.reason = "" + eventInitDict.reason;
+        s.wasClean = !!(eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.wasClean);
+    }
+    get code() { return this[state$2].code; }
+    get reason() { return this[state$2].reason; }
+    get wasClean() { return this[state$2].wasClean; }
+    /** @internal */ toString() { return "[object CloseEvent]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "CloseEvent"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["CloseEvent", "Event"] }; }
+}
+/** @internal */
+class CloseEventState {
+    constructor() {
+        this.code = 0;
+        this.reason = "";
+        this.wasClean = false;
+    }
+}
+g["EventTarget"] ? g["CloseEvent"] : CloseEventP;
+
+const dispatched = 1;
+/** @internal */
+const state$1 = Symbol( /* "MessageEventState" */);
+class MessageEventP extends EventP {
+    constructor(type, eventInitDict) {
+        var _a;
+        super(type, eventInitDict);
+        this[state$1] = new MessageEventState();
+        const s = this[state$1];
+        s.data = (_a = eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.data) !== null && _a !== void 0 ? _a : null;
+        if ((eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.origin) !== undefined)
+            s.origin = "" + eventInitDict.origin;
+        if ((eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.lastEventId) !== undefined)
+            s.lastEventId = "" + eventInitDict.lastEventId;
+        if ((eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.source) !== undefined)
+            s.source = eventInitDict.source;
+        if ((eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.ports) !== undefined)
+            s.ports = eventInitDict.ports;
+    }
+    get data() { return this[state$1].data; }
+    get lastEventId() { return this[state$1].lastEventId; }
+    get origin() { return this[state$1].origin; }
+    get ports() { return this[state$1].ports; }
+    get source() { return this[state$1].source; }
+    initMessageEvent(...args) {
+        const [type, bubbles, cancelable, data, origin, lastEventId, source, ports] = args;
+        checkArgsLength(args, 1, "MessageEvent", "initMessageEvent");
+        if (Event_getEtField(this, dispatched))
+            return;
+        this.initEvent(type, bubbles, cancelable);
+        const s = this[state$1];
+        s.data = data !== null && data !== void 0 ? data : null;
+        if (origin !== undefined)
+            s.origin = "" + origin;
+        if (lastEventId !== undefined)
+            s.lastEventId = "" + lastEventId;
+        if (source !== undefined)
+            s.source = source;
+        if (ports !== undefined)
+            s.ports = ports;
+    }
+    /** @internal */ toString() { return "[object MessageEvent]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "MessageEvent"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["MessageEvent", "Event"] }; }
+}
+/** @internal */
+class MessageEventState {
+    constructor() {
+        this.data = null;
+        this.lastEventId = "";
+        this.origin = "";
+        this.ports = [];
+        this.source = null;
+    }
+}
+g["EventTarget"] ? g["MessageEvent"] : MessageEventP;
+
+const connectSocket = mp$3 ? mp$3.connectSocket : function errorConnectSocket(options) {
+    return {
+        send(obj) { },
+        close(obj) { },
+        onOpen(listener) { },
+        onMessage(listener) { },
+        onError(listener) {
+            if (typeof listener === "function") {
+                listener({ errMsg: "NOT_SUPPORTED_ERR" });
+            }
+        },
+        onClose(listener) {
+            if (typeof listener === "function") {
+                setTimeout(() => { listener({ code: 3009, reason: "NOT_SUPPORTED_ERR" }); });
+            }
+        },
+    };
+};
+
+var _a, _b;
+const mp = { connectSocket: connectSocket };
+const setConnectSocket = (connectSocket) => { mp.connectSocket = connectSocket; };
+/** @internal */
+const state = Symbol( /* "WebSocketState" */);
+class WebSocketImpl extends EventTargetP {
+    static get CONNECTING() { return 0; }
+    static get OPEN() { return 1; }
+    static get CLOSING() { return 2; }
+    static get CLOSED() { return 3; }
+    constructor(...args) {
+        const [url, protocols] = args;
+        checkArgsLength(args, 1, "WebSocket");
+        super();
+        this[state] = new WebSocketState(this, {
+            url: "" + url,
+            protocols: protocols !== undefined
+                ? (Array.isArray(protocols) || (protocols && typeof protocols === "object" && Symbol.iterator in protocols))
+                    ? Array.isArray(protocols) ? protocols : Array.from(protocols)
+                    : ["" + protocols]
+                : [],
+            multiple: true, // Alipay Mini Program
+            fail(err) { console.error(err); },
+        });
+        let socketTask = this[state][_socketTask];
+        if (socketTask && typeof socketTask === "object") {
+            onOpen(this);
+            onClose(this);
+            onError(this);
+            onMessage(this);
+        }
+        else {
+            throw new Error(`connectSocket can't establish a connection to the server at ${"" + url}.`);
+        }
+    }
+    get CONNECTING() { return 0; }
+    get OPEN() { return 1; }
+    get CLOSING() { return 2; }
+    get CLOSED() { return 3; }
+    get binaryType() { return this[state].binaryType; }
+    set binaryType(value) { if (value === "blob" || value === "arraybuffer") {
+        this[state].binaryType = value;
+    } }
+    get bufferedAmount() { return this[state].bufferedAmount; }
+    get extensions() { return this[state].extensions; }
+    get protocol() { return this[state].protocol; }
+    get readyState() { return this[state].readyState; }
+    get url() { return this[state].url; }
+    close(code, reason) {
+        if (this.readyState === 2 /* CLOSING */ || this.readyState === 3 /* CLOSED */)
+            return;
+        this[state].readyState = 2 /* CLOSING */;
+        this[state][_socketTask].close({
+            code: code,
+            reason: reason,
+            fail(err) { console.error(err); },
+            complete: (function () {
+                this[state].readyState = 3 /* CLOSED */;
+            }).bind(this),
+        });
+    }
+    send(...args) {
+        const [data] = args;
+        checkArgsLength(args, 1, "WebSocket", "send");
+        if (this.readyState === 0 /* CONNECTING */) {
+            throw new MPException("Failed to execute 'send' on 'WebSocket': Still in CONNECTING state.", "InvalidStateError");
+        }
+        if (this.readyState === 2 /* CLOSING */ || this.readyState === 3 /* CLOSED */) {
+            return console.error("WebSocket is already in CLOSING or CLOSED state.");
+        }
+        let _data;
+        if (isArrayBuffer(data)) {
+            _data = data;
+        }
+        else if (ArrayBuffer.isView(data)) {
+            _data = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+        }
+        else if (isPolyfillType("Blob", data)) {
+            _data = Blob_toUint8Array(data).buffer.slice(0);
+        }
+        else {
+            _data = "" + data;
+        }
+        this[state][_socketTask].send({
+            data: _data,
+            fail(err) { console.error(err); },
+        });
+    }
+    get onclose() { return this[state].onclose; }
+    set onclose(value) { this[state].onclose = value; attach(this, "close"); }
+    get onerror() { return this[state].onerror; }
+    set onerror(value) { this[state].onerror = value; attach(this, "error"); }
+    get onmessage() { return this[state].onmessage; }
+    set onmessage(value) { this[state].onmessage = value; attach(this, "message"); }
+    get onopen() { return this[state].onopen; }
+    set onopen(value) { this[state].onopen = value; attach(this, "open"); }
+    /** @internal */ toString() { return "[object WebSocket]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "WebSocket"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["WebSocket", "EventTarget"] }; }
+}
+/** @internal */ const _socketTask = Symbol();
+/** @internal */ const _error = Symbol();
+/** @internal */ const _handlers = Symbol();
+/** @internal */
+class WebSocketState {
+    constructor(target, opts) {
+        this.binaryType = "blob";
+        this.bufferedAmount = 0;
+        this.extensions = "";
+        this.protocol = "";
+        this.readyState = 0;
+        this[_a] = null;
+        this[_b] = getHandlers(this);
+        this.onclose = null;
+        this.onerror = null;
+        this.onmessage = null;
+        this.onopen = null;
+        this.target = target;
+        this.url = opts.url;
+        this[_socketTask] = mp.connectSocket(opts);
+    }
+}
+_a = _error, _b = _handlers;
+function attach(target, type) {
+    const s = target[state];
+    const fnName = ("on" + type);
+    const cb = s[fnName];
+    const listener = s[_handlers][fnName];
+    attachFn(target, type, cb, listener);
+}
+function getHandlers(s) {
+    return {
+        onclose: (ev) => { executeFn(s.target, s.onclose, ev); },
+        onerror: (ev) => { executeFn(s.target, s.onerror, ev); },
+        onmessage: (ev) => { executeFn(s.target, s.onmessage, ev); },
+        onopen: (ev) => { executeFn(s.target, s.onopen, ev); },
+    };
+}
+function onOpen(ws) {
+    let socket = ws;
+    socket[state][_socketTask].onOpen(res => {
+        if ("header" in res && res.header && typeof res.header === "object") {
+            let headers = new HeadersP(res.header);
+            socket[state].protocol = headers.get("Sec-WebSocket-Protocol") || "";
+        }
+        socket[state].readyState = 1 /* OPEN */;
+        EventTarget_fire(socket, createInnerEvent(socket, "open"));
+    });
+}
+function onClose(ws) {
+    let socket = ws;
+    socket[state][_socketTask].onClose(res => {
+        socket[state].readyState = 3 /* CLOSED */;
+        let event = new CloseEventP("close", {
+            wasClean: !socket[state][_error],
+            code: res.code,
+            reason: res.reason,
+        });
+        Event_setTrusted(event, true);
+        EventTarget_fire(socket, event);
+    });
+}
+function onError(ws) {
+    let socket = ws;
+    socket[state][_socketTask].onError(res => {
+        console.error(res);
+        socket[state][_error] = res;
+        socket[state].readyState = 3 /* CLOSED */;
+        EventTarget_fire(socket, createInnerEvent(socket, "error"));
+    });
+}
+function onMessage(ws) {
+    let socket = ws;
+    socket[state][_socketTask].onMessage(res => {
+        let data = res.data;
+        let _data;
+        // Alipay Mini Program
+        if (data && typeof data === "object" && "data" in data) {
+            _data = data.data;
+            if ("isBuffer" in data && data.isBuffer && typeof _data === "string") {
+                // @ts-ignore
+                try {
+                    _data = my.base64ToArrayBuffer(_data);
+                }
+                catch (e) { }
+            }
+        }
+        else {
+            _data = data;
+        }
+        if (isArrayBuffer(_data) && socket.binaryType === "blob") {
+            _data = new BlobP([_data]);
+        }
+        let event = new MessageEventP("message", {
+            data: _data,
+            origin: socket.url,
+        });
+        Event_setTrusted(event, true);
+        EventTarget_fire(socket, event);
+    });
+}
+
+const WebSocketP = WebSocketImpl;
+const WebSocketE = (typeof WebSocket !== "undefined" && WebSocket) || WebSocketP;
+
 exports.AbortController = AbortControllerE;
 exports.AbortControllerP = AbortControllerP;
 exports.AbortSignal = AbortSignalE;
@@ -2958,8 +3231,6 @@ exports.FormData = FormDataE;
 exports.FormDataP = FormDataP;
 exports.Headers = HeadersE;
 exports.HeadersP = HeadersP;
-exports.ProgressEvent = ProgressEventE;
-exports.ProgressEventP = ProgressEventP;
 exports.Request = RequestE;
 exports.RequestP = RequestP;
 exports.Response = ResponseE;
@@ -2970,9 +3241,12 @@ exports.TextEncoder = TextEncoderE;
 exports.TextEncoderP = TextEncoderP;
 exports.URLSearchParams = URLSearchParamsE;
 exports.URLSearchParamsP = URLSearchParamsP;
+exports.WebSocket = WebSocketE;
+exports.WebSocketP = WebSocketP;
 exports.XMLHttpRequest = XMLHttpRequestE;
 exports.XMLHttpRequestP = XMLHttpRequestP;
 exports.fetch = fetchE;
 exports.fetchP = fetchP;
+exports.setConnectSocket = setConnectSocket;
 exports.setRequest = setRequest;
 exports.setXMLHttpRequest = setXMLHttpRequest;