mphttpx 1.0.6 → 1.0.8

package/dist/index.cjs.js

@@ -1,15 +1,41 @@
 'use strict';
 
-const polyfill = Symbol("isPolyfill");
 /* eslint-disable no-prototype-builtins */
-const g = (typeof globalThis !== "undefined" && globalThis) ||
+/** @internal */ const g = (typeof globalThis !== "undefined" && globalThis) ||
     (typeof self !== "undefined" && self) ||
     // @ts-ignore eslint-disable-next-line no-undef
     (typeof global !== "undefined" && global) ||
     {};
+/** @internal */
+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.`);
+    }
+}
+/** @internal */
+class MPException extends Error {
+    constructor(message, name) {
+        super(message);
+        this.name = "Error";
+        if (name) {
+            this.name = name;
+        }
+    }
+}
+/** @internal */
 function isObjectType(name, value) {
     return Object.prototype.toString.call(value) === `[object ${name}]`;
 }
+/** @internal */
 function isPolyfillType(name, value) {
     return !!value
         && typeof value === "object"
@@ -22,39 +48,28 @@ function isPolyfillType(name, value) {
         && Array.isArray(value.isPolyfill.hierarchy)
         && value.isPolyfill.hierarchy.indexOf(name) > -1;
 }
-class MPException extends Error {
-    constructor(message, name) {
-        super();
-        this.message = message !== null && message !== void 0 ? message : this.message;
-        this.name = name !== null && name !== void 0 ? name : this.name;
-    }
-}
-function defineStringTag(targetFunc, stringTag) {
-    Object.defineProperty(targetFunc.prototype, Symbol.toStringTag, {
-        configurable: true,
-        value: stringTag,
-    });
-}
-function objectValues(obj) {
-    return Object.keys(obj).map(key => obj[key]);
-}
-function objectEntries(obj) {
-    return Object.keys(obj).map(key => [key, obj[key]]);
-}
 
+/** @type {typeof globalThis.TextEncoder} */
 class TextEncoderP {
     get encoding() { return "utf-8"; }
     encode(input = "") {
-        return encodeText(input).encoded;
+        let _input = "" + input;
+        return encodeText(_input).encoded;
     }
-    encodeInto(source, destination) {
-        let result = encodeText(source, destination);
+    encodeInto(...args) {
+        const [source, destination] = args;
+        checkArgsLength(args, 2, "TextEncoder", "encodeInto");
+        let _source = "" + source;
+        if (!(destination instanceof Uint8Array)) {
+            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 };
     }
-    toString() { return "[object TextEncoder]"; }
-    get isPolyfill() { return { symbol: polyfill, hierarchy: ["TextEncoder"] }; }
+    /** @internal */ toString() { return "[object TextEncoder]"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["TextEncoder"] }; }
 }
-defineStringTag(TextEncoderP, "TextEncoder");
+Class_setStringTag(TextEncoderP, "TextEncoder");
 function encodeText(input, destination) {
     const HAS_DESTINATION = typeof destination !== "undefined";
     let pos = 0;
@@ -64,26 +79,34 @@ function encodeText(input, destination) {
     let tlen = Math.max(32, len + (len >> 1) + 7); // 1.5x size
     let target = HAS_DESTINATION ? destination : new Uint8Array((tlen >> 3) << 3); // ... but at 8 byte offset
     while (pos < len) {
-        let value = input.charCodeAt(pos++);
+        let value = input.charCodeAt(pos);
+        let codeUnitCount = 1;
         if (value >= 0xd800 && value <= 0xdbff) {
             // high surrogate
-            if (pos < len) {
-                let extra = input.charCodeAt(pos);
+            if (pos + 1 < len) {
+                let extra = input.charCodeAt(pos + 1);
                 if ((extra & 0xfc00) === 0xdc00) {
-                    ++pos;
+                    codeUnitCount = 2;
+                    pos += 2;
                     value = ((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000;
                 }
                 else {
+                    pos += 1;
                     value = 0xfffd;
                 }
             }
             else {
+                pos += 1;
                 value = 0xfffd;
             }
         }
         else if (value >= 0xdc00 && value <= 0xdfff) {
+            pos += 1;
             value = 0xfffd;
         }
+        else {
+            pos += 1;
+        }
         // expand the buffer if we couldn't write 4 bytes
         if (!HAS_DESTINATION && at + 4 > target.length) {
             tlen += 8; // minimum extra
@@ -113,28 +136,30 @@ function encodeText(input, destination) {
         if (HAS_DESTINATION && at + byteCount > target.length) {
             break;
         }
-        if (byteCount === 1) { // 1-byte
-            target[at++] = value; // ASCII
-        }
-        else if (byteCount === 2) { // 2-byte
-            target[at++] = ((value >> 6) & 0x1f) | 0xc0;
-            target[at++] = (value & 0x3f) | 0x80;
-        }
-        else if (byteCount === 3) { // 3-byte
-            target[at++] = ((value >> 12) & 0x0f) | 0xe0;
-            target[at++] = ((value >> 6) & 0x3f) | 0x80;
-            target[at++] = (value & 0x3f) | 0x80;
-        }
-        else if (byteCount === 4) { // 4-byte
-            target[at++] = ((value >> 18) & 0x07) | 0xf0;
-            target[at++] = ((value >> 12) & 0x3f) | 0x80;
-            target[at++] = ((value >> 6) & 0x3f) | 0x80;
-            target[at++] = (value & 0x3f) | 0x80;
-        }
-        read++;
+        switch (byteCount) {
+            case 1: // 1-byte
+                target[at++] = value; // ASCII
+                break;
+            case 2: // 2-byte
+                target[at++] = ((value >> 6) & 0x1f) | 0xc0;
+                target[at++] = (value & 0x3f) | 0x80;
+                break;
+            case 3: // 3-byte
+                target[at++] = ((value >> 12) & 0x0f) | 0xe0;
+                target[at++] = ((value >> 6) & 0x3f) | 0x80;
+                target[at++] = (value & 0x3f) | 0x80;
+                break;
+            case 4: // 4-byte
+                target[at++] = ((value >> 18) & 0x07) | 0xf0;
+                target[at++] = ((value >> 12) & 0x3f) | 0x80;
+                target[at++] = ((value >> 6) & 0x3f) | 0x80;
+                target[at++] = (value & 0x3f) | 0x80;
+                break;
+        }
+        read += codeUnitCount;
     }
     return {
-        encoded: !HAS_DESTINATION ? target.slice(0, at) : destination.slice(),
+        encoded: !HAS_DESTINATION ? target.slice(0, at) : destination,
         read: read,
         written: at,
     };
@@ -144,78 +169,83 @@ const TextEncoderE = g["TextEncoder"] || TextEncoderP;
 var _a$a, _b$3;
 /** @internal */
 const state$h = Symbol( /* "TextDecoderState" */);
+/** @type {typeof globalThis.TextDecoder} */
 class TextDecoderP {
-    constructor(utfLabel = "utf-8", { fatal = false, ignoreBOM = false } = {}) {
-        if (UTF8Labels.indexOf(utfLabel.toLowerCase()) === -1) {
-            throw new RangeError("TextDecoder: The encoding label provided ('" + utfLabel + "') is invalid.");
+    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$h].fatal = !!fatal;
+        this[state$h].ignoreBOM = !!ignoreBOM;
     }
     get encoding() { return "utf-8"; }
     get fatal() { return this[state$h].fatal; }
     get ignoreBOM() { return this[state$h].ignoreBOM; }
-    decode(buffer, { stream = false } = {}) {
-        const that = this[state$h];
-        let buf;
-        if (typeof buffer !== "undefined") {
-            if (buffer instanceof Uint8Array) {
-                buf = buffer;
+    decode(input, { stream = false } = {}) {
+        const s = this[state$h];
+        let bytes;
+        if (input !== undefined) {
+            if (input instanceof ArrayBuffer) {
+                bytes = new Uint8Array(input);
+            }
+            else if (input instanceof Uint8Array) {
+                bytes = input;
             }
-            else if (ArrayBuffer.isView(buffer)) {
-                buf = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+            else if (ArrayBuffer.isView(input)) {
+                bytes = new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
             }
             else {
-                buf = new Uint8Array(buffer);
+                throw new TypeError("Failed to execute 'decode' on 'TextDecoder': parameter 1 is not of type 'ArrayBuffer'.");
             }
         }
         else {
-            if (that[_partial].length > 0) {
+            if (s[_partial].length > 0) {
                 if (this.fatal) {
+                    s[_partial] = [];
                     throw new TypeError("TextDecoder: Incomplete UTF-8 sequence.");
                 }
-                else {
-                    that[_partial] = [];
-                }
             }
             return "";
         }
-        if (!that[_bomSeen] && this.ignoreBOM && buf.length >= 3) {
-            if (buf[0] === 0xef && buf[1] === 0xbb && buf[2] === 0xbf) {
-                buf = buf.subarray(3);
-                that[_bomSeen] = true;
+        if (s[_bomDone] < 3) {
+            s[_bomDone] += bytes.length;
+            if (bytes.length >= 3) {
+                if (bytes[0] === 0xef && bytes[1] === 0xbb && bytes[2] === 0xbf) {
+                    bytes = bytes.subarray(3); // × WeChat 2.5.0
+                }
             }
         }
-        if (that[_partial].length > 0) {
-            let merged = new Uint8Array(that[_partial].length + buf.length);
-            merged.set(that[_partial], 0);
-            merged.set(buf, that[_partial].length);
-            buf = merged;
-            that[_partial] = [];
+        if (s[_partial].length > 0) {
+            let merged = new Uint8Array(s[_partial].length + bytes.length);
+            merged.set(s[_partial], 0);
+            merged.set(bytes, s[_partial].length);
+            bytes = merged;
+            s[_partial] = [];
         }
-        let end = buf.length;
+        let end = bytes.length;
         let res = [];
-        if (stream && buf.length > 0) {
-            let i = buf.length;
-            while (i > 0 && i > buf.length - 4) {
-                let byte = buf[i - 1];
+        if (stream && bytes.length > 0) {
+            let i = bytes.length;
+            while (i > 0 && i > bytes.length - 4) {
+                let byte = bytes[i - 1];
                 if ((byte & 0b11000000) !== 0b10000000) {
                     let len = getBytesPerSequence(byte);
-                    if (len > buf.length - (i - 1)) {
+                    if (len > bytes.length - (i - 1)) {
                         end = i - 1;
                     }
                     break;
                 }
                 i--;
             }
-            that[_partial] = Array.from(buf.slice(end)); // save tail
-            buf = buf.slice(0, end);
+            s[_partial] = Array.from(bytes.slice(end)); // save tail        // × WeChat 2.5.0
+            bytes = bytes.slice(0, end); // × WeChat 2.5.0
         }
         let i = 0;
         while (i < end) {
-            let firstByte = buf[i];
             let codePoint = null;
+            let firstByte = bytes[i];
             let bytesPerSequence = getBytesPerSequence(firstByte);
             if (i + bytesPerSequence <= end) {
                 let secondByte, thirdByte, fourthByte, tempCodePoint;
@@ -226,7 +256,7 @@ class TextDecoderP {
                         }
                         break;
                     case 2:
-                        secondByte = buf[i + 1];
+                        secondByte = bytes[i + 1];
                         if ((secondByte & 0xC0) === 0x80) {
                             tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F);
                             if (tempCodePoint > 0x7F) {
@@ -235,8 +265,8 @@ class TextDecoderP {
                         }
                         break;
                     case 3:
-                        secondByte = buf[i + 1];
-                        thirdByte = buf[i + 2];
+                        secondByte = bytes[i + 1];
+                        thirdByte = bytes[i + 2];
                         if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
                             tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F);
                             if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
@@ -245,27 +275,31 @@ class TextDecoderP {
                         }
                         break;
                     case 4:
-                        secondByte = buf[i + 1];
-                        thirdByte = buf[i + 2];
-                        fourthByte = buf[i + 3];
+                        secondByte = bytes[i + 1];
+                        thirdByte = bytes[i + 2];
+                        fourthByte = bytes[i + 3];
                         if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
                             tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F);
                             if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
                                 codePoint = tempCodePoint;
                             }
                         }
+                        break;
                 }
             }
             if (codePoint === null) {
                 if (this.fatal) {
+                    s[_partial] = [];
                     throw new TypeError("TextDecoder.decode: Decoding failed.");
                 }
-                else {
-                    // we did not generate a valid codePoint so insert a
-                    // replacement char (U+FFFD) and advance only 1 byte
-                    codePoint = 0xFFFD;
-                    bytesPerSequence = 1;
+                let skip = 1;
+                while (i + skip < end && (bytes[i + skip] & 0b11000000) === 0b10000000) {
+                    skip += 1;
                 }
+                // we did not generate a valid codePoint so insert a replacement char (U+FFFD)
+                res.push(0xFFFD);
+                i += skip;
+                continue;
             }
             else if (codePoint > 0xFFFF) {
                 // encode to utf16 (surrogate pair dance)
@@ -276,101 +310,262 @@ class TextDecoderP {
             res.push(codePoint);
             i += bytesPerSequence;
         }
-        let str = "";
-        for (let j = 0, len = res.length; j < len; j += 0x1000) {
-            str += String.fromCharCode.apply(String, res.slice(j, j + 0x1000));
-        }
-        return str;
+        return res.length > 0x4000 ? buildString(res) : concatString(res);
     }
-    toString() { return "[object TextDecoder]"; }
-    get isPolyfill() { return { symbol: polyfill, hierarchy: ["TextDecoder"] }; }
+    /** @internal */ toString() { return "[object TextDecoder]"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["TextDecoder"] }; }
 }
-defineStringTag(TextDecoderP, "TextDecoder");
-/** @internal */ const _bomSeen = Symbol();
+Class_setStringTag(TextDecoderP, "TextDecoder");
+/** @internal */ const _bomDone = Symbol();
 /** @internal */ const _partial = Symbol();
 /** @internal */
 class TextDecoderState {
     constructor() {
         this.fatal = false;
         this.ignoreBOM = false;
-        this[_a$a] = false;
+        this[_a$a] = 0;
         this[_b$3] = [];
     }
 }
-_a$a = _bomSeen, _b$3 = _partial;
-const UTF8Labels = ["utf-8", "utf8", "unicode-1-1-utf-8"];
+_a$a = _bomDone, _b$3 = _partial;
 function getBytesPerSequence(byte) {
     return (byte > 0xEF) ? 4 : (byte > 0xDF) ? 3 : (byte > 0xBF) ? 2 : 1;
 }
+const buildString = (res) => {
+    let arr = [];
+    for (let i = 0, len = res.length; i < len; i += 0x1000) {
+        arr.push(String.fromCharCode.apply(String, res.slice(i, i + 0x1000)));
+    }
+    return arr.join("");
+};
+const concatString = (res) => {
+    let str = "";
+    for (let i = 0, len = res.length; i < len; i += 0x1000) {
+        str += String.fromCharCode.apply(String, res.slice(i, i + 0x1000));
+    }
+    return str;
+};
 const TextDecoderE = g["TextDecoder"] || TextDecoderP;
 
-var _a$9, _b$2, _c$1, _d$1, _e$1, _f$1;
 /** @internal */
-const state$g = Symbol( /* "EventState" */);
+const state$g = Symbol( /* "BlobState" */);
+/** @type {typeof globalThis.Blob} */
+class BlobP {
+    constructor(blobParts = [], options) {
+        if (!(Array.isArray(blobParts) || (blobParts && typeof blobParts === "object" && Symbol.iterator in blobParts))) {
+            throw new TypeError("Failed to construct 'Blob/File': The provided value cannot be converted to a sequence.");
+        }
+        let _blobParts = Array.isArray(blobParts) ? blobParts : Array.from(blobParts);
+        let chunks = [];
+        for (let i = 0; i < _blobParts.length; ++i) {
+            let chunk = _blobParts[i];
+            if (isPolyfillType("Blob", chunk)) {
+                chunks.push(chunk[state$g][_buffer]);
+            }
+            else if (chunk instanceof ArrayBuffer || 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];
+        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; }
+    arrayBuffer() {
+        return Promise.resolve(clone(this[state$g][_buffer].buffer).buffer);
+    }
+    bytes() {
+        return Promise.resolve(clone(this[state$g][_buffer].buffer));
+    }
+    slice(start, end, contentType) {
+        let sliced = this[state$g][_buffer].slice(start !== null && start !== void 0 ? start : 0, end !== null && end !== void 0 ? end : this[state$g][_buffer].length); // × 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]));
+    }
+    /** @internal */ toString() { return "[object Blob]"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["Blob"] }; }
+}
+Class_setStringTag(BlobP, "Blob");
+/** @internal */
+const _buffer = Symbol();
+/** @internal */
+class BlobState {
+    constructor(buffer) {
+        this.size = 0;
+        this.type = "";
+        this[_buffer] = buffer;
+    }
+}
+/** @internal */
+function Blob_toUint8Array(blob) {
+    return blob[state$g][_buffer];
+}
+function BufferSource_toUint8Array(buf) {
+    return buf instanceof ArrayBuffer
+        ? new Uint8Array(buf)
+        : new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+}
+function clone(buf) {
+    let sourceArray = BufferSource_toUint8Array(buf);
+    let cloneArray = new Uint8Array(new ArrayBuffer(sourceArray.byteLength));
+    cloneArray.set(sourceArray);
+    return cloneArray;
+}
+function concat(chunks) {
+    let totalByteLength = chunks.reduce((acc, cur) => acc + cur.byteLength, 0);
+    let result = new Uint8Array(totalByteLength);
+    chunks.reduce((offset, chunk) => {
+        result.set(chunk, offset);
+        return offset + chunk.byteLength;
+    }, 0);
+    return result;
+}
+/** @internal */
+function encode$1(str) {
+    let encoder = new TextEncoderP();
+    return encoder.encode(str);
+}
+/** @internal */
+function decode$1(buf) {
+    let decoder = new TextDecoderP();
+    return decoder.decode(buf);
+}
+/** @internal */
+function Uint8Array_toBase64(input) {
+    let byteToCharMap = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+    let output = [];
+    for (var i = 0; i < input.length; i += 3) {
+        let byte1 = input[i];
+        let haveByte2 = i + 1 < input.length;
+        let byte2 = haveByte2 ? input[i + 1] : 0;
+        let haveByte3 = i + 2 < input.length;
+        let byte3 = haveByte3 ? input[i + 2] : 0;
+        let outByte1 = byte1 >> 2;
+        let outByte2 = ((byte1 & 0x03) << 4) | (byte2 >> 4);
+        let outByte3 = ((byte2 & 0x0F) << 2) | (byte3 >> 6);
+        let outByte4 = byte3 & 0x3F;
+        if (!haveByte3) {
+            outByte4 = 64;
+            if (!haveByte2) {
+                outByte3 = 64;
+            }
+        }
+        output.push(byteToCharMap[outByte1], byteToCharMap[outByte2], byteToCharMap[outByte3], byteToCharMap[outByte4]);
+    }
+    return output.join("");
+}
+const BlobE = g["Blob"] || BlobP;
+
+/** @internal */
+const state$f = Symbol( /* "FileState" */);
+/** @type {typeof globalThis.File} */
+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;
+    }
+    get lastModified() { return this[state$f].lastModified; }
+    get name() { return this[state$f].name; }
+    get webkitRelativePath() { return ""; }
+    /** @internal */ toString() { return "[object File]"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["File", "Blob"] }; }
+}
+Class_setStringTag(FileP, "File");
+/** @internal */
+class FileState {
+    constructor() {
+        this.lastModified = 0;
+        this.name = "";
+    }
+}
+const FileE = g["Blob"] ? g["File"] : FileP;
+
+var _a$9, _b$2, _c$1, _d$1, _e$1;
+/** @internal */ const state$e = Symbol( /* "EventState" */);
+/** @type {typeof globalThis.Event} */
 class EventP {
-    constructor(type, eventInitDict) {
-        this[state$g] = new EventState();
-        const that = this[state$g];
-        that.type = String(type);
-        that.bubbles = !!(eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.bubbles);
-        that.cancelable = !!(eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.cancelable);
-        that.composed = !!(eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.composed);
+    constructor(...args) {
+        const [type, eventInitDict] = args;
+        checkArgsLength(args, 1, new.target.name);
+        this[state$e] = new EventState();
+        const s = this[state$e];
+        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$g][_isTrusted]; }).bind(this),
+            get: (function isTrusted() { return this[state$e][_isTrusted]; }).bind(this),
         });
     }
-    get type() { return this[state$g].type; }
-    get bubbles() { return this[state$g].bubbles; }
-    get cancelable() { return this[state$g].cancelable; }
-    get composed() { return this[state$g].composed; }
-    get target() { return this[state$g].target; }
-    get currentTarget() { return this[state$g].currentTarget; }
-    get eventPhase() { return this[state$g].eventPhase; }
-    get srcElement() { return this[state$g].target; }
-    get cancelBubble() { return this[state$g].cancelBubble; }
-    set cancelBubble(value) { this[state$g].cancelBubble = value; }
-    get defaultPrevented() { return this[state$g].defaultPrevented; }
-    get returnValue() { return this[state$g].returnValue; }
+    get type() { return this[state$e].type; }
+    get bubbles() { return this[state$e].bubbles; }
+    get cancelable() { return this[state$e].cancelable; }
+    get composed() { return this[state$e].composed; }
+    get target() { return this[state$e].target; }
+    get currentTarget() { return this[state$e].currentTarget; }
+    get eventPhase() { return this[state$e].eventPhase; }
+    get srcElement() { return this[state$e].target; }
+    get cancelBubble() { return this[state$e].cancelBubble; }
+    set cancelBubble(value) { this[state$e].cancelBubble = !!value; }
+    get defaultPrevented() { return this[state$e].defaultPrevented; }
+    get returnValue() { return this[state$e].returnValue; }
     set returnValue(value) { if (!value) {
         this.preventDefault();
     } }
-    get timeStamp() { return this[state$g].timeStamp; }
+    get timeStamp() { return this[state$e].timeStamp; }
     composedPath() {
         let path = !!this.target ? [this.target] : [];
         if (!!this.currentTarget && this.currentTarget !== this.target)
             path.push(this.currentTarget);
         return path;
     }
-    initEvent(type, bubbles, cancelable) {
-        const that = this[state$g];
-        if (that[_dispatched])
+    initEvent(...args) {
+        const [type, bubbles, cancelable] = args;
+        checkArgsLength(args, 1, "Event", "initEvent");
+        const s = this[state$e];
+        if (s[_dispatched])
             return;
-        that.type = String(type);
-        that.bubbles = !!bubbles;
-        that.cancelable = !!cancelable;
+        s.type = "" + type;
+        s.bubbles = !!bubbles;
+        s.cancelable = !!cancelable;
     }
     preventDefault() {
-        const that = this[state$g];
-        if (that[_passive]) {
+        const s = this[state$e];
+        if (s[_passive]) {
             console.warn(`Ignoring 'preventDefault()' call on event of type '${this.type}' from a listener registered as 'passive'.`);
             return;
         }
         if (this.cancelable) {
-            that[_preventDefaultCalled] = true;
-            that.defaultPrevented = true;
-            that.returnValue = false;
+            s[_preventDefaultCalled] = true;
+            s.defaultPrevented = true;
+            s.returnValue = false;
         }
     }
     stopImmediatePropagation() {
-        this[state$g][_stopImmediatePropagationCalled] = true;
+        this[state$e][_stopImmediatePropagationCalled] = true;
         this.cancelBubble = true;
     }
     stopPropagation() {
         this.cancelBubble = true;
     }
-    toString() { return "[object Event]"; }
-    get isPolyfill() { return { symbol: polyfill, hierarchy: ["Event"] }; }
+    /** @internal */ toString() { return "[object Event]"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["Event"] }; }
 }
 const properties$2 = {
     NONE: { value: 0, enumerable: true },
@@ -380,13 +575,13 @@ const properties$2 = {
 };
 Object.defineProperties(EventP, properties$2);
 Object.defineProperties(EventP.prototype, properties$2);
-defineStringTag(EventP, "Event");
-/** @internal */ const _TimeStamp = Symbol();
-const _isTrusted = Symbol();
-const _passive = Symbol();
-const _dispatched = Symbol();
-const _preventDefaultCalled = Symbol();
-const _stopImmediatePropagationCalled = Symbol();
+Class_setStringTag(EventP, "Event");
+/** @internal */ const _timeStamp = (new Date()).getTime();
+/** @internal */ const _isTrusted = Symbol();
+/** @internal */ const _passive = Symbol();
+/** @internal */ const _dispatched = Symbol();
+/** @internal */ const _preventDefaultCalled = Symbol();
+/** @internal */ const _stopImmediatePropagationCalled = Symbol();
 /** @internal */
 class EventState {
     constructor() {
@@ -400,139 +595,202 @@ class EventState {
         this.cancelBubble = false;
         this.defaultPrevented = false;
         this.returnValue = true;
-        this.timeStamp = (new Date()).getTime() - EventState[_TimeStamp];
+        this.timeStamp = (new Date()).getTime() - _timeStamp;
+        this[_a$9] = false;
         this[_b$2] = false;
         this[_c$1] = false;
         this[_d$1] = false;
         this[_e$1] = false;
-        this[_f$1] = false;
     }
 }
-_a$9 = _TimeStamp, _b$2 = _isTrusted, _c$1 = _passive, _d$1 = _dispatched, _e$1 = _preventDefaultCalled, _f$1 = _stopImmediatePropagationCalled;
-EventState[_a$9] = (new Date()).getTime();
+_a$9 = _isTrusted, _b$2 = _passive, _c$1 = _dispatched, _d$1 = _preventDefaultCalled, _e$1 = _stopImmediatePropagationCalled;
+/** @internal */
+function Event_setTrusted(event, isTrusted) {
+    Object.defineProperty(event[state$e], _isTrusted, {
+        value: isTrusted,
+        writable: true,
+        enumerable: true,
+        configurable: true,
+    });
+}
+const passive$1 = 0;
+const dispatched$2 = 1;
+const preventDefaultCalled$1 = 2;
+const stopImmediatePropagationCalled$1 = 3;
+/** @internal */
+function Event_getEtField(event, field) {
+    const s = event[state$e];
+    switch (field) {
+        case passive$1:
+            return s[_passive];
+        case dispatched$2:
+            return s[_dispatched];
+        case preventDefaultCalled$1:
+            return s[_preventDefaultCalled];
+        case stopImmediatePropagationCalled$1:
+            return s[_stopImmediatePropagationCalled];
+    }
+}
+/** @internal */
+function Event_setEtField(event, field, value) {
+    const s = event[state$e];
+    switch (field) {
+        case passive$1:
+            s[_passive] = value;
+            break;
+        case dispatched$2:
+            s[_dispatched] = value;
+            break;
+        case preventDefaultCalled$1:
+            s[_preventDefaultCalled] = value;
+            break;
+        case stopImmediatePropagationCalled$1:
+            s[_stopImmediatePropagationCalled] = value;
+            break;
+    }
+}
+/** @internal */
 function createInnerEvent(target, type, eventInitDict, isTrusted = true) {
     let event = new EventP(type, eventInitDict);
-    event[state$g].target = target;
-    event[state$g][_isTrusted] = isTrusted;
+    event[state$e].target = target;
+    event[state$e][_isTrusted] = isTrusted;
     return event;
 }
 const EventE = g["EventTarget"] ? g["Event"] : EventP;
 
 var _a$8;
-/** @internal */
-const state$f = Symbol( /* "EventTargetState" */);
+const passive = 0;
+const dispatched$1 = 1;
+const preventDefaultCalled = 2;
+const stopImmediatePropagationCalled = 3;
+/** @internal */ const state$d = Symbol( /* "EventTargetState" */);
+/** @type {typeof globalThis.EventTarget} */
 class EventTargetP {
     constructor() {
-        this[state$f] = new EventTargetState(this);
+        this[state$d] = new EventTargetState(this);
+        this[state$d].name = new.target.name;
     }
-    addEventListener(type, callback, options) {
-        const that = this[state$f];
+    addEventListener(...args) {
+        const [type, callback, options] = args;
+        checkArgsLength(args, 2, this[state$d].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'.`);
+        }
+        const s = this[state$d];
         const executor = new Executor(type, callback);
         executor.options.capture = typeof options === "boolean" ? options : !!(options === null || options === void 0 ? void 0 : options.capture);
