@runlith/tagma 0.0.0-stage → 0.1.0

package/types/node/v8.d.ts

@@ -0,0 +1,178 @@
+declare module "node:v8" {
+    import { NonSharedBuffer } from "node:buffer";
+    import { Readable } from "node:stream";
+    interface HeapSpaceInfo {
+        space_name: string;
+        space_size: number;
+        space_used_size: number;
+        space_available_size: number;
+        physical_space_size: number;
+    }
+    type DoesZapCodeSpaceFlag = 0 | 1;
+    interface HeapInfo {
+        total_heap_size: number;
+        total_heap_size_executable: number;
+        total_physical_size: number;
+        total_available_size: number;
+        used_heap_size: number;
+        heap_size_limit: number;
+        malloced_memory: number;
+        peak_malloced_memory: number;
+        does_zap_garbage: DoesZapCodeSpaceFlag;
+        number_of_native_contexts: number;
+        number_of_detached_contexts: number;
+        total_global_handles_size: number;
+        used_global_handles_size: number;
+        external_memory: number;
+        total_allocated_bytes: number;
+    }
+    interface HeapCodeStatistics {
+        code_and_metadata_size: number;
+        bytecode_and_metadata_size: number;
+        external_script_source_size: number;
+    }
+    interface HeapSnapshotOptions {
+        exposeInternals?: boolean | undefined;
+        exposeNumericValues?: boolean | undefined;
+    }
+    function cachedDataVersionTag(): number;
+    function getHeapStatistics(): HeapInfo;
+    function getCppHeapStatistics(detailLevel?: "brief" | "detailed"): object;
+    function getHeapSpaceStatistics(): HeapSpaceInfo[];
+    function setFlagsFromString(flags: string): void;
+    function queryObjects(ctor: Function): number | string[];
+    function queryObjects(ctor: Function, options: {
+        format: "count";
+    }): number;
+    function queryObjects(ctor: Function, options: {
+        format: "summary";
+    }): string[];
+    function getHeapSnapshot(options?: HeapSnapshotOptions): Readable;
+    function writeHeapSnapshot(filename?: string, options?: HeapSnapshotOptions): string;
+    function getHeapCodeStatistics(): HeapCodeStatistics;
+    interface SyncCPUProfileHandle {
+        stop(): string;
+        [Symbol.dispose](): void;
+    }
+    interface CPUProfileHandle {
+        stop(): Promise<string>;
+        [Symbol.asyncDispose](): Promise<void>;
+    }
+    interface HeapProfileHandle {
+        stop(): Promise<string>;
+        [Symbol.asyncDispose](): Promise<void>;
+    }
+    function startCpuProfile(): SyncCPUProfileHandle;
+    function isStringOneByteRepresentation(content: string): boolean;
+    class Serializer {
+        writeHeader(): void;
+        writeValue(val: any): boolean;
+        releaseBuffer(): NonSharedBuffer;
+        transferArrayBuffer(id: number, arrayBuffer: ArrayBuffer): void;
+        writeUint32(value: number): void;
+        writeUint64(hi: number, lo: number): void;
+        writeDouble(value: number): void;
+        writeRawBytes(buffer: NodeJS.ArrayBufferView): void;
+    }
+    class DefaultSerializer extends Serializer {
+    }
+    class Deserializer {
+        constructor(data: NodeJS.TypedArray);
+        readHeader(): boolean;
+        readValue(): any;
+        transferArrayBuffer(id: number, arrayBuffer: ArrayBuffer): void;
+        getWireFormatVersion(): number;
+        readUint32(): number;
+        readUint64(): [
+            number,
+            number
+        ];
+        readDouble(): number;
+        readRawBytes(length: number): Buffer;
+    }
+    class DefaultDeserializer extends Deserializer {
+    }
+    function serialize(value: any): NonSharedBuffer;
+    function deserialize(buffer: NodeJS.ArrayBufferView): any;
+    function takeCoverage(): void;
+    function stopCoverage(): void;
+    function setHeapSnapshotNearHeapLimit(limit: number): void;
+    class GCProfiler {
+        start(): void;
+        stop(): GCProfilerResult;
+        [Symbol.dispose](): void;
+    }
+    interface GCProfilerResult {
+        version: number;
+        startTime: number;
+        endTime: number;
+        statistics: Array<{
+            gcType: string;
+            cost: number;
+            beforeGC: {
+                heapStatistics: HeapStatistics;
+                heapSpaceStatistics: HeapSpaceStatistics[];
+            };
+            afterGC: {
+                heapStatistics: HeapStatistics;
+                heapSpaceStatistics: HeapSpaceStatistics[];
+            };
+        }>;
+    }
+    interface HeapStatistics {
+        totalHeapSize: number;
+        totalHeapSizeExecutable: number;
+        totalPhysicalSize: number;
+        totalAvailableSize: number;
+        totalGlobalHandlesSize: number;
+        usedGlobalHandlesSize: number;
+        usedHeapSize: number;
+        heapSizeLimit: number;
+        mallocedMemory: number;
+        externalMemory: number;
+        peakMallocedMemory: number;
+    }
+    interface HeapSpaceStatistics {
+        spaceName: string;
+        spaceSize: number;
+        spaceUsedSize: number;
+        spaceAvailableSize: number;
+        physicalSpaceSize: number;
+    }
+    interface Init {
+        (promise: Promise<unknown>, parent: Promise<unknown>): void;
+    }
+    interface Before {
+        (promise: Promise<unknown>): void;
+    }
+    interface After {
+        (promise: Promise<unknown>): void;
+    }
+    interface Settled {
+        (promise: Promise<unknown>): void;
+    }
+    interface HookCallbacks {
+        init?: Init;
+        before?: Before;
+        after?: After;
+        settled?: Settled;
+    }
+    interface PromiseHooks {
+        onInit: (init: Init) => Function;
+        onSettled: (settled: Settled) => Function;
+        onBefore: (before: Before) => Function;
+        onAfter: (after: After) => Function;
+        createHook: (callbacks: HookCallbacks) => Function;
+    }
+    const promiseHooks: PromiseHooks;
+    type StartupSnapshotCallbackFn = (args: any) => any;
+    namespace startupSnapshot {
+        function addSerializeCallback(callback: StartupSnapshotCallbackFn, data?: any): void;
+        function addDeserializeCallback(callback: StartupSnapshotCallbackFn, data?: any): void;
+        function setDeserializeMainFunction(callback: StartupSnapshotCallbackFn, data?: any): void;
+        function isBuildingSnapshot(): boolean;
+    }
+}
+declare module "v8" {
+    export * from "node:v8";
+}

