react-native-ariel 0.1.0-dev.50 → 0.1.0-dev.52

package/README.md

@@ -38,33 +38,57 @@ yarn add react-native-ariel react-native-svg
 ### Simple render
 
 ```typescript
-import { renderMermaid } from 'react-native-ariel';
+import { useState, useEffect } from 'react';
+import { View } from 'react-native';
 import { SvgXml } from 'react-native-svg';
-
-const svg = renderMermaid('flowchart TD\n  A[Hello] --> B[World]');
-
-<SvgXml xml={svg} width="100%" />
+import { renderMermaid, uniffiInitAsync } from 'react-native-ariel';
+
+export default function DiagramView() {
+  const [svg, setSvg] = useState<string | null>(null);
+
+  useEffect(() => {
+    async function run() {
+      // uniffiInitAsync is a no-op on native and loads the WASM module on web.
+      // Always await it before rendering so the same code works on both platforms.
+      await uniffiInitAsync();
+      try {
+        setSvg(renderMermaid('flowchart TD\n  A[Hello] --> B[World]'));
+      } catch (e) {
+        console.error('Render failed:', e);
+      }
+    }
+    run();
+  }, []);
+
+  return <View>{svg && <SvgXml xml={svg} width="100%" />}</View>;
+}
 ```
 
+`renderMermaid` is **synchronous** on native — no async overhead after init.
+
 ### With theme and layout control
 
 ```typescript
-import { renderMermaidWithOptions, ArielTheme } from 'react-native-ariel';
+import { renderMermaidWithOptions, uniffiInitAsync, ArielTheme } from 'react-native-ariel';
 
-const theme = ArielTheme.modern(); // or ArielTheme.mermaidDefault()
-const config = { nodeSpacing: 50, rankSpacing: 80, aspectRatioHint: null };
+const config = { nodeSpacing: 50, rankSpacing: 80 };
 
-const svg = renderMermaidWithOptions(diagram, theme, config);
+await uniffiInitAsync();
+const svg = renderMermaidWithOptions(diagram, ArielTheme.modern(), config);
+// or: ArielTheme.mermaidDefault()
 ```
 
 ### With timing metrics
 
 ```typescript
-import { renderMermaidWithTiming, ArielTheme } from 'react-native-ariel';
+import { renderMermaidWithTiming, uniffiInitAsync, ArielTheme } from 'react-native-ariel';
 
+const config = { nodeSpacing: 50, rankSpacing: 80 };
+
+await uniffiInitAsync();
 const result = renderMermaidWithTiming(diagram, ArielTheme.modern(), config);
 console.log(`Total: ${result.totalMs.toFixed(2)}ms`);
-// Parse: 420µs  Layout: 610µs  Render: 200µs
+// parseUs / layoutUs / renderUs are bigint (µs); totalMs is number (ms)
 ```
 
 ### Full pipeline (parse once, render with multiple themes)
@@ -74,9 +98,13 @@ import {
   parseDiagram,
   computeDiagramLayout,
   renderSvgFromLayout,
+  uniffiInitAsync,
   ArielTheme,
 } from 'react-native-ariel';
 
+const config = { nodeSpacing: 50, rankSpacing: 80 };
+
+await uniffiInitAsync();
 const parsed = parseDiagram('flowchart LR\n  A --> B --> C');
 const layout = computeDiagramLayout(parsed, ArielTheme.modern(), config);
 const svg    = renderSvgFromLayout(layout, ArielTheme.modern(), config);
@@ -95,18 +123,6 @@ Logs are written to **Android Logcat**, the **Xcode console** on iOS, and the **
 
 > **Note:** When timing is on, every render call allocates a format string regardless of whether you can see the output. This is cheap but not free. The flag is intended for debugging — avoid shipping with `setTimingLogs(true)` hardcoded.
 
-### Web (WASM) initialisation
-
-On web, call `uniffiInitAsync` before any render calls:
-
-```typescript
-import { uniffiInitAsync } from 'react-native-ariel';
-
-uniffiInitAsync().then(() => {
-  // safe to call renderMermaid here
-});
-```
-
 ---
 
 ## API
