mphttpx 2.3.0 → 2.4.0

package/dist/cjs/encoding/TextDecoderP.js

@@ -1,174 +0,0 @@
-'use strict';
-
-var utils = require('../utils.js');
-var isArrayBuffer = require('../helpers/isArrayBuffer.js');
-
-const validLabels = ["utf-8", "utf8", "unicode-1-1-utf-8"];
-class TextDecoderP {
-    constructor(label = "utf-8", options) {
-        if (validLabels.indexOf((typeof label === "string" ? label : ("" + label)).toLowerCase()) === -1) {
-            throw new RangeError(`Failed to construct 'TextDecoder': encoding ('${label}') not implemented.`);
-        }
-        utils.setState(this, "__TextDecoder__", new TextDecoderState(options));
-    }
-    get encoding() { return "utf-8"; }
-    get fatal() { return state(this).fatal; }
-    get ignoreBOM() { return state(this).ignoreBOM; }
-    decode(input, options) {
-        return decodeText(input, options, state(this));
-    }
-    /** @internal */ toString() { return "[object TextDecoder]"; }
-    /** @internal */ get [utils.SymbolP.toStringTag]() { return "TextDecoder"; }
-    /** @internal */ get __MPHTTPX__() { return { chain: ["TextDecoder"] }; }
-}
-/** @internal */
-class TextDecoderState {
-    constructor({ fatal = false, ignoreBOM = false } = {}) {
-        this.initial = 0;
-        this.partial = [];
-        this.fatal = !!fatal;
-        this.ignoreBOM = !!ignoreBOM;
-    }
-}
-function state(target) {
-    return target.__TextDecoder__;
-}
-function decodeText(input, { stream = false } = {}, settings = { fatal: false, initial: 0, partial: [] }) {
-    if (input === undefined) {
-        if (settings.partial.length > 0) {
-            if (settings.fatal) {
-                settings.partial = [];
-                throw new TypeError("Incomplete UTF-8 sequence.");
-            }
-        }
-        return "";
-    }
-    let bytes = isArrayBuffer.isArrayBuffer(input)
-        ? new Uint8Array(input)
-        : ArrayBuffer.isView(input)
-            ? new Uint8Array(input.buffer, input.byteOffset, input.byteLength)
-            : (() => { throw new TypeError("Input could not be converted to any of: ArrayBufferView, ArrayBuffer."); })();
-    if (settings.initial < 3) {
-        settings.initial += bytes.length;
-        if (bytes.length >= 3) {
-            if (bytes[0] === 0xef && bytes[1] === 0xbb && bytes[2] === 0xbf) {
-                bytes = bytes.subarray(3); // × WeChat 2.5.0
-            }
-        }
-    }
-    if (settings.partial.length > 0) {
-        let merged = new Uint8Array(settings.partial.length + bytes.length);
-        merged.set(settings.partial, 0);
-        merged.set(bytes, settings.partial.length);
-        bytes = merged;
-        settings.partial = [];
-    }
-    let end = bytes.length;
-    let res = [];
-    if (stream && bytes.length > 0) {
-        let i = bytes.length;
-        while (i > 0 && i > bytes.length - 4) {
-            let byte = bytes[i - 1];
-            if ((byte & 0b11000000) !== 0b10000000) {
-                let len = (byte > 0xEF) ? 4 : (byte > 0xDF) ? 3 : (byte > 0xBF) ? 2 : 1;
-                if (len > bytes.length - (i - 1)) {
-                    end = i - 1;
-                }
-                break;
-            }
-            --i;
-        }
-        settings.partial = Array.from(bytes.slice(end)); // save tail   // × WeChat 2.5.0
-        bytes = bytes.slice(0, end); // × WeChat 2.5.0
-    }
-    let codePoint = 0;
-    let tempCodePoint = 0;
-    let bytesPerSequence = 0;
-    let firstByte = 0, secondByte = 0, thirdByte = 0, fourthByte = 0;
-    let i = 0;
-    while (i < end) {
-        codePoint = 0;
-        firstByte = bytes[i];
-        bytesPerSequence = (firstByte > 0xEF) ? 4 : (firstByte > 0xDF) ? 3 : (firstByte > 0xBF) ? 2 : 1;
-        if (i + bytesPerSequence <= end) {
-            switch (bytesPerSequence) {
-                case 1:
-                    if (firstByte < 0x80) {
-                        codePoint = firstByte;
-                    }
-                    break;
-                case 2:
-                    secondByte = bytes[i + 1];
-                    if ((secondByte & 0xC0) === 0x80) {
-                        tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F);
-                        if (tempCodePoint > 0x7F) {
-                            codePoint = tempCodePoint;
-                        }
-                    }
-                    break;
-                case 3:
-                    secondByte = bytes[i + 1];
-                    thirdByte = bytes[i + 2];
-                    if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
-                        tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F);
-                        if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
-                            codePoint = tempCodePoint;
-                        }
-                    }
-                    break;
-                case 4:
-                    secondByte = bytes[i + 1];
-                    thirdByte = bytes[i + 2];
-                    fourthByte = bytes[i + 3];
-                    if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
-                        tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F);
-                        if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
-                            codePoint = tempCodePoint;
-                        }
-                    }
-                    break;
-            }
-        }
-        if (codePoint === 0 && ((bytesPerSequence === 1 && firstByte !== 0) || bytesPerSequence > 1)) {
-            if (settings.fatal) {
-                settings.partial = [];
-                throw new TypeError("Decoding failed.");
-            }
-            let skip = 1;
-            while (i + skip < end && (bytes[i + skip] & 0b11000000) === 0b10000000) {
-                skip += 1;
-            }
-            // we did not generate a valid codePoint so insert a replacement char (U+FFFD)
-            res.push(0xFFFD);
-            i += skip;
-            continue;
-        }
-        else if (codePoint > 0xFFFF) {
-            // encode to utf16 (surrogate pair dance)
-            codePoint -= 0x10000;
-            res.push(codePoint >>> 10 & 0x3FF | 0xD800);
-            codePoint = 0xDC00 | codePoint & 0x3FF;
-        }
-        res.push(codePoint);
-        i += bytesPerSequence;
-    }
-    return res.length > 0x4000 ? buildString(res) : concatString(res);
-}
-function buildString(val) {
-    let arr = [];
-    for (let i = 0, len = val.length; i < len; i += 0x1000) {
-        arr.push(String.fromCharCode.apply(String, val.slice(i, i + 0x1000)));
-    }
-    return arr.join("");
-}
-function concatString(val) {
-    let str = "";
-    for (let i = 0, len = val.length; i < len; i += 0x1000) {
-        str += String.fromCharCode.apply(String, val.slice(i, i + 0x1000));
-    }
-    return str;
-}
-const TextDecoderE = (typeof TextDecoder !== "undefined" && TextDecoder) || TextDecoderP;
-
-exports.TextDecoder = TextDecoderE;
-exports.TextDecoderP = TextDecoderP;