-        if (!that[_executors].some(x => x.equals(executor))) {
-            if (typeof options === "object") {
+        if (!s[_executors].some(x => x.equals(executor))) {
+            if (options && typeof options === "object") {
                 const { once, passive, signal } = options;
                 executor.options.once = !!once;
                 executor.options.passive = !!passive;
                 if (signal) {
                     executor.options.signal = signal;
-                    reply.call(that, signal, executor);
+                    reply(this, signal, executor);
                 }
             }
-            that[_executors].push(executor);
+            s[_executors].push(executor);
             const f = (v) => !!v.options.capture ? 0 : 1;
-            that[_executors] = that[_executors].sort((a, b) => f(a) - f(b));
+            s[_executors] = s[_executors].sort((a, b) => f(a) - f(b));
         }
     }
-    dispatchEvent(event) {
-        if (typeof event !== "object") {
-            throw new TypeError("EventTarget.dispatchEvent: Argument 1 is not an object.");
-        }
+    dispatchEvent(...args) {
+        const [event] = args;
+        checkArgsLength(args, 1, this[state$d].name, "dispatchEvent");
         if (!(event instanceof EventP)) {
-            throw new TypeError("EventTarget.dispatchEvent: Argument 1 does not implement interface Event.");
+            throw new TypeError(`Failed to execute 'dispatchEvent' on '${this[state$d].name}': parameter 1 is not of type 'Event'.`);
         }
-        event[state$g].target = this;
-        Object.defineProperty(event[state$g], _isTrusted, { value: false, configurable: true, enumerable: true, writable: true });
-        return fire.call(this[state$f], event);
+        Event_setTrusted(event, false);
+        event[state$e].target = this;
+        return EventTarget_fire(this, event);
     }
-    removeEventListener(type, callback, options) {
-        const that = this[state$f];
+    removeEventListener(...args) {
+        const [type, callback, options] = args;
+        checkArgsLength(args, 2, this[state$d].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'.`);
+        }
+        const s = this[state$d];
         const executor = new Executor(type, callback);
         executor.options.capture = typeof options === "boolean" ? options : !!(options === null || options === void 0 ? void 0 : options.capture);
-        if (that[_executors].some(x => x.equals(executor))) {
-            that[_executors] = that[_executors].filter(x => !x.equals(executor));
+        if (s[_executors].some(x => x.equals(executor))) {
+            s[_executors] = s[_executors].filter(x => !x.equals(executor));
         }
     }
-    toString() { return "[object EventTarget]"; }
-    get isPolyfill() { return { symbol: polyfill, hierarchy: ["EventTarget"] }; }
+    /** @internal */ toString() { return "[object EventTarget]"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["EventTarget"] }; }
 }
-defineStringTag(EventTargetP, "EventTarget");
+Class_setStringTag(EventTargetP, "EventTarget");
 /** @internal */
 const _executors = Symbol();
 /** @internal */
 class EventTargetState {
     constructor(target) {
+        this.name = "EventTarget";
         this[_a$8] = [];
         this.target = target;
     }
 }
 _a$8 = _executors;
-function fire(event) {
-    const s = event[state$g];
+/** @internal */
+function EventTarget_fire(target, event) {
+    const s = target[state$d];
+    const evs = event[state$e];
     if (!event.target)
-        s.target = this.target;
-    s.currentTarget = this.target;
-    s.eventPhase = EventP.AT_TARGET;
-    s[_dispatched] = true;
+        evs.target = target;
+    evs.currentTarget = target;
+    evs.eventPhase = EventP.AT_TARGET;
+    Event_setEtField(event, dispatched$1, true);
     let onceIndexes = [];
-    for (let i = 0; i < this[_executors].length; ++i) {
-        let executor = this[_executors][i];
+    for (let i = 0; i < s[_executors].length; ++i) {
+        if (Event_getEtField(event, stopImmediatePropagationCalled))
+            break;
+        let executor = s[_executors][i];
         if (executor.type !== event.type)
             continue;
-        s[_passive] = !!executor.options.passive;
         if (executor.options.once)
             onceIndexes.push(i);
-        let { callback: cb } = executor;
+        Event_setEtField(event, passive, !!executor.options.passive);
         try {
+            let cb = executor.callback;
             if (typeof cb === "function")
-                cb.call(this.target, event);
+                cb.call(target, event);
         }
         catch (e) {
             console.error(e);
         }
-        s[_passive] = false;
-        if (s[_stopImmediatePropagationCalled])
-            break;
+        Event_setEtField(event, passive, false);
     }
     if (onceIndexes.length > 0) {
-        this[_executors] = this[_executors].reduce((acc, cur, index) => {
+        s[_executors] = s[_executors].reduce((acc, cur, index) => {
             if (onceIndexes.indexOf(index) === -1)
                 acc.push(cur);
             return acc;
         }, []);
     }
-    s.currentTarget = null;
-    s.eventPhase = EventP.NONE;
-    s[_dispatched] = false;
-    return !(event.cancelable && s[_preventDefaultCalled]);
+    evs.currentTarget = null;
+    evs.eventPhase = EventP.NONE;
+    Event_setEtField(event, dispatched$1, false);
+    return !(event.cancelable && Event_getEtField(event, preventDefaultCalled));
 }
-function reply(signal, executor) {
+function reply(target, signal, executor) {
+    const s = target[state$d];
     const onAbort = () => {
-        this[_executors] = this[_executors].filter(x => !x.equals(executor));
+        s[_executors] = s[_executors].filter(x => !x.equals(executor));
         signal.removeEventListener("abort", onAbort);
     };
     try {
         signal.addEventListener("abort", onAbort);
     }
     catch (e) {
-        console.error(e);
+        console.warn(e);
     }
 }
 /** @internal */
 class Executor {
     constructor(type, callback) {
         this.options = {};
-        this.type = String(type);
+        this.type = "" + type;
         this.callback = extract(callback);
     }
     equals(executor) {
@@ -554,64 +812,52 @@ function extract(cb) {
 function isEventListenerObject(cb) {
     return !!cb && "handleEvent" in cb && typeof cb.handleEvent === "function";
 }
-function attachFn(type, cb, listener) {
+/** @internal */
+function attachFn(target, type, cb, listener) {
     if (typeof cb === "function") {
-        this.addEventListener(type, listener);
+        target.addEventListener(type, listener);
     }
     else {
-        this.removeEventListener(type, listener);
+        target.removeEventListener(type, listener);
     }
 }
-function executeFn(cb, ev) {
+/** @internal */
+function executeFn(target, cb, ev) {
     if (typeof cb === "function")
-        cb.call(this, ev);
+        cb.call(target, ev);
 }
 const EventTargetE = g["EventTarget"] || EventTargetP;
 
 /** @internal */
-const state$e = Symbol( /* "CustomEventState" */);
-class CustomEventP extends EventP {
-    constructor(type, eventInitDict) {
-        var _a;
-        super(type, eventInitDict);
-        this[state$e] = new CustomEventState();
-        this[state$e].detail = (_a = eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.detail) !== null && _a !== void 0 ? _a : null;
-    }
-    get detail() { return this[state$e].detail; }
-    initCustomEvent(type, bubbles, cancelable, detail) {
-        if (this[state$g][_dispatched])
-            return;
-        this.initEvent(type, bubbles, cancelable);
-        this[state$e].detail = detail !== null && detail !== void 0 ? detail : null;
-    }
-    toString() { return "[object CustomEvent]"; }
-    get isPolyfill() { return { symbol: polyfill, hierarchy: ["CustomEvent", "Event"] }; }
-}
-defineStringTag(CustomEventP, "CustomEvent");
-/** @internal */
-class CustomEventState {
-}
-const CustomEventE = g["EventTarget"] ? g["CustomEvent"] : CustomEventP;
-
-/** @internal */
-const state$d = Symbol( /* "ProgressEventState" */);
+const state$c = Symbol( /* "ProgressEventState" */);
+/** @type {typeof globalThis.ProgressEvent} */
 class ProgressEventP extends EventP {
     constructor(type, eventInitDict) {
         var _a, _b;
         super(type, eventInitDict);
-        this[state$d] = new ProgressEventState();
-        const that = this[state$d];
-        that.lengthComputable = !!(eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.lengthComputable);
-        that.loaded = (_a = eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.loaded) !== null && _a !== void 0 ? _a : 0;
-        that.total = (_b = eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.total) !== null && _b !== void 0 ? _b : 0;
+        this[state$c] = new ProgressEventState();
+        const s = this[state$c];
+        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);
+        let errField = "";
+        if (isNaN(s.loaded)) {
+            errField = "loaded";
+        }
+        if (isNaN(s.total)) {
+            errField = "total";
+        }
+        if (errField) {
+            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$d].lengthComputable); }
-    get loaded() { return getValue(this[state$d].loaded); }
-    get total() { return getValue(this[state$d].total); }
-    toString() { return "[object ProgressEvent]"; }
-    get isPolyfill() { return { symbol: polyfill, hierarchy: ["ProgressEvent", "Event"] }; }
+    get lengthComputable() { return getValue(this[state$c].lengthComputable); }
+    get loaded() { return getValue(this[state$c].loaded); }
+    get total() { return getValue(this[state$c].total); }
+    /** @internal */ toString() { return "[object ProgressEvent]"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["ProgressEvent", "Event"] }; }
 }
-defineStringTag(ProgressEventP, "ProgressEvent");
+Class_setStringTag(ProgressEventP, "ProgressEvent");
 /** @internal */
 class ProgressEventState {
     constructor() {
@@ -625,356 +871,511 @@ function getValue(val) {
 }
 function createInnerProgressEvent(target, type, { lengthComputable = false, loaded = 0, total = 0, } = {}) {
     let event = new ProgressEventP(type);
-    event[state$d].lengthComputable = lengthComputable;
-    event[state$d].loaded = loaded;
-    event[state$d].total = total;
-    event[state$g].target = target;
-    event[state$g][_isTrusted] = true;
+    event[state$c].lengthComputable = lengthComputable;
+    event[state$c].loaded = loaded;
+    event[state$c].total = total;
+    event[state$e].target = target;
+    Event_setTrusted(event, true);
     return event;
 }
+/** @internal */
 function emitProcessEvent(target, type, loaded = 0, total = 0) {
     let event = createInnerProgressEvent(target, type, {
         lengthComputable: () => { return getValue(total) > 0; },
         loaded,
         total,
     });
-    fire.call(target[state$f], event);
+    EventTarget_fire(target, event);
 }
 const ProgressEventE = g["EventTarget"] ? g["ProgressEvent"] : ProgressEventP;
 
+var _a$7;
 /** @internal */
-const state$c = Symbol( /* "BlobState" */);
-class BlobP {
-    constructor(blobParts = [], options) {
-        if (!Array.isArray(blobParts)) {
-            throw new TypeError("First argument to Blob constructor must be an Array.");
+const state$b = Symbol( /* "FileReaderState" */);
+/** @type {typeof globalThis.FileReader} */
+class FileReaderP extends EventTargetP {
+    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; }
+    abort() {
+        if (this.readyState === FileReaderP.LOADING) {
+            const s = this[state$b];
+            s.readyState = FileReaderP.DONE;
+            s.result = null;
+            s.error = new MPException("An ongoing operation was aborted, typically with a call to abort().", "AbortError");
+            emitProcessEvent(this, "abort");
         }
-        let encoder = null;
-        let chunks = blobParts.reduce((chunks, part) => {
-            if (isPolyfillType("Blob", part)) {
-                chunks.push(part[state$c][_u8array]);
-            }
-            else if (part instanceof ArrayBuffer || ArrayBuffer.isView(part)) {
-                chunks.push(convert$1(part));
-            }
-            else {
-                if (!encoder) {
-                    encoder = new TextEncoderP();
-                }
-                chunks.push(encoder.encode(String(part)));
-            }
-            return chunks;
-        }, []);
-        this[state$c] = new BlobState(concat(chunks));
-        const that = this[state$c];
-        that.size = that[_u8array].length;
-        let rawType = (options === null || options === void 0 ? void 0 : options.type) || "";
-        that.type = /[^\u0020-\u007E]/.test(rawType) ? "" : rawType.toLowerCase();
-    }
-    get size() { return this[state$c].size; }
-    get type() { return this[state$c].type; }
-    arrayBuffer() {
-        return Promise.resolve(clone(this[state$c][_u8array].buffer).buffer);
     }
-    bytes() {
-        return Promise.resolve(clone(this[state$c][_u8array].buffer));
+    readAsArrayBuffer(...args) {
+        read$1(this, "readAsArrayBuffer", args, blob => {
+            this[state$b].result = Blob_toUint8Array(blob).buffer.slice(0);
+        });
     }
-    slice(start, end, contentType) {
-        let sliced = this[state$c][_u8array].slice(start !== null && start !== void 0 ? start : 0, end !== null && end !== void 0 ? end : this[state$c][_u8array].length);
-        return new BlobP([sliced], { type: contentType !== null && contentType !== void 0 ? contentType : "" });
+    readAsBinaryString(...args) {
+        read$1(this, "readAsBinaryString", args, blob => {
+            let str = [];
+            let buf = Blob_toUint8Array(blob);
+            for (let i = 0; i < buf.length; ++i) {
+                let char = buf[i];
+                str.push(String.fromCharCode(char));
+            }
+            this[state$b].result = str.join("");
+        });
     }
-    stream() {
-        throw new ReferenceError("ReadableStream is not defined");
+    readAsDataURL(...args) {
+        read$1(this, "readAsDataURL", args, blob => {
+            this[state$b].result = "data:" + (blob.type || "application/octet-stream") + ";base64," + Uint8Array_toBase64(Blob_toUint8Array(blob));
+        });
     }
-    text() {
-        let decoder = new TextDecoderP();
-        return Promise.resolve(decoder.decode(this[state$c][_u8array]));
+    readAsText(...args) {
+        const encoding = args.length > 1 ? args[1] : undefined;
+        read$1(this, "readAsText", args, blob => {
+            if (encoding !== undefined) {
+                let _encoding = "" + encoding;
+                if (["utf-8", "utf8", "unicode-1-1-utf-8"].indexOf(_encoding.toLowerCase()) === -1) {
+                    console.error(`TypeError: Failed to execute 'readAsText' on 'FileReader': encoding ('${_encoding}') not implemented.`);
+                }
+            }
+            this[state$b].result = decode$1(Blob_toUint8Array(blob));
+        });
     }
-    toString() { return "[object Blob]"; }
-    get isPolyfill() { return { symbol: polyfill, hierarchy: ["Blob"] }; }
+    get onabort() { return this[state$b].onabort; }
+    set onabort(value) { this[state$b].onabort = value; attach$1(this, "abort"); }
+    get onerror() { return this[state$b].onerror; }
+    set onerror(value) { this[state$b].onerror = value; attach$1(this, "error"); }
+    get onload() { return this[state$b].onload; }
+    set onload(value) { this[state$b].onload = value; attach$1(this, "load"); }
+    get onloadend() { return this[state$b].onloadend; }
+    set onloadend(value) { this[state$b].onloadend = value; attach$1(this, "loadend"); }
+    get onloadstart() { return this[state$b].onloadstart; }
+    set onloadstart(value) { this[state$b].onloadstart = value; attach$1(this, "loadstart"); }
+    get onprogress() { return this[state$b].onprogress; }
+    set onprogress(value) { this[state$b].onprogress = value; attach$1(this, "progress"); }
+    /** @internal */ toString() { return "[object FileReader]"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["FileReader", "EventTarget"] }; }
 }
-defineStringTag(BlobP, "Blob");
+const properties$1 = {
+    EMPTY: { value: 0, enumerable: true },
+    LOADING: { value: 1, enumerable: true },
+    DONE: { value: 2, enumerable: true },
+};
+Object.defineProperties(FileReaderP, properties$1);
+Object.defineProperties(FileReaderP.prototype, properties$1);
+Class_setStringTag(FileReaderP, "FileReader");
 /** @internal */
-const _u8array = Symbol();
+const _handlers$3 = Symbol();
 /** @internal */
-class BlobState {
-    constructor(buffer) {
-        this.size = 0;
-        this.type = "";
-        this[_u8array] = buffer;
-    }
-    toUint8Array() {
-        return this[_u8array];
-    }
-    toArrayBuffer() {
-        return this[_u8array].buffer;
+class FileReaderState {
+    constructor(target) {
+        this.readyState = FileReaderP.EMPTY;
+        this.result = null;
+        this.error = null;
+        this[_a$7] = getHandlers$3(this);
+        this.onabort = null;
+        this.onerror = null;
+        this.onload = null;
+        this.onloadend = null;
+        this.onloadstart = null;
+        this.onprogress = null;
+        this.target = target;
     }
 }
-function u8array2base64(input) {
-    let byteToCharMap = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
-    let output = [];
-    for (var i = 0; i < input.length; i += 3) {
-        let byte1 = input[i];
-        let haveByte2 = i + 1 < input.length;
-        let byte2 = haveByte2 ? input[i + 1] : 0;
-        let haveByte3 = i + 2 < input.length;
-        let byte3 = haveByte3 ? input[i + 2] : 0;
-        let outByte1 = byte1 >> 2;
-        let outByte2 = ((byte1 & 0x03) << 4) | (byte2 >> 4);
-        let outByte3 = ((byte2 & 0x0F) << 2) | (byte3 >> 6);
-        let outByte4 = byte3 & 0x3F;
-        if (!haveByte3) {
-            outByte4 = 64;
-            if (!haveByte2) {
-                outByte3 = 64;
+_a$7 = _handlers$3;
+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];
+    s.error = null;
+    s.readyState = FileReaderP.LOADING;
+    emitProcessEvent(s.target, "loadstart", 0, blob.size);
+    setTimeout(() => {
+        if (s.readyState === FileReaderP.LOADING) {
+            s.readyState = FileReaderP.DONE;
+            try {
+                setResult(blob);
+                emitProcessEvent(s.target, "load", blob.size, blob.size);
+            }
+            catch (e) {
+                s.result = null;
+                s.error = e;
+                emitProcessEvent(s.target, "error", 0, blob.size);
             }
         }
-        output.push(byteToCharMap[outByte1], byteToCharMap[outByte2], byteToCharMap[outByte3], byteToCharMap[outByte4]);
-    }
-    return output.join("");
-}
-function convert$1(buf) {
-    return buf instanceof ArrayBuffer
-        ? new Uint8Array(buf)
-        : new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+        emitProcessEvent(s.target, "loadend", !!s.result ? blob.size : 0, blob.size);
+    });
 }
-function clone(buf) {
-    let sourceArray = convert$1(buf);
-    let cloneArray = new Uint8Array(new ArrayBuffer(sourceArray.byteLength));
-    cloneArray.set(sourceArray);
-    return cloneArray;
+function attach$1(reader, type) {
+    const s = reader[state$b];
+    const fnName = ("on" + type);
+    const cb = s[fnName];
+    const listener = s[_handlers$3][fnName];
+    attachFn(reader, type, cb, listener);
 }
-function concat(chunks) {
-    let totalByteLength = chunks.reduce((acc, cur) => acc + cur.byteLength, 0);
-    let result = new Uint8Array(totalByteLength);
-    chunks.reduce((offset, chunk) => {
-        result.set(chunk, offset);
-        return offset + chunk.byteLength;
-    }, 0);
-    return result;
+function getHandlers$3(s) {
+    return {
+        onabort: (ev) => { executeFn(s.target, s.onabort, ev); },
+        onerror: (ev) => { executeFn(s.target, s.onerror, ev); },
+        onload: (ev) => { executeFn(s.target, s.onload, ev); },
+        onloadend: (ev) => { executeFn(s.target, s.onloadend, ev); },
+        onloadstart: (ev) => { executeFn(s.target, s.onloadstart, ev); },
+        onprogress: (ev) => { executeFn(s.target, s.onprogress, ev); },
+    };
 }
-const BlobE = g["Blob"] || BlobP;
+const FileReaderE = g["Blob"] ? g["FileReader"] : FileReaderP;
 
-/** @internal */
-const state$b = Symbol( /* "FileState" */);
-class FileP extends BlobP {
-    constructor(fileBits, fileName, options) {
-        super(fileBits, options);
-        this[state$b] = new FileState();
-        this[state$b].lastModified = +((options === null || options === void 0 ? void 0 : options.lastModified) ? new Date(options.lastModified) : new Date());
-        this[state$b].name = fileName.replace(/\//g, ":");
+var _a$6;
+/** @internal */ const state$a = Symbol( /* "URLSearchParamsState" */);
+const checkArgsFn$2 = (args, required, funcName) => { checkArgsLength(args, required, "URLSearchParams", funcName); };
+/** @type {typeof globalThis.URLSearchParams} */
+class URLSearchParamsP {
+    constructor(init) {
+        this[state$a] = new URLSearchParamsState();
+        if (init !== undefined) {
+            if (isObjectType("URLSearchParams", init)) {
+                init.forEach((value, name) => { this.append(name, value); }, this);
+            }
+            else if (init && typeof init === "object") {
+                if (Array.isArray(init) || Symbol.iterator in init) {
+                    let _init = Array.isArray(init) ? init : Array.from(init);
+                    for (let i = 0; i < _init.length; ++i) {
+                        let item = _init[i];
+                        if (Array.isArray(item) || (item && typeof item === "object" && Symbol.iterator in item)) {
+                            let pair = Array.isArray(item) ? item : Array.from(item);
+                            if (pair.length === 2) {
+                                this.append(pair[0], pair[1]);
+                            }
+                            else {
+                                throw new TypeError("Failed to construct 'URLSearchParams': Sequence initializer must only contain pair elements");
+                            }
+                        }
+                        else {
+                            throw new TypeError("Failed to construct 'URLSearchParams': The provided value cannot be converted to a sequence.");
+                        }
+                    }
+                }
+                else {
+                    Object.getOwnPropertyNames(init).forEach(name => { this.append(name, init[name]); }, this);
+                }
+            }
+            else {
+                let _init = "" + init;
+                if (_init.indexOf("?") === 0) {
+                    _init = _init.slice(1);
+                }
+                let pairs = _init.split("&");
+                for (let i = 0; i < pairs.length; ++i) {
+                    let pair = pairs[i], separatorIndex = pair.indexOf("=");
+                    if (separatorIndex > -1) {
+                        this.append(decode(pair.slice(0, separatorIndex)), decode(pair.slice(separatorIndex + 1)));
+                    }
+                    else {
+                        if (pair) {
+                            this.append(decode(pair), "");
+                        }
+                    }
+                }
+            }
+        }
     }
-    get lastModified() { return this[state$b].lastModified; }
-    get name() { return this[state$b].name; }
-    get webkitRelativePath() { return ""; }
-    toString() { return "[object File]"; }
-    get isPolyfill() { return { symbol: polyfill, hierarchy: ["File", "Blob"] }; }
-}
-defineStringTag(FileP, "File");
-/** @internal */
-class FileState {
-    constructor() {
-        this.lastModified = 0;
-        this.name = "";
+    get size() { return this[state$a][_urlspArray].length; }
+    append(...args) {
+        const [name, value] = args;
+        checkArgsFn$2(args, 2, "append");
+        this[state$a][_urlspArray].push(["" + name, normalizeValue$1(value)]);
     }
-}
-const FileE = g["Blob"] ? g["File"] : FileP;
-
-var _a$7;
-/** @internal */
-const state$a = Symbol( /* "FileReaderState" */);
-class FileReaderP extends EventTargetP {
-    constructor() {
-        super();
-        this[state$a] = new FileReaderState(this);
+    delete(...args) {
+        const [name, value] = args;
+        checkArgsFn$2(args, 1, "delete");
+        let _name = "" + name;
+        let index = -1;
+        let array = this[state$a][_urlspArray];
+        let result = [];
+        for (let i = 0; i < array.length; ++i) {
+            let item = array[i];
+            if (item[0] === _name) {
+                if (args.length !== 1 && item[1] !== normalizeValue$1(value)) {
+                    result.push(item);
+                }
+                index = i;
+                continue;
+            }
+            result.push(item);
+        }
+        if (index > -1) {
+            this[state$a][_urlspArray] = result;
+        }
     }
-    get readyState() { return this[state$a].readyState; }
-    get result() { return this[state$a].result; }
-    get error() { return this[state$a].error; }
-    abort() {
-        if (this.readyState === FileReaderP.LOADING) {
-            this[state$a].readyState = FileReaderP.DONE;
-            this[state$a].result = null;
-            emitProcessEvent(this, "abort");
+    get(...args) {
+        const [name] = args;
+        checkArgsFn$2(args, 1, "get");
+        let _name = "" + name;
+        let array = this[state$a][_urlspArray];
+        for (let i = 0; i < array.length; ++i) {
+            let item = array[i];
+            if (item[0] === _name) {
+                return item[1];
+            }
         }
+        return null;
     }
-    readAsArrayBuffer(blob) {
-        read$1.call(this[state$a], "readAsArrayBuffer", blob, () => {
-            this[state$a].result = blob[state$c].toArrayBuffer().slice(0);
-        });
+    getAll(...args) {
+        const [name] = args;
+        checkArgsFn$2(args, 1, "getAll");
+        let _name = "" + name;
+        let array = this[state$a][_urlspArray];
+        let result = [];
+        for (let i = 0; i < array.length; ++i) {
+            let item = array[i];
+            if (item[0] === _name) {
+                result.push(item[1]);
+            }
+        }
+        return result;
     }
-    readAsBinaryString(blob) {
-        read$1.call(this[state$a], "readAsBinaryString", blob, () => {
-            this[state$a].result = blob[state$c].toUint8Array().reduce((acc, cur) => {
-                acc += String.fromCharCode(cur);
-                return acc;
-            }, "");
-        });
+    has(...args) {
+        const [name, value] = args;
+        checkArgsFn$2(args, 1, "has");
+        let _name = "" + name;
+        let array = this[state$a][_urlspArray];
+        for (let i = 0; i < array.length; ++i) {
+            let item = array[i];
+            if (item[0] === _name) {
+                if (args.length === 1) {
+                    return true;
+                }
+                else {
+                    if (item[1] === normalizeValue$1(value)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
     }
-    readAsDataURL(blob) {
-        read$1.call(this[state$a], "readAsDataURL", blob, () => {
-            this[state$a].result = "data:" + blob.type + ";base64," + u8array2base64(blob[state$c].toUint8Array());
-        });
+    set(...args) {
+        const [name, value] = args;
+        checkArgsFn$2(args, 2, "set");
+        let _name = "" + name;
+        let _value = normalizeValue$1(value);
+        let index = -1;
+        let array = this[state$a][_urlspArray];
+        let result = [];
+        for (let i = 0; i < array.length; ++i) {
+            let item = array[i];
+            if (item[0] === _name) {
+                if (index === -1) {
+                    index = i;
+                    result.push([_name, _value]);
+                }
+                continue;
+            }
+            result.push(item);
+        }
+        if (index === -1) {
+            result.push([_name, _value]);
+        }
+        this[state$a][_urlspArray] = result;
     }
-    readAsText(blob, encoding) {
-        read$1.call(this[state$a], "readAsText", blob, () => {
-            this[state$a].result = (new TextDecoderP(encoding)).decode(blob[state$c].toUint8Array());
-        });
+    sort() {
+        this[state$a][_urlspArray].sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
+    }
+    forEach(...args) {
+        const [callbackfn, thisArg] = args;
+        checkArgsFn$2(args, 1, "forEach");
+        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];
+        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();
+    }
+    keys() {
+        return this[state$a][_urlspArray].map(x => x[0]).values();
+    }
+    values() {
+        return this[state$a][_urlspArray].map(x => x[1]).values();
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    toString() {
+        let array = this[state$a][_urlspArray];
+        let result = [];
+        for (let i = 0; i < array.length; ++i) {
+            let item = array[i];
+            result.push(encode(item[0]) + "=" + encode(item[1]));
+        }
+        return result.join("&");
     }
-    get onabort() { return this[state$a].onabort; }
-    set onabort(value) { this[state$a].onabort = value; attach$1.call(this[state$a], "abort"); }
-    get onerror() { return this[state$a].onerror; }
-    set onerror(value) { this[state$a].onerror = value; attach$1.call(this[state$a], "error"); }
-    get onload() { return this[state$a].onload; }
-    set onload(value) { this[state$a].onload = value; attach$1.call(this[state$a], "load"); }
-    get onloadend() { return this[state$a].onloadend; }
-    set onloadend(value) { this[state$a].onloadend = value; attach$1.call(this[state$a], "loadend"); }
-    get onloadstart() { return this[state$a].onloadstart; }
-    set onloadstart(value) { this[state$a].onloadstart = value; attach$1.call(this[state$a], "loadstart"); }
-    get onprogress() { return this[state$a].onprogress; }
-    set onprogress(value) { this[state$a].onprogress = value; attach$1.call(this[state$a], "progress"); }
-    toString() { return "[object FileReader]"; }
-    get isPolyfill() { return { symbol: polyfill, hierarchy: ["FileReader", "EventTarget"] }; }
+    /** @internal */
+    get isPolyfill() { return { symbol: polyfill, hierarchy: ["URLSearchParams"] }; }
 }
-const properties$1 = {
-    EMPTY: { value: 0, enumerable: true },
-    LOADING: { value: 1, enumerable: true },
-    DONE: { value: 2, enumerable: true },
-};
-Object.defineProperties(FileReaderP, properties$1);
-Object.defineProperties(FileReaderP.prototype, properties$1);
-defineStringTag(FileReaderP, "FileReader");
+Class_setStringTag(URLSearchParamsP, "URLSearchParams");
 /** @internal */
-const _handlers$3 = Symbol();
+const _urlspArray = Symbol();
 /** @internal */
-class FileReaderState {
-    constructor(target) {
-        this.readyState = FileReaderP.EMPTY;
-        this.result = null;
-        this.error = null;
-        this[_a$7] = getHandlers$3.call(this);
-        this.onabort = null;
-        this.onerror = null;
-        this.onload = null;
-        this.onloadend = null;
-        this.onloadstart = null;
-        this.onprogress = null;
-        this.target = target;
-    }
-}
-_a$7 = _handlers$3;
-function read$1(kind, blob, setResult) {
-    if (!isPolyfillType("Blob", blob)) {
-        throw new TypeError("Failed to execute '" + kind + "' on 'FileReader': parameter 1 is not of type 'Blob'.");
+class URLSearchParamsState {
+    constructor() {
+        this[_a$6] = [];
     }
-    this.error = null;
-    this.readyState = FileReaderP.LOADING;
-    emitProcessEvent(this.target, "loadstart", 0, blob.size);
-    setTimeout(() => {
-        if (this.readyState === FileReaderP.LOADING) {
-            this.readyState = FileReaderP.DONE;
-            try {
-                setResult();
-                emitProcessEvent(this.target, "load", blob.size, blob.size);
-            }
-            catch (e) {
-                this.result = null;
-                this.error = e;
-                emitProcessEvent(this.target, "error", 0, blob.size);
-            }
-        }
-        emitProcessEvent(this.target, "loadend", !!this.result ? blob.size : 0, blob.size);
-    });
 }
-function attach$1(type) {
-    const fnName = ("on" + type);
-    const cb = this[fnName];
-    const listener = this[_handlers$3][fnName];
-    attachFn.call(this.target, type, cb, listener);
+_a$6 = _urlspArray;
+function normalizeValue$1(value) {
+    return typeof value === "string" ? value : (value !== null && value !== undefined && typeof value.toString === "function"
+        ? value.toString()
+        : JSON.stringify(value));
 }
-function getHandlers$3() {
-    return {
-        onabort: (ev) => { executeFn.call(this.target, this.onabort, ev); },
-        onerror: (ev) => { executeFn.call(this.target, this.onerror, ev); },
-        onload: (ev) => { executeFn.call(this.target, this.onload, ev); },
-        onloadend: (ev) => { executeFn.call(this.target, this.onloadend, ev); },
-        onloadstart: (ev) => { executeFn.call(this.target, this.onloadstart, ev); },
-        onprogress: (ev) => { executeFn.call(this.target, this.onprogress, ev); },
+function encode(str) {
+    const replace = {
+        "!": "%21",
+        "'": "%27",
+        "(": "%28",
+        ")": "%29",
+        "~": "%7E",
+        "%20": "+",
+        "%00": "\x00",
     };
+    return encodeURIComponent(str).replace(/[!'\(\)~]|%20|%00/g, match => replace[match]);
 }
-const FileReaderE = g["Blob"] ? g["FileReader"] : FileReaderP;
+function decode(str) {
+    return str
+        .replace(/[ +]/g, "%20")
+        .replace(/(%[a-f0-9]{2})+/ig, match => decodeURIComponent(match));
+}
+const URLSearchParamsE = g["URLSearchParams"] || URLSearchParamsP;
 
-var _a$6;
-/** @internal */
-const state$9 = Symbol( /* "FormDataState" */);
+var _a$5;
+/** @internal */ const state$9 = Symbol( /* "FormDataState" */);
+const checkArgsFn$1 = (args, required, funcName) => { checkArgsLength(args, required, "FormData", funcName); };
+/** @type {typeof globalThis.FormData} */
 class FormDataP {
     constructor(form, submitter) {
-        if (form !== void 0) {
-            throw new TypeError("Failed to construct 'FormData': parameter 1 is not of type	'HTMLFormElement'.");
+        if (submitter === undefined) {
+            if (form !== undefined) {
+                console.error("TypeError: Failed to construct 'FormData': parameter 1 not implemented.");
+            }
         }
-        if (!!submitter) {
-            throw new TypeError("Failed to construct 'FormData': parameter 2 is not of type 'HTMLElement'.");
+        else {
+            if (submitter !== null) {
+                console.error("TypeError: Failed to construct 'FormData': parameter 1 and parameter 2 not implemented.");
+            }
         }
         this[state$9] = new FormDataState();
     }
-    append(name, value, filename) {
+    append(...args) {
+        const [name, value, filename] = args;
+        checkArgsFn$1(args, 2, "append");
         this[state$9][_formData].push(normalizeArgs(name, value, filename));
     }
-    delete(name) {
+    delete(...args) {
+        const [name] = args;
+        checkArgsFn$1(args, 1, "delete");
+        let _name = "" + name;
+        let index = -1;
+        let array = this[state$9][_formData];
         let result = [];
-        name = String(name);
-        each(this[state$9][_formData], entry => {
-            entry[0] !== name && result.push(entry);
-        });
-        this[state$9][_formData] = 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$9][_formData] = result;
+        }
     }
-    get(name) {
-        let entries = this[state$9][_formData];
-        name = String(name);
-        for (let i = 0; i < entries.length; ++i) {
-            if (entries[i][0] === name) {
-                return entries[i][1];
+    get(...args) {
+        const [name] = args;
+        checkArgsFn$1(args, 1, "get");
+        let _name = "" + name;
+        let array = this[state$9][_formData];
+        for (let i = 0; i < array.length; ++i) {
+            let item = array[i];
+            if (item[0] === _name) {
+                return item[1];
             }
         }
         return null;
     }
-    getAll(name) {
+    getAll(...args) {
+        const [name] = args;
+        checkArgsFn$1(args, 1, "getAll");
+        let _name = "" + name;
+        let array = this[state$9][_formData];
         let result = [];
-        name = String(name);
-        each(this[state$9][_formData], data => {
-            data[0] === name && result.push(data[1]);
-        });
+        for (let i = 0; i < array.length; ++i) {
+            let item = array[i];
+            if (item[0] === _name) {
+                result.push(item[1]);
+            }
+        }
         return result;
     }
-    has(name) {
-        name = String(name);
-        for (let i = 0; i < this[state$9][_formData].length; ++i) {
-            if (this[state$9][_formData][i][0] === name) {
+    has(...args) {
+        const [name] = args;
+        checkArgsFn$1(args, 1, "has");
+        let _name = "" + name;
+        let array = this[state$9][_formData];
+        for (let i = 0; i < array.length; ++i) {
+            let item = array[i];
+            if (item[0] === _name) {
                 return true;
             }
         }
         return false;
     }
-    set(name, value, filename) {
-        name = String(name);
+    set(...args) {
+        const [name, value, filename] = args;
+        checkArgsFn$1(args, 2, "set");
+        let _name = "" + name;
+        let _args = normalizeArgs(name, value, filename);
+        let index = -1;
+        let array = this[state$9][_formData];
         let result = [];
-        let args = normalizeArgs(name, value, filename);
-        let replace = true;
-        each(this[state$9][_formData], data => {
-            data[0] === name
-                ? replace && (replace = !result.push(args))
-                : result.push(data);
-        });
-        replace && result.push(args);
+        for (let i = 0; i < array.length; ++i) {
+            let item = array[i];
+            if (item[0] === _name) {
+                if (index === -1) {
+                    index = i;
+                    result.push(_args);
+                }
+                continue;
+            }
+            result.push(item);
+        }
+        if (index === -1) {
+            result.push(_args);
+        }
         this[state$9][_formData] = result;
     }
-    forEach(callbackfn, thisArg) {
-        for (let [name, value] of this) {
-            callbackfn.call(thisArg, value, name, thisArg);
+    forEach(...args) {
+        const [callbackfn, thisArg] = args;
+        checkArgsFn$1(args, 1, "forEach");
+        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];
+        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].values();
+        return this[state$9][_formData].map(x => [x[0], x[1]]).values();
     }
     keys() {
         return this[state$9][_formData].map(x => x[0]).values();
@@ -985,391 +1386,599 @@ class FormDataP {
     [Symbol.iterator]() {
         return this.entries();
     }
-    toString() { return "[object FormData]"; }
-    get isPolyfill() { return { symbol: polyfill, hierarchy: ["FormData"] }; }
+    /** @internal */ toString() { return "[object FormData]"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["FormData"] }; }
 }
-defineStringTag(FormDataP, "FormData");
+Class_setStringTag(FormDataP, "FormData");
 /** @internal */
 const _formData = Symbol();
 /** @internal */
 class FormDataState {
     constructor() {
-        this[_a$6] = [];
+        this[_a$5] = [];
     }
-    toBlob() {
-        const boundary = "----formdata-polyfill-" + Math.random();
-        const p = `--${boundary}\r\nContent-Disposition: form-data; name="`;
-        let chunks = [];
-        for (const [name, value] of this[_formData].values()) {
-            if (typeof value === "string") {
-                chunks.push(p + escape(normalizeLinefeeds(name)) + `"\r\n\r\n${normalizeLinefeeds(value)}\r\n`);
-            }
-            else {
-                chunks.push(p + escape(normalizeLinefeeds(name)) + `"; filename="${escape(value.name)}"\r\nContent-Type: ${value.type || "application/octet-stream"}\r\n\r\n`, value, `\r\n`);
-            }
+}
+_a$5 = _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];
+        let name = pair[0];
+        let value = pair[1];
+        if (typeof value === "string") {
+            chunks.push(p + escape(normalizeLinefeeds(name)) + `"\r\n\r\n${normalizeLinefeeds(value)}\r\n`);
+        }
+        else {
+            chunks.push(p + escape(normalizeLinefeeds(name)) + `"; filename="${escape(value.name)}"\r\nContent-Type: ${value.type || "application/octet-stream"}\r\n\r\n`, value, `\r\n`);
         }
-        chunks.push(`--${boundary}--`);
-        return new BlobP(chunks, {
-            type: "multipart/form-data; boundary=" + boundary,
-        });
     }
+    chunks.push(`--${boundary}--`);
+    return new BlobP(chunks, { type: "multipart/form-data; boundary=" + boundary });
 }
-_a$6 = _formData;
 function normalizeArgs(name, value, filename) {
     if (isPolyfillType("Blob", value)) {
         filename = filename !== undefined
-            ? String(filename + "")
+            ? ("" + filename)
             : typeof value.name === "string"
                 ? value.name
                 : "blob";
-        if (value.name !== filename || Object.prototype.toString.call(value) === "[object Blob]") {
+        if (value.name !== filename || isObjectType("Blob", value)) {
             value = new FileP([value], filename);
         }
-        return [String(name), value];
+        return ["" + name, value];
     }
-    return [String(name), String(value)];
+    return ["" + name, "" + value];
 }
+// normalize line feeds for textarea
+// https://html.spec.whatwg.org/multipage/form-elements.html#textarea-line-break-normalisation-transformation
 function normalizeLinefeeds(value) {
     return value.replace(/\r?\n|\r/g, "\r\n");
 }
-function each(arr, cb) {
-    for (let i = 0; i < arr.length; ++i) {
-        cb(arr[i]);
-    }
-}
 function escape(str) {
     return str.replace(/\n/g, '%0A').replace(/\r/g, '%0D').replace(/"/g, '%22');
 }
-/**
- * Parses multipart/form-data binary data, supporting restoration of text fields and files
- * @param body - Text in multipart/form-data format (including boundaries and data)
- * @returns Parsed FormData object (text fields as strings, files as File objects)
- */
-function createFormDataFromBody(body, errMsg = "Failed to fetch") {
-    const formData = new FormDataP();
-    if (typeof body !== "string" || body.trim() === "") {
-        return formData;
-    }
-    // 1. Extract boundary string (from the first line, removing leading "--")
-    const firstLineEnd = body.indexOf("\r\n");
+/** @internal */
+function createFormDataFromBinaryText(text, boundary) {
+    const throwParseError = () => {
+        throw new TypeError("Could not parse content as FormData.");
+    };
+    if (typeof text !== "string" || text.trim() === "") {
+        throwParseError();
+    }
+    let firstLineEnd = text.indexOf("\r\n");
     if (firstLineEnd === -1) {
-        // Invalid multipart format: Missing line break in header
-        throw new TypeError(errMsg);
+        throwParseError();
+    }
+    let _boundary = text.substring(2, firstLineEnd).trim();
+    if (!_boundary) {
+        throwParseError();
     }
-    const boundary = body.substring(2, firstLineEnd).trim();
-    if (!boundary) {
-        // Invalid multipart format: Empty boundary
-        throw new TypeError("Invalid MIME type");
+    if (boundary !== undefined && boundary !== _boundary) {
+        throwParseError();
     }
-    // 2. Split data into individual parts (excluding empty content and trailing "--")
-    const parts = body.split(`--${boundary}`).filter(part => {
-        const trimmed = part.trim();
+    let parts = text.split(`--${_boundary}`).filter(part => {
+        let trimmed = part.trim();
         return trimmed !== "" && trimmed !== "--";
     });
     if (parts.length === 0) {
-        // Invalid multipart format: No parts found
-        throw new TypeError(errMsg);
+        throwParseError();
     }
-    // 3. Parse each part
+    let formData = new FormDataP();
     parts.forEach(part => {
-        // Split header and content (separator between header and content is "\r\n\r\n")
-        const separatorIndex = part.indexOf("\r\n\r\n");
+        let separatorIndex = part.indexOf("\r\n\r\n");
         if (separatorIndex === -1) {
-            // Invalid part format: Missing header-content separator
-            throw new TypeError(errMsg);
-        }
-        // Extract header (Content-Disposition and Content-Type)
-        const headerRaw = part.substring(0, separatorIndex).trim();
-        const contentRaw = part.substring(separatorIndex + 4); // Skip "\r\n\r\n"
-        // Parse header information
-        const nameMatch = headerRaw.match(/name="([^"]+)"/); // Field name
-        const filenameMatch = headerRaw.match(/filename="([^"]*)"/); // Filename (optional, only for file fields)
-        const contentTypeMatch = headerRaw.match(/Content-Type: ([^\r\n]+)/); // MIME type (optional)
-        if (!nameMatch || !nameMatch[1]) {
-            // Invalid part format: Missing field name
-            throw new TypeError(errMsg);
-        }
-        const fieldName = nameMatch[1];
-        const isFile = !!filenameMatch; // Whether it's a file field
-        const mimeType = contentTypeMatch ? (contentTypeMatch[1] || "").trim() : "application/octet-stream";
-        // 4. Process content (text or binary)
-        if (isFile) {
-            // File field: Use TextEncoder to handle raw binary data
-            try {
-                // Remove line breaks from content (simulating browser behavior)
-                const content = contentRaw.replace(/\r\n/g, "");
-                // Convert string to Uint8Array using TextEncoder
-                const encoder = new TextEncoderP();
-                const uint8Array = encoder.encode(content);
-                // Create File object (default filename is unknown-file)
-                const filename = filenameMatch[1] || "unknown-file";
-                const file = new FileP([uint8Array], filename, { type: mimeType });
-                formData.append(fieldName, file, filename);
-            }
-            catch (e) {
-                // `Failed to process file field "${fieldName}": ${(e as Error).message}`
-                throw new TypeError(errMsg);
-            }
+            throwParseError();
+        }
+        let headerRaw = part.substring(0, separatorIndex).trim();
+        let nameMatch = headerRaw.match(/name="([^"]*)"/);
+        if (!nameMatch || nameMatch.length < 2) {
+            throwParseError();
+        }
+        let fieldName = nameMatch[1];
+        let filenameMatch = headerRaw.match(/filename="([^"]*)"/);
+        let contentRaw = part.substring(separatorIndex + 4);
+        if (!filenameMatch) {
+            formData.append(fieldName, contentRaw.replace(/^[\r\n]+|[\r\n]+$/g, ""));
         }
         else {
-            // Text field: Directly take content (remove leading/trailing line breaks to match browser behavior)
-            const value = contentRaw.replace(/^[\r\n]+|[\r\n]+$/g, "");
-            formData.append(fieldName, value);
+            let filename = filenameMatch[1] || "";
+            let contentTypeMatch = headerRaw.match(/Content-Type: ([^\r\n]+)/);
+            let mimeType = contentTypeMatch ? (contentTypeMatch[1] || "").trim() : "text/plain";
+            let content = contentRaw.replace(/\r\n/g, "");
+            formData.append(fieldName, new FileP([content], filename, { type: mimeType }));
         }
     });
     return formData;
 }
 const FormDataE = g["FormData"] || FormDataP;
 
-var _a$5;
-/** @internal */
-const state$8 = Symbol( /* "URLSearchParamsState" */);
-class URLSearchParamsP {
+var _a$4, _b$1;
+/** @internal */ const state$8 = Symbol( /* "HeadersState" */);
+const checkArgsFn = (args, required, funcName) => { checkArgsLength(args, required, "Headers", funcName); };
+/** @type {typeof globalThis.Headers} */
+class HeadersP {
     constructor(init) {
-        let search = init || "";
-        if (isObjectType("URLSearchParams", search)) {
-            search = search.toString();
-        }
-        this[state$8] = new URLSearchParamsState();
-        this[state$8][_urlspDict] = parseToDict(search);
-    }
-    get size() {
-        return objectValues(this[state$8][_urlspDict]).reduce((acc, cur) => acc + cur.length, 0);
-    }
-    append(name, value) {
-        appendTo(this[state$8][_urlspDict], name, value);
-    }
-    delete(name, value) {
-        let dict = {};
-        for (let [key, values] of objectEntries(this[state$8][_urlspDict])) {
-            if (key === name) {
-                if (value !== undefined) {
-                    let vals = values.filter(x => x !== ("" + value));
-                    if (vals.length > 0)
-                        Object.assign(dict, { [key]: vals });
+        this[state$8] = new HeadersState();
+        if (init !== undefined) {
+            if (isObjectType("Headers", init)) {
+                init.forEach((value, name) => { this.append(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);
+                _init.forEach(item => {
+                    if (Array.isArray(item) || (item && typeof item === "object" && Symbol.iterator in item)) {
+                        let pair = Array.isArray(item) ? item : Array.from(item);
+                        if (pair.length === 2) {
+                            this.append(pair[0], pair[1]);
+                        }
+                        else {
+                            throw new TypeError("Failed to construct 'Headers': Invalid value");
+                        }
+                    }
+                    else {
+                        throw new TypeError("Failed to construct 'Headers': The provided value cannot be converted to a sequence.");
+                    }
+                }, this);
+            }
+            else {
+                if (init && typeof init === "object") {
+                    Object.getOwnPropertyNames(init).forEach(name => { this.append(name, init[name]); }, this);
+                }
+                else {
+                    throw new TypeError("Failed to construct 'Headers': The provided value is not of type '(record<ByteString, ByteString> or sequence<sequence<ByteString>>)'.");
                 }
+            }
+        }
+        this[state$8][_initialized] = true;
+    }
+    append(...args) {
+        const [name, value] = args;
+        checkArgsFn(args, 2, "append");
+        let _name = normalizeName(name, throwsFn(this[state$8][_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]);
+        }
+    }
+    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;
             }
-            Object.assign(dict, { [key]: values });
+            result.push(item);
+        }
+        if (index > -1) {
+            this[state$8][_headersArray] = result;
         }
-        this[state$8][_urlspDict] = dict;
     }
-    get(name) {
-        var _b;
-        return this.has(name) ? (_b = this[state$8][_urlspDict][name][0]) !== null && _b !== void 0 ? _b : null : null;
+    get(...args) {
+        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;
     }
-    getAll(name) {
-        return this.has(name) ? this[state$8][_urlspDict][name].slice(0) : [];
+    getSetCookie() {
+        let value = this.get("Set-Cookie");
+        return value ? value.split(", ") : [];
     }
-    has(name, value) {
-        if (hasOwnProperty(this[state$8][_urlspDict], name)) {
-            if (value !== undefined) {
-                return this[state$8][_urlspDict][name].indexOf(("" + value)) > -1;
+    has(...args) {
+        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 true;
         }
         return false;
     }
-    set(name, value) {
-        this[state$8][_urlspDict][name] = ["" + value];
+    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]);
+        }
     }
-    sort() {
-        const that = this[state$8];
-        let keys = Object.keys(that[_urlspDict]);
-        keys.sort();
-        let dict = {};
-        for (let key of keys) {
-            Object.assign(dict, { [key]: that[_urlspDict][key] });
-        }
-        that[_urlspDict] = dict;
-    }
-    forEach(callbackfn, thisArg) {
-        objectEntries(this[state$8][_urlspDict]).forEach(([key, values]) => {
-            values.forEach(value => {
-                callbackfn.call(thisArg, value, key, this);
-            });
-        });
+    forEach(...args) {
+        const [callbackfn, thisArg] = args;
+        checkArgsFn(args, 1, "forEach");
+        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);
+        }
     }
     entries() {
-        return objectEntries(this[state$8][_urlspDict])
-            .map(([key, values]) => {
-            return values.map(value => {
-                return [key, value];
-            });
-        })
-            .reduce(flatCb, [])
-            .values();
+        return this[state$8][_headersArray].map(x => [x[0], x[1]]).values();
     }
     keys() {
-        return Object.keys(this[state$8][_urlspDict]).values();
+        return this[state$8][_headersArray].map(x => x[0]).values();
+    }
+    values() {
+        return this[state$8][_headersArray].map(x => x[1]).values();
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    /** @internal */ toString() { return "[object Headers]"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["Headers"] }; }
+}
+Class_setStringTag(HeadersP, "Headers");
+/** @internal */ const _initialized = Symbol();
+/** @internal */ const _headersArray = Symbol();
+/** @internal */
+class HeadersState {
+    constructor() {
+        this[_a$4] = false;
+        this[_b$1] = [];
+    }
+}
+_a$4 = _initialized, _b$1 = _headersArray;
+function throwsFn(kind) {
+    return () => {
+        throw new TypeError(`Failed to ${kind ? ("execute '" + kind + "' on") : "construct"} 'Headers': Invalid name`);
+    };
+}
+/** @internal */
+function normalizeName(name, throwError) {
+    if (typeof name !== "string") {
+        name = "" + name;
+    }
+    if (throwError && (/[^a-z0-9\-#$%&'*+.^_`|~!]/i.test(name) || name === "")) {
+        throwError();
+    }
+    return name.toLowerCase();
+}
+/** @internal */
+function normalizeValue(value) {
+    return typeof value === "string" ? value : ("" + value);
+}
+/** @internal */
+function parseHeaders(rawHeaders) {
+    let headers = new HeadersP();
+    let preProcessedHeaders = rawHeaders.replace(/\r?\n[\t ]+/g, " ");
+    preProcessedHeaders
+        .split("\r")
+        .map(header => header.indexOf("\n") === 0 ? header.substring(1, header.length) : header)
+        .forEach(line => {
+        let parts = line.split(":");
+        let name = parts.shift().trim();
+        if (name) {
+            let value = parts.join(":").trim();
+            try {
+                headers.append(name, value);
+            }
+            catch (e) {
+                console.warn(`SyntaxError: Response.headers: '${name}' is not a valid HTTP header field name.`);
+            }
+        }
+    });
+    return headers;
+}
+const HeadersE = g["Headers"] || HeadersP;
+
+var _a$3;
+/** @internal */ const state$7 = Symbol( /* "BodyState" */);
+class BodyImpl {
+    /** @internal */
+    constructor() {
+        if (new.target === BodyImpl) {
+            throw new TypeError("Failed to construct 'Body': Illegal constructor");
+        }
+        this[state$7] = new BodyState();
+    }
+    get body() {
+        if (!this[state$7][_body]) {
+            return null;
+        }
+        throw new TypeError(`Failed to access 'body' on '${this[state$7].name}': property not implemented.`);
+    }
+    get bodyUsed() { return this[state$7].bodyUsed; }
+    ;
+    arrayBuffer() {
+        const kind = "arrayBuffer";
+        return consumed(this, kind) || read(this, kind);
+    }
+    blob() {
+        const kind = "blob";
+        return consumed(this, kind) || read(this, kind);
+    }
+    bytes() {
+        const kind = "bytes";
+        return consumed(this, kind) || read(this, kind);
+    }
+    formData() {
+        const kind = "formData";
+        return consumed(this, kind) || read(this, kind);
+    }
+    json() {
+        const kind = "json";
+        return consumed(this, kind) || read(this, kind);
+    }
+    text() {
+        const kind = "text";
+        return consumed(this, kind) || read(this, kind);
+    }
+    /** @internal */ toString() { return "[object Body]"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["Body"] }; }
+}
+Class_setStringTag(BodyImpl, "Body");
+/** @internal */
+const _body = Symbol();
+/** @internal */
+class BodyState {
+    constructor() {
+        this.name = "Body";
+        this.bodyUsed = false;
+        this[_a$3] = "";
+    }
+}
+_a$3 = _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.`);
+    }
+    b[state$7][_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];
+}
+function read(body, kind) {
+    return new Promise((resolve, reject) => {
+        try {
+            resolve(readSync(body, kind));
+        }
+        catch (e) {
+            reject(e);
+        }
+    });
+}
+function readSync(body, kind) {
+    const payload = body[state$7][_body];
+    if (kind === "arrayBuffer") {
+        return convertBack("arraybuffer", payload);
+    }
+    else if (kind === "blob") {
+        return convertBack("blob", payload);
+    }
+    else if (kind === "bytes") {
+        let arrayBuffer = convertBack("arraybuffer", payload);
+        return new Uint8Array(arrayBuffer);
+    }
+    else if (kind === "formData") {
+        const extractBoundary = (contentType) => {
+            if (!contentType) {
+                return;
+            }
+            if (!/multipart\/form-data/i.test(contentType)) {
+                return;
+            }
+            let boundaryMatch = contentType.match(/boundary\s*=\s*([^;]+)/i);
+            if (boundaryMatch && boundaryMatch[1]) {
+                let boundary = boundaryMatch[1].trim();
+                return boundary.replace(/^["']|["']$/g, "");
+            }
+        };
+        let text = convertBack("text", payload);
+        let boundary = extractBoundary(body.headers.get("Content-Type")) || "";
+        return createFormDataFromBinaryText(text, boundary);
+    }
+    else if (kind === "json") {
+        return convertBack("json", payload);
+    }
+    else {
+        return convertBack("text", payload);
+    }
+}
+function consumed(body, kind) {
+    const s = body[state$7];
+    if (!s[_body])
+        return;
+    if (s.bodyUsed) {
+        return Promise.reject(new TypeError(`Failed to execute '${kind}' on '${s.name}': body stream already read`));
+    }
+    s.bodyUsed = true;
+}
+/** @internal */
+function convert(body, cloneArrayBuffer = true, setContentType, setContentLength) {
+    let result;
+    if (typeof body === "string") {
+        result = body;
+        if (setContentType) {
+            setContentType("text/plain;charset=UTF-8");
+        }
+    }
+    else if (isObjectType("URLSearchParams", body)) {
+        result = body.toString();
+        if (setContentType) {
+            setContentType("application/x-www-form-urlencoded;charset=UTF-8");
+        }
+    }
+    else if (body instanceof ArrayBuffer) {
+        result = cloneArrayBuffer ? body.slice(0) : body;
+    }
+    else if (ArrayBuffer.isView(body)) {
+        result = body.buffer.slice(body.byteOffset, body.byteOffset + body.byteLength);
+    }
+    else if (isPolyfillType("Blob", body)) {
+        result = Blob_toUint8Array(body).buffer.slice(0);
+        if (setContentType && body.type) {
+            setContentType(body.type);
+        }
+    }
+    else if (isPolyfillType("FormData", body)) {
+        let blob = FormData_toBlob(body);
+        result = Blob_toUint8Array(blob).buffer;
+        if (setContentType) {
+            setContentType(blob.type);
+        }
     }
-    values() {
-        return objectValues(this[state$8][_urlspDict]).reduce(flatCb, []).values();
+    else if (!body) {
+        result = "";
     }
-    [Symbol.iterator]() {
-        return this.entries();
+    else {
+        result = "" + body;
     }
-    toString() {
-        let query = [];
-        for (let [key, values] of objectEntries(this[state$8][_urlspDict])) {
-            let name = encode$1(key);
-            for (let val of values) {
-                query.push(name + "=" + encode$1(val));
+    if (setContentLength) {
+        let calculated = false, contentLength = 0;
+        setContentLength(() => {
+            if (!calculated) {
+                calculated = true;
+                contentLength = (typeof result === "string" ? encode$1(result).buffer : result).byteLength;
             }
-        }
-        return query.join("&");
+            return contentLength;
+        });
     }
-    get isPolyfill() { return { symbol: polyfill, hierarchy: ["URLSearchParams"] }; }
+    return result;
 }
-defineStringTag(URLSearchParamsP, "URLSearchParams");
 /** @internal */
-const _urlspDict = Symbol();
-/** @internal */
-class URLSearchParamsState {
-    constructor() {
-        this[_a$5] = {};
-    }
-}
-_a$5 = _urlspDict;
-function parseToDict(search) {
-    let dict = {};
-    if (typeof search === "object") {
-        // if `search` is an array, treat it as a sequence
-        if (Array.isArray(search)) {
-            for (let i = 0; i < search.length; ++i) {
-                let item = search[i];
-                if (Array.isArray(item) && item.length === 2) {
-                    appendTo(dict, item[0], item[1]);
-                }
-                else {
-                    throw new TypeError("Failed to construct 'URLSearchParams': Sequence initializer must only contain pair elements");
-                }
-            }
-        }
-        else {
-            for (let key in search) {
-                if (search.hasOwnProperty(key)) {
-                    appendTo(dict, key, search[key]);
-                }
-            }
-        }
+function convertBack(type, data) {
+    let temp = !!data ? (typeof data !== "string" && !(data instanceof ArrayBuffer) ? JSON.stringify(data) : data) : "";
+    if (!type || type === "text") {
+        return typeof temp === "string" ? temp : decode$1(temp);
     }
-    else {
-        // remove first '?'
-        if (search.indexOf("?") === 0) {
-            search = search.slice(1);
-        }
-        let pairs = search.split("&");
-        for (let j = 0; j < pairs.length; ++j) {
-            let value = pairs[j], index = value.indexOf("=");
-            if (-1 < index) {
-                appendTo(dict, decode$1(value.slice(0, index)), decode$1(value.slice(index + 1)));
-            }
-            else {
-                if (value) {
-                    appendTo(dict, decode$1(value), "");
-                }
-            }
-        }
+    else if (type === "json") {
+        return JSON.parse(typeof temp === "string" ? temp : decode$1(temp));
     }
-    return dict;
-}
-function appendTo(dict, name, value) {
-    let val = typeof value === "string" ? value : (value !== null && value !== undefined && typeof value.toString === "function" ? value.toString() : JSON.stringify(value));
-    // Prevent using `hasOwnProperty` as a property name
-    if (hasOwnProperty(dict, name)) {
-        dict[name].push(val);
+    else if (type === "arraybuffer") {
+        return temp instanceof ArrayBuffer ? temp.slice(0) : encode$1(temp).buffer;
     }
-    else {
-        dict[name] = [val];
+    else if (type === "blob") {
+        return new BlobP([temp]);
     }
-}
-function encode$1(str) {
-    const replace = {
-        "!": "%21",
-        "'": "%27",
-        "(": "%28",
-        ")": "%29",
-        "~": "%7E",
-        "%20": "+",
-        "%00": "\x00",
-    };
-    return encodeURIComponent(str).replace(/[!'\(\)~]|%20|%00/g, match => replace[match]);
-}
-function decode$1(str) {
-    return str
-        .replace(/[ +]/g, "%20")
-        .replace(/(%[a-f0-9]{2})+/ig, match => decodeURIComponent(match));
-}
-function hasOwnProperty(obj, prop) {
-    return Object.prototype.hasOwnProperty.call(obj, prop);
-}
-function flatCb(acc, cur) {
-    for (let item of cur) {
-        acc.push(item);
+    else {
+        return temp;
     }
-    return acc;
 }
-const URLSearchParamsE = g["URLSearchParams"] || URLSearchParamsP;
 
-var _a$4;
+var _a$2;
 /** @internal */
-const state$7 = Symbol( /* "AbortSignalState" */);
+const state$6 = Symbol( /* "AbortSignalState" */);
+/** @type {typeof globalThis.AbortSignal} */
 class AbortSignalP extends EventTargetP {
     static abort(reason) {
-        let signal = createAbortSignalP();
-        abort.call(signal[state$7], reason, false);
+        let signal = createAbortSignal();
+        AbortSignal_abort(signal, reason, false);
         return signal;
     }
-    static any(signals) {
-        let signal = createAbortSignalP();
-        let abortedSignal = signals.find(x => x.aborted);
+    static any(...args) {
+        const [signals] = args;
+        checkArgsLength(args, 1, "AbortSignal", "any");
+        if (!(Array.isArray(signals) || (signals && typeof signals === "object" && Symbol.iterator in signals))) {
+            throw new TypeError("Failed to execute 'any' on 'AbortSignal': The provided value cannot be converted to a sequence.");
+        }
+        let _signals = Array.isArray(signals) ? signals : Array.from(signals);
+        _signals.forEach(sig => {
+            if (!isPolyfillType("EventTarget", sig)) {
+                throw new TypeError("Failed to execute 'any' on 'AbortSignal': Failed to convert value to 'AbortSignal'.");
+            }
+        });
+        let signal = createAbortSignal();
+        let abortedSignal = _signals.find(x => x.aborted);
         if (abortedSignal) {
-            abort.call(signal[state$7], abortedSignal.reason, false);
+            AbortSignal_abort(signal, abortedSignal.reason, false);
         }
         else {
             function abortFn(ev) {
-                for (let sig of signals) {
+                for (let i = 0; i < _signals.length; ++i) {
+                    let sig = _signals[i];
                     sig.removeEventListener("abort", abortFn);
                 }
-                abort.call(signal[state$7], this.reason, true, ev.isTrusted);
+                AbortSignal_abort(signal, this.reason, true, ev.isTrusted);
             }
-            for (let sig of signals) {
+            for (let i = 0; i < _signals.length; ++i) {
+                let sig = _signals[i];
                 sig.addEventListener("abort", abortFn);
             }
         }
         return signal;
     }
-    static timeout(milliseconds) {
-        let signal = createAbortSignalP();
+    static timeout(...args) {
+        const [milliseconds] = args;
+        checkArgsLength(args, 1, "AbortSignal", "timeout");
+        if (!(milliseconds >= 0)) {
+            throw new TypeError("Failed to execute 'timeout' on 'AbortSignal': Value is outside the 'unsigned long long' value range.");
+        }
+        let signal = createAbortSignal();
         setTimeout(() => {
-            abort.call(signal[state$7], new MPException("signal timed out", "TimeoutError"));
+            AbortSignal_abort(signal, new MPException("signal timed out", "TimeoutError"));
         }, milliseconds);
         return signal;
     }
+    /** @internal */
     constructor() {
         if (new.target === AbortSignalP) {
             throw new TypeError("Failed to construct 'AbortSignal': Illegal constructor");
         }
         super();
-        this[state$7] = new AbortSignalState(this);
+        this[state$6] = new AbortSignalState(this);
     }
-    get aborted() { return this[state$7].aborted; }
-    get reason() { return this[state$7].reason; }
+    get aborted() { return this[state$6].aborted; }
+    get reason() { return this[state$6].reason; }
     throwIfAborted() {
         if (this.aborted) {
             throw this.reason;
         }
     }
-    get onabort() { return this[state$7].onabort; }
+    get onabort() { return this[state$6].onabort; }
     set onabort(value) {
-        this[state$7].onabort = value;
-        attachFn.call(this, "abort", value, this[state$7][_handlers$2].onabort);
+        this[state$6].onabort = value;
+        attachFn(this, "abort", value, this[state$6][_handlers$2].onabort);
     }
-    toString() { return "[object AbortSignal]"; }
-    get isPolyfill() { return { symbol: polyfill, hierarchy: ["AbortSignal", "EventTarget"] }; }
+    /** @internal */ toString() { return "[object AbortSignal]"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["AbortSignal", "EventTarget"] }; }
 }
-defineStringTag(AbortSignalP, "AbortSignal");
+Class_setStringTag(AbortSignalP, "AbortSignal");
 /** @internal */
 const _handlers$2 = Symbol();
 /** @internal */
@@ -1377,95 +1986,239 @@ class AbortSignalState {
     constructor(target) {
         this.aborted = false;
         this.reason = undefined;
-        this[_a$4] = getHandlers$2.call(this);
+        this[_a$2] = getHandlers$2(this);
         this.onabort = null;
         this.target = target;
     }
 }
-_a$4 = _handlers$2;
-function abort(reason, notify = true, isTrusted = true) {
-    if (!this.aborted) {
-        this.aborted = true;
-        this.reason = reason !== null && reason !== void 0 ? reason : (new MPException("signal is aborted without reason", "AbortError"));
+_a$2 = _handlers$2;
+/** @internal */
+function AbortSignal_abort(signal, reason, notify = true, isTrusted = true) {
+    const s = signal[state$6];
+    if (!s.aborted) {
+        s.aborted = true;
+        s.reason = reason !== null && reason !== void 0 ? reason : (new MPException("signal is aborted without reason", "AbortError"));
         if (notify) {
-            let evt = createInnerEvent(this.target, "abort", undefined, isTrusted);
-            fire.call(this.target[state$f], evt);
+            let evt = createInnerEvent(signal, "abort", undefined, isTrusted);
+            EventTarget_fire(signal, evt);
         }
     }
 }
-function getHandlers$2() {
+function getHandlers$2(s) {
     return {
-        onabort: (ev) => { executeFn.call(this.target, this.onabort, ev); },
+        onabort: (ev) => { executeFn(s.target, s.onabort, ev); },
     };
 }
-function createAbortSignalP() {
-    let instance = Object.create(AbortSignalP.prototype);
-    instance[state$f] = new EventTargetState(instance);
-    instance[state$7] = new AbortSignalState(instance);
-    return instance;
+/** @internal */
+function createAbortSignal() {
+    let signal = Object.create(AbortSignalP.prototype);
+    signal[state$d] = new EventTargetState(signal);
+    signal[state$6] = new AbortSignalState(signal);
+    return signal;
 }
 const AbortSignalE = g["AbortSignal"] || AbortSignalP;
 
 /** @internal */
-const state$6 = Symbol( /* "AbortControllerState" */);
+const state$5 = Symbol( /* "AbortControllerState" */);
+/** @type {typeof globalThis.AbortController} */
 class AbortControllerP {
     constructor() {
-        this[state$6] = new AbortControllerState();
+        this[state$5] = new AbortControllerState();
     }
-    get signal() { return this[state$6].signal; }
+    get signal() { return this[state$5].signal; }
     abort(reason) {
-        abort.call(this[state$6].signal[state$7], reason);
+        AbortSignal_abort(this[state$5].signal, reason);
     }
-    toString() { return "[object AbortController]"; }
-    get isPolyfill() { return { symbol: polyfill, hierarchy: ["AbortController"] }; }
+    /** @internal */ toString() { return "[object AbortController]"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["AbortController"] }; }
 }
-defineStringTag(AbortControllerP, "AbortController");
+Class_setStringTag(AbortControllerP, "AbortController");
 /** @internal */
 class AbortControllerState {
     constructor() {
-        this.signal = createAbortSignalP();
+        this.signal = createAbortSignal();
     }
 }
 const AbortControllerE = g["AbortController"] || AbortControllerP;
 
-var _a$3;
+/** @internal */ const state$4 = Symbol( /* "RequestState" */);
+/** @type {typeof globalThis.Request} */
+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];
+        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'.");
+        }
+        let body = _init.body;
+        if (isPolyfillType("Request", input)) {
+            if (input.bodyUsed) {
+                throw new TypeError("Failed to construct 'Request': Cannot construct a Request with a Request object that has already been used.");
+            }
+            s.cache = input.cache;
+            s.credentials = input.credentials;
+            if (!_init.headers) {
+                s.headers = new HeadersP(input.headers);
+            }
+            s.method = input.method;
+            s.mode = input.mode;
+            let inputSignal = input[state$4].signal;
+            if (inputSignal) {
+                s.signal = inputSignal;
+            }
+            s.url = input.url;
+            let payload = Body_toPayload(input);
+            if (!body && payload !== "") {
+                body = payload;
+                input[state$7].bodyUsed = true;
+            }
+        }
+        else {
+            s.url = "" + input;
+        }
+        if (_init.cache) {
+            s.cache = _init.cache;
+        }
+        if (_init.credentials) {
+            s.credentials = _init.credentials;
+        }
+        if (_init.headers) {
+            s.headers = new HeadersP(_init.headers);
+        }
+        if (_init.method) {
+            s.method = normalizeMethod(_init.method);
+        }
+        if (_init.mode) {
+            s.mode = _init.mode;
+        }
+        if (_init.signal) {
+            s.signal = _init.signal;
+        }
+        if ((this.method === "GET" || this.method === "HEAD") && body) {
+            throw new TypeError("Failed to construct 'Request': Request with GET/HEAD method cannot have body.");
+        }
+        Body_init(this, body);
+        if (this.method === "GET" || this.method === "HEAD") {
+            if (_init.cache === "no-store" || _init.cache === "no-cache") {
+                // Search for a '_' parameter in the query string
+                let reParamSearch = /([?&])_=[^&]*/;
+                if (reParamSearch.test(this.url)) {
+                    // If it already exists then set the value with the current time
+                    s.url = this.url.replace(reParamSearch, "$1_=" + (new Date()).getTime());
+                }
+                else {
+                    // Otherwise add a new '_' parameter to the end with the current time
+                    let reQueryString = /\?/;
+                    s.url += (reQueryString.test(this.url) ? "&" : "?") + "_=" + (new Date()).getTime();
+                }
+            }
+        }
+    }
+    get cache() { return this[state$4].cache; }
+    get credentials() { return this[state$4].credentials; }
+    get destination() { return this[state$4].destination; }
+    get headers() {
+        const s = this[state$4];
+        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 signal() {
+        const s = this[state$4];
+        if (!s.signal) {
+            s.signal = (new AbortControllerP()).signal;
+        }
+        return s.signal;
+    }
+    get url() { return this[state$4].url; }
+    clone() {
+        var _a;
+        if (this.bodyUsed) {
+            throw new TypeError("Failed to execute 'clone' on 'Request': Request body is already used");
+        }
+        return new RequestP(this, { body: (_a = Body_toPayload(this)) !== null && _a !== void 0 ? _a : null });
+    }
+    /** @internal */ toString() { return "[object Request]"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["Request"] }; }
+}
+Class_setStringTag(RequestP, "Request");
+/** @internal */
+class RequestState {
+    constructor() {
+        this.cache = "default";
+        this.credentials = "same-origin";
+        this.destination = "";
+        this.integrity = "";
+        this.keepalive = false;
+        this.method = "GET";
+        this.mode = "cors";
+        this.redirect = "follow";
+        this.referrer = "about:client";
+        this.referrerPolicy = "";
+        this.url = "";
+    }
+}
+// HTTP methods whose capitalization should be normalized
+const methods = ["CONNECT", "DELETE", "GET", "HEAD", "OPTIONS", "PATCH", "POST", "PUT", "TRACE"];
 /** @internal */
-const state$5 = Symbol( /* "XMLHttpRequestEventTargetState" */);
+function normalizeMethod(method) {
+    let upcased = method.toUpperCase();
+    return methods.indexOf(upcased) > -1 ? upcased : method;
+}
+const RequestE = g["Request"] || RequestP;
+
+var _a$1;
+/** @internal */ const state$3 = Symbol( /* "XMLHttpRequestEventTargetState" */);
+/** @type {typeof globalThis.XMLHttpRequestEventTarget} */
 class XMLHttpRequestEventTargetP extends EventTargetP {
+    /** @internal */
     constructor() {
         if (new.target === XMLHttpRequestEventTargetP) {
             throw new TypeError("Failed to construct 'XMLHttpRequestEventTarget': Illegal constructor");
         }
         super();
-        this[state$5] = new XMLHttpRequestEventTargetState(this);
-    }
-    get onabort() { return this[state$5].onabort; }
-    set onabort(value) { this[state$5].onabort = value; attach.call(this[state$5], "abort"); }
-    get onerror() { return this[state$5].onerror; }
-    set onerror(value) { this[state$5].onerror = value; attach.call(this[state$5], "error"); }
-    get onload() { return this[state$5].onload; }
-    set onload(value) { this[state$5].onload = value; attach.call(this[state$5], "load"); }
-    get onloadend() { return this[state$5].onloadend; }
-    set onloadend(value) { this[state$5].onloadend = value; attach.call(this[state$5], "loadend"); }
-    get onloadstart() { return this[state$5].onloadstart; }
-    set onloadstart(value) { this[state$5].onloadstart = value; attach.call(this[state$5], "loadstart"); }
-    get onprogress() { return this[state$5].onprogress; }
-    set onprogress(value) { this[state$5].onprogress = value; attach.call(this[state$5], "progress"); }
-    get ontimeout() { return this[state$5].ontimeout; }
-    set ontimeout(value) { this[state$5].ontimeout = value; attach.call(this[state$5], "timeout"); }
-    toString() { return "[object XMLHttpRequestEventTarget]"; }
-    get isPolyfill() { return { symbol: polyfill, hierarchy: ["XMLHttpRequestEventTarget", "EventTarget"] }; }
-}
-defineStringTag(XMLHttpRequestEventTargetP, "XMLHttpRequestEventTarget");
+        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"); }
+    /** @internal */ toString() { return "[object XMLHttpRequestEventTarget]"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["XMLHttpRequestEventTarget", "EventTarget"] }; }
+}
+Class_setStringTag(XMLHttpRequestEventTargetP, "XMLHttpRequestEventTarget");
 /** @internal */
 const _handlers$1 = Symbol();
 /** @internal */
 class XMLHttpRequestEventTargetState {
     /**
-     * @param _target XMLHttpRequestEventTargetP
+     * @param _target XMLHttpRequestEventTarget
      */
     constructor(_target) {
-        this[_a$3] = getHandlers$1.call(this);
+        this[_a$1] = getHandlers$1(this);
         this.onabort = null;
         this.onerror = null;
         this.onload = null;
@@ -1476,45 +2229,50 @@ class XMLHttpRequestEventTargetState {
         this.target = _target;
     }
 }
-_a$3 = _handlers$1;
-function attach(type) {
+_a$1 = _handlers$1;
+function attach(target, type) {
+    const s = target[state$3];
     const fnName = ("on" + type);
-    const cb = this[fnName];
-    const listener = this[_handlers$1][fnName];
-    attachFn.call(this.target, type, cb, listener);
+    const cb = s[fnName];
+    const listener = s[_handlers$1][fnName];
+    attachFn(target, type, cb, listener);
 }
-function getHandlers$1() {
+function getHandlers$1(s) {
     return {
-        onabort: (ev) => { executeFn.call(this.target, this.onabort, ev); },
-        onerror: (ev) => { executeFn.call(this.target, this.onerror, ev); },
-        onload: (ev) => { executeFn.call(this.target, this.onload, ev); },
-        onloadend: (ev) => { executeFn.call(this.target, this.onloadend, ev); },
-        onloadstart: (ev) => { executeFn.call(this.target, this.onloadstart, ev); },
-        onprogress: (ev) => { executeFn.call(this.target, this.onprogress, ev); },
-        ontimeout: (ev) => { executeFn.call(this.target, this.ontimeout, ev); },
+        onabort: (ev) => { executeFn(s.target, s.onabort, ev); },
+        onerror: (ev) => { executeFn(s.target, s.onerror, ev); },
+        onload: (ev) => { executeFn(s.target, s.onload, ev); },
+        onloadend: (ev) => { executeFn(s.target, s.onloadend, ev); },
+        onloadstart: (ev) => { executeFn(s.target, s.onloadstart, ev); },
+        onprogress: (ev) => { executeFn(s.target, s.onprogress, ev); },
+        ontimeout: (ev) => { executeFn(s.target, s.ontimeout, ev); },
     };
 }
 
+/** @type {typeof globalThis.XMLHttpRequestUpload} */
 class XMLHttpRequestUploadP extends XMLHttpRequestEventTargetP {
+    /** @internal */
     constructor() {
         if (new.target === XMLHttpRequestUploadP) {
             throw new TypeError("Failed to construct 'XMLHttpRequestUpload': Illegal constructor");
         }
         super();
     }
-    toString() { return "[object XMLHttpRequestUpload]"; }
-    get isPolyfill() { return { symbol: polyfill, hierarchy: ["XMLHttpRequestUpload", "XMLHttpRequestEventTarget", "EventTarget"] }; }
+    /** @internal */ toString() { return "[object XMLHttpRequestUpload]"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["XMLHttpRequestUpload", "XMLHttpRequestEventTarget", "EventTarget"] }; }
 }
-defineStringTag(XMLHttpRequestUploadP, "XMLHttpRequestUpload");
-function createXMLHttpRequestUploadP() {
-    let instance = Object.create(XMLHttpRequestUploadP.prototype);
-    instance[state$f] = new EventTargetState(instance);
-    instance[state$5] = new XMLHttpRequestEventTargetState(instance);
-    return instance;
+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);
+    return upload;
 }
 
 // @ts-nocheck
-const mp = (() => {
+/** @internal */
+const mp$2 = (() => {
     let u = "undefined", r = "request", f = "function";
     let mp;
     mp =
@@ -1539,7 +2297,7 @@ const mp = (() => {
     return mp;
 })();
 
-const request = mp ? mp.request : function errorRequest(options) {
+const request = mp$2 ? mp$2.request : function errorRequest(options) {
     const errMsg = "NOT_SUPPORTED_ERR";
     const errno = 9;
     const err = {
@@ -1558,7 +2316,7 @@ const request = mp ? mp.request : function errorRequest(options) {
         }
     }
     catch (e) {
-        console.warn(e);
+        console.error(e);
     } })
         .then(() => { if (options.complete) {
         options.complete(err);
@@ -1566,144 +2324,159 @@ const request = mp ? mp.request : function errorRequest(options) {
     throw new ReferenceError("request is not defined");
 };
 
-var _a$2, _b$1, _c, _d, _e, _f, _g, _h, _j, _k;
+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$4 = Symbol( /* "XMLHttpRequestState" */);
+const state$2 = Symbol( /* "XMLHttpRequestState" */);
+/** @type {typeof globalThis.XMLHttpRequest} */
 class XMLHttpRequestP extends XMLHttpRequestEventTargetP {
     constructor() {
         super();
-        this[state$4] = new XMLHttpRequestState(this);
+        this[state$2] = new XMLHttpRequestState(this);
     }
-    get readyState() { return this[state$4].readyState; }
-    get response() { return this[state$4].response; }
+    get readyState() { return this[state$2].readyState; }
+    get response() { return this[state$2].response; }
     get responseText() { return (!this.responseType || this.responseType === "text") ? this.response : ""; }
-    get responseType() { return this[state$4].responseType; }
-    set responseType(value) { this[state$4].responseType = value; }
-    get responseURL() { return this[state$4].responseURL; }
+    get responseType() { return this[state$2].responseType; }
+    set responseType(value) { this[state$2].responseType = normalizeResponseType(value); }
+    get responseURL() { return this[state$2].responseURL; }
     get responseXML() { return null; }
-    get status() { return this[state$4].status; }
+    get status() { return this[state$2].status; }
     get statusText() {
         if (this.readyState === XMLHttpRequestP.UNSENT || this.readyState === XMLHttpRequestP.OPENED)
             return "";
-        return this[state$4].statusText || statusTextMap(this.status);
+        return this[state$2].statusText || statusTextMap(this.status);
     }
-    get timeout() { return this[state$4].timeout; }
-    set timeout(value) { this[state$4].timeout = value; }
+    get timeout() { return this[state$2].timeout; }
+    set timeout(value) { this[state$2].timeout = value > 0 ? value : 0; }
     get upload() {
-        const that = this[state$4];
-        if (!that.upload) {
-            that.upload = createXMLHttpRequestUploadP();
+        const s = this[state$2];
+        if (!s.upload) {
+            s.upload = createXMLHttpRequestUpload();
         }
-        return that.upload;
+        return s.upload;
     }
-    get withCredentials() { return this[state$4].withCredentials; }
-    set withCredentials(value) { this[state$4].withCredentials = value; }
+    get withCredentials() { return this[state$2].withCredentials; }
+    set withCredentials(value) { this[state$2].withCredentials = !!value; }
     abort() {
-        clearRequest.call(this[state$4]);
+        clearRequest(this);
     }
     getAllResponseHeaders() {
-        if (!this[state$4][_responseHeaders])
+        if (!this[state$2][_responseHeaders])
             return "";
-        return objectEntries(this[state$4][_responseHeaders] || {}).map(([k, v]) => `${k}: ${v}\r\n`).join("");
+        return Array.from(this[state$2][_responseHeaders].entries()).map(([k, v]) => `${k}: ${v}\r\n`).join("");
     }
-    getResponseHeader(name) {
-        var _l, _m;
-        if (!this[state$4][_responseHeaders])
+    getResponseHeader(...args) {
+        const [name] = args;
+        checkArgsLength(args, 1, "XMLHttpRequest", "getResponseHeader");
+        if (!this[state$2][_responseHeaders])
             return null;
-        let nameKey = name.toLowerCase();
-        return (_m = (_l = objectEntries(this[state$4][_responseHeaders] || {}).find(x => x[0].toLowerCase() === nameKey)) === null || _l === void 0 ? void 0 : _l[1]) !== null && _m !== void 0 ? _m : null;
+        return this[state$2][_responseHeaders].get(name);
     }
     open(...args) {
         const [method, url, async = true, username = null, password = null] = args;
-        const that = this[state$4];
-        if (args.length < 2) {
-            throw new TypeError(`Failed to execute 'open' on 'XMLHttpRequest': 2 arguments required, but only ${args.length} present.`);
-        }
+        checkArgsLength(args, 2, "XMLHttpRequest", "open");
         if (!async) {
             console.warn("Synchronous XMLHttpRequest is not supported because of its detrimental effects to the end user's experience.");
         }
-        clearRequest.call(that, false);
-        that[_method] = normalizeMethod(method);
-        that[_requestURL] = String(url);
+        const s = this[state$2];
+        clearRequest(this, false);
+        s[_method] = normalizeMethod(method);
+        s[_requestURL] = "" + url;
         if (username !== null || password !== null) {
-            let _username = String(username !== null && username !== void 0 ? username : "");
-            let _password = String(password !== null && password !== void 0 ? password : "");
+            let _username = "" + (username !== null && username !== void 0 ? username : "");
+            let _password = "" + (password !== null && password !== void 0 ? password : "");
             if (_username.length > 0 || _password.length > 0) {
-                let auth = `Basic ${u8array2base64((new TextEncoderP()).encode(_username + ":" + _password))}`;
+                let auth = `Basic ${Uint8Array_toBase64(encode$1(_username + ":" + _password))}`;
                 this.setRequestHeader("Authorization", auth);
             }
         }
-        that[_inAfterOpenBeforeSend] = true;
-        setReadyStateAndNotify.call(that, XMLHttpRequestP.OPENED);
+        s[_inAfterOpenBeforeSend] = true;
+        setReadyStateAndNotify(this, XMLHttpRequestP.OPENED);
     }
-    overrideMimeType(mime) {
-        if (this[state$4][_inAfterOpenBeforeSend]) {
-            console.warn(`XMLHttpRequest.overrideMimeType('${mime}') is not implemented: The method will have no effect on response parsing.`);
+    overrideMimeType(...args) {
+        const [mime] = args;
+        checkArgsLength(args, 1, "XMLHttpRequest", "overrideMimeType");
+        if (this[state$2][_inAfterOpenBeforeSend]) {
+            console.error(`TypeError: Failed to execute 'overrideMimeType' on 'XMLHttpRequest': mimeType ('${mime}') not implemented.`);
         }
     }
     send(body) {
-        const that = this[state$4];
-        if (!that[_inAfterOpenBeforeSend] || that.readyState !== XMLHttpRequestP.OPENED) {
+        const s = this[state$2];
+        if (!s[_inAfterOpenBeforeSend] || s.readyState !== XMLHttpRequestP.OPENED) {
             throw new MPException("Failed to execute 'send' on 'XMLHttpRequest': The object's state must be OPENED.", "InvalidStateError");
         }
-        that[_inAfterOpenBeforeSend] = false;
-        const allowsRequestBody = that[_method] !== "GET" && that[_method] !== "HEAD";
-        const processHeaders = allowsRequestBody && Object.keys(that[_requestHeaders]).map(x => x.toLowerCase()).indexOf("content-type") === -1;
-        const upload = that.upload;
-        const processContentLength = upload && upload[state$f][_executors].length > 0;
-        let headers = processHeaders ? Object.assign({}, that[_requestHeaders]) : that[_requestHeaders];
+        s[_inAfterOpenBeforeSend] = false;
+        const allowsRequestBody = s[_method] !== "GET" && s[_method] !== "HEAD";
+        const processHeaders = allowsRequestBody && !s[_requestHeaders].has("Content-Type");
+        const processContentLength = allowsRequestBody && !!body;
+        let headers = () => { let dict = {}; s[_requestHeaders].forEach((value, name) => { dict[name] = value; }); return dict; };
         let contentLength = zero;
-        let data = convert(body, processHeaders ? v => { assignRequestHeader(headers, "Content-Type", v); } : void 0, processContentLength ? v => { contentLength = v; } : void 0);
+        const processHeadersFn = processHeaders ? (v) => { s[_requestHeaders].set("Content-Type", v); } : void 0;
+        const processContentLengthFn = processContentLength ? (v) => { contentLength = v; } : void 0;
+        let data = body;
+        try {
+            data = convert(body, false, processHeadersFn, processContentLengthFn);
+        }
+        catch (e) {
+            console.warn(e);
+        }
         let options = {
-            url: that[_requestURL],
-            method: that[_method],
-            header: headers,
+            url: s[_requestURL],
+            method: s[_method],
+            header: headers(),
             data,
-            dataType: that.responseType === "json" ? "json" : normalizeDataType(that.responseType),
-            responseType: normalizeDataType(that.responseType),
-            success: requestSuccess.bind(that),
-            fail: requestFail.bind(that),
-            complete: requestComplete.bind(that),
+            dataType: s.responseType === "json" ? "json" : normalizeDataType(s.responseType),
+            responseType: normalizeDataType(s.responseType),
+            withCredentials: s.withCredentials,
+            success: requestSuccess.bind(this),
+            fail: requestFail.bind(this),
+            complete: requestComplete.bind(this),
         };
-        if (that.withCredentials) {
-            options.withCredentials = true;
-            options.enableCookie = true;
-        }
-        that[_requestTask] = request(options);
+        s[_requestTask] = mp$1.request(options);
         emitProcessEvent(this, "loadstart");
-        if (processContentLength) {
-            const hasRequestBody = allowsRequestBody && (typeof data === "string" ? data.length > 0 : data.byteLength > 0);
-            if (hasRequestBody) {
-                emitProcessEvent(upload, "loadstart", 0, contentLength);
-            }
-            setTimeout(() => {
-                const _aborted = that[_inAfterOpenBeforeSend] || that.readyState !== XMLHttpRequestP.OPENED;
+        if (processContentLength && s.upload) {
+            emitProcessEvent(this.upload, "loadstart", 0, contentLength);
+        }
+        setTimeout(() => {
+            if (s.upload) {
+                const _aborted = s[_inAfterOpenBeforeSend] || s.readyState !== XMLHttpRequestP.OPENED;
                 const _contentLength = _aborted ? 0 : contentLength;
                 if (_aborted) {
-                    emitProcessEvent(upload, "abort");
+                    emitProcessEvent(this.upload, "abort");
                 }
                 else {
-                    if (hasRequestBody) {
-                        emitProcessEvent(upload, "load", _contentLength, _contentLength);
+                    if (processContentLength) {
+                        emitProcessEvent(this.upload, "load", _contentLength, _contentLength);
                     }
                 }
-                if (_aborted || hasRequestBody) {
-                    emitProcessEvent(upload, "loadend", _contentLength, _contentLength);
+                if (_aborted || processContentLength) {
+                    emitProcessEvent(this.upload, "loadend", _contentLength, _contentLength);
                 }
-            });
-        }
-        checkRequestTimeout.call(that);
+            }
+        });
+        checkRequestTimeout(this);
     }
-    setRequestHeader(name, value) {
-        assignRequestHeader(this[state$4][_requestHeaders], name, value);
+    setRequestHeader(...args) {
+        const [name, value] = args;
+        checkArgsLength(args, 2, "XMLHttpRequest", "setRequestHeader");
+        const s = this[state$2];
+        if (!s[_inAfterOpenBeforeSend] || s.readyState !== XMLHttpRequestP.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);
     }
-    get onreadystatechange() { return this[state$4].onreadystatechange; }
+    get onreadystatechange() { return this[state$2].onreadystatechange; }
     set onreadystatechange(value) {
-        this[state$4].onreadystatechange = value;
-        attachFn.call(this, "readystatechange", value, this[state$4][_handlers].onreadystatechange);
+        this[state$2].onreadystatechange = value;
+        attachFn(this, "readystatechange", value, this[state$2][_handlers].onreadystatechange);
     }
-    toString() { return "[object XMLHttpRequest]"; }
-    get isPolyfill() { return { symbol: polyfill, hierarchy: ["XMLHttpRequest", "XMLHttpRequestEventTarget", "EventTarget"] }; }
+    /** @internal */ toString() { return "[object XMLHttpRequest]"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["XMLHttpRequest", "XMLHttpRequestEventTarget", "EventTarget"] }; }
 }
 const properties = {
     UNSENT: { value: 0, enumerable: true },
@@ -1714,7 +2487,7 @@ const properties = {
 };
 Object.defineProperties(XMLHttpRequestP, properties);
 Object.defineProperties(XMLHttpRequestP.prototype, properties);
-defineStringTag(XMLHttpRequestP, "XMLHttpRequest");
+Class_setStringTag(XMLHttpRequestP, "XMLHttpRequest");
 /** @internal */ const _handlers = Symbol();
 /** @internal */ const _inAfterOpenBeforeSend = Symbol();
 /** @internal */ const _resetPending = Symbol();
@@ -1722,7 +2495,7 @@ defineStringTag(XMLHttpRequestP, "XMLHttpRequest");
 /** @internal */ const _requestURL = Symbol();
 /** @internal */ const _method = Symbol();
 /** @internal */ const _requestHeaders = Symbol();
-const _responseHeaders = Symbol();
+/** @internal */ const _responseHeaders = Symbol();
 /** @internal */ const _responseContentLength = Symbol();
 /** @internal */ const _requestTask = Symbol();
 /** @internal */
@@ -1736,40 +2509,41 @@ class XMLHttpRequestState {
         this.statusText = "";
         this.timeout = 0;
         this.withCredentials = false;
-        this[_a$2] = getHandlers.call(this);
+        this[_a] = getHandlers(this);
         this.onreadystatechange = null;
-        this[_b$1] = false;
+        this[_b] = false;
         this[_c] = false;
         this[_d] = 0;
         this[_e] = "";
         this[_f] = "GET";
-        this[_g] = { Accept: "*/*" };
+        this[_g] = new HeadersP();
         this[_h] = null;
         this[_j] = zero;
         this[_k] = null;
         this.target = target;
     }
 }
-_a$2 = _handlers, _b$1 = _inAfterOpenBeforeSend, _c = _resetPending, _d = _timeoutId, _e = _requestURL, _f = _method, _g = _requestHeaders, _h = _responseHeaders, _j = _responseContentLength, _k = _requestTask;
+_a = _handlers, _b = _inAfterOpenBeforeSend, _c = _resetPending, _d = _timeoutId, _e = _requestURL, _f = _method, _g = _requestHeaders, _h = _responseHeaders, _j = _responseContentLength, _k = _requestTask;
 function requestSuccess({ statusCode, header, data }) {
-    this.responseURL = this[_requestURL];
-    this.status = statusCode;
-    this[_responseHeaders] = header;
-    let lengthStr = this.target.getResponseHeader("Content-Length");
-    this[_responseContentLength] = () => { return lengthStr ? parseInt(lengthStr) : 0; };
-    if (this.readyState === XMLHttpRequestP.OPENED) {
-        setReadyStateAndNotify.call(this, XMLHttpRequestP.HEADERS_RECEIVED);
-        setReadyStateAndNotify.call(this, XMLHttpRequestP.LOADING);
+    const s = this[state$2];
+    s.responseURL = s[_requestURL];
+    s.status = statusCode;
+    s[_responseHeaders] = new HeadersP(header);
+    let lengthStr = s[_responseHeaders].get("Content-Length");
+    s[_responseContentLength] = () => { return lengthStr ? parseInt(lengthStr) : 0; };
+    if (s.readyState === XMLHttpRequestP.OPENED) {
+        setReadyStateAndNotify(this, XMLHttpRequestP.HEADERS_RECEIVED);
+        setReadyStateAndNotify(this, XMLHttpRequestP.LOADING);
         setTimeout(() => {
-            if (!this[_inAfterOpenBeforeSend]) {
-                let l = this[_responseContentLength];
+            if (!s[_inAfterOpenBeforeSend]) {
+                let l = s[_responseContentLength];
                 try {
-                    this.response = convertBack(this.responseType, data);
-                    emitProcessEvent(this.target, "load", l, l);
+                    s.response = convertBack(s.responseType, data);
+                    emitProcessEvent(this, "load", l, l);
                 }
                 catch (e) {
                     console.error(e);
-                    emitProcessEvent(this.target, "error");
+                    emitProcessEvent(this, "error");
                 }
             }
         });
@@ -1783,193 +2557,115 @@ function requestFail(err) {
     // returned from the server: status, headers, and data.
     // In the browser's XMLHttpRequest, these two errors (Error 14 and Error 19)
     // differ from those in Alipay Mini Programs and should instead return normally.
-    // Therefore, this scenario is also handled here as a successful request response.
-    if ("status" in err) {
-        requestSuccess.call(this, { statusCode: err.status, header: err.headers, data: err.data });
-        return;
-    }
-    this.status = 0;
-    this.statusText = "errMsg" in err ? err.errMsg : "errorMessage" in err ? err.errorMessage : "";
-    if (!this[_inAfterOpenBeforeSend] && this.readyState !== XMLHttpRequestP.UNSENT && this.readyState !== XMLHttpRequestP.DONE) {
-        emitProcessEvent(this.target, "error");
-        resetRequestTimeout.call(this);
-    }
-}
-function requestComplete() {
-    this[_requestTask] = null;
-    if (!this[_inAfterOpenBeforeSend] && (this.readyState === XMLHttpRequestP.OPENED || this.readyState === XMLHttpRequestP.LOADING)) {
-        setReadyStateAndNotify.call(this, XMLHttpRequestP.DONE);
-    }
-    setTimeout(() => {
-        if (!this[_inAfterOpenBeforeSend]) {
-            let l = this[_responseContentLength];
-            emitProcessEvent(this.target, "loadend", l, l);
-        }
-    });
-}
-function clearRequest(delay = true) {
-    const timerFn = delay ? setTimeout : (f) => { f(); };
-    this[_resetPending] = true;
-    if (this[_requestTask] && this.readyState !== XMLHttpRequestP.DONE) {
-        if (delay) {
-            setReadyStateAndNotify.call(this, XMLHttpRequestP.DONE);
-        }
-        timerFn(() => {
-            const requestTask = this[_requestTask];
-            if (requestTask) {
-                requestTask.abort();
-            }
-            if (delay) {
-                emitProcessEvent(this.target, "abort");
-            }
-            if (delay && !requestTask) {
-                emitProcessEvent(this.target, "loadend");
-            }
-        });
-    }
-    timerFn(() => {
-        if (this[_resetPending]) {
-            if (delay) {
-                this.readyState = XMLHttpRequestP.UNSENT;
-            }
-            resetXHR.call(this);
-        }
-    });
-}
-function checkRequestTimeout() {
-    if (this.timeout) {
-        this[_timeoutId] = setTimeout(() => {
-            if (!this.status && this.readyState !== XMLHttpRequestP.DONE) {
-                if (this[_requestTask])
-                    this[_requestTask].abort();
-                setReadyStateAndNotify.call(this, XMLHttpRequestP.DONE);
-                emitProcessEvent(this.target, "timeout");
-            }
-        }, this.timeout);
-    }
-}
-function resetXHR() {
-    this[_resetPending] = false;
-    resetRequestTimeout.call(this);
-    this.response = "";
-    this.responseURL = "";
-    this.status = 0;
-    this.statusText = "";
-    this[_requestHeaders] = {};
-    this[_responseHeaders] = null;
-    this[_responseContentLength] = zero;
-}
-function resetRequestTimeout() {
-    if (this[_timeoutId]) {
-        clearTimeout(this[_timeoutId]);
-        this[_timeoutId] = 0;
-    }
-}
-function setReadyStateAndNotify(value) {
-    let hasChanged = value !== this.readyState;
-    this.readyState = value;
-    if (hasChanged) {
-        let evt = createInnerEvent(this.target, "readystatechange");
-        fire.call(this.target[state$f], evt);
-    }
-}
-function getHandlers() {
-    return {
-        onreadystatechange: (ev) => { executeFn.call(this.target, this.onreadystatechange, ev); },
-    };
-}
-// HTTP methods whose capitalization should be normalized
-const methods = ["CONNECT", "DELETE", "GET", "HEAD", "OPTIONS", "PATCH", "POST", "PUT", "TRACE"];
-function normalizeMethod(method) {
-    let upcased = method.toUpperCase();
-    return methods.indexOf(upcased) > -1 ? upcased : method;
-}
-function normalizeDataType(responseType) {
-    return (responseType === "blob" || responseType === "arraybuffer") ? "arraybuffer" : "text";
-}
-function assignRequestHeader(headers, name, value) {
-    let nameKey = name.toLowerCase();
-    for (let key of Object.keys(headers)) {
-        if (key.toLowerCase() === nameKey) {
-            headers[key] = value;
-            return;
-        }
-    }
-    Object.assign(headers, { [name]: value });
-    return;
-}
-const encode = (str) => {
-    const encoder = new TextEncoderP();
-    return encoder.encode(str).buffer;
-};
-const decode = (buf) => {
-    let decoder = new TextDecoderP();
-    return decoder.decode(buf);
-};
-function convert(body, setContentType, setContentLength) {
-    let result;
-    if (typeof body === "string") {
-        result = body;
-        if (setContentType) {
-            setContentType("text/plain;charset=UTF-8");
-        }
-    }
-    else if (isObjectType("URLSearchParams", body)) {
-        result = body.toString();
-        if (setContentType) {
-            setContentType("application/x-www-form-urlencoded;charset=UTF-8");
-        }
-    }
-    else if (body instanceof ArrayBuffer) {
-        result = body.slice(0);
-    }
-    else if (ArrayBuffer.isView(body)) {
-        result = body.buffer.slice(body.byteOffset, body.byteOffset + body.byteLength);
-    }
-    else if (isPolyfillType("Blob", body)) {
-        result = body[state$c].toArrayBuffer().slice(0);
-        if (setContentType && body.type) {
-            setContentType(body.type);
-        }
-    }
-    else if (isPolyfillType("FormData", body)) {
-        let blob = body[state$9].toBlob();
-        result = blob[state$c].toArrayBuffer();
-        if (setContentType) {
-            setContentType(blob.type);
-        }
-    }
-    else if (!body) {
-        result = "";
-    }
-    else {
-        result = String(body);
-    }
-    if (setContentLength) {
-        setContentLength(() => {
-            return (typeof result === "string" ? encode(result) : result).byteLength;
-        });
-    }
-    return result;
-}
-function convertBack(type, data) {
-    let temp = !!data ? (typeof data !== "string" && !(data instanceof ArrayBuffer) ? JSON.stringify(data) : data) : "";
-    if (!type || type === "text") {
-        return typeof temp === "string" ? temp : decode(temp);
+    // Therefore, this scenario is also handled here as a successful request response.
+    if ("status" in err) {
+        requestSuccess.call(this, { statusCode: err.status, header: err.headers, data: err.data });
+        return;
     }
-    else if (type === "json") {
-        return JSON.parse(typeof temp === "string" ? temp : decode(temp));
+    const s = this[state$2];
+    s.status = 0;
+    s.statusText = "errMsg" in err ? err.errMsg : "errorMessage" in err ? err.errorMessage : "";
+    if (!s[_inAfterOpenBeforeSend] && s.readyState !== XMLHttpRequestP.UNSENT && s.readyState !== XMLHttpRequestP.DONE) {
+        emitProcessEvent(this, "error");
+        resetRequestTimeout(this);
     }
-    else if (type === "arraybuffer") {
-        return temp instanceof ArrayBuffer ? temp.slice(0) : encode(temp);
+}
+function requestComplete() {
+    const s = this[state$2];
+    s[_requestTask] = null;
+    if (!s[_inAfterOpenBeforeSend] && (s.readyState === XMLHttpRequestP.OPENED || s.readyState === XMLHttpRequestP.LOADING)) {
+        setReadyStateAndNotify(this, XMLHttpRequestP.DONE);
     }
-    else if (type === "blob") {
-        return new BlobP([temp]);
+    setTimeout(() => {
+        if (!s[_inAfterOpenBeforeSend]) {
+            let l = s[_responseContentLength];
+            emitProcessEvent(this, "loadend", l, l);
+        }
+    });
+}
+function clearRequest(xhr, delay = true) {
+    const s = xhr[state$2];
+    const timerFn = delay ? setTimeout : (f) => { f(); };
+    s[_resetPending] = true;
+    if (s[_requestTask] && s.readyState !== XMLHttpRequestP.DONE) {
+        if (delay) {
+            setReadyStateAndNotify(xhr, XMLHttpRequestP.DONE);
+        }
+        timerFn(() => {
+            const requestTask = s[_requestTask];
+            if (requestTask) {
+                requestTask.abort();
+            }
+            if (delay) {
+                emitProcessEvent(xhr, "abort");
+            }
+            if (delay && !requestTask) {
+                emitProcessEvent(xhr, "loadend");
+            }
+        });
     }
-    else {
-        return temp;
+    timerFn(() => {
+        if (s[_resetPending]) {
+            if (delay) {
+                s.readyState = XMLHttpRequestP.UNSENT;
+            }
+            resetXHR(xhr);
+        }
+    });
+}
+function checkRequestTimeout(xhr) {
+    const s = xhr[state$2];
+    if (s.timeout) {
+        s[_timeoutId] = setTimeout(() => {
+            if (!s.status && s.readyState !== XMLHttpRequestP.DONE) {
+                if (s[_requestTask])
+                    s[_requestTask].abort();
+                setReadyStateAndNotify(xhr, XMLHttpRequestP.DONE);
+                emitProcessEvent(xhr, "timeout");
+            }
+        }, s.timeout);
+    }
+}
+function resetXHR(xhr) {
+    const s = xhr[state$2];
+    s[_resetPending] = false;
+    resetRequestTimeout(xhr);
+    s.response = "";
+    s.responseURL = "";
+    s.status = 0;
+    s.statusText = "";
+    s[_requestHeaders] = new HeadersP();
+    s[_responseHeaders] = null;
+    s[_responseContentLength] = zero;
+}
+function resetRequestTimeout(xhr) {
+    const s = xhr[state$2];
+    if (s[_timeoutId]) {
+        clearTimeout(s[_timeoutId]);
+        s[_timeoutId] = 0;
+    }
+}
+function setReadyStateAndNotify(xhr, value) {
+    const s = xhr[state$2];
+    let hasChanged = value !== s.readyState;
+    s.readyState = value;
+    if (hasChanged) {
+        let evt = createInnerEvent(xhr, "readystatechange");
+        EventTarget_fire(xhr, evt);
     }
 }
+function getHandlers(s) {
+    return {
+        onreadystatechange: (ev) => { executeFn(s.target, s.onreadystatechange, ev); },
+    };
+}
+const responseTypes = ["", "text", "json", "arraybuffer", "blob", "document"];
+function normalizeResponseType(responseType) {
+    return responseTypes.indexOf(responseType) > -1 ? responseType : "";
+}
+function normalizeDataType(responseType) {
+    return (responseType === "blob" || responseType === "arraybuffer") ? "arraybuffer" : "text";
+}
 const zero = () => 0;
 const statusMessages = {
     100: "Continue",
@@ -2039,425 +2735,81 @@ function statusTextMap(val) {
 }
 const XMLHttpRequestE = (typeof XMLHttpRequest !== "undefined" && XMLHttpRequest) || XMLHttpRequestP;
 
-var _a$1, _b;
-/** @internal */
-const state$3 = Symbol( /* "BodyState" */);
-class BodyP {
-    constructor() {
-        if (new.target === BodyP) {
-            throw new TypeError("Failed to construct 'Body': Illegal constructor");
-        }
-        this[state$3] = new BodyState();
-    }
-    get body() {
-        if (!this[state$3][_body]) {
-            return null;
-        }
-        throw new ReferenceError("ReadableStream is not defined");
-    }
-    get bodyUsed() { return this[state$3].bodyUsed; }
-    ;
-    arrayBuffer() {
-        const kind = "arrayBuffer";
-        return consumed.call(this[state$3], kind) || read.call(this[state$3], kind);
-    }
-    blob() {
-        const kind = "blob";
-        return consumed.call(this[state$3], kind) || read.call(this[state$3], kind);
-    }
-    bytes() {
-        const kind = "bytes";
-        return consumed.call(this[state$3], kind) || read.call(this[state$3], kind);
-    }
-    formData() {
-        const kind = "formData";
-        return consumed.call(this[state$3], kind) || read.call(this[state$3], kind);
-    }
-    json() {
-        const kind = "json";
-        return consumed.call(this[state$3], kind) || read.call(this[state$3], kind);
-    }
-    text() {
-        const kind = "text";
-        return consumed.call(this[state$3], kind) || read.call(this[state$3], kind);
-    }
-    toString() { return "[object Body]"; }
-    get isPolyfill() { return { symbol: polyfill, hierarchy: ["Body"] }; }
-}
-defineStringTag(BodyP, "Body");
-const _name = Symbol();
-const _body = Symbol();
-/** @internal */
-class BodyState {
-    constructor() {
-        this.bodyUsed = false;
-        this[_a$1] = "Body";
-        this[_b] = "";
-    }
-}
-_a$1 = _name, _b = _body;
-function initFn(body, headers) {
-    if (isObjectType("ReadableStream", body)) {
-        throw new ReferenceError("ReadableStream is not defined");
-    }
-    this[_body] = convert(body, type => {
-        if (headers && !headers.get("Content-Type")) {
-            headers.set("Content-Type", type);
-        }
-    });
-}
-function read(kind) {
-    return new Promise((resolve, reject) => {
-        try {
-            resolve(readSync.call(this, kind));
-        }
-        catch (e) {
-            reject(e);
-        }
-    });
-}
-function readSync(kind) {
-    if (kind === "arrayBuffer") {
-        return convertBack("arraybuffer", this[_body]);
-    }
-    else if (kind === "blob") {
-        return convertBack("blob", this[_body]);
-    }
-    else if (kind === "bytes") {
-        let arrayBuffer = convertBack("arraybuffer", this[_body]);
-        return new Uint8Array(arrayBuffer);
-    }
-    else if (kind === "formData") {
-        let text = convertBack("text", this[_body]);
-        return createFormDataFromBody(text);
-    }
-    else if (kind === "json") {
-        return convertBack("json", this[_body]);
-    }
-    else {
-        return convertBack("text", this[_body]);
-    }
-}
-function consumed(kind) {
-    if (!this[_body])
-        return;
-    if (this.bodyUsed) {
-        return Promise.reject(new TypeError(`TypeError: Failed to execute '${kind}' on '${this[_name]}': body stream already read`));
-    }
-    this.bodyUsed = true;
-}
-
-var _a;
-/** @internal */
-const state$2 = Symbol( /* "HeadersState" */);
-class HeadersP {
-    constructor(init) {
-        this[state$2] = new HeadersState();
-        if (isObjectType("Headers", init)) {
-            init.forEach((value, name) => {
-                this.append(name, value);
-            });
-        }
-        else if (Array.isArray(init)) {
-            init.forEach(header => {
-                if (!Array.isArray(header)) {
-                    throw new TypeError("Failed to construct 'Headers': The provided value cannot be converted to a sequence.");
-                }
-                if (header.length !== 2) {
-                    throw new TypeError("Failed to construct 'Headers': Invalid value");
-                }
-                this.append(header[0], header[1]);
-            });
-        }
-        else if (init) {
-            objectEntries(init).forEach(([name, value]) => {
-                this.append(name, value);
-            });
-        }
-    }
-    append(name, value) {
-        var _b;
-        let key = normalizeName(name, "append");
-        value = normalizeValue(value);
-        let oldValue = (_b = this[state$2][_headersMap].get(key)) === null || _b === void 0 ? void 0 : _b[1];
-        this[state$2][_headersMap].set(key, ["" + name, oldValue ? `${oldValue}, ${value}` : value]);
-    }
-    delete(name) {
-        let key = normalizeName(name, "delete");
-        this[state$2][_headersMap].delete(key);
-    }
-    get(name) {
-        var _b, _c;
-        let key = normalizeName(name, "get");
-        return (_c = (_b = this[state$2][_headersMap].get(key)) === null || _b === void 0 ? void 0 : _b[1]) !== null && _c !== void 0 ? _c : null;
-    }
-    getSetCookie() {
-        let value = this.get("Set-Cookie");
-        return value ? value.split(", ") : [];
-    }
-    has(name) {
-        let key = normalizeName(name, "has");
-        return this[state$2][_headersMap].has(key);
-    }
-    set(name, value) {
-        let key = normalizeName(name, "set");
-        this[state$2][_headersMap].set(key, ["" + name, normalizeValue(value)]);
-    }
-    forEach(callbackfn, thisArg) {
-        Array.from(this.entries()).forEach(([name, value]) => {
-            callbackfn.call(thisArg, value, name, this);
-        });
-    }
-    entries() {
-        return this[state$2][_headersMap].values();
-    }
-    keys() {
-        return Array.from(this.entries()).map(pair => pair[0]).values();
-    }
-    values() {
-        return Array.from(this.entries()).map(pair => pair[1]).values();
-    }
-    [Symbol.iterator]() {
-        return this.entries();
-    }
-    toString() { return "[object Headers]"; }
-    get isPolyfill() { return { symbol: polyfill, hierarchy: ["Headers"] }; }
-}
-defineStringTag(HeadersP, "Headers");
-/** @internal */
-const _headersMap = Symbol();
-/** @internal */
-class HeadersState {
-    constructor() {
-        this[_a] = new Map();
-    }
-}
-_a = _headersMap;
-function normalizeName(name, kind = "") {
-    if (typeof name !== "string") {
-        name = String(name);
-    }
-    if (/[^a-z0-9\-#$%&'*+.^_`|~!]/i.test(name) || name === "") {
-        if (kind) {
-            throw new TypeError(`Failed to execute '${kind}' on 'Headers': Invalid name`);
-        }
-    }
-    return name.toLowerCase();
-}
-function normalizeValue(value) {
-    if (typeof value !== "string") {
-        value = String(value);
-    }
-    return value;
-}
-function parseHeaders(rawHeaders) {
-    let headers = new HeadersP();
-    let preProcessedHeaders = rawHeaders.replace(/\r?\n[\t ]+/g, " ");
-    preProcessedHeaders
-        .split("\r")
-        .map(function (header) {
-        return header.indexOf("\n") === 0 ? header.substring(1, header.length) : header;
-    })
-        .forEach(function (line) {
-        let parts = line.split(":");
-        let key = parts.shift().trim();
-        if (key) {
-            let value = parts.join(":").trim();
-            try {
-                headers.append(key, value);
-            }
-            catch (error) {
-                console.warn("Response " + error.message);
-            }
-        }
-    });
-    return headers;
-}
-const HeadersE = g["Headers"] || HeadersP;
-
-/** @internal */
-const state$1 = Symbol( /* "RequestState" */);
-class RequestP extends BodyP {
-    constructor(input, init) {
+/** @internal */ const state$1 = Symbol( /* "ResponseState" */);
+/** @type {typeof globalThis.Response} */
+class ResponseP extends BodyImpl {
+    constructor(body, init) {
         super();
-        this[state$1] = new RequestState();
-        const that = this[state$1];
-        this[state$3][_name] = "Request";
-        let options = init !== null && init !== void 0 ? init : {};
-        let body = options.body;
-        if (isPolyfillType("Request", input)) {
-            if (input.bodyUsed) {
-                throw new TypeError("Failed to construct 'Request': Cannot construct a Request with a Request object that has already been used.");
-            }
-            that.credentials = input.credentials;
-            if (!options.headers) {
-                that.headers = new HeadersP(input.headers);
-            }
-            that.method = input.method;
-            that.mode = input.mode;
-            let inputSignal = input[state$1].signal;
-            if (inputSignal) {
-                that.signal = inputSignal;
-            }
-            that.url = input.url;
-            let _input = input;
-            if (!body && _input[state$3][_body] !== null) {
-                body = _input[state$3][_body];
-                _input[state$3].bodyUsed = true;
-            }
-        }
-        else {
-            that.url = String(input);
-        }
-        if (options.credentials) {
-            that.credentials = options.credentials;
-        }
-        if (options.headers) {
-            that.headers = new HeadersP(options.headers);
-        }
-        if (options.method) {
-            that.method = normalizeMethod(options.method);
-        }
-        if (options.mode) {
-            that.mode = options.mode;
-        }
-        if (options.signal) {
-            that.signal = options.signal;
-        }
-        if ((this.method === "GET" || this.method === "HEAD") && body) {
-            throw new TypeError("Failed to construct 'Request': Request with GET/HEAD method cannot have body.");
+        this[state$7].name = "Response";
+        this[state$1] = new ResponseState();
+        const s = this[state$1];
+        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'.");
+        }
+        let status = _init.status === undefined ? 200 : _init.status;
+        if (status < 200 || status > 500) {
+            throw new RangeError(`Failed to construct 'Response': The status provided (${+status}) is outside the range [200, 599].`);
         }
-        initFn.call(this[state$3], body, this.headers);
-        if (this.method === "GET" || this.method === "HEAD") {
-            if (options.cache === "no-store" || options.cache === "no-cache") {
-                // Search for a '_' parameter in the query string
-                let reParamSearch = /([?&])_=[^&]*/;
-                if (reParamSearch.test(this.url)) {
-                    // If it already exists then set the value with the current time
-                    that.url = this.url.replace(reParamSearch, "$1_=" + (new Date()).getTime());
-                }
-                else {
-                    // Otherwise add a new '_' parameter to the end with the current time
-                    let reQueryString = /\?/;
-                    that.url += (reQueryString.test(this.url) ? "&" : "?") + "_=" + (new Date()).getTime();
-                }
-            }
+        if (_init.headers) {
+            s.headers = new HeadersP(_init.headers);
         }
+        s.ok = status >= 200 && status < 300;
+        s.status = status;
+        s.statusText = _init.statusText === undefined ? "" : "" + _init.statusText;
+        Body_init(this, body);
     }
-    get cache() { return this[state$1].cache; }
-    get credentials() { return this[state$1].credentials; }
-    get destination() { return this[state$1].destination; }
     get headers() {
-        const that = this[state$1];
-        if (!that.headers) {
-            that.headers = new HeadersP();
-        }
-        return that.headers;
-    }
-    get integrity() { return this[state$1].integrity; }
-    get keepalive() { return this[state$1].keepalive; }
-    get method() { return this[state$1].method; }
-    get mode() { return this[state$1].mode; }
-    get redirect() { return this[state$1].redirect; }
-    get referrer() { return this[state$1].referrer; }
-    get referrerPolicy() { return this[state$1].referrerPolicy; }
-    get signal() {
-        const that = this[state$1];
-        if (!that.signal) {
-            that.signal = (new AbortControllerP()).signal;
+        const s = this[state$1];
+        if (!s.headers) {
+            s.headers = new HeadersP();
         }
-        return that.signal;
+        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; }
     clone() {
-        var _a;
-        return new RequestP(this, { body: (_a = this[state$3][_body]) !== null && _a !== void 0 ? _a : null });
-    }
-    toString() { return "[object Request]"; }
-    get isPolyfill() { return { symbol: polyfill, hierarchy: ["Request", "Body"] }; }
-}
-defineStringTag(RequestP, "Request");
-/** @internal */
-class RequestState {
-    constructor() {
-        this.cache = "default";
-        this.credentials = "same-origin";
-        this.destination = "";
-        this.integrity = "";
-        this.keepalive = false;
-        this.method = "GET";
-        this.mode = "cors";
-        this.redirect = "follow";
-        this.referrer = "about:client";
-        this.referrerPolicy = "";
-        this.url = "";
-    }
-}
-const RequestE = g["Request"] || RequestP;
-
-/** @internal */
-const state = Symbol( /* "ResponseState" */);
-class ResponseP extends BodyP {
-    constructor(body, init) {
-        super();
-        this[state] = new ResponseState();
-        const that = this[state];
-        this[state$3][_name] = "Response";
-        let options = init !== null && init !== void 0 ? init : {};
-        let status = options.status === undefined ? 200 : options.status;
-        if (status < 200 || status > 500) {
-            throw new RangeError(`Failed to construct 'Response': The status provided (${+status}) is outside the range [200, 599].`);
-        }
-        if (options.headers) {
-            that.headers = new HeadersP(options.headers);
+        if (this.bodyUsed) {
+            throw new TypeError("Failed to execute 'clone' on 'Response': Response body is already used");
         }
-        that.ok = this.status >= 200 && this.status < 300;
-        that.status = status;
-        that.statusText = options.statusText === undefined ? "" : "" + options.statusText;
-        initFn.call(this[state$3], body, this.headers);
-    }
-    get headers() {
-        const that = this[state];
-        if (!that.headers) {
-            that.headers = new HeadersP();
-        }
-        return that.headers;
-    }
-    get ok() { return this[state].ok; }
-    get redirected() { return this[state].redirected; }
-    get status() { return this[state].status; }
-    get statusText() { return this[state].statusText; }
-    get type() { return this[state].type; }
-    get url() { return this[state].url; }
-    clone() {
-        let response = new ResponseP(this[state$3][_body], {
+        let response = new ResponseP(Body_toPayload(this), {
             headers: new HeadersP(this.headers),
             status: this.status,
             statusText: this.statusText,
         });
-        response[state].url = this.url;
+        response[state$1].url = this.url;
         return response;
     }
-    static json(data, init) {
-        return new Response(JSON.stringify(data), init);
+    static json(...args) {
+        const [data, init] = args;
+        checkArgsLength(args, 1, "Response", "json");
+        let response = new ResponseP(typeof data === "string" ? data : JSON.stringify(data), init);
+        response.headers.set("Content-Type", "application/json");
+        return response;
     }
     static error() {
         let response = new ResponseP(null, { status: 200, statusText: "" });
-        response[state].ok = false;
-        response[state].status = 0;
-        response[state].type = "error";
+        response[state$1].ok = false;
+        response[state$1].status = 0;
+        response[state$1].type = "error";
         return response;
     }
-    static redirect(url, status = 301) {
+    static redirect(...args) {
+        const [url, status = 301] = args;
+        checkArgsLength(args, 1, "Response", "redirect");
         if ([301, 302, 303, 307, 308].indexOf(status) === -1) {
             throw new RangeError("Failed to execute 'redirect' on 'Response': Invalid status code");
         }
-        return new Response(null, { status, headers: { location: String(url) } });
+        return new ResponseP(null, { status, headers: { location: "" + url } });
     }
-    toString() { return "[object Response]"; }
-    get isPolyfill() { return { symbol: polyfill, hierarchy: ["Response", "Body"] }; }
+    /** @internal */ toString() { return "[object Response]"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["Response"] }; }
 }
-defineStringTag(ResponseP, "Response");
+Class_setStringTag(ResponseP, "Response");
 /** @internal */
 class ResponseState {
     constructor() {
@@ -2471,26 +2823,36 @@ class ResponseState {
 }
 const ResponseE = g["Response"] || ResponseP;
 
-function fetchP(input, init) {
+const mp = { XMLHttpRequest: XMLHttpRequestE };
+const setXMLHttpRequest = (XHR) => { mp.XMLHttpRequest = XHR; };
+/** @type {typeof globalThis["fetch"]} */
+function fetchP(...args) {
     if (new.target === fetchP) {
         throw new TypeError("fetch is not a constructor");
     }
-    return new Promise(function (resolve, reject) {
+    const [input, init] = args;
+    checkArgsLength(args, 1, "Window", "fetch");
+    return new Promise((resolve, reject) => {
         const request = new RequestP(input, init);
-        const signal = request[state$1].signal;
+        const signal = request[state$4].signal;
         if (signal && signal.aborted) {
             return reject(signal.reason);
         }
-        let xhr = new XMLHttpRequestE();
+        let xhr = new mp.XMLHttpRequest();
         xhr.onload = function () {
             let options = {
-                headers: xhr instanceof XMLHttpRequestP ? (new HeadersP(xhr[state$4][_responseHeaders] || undefined)) : parseHeaders(xhr.getAllResponseHeaders() || ""),
+                headers: parseHeaders(xhr.getAllResponseHeaders() || ""),
                 status: xhr.status,
                 statusText: xhr.statusText,
             };
+            // This check if specifically for when a user fetches a file locally from the file system
+            // Only if the status is out of a normal range
+            if (request.url.indexOf("file://") === 0 && (xhr.status < 200 || xhr.status > 599)) {
+                options.status = 200;
+            }
             setTimeout(() => {
-                let response = new ResponseP(xhr.response, options);
-                response[state].url = xhr.responseURL;
+                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") || "");
                 resolve(response);
             });
         };
@@ -2509,28 +2871,31 @@ function fetchP(input, init) {
                 reject(new MPException("request:fail abort", "AbortError"));
             });
         };
-        xhr.open(request.method, request.url);
+        xhr.open(request.method, request.url, true);
         if (request.credentials === "include") {
             xhr.withCredentials = true;
         }
         else if (request.credentials === "omit") {
             xhr.withCredentials = false;
         }
-        if (init && typeof init === "object" && isObjectHeaders(init.headers)) {
+        if ("responseType" in xhr) {
+            xhr.responseType = "arraybuffer";
+        }
+        if (init && typeof init === "object" && typeof init.headers === "object" && !isObjectType("Headers", init.headers)) {
             let headers = init.headers;
             let names = [];
-            objectEntries(headers).forEach(([name, value]) => {
+            Object.getOwnPropertyNames(headers).forEach(name => {
                 names.push(normalizeName(name));
-                xhr.setRequestHeader(name, normalizeValue(value));
+                xhr.setRequestHeader(name, normalizeValue(headers[name]));
             });
-            request.headers.forEach(function (value, name) {
-                if (names.indexOf(normalizeName(name)) === -1) {
+            request.headers.forEach((value, name) => {
+                if (names.indexOf(name) === -1) {
                     xhr.setRequestHeader(name, value);
                 }
             });
         }
         else {
-            request.headers.forEach(function (value, name) {
+            request.headers.forEach((value, name) => {
                 xhr.setRequestHeader(name, value);
             });
         }
@@ -2544,14 +2909,40 @@ function fetchP(input, init) {
                 }
             };
         }
-        xhr.send(request[state$3][_body]);
+        xhr.send(Body_toPayload(request));
     });
 }
-function isObjectHeaders(val) {
-    return typeof val === "object" && !isObjectType("Headers", val);
-}
 const fetchE = g["fetch"] || fetchP;
 
+const dispatched = 1;
+/** @internal */
+const state = Symbol( /* "CustomEventState" */);
+/** @type {typeof globalThis.CustomEvent} */
+class CustomEventP extends EventP {
+    constructor(type, eventInitDict) {
+        var _a;
+        super(type, eventInitDict);
+        this[state] = new CustomEventState();
+        this[state].detail = (_a = eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.detail) !== null && _a !== void 0 ? _a : null;
+    }
+    get detail() { return this[state].detail; }
+    initCustomEvent(...args) {
+        const [type, bubbles, cancelable, detail] = args;
+        checkArgsLength(args, 1, "CustomEvent", "initCustomEvent");
+        if (Event_getEtField(this, dispatched))
+            return;
+        this.initEvent(type, bubbles, cancelable);
+        this[state].detail = detail !== null && detail !== void 0 ? detail : null;
+    }
+    /** @internal */ toString() { return "[object CustomEvent]"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["CustomEvent", "Event"] }; }
+}
+Class_setStringTag(CustomEventP, "CustomEvent");
+/** @internal */
+class CustomEventState {
+}
+const CustomEventE = g["EventTarget"] ? g["CustomEvent"] : CustomEventP;
+
 exports.AbortController = AbortControllerE;
 exports.AbortControllerP = AbortControllerP;
 exports.AbortSignal = AbortSignalE;
@@ -2588,3 +2979,5 @@ exports.XMLHttpRequest = XMLHttpRequestE;
 exports.XMLHttpRequestP = XMLHttpRequestP;
 exports.fetch = fetchE;
 exports.fetchP = fetchP;
+exports.setRequest = setRequest;
+exports.setXMLHttpRequest = setXMLHttpRequest;