@gmb/bitmark-parser 6.10.1 → 6.11.1

package/wasm-bitmark-json/bitmark_json_wasm.js

@@ -154,7 +154,8 @@ module.exports.unbreakscape_text = function(input, format, location) {
 /**
  * Query information about supported bit types.
  *
- * `info_type`: `"list"`, `"bit"`, `"all"`, or `"deprecated"`
+ * `info_type`: `"list"`, `"bit"`, `"all"`, `"deprecated"`, `"bit-groups"`,
+ * or `"resource-groups"`
  * `format`: `"text"` or `"json"`
  * `bit`: bit name (required when `info_type` is `"bit"`)
  * `pretty`: whether to pretty-print JSON output
@@ -164,6 +165,8 @@ module.exports.unbreakscape_text = function(input, format, location) {
  * `include_deprecated`)
  * `full`: complete outline for `bit`/`all` (default is the compact
  * one-line-per-tag view)
+ * `language`: BCP-47 tag(s) for display names — "" = English, `"de,fr"` for
+ * several (adds a `titles` map), `"all"` for every resolvable language
  * @param {string} info_type
  * @param {string} format
  * @param {string} bit
@@ -172,11 +175,12 @@ module.exports.unbreakscape_text = function(input, format, location) {
  * @param {boolean} include_deprecated
  * @param {boolean} only_deprecated
  * @param {boolean} full
+ * @param {string} language
  * @returns {string}
  */
-module.exports.info = function(info_type, format, bit, pretty, indent, include_deprecated, only_deprecated, full) {
-    let deferred4_0;
-    let deferred4_1;
+module.exports.info = function(info_type, format, bit, pretty, indent, include_deprecated, only_deprecated, full, language) {
+    let deferred5_0;
+    let deferred5_1;
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
         const ptr0 = passStringToWasm0(info_type, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
@@ -185,15 +189,132 @@ module.exports.info = function(info_type, format, bit, pretty, indent, include_d
         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);
+        const ptr3 = passStringToWasm0(language, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len3 = WASM_VECTOR_LEN;
+        wasm.info(retptr, ptr0, len0, ptr1, len1, ptr2, len2, pretty, indent, include_deprecated, only_deprecated, full, ptr3, len3);
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-        deferred4_0 = r0;
-        deferred4_1 = r1;
+        deferred5_0 = r0;
+        deferred5_1 = r1;
         return getStringFromWasm0(r0, r1);
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
-        wasm.__wbindgen_export_2(deferred4_0, deferred4_1, 1);
+        wasm.__wbindgen_export_2(deferred5_0, deferred5_1, 1);
+    }
+};
+
+/**
+ * Register data with the parser process (PLAN-173 P12).
+ *
+ * `data_type`: `"translations"` today. One verb rather than one function per
+ * registerable thing — the same discriminated-options idiom as `info`.
+ *
+ * `data` is the file's own text. Semantics are REPLACE: a second call
+ * supersedes the first entirely, and the built-in table (where the variant
+ * bakes one) stays underneath. Returns `""` on success, or an
+ * `error:`-prefixed message — matching the other string-returning exports.
+ *
+ * Available in EVERY variant, including those that bake nothing: that is
+ * exactly where a consumer must supply the file themselves.
+ * @param {string} data_type
+ * @param {string} data
+ * @returns {string}
+ */
+module.exports.register = function(data_type, data) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(data_type, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(data, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.register(retptr, ptr0, len0, ptr1, len1);
+        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);
+    }
+};
+
+/**
+ * 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);
+    }
+};
+
+/**
+ * Resolve a patch document against `input` (bitmark or JSON) into the
+ * ordered output items, so a JS per-bit planner (hooks, worker pool) can
+ * reorder, drop and insert jobs from the one Rust implementation
+ * (PLAN-179). Returns a JSON array of
+ * `{ "source": <original index> | null, "bit": <inner bit> | null,
+ *    "patch": [ … ] }`, or `error: …`.
+ * @param {string} input
+ * @param {string} patch_json
+ * @returns {string}
+ */
+module.exports.resolve_patch_document = function(input, patch_json) {
+    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(patch_json, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.resolve_patch_document(retptr, ptr0, len0, ptr1, len1);
+        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);
     }
 };
 
@@ -436,51 +557,6 @@ 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`: `"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);
 

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

@@ -6,9 +6,11 @@ export const canonicalize: (a: number, b: number, c: number, d: number, e: numbe
 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 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;
 export const is_bitmark: (a: number, b: number) => number;
 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_patch_document: (a: number, b: number, c: number, d: number, e: 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;

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": "6.10.1",
+  "version": "6.11.1",
   "license": "ISC",
   "repository": {
     "type": "git",

package/wasm-browser-full/bitmark_browser_full_wasm.d.ts

@@ -0,0 +1,149 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * 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
+ */
+export function lex(input: string, stage: string): string;
+/**
+ * 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"`, `"deprecated"`, `"bit-groups"`,
+ * or `"resource-groups"`
+ * `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)
+ * `language`: BCP-47 tag(s) for display names — "" = English, `"de,fr"` for
+ * several (adds a `titles` map), `"all"` for every resolvable language
+ */
+export function info(info_type: string, format: string, bit: string, pretty: boolean, indent: number, include_deprecated: boolean, only_deprecated: boolean, full: boolean, language: string): 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;
+/**
+ * Resolve a patch document against `input` (bitmark or JSON) into the
+ * ordered output items, so a JS per-bit planner (hooks, worker pool) can
+ * reorder, drop and insert jobs from the one Rust implementation
+ * (PLAN-179). Returns a JSON array of
+ * `{ "source": <original index> | null, "bit": <inner bit> | null,
+ *    "patch": [ … ] }`, or `error: …`.
+ */
+export function resolve_patch_document(input: string, patch_json: string): string;
+/**
+ * Semantic diff of two documents (PLAN-179). Flat arguments like every
+ * other export:
+ *   - `input_format`: `"auto"` | `"bitmark"` | `"json"` | a mapping id,
+ *     applied to both sides;
+ *   - `output_format`: `"bitmark"` (unified-style text) | `"json"` |
+ *     `"patch"`;
+ *   - `context`, `locate`, `similarity`, `bbox_tolerance`,
+ *     `spaces_around_values` as documented on `DiffOptions`.
+ * Returns the diff (empty text / `[]` of unchanged bits / a patch document
+ * with no entries when the documents are semantically equal), or
+ * `error: …`.
+ */
+export function diff(a: string, b: string, input_format_sel: string, output_format_sel: string, context: number, locate: boolean, similarity: number, bbox_tolerance: number, spaces_around_values: number): string;
+/**
+ * Register data with the parser process (PLAN-173 P12).
+ *
+ * `data_type`: `"translations"` today. One verb rather than one function per
+ * registerable thing — the same discriminated-options idiom as `info`.
+ *
+ * `data` is the file's own text. Semantics are REPLACE: a second call
+ * supersedes the first entirely, and the built-in table (where the variant
+ * bakes one) stays underneath. Returns `""` on success, or an
+ * `error:`-prefixed message — matching the other string-returning exports.
+ *
+ * Available in EVERY variant, including those that bake nothing: that is
+ * exactly where a consumer must supply the file themselves.
+ */
+export function register(data_type: string, data: string): 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;