mphttpx 1.0.7 → 1.0.8

package/dist/index.cjs.js

@@ -1,7 +1,5 @@
 'use strict';
 
-/** @internal */
-const polyfill = Symbol("isPolyfill");
 /* eslint-disable no-prototype-builtins */
 /** @internal */ const g = (typeof globalThis !== "undefined" && globalThis) ||
     (typeof self !== "undefined" && self) ||
@@ -9,11 +7,28 @@ const polyfill = Symbol("isPolyfill");
     (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();
-        this.message = message !== null && message !== void 0 ? message : this.message;
-        this.name = name !== null && name !== void 0 ? name : this.name;
+        super(message);
+        this.name = "Error";
+        if (name) {
+            this.name = name;
+        }
     }
 }
 /** @internal */
@@ -33,35 +48,28 @@ function isPolyfillType(name, value) {
         && Array.isArray(value.isPolyfill.hierarchy)
         && value.isPolyfill.hierarchy.indexOf(name) > -1;
 }
-/** @internal */
-function dfStringTag(targetFunc, stringTag) {
-    Object.defineProperty(targetFunc.prototype, Symbol.toStringTag, {
-        configurable: true,
-        value: stringTag,
-    });
-}
-/** @internal */
-function objectValues(obj) {
-    return Object.keys(obj).map(key => obj[key]);
-}
-/** @internal */
-function objectEntries(obj) {
-    return Object.keys(obj).map(key => [key, obj[key]]);
-}
 
+/** @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"] }; }
 }
-dfStringTag(TextEncoderP, "TextEncoder");
+Class_setStringTag(TextEncoderP, "TextEncoder");
 function encodeText(input, destination) {
     const HAS_DESTINATION = typeof destination !== "undefined";
     let pos = 0;
@@ -71,26 +79,34 @@ function encodeText(input, destination) {
     let tlen = Math.max(32, len + (len >> 1) + 7); // 1.5x size
     let target = HAS_DESTINATION ? destination : new Uint8Array((tlen >> 3) << 3); // ... but at 8 byte offset
     while (pos < len) {
-        let value = input.charCodeAt(pos++);
+        let value = input.charCodeAt(pos);
+        let codeUnitCount = 1;
         if (value >= 0xd800 && value <= 0xdbff) {
             // high surrogate
-            if (pos < len) {
-                let extra = input.charCodeAt(pos);
+            if (pos + 1 < len) {
+                let extra = input.charCodeAt(pos + 1);
                 if ((extra & 0xfc00) === 0xdc00) {
-                    ++pos;
+                    codeUnitCount = 2;
+                    pos += 2;
                     value = ((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000;
                 }
                 else {
+                    pos += 1;
                     value = 0xfffd;
                 }
             }
             else {
+                pos += 1;
                 value = 0xfffd;
             }
         }
         else if (value >= 0xdc00 && value <= 0xdfff) {
+            pos += 1;
             value = 0xfffd;
         }
+        else {
+            pos += 1;
+        }
         // expand the buffer if we couldn't write 4 bytes
         if (!HAS_DESTINATION && at + 4 > target.length) {
             tlen += 8; // minimum extra
@@ -120,28 +136,30 @@ function encodeText(input, destination) {
         if (HAS_DESTINATION && at + byteCount > target.length) {
             break;
         }
-        if (byteCount === 1) { // 1-byte
-            target[at++] = value; // ASCII
-        }
-        else if (byteCount === 2) { // 2-byte
-            target[at++] = ((value >> 6) & 0x1f) | 0xc0;
-            target[at++] = (value & 0x3f) | 0x80;
-        }
-        else if (byteCount === 3) { // 3-byte
-            target[at++] = ((value >> 12) & 0x0f) | 0xe0;
-            target[at++] = ((value >> 6) & 0x3f) | 0x80;
-            target[at++] = (value & 0x3f) | 0x80;
-        }
-        else if (byteCount === 4) { // 4-byte
-            target[at++] = ((value >> 18) & 0x07) | 0xf0;
-            target[at++] = ((value >> 12) & 0x3f) | 0x80;
-            target[at++] = ((value >> 6) & 0x3f) | 0x80;
-            target[at++] = (value & 0x3f) | 0x80;
+        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++;
+        read += codeUnitCount;
     }
     return {
-        encoded: !HAS_DESTINATION ? target.slice(0, at) : destination.slice(),
+        encoded: !HAS_DESTINATION ? target.slice(0, at) : destination,
         read: read,
         written: at,
     };
@@ -151,78 +169,83 @@ const TextEncoderE = g["TextEncoder"] || TextEncoderP;
 var _a$a, _b$3;
 /** @internal */
 const state$h = Symbol( /* "TextDecoderState" */);
