@gmb/bitmark-parser 7.6.0 → 7.7.0

package/wasm-bitmark-json/bitmark_json_wasm.d.ts

@@ -53,23 +53,6 @@ export function info(info_type: string, format: string, bit: string, pretty: boo
  * exactly where a consumer must supply the file themselves.
  */
 export function register(data_type: string, data: string): void;
-/**
- * Apply a patch (a JSON array of patch entries) to every bit and re-emit.
- *
- * `input_format_sel`: `"auto"` | `"bitmark"` | `"json"`.
- * `output_format_sel`: the same vocabulary as `convert` — `"bitmark"` |
- * `"json"` | `"text"` | a mapping id (`"html"`, …), `"auto"` (or empty) being
- * the opposite of the resolved input format. The whole-document outputs
- * (`lex`, `semantic-tokens`, `diagnostics`) are not per-bit formats; the
- * pipeline refuses them and that refusal is what throws.
- * `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 `{ "data": <document text/JSON>, "diagnostics":
- * [ { "path", "kind", "message" } ] }` — the diagnostics are the entries the
- * pipeline skipped (PLAN-209 T9; `kind` is the error contract's identifier,
- * e.g. `patch-index-out-of-range`); throws on failure.
- */
-export function transform(input: string, input_format_sel: string, output_format_sel: string, mode: string, patch_json: string, pretty: boolean, indent: number, spaces_around_values: number): string;
 /**
  * Resolve a patch document against `input` (bitmark or JSON) into the
  * ordered output items, so a JS per-bit planner (hooks, worker pool) can
@@ -109,24 +92,6 @@ export function resolve(input: string, line: number, character: number, position
  * there is nothing to show (PLAN-196 D8). Arguments as `complete`.
  */
 export function hover(input: string, line: number, character: number, position_encoding: string): string;
-/**
- * Convert between bitmark and JSON with explicit input/output formats + mode.
- *
- * `input_format`: `"auto"` (default) | `"bitmark"` | `"json"` | a mapping id.
- * `output_format`: `"auto"` (opposite of input) | `"bitmark"` | `"json"` |
- * `"text"` | `"lex"` (the token stream as JSON) | `"semantic-tokens"` |
- * `"diagnostics"` (the last three bitmark input only) | a mapping id.
- * `mode`: `"optimized"` (default) | `"full"`.
- * `mapping_report`: replace the output with a human-readable report of the
- * input→output mappings, including inputs that are NOT mapped (PLAN-147).
- * `position_encoding`: `"utf-16"` (default) | `"utf-8"` — the
- * `semantic-tokens` and `diagnostics` outputs' encoding (PLAN-193 /
- * PLAN-196) — and `tokens_layout`: `"lsp"` (default) | `"absolute"` — the
- * `semantic-tokens` layout; `""` means the default, and every other output
- * format ignores them.
- * Returns the converted text/JSON; throws on failure.
- */
-export function convert(input: string, input_format_sel: string, output_format_sel: string, mode: string, pretty: boolean, indent: number, spaces_around_values: number, include_unknown_properties: boolean, mapping_report: boolean, position_encoding: string, tokens_layout: string): string;
 /**
  * Re-emit input in its own format in canonical form at `mode`.
  *
@@ -142,10 +107,13 @@ export function count_bits(input: string): string;
 /**
  * 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).
+ * Returns a JSON array of `{ index, start, end, byteStart, byteEnd, source }`:
+ * `start` / `end` locate `source` in `position_encoding` units (`"utf-16"`
+ * default | `"utf-8"`; PLAN-221 D3), `byteStart` / `byteEnd` are the byte
+ * partition. Lets a JS caller chunk a document at bit boundaries (e.g. to
+ * feed a worker pool).
  */
-export function split_bits(input: string): string;
+export function split_bits(input: string, position_encoding: string): string;
 /**
  * Whether `input` looks like bitmark (vs JSON). Mirrors the auto-detection
  * used across the API so a JS caller can resolve `"auto"` consistently.
@@ -174,3 +142,69 @@ export function prettify(json: string, indent: number): string;
  * Returns the converted fragment; throws on failure.
  */
 export function convert_text(input: string, direction: string, format: string, location: string): string;
+/**
+ * Apply a patch (a JSON array of patch entries) to every bit and re-emit.
+ *
+ * `input_format_sel`: `"auto"` | `"bitmark"` | `"json"`.
+ * `output_format_sel`: the same vocabulary as `convert` — `"bitmark"` |
+ * `"json"` | `"text"` | a mapping id (`"html"`, …), `"auto"` (or empty) being
+ * the opposite of the resolved input format. The whole-document outputs
+ * (`lex`, `semantic-tokens`, `diagnostics`) are not per-bit formats; the
+ * pipeline refuses them and that refusal is what throws.
+ * `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 `{ "data": <document text/JSON>, "diagnostics":
+ * [ { "path", "kind", "message" } ] }` — the diagnostics are the entries the
+ * pipeline skipped (PLAN-209 T9; `kind` is the error contract's identifier,
+ * e.g. `patch-index-out-of-range`); throws on failure.
+ */
+export function transform(input: string, input_format_sel: string, output_format_sel: string, mode: string, patch_json: string, pretty: boolean, indent: number, spaces_around_values: number): string;
+/**
+ * Convert between bitmark and JSON with explicit input/output formats + mode.
+ *
+ * `input_format`: `"auto"` (default) | `"bitmark"` | `"json"` | a mapping id.
+ * `output_format`: `"auto"` (opposite of input) | `"bitmark"` | `"json"` |
+ * `"text"` | `"lex"` (the token stream as JSON) | `"semantic-tokens"` |
+ * `"diagnostics"` (the last three bitmark input only) | a mapping id.
+ * `mode`: `"optimized"` (default) | `"full"`.
+ * `mapping_report`: replace the output with a human-readable report of the
+ * input→output mappings, including inputs that are NOT mapped (PLAN-147).
+ * `position_encoding`: `"utf-16"` (default) | `"utf-8"` — the
+ * `semantic-tokens` and `diagnostics` outputs' encoding (PLAN-193 /
+ * PLAN-196), and that of `convert_with_details`' bit spans (PLAN-221) —
+ * and `tokens_layout`: `"lsp"` (default) | `"absolute"` — the
+ * `semantic-tokens` layout; `""` means the default, and every other output
+ * format ignores them.
+ * Returns the converted text/JSON; throws on failure.
+ */
+export function convert(input: string, input_format_sel: string, output_format_sel: string, mode: string, pretty: boolean, indent: number, spaces_around_values: number, include_unknown_properties: boolean, mapping_report: boolean, position_encoding: string, tokens_layout: string): string;
+/**
+ * [`convert`] plus the extras asked for (PLAN-221 D1a, F7): the same
+ * arguments, then one flag per extra — today `bit_spans`. Returns a
+ * [`ConvertDetails`] the caller must `free()`; throws as `convert` does.
+ */
+export function convert_with_details(input: string, input_format_sel: string, output_format_sel: string, mode: string, pretty: boolean, indent: number, spaces_around_values: number, include_unknown_properties: boolean, mapping_report: boolean, position_encoding: string, tokens_layout: string, bit_spans: boolean): ConvertDetails;
+/**
+ * The result of [`convert_with_details`] (PLAN-221 F7): the output and each
+ * extra that was asked for, handed over without a JSON round trip. It lives
+ * in wasm memory: the caller must `free()` it. One accessor per extra.
+ */
+export class ConvertDetails {
+  private constructor();
+  free(): void;
+  /**
+   * The encoding the bit spans' offsets are counted in; `undefined` when
+   * not asked for.
+   */
+  bit_spans_encoding(): string | undefined;
+  /**
+   * The bit spans, flat `[index, start, end, …]`; `undefined` when not
+   * asked for.
+   */
+  bit_spans(): Uint32Array | undefined;
+  /**
+   * The converted output, moved out so it crosses to JS once: a second
+   * call returns `""`.
+   */
+  take_data(): string;
+}

package/wasm-bitmark-json/bitmark_json_wasm.js

@@ -282,66 +282,6 @@ module.exports.register = function(data_type, data) {
     }
 };
 
