@gmb/bitmark-parser 6.9.0 → 6.10.0

package/wasm/package.json

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

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

@@ -0,0 +1,99 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Breakscape text (escape bitmark special characters).
+ *
+ * `format`: `"bitmark++"` (default) or `"plainText"`
+ * `location`: `"body"` (default) or `"tag"`
+ */
+export function breakscape_text(input: string, format: string, location: string): string;
+/**
+ * Unbreakscape text (unescape bitmark special characters).
+ *
+ * `format`: `"bitmark++"` (default) or `"plainText"`
+ * `location`: `"body"` (default) or `"tag"`
+ */
+export function unbreakscape_text(input: string, format: string, location: string): string;
+/**
+ * Query information about supported bit types.
+ *
+ * `info_type`: `"list"`, `"bit"`, `"all"`, or `"deprecated"`
+ * `format`: `"text"` or `"json"`
+ * `bit`: bit name (required when `info_type` is `"bit"`)
+ * `pretty`: whether to pretty-print JSON output
+ * `indent`: indent size for pretty-printing (default: 2)
+ * `include_deprecated`: include deprecated bits in `list`/`all` (PLAN-149)
+ * `only_deprecated`: restrict `list`/`all` to deprecated bits (wins over
+ * `include_deprecated`)
+ * `full`: complete outline for `bit`/`all` (default is the compact
+ * one-line-per-tag view)
+ */
+export function info(info_type: string, format: string, bit: string, pretty: boolean, indent: number, include_deprecated: boolean, only_deprecated: boolean, full: boolean): string;
+/**
+ * Convert between bitmark and JSON with explicit input/output formats + mode.
+ *
+ * `input_format`: `"auto"` (default) | `"bitmark"` | `"json"`.
+ * `output_format`: `"auto"` (opposite of input) | `"bitmark"` | `"json"`.
+ * `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).
+ * Returns the converted text/JSON, or a string prefixed `error:` 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): string;
+/**
+ * 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.
+ */
+export function canonicalize(input: string, input_format_sel: string, mode: string, pretty: boolean, indent: number, spaces_around_values: number): string;
+/**
+ * Count the bits in `input` (auto-detecting bitmark vs JSON).
+ * Returns the count as a decimal string, or `error: …`.
+ */
+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).
+ */
+export function split_bits(input: 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.
+ */
+export function is_bitmark(input: string): boolean;
+/**
+ * Split a JSON document (a top-level array of bit envelopes) into its per-bit
+ * envelope objects, returned as a JSON array string. Lets a JS caller iterate
+ * JSON-input bits for per-bit hooks (the JSON counterpart of [`split_bits`]).
+ * Returns `error: …` if the input is not a JSON array of bits.
+ */
+export function split_json_bits(input: string): string;
+/**
+ * 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.
+ */
+export function prettify(json: string, indent: number): string;
+/**
+ * Convert a standalone bitmark text fragment ↔ TextAst (ProseMirror JSON).
+ *
+ * `direction`: `"textToAst"` | `"astToText"` | `"astToPlainText"`.
+ * `format`: a bitmark text format (`"bitmark++"`, `"bitmark+"`) parses
+ * inline marks; anything else is treated as plain text (textToAst only).
+ * `location`: `"body"` (default) or `"tag"`.
+ * Returns the converted fragment, or `error: …`.
+ */
+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`: `"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: …`.
+ */
+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;

package/wasm-bitmark-json/bitmark_json_wasm.js

@@ -0,0 +1,491 @@
+
+let imports = {};
+let wasm;
+const { TextEncoder, TextDecoder } = require(`util`);
+
+let WASM_VECTOR_LEN = 0;
+
+let cachedUint8ArrayMemory0 = null;
+
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+let cachedTextEncoder = new TextEncoder('utf-8');
+
+const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
+    ? function (arg, view) {
+    return cachedTextEncoder.encodeInto(arg, view);
+}
+    : function (arg, view) {
+    const buf = cachedTextEncoder.encode(arg);
+    view.set(buf);
+    return {
+        read: arg.length,
+        written: buf.length
+    };
+});
+
+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 = encodeString(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+let cachedDataViewMemory0 = null;
+
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+
+cachedTextDecoder.decode();
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+/**
+ * Breakscape text (escape 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.breakscape_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.breakscape_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);
+    }
+};
+
+/**
+ * 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);
+    }
+};
+
+/**
+ * Query information about supported bit types.
+ *
+ * `info_type`: `"list"`, `"bit"`, `"all"`, or `"deprecated"`
+ * `format`: `"text"` or `"json"`
+ * `bit`: bit name (required when `info_type` is `"bit"`)
+ * `pretty`: whether to pretty-print JSON output
+ * `indent`: indent size for pretty-printing (default: 2)
+ * `include_deprecated`: include deprecated bits in `list`/`all` (PLAN-149)
+ * `only_deprecated`: restrict `list`/`all` to deprecated bits (wins over
+ * `include_deprecated`)
+ * `full`: complete outline for `bit`/`all` (default is the compact
+ * one-line-per-tag view)
+ * @param {string} info_type
+ * @param {string} format
+ * @param {string} bit
+ * @param {boolean} pretty
+ * @param {number} indent
+ * @param {boolean} include_deprecated
+ * @param {boolean} only_deprecated
+ * @param {boolean} full
+ * @returns {string}
+ */
+module.exports.info = function(info_type, format, bit, pretty, indent, include_deprecated, only_deprecated, full) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(info_type, 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(bit, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len2 = WASM_VECTOR_LEN;
+        wasm.info(retptr, ptr0, len0, ptr1, len1, ptr2, len2, pretty, indent, include_deprecated, only_deprecated, full);
+        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);
+    }
+};
+
+/**
+ * Convert between bitmark and JSON with explicit input/output formats + mode.
+ *
+ * `input_format`: `"auto"` (default) | `"bitmark"` | `"json"`.
+ * `output_format`: `"auto"` (opposite of input) | `"bitmark"` | `"json"`.
+ * `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).
+ * 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
+ * @param {boolean} include_unknown_properties
+ * @param {boolean} mapping_report
+ * @returns {string}
+ */
+module.exports.convert = function(input, input_format_sel, output_format_sel, mode, pretty, indent, spaces_around_values, include_unknown_properties, mapping_report) {
+    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, include_unknown_properties, mapping_report);
+        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 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.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(input, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len0 = WASM_VECTOR_LEN;
+        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;
+        deferred2_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export_2(deferred2_0, deferred2_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);
+        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);
+    }
+};
+
+/**
+ * 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;
+};
+
+/**
+ * Split a JSON document (a top-level array of bit envelopes) into its per-bit
+ * envelope objects, returned as a JSON array string. Lets a JS caller iterate
+ * JSON-input bits for per-bit hooks (the JSON counterpart of [`split_bits`]).
+ * Returns `error: …` if the input is not a JSON array of bits.
+ * @param {string} input
+ * @returns {string}
+ */
+module.exports.split_json_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_json_bits(retptr, ptr0, len0);
+        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);
+    }
+};
+
+/**
+ * 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.prettify = function(json, indent) {
+    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 len0 = WASM_VECTOR_LEN;
+        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;
+        deferred2_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export_2(deferred2_0, deferred2_1, 1);
+    }
+};
+
+/**
+ * Convert a standalone bitmark text fragment ↔ TextAst (ProseMirror JSON).
+ *
+ * `direction`: `"textToAst"` | `"astToText"` | `"astToPlainText"`.
+ * `format`: a bitmark text format (`"bitmark++"`, `"bitmark+"`) parses
+ * inline marks; anything else is treated as plain text (textToAst only).
+ * `location`: `"body"` (default) or `"tag"`.
+ * Returns the converted fragment, or `error: …`.
+ * @param {string} input
+ * @param {string} direction
+ * @param {string} format
+ * @param {string} location
+ * @returns {string}
+ */
+module.exports.convert_text = function(input, direction, format, location) {
+    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(direction, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(format, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(location, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len3 = WASM_VECTOR_LEN;
+        wasm.convert_text(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+        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);
+    }
+};
+
+/**
+ * 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.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;
+        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);
+        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);
+    }
+};
+
+const path = require('path').join(__dirname, 'bitmark_json_wasm_bg.wasm');
+const bytes = require('fs').readFileSync(path);
+
+const wasmModule = new WebAssembly.Module(bytes);
+const wasmInstance = new WebAssembly.Instance(wasmModule, imports);
+wasm = wasmInstance.exports;
+module.exports.__wasm = wasm;
+

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

@@ -0,0 +1,19 @@
+/* tslint:disable */
+/* 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, 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) => 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 count_bits: (a: number, b: number, c: 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) => void;
+export const is_bitmark: (a: number, b: number) => number;
+export const prettify: (a: number, b: number, c: number, d: number) => void;
+export const split_bits: (a: number, b: number, c: 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) => void;
+export const __wbindgen_add_to_stack_pointer: (a: number) => number;
+export const __wbindgen_export_0: (a: number, b: number) => number;
+export const __wbindgen_export_1: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_export_2: (a: number, b: number, c: number) => void;

package/wasm-bitmark-json/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "bitmark-wasm",
+  "collaborators": [
+    "Get More Brain Ltd <info@getmorebrain.com>"
+  ],
+  "description": "WebAssembly bindings for the bitmark parser",
+  "version": "6.10.0",
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/getMoreBrain/bitmark-parser"
+  },
+  "files": [
+    "bitmark_json_wasm_bg.wasm",
+    "bitmark_json_wasm.js",
+    "bitmark_json_wasm.d.ts"
+  ],
+  "main": "bitmark_json_wasm.js",
+  "types": "bitmark_json_wasm.d.ts"
+}