fetch-xhr-shim 0.0.1-beta

package/dist/dev.d.ts

@@ -0,0 +1,145 @@
+declare function isArrayBuffer(value: unknown): value is ArrayBuffer;
+
+declare function EventTarget_dispatchEvent(target: EventTarget, event: Event): boolean;
+declare function attachFn<T extends EventTarget & Record<`on${K}`, ((ev: any) => any) | null>, K extends string>(target: T, handlers: Record<`on${K}`, (ev: any) => void>): (type: K) => void;
+declare function executeFn(target: EventTarget, cb: Function | null, ev: Event): void;
+declare function isEventTarget(value: unknown): value is EventTarget;
+
+declare class EventP implements Event {
+    static get NONE(): 0;
+    static get CAPTURING_PHASE(): 1;
+    static get AT_TARGET(): 2;
+    static get BUBBLING_PHASE(): 3;
+    constructor(type: string, eventInitDict?: EventInit);
+    get NONE(): 0;
+    get CAPTURING_PHASE(): 1;
+    get AT_TARGET(): 2;
+    get BUBBLING_PHASE(): 3;
+    get bubbles(): boolean;
+    get cancelBubble(): boolean;
+    set cancelBubble(value: boolean);
+    get cancelable(): boolean;
+    get composed(): boolean;
+    get currentTarget(): EventTarget | null;
+    get defaultPrevented(): boolean;
+    get eventPhase(): number;
+    readonly isTrusted: boolean;
+    get returnValue(): boolean;
+    set returnValue(value: boolean);
+    get srcElement(): EventTarget | null;
+    get target(): EventTarget | null;
+    get timeStamp(): DOMHighResTimeStamp;
+    get type(): string;
+    composedPath(): EventTarget[];
+    initEvent(type: string, bubbles?: boolean, cancelable?: boolean): void;
+    preventDefault(): void;
+    stopImmediatePropagation(): void;
+    stopPropagation(): void;
+}
+declare function Event_setTrusted(event: Event, isTrusted: boolean): void;
+
+declare class ProgressEventP extends EventP implements ProgressEvent {
+    constructor(type: string, eventInitDict?: ProgressEventInit);
+    get lengthComputable(): boolean;
+    get loaded(): number;
+    get total(): number;
+}
+declare function emitProgressEvent(target: EventTarget, type: string, loaded?: number, total?: number): void;
+
+declare function createAbortSignal(): AbortSignal;
+declare function AbortSignal_abort(signal: AbortSignal, notify?: boolean, reason?: any): void;
+
+declare const encode: (input?: string) => Uint8Array<ArrayBuffer>;
+declare const decode: (input?: AllowSharedBufferSource, options?: TextDecodeOptions) => string;
+declare function isBlob(value: unknown, strict?: boolean): value is Blob;
+
+declare function Uint8Array_toBase64(input: Uint8Array<ArrayBuffer>): string;
+
+declare function isURLSearchParams(value: unknown): value is URLSearchParams;
+
+declare function isFormData(value: unknown): value is FormData;
+declare function FormData_toBlob(formData: FormData, externalBoundary?: string): Blob;
+declare function extractBoundary(contentType: string | null): string | undefined;
+declare function createFormDataFromBinaryText(text: string, boundary?: string): FormData;
+
+declare function isHeaders(value: unknown): value is Headers;
+declare function normalizeName(name: string, throwError?: () => never): string;
+declare function normalizeValue(value: string): string;
+declare function parseHeaders(rawHeaders: string): Headers;
+declare function createHeaders(headers?: HeadersInit): Headers;
+
+declare class Payload {
+    constructor(body?: XMLHttpRequestBodyInit | null, contentType?: string);
+    promise: Promise<string | ArrayBuffer>;
+    get type(): string;
+    set type(value: string);
+    get size(): number;
+    private _type;
+    private length?;
+    private calcLength?;
+    text(): Promise<string>;
+    arrayBuffer(): Promise<ArrayBuffer>;
+}
+declare class BodyImpl implements Body {
+    get bodyUsed(): boolean;
+    get body(): ReadableStream<Uint8Array<ArrayBuffer>> | null;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    blob(): Promise<Blob>;
+    bytes(): Promise<Uint8Array<ArrayBuffer>>;
+    formData(): Promise<FormData>;
+    json(): Promise<any>;
+    text(): Promise<string>;
+}
+declare function initBody(instance: Body, body?: BodyInit | null | undefined): void;
+
+declare function normalizeMethod(method: string): string;
+
+declare const _Symbol: {
+    iterator: typeof Symbol.iterator;
+    toStringTag: typeof Symbol.toStringTag;
+};
+declare class DOMExceptionP extends Error {
+    constructor(message?: string, name?: string);
+}
+declare const DOMExceptionE: {
+    new (message?: string, name?: string): DOMException;
+    prototype: DOMException;
+    readonly INDEX_SIZE_ERR: 1;
+    readonly DOMSTRING_SIZE_ERR: 2;
+    readonly HIERARCHY_REQUEST_ERR: 3;
+    readonly WRONG_DOCUMENT_ERR: 4;
+    readonly INVALID_CHARACTER_ERR: 5;
+    readonly NO_DATA_ALLOWED_ERR: 6;
+    readonly NO_MODIFICATION_ALLOWED_ERR: 7;
+    readonly NOT_FOUND_ERR: 8;
+    readonly NOT_SUPPORTED_ERR: 9;
+    readonly INUSE_ATTRIBUTE_ERR: 10;
+    readonly INVALID_STATE_ERR: 11;
+    readonly SYNTAX_ERR: 12;
+    readonly INVALID_MODIFICATION_ERR: 13;
+    readonly NAMESPACE_ERR: 14;
+    readonly INVALID_ACCESS_ERR: 15;
+    readonly VALIDATION_ERR: 16;
+    readonly TYPE_MISMATCH_ERR: 17;
+    readonly SECURITY_ERR: 18;
+    readonly NETWORK_ERR: 19;
+    readonly ABORT_ERR: 20;
+    readonly URL_MISMATCH_ERR: 21;
+    readonly QUOTA_EXCEEDED_ERR: 22;
+    readonly TIMEOUT_ERR: 23;
+    readonly INVALID_NODE_TYPE_ERR: 24;
+    readonly DATA_CLONE_ERR: 25;
+};
+
+declare function className(object: {
+    __MPHTTPX__: {
+        chain: string[];
+    };
+}): string;
+declare function setState<T extends object, K extends keyof T>(target: T, name: K, value: T[K]): void;
+declare function isObjectType<T>(name: string, value: unknown): value is T;
+declare function isPolyfillType<T>(name: string, value: unknown, strict?: boolean): value is T;
+declare function isSequence(value: unknown): value is any[];
+declare function checkArgsLength(actual: number, expect: number, className: string, funcName?: string): void;
+
+export { AbortSignal_abort, BodyImpl, DOMExceptionE as DOMException, DOMExceptionP, EventTarget_dispatchEvent, Event_setTrusted, FormData_toBlob, Payload, ProgressEventP, Uint8Array_toBase64, _Symbol, attachFn, checkArgsLength, className, createAbortSignal, createFormDataFromBinaryText, createHeaders, decode, emitProgressEvent, encode, executeFn, extractBoundary, initBody, isArrayBuffer, isBlob, isEventTarget, isFormData, isHeaders, isObjectType, isPolyfillType, isSequence, isURLSearchParams, normalizeMethod, normalizeName, normalizeValue, parseHeaders, setState };

