math-core 0.6.4 → 0.8.1

package/README.md

@@ -12,6 +12,7 @@ A Node.js library for converting LaTeX math expressions to MathML Core.
 - Support for both inline and display (block) math
 - Define custom LaTeX macros for extended functionality
 - Global and local counter for numbered equations
+- Batch conversion which resolves forward references between snippets
 - Pretty-printing option for readable MathML output
 - Comprehensive error handling with descriptive error messages
 
@@ -31,12 +32,12 @@ import { LatexToMathML } from "math-core";
 const converter = new LatexToMathML({});
 
 // Convert inline math
-const inline = converter.convert_with_local_counter("x^2 + y^2 = z^2", false);
+const inline = converter.convert_with_local_state("x^2 + y^2 = z^2", false);
 console.log(inline);
 // Output: <math><msup><mi>x</mi><mn>2</mn></msup><mo>+</mo><msup><mi>y</mi><mn>2</mn></msup><mo>=</mo><msup><mi>z</mi><mn>2</mn></msup></math>
 
 // Convert display math
-const display = converter.convert_with_local_counter("\\frac{1}{2}", true);
+const display = converter.convert_with_local_state("\\frac{1}{2}", true);
 console.log(display);
 // Output: <math display="block"><mfrac><mn>1</mn><mn>2</mn></mfrac></math>
 ```
@@ -51,7 +52,7 @@ import { LatexToMathML } from "math-core";
 const converter = new LatexToMathML({ prettyPrint: "always" });
 
 try {
-  const mathml = converter.convert_with_local_counter("\\sqrt{x^2 + 1}", false);
+  const mathml = converter.convert_with_local_state("\\sqrt{x^2 + 1}", false);
   console.log(mathml);
 } catch (e) {
   console.error(`Conversion error: ${e.message}`);
@@ -69,10 +70,10 @@ macros.set("R", "\\mathbb{R}");    // Real numbers
 macros.set("vec", "\\mathbf{#1}"); // Vector notation
 
 const converter = new LatexToMathML({ macros });
-const mathml = converter.convert_with_local_counter("\\d x", false);
+const mathml = converter.convert_with_local_state("\\d x", false);
 ```
 
-### Numbered Equations with Global Counter
+### Numbered Equations with Global State
 
 For documents with multiple numbered equations:
 
@@ -80,22 +81,22 @@ For documents with multiple numbered equations:
 const converter = new LatexToMathML({});
 
 // First equation gets (1)
