m06_task3.js 1.0.0

package/package/node_modules/@types/node/ts4.8/vm.d.ts

@@ -0,0 +1,509 @@
+/**
+ * The `vm` module enables compiling and running code within V8 Virtual
+ * Machine contexts.
+ *
+ * **The `vm` module is not a security**
+ * **mechanism. Do not use it to run untrusted code.**
+ *
+ * JavaScript code can be compiled and run immediately or
+ * compiled, saved, and run later.
+ *
+ * A common use case is to run the code in a different V8 Context. This means
+ * invoked code has a different global object than the invoking code.
+ *
+ * One can provide the context by `contextifying` an
+ * object. The invoked code treats any property in the context like a
+ * global variable. Any changes to global variables caused by the invoked
+ * code are reflected in the context object.
+ *
+ * ```js
+ * const vm = require('vm');
+ *
+ * const x = 1;
+ *
+ * const context = { x: 2 };
+ * vm.createContext(context); // Contextify the object.
+ *
+ * const code = 'x += 40; var y = 17;';
+ * // `x` and `y` are global variables in the context.
+ * // Initially, x has the value 2 because that is the value of context.x.
+ * vm.runInContext(code, context);
+ *
+ * console.log(context.x); // 42
+ * console.log(context.y); // 17
+ *
+ * console.log(x); // 1; y is not defined.
+ * ```
+ * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/vm.js)
+ */
+declare module 'vm' {
+    interface Context extends NodeJS.Dict<any> {}
+    interface BaseOptions {
+        /**
+         * Specifies the filename used in stack traces produced by this script.
+         * Default: `''`.
+         */
+        filename?: string | undefined;
+        /**
+         * Specifies the line number offset that is displayed in stack traces produced by this script.
+         * Default: `0`.
+         */
+        lineOffset?: number | undefined;
+        /**
+         * Specifies the column number offset that is displayed in stack traces produced by this script.
+         * @default 0
+         */
+        columnOffset?: number | undefined;
+    }
+    interface ScriptOptions extends BaseOptions {
+        displayErrors?: boolean | undefined;
+        timeout?: number | undefined;
+        cachedData?: Buffer | undefined;
+        /** @deprecated in favor of `script.createCachedData()` */
+        produceCachedData?: boolean | undefined;
+    }
+    interface RunningScriptOptions extends BaseOptions {
+        /**
+         * When `true`, if an `Error` occurs while compiling the `code`, the line of code causing the error is attached to the stack trace.
+         * Default: `true`.
+         */
+        displayErrors?: boolean | undefined;
+        /**
+         * Specifies the number of milliseconds to execute code before terminating execution.
+         * If execution is terminated, an `Error` will be thrown. This value must be a strictly positive integer.
+         */
+        timeout?: number | undefined;
+        /**
+         * If `true`, the execution will be terminated when `SIGINT` (Ctrl+C) is received.
+         * Existing handlers for the event that have been attached via `process.on('SIGINT')` will be disabled during script execution, but will continue to work after that.
+         * If execution is terminated, an `Error` will be thrown.
+         * Default: `false`.
+         */
+        breakOnSigint?: boolean | undefined;
+        /**
+         * If set to `afterEvaluate`, microtasks will be run immediately after the script has run.
+         */
+        microtaskMode?: 'afterEvaluate' | undefined;
+    }
+    interface CompileFunctionOptions extends BaseOptions {
+        /**
+         * Provides an optional data with V8's code cache data for the supplied source.
+         */
+        cachedData?: Buffer | undefined;
+        /**
+         * Specifies whether to produce new cache data.
+         * Default: `false`,
+         */
+        produceCachedData?: boolean | undefined;
+        /**
+         * The sandbox/context in which the said function should be compiled in.
+         */
+        parsingContext?: Context | undefined;
+        /**
+         * An array containing a collection of context extensions (objects wrapping the current scope) to be applied while compiling
+         */
+        contextExtensions?: Object[] | undefined;
+    }
+    interface CreateContextOptions {
+        /**
+         * Human-readable name of the newly created context.
+         * @default 'VM Context i' Where i is an ascending numerical index of the created context.
+         */
+        name?: string | undefined;
+        /**
+         * Corresponds to the newly created context for display purposes.
+         * The origin should be formatted like a `URL`, but with only the scheme, host, and port (if necessary),
+         * like the value of the `url.origin` property of a URL object.
+         * Most notably, this string should omit the trailing slash, as that denotes a path.
+         * @default ''
+         */
+        origin?: string | undefined;
+        codeGeneration?:
+            | {
+                  /**
+                   * If set to false any calls to eval or function constructors (Function, GeneratorFunction, etc)
+                   * will throw an EvalError.
+                   * @default true
+                   */
+                  strings?: boolean | undefined;
+                  /**
+                   * If set to false any attempt to compile a WebAssembly module will throw a WebAssembly.CompileError.
+                   * @default true
+                   */
+                  wasm?: boolean | undefined;
+              }
+            | undefined;
+        /**
+         * If set to `afterEvaluate`, microtasks will be run immediately after the script has run.
+         */
+        microtaskMode?: 'afterEvaluate' | undefined;
+    }
+    type MeasureMemoryMode = 'summary' | 'detailed';
+    interface MeasureMemoryOptions {
+        /**
+         * @default 'summary'
+         */
+        mode?: MeasureMemoryMode | undefined;
+        context?: Context | undefined;
+    }
+    interface MemoryMeasurement {
+        total: {
+            jsMemoryEstimate: number;
+            jsMemoryRange: [number, number];
+        };
+    }
+    /**
+     * Instances of the `vm.Script` class contain precompiled scripts that can be
+     * executed in specific contexts.
+     * @since v0.3.1
+     */
+    class Script {
+        constructor(code: string, options?: ScriptOptions);
+        /**
+         * Runs the compiled code contained by the `vm.Script` object within the given`contextifiedObject` and returns the result. Running code does not have access
+         * to local scope.
+         *
+         * The following example compiles code that increments a global variable, sets
+         * the value of another global variable, then execute the code multiple times.
+         * The globals are contained in the `context` object.
+         *
+         * ```js
+         * const vm = require('vm');
+         *
+         * const context = {
+         *   animal: 'cat',
+         *   count: 2
+         * };
+         *
+         * const script = new vm.Script('count += 1; name = "kitty";');
+         *
+         * vm.createContext(context);
+         * for (let i = 0; i < 10; ++i) {
+         *   script.runInContext(context);
+         * }
+         *
+         * console.log(context);
+         * // Prints: { animal: 'cat', count: 12, name: 'kitty' }
+         * ```
+         *
+         * Using the `timeout` or `breakOnSigint` options will result in new event loops
+         * and corresponding threads being started, which have a non-zero performance
+         * overhead.
+         * @since v0.3.1
+         * @param contextifiedObject A `contextified` object as returned by the `vm.createContext()` method.
+         * @return the result of the very last statement executed in the script.
+         */
+        runInContext(contextifiedObject: Context, options?: RunningScriptOptions): any;
+        /**
+         * First contextifies the given `contextObject`, runs the compiled code contained
+         * by the `vm.Script` object within the created context, and returns the result.
+         * Running code does not have access to local scope.
+         *
+         * The following example compiles code that sets a global variable, then executes
+         * the code multiple times in different contexts. The globals are set on and
+         * contained within each individual `context`.
+         *
+         * ```js
+         * const vm = require('vm');
+         *
+         * const script = new vm.Script('globalVar = "set"');
+         *
+         * const contexts = [{}, {}, {}];
+         * contexts.forEach((context) => {
+         *   script.runInNewContext(context);
+         * });
+         *
+         * console.log(contexts);
+         * // Prints: [{ globalVar: 'set' }, { globalVar: 'set' }, { globalVar: 'set' }]
+         * ```
+         * @since v0.3.1
+         * @param contextObject An object that will be `contextified`. If `undefined`, a new object will be created.
+         * @return the result of the very last statement executed in the script.
+         */
+        runInNewContext(contextObject?: Context, options?: RunningScriptOptions): any;
+        /**
+         * Runs the compiled code contained by the `vm.Script` within the context of the
+         * current `global` object. Running code does not have access to local scope, but _does_ have access to the current `global` object.
+         *
+         * The following example compiles code that increments a `global` variable then
+         * executes that code multiple times:
+         *
+         * ```js
+         * const vm = require('vm');
+         *
+         * global.globalVar = 0;
+         *
+         * const script = new vm.Script('globalVar += 1', { filename: 'myfile.vm' });
+         *
+         * for (let i = 0; i < 1000; ++i) {
+         *   script.runInThisContext();
+         * }
+         *
+         * console.log(globalVar);
+         *
+         * // 1000
+         * ```
+         * @since v0.3.1
+         * @return the result of the very last statement executed in the script.
+         */
+        runInThisContext(options?: RunningScriptOptions): any;
+        /**
+         * Creates a code cache that can be used with the `Script` constructor's`cachedData` option. Returns a `Buffer`. This method may be called at any
+         * time and any number of times.
+         *
+         * ```js
+         * const script = new vm.Script(`
+         * function add(a, b) {
+         *   return a + b;
+         * }
+         *
+         * const x = add(1, 2);
+         * `);
+         *
+         * const cacheWithoutX = script.createCachedData();
+         *
+         * script.runInThisContext();
+         *
+         * const cacheWithX = script.createCachedData();
+         * ```
+         * @since v10.6.0
+         */
+        createCachedData(): Buffer;
+        /** @deprecated in favor of `script.createCachedData()` */
+        cachedDataProduced?: boolean | undefined;
+        cachedDataRejected?: boolean | undefined;
+        cachedData?: Buffer | undefined;
+    }
+    /**
+     * If given a `contextObject`, the `vm.createContext()` method will `prepare
+     * that object` so that it can be used in calls to {@link runInContext} or `script.runInContext()`. Inside such scripts,
+     * the `contextObject` will be the global object, retaining all of its existing
+     * properties but also having the built-in objects and functions any standard [global object](https://es5.github.io/#x15.1) has. Outside of scripts run by the vm module, global variables
+     * will remain unchanged.
+     *
+     * ```js
+     * const vm = require('vm');
+     *
+     * global.globalVar = 3;
+     *
+     * const context = { globalVar: 1 };
+     * vm.createContext(context);
+     *
+     * vm.runInContext('globalVar *= 2;', context);
+     *
+     * console.log(context);
+     * // Prints: { globalVar: 2 }
+     *
+     * console.log(global.globalVar);
+     * // Prints: 3
+     * ```
+     *
+     * If `contextObject` is omitted (or passed explicitly as `undefined`), a new,
+     * empty `contextified` object will be returned.
+     *
+     * The `vm.createContext()` method is primarily useful for creating a single
+     * context that can be used to run multiple scripts. For instance, if emulating a
+     * web browser, the method can be used to create a single context representing a
+     * window's global object, then run all `<script>` tags together within that
+     * context.
+     *
+     * The provided `name` and `origin` of the context are made visible through the
+     * Inspector API.
+     * @since v0.3.1
+     * @return contextified object.
+     */
+    function createContext(sandbox?: Context, options?: CreateContextOptions): Context;
+    /**
+     * Returns `true` if the given `object` object has been `contextified` using {@link createContext}.
+     * @since v0.11.7
+     */
+    function isContext(sandbox: Context): boolean;
+    /**
+     * The `vm.runInContext()` method compiles `code`, runs it within the context of
+     * the `contextifiedObject`, then returns the result. Running code does not have
+     * access to the local scope. The `contextifiedObject` object _must_ have been
+     * previously `contextified` using the {@link createContext} method.
+     *
+     * If `options` is a string, then it specifies the filename.
+     *
+     * The following example compiles and executes different scripts using a single `contextified` object:
+     *
+     * ```js
+     * const vm = require('vm');
+     *
+     * const contextObject = { globalVar: 1 };
+     * vm.createContext(contextObject);
+     *
+     * for (let i = 0; i < 10; ++i) {
+     *   vm.runInContext('globalVar *= 2;', contextObject);
+     * }
+     * console.log(contextObject);
+     * // Prints: { globalVar: 1024 }
+     * ```
+     * @since v0.3.1
+     * @param code The JavaScript code to compile and run.
+     * @param contextifiedObject The `contextified` object that will be used as the `global` when the `code` is compiled and run.
+     * @return the result of the very last statement executed in the script.
+     */
+    function runInContext(code: string, contextifiedObject: Context, options?: RunningScriptOptions | string): any;
+    /**
+     * The `vm.runInNewContext()` first contextifies the given `contextObject` (or
+     * creates a new `contextObject` if passed as `undefined`), compiles the `code`,
+     * runs it within the created context, then returns the result. Running code
+     * does not have access to the local scope.
+     *
+     * If `options` is a string, then it specifies the filename.
+     *
+     * The following example compiles and executes code that increments a global
+     * variable and sets a new one. These globals are contained in the `contextObject`.
+     *
+     * ```js
+     * const vm = require('vm');
+     *
+     * const contextObject = {
+     *   animal: 'cat',
+     *   count: 2
+     * };
+     *
+     * vm.runInNewContext('count += 1; name = "kitty"', contextObject);
+     * console.log(contextObject);
+     * // Prints: { animal: 'cat', count: 3, name: 'kitty' }
+     * ```
+     * @since v0.3.1
+     * @param code The JavaScript code to compile and run.
+     * @param contextObject An object that will be `contextified`. If `undefined`, a new object will be created.
+     * @return the result of the very last statement executed in the script.
+     */
+    function runInNewContext(code: string, contextObject?: Context, options?: RunningScriptOptions | string): any;
+    /**
+     * `vm.runInThisContext()` compiles `code`, runs it within the context of the
+     * current `global` and returns the result. Running code does not have access to
+     * local scope, but does have access to the current `global` object.
+     *
+     * If `options` is a string, then it specifies the filename.
+     *
+     * The following example illustrates using both `vm.runInThisContext()` and
+     * the JavaScript [`eval()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval) function to run the same code:
+     *
+     * ```js
+     * const vm = require('vm');
+     * let localVar = 'initial value';
+     *
+     * const vmResult = vm.runInThisContext('localVar = "vm";');
+     * console.log(`vmResult: '${vmResult}', localVar: '${localVar}'`);
+     * // Prints: vmResult: 'vm', localVar: 'initial value'
+     *
+     * const evalResult = eval('localVar = "eval";');
+     * console.log(`evalResult: '${evalResult}', localVar: '${localVar}'`);
+     * // Prints: evalResult: 'eval', localVar: 'eval'
+     * ```
+     *
+     * Because `vm.runInThisContext()` does not have access to the local scope,`localVar` is unchanged. In contrast,
+     * [`eval()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval) _does_ have access to the
+     * local scope, so the value `localVar` is changed. In this way`vm.runInThisContext()` is much like an [indirect `eval()` call](https://es5.github.io/#x10.4.2), e.g.`(0,eval)('code')`.
+     *
+     * ## Example: Running an HTTP server within a VM
+     *
+     * When using either `script.runInThisContext()` or {@link runInThisContext}, the code is executed within the current V8 global
+     * context. The code passed to this VM context will have its own isolated scope.
+     *
+     * In order to run a simple web server using the `http` module the code passed to
+     * the context must either call `require('http')` on its own, or have a reference
+     * to the `http` module passed to it. For instance:
+     *
+     * ```js
+     * 'use strict';
+     * const vm = require('vm');
+     *
+     * const code = `
+     * ((require) => {
+     *   const http = require('http');
+     *
+     *   http.createServer((request, response) => {
+     *     response.writeHead(200, { 'Content-Type': 'text/plain' });
+     *     response.end('Hello World\\n');
+     *   }).listen(8124);
+     *
+     *   console.log('Server running at http://127.0.0.1:8124/');
+     * })`;
+     *
+     * vm.runInThisContext(code)(require);
+     * ```
+     *
+     * The `require()` in the above case shares the state with the context it is
+     * passed from. This may introduce risks when untrusted code is executed, e.g.
+     * altering objects in the context in unwanted ways.
+     * @since v0.3.1
+     * @param code The JavaScript code to compile and run.
+     * @return the result of the very last statement executed in the script.
+     */
+    function runInThisContext(code: string, options?: RunningScriptOptions | string): any;
+    /**
+     * Compiles the given code into the provided context (if no context is
+     * supplied, the current context is used), and returns it wrapped inside a
+     * function with the given `params`.
+     * @since v10.10.0
+     * @param code The body of the function to compile.
+     * @param params An array of strings containing all parameters for the function.
+     */
+    function compileFunction(code: string, params?: ReadonlyArray<string>, options?: CompileFunctionOptions): Function;
+    /**
+     * Measure the memory known to V8 and used by all contexts known to the
+     * current V8 isolate, or the main context.
+     *
+     * The format of the object that the returned Promise may resolve with is
+     * specific to the V8 engine and may change from one version of V8 to the next.
+     *
+     * The returned result is different from the statistics returned by`v8.getHeapSpaceStatistics()` in that `vm.measureMemory()` measure the
+     * memory reachable by each V8 specific contexts in the current instance of
+     * the V8 engine, while the result of `v8.getHeapSpaceStatistics()` measure
+     * the memory occupied by each heap space in the current V8 instance.
+     *
+     * ```js
+     * const vm = require('vm');
+     * // Measure the memory used by the main context.
+     * vm.measureMemory({ mode: 'summary' })
+     *   // This is the same as vm.measureMemory()
+     *   .then((result) => {
+     *     // The current format is:
+     *     // {
+     *     //   total: {
+     *     //      jsMemoryEstimate: 2418479, jsMemoryRange: [ 2418479, 2745799 ]
+     *     //    }
+     *     // }
+     *     console.log(result);
+     *   });
+     *
+     * const context = vm.createContext({ a: 1 });
+     * vm.measureMemory({ mode: 'detailed', execution: 'eager' })
+     *   .then((result) => {
+     *     // Reference the context here so that it won't be GC'ed
+     *     // until the measurement is complete.
+     *     console.log(context.a);
+     *     // {
+     *     //   total: {
+     *     //     jsMemoryEstimate: 2574732,
+     *     //     jsMemoryRange: [ 2574732, 2904372 ]
+     *     //   },
+     *     //   current: {
+     *     //     jsMemoryEstimate: 2438996,
+     *     //     jsMemoryRange: [ 2438996, 2768636 ]
+     *     //   },
+     *     //   other: [
+     *     //     {
+     *     //       jsMemoryEstimate: 135736,
+     *     //       jsMemoryRange: [ 135736, 465376 ]
+     *     //     }
+     *     //   ]
+     *     // }
+     *     console.log(result);
+     *   });
+     * ```
+     * @since v13.10.0
+     * @experimental
+     */
+    function measureMemory(options?: MeasureMemoryOptions): Promise<MemoryMeasurement>;
+}
+declare module 'node:vm' {
+    export * from 'vm';
+}

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

