@yodaos-pkg/ink 0.2.0 → 0.3.0

package/dist/env.js

@@ -3,6 +3,21 @@ const allocationSizes = new Map();
 const textDecoder = new TextDecoder('utf-8', { fatal: false });
 const textEncoder = new TextEncoder();
 let inkRequestInterceptor = null;
+const hrtimeOriginNs =
+  typeof performance !== 'undefined' && typeof performance.now === 'function'
+    ? BigInt(Math.floor(performance.now() * 1_000_000))
+    : 0n;
+
+export function rquickjs_browser_date_now_us() {
+  return BigInt(Date.now()) * 1000n;
+}
+
+export function rquickjs_browser_hrtime_ns() {
+  if (typeof performance !== 'undefined' && typeof performance.now === 'function') {
+    return BigInt(Math.floor(performance.now() * 1_000_000)) - hrtimeOriginNs;
+  }
+  return BigInt(Date.now()) * 1_000_000n;
+}
 
 export function __setWasmInstance(exports) {
   wasmExports = exports;
@@ -39,7 +54,10 @@ function headersToObject(headersLike) {
   }
   if (headersLike && typeof headersLike === 'object') {
     return Object.fromEntries(
-      Object.entries(headersLike).map(([name, value]) => [name, Array.isArray(value) ? value.join(', ') : String(value)]),
+      Object.entries(headersLike).map(([name, value]) => [
+        name,
+        Array.isArray(value) ? value.join(', ') : String(value),
+      ]),
     );
   }
   return {};
@@ -156,7 +174,12 @@ export async function __inkFetch(input, init, metadata) {
 }
 
 export async function fetchWithInkRequestInterceptor(input, init = {}, options = {}) {
-  const resolved = await resolveInkFetchRequest(input, init, options.metadata, options.interceptor || null);
+  const resolved = await resolveInkFetchRequest(
+    input,
+    init,
+    options.metadata,
+    options.interceptor || null,
+  );
   const fetchImpl = ensureFetchImplementation(options.fetch);
   return fetchImpl(resolved.url, resolved.init);
 }
@@ -229,8 +252,243 @@ function consoleWrite(prefix, text) {
   console.log(value);
 }
 
-function formatPrintf(fmtPtr) {
-  return readCString(fmtPtr);
+function readCStringWithLength(ptr, maxBytes) {
+  ptr >>>= 0;
+  const bytes = memoryBytes();
+  let end = ptr;
+  const maxEnd = Math.min(bytes.length, ptr + Math.max(0, maxBytes | 0));
+  while (end < maxEnd && bytes[end] !== 0) {
+    end += 1;
+  }
+  return textDecoder.decode(bytes.subarray(ptr, end));
+}
+
+function normalizePrintfValue(value) {
+  if (typeof value === 'bigint') {
+    return value;
+  }
+  if (typeof value === 'number') {
+    return Number.isFinite(value) ? value : 0;
+  }
+  if (value == null) {
+    return 0;
+  }
+  return Number(value) || 0;
+}
+
+function createDirectArgumentReader(values, offset) {
+  let index = offset;
+  return {
+    next() {
+      const value = index < values.length ? values[index] : 0;
+      index += 1;
+      return value;
+    },
+    nextInt32() {
+      return Number(normalizePrintfValue(this.next())) | 0;
+    },
+    nextUint32() {
+      return Number(normalizePrintfValue(this.next())) >>> 0;
+    },
+    nextPointer() {
+      return Number(normalizePrintfValue(this.next())) >>> 0;
+    },
+    nextFloat64() {
+      return Number(normalizePrintfValue(this.next()));
+    },
+  };
+}
+
+function createVaListReader(argsPtr) {
+  let cursor = argsPtr >>> 0;
+  const view = memoryView();
+  const nextSlot = () => {
+    const slot = cursor;
+    cursor = (cursor + 8) >>> 0;
+    return slot;
+  };
+  return {
+    nextInt32() {
+      return view.getInt32(nextSlot(), true);
+    },
+    nextUint32() {
+      return view.getUint32(nextSlot(), true);
+    },
+    nextPointer() {
+      return view.getUint32(nextSlot(), true);
+    },
+    nextFloat64() {
+      return view.getFloat64(nextSlot(), true);
+    },
+  };
+}
+
+function formatInteger(value, {
+  signed = true,
+  base = 10,
+  width = 0,
+  padZero = false,
+  uppercase = false,
+} = {}) {
+  let normalized = normalizePrintfValue(value);
+  let negative = false;
+  let digits = '';
+
+  if (typeof normalized === 'bigint') {
+    if (signed && normalized < 0n) {
+      negative = true;
+      normalized = -normalized;
+    } else if (!signed) {
+      normalized = BigInt.asUintN(64, normalized);
+    }
+    digits = normalized.toString(base);
+  } else {
+    let numberValue = Math.trunc(Number(normalized) || 0);
+    if (signed) {
+      negative = numberValue < 0;
+      numberValue = Math.abs(numberValue);
+      digits = numberValue.toString(base);
+    } else {
+      digits = (numberValue >>> 0).toString(base);
+    }
+  }
+
+  if (uppercase) {
+    digits = digits.toUpperCase();
+  }
+
+  const prefix = negative ? '-' : '';
+  const paddedDigits = padZero && width > prefix.length + digits.length
+    ? digits.padStart(width - prefix.length, '0')
+    : digits;
+  const result = `${prefix}${paddedDigits}`;
+  return !padZero && width > result.length
+    ? result.padStart(width, ' ')
+    : result;
+}
+
+function formatStringValue(value, precision) {
+  if (typeof value === 'string') {
+    return precision == null ? value : value.slice(0, precision);
+  }
+  const ptr = Number(normalizePrintfValue(value)) >>> 0;
+  if (ptr === 0) {
+    return '(null)';
+  }
+  if (precision == null) {
+    return readCString(ptr);
+  }
+  return readCStringWithLength(ptr, precision);
+}
+
+function formatPrintf(fmtPtr, reader = null) {
+  const fmt = readCString(fmtPtr);
+  if (!reader) {
+    return fmt;
+  }
+
+  let result = '';
+  for (let i = 0; i < fmt.length; i += 1) {
+    const ch = fmt[i];
+    if (ch !== '%') {
+      result += ch;
+      continue;
+    }
+
+    const next = fmt[i + 1];
+    if (next === '%') {
+      result += '%';
+      i += 1;
+      continue;
+    }
+
+    let cursor = i + 1;
+    let padZero = false;
+    if (fmt[cursor] === '0') {
+      padZero = true;
+      cursor += 1;
+    }
+
+    let widthText = '';
+    while (cursor < fmt.length && /[0-9]/.test(fmt[cursor])) {
+      widthText += fmt[cursor];
+      cursor += 1;
+    }
+    const width = widthText ? Number.parseInt(widthText, 10) : 0;
+
+    let precision = null;
+    if (fmt[cursor] === '.') {
+      cursor += 1;
+      if (fmt[cursor] === '*') {
+        precision = Math.max(0, reader.nextInt32());
+        cursor += 1;
+      } else {
+        let precisionText = '';
+        while (cursor < fmt.length && /[0-9]/.test(fmt[cursor])) {
+          precisionText += fmt[cursor];
+          cursor += 1;
+        }
+        precision = precisionText ? Number.parseInt(precisionText, 10) : 0;
+      }
+    }
+
+    while (cursor < fmt.length && /[hljztL]/.test(fmt[cursor])) {
+      cursor += 1;
+    }
+
+    const specifier = fmt[cursor];
+    if (!specifier) {
+      result += '%';
+      break;
+    }
+
+    switch (specifier) {
+      case 's':
+        result += formatStringValue(reader.nextPointer(), precision);
+        break;
+      case 'c':
+        result += String.fromCodePoint(reader.nextInt32() >>> 0);
+        break;
+      case 'd':
+      case 'i':
+        result += formatInteger(reader.nextInt32(), {
+          signed: true,
+          base: 10,
+          width,
+          padZero,
+        });
+        break;
+      case 'u':
+        result += formatInteger(reader.nextUint32(), {
+          signed: false,
+          base: 10,
+          width,
+          padZero,
+        });
+        break;
+      case 'x':
+      case 'X':
+        result += formatInteger(reader.nextUint32(), {
+          signed: false,
+          base: 16,
+          width,
+          padZero,
+          uppercase: specifier === 'X',
+        });
+        break;
+      case 'f':
+      case 'g':
+        result += String(reader.nextFloat64());
+        break;
+      default:
+        result += `%${fmt.slice(i + 1, cursor + 1)}`;
+        break;
+    }
+
+    i = cursor;
+  }
+
+  return result;
 }
 
 function parseNumberPrefix(text) {
@@ -262,8 +520,8 @@ export function __assert_fail(assertionPtr, filePtr, line, functionPtr) {
   throw new Error(`assertion failed: ${assertion} at ${file}:${line} in ${func}`);
 }
 
-export function printf(fmtPtr, _argsPtr) {
-  const message = formatPrintf(fmtPtr);
+export function printf(fmtPtr) {
+  const message = formatPrintf(fmtPtr, createDirectArgumentReader(arguments, 1));
   consoleWrite('', message);
   return message.length | 0;
 }
@@ -284,8 +542,8 @@ export function putchar(ch) {
   return ch | 0;
 }
 
-export function fprintf(_stream, fmtPtr, _argsPtr) {
-  const message = formatPrintf(fmtPtr);
+export function fprintf(_stream, fmtPtr) {
+  const message = formatPrintf(fmtPtr, createDirectArgumentReader(arguments, 2));
   consoleWrite('', message);
   return message.length | 0;
 }
@@ -301,12 +559,12 @@ export function fputc(ch, _stream) {
   return putchar(ch);
 }
 
-export function vsnprintf(dst, size, fmtPtr, _argsPtr) {
-  return writeCString(dst, size, formatPrintf(fmtPtr)) | 0;
+export function vsnprintf(dst, size, fmtPtr, argsPtr) {
+  return writeCString(dst, size, formatPrintf(fmtPtr, createVaListReader(argsPtr))) | 0;
 }
 
-export function snprintf(dst, size, fmtPtr, _arg3) {
-  return writeCString(dst, size, formatPrintf(fmtPtr)) | 0;
+export function snprintf(dst, size, fmtPtr) {
+  return writeCString(dst, size, formatPrintf(fmtPtr, createDirectArgumentReader(arguments, 3))) | 0;
 }
 
 export function scalbn(x, n) {

package/dist/index.d.ts

@@ -1,8 +1,4 @@
-export type BundleFileInput =
-  | string
-  | Uint8Array
-  | ArrayBuffer
-  | ArrayBufferView;
+export type BundleFileInput = string | Uint8Array | ArrayBuffer | ArrayBufferView;
 
 export type BundleFiles =
   | Map<string, BundleFileInput>
@@ -113,28 +109,31 @@ export declare function getInkVersion(): string;
 
 export declare function normalizeBundleFiles(files: BundleFiles): Map<string, Uint8Array>;
 
-export declare function serializeQuery(query: string | Record<string, unknown> | null | undefined): string | null;
+export declare function serializeQuery(
+  query: string | Record<string, unknown> | null | undefined,
+): string | null;
 
 export declare function createProxyUrlResolver(options: {
   proxyUrl: string;
   targetSearchParam?: string;
 }): InkRequestInterceptor;
 
-export declare function setInkRequestInterceptor(interceptor: InkRequestInterceptor | null | undefined): void;
+export declare function setInkRequestInterceptor(
+  interceptor: InkRequestInterceptor | null | undefined,
+): void;
 
 export declare function clearInkRequestInterceptor(): void;
 
 export declare function configureNetwork(options?: ConfigureNetworkOptions): void;
 
-export declare function createVfsUrls(input: {
-  baseUrl: string;
-  appId: string;
-}): {
+export declare function createVfsUrls(input: { baseUrl: string; appId: string }): {
   manifestUrl: string;
   fileUrl(filePath: string): string;
 };
 
-export declare function loadBundleFromVfs(options: LoadBundleFromVfsOptions): Promise<LoadedVfsBundle>;
+export declare function loadBundleFromVfs(
+  options: LoadBundleFromVfsOptions,
+): Promise<LoadedVfsBundle>;
 
 export declare class InkView {
   static create(options: CreateInkViewOptions): Promise<InkView>;

package/dist/index.js

@@ -45,7 +45,9 @@ function cloneUint8Array(value) {
     return new Uint8Array(value);
   }
   if (ArrayBuffer.isView(value)) {
-    return new Uint8Array(value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength));
+    return new Uint8Array(
+      value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength),
+    );
   }
   if (value instanceof ArrayBuffer) {
     return new Uint8Array(value.slice(0));
@@ -284,7 +286,8 @@ export async function initInk(options = {}) {
   }
 
   if (!bindingsPromise) {
-    const initInput = options.wasmUrl || options.moduleOrPath || new URL('./pkg/ink_web_bg.wasm', import.meta.url);
+    const initInput =
+      options.wasmUrl || options.moduleOrPath || new URL('./pkg/ink_web_bg.wasm', import.meta.url);
     bindingsPromise = initInkWasm(initInput).then(() => ({
       InkWebView: RawInkWebView,
       getInkVersion: getInkVersionFromWasm,
@@ -309,7 +312,11 @@ export class InkView {
     }
 
     const bindings = await initInk(config.wasm);
-    const rawView = new bindings.InkWebView(width, height, Number(config.scaleFactor || getDefaultScaleFactor()));
+    const rawView = new bindings.InkWebView(
+      width,
+      height,
+      Number(config.scaleFactor || getDefaultScaleFactor()),
+    );
     const view = new InkView(rawView, config);
 
     if (config.canvas) {
@@ -376,22 +383,54 @@ export class InkView {
       if (focusTarget && typeof focusTarget.focus === 'function') {
         focusTarget.focus();
       }
-      this.#rawView.dispatchPointer('pointerdown', x, y, event.pointerId || 0, event.button || 0, 0, 0);
+      this.#rawView.dispatchPointer(
+        'pointerdown',
+        x,
+        y,
+        event.pointerId || 0,
+        event.button || 0,
+        0,
+        0,
+      );
       this.requestRender();
     });
     addListener(canvas, 'pointermove', (event) => {
       const { x, y } = getPointerPosition(canvas, event);
-      this.#rawView.dispatchPointer('pointermove', x, y, event.pointerId || 0, event.button || 0, 0, 0);
+      this.#rawView.dispatchPointer(
+        'pointermove',
+        x,
+        y,
+        event.pointerId || 0,
+        event.button || 0,
+        0,
+        0,
+      );
       this.requestRender();
     });
     addListener(canvas, 'pointerup', (event) => {
       const { x, y } = getPointerPosition(canvas, event);
-      this.#rawView.dispatchPointer('pointerup', x, y, event.pointerId || 0, event.button || 0, 0, 0);
+      this.#rawView.dispatchPointer(
+        'pointerup',
+        x,
+        y,
+        event.pointerId || 0,
+        event.button || 0,
+        0,
+        0,
+      );
       this.requestRender();
     });
     addListener(canvas, 'pointercancel', (event) => {
       const { x, y } = getPointerPosition(canvas, event);
-      this.#rawView.dispatchPointer('touchcancel', x, y, event.pointerId || 0, event.button || 0, 0, 0);
+      this.#rawView.dispatchPointer(
+        'touchcancel',
+        x,
+        y,
+        event.pointerId || 0,
+        event.button || 0,
+        0,
+        0,
+      );
       this.requestRender();
     });
     addListener(
@@ -402,18 +441,34 @@ export class InkView {
         if (options.preventWheelDefault !== false && typeof event.preventDefault === 'function') {
           event.preventDefault();
         }
-        this.#rawView.dispatchPointer('mousewheel', x, y, 0, 0, event.deltaX || 0, event.deltaY || 0);
+        this.#rawView.dispatchPointer(
+          'mousewheel',
+          x,
+          y,
+          0,
+          0,
+          event.deltaX || 0,
+          event.deltaY || 0,
+        );
         this.requestRender();
       },
       { passive: false },
     );
 
     addListener(keyboardTarget, 'keydown', (event) => {
-      this.#rawView.dispatchInput('keydown', normalizeKeyboardCode(event), Number(event.timeStamp || Date.now()));
+      this.#rawView.dispatchInput(
+        'keydown',
+        normalizeKeyboardCode(event),
+        Number(event.timeStamp || Date.now()),
+      );
       this.requestRender();
     });
     addListener(keyboardTarget, 'keyup', (event) => {
-      this.#rawView.dispatchInput('keyup', normalizeKeyboardCode(event), Number(event.timeStamp || Date.now()));
+      this.#rawView.dispatchInput(
+        'keyup',
+        normalizeKeyboardCode(event),
+        Number(event.timeStamp || Date.now()),
+      );
       this.requestRender();
     });
     addListener(focusTarget, 'focus', () => {
@@ -438,7 +493,12 @@ export class InkView {
       throw new Error('`appId` must be a non-empty string.');
     }
 
-    this.#rawView.openBundle(appId, normalizeBundleFiles(files), initialPage, serializeQuery(query));
+    this.#rawView.openBundle(
+      appId,
+      normalizeBundleFiles(files),
+      initialPage,
+      serializeQuery(query),
+    );
     this.requestRender();
     return this;
   }

package/dist/pkg/ink_web.d.ts

@@ -41,11 +41,11 @@ export interface InitOutput {
     readonly inkwebview_render: (a: number, b: number) => void;
     readonly inkwebview_resize: (a: number, b: number, c: number, d: number) => void;
     readonly main: () => void;
-    readonly __wasm_bindgen_func_elem_8655: (a: number, b: number) => void;
-    readonly __wasm_bindgen_func_elem_12872: (a: number, b: number) => void;
-    readonly __wasm_bindgen_func_elem_8822: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_12873: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_8821: (a: number, b: number) => void;
+    readonly __wasm_bindgen_func_elem_8658: (a: number, b: number) => void;
+    readonly __wasm_bindgen_func_elem_12847: (a: number, b: number) => void;
+    readonly __wasm_bindgen_func_elem_8747: (a: number, b: number, c: number) => void;
+    readonly __wasm_bindgen_func_elem_12848: (a: number, b: number, c: number) => void;
+    readonly __wasm_bindgen_func_elem_8748: (a: number, b: number) => void;
     readonly __wbindgen_export: (a: number, b: number) => number;
     readonly __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
     readonly __wbindgen_export3: (a: number) => void;

package/dist/pkg/ink_web.js

@@ -208,6 +208,8 @@ import * as import25 from "../env.js"
 import * as import26 from "../env.js"
 import * as import27 from "../env.js"
 import * as import28 from "../env.js"
+import * as import29 from "../env.js"
+import * as import30 from "../env.js"
 
 function __wbg_get_imports() {
     const import0 = {
@@ -498,6 +500,16 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
+        __wbg_instanceof_Error_8573fe0b0b480f46: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Error;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
         __wbg_instanceof_HtmlCanvasElement_3f2f6e1edb1c9792: function(arg0) {
             let result;
             try {
@@ -598,9 +610,17 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).measureText(getStringFromWasm0(arg1, arg2));
             return addHeapObject(ret);
         }, arguments); },
+        __wbg_message_9ddc4b9a62a7c379: function(arg0) {
+            const ret = getObject(arg0).message;
+            return addHeapObject(ret);
+        },
         __wbg_moveTo_e9190fc700d55b40: function(arg0, arg1, arg2) {
             getObject(arg0).moveTo(arg1, arg2);
         },
+        __wbg_name_446e25ef2cfdab5a: function(arg0) {
+            const ret = getObject(arg0).name;
+            return addHeapObject(ret);
+        },
         __wbg_navigator_43be698ba96fc088: function(arg0) {
             const ret = getObject(arg0).navigator;
             return addHeapObject(ret);
@@ -621,6 +641,10 @@ function __wbg_get_imports() {
             const ret = new Headers();
             return addHeapObject(ret);
         }, arguments); },
+        __wbg_new_72b49615380db768: function(arg0, arg1) {
+            const ret = new Error(getStringFromWasm0(arg0, arg1));
+            return addHeapObject(ret);
+        },
         __wbg_new_7455c5eb8798868d: function() { return handleError(function () {
             const ret = new Audio();
             return addHeapObject(ret);
@@ -943,28 +967,28 @@ function __wbg_get_imports() {
             return ret;
         },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 2276, function: Function { arguments: [NamedExternref("CloseEvent")], shim_idx: 2278, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_8655, __wasm_bindgen_func_elem_8822);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 2300, function: Function { arguments: [NamedExternref("CloseEvent")], shim_idx: 2304, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_8658, __wasm_bindgen_func_elem_8747);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000002: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 2276, function: Function { arguments: [NamedExternref("Event")], shim_idx: 2278, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_8655, __wasm_bindgen_func_elem_8822);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 2300, function: Function { arguments: [NamedExternref("Event")], shim_idx: 2304, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_8658, __wasm_bindgen_func_elem_8747);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000003: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 2276, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 2278, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_8655, __wasm_bindgen_func_elem_8822);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 2300, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 2304, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_8658, __wasm_bindgen_func_elem_8747);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000004: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 2276, function: Function { arguments: [], shim_idx: 2280, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_8655, __wasm_bindgen_func_elem_8821);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 2300, function: Function { arguments: [], shim_idx: 2301, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_8658, __wasm_bindgen_func_elem_8748);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000005: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 3267, function: Function { arguments: [Externref], shim_idx: 3268, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_12872, __wasm_bindgen_func_elem_12873);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 3264, function: Function { arguments: [Externref], shim_idx: 3265, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_12847, __wasm_bindgen_func_elem_12848);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000006: function(arg0) {
@@ -1016,19 +1040,21 @@ function __wbg_get_imports() {
         "env": import26,
         "env": import27,
         "env": import28,
+        "env": import29,
+        "env": import30,
     };
 }
 
-function __wasm_bindgen_func_elem_8821(arg0, arg1) {
-    wasm.__wasm_bindgen_func_elem_8821(arg0, arg1);
+function __wasm_bindgen_func_elem_8748(arg0, arg1) {
+    wasm.__wasm_bindgen_func_elem_8748(arg0, arg1);
 }
 
-function __wasm_bindgen_func_elem_8822(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_8822(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_8747(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_8747(arg0, arg1, addHeapObject(arg2));
 }
 
-function __wasm_bindgen_func_elem_12873(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_12873(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_12848(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_12848(arg0, arg1, addHeapObject(arg2));
 }
 
 

package/dist/pkg/ink_web_bg.wasm.d.ts

@@ -16,11 +16,11 @@ export const inkwebview_openBundle: (a: number, b: number, c: number, d: number,
 export const inkwebview_render: (a: number, b: number) => void;
 export const inkwebview_resize: (a: number, b: number, c: number, d: number) => void;
 export const main: () => void;
-export const __wasm_bindgen_func_elem_8655: (a: number, b: number) => void;
-export const __wasm_bindgen_func_elem_12872: (a: number, b: number) => void;
-export const __wasm_bindgen_func_elem_8822: (a: number, b: number, c: number) => void;
-export const __wasm_bindgen_func_elem_12873: (a: number, b: number, c: number) => void;
-export const __wasm_bindgen_func_elem_8821: (a: number, b: number) => void;
+export const __wasm_bindgen_func_elem_8658: (a: number, b: number) => void;
+export const __wasm_bindgen_func_elem_12847: (a: number, b: number) => void;
+export const __wasm_bindgen_func_elem_8747: (a: number, b: number, c: number) => void;
+export const __wasm_bindgen_func_elem_12848: (a: number, b: number, c: number) => void;
+export const __wasm_bindgen_func_elem_8748: (a: number, b: number) => void;
 export const __wbindgen_export: (a: number, b: number) => number;
 export const __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
 export const __wbindgen_export3: (a: number) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yodaos-pkg/ink",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Ink Web SDK for browser rendering and VFS-backed app loading",
   "type": "module",
   "main": "dist/index.js",