package/dist/esm/dev.js

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

package/dist/esm/encoding/TextDecoderP.js

@@ -0,0 +1,175 @@
+import { setState, _Symbol, isObjectType } from '../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.`);
+        }
+        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 [_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 (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;
+
+export { TextDecoderE as TextDecoder, TextDecoderP, isArrayBuffer };

package/dist/esm/encoding/TextEncoderP.js

@@ -0,0 +1,118 @@
+import { checkArgsLength, isObjectType, _Symbol } from '../utils.js';
+
+class TextEncoderP {
+    get encoding() { return "utf-8"; }
+    encode(input = "") {
+        return encodeText(typeof input === "string" ? input : ("" + input)).encoded;
+    }
+    encodeInto(source, destination) {
+        checkArgsLength(arguments.length, 2, "TextEncoder", "encodeInto");
+        if (!(Uint8Array.prototype.isPrototypeOf(destination) || 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 [_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;
+
+export { TextEncoderE as TextEncoder, TextEncoderP };

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

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

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

@@ -0,0 +1,112 @@
+import { checkArgsLength, isSequence, setState, _Symbol, DOMException as DOMExceptionE } from '../utils.js';
+import { EventP, Event_setTrusted } from './EventP.js';
+import { EventTargetP, isEventTarget, EventTarget_dispatchEvent, attachFn, executeFn } from './EventTargetP.js';
+
+class AbortSignalP extends EventTargetP {
+    static abort(reason) {
+        let signal = createAbortSignal();
+        AbortSignal_abort(signal, false, reason);
+        return signal;
+    }
+    static any(signals) {
+        checkArgsLength(arguments.length, 1, "AbortSignal", "any");
+        if (!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(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) {
+        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 DOMExceptionE("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();
+        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 [_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 = attachFn(target, getHandlers(target));
+    }
+}
+function getHandlers(t) {
+    return {
+        onabort: (ev) => { executeFn(t, t.onabort, ev); },
+    };
+}
+function state(target) {
+    return target.__AbortSignal__;
+}
+function createAbortSignal() {
+    let signal = Object.create(AbortSignalP.prototype);
+    setState(signal, "__EventTarget__", { executors: [] });
+    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 DOMExceptionE("signal is aborted without reason", "AbortError");
+        if (notify) {
+            let event = new EventP("abort");
+            event.__Event__.target = signal;
+            Event_setTrusted(event, true);
+            EventTarget_dispatchEvent(signal, event);
+        }
+    }
+}
+const AbortSignalE = (typeof AbortSignal !== "undefined" && AbortSignal) || AbortSignalP;
+
+export { AbortSignalE as AbortSignal, AbortSignalP, AbortSignal_abort, createAbortSignal };

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

@@ -0,0 +1,32 @@
+import { EventP } from './EventP.js';
+import { checkArgsLength, setState, _Symbol } from '../utils.js';
+
+class CustomEventP extends EventP {
+    constructor(type, eventInitDict) {
+        var _a;
+        checkArgsLength(arguments.length, 1, "CustomEvent");
+        super(type, eventInitDict);
+        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) {
+        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 [_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;
+
+export { CustomEventE as CustomEvent, CustomEventP };