mphttpx 2.0.0 → 2.1.0

package/dist/cjs/encoding/TextDecoderP.js

@@ -0,0 +1,182 @@
+'use strict';
+
+var utils = require('../utils.js');
+var isArrayBuffer = require('../helpers/isArrayBuffer.js');
+
+class TextDecoderP {
+    constructor(label = "utf-8", options) {
+        if (["utf-8", "utf8", "unicode-1-1-utf-8"].indexOf(("" + label).toLowerCase()) === -1) {
+            throw new RangeError(`Failed to construct 'TextDecoder': encoding ('${label}') not implemented.`);
+        }
+        utils.setState(this, "__TextDecoder__", new TextDecoderState());
+        state(this).fatal = !!(options === null || options === void 0 ? void 0 : options.fatal);
+        state(this).ignoreBOM = !!(options === null || options === void 0 ? void 0 : options.ignoreBOM);
+    }
+    get encoding() { return "utf-8"; }
+    get fatal() { return state(this).fatal; }
+    get ignoreBOM() { return state(this).ignoreBOM; }
+    decode(input, options) {
+        return decodeText(state(this), input, options);
+    }
+    /** @internal */ toString() { return "[object TextDecoder]"; }
+    /** @internal */ get [utils.SymbolP.toStringTag]() { return "TextDecoder"; }
+    /** @internal */ get __MPHTTPX__() { return { chain: ["TextDecoder"] }; }
+}
+/** @internal */
+class TextDecoderState {
+    constructor() {
+        this.fatal = false;
+        this.ignoreBOM = false;
+        this.initial = 0;
+        this.partial = [];
+    }
+}
+function state(target) {
+    return target.__TextDecoder__;
+}
+function decodeText(settings, input, options) {
+    let bytes;
+    if (input !== undefined) {
+        if (isArrayBuffer.isArrayBuffer(input)) {
+            bytes = new Uint8Array(input);
+        }
+        else if (ArrayBuffer.isView(input)) {
+            bytes = new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+        }
+        else {
+            throw new TypeError("Input could not be converted to any of: ArrayBufferView, ArrayBuffer.");
+        }
+    }
+    else {
+        if (settings.partial.length > 0) {
+            if (settings.fatal) {
+                settings.partial = [];
+                throw new TypeError("Incomplete UTF-8 sequence.");
+            }
+        }
+        return "";
+    }
+    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 (!!(options === null || options === void 0 ? void 0 : options.stream) && bytes.length > 0) {
+        let i = bytes.length;
+        while (i > 0 && i > bytes.length - 4) {
+            let byte = bytes[i - 1];
+            if ((byte & 0b11000000) !== 0b10000000) {
+                let len = getBytesPerSequence(byte);
+                if (len > 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 i = 0;
+    while (i < end) {
+        let codePoint = null;
+        let firstByte = bytes[i];
+        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 = 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 === null) {
+            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 getBytesPerSequence(byte) {
+    return (byte > 0xEF) ? 4 : (byte > 0xDF) ? 3 : (byte > 0xBF) ? 2 : 1;
+}
+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/{TextEncoderP.js → encoding/TextEncoderP.js}

@@ -1,29 +1,26 @@
 'use strict';
 
-var isPolyfill = require('./isPolyfill.js');
+var utils = require('../utils.js');
 
 class TextEncoderP {
     get encoding() { return "utf-8"; }
     encode(input = "") {
-        let _input = "" + input;
-        return encodeText(_input).encoded;
+        return encodeText("" + input).encoded;
     }
-    encodeInto(...args) {
-        const [source, destination] = args;
-        isPolyfill.checkArgsLength(args, 2, "TextEncoder", "encodeInto");
-        let _source = "" + source;
-        if (!(destination instanceof Uint8Array || isPolyfill.isObjectType("Uint8Array", destination))) {
+    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(_source, destination);
+        let result = encodeText("" + source, destination);
         return { read: result.read, written: result.written };
     }
     /** @internal */ toString() { return "[object TextEncoder]"; }
-    /** @internal */ get [Symbol.toStringTag]() { return "TextEncoder"; }
-    /** @internal */ get isPolyfill() { return { symbol: isPolyfill.polyfill, hierarchy: ["TextEncoder"] }; }
+    /** @internal */ get [utils.SymbolP.toStringTag]() { return "TextEncoder"; }
+    /** @internal */ get __MPHTTPX__() { return { chain: ["TextEncoder"] }; }
 }
 function encodeText(input, destination) {
-    const HAS_DESTINATION = typeof destination !== "undefined";
+    const HAS_DESTINATION = destination !== undefined;
     let pos = 0;
     let read = 0;
     let len = input.length;
@@ -116,7 +113,7 @@ function encodeText(input, destination) {
         written: at,
     };
 }
-const TextEncoderE = isPolyfill.g["TextEncoder"] || TextEncoderP;
+const TextEncoderE = (typeof TextEncoder !== "undefined" && TextEncoder) || TextEncoderP;
 
 exports.TextEncoder = TextEncoderE;
 exports.TextEncoderP = TextEncoderP;

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

@@ -0,0 +1,30 @@
+'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/{AbortSignalP.js → event-system/AbortSignalP.js}

@@ -1,42 +1,41 @@
 'use strict';
 
-var isPolyfill = require('./isPolyfill.js');
-var EventP = require('./EventP.js');
+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');
 
-var _a;
-/** @internal */
-const state = Symbol( /* "AbortSignalState" */);
 class AbortSignalP extends EventTargetP.EventTargetP {
     static abort(reason) {
         let signal = createAbortSignal();
-        AbortSignal_abort(signal, reason, false);
+        AbortSignal_abort(signal, false, reason);
         return signal;
     }
-    static any(...args) {
-        const [signals] = args;
-        isPolyfill.checkArgsLength(args, 1, "AbortSignal", "any");
-        if (!(Array.isArray(signals) || (signals && typeof signals === "object" && Symbol.iterator in signals))) {
+    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 (!isPolyfill.isPolyfillType("EventTarget", 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 = _signals.find(x => x.aborted);
         if (abortedSignal) {
-            AbortSignal_abort(signal, abortedSignal.reason, false);
+            AbortSignal_abort(signal, false, abortedSignal.reason);
         }
         else {
-            function abortFn(ev) {
+            function abortFn() {
                 for (let i = 0; i < _signals.length; ++i) {
                     let sig = _signals[i];
                     sig.removeEventListener("abort", abortFn);
                 }
-                AbortSignal_abort(signal, this.reason, true, ev.isTrusted);
+                AbortSignal_abort(signal, true, this.reason);
             }
             for (let i = 0; i < _signals.length; ++i) {
                 let sig = _signals[i];
@@ -45,16 +44,14 @@ class AbortSignalP extends EventTargetP.EventTargetP {
         }
         return signal;
     }
-    static timeout(...args) {
-        const [milliseconds] = args;
-        isPolyfill.checkArgsLength(args, 1, "AbortSignal", "timeout");
+    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.");
         }
-        let signal = createAbortSignal();
-        setTimeout(() => {
-            AbortSignal_abort(signal, new isPolyfill.MPException("signal timed out", "TimeoutError"));
-        }, milliseconds);
+        const signal = createAbortSignal();
+        const whenTimeout = () => AbortSignal_abort(signal, true, new utils.DOMExceptionP("signal timed out", "TimeoutError"));
+        setTimeout(whenTimeout, milliseconds);
         return signal;
     }
     /** @internal */
@@ -63,62 +60,60 @@ class AbortSignalP extends EventTargetP.EventTargetP {
             throw new TypeError("Failed to construct 'AbortSignal': Illegal constructor");
         }
         super();
-        this[state] = new AbortSignalState(this);
+        utils.setState(this, "__AbortSignal__", new AbortSignalState(this));
     }
-    get aborted() { return this[state].aborted; }
-    get reason() { return this[state].reason; }
+    get aborted() { return state(this).aborted; }
+    get reason() { return state(this).reason; }
     throwIfAborted() {
         if (this.aborted) {
             throw this.reason;
         }
     }
-    get onabort() { return this[state].onabort; }
-    set onabort(value) {
-        this[state].onabort = value;
-        EventTargetP.attachFn(this, "abort", value, this[state][_handlers].onabort);
-    }
+    get onabort() { return state(this).onabort; }
+    set onabort(value) { state(this).onabort = value; state(this).attach("abort"); }
     /** @internal */ toString() { return "[object AbortSignal]"; }
-    /** @internal */ get [Symbol.toStringTag]() { return "AbortSignal"; }
-    /** @internal */ get isPolyfill() { return { symbol: isPolyfill.polyfill, hierarchy: ["AbortSignal", "EventTarget"] }; }
+    /** @internal */ get [utils.SymbolP.toStringTag]() { return "AbortSignal"; }
+    /** @internal */ get __MPHTTPX__() { return { chain: ["AbortSignal", "EventTarget"] }; }
 }
 /** @internal */
-const _handlers = Symbol();
-/** @internal */
 class AbortSignalState {
     constructor(target) {
         this.aborted = false;
         this.reason = undefined;
-        this[_a] = getHandlers(this);
         this.onabort = null;
-        this.target = target;
+        this.attach = handlers.attachFn(target, getHandlers(target));
     }
 }
-_a = _handlers;
+function getHandlers(t) {
+    return {
+        onabort: (ev) => { handlers.executeFn(t, t.onabort, ev); },
+    };
+}
+function state(target) {
+    return target.__AbortSignal__;
+}
 /** @internal */
-function AbortSignal_abort(signal, reason, notify = true, isTrusted = true) {
-    const s = signal[state];
-    if (!s.aborted) {
+function AbortSignal_abort(signal, notify = true, reason) {
+    const s = state(signal);
+    const whenAbort = () => {
         s.aborted = true;
-        s.reason = reason !== null && reason !== void 0 ? reason : (new isPolyfill.MPException("signal is aborted without reason", "AbortError"));
+        s.reason = reason !== null && reason !== void 0 ? reason : (new utils.DOMExceptionP("signal is aborted without reason", "AbortError"));
         if (notify) {
-            let evt = EventP.createInnerEvent(signal, "abort", undefined, isTrusted);
-            EventTargetP.EventTarget_fire(signal, evt);
+            emitEvent.emitEvent(signal, "abort");
         }
-    }
-}
-function getHandlers(s) {
-    return {
-        onabort: (ev) => { EventTargetP.executeFn(s.target, s.onabort, ev); },
     };
+    if (!signal.aborted) {
+        whenAbort();
+    }
 }
 /** @internal */
 function createAbortSignal() {
     let signal = Object.create(AbortSignalP.prototype);
-    signal[EventTargetP.eventTargetState] = new EventTargetP.EventTargetState(signal);
-    signal[state] = new AbortSignalState(signal);
+    utils.setState(signal, "__EventTarget__", new EventTargetP.EventTargetState());
+    utils.setState(signal, "__AbortSignal__", new AbortSignalState(signal));
     return signal;
 }
-const AbortSignalE = isPolyfill.g["AbortSignal"] || AbortSignalP;
+const AbortSignalE = (typeof AbortSignal !== "undefined" && AbortSignal) || AbortSignalP;
 
 exports.AbortSignal = AbortSignalE;
 exports.AbortSignalP = AbortSignalP;

package/dist/cjs/{CloseEventP.js → event-system/CloseEventP.js}

@@ -1,28 +1,26 @@
 'use strict';
 
 var EventP = require('./EventP.js');
-var isPolyfill = require('./isPolyfill.js');
+var utils = require('../utils.js');
 
-/** @internal */
-const state = Symbol( /* "CloseEventState" */);
 class CloseEventP extends EventP.EventP {
     constructor(type, eventInitDict) {
         var _a;
         super(type, eventInitDict);
-        this[state] = new CloseEventState();
-        const s = this[state];
+        utils.setState(this, "__CloseEvent__", new CloseEventState());
+        const s = state(this);
         let _code = Number((_a = eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.code) !== null && _a !== void 0 ? _a : 0);
         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 this[state].code; }
-    get reason() { return this[state].reason; }
-    get wasClean() { return this[state].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 [Symbol.toStringTag]() { return "CloseEvent"; }
-    /** @internal */ get isPolyfill() { return { symbol: isPolyfill.polyfill, hierarchy: ["CloseEvent", "Event"] }; }
+    /** @internal */ get [utils.SymbolP.toStringTag]() { return "CloseEvent"; }
+    /** @internal */ get __MPHTTPX__() { return { chain: ["CloseEvent", "Event"] }; }
 }
 /** @internal */
 class CloseEventState {
@@ -32,7 +30,8 @@ class CloseEventState {
         this.wasClean = false;
     }
 }
-const CloseEventE = isPolyfill.g["EventTarget"] ? isPolyfill.g["CloseEvent"] : CloseEventP;
+function state(target) {
+    return target.__CloseEvent__;
+}
 
-exports.CloseEvent = CloseEventE;
 exports.CloseEventP = CloseEventP;

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

@@ -0,0 +1,34 @@
+'use strict';
+
+var EventP = require('./EventP.js');
+var utils = require('../utils.js');
+
+class CustomEventP extends EventP.EventP {
+    constructor(type, eventInitDict) {
+        var _a;
+        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

@@ -0,0 +1,125 @@
+'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());
+        state(this).type = "" + type;
+        state(this).bubbles = !!(eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.bubbles);
+        state(this).cancelable = !!(eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.cancelable);
+        state(this).composed = !!(eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.composed);
+        Object.defineProperty(this, "isTrusted", {
+            enumerable: true,
+            get: (function isTrusted() { return state(this).isTrusted === "YES"; }).bind(this),
+        });
+    }
+    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");
+        if (state(this).eventDispatched)
+            return;
+        state(this).type = "" + type;
+        state(this).bubbles = !!bubbles;
+        state(this).cancelable = !!cancelable;
+    }
+    preventDefault() {
+        if (state(this).passive) {
+            return console.warn(`Ignoring 'preventDefault()' call on event of type '${this.type}' from a listener registered as 'passive'.`);
+        }
+        if (this.cancelable) {
+            state(this).defaultPrevented = true;
+            state(this).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() - EventState.timeStamp;
+        this.type = "";
+        this.passive = false;
+        this.eventDispatched = false;
+        this.immediatePropagationStopped = false;
+        Object.defineProperty(this, "isTrusted", createTrustedPropertyDescriptor());
+    }
+}
+EventState.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;