mphttpx 1.0.6 → 1.0.8

package/dist/index.esm.js

@@ -1,13 +1,39 @@
-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"
@@ -20,39 +46,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;
@@ -62,26 +77,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
@@ -111,28 +134,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,
     };
@@ -142,78 +167,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;
@@ -224,7 +254,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) {
@@ -233,8 +263,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)) {
@@ -243,27 +273,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)
@@ -274,101 +308,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 },
@@ -378,13 +573,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() {
@@ -398,139 +593,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) {
@@ -552,64 +810,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() {
@@ -623,356 +869,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();
@@ -983,391 +1384,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 */
@@ -1375,95 +1984,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;
@@ -1474,45 +2227,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 =
@@ -1537,7 +2295,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 = {
@@ -1556,7 +2314,7 @@ const request = mp ? mp.request : function errorRequest(options) {
         }
     }
     catch (e) {
-        console.warn(e);
+        console.error(e);
     } })
         .then(() => { if (options.complete) {
         options.complete(err);
@@ -1564,144 +2322,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 },
@@ -1712,7 +2485,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();
@@ -1720,7 +2493,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 */
@@ -1734,40 +2507,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");
                 }
             }
         });
@@ -1781,193 +2555,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",
@@ -2037,425 +2733,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() {
@@ -2469,26 +2821,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);
             });
         };
@@ -2507,28 +2869,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);
             });
         }
@@ -2542,12 +2907,38 @@ 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;
 
-export { AbortControllerE as AbortController, AbortControllerP, AbortSignalE as AbortSignal, AbortSignalP, BlobE as Blob, BlobP, CustomEventE as CustomEvent, CustomEventP, EventE as Event, EventP, EventTargetE as EventTarget, EventTargetP, FileE as File, FileP, FileReaderE as FileReader, FileReaderP, FormDataE as FormData, FormDataP, HeadersE as Headers, HeadersP, ProgressEventE as ProgressEvent, ProgressEventP, RequestE as Request, RequestP, ResponseE as Response, ResponseP, TextDecoderE as TextDecoder, TextDecoderP, TextEncoderE as TextEncoder, TextEncoderP, URLSearchParamsE as URLSearchParams, URLSearchParamsP, XMLHttpRequestE as XMLHttpRequest, XMLHttpRequestP, fetchE as fetch, fetchP };
+const dispatched = 1;
+/** @internal */
+const state = Symbol( /* "CustomEventState" */);
+/** @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;
+
+export { AbortControllerE as AbortController, AbortControllerP, AbortSignalE as AbortSignal, AbortSignalP, BlobE as Blob, BlobP, CustomEventE as CustomEvent, CustomEventP, EventE as Event, EventP, EventTargetE as EventTarget, EventTargetP, FileE as File, FileP, FileReaderE as FileReader, FileReaderP, FormDataE as FormData, FormDataP, HeadersE as Headers, HeadersP, ProgressEventE as ProgressEvent, ProgressEventP, RequestE as Request, RequestP, ResponseE as Response, ResponseP, TextDecoderE as TextDecoder, TextDecoderP, TextEncoderE as TextEncoder, TextEncoderP, URLSearchParamsE as URLSearchParams, URLSearchParamsP, XMLHttpRequestE as XMLHttpRequest, XMLHttpRequestP, fetchE as fetch, fetchP, setRequest, setXMLHttpRequest };