mphttpx 1.0.0

package/dist/index.esm.js

@@ -0,0 +1,2312 @@
+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;
+
+export { AbortControllerE as AbortController, AbortControllerP, AbortSignalE as AbortSignal, AbortSignalP, BlobE as Blob, BlobP, CustomEventE as CustomEvent, CustomEventP, EventE as Event, EventP, EventTargetE as EventTarget, EventTargetP, FileE as File, FileP, FileReaderE as FileReader, FileReaderP, FormDataE as FormData, FormDataP, HeadersE as Headers, HeadersP, ProgressEventE as ProgressEvent, ProgressEventP, RequestE as Request, RequestP, ResponseE as Response, ResponseP, TextDecoderE as TextDecoder, TextDecoderP, TextEncoderE as TextEncoder, TextEncoderP, URLSearchParamsE as URLSearchParams, URLSearchParamsP, XMLHttpRequestE as XMLHttpRequest, XMLHttpRequestP, fetchE as fetch, fetchP };