@@ -120,6 +136,7 @@ uniffiInitAsync().then(() => {
 | `computeDiagramLayout(parsed, theme, config)` | Layout stage — returns opaque `ArielLayout` |
 | `renderSvgFromLayout(layout, theme, config)` | SVG stage from pre-computed layout |
 | `setTimingLogs(enabled)` | Toggle timing output to console (default: off) |
+| `uniffiInitAsync()` | Load WASM module on web; no-op on native. Call once before rendering |
 | `ArielTheme.modern()` | Modern theme — see below |
 | `ArielTheme.mermaidDefault()` | Classic Mermaid theme — see below |
 
@@ -147,9 +164,8 @@ const svg = renderMermaidWithOptions(diagram, ArielTheme.mermaidDefault(), confi
 
 ```typescript
 {
-  nodeSpacing?: number | null;
-  rankSpacing?: number | null;
-  aspectRatioHint?: number | null;
+  nodeSpacing?: number;
+  rankSpacing?: number;
 }
 ```
 
@@ -158,10 +174,10 @@ const svg = renderMermaidWithOptions(diagram, ArielTheme.mermaidDefault(), confi
 ```typescript
 {
   svg: string;
-  parseUs: number;
-  layoutUs: number;
-  renderUs: number;
-  totalMs: number;
+  parseUs: bigint;   // microseconds (u64)
+  layoutUs: bigint;  // microseconds (u64)
+  renderUs: bigint;  // microseconds (u64)
+  totalMs: number;   // milliseconds (f64)
 }
 ```
 
@@ -174,7 +190,7 @@ const svg = renderMermaidWithOptions(diagram, ArielTheme.mermaidDefault(), confi
 | Tool | Purpose | Install |
 |---|---|---|
 | [Rust](https://rustup.rs) | Compile the Rust crate | `curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs \| sh` |
-| [Node.js](https://nodejs.org) ≥ 20 | JS toolchain | nodejs.org |
+| [Node.js](https://nodejs.org) ≥ 22 | JS toolchain | nodejs.org |
 | Yarn | Package manager | `npm i -g yarn` |
 | [Android Studio](https://developer.android.com/studio) | Android SDK + NDK | See below |
 | Xcode ≥ 15 | iOS builds (macOS only) | Mac App Store |
@@ -222,29 +238,44 @@ This works on **Windows**, **macOS**, and **Linux** and writes to `src/generated
 
 ### Android
 
-Compiles the Rust crate for all Android ABIs and places `.a` / `.so` files under `android/src/main/jniLibs/`. Run `yarn ubrn:generate` first if you haven't already.
+Compiles the Rust crate for all Android ABIs and places `.a` files under `android/src/main/jniLibs/`. Run `yarn ubrn:generate` first if you haven't already.
 
 ```sh
 yarn ubrn:generate   # generates src/generated/rn/ and cpp/
 yarn ubrn:android    # compiles for arm64-v8a, armeabi-v7a, x86_64, x86
+yarn bob build       # compiles TypeScript → lib/
 ```
 
 ### iOS (macOS only)
 
-Compiles for device + simulator and runs `pod install`. Run `yarn ubrn:generate` first.
+Compiles for device + simulator. Run `yarn ubrn:generate` first.
 
 ```sh
 yarn ubrn:generate   # generates src/generated/rn/ and cpp/
 yarn ubrn:ios        # compiles for aarch64-apple-ios, x86_64-apple-ios, aarch64-apple-ios-sim
+yarn bob build       # compiles TypeScript → lib/
 ```
 
 ### Web (WASM)
 
-Compiles to `wasm32-unknown-unknown` and produces a `.wasm` bundle under `src/generated/web/`. Run `yarn ubrn:generate` first.
+Compiles to `wasm32-unknown-unknown` and produces a `.wasm` bundle. Run `yarn ubrn:generate` first.
 
 ```sh
 yarn ubrn:generate   # generates src/generated/web/ (WASM TypeScript bindings)
 yarn ubrn:web        # compiles the WASM crate with wasm-pack
+yarn bob build       # compiles TypeScript → lib/ and copies WASM into lib/module/
+```
+
+### Building the npm package
+
+To produce a publishable tarball locally (mirrors what CI does, skipping iOS):
+
+```sh
+yarn ubrn:generate
+yarn ubrn:android
+yarn ubrn:web
+yarn bob build
+npm pack --ignore-scripts
 ```
 
 ### Rust unit tests

package/lib/module/generated/web/wasm-bindgen/react_native_ariel.d.ts

@@ -0,0 +1,202 @@
+/* tslint:disable */
+/* eslint-disable */
+
+export class RustCallStatus {
+    free(): void;
+    [Symbol.dispose](): void;
+    constructor();
+    code: number;
+    get errorBuf(): Uint8Array | undefined;
+    set errorBuf(value: Uint8Array | null | undefined);
+}
+
+export function ubrn_ffi_mermaid_wrapper_uniffi_contract_version(): number;
+
+export function ubrn_uniffi_mermaid_wrapper_checksum_constructor_arieltheme_mermaid_default(): number;
+
+export function ubrn_uniffi_mermaid_wrapper_checksum_constructor_arieltheme_modern(): number;
+
+export function ubrn_uniffi_mermaid_wrapper_checksum_func_compute_diagram_layout(): number;
+
+export function ubrn_uniffi_mermaid_wrapper_checksum_func_parse_diagram(): number;
+
+export function ubrn_uniffi_mermaid_wrapper_checksum_func_render_mermaid(): number;
+
+export function ubrn_uniffi_mermaid_wrapper_checksum_func_render_mermaid_with_options(): number;
+
+export function ubrn_uniffi_mermaid_wrapper_checksum_func_render_mermaid_with_timing(): number;
+
+export function ubrn_uniffi_mermaid_wrapper_checksum_func_render_svg_from_layout(): number;
+
+export function ubrn_uniffi_mermaid_wrapper_checksum_func_set_timing_logs(): number;
+
+export function ubrn_uniffi_mermaid_wrapper_fn_clone_ariellayout(handle: bigint, f_status_: RustCallStatus): bigint;
+
+export function ubrn_uniffi_mermaid_wrapper_fn_clone_arielparseddiagram(handle: bigint, f_status_: RustCallStatus): bigint;
+
+export function ubrn_uniffi_mermaid_wrapper_fn_clone_arieltheme(handle: bigint, f_status_: RustCallStatus): bigint;
+
+export function ubrn_uniffi_mermaid_wrapper_fn_constructor_arieltheme_mermaid_default(f_status_: RustCallStatus): bigint;
+
+export function ubrn_uniffi_mermaid_wrapper_fn_constructor_arieltheme_modern(f_status_: RustCallStatus): bigint;
+
+export function ubrn_uniffi_mermaid_wrapper_fn_free_ariellayout(handle: bigint, f_status_: RustCallStatus): void;
+
+export function ubrn_uniffi_mermaid_wrapper_fn_free_arielparseddiagram(handle: bigint, f_status_: RustCallStatus): void;
+
+export function ubrn_uniffi_mermaid_wrapper_fn_free_arieltheme(handle: bigint, f_status_: RustCallStatus): void;
+
+export function ubrn_uniffi_mermaid_wrapper_fn_func_compute_diagram_layout(parsed: bigint, theme: bigint, config: Uint8Array, f_status_: RustCallStatus): bigint;
+
+export function ubrn_uniffi_mermaid_wrapper_fn_func_parse_diagram(input: Uint8Array, f_status_: RustCallStatus): bigint;
+
+export function ubrn_uniffi_mermaid_wrapper_fn_func_render_mermaid(input: Uint8Array, f_status_: RustCallStatus): Uint8Array;
+
+export function ubrn_uniffi_mermaid_wrapper_fn_func_render_mermaid_with_options(input: Uint8Array, _theme: bigint, _config: Uint8Array, f_status_: RustCallStatus): Uint8Array;
+
+export function ubrn_uniffi_mermaid_wrapper_fn_func_render_mermaid_with_timing(input: Uint8Array, _theme: bigint, _config: Uint8Array, f_status_: RustCallStatus): Uint8Array;
+
+export function ubrn_uniffi_mermaid_wrapper_fn_func_render_svg_from_layout(layout: bigint, theme: bigint, config: Uint8Array, f_status_: RustCallStatus): Uint8Array;
+
+export function ubrn_uniffi_mermaid_wrapper_fn_func_set_timing_logs(enabled: number, f_status_: RustCallStatus): void;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly uniffi_mermaid_wrapper_fn_func_compute_diagram_layout: (a: bigint, b: bigint, c: number, d: number) => bigint;
+    readonly uniffi_mermaid_wrapper_fn_constructor_arieltheme_mermaid_default: (a: number) => bigint;
+    readonly uniffi_mermaid_wrapper_fn_constructor_arieltheme_modern: (a: number) => bigint;
+    readonly uniffi_mermaid_wrapper_fn_func_render_mermaid_with_timing: (a: number, b: number, c: bigint, d: number, e: number) => void;
+    readonly uniffi_mermaid_wrapper_fn_free_arieltheme: (a: bigint, b: number) => void;
+    readonly uniffi_mermaid_wrapper_fn_clone_ariellayout: (a: bigint, b: number) => bigint;
+    readonly uniffi_mermaid_wrapper_fn_clone_arieltheme: (a: bigint, b: number) => bigint;
+    readonly uniffi_mermaid_wrapper_fn_free_arielparseddiagram: (a: bigint, b: number) => void;
+    readonly uniffi_mermaid_wrapper_fn_func_render_mermaid_with_options: (a: number, b: number, c: bigint, d: number, e: number) => void;
+    readonly uniffi_mermaid_wrapper_fn_func_parse_diagram: (a: number, b: number) => bigint;
+    readonly uniffi_mermaid_wrapper_fn_func_set_timing_logs: (a: number, b: number) => void;
+    readonly uniffi_mermaid_wrapper_fn_clone_arielparseddiagram: (a: bigint, b: number) => bigint;
+    readonly uniffi_mermaid_wrapper_fn_func_render_mermaid: (a: number, b: number, c: number) => void;
+    readonly uniffi_mermaid_wrapper_fn_free_ariellayout: (a: bigint, b: number) => void;
+    readonly uniffi_mermaid_wrapper_fn_func_render_svg_from_layout: (a: number, b: bigint, c: bigint, d: number, e: number) => void;
+    readonly ubrn_ffi_mermaid_wrapper_uniffi_contract_version: () => number;
+    readonly ffi_mermaid_wrapper_uniffi_contract_version: () => number;
+    readonly ubrn_uniffi_mermaid_wrapper_checksum_constructor_arieltheme_mermaid_default: () => number;
+    readonly uniffi_mermaid_wrapper_checksum_constructor_arieltheme_mermaid_default: () => number;
+    readonly ubrn_uniffi_mermaid_wrapper_checksum_constructor_arieltheme_modern: () => number;
+    readonly uniffi_mermaid_wrapper_checksum_constructor_arieltheme_modern: () => number;
+    readonly ubrn_uniffi_mermaid_wrapper_checksum_func_compute_diagram_layout: () => number;
+    readonly uniffi_mermaid_wrapper_checksum_func_compute_diagram_layout: () => number;
+    readonly ubrn_uniffi_mermaid_wrapper_checksum_func_parse_diagram: () => number;
+    readonly uniffi_mermaid_wrapper_checksum_func_parse_diagram: () => number;
+    readonly ubrn_uniffi_mermaid_wrapper_checksum_func_render_mermaid: () => number;
+    readonly uniffi_mermaid_wrapper_checksum_func_render_mermaid: () => number;
+    readonly ubrn_uniffi_mermaid_wrapper_checksum_func_render_mermaid_with_options: () => number;
+    readonly uniffi_mermaid_wrapper_checksum_func_render_mermaid_with_options: () => number;
+    readonly ubrn_uniffi_mermaid_wrapper_checksum_func_render_mermaid_with_timing: () => number;
+    readonly uniffi_mermaid_wrapper_checksum_func_render_mermaid_with_timing: () => number;
+    readonly ubrn_uniffi_mermaid_wrapper_checksum_func_render_svg_from_layout: () => number;
+    readonly uniffi_mermaid_wrapper_checksum_func_render_svg_from_layout: () => number;
+    readonly ubrn_uniffi_mermaid_wrapper_checksum_func_set_timing_logs: () => number;
+    readonly uniffi_mermaid_wrapper_checksum_func_set_timing_logs: () => number;
+    readonly ubrn_uniffi_mermaid_wrapper_fn_clone_ariellayout: (a: bigint, b: number) => bigint;
+    readonly ubrn_uniffi_mermaid_wrapper_fn_clone_arielparseddiagram: (a: bigint, b: number) => bigint;
+    readonly ubrn_uniffi_mermaid_wrapper_fn_clone_arieltheme: (a: bigint, b: number) => bigint;
+    readonly ubrn_uniffi_mermaid_wrapper_fn_constructor_arieltheme_mermaid_default: (a: number) => bigint;
+    readonly ubrn_uniffi_mermaid_wrapper_fn_constructor_arieltheme_modern: (a: number) => bigint;
+    readonly ubrn_uniffi_mermaid_wrapper_fn_free_ariellayout: (a: bigint, b: number) => void;
+    readonly ubrn_uniffi_mermaid_wrapper_fn_free_arielparseddiagram: (a: bigint, b: number) => void;
+    readonly ubrn_uniffi_mermaid_wrapper_fn_free_arieltheme: (a: bigint, b: number) => void;
+    readonly ubrn_uniffi_mermaid_wrapper_fn_func_compute_diagram_layout: (a: bigint, b: bigint, c: number, d: number, e: number) => bigint;
+    readonly ubrn_uniffi_mermaid_wrapper_fn_func_parse_diagram: (a: number, b: number, c: number) => bigint;
+    readonly ubrn_uniffi_mermaid_wrapper_fn_func_render_mermaid: (a: number, b: number, c: number) => [number, number];
+    readonly ubrn_uniffi_mermaid_wrapper_fn_func_render_mermaid_with_options: (a: number, b: number, c: bigint, d: number, e: number, f: number) => [number, number];
+    readonly ubrn_uniffi_mermaid_wrapper_fn_func_render_mermaid_with_timing: (a: number, b: number, c: bigint, d: number, e: number, f: number) => [number, number];
+    readonly ubrn_uniffi_mermaid_wrapper_fn_func_render_svg_from_layout: (a: bigint, b: bigint, c: number, d: number, e: number) => [number, number];
+    readonly ubrn_uniffi_mermaid_wrapper_fn_func_set_timing_logs: (a: number, b: number) => void;
+    readonly __wbg_get_rustcallstatus_code: (a: number) => number;
+    readonly __wbg_rustcallstatus_free: (a: number, b: number) => void;
+    readonly __wbg_set_rustcallstatus_code: (a: number, b: number) => void;
+    readonly rustcallstatus_error_buf: (a: number) => [number, number];
+    readonly rustcallstatus_new: () => number;
+    readonly rustcallstatus_set_error_buf: (a: number, b: number, c: number) => void;
+    readonly ffi_mermaid_wrapper_rust_future_cancel_f32: (a: bigint) => void;
+    readonly ffi_mermaid_wrapper_rust_future_cancel_f64: (a: bigint) => void;
+    readonly ffi_mermaid_wrapper_rust_future_cancel_i16: (a: bigint) => void;
+    readonly ffi_mermaid_wrapper_rust_future_cancel_i32: (a: bigint) => void;
+    readonly ffi_mermaid_wrapper_rust_future_cancel_i64: (a: bigint) => void;
+    readonly ffi_mermaid_wrapper_rust_future_cancel_i8: (a: bigint) => void;
+    readonly ffi_mermaid_wrapper_rust_future_cancel_rust_buffer: (a: bigint) => void;
+    readonly ffi_mermaid_wrapper_rust_future_cancel_u16: (a: bigint) => void;
+    readonly ffi_mermaid_wrapper_rust_future_cancel_u32: (a: bigint) => void;
+    readonly ffi_mermaid_wrapper_rust_future_cancel_u64: (a: bigint) => void;
+    readonly ffi_mermaid_wrapper_rust_future_cancel_u8: (a: bigint) => void;
+    readonly ffi_mermaid_wrapper_rust_future_cancel_void: (a: bigint) => void;
+    readonly ffi_mermaid_wrapper_rust_future_complete_f32: (a: bigint, b: number) => number;
+    readonly ffi_mermaid_wrapper_rust_future_complete_f64: (a: bigint, b: number) => number;
+    readonly ffi_mermaid_wrapper_rust_future_complete_i16: (a: bigint, b: number) => number;
+    readonly ffi_mermaid_wrapper_rust_future_complete_i32: (a: bigint, b: number) => number;
+    readonly ffi_mermaid_wrapper_rust_future_complete_i64: (a: bigint, b: number) => bigint;
+    readonly ffi_mermaid_wrapper_rust_future_complete_i8: (a: bigint, b: number) => number;
+    readonly ffi_mermaid_wrapper_rust_future_complete_rust_buffer: (a: number, b: bigint, c: number) => void;
+    readonly ffi_mermaid_wrapper_rust_future_complete_u16: (a: bigint, b: number) => number;
+    readonly ffi_mermaid_wrapper_rust_future_complete_u32: (a: bigint, b: number) => number;
+    readonly ffi_mermaid_wrapper_rust_future_complete_u64: (a: bigint, b: number) => bigint;
+    readonly ffi_mermaid_wrapper_rust_future_complete_u8: (a: bigint, b: number) => number;
+    readonly ffi_mermaid_wrapper_rust_future_complete_void: (a: bigint, b: number) => void;
+    readonly ffi_mermaid_wrapper_rust_future_free_f32: (a: bigint) => void;
+    readonly ffi_mermaid_wrapper_rust_future_free_f64: (a: bigint) => void;
+    readonly ffi_mermaid_wrapper_rust_future_free_i16: (a: bigint) => void;
+    readonly ffi_mermaid_wrapper_rust_future_free_i32: (a: bigint) => void;
+    readonly ffi_mermaid_wrapper_rust_future_free_i64: (a: bigint) => void;
+    readonly ffi_mermaid_wrapper_rust_future_free_i8: (a: bigint) => void;
+    readonly ffi_mermaid_wrapper_rust_future_free_rust_buffer: (a: bigint) => void;
+    readonly ffi_mermaid_wrapper_rust_future_free_u16: (a: bigint) => void;
+    readonly ffi_mermaid_wrapper_rust_future_free_u32: (a: bigint) => void;
+    readonly ffi_mermaid_wrapper_rust_future_free_u64: (a: bigint) => void;
+    readonly ffi_mermaid_wrapper_rust_future_free_u8: (a: bigint) => void;
+    readonly ffi_mermaid_wrapper_rust_future_free_void: (a: bigint) => void;
+    readonly ffi_mermaid_wrapper_rust_future_poll_f32: (a: bigint, b: number, c: bigint) => void;
+    readonly ffi_mermaid_wrapper_rust_future_poll_f64: (a: bigint, b: number, c: bigint) => void;
+    readonly ffi_mermaid_wrapper_rust_future_poll_i16: (a: bigint, b: number, c: bigint) => void;
+    readonly ffi_mermaid_wrapper_rust_future_poll_i32: (a: bigint, b: number, c: bigint) => void;
+    readonly ffi_mermaid_wrapper_rust_future_poll_i64: (a: bigint, b: number, c: bigint) => void;
+    readonly ffi_mermaid_wrapper_rust_future_poll_i8: (a: bigint, b: number, c: bigint) => void;
+    readonly ffi_mermaid_wrapper_rust_future_poll_rust_buffer: (a: bigint, b: number, c: bigint) => void;
+    readonly ffi_mermaid_wrapper_rust_future_poll_u16: (a: bigint, b: number, c: bigint) => void;
+    readonly ffi_mermaid_wrapper_rust_future_poll_u32: (a: bigint, b: number, c: bigint) => void;
+    readonly ffi_mermaid_wrapper_rust_future_poll_u64: (a: bigint, b: number, c: bigint) => void;
+    readonly ffi_mermaid_wrapper_rust_future_poll_u8: (a: bigint, b: number, c: bigint) => void;
+    readonly ffi_mermaid_wrapper_rust_future_poll_void: (a: bigint, b: number, c: bigint) => void;
+    readonly ffi_mermaid_wrapper_rustbuffer_alloc: (a: number, b: bigint, c: number) => void;
+    readonly ffi_mermaid_wrapper_rustbuffer_free: (a: number, b: number) => void;
+    readonly ffi_mermaid_wrapper_rustbuffer_from_bytes: (a: number, b: number, c: number) => void;
+    readonly ffi_mermaid_wrapper_rustbuffer_reserve: (a: number, b: number, c: bigint, d: number) => void;
+    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_malloc: (a: number, b: number) => number;
+    readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;

package/lib/module/generated/web/wasm-bindgen/react_native_ariel.js

@@ -0,0 +1,579 @@
+/* @ts-self-types="./react_native_ariel.d.ts" */
+
+export class RustCallStatus {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RustCallStatusFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_rustcallstatus_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    get code() {
+        const ret = wasm.__wbg_get_rustcallstatus_code(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {Uint8Array | undefined}
+     */
+    get errorBuf() {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.rustcallstatus_error_buf(ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    constructor() {
+        const ret = wasm.rustcallstatus_new();
+        this.__wbg_ptr = ret;
+        RustCallStatusFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {Uint8Array | null} [bytes]
+     */
+    set errorBuf(bytes) {
+        var ptr0 = isLikeNone(bytes) ? 0 : passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.rustcallstatus_set_error_buf(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {number} arg0
+     */
+    set code(arg0) {
+        wasm.__wbg_set_rustcallstatus_code(this.__wbg_ptr, arg0);
+    }
+}
+if (Symbol.dispose) RustCallStatus.prototype[Symbol.dispose] = RustCallStatus.prototype.free;
+
+/**
+ * @returns {number}
+ */
+export function ubrn_ffi_mermaid_wrapper_uniffi_contract_version() {
+    const ret = wasm.ubrn_ffi_mermaid_wrapper_uniffi_contract_version();
+    return ret >>> 0;
+}
+
+/**
+ * @returns {number}
+ */
+export function ubrn_uniffi_mermaid_wrapper_checksum_constructor_arieltheme_mermaid_default() {
+    const ret = wasm.ubrn_uniffi_mermaid_wrapper_checksum_constructor_arieltheme_mermaid_default();
+    return ret;
+}
+
+/**
+ * @returns {number}
+ */
+export function ubrn_uniffi_mermaid_wrapper_checksum_constructor_arieltheme_modern() {
+    const ret = wasm.ubrn_uniffi_mermaid_wrapper_checksum_constructor_arieltheme_modern();
+    return ret;
+}
+
+/**
+ * @returns {number}
+ */
+export function ubrn_uniffi_mermaid_wrapper_checksum_func_compute_diagram_layout() {
+    const ret = wasm.ubrn_uniffi_mermaid_wrapper_checksum_func_compute_diagram_layout();
+    return ret;
+}
+
+/**
+ * @returns {number}
+ */
+export function ubrn_uniffi_mermaid_wrapper_checksum_func_parse_diagram() {
+    const ret = wasm.ubrn_uniffi_mermaid_wrapper_checksum_func_parse_diagram();
+    return ret;
+}
+
+/**
+ * @returns {number}
+ */
+export function ubrn_uniffi_mermaid_wrapper_checksum_func_render_mermaid() {
+    const ret = wasm.ubrn_uniffi_mermaid_wrapper_checksum_func_render_mermaid();
+    return ret;
+}
+
+/**
+ * @returns {number}
+ */
+export function ubrn_uniffi_mermaid_wrapper_checksum_func_render_mermaid_with_options() {
+    const ret = wasm.ubrn_uniffi_mermaid_wrapper_checksum_func_render_mermaid_with_options();
+    return ret;
+}
+
+/**
+ * @returns {number}
+ */
+export function ubrn_uniffi_mermaid_wrapper_checksum_func_render_mermaid_with_timing() {
+    const ret = wasm.ubrn_uniffi_mermaid_wrapper_checksum_func_render_mermaid_with_timing();
+    return ret;
+}
+
+/**
+ * @returns {number}
+ */
+export function ubrn_uniffi_mermaid_wrapper_checksum_func_render_svg_from_layout() {
+    const ret = wasm.ubrn_uniffi_mermaid_wrapper_checksum_func_render_svg_from_layout();
+    return ret;
+}
+
+/**
+ * @returns {number}
+ */
+export function ubrn_uniffi_mermaid_wrapper_checksum_func_set_timing_logs() {
+    const ret = wasm.ubrn_uniffi_mermaid_wrapper_checksum_func_set_timing_logs();
+    return ret;
+}
+
+/**
+ * @param {bigint} handle
+ * @param {RustCallStatus} f_status_
+ * @returns {bigint}
+ */
+export function ubrn_uniffi_mermaid_wrapper_fn_clone_ariellayout(handle, f_status_) {
+    _assertClass(f_status_, RustCallStatus);
+    const ret = wasm.ubrn_uniffi_mermaid_wrapper_fn_clone_ariellayout(handle, f_status_.__wbg_ptr);
+    return BigInt.asUintN(64, ret);
+}
+
+/**
+ * @param {bigint} handle
+ * @param {RustCallStatus} f_status_
+ * @returns {bigint}
+ */
+export function ubrn_uniffi_mermaid_wrapper_fn_clone_arielparseddiagram(handle, f_status_) {
+    _assertClass(f_status_, RustCallStatus);
+    const ret = wasm.ubrn_uniffi_mermaid_wrapper_fn_clone_arielparseddiagram(handle, f_status_.__wbg_ptr);
+    return BigInt.asUintN(64, ret);
+}
+
+/**
+ * @param {bigint} handle
+ * @param {RustCallStatus} f_status_
+ * @returns {bigint}
+ */
+export function ubrn_uniffi_mermaid_wrapper_fn_clone_arieltheme(handle, f_status_) {
+    _assertClass(f_status_, RustCallStatus);
+    const ret = wasm.ubrn_uniffi_mermaid_wrapper_fn_clone_arieltheme(handle, f_status_.__wbg_ptr);
+    return BigInt.asUintN(64, ret);
+}
+
+/**
+ * @param {RustCallStatus} f_status_
+ * @returns {bigint}
+ */
+export function ubrn_uniffi_mermaid_wrapper_fn_constructor_arieltheme_mermaid_default(f_status_) {
+    _assertClass(f_status_, RustCallStatus);
+    const ret = wasm.ubrn_uniffi_mermaid_wrapper_fn_constructor_arieltheme_mermaid_default(f_status_.__wbg_ptr);
+    return BigInt.asUintN(64, ret);
+}
+
+/**
+ * @param {RustCallStatus} f_status_
+ * @returns {bigint}
+ */
+export function ubrn_uniffi_mermaid_wrapper_fn_constructor_arieltheme_modern(f_status_) {
+    _assertClass(f_status_, RustCallStatus);
+    const ret = wasm.ubrn_uniffi_mermaid_wrapper_fn_constructor_arieltheme_modern(f_status_.__wbg_ptr);
+    return BigInt.asUintN(64, ret);
+}
+
+/**
+ * @param {bigint} handle
+ * @param {RustCallStatus} f_status_
+ */
+export function ubrn_uniffi_mermaid_wrapper_fn_free_ariellayout(handle, f_status_) {
+    _assertClass(f_status_, RustCallStatus);
+    wasm.ubrn_uniffi_mermaid_wrapper_fn_free_ariellayout(handle, f_status_.__wbg_ptr);
+}
+
+/**
+ * @param {bigint} handle
+ * @param {RustCallStatus} f_status_
+ */
+export function ubrn_uniffi_mermaid_wrapper_fn_free_arielparseddiagram(handle, f_status_) {
+    _assertClass(f_status_, RustCallStatus);
+    wasm.ubrn_uniffi_mermaid_wrapper_fn_free_arielparseddiagram(handle, f_status_.__wbg_ptr);
+}
+
+/**
+ * @param {bigint} handle
+ * @param {RustCallStatus} f_status_
+ */
+export function ubrn_uniffi_mermaid_wrapper_fn_free_arieltheme(handle, f_status_) {
+    _assertClass(f_status_, RustCallStatus);
+    wasm.ubrn_uniffi_mermaid_wrapper_fn_free_arieltheme(handle, f_status_.__wbg_ptr);
+}
+
+/**
+ * @param {bigint} parsed
+ * @param {bigint} theme
+ * @param {Uint8Array} config
+ * @param {RustCallStatus} f_status_
+ * @returns {bigint}
+ */
+export function ubrn_uniffi_mermaid_wrapper_fn_func_compute_diagram_layout(parsed, theme, config, f_status_) {
+    const ptr0 = passArray8ToWasm0(config, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    _assertClass(f_status_, RustCallStatus);
+    const ret = wasm.ubrn_uniffi_mermaid_wrapper_fn_func_compute_diagram_layout(parsed, theme, ptr0, len0, f_status_.__wbg_ptr);
+    return BigInt.asUintN(64, ret);
+}
+
+/**
+ * @param {Uint8Array} input
+ * @param {RustCallStatus} f_status_
+ * @returns {bigint}
+ */
+export function ubrn_uniffi_mermaid_wrapper_fn_func_parse_diagram(input, f_status_) {
+    const ptr0 = passArray8ToWasm0(input, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    _assertClass(f_status_, RustCallStatus);
+    const ret = wasm.ubrn_uniffi_mermaid_wrapper_fn_func_parse_diagram(ptr0, len0, f_status_.__wbg_ptr);
+    return BigInt.asUintN(64, ret);
+}
+
+/**
+ * @param {Uint8Array} input
+ * @param {RustCallStatus} f_status_
+ * @returns {Uint8Array}
+ */
+export function ubrn_uniffi_mermaid_wrapper_fn_func_render_mermaid(input, f_status_) {
+    const ptr0 = passArray8ToWasm0(input, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    _assertClass(f_status_, RustCallStatus);
+    const ret = wasm.ubrn_uniffi_mermaid_wrapper_fn_func_render_mermaid(ptr0, len0, f_status_.__wbg_ptr);
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+
+/**
+ * @param {Uint8Array} input
+ * @param {bigint} _theme
+ * @param {Uint8Array} _config
+ * @param {RustCallStatus} f_status_
+ * @returns {Uint8Array}
+ */
+export function ubrn_uniffi_mermaid_wrapper_fn_func_render_mermaid_with_options(input, _theme, _config, f_status_) {
+    const ptr0 = passArray8ToWasm0(input, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(_config, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    _assertClass(f_status_, RustCallStatus);
+    const ret = wasm.ubrn_uniffi_mermaid_wrapper_fn_func_render_mermaid_with_options(ptr0, len0, _theme, ptr1, len1, f_status_.__wbg_ptr);
+    var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v3;
+}
+
+/**
+ * @param {Uint8Array} input
+ * @param {bigint} _theme
+ * @param {Uint8Array} _config
+ * @param {RustCallStatus} f_status_
+ * @returns {Uint8Array}
+ */
+export function ubrn_uniffi_mermaid_wrapper_fn_func_render_mermaid_with_timing(input, _theme, _config, f_status_) {
+    const ptr0 = passArray8ToWasm0(input, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(_config, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    _assertClass(f_status_, RustCallStatus);
+    const ret = wasm.ubrn_uniffi_mermaid_wrapper_fn_func_render_mermaid_with_timing(ptr0, len0, _theme, ptr1, len1, f_status_.__wbg_ptr);
+    var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v3;
+}
+
+/**
+ * @param {bigint} layout
+ * @param {bigint} theme
+ * @param {Uint8Array} config
+ * @param {RustCallStatus} f_status_
+ * @returns {Uint8Array}
+ */
+export function ubrn_uniffi_mermaid_wrapper_fn_func_render_svg_from_layout(layout, theme, config, f_status_) {
+    const ptr0 = passArray8ToWasm0(config, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    _assertClass(f_status_, RustCallStatus);
+    const ret = wasm.ubrn_uniffi_mermaid_wrapper_fn_func_render_svg_from_layout(layout, theme, ptr0, len0, f_status_.__wbg_ptr);
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+
+/**
+ * @param {number} enabled
+ * @param {RustCallStatus} f_status_
+ */
+export function ubrn_uniffi_mermaid_wrapper_fn_func_set_timing_logs(enabled, f_status_) {
+    _assertClass(f_status_, RustCallStatus);
+    wasm.ubrn_uniffi_mermaid_wrapper_fn_func_set_timing_logs(enabled, f_status_.__wbg_ptr);
+}
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg___wbindgen_throw_9c31b086c2b26051: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+        __wbg_error_a6fa202b58aa1cd3: function(arg0, arg1) {
+            let deferred0_0;
+            let deferred0_1;
+            try {
+                deferred0_0 = arg0;
+                deferred0_1 = arg1;
+                console.error(getStringFromWasm0(arg0, arg1));
+            } finally {
+                wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+            }
+        },
+        __wbg_log_eb752234eec406d1: function(arg0) {
+            console.log(arg0);
+        },
+        __wbg_new_227d7c05414eb861: function() {
+            const ret = new Error();
+            return ret;
+        },
+        __wbg_stack_3b0d974bbf31e44f: function(arg0, arg1) {
+            const ret = arg1.stack;
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbindgen_cast_0000000000000001: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(String) -> Externref`.
+            const ret = getStringFromWasm0(arg0, arg1);
+            return ret;
+        },
+        __wbindgen_init_externref_table: function() {
+            const table = wasm.__wbindgen_externrefs;
+            const offset = table.grow(4);
+            table.set(0, undefined);
+            table.set(offset + 0, undefined);
+            table.set(offset + 1, null);
+            table.set(offset + 2, true);
+            table.set(offset + 3, false);
+        },
+    };
+    return {
+        __proto__: null,
+        "./react_native_ariel_bg.js": import0,
+    };
+}
+
+const RustCallStatusFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_rustcallstatus_free(ptr, 1));
+
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    return decodeText(ptr >>> 0, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+let wasmModule, wasmInstance, wasm;
+function __wbg_finalize_init(instance, module) {
+    wasmInstance = instance;
+    wasm = instance.exports;
+    wasmModule = module;
+    cachedDataViewMemory0 = null;
+    cachedUint8ArrayMemory0 = null;
+    wasm.__wbindgen_start();
+    return wasm;
+}
+
+async function __wbg_load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+            } catch (e) {
+                const validResponse = module.ok && expectedResponseType(module.type);
+
+                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
+                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                } else { throw e; }
+            }
+        }
+
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+        } else {
+            return instance;
+        }
+    }
+
+    function expectedResponseType(type) {
+        switch (type) {
+            case 'basic': case 'cors': case 'default': return true;
+        }
+        return false;
+    }
+}
+
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module !== undefined) {
+        if (Object.getPrototypeOf(module) === Object.prototype) {
+            ({module} = module)
+        } else {
+            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+        }
+    }
+
+    const imports = __wbg_get_imports();
+    if (!(module instanceof WebAssembly.Module)) {
+        module = new WebAssembly.Module(module);
+    }
+    const instance = new WebAssembly.Instance(module, imports);
+    return __wbg_finalize_init(instance, module);
+}
+
+async function __wbg_init(module_or_path) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module_or_path !== undefined) {
+        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+            ({module_or_path} = module_or_path)
+        } else {
+            console.warn('using deprecated parameters for the initialization function; pass a single object instead')
+        }
+    }
+
+    if (module_or_path === undefined) {
+        module_or_path = new URL('react_native_ariel_bg.wasm', '');
+    }
+    const imports = __wbg_get_imports();
+
+    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+        module_or_path = fetch(module_or_path);
+    }
+
+    const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+export { initSync, __wbg_init as default };