package/types/node/vm.d.ts

@@ -0,0 +1,130 @@
+declare module "node:vm" {
+    import { NonSharedBuffer } from "node:buffer";
+    import { ImportAttributes, ImportPhase } from "node:module";
+    interface Context extends NodeJS.Dict<any> {
+    }
+    interface BaseOptions {
+        filename?: string | undefined;
+        lineOffset?: number | undefined;
+        columnOffset?: number | undefined;
+    }
+    type DynamicModuleLoader<T> = (specifier: string, referrer: T, importAttributes: ImportAttributes, phase: ImportPhase) => Module | Promise<Module>;
+    interface ScriptOptions extends BaseOptions {
+        cachedData?: NodeJS.ArrayBufferView | undefined;
+        produceCachedData?: boolean | undefined;
+        importModuleDynamically?: DynamicModuleLoader<Script> | typeof constants.USE_MAIN_CONTEXT_DEFAULT_LOADER | undefined;
+    }
+    interface RunningScriptOptions extends BaseOptions {
+        displayErrors?: boolean | undefined;
+        timeout?: number | undefined;
+        breakOnSigint?: boolean | undefined;
+    }
+    interface RunningScriptInNewContextOptions extends RunningScriptOptions, Pick<CreateContextOptions, "microtaskMode"> {
+        contextName?: CreateContextOptions["name"] | undefined;
+        contextOrigin?: CreateContextOptions["origin"] | undefined;
+        contextCodeGeneration?: CreateContextOptions["codeGeneration"] | undefined;
+    }
+    interface RunningCodeOptions extends RunningScriptOptions, Pick<ScriptOptions, "cachedData"> {
+        importModuleDynamically?: DynamicModuleLoader<Script> | typeof constants.USE_MAIN_CONTEXT_DEFAULT_LOADER | undefined;
+    }
+    interface RunningCodeInNewContextOptions extends RunningScriptInNewContextOptions, Pick<ScriptOptions, "cachedData"> {
+        importModuleDynamically?: DynamicModuleLoader<Script> | typeof constants.USE_MAIN_CONTEXT_DEFAULT_LOADER | undefined;
+    }
+    interface CompileFunctionOptions extends BaseOptions, Pick<ScriptOptions, "cachedData" | "produceCachedData"> {
+        parsingContext?: Context | undefined;
+        contextExtensions?: Object[] | undefined;
+        importModuleDynamically?: DynamicModuleLoader<ReturnType<typeof compileFunction>> | typeof constants.USE_MAIN_CONTEXT_DEFAULT_LOADER | undefined;
+    }
+    interface CreateContextOptions {
+        name?: string | undefined;
+        origin?: string | undefined;
+        codeGeneration?: {
+            strings?: boolean | undefined;
+            wasm?: boolean | undefined;
+        } | undefined;
+        microtaskMode?: "afterEvaluate" | undefined;
+        importModuleDynamically?: DynamicModuleLoader<Context> | typeof constants.USE_MAIN_CONTEXT_DEFAULT_LOADER | undefined;
+    }
+    type MeasureMemoryMode = "summary" | "detailed";
+    interface MeasureMemoryOptions {
+        mode?: MeasureMemoryMode | undefined;
+        execution?: "default" | "eager" | undefined;
+    }
+    interface MemoryMeasurement {
+        total: {
+            jsMemoryEstimate: number;
+            jsMemoryRange: [
+                number,
+                number
+            ];
+        };
+    }
+    class Script {
+        constructor(code: string, options?: ScriptOptions | string);
+        runInContext(contextifiedObject: Context, options?: RunningScriptOptions): any;
+        runInNewContext(contextObject?: Context | typeof constants.DONT_CONTEXTIFY, options?: RunningScriptInNewContextOptions): any;
+        runInThisContext(options?: RunningScriptOptions): any;
+        createCachedData(): NonSharedBuffer;
+        cachedDataProduced?: boolean;
+        cachedDataRejected?: boolean;
+        cachedData?: NonSharedBuffer;
+        sourceMapURL: string | undefined;
+    }
+    function createContext(contextObject?: Context | typeof constants.DONT_CONTEXTIFY, options?: CreateContextOptions): Context;
+    function isContext(sandbox: Context): boolean;
+    function runInContext(code: string, contextifiedObject: Context, options?: RunningCodeOptions | string): any;
+    function runInNewContext(code: string, contextObject?: Context | typeof constants.DONT_CONTEXTIFY, options?: RunningCodeInNewContextOptions | string): any;
+    function runInThisContext(code: string, options?: RunningCodeOptions | string): any;
+    function compileFunction(code: string, params?: readonly string[], options?: CompileFunctionOptions): Function & Pick<Script, "cachedData" | "cachedDataProduced" | "cachedDataRejected">;
+    function measureMemory(options?: MeasureMemoryOptions): Promise<MemoryMeasurement>;
+    interface ModuleEvaluateOptions extends Pick<RunningScriptOptions, "breakOnSigint" | "timeout"> {
+    }
+    type ModuleLinker = (specifier: string, referencingModule: Module, extra: {
+        attributes: ImportAttributes;
+    }) => Module | Promise<Module>;
+    type ModuleStatus = "unlinked" | "linking" | "linked" | "evaluating" | "evaluated" | "errored";
+    class Module {
+        error: any;
+        identifier: string;
+        context: Context;
+        namespace: Object;
+        status: ModuleStatus;
+        evaluate(options?: ModuleEvaluateOptions): Promise<void>;
+        link(linker: ModuleLinker): Promise<void>;
+    }
+    interface SourceTextModuleOptions extends Pick<ScriptOptions, "cachedData" | "columnOffset" | "lineOffset"> {
+        identifier?: string | undefined;
+        context?: Context | undefined;
+        initializeImportMeta?: ((meta: ImportMeta, module: SourceTextModule) => void) | undefined;
+        importModuleDynamically?: DynamicModuleLoader<SourceTextModule> | undefined;
+    }
+    interface ModuleRequest {
+        specifier: string;
+        attributes: ImportAttributes;
+        phase: ImportPhase;
+    }
+    class SourceTextModule extends Module {
+        constructor(code: string, options?: SourceTextModuleOptions);
+        readonly dependencySpecifiers: readonly string[];
+        hasAsyncGraph(): boolean;
+        hasTopLevelAwait(): boolean;
+        instantiate(): void;
+        linkRequests(modules: readonly Module[]): void;
+        readonly moduleRequests: readonly ModuleRequest[];
+    }
+    interface SyntheticModuleOptions {
+        identifier?: string | undefined;
+        context?: Context | undefined;
+    }
+    class SyntheticModule extends Module {
+        constructor(exportNames: string[], evaluateCallback: (this: SyntheticModule) => void, options?: SyntheticModuleOptions);
+        setExport(name: string, value: any): void;
+    }
+    namespace constants {
+        const USE_MAIN_CONTEXT_DEFAULT_LOADER: number;
+        const DONT_CONTEXTIFY: number;
+    }
+}
+declare module "vm" {
+    export * from "node:vm";
+}