-/**
- * Apply a patch (a JSON array of patch entries) to every bit and re-emit.
- *
- * `input_format_sel`: `"auto"` | `"bitmark"` | `"json"`.
- * `output_format_sel`: the same vocabulary as `convert` — `"bitmark"` |
- * `"json"` | `"text"` | a mapping id (`"html"`, …), `"auto"` (or empty) being
- * the opposite of the resolved input format. The whole-document outputs
- * (`lex`, `semantic-tokens`, `diagnostics`) are not per-bit formats; the
- * pipeline refuses them and that refusal is what throws.
- * `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 `{ "data": <document text/JSON>, "diagnostics":
- * [ { "path", "kind", "message" } ] }` — the diagnostics are the entries the
- * pipeline skipped (PLAN-209 T9; `kind` is the error contract's identifier,
- * e.g. `patch-index-out-of-range`); throws on failure.
- * @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 deferred7_0;
-    let deferred7_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;
-        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);
-        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
-        var ptr6 = r0;
-        var len6 = r1;
-        if (r3) {
-            ptr6 = 0; len6 = 0;
-            throw takeObject(r2);
-        }
-        deferred7_0 = ptr6;
-        deferred7_1 = len6;
-        return getStringFromWasm0(ptr6, len6);
-    } finally {
-        wasm.__wbindgen_add_to_stack_pointer(16);
-        wasm.__wbindgen_export_2(deferred7_0, deferred7_1, 1);
-    }
-};
-
 /**
  * Resolve a patch document against `input` (bitmark or JSON) into the
  * ordered output items, so a JS per-bit planner (hooks, worker pool) can
@@ -523,72 +463,6 @@ module.exports.hover = function(input, line, character, position_encoding) {
     }
 };
 
-/**
- * Convert between bitmark and JSON with explicit input/output formats + mode.
- *
- * `input_format`: `"auto"` (default) | `"bitmark"` | `"json"` | a mapping id.
- * `output_format`: `"auto"` (opposite of input) | `"bitmark"` | `"json"` |
- * `"text"` | `"lex"` (the token stream as JSON) | `"semantic-tokens"` |
- * `"diagnostics"` (the last three bitmark input only) | a mapping id.
- * `mode`: `"optimized"` (default) | `"full"`.
- * `mapping_report`: replace the output with a human-readable report of the
- * input→output mappings, including inputs that are NOT mapped (PLAN-147).
- * `position_encoding`: `"utf-16"` (default) | `"utf-8"` — the
- * `semantic-tokens` and `diagnostics` outputs' encoding (PLAN-193 /
- * PLAN-196) — and `tokens_layout`: `"lsp"` (default) | `"absolute"` — the
- * `semantic-tokens` layout; `""` means the default, and every other output
- * format ignores them.
- * Returns the converted text/JSON; throws 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
- * @param {boolean} include_unknown_properties
- * @param {boolean} mapping_report
- * @param {string} position_encoding
- * @param {string} tokens_layout
- * @returns {string}
- */
-module.exports.convert = function(input, input_format_sel, output_format_sel, mode, pretty, indent, spaces_around_values, include_unknown_properties, mapping_report, position_encoding, tokens_layout) {
-    let deferred8_0;
-    let deferred8_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;
-        const ptr4 = passStringToWasm0(position_encoding, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
-        const len4 = WASM_VECTOR_LEN;
-        const ptr5 = passStringToWasm0(tokens_layout, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
-        const len5 = WASM_VECTOR_LEN;
-        wasm.convert(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, pretty, indent, spaces_around_values, include_unknown_properties, mapping_report, ptr4, len4, ptr5, len5);
-        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
-        var ptr7 = r0;
-        var len7 = r1;
-        if (r3) {
-            ptr7 = 0; len7 = 0;
-            throw takeObject(r2);
-        }
-        deferred8_0 = ptr7;
-        deferred8_1 = len7;
-        return getStringFromWasm0(ptr7, len7);
-    } finally {
-        wasm.__wbindgen_add_to_stack_pointer(16);
-        wasm.__wbindgen_export_2(deferred8_0, deferred8_1, 1);
-    }
-};
-
 /**
  * Re-emit input in its own format in canonical form at `mode`.
  *
@@ -669,27 +543,33 @@ module.exports.count_bits = function(input) {
 /**
  * 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).
+ * Returns a JSON array of `{ index, start, end, byteStart, byteEnd, source }`:
+ * `start` / `end` locate `source` in `position_encoding` units (`"utf-16"`
+ * default | `"utf-8"`; PLAN-221 D3), `byteStart` / `byteEnd` are the byte
+ * partition. Lets a JS caller chunk a document at bit boundaries (e.g. to
+ * feed a worker pool).
  * @param {string} input
+ * @param {string} position_encoding
  * @returns {string}
  */
-module.exports.split_bits = function(input) {
-    let deferred2_0;
-    let deferred2_1;
+module.exports.split_bits = function(input, position_encoding) {
+    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;
-        wasm.split_bits(retptr, ptr0, len0);
+        const ptr1 = passStringToWasm0(position_encoding, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.split_bits(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);
     }
 };
 
@@ -815,11 +695,297 @@ module.exports.convert_text = function(input, direction, format, location) {
     }
 };
 
+/**
+ * Apply a patch (a JSON array of patch entries) to every bit and re-emit.
+ *
+ * `input_format_sel`: `"auto"` | `"bitmark"` | `"json"`.
+ * `output_format_sel`: the same vocabulary as `convert` — `"bitmark"` |
+ * `"json"` | `"text"` | a mapping id (`"html"`, …), `"auto"` (or empty) being
+ * the opposite of the resolved input format. The whole-document outputs
+ * (`lex`, `semantic-tokens`, `diagnostics`) are not per-bit formats; the
+ * pipeline refuses them and that refusal is what throws.
+ * `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 `{ "data": <document text/JSON>, "diagnostics":
+ * [ { "path", "kind", "message" } ] }` — the diagnostics are the entries the
+ * pipeline skipped (PLAN-209 T9; `kind` is the error contract's identifier,
+ * e.g. `patch-index-out-of-range`); throws on failure.
+ * @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 deferred7_0;
+    let deferred7_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;
+        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);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr6 = r0;
+        var len6 = r1;
+        if (r3) {
+            ptr6 = 0; len6 = 0;
+            throw takeObject(r2);
+        }
+        deferred7_0 = ptr6;
+        deferred7_1 = len6;
+        return getStringFromWasm0(ptr6, len6);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export_2(deferred7_0, deferred7_1, 1);
+    }
+};
+
+/**
+ * Convert between bitmark and JSON with explicit input/output formats + mode.
+ *
+ * `input_format`: `"auto"` (default) | `"bitmark"` | `"json"` | a mapping id.
+ * `output_format`: `"auto"` (opposite of input) | `"bitmark"` | `"json"` |
+ * `"text"` | `"lex"` (the token stream as JSON) | `"semantic-tokens"` |
+ * `"diagnostics"` (the last three bitmark input only) | a mapping id.
+ * `mode`: `"optimized"` (default) | `"full"`.
+ * `mapping_report`: replace the output with a human-readable report of the
+ * input→output mappings, including inputs that are NOT mapped (PLAN-147).
+ * `position_encoding`: `"utf-16"` (default) | `"utf-8"` — the
+ * `semantic-tokens` and `diagnostics` outputs' encoding (PLAN-193 /
+ * PLAN-196), and that of `convert_with_details`' bit spans (PLAN-221) —
+ * and `tokens_layout`: `"lsp"` (default) | `"absolute"` — the
+ * `semantic-tokens` layout; `""` means the default, and every other output
+ * format ignores them.
+ * Returns the converted text/JSON; throws 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
+ * @param {boolean} include_unknown_properties
+ * @param {boolean} mapping_report
+ * @param {string} position_encoding
+ * @param {string} tokens_layout
+ * @returns {string}
+ */
+module.exports.convert = function(input, input_format_sel, output_format_sel, mode, pretty, indent, spaces_around_values, include_unknown_properties, mapping_report, position_encoding, tokens_layout) {
+    let deferred8_0;
+    let deferred8_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;
+        const ptr4 = passStringToWasm0(position_encoding, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len4 = WASM_VECTOR_LEN;
+        const ptr5 = passStringToWasm0(tokens_layout, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len5 = WASM_VECTOR_LEN;
+        wasm.convert(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, pretty, indent, spaces_around_values, include_unknown_properties, mapping_report, ptr4, len4, ptr5, len5);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr7 = r0;
+        var len7 = r1;
+        if (r3) {
+            ptr7 = 0; len7 = 0;
+            throw takeObject(r2);
+        }
+        deferred8_0 = ptr7;
+        deferred8_1 = len7;
+        return getStringFromWasm0(ptr7, len7);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export_2(deferred8_0, deferred8_1, 1);
+    }
+};
+
+/**
+ * [`convert`] plus the extras asked for (PLAN-221 D1a, F7): the same
+ * arguments, then one flag per extra — today `bit_spans`. Returns a
+ * [`ConvertDetails`] the caller must `free()`; throws as `convert` does.
+ * @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
+ * @param {boolean} include_unknown_properties
+ * @param {boolean} mapping_report
+ * @param {string} position_encoding
+ * @param {string} tokens_layout
+ * @param {boolean} bit_spans
+ * @returns {ConvertDetails}
+ */
+module.exports.convert_with_details = function(input, input_format_sel, output_format_sel, mode, pretty, indent, spaces_around_values, include_unknown_properties, mapping_report, position_encoding, tokens_layout, bit_spans) {
+    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;
+        const ptr4 = passStringToWasm0(position_encoding, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len4 = WASM_VECTOR_LEN;
+        const ptr5 = passStringToWasm0(tokens_layout, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len5 = WASM_VECTOR_LEN;
+        wasm.convert_with_details(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, pretty, indent, spaces_around_values, include_unknown_properties, mapping_report, ptr4, len4, ptr5, len5, bit_spans);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return ConvertDetails.__wrap(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+};
+
+let cachedUint32ArrayMemory0 = null;
+
+function getUint32ArrayMemory0() {
+    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
+    }
+    return cachedUint32ArrayMemory0;
+}
+
+function getArrayU32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
+const ConvertDetailsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_convertdetails_free(ptr >>> 0, 1));
+/**
+ * The result of [`convert_with_details`] (PLAN-221 F7): the output and each
+ * extra that was asked for, handed over without a JSON round trip. It lives
+ * in wasm memory: the caller must `free()` it. One accessor per extra.
+ */
+class ConvertDetails {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ConvertDetails.prototype);
+        obj.__wbg_ptr = ptr;
+        ConvertDetailsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ConvertDetailsFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_convertdetails_free(ptr, 0);
+    }
+    /**
+     * The encoding the bit spans' offsets are counted in; `undefined` when
+     * not asked for.
+     * @returns {string | undefined}
+     */
+    bit_spans_encoding() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.convertdetails_bit_spans_encoding(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            let v1;
+            if (r0 !== 0) {
+                v1 = getStringFromWasm0(r0, r1).slice();
+                wasm.__wbindgen_export_2(r0, r1 * 1, 1);
+            }
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * The bit spans, flat `[index, start, end, …]`; `undefined` when not
+     * asked for.
+     * @returns {Uint32Array | undefined}
+     */
+    bit_spans() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.convertdetails_bit_spans(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            let v1;
+            if (r0 !== 0) {
+                v1 = getArrayU32FromWasm0(r0, r1).slice();
+                wasm.__wbindgen_export_2(r0, r1 * 4, 4);
+            }
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * The converted output, moved out so it crosses to JS once: a second
+     * call returns `""`.
+     * @returns {string}
+     */
+    take_data() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.convertdetails_take_data(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+module.exports.ConvertDetails = ConvertDetails;
+
 module.exports.__wbindgen_error_new = function(arg0, arg1) {
     const ret = new Error(getStringFromWasm0(arg0, arg1));
     return addHeapObject(ret);
 };
 
+module.exports.__wbindgen_throw = function(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+};
+
 const path = require('path').join(__dirname, 'bitmark_json_wasm_bg.wasm');
 const bytes = require('fs').readFileSync(path);
 

package/wasm-bitmark-json/bitmark_json_wasm_bg.wasm.d.ts

@@ -1,11 +1,16 @@
 /* tslint:disable */
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
+export const __wbg_convertdetails_free: (a: number, b: number) => void;
 export const breakscape_text: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: 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 complete: (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, m: number, n: number, o: number, p: number, q: number, r: number) => void;
 export const convert_text: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
+export const convert_with_details: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number) => void;
+export const convertdetails_bit_spans: (a: number, b: number) => void;
+export const convertdetails_bit_spans_encoding: (a: number, b: number) => void;
+export const convertdetails_take_data: (a: number, b: number) => void;
 export const count_bits: (a: number, b: number, c: number) => void;
 export const hover: (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, j: number, k: number, l: number, m: number, n: number) => void;
@@ -14,7 +19,7 @@ export const prettify: (a: number, b: number, c: number, d: number) => void;
 export const register: (a: number, b: number, c: number, d: number, e: number) => void;
 export const resolve: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => void;
 export const resolve_patch_document: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
-export const split_bits: (a: number, b: number, c: number) => void;
+export const split_bits: (a: number, b: number, c: number, d: number, e: number) => void;
 export const split_json_bits: (a: number, b: number, c: number) => void;
 export const transform: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number) => void;
 export const unbreakscape_text: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;

package/wasm-bitmark-json/package.json

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