@gmb/bitmark-parser 6.1.1 → 6.1.3

package/wasm/bitmark_wasm.js

@@ -86,24 +86,26 @@ function getStringFromWasm0(ptr, len) {
     return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
 }
 /**
- * Re-emit input in its own format in canonical form at `mode`.
+ * Lex bitmark input text, returning one line per token in the same format as
+ * the Rust CLI: `{kind:?} {span:?} "{text}"`.
+ *
+ * `stage` selects the lexer pipeline:
+ *   - `"lex"` — combined (default)
+ *   - `"lex-json"` — combined, JSON array output
  * @param {string} input
- * @param {string} mode
- * @param {boolean} pretty
- * @param {number} indent
- * @param {number} spaces_around_values
+ * @param {string} stage
  * @returns {string}
  */
-module.exports.canonicalize = function(input, mode, pretty, indent, spaces_around_values) {
+module.exports.lex = function(input, stage) {
     let deferred3_0;
     let deferred3_1;
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
         const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
         const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(mode, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const ptr1 = passStringToWasm0(stage, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
         const len1 = WASM_VECTOR_LEN;
-        wasm.canonicalize(retptr, ptr0, len0, ptr1, len1, pretty, indent, spaces_around_values);
+        wasm.lex(retptr, ptr0, len0, ptr1, len1);
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         deferred3_0 = r0;
@@ -116,100 +118,33 @@ module.exports.canonicalize = function(input, mode, pretty, indent, spaces_aroun
 };
 
 /**
- * Re-emit input in its own format at full mode (all keys).
- * @param {string} input
- * @param {boolean} pretty
- * @param {number} indent
- * @returns {string}
- */
-module.exports.fullize = function(input, pretty, indent) {
-    let deferred2_0;
-    let deferred2_1;
-    try {
-        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
-        const len0 = WASM_VECTOR_LEN;
-        wasm.fullize(retptr, ptr0, len0, pretty, indent);
-        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-        deferred2_0 = r0;
-        deferred2_1 = r1;
-        return getStringFromWasm0(r0, r1);
-    } finally {
-        wasm.__wbindgen_add_to_stack_pointer(16);
-        wasm.__wbindgen_export_2(deferred2_0, deferred2_1, 1);
-    }
-};
-
-/**
- * Apply a patch (a JSON array of patch entries) to every bit and re-emit.
+ * Parse bitmark input text and return the reference JSON format.
  *
- * `input_format_sel`: `"auto"` | `"bitmark"` | `"json"`.
- * `output_format_sel`: `"bitmark"` | `"json"` (default json).
- * `patch_json`: the patch entry array (empty string = no patches, i.e. a
- * canonicalizing pass). Parallelism is a JS-side concern (web workers); this
- * runs sequentially. Returns the document text/JSON, or `error: …`.
+ * Uses the full pipeline: parse → validate → serialize.
+ *
+ * `mode`: `"optimized"` (default) or `"full"`
  * @param {string} input
- * @param {string} input_format_sel
- * @param {string} output_format_sel
  * @param {string} mode
- * @param {string} patch_json
- * @param {boolean} pretty
- * @param {number} indent
- * @param {number} spaces_around_values
  * @returns {string}
  */
-module.exports.transform = function(input, input_format_sel, output_format_sel, mode, patch_json, pretty, indent, spaces_around_values) {
-    let deferred6_0;
-    let deferred6_1;
+module.exports.parse = function(input, mode) {
+    let deferred3_0;
+    let deferred3_1;
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
         const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
         const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(input_format_sel, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const ptr1 = passStringToWasm0(mode, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
         const len1 = WASM_VECTOR_LEN;
-        const ptr2 = passStringToWasm0(output_format_sel, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
-        const len2 = WASM_VECTOR_LEN;
-        const ptr3 = passStringToWasm0(mode, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
-        const len3 = WASM_VECTOR_LEN;
-        const ptr4 = passStringToWasm0(patch_json, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
-        const len4 = WASM_VECTOR_LEN;
-        wasm.transform(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, pretty, indent, spaces_around_values);
-        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-        deferred6_0 = r0;
-        deferred6_1 = r1;
-        return getStringFromWasm0(r0, r1);
-    } finally {
-        wasm.__wbindgen_add_to_stack_pointer(16);
-        wasm.__wbindgen_export_2(deferred6_0, deferred6_1, 1);
-    }
-};
-
-/**
- * Split a bitmark document into per-bit source slices.
- *
- * Returns a JSON array of `{ index, byteStart, byteEnd, source }`. Lets a JS
- * caller chunk a document at bit boundaries (e.g. to feed a worker pool).
- * @param {string} input
- * @returns {string}
- */
-module.exports.split_bits = function(input) {
-    let deferred2_0;
-    let deferred2_1;
-    try {
-        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
-        const len0 = WASM_VECTOR_LEN;
-        wasm.split_bits(retptr, ptr0, len0);
+        wasm.parse(retptr, ptr0, len0, ptr1, len1);
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-        deferred2_0 = r0;
-        deferred2_1 = r1;
+        deferred3_0 = r0;
+        deferred3_1 = r1;
         return getStringFromWasm0(r0, r1);
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
-        wasm.__wbindgen_export_2(deferred2_0, deferred2_1, 1);
+        wasm.__wbindgen_export_2(deferred3_0, deferred3_1, 1);
     }
 };
 
@@ -247,34 +182,35 @@ module.exports.breakscape_text = function(input, format, location) {
 };
 
 /**
- * Lex bitmark input text, returning one line per token in the same format as
- * the Rust CLI: `{kind:?} {span:?} "{text}"`.
+ * Unbreakscape text (unescape bitmark special characters).
  *
- * `stage` selects the lexer pipeline:
- *   - `"lex"` — combined (default)
- *   - `"lex-json"` — combined, JSON array output
+ * `format`: `"bitmark++"` (default) or `"plainText"`
+ * `location`: `"body"` (default) or `"tag"`
  * @param {string} input
- * @param {string} stage
+ * @param {string} format
+ * @param {string} location
  * @returns {string}
  */
-module.exports.lex = function(input, stage) {
-    let deferred3_0;
-    let deferred3_1;
+module.exports.unbreakscape_text = function(input, format, location) {
+    let deferred4_0;
+    let deferred4_1;
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
         const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
         const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(stage, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const ptr1 = passStringToWasm0(format, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
         const len1 = WASM_VECTOR_LEN;
-        wasm.lex(retptr, ptr0, len0, ptr1, len1);
+        const ptr2 = passStringToWasm0(location, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len2 = WASM_VECTOR_LEN;
+        wasm.unbreakscape_text(retptr, ptr0, len0, ptr1, len1, ptr2, len2);
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-        deferred3_0 = r0;
-        deferred3_1 = r1;
+        deferred4_0 = r0;
+        deferred4_1 = r1;
         return getStringFromWasm0(r0, r1);
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
-        wasm.__wbindgen_export_2(deferred3_0, deferred3_1, 1);
+        wasm.__wbindgen_export_2(deferred4_0, deferred4_1, 1);
     }
 };
 
@@ -306,52 +242,21 @@ module.exports.split_json_bits = function(input) {
 };
 
 /**
- * Unbreakscape text (unescape bitmark special characters).
- *
- * `format`: `"bitmark++"` (default) or `"plainText"`
- * `location`: `"body"` (default) or `"tag"`
- * @param {string} input
- * @param {string} format
- * @param {string} location
- * @returns {string}
- */
-module.exports.unbreakscape_text = function(input, format, location) {
-    let deferred4_0;
-    let deferred4_1;
-    try {
-        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(format, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
-        const len1 = WASM_VECTOR_LEN;
-        const ptr2 = passStringToWasm0(location, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
-        const len2 = WASM_VECTOR_LEN;
-        wasm.unbreakscape_text(retptr, ptr0, len0, ptr1, len1, ptr2, len2);
-        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-        deferred4_0 = r0;
-        deferred4_1 = r1;
-        return getStringFromWasm0(r0, r1);
-    } finally {
-        wasm.__wbindgen_add_to_stack_pointer(16);
-        wasm.__wbindgen_export_2(deferred4_0, deferred4_1, 1);
-    }
-};
-
-/**
- * Count the bits in `input` (auto-detecting bitmark vs JSON).
- * Returns the count as a decimal string, or `error: …`.
- * @param {string} input
+ * Pretty-print a compact JSON string with the given indent. Used to format a
+ * document recombined on the JS side (the per-bit hook path) so its output
+ * matches the in-Rust recombination byte-for-byte.
+ * @param {string} json
+ * @param {number} indent
  * @returns {string}
  */
-module.exports.count_bits = function(input) {
+module.exports.prettify = function(json, indent) {
     let deferred2_0;
     let deferred2_1;
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const ptr0 = passStringToWasm0(json, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
         const len0 = WASM_VECTOR_LEN;
-        wasm.count_bits(retptr, ptr0, len0);
+        wasm.prettify(retptr, ptr0, len0, indent);
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         deferred2_0 = r0;
@@ -364,28 +269,47 @@ module.exports.count_bits = function(input) {
 };
 
 /**
- * Re-emit input in its own format at optimized mode (omit natural defaults).
+ * Apply a patch (a JSON array of patch entries) to every bit and re-emit.
+ *
+ * `input_format_sel`: `"auto"` | `"bitmark"` | `"json"`.
+ * `output_format_sel`: `"bitmark"` | `"json"` (default json).
+ * `patch_json`: the patch entry array (empty string = no patches, i.e. a
+ * canonicalizing pass). Parallelism is a JS-side concern (web workers); this
+ * runs sequentially. Returns the document text/JSON, or `error: …`.
  * @param {string} input
+ * @param {string} input_format_sel
+ * @param {string} output_format_sel
+ * @param {string} mode
+ * @param {string} patch_json
  * @param {boolean} pretty
  * @param {number} indent
+ * @param {number} spaces_around_values
  * @returns {string}
  */
-module.exports.optimize = function(input, pretty, indent) {
-    let deferred2_0;
-    let deferred2_1;
+module.exports.transform = function(input, input_format_sel, output_format_sel, mode, patch_json, pretty, indent, spaces_around_values) {
+    let deferred6_0;
+    let deferred6_1;
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
         const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
         const len0 = WASM_VECTOR_LEN;
-        wasm.optimize(retptr, ptr0, len0, pretty, indent);
+        const ptr1 = passStringToWasm0(input_format_sel, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(output_format_sel, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(mode, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len3 = WASM_VECTOR_LEN;
+        const ptr4 = passStringToWasm0(patch_json, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len4 = WASM_VECTOR_LEN;
+        wasm.transform(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, pretty, indent, spaces_around_values);
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-        deferred2_0 = r0;
-        deferred2_1 = r1;
+        deferred6_0 = r0;
+        deferred6_1 = r1;
         return getStringFromWasm0(r0, r1);
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
-        wasm.__wbindgen_export_2(deferred2_0, deferred2_1, 1);
+        wasm.__wbindgen_export_2(deferred6_0, deferred6_1, 1);
     }
 };
 
@@ -428,25 +352,67 @@ module.exports.info = function(info_type, format, bit, pretty, indent) {
 };
 
 /**
- * Parse bitmark input text and return the reference JSON format.
- *
- * Uses the full pipeline: parse → validate → serialize.
+ * Convert between bitmark and JSON with explicit input/output formats + mode.
  *
- * `mode`: `"optimized"` (default) or `"full"`
+ * `input_format`: `"auto"` (default) | `"bitmark"` | `"json"`.
+ * `output_format`: `"auto"` (opposite of input) | `"bitmark"` | `"json"`.
+ * `mode`: `"optimized"` (default) | `"full"`.
+ * Returns the converted text/JSON, or a string prefixed `error:` on failure.
  * @param {string} input
+ * @param {string} input_format_sel
+ * @param {string} output_format_sel
  * @param {string} mode
+ * @param {boolean} pretty
+ * @param {number} indent
+ * @param {number} spaces_around_values
  * @returns {string}
  */
-module.exports.parse = function(input, mode) {
+module.exports.convert = function(input, input_format_sel, output_format_sel, mode, pretty, indent, spaces_around_values) {
+    let deferred5_0;
+    let deferred5_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(input_format_sel, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(output_format_sel, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(mode, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len3 = WASM_VECTOR_LEN;
+        wasm.convert(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, pretty, indent, spaces_around_values);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        deferred5_0 = r0;
+        deferred5_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export_2(deferred5_0, deferred5_1, 1);
+    }
+};
+
+/**
+ * Re-emit input in its own format at optimized mode (omit natural defaults).
+ *
+ * `input_format`: `"auto"` (default) | `"bitmark"` | `"json"` | any config
+ * mapping id (`html`, `xml`, …). The output is re-emitted in this same format.
+ * @param {string} input
+ * @param {string} input_format_sel
+ * @param {boolean} pretty
+ * @param {number} indent
+ * @returns {string}
+ */
+module.exports.optimize = function(input, input_format_sel, pretty, indent) {
     let deferred3_0;
     let deferred3_1;
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
         const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
         const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(mode, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const ptr1 = passStringToWasm0(input_format_sel, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
         const len1 = WASM_VECTOR_LEN;
-        wasm.parse(retptr, ptr0, len0, ptr1, len1);
+        wasm.optimize(retptr, ptr0, len0, ptr1, len1, pretty, indent);
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         deferred3_0 = r0;
@@ -459,34 +425,87 @@ module.exports.parse = function(input, mode) {
 };
 
 /**
- * Whether `input` looks like bitmark (vs JSON). Mirrors the auto-detection
- * used across the API so a JS caller can resolve `"auto"` consistently.
+ * Re-emit input in its own format at full mode (all keys).
+ *
+ * `input_format`: `"auto"` (default) | `"bitmark"` | `"json"` | any config
+ * mapping id (`html`, `xml`, …). The output is re-emitted in this same format.
  * @param {string} input
- * @returns {boolean}
+ * @param {string} input_format_sel
+ * @param {boolean} pretty
+ * @param {number} indent
+ * @returns {string}
  */
-module.exports.is_bitmark = function(input) {
-    const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.is_bitmark(ptr0, len0);
-    return ret !== 0;
+module.exports.fullize = function(input, input_format_sel, pretty, indent) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(input_format_sel, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.fullize(retptr, ptr0, len0, ptr1, len1, pretty, indent);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        deferred3_0 = r0;
+        deferred3_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export_2(deferred3_0, deferred3_1, 1);
+    }
 };
 
 /**
- * Pretty-print a compact JSON string with the given indent. Used to format a
- * document recombined on the JS side (the per-bit hook path) so its output
- * matches the in-Rust recombination byte-for-byte.
- * @param {string} json
+ * Re-emit input in its own format in canonical form at `mode`.
+ *
+ * `input_format`: `"auto"` (default) | `"bitmark"` | `"json"` | any config
+ * mapping id (`html`, `xml`, …). The output is re-emitted in this same format.
+ * @param {string} input
+ * @param {string} input_format_sel
+ * @param {string} mode
+ * @param {boolean} pretty
  * @param {number} indent
+ * @param {number} spaces_around_values
  * @returns {string}
  */
-module.exports.prettify = function(json, indent) {
+module.exports.canonicalize = function(input, input_format_sel, mode, pretty, indent, spaces_around_values) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(input_format_sel, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(mode, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len2 = WASM_VECTOR_LEN;
+        wasm.canonicalize(retptr, ptr0, len0, ptr1, len1, ptr2, len2, pretty, indent, spaces_around_values);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        deferred4_0 = r0;
+        deferred4_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export_2(deferred4_0, deferred4_1, 1);
+    }
+};
+
+/**
+ * Count the bits in `input` (auto-detecting bitmark vs JSON).
+ * Returns the count as a decimal string, or `error: …`.
+ * @param {string} input
+ * @returns {string}
+ */
+module.exports.count_bits = function(input) {
     let deferred2_0;
     let deferred2_1;
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        const ptr0 = passStringToWasm0(json, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
         const len0 = WASM_VECTOR_LEN;
-        wasm.prettify(retptr, ptr0, len0, indent);
+        wasm.count_bits(retptr, ptr0, len0);
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         deferred2_0 = r0;
@@ -499,46 +518,45 @@ module.exports.prettify = function(json, indent) {
 };
 
 /**
- * Convert between bitmark and JSON with explicit input/output formats + mode.
+ * Split a bitmark document into per-bit source slices.
  *
- * `input_format`: `"auto"` (default) | `"bitmark"` | `"json"`.
- * `output_format`: `"auto"` (opposite of input) | `"bitmark"` | `"json"`.
- * `mode`: `"optimized"` (default) | `"full"`.
- * Returns the converted text/JSON, or a string prefixed `error:` on failure.
+ * Returns a JSON array of `{ index, byteStart, byteEnd, source }`. Lets a JS
+ * caller chunk a document at bit boundaries (e.g. to feed a worker pool).
  * @param {string} input
- * @param {string} input_format_sel
- * @param {string} output_format_sel
- * @param {string} mode
- * @param {boolean} pretty
- * @param {number} indent
- * @param {number} spaces_around_values
  * @returns {string}
  */
-module.exports.convert = function(input, input_format_sel, output_format_sel, mode, pretty, indent, spaces_around_values) {
-    let deferred5_0;
-    let deferred5_1;
+module.exports.split_bits = function(input) {
+    let deferred2_0;
+    let deferred2_1;
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
         const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
         const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(input_format_sel, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
-        const len1 = WASM_VECTOR_LEN;
-        const ptr2 = passStringToWasm0(output_format_sel, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
-        const len2 = WASM_VECTOR_LEN;
-        const ptr3 = passStringToWasm0(mode, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
-        const len3 = WASM_VECTOR_LEN;
-        wasm.convert(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, pretty, indent, spaces_around_values);
+        wasm.split_bits(retptr, ptr0, len0);
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-        deferred5_0 = r0;
-        deferred5_1 = r1;
+        deferred2_0 = r0;
+        deferred2_1 = r1;
         return getStringFromWasm0(r0, r1);
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
-        wasm.__wbindgen_export_2(deferred5_0, deferred5_1, 1);
+        wasm.__wbindgen_export_2(deferred2_0, deferred2_1, 1);
     }
 };
 
+/**
+ * Whether `input` looks like bitmark (vs JSON). Mirrors the auto-detection
+ * used across the API so a JS caller can resolve `"auto"` consistently.
+ * @param {string} input
+ * @returns {boolean}
+ */
+module.exports.is_bitmark = function(input) {
+    const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.is_bitmark(ptr0, len0);
+    return ret !== 0;
+};
+
 const path = require('path').join(__dirname, 'bitmark_wasm_bg.wasm');
 const bytes = require('fs').readFileSync(path);
 

package/wasm/bitmark_wasm_bg.wasm.d.ts

@@ -2,14 +2,14 @@
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
 export const breakscape_text: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
-export const canonicalize: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
+export const canonicalize: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
 export const convert: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number) => void;
 export const count_bits: (a: number, b: number, c: number) => void;
-export const fullize: (a: number, b: number, c: number, d: number, e: number) => void;
+export const fullize: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
 export const info: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
 export const is_bitmark: (a: number, b: number) => number;
 export const lex: (a: number, b: number, c: number, d: number, e: number) => void;
-export const optimize: (a: number, b: number, c: number, d: number, e: number) => void;
+export const optimize: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
 export const parse: (a: number, b: number, c: number, d: number, e: number) => void;
 export const prettify: (a: number, b: number, c: number, d: number) => void;
 export const split_bits: (a: number, b: number, c: number) => void;

package/wasm/package.json

@@ -4,7 +4,7 @@
     "Get More Brain Ltd <info@getmorebrain.com>"
   ],
   "description": "WebAssembly bindings for the bitmark parser",
-  "version": "6.1.1",
+  "version": "6.1.3",
   "license": "ISC",
   "repository": {
     "type": "git",