@ruby/wasm-wasi 2.3.0 → 2.4.0

package/dist/cjs/browser.script.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = void 0;
+const tslib_1 = require("tslib");
+const browser_js_1 = require("./browser.js");
+const main = async (pkg, options) => {
+    const response = fetch(`https://cdn.jsdelivr.net/npm/${pkg.name}@${pkg.version}/dist/ruby+stdlib.wasm`);
+    const module = await compileWebAssemblyModule(response);
+    const { vm } = await (0, browser_js_1.DefaultRubyVM)(module, options);
+    vm.printVersion();
+    globalThis.rubyVM = vm;
+    // Wait for the text/ruby script tag to be read.
+    // It may take some time to read ruby+stdlib.wasm
+    // and DOMContentLoaded has already been fired.
+    if (document.readyState === "loading") {
+        document.addEventListener("DOMContentLoaded", () => runRubyScriptsInHtml(vm));
+    }
+    else {
+        runRubyScriptsInHtml(vm);
+    }
+};
+exports.main = main;
+const runRubyScriptsInHtml = async (vm) => {
+    var _a, e_1, _b, _c;
+    const tags = document.querySelectorAll('script[type="text/ruby"]');
+    // Get Ruby scripts in parallel.
+    const promisingRubyScripts = Array.from(tags).map((tag) => loadScriptAsync(tag));
+    try {
+        // Run Ruby scripts sequentially.
+        for (var _d = true, promisingRubyScripts_1 = tslib_1.__asyncValues(promisingRubyScripts), promisingRubyScripts_1_1; promisingRubyScripts_1_1 = await promisingRubyScripts_1.next(), _a = promisingRubyScripts_1_1.done, !_a; _d = true) {
+            _c = promisingRubyScripts_1_1.value;
+            _d = false;
+            const script = _c;
+            if (script) {
+                const { scriptContent, evalStyle } = script;
+                switch (evalStyle) {
+                    case "async":
+                        vm.evalAsync(scriptContent);
+                        break;
+                    case "sync":
+                        vm.eval(scriptContent);
+                        break;
+                }
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (!_d && !_a && (_b = promisingRubyScripts_1.return)) await _b.call(promisingRubyScripts_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+};
+const deriveEvalStyle = (tag) => {
+    const rawEvalStyle = tag.getAttribute("data-eval") || "sync";
+    if (rawEvalStyle !== "async" && rawEvalStyle !== "sync") {
+        console.warn(`data-eval attribute of script tag must be "async" or "sync". ${rawEvalStyle} is ignored and "sync" is used instead.`);
+        return "sync";
+    }
+    return rawEvalStyle;
+};
+const loadScriptAsync = async (tag) => {
+    const evalStyle = deriveEvalStyle(tag);
+    // Inline comments can be written with the src attribute of the script tag.
+    // The presence of the src attribute is checked before the presence of the inline.
+    // see: https://html.spec.whatwg.org/multipage/scripting.html#inline-documentation-for-external-scripts
+    if (tag.hasAttribute("src")) {
+        const url = tag.getAttribute("src");
+        const response = await fetch(url);
+        if (response.ok) {
+            return { scriptContent: await response.text(), evalStyle };
+        }
+        return Promise.resolve(null);
+    }
+    return Promise.resolve({ scriptContent: tag.innerHTML, evalStyle });
+};
+// WebAssembly.compileStreaming is a relatively new API.
+// For example, it is not available in iOS Safari 14,
+// so check whether WebAssembly.compileStreaming is available and
+// fall back to the existing implementation using WebAssembly.compile if not.
+const compileWebAssemblyModule = async function (response) {
+    if (!WebAssembly.compileStreaming) {
+        const buffer = await (await response).arrayBuffer();
+        return WebAssembly.compile(buffer);
+    }
+    else {
+        return WebAssembly.compileStreaming(response);
+    }
+};

package/dist/cjs/console.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Create a console printer that can be used as an overlay of WASI imports.
+ * See the example below for how to use it.
+ *
+ * ```javascript
+ * const imports = {
+ *  "wasi_snapshot_preview1": wasi.wasiImport,
+ * }
+ * const printer = consolePrinter();
+ * printer.addToImports(imports);
+ *
+ * const instance = await WebAssembly.instantiate(module, imports);
+ * printer.setMemory(instance.exports.memory);
+ * ```
+ *
+ * Note that the `stdout` and `stderr` functions are called with text, not
+ * bytes. This means that bytes written to stdout/stderr will be decoded as
+ * UTF-8 and then passed to the `stdout`/`stderr` functions every time a write
+ * occurs without buffering.
+ *
+ * @param stdout A function that will be called when stdout is written to.
+ *               Defaults to `console.log`.
+ * @param stderr A function that will be called when stderr is written to.
+ *               Defaults to `console.warn`.
+ * @returns An object that can be used as an overlay of WASI imports.
+ */
+export declare function consolePrinter({ stdout, stderr, }?: {
+    stdout: (str: string) => void;
+    stderr: (str: string) => void;
+}): {
+    addToImports(imports: WebAssembly.Imports): void;
+    setMemory(m: WebAssembly.Memory): void;
+};

package/dist/cjs/console.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.consolePrinter = void 0;
+/**
+ * Create a console printer that can be used as an overlay of WASI imports.
+ * See the example below for how to use it.
+ *
+ * ```javascript
+ * const imports = {
+ *  "wasi_snapshot_preview1": wasi.wasiImport,
+ * }
+ * const printer = consolePrinter();
+ * printer.addToImports(imports);
+ *
+ * const instance = await WebAssembly.instantiate(module, imports);
+ * printer.setMemory(instance.exports.memory);
+ * ```
+ *
+ * Note that the `stdout` and `stderr` functions are called with text, not
+ * bytes. This means that bytes written to stdout/stderr will be decoded as
+ * UTF-8 and then passed to the `stdout`/`stderr` functions every time a write
+ * occurs without buffering.
+ *
+ * @param stdout A function that will be called when stdout is written to.
+ *               Defaults to `console.log`.
+ * @param stderr A function that will be called when stderr is written to.
+ *               Defaults to `console.warn`.
+ * @returns An object that can be used as an overlay of WASI imports.
+ */
+function consolePrinter({ stdout, stderr, } = {
+    stdout: console.log,
+    stderr: console.warn,
+}) {
+    let memory = undefined;
+    let _view = undefined;
+    function getMemoryView() {
+        if (typeof memory === "undefined") {
+            throw new Error("Memory is not set");
+        }
+        if (_view === undefined || _view.buffer.byteLength === 0) {
+            _view = new DataView(memory.buffer);
+        }
+        return _view;
+    }
+    const decoder = new TextDecoder();
+    return {
+        addToImports(imports) {
+            const wasiImport = imports.wasi_snapshot_preview1;
+            const original_fd_write = wasiImport.fd_write;
+            wasiImport.fd_write = (fd, iovs, iovsLen, nwritten) => {
+                if (fd !== 1 && fd !== 2) {
+                    return original_fd_write(fd, iovs, iovsLen, nwritten);
+                }
+                const view = getMemoryView();
+                const buffers = Array.from({ length: iovsLen }, (_, i) => {
+                    const ptr = iovs + i * 8;
+                    const buf = view.getUint32(ptr, true);
+                    const bufLen = view.getUint32(ptr + 4, true);
+                    return new Uint8Array(memory.buffer, buf, bufLen);
+                });
+                let written = 0;
+                let str = "";
+                for (const buffer of buffers) {
+                    str += decoder.decode(buffer);
+                    written += buffer.byteLength;
+                }
+                view.setUint32(nwritten, written, true);
+                const log = fd === 1 ? stdout : stderr;
+                log(str);
+                return 0;
+            };
+            const original_fd_filestat_get = wasiImport.fd_filestat_get;
+            wasiImport.fd_filestat_get = (fd, filestat) => {
+                if (fd !== 1 && fd !== 2) {
+                    return original_fd_filestat_get(fd, filestat);
+                }
+                const view = getMemoryView();
+                const result = original_fd_filestat_get(fd, filestat);
+                if (result !== 0) {
+                    return result;
+                }
+                const filetypePtr = filestat + 0;
+                view.setUint8(filetypePtr, 2); // FILETYPE_CHARACTER_DEVICE
+                return 0;
+            };
+            const original_fd_fdstat_get = wasiImport.fd_fdstat_get;
+            wasiImport.fd_fdstat_get = (fd, fdstat) => {
+                if (fd !== 1 && fd !== 2) {
+                    return original_fd_fdstat_get(fd, fdstat);
+                }
+                const view = getMemoryView();
+                const fs_filetypePtr = fdstat + 0;
+                view.setUint8(fs_filetypePtr, 2); // FILETYPE_CHARACTER_DEVICE
+                const fs_rights_basePtr = fdstat + 8;
+                view.setBigUint64(fs_rights_basePtr, BigInt(1)); // RIGHTS_FD_WRITE
+                return 0;
+            };
+        },
+        setMemory(m) {
+            memory = m;
+        },
+    };
+}
+exports.consolePrinter = consolePrinter;

package/dist/{index.d.ts → cjs/index.d.ts}

@@ -1,5 +1,6 @@
-import * as RbAbi from "./bindgen/rb-abi-guest";
-import { JsAbiValue } from "./bindgen/rb-js-abi-host";
+import * as RbAbi from "./bindgen/rb-abi-guest.js";
+import { JsAbiValue } from "./bindgen/rb-js-abi-host.js";
+export { consolePrinter } from "./console.js";
 /**
  * A Ruby VM instance
  *
@@ -89,7 +90,9 @@ export declare class RubyVM {
      * hash.call("store", vm.eval(`"key1"`), vm.wrap(new Object()));
      */
     wrap(value: any): RbValue;
+    /** @private */
     private privateObject;
+    /** @private */
     private rbValueOfPointer;
 }
 /**
@@ -167,7 +170,9 @@ type RubyVMPrivate = {
 };
 declare class RbExceptionFormatter {
     private literalsCache;
+    private isFormmatting;
     format(error: RbValue, vm: RubyVM, privateObject: RubyVMPrivate): string;
+    private _format;
     formatString(klass: string, message: string, backtrace?: [string, string]): string;
 }
 /**
@@ -189,4 +194,3 @@ export declare class RbFatalError extends RbError {
      */
     constructor(message: string);
 }
-export {};