omegon 0.8.3 → 0.9.0

package/node_modules/@types/node/wasi.d.ts

@@ -67,9 +67,9 @@
  * wat2wasm demo.wat
  * ```
  * @experimental
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/wasi.js)
+ * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/wasi.js)
  */
-declare module "node:wasi" {
+declare module "wasi" {
     interface WASIOptions {
         /**
          * An array of strings that the WebAssembly application will
@@ -121,12 +121,6 @@ declare module "node:wasi" {
          */
         version: "unstable" | "preview1";
     }
-    interface FinalizeBindingsOptions {
-        /**
-         * @default instance.exports.memory
-         */
-        memory?: object | undefined;
-    }
     /**
      * The `WASI` class provides the WASI system call API and additional convenience
      * methods for working with WASI-based applications. Each `WASI` instance
@@ -173,21 +167,6 @@ declare module "node:wasi" {
          * @since v14.6.0, v12.19.0
          */
         initialize(instance: object): void; // TODO: avoid DOM dependency until WASM moved to own lib.
-        /**
-         * Set up WASI host bindings to `instance` without calling `initialize()`
-         * or `start()`. This method is useful when the WASI module is instantiated in
-         * child threads for sharing the memory across threads.
-         *
-         * `finalizeBindings()` requires that either `instance` exports a
-         * [`WebAssembly.Memory`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory) named `memory` or user specify a
-         * [`WebAssembly.Memory`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory) object in `options.memory`. If the `memory` is invalid
-         * an exception is thrown.
-         *
-         * `start()` and `initialize()` will call `finalizeBindings()` internally.
-         * If `finalizeBindings()` is called more than once, an exception is thrown.
-         * @since v24.4.0
-         */
-        finalizeBindings(instance: object, options?: FinalizeBindingsOptions): void;
         /**
          * `wasiImport` is an object that implements the WASI system call API. This object
          * should be passed as the `wasi_snapshot_preview1` import during the instantiation
@@ -197,6 +176,6 @@ declare module "node:wasi" {
         readonly wasiImport: NodeJS.Dict<any>; // TODO: Narrow to DOM types
     }
 }
-declare module "wasi" {
-    export * from "node:wasi";
+declare module "node:wasi" {
+    export * from "wasi";
 }

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

@@ -1,42 +1,17 @@
 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> {
+interface AbortSignal extends EventTarget {
     readonly aborted: boolean;
+    onabort: ((this: AbortSignal, ev: Event) => any) | null;
     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 {

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

@@ -1,6 +1,5 @@
 export {};
 
-type _AddEventListenerOptions = typeof globalThis extends { onmessage: any } ? {} : AddEventListenerOptions;
 interface AddEventListenerOptions extends EventListenerOptions {
     once?: boolean;
     passive?: boolean;
@@ -44,12 +43,10 @@ interface EventInit {
     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;
 }
@@ -75,8 +72,6 @@ interface EventTarget {
 }
 
 declare global {
-    interface AddEventListenerOptions extends _AddEventListenerOptions {}
-
     interface CustomEvent<T = any> extends _CustomEvent<T> {}
     var CustomEvent: typeof globalThis extends { onmessage: any; CustomEvent: infer T } ? T
         : {
@@ -91,10 +86,6 @@ declare global {
             new(type: string, eventInitDict?: EventInit): Event;
         };
 
-    interface EventListener extends _EventListener {}
-
-    interface EventListenerObject extends _EventListenerObject {}
-
     interface EventListenerOptions extends _EventListenerOptions {}
 
     interface EventTarget extends _EventTarget {}

package/node_modules/@types/node/web-globals/fetch.d.ts

@@ -2,10 +2,6 @@ export {};
 
 import * as undici from "undici-types";
 
-type _CloseEvent = typeof globalThis extends { onmessage: any } ? {} : undici.CloseEvent;
-type _CloseEventInit = typeof globalThis extends { onmessage: any } ? {} : undici.CloseEventInit;
-type _ErrorEvent = typeof globalThis extends { onmessage: any } ? {} : undici.ErrorEvent;
-type _ErrorEventInit = typeof globalThis extends { onmessage: any } ? {} : undici.ErrorEventInit;
 type _EventSource = typeof globalThis extends { onmessage: any } ? {} : undici.EventSource;
 type _EventSourceInit = typeof globalThis extends { onmessage: any } ? {} : undici.EventSourceInit;
 type _FormData = typeof globalThis extends { onmessage: any } ? {} : undici.FormData;
@@ -25,16 +21,6 @@ declare global {
         init?: RequestInit,
     ): Promise<Response>;
 
-    interface CloseEvent extends _CloseEvent {}
-    var CloseEvent: typeof globalThis extends { onmessage: any; CloseEvent: infer T } ? T : typeof undici.CloseEvent;
-
-    interface CloseEventInit extends _CloseEventInit {}
-
-    interface ErrorEvent extends _ErrorEvent {}
-    var ErrorEvent: typeof globalThis extends { onmessage: any; ErrorEvent: infer T } ? T : typeof undici.ErrorEvent;
-
-    interface ErrorEventInit extends _ErrorEventInit {}
-
     interface EventSource extends _EventSource {}
     var EventSource: typeof globalThis extends { onmessage: any; EventSource: infer T } ? T : typeof undici.EventSource;
 

package/node_modules/@types/node/web-globals/navigator.d.ts

@@ -1,14 +1,11 @@
 export {};
 
-import { LockManager } from "worker_threads";
-
 // lib.webworker has `WorkerNavigator` rather than `Navigator`, so conditionals use `onabort` instead of `onmessage`
 type _Navigator = typeof globalThis extends { onabort: any } ? {} : Navigator;
 interface Navigator {
     readonly hardwareConcurrency: number;
     readonly language: string;
     readonly languages: readonly string[];
-    readonly locks: LockManager;
     readonly platform: string;
     readonly userAgent: string;
 }