package/types/node/wasi.d.ts

@@ -0,0 +1,26 @@
+declare module "node:wasi" {
+    interface WASIOptions {
+        args?: readonly string[] | undefined;
+        env?: object | undefined;
+        preopens?: NodeJS.Dict<string> | undefined;
+        returnOnExit?: boolean | undefined;
+        stdin?: number | undefined;
+        stdout?: number | undefined;
+        stderr?: number | undefined;
+        version: "unstable" | "preview1";
+    }
+    interface FinalizeBindingsOptions {
+        memory?: object | undefined;
+    }
+    class WASI {
+        constructor(options?: WASIOptions);
+        getImportObject(): object;
+        start(instance: object): number;
+        initialize(instance: object): void;
+        finalizeBindings(instance: object, options?: FinalizeBindingsOptions): void;
+        readonly wasiImport: NodeJS.Dict<any>;
+    }
+}
+declare module "wasi" {
+    export * from "node:wasi";
+}

package/types/node/web-globals/abortcontroller.d.ts

@@ -0,0 +1,47 @@
+export {};
+import { InternalEventTargetEventProperties } from "node:events";
+type _AbortController = typeof globalThis extends {
+    onmessage: any;
+} ? {} : AbortController;
+interface AbortController {
+    readonly signal: AbortSignal;
+    abort(reason?: any): void;
+}
+interface AbortSignalEventMap {
+    "abort": Event;
+}
+type _AbortSignal = typeof globalThis extends {
+    onmessage: any;
+} ? {} : AbortSignal;
+interface AbortSignal extends EventTarget, InternalEventTargetEventProperties<AbortSignalEventMap> {
+    readonly aborted: boolean;
+    readonly reason: any;
+    throwIfAborted(): void;
+    addEventListener<K extends keyof AbortSignalEventMap>(type: K, listener: (ev: AbortSignalEventMap[K]) => void, options?: AddEventListenerOptions | boolean): void;
+    addEventListener(type: string, listener: EventListener | EventListenerObject, options?: AddEventListenerOptions | boolean): void;
+    removeEventListener<K extends keyof AbortSignalEventMap>(type: K, listener: (ev: AbortSignalEventMap[K]) => void, options?: EventListenerOptions | boolean): void;
+    removeEventListener(type: string, listener: EventListener | EventListenerObject, options?: EventListenerOptions | boolean): void;
+}
+declare global {
+    interface AbortController extends _AbortController {
+    }
+    var AbortController: typeof globalThis extends {
+        onmessage: any;
+        AbortController: infer T;
+    } ? T : {
+        prototype: AbortController;
+        new (): AbortController;
+    };
+    interface AbortSignal extends _AbortSignal {
+    }
+    var AbortSignal: typeof globalThis extends {
+        onmessage: any;
+        AbortSignal: infer T;
+    } ? T : {
+        prototype: AbortSignal;
+        new (): AbortSignal;
+        abort(reason?: any): AbortSignal;
+        any(signals: AbortSignal[]): AbortSignal;
+        timeout(milliseconds: number): AbortSignal;
+    };
+}

