mphttpx 1.0.0

package/dist/index.cjs.js

@@ -0,0 +1,2349 @@
+'use strict';
+
+const polyfill = Symbol("isPolyfill");
+const state$9 = Symbol("INTERNAL_STATE");
+/* eslint-disable no-prototype-builtins */
+const g = (typeof globalThis !== "undefined" && globalThis) ||
+    (typeof self !== "undefined" && self) ||
+    // @ts-ignore eslint-disable-next-line no-undef
+    (typeof global !== "undefined" && global) ||
+    {};
+function isObjectType(name, value) {
+    return Object.prototype.toString.call(value) === `[object ${name}]`;
+}
+function isPolyfillType(name, value) {
+    return !!value
+        && typeof value === "object"
+        && "isPolyfill" in value
+        && !!value.isPolyfill
+        && typeof value.isPolyfill === "object"
+        && "symbol" in value.isPolyfill
+        && value.isPolyfill.symbol === polyfill
+        && "hierarchy" in value.isPolyfill
+        && Array.isArray(value.isPolyfill.hierarchy)
+        && value.isPolyfill.hierarchy.includes(name);
+}
+class MPException extends Error {
+    constructor(message, name) {
+        super();
+        this.message = message ?? this.message;
+        this.name = name ?? this.name;
+    }
+}
+function defineStringTag(targetFunc, stringTag) {
+    Object.defineProperty(targetFunc.prototype, Symbol.toStringTag, {
+        configurable: true,
+        value: stringTag,
+    });
+}
+
+class TextEncoderP {
+    get encoding() { return "utf-8"; }
+    encode(input = "") {
+        return encodeText(input).encoded;
+    }
+    encodeInto(source, destination) {
+        const result = encodeText(source, destination);
+        return { read: result.read, written: result.written };
+    }
+    toString() { return "[object TextEncoder]"; }
+    get isPolyfill() { return { symbol: polyfill, hierarchy: ["TextEncoder"] }; }
+}
+defineStringTag(TextEncoderP, "TextEncoder");
+function encodeText(input, destination) {
+    const HAS_DESTINATION = typeof destination !== "undefined";
+    let pos = 0;
+    let read = 0;
+    let len = input.length;
+    let at = 0; // output position
+    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++);
+        if (value >= 0xd800 && value <= 0xdbff) {
+            // high surrogate
+            if (pos < len) {
+                let extra = input.charCodeAt(pos);
+                if ((extra & 0xfc00) === 0xdc00) {
+                    ++pos;
+                    value = ((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000;
+                }
+                else {
+                    value = 0xfffd;
+                }
+            }
+            else {
+                value = 0xfffd;
+            }
+        }
+        else if (value >= 0xdc00 && value <= 0xdfff) {
+            value = 0xfffd;
+        }
+        // expand the buffer if we couldn't write 4 bytes
+        if (!HAS_DESTINATION && at + 4 > target.length) {
+            tlen += 8; // minimum extra
+            tlen *= (1.0 + (pos / input.length) * 2); // take 2x the remaining
+            tlen = (tlen >> 3) << 3; // 8 byte offset
+            let update = new Uint8Array(tlen);
+            update.set(target);
+            target = update;
+        }
+        let byteCount;
+        if ((value & 0xffffff80) === 0) { // 1-byte
+            byteCount = 1;
+        }
+        else if ((value & 0xfffff800) === 0) { // 2-byte
+            byteCount = 2;
+        }
+        else if ((value & 0xffff0000) === 0) { // 3-byte
+            byteCount = 3;
+        }
+        else if ((value & 0xffe00000) === 0) { // 4-byte
+            byteCount = 4;
+        }
+        else {
+            value = 0xfffd;
+            byteCount = 3;
+        }
+        if (HAS_DESTINATION && at + byteCount > target.length) {
+            break;
+        }
+        if (byteCount === 1) { // 1-byte
+            target[at++] = value; // ASCII
+        }
+        else if (byteCount === 2) { // 2-byte
+            target[at++] = ((value >> 6) & 0x1f) | 0xc0;
+            target[at++] = (value & 0x3f) | 0x80;
+        }
+        else if (byteCount === 3) { // 3-byte
+            target[at++] = ((value >> 12) & 0x0f) | 0xe0;
+            target[at++] = ((value >> 6) & 0x3f) | 0x80;
+            target[at++] = (value & 0x3f) | 0x80;
+        }
+        else if (byteCount === 4) { // 4-byte
+            target[at++] = ((value >> 18) & 0x07) | 0xf0;
+            target[at++] = ((value >> 12) & 0x3f) | 0x80;
+            target[at++] = ((value >> 6) & 0x3f) | 0x80;
+            target[at++] = (value & 0x3f) | 0x80;
+        }
+        read++;
+    }
+    return {
+        encoded: !HAS_DESTINATION ? target.slice(0, at) : destination.slice(),
+        read: read,
+        written: at,
+    };
+}
+const TextEncoderE = g["TextEncoder"] || TextEncoderP;
+
+const state$8 = Symbol("TextDecoderState");
+class TextDecoderP {
+    constructor(utfLabel = "utf-8", { fatal = false, ignoreBOM = false } = {}) {
+        if (!UTF8Labels.includes(utfLabel.toLowerCase())) {
+            throw new RangeError("TextDecoder: The encoding label provided ('" + utfLabel + "') is invalid.");
+        }
+        this[state$8] = new TextDecoderState();
+        this[state$8].fatal = fatal;
+        this[state$8].ignoreBOM = ignoreBOM;
+    }
+    [state$8];
+    get encoding() { return "utf-8"; }
+    get fatal() { return this[state$8].fatal; }
+    get ignoreBOM() { return this[state$8].ignoreBOM; }
+    decode(buffer, { stream = false } = {}) {
+        let buf;
+        if (typeof buffer !== "undefined") {
+            if (buffer instanceof Uint8Array) {
+                buf = buffer;
+            }
+            else if (ArrayBuffer.isView(buffer)) {
+                buf = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+            }
+            else {
+                buf = new Uint8Array(buffer);
+            }
+        }
+        else {
+            if (this[state$8]._partial.length > 0) {
+                if (this.fatal) {
+                    throw new TypeError("TextDecoder: Incomplete UTF-8 sequence.");
+                }
+                else {
+                    this[state$8]._partial = [];
+                }
+            }
+            return "";
+        }
+        if (!this[state$8]._bomSeen && this.ignoreBOM && buf.length >= 3) {
+            if (buf[0] === 0xef && buf[1] === 0xbb && buf[2] === 0xbf) {
+                buf = buf.subarray(3);
+                this[state$8]._bomSeen = true;
+            }
+        }
+        if (this[state$8]._partial.length > 0) {
+            let merged = new Uint8Array(this[state$8]._partial.length + buf.length);
+            merged.set(this[state$8]._partial, 0);
+            merged.set(buf, this[state$8]._partial.length);
+            buf = merged;
+            this[state$8]._partial = [];
+        }
+        let end = buf.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 ((byte & 0b11000000) !== 0b10000000) {
+                    let len = getBytesPerSequence(byte);
+                    if (len > buf.length - (i - 1)) {
+                        end = i - 1;
+                    }
+                    break;
+                }
+                i--;
+            }
+            this[state$8]._partial = Array.from(buf.slice(end)); // save tail
+            buf = buf.slice(0, end);
+        }
+        let i = 0;
+        while (i < end) {
+            let firstByte = buf[i];
+            let codePoint = null;
+            let bytesPerSequence = getBytesPerSequence(firstByte);
+            if (i + bytesPerSequence <= end) {
+                let secondByte, thirdByte, fourthByte, tempCodePoint;
+                switch (bytesPerSequence) {
+                    case 1:
+                        if (firstByte < 0x80) {
+                            codePoint = firstByte;
+                        }
+                        break;
+                    case 2:
+                        secondByte = buf[i + 1];
+                        if ((secondByte & 0xC0) === 0x80) {
+                            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F);
+                            if (tempCodePoint > 0x7F) {
+                                codePoint = tempCodePoint;
+                            }
+                        }
+                        break;
+                    case 3:
+                        secondByte = buf[i + 1];
+                        thirdByte = buf[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)) {
+                                codePoint = tempCodePoint;
+                            }
+                        }
+                        break;
+                    case 4:
+                        secondByte = buf[i + 1];
+                        thirdByte = buf[i + 2];
+                        fourthByte = buf[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;
+                            }
+                        }
+                }
+            }
+            if (codePoint === null) {
+                if (this.fatal) {
+                    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;
+                }
+            }
+            else if (codePoint > 0xFFFF) {
+                // encode to utf16 (surrogate pair dance)
+                codePoint -= 0x10000;
+                res.push(codePoint >>> 10 & 0x3FF | 0xD800);
+                codePoint = 0xDC00 | codePoint & 0x3FF;
+            }
+            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;
+    }
+    toString() { return "[object TextDecoder]"; }
+    get isPolyfill() { return { symbol: polyfill, hierarchy: ["TextDecoder"] }; }
+}
+defineStringTag(TextDecoderP, "TextDecoder");
+class TextDecoderState {
+    fatal = false;
+    ignoreBOM = false;
+    _bomSeen = false;
+    _partial = [];
+}
+const UTF8Labels = ["utf-8", "utf8", "unicode-1-1-utf-8"];
+function getBytesPerSequence(byte) {
+    return (byte > 0xEF) ? 4 : (byte > 0xDF) ? 3 : (byte > 0xBF) ? 2 : 1;
+}
+const TextDecoderE = g["TextDecoder"] || TextDecoderP;
+
+class EventP {
+    static NONE = 0;
+    static CAPTURING_PHASE = 1;
+    static AT_TARGET = 2;
+    static BUBBLING_PHASE = 3;
+    constructor(type, eventInitDict) {
+        this[state$9] = new EventState();
+        this[state$9].type = String(type);
+        this[state$9].bubbles = !!eventInitDict?.bubbles;
+        this[state$9].cancelable = !!eventInitDict?.cancelable;
+        this[state$9].composed = !!eventInitDict?.composed;
+    }
+    [state$9];
+    get type() { return this[state$9].type; }
+    get bubbles() { return this[state$9].bubbles; }
+    get cancelable() { return this[state$9].cancelable; }
+    get composed() { return this[state$9].composed; }
+    get target() { return this[state$9].target; }
+    get currentTarget() { return this[state$9].currentTarget; }
+    get eventPhase() { return this[state$9].eventPhase; }
+    NONE = EventP.NONE;
+    CAPTURING_PHASE = EventP.CAPTURING_PHASE;
+    AT_TARGET = EventP.AT_TARGET;
+    BUBBLING_PHASE = EventP.BUBBLING_PHASE;
+    get srcElement() { return this[state$9].target; }
+    cancelBubble = false;
+    get defaultPrevented() { return this[state$9].defaultPrevented; }
+    get returnValue() { return this[state$9].returnValue; }
+    set returnValue(value) { if (!value) {
+        this.preventDefault();
+    } }
+    get isTrusted() { return this[state$9].isTrusted; }
+    get timeStamp() { return this[state$9].timeStamp; }
+    composedPath() {
+        const path = !!this.target ? [this.target] : [];
+        if (!!this.currentTarget && this.currentTarget !== this.target)
+            path.push(this.currentTarget);
+        return path;
+    }
+    initEvent = (type, bubbles, cancelable) => {
+        if (this[state$9]._dispatched)
+            return;
+        this[state$9].type = String(type);
+        this[state$9].bubbles = !!bubbles;
+        this[state$9].cancelable = !!cancelable;
+    };
+    preventDefault = () => {
+        if (this[state$9]._passive) {
+            console.warn(`Ignoring 'preventDefault()' call on event of type '${this.type}' from a listener registered as 'passive'.`);
+            return;
+        }
+        if (this.cancelable) {
+            this[state$9]._preventDefaultCalled = true;
+            this[state$9].defaultPrevented = true;
+            this[state$9].returnValue = false;
+        }
+    };
+    stopImmediatePropagation = () => {
+        this[state$9]._stopImmediatePropagationCalled = true;
+        this.cancelBubble = true;
+    };
+    stopPropagation() {
+        this.cancelBubble = true;
+    }
+    toString() { return "[object Event]"; }
+    get isPolyfill() { return { symbol: polyfill, hierarchy: ["Event"] }; }
+}
+defineStringTag(EventP, "Event");
+class EventState {
+    static TimeStamp = (new Date()).getTime();
+    type = "";
+    bubbles = false;
+    cancelable = false;
+    composed = false;
+    target = null;
+    currentTarget = null;
+    eventPhase = EventP.NONE;
+    defaultPrevented = false;
+    returnValue = true;
+    isTrusted = false;
+    timeStamp = (new Date()).getTime() - EventState.TimeStamp;
+    _passive = false;
+    _dispatched = false;
+    _preventDefaultCalled = false;
+    _stopImmediatePropagationCalled = false;
+}
+const EventE = g["EventTarget"] ? g["Event"] : EventP;
+
+const state$7 = Symbol("EventTargetState");
+class EventTargetP {
+    constructor() {
+        this[state$7] = new EventTargetState(this);
+    }
+    [state$7];
+    addEventListener(type, callback, options) {
+        const executor = new Executor(type, callback);
+        executor.options.capture = typeof options === "boolean" ? options : !!options?.capture;
+        if (!this[state$7].executors.some(x => x.equals(executor))) {
+            if (typeof options === "object") {
+                const { once, passive, signal } = options;
+                executor.options.once = !!once;
+                executor.options.passive = !!passive;
+                if (signal) {
+                    executor.options.signal = signal;
+                    this[state$7].reply(signal, executor);
+                }
+            }
+            this[state$7].executors.push(executor);
+            const f = (v) => !!v.options.capture ? 0 : 1;
+            this[state$7].executors = this[state$7].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.");
+        }
+        if (!(event instanceof EventP)) {
+            throw new TypeError("EventTarget.dispatchEvent: Argument 1 does not implement interface Event.");
+        }
+        const s = event[state$9];
+        s.target = this;
+        s.isTrusted = false;
+        return this[state$7].fire(event);
+    }
+    removeEventListener(type, callback, options) {
+        const executor = new Executor(type, callback);
+        executor.options.capture = typeof options === "boolean" ? options : !!options?.capture;
+        if (this[state$7].executors.some(x => x.equals(executor))) {
+            this[state$7].executors = this[state$7].executors.filter(x => !x.equals(executor));
+        }
+    }
+    toString() { return "[object EventTarget]"; }
+    get isPolyfill() { return { symbol: polyfill, hierarchy: ["EventTarget"] }; }
+}
+defineStringTag(EventTargetP, "EventTarget");
+class EventTargetState {
+    constructor(target) {
+        this.target = target;
+    }
+    target;
+    executors = [];
+    fire(event) {
+        const s = event[state$9];
+        if (!event.target)
+            s.target = this.target;
+        s.currentTarget = this.target;
+        s.eventPhase = EventP.AT_TARGET;
+        s._dispatched = true;
+        const onceIndexes = [];
+        for (let i = 0; i < this.executors.length; ++i) {
+            const executor = this.executors[i];
+            if (executor.type !== event.type)
+                continue;
+            s._passive = !!executor.options.passive;
+            if (executor.options.once)
+                onceIndexes.push(i);
+            try {
+                const { callback: cb } = executor;
+                if (typeof cb === "function")
+                    cb.call(this.target, event);
+            }
+            catch (e) {
+                console.error(e);
+            }
+            s._passive = false;
+            if (s._stopImmediatePropagationCalled)
+                break;
+        }
+        if (onceIndexes.length > 0) {
+            this.executors = this.executors.reduce((acc, cur, index) => {
+                if (!onceIndexes.includes(index))
+                    acc.push(cur);
+                return acc;
+            }, []);
+        }
+        s.currentTarget = null;
+        s.eventPhase = EventP.NONE;
+        s._dispatched = false;
+        return !(event.cancelable && s._preventDefaultCalled);
+    }
+    reply(signal, executor) {
+        try {
+            const onAbort = () => {
+                this.executors = this.executors.filter(x => !x.equals(executor));
+                signal.removeEventListener("abort", onAbort);
+            };
+            signal.addEventListener("abort", onAbort);
+        }
+        catch (e) {
+            console.error(e);
+        }
+    }
+}
+class Executor {
+    static extract(cb) {
+        if (typeof cb === "function") {
+            return cb;
+        }
+        else if (isEventListenerObject(cb)) {
+            return cb.handleEvent;
+        }
+        else {
+            return cb;
+        }
+    }
+    constructor(type, callback) {
+        this.type = String(type);
+        this.callback = Executor.extract(callback);
+    }
+    type;
+    callback;
+    options = {};
+    equals(executor) {
+        return Object.is(this.type, executor.type) && Object.is(this.callback, executor.callback)
+            && Object.is(this.options.capture, executor.options.capture);
+    }
+}
+function isEventListenerObject(cb) {
+    return !!cb && "handleEvent" in cb && typeof cb.handleEvent === "function";
+}
+function attachFn(type, cb, listener) {
+    if (typeof cb === "function") {
+        this.addEventListener(type, listener);
+    }
+    else {
+        this.removeEventListener(type, listener);
+    }
+}
+function executeFn(cb, ev) {
+    if (typeof cb === "function")
+        cb.call(this, ev);
+}
+const EventTargetE = g["EventTarget"] || EventTargetP;
+
+const state$6 = Symbol("CustomEventState");
+class CustomEventP extends EventP {
+    constructor(type, eventInitDict) {
+        super(type, eventInitDict);
+        this[state$6] = new CustomEventState();
+        this[state$6].detail = eventInitDict?.detail ?? null;
+    }
+    [state$6];
+    get detail() { return this[state$6].detail; }
+    initCustomEvent(type, bubbles, cancelable, detail) {
+        if (this[state$9]._dispatched)
+            return;
+        this.initEvent(type, bubbles, cancelable);
+        this[state$6].detail = detail ?? null;
+    }
+    toString() { return "[object CustomEvent]"; }
+    get isPolyfill() { return { symbol: polyfill, hierarchy: ["CustomEvent", "Event"] }; }
+}
+defineStringTag(CustomEventP, "CustomEvent");
+class CustomEventState {
+    detail;
+}
+const CustomEventE = g["EventTarget"] ? g["CustomEvent"] : CustomEventP;
+
+const state$5 = Symbol("ProgressEventState");
+class ProgressEventP extends EventP {
+    constructor(type, eventInitDict) {
+        super(type, eventInitDict);
+        this[state$5] = new ProgressEventState();
+        this[state$5].lengthComputable = !!eventInitDict?.lengthComputable;
+        this[state$5].loaded = eventInitDict?.loaded ?? 0;
+        this[state$5].total = eventInitDict?.total ?? 0;
+    }
+    [state$5];
+    get lengthComputable() { return this[state$5].lengthComputable; }
+    get loaded() { return this[state$5].loaded; }
+    get total() { return this[state$5].total; }
+    toString() { return "[object ProgressEvent]"; }
+    get isPolyfill() { return { symbol: polyfill, hierarchy: ["ProgressEvent", "Event"] }; }
+}
+defineStringTag(ProgressEventP, "ProgressEvent");
+class ProgressEventState {
+    lengthComputable = false;
+    loaded = 0;
+    total = 0;
+}
+const ProgressEventE = g["EventTarget"] ? g["ProgressEvent"] : ProgressEventP;
+
+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$9]._u8array);
+            }
+            else if (part instanceof ArrayBuffer || ArrayBuffer.isView(part)) {
+                chunks.push(convert$1(part));
+            }
+            else {
+                if (!encoder) {
+                    encoder = new TextEncoderP();
+                }
+                chunks.push(encoder.encode(String(part)));
+            }
+            return chunks;
+        }, []);
+        this[state$9] = new BlobState(concat(chunks));
+        this[state$9].size = this[state$9]._u8array.length;
+        const rawType = options?.type || "";
+        this[state$9].type = /[^\u0020-\u007E]/.test(rawType) ? "" : rawType.toLowerCase();
+    }
+    [state$9];
+    get size() { return this[state$9].size; }
+    get type() { return this[state$9].type; }
+    arrayBuffer() {
+        return Promise.resolve(clone(this[state$9]._u8array.buffer).buffer);
+    }
+    bytes() {
+        return Promise.resolve(clone(this[state$9]._u8array.buffer));
+    }
+    slice(start, end, contentType) {
+        const sliced = this[state$9]._u8array.slice(start ?? 0, end ?? this[state$9]._u8array.length);
+        return new BlobP([sliced], { type: contentType ?? "" });
+    }
+    stream() {
+        throw new ReferenceError("ReadableStream is not defined");
+    }
+    text() {
+        const decoder = new TextDecoderP();
+        return Promise.resolve(decoder.decode(this[state$9]._u8array));
+    }
+    toString() { return "[object Blob]"; }
+    get isPolyfill() { return { symbol: polyfill, hierarchy: ["Blob"] }; }
+}
+defineStringTag(BlobP, "Blob");
+class BlobState {
+    constructor(buffer) {
+        this._u8array = buffer;
+    }
+    size = 0;
+    type = "";
+    _u8array;
+}
+function u8array2base64(input) {
+    let byteToCharMap = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+    let output = [];
+    for (var i = 0; i < input.length; i += 3) {
+        let byte1 = input[i];
+        let haveByte2 = i + 1 < input.length;
+        let byte2 = haveByte2 ? input[i + 1] : 0;
+        let haveByte3 = i + 2 < input.length;
+        let byte3 = haveByte3 ? input[i + 2] : 0;
+        let outByte1 = byte1 >> 2;
+        let outByte2 = ((byte1 & 0x03) << 4) | (byte2 >> 4);
+        let outByte3 = ((byte2 & 0x0F) << 2) | (byte3 >> 6);
+        let outByte4 = byte3 & 0x3F;
+        if (!haveByte3) {
+            outByte4 = 64;
+            if (!haveByte2) {
+                outByte3 = 64;
+            }
+        }
+        output.push(byteToCharMap[outByte1], byteToCharMap[outByte2], byteToCharMap[outByte3], byteToCharMap[outByte4]);
+    }
+    return output.join("");
+}
+function convert$1(buf) {
+    return buf instanceof ArrayBuffer
+        ? new Uint8Array(buf)
+        : new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+}
+function clone(buf) {
+    const sourceArray = convert$1(buf);
+    const cloneArray = new Uint8Array(new ArrayBuffer(sourceArray.byteLength));
+    cloneArray.set(sourceArray);
+    return cloneArray;
+}
+function concat(chunks) {
+    const totalByteLength = chunks.reduce((acc, cur) => acc + cur.byteLength, 0);
+    const result = new Uint8Array(totalByteLength);
+    chunks.reduce((offset, chunk) => {
+        result.set(chunk, offset);
+        return offset + chunk.byteLength;
+    }, 0);
+    return result;
+}
+const BlobE = g["Blob"] || BlobP;
+
+const state$4 = Symbol("FileState");
+class FileP extends BlobP {
+    constructor(fileBits, fileName, options) {
+        super(fileBits, options);
+        this[state$4] = new FileState();
+        this[state$4].lastModified = +(options?.lastModified ? new Date(options.lastModified) : new Date());
+        this[state$4].name = fileName.replace(/\//g, ":");
+    }
+    [state$4];
+    get lastModified() { return this[state$4].lastModified; }
+    get name() { return this[state$4].name; }
+    get webkitRelativePath() { return ""; }
+    toString() { return "[object File]"; }
+    get isPolyfill() { return { symbol: polyfill, hierarchy: ["File", "Blob"] }; }
+}
+defineStringTag(FileP, "File");
+class FileState {
+    lastModified = 0;
+    name = "";
+}
+const FileE = g["Blob"] ? g["File"] : FileP;
+
+const state$3 = Symbol("FileReaderState");
+class FileReaderP extends EventTargetP {
+    static EMPTY = 0;
+    static LOADING = 1;
+    static DONE = 2;
+    constructor() {
+        super();
+        this[state$3] = new FileReaderState(this);
+    }
+    [state$3];
+    get readyState() { return this[state$3].readyState; }
+    get result() { return this[state$3].result; }
+    EMPTY = 0;
+    LOADING = 1;
+    DONE = 2;
+    get error() { return this[state$3].error; }
+    abort() {
+        if (this.readyState === FileReaderP.LOADING) {
+            this[state$3].readyState = FileReaderP.DONE;
+            this[state$3].result = null;
+            this[state$3].emitProcessEvent("abort");
+        }
+    }
+    readAsArrayBuffer = (blob) => {
+        this[state$3].read("readAsArrayBuffer", blob, () => {
+            this[state$3].result = blob[state$9]._u8array.buffer.slice(0);
+        });
+    };
+    readAsBinaryString = (blob) => {
+        this[state$3].read("readAsBinaryString", blob, () => {
+            this[state$3].result = blob[state$9]._u8array.reduce((acc, cur) => {
+                acc += String.fromCharCode(cur);
+                return acc;
+            }, "");
+        });
+    };
+    readAsDataURL = (blob) => {
+        this[state$3].read("readAsDataURL", blob, () => {
+            this[state$3].result = "data:" + blob.type + ";base64," + u8array2base64(blob[state$9]._u8array);
+        });
+    };
+    readAsText = (blob, encoding) => {
+        this[state$3].read("readAsText", blob, () => {
+            this[state$3].result = (new TextDecoderP(encoding)).decode(blob[state$9]._u8array);
+        });
+    };
+    get onabort() { return this[state$3].onabort; }
+    set onabort(value) { this[state$3].onabort = value; this[state$3].attach("abort"); }
+    get onerror() { return this[state$3].onerror; }
+    set onerror(value) { this[state$3].onerror = value; this[state$3].attach("error"); }
+    get onload() { return this[state$3].onload; }
+    set onload(value) { this[state$3].onload = value; this[state$3].attach("load"); }
+    get onloadend() { return this[state$3].onloadend; }
+    set onloadend(value) { this[state$3].onloadend = value; this[state$3].attach("loadend"); }
+    get onloadstart() { return this[state$3].onloadstart; }
+    set onloadstart(value) { this[state$3].onloadstart = value; this[state$3].attach("loadstart"); }
+    get onprogress() { return this[state$3].onprogress; }
+    set onprogress(value) { this[state$3].onprogress = value; this[state$3].attach("progress"); }
+    toString() { return "[object FileReader]"; }
+    get isPolyfill() { return { symbol: polyfill, hierarchy: ["FileReader", "EventTarget"] }; }
+}
+defineStringTag(FileReaderP, "FileReader");
+class FileReaderState {
+    constructor(target) {
+        this.target = target;
+    }
+    target;
+    readyState = FileReaderP.EMPTY;
+    result = null;
+    error = null;
+    read(kind, blob, setResult) {
+        if (!isPolyfillType("Blob", blob)) {
+            throw new TypeError("Failed to execute '" + kind + "' on 'FileReader': parameter 1 is not of type 'Blob'.");
+        }
+        this.error = null;
+        this.readyState = FileReaderP.LOADING;
+        this.emitProcessEvent("loadstart", 0, blob.size);
+        setTimeout(() => {
+            if (this.readyState === FileReaderP.LOADING) {
+                this.readyState = FileReaderP.DONE;
+                try {
+                    setResult();
+                    this.emitProcessEvent("load", blob.size, blob.size);
+                }
+                catch (e) {
+                    this.result = null;
+                    this.error = e;
+                    this.emitProcessEvent("error", 0, blob.size);
+                }
+            }
+            this.emitProcessEvent("loadend", !!this.result ? blob.size : 0, blob.size);
+        });
+    }
+    emitProcessEvent(type, loaded = 0, total = 0) {
+        const event = new ProgressEventP(type, {
+            lengthComputable: total > 0,
+            loaded,
+            total,
+        });
+        event[state$9].target = this.target;
+        event[state$9].isTrusted = true;
+        this.target[state$7].fire(event);
+    }
+    attach(type) {
+        const cb = this[("on" + type)];
+        const listener = this[("_on" + type)];
+        attachFn.call(this.target, type, cb, listener);
+    }
+    onabort = null;
+    _onabort = (ev) => { executeFn.call(this.target, this.onabort, ev); };
+    onerror = null;
+    _onerror = (ev) => { executeFn.call(this.target, this.onerror, ev); };
+    onload = null;
+    _onload = (ev) => { executeFn.call(this.target, this.onload, ev); };
+    onloadend = null;
+    _onloadend = (ev) => { executeFn.call(this.target, this.onloadend, ev); };
+    onloadstart = null;
+    _onloadstart = (ev) => { executeFn.call(this.target, this.onloadstart, ev); };
+    onprogress = null;
+    _onprogress = (ev) => { executeFn.call(this.target, this.onprogress, ev); };
+}
+const FileReaderE = g["Blob"] ? g["FileReader"] : FileReaderP;
+
+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) {
+            throw new TypeError("Failed to construct 'FormData': parameter 2 is not of type 'HTMLElement'.");
+        }
+        this[state$9] = new FormDataState();
+    }
+    [state$9];
+    append(name, value, filename) {
+        this[state$9]._data.push(normalizeArgs(name, value, filename));
+    }
+    delete(name) {
+        const result = [];
+        name = String(name);
+        each(this[state$9]._data, entry => {
+            entry[0] !== name && result.push(entry);
+        });
+        this[state$9]._data = result;
+    }
+    get(name) {
+        const entries = this[state$9]._data;
+        name = String(name);
+        for (let i = 0; i < entries.length; ++i) {
+            if (entries[i][0] === name) {
+                return entries[i][1];
+            }
+        }
+        return null;
+    }
+    getAll(name) {
+        const result = [];
+        name = String(name);
+        each(this[state$9]._data, data => {
+            data[0] === name && result.push(data[1]);
+        });
+        return result;
+    }
+    has(name) {
+        name = String(name);
+        for (let i = 0; i < this[state$9]._data.length; ++i) {
+            if (this[state$9]._data[i][0] === name) {
+                return true;
+            }
+        }
+        return false;
+    }
+    set(name, value, filename) {
+        name = String(name);
+        const result = [];
+        const args = normalizeArgs(name, value, filename);
+        let replace = true;
+        each(this[state$9]._data, data => {
+            data[0] === name
+                ? replace && (replace = !result.push(args))
+                : result.push(data);
+        });
+        replace && result.push(args);
+        this[state$9]._data = result;
+    }
+    forEach(callbackfn, thisArg) {
+        for (const [name, value] of this) {
+            callbackfn.call(thisArg, value, name, thisArg);
+        }
+    }
+    entries() {
+        return this[state$9]._data.values();
+    }
+    keys() {
+        return this[state$9]._data.map(x => x[0]).values();
+    }
+    values() {
+        return this[state$9]._data.map(x => x[1]).values();
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    toString() { return "[object FormData]"; }
+    get isPolyfill() { return { symbol: polyfill, hierarchy: ["FormData"] }; }
+}
+defineStringTag(FormDataP, "FormData");
+class FormDataState {
+    _data = [];
+    toBlob() {
+        const boundary = "----formdata-polyfill-" + Math.random();
+        const p = `--${boundary}\r\nContent-Disposition: form-data; name="`;
+        let chunks = [];
+        for (const [name, value] of this._data.values()) {
+            if (typeof value === "string") {
+                chunks.push(p + escape(normalizeLinefeeds(name)) + `"\r\n\r\n${normalizeLinefeeds(value)}\r\n`);
+            }
+            else {
+                chunks.push(p + escape(normalizeLinefeeds(name)) + `"; filename="${escape(value.name)}"\r\nContent-Type: ${value.type || "application/octet-stream"}\r\n\r\n`, value, `\r\n`);
+            }
+        }
+        chunks.push(`--${boundary}--`);
+        return new BlobP(chunks, {
+            type: "multipart/form-data; boundary=" + boundary,
+        });
+    }
+}
+function normalizeArgs(name, value, filename) {
+    if (isPolyfillType("Blob", value)) {
+        filename = filename !== undefined
+            ? String(filename + "")
+            : typeof value.name === "string"
+                ? value.name
+                : "blob";
+        if (value.name !== filename || Object.prototype.toString.call(value) === "[object Blob]") {
+            value = new FileP([value], filename);
+        }
+        return [String(name), value];
+    }
+    return [String(name), String(value)];
+}
+function normalizeLinefeeds(value) {
+    return value.replace(/\r?\n|\r/g, "\r\n");
+}
+function each(arr, cb) {
+    for (let i = 0; i < arr.length; ++i) {
+        cb(arr[i]);
+    }
+}
+function escape(str) {
+    return str.replace(/\n/g, '%0A').replace(/\r/g, '%0D').replace(/"/g, '%22');
+}
+/**
+ * Parses multipart/form-data binary data, supporting restoration of text fields and files
+ * @param body - Text in multipart/form-data format (including boundaries and data)
+ * @returns Parsed FormData object (text fields as strings, files as File objects)
+ */
+function createFormData(body) {
+    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");
+    if (firstLineEnd === -1) {
+        // Invalid multipart format: Missing line break in header
+        throw new TypeError("Failed to fetch");
+    }
+    const boundary = body.substring(2, firstLineEnd).trim();
+    if (!boundary) {
+        // Invalid multipart format: Empty boundary
+        throw new TypeError("Invalid MIME type");
+    }
+    // 2. Split data into individual parts (excluding empty content and trailing "--")
+    const parts = body.split(`--${boundary}`).filter(part => {
+        const trimmed = part.trim();
+        return trimmed !== "" && trimmed !== "--";
+    });
+    if (parts.length === 0) {
+        // Invalid multipart format: No parts found
+        throw new TypeError("Failed to fetch");
+    }
+    // 3. Parse each part
+    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");
+        if (separatorIndex === -1) {
+            // Invalid part format: Missing header-content separator
+            throw new TypeError("Failed to fetch");
+        }
+        // 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("Failed to fetch");
+        }
+        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("Failed to fetch");
+            }
+        }
+        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);
+        }
+    });
+    return formData;
+}
+const FormDataE = g["FormData"] || FormDataP;
+
+class URLSearchParamsP {
+    constructor(init) {
+        let search = init || "";
+        if (isObjectType("URLSearchParams", search)) {
+            search = search.toString();
+        }
+        this[state$9] = new URLSearchParamsState();
+        this[state$9]._dict = parseToDict(search);
+    }
+    [state$9];
+    get size() {
+        return Object.values(this[state$9]._dict).reduce((acc, cur) => acc + cur.length, 0);
+    }
+    append(name, value) {
+        appendTo(this[state$9]._dict, name, value);
+    }
+    delete(name, value) {
+        let dict = {};
+        for (let [key, values] of Object.entries(this[state$9]._dict)) {
+            if (key === name) {
+                if (value !== undefined) {
+                    let vals = values.filter(x => x !== ("" + value));
+                    if (vals.length > 0)
+                        Object.assign(dict, { [key]: vals });
+                }
+                continue;
+            }
+            Object.assign(dict, { [key]: values });
+        }
+        this[state$9]._dict = dict;
+    }
+    get(name) {
+        return this.has(name) ? this[state$9]._dict[name][0] ?? null : null;
+    }
+    getAll(name) {
+        return this.has(name) ? this[state$9]._dict[name].slice(0) : [];
+    }
+    has(name, value) {
+        if (hasOwnProperty(this[state$9]._dict, name)) {
+            if (value !== undefined) {
+                return this[state$9]._dict[name].includes(("" + value));
+            }
+            return true;
+        }
+        return false;
+    }
+    set(name, value) {
+        this[state$9]._dict[name] = ["" + value];
+    }
+    sort() {
+        let keys = Object.keys(this[state$9]._dict);
+        keys.sort();
+        let dict = {};
+        for (let key of keys) {
+            Object.assign(dict, { [key]: this[state$9]._dict[key] });
+        }
+        this[state$9]._dict = dict;
+    }
+    forEach(callbackfn, thisArg) {
+        Object.entries(this[state$9]._dict).forEach(([key, values]) => {
+            values.forEach(value => {
+                callbackfn.call(thisArg, value, key, this);
+            });
+        });
+    }
+    entries() {
+        return Object.entries(this[state$9]._dict)
+            .map(([key, values]) => {
+            return values.map(value => {
+                return [key, value];
+            });
+        })
+            .flat()
+            .values();
+    }
+    keys() {
+        return Object.keys(this[state$9]._dict).values();
+    }
+    values() {
+        return Object.values(this[state$9]._dict).flat().values();
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    toString() {
+        let query = [];
+        for (let [key, values] of Object.entries(this[state$9]._dict)) {
+            let name = encode$1(key);
+            for (let val of values) {
+                query.push(name + "=" + encode$1(val));
+            }
+        }
+        return query.join("&");
+    }
+    get isPolyfill() { return { symbol: polyfill, hierarchy: ["URLSearchParams"] }; }
+}
+defineStringTag(URLSearchParamsP, "URLSearchParams");
+class URLSearchParamsState {
+    _dict = {};
+}
+function parseToDict(search) {
+    let dict = {};
+    if (typeof search === "object") {
+        // if `search` is an array, treat it as a sequence
+        if (Array.isArray(search)) {
+            for (let i = 0; i < search.length; ++i) {
+                let item = search[i];
+                if (Array.isArray(item) && item.length === 2) {
+                    appendTo(dict, item[0], item[1]);
+                }
+                else {
+                    throw new TypeError("Failed to construct 'URLSearchParams': Sequence initializer must only contain pair elements");
+                }
+            }
+        }
+        else {
+            for (const key in search) {
+                if (search.hasOwnProperty(key)) {
+                    appendTo(dict, key, search[key]);
+                }
+            }
+        }
+    }
+    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",
+    };
+    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);
+}
+const URLSearchParamsE = g["URLSearchParams"] || URLSearchParamsP;
+
+class AbortSignalP extends EventTargetP {
+    static abort(reason) {
+        const signal = createAbortSignalP();
+        signal[state$9].abort(reason, false);
+        return signal;
+    }
+    static any(signals) {
+        const signal = createAbortSignalP();
+        const abortedSignal = signals.find(x => x.aborted);
+        if (abortedSignal) {
+            signal[state$9].abort(abortedSignal.reason, false);
+        }
+        else {
+            function abortFn(ev) {
+                for (const sig of signals) {
+                    sig.removeEventListener("abort", abortFn);
+                }
+                signal[state$9].abort(this.reason, true, ev.isTrusted);
+            }
+            for (const sig of signals) {
+                sig.addEventListener("abort", abortFn);
+            }
+        }
+        return signal;
+    }
+    static timeout(milliseconds) {
+        const signal = createAbortSignalP();
+        setTimeout(() => {
+            signal[state$9].abort(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$9] = new AbortSignalState(this);
+    }
+    [state$9];
+    get aborted() { return this[state$9].aborted; }
+    get reason() { return this[state$9].reason; }
+    throwIfAborted() {
+        if (this.aborted) {
+            throw this.reason;
+        }
+    }
+    get onabort() { return this[state$9].onabort; }
+    set onabort(value) {
+        this[state$9].onabort = value;
+        attachFn.call(this, "abort", value, this[state$9]._onabort);
+    }
+    toString() { return "[object AbortSignal]"; }
+    get isPolyfill() { return { symbol: polyfill, hierarchy: ["AbortSignal", "EventTarget"] }; }
+}
+defineStringTag(AbortSignalP, "AbortSignal");
+class AbortSignalState {
+    constructor(target) {
+        this.target = target;
+    }
+    target;
+    aborted = false;
+    reason = undefined;
+    abort(reason, notify = true, isTrusted = true) {
+        if (!this.aborted) {
+            this.aborted = true;
+            this.reason = reason ?? (new MPException("signal is aborted without reason", "AbortError"));
+            if (notify) {
+                const evt = new EventP("abort");
+                evt[state$9].target = this.target;
+                evt[state$9].isTrusted = isTrusted;
+                this.target[state$7].fire(evt);
+            }
+        }
+    }
+    onabort = null;
+    _onabort = (ev) => { executeFn.call(this.target, this.onabort, ev); };
+}
+function createAbortSignalP() {
+    const instance = Object.create(AbortSignalP.prototype);
+    instance[state$7] = new EventTargetState(instance);
+    instance[state$9] = new AbortSignalState(instance);
+    return instance;
+}
+const AbortSignalE = g["AbortSignal"] || AbortSignalP;
+
+const state$2 = Symbol("AbortControllerState");
+class AbortControllerP {
+    constructor() {
+        this[state$2] = new AbortControllerState();
+    }
+    [state$2];
+    get signal() { return this[state$2].signal; }
+    abort(reason) {
+        this[state$2].signal[state$9].abort(reason);
+    }
+    toString() { return "[object AbortController]"; }
+    get isPolyfill() { return { symbol: polyfill, hierarchy: ["AbortController"] }; }
+}
+defineStringTag(AbortControllerP, "AbortController");
+class AbortControllerState {
+    signal = createAbortSignalP();
+}
+const AbortControllerE = g["AbortController"] || AbortControllerP;
+
+// @ts-nocheck
+const mp = (() => {
+    let u = "undefined", r = "request", f = "function";
+    let mp;
+    mp =
+        (typeof wx !== u && typeof wx?.[r] === f && wx) || // 微信
+            (typeof my !== u && typeof my?.[r] === f && my) || // 支付宝
+            (typeof qq !== u && typeof qq?.[r] === f && qq) || // QQ
+            (typeof jd !== u && typeof jd?.[r] === f && jd) || // 京东
+            (typeof swan !== u && typeof swan?.[r] === f && swan) || // 百度
+            (typeof tt !== u && typeof tt?.[r] === f && tt) || // 抖音 | 飞书
+            (typeof ks !== u && typeof ks?.[r] === f && ks) || // 快手
+            (typeof qh !== u && typeof qh?.[r] === f && qh) || // 360
+            undefined;
+    if (typeof g["XMLHttpRequest"] === f && typeof g["fetch"] === f) {
+        return;
+    }
+    if (mp === undefined)
+        mp =
+            (typeof uni !== u && typeof uni?.[r] === f && uni) || // UniApp
+                (typeof Taro !== u && typeof Taro?.[r] === f && Taro) || // Taro
+                undefined;
+    return mp;
+})();
+
+class XMLHttpRequestEventTargetP extends EventTargetP {
+    constructor() {
+        if (new.target === XMLHttpRequestEventTargetP) {
+            throw new TypeError("Failed to construct 'XMLHttpRequestEventTarget': Illegal constructor");
+        }
+        super();
+        this[state$9] = new XMLHttpRequestEventTargetState(this);
+    }
+    [state$9];
+    get onabort() { return this[state$9].onabort; }
+    set onabort(value) { this[state$9].onabort = value; this[state$9].attach("abort"); }
+    get onerror() { return this[state$9].onerror; }
+    set onerror(value) { this[state$9].onerror = value; this[state$9].attach("error"); }
+    get onload() { return this[state$9].onload; }
+    set onload(value) { this[state$9].onload = value; this[state$9].attach("load"); }
+    get onloadend() { return this[state$9].onloadend; }
+    set onloadend(value) { this[state$9].onloadend = value; this[state$9].attach("loadend"); }
+    get onloadstart() { return this[state$9].onloadstart; }
+    set onloadstart(value) { this[state$9].onloadstart = value; this[state$9].attach("loadstart"); }
+    get onprogress() { return this[state$9].onprogress; }
+    set onprogress(value) { this[state$9].onprogress = value; this[state$9].attach("progress"); }
+    get ontimeout() { return this[state$9].ontimeout; }
+    set ontimeout(value) { this[state$9].ontimeout = value; this[state$9].attach("timeout"); }
+    toString() { return "[object XMLHttpRequestEventTarget]"; }
+    get isPolyfill() { return { symbol: polyfill, hierarchy: ["XMLHttpRequestEventTarget", "EventTarget"] }; }
+}
+defineStringTag(XMLHttpRequestEventTargetP, "XMLHttpRequestEventTarget");
+class XMLHttpRequestEventTargetState {
+    /**
+     * @param _target XMLHttpRequestEventTargetP
+     */
+    constructor(_target) {
+        this.target = _target;
+    }
+    target;
+    attach(type) {
+        const cb = this[("on" + type)];
+        const listener = this[("_on" + type)];
+        attachFn.call(this.target, type, cb, listener);
+    }
+    onabort = null;
+    _onabort = (ev) => { executeFn.call(this.target, this.onabort, ev); };
+    onerror = null;
+    _onerror = (ev) => { executeFn.call(this.target, this.onerror, ev); };
+    onload = null;
+    _onload = (ev) => { executeFn.call(this.target, this.onload, ev); };
+    onloadend = null;
+    _onloadend = (ev) => { executeFn.call(this.target, this.onloadend, ev); };
+    onloadstart = null;
+    _onloadstart = (ev) => { executeFn.call(this.target, this.onloadstart, ev); };
+    onprogress = null;
+    _onprogress = (ev) => { executeFn.call(this.target, this.onprogress, ev); };
+    ontimeout = null;
+    _ontimeout = (ev) => { executeFn.call(this.target, this.ontimeout, ev); };
+}
+
+class XMLHttpRequestUploadP extends XMLHttpRequestEventTargetP {
+    constructor() {
+        if (new.target === XMLHttpRequestUploadP) {
+            throw new TypeError("Failed to construct 'XMLHttpRequestUpload': Illegal constructor");
+        }
+        super();
+    }
+    toString() { return "[object XMLHttpRequestUpload]"; }
+    get isPolyfill() { return { symbol: polyfill, hierarchy: ["XMLHttpRequestUpload", "XMLHttpRequestEventTarget", "EventTarget"] }; }
+}
+defineStringTag(XMLHttpRequestUploadP, "XMLHttpRequestUpload");
+function createXMLHttpRequestUploadP() {
+    const instance = Object.create(XMLHttpRequestUploadP.prototype);
+    instance[state$7] = new EventTargetState(instance);
+    instance[state$9] = new XMLHttpRequestEventTargetState(instance);
+    return instance;
+}
+
+const request = mp ? mp.request : function errorRequest(options) {
+    const errMsg = "NOT_SUPPORTED_ERR";
+    const errno = 9;
+    const err = {
+        errMsg,
+        errno,
+        exception: {
+            retryCount: 0,
+            reasons: [{ errMsg, errno }],
+        },
+        useHttpDNS: false,
+    };
+    Promise.resolve(err)
+        .then(err => { if (options.fail) {
+        options.fail(err);
+    } })
+        .finally(() => { if (options.complete) {
+        options.complete(err);
+    } });
+    throw new ReferenceError("request is not defined");
+};
+
+const state$1 = Symbol("XMLHttpRequestState");
+class XMLHttpRequestP extends XMLHttpRequestEventTargetP {
+    static UNSENT = 0;
+    static OPENED = 1;
+    static HEADERS_RECEIVED = 2;
+    static LOADING = 3;
+    static DONE = 4;
+    constructor() {
+        super();
+        this[state$1] = new XMLHttpRequestState(this);
+    }
+    [state$1];
+    UNSENT = 0;
+    OPENED = 1;
+    HEADERS_RECEIVED = 2;
+    LOADING = 3;
+    DONE = 4;
+    get readyState() { return this[state$1].readyState; }
+    get response() { return this[state$1].response; }
+    get responseText() { return (!this.responseType || this.responseType === "text") ? this.response : ""; }
+    get responseType() { return this[state$1].responseType; }
+    set responseType(value) { this[state$1].responseType = value; }
+    get responseURL() { return this[state$1].responseURL; }
+    get responseXML() { return null; }
+    get status() { return this[state$1].status; }
+    get statusText() {
+        if (this.readyState === XMLHttpRequestP.UNSENT || this.readyState === XMLHttpRequestP.OPENED)
+            return "";
+        return this[state$1].statusText || statusTextMap(this.status);
+    }
+    get timeout() { return this[state$1].timeout; }
+    set timeout(value) { this[state$1].timeout = value; }
+    get upload() { return this[state$1].upload; }
+    get withCredentials() { return this[state$1].withCredentials; }
+    set withCredentials(value) { this[state$1].withCredentials = value; }
+    abort() {
+        this[state$1].clearRequest();
+    }
+    getAllResponseHeaders() {
+        if (!this[state$1]._resHeaders)
+            return "";
+        return Object.entries(this[state$1]._resHeaders || {}).map(([k, v]) => `${k}: ${v}\r\n`).join("");
+    }
+    getResponseHeader(name) {
+        if (!this[state$1]._resHeaders)
+            return null;
+        return Object.entries(this[state$1]._resHeaders || {}).find(x => x[0].toLowerCase() === name.toLowerCase())?.[1] ?? null;
+    }
+    open(...args) {
+        const [method, url, async = true, username = null, password = null] = args;
+        if (args.length < 2) {
+            throw new TypeError(`Failed to execute 'open' on 'XMLHttpRequest': 2 arguments required, but only ${args.length} present.`);
+        }
+        if (!async) {
+            console.warn("Synchronous XMLHttpRequest is deprecated because of its detrimental effects to the end user's experience.");
+        }
+        this[state$1].clearRequest(false);
+        this[state$1]._method = normalizeMethod(method);
+        this[state$1]._reqURL = String(url);
+        this[state$1]._reqCanSend = true;
+        this[state$1].setReadyStateAndNotify(XMLHttpRequestP.OPENED);
+    }
+    overrideMimeType(mime) { }
+    send(body) {
+        if (!this[state$1]._reqCanSend || this.readyState !== XMLHttpRequestP.OPENED) {
+            throw new MPException("Failed to execute 'send' on 'XMLHttpRequest': The object's state must be OPENED.", "InvalidStateError");
+        }
+        this[state$1]._reqCanSend = false;
+        this[state$1].execRequest(body);
+        this[state$1].checkRequestTimeout();
+    }
+    setRequestHeader(name, value) {
+        assignRequestHeader(this[state$1]._reqHeaders, name, value);
+    }
+    get onreadystatechange() { return this[state$1].onreadystatechange; }
+    set onreadystatechange(value) {
+        this[state$1].onreadystatechange = value;
+        attachFn.call(this, "readystatechange", value, this[state$1]._onreadystatechange);
+    }
+    toString() { return "[object XMLHttpRequest"; }
+    get isPolyfill() { return { symbol: polyfill, hierarchy: ["XMLHttpRequest", "XMLHttpRequestEventTarget", "EventTarget"] }; }
+}
+defineStringTag(XMLHttpRequestP, "XMLHttpRequest");
+class XMLHttpRequestState {
+    constructor(target) {
+        this.target = target;
+        this.upload = createXMLHttpRequestUploadP();
+    }
+    target;
+    readyState = XMLHttpRequestP.UNSENT;
+    response = "";
+    responseType = "";
+    responseURL = "";
+    status = 0;
+    statusText = "";
+    timeout = 0;
+    upload;
+    withCredentials = false;
+    _reqCanSend = false;
+    _resetPending = false;
+    _timeoutId = 0;
+    _reqURL = "";
+    _method = "GET";
+    _reqHeaders = { Accept: "*/*" };
+    _resHeaders = null;
+    _resContLen = 0;
+    _requestTask = null;
+    execRequest(body) {
+        const allowsRequestBody = !["GET", "HEAD"].includes(this._method);
+        const contentTypeExists = Object.keys(this._reqHeaders).map(x => x.toLowerCase()).includes("Content-Type".toLowerCase());
+        const processHeaders = allowsRequestBody && !contentTypeExists;
+        const processContentLength = this.upload[state$7].executors.length > 0;
+        let headers = { ...this._reqHeaders };
+        let contentLength = 0;
+        let data = convert(body, processHeaders ? v => { headers["Content-Type"] = v; } : void 0, processContentLength ? v => { contentLength = v; } : void 0);
+        this._requestTask = request({
+            url: this._reqURL,
+            method: this._method,
+            header: headers,
+            data,
+            dataType: this.responseType === "json" ? "json" : "text",
+            responseType: this.responseType === "arraybuffer" ? "arraybuffer" : "text",
+            success: this.requestSuccess.bind(this),
+            fail: this.requestFail.bind(this),
+            complete: this.requestComplete.bind(this),
+        });
+        this.emitProcessEvent("loadstart");
+        if (processContentLength) {
+            const hasRequestBody = allowsRequestBody && contentLength > 0;
+            if (hasRequestBody) {
+                this.emitProcessEvent("loadstart", 0, contentLength, this.upload);
+            }
+            setTimeout(() => {
+                const _aborted = this._reqCanSend || this.readyState !== XMLHttpRequestP.OPENED;
+                const _contentLength = _aborted ? 0 : contentLength;
+                if (_aborted) {
+                    this.emitProcessEvent("abort", 0, 0, this.upload);
+                }
+                else {
+                    if (hasRequestBody) {
+                        this.emitProcessEvent("load", _contentLength, _contentLength, this.upload);
+                    }
+                }
+                if (_aborted || hasRequestBody) {
+                    this.emitProcessEvent("loadend", _contentLength, _contentLength, this.upload);
+                }
+            });
+        }
+    }
+    requestSuccess({ statusCode, header, data }) {
+        this.responseURL = this._reqURL;
+        this.status = statusCode;
+        this._resHeaders = header;
+        this._resContLen = parseInt(this.target.getResponseHeader("Content-Length") || "0");
+        if (this.readyState === XMLHttpRequestP.OPENED) {
+            this.setReadyStateAndNotify(XMLHttpRequestP.HEADERS_RECEIVED);
+            this.setReadyStateAndNotify(XMLHttpRequestP.LOADING);
+            setTimeout(() => {
+                if (!this._reqCanSend) {
+                    let l = this._resContLen;
+                    try {
+                        this.response = convertBack(this.responseType, data);
+                        this.emitProcessEvent("load", l, l);
+                    }
+                    catch (e) {
+                        console.error(e);
+                        this.emitProcessEvent("error");
+                    }
+                }
+            });
+        }
+    }
+    requestFail(err) {
+        // Alipay Mini Programs
+        // error: 14 --- JSON parse data error
+        // error: 19 --- http status error
+        // At this point, the error data object will contain three pieces of information
+        // returned from the server: status, headers, and data.
+        // In the browser's XMLHttpRequest, these two errors (Error 14 and Error 19)
+        // differ from those in Alipay Mini Programs and should instead return normally.
+        // Therefore, this scenario is also handled here as a successful request response.
+        if ("status" in err) {
+            this.requestSuccess({ statusCode: err.status, header: err.headers, data: err.data });
+            return;
+        }
+        this.status = 0;
+        this.statusText = "errMsg" in err ? err.errMsg : "errorMessage" in err ? err.errorMessage : "";
+        if (!this._reqCanSend && this.readyState !== XMLHttpRequestP.UNSENT && this.readyState !== XMLHttpRequestP.DONE) {
+            this.emitProcessEvent("error");
+            this.resetRequestTimeout();
+        }
+    }
+    requestComplete() {
+        this._requestTask = null;
+        if (!this._reqCanSend && (this.readyState === XMLHttpRequestP.OPENED || this.readyState === XMLHttpRequestP.LOADING)) {
+            this.setReadyStateAndNotify(XMLHttpRequestP.DONE);
+        }
+        setTimeout(() => {
+            if (!this._reqCanSend) {
+                let l = this._resContLen;
+                this.emitProcessEvent("loadend", l, l);
+            }
+        });
+    }
+    clearRequest(delay = true) {
+        const timerFn = delay ? setTimeout : (f) => { f(); };
+        this._resetPending = true;
+        if (this._requestTask && this.readyState !== XMLHttpRequestP.DONE) {
+            if (delay) {
+                this.setReadyStateAndNotify(XMLHttpRequestP.DONE);
+            }
+            timerFn(() => {
+                const requestTask = this._requestTask;
+                if (requestTask) {
+                    requestTask.abort();
+                }
+                if (delay) {
+                    this.emitProcessEvent("abort");
+                }
+                if (delay && !requestTask) {
+                    this.emitProcessEvent("loadend");
+                }
+            });
+        }
+        timerFn(() => {
+            if (this._resetPending) {
+                if (delay) {
+                    this.readyState = XMLHttpRequestP.UNSENT;
+                }
+                this.resetXHR();
+            }
+        });
+    }
+    checkRequestTimeout() {
+        if (this.timeout) {
+            this._timeoutId = setTimeout(() => {
+                if (!this.status && this.readyState !== XMLHttpRequestP.DONE) {
+                    if (this._requestTask)
+                        this._requestTask.abort();
+                    this.setReadyStateAndNotify(XMLHttpRequestP.DONE);
+                    this.emitProcessEvent("timeout");
+                }
+            }, this.timeout);
+        }
+    }
+    resetXHR() {
+        this._resetPending = false;
+        this.resetRequestTimeout();
+        this.response = "";
+        this.responseURL = "";
+        this.status = 0;
+        this.statusText = "";
+        this._reqHeaders = {};
+        this._resHeaders = null;
+        this._resContLen = 0;
+    }
+    resetRequestTimeout() {
+        if (this._timeoutId) {
+            clearTimeout(this._timeoutId);
+            this._timeoutId = 0;
+        }
+    }
+    emitProcessEvent(type, loaded = 0, total = 0, target) {
+        const _target = target ?? this.target;
+        const _event = new ProgressEventP(type, {
+            lengthComputable: total > 0,
+            loaded,
+            total,
+        });
+        _event[state$9].target = _target;
+        _event[state$9].isTrusted = true;
+        _target[state$7].fire(_event);
+    }
+    setReadyStateAndNotify(value) {
+        const hasChanged = value !== this.readyState;
+        this.readyState = value;
+        if (hasChanged) {
+            const evt = new EventP("readystatechange");
+            evt[state$9].target = this.target;
+            evt[state$9].isTrusted = true;
+            this.target[state$7].fire(evt);
+        }
+    }
+    onreadystatechange = null;
+    _onreadystatechange = (ev) => { executeFn.call(this.target, this.onreadystatechange, ev); };
+}
+// HTTP methods whose capitalization should be normalized
+const methods = ["CONNECT", "DELETE", "GET", "HEAD", "OPTIONS", "PATCH", "POST", "PUT", "TRACE"];
+function normalizeMethod(method) {
+    let upcased = method.toUpperCase();
+    return methods.indexOf(upcased) > -1 ? upcased : method;
+}
+function assignRequestHeader(headers, name, value) {
+    for (const key of Object.keys(headers)) {
+        if (key.toLowerCase() === name.toLowerCase()) {
+            headers[key] = value;
+            return;
+        }
+    }
+    Object.assign(headers, { [name]: value });
+    return;
+}
+const encode = (str) => {
+    const encoder = new TextEncoderP();
+    return encoder.encode(str).buffer;
+};
+const decode = (buf) => {
+    let decoder = new TextDecoderP();
+    return decoder.decode(buf);
+};
+function convert(body, setContentType, setContentLength) {
+    let result;
+    if (typeof body === "string") {
+        result = body;
+        if (setContentType) {
+            setContentType("text/plain;charset=UTF-8");
+        }
+    }
+    else if (isObjectType("URLSearchParams", body)) {
+        result = body.toString();
+        if (setContentType) {
+            setContentType("application/x-www-form-urlencoded;charset=UTF-8");
+        }
+    }
+    else if (body instanceof ArrayBuffer) {
+        result = body.slice(0);
+    }
+    else if (ArrayBuffer.isView(body)) {
+        result = body.buffer.slice(body.byteOffset, body.byteOffset + body.byteLength);
+    }
+    else if (isPolyfillType("Blob", body)) {
+        result = body[state$9]._u8array.buffer.slice(0);
+        if (setContentType && body.type) {
+            setContentType(body.type);
+        }
+    }
+    else if (isPolyfillType("FormData", body)) {
+        const blob = body[state$9].toBlob();
+        result = blob[state$9]._u8array.buffer;
+        if (setContentType) {
+            setContentType(blob.type);
+        }
+    }
+    else if (!body) {
+        result = "";
+    }
+    else {
+        result = String(body);
+    }
+    if (setContentLength) {
+        setContentLength((typeof result === "string" ? encode(result) : result).byteLength);
+    }
+    return result;
+}
+function convertBack(type, data) {
+    let temp = !!data ? (typeof data !== "string" && !(data instanceof ArrayBuffer) ? JSON.stringify(data) : data) : "";
+    if (!type || type === "text") {
+        return typeof temp === "string" ? temp : decode(temp);
+    }
+    else if (type === "json") {
+        return JSON.parse(typeof temp === "string" ? temp : decode(temp));
+    }
+    else if (type === "arraybuffer") {
+        return temp instanceof ArrayBuffer ? temp.slice(0) : encode(temp);
+    }
+    else if (type === "blob") {
+        return new BlobP([temp]);
+    }
+    else {
+        return temp;
+    }
+}
+const statusMessages = {
+    100: "Continue",
+    101: "Switching Protocols",
+    102: "Processing",
+    103: "Early Hints",
+    200: "OK",
+    201: "Created",
+    202: "Accepted",
+    203: "Non-Authoritative Information",
+    204: "No Content",
+    205: "Reset Content",
+    206: "Partial Content",
+    207: "Multi-Status",
+    208: "Already Reported",
+    226: "IM Used",
+    300: "Multiple Choices",
+    301: "Moved Permanently",
+    302: "Found",
+    303: "See Other",
+    304: "Not Modified",
+    307: "Temporary Redirect",
+    308: "Permanent Redirect",
+    400: "Bad Request",
+    401: "Unauthorized",
+    402: "Payment Required",
+    403: "Forbidden",
+    404: "Not Found",
+    405: "Method Not Allowed",
+    406: "Not Acceptable",
+    407: "Proxy Authentication Required",
+    408: "Request Timeout",
+    409: "Conflict",
+    410: "Gone",
+    411: "Length Required",
+    412: "Precondition Failed",
+    413: "Content Too Large",
+    414: "URI Too Long",
+    415: "Unsupported Media Type",
+    416: "Range Not Satisfiable",
+    417: "Expectation Failed",
+    418: "I'm a teapot",
+    421: "Misdirected Request",
+    422: "Unprocessable Entity",
+    423: "Locked",
+    424: "Failed Dependency",
+    425: "Too Early",
+    426: "Upgrade Required",
+    428: "Precondition Required",
+    429: "Too Many Requests",
+    431: "Request Header Fields Too Large",
+    451: "Unavailable For Legal Reasons",
+    500: "Internal Server Error",
+    501: "Not Implemented",
+    502: "Bad Gateway",
+    503: "Service Unavailable",
+    504: "Gateway Timeout",
+    505: "HTTP Version Not Supported",
+    506: "Variant Also Negotiates",
+    507: "Insufficient Storage",
+    508: "Loop Detected",
+    510: "Not Extended",
+    511: "Network Authentication Required"
+};
+function statusTextMap(val) {
+    return statusMessages[val] || "unknown";
+}
+const XMLHttpRequestE = !mp ? g["XMLHttpRequest"] : XMLHttpRequestP;
+
+const state = Symbol("BodyState");
+class BodyP {
+    constructor() {
+        if (new.target === BodyP) {
+            throw new TypeError("Failed to construct 'Body': Illegal constructor");
+        }
+        this[state] = new BodyState();
+    }
+    [state];
+    get body() {
+        if (!this[state]._body) {
+            return null;
+        }
+        throw new ReferenceError("ReadableStream is not defined");
+    }
+    get bodyUsed() { return this[state].bodyUsed; }
+    ;
+    arrayBuffer() {
+        const kind = "arrayBuffer";
+        return this[state].consumed(kind) || this[state].read(kind);
+    }
+    blob() {
+        const kind = "blob";
+        return this[state].consumed(kind) || this[state].read(kind);
+    }
+    bytes() {
+        const kind = "bytes";
+        return this[state].consumed(kind) || this[state].read(kind);
+    }
+    formData() {
+        const kind = "formData";
+        return this[state].consumed(kind) || this[state].read(kind);
+    }
+    json() {
+        const kind = "json";
+        return this[state].consumed(kind) || this[state].read(kind);
+    }
+    text() {
+        const kind = "text";
+        return this[state].consumed(kind) || this[state].read(kind);
+    }
+    toString() { return "[object Body]"; }
+    get isPolyfill() { return { symbol: polyfill, hierarchy: ["Body"] }; }
+}
+defineStringTag(BodyP, "Body");
+class BodyState {
+    bodyUsed = false;
+    _name = "Body";
+    _body = "";
+    init(body, headers) {
+        if (isObjectType("ReadableStream", body)) {
+            throw new ReferenceError("ReadableStream is not defined");
+        }
+        this._body = convert(body, type => {
+            if (headers && !headers.get("Content-Type")) {
+                headers.set("Content-Type", type);
+            }
+        });
+    }
+    read(kind) {
+        return new Promise((resolve, reject) => {
+            try {
+                if (kind === "arrayBuffer") {
+                    resolve(convertBack("arraybuffer", this._body));
+                }
+                else if (kind === "blob") {
+                    resolve(convertBack("blob", this._body));
+                }
+                else if (kind === "bytes") {
+                    let arrayBuffer = convertBack("arraybuffer", this._body);
+                    resolve(new Uint8Array(arrayBuffer));
+                }
+                else if (kind === "formData") {
+                    let text = convertBack("text", this._body);
+                    resolve(createFormData(text));
+                }
+                else if (kind === "json") {
+                    resolve(convertBack("json", this._body));
+                }
+                else {
+                    resolve(convertBack("text", this._body));
+                }
+            }
+            catch (e) {
+                reject(e);
+            }
+        });
+    }
+    consumed(kind) {
+        if (!this._body)
+            return;
+        if (this.bodyUsed) {
+            return Promise.reject(new TypeError(`TypeError: Failed to execute '${kind}' on '${this._name}': body stream already read`));
+        }
+        this.bodyUsed = true;
+    }
+}
+
+class HeadersP {
+    constructor(init) {
+        this[state$9] = 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) {
+            Object.entries(init).forEach(([name, value]) => {
+                this.append(name, value);
+            });
+        }
+    }
+    [state$9];
+    append(name, value) {
+        let key = normalizeName(name, "append");
+        value = normalizeValue(value);
+        let oldValue = this[state$9]._map.get(key)?.[1];
+        this[state$9]._map.set(key, ["" + name, oldValue ? `${oldValue}, ${value}` : value]);
+    }
+    delete(name) {
+        let key = normalizeName(name, "delete");
+        this[state$9]._map.delete(key);
+    }
+    get(name) {
+        let key = normalizeName(name, "get");
+        return this[state$9]._map.get(key)?.[1] ?? null;
+    }
+    getSetCookie() {
+        let value = this.get("Set-Cookie");
+        return value ? value.split(", ") : [];
+    }
+    has(name) {
+        let key = normalizeName(name, "has");
+        return this[state$9]._map.has(key);
+    }
+    set(name, value) {
+        let key = normalizeName(name, "set");
+        this[state$9]._map.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$9]._map.values();
+    }
+    keys() {
+        return Array.from(this.entries()).map(pair => pair[0]).values();
+    }
+    values() {
+        return Array.from(this.entries()).map(pair => pair[1]).values();
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    toString() { return "[object Headers]"; }
+    get isPolyfill() { return { symbol: polyfill, hierarchy: ["Headers"] }; }
+}
+defineStringTag(HeadersP, "Headers");
+class HeadersState {
+    _map = new Map();
+}
+function normalizeName(name, kind = "") {
+    if (typeof name !== "string") {
+        name = String(name);
+    }
+    if (/[^a-z0-9\-#$%&'*+.^_`|~!]/i.test(name) || name === "") {
+        if (kind) {
+            throw new TypeError(`Failed to execute '${kind}' on 'Headers': Invalid name`);
+        }
+    }
+    return name.toLowerCase();
+}
+function normalizeValue(value) {
+    if (typeof value !== "string") {
+        value = String(value);
+    }
+    return value;
+}
+const HeadersE = g["Headers"] || HeadersP;
+
+class RequestP extends BodyP {
+    constructor(input, init) {
+        super();
+        this[state$9] = new RequestState();
+        this[state]._name = "Request";
+        let options = init ?? {};
+        let body = options.body;
+        if (isPolyfillType("Request", input)) {
+            if (input.bodyUsed) {
+                throw new TypeError("Failed to construct 'Request': Cannot construct a Request with a Request object that has already been used.");
+            }
+            this[state$9].credentials = input.credentials;
+            if (!options.headers) {
+                this[state$9].headers = new HeadersP(input.headers);
+            }
+            this[state$9].method = input.method;
+            this[state$9].mode = input.mode;
+            this[state$9].signal = input.signal;
+            this[state$9].url = input.url;
+            let _input = input;
+            if (!body && _input[state]._body !== null) {
+                body = _input[state]._body;
+                _input[state].bodyUsed = true;
+            }
+        }
+        else {
+            this[state$9].url = String(input);
+        }
+        if (options.credentials) {
+            this[state$9].credentials = options.credentials;
+        }
+        if (options.headers) {
+            this[state$9].headers = new HeadersP(options.headers);
+        }
+        if (options.method) {
+            this[state$9].method = normalizeMethod(options.method);
+        }
+        if (options.mode) {
+            this[state$9].mode = options.mode;
+        }
+        if (options.signal) {
+            this[state$9].signal = options.signal;
+        }
+        if ((this.method === "GET" || this.method === "HEAD") && body) {
+            throw new TypeError("Failed to construct 'Request': Request with GET/HEAD method cannot have body.");
+        }
+        this[state].init(body, this.headers);
+        if (this.method === "GET" || this.method === "HEAD") {
+            if (options.cache === "no-store" || options.cache === "no-cache") {
+                // Search for a '_' parameter in the query string
+                let reParamSearch = /([?&])_=[^&]*/;
+                if (reParamSearch.test(this.url)) {
+                    // If it already exists then set the value with the current time
+                    this[state$9].url = this.url.replace(reParamSearch, "$1_=" + (new Date()).getTime());
+                }
+                else {
+                    // Otherwise add a new '_' parameter to the end with the current time
+                    let reQueryString = /\?/;
+                    this[state$9].url += (reQueryString.test(this.url) ? "&" : "?") + "_=" + (new Date()).getTime();
+                }
+            }
+        }
+    }
+    [state$9];
+    get cache() { return this[state$9].cache; }
+    get credentials() { return this[state$9].credentials; }
+    get destination() { return this[state$9].destination; }
+    get headers() { return this[state$9].headers; }
+    get integrity() { return this[state$9].integrity; }
+    get keepalive() { return this[state$9].keepalive; }
+    get method() { return this[state$9].method; }
+    get mode() { return this[state$9].mode; }
+    get redirect() { return this[state$9].redirect; }
+    get referrer() { return this[state$9].referrer; }
+    get referrerPolicy() { return this[state$9].referrerPolicy; }
+    get signal() { return this[state$9].signal; }
+    get url() { return this[state$9].url; }
+    clone() {
+        return new RequestP(this, { body: this[state]._body ?? null });
+    }
+    toString() { return "[object Request]"; }
+    get isPolyfill() { return { symbol: polyfill, hierarchy: ["Request"] }; }
+}
+defineStringTag(RequestP, "Request");
+class RequestState {
+    cache = "default";
+    credentials = "same-origin";
+    destination = "";
+    headers = new HeadersP();
+    integrity = "";
+    keepalive = false;
+    method = "GET";
+    mode = "cors";
+    redirect = "follow";
+    referrer = "about:client";
+    referrerPolicy = "";
+    signal = (new AbortControllerP()).signal;
+    url = "";
+}
+const RequestE = g["Request"] || RequestP;
+
+class ResponseP extends BodyP {
+    constructor(body, init) {
+        super();
+        this[state$9] = new ResponseState();
+        this[state]._name = "Response";
+        let options = 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) {
+            this[state$9].headers = new HeadersP(options.headers);
+        }
+        this[state$9].ok = this.status >= 200 && this.status < 300;
+        this[state$9].status = status;
+        this[state$9].statusText = options.statusText === undefined ? "" : "" + options.statusText;
+        this[state].init(body, this.headers);
+    }
+    [state$9];
+    get headers() { return this[state$9].headers; }
+    get ok() { return this[state$9].ok; }
+    get redirected() { return this[state$9].redirected; }
+    get status() { return this[state$9].status; }
+    get statusText() { return this[state$9].statusText; }
+    get type() { return this[state$9].type; }
+    get url() { return this[state$9].url; }
+    clone() {
+        const response = new ResponseP(this[state]._body, {
+            headers: new HeadersP(this.headers),
+            status: this.status,
+            statusText: this.statusText,
+        });
+        response[state$9].url = this.url;
+        return response;
+    }
+    static json(data, init) {
+        return new Response(JSON.stringify(data), init);
+    }
+    static error() {
+        const response = new ResponseP(null, { status: 200, statusText: "" });
+        response[state$9].ok = false;
+        response[state$9].status = 0;
+        response[state$9].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 Response(null, { status, headers: { location: String(url) } });
+    }
+    toString() { return "[object Response]"; }
+    get isPolyfill() { return { symbol: polyfill, hierarchy: ["Response"] }; }
+}
+defineStringTag(ResponseP, "Response");
+class ResponseState {
+    headers = new HeadersP();
+    ok = true;
+    redirected = false;
+    status = 200;
+    statusText = "";
+    type = "default";
+    url = "";
+}
+const ResponseE = g["Response"] || ResponseP;
+
+function fetchP(input, init) {
+    if (new.target === fetchP) {
+        throw new TypeError("fetch is not a constructor");
+    }
+    return new Promise(function (resolve, reject) {
+        let request = new RequestP(input, init);
+        if (request.signal && request.signal.aborted) {
+            return reject(request.signal.reason);
+        }
+        let xhr = new XMLHttpRequestP();
+        xhr.onload = function () {
+            let options = {
+                headers: new HeadersP(xhr[state$1]._resHeaders || undefined),
+                status: xhr.status,
+                statusText: xhr.statusText,
+            };
+            setTimeout(() => {
+                const response = new ResponseP(xhr.response, options);
+                response[state$9].url = xhr.responseURL;
+                resolve(response);
+            });
+        };
+        xhr.onerror = function () {
+            setTimeout(function () {
+                reject(new TypeError("Failed to fetch"));
+            });
+        };
+        xhr.ontimeout = function () {
+            setTimeout(function () {
+                reject(new MPException("request:fail timeout", "TimeoutError"));
+            });
+        };
+        xhr.onabort = function () {
+            setTimeout(function () {
+                reject(new MPException("request:fail abort", "AbortError"));
+            });
+        };
+        xhr.open(request.method, request.url);
+        if (request.credentials === "include") {
+            xhr.withCredentials = true;
+        }
+        else if (request.credentials === "omit") {
+            xhr.withCredentials = false;
+        }
+        if (init && isObjectHeaders(init.headers)) {
+            let headers = init.headers;
+            let names = [];
+            Object.entries(headers).forEach(([name, value]) => {
+                names.push(normalizeName(name));
+                xhr.setRequestHeader(name, normalizeValue(value));
+            });
+            request.headers.forEach(function (value, name) {
+                if (names.indexOf(normalizeName(name)) === -1) {
+                    xhr.setRequestHeader(name, value);
+                }
+            });
+        }
+        else {
+            request.headers.forEach(function (value, name) {
+                xhr.setRequestHeader(name, value);
+            });
+        }
+        if (request.signal) {
+            const abortXHR = () => { xhr.abort(); };
+            request.signal.addEventListener("abort", abortXHR);
+            xhr.onreadystatechange = function () {
+                // DONE (success or failure)
+                if (xhr.readyState === 4) {
+                    request.signal.removeEventListener("abort", abortXHR);
+                }
+            };
+        }
+        xhr.send(request[state]._body);
+    });
+}
+function isObjectHeaders(val) {
+    return typeof val === "object" && !isObjectType("Headers", val);
+}
+const fetchE = !mp ? g["fetch"] : fetchP;
+
+exports.AbortController = AbortControllerE;
+exports.AbortControllerP = AbortControllerP;
+exports.AbortSignal = AbortSignalE;
+exports.AbortSignalP = AbortSignalP;
+exports.Blob = BlobE;
+exports.BlobP = BlobP;
+exports.CustomEvent = CustomEventE;
+exports.CustomEventP = CustomEventP;
+exports.Event = EventE;
+exports.EventP = EventP;
+exports.EventTarget = EventTargetE;
+exports.EventTargetP = EventTargetP;
+exports.File = FileE;
+exports.FileP = FileP;
+exports.FileReader = FileReaderE;
+exports.FileReaderP = FileReaderP;
+exports.FormData = FormDataE;
+exports.FormDataP = FormDataP;
+exports.Headers = HeadersE;
+exports.HeadersP = HeadersP;
+exports.ProgressEvent = ProgressEventE;
+exports.ProgressEventP = ProgressEventP;
+exports.Request = RequestE;
+exports.RequestP = RequestP;
+exports.Response = ResponseE;
+exports.ResponseP = ResponseP;
+exports.TextDecoder = TextDecoderE;
+exports.TextDecoderP = TextDecoderP;
+exports.TextEncoder = TextEncoderE;
+exports.TextEncoderP = TextEncoderP;
+exports.URLSearchParams = URLSearchParamsE;
+exports.URLSearchParamsP = URLSearchParamsP;
+exports.XMLHttpRequest = XMLHttpRequestE;
+exports.XMLHttpRequestP = XMLHttpRequestP;
+exports.fetch = fetchE;
+exports.fetchP = fetchP;