@tybys/wasm-util 0.4.0 → 0.5.1

package/lib/cjs/wasi/rights.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getRights = exports.TTY_INHERITING = exports.TTY_BASE = exports.SOCKET_INHERITING = exports.SOCKET_BASE = exports.DIRECTORY_INHERITING = exports.DIRECTORY_BASE = exports.REGULAR_FILE_INHERITING = exports.REGULAR_FILE_BASE = exports.CHARACTER_DEVICE_INHERITING = exports.CHARACTER_DEVICE_BASE = exports.BLOCK_DEVICE_INHERITING = exports.BLOCK_DEVICE_BASE = exports.RIGHTS_ALL = void 0;
+/* eslint-disable spaced-comment */
 const error_1 = require("./error");
 const types_1 = require("./types");
 exports.RIGHTS_ALL = types_1.WasiRights.FD_DATASYNC |

package/lib/cjs/wasi/types.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WasiFstFlag = exports.WasiClockid = exports.WasiFdFlag = exports.WasiFileControlFlag = exports.FileControlFlag = exports.WasiWhence = exports.WasiRights = exports.WasiFileType = exports.WasiErrno = void 0;
+/* eslint-disable spaced-comment */
 var WasiErrno;
 (function (WasiErrno) {
     WasiErrno[WasiErrno["ESUCCESS"] = 0] = "ESUCCESS";
@@ -92,37 +93,67 @@ var WasiFileType;
     WasiFileType[WasiFileType["SOCKET_STREAM"] = 6] = "SOCKET_STREAM";
     WasiFileType[WasiFileType["SYMBOLIC_LINK"] = 7] = "SYMBOLIC_LINK";
 })(WasiFileType = exports.WasiFileType || (exports.WasiFileType = {}));