package/types/node/web-globals/blob.d.ts

@@ -0,0 +1,34 @@
+export {};
+import * as buffer from "node:buffer";
+type _Blob = typeof globalThis extends {
+    onmessage: any;
+} ? {} : buffer.Blob;
+type _BlobPropertyBag = typeof globalThis extends {
+    onmessage: any;
+} ? {} : buffer.BlobPropertyBag;
+type _File = typeof globalThis extends {
+    onmessage: any;
+} ? {} : buffer.File;
+type _FilePropertyBag = typeof globalThis extends {
+    onmessage: any;
+} ? {} : buffer.FilePropertyBag;
+declare global {
+    interface Blob extends _Blob {
+    }
+    var Blob: typeof globalThis extends {
+        onmessage: any;
+        Blob: infer T;
+    } ? T : typeof buffer.Blob;
+    interface BlobPropertyBag extends _BlobPropertyBag {
+    }
+    interface File extends _File {
+    }
+    var File: typeof globalThis extends {
+        onmessage: any;
+        File: infer T;
+    } ? T : typeof buffer.File;
+    interface FilePropertyBag extends _FilePropertyBag {
+    }
+    function atob(data: string): string;
+    function btoa(data: string): string;
+}

package/types/node/web-globals/console.d.ts

@@ -0,0 +1,7 @@
+export {};
+import * as console from "node:console";
+declare global {
+    interface Console extends console.Console {
+    }
+    var console: Console;
+}

