mphttpx 1.2.0-beta.1 → 1.2.0-beta.2

package/dist/cjs/AbortControllerP.js

@@ -0,0 +1,31 @@
+'use strict';
+
+var isPolyfill = require('./isPolyfill.js');
+var AbortSignalP = require('./AbortSignalP.js');
+require('./EventP.js');
+require('./EventTargetP.js');
+
+/** @internal */
+const state = Symbol( /* "AbortControllerState" */);
+class AbortControllerP {
+    constructor() {
+        this[state] = new AbortControllerState();
+    }
+    get signal() { return this[state].signal; }
+    abort(reason) {
+        AbortSignalP.AbortSignal_abort(this[state].signal, reason);
+    }
+    /** @internal */ toString() { return "[object AbortController]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "AbortController"; }
+    /** @internal */ get isPolyfill() { return { symbol: isPolyfill.polyfill, hierarchy: ["AbortController"] }; }
+}
+/** @internal */
+class AbortControllerState {
+    constructor() {
+        this.signal = AbortSignalP.createAbortSignal();
+    }
+}
+const AbortControllerE = isPolyfill.g["AbortController"] || AbortControllerP;
+
+exports.AbortController = AbortControllerE;
+exports.AbortControllerP = AbortControllerP;

package/dist/cjs/AbortSignalP.js

@@ -0,0 +1,126 @@
+'use strict';
+
+var isPolyfill = require('./isPolyfill.js');
+var EventP = require('./EventP.js');
+var EventTargetP = require('./EventTargetP.js');
+
+var _a;
+/** @internal */
+const state = Symbol( /* "AbortSignalState" */);
+class AbortSignalP extends EventTargetP.EventTargetP {
+    static abort(reason) {
+        let signal = createAbortSignal();
+        AbortSignal_abort(signal, reason, false);
+        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))) {
+            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)) {
+                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);
+        }
+        else {
+            function abortFn(ev) {
+                for (let i = 0; i < _signals.length; ++i) {
+                    let sig = _signals[i];
+                    sig.removeEventListener("abort", abortFn);
+                }
+                AbortSignal_abort(signal, this.reason, true, ev.isTrusted);
+            }
+            for (let i = 0; i < _signals.length; ++i) {
+                let sig = _signals[i];
+                sig.addEventListener("abort", abortFn);
+            }
+        }
+        return signal;
+    }
+    static timeout(...args) {
+        const [milliseconds] = args;
+        isPolyfill.checkArgsLength(args, 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);
+        return signal;
+    }
+    /** @internal */
+    constructor() {
+        if (new.target === AbortSignalP) {
+            throw new TypeError("Failed to construct 'AbortSignal': Illegal constructor");
+        }
+        super();
+        this[state] = new AbortSignalState(this);
+    }
+    get aborted() { return this[state].aborted; }
+    get reason() { return this[state].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);
+    }
+    /** @internal */ toString() { return "[object AbortSignal]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "AbortSignal"; }
+    /** @internal */ get isPolyfill() { return { symbol: isPolyfill.polyfill, hierarchy: ["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;
+    }
+}
+_a = _handlers;
+/** @internal */
+function AbortSignal_abort(signal, reason, notify = true, isTrusted = true) {
+    const s = signal[state];
+    if (!s.aborted) {
+        s.aborted = true;
+        s.reason = reason !== null && reason !== void 0 ? reason : (new isPolyfill.MPException("signal is aborted without reason", "AbortError"));
+        if (notify) {
+            let evt = EventP.createInnerEvent(signal, "abort", undefined, isTrusted);
+            EventTargetP.EventTarget_fire(signal, evt);
+        }
+    }
+}
+function getHandlers(s) {
+    return {
+        onabort: (ev) => { EventTargetP.executeFn(s.target, s.onabort, ev); },
+    };
+}
+/** @internal */
+function createAbortSignal() {
+    let signal = Object.create(AbortSignalP.prototype);
+    signal[EventTargetP.eventTargetState] = new EventTargetP.EventTargetState(signal);
+    signal[state] = new AbortSignalState(signal);
+    return signal;
+}
+const AbortSignalE = isPolyfill.g["AbortSignal"] || AbortSignalP;
+
+exports.AbortSignal = AbortSignalE;
+exports.AbortSignalP = AbortSignalP;
+exports.AbortSignal_abort = AbortSignal_abort;
+exports.createAbortSignal = createAbortSignal;

package/dist/cjs/BlobP.js

@@ -0,0 +1,131 @@
+'use strict';
+
+var TextEncoderP = require('./TextEncoderP.js');
+var TextDecoderP = require('./TextDecoderP.js');
+var isPolyfill = require('./isPolyfill.js');
+
+/** @internal */
+const state = Symbol( /* "BlobState" */);
+class BlobP {
+    constructor(blobParts = [], options) {
+        if (!(Array.isArray(blobParts) || (blobParts && typeof blobParts === "object" && Symbol.iterator in blobParts))) {
+            throw new TypeError("Failed to construct 'Blob/File': The provided value cannot be converted to a sequence.");
+        }
+        let _blobParts = Array.isArray(blobParts) ? blobParts : Array.from(blobParts);
+        let chunks = [];
+        for (let i = 0; i < _blobParts.length; ++i) {
+            let chunk = _blobParts[i];
+            if (isPolyfill.isPolyfillType("Blob", chunk)) {
+                chunks.push(chunk[state][_buffer]);
+            }
+            else if (isPolyfill.isArrayBuffer(chunk) || ArrayBuffer.isView(chunk)) {
+                chunks.push(BufferSource_toUint8Array(chunk));
+            }
+            else {
+                chunks.push(encode("" + chunk));
+            }
+        }
+        this[state] = new BlobState(concat(chunks));
+        const s = this[state];
+        s.size = s[_buffer].length;
+        let rawType = "" + ((options === null || options === void 0 ? void 0 : options.type) || "");
+        s.type = /[^\u0020-\u007E]/.test(rawType) ? "" : rawType.toLowerCase();
+    }
+    get size() { return this[state].size; }
+    get type() { return this[state].type; }
+    arrayBuffer() {
+        return Promise.resolve(clone(this[state][_buffer].buffer).buffer);
+    }
+    bytes() {
+        return Promise.resolve(clone(this[state][_buffer].buffer));
+    }
+    slice(start, end, contentType) {
+        let sliced = this[state][_buffer].slice(start !== null && start !== void 0 ? start : 0, end !== null && end !== void 0 ? end : this[state][_buffer].length); // × WeChat 2.5.0
+        return new BlobP([sliced], { type: "" + (contentType !== null && contentType !== void 0 ? contentType : "") });
+    }
+    stream() {
+        throw new TypeError("Failed to execute 'stream' on 'Blob': method not implemented.");
+    }
+    text() {
+        return Promise.resolve(decode(this[state][_buffer]));
+    }
+    /** @internal */ toString() { return "[object Blob]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "Blob"; }
+    /** @internal */ get isPolyfill() { return { symbol: isPolyfill.polyfill, hierarchy: ["Blob"] }; }
+}
+/** @internal */
+const _buffer = Symbol();
+/** @internal */
+class BlobState {
+    constructor(buffer) {
+        this.size = 0;
+        this.type = "";
+        this[_buffer] = buffer;
+    }
+}
+/** @internal */
+function Blob_toUint8Array(blob) {
+    return blob[state][_buffer];
+}
+function BufferSource_toUint8Array(buf) {
+    return isPolyfill.isArrayBuffer(buf)
+        ? new Uint8Array(buf)
+        : new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+}
+function clone(buf) {
+    let sourceArray = BufferSource_toUint8Array(buf);
+    let cloneArray = new Uint8Array(new ArrayBuffer(sourceArray.byteLength));
+    cloneArray.set(sourceArray);
+    return cloneArray;
+}
+function concat(chunks) {
+    let totalByteLength = chunks.reduce((acc, cur) => acc + cur.byteLength, 0);
+    let result = new Uint8Array(totalByteLength);
+    chunks.reduce((offset, chunk) => {
+        result.set(chunk, offset);
+        return offset + chunk.byteLength;
+    }, 0);
+    return result;
+}
+/** @internal */
+function encode(str) {
+    let encoder = new TextEncoderP.TextEncoderP();
+    return encoder.encode(str);
+}
+/** @internal */
+function decode(buf) {
+    let decoder = new TextDecoderP.TextDecoderP();
+    return decoder.decode(buf);
+}
+/** @internal */
+function Uint8Array_toBase64(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("");
+}
+const BlobE = isPolyfill.g["Blob"] || BlobP;
+
+exports.Blob = BlobE;
+exports.BlobP = BlobP;
+exports.Blob_toUint8Array = Blob_toUint8Array;
+exports.Uint8Array_toBase64 = Uint8Array_toBase64;
+exports.decode = decode;
+exports.encode = encode;

package/dist/cjs/BodyImpl.js

@@ -0,0 +1,142 @@
+'use strict';
+
+var isPolyfill = require('./isPolyfill.js');
+var convertor = require('./convertor.js');
+var FormDataP = require('./FormDataP.js');
+require('./BlobP.js');
+require('./TextEncoderP.js');
+require('./TextDecoderP.js');
+require('./FileP.js');
+
+var _a;
+/** @internal */ const state = Symbol( /* "BodyState" */);
+class BodyImpl {
+    /** @internal */
+    constructor() {
+        if (new.target === BodyImpl) {
+            throw new TypeError("Failed to construct 'Body': Illegal constructor");
+        }
+        this[state] = new BodyState();
+    }
+    get body() {
+        if (!this[state][_body]) {
+            return null;
+        }
+        throw new TypeError(`Failed to access 'body' on '${this[state].name}': property not implemented.`);
+    }
+    get bodyUsed() { return this[state].bodyUsed; }
+    ;
+    arrayBuffer() {
+        const kind = "arrayBuffer";
+        return consumed(this, kind) || read(this, kind);
+    }
+    blob() {
+        const kind = "blob";
+        return consumed(this, kind) || read(this, kind);
+    }
+    bytes() {
+        const kind = "bytes";
+        return consumed(this, kind) || read(this, kind);
+    }
+    formData() {
+        const kind = "formData";
+        return consumed(this, kind) || read(this, kind);
+    }
+    json() {
+        const kind = "json";
+        return consumed(this, kind) || read(this, kind);
+    }
+    text() {
+        const kind = "text";
+        return consumed(this, kind) || read(this, kind);
+    }
+    /** @internal */ toString() { return "[object Body]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "Body"; }
+    /** @internal */ get isPolyfill() { return { symbol: isPolyfill.polyfill, hierarchy: ["Body"] }; }
+}
+/** @internal */
+const _body = Symbol();
+/** @internal */
+class BodyState {
+    constructor() {
+        this.name = "Body";
+        this.bodyUsed = false;
+        this[_a] = "";
+    }
+}
+_a = _body;
+/** @internal */
+function Body_init(body, payload) {
+    const b = body;
+    if (isPolyfill.isObjectType("ReadableStream", payload)) {
+        throw new TypeError(`Failed to construct '${b[state].name}': ReadableStream not implemented.`);
+    }
+    b[state][_body] = convertor.convert(payload, true, type => { if (!b.headers.has("Content-Type")) {
+        b.headers.set("Content-Type", type);
+    } });
+}
+/** @internal */
+function Body_toPayload(body) {
+    return body[state][_body];
+}
+function read(body, kind) {
+    return new Promise((resolve, reject) => {
+        try {
+            resolve(readSync(body, kind));
+        }
+        catch (e) {
+            reject(e);
+        }
+    });
+}
+function readSync(body, kind) {
+    const payload = body[state][_body];
+    if (kind === "arrayBuffer") {
+        return convertor.convertBack("arraybuffer", payload);
+    }
+    else if (kind === "blob") {
+        return convertor.convertBack("blob", payload);
+    }
+    else if (kind === "bytes") {
+        let arrayBuffer = convertor.convertBack("arraybuffer", payload);
+        return new Uint8Array(arrayBuffer);
+    }
+    else if (kind === "formData") {
+        const extractBoundary = (contentType) => {
+            if (!contentType) {
+                return;
+            }
+            if (!/multipart\/form-data/i.test(contentType)) {
+                return;
+            }
+            let boundaryMatch = contentType.match(/boundary\s*=\s*([^;]+)/i);
+            if (boundaryMatch && boundaryMatch[1]) {
+                let boundary = boundaryMatch[1].trim();
+                return boundary.replace(/^["']|["']$/g, "");
+            }
+        };
+        let text = convertor.convertBack("text", payload);
+        let boundary = extractBoundary(body.headers.get("Content-Type")) || "";
+        return FormDataP.createFormDataFromBinaryText(text, boundary);
+    }
+    else if (kind === "json") {
+        return convertor.convertBack("json", payload);
+    }
+    else {
+        return convertor.convertBack("text", payload);
+    }
+}
+function consumed(body, kind) {
+    const s = body[state];
+    if (!s[_body])
+        return;
+    if (s.bodyUsed) {
+        return Promise.reject(new TypeError(`Failed to execute '${kind}' on '${s.name}': body stream already read`));
+    }
+    s.bodyUsed = true;
+}
+
+exports.BodyImpl = BodyImpl;
+exports.Body_init = Body_init;
+exports.Body_toPayload = Body_toPayload;
+exports.bodyState = state;

package/dist/cjs/CloseEventP.js

@@ -0,0 +1,38 @@
+'use strict';
+
+var EventP = require('./EventP.js');
+var isPolyfill = require('./isPolyfill.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];
+        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; }
+    /** @internal */ toString() { return "[object CloseEvent]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "CloseEvent"; }
+    /** @internal */ get isPolyfill() { return { symbol: isPolyfill.polyfill, hierarchy: ["CloseEvent", "Event"] }; }
+}
+/** @internal */
+class CloseEventState {
+    constructor() {
+        this.code = 0;
+        this.reason = "";
+        this.wasClean = false;
+    }
+}
+const CloseEventE = isPolyfill.g["EventTarget"] ? isPolyfill.g["CloseEvent"] : CloseEventP;
+
+exports.CloseEvent = CloseEventE;
+exports.CloseEventP = CloseEventP;

package/dist/cjs/CustomEventP.js

@@ -0,0 +1,35 @@
+'use strict';
+
+var EventP = require('./EventP.js');
+var isPolyfill = require('./isPolyfill.js');
+
+const dispatched = 1;
+/** @internal */
+const state = Symbol( /* "CustomEventState" */);
+class CustomEventP extends EventP.EventP {
+    constructor(type, eventInitDict) {
+        var _a;
+        super(type, eventInitDict);
+        this[state] = new CustomEventState();
+        this[state].detail = (_a = eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.detail) !== null && _a !== void 0 ? _a : null;
+    }
+    get detail() { return this[state].detail; }
+    initCustomEvent(...args) {
+        const [type, bubbles, cancelable, detail] = args;
+        isPolyfill.checkArgsLength(args, 1, "CustomEvent", "initCustomEvent");
+        if (EventP.Event_getEtField(this, dispatched))
+            return;
+        this.initEvent(type, bubbles, cancelable);
+        this[state].detail = detail !== null && detail !== void 0 ? detail : null;
+    }
+    /** @internal */ toString() { return "[object CustomEvent]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "CustomEvent"; }
+    /** @internal */ get isPolyfill() { return { symbol: isPolyfill.polyfill, hierarchy: ["CustomEvent", "Event"] }; }
+}
+/** @internal */
+class CustomEventState {
+}
+const CustomEventE = isPolyfill.g["EventTarget"] ? isPolyfill.g["CustomEvent"] : CustomEventP;
+
+exports.CustomEvent = CustomEventE;
+exports.CustomEventP = CustomEventP;

package/dist/cjs/EventP.js

@@ -0,0 +1,173 @@
+'use strict';
+
+var isPolyfill = require('./isPolyfill.js');
+
+var _a, _b, _c, _d, _e;
+/** @internal */ const state = Symbol( /* "EventState" */);
+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(...args) {
+        const [type, eventInitDict] = args;
+        isPolyfill.checkArgsLength(args, 1, new.target.name);
+        this[state] = new EventState();
+        const s = this[state];
+        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 this[state][_isTrusted]; }).bind(this),
+        });
+    }
+    get type() { return this[state].type; }
+    get bubbles() { return this[state].bubbles; }
+    get cancelable() { return this[state].cancelable; }
+    get composed() { return this[state].composed; }
+    get target() { return this[state].target; }
+    get currentTarget() { return this[state].currentTarget; }
+    get eventPhase() { return this[state].eventPhase; }
+    get NONE() { return 0; }
+    get CAPTURING_PHASE() { return 1; }
+    get AT_TARGET() { return 2; }
+    get BUBBLING_PHASE() { return 3; }
+    get srcElement() { return this[state].target; }
+    get cancelBubble() { return this[state].cancelBubble; }
+    set cancelBubble(value) { this[state].cancelBubble = !!value; }
+    get defaultPrevented() { return this[state].defaultPrevented; }
+    get returnValue() { return this[state].returnValue; }
+    set returnValue(value) { if (!value) {
+        this.preventDefault();
+    } }
+    get timeStamp() { return this[state].timeStamp; }
+    composedPath() {
+        let path = !!this.target ? [this.target] : [];
+        if (!!this.currentTarget && this.currentTarget !== this.target)
+            path.push(this.currentTarget);
+        return path;
+    }
+    initEvent(...args) {
+        const [type, bubbles, cancelable] = args;
+        isPolyfill.checkArgsLength(args, 1, "Event", "initEvent");
+        const s = this[state];
+        if (s[_dispatched])
+            return;
+        s.type = "" + type;
+        s.bubbles = !!bubbles;
+        s.cancelable = !!cancelable;
+    }
+    preventDefault() {
+        const s = this[state];
+        if (s[_passive]) {
+            console.warn(`Ignoring 'preventDefault()' call on event of type '${this.type}' from a listener registered as 'passive'.`);
+            return;
+        }
+        if (this.cancelable) {
+            s[_preventDefaultCalled] = true;
+            s.defaultPrevented = true;
+            s.returnValue = false;
+        }
+    }
+    stopImmediatePropagation() {
+        this[state][_stopImmediatePropagationCalled] = true;
+        this.cancelBubble = true;
+    }
+    stopPropagation() {
+        this.cancelBubble = true;
+    }
+    /** @internal */ toString() { return "[object Event]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "Event"; }
+    /** @internal */ get isPolyfill() { return { symbol: isPolyfill.polyfill, hierarchy: ["Event"] }; }
+}
+/** @internal */ const _timeStamp = (new Date()).getTime();
+/** @internal */ const _isTrusted = Symbol();
+/** @internal */ const _passive = Symbol();
+/** @internal */ const _dispatched = Symbol();
+/** @internal */ const _preventDefaultCalled = Symbol();
+/** @internal */ const _stopImmediatePropagationCalled = Symbol();
+/** @internal */
+class EventState {
+    constructor() {
+        this.type = "";
+        this.bubbles = false;
+        this.cancelable = false;
+        this.composed = false;
+        this.target = null;
+        this.currentTarget = null;
+        this.eventPhase = 0 /* NONE */;
+        this.cancelBubble = false;
+        this.defaultPrevented = false;
+        this.returnValue = true;
+        this.timeStamp = (new Date()).getTime() - _timeStamp;
+        this[_a] = false;
+        this[_b] = false;
+        this[_c] = false;
+        this[_d] = false;
+        this[_e] = false;
+    }
+}
+_a = _isTrusted, _b = _passive, _c = _dispatched, _d = _preventDefaultCalled, _e = _stopImmediatePropagationCalled;
+/** @internal */
+function Event_setTrusted(event, isTrusted) {
+    Object.defineProperty(event[state], _isTrusted, {
+        value: isTrusted,
+        writable: true,
+        enumerable: true,
+        configurable: true,
+    });
+}
+const passive = 0;
+const dispatched = 1;
+const preventDefaultCalled = 2;
+const stopImmediatePropagationCalled = 3;
+/** @internal */
+function Event_getEtField(event, field) {
+    const s = event[state];
+    switch (field) {
+        case passive:
+            return s[_passive];
+        case dispatched:
+            return s[_dispatched];
+        case preventDefaultCalled:
+            return s[_preventDefaultCalled];
+        case stopImmediatePropagationCalled:
+            return s[_stopImmediatePropagationCalled];
+    }
+}
+/** @internal */
+function Event_setEtField(event, field, value) {
+    const s = event[state];
+    switch (field) {
+        case passive:
+            s[_passive] = value;
+            break;
+        case dispatched:
+            s[_dispatched] = value;
+            break;
+        case preventDefaultCalled:
+            s[_preventDefaultCalled] = value;
+            break;
+        case stopImmediatePropagationCalled:
+            s[_stopImmediatePropagationCalled] = value;
+            break;
+    }
+}
+/** @internal */
+function createInnerEvent(target, type, eventInitDict, isTrusted = true) {
+    let event = new EventP(type, eventInitDict);
+    event[state].target = target;
+    event[state][_isTrusted] = isTrusted;
+    return event;
+}
+const EventE = isPolyfill.g["EventTarget"] ? isPolyfill.g["Event"] : EventP;
+
+exports.Event = EventE;
+exports.EventP = EventP;
+exports.Event_getEtField = Event_getEtField;
+exports.Event_setEtField = Event_setEtField;
+exports.Event_setTrusted = Event_setTrusted;
+exports.createInnerEvent = createInnerEvent;
+exports.eventState = state;