@pnpm/exe 12.8.1 → 12.9.0

package/dist/wasm/node_modules/@tybys/wasm-util/README.md

@@ -0,0 +1,193 @@
+# @tybys/wasm-util
+
+WebAssembly related utils for browser environment
+
+**The output code is ES2019**
+
+## Features
+
+All example code below need to be bundled by ES module bundlers like `webpack` / `rollup`, or specify import map in browser native ES module runtime.
+
+### WASI polyfill for browser
+
+The API is similar to the `require('wasi').WASI` in Node.js.
+
+You can use `memfs-browser` to provide filesystem capability.
+
+- Example: [https://github.com/toyobayashi/wasi-wabt](https://github.com/toyobayashi/wasi-wabt)
+- Demo: [https://toyobayashi.github.io/wasi-wabt/](https://toyobayashi.github.io/wasi-wabt/)
+
+```js
+import { load, WASI } from '@tybys/wasm-util'
+import { Volume, createFsFromVolume } from 'memfs-browser'
+
+const fs = createFsFromVolume(Volume.fromJSON({
+  '/home/wasi': null
+}))
+
+const wasi = new WASI({
+  args: ['chrome', 'file.wasm'],
+  env: {
+    NODE_ENV: 'development',
+    WASI_SDK_PATH: '/opt/wasi-sdk'
+  },
+  preopens: {
+    '/': '/'
+  },
+  fs,
+
+  // redirect stdout / stderr
+
+  // print (text) { console.log(text) },
+  // printErr (text) { console.error(text) }
+})
+
+const imports = {
+  wasi_snapshot_preview1: wasi.wasiImport
+}
+
+const { module, instance } = await load('/path/to/file.wasm', imports)
+wasi.start(instance)
+// wasi.initialize(instance)
+```
+
+Implemented syscalls: [wasi_snapshot_preview1](#wasi_snapshot_preview1)
+
+### `load` / `loadSync`
+
+`loadSync` has 4KB wasm size limit in browser.
+
+```js
+// bundler
+import { load, loadSync } from '@tybys/wasm-util'
+
+const imports = { /* ... */ }
+
+// using path
+const { module, instance } = await load('/path/to/file.wasm', imports)
+const { module, instance } = loadSync('/path/to/file.wasm', imports)
+
+// using URL
+const { module, instance } = await load(new URL('./file.wasm', import.meta.url), imports)
+const { module, instance } = loadSync(new URL('./file.wasm', import.meta.url), imports)
+
+// using Uint8Array
+const buffer = new Uint8Array([
+  0x00, 0x61, 0x73, 0x6d,
+  0x01, 0x00, 0x00, 0x00
+])
+const { module, instance } = await load(buffer, imports)
+const { module, instance } = loadSync(buffer, imports)
+
+// auto asyncify
+const {
+  module,
+  instance: asyncifiedInstance
+} = await load(buffer, imports, { /* asyncify options */})
+asyncifiedInstance.exports.fn() // => return Promise
+```
+
+### Extend Memory instance
+
+```js
+import { Memory, extendMemory } from '@tybys/wasm-util'
+
+const memory = new WebAssembly.Memory({ initial: 256 })
+// const memory = instance.exports.memory
+
+extendMemory(memory)
+console.log(memory instanceof Memory)
+console.log(memory instanceof WebAssembly.Memory)
+// expose memory view getters like Emscripten
+const { HEAPU8, HEAPU32, view } = memory
+```
+
+### Asyncify wrap
+
+Build the C code using `clang`, `wasm-ld` and `wasm-opt`
+
+```c
+void async_sleep(int ms);
+
+int main() {
+  async_sleep(200);
+  return 0;
+}
+```
+
+```js
+import { Asyncify } from '@tybys/wasm-util'
+
+const asyncify = new Asyncify()
+
+const imports = {
+  env: {
+    async_sleep: asyncify.wrapImportFunction(function (ms) {
+      return new Promise((resolve) => {
+        setTimeout(resolve, ms)
+      })
+    })
+  }
+}
+
+// async_sleep(200)
+const bytes = await (await fetch('/asyncfied_by_wasm-opt.wasm')).arrayBuffer()
+const { instance } = await WebAssembly.instantiate(bytes, imports)
+const asyncifiedInstance = asyncify.init(instance.exports.memory, instance, {
+  wrapExports: ['_start']
+})
+
+const p = asyncifedInstance._start()
+console.log(typeof p.then === 'function')
+const now = Date.now()
+await p
+console.log(Date.now() - now >= 200)
+```
+
+### wasi_snapshot_preview1
+
+- [x] args_get
+- [x] args_sizes_get
+- [x] environ_get
+- [x] environ_sizes_get
+- [x] clock_res_get
+- [x] clock_time_get
+- [ ] ~~fd_advise~~
+- [x] fd_allocate
+- [x] fd_close
+- [x] fd_datasync
+- [x] fd_fdstat_get
+- [ ] ~~fd_fdstat_set_flags~~
+- [x] fd_fdstat_set_rights
+- [x] fd_filestat_get
+- [x] fd_filestat_set_size
+- [x] fd_filestat_set_times
+- [x] fd_pread
+- [x] fd_prestat_get
+- [x] fd_prestat_dir_name
+- [x] fd_pwrite
+- [x] fd_read
+- [x] fd_readdir
+- [x] fd_renumber
+- [x] fd_seek
+- [x] fd_sync
+- [x] fd_tell
+- [x] fd_write
+- [x] path_create_directory
+- [x] path_filestat_get
+- [x] path_filestat_set_times
+- [x] path_link
+- [x] path_open
+- [x] path_readlink
+- [x] path_remove_directory
+- [x] path_rename
+- [x] path_symlink
+- [x] path_unlink_file
+- [x] poll_oneoff (timer only)
+- [x] proc_exit
+- [ ] ~~proc_raise~~
+- [x] sched_yield
+- [x] random_get
+- [ ] ~~sock_recv~~
+- [ ] ~~sock_send~~
+- [ ] ~~sock_shutdown~~

package/dist/wasm/node_modules/@tybys/wasm-util/dist/tsdoc-metadata.json

@@ -0,0 +1,11 @@
+// This file is read by tools that parse documentation comments conforming to the TSDoc standard.
+// It should be published with your NPM package.  It should not be tracked by Git.
+{
+  "tsdocVersion": "0.12",
+  "toolPackages": [
+    {
+      "packageName": "@microsoft/api-extractor",
+      "packageVersion": "7.34.4"
+    }
+  ]
+}

package/dist/wasm/node_modules/@tybys/wasm-util/dist/wasm-util.d.ts

@@ -0,0 +1,423 @@
+/**
+ * @packageDocumentation
+ */
+
+/** @public */
+export declare class Asyncify {
+    private value;
+    private exports;
+    private dataPtr;
+    init<T extends WebAssembly.Exports, U extends Array<Exclude<keyof T, AsyncifyExportName>>>(memory: WebAssembly.Memory, instance: {
+        readonly exports: T;
+    }, options: AsyncifyOptions): {
+        readonly exports: AsyncifyExports<T, U>;
+    };
+    private assertState;
+    wrapImportFunction<T extends Function>(f: T): T;
+    wrapImports<T extends WebAssembly.Imports>(imports: T): T;
+    wrapExportFunction<T extends Function>(f: T): AsyncifyExportFunction<T>;
+    wrapExports<T extends WebAssembly.Exports>(exports: T): AsyncifyExports<T, void>;
+    wrapExports<T extends WebAssembly.Exports, U extends Array<Exclude<keyof T, AsyncifyExportName>>>(exports: T, needWrap: U): AsyncifyExports<T, U>;
+}
+
+/** @public */
+export declare type AsyncifyExportFunction<T> = T extends Callable ? (...args: Parameters<T>) => Promise<ReturnType<T>> : T;
+
+/** @public */
+export declare type AsyncifyExportName = 'asyncify_get_state' | 'asyncify_start_unwind' | 'asyncify_stop_unwind' | 'asyncify_start_rewind' | 'asyncify_stop_rewind';
+
+/** @public */
+export declare type AsyncifyExports<T, U> = T extends Record<string, any> ? {
+    [P in keyof T]: T[P] extends Callable ? U extends Array<Exclude<keyof T, AsyncifyExportName>> ? P extends U[number] ? AsyncifyExportFunction<T[P]> : T[P] : AsyncifyExportFunction<T[P]> : T[P];
+} : T;
+
+/** @public */
+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 | WebAssembly.Module, imports?: WebAssembly.Imports): WebAssembly.WebAssemblyInstantiatedSource;
+
+/** @public */
+export declare interface AsyncifyOptions {
+    wasm64?: boolean;
+    tryAllocate?: boolean | {
+        size?: number;
+        name?: string;
+    };
+    wrapExports?: string[];
+}
+
+/** @public */
+export declare interface AsyncWASIOptions extends WASIOptions {
+    fs: {
+        promises: IFsPromises;
+    };
+    asyncify?: Asyncify;
+}
+
+/** @public */
+export declare interface BaseEncodingOptions {
+    encoding?: BufferEncoding_2;
+}
+
+/** @public */
+export declare interface BigIntStats extends StatsBase<bigint> {
+}
+
+/** @public */
+declare type BufferEncoding_2 = 'ascii' | 'utf8' | 'utf-8' | 'utf16le' | 'ucs2' | 'ucs-2' | 'base64' | 'base64url' | 'latin1' | 'binary' | 'hex';
+export { BufferEncoding_2 as BufferEncoding }
+
+/** @public */
+export declare type BufferEncodingOption = 'buffer' | {
+    encoding: '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;
+
+/** @public */
+export declare interface FileHandle {
+    readonly fd: number;
+    datasync(): Promise<void>;
+    sync(): Promise<void>;
+    read<TBuffer extends Uint8Array>(buffer: TBuffer, offset?: number, length?: number, position?: number): Promise<{
+        bytesRead: number;
+        buffer: TBuffer;
+    }>;
+    stat(opts?: StatOptions & {
+        bigint?: false;
+    }): Promise<Stats>;
+    stat(opts: StatOptions & {
+        bigint: true;
+    }): Promise<BigIntStats>;
+    stat(opts?: StatOptions): Promise<Stats | BigIntStats>;
+    truncate(len?: number): Promise<void>;
+    utimes(atime: string | number | Date, mtime: string | number | Date): Promise<void>;
+    write<TBuffer extends Uint8Array>(buffer: TBuffer, offset?: number, length?: number, position?: number): Promise<{
+        bytesWritten: number;
+        buffer: TBuffer;
+    }>;
+    write(data: string | Uint8Array, position?: number, encoding?: BufferEncoding_2): Promise<{
+        bytesWritten: number;
+        buffer: string;
+    }>;
+    close(): Promise<void>;
+}
+
+/** @public */
+export declare interface FinalizeBindingsOptions {
+    memory?: WebAssembly.Memory;
+}
+
+/** @public */
+export declare interface IDirent {
+    isFile(): boolean;
+    isDirectory(): boolean;
+    isBlockDevice(): boolean;
+    isCharacterDevice(): boolean;
+    isSymbolicLink(): boolean;
+    isFIFO(): boolean;
+    isSocket(): boolean;
+    name: string;
+}
+
+/** @public */
+export declare interface IFs {
+    fstatSync(fd: number, options?: StatOptions & {
+        bigint?: false;
+    }): Stats;
+    fstatSync(fd: number, options: StatOptions & {
+        bigint: true;
+    }): BigIntStats;
+    fstatSync(fd: number, options?: StatOptions): Stats | BigIntStats;
+    statSync(path: PathLike, options?: StatOptions & {
+        bigint?: false;
+    }): Stats;
+    statSync(path: PathLike, options: StatOptions & {
+        bigint: true;
+    }): BigIntStats;
+    statSync(path: PathLike, options?: StatOptions): Stats | BigIntStats;
+    lstatSync(path: PathLike, options?: StatOptions & {
+        bigint?: false;
+    }): Stats;
+    lstatSync(path: PathLike, options: StatOptions & {
+        bigint: true;
+    }): BigIntStats;
+    lstatSync(path: PathLike, options?: StatOptions): Stats | BigIntStats;
+    utimesSync(path: PathLike, atime: string | number | Date, mtime: string | number | Date): void;
+    openSync(path: PathLike, flags: OpenMode, mode?: Mode): number;
+    readSync(fd: number, buffer: ArrayBufferView, offset: number, length: number, position: number | null): number;
+    readSync(fd: number, buffer: ArrayBufferView, opts?: ReadSyncOptions): number;
+    writeSync(fd: number, buffer: ArrayBufferView, offset?: number, length?: number, position?: number): number;
+    writeSync(fd: number, string: string, position?: number, encoding?: BufferEncoding_2): number;
+    closeSync(fd: number): void;
+    readlinkSync(path: PathLike, options?: BaseEncodingOptions | BufferEncoding_2): string;
+    readlinkSync(path: PathLike, options: BufferEncodingOption): Uint8Array;
+    readlinkSync(path: PathLike, options?: BaseEncodingOptions | string): string | Uint8Array;
+    realpathSync(path: PathLike, options?: BaseEncodingOptions | BufferEncoding_2): string;
+    realpathSync(path: PathLike, options: BufferEncodingOption): Uint8Array;
+    realpathSync(path: PathLike, options?: BaseEncodingOptions | string): string | Uint8Array;
+    truncateSync(path: PathLike, len?: number): void;
+    ftruncateSync(fd: number, len?: number): void;
+    fdatasyncSync(fd: number): void;
+    futimesSync(fd: number, atime: string | number | Date, mtime: string | number | Date): void;
+    readdirSync(path: PathLike, options?: {
+        encoding: BufferEncoding_2 | null;
+        withFileTypes?: false;
+    } | BufferEncoding_2): string[];
+    readdirSync(path: PathLike, options: {
+        encoding: 'buffer';
+        withFileTypes?: false;
+    } | 'buffer'): Uint8Array[];
+    readdirSync(path: PathLike, options?: BaseEncodingOptions & {
+        withFileTypes?: false;
+    } | BufferEncoding_2): string[] | Uint8Array[];
+    readdirSync(path: PathLike, options: BaseEncodingOptions & {
+        withFileTypes: true;
+    }): IDirent[];
+    fsyncSync(fd: number): void;
+    mkdirSync(path: PathLike, options: MakeDirectoryOptions & {
+        recursive: true;
+    }): string | undefined;
+    mkdirSync(path: PathLike, options?: Mode | (MakeDirectoryOptions & {
+        recursive?: false;
+    })): void;
+    mkdirSync(path: PathLike, options?: Mode | MakeDirectoryOptions): string | undefined;
+    rmdirSync(path: PathLike, options?: RmDirOptions): void;
+    linkSync(existingPath: PathLike, newPath: PathLike): void;
+    unlinkSync(path: PathLike): void;
+    renameSync(oldPath: PathLike, newPath: PathLike): void;
+    symlinkSync(target: PathLike, path: PathLike, type?: 'dir' | 'file' | 'junction'): void;
+}
+
+/** @public */
+export declare interface IFsPromises {
+    stat(path: PathLike, options?: StatOptions & {
+        bigint?: false;
+    }): Promise<Stats>;
+    stat(path: PathLike, options: StatOptions & {
+        bigint: true;
+    }): Promise<BigIntStats>;
+    stat(path: PathLike, options?: StatOptions): Promise<Stats | BigIntStats>;
+    lstat(path: PathLike, options?: StatOptions & {
+        bigint?: false;
+    }): Promise<Stats>;
+    lstat(path: PathLike, options: StatOptions & {
+        bigint: true;
+    }): Promise<BigIntStats>;
+    lstat(path: PathLike, options?: StatOptions): Promise<Stats | BigIntStats>;
+    utimes(path: PathLike, atime: string | number | Date, mtime: string | number | Date): Promise<void>;
+    open(path: PathLike, flags: OpenMode, mode?: Mode): Promise<FileHandle>;
+    read<TBuffer extends Uint8Array>(handle: FileHandle, buffer: TBuffer, offset?: number, length?: number, position?: number): Promise<{
+        bytesRead: number;
+        buffer: TBuffer;
+    }>;
+    write<TBuffer extends Uint8Array>(handle: FileHandle, buffer: TBuffer, offset?: number, length?: number, position?: number): Promise<{
+        bytesWritten: number;
+        buffer: TBuffer;
+    }>;
+    readlink(path: PathLike, options?: BaseEncodingOptions | BufferEncoding_2): Promise<string>;
+    readlink(path: PathLike, options: BufferEncodingOption): Promise<Uint8Array>;
+    readlink(path: PathLike, options?: BaseEncodingOptions | string): Promise<string | Uint8Array>;
+    realpath(path: PathLike, options?: BaseEncodingOptions | BufferEncoding_2): Promise<string>;
+    realpath(path: PathLike, options: BufferEncodingOption): Promise<Uint8Array>;
+    realpath(path: PathLike, options?: BaseEncodingOptions | string): Promise<string | Uint8Array>;
+    truncate(path: PathLike, len?: number): Promise<void>;
+    ftruncate(handle: FileHandle, len?: number): Promise<void>;
+    fdatasync(handle: FileHandle): Promise<void>;
+    futimes(handle: FileHandle, atime: string | number | Date, mtime: string | number | Date): Promise<void>;
+    readdir(path: PathLike, options?: {
+        encoding: BufferEncoding_2 | null;
+        withFileTypes?: false;
+    } | BufferEncoding_2): Promise<string[]>;
+    readdir(path: PathLike, options: {
+        encoding: 'buffer';
+        withFileTypes?: false;
+    } | 'buffer'): Promise<Uint8Array[]>;
+    readdir(path: PathLike, options?: BaseEncodingOptions & {
+        withFileTypes?: false;
+    } | BufferEncoding_2): Promise<string[] | Uint8Array[]>;
+    readdir(path: PathLike, options: BaseEncodingOptions & {
+        withFileTypes: true;
+    }): Promise<IDirent[]>;
+    fsync(handle: FileHandle): Promise<void>;
+    mkdir(path: PathLike, options: MakeDirectoryOptions & {
+        recursive: true;
+    }): Promise<string | undefined>;
+    mkdir(path: PathLike, options?: Mode | (MakeDirectoryOptions & {
+        recursive?: false;
+    })): Promise<void>;
+    mkdir(path: PathLike, options?: Mode | MakeDirectoryOptions): Promise<string | undefined>;
+    rmdir(path: PathLike, options?: RmDirOptions): Promise<void>;
+    link(existingPath: PathLike, newPath: PathLike): Promise<void>;
+    unlink(path: PathLike): Promise<void>;
+    rename(oldPath: PathLike, newPath: PathLike): Promise<void>;
+    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;
+
+declare const kSetMemory: unique symbol;
+
+declare const kStarted: unique symbol;
+
+/** @public */
+export declare function load(wasmInput: string | URL | BufferSource | WebAssembly.Module, imports?: WebAssembly.Imports): Promise<WebAssembly.WebAssemblyInstantiatedSource>;
+
+/** @public */
+export declare function loadSync(wasmInput: BufferSource | WebAssembly.Module, imports?: WebAssembly.Imports): WebAssembly.WebAssemblyInstantiatedSource;
+
+/** @public */
+export declare interface MakeDirectoryOptions {
+    recursive?: boolean;
+    mode?: Mode;
+}
+
+/** @public */
+export declare class Memory extends WebAssemblyMemory {
+    constructor(descriptor: WebAssembly.MemoryDescriptor);
+    get HEAP8(): Int8Array;
+    get HEAPU8(): Uint8Array;
+    get HEAP16(): Int16Array;
+    get HEAPU16(): Uint16Array;
+    get HEAP32(): Int32Array;
+    get HEAPU32(): Uint32Array;
+    get HEAP64(): BigInt64Array;
+    get HEAPU64(): BigUint64Array;
+    get HEAPF32(): Float32Array;
+    get HEAPF64(): Float64Array;
+    get view(): DataView;
+}
+
+/** @public */
+export declare type Mode = number | string;
+
+/** @public */
+export declare type OpenMode = number | string;
+
+/** @public */
+export declare type PathLike = string | Uint8Array | URL;
+
+/** @public */
+export declare type PromisifyExports<T, U> = T extends Record<string, any> ? {
+    [P in keyof T]: T[P] extends Callable ? U extends Array<keyof T> ? P extends U[number] ? AsyncifyExportFunction<T[P]> : T[P] : AsyncifyExportFunction<T[P]> : T[P];
+} : T;
+
+/** @public */
+export declare interface ReadSyncOptions {
+    offset?: number;
+    length?: number;
+    position?: number;
+}
+
+/** @public */
+export declare interface RmDirOptions {
+    maxRetries?: number;
+    recursive?: boolean;
+    retryDelay?: number;
+}
+
+/** @public */
+export declare interface StatOptions {
+    bigint?: boolean;
+}
+
+/** @public */
+export declare interface Stats extends StatsBase<number> {
+}
+
+/** @public */
+export declare interface StatsBase<T> {
+    isFile(): boolean;
+    isDirectory(): boolean;
+    isBlockDevice(): boolean;
+    isCharacterDevice(): boolean;
+    isSymbolicLink(): boolean;
+    isFIFO(): boolean;
+    isSocket(): boolean;
+    dev: T;
+    ino: T;
+    mode: T;
+    nlink: T;
+    uid: T;
+    gid: T;
+    rdev: T;
+    size: T;
+    blksize: T;
+    blocks: T;
+    atimeMs: T;
+    mtimeMs: T;
+    ctimeMs: T;
+    birthtimeMs: T;
+    atime: Date;
+    mtime: Date;
+    ctime: Date;
+    birthtime: Date;
+}
+
+/** @public */
+export declare interface SyncWASIOptions extends WASIOptions {
+    fs?: IFs;
+}
+
+/** @public */
+export declare class WASI {
+    private [kSetMemory];
+    private [kStarted];
+    private [kExitCode];
+    private [kInstance];
+    private [kBindingName];
+    readonly wasiImport: Record<string, any>;
+    constructor(options?: SyncWASIOptions);
+    finalizeBindings(instance: WebAssembly.Instance, { memory }?: FinalizeBindingsOptions): void;
+    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;
+    /**
+     * @defaultValue `false`
+     */
+    returnOnExit?: boolean | undefined;
+    print?: (str: string) => void;
+    printErr?: (str: string) => void;
+}
+
+/** @public */
+export declare const WebAssemblyMemory: {
+    new (descriptor: WebAssembly.MemoryDescriptor): WebAssembly.Memory;
+    prototype: WebAssembly.Memory;
+};
+
+/** @public */
+export declare function wrapAsyncExport<T extends Function = any>(f: Function): T;
+
+/** @public */
+export declare function wrapAsyncImport<T extends (...args: any[]) => any>(f: T, parameterType: WebAssembly.ValueType[], returnType: WebAssembly.ValueType[]): (...args: [object, ...Parameters<T>]) => ReturnType<T>;
+
+/** @public */
+export declare function wrapExports<T extends WebAssembly.Exports>(exports: T): PromisifyExports<T, void>;
+
+/** @public */
+export declare function wrapExports<T extends WebAssembly.Exports, U extends Array<keyof T>>(exports: T, needWrap: U): PromisifyExports<T, U>;
+
+export { }
+
+export as namespace wasmUtil;