package/types/node/web-globals/crypto.d.ts

@@ -0,0 +1,46 @@
+export {};
+import { webcrypto } from "crypto";
+type _Crypto = typeof globalThis extends {
+    onmessage: any;
+} ? {} : webcrypto.Crypto;
+type _CryptoKey = typeof globalThis extends {
+    onmessage: any;
+} ? {} : webcrypto.CryptoKey;
+type _SubtleCrypto = typeof globalThis extends {
+    onmessage: any;
+} ? {} : webcrypto.SubtleCrypto;
+declare global {
+    interface Crypto extends _Crypto {
+    }
+    var Crypto: typeof globalThis extends {
+        onmessage: any;
+        Crypto: infer T;
+    } ? T : {
+        prototype: webcrypto.Crypto;
+        new (): webcrypto.Crypto;
+    };
+    interface CryptoKey extends _CryptoKey {
+    }
+    var CryptoKey: typeof globalThis extends {
+        onmessage: any;
+        CryptoKey: infer T;
+    } ? T : {
+        prototype: webcrypto.CryptoKey;
+        new (): webcrypto.CryptoKey;
+    };
+    interface SubtleCrypto extends _SubtleCrypto {
+    }
+    var SubtleCrypto: typeof globalThis extends {
+        onmessage: any;
+        SubtleCrypto: infer T;
+    } ? T : {
+        prototype: webcrypto.SubtleCrypto;
+        new (): webcrypto.SubtleCrypto;
+        supports(operation: string, algorithm: webcrypto.AlgorithmIdentifier, length?: number): boolean;
+        supports(operation: string, algorithm: webcrypto.AlgorithmIdentifier, additionalAlgorithm: webcrypto.AlgorithmIdentifier): boolean;
+    };
+    var crypto: typeof globalThis extends {
+        onmessage: any;
+        crypto: infer T;
+    } ? T : webcrypto.Crypto;
+}

package/types/node/web-globals/domexception.d.ts

