@tybys/wasm-util 0.7.0 → 0.8.1

package/README.md

@@ -19,13 +19,13 @@ You can use `memfs-browser` to provide filesystem capability.
 
 ```js
 import { load, WASI } from '@tybys/wasm-util'
-import { Volumn, createFsFromVolume } from 'memfs-browser'
+import { Volume, createFsFromVolume } from 'memfs-browser'
 
-const fs = createFsFromVolume(Volume.from({
+const fs = createFsFromVolume(Volume.fromJSON({
   '/home/wasi': null
 }))
 
-const wasi = WASI.createSync({
+const wasi = new WASI({
   args: ['chrome', 'file.wasm'],
   env: {
     NODE_ENV: 'development',

package/dist/wasm-util.d.ts

@@ -32,10 +32,10 @@ export declare type AsyncifyExports<T, U> = T extends Record<string, any> ? {
 } : T;
 
 /** @public */
-export declare function asyncifyLoad(asyncify: AsyncifyOptions, urlOrBuffer: string | URL | BufferSource, imports?: WebAssembly.Imports): Promise<WebAssembly.WebAssemblyInstantiatedSource>;
+export declare function asyncifyLoad(asyncify: AsyncifyOptions, urlOrBuffer: string | URL | BufferSource | WebAssembly.Module, imports?: WebAssembly.Imports): Promise<WebAssembly.WebAssemblyInstantiatedSource>;
 
 /** @public */
-export declare function asyncifyLoadSync(asyncify: AsyncifyOptions, buffer: BufferSource, imports?: WebAssembly.Imports): WebAssembly.WebAssemblyInstantiatedSource;
+export declare function asyncifyLoadSync(asyncify: AsyncifyOptions, buffer: BufferSource | WebAssembly.Module, imports?: WebAssembly.Imports): WebAssembly.WebAssemblyInstantiatedSource;
 
 /** @public */
 export declare interface AsyncifyOptions {
@@ -76,6 +76,9 @@ export declare type BufferEncodingOption = 'buffer' | {
 /** @public */
 export declare type Callable = (...args: any[]) => any;
 
+/** @public */
+export declare function createAsyncWASI(options?: AsyncWASIOptions): Promise<WASI>;
+
 /** @public */
 export declare function extendMemory(memory: WebAssembly.Memory): Memory;
 
@@ -254,6 +257,8 @@ export declare interface IFsPromises {
     symlink(target: PathLike, path: PathLike, type?: 'dir' | 'file' | 'junction'): Promise<void>;
 }
 
+declare const kBindingName: unique symbol;
+
 declare const kExitCode: unique symbol;
 
 declare const kInstance: unique symbol;
@@ -263,10 +268,10 @@ declare const kSetMemory: unique symbol;
 declare const kStarted: unique symbol;
 
 /** @public */
-export declare function load(urlOrBuffer: string | URL | BufferSource, imports?: WebAssembly.Imports): Promise<WebAssembly.WebAssemblyInstantiatedSource>;
+export declare function load(wasmInput: string | URL | BufferSource | WebAssembly.Module, imports?: WebAssembly.Imports): Promise<WebAssembly.WebAssemblyInstantiatedSource>;
 
 /** @public */
-export declare function loadSync(buffer: BufferSource, imports?: WebAssembly.Imports): WebAssembly.WebAssemblyInstantiatedSource;
+export declare function loadSync(wasmInput: BufferSource | WebAssembly.Module, imports?: WebAssembly.Imports): WebAssembly.WebAssemblyInstantiatedSource;
 
 /** @public */
 export declare interface MakeDirectoryOptions {
@@ -367,16 +372,17 @@ export declare class WASI {
     private [kStarted];
     private [kExitCode];
     private [kInstance];
+    private [kBindingName];
     readonly wasiImport: Record<string, any>;
-    static createSync(options?: SyncWASIOptions): WASI;
-    static createAsync(options?: AsyncWASIOptions): Promise<WASI>;
     constructor(options?: SyncWASIOptions);
     start(instance: WebAssembly.Instance): number | undefined | Promise<number> | Promise<undefined>;
     initialize(instance: WebAssembly.Instance): void | Promise<void>;
+    getImportObject(): Record<string, Record<string, any>>;
 }
 
 /** @public */
 export declare interface WASIOptions {
+    version?: 'unstable' | 'preview1';
     args?: string[] | undefined;
     env?: Record<string, string> | undefined;
     preopens?: Record<string, string> | undefined;

package/dist/wasm-util.esm-bundler.js

@@ -225,30 +225,35 @@ function fetchWasm(urlOrBuffer, imports) {
         .then(buffer => _WebAssembly.instantiate(buffer, imports));
 }
 /** @public */
-function load(urlOrBuffer, imports) {
+function load(wasmInput, imports) {
     validateImports(imports);
     imports = imports !== null && imports !== void 0 ? imports : {};
     let source;
-    if (urlOrBuffer instanceof ArrayBuffer || ArrayBuffer.isView(urlOrBuffer)) {
-        return _WebAssembly.instantiate(urlOrBuffer, imports);
+    if (wasmInput instanceof ArrayBuffer || ArrayBuffer.isView(wasmInput)) {
+        return _WebAssembly.instantiate(wasmInput, imports);
+    }
+    if (wasmInput instanceof _WebAssembly.Module) {
+        return _WebAssembly.instantiate(wasmInput, imports).then((instance) => {
+            return { instance, module: wasmInput };
+        });
     }
-    if (typeof urlOrBuffer !== 'string' && !(urlOrBuffer instanceof URL)) {
+    if (typeof wasmInput !== 'string' && !(wasmInput instanceof URL)) {
         throw new TypeError('Invalid source');
     }
     if (typeof _WebAssembly.instantiateStreaming === 'function') {
         let responsePromise;
         try {
-            responsePromise = fetch(urlOrBuffer);
+            responsePromise = fetch(wasmInput);
             source = _WebAssembly.instantiateStreaming(responsePromise, imports).catch(() => {
-                return fetchWasm(urlOrBuffer, imports);
+                return fetchWasm(wasmInput, imports);
             });
         }
         catch (_) {
-            source = fetchWasm(urlOrBuffer, imports);
+            source = fetchWasm(wasmInput, imports);
         }
     }
     else {
-        source = fetchWasm(urlOrBuffer, imports);
+        source = fetchWasm(wasmInput, imports);
     }
     return source;
 }
@@ -265,13 +270,19 @@ function asyncifyLoad(asyncify, urlOrBuffer, imports) {
     });
 }
 /** @public */
-function loadSync(buffer, imports) {
-    if ((buffer instanceof ArrayBuffer) && !ArrayBuffer.isView(buffer)) {
-        throw new TypeError('Invalid source');
-    }
+function loadSync(wasmInput, imports) {
     validateImports(imports);
     imports = imports !== null && imports !== void 0 ? imports : {};
-    const module = new _WebAssembly.Module(buffer);
+    let module;
+    if ((wasmInput instanceof ArrayBuffer) || ArrayBuffer.isView(wasmInput)) {
+        module = new _WebAssembly.Module(wasmInput);
+    }
+    else if (wasmInput instanceof WebAssembly.Module) {
+        module = wasmInput;
+    }
+    else {
+        throw new TypeError('Invalid source');
+    }
     const instance = new _WebAssembly.Instance(module, imports);
     const source = { instance, module };
     return source;
@@ -1449,7 +1460,14 @@ class WASI$1 {
                     return 28 /* WasiErrno.EINVAL */;
                 }
                 buf_len = Number(buf_len);
-                const { HEAPU8 } = getMemory(this);
+                const { HEAPU8, view } = getMemory(this);
+                if ((typeof SharedArrayBuffer === 'function' && HEAPU8.buffer instanceof SharedArrayBuffer) ||
+                    (Object.prototype.toString.call(HEAPU8.buffer) === '[object SharedArrayBuffer]')) {
+                    for (let i = buf; i < buf + buf_len; ++i) {
+                        view.setUint8(i, Math.floor(Math.random() * 256));
+                    }
+                    return 0 /* WasiErrno.ESUCCESS */;
+                }
                 let pos;
                 const stride = 65536;
                 for (pos = 0; pos + stride < buf_len; pos += stride) {
@@ -2472,17 +2490,36 @@ const kExitCode = Symbol('kExitCode');
 const kSetMemory = Symbol('kSetMemory');
 const kStarted = Symbol('kStarted');
 const kInstance = Symbol('kInstance');
+const kBindingName = Symbol('kBindingName');
 function setupInstance(self, instance) {
     validateObject(instance, 'instance');
     validateObject(instance.exports, 'instance.exports');
     self[kInstance] = instance;
     self[kSetMemory](instance.exports.memory);
 }
-// /** @public */
-// export type WasiSnapshotPreview1 = Omit<_WASI, '_setMemory'>
 function validateOptions(options) {
     var _a;
     validateObject(options, 'options');
+    let _WASI;
+    if (options.version !== undefined) {
+        validateString(options.version, 'options.version');
+        switch (options.version) {
+            case 'unstable':
+                _WASI = WASI$1;
+                this[kBindingName] = 'wasi_unstable';
+                break;
+            case 'preview1':
+                _WASI = WASI$1;
+                this[kBindingName] = 'wasi_snapshot_preview1';
+                break;
+            default:
+                throw new TypeError(`unsupported WASI version "${options.version}"`);
+        }
+    }
+    else {
+        _WASI = WASI$1;
+        this[kBindingName] = 'wasi_snapshot_preview1';
+    }
     if (options.args !== undefined) {
         validateArray(options.args, 'options.args');
     }
@@ -2541,7 +2578,8 @@ function validateOptions(options) {
         args,
         env,
         preopens,
-        stdio
+        stdio,
+        _WASI
     };
 }
 function initWASI(setMemory, wrap) {
@@ -2554,8 +2592,8 @@ function initWASI(setMemory, wrap) {
 /** @public */
 class WASI {
     constructor(options = kEmptyObject) {
-        const { args, env, preopens, stdio } = validateOptions(options);
-        const wrap = WASI$1.createSync(args, env, preopens, stdio, options.fs, options.print, options.printErr);
+        const { args, env, preopens, stdio, _WASI } = validateOptions.call(this, options);
+        const wrap = _WASI.createSync(args, env, preopens, stdio, options.fs, options.print, options.printErr);
         const setMemory = wrap._setMemory;
         delete wrap._setMemory;
         initWASI.call(this, setMemory, wrap);
@@ -2563,25 +2601,6 @@ class WASI {
             wrap.proc_exit = wasiReturnOnProcExit.bind(this);
         }
     }
-    static createSync(options = kEmptyObject) {
-        return new WASI(options);
-    }
-    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$1.createAsync(args, env, preopens, stdio, options.fs, options.print, options.printErr, options.asyncify);
-        const setMemory = wrap._setMemory;
-        delete wrap._setMemory;
-        const _this = Object.create(WASI.prototype);
-        initWASI.call(_this, 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]) {
@@ -2625,11 +2644,31 @@ class WASI {
             return _initialize();
         }
     }
+    getImportObject() {
+        return { [this[kBindingName]]: this.wasiImport };
+    }
 }
 function wasiReturnOnProcExit(rval) {
     this[kExitCode] = rval;
     // eslint-disable-next-line @typescript-eslint/no-throw-literal
     throw kExitCode;
 }
+/** @public */
+async function createAsyncWASI(options = kEmptyObject) {
+    const _this = Object.create(WASI.prototype);
+    const { args, env, preopens, stdio, _WASI } = validateOptions.call(_this, 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;
+    initWASI.call(_this, setMemory, wrap);
+    if (options.returnOnExit) {
+        wrap.proc_exit = wasiReturnOnProcExit.bind(_this);
+    }
+    return _this;
+}
 
-export { Asyncify, Memory, WASI, WebAssemblyMemory, asyncifyLoad, asyncifyLoadSync, extendMemory, load, loadSync, wrapAsyncExport, wrapAsyncImport, wrapExports };
+export { Asyncify, Memory, WASI, WebAssemblyMemory, asyncifyLoad, asyncifyLoadSync, createAsyncWASI, extendMemory, load, loadSync, wrapAsyncExport, wrapAsyncImport, wrapExports };

package/dist/wasm-util.esm.js

@@ -225,30 +225,35 @@ function fetchWasm(urlOrBuffer, imports) {
         .then(buffer => _WebAssembly.instantiate(buffer, imports));
 }
 /** @public */
-function load(urlOrBuffer, imports) {
+function load(wasmInput, imports) {
     validateImports(imports);
     imports = imports !== null && imports !== void 0 ? imports : {};
     let source;
-    if (urlOrBuffer instanceof ArrayBuffer || ArrayBuffer.isView(urlOrBuffer)) {
-        return _WebAssembly.instantiate(urlOrBuffer, imports);
+    if (wasmInput instanceof ArrayBuffer || ArrayBuffer.isView(wasmInput)) {
+        return _WebAssembly.instantiate(wasmInput, imports);
+    }
+    if (wasmInput instanceof _WebAssembly.Module) {
+        return _WebAssembly.instantiate(wasmInput, imports).then((instance) => {
+            return { instance, module: wasmInput };
+        });
     }
-    if (typeof urlOrBuffer !== 'string' && !(urlOrBuffer instanceof URL)) {
+    if (typeof wasmInput !== 'string' && !(wasmInput instanceof URL)) {
         throw new TypeError('Invalid source');
     }
     if (typeof _WebAssembly.instantiateStreaming === 'function') {
         let responsePromise;
         try {
-            responsePromise = fetch(urlOrBuffer);
+            responsePromise = fetch(wasmInput);
             source = _WebAssembly.instantiateStreaming(responsePromise, imports).catch(() => {
-                return fetchWasm(urlOrBuffer, imports);
+                return fetchWasm(wasmInput, imports);
             });
         }
         catch (_) {
-            source = fetchWasm(urlOrBuffer, imports);
+            source = fetchWasm(wasmInput, imports);
         }
     }
     else {
-        source = fetchWasm(urlOrBuffer, imports);
+        source = fetchWasm(wasmInput, imports);
     }
     return source;
 }
@@ -265,13 +270,19 @@ function asyncifyLoad(asyncify, urlOrBuffer, imports) {
     });
 }
 /** @public */
-function loadSync(buffer, imports) {
-    if ((buffer instanceof ArrayBuffer) && !ArrayBuffer.isView(buffer)) {
-        throw new TypeError('Invalid source');
-    }
+function loadSync(wasmInput, imports) {
     validateImports(imports);
     imports = imports !== null && imports !== void 0 ? imports : {};
-    const module = new _WebAssembly.Module(buffer);
+    let module;
+    if ((wasmInput instanceof ArrayBuffer) || ArrayBuffer.isView(wasmInput)) {
+        module = new _WebAssembly.Module(wasmInput);
+    }
+    else if (wasmInput instanceof WebAssembly.Module) {
+        module = wasmInput;
+    }
+    else {
+        throw new TypeError('Invalid source');
+    }
     const instance = new _WebAssembly.Instance(module, imports);
     const source = { instance, module };
     return source;
@@ -1449,7 +1460,14 @@ class WASI$1 {
                     return 28 /* WasiErrno.EINVAL */;
                 }
                 buf_len = Number(buf_len);
-                const { HEAPU8 } = getMemory(this);
+                const { HEAPU8, view } = getMemory(this);
+                if ((typeof SharedArrayBuffer === 'function' && HEAPU8.buffer instanceof SharedArrayBuffer) ||
+                    (Object.prototype.toString.call(HEAPU8.buffer) === '[object SharedArrayBuffer]')) {
+                    for (let i = buf; i < buf + buf_len; ++i) {
+                        view.setUint8(i, Math.floor(Math.random() * 256));
+                    }
+                    return 0 /* WasiErrno.ESUCCESS */;
+                }
                 let pos;
                 const stride = 65536;
                 for (pos = 0; pos + stride < buf_len; pos += stride) {
@@ -2472,17 +2490,36 @@ const kExitCode = Symbol('kExitCode');
 const kSetMemory = Symbol('kSetMemory');
 const kStarted = Symbol('kStarted');
 const kInstance = Symbol('kInstance');
+const kBindingName = Symbol('kBindingName');
 function setupInstance(self, instance) {
     validateObject(instance, 'instance');
     validateObject(instance.exports, 'instance.exports');
     self[kInstance] = instance;
     self[kSetMemory](instance.exports.memory);
 }
-// /** @public */
-// export type WasiSnapshotPreview1 = Omit<_WASI, '_setMemory'>
 function validateOptions(options) {
     var _a;
     validateObject(options, 'options');
+    let _WASI;
+    if (options.version !== undefined) {
+        validateString(options.version, 'options.version');
+        switch (options.version) {
+            case 'unstable':
+                _WASI = WASI$1;
+                this[kBindingName] = 'wasi_unstable';
+                break;
+            case 'preview1':
+                _WASI = WASI$1;
+                this[kBindingName] = 'wasi_snapshot_preview1';
+                break;
+            default:
+                throw new TypeError(`unsupported WASI version "${options.version}"`);
+        }
+    }
+    else {
+        _WASI = WASI$1;
+        this[kBindingName] = 'wasi_snapshot_preview1';
+    }
     if (options.args !== undefined) {
         validateArray(options.args, 'options.args');
     }
@@ -2541,7 +2578,8 @@ function validateOptions(options) {
         args,
         env,
         preopens,
-        stdio
+        stdio,
+        _WASI
     };
 }
 function initWASI(setMemory, wrap) {
@@ -2554,8 +2592,8 @@ function initWASI(setMemory, wrap) {
 /** @public */
 class WASI {
     constructor(options = kEmptyObject) {
-        const { args, env, preopens, stdio } = validateOptions(options);
-        const wrap = WASI$1.createSync(args, env, preopens, stdio, options.fs, options.print, options.printErr);
+        const { args, env, preopens, stdio, _WASI } = validateOptions.call(this, options);
+        const wrap = _WASI.createSync(args, env, preopens, stdio, options.fs, options.print, options.printErr);
         const setMemory = wrap._setMemory;
         delete wrap._setMemory;
         initWASI.call(this, setMemory, wrap);
@@ -2563,25 +2601,6 @@ class WASI {
             wrap.proc_exit = wasiReturnOnProcExit.bind(this);
         }
     }
-    static createSync(options = kEmptyObject) {
-        return new WASI(options);
-    }
-    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$1.createAsync(args, env, preopens, stdio, options.fs, options.print, options.printErr, options.asyncify);
-        const setMemory = wrap._setMemory;
-        delete wrap._setMemory;
-        const _this = Object.create(WASI.prototype);
-        initWASI.call(_this, 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]) {
@@ -2625,11 +2644,31 @@ class WASI {
             return _initialize();
         }
     }
+    getImportObject() {
+        return { [this[kBindingName]]: this.wasiImport };
+    }
 }
 function wasiReturnOnProcExit(rval) {
     this[kExitCode] = rval;
     // eslint-disable-next-line @typescript-eslint/no-throw-literal
     throw kExitCode;
 }
+/** @public */
+async function createAsyncWASI(options = kEmptyObject) {
+    const _this = Object.create(WASI.prototype);
+    const { args, env, preopens, stdio, _WASI } = validateOptions.call(_this, 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;
+    initWASI.call(_this, setMemory, wrap);
+    if (options.returnOnExit) {
+        wrap.proc_exit = wasiReturnOnProcExit.bind(_this);
+    }
+    return _this;
+}
 
-export { Asyncify, Memory, WASI, WebAssemblyMemory, asyncifyLoad, asyncifyLoadSync, extendMemory, load, loadSync, wrapAsyncExport, wrapAsyncImport, wrapExports };
+export { Asyncify, Memory, WASI, WebAssemblyMemory, asyncifyLoad, asyncifyLoadSync, createAsyncWASI, extendMemory, load, loadSync, wrapAsyncExport, wrapAsyncImport, wrapExports };