package/dist/cjs/encoding/TextEncoderP.js

@@ -1,121 +0,0 @@
-'use strict';
-
-var utils = require('../utils.js');
-
-class TextEncoderP {
-    get encoding() { return "utf-8"; }
-    encode(input = "") {
-        return encodeText(typeof input === "string" ? input : ("" + input)).encoded;
-    }
-    encodeInto(source, destination) {
-        utils.checkArgsLength(arguments.length, 2, "TextEncoder", "encodeInto");
-        if (!(destination instanceof Uint8Array || utils.isObjectType("Uint8Array", destination) /* Mini Program */)) {
-            throw new TypeError("Failed to execute 'encodeInto' on 'TextEncoder': parameter 2 is not of type 'Uint8Array'.");
-        }
-        let result = encodeText(typeof source === "string" ? source : ("" + source), destination);
-        return { read: result.read, written: result.written };
-    }
-    /** @internal */ toString() { return "[object TextEncoder]"; }
-    /** @internal */ get [utils.SymbolP.toStringTag]() { return "TextEncoder"; }
-    /** @internal */ get __MPHTTPX__() { return { chain: ["TextEncoder"] }; }
-}
-function encodeText(input, destination) {
-    const HAS_DESTINATION = 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
-    let value = 0;
-    let codeUnitCount = 0;
-    let byteCount = 0;
-    while (pos < len) {
-        value = input.charCodeAt(pos);
-        codeUnitCount = 1;
-        if (value >= 0xd800 && value <= 0xdbff) {
-            // high surrogate
-            if (pos + 1 < len) {
-                let extra = input.charCodeAt(pos + 1);
-                if ((extra & 0xfc00) === 0xdc00) {
-                    codeUnitCount = 2;
-                    pos += 2;
-                    value = ((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000;
-                }
-                else {
-                    pos += 1;
-                    value = 0xfffd;
-                }
-            }
-            else {
-                pos += 1;
-                value = 0xfffd;
-            }
-        }
-        else if (value >= 0xdc00 && value <= 0xdfff) {
-            pos += 1;
-            value = 0xfffd;
-        }
-        else {
-            pos += 1;
-        }
-        // expand the buffer if we couldn't write 4 bytes
-        if (!HAS_DESTINATION && at + 4 > target.length) {
-            tlen += 8; // minimum extra
-            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;
-        }
-        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;
-        }
-        switch (byteCount) {
-            case 1: // 1-byte
-                target[at++] = value; // ASCII
-                break;
-            case 2: // 2-byte
-                target[at++] = ((value >> 6) & 0x1f) | 0xc0;
-                target[at++] = (value & 0x3f) | 0x80;
-                break;
-            case 3: // 3-byte
-                target[at++] = ((value >> 12) & 0x0f) | 0xe0;
-                target[at++] = ((value >> 6) & 0x3f) | 0x80;
-                target[at++] = (value & 0x3f) | 0x80;
-                break;
-            case 4: // 4-byte
-                target[at++] = ((value >> 18) & 0x07) | 0xf0;
-                target[at++] = ((value >> 12) & 0x3f) | 0x80;
-                target[at++] = ((value >> 6) & 0x3f) | 0x80;
-                target[at++] = (value & 0x3f) | 0x80;
-                break;
-        }
-        read += codeUnitCount;
-    }
-    return {
-        encoded: !HAS_DESTINATION ? target.slice(0, at) : destination,
-        read: read,
-        written: at,
-    };
-}
-const TextEncoderE = (typeof TextEncoder !== "undefined" && TextEncoder) || TextEncoderP;
-
-exports.TextEncoder = TextEncoderE;
-exports.TextEncoderP = TextEncoderP;

package/dist/cjs/event-system/AbortControllerP.js

@@ -1,28 +0,0 @@
-'use strict';
-
-var utils = require('../utils.js');
-var AbortSignalP = require('./AbortSignalP.js');
-
-class AbortControllerP {
-    constructor() {
-        utils.setState(this, "__AbortController__", new AbortControllerState());
-    }
-    get signal() { return state(this).signal; }
-    abort(reason) { AbortSignalP.AbortSignal_abort(this.signal, true, reason); }
-    /** @internal */ toString() { return "[object AbortController]"; }
-    /** @internal */ get [utils.SymbolP.toStringTag]() { return "AbortController"; }
-    /** @internal */ get __MPHTTPX__() { return { chain: ["AbortController"] }; }
-}
-/** @internal */
-class AbortControllerState {
-    constructor() {
-        this.signal = AbortSignalP.createAbortSignal();
-    }
-}
-function state(target) {
-    return target.__AbortController__;
-}
-const AbortControllerE = (typeof AbortController !== "undefined" && AbortController) || AbortControllerP;
-
-exports.AbortController = AbortControllerE;
-exports.AbortControllerP = AbortControllerP;

package/dist/cjs/event-system/AbortSignalP.js

@@ -1,120 +0,0 @@
-'use strict';
-
-var emitEvent = require('../helpers/emitEvent.js');
-var handlers = require('../helpers/handlers.js');
-var EventTargetP = require('./EventTargetP.js');
-var isSequence = require('../helpers/isSequence.js');
-var isEventTarget = require('../helpers/isEventTarget.js');
-var utils = require('../utils.js');
-
-class AbortSignalP extends EventTargetP.EventTargetP {
-    static abort(reason) {
-        let signal = createAbortSignal();
-        AbortSignal_abort(signal, false, reason);
-        return signal;
-    }
-    static any(signals) {
-        utils.checkArgsLength(arguments.length, 1, "AbortSignal", "any");
-        if (!isSequence.isSequence(signals)) {
-            throw new TypeError("Failed to execute 'any' on 'AbortSignal': The provided value cannot be converted to a sequence.");
-        }
-        let _signals = Array.isArray(signals) ? signals : Array.from(signals);
-        _signals.forEach(sig => { if (!isEventTarget.isEventTarget(sig))
-            throw new TypeError("Failed to execute 'any' on 'AbortSignal': Failed to convert value to 'AbortSignal'."); });
-        let signal = createAbortSignal();
-        let abortedSignal = (() => { for (let i = 0; i < _signals.length; ++i) {
-            let sig = _signals[i];
-            if (sig.aborted)
-                return sig;
-        } })();
-        if (abortedSignal) {
-            AbortSignal_abort(signal, false, abortedSignal.reason);
-        }
-        else {
-            function abortFn() {
-                for (let i = 0; i < _signals.length; ++i) {
-                    let sig = _signals[i];
-                    sig.removeEventListener("abort", abortFn);
-                }
-                AbortSignal_abort(signal, true, this.reason);
-            }
-            for (let i = 0; i < _signals.length; ++i) {
-                let sig = _signals[i];
-                sig.addEventListener("abort", abortFn);
-            }
-        }
-        return signal;
-    }
-    static timeout(milliseconds) {
-        utils.checkArgsLength(arguments.length, 1, "AbortSignal", "timeout");
-        if (!(milliseconds >= 0)) {
-            throw new TypeError("Failed to execute 'timeout' on 'AbortSignal': Value is outside the 'unsigned long long' value range.");
-        }
-        const signal = createAbortSignal();
-        const execTimeout = () => AbortSignal_abort(signal, true, new utils.DOMExceptionP("signal timed out", "TimeoutError"));
-        setTimeout(execTimeout, milliseconds);
-        return signal;
-    }
-    /** @internal */
-    constructor() {
-        if (new.target === AbortSignalP) {
-            throw new TypeError("Failed to construct 'AbortSignal': Illegal constructor");
-        }
-        super();
-        utils.setState(this, "__AbortSignal__", new AbortSignalState(this));
-    }
-    get aborted() { return state(this).aborted; }
-    get reason() { return state(this).reason; }
-    throwIfAborted() {
-        if (this.aborted) {
-            throw this.reason;
-        }
-    }
-    get onabort() { return state(this).onabort; }
-    set onabort(value) { state(this).onabort = value; state(this).attach("abort"); }
-    /** @internal */ toString() { return "[object AbortSignal]"; }
-    /** @internal */ get [utils.SymbolP.toStringTag]() { return "AbortSignal"; }
-    /** @internal */ get __MPHTTPX__() { return { chain: ["AbortSignal", "EventTarget"] }; }
-}
-/** @internal */
-class AbortSignalState {
-    constructor(target) {
-        this.aborted = false;
-        this.reason = undefined;
-        this.onabort = null;
-        this.attach = handlers.attachFn(target, getHandlers(target));
-    }
-}
-function getHandlers(t) {
-    return {
-        onabort: (ev) => { handlers.executeFn(t, t.onabort, ev); },
-    };
-}
-function state(target) {
-    return target.__AbortSignal__;
-}
-/** @internal */
-function AbortSignal_abort(signal, notify = true, reason) {
-    const s = state(signal);
-    const execAbort = () => {
-        s.aborted = true;
-        s.reason = reason !== undefined ? reason : new utils.DOMExceptionP("signal is aborted without reason", "AbortError");
-        if (notify)
-            emitEvent.emitEvent(signal, "abort");
-    };
-    if (!signal.aborted)
-        execAbort();
-}
-/** @internal */
-function createAbortSignal() {
-    let signal = Object.create(AbortSignalP.prototype);
-    utils.setState(signal, "__EventTarget__", new EventTargetP.EventTargetState());
-    utils.setState(signal, "__AbortSignal__", new AbortSignalState(signal));
-    return signal;
-}
-const AbortSignalE = (typeof AbortSignal !== "undefined" && AbortSignal) || AbortSignalP;
-
-exports.AbortSignal = AbortSignalE;
-exports.AbortSignalP = AbortSignalP;
-exports.AbortSignal_abort = AbortSignal_abort;
-exports.createAbortSignal = createAbortSignal;

package/dist/cjs/event-system/CloseEventP.js

@@ -1,36 +0,0 @@
-'use strict';
-
-var EventP = require('./EventP.js');
-var utils = require('../utils.js');
-
-class CloseEventP extends EventP.EventP {
-    constructor(type, eventInitDict) {
-        super(type, eventInitDict);
-        utils.setState(this, "__CloseEvent__", new CloseEventState());
-        const s = state(this);
-        let _code = Number(eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.code);
-        s.code = isNaN(_code) ? 0 : _code;
-        if ((eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.reason) !== undefined)
-            s.reason = "" + eventInitDict.reason;
-        s.wasClean = !!(eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.wasClean);
-    }
-    get code() { return state(this).code; }
-    get reason() { return state(this).reason; }
-    get wasClean() { return state(this).wasClean; }
-    /** @internal */ toString() { return "[object CloseEvent]"; }
-    /** @internal */ get [utils.SymbolP.toStringTag]() { return "CloseEvent"; }
-    /** @internal */ get __MPHTTPX__() { return { chain: ["CloseEvent", "Event"] }; }
-}
-/** @internal */
-class CloseEventState {
-    constructor() {
-        this.code = 0;
-        this.reason = "";
-        this.wasClean = false;
-    }
-}
-function state(target) {
-    return target.__CloseEvent__;
-}
-
-exports.CloseEventP = CloseEventP;

package/dist/cjs/event-system/CustomEventP.js

@@ -1,35 +0,0 @@
-'use strict';
-
-var EventP = require('./EventP.js');
-var utils = require('../utils.js');
-
-class CustomEventP extends EventP.EventP {
-    constructor(type, eventInitDict) {
-        var _a;
-        utils.checkArgsLength(arguments.length, 1, "CustomEvent");
-        super(type, eventInitDict);
-        utils.setState(this, "__CustomEvent__", new CustomEventState());
-        state(this).detail = (_a = eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.detail) !== null && _a !== void 0 ? _a : null;
-    }
-    get detail() { return state(this).detail; }
-    initCustomEvent(type, bubbles, cancelable, detail) {
-        utils.checkArgsLength(arguments.length, 1, "CustomEvent", "initCustomEvent");
-        if (this.__Event__.eventDispatched)
-            return;
-        this.initEvent(type, bubbles, cancelable);
-        state(this).detail = detail !== null && detail !== void 0 ? detail : null;
-    }
-    /** @internal */ toString() { return "[object CustomEvent]"; }
-    /** @internal */ get [utils.SymbolP.toStringTag]() { return "CustomEvent"; }
-    /** @internal */ get __MPHTTPX__() { return { chain: ["CustomEvent", "Event"] }; }
-}
-/** @internal */
-class CustomEventState {
-}
-function state(target) {
-    return target.__CustomEvent__;
-}
-const CustomEventE = (typeof CustomEvent !== "undefined" && CustomEvent) || CustomEventP;
-
-exports.CustomEvent = CustomEventE;
-exports.CustomEventP = CustomEventP;

package/dist/cjs/event-system/EventP.js

@@ -1,127 +0,0 @@
-'use strict';
-
-var utils = require('../utils.js');
-
-class EventP {
-    static get NONE() { return 0; }
-    static get CAPTURING_PHASE() { return 1; }
-    static get AT_TARGET() { return 2; }
-    static get BUBBLING_PHASE() { return 3; }
-    constructor(type, eventInitDict) {
-        utils.checkArgsLength(arguments.length, 1, "Event");
-        utils.setState(this, "__Event__", new EventState());
-        const s = state(this);
-        s.type = "" + type;
-        s.bubbles = !!(eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.bubbles);
-        s.cancelable = !!(eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.cancelable);
-        s.composed = !!(eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.composed);
-        Object.defineProperty(this, "isTrusted", {
-            enumerable: true,
-            get: function isTrusted() { return s.isTrusted === "YES"; },
-        });
-    }
-    get NONE() { return 0; }
-    get CAPTURING_PHASE() { return 1; }
-    get AT_TARGET() { return 2; }
-    get BUBBLING_PHASE() { return 3; }
-    get bubbles() { return state(this).bubbles; }
-    get cancelBubble() { return state(this).cancelBubble; }
-    set cancelBubble(value) { if (value) {
-        state(this).cancelBubble = true;
-    } }
-    get cancelable() { return state(this).cancelable; }
-    get composed() { return state(this).composed; }
-    get currentTarget() { return state(this).currentTarget; }
-    get defaultPrevented() { return state(this).defaultPrevented; }
-    get eventPhase() { return state(this).eventPhase; }
-    get returnValue() { return state(this).returnValue; }
-    set returnValue(value) { if (!value) {
-        this.preventDefault();
-    } }
-    get srcElement() { return state(this).target; }
-    get target() { return state(this).target; }
-    get timeStamp() { return state(this).timeStamp; }
-    get type() { return state(this).type; }
-    composedPath() {
-        let path = this.target ? [this.target] : [];
-        if (this.currentTarget && this.currentTarget !== this.target)
-            path.push(this.currentTarget);
-        return path;
-    }
-    initEvent(type, bubbles, cancelable) {
-        utils.checkArgsLength(arguments.length, 1, utils.className(this), "initEvent");
-        let s = state(this);
-        if (s.eventDispatched)
-            return;
-        s.type = "" + type;
-        s.bubbles = !!bubbles;
-        s.cancelable = !!cancelable;
-    }
-    preventDefault() {
-        let s = state(this);
-        if (s.passive)
-            return console.warn(`Ignoring 'preventDefault()' call on event of type '${this.type}' from a listener registered as 'passive'.`);
-        if (this.cancelable) {
-            s.defaultPrevented = true;
-            s.returnValue = false;
-        }
-    }
-    stopImmediatePropagation() {
-        state(this).immediatePropagationStopped = true;
-        this.cancelBubble = true;
-    }
-    stopPropagation() {
-        this.cancelBubble = true;
-    }
-    /** @internal */ toString() { return "[object Event]"; }
-    /** @internal */ get [utils.SymbolP.toStringTag]() { return "Event"; }
-    /** @internal */ get __MPHTTPX__() { return { chain: ["Event"] }; }
-}
-/** @internal */
-class EventState {
-    constructor() {
-        this.bubbles = false;
-        this.cancelBubble = false;
-        this.cancelable = false;
-        this.composed = false;
-        this.currentTarget = null;
-        this.defaultPrevented = false;
-        this.eventPhase = 0 /* NONE */;
-        this.returnValue = true;
-        this.target = null;
-        this.timeStamp = (new Date()).getTime() - timeStamp;
-        this.type = "";
-        this.passive = false;
-        this.eventDispatched = false;
-        this.immediatePropagationStopped = false;
-        Object.defineProperty(this, "isTrusted", createTrustedPropertyDescriptor());
-    }
-}
-const timeStamp = (new Date()).getTime();
-/** @internal */
-function state(target) {
-    return target.__Event__;
-}
-function createTrustedPropertyDescriptor() {
-    let name = createTrustedPropertyDescriptor.name;
-    let idx = name.length;
-    let isTrusted = "NO";
-    return {
-        configurable: false,
-        enumerable: true,
-        get: function () { return isTrusted; },
-        set: function (value) { if (name === value.slice(0, idx)) {
-            isTrusted = value.slice(idx + 1);
-        } },
-    };
-}
-/** @internal */
-function Event_setTrusted(event, isTrusted) {
-    state(event).isTrusted = `${createTrustedPropertyDescriptor.name}:${isTrusted ? "YES" : "NO"}`;
-}
-const EventE = (typeof Event !== "undefined" && Event) || EventP;
-
-exports.Event = EventE;
-exports.EventP = EventP;
-exports.Event_setTrusted = Event_setTrusted;
-exports.state = state;