+/** @type {typeof globalThis.TextDecoder} */
 class TextDecoderP {
-    constructor(utfLabel = "utf-8", { fatal = false, ignoreBOM = false } = {}) {
-        if (UTF8Labels.indexOf(utfLabel.toLowerCase()) === -1) {
-            throw new RangeError("TextDecoder: The encoding label provided ('" + utfLabel + "') is invalid.");
+    constructor(label = "utf-8", { fatal = false, ignoreBOM = false } = {}) {
+        let _label = "" + label;
+        if (["utf-8", "utf8", "unicode-1-1-utf-8"].indexOf(_label.toLowerCase()) === -1) {
+            throw new RangeError(`Failed to construct 'TextDecoder': encoding ('${_label}') not implemented.`);
         }
         this[state$h] = new TextDecoderState();
-        this[state$h].fatal = fatal;
-        this[state$h].ignoreBOM = ignoreBOM;
+        this[state$h].fatal = !!fatal;
+        this[state$h].ignoreBOM = !!ignoreBOM;
     }
     get encoding() { return "utf-8"; }
     get fatal() { return this[state$h].fatal; }
     get ignoreBOM() { return this[state$h].ignoreBOM; }
-    decode(buffer, { stream = false } = {}) {
-        const that = this[state$h];
-        let buf;
-        if (typeof buffer !== "undefined") {
-            if (buffer instanceof Uint8Array) {
-                buf = buffer;
+    decode(input, { stream = false } = {}) {
+        const s = this[state$h];
+        let bytes;
+        if (input !== undefined) {
+            if (input instanceof ArrayBuffer) {
+                bytes = new Uint8Array(input);
+            }
+            else if (input instanceof Uint8Array) {
+                bytes = input;
             }
-            else if (ArrayBuffer.isView(buffer)) {
-                buf = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+            else if (ArrayBuffer.isView(input)) {
+                bytes = new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
             }
             else {
-                buf = new Uint8Array(buffer);
+                throw new TypeError("Failed to execute 'decode' on 'TextDecoder': parameter 1 is not of type 'ArrayBuffer'.");
             }
         }
         else {
-            if (that[_partial].length > 0) {
+            if (s[_partial].length > 0) {
                 if (this.fatal) {
+                    s[_partial] = [];
                     throw new TypeError("TextDecoder: Incomplete UTF-8 sequence.");
                 }
-                else {
-                    that[_partial] = [];
-                }
             }
             return "";
         }
-        if (!that[_bomSeen] && this.ignoreBOM && buf.length >= 3) {
-            if (buf[0] === 0xef && buf[1] === 0xbb && buf[2] === 0xbf) {
-                buf = buf.subarray(3);
-                that[_bomSeen] = true;
+        if (s[_bomDone] < 3) {
+            s[_bomDone] += bytes.length;
+            if (bytes.length >= 3) {
+                if (bytes[0] === 0xef && bytes[1] === 0xbb && bytes[2] === 0xbf) {
+                    bytes = bytes.subarray(3); // × WeChat 2.5.0
+                }
             }
         }
-        if (that[_partial].length > 0) {
-            let merged = new Uint8Array(that[_partial].length + buf.length);
-            merged.set(that[_partial], 0);
-            merged.set(buf, that[_partial].length);
-            buf = merged;
-            that[_partial] = [];
+        if (s[_partial].length > 0) {
+            let merged = new Uint8Array(s[_partial].length + bytes.length);
+            merged.set(s[_partial], 0);
+            merged.set(bytes, s[_partial].length);
+            bytes = merged;
+            s[_partial] = [];
         }
-        let end = buf.length;
+        let end = bytes.length;
         let res = [];
-        if (stream && buf.length > 0) {
-            let i = buf.length;
-            while (i > 0 && i > buf.length - 4) {
-                let byte = buf[i - 1];
+        if (stream && bytes.length > 0) {
+            let i = bytes.length;
+            while (i > 0 && i > bytes.length - 4) {
+                let byte = bytes[i - 1];
                 if ((byte & 0b11000000) !== 0b10000000) {
                     let len = getBytesPerSequence(byte);
-                    if (len > buf.length - (i - 1)) {
+                    if (len > bytes.length - (i - 1)) {
                         end = i - 1;
                     }
                     break;
                 }
                 i--;
             }
-            that[_partial] = Array.from(buf.slice(end)); // save tail
-            buf = buf.slice(0, end);
+            s[_partial] = Array.from(bytes.slice(end)); // save tail        // × WeChat 2.5.0
+            bytes = bytes.slice(0, end); // × WeChat 2.5.0
         }
         let i = 0;
         while (i < end) {
-            let firstByte = buf[i];
             let codePoint = null;
+            let firstByte = bytes[i];
             let bytesPerSequence = getBytesPerSequence(firstByte);
             if (i + bytesPerSequence <= end) {
                 let secondByte, thirdByte, fourthByte, tempCodePoint;
@@ -233,7 +256,7 @@ class TextDecoderP {
                         }
                         break;
                     case 2:
-                        secondByte = buf[i + 1];
+                        secondByte = bytes[i + 1];
                         if ((secondByte & 0xC0) === 0x80) {
                             tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F);
                             if (tempCodePoint > 0x7F) {
@@ -242,8 +265,8 @@ class TextDecoderP {
                         }
                         break;
                     case 3:
-                        secondByte = buf[i + 1];
-                        thirdByte = buf[i + 2];
+                        secondByte = bytes[i + 1];
+                        thirdByte = bytes[i + 2];
                         if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
                             tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F);
                             if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
@@ -252,27 +275,31 @@ class TextDecoderP {
                         }
                         break;
                     case 4:
-                        secondByte = buf[i + 1];
-                        thirdByte = buf[i + 2];
-                        fourthByte = buf[i + 3];
+                        secondByte = bytes[i + 1];
+                        thirdByte = bytes[i + 2];
+                        fourthByte = bytes[i + 3];
                         if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
                             tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F);
                             if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
                                 codePoint = tempCodePoint;
                             }
                         }
+                        break;
                 }
             }
             if (codePoint === null) {
                 if (this.fatal) {
+                    s[_partial] = [];
                     throw new TypeError("TextDecoder.decode: Decoding failed.");
                 }
-                else {
-                    // we did not generate a valid codePoint so insert a
-                    // replacement char (U+FFFD) and advance only 1 byte
-                    codePoint = 0xFFFD;
-                    bytesPerSequence = 1;
+                let skip = 1;
+                while (i + skip < end && (bytes[i + skip] & 0b11000000) === 0b10000000) {
+                    skip += 1;
                 }
+                // we did not generate a valid codePoint so insert a replacement char (U+FFFD)
+                res.push(0xFFFD);
+                i += skip;
+                continue;
             }
             else if (codePoint > 0xFFFF) {
                 // encode to utf16 (surrogate pair dance)
@@ -283,62 +310,70 @@ 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"] }; }
 }
-dfStringTag(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;
 
 /** @internal */
 const state$g = Symbol( /* "BlobState" */);
+/** @type {typeof globalThis.Blob} */
 class BlobP {
     constructor(blobParts = [], options) {
-        if (!Array.isArray(blobParts)) {
-            throw new TypeError("First argument to Blob constructor must be an Array.");
-        }
-        let encoder = null;
-        let chunks = blobParts.reduce((chunks, part) => {
-            if (isPolyfillType("Blob", part)) {
-                chunks.push(part[state$g][_buffer]);
+        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 (part instanceof ArrayBuffer || ArrayBuffer.isView(part)) {
-                chunks.push(BufferSource_toUint8Array(part));
+            else if (chunk instanceof ArrayBuffer || ArrayBuffer.isView(chunk)) {
+                chunks.push(BufferSource_toUint8Array(chunk));
             }
             else {
-                if (!encoder) {
-                    encoder = new TextEncoderP();
-                }
-                chunks.push(encoder.encode(String(part)));
+                chunks.push(encode$1("" + chunk));
             }
-            return chunks;
-        }, []);
+        }
         this[state$g] = new BlobState(concat(chunks));
-        const that = this[state$g];
-        that.size = that[_buffer].length;
-        let rawType = (options === null || options === void 0 ? void 0 : options.type) || "";
-        that.type = /[^\u0020-\u007E]/.test(rawType) ? "" : rawType.toLowerCase();
+        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; }
@@ -349,20 +384,19 @@ class BlobP {
         return Promise.resolve(clone(this[state$g][_buffer].buffer));
     }
     slice(start, end, contentType) {
-        let sliced = this[state$g][_buffer].slice(start !== null && start !== void 0 ? start : 0, end !== null && end !== void 0 ? end : this[state$g][_buffer].length);
-        return new BlobP([sliced], { type: contentType !== null && contentType !== void 0 ? contentType : "" });
+        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 ReferenceError("ReadableStream is not defined");
+        throw new TypeError("Failed to execute 'stream' on 'Blob': method not implemented.");
     }
     text() {
-        let decoder = new TextDecoderP();
-        return Promise.resolve(decoder.decode(this[state$g][_buffer]));
+        return Promise.resolve(decode$1(this[state$g][_buffer]));
     }
-    toString() { return "[object Blob]"; }
-    get isPolyfill() { return { symbol: polyfill, hierarchy: ["Blob"] }; }
+    /** @internal */ toString() { return "[object Blob]"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["Blob"] }; }
 }
-dfStringTag(BlobP, "Blob");
+Class_setStringTag(BlobP, "Blob");
 /** @internal */
 const _buffer = Symbol();
 /** @internal */
@@ -398,6 +432,16 @@ function concat(chunks) {
     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 = [];
@@ -425,20 +469,23 @@ const BlobE = g["Blob"] || BlobP;
 
 /** @internal */
 const state$f = Symbol( /* "FileState" */);
+/** @type {typeof globalThis.File} */
 class FileP extends BlobP {
-    constructor(fileBits, fileName, options) {
+    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());
-        this[state$f].name = fileName.replace(/\//g, ":");
+        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 ""; }
-    toString() { return "[object File]"; }
-    get isPolyfill() { return { symbol: polyfill, hierarchy: ["File", "Blob"] }; }
+    /** @internal */ toString() { return "[object File]"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["File", "Blob"] }; }
 }
-dfStringTag(FileP, "File");
+Class_setStringTag(FileP, "File");
 /** @internal */
 class FileState {
     constructor() {
@@ -450,14 +497,17 @@ 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) {
+    constructor(...args) {
+        const [type, eventInitDict] = args;
+        checkArgsLength(args, 1, new.target.name);
         this[state$e] = new EventState();
-        const that = this[state$e];
-        that.type = String(type);
-        that.bubbles = !!(eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.bubbles);
-        that.cancelable = !!(eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.cancelable);
-        that.composed = !!(eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.composed);
+        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$e][_isTrusted]; }).bind(this),
@@ -472,7 +522,7 @@ class EventP {
     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; }
+    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) {
@@ -485,24 +535,26 @@ class EventP {
             path.push(this.currentTarget);
         return path;
     }
-    initEvent(type, bubbles, cancelable) {
-        const that = this[state$e];
-        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$e];
-        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() {
@@ -512,8 +564,8 @@ class EventP {
     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 },
@@ -523,7 +575,7 @@ const properties$2 = {
 };
 Object.defineProperties(EventP, properties$2);
 Object.defineProperties(EventP.prototype, properties$2);
-dfStringTag(EventP, "Event");
+Class_setStringTag(EventP, "Event");
 /** @internal */ const _timeStamp = (new Date()).getTime();
 /** @internal */ const _isTrusted = Symbol();
 /** @internal */ const _passive = Symbol();
@@ -612,16 +664,23 @@ 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$d] = new EventTargetState(this);
+        this[state$d].name = new.target.name;
     }
-    addEventListener(type, callback, options) {
-        const that = this[state$d];
+    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;
@@ -630,39 +689,44 @@ class EventTargetP {
                     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_setTrusted(event, false);
         event[state$e].target = this;
         return EventTarget_fire(this, event);
     }
-    removeEventListener(type, callback, options) {
-        const that = this[state$d];
+    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"] }; }
 }
-dfStringTag(EventTargetP, "EventTarget");
+Class_setStringTag(EventTargetP, "EventTarget");
 /** @internal */
 const _executors = Symbol();
 /** @internal */
 class EventTargetState {
     constructor(target) {
+        this.name = "EventTarget";
         this[_a$8] = [];
         this.target = target;
     }
@@ -670,23 +734,25 @@ class EventTargetState {
 _a$8 = _executors;
 /** @internal */
 function EventTarget_fire(target, event) {
-    const that = target[state$d];
-    const s = event[state$e];
+    const s = target[state$d];
+    const evs = event[state$e];
     if (!event.target)
-        s.target = target;
-    s.currentTarget = target;
-    s.eventPhase = EventP.AT_TARGET;
+        evs.target = target;
+    evs.currentTarget = target;
+    evs.eventPhase = EventP.AT_TARGET;
     Event_setEtField(event, dispatched$1, true);
     let onceIndexes = [];
-    for (let i = 0; i < that[_executors].length; ++i) {
-        let executor = that[_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;
-        Event_setEtField(event, 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(target, event);
         }
@@ -694,25 +760,19 @@ function EventTarget_fire(target, event) {
             console.error(e);
         }
         Event_setEtField(event, passive, false);
-        if (Event_getEtField(event, stopImmediatePropagationCalled))
-            break;
     }
     if (onceIndexes.length > 0) {
-        that[_executors] = that[_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;
+    evs.currentTarget = null;
+    evs.eventPhase = EventP.NONE;
     Event_setEtField(event, dispatched$1, false);
     return !(event.cancelable && Event_getEtField(event, preventDefaultCalled));
 }
-/** @internal */
-function EventTarget_count(target) {
-    return target[state$d][_executors].length;
-}
 function reply(target, signal, executor) {
     const s = target[state$d];
     const onAbort = () => {
@@ -730,7 +790,7 @@ function reply(target, signal, executor) {
 class Executor {
     constructor(type, callback) {
         this.options = {};
-        this.type = String(type);
+        this.type = "" + type;
         this.callback = extract(callback);
     }
     equals(executor) {
@@ -770,23 +830,34 @@ const EventTargetE = g["EventTarget"] || EventTargetP;
 
 /** @internal */
 const state$c = Symbol( /* "ProgressEventState" */);
+/** @type {typeof globalThis.ProgressEvent} */
 class ProgressEventP extends EventP {
     constructor(type, eventInitDict) {
         var _a, _b;
         super(type, eventInitDict);
         this[state$c] = new ProgressEventState();
-        const that = this[state$c];
-        that.lengthComputable = !!(eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.lengthComputable);
-        that.loaded = (_a = eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.loaded) !== null && _a !== void 0 ? _a : 0;
-        that.total = (_b = eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.total) !== null && _b !== void 0 ? _b : 0;
+        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$c].lengthComputable); }
     get loaded() { return getValue(this[state$c].loaded); }
     get total() { return getValue(this[state$c].total); }
-    toString() { return "[object ProgressEvent]"; }
-    get isPolyfill() { return { symbol: polyfill, hierarchy: ["ProgressEvent", "Event"] }; }
+    /** @internal */ toString() { return "[object ProgressEvent]"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["ProgressEvent", "Event"] }; }
 }
-dfStringTag(ProgressEventP, "ProgressEvent");
+Class_setStringTag(ProgressEventP, "ProgressEvent");
 /** @internal */
 class ProgressEventState {
     constructor() {
@@ -821,6 +892,7 @@ const ProgressEventE = g["EventTarget"] ? g["ProgressEvent"] : ProgressEventP;
 var _a$7;
 /** @internal */
 const state$b = Symbol( /* "FileReaderState" */);
+/** @type {typeof globalThis.FileReader} */
 class FileReaderP extends EventTargetP {
     constructor() {
         super();
@@ -831,32 +903,44 @@ class FileReaderP extends EventTargetP {
     get error() { return this[state$b].error; }
     abort() {
         if (this.readyState === FileReaderP.LOADING) {
-            this[state$b].readyState = FileReaderP.DONE;
-            this[state$b].result = null;
+            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");
         }
     }
-    readAsArrayBuffer(blob) {
-        read$1(this, "readAsArrayBuffer", blob, () => {
+    readAsArrayBuffer(...args) {
+        read$1(this, "readAsArrayBuffer", args, blob => {
             this[state$b].result = Blob_toUint8Array(blob).buffer.slice(0);
         });
     }
-    readAsBinaryString(blob) {
-        read$1(this, "readAsBinaryString", blob, () => {
-            this[state$b].result = Blob_toUint8Array(blob).reduce((acc, cur) => {
-                acc += String.fromCharCode(cur);
-                return acc;
-            }, "");
+    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("");
         });
     }
-    readAsDataURL(blob) {
-        read$1(this, "readAsDataURL", blob, () => {
+    readAsDataURL(...args) {
+        read$1(this, "readAsDataURL", args, blob => {
             this[state$b].result = "data:" + (blob.type || "application/octet-stream") + ";base64," + Uint8Array_toBase64(Blob_toUint8Array(blob));
         });
     }
-    readAsText(blob, encoding) {
-        read$1(this, "readAsText", blob, () => {
-            this[state$b].result = (new TextDecoderP(encoding)).decode(Blob_toUint8Array(blob));
+    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));
         });
     }
     get onabort() { return this[state$b].onabort; }
@@ -871,8 +955,8 @@ class FileReaderP extends EventTargetP {
     set onloadstart(value) { this[state$b].onloadstart = value; attach$1(this, "loadstart"); }
     get onprogress() { return this[state$b].onprogress; }
     set onprogress(value) { this[state$b].onprogress = value; attach$1(this, "progress"); }
-    toString() { return "[object FileReader]"; }
-    get isPolyfill() { return { symbol: polyfill, hierarchy: ["FileReader", "EventTarget"] }; }
+    /** @internal */ toString() { return "[object FileReader]"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["FileReader", "EventTarget"] }; }
 }
 const properties$1 = {
     EMPTY: { value: 0, enumerable: true },
@@ -881,7 +965,7 @@ const properties$1 = {
 };
 Object.defineProperties(FileReaderP, properties$1);
 Object.defineProperties(FileReaderP.prototype, properties$1);
-dfStringTag(FileReaderP, "FileReader");
+Class_setStringTag(FileReaderP, "FileReader");
 /** @internal */
 const _handlers$3 = Symbol();
 /** @internal */
@@ -901,7 +985,9 @@ class FileReaderState {
     }
 }
 _a$7 = _handlers$3;
-function read$1(reader, kind, blob, setResult) {
+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'.");
     }
@@ -913,7 +999,7 @@ function read$1(reader, kind, blob, setResult) {
         if (s.readyState === FileReaderP.LOADING) {
             s.readyState = FileReaderP.DONE;
             try {
-                setResult();
+                setResult(blob);
                 emitProcessEvent(s.target, "load", blob.size, blob.size);
             }
             catch (e) {
@@ -945,106 +1031,381 @@ function getHandlers$3(s) {
 const FileReaderE = g["Blob"] ? g["FileReader"] : FileReaderP;
 
 var _a$6;
-/** @internal */ const state$a = Symbol( /* "FormDataState" */);
+/** @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 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)]);
+    }
+    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(...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;
+    }
+    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;
+    }
+    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;
+    }
+    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;
+    }
+    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("&");
+    }
+    /** @internal */
+    get isPolyfill() { return { symbol: polyfill, hierarchy: ["URLSearchParams"] }; }
+}
+Class_setStringTag(URLSearchParamsP, "URLSearchParams");
+/** @internal */
+const _urlspArray = Symbol();
+/** @internal */
+class URLSearchParamsState {
+    constructor() {
+        this[_a$6] = [];
+    }
+}
+_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 encode(str) {
+    const replace = {
+        "!": "%21",
+        "'": "%27",
+        "(": "%28",
+        ")": "%29",
+        "~": "%7E",
+        "%20": "+",
+        "%00": "\x00",
+    };
+    return encodeURIComponent(str).replace(/[!'\(\)~]|%20|%00/g, match => replace[match]);
+}
+function decode(str) {
+    return str
+        .replace(/[ +]/g, "%20")
+        .replace(/(%[a-f0-9]{2})+/ig, match => decodeURIComponent(match));
+}
+const URLSearchParamsE = g["URLSearchParams"] || URLSearchParamsP;
+
+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$a] = new FormDataState();
+        this[state$9] = new FormDataState();
     }
-    append(name, value, filename) {
-        this[state$a][_formData].push(normalizeArgs(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$a][_formData], entry => {
-            entry[0] !== name && result.push(entry);
-        });
-        this[state$a][_formData] = result;
-    }
-    get(name) {
-        let entries = this[state$a][_formData];
-        name = String(name);
-        for (let i = 0; i < entries.length; ++i) {
-            if (entries[i][0] === name) {
-                return entries[i][1];
+        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(...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$a][_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$a][_formData].length; ++i) {
-            if (this[state$a][_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$a][_formData], data => {
-            data[0] === name
-                ? replace && (replace = !result.push(args))
-                : result.push(data);
-        });
-        replace && result.push(args);
-        this[state$a][_formData] = result;
+        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 i = 0; i < this[state$a][_formData].length; ++i) {
-            let pair = this[state$a][_formData][i];
-            callbackfn.call(thisArg, pair[1], pair[0], 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$a][_formData].values();
+        return this[state$9][_formData].map(x => [x[0], x[1]]).values();
     }
     keys() {
-        return this[state$a][_formData].map(x => x[0]).values();
+        return this[state$9][_formData].map(x => x[0]).values();
     }
     values() {
-        return this[state$a][_formData].map(x => x[1]).values();
+        return this[state$9][_formData].map(x => x[1]).values();
     }
     [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"] }; }
 }
-dfStringTag(FormDataP, "FormData");
+Class_setStringTag(FormDataP, "FormData");
 /** @internal */
 const _formData = Symbol();
 /** @internal */
 class FormDataState {
     constructor() {
-        this[_a$6] = [];
+        this[_a$5] = [];
     }
 }
-_a$6 = _formData;
+_a$5 = _formData;
 /** @internal */
 function FormData_toBlob(formData) {
-    const boundary = "----formdata-polyfill-" + Math.random();
+    const boundary = "----formdata-mphttpx-" + Math.random();
     const p = `--${boundary}\r\nContent-Disposition: form-data; name="`;
     let chunks = [];
-    for (let i = 0; i < formData[state$a][_formData].length; ++i) {
-        let pair = formData[state$a][_formData][i];
+    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") {
@@ -1060,418 +1421,291 @@ function FormData_toBlob(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)
- * @internal
- */
-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();
     }
-    const boundary = body.substring(2, firstLineEnd).trim();
-    if (!boundary) {
-        // Invalid multipart format: Empty boundary
-        throw new TypeError("Invalid MIME type");
+    let _boundary = text.substring(2, firstLineEnd).trim();
+    if (!_boundary) {
+        throwParseError();
     }
-    // 2. Split data into individual parts (excluding empty content and trailing "--")
-    const parts = body.split(`--${boundary}`).filter(part => {
-        const trimmed = part.trim();
+    if (boundary !== undefined && boundary !== _boundary) {
+        throwParseError();
+    }
+    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$9 = 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$9] = new URLSearchParamsState();
-        this[state$9][_urlspDict] = parseToDict(search);
-    }
-    get size() {
-        return objectValues(this[state$9][_urlspDict]).reduce((acc, cur) => acc + cur.length, 0);
-    }
-    append(name, value) {
-        appendTo(this[state$9][_urlspDict], name, value);
-    }
-    delete(name, value) {
-        let dict = {};
-        let pairs = objectEntries(this[state$9][_urlspDict]);
-        for (let i = 0; i < pairs.length; ++i) {
-            let pair = pairs[i];
-            let key = pair[0];
-            let values = pair[1];
-            if (key === name) {
-                if (value !== undefined) {
-                    let vals = values.filter(x => x !== ("" + value));
-                    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>>)'.");
                 }
-                continue;
             }
-            Object.assign(dict, { [key]: values });
         }
-        this[state$9][_urlspDict] = dict;
-    }
-    get(name) {
-        var _b;
-        return this.has(name) ? (_b = this[state$9][_urlspDict][name][0]) !== null && _b !== void 0 ? _b : null : null;
+        this[state$8][_initialized] = true;
     }
-    getAll(name) {
-        return this.has(name) ? this[state$9][_urlspDict][name].slice(0) : [];
+    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]);
+        }
     }
-    has(name, value) {
-        if (hasOwnProperty(this[state$9][_urlspDict], name)) {
-            if (value !== undefined) {
-                return this[state$9][_urlspDict][name].indexOf(("" + value)) > -1;
+    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;
             }
-            return true;
+            result.push(item);
         }
-        return false;
+        if (index > -1) {
+            this[state$8][_headersArray] = result;
+        }
+    }
+    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;
     }
-    set(name, value) {
-        this[state$9][_urlspDict][name] = ["" + value];
+    getSetCookie() {
+        let value = this.get("Set-Cookie");
+        return value ? value.split(", ") : [];
     }
-    sort() {
-        const that = this[state$9];
-        let keys = Object.keys(that[_urlspDict]);
-        keys.sort();
-        let dict = {};
-        for (let i = 0; i < keys.length; ++i) {
-            let key = keys[i];
-            Object.assign(dict, { [key]: that[_urlspDict][key] });
-        }
-        that[_urlspDict] = dict;
-    }
-    forEach(callbackfn, thisArg) {
-        objectEntries(this[state$9][_urlspDict]).forEach(([key, values]) => {
-            values.forEach(value => {
-                callbackfn.call(thisArg, value, key, this);
-            });
-        });
+    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 false;
+    }
+    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]);
+        }
+    }
+    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$9][_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$9][_urlspDict]).values();
+        return this[state$8][_headersArray].map(x => x[0]).values();
     }
     values() {
-        return objectValues(this[state$9][_urlspDict]).reduce(flatCb, []).values();
+        return this[state$8][_headersArray].map(x => x[1]).values();
     }
     [Symbol.iterator]() {
         return this.entries();
     }
-    toString() {
-        let query = [];
-        let pairs = objectEntries(this[state$9][_urlspDict]);
-        for (let i = 0; i < pairs.length; ++i) {
-            let pair = pairs[i];
-            let key = pair[0];
-            let values = pair[1];
-            let name = encode$1(key);
-            for (let j = 0; j < values.length; ++j) {
-                let val = values[j];
-                query.push(name + "=" + encode$1(val));
-            }
-        }
-        return query.join("&");
-    }
-    get isPolyfill() { return { symbol: polyfill, hierarchy: ["URLSearchParams"] }; }
+    /** @internal */ toString() { return "[object Headers]"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["Headers"] }; }
 }
-dfStringTag(URLSearchParamsP, "URLSearchParams");
+Class_setStringTag(HeadersP, "Headers");
+/** @internal */ const _initialized = Symbol();
+/** @internal */ const _headersArray = Symbol();
 /** @internal */
-const _urlspDict = Symbol();
-/** @internal */
-class URLSearchParamsState {
+class HeadersState {
     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 {
-            let keys = Object.keys(search);
-            for (let i = 0; i < keys.length; ++i) {
-                let key = keys[i];
-                if (search.hasOwnProperty(key)) {
-                    appendTo(dict, key, search[key]);
-                }
-            }
-        }
+        this[_a$4] = false;
+        this[_b$1] = [];
     }
-    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), "");
-                }
-            }
-        }
-    }
-    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 {
-        dict[name] = [val];
-    }
-}
-function encode$1(str) {
-    const replace = {
-        "!": "%21",
-        "'": "%27",
-        "(": "%28",
-        ")": "%29",
-        "~": "%7E",
-        "%20": "+",
-        "%00": "\x00",
+_a$4 = _initialized, _b$1 = _headersArray;
+function throwsFn(kind) {
+    return () => {
+        throw new TypeError(`Failed to ${kind ? ("execute '" + kind + "' on") : "construct"} 'Headers': Invalid name`);
     };
-    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 i = 0; i < cur.length; ++i) {
-        let item = cur[i];
-        acc.push(item);
-    }
-    return acc;
-}
-const URLSearchParamsE = g["URLSearchParams"] || URLSearchParamsP;
-
-var _a$4;
 /** @internal */
-const state$8 = Symbol( /* "AbortSignalState" */);
-class AbortSignalP extends EventTargetP {
-    static abort(reason) {
-        let signal = createAbortSignal();
-        AbortSignal_abort(signal, reason, false);
-        return signal;
-    }
-    static any(signals) {
-        let signal = createAbortSignal();
-        let abortedSignal = signals.find(x => x.aborted);
-        if (abortedSignal) {
-            AbortSignal_abort(signal, abortedSignal.reason, false);
-        }
-        else {
-            let _signals = Array.from(signals);
-            function abortFn(ev) {
-                for (let i = 0; i < _signals.length; ++i) {
-                    let sig = _signals[i];
-                    sig.removeEventListener("abort", abortFn);
-                }
-                AbortSignal_abort(signal, this.reason, true, ev.isTrusted);
-            }
-            for (let i = 0; i < _signals.length; ++i) {
-                let sig = _signals[1];
-                sig.addEventListener("abort", abortFn);
-            }
-        }
-        return signal;
-    }
-    static timeout(milliseconds) {
-        let signal = createAbortSignal();
-        setTimeout(() => {
-            AbortSignal_abort(signal, new MPException("signal timed out", "TimeoutError"));
-        }, milliseconds);
-        return signal;
-    }
-    constructor() {
-        if (new.target === AbortSignalP) {
-            throw new TypeError("Failed to construct 'AbortSignal': Illegal constructor");
-        }
-        super();
-        this[state$8] = new AbortSignalState(this);
-    }
-    get aborted() { return this[state$8].aborted; }
-    get reason() { return this[state$8].reason; }
-    throwIfAborted() {
-        if (this.aborted) {
-            throw this.reason;
-        }
+function normalizeName(name, throwError) {
+    if (typeof name !== "string") {
+        name = "" + name;
     }
-    get onabort() { return this[state$8].onabort; }
-    set onabort(value) {
-        this[state$8].onabort = value;
-        attachFn(this, "abort", value, this[state$8][_handlers$2].onabort);
+    if (throwError && (/[^a-z0-9\-#$%&'*+.^_`|~!]/i.test(name) || name === "")) {
+        throwError();
     }
-    toString() { return "[object AbortSignal]"; }
-    get isPolyfill() { return { symbol: polyfill, hierarchy: ["AbortSignal", "EventTarget"] }; }
+    return name.toLowerCase();
 }
-dfStringTag(AbortSignalP, "AbortSignal");
-/** @internal */
-const _handlers$2 = Symbol();
 /** @internal */
-class AbortSignalState {
-    constructor(target) {
-        this.aborted = false;
-        this.reason = undefined;
-        this[_a$4] = getHandlers$2(this);
-        this.onabort = null;
-        this.target = target;
-    }
+function normalizeValue(value) {
+    return typeof value === "string" ? value : ("" + value);
 }
-_a$4 = _handlers$2;
 /** @internal */
-function AbortSignal_abort(signal, reason, notify = true, isTrusted = true) {
-    const s = signal[state$8];
-    if (!s.aborted) {
-        s.aborted = true;
-        s.reason = reason !== null && reason !== void 0 ? reason : (new MPException("signal is aborted without reason", "AbortError"));
-        if (notify) {
-            let evt = createInnerEvent(signal, "abort", undefined, isTrusted);
-            EventTarget_fire(signal, evt);
+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.`);
+            }
         }
-    }
-}
-function getHandlers$2(s) {
-    return {
-        onabort: (ev) => { executeFn(s.target, s.onabort, ev); },
-    };
-}
-/** @internal */
-function createAbortSignal() {
-    let signal = Object.create(AbortSignalP.prototype);
-    signal[state$d] = new EventTargetState(signal);
-    signal[state$8] = new AbortSignalState(signal);
-    return signal;
+    });
+    return headers;
 }
-const AbortSignalE = g["AbortSignal"] || AbortSignalP;
+const HeadersE = g["Headers"] || HeadersP;
 
-var _a$3, _b$1;
-/** @internal */
-const state$7 = Symbol( /* "BodyState" */);
+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");
@@ -1482,7 +1716,7 @@ class BodyImpl {
         if (!this[state$7][_body]) {
             return null;
         }
-        throw new ReferenceError("ReadableStream is not defined");
+        throw new TypeError(`Failed to access 'body' on '${this[state$7].name}': property not implemented.`);
     }
     get bodyUsed() { return this[state$7].bodyUsed; }
     ;
@@ -1510,39 +1744,30 @@ class BodyImpl {
         const kind = "text";
         return consumed(this, kind) || read(this, kind);
     }
-    toString() { return "[object Body]"; }
-    get isPolyfill() { return { symbol: polyfill, hierarchy: ["Body"] }; }
+    /** @internal */ toString() { return "[object Body]"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["Body"] }; }
 }
-dfStringTag(BodyImpl, "Body");
-/** @internal */ const _name = Symbol();
-/** @internal */ const _body = Symbol();
+Class_setStringTag(BodyImpl, "Body");
+/** @internal */
+const _body = Symbol();
 /** @internal */
 class BodyState {
     constructor() {
+        this.name = "Body";
         this.bodyUsed = false;
-        this[_a$3] = "Body";
-        this[_b$1] = "";
+        this[_a$3] = "";
     }
 }
-_a$3 = _name, _b$1 = _body;
+_a$3 = _body;
 /** @internal */
-function Body_init(body, payload, headers) {
+function Body_init(body, payload) {
+    const b = body;
     if (isObjectType("ReadableStream", payload)) {
-        throw new ReferenceError("ReadableStream is not defined");
+        throw new TypeError(`Failed to construct '${b[state$7].name}': ReadableStream not implemented.`);
     }
-    body[state$7][_body] = convert(payload, type => {
-        if (headers && !headers.get("Content-Type")) {
-            headers.set("Content-Type", type);
-        }
-    });
-}
-/** @internal */
-function Body_setName(body, name) {
-    body[state$7][_name] = name;
-}
-/** @internal */
-function Body_setBodyUsed(body, bodyUsed) {
-    body[state$7].bodyUsed = bodyUsed;
+    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) {
@@ -1571,8 +1796,22 @@ function readSync(body, kind) {
         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);
-        return createFormDataFromBody(text);
+        let boundary = extractBoundary(body.headers.get("Content-Type")) || "";
+        return createFormDataFromBinaryText(text, boundary);
     }
     else if (kind === "json") {
         return convertBack("json", payload);
@@ -1586,20 +1825,12 @@ function consumed(body, kind) {
     if (!s[_body])
         return;
     if (s.bodyUsed) {
-        return Promise.reject(new TypeError(`TypeError: Failed to execute '${kind}' on '${s[_name]}': body stream already read`));
+        return Promise.reject(new TypeError(`Failed to execute '${kind}' on '${s.name}': body stream already read`));
     }
     s.bodyUsed = true;
 }
-const encode = (str) => {
-    const encoder = new TextEncoderP();
-    return encoder.encode(str).buffer;
-};
-const decode = (buf) => {
-    let decoder = new TextDecoderP();
-    return decoder.decode(buf);
-};
 /** @internal */
-function convert(body, setContentType, setContentLength) {
+function convert(body, cloneArrayBuffer = true, setContentType, setContentLength) {
     let result;
     if (typeof body === "string") {
         result = body;
@@ -1614,7 +1845,7 @@ function convert(body, setContentType, setContentLength) {
         }
     }
     else if (body instanceof ArrayBuffer) {
-        result = body.slice(0);
+        result = cloneArrayBuffer ? body.slice(0) : body;
     }
     else if (ArrayBuffer.isView(body)) {
         result = body.buffer.slice(body.byteOffset, body.byteOffset + body.byteLength);
@@ -1636,10 +1867,17 @@ function convert(body, setContentType, setContentLength) {
         result = "";
     }
     else {
-        result = String(body);
+        result = "" + body;
     }
     if (setContentLength) {
-        setContentLength(() => (typeof result === "string" ? encode(result) : result).byteLength);
+        let calculated = false, contentLength = 0;
+        setContentLength(() => {
+            if (!calculated) {
+                calculated = true;
+                contentLength = (typeof result === "string" ? encode$1(result).buffer : result).byteLength;
+            }
+            return contentLength;
+        });
     }
     return result;
 }
@@ -1647,13 +1885,13 @@ function convert(body, setContentType, setContentLength) {
 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);
+        return typeof temp === "string" ? temp : decode$1(temp);
     }
     else if (type === "json") {
-        return JSON.parse(typeof temp === "string" ? temp : decode(temp));
+        return JSON.parse(typeof temp === "string" ? temp : decode$1(temp));
     }
     else if (type === "arraybuffer") {
-        return temp instanceof ArrayBuffer ? temp.slice(0) : encode(temp);
+        return temp instanceof ArrayBuffer ? temp.slice(0) : encode$1(temp).buffer;
     }
     else if (type === "blob") {
         return new BlobP([temp]);
@@ -1665,194 +1903,124 @@ function convertBack(type, data) {
 
 var _a$2;
 /** @internal */
-const state$6 = Symbol( /* "HeadersState" */);
-class HeadersP {
-    constructor(init) {
-        this[state$6] = 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");
-        let newValue = normalizeValue(value);
-        let oldValue = (_b = this[state$6][_headersMap].get(key)) === null || _b === void 0 ? void 0 : _b[1];
-        this[state$6][_headersMap].set(key, ["" + name, oldValue ? `${oldValue}, ${newValue}` : newValue]);
-    }
-    delete(name) {
-        let key = normalizeName(name, "delete");
-        this[state$6][_headersMap].delete(key);
-    }
-    get(name) {
-        var _b, _c;
-        let key = normalizeName(name, "get");
-        return (_c = (_b = this[state$6][_headersMap].get(key)) === null || _b === void 0 ? void 0 : _b[1]) !== null && _c !== void 0 ? _c : null;
-    }
-    getSetCookie() {
-        let value = this.get("Set-Cookie");
-        return value ? value.split(", ") : [];
-    }
-    has(name) {
-        let key = normalizeName(name, "has");
-        return this[state$6][_headersMap].has(key);
-    }
-    set(name, value) {
-        let key = normalizeName(name, "set");
-        this[state$6][_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$6][_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"] }; }
-}
-dfStringTag(HeadersP, "Headers");
-/** @internal */
-const _headersMap = Symbol();
-/** @internal */
-class HeadersState {
-    constructor() {
-        this[_a$2] = new SimpleMap();
-    }
-}
-_a$2 = _headersMap;
-/** @internal */
-class SimpleMap {
-    constructor() {
-        this.array = [];
+const state$6 = Symbol( /* "AbortSignalState" */);
+/** @type {typeof globalThis.AbortSignal} */
+class AbortSignalP extends EventTargetP {
+    static abort(reason) {
+        let signal = createAbortSignal();
+        AbortSignal_abort(signal, reason, false);
+        return signal;
     }
-    get(key) {
-        for (let i = 0; i < this.array.length; ++i) {
-            let pair = this.array[i];
-            if (pair[0] === key) {
-                return pair[1];
-            }
+    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.");
         }
-    }
-    set(key, value) {
-        let index = -1;
-        for (let i = 0; i < this.array.length; ++i) {
-            let pair = this.array[i];
-            if (pair[0] === key) {
-                pair[1] = value;
-                index = i;
-                break;
+        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) {
+            AbortSignal_abort(signal, abortedSignal.reason, false);
         }
-        if (index === -1) {
-            this.array.push([key, value]);
+        else {
+            function abortFn(ev) {
+                for (let i = 0; i < _signals.length; ++i) {
+                    let sig = _signals[i];
+                    sig.removeEventListener("abort", abortFn);
+                }
+                AbortSignal_abort(signal, this.reason, true, ev.isTrusted);
+            }
+            for (let i = 0; i < _signals.length; ++i) {
+                let sig = _signals[i];
+                sig.addEventListener("abort", abortFn);
+            }
         }
-        return this.array;
+        return signal;
     }
-    has(key) {
-        for (let i = 0; i < this.array.length; ++i) {
-            let pair = this.array[i];
-            if (pair[0] === key) {
-                return true;
-            }
+    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.");
         }
-        return false;
+        let signal = createAbortSignal();
+        setTimeout(() => {
+            AbortSignal_abort(signal, new MPException("signal timed out", "TimeoutError"));
+        }, milliseconds);
+        return signal;
     }
-    delete(key) {
-        let index = -1;
-        let array = [];
-        for (let i = 0; i < this.array.length; ++i) {
-            let pair = this.array[i];
-            if (pair[0] === key) {
-                index = i;
-                continue;
-            }
-            array.push(pair);
+    /** @internal */
+    constructor() {
+        if (new.target === AbortSignalP) {
+            throw new TypeError("Failed to construct 'AbortSignal': Illegal constructor");
         }
-        if (index > -1) {
-            this.array = array;
+        super();
+        this[state$6] = new AbortSignalState(this);
+    }
+    get aborted() { return this[state$6].aborted; }
+    get reason() { return this[state$6].reason; }
+    throwIfAborted() {
+        if (this.aborted) {
+            throw this.reason;
         }
-        return index > -1;
     }
-    values() {
-        return this.array.map(x => x[1]).values();
+    get onabort() { return this[state$6].onabort; }
+    set onabort(value) {
+        this[state$6].onabort = value;
+        attachFn(this, "abort", value, this[state$6][_handlers$2].onabort);
     }
+    /** @internal */ toString() { return "[object AbortSignal]"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["AbortSignal", "EventTarget"] }; }
 }
+Class_setStringTag(AbortSignalP, "AbortSignal");
 /** @internal */
-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`);
-        }
+const _handlers$2 = Symbol();
+/** @internal */
+class AbortSignalState {
+    constructor(target) {
+        this.aborted = false;
+        this.reason = undefined;
+        this[_a$2] = getHandlers$2(this);
+        this.onabort = null;
+        this.target = target;
     }
-    return name.toLowerCase();
 }
+_a$2 = _handlers$2;
 /** @internal */
-function normalizeValue(value) {
-    if (typeof value !== "string") {
-        value = String(value);
+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(signal, "abort", undefined, isTrusted);
+            EventTarget_fire(signal, evt);
+        }
     }
-    return value;
+}
+function getHandlers$2(s) {
+    return {
+        onabort: (ev) => { executeFn(s.target, s.onabort, ev); },
+    };
 }
 /** @internal */
-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;
+function createAbortSignal() {
+    let signal = Object.create(AbortSignalP.prototype);
+    signal[state$d] = new EventTargetState(signal);
+    signal[state$6] = new AbortSignalState(signal);
+    return signal;
 }
-const HeadersE = g["Headers"] || HeadersP;
+const AbortSignalE = g["AbortSignal"] || AbortSignalP;
 
 /** @internal */
 const state$5 = Symbol( /* "AbortControllerState" */);
+/** @type {typeof globalThis.AbortController} */
 class AbortControllerP {
     constructor() {
         this[state$5] = new AbortControllerState();
@@ -1861,10 +2029,10 @@ class AbortControllerP {
     abort(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"] }; }
 }
-dfStringTag(AbortControllerP, "AbortController");
+Class_setStringTag(AbortControllerP, "AbortController");
 /** @internal */
 class AbortControllerState {
     constructor() {
@@ -1874,69 +2042,79 @@ class AbortControllerState {
 const AbortControllerE = g["AbortController"] || AbortControllerP;
 
 /** @internal */ const state$4 = Symbol( /* "RequestState" */);
+/** @type {typeof globalThis.Request} */
 class RequestP extends BodyImpl {
-    constructor(input, init) {
+    constructor(...args) {
+        const [input, init] = args;
+        checkArgsLength(args, 1, "Request");
         super();
-        Body_setName(this, "Request");
+        this[state$7].name = "Request";
         this[state$4] = new RequestState();
-        const that = this[state$4];
-        let options = init !== null && init !== void 0 ? init : {};
-        let body = options.body;
+        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.");
             }
-            that.credentials = input.credentials;
-            if (!options.headers) {
-                that.headers = new HeadersP(input.headers);
+            s.cache = input.cache;
+            s.credentials = input.credentials;
+            if (!_init.headers) {
+                s.headers = new HeadersP(input.headers);
             }
-            that.method = input.method;
-            that.mode = input.mode;
+            s.method = input.method;
+            s.mode = input.mode;
             let inputSignal = input[state$4].signal;
             if (inputSignal) {
-                that.signal = inputSignal;
+                s.signal = inputSignal;
             }
-            that.url = input.url;
+            s.url = input.url;
             let payload = Body_toPayload(input);
-            if (!body && payload !== null) {
+            if (!body && payload !== "") {
                 body = payload;
-                Body_setBodyUsed(input, true);
+                input[state$7].bodyUsed = true;
             }
         }
         else {
-            that.url = String(input);
+            s.url = "" + input;
+        }
+        if (_init.cache) {
+            s.cache = _init.cache;
         }
-        if (options.credentials) {
-            that.credentials = options.credentials;
+        if (_init.credentials) {
+            s.credentials = _init.credentials;
         }
-        if (options.headers) {
-            that.headers = new HeadersP(options.headers);
+        if (_init.headers) {
+            s.headers = new HeadersP(_init.headers);
         }
-        if (options.method) {
-            that.method = normalizeMethod(options.method);
+        if (_init.method) {
+            s.method = normalizeMethod(_init.method);
         }
-        if (options.mode) {
-            that.mode = options.mode;
+        if (_init.mode) {
+            s.mode = _init.mode;
         }
-        if (options.signal) {
-            that.signal = options.signal;
+        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, this.headers);
+        Body_init(this, body);
         if (this.method === "GET" || this.method === "HEAD") {
-            if (options.cache === "no-store" || options.cache === "no-cache") {
+            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
-                    that.url = this.url.replace(reParamSearch, "$1_=" + (new Date()).getTime());
+                    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 = /\?/;
-                    that.url += (reQueryString.test(this.url) ? "&" : "?") + "_=" + (new Date()).getTime();
+                    s.url += (reQueryString.test(this.url) ? "&" : "?") + "_=" + (new Date()).getTime();
                 }
             }
         }
@@ -1945,11 +2123,11 @@ class RequestP extends BodyImpl {
     get credentials() { return this[state$4].credentials; }
     get destination() { return this[state$4].destination; }
     get headers() {
-        const that = this[state$4];
-        if (!that.headers) {
-            that.headers = new HeadersP();
+        const s = this[state$4];
+        if (!s.headers) {
+            s.headers = new HeadersP();
         }
-        return that.headers;
+        return s.headers;
     }
     get integrity() { return this[state$4].integrity; }
     get keepalive() { return this[state$4].keepalive; }
@@ -1959,21 +2137,24 @@ class RequestP extends BodyImpl {
     get referrer() { return this[state$4].referrer; }
     get referrerPolicy() { return this[state$4].referrerPolicy; }
     get signal() {
-        const that = this[state$4];
-        if (!that.signal) {
-            that.signal = (new AbortControllerP()).signal;
+        const s = this[state$4];
+        if (!s.signal) {
+            s.signal = (new AbortControllerP()).signal;
         }
-        return that.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 });
     }
-    toString() { return "[object Request]"; }
-    get isPolyfill() { return { symbol: polyfill, hierarchy: ["Request", "Body"] }; }
+    /** @internal */ toString() { return "[object Request]"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["Request"] }; }
 }
-dfStringTag(RequestP, "Request");
+Class_setStringTag(RequestP, "Request");
 /** @internal */
 class RequestState {
     constructor() {
@@ -1999,109 +2180,36 @@ function normalizeMethod(method) {
 }
 const RequestE = g["Request"] || RequestP;
 
-/** @internal */ const state$3 = Symbol( /* "ResponseState" */);
-class ResponseP extends BodyImpl {
-    constructor(body, init) {
-        super();
-        Body_setName(this, "Response");
-        this[state$3] = new ResponseState();
-        const that = this[state$3];
-        let options = init !== null && init !== void 0 ? init : {};
-        let status = options.status === undefined ? 200 : options.status;
-        if (status < 200 || status > 500) {
-            throw new RangeError(`Failed to construct 'Response': The status provided (${+status}) is outside the range [200, 599].`);
-        }
-        if (options.headers) {
-            that.headers = new HeadersP(options.headers);
-        }
-        that.ok = this.status >= 200 && this.status < 300;
-        that.status = status;
-        that.statusText = options.statusText === undefined ? "" : "" + options.statusText;
-        Body_init(this, body, this.headers);
-    }
-    get headers() {
-        const that = this[state$3];
-        if (!that.headers) {
-            that.headers = new HeadersP();
-        }
-        return that.headers;
-    }
-    get ok() { return this[state$3].ok; }
-    get redirected() { return this[state$3].redirected; }
-    get status() { return this[state$3].status; }
-    get statusText() { return this[state$3].statusText; }
-    get type() { return this[state$3].type; }
-    get url() { return this[state$3].url; }
-    clone() {
-        let response = new ResponseP(Body_toPayload(this), {
-            headers: new HeadersP(this.headers),
-            status: this.status,
-            statusText: this.statusText,
-        });
-        response[state$3].url = this.url;
-        return response;
-    }
-    static json(data, init) {
-        return new ResponseP(JSON.stringify(data), init);
-    }
-    static error() {
-        let response = new ResponseP(null, { status: 200, statusText: "" });
-        response[state$3].ok = false;
-        response[state$3].status = 0;
-        response[state$3].type = "error";
-        return response;
-    }
-    static redirect(url, status = 301) {
-        if ([301, 302, 303, 307, 308].indexOf(status) === -1) {
-            throw new RangeError("Failed to execute 'redirect' on 'Response': Invalid status code");
-        }
-        return new ResponseP(null, { status, headers: { location: String(url) } });
-    }
-    toString() { return "[object Response]"; }
-    get isPolyfill() { return { symbol: polyfill, hierarchy: ["Response", "Body"] }; }
-}
-dfStringTag(ResponseP, "Response");
-/** @internal */
-class ResponseState {
-    constructor() {
-        this.ok = true;
-        this.redirected = false;
-        this.status = 200;
-        this.statusText = "";
-        this.type = "default";
-        this.url = "";
-    }
-}
-const ResponseE = g["Response"] || ResponseP;
-
 var _a$1;
-/** @internal */ const state$2 = Symbol( /* "XMLHttpRequestEventTargetState" */);
+/** @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$2] = new XMLHttpRequestEventTargetState(this);
-    }
-    get onabort() { return this[state$2].onabort; }
-    set onabort(value) { this[state$2].onabort = value; attach(this, "abort"); }
-    get onerror() { return this[state$2].onerror; }
-    set onerror(value) { this[state$2].onerror = value; attach(this, "error"); }
-    get onload() { return this[state$2].onload; }
-    set onload(value) { this[state$2].onload = value; attach(this, "load"); }
-    get onloadend() { return this[state$2].onloadend; }
-    set onloadend(value) { this[state$2].onloadend = value; attach(this, "loadend"); }
-    get onloadstart() { return this[state$2].onloadstart; }
-    set onloadstart(value) { this[state$2].onloadstart = value; attach(this, "loadstart"); }
-    get onprogress() { return this[state$2].onprogress; }
-    set onprogress(value) { this[state$2].onprogress = value; attach(this, "progress"); }
-    get ontimeout() { return this[state$2].ontimeout; }
-    set ontimeout(value) { this[state$2].ontimeout = value; attach(this, "timeout"); }
-    toString() { return "[object XMLHttpRequestEventTarget]"; }
-    get isPolyfill() { return { symbol: polyfill, hierarchy: ["XMLHttpRequestEventTarget", "EventTarget"] }; }
-}
-dfStringTag(XMLHttpRequestEventTargetP, "XMLHttpRequestEventTarget");
+        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 */
@@ -2123,7 +2231,7 @@ class XMLHttpRequestEventTargetState {
 }
 _a$1 = _handlers$1;
 function attach(target, type) {
-    const s = target[state$2];
+    const s = target[state$3];
     const fnName = ("on" + type);
     const cb = s[fnName];
     const listener = s[_handlers$1][fnName];
@@ -2141,22 +2249,24 @@ function getHandlers$1(s) {
     };
 }
 
+/** @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"] }; }
 }
-dfStringTag(XMLHttpRequestUploadP, "XMLHttpRequestUpload");
+Class_setStringTag(XMLHttpRequestUploadP, "XMLHttpRequestUpload");
 /** @internal */
 function createXMLHttpRequestUpload() {
     let upload = Object.create(XMLHttpRequestUploadP.prototype);
     upload[state$d] = new EventTargetState(upload);
-    upload[state$2] = new XMLHttpRequestEventTargetState(upload);
+    upload[state$3] = new XMLHttpRequestEventTargetState(upload);
     return upload;
 }
 
@@ -2217,146 +2327,156 @@ const request = mp$2 ? mp$2.request : function errorRequest(options) {
 var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
 const mp$1 = { request: request };
 const setRequest = (request) => { mp$1.request = request; };
-/** @internal */ const state$1 = Symbol( /* "XMLHttpRequestState" */);
+/** @internal */
+const state$2 = Symbol( /* "XMLHttpRequestState" */);
+/** @type {typeof globalThis.XMLHttpRequest} */
 class XMLHttpRequestP extends XMLHttpRequestEventTargetP {
     constructor() {
         super();
-        this[state$1] = new XMLHttpRequestState(this);
+        this[state$2] = new XMLHttpRequestState(this);
     }
-    get readyState() { return this[state$1].readyState; }
-    get response() { return this[state$1].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$1].responseType; }
-    set responseType(value) { this[state$1].responseType = normalizeResponseType(value); }
-    get responseURL() { return this[state$1].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$1].status; }
+    get status() { return this[state$2].status; }
     get statusText() {
         if (this.readyState === XMLHttpRequestP.UNSENT || this.readyState === XMLHttpRequestP.OPENED)
             return "";
-        return this[state$1].statusText || statusTextMap(this.status);
+        return this[state$2].statusText || statusTextMap(this.status);
     }
-    get timeout() { return this[state$1].timeout; }
-    set timeout(value) { this[state$1].timeout = value > 0 ? value : 0; }
+    get timeout() { return this[state$2].timeout; }
+    set timeout(value) { this[state$2].timeout = value > 0 ? value : 0; }
     get upload() {
-        const that = this[state$1];
-        if (!that.upload) {
-            that.upload = createXMLHttpRequestUpload();
+        const s = this[state$2];
+        if (!s.upload) {
+            s.upload = createXMLHttpRequestUpload();
         }
-        return that.upload;
+        return s.upload;
     }
-    get withCredentials() { return this[state$1].withCredentials; }
-    set withCredentials(value) { this[state$1].withCredentials = !!value; }
+    get withCredentials() { return this[state$2].withCredentials; }
+    set withCredentials(value) { this[state$2].withCredentials = !!value; }
     abort() {
         clearRequest(this);
     }
     getAllResponseHeaders() {
-        if (!this[state$1][_responseHeaders])
+        if (!this[state$2][_responseHeaders])
             return "";
-        return Array.from(this[state$1][_responseHeaders].entries()).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) {
-        if (!this[state$1][_responseHeaders])
+    getResponseHeader(...args) {
+        const [name] = args;
+        checkArgsLength(args, 1, "XMLHttpRequest", "getResponseHeader");
+        if (!this[state$2][_responseHeaders])
             return null;
-        return this[state$1][_responseHeaders].get(name);
+        return this[state$2][_responseHeaders].get(name);
     }
     open(...args) {
         const [method, url, async = true, username = null, password = null] = args;
-        const that = this[state$1];
-        if (args.length < 2) {
-            throw new TypeError(`Failed to execute 'open' on 'XMLHttpRequest': 2 arguments required, but only ${args.length} present.`);
-        }
+        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.");
         }
+        const s = this[state$2];
         clearRequest(this, false);
-        that[_method] = normalizeMethod(method);
-        that[_requestURL] = String(url);
+        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 ${Uint8Array_toBase64((new TextEncoderP()).encode(_username + ":" + _password))}`;
+                let auth = `Basic ${Uint8Array_toBase64(encode$1(_username + ":" + _password))}`;
                 this.setRequestHeader("Authorization", auth);
             }
         }
-        that[_inAfterOpenBeforeSend] = true;
+        s[_inAfterOpenBeforeSend] = true;
         setReadyStateAndNotify(this, XMLHttpRequestP.OPENED);
     }
-    overrideMimeType(mime) {
-        if (this[state$1][_inAfterOpenBeforeSend]) {
-            console.warn(`XMLHttpRequest.overrideMimeType('${mime}') is not implemented: The method will have no effect on response parsing.`);
+    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$1];
-        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 && !that[_requestHeaders].has("Content-Type");
-        const upload = that.upload;
-        const processContentLength = upload && EventTarget_count(upload) > 0;
-        let headers = () => Array.from(that[_requestHeaders].entries())
-            .reduce((acc, cur) => { acc[cur[0]] = cur[1]; return acc; }, {});
+        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;
-        const processHeadersFn = processHeaders ? (v) => { that[_requestHeaders].set("Content-Type", 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, processHeadersFn, processContentLengthFn);
+            data = convert(body, false, processHeadersFn, processContentLengthFn);
         }
         catch (e) {
             console.warn(e);
         }
         let options = {
-            url: that[_requestURL],
-            method: that[_method],
+            url: s[_requestURL],
+            method: s[_method],
             header: headers(),
             data,
-            dataType: that.responseType === "json" ? "json" : normalizeDataType(that.responseType),
-            responseType: normalizeDataType(that.responseType),
-            withCredentials: that.withCredentials,
+            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),
         };
-        that[_requestTask] = mp$1.request(options);
+        s[_requestTask] = mp$1.request(options);
         emitProcessEvent(this, "loadstart");
-        if (processContentLength) {
-            const hasRequestBody = allowsRequestBody && !!data;
-            if (hasRequestBody) {
-                emitProcessEvent(upload, "loadstart", 0, contentLength);
-            }
-            setTimeout(() => {
-                const _aborted = that[_inAfterOpenBeforeSend] || that.readyState !== XMLHttpRequestP.OPENED;
+        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(this);
     }
-    setRequestHeader(name, value) {
-        this[state$1][_requestHeaders].append(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$1].onreadystatechange; }
+    get onreadystatechange() { return this[state$2].onreadystatechange; }
     set onreadystatechange(value) {
-        this[state$1].onreadystatechange = value;
-        attachFn(this, "readystatechange", value, this[state$1][_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 },
@@ -2367,7 +2487,7 @@ const properties = {
 };
 Object.defineProperties(XMLHttpRequestP, properties);
 Object.defineProperties(XMLHttpRequestP.prototype, properties);
-dfStringTag(XMLHttpRequestP, "XMLHttpRequest");
+Class_setStringTag(XMLHttpRequestP, "XMLHttpRequest");
 /** @internal */ const _handlers = Symbol();
 /** @internal */ const _inAfterOpenBeforeSend = Symbol();
 /** @internal */ const _resetPending = Symbol();
@@ -2405,7 +2525,7 @@ class XMLHttpRequestState {
 }
 _a = _handlers, _b = _inAfterOpenBeforeSend, _c = _resetPending, _d = _timeoutId, _e = _requestURL, _f = _method, _g = _requestHeaders, _h = _responseHeaders, _j = _responseContentLength, _k = _requestTask;
 function requestSuccess({ statusCode, header, data }) {
-    const s = this[state$1];
+    const s = this[state$2];
     s.responseURL = s[_requestURL];
     s.status = statusCode;
     s[_responseHeaders] = new HeadersP(header);
@@ -2442,7 +2562,7 @@ function requestFail(err) {
         requestSuccess.call(this, { statusCode: err.status, header: err.headers, data: err.data });
         return;
     }
-    const s = this[state$1];
+    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) {
@@ -2451,7 +2571,7 @@ function requestFail(err) {
     }
 }
 function requestComplete() {
-    const s = this[state$1];
+    const s = this[state$2];
     s[_requestTask] = null;
     if (!s[_inAfterOpenBeforeSend] && (s.readyState === XMLHttpRequestP.OPENED || s.readyState === XMLHttpRequestP.LOADING)) {
         setReadyStateAndNotify(this, XMLHttpRequestP.DONE);
@@ -2464,7 +2584,7 @@ function requestComplete() {
     });
 }
 function clearRequest(xhr, delay = true) {
-    const s = xhr[state$1];
+    const s = xhr[state$2];
     const timerFn = delay ? setTimeout : (f) => { f(); };
     s[_resetPending] = true;
     if (s[_requestTask] && s.readyState !== XMLHttpRequestP.DONE) {
@@ -2494,7 +2614,7 @@ function clearRequest(xhr, delay = true) {
     });
 }
 function checkRequestTimeout(xhr) {
-    const s = xhr[state$1];
+    const s = xhr[state$2];
     if (s.timeout) {
         s[_timeoutId] = setTimeout(() => {
             if (!s.status && s.readyState !== XMLHttpRequestP.DONE) {
@@ -2507,7 +2627,7 @@ function checkRequestTimeout(xhr) {
     }
 }
 function resetXHR(xhr) {
-    const s = xhr[state$1];
+    const s = xhr[state$2];
     s[_resetPending] = false;
     resetRequestTimeout(xhr);
     s.response = "";
@@ -2519,14 +2639,14 @@ function resetXHR(xhr) {
     s[_responseContentLength] = zero;
 }
 function resetRequestTimeout(xhr) {
-    const s = xhr[state$1];
+    const s = xhr[state$2];
     if (s[_timeoutId]) {
         clearTimeout(s[_timeoutId]);
         s[_timeoutId] = 0;
     }
 }
 function setReadyStateAndNotify(xhr, value) {
-    const s = xhr[state$1];
+    const s = xhr[state$2];
     let hasChanged = value !== s.readyState;
     s.readyState = value;
     if (hasChanged) {
@@ -2546,11 +2666,6 @@ function normalizeResponseType(responseType) {
 function normalizeDataType(responseType) {
     return (responseType === "blob" || responseType === "arraybuffer") ? "arraybuffer" : "text";
 }
-function getAllResponseHeaders(xhr) {
-    return xhr instanceof XMLHttpRequestP
-        ? xhr[state$1][_responseHeaders]
-        : parseHeaders(xhr.getAllResponseHeaders() || "");
-}
 const zero = () => 0;
 const statusMessages = {
     100: "Continue",
@@ -2620,13 +2735,104 @@ function statusTextMap(val) {
 }
 const XMLHttpRequestE = (typeof XMLHttpRequest !== "undefined" && XMLHttpRequest) || XMLHttpRequestP;
 
+/** @internal */ const state$1 = Symbol( /* "ResponseState" */);
+/** @type {typeof globalThis.Response} */
+class ResponseP extends BodyImpl {
+    constructor(body, init) {
+        super();
+        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].`);
+        }
+        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 headers() {
+        const s = this[state$1];
+        if (!s.headers) {
+            s.headers = new HeadersP();
+        }
+        return s.headers;
+    }
+    get ok() { return this[state$1].ok; }
+    get redirected() { return this[state$1].redirected; }
+    get status() { return this[state$1].status; }
+    get statusText() { return this[state$1].statusText; }
+    get type() { return this[state$1].type; }
+    get url() { return this[state$1].url; }
+    clone() {
+        if (this.bodyUsed) {
+            throw new TypeError("Failed to execute 'clone' on 'Response': Response body is already used");
+        }
+        let response = new ResponseP(Body_toPayload(this), {
+            headers: new HeadersP(this.headers),
+            status: this.status,
+            statusText: this.statusText,
+        });
+        response[state$1].url = this.url;
+        return response;
+    }
+    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$1].ok = false;
+        response[state$1].status = 0;
+        response[state$1].type = "error";
+        return response;
+    }
+    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 ResponseP(null, { status, headers: { location: "" + url } });
+    }
+    /** @internal */ toString() { return "[object Response]"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["Response"] }; }
+}
+Class_setStringTag(ResponseP, "Response");
+/** @internal */
+class ResponseState {
+    constructor() {
+        this.ok = true;
+        this.redirected = false;
+        this.status = 200;
+        this.statusText = "";
+        this.type = "default";
+        this.url = "";
+    }
+}
+const ResponseE = g["Response"] || ResponseP;
+
 const mp = { XMLHttpRequest: XMLHttpRequestE };
 const setXMLHttpRequest = (XHR) => { mp.XMLHttpRequest = XHR; };
-function fetchP(input, init) {
+/** @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$4].signal;
         if (signal && signal.aborted) {
@@ -2635,13 +2841,18 @@ function fetchP(input, init) {
         let xhr = new mp.XMLHttpRequest();
         xhr.onload = function () {
             let options = {
-                headers: getAllResponseHeaders(xhr),
+                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$3].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);
             });
         };
@@ -2660,28 +2871,31 @@ function fetchP(input, init) {
                 reject(new MPException("request:fail abort", "AbortError"));
             });
         };
-        xhr.open(request.method, request.url);
+        xhr.open(request.method, request.url, true);
         if (request.credentials === "include") {
             xhr.withCredentials = true;
         }
         else if (request.credentials === "omit") {
             xhr.withCredentials = false;
         }
-        if (init && typeof init === "object" && isObjectHeaders(init.headers)) {
+        if ("responseType" in xhr) {
+            xhr.responseType = "arraybuffer";
+        }
+        if (init && typeof init === "object" && typeof init.headers === "object" && !isObjectType("Headers", init.headers)) {
             let headers = init.headers;
             let names = [];
-            objectEntries(headers).forEach(([name, value]) => {
+            Object.getOwnPropertyNames(headers).forEach(name => {
                 names.push(normalizeName(name));
-                xhr.setRequestHeader(name, normalizeValue(value));
+                xhr.setRequestHeader(name, normalizeValue(headers[name]));
             });
-            request.headers.forEach(function (value, name) {
-                if (names.indexOf(normalizeName(name)) === -1) {
+            request.headers.forEach((value, name) => {
+                if (names.indexOf(name) === -1) {
                     xhr.setRequestHeader(name, value);
                 }
             });
         }
         else {
-            request.headers.forEach(function (value, name) {
+            request.headers.forEach((value, name) => {
                 xhr.setRequestHeader(name, value);
             });
         }
@@ -2698,14 +2912,12 @@ function fetchP(input, init) {
         xhr.send(Body_toPayload(request));
     });
 }
-function isObjectHeaders(val) {
-    return typeof val === "object" && !isObjectType("Headers", val);
-}
 const fetchE = g["fetch"] || fetchP;
 
 const dispatched = 1;
 /** @internal */
 const state = Symbol( /* "CustomEventState" */);
+/** @type {typeof globalThis.CustomEvent} */
 class CustomEventP extends EventP {
     constructor(type, eventInitDict) {
         var _a;
@@ -2714,16 +2926,18 @@ class CustomEventP extends EventP {
         this[state].detail = (_a = eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.detail) !== null && _a !== void 0 ? _a : null;
     }
     get detail() { return this[state].detail; }
-    initCustomEvent(type, bubbles, cancelable, detail) {
+    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;
     }
-    toString() { return "[object CustomEvent]"; }
-    get isPolyfill() { return { symbol: polyfill, hierarchy: ["CustomEvent", "Event"] }; }
+    /** @internal */ toString() { return "[object CustomEvent]"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["CustomEvent", "Event"] }; }
 }
-dfStringTag(CustomEventP, "CustomEvent");
+Class_setStringTag(CustomEventP, "CustomEvent");
 /** @internal */
 class CustomEventState {
 }