+const FD_DATASYNC = /*#__PURE__*/ (BigInt(1) << BigInt(0));
+const FD_READ = /*#__PURE__*/ (BigInt(1) << BigInt(1));
+const FD_SEEK = /*#__PURE__*/ (BigInt(1) << BigInt(2));
+const FD_FDSTAT_SET_FLAGS = /*#__PURE__*/ (BigInt(1) << BigInt(3));
+const FD_SYNC = /*#__PURE__*/ (BigInt(1) << BigInt(4));
+const FD_TELL = /*#__PURE__*/ (BigInt(1) << BigInt(5));
+const FD_WRITE = /*#__PURE__*/ (BigInt(1) << BigInt(6));
+const FD_ADVISE = /*#__PURE__*/ (BigInt(1) << BigInt(7));
+const FD_ALLOCATE = /*#__PURE__*/ (BigInt(1) << BigInt(8));
+const PATH_CREATE_DIRECTORY = /*#__PURE__*/ (BigInt(1) << BigInt(9));
+const PATH_CREATE_FILE = /*#__PURE__*/ (BigInt(1) << BigInt(10));
+const PATH_LINK_SOURCE = /*#__PURE__*/ (BigInt(1) << BigInt(11));
+const PATH_LINK_TARGET = /*#__PURE__*/ (BigInt(1) << BigInt(12));
+const PATH_OPEN = /*#__PURE__*/ (BigInt(1) << BigInt(13));
+const FD_READDIR = /*#__PURE__*/ (BigInt(1) << BigInt(14));
+const PATH_READLINK = /*#__PURE__*/ (BigInt(1) << BigInt(15));
+const PATH_RENAME_SOURCE = /*#__PURE__*/ (BigInt(1) << BigInt(16));
+const PATH_RENAME_TARGET = /*#__PURE__*/ (BigInt(1) << BigInt(17));
+const PATH_FILESTAT_GET = /*#__PURE__*/ (BigInt(1) << BigInt(18));
+const PATH_FILESTAT_SET_SIZE = /*#__PURE__*/ (BigInt(1) << BigInt(19));
+const PATH_FILESTAT_SET_TIMES = /*#__PURE__*/ (BigInt(1) << BigInt(20));
+const FD_FILESTAT_GET = /*#__PURE__*/ (BigInt(1) << BigInt(21));
+const FD_FILESTAT_SET_SIZE = /*#__PURE__*/ (BigInt(1) << BigInt(22));
+const FD_FILESTAT_SET_TIMES = /*#__PURE__*/ (BigInt(1) << BigInt(23));
+const PATH_SYMLINK = /*#__PURE__*/ (BigInt(1) << BigInt(24));
+const PATH_REMOVE_DIRECTORY = /*#__PURE__*/ (BigInt(1) << BigInt(25));
+const PATH_UNLINK_FILE = /*#__PURE__*/ (BigInt(1) << BigInt(26));
+const POLL_FD_READWRITE = /*#__PURE__*/ (BigInt(1) << BigInt(27));
+const SOCK_SHUTDOWN = /*#__PURE__*/ (BigInt(1) << BigInt(28));
+const SOCK_ACCEPT = /*#__PURE__*/ (BigInt(1) << BigInt(29));
 exports.WasiRights = {
-    FD_DATASYNC: (BigInt(1) << BigInt(0)),
-    FD_READ: (BigInt(1) << BigInt(1)),
-    FD_SEEK: (BigInt(1) << BigInt(2)),
-    FD_FDSTAT_SET_FLAGS: (BigInt(1) << BigInt(3)),
-    FD_SYNC: (BigInt(1) << BigInt(4)),
-    FD_TELL: (BigInt(1) << BigInt(5)),
-    FD_WRITE: (BigInt(1) << BigInt(6)),
-    FD_ADVISE: (BigInt(1) << BigInt(7)),
-    FD_ALLOCATE: (BigInt(1) << BigInt(8)),
-    PATH_CREATE_DIRECTORY: (BigInt(1) << BigInt(9)),
-    PATH_CREATE_FILE: (BigInt(1) << BigInt(10)),
-    PATH_LINK_SOURCE: (BigInt(1) << BigInt(11)),
-    PATH_LINK_TARGET: (BigInt(1) << BigInt(12)),
-    PATH_OPEN: (BigInt(1) << BigInt(13)),
-    FD_READDIR: (BigInt(1) << BigInt(14)),
-    PATH_READLINK: (BigInt(1) << BigInt(15)),
-    PATH_RENAME_SOURCE: (BigInt(1) << BigInt(16)),
-    PATH_RENAME_TARGET: (BigInt(1) << BigInt(17)),
-    PATH_FILESTAT_GET: (BigInt(1) << BigInt(18)),
-    PATH_FILESTAT_SET_SIZE: (BigInt(1) << BigInt(19)),
-    PATH_FILESTAT_SET_TIMES: (BigInt(1) << BigInt(20)),
-    FD_FILESTAT_GET: (BigInt(1) << BigInt(21)),
-    FD_FILESTAT_SET_SIZE: (BigInt(1) << BigInt(22)),
-    FD_FILESTAT_SET_TIMES: (BigInt(1) << BigInt(23)),
-    PATH_SYMLINK: (BigInt(1) << BigInt(24)),
-    PATH_REMOVE_DIRECTORY: (BigInt(1) << BigInt(25)),
-    PATH_UNLINK_FILE: (BigInt(1) << BigInt(26)),
-    POLL_FD_READWRITE: (BigInt(1) << BigInt(27)),
-    SOCK_SHUTDOWN: (BigInt(1) << BigInt(28)),
-    SOCK_ACCEPT: (BigInt(1) << BigInt(29))
+    FD_DATASYNC,
+    FD_READ,
+    FD_SEEK,
+    FD_FDSTAT_SET_FLAGS,
+    FD_SYNC,
+    FD_TELL,
+    FD_WRITE,
+    FD_ADVISE,
+    FD_ALLOCATE,
+    PATH_CREATE_DIRECTORY,
+    PATH_CREATE_FILE,
+    PATH_LINK_SOURCE,
+    PATH_LINK_TARGET,
+    PATH_OPEN,
+    FD_READDIR,
+    PATH_READLINK,
+    PATH_RENAME_SOURCE,
+    PATH_RENAME_TARGET,
+    PATH_FILESTAT_GET,
+    PATH_FILESTAT_SET_SIZE,
+    PATH_FILESTAT_SET_TIMES,
+    FD_FILESTAT_GET,
+    FD_FILESTAT_SET_SIZE,
+    FD_FILESTAT_SET_TIMES,
+    PATH_SYMLINK,
+    PATH_REMOVE_DIRECTORY,
+    PATH_UNLINK_FILE,
+    POLL_FD_READWRITE,
+    SOCK_SHUTDOWN,
+    SOCK_ACCEPT
 };
 var WasiWhence;
 (function (WasiWhence) {

package/lib/mjs/asyncify.mjs

@@ -90,18 +90,20 @@ export class Asyncify {
         }
     }
     wrapImportFunction(f) {
-        return ((...args) => {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const _this = this;
+        return (function () {
             // eslint-disable-next-line no-unreachable-loop
-            while (this.exports.asyncify_get_state() === AsyncifyState.REWINDING) {
-                this.exports.asyncify_stop_rewind();
-                return this.value;
+            while (_this.exports.asyncify_get_state() === AsyncifyState.REWINDING) {
+                _this.exports.asyncify_stop_rewind();
+                return _this.value;
             }
-            this.assertState();
-            const v = f(...args);
+            _this.assertState();
+            const v = f.apply(this, arguments);
             if (!isPromiseLike(v))
                 return v;
-            this.exports.asyncify_start_unwind(this.dataPtr);
-            this.value = v;
+            _this.exports.asyncify_start_unwind(_this.dataPtr);
+            _this.value = v;
         });
     }
     wrapImports(imports) {
@@ -123,17 +125,19 @@ export class Asyncify {
         return importObject;
     }
     wrapExportFunction(f) {
-        return (async (...args) => {
-            this.assertState();
-            let ret = f(...args);
-            while (this.exports.asyncify_get_state() === AsyncifyState.UNWINDING) {
-                this.exports.asyncify_stop_unwind();
-                this.value = await this.value;
-                this.assertState();
-                this.exports.asyncify_start_rewind(this.dataPtr);
-                ret = f();
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const _this = this;
+        return (async function () {
+            _this.assertState();
+            let ret = f.apply(this, arguments);
+            while (_this.exports.asyncify_get_state() === AsyncifyState.UNWINDING) {
+                _this.exports.asyncify_stop_unwind();
+                _this.value = await _this.value;
+                _this.assertState();
+                _this.exports.asyncify_start_rewind(_this.dataPtr);
+                ret = f.call(this);
             }
-            this.assertState();
+            _this.assertState();
             return ret;
         });
     }
@@ -147,16 +151,3 @@ export class Asyncify {
         });
     }
 }
-// /** @public */
-// export class Instance extends WebAssembly.Instance {
-//   constructor (options: AsyncifyOptions, module: WebAssembly.Module, importObject?: WebAssembly.Imports) {
-//     importObject = importObject ?? {}
-//     const asyncify = new Asyncify()
-//     super(module, asyncify.wrapImports(importObject))
-//     asyncify.init(importObject, this, options)
-//   }
-//   get exports (): WebAssembly.Exports {
-//     return wrappedExports.get(super.exports)!
-//   }
-// }
-// Object.defineProperty(Instance.prototype, 'exports', { enumerable: true })

package/lib/mjs/load.mjs

@@ -1,5 +1,10 @@
 import { _WebAssembly } from "./webassembly.mjs";
 import { Asyncify } from "./asyncify.mjs";
+function validateImports(imports) {
+    if (imports && typeof imports !== 'object') {
+        throw new TypeError('imports must be an object or undefined');
+    }
+}
 async function fetchWasm(urlOrBuffer, imports) {
     if (typeof wx !== 'undefined' && typeof __wxConfig !== 'undefined') {
         return await _WebAssembly.instantiate(urlOrBuffer, imports);
@@ -10,24 +15,12 @@ async function fetchWasm(urlOrBuffer, imports) {
     return source;
 }
 /** @public */
-export async function load(urlOrBuffer, imports, asyncify) {
-    var _a, _b;
-    if (imports && typeof imports !== 'object') {
-        throw new TypeError('imports must be an object or undefined');
-    }
+export async function load(urlOrBuffer, imports) {
+    validateImports(imports);
     imports = imports !== null && imports !== void 0 ? imports : {};
-    let asyncifyHelper;
     let source;
-    if (asyncify) {
-        asyncifyHelper = new Asyncify();
-        imports = asyncifyHelper.wrapImports(imports);
-    }
     if (urlOrBuffer instanceof ArrayBuffer || ArrayBuffer.isView(urlOrBuffer)) {
         source = await _WebAssembly.instantiate(urlOrBuffer, imports);
-        if (asyncify) {
-            const memory = source.instance.exports.memory || ((_a = imports.env) === null || _a === void 0 ? void 0 : _a.memory);
-            return { module: source.module, instance: asyncifyHelper.init(memory, source.instance, asyncify) };
-        }
         return source;
     }
     if (typeof urlOrBuffer !== 'string' && !(urlOrBuffer instanceof URL)) {
@@ -44,33 +37,39 @@ export async function load(urlOrBuffer, imports, asyncify) {
     else {
         source = await fetchWasm(urlOrBuffer, imports);
     }
-    if (asyncify) {
-        const memory = source.instance.exports.memory || ((_b = imports.env) === null || _b === void 0 ? void 0 : _b.memory);
-        return { module: source.module, instance: asyncifyHelper.init(memory, source.instance, asyncify) };
-    }
     return source;
 }
 /** @public */
-export function loadSync(buffer, imports, asyncify) {
+export async function asyncifyLoad(asyncify, urlOrBuffer, imports) {
     var _a;
+    validateImports(imports);
+    imports = imports !== null && imports !== void 0 ? imports : {};
+    const asyncifyHelper = new Asyncify();
+    imports = asyncifyHelper.wrapImports(imports);
+    const source = await load(urlOrBuffer, imports);
+    const memory = source.instance.exports.memory || ((_a = imports.env) === null || _a === void 0 ? void 0 : _a.memory);
+    return { module: source.module, instance: asyncifyHelper.init(memory, source.instance, asyncify) };
+}
+/** @public */
+export function loadSync(buffer, imports) {
     if ((buffer instanceof ArrayBuffer) && !ArrayBuffer.isView(buffer)) {
         throw new TypeError('Invalid source');
     }
-    if (imports && typeof imports !== 'object') {
-        throw new TypeError('imports must be an object or undefined');
-    }
+    validateImports(imports);
     imports = imports !== null && imports !== void 0 ? imports : {};
-    let asyncifyHelper;
-    if (asyncify) {
-        asyncifyHelper = new Asyncify();
-        imports = asyncifyHelper.wrapImports(imports);
-    }
     const module = new _WebAssembly.Module(buffer);
     const instance = new _WebAssembly.Instance(module, imports);
     const source = { instance, module };
-    if (asyncify) {
-        const memory = source.instance.exports.memory || ((_a = imports.env) === null || _a === void 0 ? void 0 : _a.memory);
-        return { module: source.module, instance: asyncifyHelper.init(memory, instance, asyncify) };
-    }
     return source;
 }
+/** @public */
+export function asyncifyLoadSync(asyncify, buffer, imports) {
+    var _a;
+    validateImports(imports);
+    imports = imports !== null && imports !== void 0 ? imports : {};
+    const asyncifyHelper = new Asyncify();
+    imports = asyncifyHelper.wrapImports(imports);
+    const source = loadSync(buffer, imports);
+    const memory = source.instance.exports.memory || ((_a = imports.env) === null || _a === void 0 ? void 0 : _a.memory);
+    return { module: source.module, instance: asyncifyHelper.init(memory, source.instance, asyncify) };
+}

package/lib/mjs/memory.mjs

@@ -1,6 +1,6 @@
 import { _WebAssembly } from "./webassembly.mjs";
 /** @public */
-export const WebAssemblyMemory = _WebAssembly.Memory;
+export const WebAssemblyMemory = /*#__PURE__*/ _WebAssembly.Memory;
 /** @public */
 export class Memory extends WebAssemblyMemory {
     // eslint-disable-next-line @typescript-eslint/no-useless-constructor

package/lib/mjs/wasi/fd.mjs

@@ -112,7 +112,6 @@ export class FileDescriptorTable {
         this.size = options.size;
         this.fds = Array(options.size);
         this.stdio = [options.in, options.out, options.err];
-        this.fs = options.fs;
         this.print = options.print;
         this.printErr = options.printErr;
         this.insertStdio(options.in, 0, '<stdin>');
@@ -159,18 +158,6 @@ export class FileDescriptorTable {
         this.used++;
         return entry;
     }
-    getFileTypeByFd(fd) {
-        const stat = this.fs.fstatSync(fd);
-        return toFileType(stat);
-    }
-    insertPreopen(fd, mappedPath, realPath) {
-        const type = this.getFileTypeByFd(fd);
-        if (type !== WasiFileType.DIRECTORY) {
-            throw new WasiError(`Preopen not dir: ["${mappedPath}", "${realPath}"]`, WasiErrno.ENOTDIR);
-        }
-        const result = getRights(this.stdio, fd, 0, type);
-        return this.insert(fd, mappedPath, realPath, type, result.base, result.inheriting, 1);
-    }
     get(id, base, inheriting) {
         if (id >= this.size) {
             throw new WasiError('Invalid fd', WasiErrno.EBADF);
@@ -196,6 +183,24 @@ export class FileDescriptorTable {
         this.fds[id] = undefined;
         this.used--;
     }
+}
+export class SyncTable extends FileDescriptorTable {
+    constructor(options) {
+        super(options);
+        this.fs = options.fs;
+    }
+    getFileTypeByFd(fd) {
+        const stats = this.fs.fstatSync(fd, { bigint: true });
+        return toFileType(stats);
+    }
+    insertPreopen(fd, mappedPath, realPath) {
+        const type = this.getFileTypeByFd(fd);
+        if (type !== WasiFileType.DIRECTORY) {
+            throw new WasiError(`Preopen not dir: ["${mappedPath}", "${realPath}"]`, WasiErrno.ENOTDIR);
+        }
+        const result = getRights(this.stdio, fd, 0, type);
+        return this.insert(fd, mappedPath, realPath, type, result.base, result.inheriting, 1);
+    }
     renumber(dst, src) {
         if (dst === src)
             return;
@@ -214,3 +219,38 @@ export class FileDescriptorTable {
         this.used--;
     }
 }
+export class AsyncTable extends FileDescriptorTable {
+    // eslint-disable-next-line @typescript-eslint/no-useless-constructor
+    constructor(options) {
+        super(options);
+    }
+    async getFileTypeByFd(fd) {
+        const stats = await fd.stat({ bigint: true });
+        return toFileType(stats);
+    }
+    async insertPreopen(fd, mappedPath, realPath) {
+        const type = await this.getFileTypeByFd(fd);
+        if (type !== WasiFileType.DIRECTORY) {
+            throw new WasiError(`Preopen not dir: ["${mappedPath}", "${realPath}"]`, WasiErrno.ENOTDIR);
+        }
+        const result = getRights(this.stdio, fd.fd, 0, type);
+        return this.insert(fd, mappedPath, realPath, type, result.base, result.inheriting, 1);
+    }
+    async renumber(dst, src) {
+        if (dst === src)
+            return;
+        if (dst >= this.size || src >= this.size) {
+            throw new WasiError('Invalid fd', WasiErrno.EBADF);
+        }
+        const dstEntry = this.fds[dst];
+        const srcEntry = this.fds[src];
+        if (!dstEntry || !srcEntry || dstEntry.id !== dst || srcEntry.id !== src) {
+            throw new WasiError('Invalid fd', WasiErrno.EBADF);
+        }
+        await dstEntry.fd.close();
+        this.fds[dst] = this.fds[src];
+        this.fds[dst].id = dst;
+        this.fds[src] = undefined;
+        this.used--;
+    }
+}

package/lib/mjs/wasi/index.mjs

@@ -1,6 +1,7 @@
 import { WASI as _WASI } from "./preview1.mjs";
-import { validateObject, validateArray, validateBoolean, validateFunction, validateUndefined, validateString } from "./util.mjs";
-const kEmptyObject = Object.freeze(Object.create(null));
+import { validateObject, validateArray, validateBoolean, validateFunction, validateUndefined } from "./util.mjs";
+// eslint-disable-next-line spaced-comment
+const kEmptyObject = /*#__PURE__*/ Object.freeze(/*#__PURE__*/ Object.create(null));
 const kExitCode = Symbol('kExitCode');
 const kSetMemory = Symbol('kSetMemory');
 const kStarted = Symbol('kStarted');
@@ -13,74 +14,105 @@ function setupInstance(self, instance) {
 }
 // /** @public */
 // export type WasiSnapshotPreview1 = Omit<_WASI, '_setMemory'>
-/** @public */
-export class WASI {
-    constructor(options = kEmptyObject) {
-        var _a;
-        validateObject(options, 'options');
-        if (options.args !== undefined) {
-            validateArray(options.args, 'options.args');
-        }
-        const args = ((_a = options.args) !== null && _a !== void 0 ? _a : []).map(String);
-        const env = [];
-        if (options.env !== undefined) {
-            validateObject(options.env, 'options.env');
-            Object.entries(options.env).forEach(({ 0: key, 1: value }) => {
-                if (value !== undefined) {
-                    env.push(`${key}=${value}`);
-                }
-            });
-        }
-        const preopens = [];
-        if (options.preopens !== undefined) {
-            validateObject(options.preopens, 'options.preopens');
-            Object.entries(options.preopens).forEach(({ 0: key, 1: value }) => preopens.push({ mappedPath: String(key), realPath: String(value) }));
-        }
-        if (preopens.length > 0) {
-            if (options.filesystem === undefined) {
-                throw new Error('filesystem is disabled, can not preopen directory');
+function validateOptions(options) {
+    var _a;
+    validateObject(options, 'options');
+    if (options.args !== undefined) {
+        validateArray(options.args, 'options.args');
+    }
+    const args = ((_a = options.args) !== null && _a !== void 0 ? _a : []).map(String);
+    const env = [];
+    if (options.env !== undefined) {
+        validateObject(options.env, 'options.env');
+        Object.entries(options.env).forEach(({ 0: key, 1: value }) => {
+            if (value !== undefined) {
+                env.push(`${key}=${value}`);
             }
+        });
+    }
+    const preopens = [];
+    if (options.preopens !== undefined) {
+        validateObject(options.preopens, 'options.preopens');
+        Object.entries(options.preopens).forEach(({ 0: key, 1: value }) => preopens.push({ mappedPath: String(key), realPath: String(value) }));
+    }
+    if (preopens.length > 0) {
+        if (options.fs === undefined) {
+            throw new Error('filesystem is disabled, can not preopen directory');
         }
-        if (options.filesystem !== undefined) {
-            validateObject(options.filesystem, 'options.filesystem');
-            validateString(options.filesystem.type, 'options.filesystem.type');
-            if (options.filesystem.type !== 'memfs') {
-                throw new Error(`Filesystem type ${options.filesystem.type} is not supported, only "memfs" is supported currently`);
-            }
-            try {
-                validateObject(options.filesystem.fs, 'options.filesystem.fs');
-            }
-            catch (_) {
-                throw new Error('Node.js fs like implementation is not provided');
-            }
+        try {
+            validateObject(options.fs, 'options.fs');
         }
-        if (options.print !== undefined)
-            validateFunction(options.print, 'options.print');
-        if (options.printErr !== undefined)
-            validateFunction(options.printErr, 'options.printErr');
-        // const { stdin = 0, stdout = 1, stderr = 2 } = options
-        // validateInt32(stdin, 'options.stdin', 0)
-        // validateInt32(stdout, 'options.stdout', 0)
-        // validateInt32(stderr, 'options.stderr', 0)
-        // const stdio = [stdin, stdout, stderr] as const
-        const stdio = [0, 1, 2];
-        const wrap = new _WASI(args, env, preopens, stdio, options.filesystem, options.print, options.printErr);
-        for (const prop in wrap) {
-            wrap[prop] = wrap[prop].bind(wrap);
+        catch (_) {
+            throw new TypeError('Node.js fs like implementation is not provided');
         }
-        if (options.returnOnExit !== undefined) {
-            validateBoolean(options.returnOnExit, 'options.returnOnExit');
-            if (options.returnOnExit) {
-                wrap.proc_exit = wasiReturnOnProcExit.bind(this);
-            }
-        }
-        this[kSetMemory] = wrap._setMemory;
-        delete wrap._setMemory;
+    }
+    // if (options.filesystem !== undefined) {
+    //   validateObject(options.filesystem, 'options.filesystem')
+    //   validateString(options.filesystem.type, 'options.filesystem.type')
+    //   if (options.filesystem.type !== 'memfs' && options.filesystem.type !== 'file-system-access-api') {
+    //     throw new Error(`Filesystem type ${(options.filesystem as any).type as string} is not supported, only "memfs" and "file-system-access-api" is supported currently`)
+    //   }
+    //   try {
+    //     validateObject(options.filesystem.fs, 'options.filesystem.fs')
+    //   } catch (_) {
+    //     throw new Error('Node.js fs like implementation is not provided')
+    //   }
+    // }
+    if (options.print !== undefined)
+        validateFunction(options.print, 'options.print');
+    if (options.printErr !== undefined)
+        validateFunction(options.printErr, 'options.printErr');
+    if (options.returnOnExit !== undefined) {
+        validateBoolean(options.returnOnExit, 'options.returnOnExit');
+    }
+    // const { stdin = 0, stdout = 1, stderr = 2 } = options
+    // validateInt32(stdin, 'options.stdin', 0)
+    // validateInt32(stdout, 'options.stdout', 0)
+    // validateInt32(stderr, 'options.stderr', 0)
+    // const stdio = [stdin, stdout, stderr] as const
+    const stdio = [0, 1, 2];
+    return {
+        args,
+        env,
+        preopens,
+        stdio
+    };
+}
+/** @public */
+export class WASI {
+    constructor(setMemory, wrap) {
+        this[kSetMemory] = setMemory;
         this.wasiImport = wrap;
         this[kStarted] = false;
         this[kExitCode] = 0;
         this[kInstance] = undefined;
     }
+    static createSync(options = kEmptyObject) {
+        const { args, env, preopens, stdio } = validateOptions(options);
+        const wrap = _WASI.createSync(args, env, preopens, stdio, options.fs, options.print, options.printErr);
+        const setMemory = wrap._setMemory;
+        delete wrap._setMemory;
+        const _this = new WASI(setMemory, wrap);
+        if (options.returnOnExit) {
+            wrap.proc_exit = wasiReturnOnProcExit.bind(_this);
+        }
+        return _this;
+    }
+    static async createAsync(options = kEmptyObject) {
+        const { args, env, preopens, stdio } = validateOptions(options);
+        if (options.asyncify !== undefined) {
+            validateObject(options.asyncify, 'options.asyncify');
+            validateFunction(options.asyncify.wrapImportFunction, 'options.asyncify.wrapImportFunction');
+        }
+        const wrap = await _WASI.createAsync(args, env, preopens, stdio, options.fs, options.print, options.printErr, options.asyncify);
+        const setMemory = wrap._setMemory;
+        delete wrap._setMemory;
+        const _this = new WASI(setMemory, wrap);
+        if (options.returnOnExit) {
+            wrap.proc_exit = wasiReturnOnProcExit.bind(_this);
+        }
+        return _this;
+    }
     // Must not export _initialize, must export _start
     start(instance) {
         if (this[kStarted]) {