-const eq1 = converter.convert_with_global_counter(
+const eq1 = converter.convert_with_global_state(
   "\\begin{align}E = mc^2\\end{align}",
   true,
 );
 
 // Second equation gets (2)
-const eq2 = converter.convert_with_global_counter(
+const eq2 = converter.convert_with_global_state(
   "\\begin{align}F = ma\\end{align}",
   true,
 );
 
 // Reset counter when starting a new chapter/section
-converter.reset_global_counter();
+converter.reset_global_state();
 
 // This equation gets (1) again
-const eq3 = converter.convert_with_global_counter(
+const eq3 = converter.convert_with_global_state(
   "\\begin{align}p = mv\\end{align}",
   true,
 );
@@ -109,17 +110,39 @@ Use local counters when equation numbers should restart within each conversion:
 const converter = new LatexToMathML({});
 
 // Each conversion has independent numbering
-const doc1 = converter.convert_with_local_counter(
+const doc1 = converter.convert_with_local_state(
   "\\begin{align}a &= b\\\\c &= d\\end{align}",
   true,
 ); // Contains (1) and (2)
 
-const doc2 = converter.convert_with_local_counter(
+const doc2 = converter.convert_with_local_state(
   "\\begin{align}x &= y\\\\z &= w\\end{align}",
   true,
 ); // Also contains (1) and (2)
 ```
 
+### Converting a Whole Document at Once
+
+`convert_all` converts a collection of snippets in one go, which is the only way to get
+*forward references* right: a snippet may refer to an equation which is only defined in a later
+snippet.
+
+```javascript
+const converter = new LatexToMathML({});
+
+const [reference, equation] = converter.convert_all([
+  { latex: "\\eqref{eq:euler}", displayStyle: false },
+  {
+    latex: "\\begin{align}e^{i\\pi} + 1 = 0\\label{eq:euler}\\end{align}",
+    displayStyle: true,
+  },
+]);
+// `reference` refers to equation (1), even though it comes first.
+```
+
+Equation numbering restarts with every call to `convert_all`; the state of
+`convert_with_global_state` is neither used nor modified.
+
 ### Error Handling
 
 By default, conversion errors throw a `LatexError` with detailed diagnostics:
@@ -128,7 +151,7 @@ By default, conversion errors throw a `LatexError` with detailed diagnostics:
 const converter = new LatexToMathML({});
 
 try {
-  converter.convert_with_local_counter("\\begin{foobar}", false);
+  converter.convert_with_local_state("\\begin{foobar}", false);
 } catch (e) {
   console.log(e.message); // 'Unknown environment "foobar".'
   console.log(e.report);  // Formatted diagnostic with source spans
@@ -142,7 +165,7 @@ Set `throwOnError: false` to return an HTML error snippet instead of throwing:
 
 ```javascript
 const converter = new LatexToMathML({ throwOnError: false });
-const result = converter.convert_with_local_counter("\\invalid", false);
+const result = converter.convert_with_local_state("\\invalid", false);
 // Returns: <span class="math-core-error" title="..."><code>\invalid</code></span>
 ```
 
@@ -168,12 +191,16 @@ new LatexToMathML(options: MathCoreOptions)
 | `throwOnError` | `boolean` | `true` | Throw `LatexError` on conversion errors. If `false`, returns an HTML error snippet instead. |
 | `ignoreUnknownCommands` | `boolean` | `false` | Render unknown commands as red text instead of erroring. |
 | `annotation` | `boolean` | `false` | Include the original LaTeX as an annotation in the MathML output. |
+| `globalGroup` | `boolean` | `false` | Run the conversion in the global group, so that commands defined with `\newcommand` stay defined for subsequent calls to `convert_with_global_state`. If `false`, such definitions are local to the snippet which contains them. |
+| `maxExpansions` | `number` | `1000` | How many custom commands may be expanded in one snippet before the conversion gives up. The limit exists because a macro may expand to itself, directly or indirectly. |
+| `idPrefix`      | `string` | `""`   | Added to the beginning of every `id` and anchor reference. Use this to avoid conflicts when embedding the output. |
 
 **Methods:**
 
-- `convert_with_global_counter(latex: string, displaystyle: boolean): string` — Convert LaTeX to MathML using a global equation counter.
-- `convert_with_local_counter(latex: string, displaystyle: boolean): string` — Convert LaTeX to MathML using a local equation counter.
-- `reset_global_counter(): void` — Reset the global equation counter to zero.
+- `convert_with_global_state(latex: string, displaystyle: boolean): string` — Convert LaTeX to MathML using global state.
+- `convert_with_local_state(latex: string, displaystyle: boolean): string` — Convert LaTeX to MathML using local state.
+- `convert_all(snippets: MathSnippet[]): string[]` — Convert all snippets of a document at once, resolving forward references between them. A `MathSnippet` is `{ latex: string, displayStyle: boolean }`. Uses a fresh state for the batch, independent of the global state.
+- `reset_global_state(): void` — Reset the global state (e.g., set the equation counter to zero).
 
 ### `LatexError`
 
@@ -188,6 +215,7 @@ Error thrown when LaTeX parsing or conversion fails.
 | `context` | `string \| undefined` | The relevant LaTeX source. |
 | `start` | `number` | Start offset of the error in the source. |
 | `end` | `number` | End offset of the error in the source. |
+| `index` | `number \| undefined` | Index of the failing snippet; only set by `convert_all`. |
 
 ## Why MathML Core?
 

package/dist/math_core.d.ts

@@ -9,6 +9,15 @@ interface MathCoreOptions {
     ignoreUnknownCommands?: boolean;
     annotation?: boolean;
     allowUnreliableRendering?: boolean;
+    globalGroup?: boolean;
+    unicodeSubstitution?: "never" | "conventional";
+    maxExpansions?: number;
+    idPrefix?: string;
+}
+
+interface MathSnippet {
+    latex: string;
+    displayStyle: boolean;
 }
 
 
@@ -25,6 +34,14 @@ export class LatexError {
     free(): void;
     [Symbol.dispose](): void;
     end: number;
+    /**
+     * The index of the snippet that caused the error; only set by `convert_all`.
+     */
+    get index(): number | undefined;
+    /**
+     * The index of the snippet that caused the error; only set by `convert_all`.
+     */
+    set index(value: number | null | undefined);
     start: number;
     readonly context: string | undefined;
     readonly label: string;
@@ -35,8 +52,18 @@ export class LatexError {
 export class LatexToMathML {
     free(): void;
     [Symbol.dispose](): void;
-    convert_with_global_counter(content: string, displaystyle: boolean): string;
-    convert_with_local_counter(content: string, displaystyle: boolean): string;
+    /**
+     * Convert a collection of LaTeX snippets to MathML.
+     *
+     * In contrast to the other conversion methods, this one resolves *forward references*
+     * correctly, meaning that a snippet can refer to an equation which is only defined in a
+     * later snippet. This is why all snippets of a document have to be passed in at once.
+     *
+     * The conversion does not touch the global state; it uses a fresh state for the whole batch.
+     */
+    convert_all(snippets: MathSnippet[]): string[];
+    convert_with_global_state(content: string, displaystyle: boolean): string;
+    convert_with_local_state(content: string, displaystyle: boolean): string;
     constructor(js_config: MathCoreOptions);
-    reset_global_counter(): void;
+    reset_global_state(): void;
 }

package/dist/math_core.js

@@ -53,6 +53,14 @@ export class LatexError {
         const ret = wasm.__wbg_get_latexerror_end(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * The index of the snippet that caused the error; only set by `convert_all`.
+     * @returns {number | undefined}
+     */
+    get index() {
+        const ret = wasm.__wbg_get_latexerror_index(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+    }
     /**
      * @returns {number}
      */
@@ -94,6 +102,13 @@ export class LatexError {
     set end(arg0) {
         wasm.__wbg_set_latexerror_end(this.__wbg_ptr, arg0);
     }
+    /**
+     * The index of the snippet that caused the error; only set by `convert_all`.
+     * @param {number | null} [arg0]
+     */
+    set index(arg0) {
+        wasm.__wbg_set_latexerror_index(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : (arg0) >>> 0);
+    }
     /**
      * @param {number} arg0
      */
@@ -114,15 +129,35 @@ export class LatexToMathML {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_latextomathml_free(ptr, 0);
     }
+    /**
+     * Convert a collection of LaTeX snippets to MathML.
+     *
+     * In contrast to the other conversion methods, this one resolves *forward references*
+     * correctly, meaning that a snippet can refer to an equation which is only defined in a
+     * later snippet. This is why all snippets of a document have to be passed in at once.
+     *
+     * The conversion does not touch the global state; it uses a fresh state for the whole batch.
+     * @param {MathSnippet[]} snippets
+     * @returns {string[]}
+     */
+    convert_all(snippets) {
+        const ptr0 = passArrayJsValueToWasm0(snippets, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.latextomathml_convert_all(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * @param {string} content
      * @param {boolean} displaystyle
      * @returns {string}
      */
-    convert_with_global_counter(content, displaystyle) {
+    convert_with_global_state(content, displaystyle) {
         const ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.latextomathml_convert_with_global_counter(this.__wbg_ptr, ptr0, len0, displaystyle);
+        const ret = wasm.latextomathml_convert_with_global_state(this.__wbg_ptr, ptr0, len0, displaystyle);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -133,10 +168,10 @@ export class LatexToMathML {
      * @param {boolean} displaystyle
      * @returns {string}
      */
-    convert_with_local_counter(content, displaystyle) {
+    convert_with_local_state(content, displaystyle) {
         const ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.latextomathml_convert_with_local_counter(this.__wbg_ptr, ptr0, len0, displaystyle);
+        const ret = wasm.latextomathml_convert_with_local_state(this.__wbg_ptr, ptr0, len0, displaystyle);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -154,15 +189,15 @@ export class LatexToMathML {
         LatexToMathMLFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
-    reset_global_counter() {
-        wasm.latextomathml_reset_global_counter(this.__wbg_ptr);
+    reset_global_state() {
+        wasm.latextomathml_reset_global_state(this.__wbg_ptr);
     }
 }
 if (Symbol.dispose) LatexToMathML.prototype[Symbol.dispose] = LatexToMathML.prototype.free;
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
-        __wbg___wbindgen_string_get_72bdf95d3ae505b1: function(arg0, arg1) {
+        __wbg___wbindgen_string_get_d154f1e671052120: function(arg0, arg1) {
             const obj = arg1;
             const ret = typeof(obj) === 'string' ? obj : undefined;
             var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -170,14 +205,14 @@ function __wbg_get_imports() {
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
-        __wbg___wbindgen_throw_1506f2235d1bdba0: function(arg0, arg1) {
+        __wbg___wbindgen_throw_bb96b2010945f0bc: function(arg0, arg1) {
             throw new Error(getStringFromWasm0(arg0, arg1));
         },
-        __wbg_allowUnreliableRendering_85799e8d6aea3b13: function(arg0) {
+        __wbg_allowUnreliableRendering_f0c78f4923af73fc: function(arg0) {
             const ret = arg0.allowUnreliableRendering;
             return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
         },
-        __wbg_annotation_787a5a6d7b450089: function(arg0) {
+        __wbg_annotation_219e13c187863cec: function(arg0) {
             const ret = arg0.annotation;
             return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
         },
@@ -185,58 +220,91 @@ function __wbg_get_imports() {
             const ret = ConfigParseError.__wrap(arg0);
             return ret;
         },
-        __wbg_done_60cf307fcc680536: function(arg0) {
+        __wbg_displayStyle_ef5256c58c97a5f4: function(arg0) {
+            const ret = arg0.displayStyle;
+            return ret;
+        },
+        __wbg_done_669171204c3dcae2: function(arg0) {
             const ret = arg0.done;
             return ret;
         },
-        __wbg_entries_206899f1a3dd30a8: function(arg0) {
+        __wbg_entries_71601bcb707d5078: function(arg0) {
             const ret = arg0.entries();
             return ret;
         },
-        __wbg_get_2b48c7d0d006a781: function(arg0, arg1) {
+        __wbg_get_c0c8f8d7da0c03dd: function(arg0, arg1) {
             const ret = arg0[arg1 >>> 0];
             return ret;
         },
-        __wbg_ignoreUnknownCommands_2e5f9e0782e159a4: function(arg0) {
+        __wbg_globalGroup_417d1d431020809d: function(arg0) {
+            const ret = arg0.globalGroup;
+            return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
+        },
+        __wbg_idPrefix_07be803c89cf3933: function(arg0, arg1) {
+            const ret = arg1.idPrefix;
+            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg_ignoreUnknownCommands_da90e0b44c9174eb: function(arg0) {
             const ret = arg0.ignoreUnknownCommands;
             return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
         },
-        __wbg_isArray_67c2c9c4313f4448: function(arg0) {
+        __wbg_isArray_6339f732981044bf: function(arg0) {
             const ret = Array.isArray(arg0);
             return ret;
         },
+        __wbg_latex_1391c6fb0158a049: function(arg0, arg1) {
+            const ret = arg1.latex;
+            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);
+        },
         __wbg_latexerror_new: function(arg0) {
             const ret = LatexError.__wrap(arg0);
             return ret;
         },
-        __wbg_macros_b577b47d3bca5e4c: function(arg0) {
+        __wbg_macros_8b80b019c07a1eea: function(arg0) {
             const ret = arg0.macros;
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         },
-        __wbg_next_eb8ca7351fa27906: function() { return handleError(function (arg0) {
+        __wbg_maxExpansions_16e5fe2a6d81c63d: function(arg0) {
+            const ret = arg0.maxExpansions;
+            return isLikeNone(ret) ? Number.MAX_SAFE_INTEGER : (ret) >>> 0;
+        },
+        __wbg_next_42cf16ee0dafc9e2: function() { return handleError(function (arg0) {
             const ret = arg0.next();
             return ret;
         }, arguments); },
-        __wbg_prettyPrint_3bde870ba3a210c7: function(arg0, arg1) {
+        __wbg_prettyPrint_5d11563071318855: function(arg0, arg1) {
             const ret = arg1.prettyPrint;
             var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
             var len1 = WASM_VECTOR_LEN;
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
-        __wbg_size_5ef6bbbc4b6332a9: function(arg0) {
+        __wbg_size_7c5f5d6c17503441: function(arg0) {
             const ret = arg0.size;
             return ret;
         },
-        __wbg_throwOnError_f0f4b6c0a179492b: function(arg0) {
+        __wbg_throwOnError_1c2db037b7b92155: function(arg0) {
             const ret = arg0.throwOnError;
             return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
         },
-        __wbg_value_f3625092ee4b37f4: function(arg0) {
+        __wbg_unicodeSubstitution_ef25a02b6746022e: function(arg0, arg1) {
+            const ret = arg1.unicodeSubstitution;
+            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg_value_1e2369fab29b420e: function(arg0) {
             const ret = arg0.value;
             return ret;
         },
-        __wbg_xmlNamespace_64127331da9c1367: function(arg0) {
+        __wbg_xmlNamespace_58e49416ebc58362: function(arg0) {
             const ret = arg0.xmlNamespace;
             return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
         },
@@ -245,6 +313,13 @@ function __wbg_get_imports() {
             const ret = getStringFromWasm0(arg0, arg1);
             return ret;
         },
+        __wbindgen_cast_0000000000000002: function(arg0, arg1) {
+            var v0 = getArrayJsValueFromWasm0(arg0, arg1);
+            wasm.__wbindgen_free(arg0, arg1 * 4, 4);
+            // Cast intrinsic for `Vector(Externref) -> Externref`.
+            const ret = v0;
+            return ret;
+        },
         __wbindgen_init_externref_table: function() {
             const table = wasm.__wbindgen_externrefs;
             const offset = table.grow(4);
@@ -277,6 +352,17 @@ function addToExternrefTable0(obj) {
     return idx;
 }
 
+function getArrayJsValueFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    const mem = getDataViewMemory0();
+    const result = [];
+    for (let i = ptr; i < ptr + 4 * len; i += 4) {
+        result.push(wasm.__wbindgen_externrefs.get(mem.getUint32(i, true)));
+    }
+    wasm.__externref_drop_slice(ptr, len);
+    return result;
+}
+
 let cachedDataViewMemory0 = null;
 function getDataViewMemory0() {
     if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
@@ -310,6 +396,16 @@ function isLikeNone(x) {
     return x === undefined || x === null;
 }
 
+function passArrayJsValueToWasm0(array, malloc) {
+    const ptr = malloc(array.length * 4, 4) >>> 0;
+    for (let i = 0; i < array.length; i++) {
+        const add = addToExternrefTable0(array[i]);
+        getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
+    }
+    WASM_VECTOR_LEN = array.length;
+    return ptr;
+}
+
 function passStringToWasm0(arg, malloc, realloc) {
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);

package/dist/math_core_bg.wasm.d.ts

@@ -3,24 +3,29 @@
 export const memory: WebAssembly.Memory;
 export const __wbg_configparseerror_free: (a: number, b: number) => void;
 export const __wbg_get_latexerror_end: (a: number) => number;
+export const __wbg_get_latexerror_index: (a: number) => number;
 export const __wbg_get_latexerror_start: (a: number) => number;
 export const __wbg_latexerror_free: (a: number, b: number) => void;
 export const __wbg_latextomathml_free: (a: number, b: number) => void;
 export const __wbg_set_latexerror_end: (a: number, b: number) => void;
+export const __wbg_set_latexerror_index: (a: number, b: number) => void;
 export const __wbg_set_latexerror_start: (a: number, b: number) => void;
 export const configparseerror_message: (a: number) => any;
 export const latexerror_context: (a: number) => any;
 export const latexerror_label: (a: number) => any;
 export const latexerror_message: (a: number) => any;
 export const latexerror_report: (a: number) => any;
-export const latextomathml_convert_with_global_counter: (a: number, b: number, c: number, d: number) => [number, number, number];
-export const latextomathml_convert_with_local_counter: (a: number, b: number, c: number, d: number) => [number, number, number];
+export const latextomathml_convert_all: (a: number, b: number, c: number) => [number, number, number];
+export const latextomathml_convert_with_global_state: (a: number, b: number, c: number, d: number) => [number, number, number];
+export const latextomathml_convert_with_local_state: (a: number, b: number, c: number, d: number) => [number, number, number];
 export const latextomathml_new: (a: any) => [number, number, number];
-export const latextomathml_reset_global_counter: (a: number) => void;
+export const latextomathml_reset_global_state: (a: 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 __externref_table_alloc: () => number;
 export const __wbindgen_externrefs: WebAssembly.Table;
 export const __wbindgen_exn_store: (a: number) => void;
+export const __externref_drop_slice: (a: number, b: number) => void;
+export const __wbindgen_free: (a: number, b: number, c: number) => void;
 export const __externref_table_dealloc: (a: number) => void;
 export const __wbindgen_start: () => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "math-core",
-  "version": "0.6.4",
+  "version": "0.8.1",
   "description": "Convert LaTeX to MathML Core",
   "homepage": "https://github.com/tmke8/math-core#readme",
   "bugs": {