package/lib/module/generated/web/wasm-bindgen/react_native_ariel_bg.wasm.d.ts

@@ -0,0 +1,116 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const uniffi_mermaid_wrapper_fn_func_compute_diagram_layout: (a: bigint, b: bigint, c: number, d: number) => bigint;
+export const uniffi_mermaid_wrapper_fn_constructor_arieltheme_mermaid_default: (a: number) => bigint;
+export const uniffi_mermaid_wrapper_fn_constructor_arieltheme_modern: (a: number) => bigint;
+export const uniffi_mermaid_wrapper_fn_func_render_mermaid_with_timing: (a: number, b: number, c: bigint, d: number, e: number) => void;
+export const uniffi_mermaid_wrapper_fn_free_arieltheme: (a: bigint, b: number) => void;
+export const uniffi_mermaid_wrapper_fn_clone_ariellayout: (a: bigint, b: number) => bigint;
+export const uniffi_mermaid_wrapper_fn_clone_arieltheme: (a: bigint, b: number) => bigint;
+export const uniffi_mermaid_wrapper_fn_free_arielparseddiagram: (a: bigint, b: number) => void;
+export const uniffi_mermaid_wrapper_fn_func_render_mermaid_with_options: (a: number, b: number, c: bigint, d: number, e: number) => void;
+export const uniffi_mermaid_wrapper_fn_func_parse_diagram: (a: number, b: number) => bigint;
+export const uniffi_mermaid_wrapper_fn_func_set_timing_logs: (a: number, b: number) => void;
+export const uniffi_mermaid_wrapper_fn_clone_arielparseddiagram: (a: bigint, b: number) => bigint;
+export const uniffi_mermaid_wrapper_fn_func_render_mermaid: (a: number, b: number, c: number) => void;
+export const uniffi_mermaid_wrapper_fn_free_ariellayout: (a: bigint, b: number) => void;
+export const uniffi_mermaid_wrapper_fn_func_render_svg_from_layout: (a: number, b: bigint, c: bigint, d: number, e: number) => void;
+export const ubrn_ffi_mermaid_wrapper_uniffi_contract_version: () => number;
+export const ffi_mermaid_wrapper_uniffi_contract_version: () => number;
+export const ubrn_uniffi_mermaid_wrapper_checksum_constructor_arieltheme_mermaid_default: () => number;
+export const uniffi_mermaid_wrapper_checksum_constructor_arieltheme_mermaid_default: () => number;
+export const ubrn_uniffi_mermaid_wrapper_checksum_constructor_arieltheme_modern: () => number;
+export const uniffi_mermaid_wrapper_checksum_constructor_arieltheme_modern: () => number;
+export const ubrn_uniffi_mermaid_wrapper_checksum_func_compute_diagram_layout: () => number;
+export const uniffi_mermaid_wrapper_checksum_func_compute_diagram_layout: () => number;
+export const ubrn_uniffi_mermaid_wrapper_checksum_func_parse_diagram: () => number;
+export const uniffi_mermaid_wrapper_checksum_func_parse_diagram: () => number;
+export const ubrn_uniffi_mermaid_wrapper_checksum_func_render_mermaid: () => number;
+export const uniffi_mermaid_wrapper_checksum_func_render_mermaid: () => number;
+export const ubrn_uniffi_mermaid_wrapper_checksum_func_render_mermaid_with_options: () => number;
+export const uniffi_mermaid_wrapper_checksum_func_render_mermaid_with_options: () => number;
+export const ubrn_uniffi_mermaid_wrapper_checksum_func_render_mermaid_with_timing: () => number;
+export const uniffi_mermaid_wrapper_checksum_func_render_mermaid_with_timing: () => number;
+export const ubrn_uniffi_mermaid_wrapper_checksum_func_render_svg_from_layout: () => number;
+export const uniffi_mermaid_wrapper_checksum_func_render_svg_from_layout: () => number;
+export const ubrn_uniffi_mermaid_wrapper_checksum_func_set_timing_logs: () => number;
+export const uniffi_mermaid_wrapper_checksum_func_set_timing_logs: () => number;
+export const ubrn_uniffi_mermaid_wrapper_fn_clone_ariellayout: (a: bigint, b: number) => bigint;
+export const ubrn_uniffi_mermaid_wrapper_fn_clone_arielparseddiagram: (a: bigint, b: number) => bigint;
+export const ubrn_uniffi_mermaid_wrapper_fn_clone_arieltheme: (a: bigint, b: number) => bigint;
+export const ubrn_uniffi_mermaid_wrapper_fn_constructor_arieltheme_mermaid_default: (a: number) => bigint;
+export const ubrn_uniffi_mermaid_wrapper_fn_constructor_arieltheme_modern: (a: number) => bigint;
+export const ubrn_uniffi_mermaid_wrapper_fn_free_ariellayout: (a: bigint, b: number) => void;
+export const ubrn_uniffi_mermaid_wrapper_fn_free_arielparseddiagram: (a: bigint, b: number) => void;
+export const ubrn_uniffi_mermaid_wrapper_fn_free_arieltheme: (a: bigint, b: number) => void;
+export const ubrn_uniffi_mermaid_wrapper_fn_func_compute_diagram_layout: (a: bigint, b: bigint, c: number, d: number, e: number) => bigint;
+export const ubrn_uniffi_mermaid_wrapper_fn_func_parse_diagram: (a: number, b: number, c: number) => bigint;
+export const ubrn_uniffi_mermaid_wrapper_fn_func_render_mermaid: (a: number, b: number, c: number) => [number, number];
+export const ubrn_uniffi_mermaid_wrapper_fn_func_render_mermaid_with_options: (a: number, b: number, c: bigint, d: number, e: number, f: number) => [number, number];
+export const ubrn_uniffi_mermaid_wrapper_fn_func_render_mermaid_with_timing: (a: number, b: number, c: bigint, d: number, e: number, f: number) => [number, number];
+export const ubrn_uniffi_mermaid_wrapper_fn_func_render_svg_from_layout: (a: bigint, b: bigint, c: number, d: number, e: number) => [number, number];
+export const ubrn_uniffi_mermaid_wrapper_fn_func_set_timing_logs: (a: number, b: number) => void;
+export const __wbg_get_rustcallstatus_code: (a: number) => number;
+export const __wbg_rustcallstatus_free: (a: number, b: number) => void;
+export const __wbg_set_rustcallstatus_code: (a: number, b: number) => void;
+export const rustcallstatus_error_buf: (a: number) => [number, number];
+export const rustcallstatus_new: () => number;
+export const rustcallstatus_set_error_buf: (a: number, b: number, c: number) => void;
+export const ffi_mermaid_wrapper_rust_future_cancel_f32: (a: bigint) => void;
+export const ffi_mermaid_wrapper_rust_future_cancel_f64: (a: bigint) => void;
+export const ffi_mermaid_wrapper_rust_future_cancel_i16: (a: bigint) => void;
+export const ffi_mermaid_wrapper_rust_future_cancel_i32: (a: bigint) => void;
+export const ffi_mermaid_wrapper_rust_future_cancel_i64: (a: bigint) => void;
+export const ffi_mermaid_wrapper_rust_future_cancel_i8: (a: bigint) => void;
+export const ffi_mermaid_wrapper_rust_future_cancel_rust_buffer: (a: bigint) => void;
+export const ffi_mermaid_wrapper_rust_future_cancel_u16: (a: bigint) => void;
+export const ffi_mermaid_wrapper_rust_future_cancel_u32: (a: bigint) => void;
+export const ffi_mermaid_wrapper_rust_future_cancel_u64: (a: bigint) => void;
+export const ffi_mermaid_wrapper_rust_future_cancel_u8: (a: bigint) => void;
+export const ffi_mermaid_wrapper_rust_future_cancel_void: (a: bigint) => void;
+export const ffi_mermaid_wrapper_rust_future_complete_f32: (a: bigint, b: number) => number;
+export const ffi_mermaid_wrapper_rust_future_complete_f64: (a: bigint, b: number) => number;
+export const ffi_mermaid_wrapper_rust_future_complete_i16: (a: bigint, b: number) => number;
+export const ffi_mermaid_wrapper_rust_future_complete_i32: (a: bigint, b: number) => number;
+export const ffi_mermaid_wrapper_rust_future_complete_i64: (a: bigint, b: number) => bigint;
+export const ffi_mermaid_wrapper_rust_future_complete_i8: (a: bigint, b: number) => number;
+export const ffi_mermaid_wrapper_rust_future_complete_rust_buffer: (a: number, b: bigint, c: number) => void;
+export const ffi_mermaid_wrapper_rust_future_complete_u16: (a: bigint, b: number) => number;
+export const ffi_mermaid_wrapper_rust_future_complete_u32: (a: bigint, b: number) => number;
+export const ffi_mermaid_wrapper_rust_future_complete_u64: (a: bigint, b: number) => bigint;
+export const ffi_mermaid_wrapper_rust_future_complete_u8: (a: bigint, b: number) => number;
+export const ffi_mermaid_wrapper_rust_future_complete_void: (a: bigint, b: number) => void;
+export const ffi_mermaid_wrapper_rust_future_free_f32: (a: bigint) => void;
+export const ffi_mermaid_wrapper_rust_future_free_f64: (a: bigint) => void;
+export const ffi_mermaid_wrapper_rust_future_free_i16: (a: bigint) => void;
+export const ffi_mermaid_wrapper_rust_future_free_i32: (a: bigint) => void;
+export const ffi_mermaid_wrapper_rust_future_free_i64: (a: bigint) => void;
+export const ffi_mermaid_wrapper_rust_future_free_i8: (a: bigint) => void;
+export const ffi_mermaid_wrapper_rust_future_free_rust_buffer: (a: bigint) => void;
+export const ffi_mermaid_wrapper_rust_future_free_u16: (a: bigint) => void;
+export const ffi_mermaid_wrapper_rust_future_free_u32: (a: bigint) => void;
+export const ffi_mermaid_wrapper_rust_future_free_u64: (a: bigint) => void;
+export const ffi_mermaid_wrapper_rust_future_free_u8: (a: bigint) => void;
+export const ffi_mermaid_wrapper_rust_future_free_void: (a: bigint) => void;
+export const ffi_mermaid_wrapper_rust_future_poll_f32: (a: bigint, b: number, c: bigint) => void;
+export const ffi_mermaid_wrapper_rust_future_poll_f64: (a: bigint, b: number, c: bigint) => void;
+export const ffi_mermaid_wrapper_rust_future_poll_i16: (a: bigint, b: number, c: bigint) => void;
+export const ffi_mermaid_wrapper_rust_future_poll_i32: (a: bigint, b: number, c: bigint) => void;
+export const ffi_mermaid_wrapper_rust_future_poll_i64: (a: bigint, b: number, c: bigint) => void;
+export const ffi_mermaid_wrapper_rust_future_poll_i8: (a: bigint, b: number, c: bigint) => void;
+export const ffi_mermaid_wrapper_rust_future_poll_rust_buffer: (a: bigint, b: number, c: bigint) => void;
+export const ffi_mermaid_wrapper_rust_future_poll_u16: (a: bigint, b: number, c: bigint) => void;
+export const ffi_mermaid_wrapper_rust_future_poll_u32: (a: bigint, b: number, c: bigint) => void;
+export const ffi_mermaid_wrapper_rust_future_poll_u64: (a: bigint, b: number, c: bigint) => void;
+export const ffi_mermaid_wrapper_rust_future_poll_u8: (a: bigint, b: number, c: bigint) => void;
+export const ffi_mermaid_wrapper_rust_future_poll_void: (a: bigint, b: number, c: bigint) => void;
+export const ffi_mermaid_wrapper_rustbuffer_alloc: (a: number, b: bigint, c: number) => void;
+export const ffi_mermaid_wrapper_rustbuffer_free: (a: number, b: number) => void;
+export const ffi_mermaid_wrapper_rustbuffer_from_bytes: (a: number, b: number, c: number) => void;
+export const ffi_mermaid_wrapper_rustbuffer_reserve: (a: number, b: number, c: bigint, d: number) => void;
+export const __wbindgen_free: (a: number, b: number, c: number) => void;
+export const __wbindgen_malloc: (a: number, b: number) => number;
+export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_externrefs: WebAssembly.Table;
+export const __wbindgen_start: () => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-ariel",
-  "version": "0.1.0-dev.50",
+  "version": "0.1.0-dev.52",
   "description": "Mermaid diagrams for React Native and React Native Web. No DOM. No WebView. Pure Rust.",
   "main": "./lib/module/index.js",
   "source": "./src/index.tsx",