@@ -0,0 +1,158 @@
+/**
+ * The WASI API provides an implementation of the [WebAssembly System Interface](https://wasi.dev/) specification. WASI gives sandboxed WebAssembly applications access to the
+ * underlying operating system via a collection of POSIX-like functions.
+ *
+ * ```js
+ * import { readFile } from 'fs/promises';
+ * import { WASI } from 'wasi';
+ * import { argv, env } from 'process';
+ *
+ * const wasi = new WASI({
+ *   args: argv,
+ *   env,
+ *   preopens: {
+ *     '/sandbox': '/some/real/path/that/wasm/can/access'
+ *   }
+ * });
+ *
+ * // Some WASI binaries require:
+ * //   const importObject = { wasi_unstable: wasi.wasiImport };
+ * const importObject = { wasi_snapshot_preview1: wasi.wasiImport };
+ *
+ * const wasm = await WebAssembly.compile(
+ *   await readFile(new URL('./demo.wasm', import.meta.url))
+ * );
+ * const instance = await WebAssembly.instantiate(wasm, importObject);
+ *
+ * wasi.start(instance);
+ * ```
+ *
+ * To run the above example, create a new WebAssembly text format file named`demo.wat`:
+ *
+ * ```text
+ * (module
+ *     ;; Import the required fd_write WASI function which will write the given io vectors to stdout
+ *     ;; The function signature for fd_write is:
+ *     ;; (File Descriptor, *iovs, iovs_len, nwritten) -> Returns number of bytes written
+ *     (import "wasi_snapshot_preview1" "fd_write" (func $fd_write (param i32 i32 i32 i32) (result i32)))
+ *
+ *     (memory 1)
+ *     (export "memory" (memory 0))
+ *
+ *     ;; Write 'hello world\n' to memory at an offset of 8 bytes
+ *     ;; Note the trailing newline which is required for the text to appear
+ *     (data (i32.const 8) "hello world\n")
+ *
+ *     (func $main (export "_start")
+ *         ;; Creating a new io vector within linear memory
+ *         (i32.store (i32.const 0) (i32.const 8))  ;; iov.iov_base - This is a pointer to the start of the 'hello world\n' string
+ *         (i32.store (i32.const 4) (i32.const 12))  ;; iov.iov_len - The length of the 'hello world\n' string
+ *
+ *         (call $fd_write
+ *             (i32.const 1) ;; file_descriptor - 1 for stdout
+ *             (i32.const 0) ;; *iovs - The pointer to the iov array, which is stored at memory location 0
+ *             (i32.const 1) ;; iovs_len - We're printing 1 string stored in an iov - so one.
+ *             (i32.const 20) ;; nwritten - A place in memory to store the number of bytes written
+ *         )
+ *         drop ;; Discard the number of bytes written from the top of the stack
+ *     )
+ * )
+ * ```
+ *
+ * Use [wabt](https://github.com/WebAssembly/wabt) to compile `.wat` to `.wasm`
+ *
+ * ```console
+ * $ wat2wasm demo.wat
+ * ```
+ *
+ * The `--experimental-wasi-unstable-preview1` CLI argument is needed for this
+ * example to run.
+ * @experimental
+ * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/wasi.js)
+ */
+declare module 'wasi' {
+    interface WASIOptions {
+        /**
+         * An array of strings that the WebAssembly application will
+         * see as command line arguments. The first argument is the virtual path to the
+         * WASI command itself.
+         */
+        args?: string[] | undefined;
+        /**
+         * An object similar to `process.env` that the WebAssembly
+         * application will see as its environment.
+         */
+        env?: object | undefined;
+        /**
+         * This object represents the WebAssembly application's
+         * sandbox directory structure. The string keys of `preopens` are treated as
+         * directories within the sandbox. The corresponding values in `preopens` are
+         * the real paths to those directories on the host machine.
+         */
+        preopens?: NodeJS.Dict<string> | undefined;
+        /**
+         * By default, WASI applications terminate the Node.js
+         * process via the `__wasi_proc_exit()` function. Setting this option to `true`
+         * causes `wasi.start()` to return the exit code rather than terminate the
+         * process.
+         * @default false
+         */
+        returnOnExit?: boolean | undefined;
+        /**
+         * The file descriptor used as standard input in the WebAssembly application.
+         * @default 0
+         */
+        stdin?: number | undefined;
+        /**
+         * The file descriptor used as standard output in the WebAssembly application.
+         * @default 1
+         */
+        stdout?: number | undefined;
+        /**
+         * The file descriptor used as standard error in the WebAssembly application.
+         * @default 2
+         */
+        stderr?: number | undefined;
+    }
+    /**
+     * The `WASI` class provides the WASI system call API and additional convenience
+     * methods for working with WASI-based applications. Each `WASI` instance
+     * represents a distinct sandbox environment. For security purposes, each `WASI`instance must have its command-line arguments, environment variables, and
+     * sandbox directory structure configured explicitly.
+     * @since v13.3.0, v12.16.0
+     */
+    class WASI {
+        constructor(options?: WASIOptions);
+        /**
+         * Attempt to begin execution of `instance` as a WASI command by invoking its`_start()` export. If `instance` does not contain a `_start()` export, or if`instance` contains an `_initialize()`
+         * export, then an exception is thrown.
+         *
+         * `start()` requires that `instance` exports a [`WebAssembly.Memory`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory) named`memory`. If
+         * `instance` does not have a `memory` export an exception is thrown.
+         *
+         * If `start()` is called more than once, an exception is thrown.
+         * @since v13.3.0, v12.16.0
+         */
+        start(instance: object): void; // TODO: avoid DOM dependency until WASM moved to own lib.
+        /**
+         * Attempt to initialize `instance` as a WASI reactor by invoking its`_initialize()` export, if it is present. If `instance` contains a `_start()`export, then an exception is thrown.
+         *
+         * `initialize()` requires that `instance` exports a [`WebAssembly.Memory`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory) named`memory`.
+         * If `instance` does not have a `memory` export an exception is thrown.
+         *
+         * If `initialize()` is called more than once, an exception is thrown.
+         * @since v14.6.0, v12.19.0
+         */
+        initialize(instance: object): void; // TODO: avoid DOM dependency until WASM moved to own lib.
+        /**
+         * `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
+         * of a [`WebAssembly.Instance`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Instance).
+         * @since v13.3.0, v12.16.0
+         */
+        readonly wasiImport: NodeJS.Dict<any>; // TODO: Narrow to DOM types
+    }
+}
+declare module 'node:wasi' {
+    export * from 'wasi';
+}