@strategicprojects/rpic 0.5.0 → 0.6.0

package/README.md

@@ -9,7 +9,7 @@ import * as rpic from '@strategicprojects/rpic';
 
 await rpic.ready();                       // browser: wasm fetched automatically
 
-const { svg, animations, diagnostics } = rpic.compile('box "A"; arrow; box "B"');
+const { svg, animations, diagnostics, warnings } = rpic.compile('box "A"; arrow; box "B"');
 document.querySelector('#stage').innerHTML = svg;
 
 // animate with GSAP:
@@ -29,20 +29,52 @@ await rpic.ready(readFileSync(new URL('./node_modules/rpic/pkg/rpic_wasm_bg.wasm
 console.log(rpic.renderSvg('box "hi"'));
 ```
 
+### TeX math labels (`texlabels`)
+
+The default wasm build is lean and renders `$…$` labels as literal text (plus
+a diagnostic). To typeset them exactly like the native CLI, opt into the
+math-enabled build — a second, heavier `.wasm` (RaTeX + embedded KaTeX glyph
+data) that is only fetched when you ask for it:
+
+```js
+await rpic.ready(undefined, { math: true }); // browser: fetches pkg/rpic_wasm_math_bg.wasm
+rpic.renderSvg('box "$-\\\\frac{T}{2}$" fit', { texlabels: true });
+```
+
+Apps can keep the fast path untouched and lazy-load math only when the source
+contains `$…$`. The build choice is fixed by the first `ready()` call. In
+Node, pass the math artifact's bytes:
+`ready(readFileSync(new URL('…/pkg/rpic_wasm_math_bg.wasm', import.meta.url)), { math: true })`.
+
 ## API
 
 | Function | Description |
 |----------|-------------|
-| `ready(wasmInput?)` | Initialize WASM. Browser: no arg. Node: pass `.wasm` bytes/URL. |
-| `compile(src, {circuits?})` | → `{ svg, animations, diagnostics }` (throws on a pic error). |
-| `renderSvg(src, {circuits?})` | → SVG string. |
+| `ready(wasmInput?, {math?})` | Initialize WASM. Browser: no arg. Node: pass `.wasm` bytes/URL. `math: true` loads the math-enabled build. |
+| `compile(src, {circuits?, texlabels?})` | → `{ svg, animations, diagnostics, warnings }` (throws on a pic error with `errorInfo`). |
+| `renderSvg(src, {circuits?, texlabels?})` | → SVG string. |
 | `animate(root, animations, gsap)` | Build/play a GSAP timeline (`draw`/`fade`/`pop`). Browser only. |
 
+Compile errors keep a readable `message` and expose structured data for editors:
+
+```js
+try {
+  rpic.compile('bxo');
+} catch (err) {
+  console.log(err.errorInfo); // { message, line, col, end_col, file, kind, found, expected, hint }
+}
+```
+
+Positions are always relative to your own source — with `circuits: true` an
+error on your line 1 reports `line: 1`, and a problem inside a `copy` include
+carries the include's name in `file` (`null` means your own input).
+
 PNG/PDF are available via the CLI, the Python package, or the R package (the
 WASM core renders SVG; rasterization isn't bundled here).
 
 ## Rebuild
 
 ```sh
-wasm-pack build crates/wasm --target web --out-dir bindings/js/pkg
+npm run build:wasm
+npm test
 ```

package/index.d.ts

@@ -8,11 +8,38 @@ export interface Anim {
   duration: number;
 }
 
+export interface Diagnostic {
+  message: string;
+  line: number | null;
+  col: number | null;
+  end_col: number | null;
+  /**
+   * Which source the position refers to: `null` is your own input; a string
+   * names a `copy` include (as written) or a loaded library (`"circuits"`).
+   * Positions are always relative to that source — with `circuits: true` an
+   * error on your line 1 reports line 1.
+   */
+  file: string | null;
+  kind: string;
+  found: string | null;
+  expected: string | null;
+  hint: string | null;
+}
+
 export interface Bundle {
   svg: string;
   animations: Anim[];
   /** lines emitted by pic `print` statements */
   diagnostics: string[];
+  /** non-fatal compiler warnings for accepted but suspicious input */
+  warnings: Diagnostic[];
+}
+
+export interface CompileError extends Error {
+  /** structured compiler error, when available */
+  errorInfo?: Diagnostic;
+  /** warnings emitted before the fatal error, currently usually empty */
+  warnings?: Diagnostic[];
 }
 
 export interface CompileOptions {
@@ -20,20 +47,34 @@ export interface CompileOptions {
   circuits?: boolean;
   /**
    * set `texlabels = 1`, typesetting fully `$…$`-delimited labels as TeX
-   * math. The default wasm build ships without the math renderer (size
-   * budget), so labels fall back to literal text plus a diagnostic; the
-   * option exists for API parity and future math-enabled builds.
+   * math. Requires the math-enabled build (`ready(…, { math: true })`); the
+   * default lean build ships without the math renderer (size budget), so
+   * labels fall back to literal text plus a diagnostic.
    */
   texlabels?: boolean;
 }
 
+export interface ReadyOptions {
+  /**
+   * Load the math-enabled wasm build (`pkg/rpic_wasm_math_bg.wasm`), which
+   * bundles the RaTeX renderer so `texlabels` sources typeset `$…$` labels.
+   * The heavier artifact is only fetched when requested; the choice is fixed
+   * by the first `ready()` call. In Node, pass the math wasm bytes as
+   * `wasmInput`.
+   */
+  math?: boolean;
+}
+
 /**
  * Initialize the WebAssembly module. In the browser call with no argument; in
  * Node pass the `.wasm` bytes or a file URL.
  */
-export function ready(wasmInput?: BufferSource | URL | string): Promise<void>;
+export function ready(
+  wasmInput?: BufferSource | URL | string,
+  opts?: ReadyOptions
+): Promise<void>;
 
-/** Compile pic source into `{ svg, animations, diagnostics }`. Throws on a pic error. */
+/** Compile pic source into `{ svg, animations, diagnostics, warnings }`. Throws on a pic error. */
 export function compile(src: string, opts?: CompileOptions): Bundle;
 
 /** Compile and return only the SVG string. */

package/index.js

@@ -2,51 +2,60 @@
 //
 // Browser:  await ready();                         // wasm fetched automatically
 // Node:     await ready(fs.readFileSync(url));      // pass the .wasm bytes/URL
-import initWasm, {
-  compile as wasmCompile,
-  compile_circuits as wasmCompileCircuits,
-  compile_with as wasmCompileWith,
-} from './pkg/rpic_wasm.js';
+// Math:     await ready(undefined, { math: true }); // texlabels typeset in-browser
+import * as leanModule from './pkg/rpic_wasm.js';
 
 let initPromise = null;
-let initialized = false;
+let wasm = null; // the initialized glue module (lean or math)
 
 /**
  * Initialize the WebAssembly module (idempotent; concurrent calls share one
  * init). In the browser, call with no argument (the .wasm is fetched relative
  * to the module). In Node, pass the wasm bytes or a file URL.
+ *
+ * Pass `{ math: true }` to load the math-enabled build instead: it bundles
+ * the RaTeX renderer so `texlabels` sources typeset `$…$` labels exactly like
+ * the native CLI. The math glue + wasm are only fetched when requested, so
+ * the lean fast path stays untouched. The choice is fixed by the first call;
+ * in Node, pass the bytes of `pkg/rpic_wasm_math_bg.wasm` along with it.
  */
-export function ready(wasmInput) {
+export function ready(wasmInput, opts = {}) {
   if (!initPromise) {
-    initPromise = initWasm(
-      wasmInput === undefined ? undefined : { module_or_path: wasmInput }
-    ).then(() => {
-      initialized = true;
+    initPromise = (
+      opts.math ? import('./pkg/rpic_wasm_math.js') : Promise.resolve(leanModule)
+    ).then(async (mod) => {
+      await mod.default(wasmInput === undefined ? undefined : { module_or_path: wasmInput });
+      wasm = mod;
     });
   }
   return initPromise;
 }
 
 function ensure() {
-  if (!initialized) {
+  if (!wasm) {
     throw new Error('rpic: call `await ready()` before compiling');
   }
 }
 
 /**
- * Compile pic source into `{ svg, animations, diagnostics }` (throws on a pic error).
+ * Compile pic source into `{ svg, animations, diagnostics, warnings }` (throws on a pic error).
  * @param {string} src
  * @param {{circuits?: boolean, texlabels?: boolean}} [opts]
  */
 export function compile(src, opts = {}) {
   ensure();
   const json = opts.texlabels
-    ? wasmCompileWith(src, !!opts.circuits, true)
+    ? wasm.compile_with(src, !!opts.circuits, true)
     : opts.circuits
-      ? wasmCompileCircuits(src)
-      : wasmCompile(src);
+      ? wasm.compile_circuits(src)
+      : wasm.compile(src);
   const out = JSON.parse(json);
-  if (out.error) throw new Error(out.error);
+  if (out.error) {
+    const err = new Error(out.error);
+    err.errorInfo = out.error_info;
+    err.warnings = out.warnings ?? [];
+    throw err;
+  }
   return out;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strategicprojects/rpic",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "The pic graphics language compiled to SVG with animation manifests, via WebAssembly. Browser + Node.",
   "type": "module",
   "main": "./index.js",
@@ -11,7 +11,8 @@
       "types": "./index.d.ts",
       "default": "./index.js"
     },
-    "./pkg/rpic_wasm_bg.wasm": "./pkg/rpic_wasm_bg.wasm"
+    "./pkg/rpic_wasm_bg.wasm": "./pkg/rpic_wasm_bg.wasm",
+    "./pkg/rpic_wasm_math_bg.wasm": "./pkg/rpic_wasm_math_bg.wasm"
   },
   "files": [
     "index.js",
@@ -20,10 +21,18 @@
     "pkg/rpic_wasm.d.ts",
     "pkg/rpic_wasm_bg.wasm",
     "pkg/rpic_wasm_bg.wasm.d.ts",
+    "pkg/rpic_wasm_math.js",
+    "pkg/rpic_wasm_math.d.ts",
+    "pkg/rpic_wasm_math_bg.wasm",
+    "pkg/rpic_wasm_math_bg.wasm.d.ts",
     "README.md"
   ],
   "scripts": {
-    "prepack": "wasm-pack build ../../crates/wasm --target web --out-dir ../../bindings/js/pkg"
+    "build:wasm:lean": "wasm-pack build ../../crates/wasm --target web --out-dir ../../bindings/js/pkg",
+    "build:wasm:math": "wasm-pack build ../../crates/wasm --target web --out-dir ../../bindings/js/pkg --out-name rpic_wasm_math -- --features math",
+    "build:wasm": "npm run build:wasm:lean && npm run build:wasm:math",
+    "prepack": "npm run build:wasm",
+    "test": "node test/smoke.mjs && node test/smoke-math.mjs"
   },
   "keywords": ["pic", "svg", "diagram", "graphics", "wasm", "gsap", "animation", "circuits"],
   "author": "André Leite <leite@de.ufpe.br>",

package/pkg/rpic_wasm.d.ts

@@ -2,24 +2,25 @@
 /* eslint-disable */
 
 /**
- * Compile pic source to a JSON `{svg, animations, diagnostics}` bundle (or
- * `{error}`).
+ * Compile pic source to a JSON `{svg, animations, diagnostics, warnings}`
+ * bundle (or `{error, error_info}`).
  */
 export function compile(src: string): string;
 
 /**
- * Like [`compile`], but with the native circuit-element library prepended
- * (so `resistor`, `and_gate`, … are available).
+ * Like [`compile`], but with the native circuit-element library loaded
+ * (so `resistor`, `and_gate`, … are available). Loaded as an option, not
+ * prepended text: diagnostic positions stay relative to `src`.
  */
 export function compile_circuits(src: string): string;
 
 /**
- * Like [`compile`], with options: `circuits` prepends the circuit-element
+ * Like [`compile`], with options: `circuits` loads the circuit-element
  * library; `texlabels` sets `texlabels = 1` so `$…$` labels are typeset as
- * TeX math. Note: this wasm build ships without the math renderer (size
- * budget), so with `texlabels` the labels currently fall back to literal
- * text and a diagnostic — the option exists for API parity and for future
- * math-enabled builds.
+ * TeX math. Note: the default wasm build ships without the math renderer
+ * (size budget), so with `texlabels` the labels fall back to literal text
+ * and a diagnostic — use the math-enabled build (`--features math`, the
+ * `rpic_wasm_math` npm artifact) to typeset them.
  */
 export function compile_with(src: string, circuits: boolean, texlabels: boolean): string;
 

package/pkg/rpic_wasm.js

@@ -1,8 +1,8 @@
 /* @ts-self-types="./rpic_wasm.d.ts" */
 
 /**
- * Compile pic source to a JSON `{svg, animations, diagnostics}` bundle (or
- * `{error}`).
+ * Compile pic source to a JSON `{svg, animations, diagnostics, warnings}`
+ * bundle (or `{error, error_info}`).
  * @param {string} src
  * @returns {string}
  */
@@ -22,8 +22,9 @@ export function compile(src) {
 }
 
 /**
- * Like [`compile`], but with the native circuit-element library prepended
- * (so `resistor`, `and_gate`, … are available).
+ * Like [`compile`], but with the native circuit-element library loaded
+ * (so `resistor`, `and_gate`, … are available). Loaded as an option, not
+ * prepended text: diagnostic positions stay relative to `src`.
  * @param {string} src
  * @returns {string}
  */
@@ -43,12 +44,12 @@ export function compile_circuits(src) {
 }
 
 /**
- * Like [`compile`], with options: `circuits` prepends the circuit-element
+ * Like [`compile`], with options: `circuits` loads the circuit-element
  * library; `texlabels` sets `texlabels = 1` so `$…$` labels are typeset as
- * TeX math. Note: this wasm build ships without the math renderer (size
- * budget), so with `texlabels` the labels currently fall back to literal
- * text and a diagnostic — the option exists for API parity and for future
- * math-enabled builds.
+ * TeX math. Note: the default wasm build ships without the math renderer
+ * (size budget), so with `texlabels` the labels fall back to literal text
+ * and a diagnostic — use the math-enabled build (`--features math`, the
+ * `rpic_wasm_math` npm artifact) to typeset them.
  * @param {string} src
  * @param {boolean} circuits
  * @param {boolean} texlabels

package/pkg/rpic_wasm_math.d.ts

@@ -0,0 +1,70 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * Compile pic source to a JSON `{svg, animations, diagnostics, warnings}`
+ * bundle (or `{error, error_info}`).
+ */
+export function compile(src: string): string;
+
+/**
+ * Like [`compile`], but with the native circuit-element library loaded
+ * (so `resistor`, `and_gate`, … are available). Loaded as an option, not
+ * prepended text: diagnostic positions stay relative to `src`.
+ */
+export function compile_circuits(src: string): string;
+
+/**
+ * Like [`compile`], with options: `circuits` loads the circuit-element
+ * library; `texlabels` sets `texlabels = 1` so `$…$` labels are typeset as
+ * TeX math. Note: the default wasm build ships without the math renderer
+ * (size budget), so with `texlabels` the labels fall back to literal text
+ * and a diagnostic — use the math-enabled build (`--features math`, the
+ * `rpic_wasm_math` npm artifact) to typeset them.
+ */
+export function compile_with(src: string, circuits: boolean, texlabels: boolean): string;
+
+/**
+ * Math-enabled builds (`--features math`) register the RaTeX renderer once
+ * at module init, so `texlabels` sources typeset `$…$` labels exactly like
+ * the native CLI. The lean default build registers nothing and math labels
+ * fall back to literal text plus a diagnostic.
+ */
+export function init_math(): void;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly compile: (a: number, b: number) => [number, number];
+    readonly compile_circuits: (a: number, b: number) => [number, number];
+    readonly compile_with: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly init_math: () => void;
+    readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly __wbindgen_malloc: (a: number, b: number) => number;
+    readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+    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/pkg/rpic_wasm_math.js

@@ -0,0 +1,273 @@
+/* @ts-self-types="./rpic_wasm_math.d.ts" */
+
+/**
+ * Compile pic source to a JSON `{svg, animations, diagnostics, warnings}`
+ * bundle (or `{error, error_info}`).
+ * @param {string} src
+ * @returns {string}
+ */
+export function compile(src) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(src, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.compile(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * Like [`compile`], but with the native circuit-element library loaded
+ * (so `resistor`, `and_gate`, … are available). Loaded as an option, not
+ * prepended text: diagnostic positions stay relative to `src`.
+ * @param {string} src
+ * @returns {string}
+ */
+export function compile_circuits(src) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(src, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.compile_circuits(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * Like [`compile`], with options: `circuits` loads the circuit-element
+ * library; `texlabels` sets `texlabels = 1` so `$…$` labels are typeset as
+ * TeX math. Note: the default wasm build ships without the math renderer
+ * (size budget), so with `texlabels` the labels fall back to literal text
+ * and a diagnostic — use the math-enabled build (`--features math`, the
+ * `rpic_wasm_math` npm artifact) to typeset them.
+ * @param {string} src
+ * @param {boolean} circuits
+ * @param {boolean} texlabels
+ * @returns {string}
+ */
+export function compile_with(src, circuits, texlabels) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(src, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.compile_with(ptr0, len0, circuits, texlabels);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * Math-enabled builds (`--features math`) register the RaTeX renderer once
+ * at module init, so `texlabels` sources typeset `$…$` labels exactly like
+ * the native CLI. The lean default build registers nothing and math labels
+ * fall back to literal text plus a diagnostic.
+ */
+export function init_math() {
+    wasm.init_math();
+}
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg___wbindgen_throw_344f42d3211c4765: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+        __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,
+        "./rpic_wasm_math_bg.js": import0,
+    };
+}
+
+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 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;
+    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('rpic_wasm_math_bg.wasm', import.meta.url);
+    }
+    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/pkg/rpic_wasm_math_bg.wasm.d.ts

@@ -0,0 +1,12 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const compile: (a: number, b: number) => [number, number];
+export const compile_circuits: (a: number, b: number) => [number, number];
+export const compile_with: (a: number, b: number, c: number, d: number) => [number, number];
+export const init_math: () => void;
+export const __wbindgen_externrefs: WebAssembly.Table;
+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_free: (a: number, b: number, c: number) => void;
+export const __wbindgen_start: () => void;