fetch-xhr-shim 0.0.1-beta

package/dist/cjs/dev.js

@@ -0,0 +1,55 @@
+'use strict';
+
+var TextDecoderP = require('./encoding/TextDecoderP.js');
+var EventTargetP = require('./event-system/EventTargetP.js');
+var EventP = require('./event-system/EventP.js');
+var ProgressEventP = require('./event-system/ProgressEventP.js');
+var AbortSignalP = require('./event-system/AbortSignalP.js');
+var BlobP = require('./file-system/BlobP.js');
+var FileReaderP = require('./file-system/FileReaderP.js');
+var URLSearchParamsP = require('./network/URLSearchParamsP.js');
+var FormDataP = require('./network/FormDataP.js');
+var HeadersP = require('./fetch-api/HeadersP.js');
+var BodyImpl = require('./fetch-api/BodyImpl.js');
+var RequestP = require('./fetch-api/RequestP.js');
+var utils = require('./utils.js');
+
+
+
+exports.isArrayBuffer = TextDecoderP.isArrayBuffer;
+exports.EventTarget_dispatchEvent = EventTargetP.EventTarget_dispatchEvent;
+exports.attachFn = EventTargetP.attachFn;
+exports.executeFn = EventTargetP.executeFn;
+exports.isEventTarget = EventTargetP.isEventTarget;
+exports.Event_setTrusted = EventP.Event_setTrusted;
+exports.ProgressEventP = ProgressEventP.ProgressEventP;
+exports.emitProgressEvent = ProgressEventP.emitProgressEvent;
+exports.AbortSignal_abort = AbortSignalP.AbortSignal_abort;
+exports.createAbortSignal = AbortSignalP.createAbortSignal;
+exports.decode = BlobP.decode;
+exports.encode = BlobP.encode;
+exports.isBlob = BlobP.isBlob;
+exports.Uint8Array_toBase64 = FileReaderP.Uint8Array_toBase64;
+exports.isURLSearchParams = URLSearchParamsP.isURLSearchParams;
+exports.FormData_toBlob = FormDataP.FormData_toBlob;
+exports.createFormDataFromBinaryText = FormDataP.createFormDataFromBinaryText;
+exports.extractBoundary = FormDataP.extractBoundary;
+exports.isFormData = FormDataP.isFormData;
+exports.createHeaders = HeadersP.createHeaders;
+exports.isHeaders = HeadersP.isHeaders;
+exports.normalizeName = HeadersP.normalizeName;
+exports.normalizeValue = HeadersP.normalizeValue;
+exports.parseHeaders = HeadersP.parseHeaders;
+exports.BodyImpl = BodyImpl.BodyImpl;
+exports.Payload = BodyImpl.Payload;
+exports.initBody = BodyImpl.initBody;
+exports.normalizeMethod = RequestP.normalizeMethod;
+exports.DOMException = utils.DOMException;
+exports.DOMExceptionP = utils.DOMExceptionP;
+exports._Symbol = utils._Symbol;
+exports.checkArgsLength = utils.checkArgsLength;
+exports.className = utils.className;
+exports.isObjectType = utils.isObjectType;
+exports.isPolyfillType = utils.isPolyfillType;
+exports.isSequence = utils.isSequence;
+exports.setState = utils.setState;

package/dist/cjs/encoding/TextDecoderP.js

@@ -0,0 +1,179 @@
+'use strict';
+
+var utils = require('../utils.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._Symbol.toStringTag]() { return "TextDecoder"; }
+    /** @internal */ get __MPHTTPX__() { return { chain: ["TextDecoder"] }; }
+}
+/** @internal */
+class TextDecoderState {
+    constructor({ fatal = false, ignoreBOM = false } = {}) {
+        this.partial = [];
+        this.fatal = !!fatal;
+        this.ignoreBOM = !!ignoreBOM;
+    }
+}
+function state(target) {
+    return target.__TextDecoder__;
+}
+function decodeText(input, { stream = false } = {}, settings = { fatal: false, ignoreBOM: false, 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(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.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 = [];
+    }
+    if (!settings.ignoreBOM && bytes.length >= 3) {
+        if (bytes[0] === 0xEF && bytes[1] === 0xBB && bytes[2] === 0xBF) {
+            bytes = bytes.subarray(3); // × WeChat 2.5.0
+        }
+    }
+    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;
+}
+// Mini Program
+function isOtherArrayBuffer(value) {
+    return (utils.isObjectType("ArrayBuffer", value) || String(value) === "[object ArrayBuffer]")
+        && "byteLength" in value
+        && typeof value.byteLength === "number";
+}
+function isArrayBuffer(value) {
+    return (!!value && typeof value === "object" && ArrayBuffer.prototype.isPrototypeOf(value)) || isOtherArrayBuffer(value);
+}
+const TextDecoderE = (typeof TextDecoder !== "undefined" && TextDecoder) || TextDecoderP;
+
+exports.TextDecoder = TextDecoderE;
+exports.TextDecoderP = TextDecoderP;
+exports.isArrayBuffer = isArrayBuffer;

package/dist/cjs/encoding/TextEncoderP.js

@@ -0,0 +1,121 @@
+'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 (!(Uint8Array.prototype.isPrototypeOf(destination) || 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._Symbol.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

@@ -0,0 +1,28 @@
+'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._Symbol.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

@@ -0,0 +1,117 @@
+'use strict';
+
+var utils = require('../utils.js');
+var EventP = require('./EventP.js');
+var EventTargetP = require('./EventTargetP.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 (!utils.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 (!EventTargetP.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.DOMException("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._Symbol.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 = EventTargetP.attachFn(target, getHandlers(target));
+    }
+}
+function getHandlers(t) {
+    return {
+        onabort: (ev) => { EventTargetP.executeFn(t, t.onabort, ev); },
+    };
+}
+function state(target) {
+    return target.__AbortSignal__;
+}
+function createAbortSignal() {
+    let signal = Object.create(AbortSignalP.prototype);
+    utils.setState(signal, "__EventTarget__", { executors: [] });
+    utils.setState(signal, "__AbortSignal__", new AbortSignalState(signal));
+    return signal;
+}
+function AbortSignal_abort(signal, notify = true, reason) {
+    if (!signal.aborted) {
+        let s = state(signal) || {};
+        s.aborted = true;
+        s.reason = reason !== undefined ? reason : new utils.DOMException("signal is aborted without reason", "AbortError");
+        if (notify) {
+            let event = new EventP.EventP("abort");
+            event.__Event__.target = signal;
+            EventP.Event_setTrusted(event, true);
+            EventTargetP.EventTarget_dispatchEvent(signal, event);
+        }
+    }
+}
+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/CustomEventP.js

@@ -0,0 +1,35 @@
+'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._Symbol.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());
+        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._Symbol.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());
+    }
+}
+function state(target) {
+    return target.__Event__;
+}
+const timeStamp = (new Date()).getTime();
+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);
+        } },
+    };
+}
+function Event_setTrusted(event, isTrusted) {
+    let s = state(event) || {};
+    s.isTrusted = `${createTrustedPropertyDescriptor.name}:${isTrusted ? "YES" : "NO"}`;
+}
+const EventE = (typeof Event !== "undefined" && Event) || EventP;
+
+exports.Event = EventE;
+exports.EventP = EventP;
+exports.Event_setTrusted = Event_setTrusted;