@@ -0,0 +1,74 @@
+export {};
+type _DOMException = typeof globalThis extends {
+    onmessage: any;
+} ? {} : DOMException;
+interface DOMException extends Error {
+    readonly code: number;
+    readonly message: string;
+    readonly name: string;
+    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 global {
+    interface DOMException extends _DOMException {
+    }
+    var DOMException: typeof globalThis extends {
+        onmessage: any;
+        DOMException: infer T;
+    } ? T : {
+        prototype: DOMException;
+        new (message?: string, name?: string): DOMException;
+        new (message?: string, options?: {
+            name?: string;
+            cause?: unknown;
+        }): 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;
+    };
+}

package/types/node/web-globals/encoding.d.ts

@@ -0,0 +1,16 @@
+export {};
+import * as util from "node:util";
+declare global {
+    interface TextDecoder extends util.TextDecoder {
+    }
+    var TextDecoder: typeof globalThis extends {
+        onmessage: any;
+        TextDecoder: infer T;
+    } ? T : typeof util.TextDecoder;
+    interface TextEncoder extends util.TextEncoder {
+    }
+    var TextEncoder: typeof globalThis extends {
+        onmessage: any;
+        TextEncoder: infer T;
+    } ? T : typeof util.TextEncoder;
+}

package/types/node/web-globals/events.d.ts

@@ -0,0 +1,111 @@
+export {};
+type _AddEventListenerOptions = typeof globalThis extends {
+    onmessage: any;
+} ? {} : AddEventListenerOptions;
+interface AddEventListenerOptions extends EventListenerOptions {
+    once?: boolean;
+    passive?: boolean;
+    signal?: AbortSignal;
+}
+type _CustomEvent<T = any> = typeof globalThis extends {
+    onmessage: any;
+} ? {} : CustomEvent<T>;
+interface CustomEvent<T = any> extends Event {
+    readonly detail: T;
+}
+interface CustomEventInit<T = any> extends EventInit {
+    detail?: T;
+}
+type _Event = typeof globalThis extends {
+    onmessage: any;
+} ? {} : Event;
+interface Event {
+    readonly bubbles: boolean;
+    cancelBubble: boolean;
+    readonly cancelable: boolean;
+    readonly composed: boolean;
+    readonly currentTarget: EventTarget | null;
+    readonly defaultPrevented: boolean;
+    readonly eventPhase: 0 | 2;
+    readonly isTrusted: boolean;
+    returnValue: boolean;
+    readonly srcElement: EventTarget | null;
+    readonly target: EventTarget | null;
+    readonly timeStamp: number;
+    readonly type: string;
+    composedPath(): [
+        EventTarget?
+    ];
+    initEvent(type: string, bubbles?: boolean, cancelable?: boolean): void;
+    preventDefault(): void;
+    stopImmediatePropagation(): void;
+    stopPropagation(): void;
+}
+interface EventInit {
+    bubbles?: boolean;
+    cancelable?: boolean;
+    composed?: boolean;
+}
+type _EventListener = typeof globalThis extends {
+    onmessage: any;
+} ? {} : EventListener;
+interface EventListener {
+    (evt: Event): void;
+}
+type _EventListenerObject = typeof globalThis extends {
+    onmessage: any;
+} ? {} : EventListenerObject;
+interface EventListenerObject {
+    handleEvent(object: Event): void;
+}
+type _EventListenerOptions = typeof globalThis extends {
+    onmessage: any;
+} ? {} : EventListenerOptions;
+interface EventListenerOptions {
+    capture?: boolean;
+}
+type _EventTarget = typeof globalThis extends {
+    onmessage: any;
+} ? {} : EventTarget;
+interface EventTarget {
+    addEventListener(type: string, listener: EventListener | EventListenerObject, options?: AddEventListenerOptions | boolean): void;
+    dispatchEvent(event: Event): boolean;
+    removeEventListener(type: string, listener: EventListener | EventListenerObject, options?: EventListenerOptions | boolean): void;
+}
+declare global {
+    interface AddEventListenerOptions extends _AddEventListenerOptions {
+    }
+    interface CustomEvent<T = any> extends _CustomEvent<T> {
+    }
+    var CustomEvent: typeof globalThis extends {
+        onmessage: any;
+        CustomEvent: infer T;
+    } ? T : {
+        prototype: CustomEvent;
+        new <T>(type: string, eventInitDict?: CustomEventInit<T>): CustomEvent<T>;
+    };
+    interface Event extends _Event {
+    }
+    var Event: typeof globalThis extends {
+        onmessage: any;
+        Event: infer T;
+    } ? T : {
+        prototype: Event;
+        new (type: string, eventInitDict?: EventInit): Event;
+    };
+    interface EventListener extends _EventListener {
+    }
+    interface EventListenerObject extends _EventListenerObject {
+    }
+    interface EventListenerOptions extends _EventListenerOptions {
+    }
+    interface EventTarget extends _EventTarget {
+    }
+    var EventTarget: typeof globalThis extends {
+        onmessage: any;
+        EventTarget: infer T;
+    } ? T : {
+        prototype: EventTarget;
+        new (): EventTarget;
+    };
+}