package/android/CMakeLists.txt

@@ -1,79 +0,0 @@
-# Generated by uniffi-bindgen-react-native
-cmake_minimum_required(VERSION 3.9.0)
-project(Ariel)
-
-set (CMAKE_VERBOSE_MAKEFILE ON)
-set (CMAKE_CXX_STANDARD 17)
-
-# Resolve uniffi-bindgen-react-native includes.
-# When building the library locally: ../node_modules/ (workspace root)
-# When installed as npm dependency: ../../ (npm hoists to consumer's node_modules)
-set(_UNIFFI_LOCAL  "${CMAKE_CURRENT_LIST_DIR}/../node_modules/uniffi-bindgen-react-native/cpp/includes")
-set(_UNIFFI_HOISTED "${CMAKE_CURRENT_LIST_DIR}/../../uniffi-bindgen-react-native/cpp/includes")
-if(EXISTS "${_UNIFFI_LOCAL}")
-  cmake_path(SET UNIFFI_INCLUDES "${_UNIFFI_LOCAL}" NORMALIZE)
-else()
-  cmake_path(SET UNIFFI_INCLUDES "${_UNIFFI_HOISTED}" NORMALIZE)
-endif()
-
-include_directories(
-    ../cpp
-    ../cpp/generated
-
-    ${UNIFFI_INCLUDES}
-)
-
-add_library(react-native-ariel            SHARED
-    ../cpp/react-native-ariel.cpp
-    ../cpp/generated/mermaid_wrapper.cpp
-    cpp-adapter.cpp
-)
-
-# Set C++ compiler flags
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O2")
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fexceptions")
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -frtti")
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fstack-protector-all")
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror")
-
-# Set linker flags for 16KB page size alignment (required for Android 15+)
-set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-z,max-page-size=16384")
-
-cmake_path(
-  SET MY_RUST_LIB
-  ${CMAKE_CURRENT_LIST_DIR}/src/main/jniLibs/${ANDROID_ABI}/libmermaid_wrapper.a
-  NORMALIZE
-)
-add_library(my_rust_lib STATIC IMPORTED)
-set_target_properties(my_rust_lib PROPERTIES IMPORTED_LOCATION ${MY_RUST_LIB})
-
-# Add ReactAndroid libraries, being careful to account for different versions.
-find_package(ReactAndroid REQUIRED CONFIG)
-find_library(LOGCAT log)
-
-# REACTNATIVE_MERGED_SO seems to be only be set in a build.gradle.kt file,
-# which we don't use. Thus falling back to version number sniffing.
-if (ReactAndroid_VERSION_MINOR GREATER_EQUAL 76)
-  set(REACTNATIVE_MERGED_SO true)
-endif()
-
-# https://github.com/react-native-community/discussions-and-proposals/discussions/816
-# This if-then-else can be removed once this library does not support version below 0.76
-if (REACTNATIVE_MERGED_SO)
-  target_link_libraries(react-native-ariel ReactAndroid::reactnative)
-else()
-  target_link_libraries(react-native-ariel
-    ReactAndroid::turbomodulejsijni
-    ReactAndroid::react_nativemodule_core
-  )
-endif()
-
-find_package(fbjni REQUIRED CONFIG)
-target_link_libraries(
-  react-native-ariel
-  fbjni::fbjni
-  ReactAndroid::jsi
-  ${LOGCAT}
-  my_rust_lib
-)