@gmb/bitmark-parser 6.0.1 → 6.1.0

package/dist/browser/cjs/index.cjs

@@ -21,12 +21,20 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   breakscapeText: () => breakscapeText,
+  canonicalize: () => canonicalize2,
   convert: () => convert2,
+  countBits: () => countBits,
+  expand: () => expand,
+  fullize: () => fullize2,
   info: () => info2,
   init: () => init,
   initSync: () => initSync,
   lex: () => lex2,
+  optimize: () => optimize2,
   parse: () => parse2,
+  splitBits: () => splitBits,
+  transform: () => transform2,
+  transformParallel: () => transformParallel,
   unbreakscapeText: () => unbreakscapeText,
   version: () => version
 });
@@ -37,6 +45,26 @@ var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${_
 var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
 
 // wasm-web/bitmark_wasm.js
+var bitmark_wasm_exports = {};
+__export(bitmark_wasm_exports, {
+  breakscape_text: () => breakscape_text,
+  canonicalize: () => canonicalize,
+  convert: () => convert,
+  count_bits: () => count_bits,
+  default: () => bitmark_wasm_default,
+  fullize: () => fullize,
+  info: () => info,
+  initSync: () => initSync,
+  is_bitmark: () => is_bitmark,
+  lex: () => lex,
+  optimize: () => optimize,
+  parse: () => parse,
+  prettify: () => prettify,
+  split_bits: () => split_bits,
+  split_json_bits: () => split_json_bits,
+  transform: () => transform,
+  unbreakscape_text: () => unbreakscape_text
+});
 var wasm;
 var WASM_VECTOR_LEN = 0;
 var cachedUint8ArrayMemory0 = null;
@@ -106,6 +134,44 @@ function getStringFromWasm0(ptr, len) {
   ptr = ptr >>> 0;
   return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
 }
+function lex(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(stage, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+    const len1 = WASM_VECTOR_LEN;
+    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;
+    deferred3_1 = r1;
+    return getStringFromWasm0(r0, r1);
+  } finally {
+    wasm.__wbindgen_add_to_stack_pointer(16);
+    wasm.__wbindgen_export_2(deferred3_0, deferred3_1, 1);
+  }
+}
+function prettify(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);
+  }
+}
 function unbreakscape_text(input, format, location) {
   let deferred4_0;
   let deferred4_1;
@@ -128,36 +194,64 @@ function unbreakscape_text(input, format, location) {
     wasm.__wbindgen_export_2(deferred4_0, deferred4_1, 1);
   }
 }
-function convert(input, mode, warnings, plain_text, pretty, indent) {
-  let deferred3_0;
-  let deferred3_1;
+function info(info_type, format, bit, pretty, indent) {
+  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);
+    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);
+  }
+}
+function transform(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(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.convert(retptr, ptr0, len0, ptr1, len1, warnings, plain_text, pretty, indent);
+    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);
-    deferred3_0 = r0;
-    deferred3_1 = r1;
+    deferred6_0 = r0;
+    deferred6_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(deferred6_0, deferred6_1, 1);
   }
 }
-function lex(input, stage) {
+function canonicalize(input, mode, pretty, indent, spaces_around_values) {
   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(stage, 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;
-    wasm.lex(retptr, ptr0, len0, ptr1, len1);
+    wasm.canonicalize(retptr, ptr0, len0, ptr1, len1, pretty, indent, spaces_around_values);
     var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
     var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
     deferred3_0 = r0;
@@ -168,40 +262,84 @@ function lex(input, stage) {
     wasm.__wbindgen_export_2(deferred3_0, deferred3_1, 1);
   }
 }
-function breakscape_text(input, format, location) {
-  let deferred4_0;
-  let deferred4_1;
+function split_json_bits(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(format, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+    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);
+  }
+}
+function fullize(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);
+  }
+}
+function convert(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(location, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+    const ptr2 = passStringToWasm0(output_format_sel, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
     const len2 = WASM_VECTOR_LEN;
-    wasm.breakscape_text(retptr, ptr0, len0, ptr1, len1, ptr2, len2);
+    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);
-    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);
   }
 }
-function info(info_type, format, bit, pretty, indent) {
+function is_bitmark(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;
+}
+function breakscape_text(input, format, location) {
   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 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(bit, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+    const ptr2 = passStringToWasm0(location, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
     const len2 = WASM_VECTOR_LEN;
-    wasm.info(retptr, ptr0, len0, ptr1, len1, ptr2, len2, pretty, indent);
+    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;
@@ -232,6 +370,60 @@ function parse(input, mode) {
     wasm.__wbindgen_export_2(deferred3_0, deferred3_1, 1);
   }
 }
+function optimize(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.optimize(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);
+  }
+}
+function count_bits(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);
+  }
+}
+function split_bits(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);
+  }
+}
 async function __wbg_load(module2, imports) {
   if (typeof Response === "function" && module2 instanceof Response) {
     if (typeof WebAssembly.instantiateStreaming === "function") {
@@ -312,12 +504,193 @@ var bitmark_wasm_default = __wbg_init;
 // src/generated/package_info.ts
 var PACKAGE_INFO = {
   "name": "@gmb/bitmark-parser",
-  "version": "6.0.1",
+  "version": "6.1.0",
   "author": "Get More Brain Ltd <info@getmorebrain.com>",
   "license": "ISC",
   "description": "A parser for bitmark text, powered by WebAssembly."
 };
 
+// src/core/hooked-transform.ts
+function isError(s) {
+  return s.startsWith("error:");
+}
+function errorString(e) {
+  const m = e instanceof Error ? e.message : String(e);
+  return m.startsWith("error:") ? m : `error: ${m}`;
+}
+function stripArray(doc) {
+  const t = doc.trim();
+  return t.startsWith("[") && t.endsWith("]") ? t.slice(1, -1) : doc;
+}
+function normalisePatch(patch) {
+  if (patch === void 0) return [];
+  if (typeof patch === "string") {
+    const trimmed = patch.trim();
+    return trimmed === "" ? [] : JSON.parse(trimmed);
+  }
+  return patch;
+}
+function buildUnits(wasm2, input, inputIsBitmark) {
+  if (inputIsBitmark) {
+    const out2 = wasm2.split_bits(input);
+    if (isError(out2)) throw new Error(out2);
+    const slices = JSON.parse(out2);
+    return slices.map((s) => ({
+      view: { format: "bitmark", index: s.index, total: slices.length, source: s.source },
+      source: s.source
+    }));
+  }
+  const out = wasm2.split_json_bits(input);
+  if (isError(out)) throw new Error(out);
+  const envelopes = JSON.parse(out);
+  return envelopes.map((env, index) => ({
+    view: { format: "json", index, total: envelopes.length, bit: env.bit },
+    // Per-bit transform consumes a one-bit JSON document.
+    source: JSON.stringify([env])
+  }));
+}
+function planTransform(wasm2, input, options) {
+  const mode = options.mode ?? "optimized";
+  const output = options.outputFormat ?? "json";
+  const spacesAroundValues = options.spacesAroundValues ?? 1;
+  const indent = options.indent ?? 2;
+  const pretty = options.pretty ?? false;
+  const sel = options.inputFormat ?? "auto";
+  const inputIsBitmark = sel === "bitmark" || sel !== "json" && wasm2.is_bitmark(input);
+  const inputFormat = inputIsBitmark ? "bitmark" : "json";
+  const staticPatch = normalisePatch(options.patch);
+  const units = buildUnits(wasm2, input, inputIsBitmark);
+  const total = units.length;
+  const jobs = [];
+  const views = [];
+  for (let index = 0; index < total; index++) {
+    const { view, source } = units[index];
+    view.index = index;
+    view.total = total;
+    const result = options.preHook ? options.preHook(view) || {} : {};
+    if (result.drop) continue;
+    const patches = result.patches ? [...staticPatch, ...result.patches] : staticPatch;
+    jobs.push({
+      index,
+      source,
+      inputFormat,
+      outputFormat: result.outputFormat ?? output,
+      mode,
+      patchJson: JSON.stringify(patches),
+      spacesAroundValues
+    });
+    views.push(view);
+  }
+  return { jobs, views, output, pretty, indent };
+}
+function computeBit(wasm2, job) {
+  const out = wasm2.transform(
+    job.source,
+    job.inputFormat,
+    job.outputFormat,
+    job.mode,
+    job.patchJson,
+    false,
+    2,
+    job.spacesAroundValues
+  );
+  if (isError(out)) return out;
+  return job.outputFormat === "json" ? stripArray(out) : out;
+}
+function recombine(wasm2, elements, output, pretty, indent) {
+  if (output === "bitmark") return elements.join("\n");
+  const arr = `[${elements.join(",")}]`;
+  return pretty ? wasm2.prettify(arr, indent) : arr;
+}
+function runHookedTransform(wasm2, input, options) {
+  let plan;
+  try {
+    plan = planTransform(wasm2, input, options);
+  } catch (e) {
+    return errorString(e);
+  }
+  const rendered = [];
+  for (let i = 0; i < plan.jobs.length; i++) {
+    const element = computeBit(wasm2, plan.jobs[i]);
+    if (isError(element)) return element;
+    options.postHook?.(plan.views[i], element);
+    rendered.push(element);
+  }
+  return recombine(wasm2, rendered, plan.output, plan.pretty, plan.indent);
+}
+
+// src/core/parallel.ts
+async function orchestrateParallel(wasm2, input, options, runJobs) {
+  let plan;
+  try {
+    plan = planTransform(wasm2, input, options);
+  } catch (e) {
+    return errorString(e);
+  }
+  let elements;
+  try {
+    elements = await runJobs(plan.jobs, options.workers ?? 4);
+  } catch (e) {
+    return errorString(e);
+  }
+  for (let i = 0; i < elements.length; i++) {
+    if (isError(elements[i])) return elements[i];
+    options.postHook?.(plan.views[i], elements[i]);
+  }
+  return recombine(wasm2, elements, plan.output, plan.pretty, plan.indent);
+}
+
+// src/browser/pool.ts
+function runJobsParallel(jobs, workers) {
+  if (jobs.length === 0) return Promise.resolve([]);
+  const poolSize = Math.max(1, Math.min(workers, jobs.length));
+  const workerUrl = new URL("./worker-entry.js", importMetaUrl);
+  return new Promise((resolve, reject) => {
+    const results = new Array(jobs.length);
+    let next = 0;
+    let settled = 0;
+    let done = false;
+    const pool = [];
+    const shutdown = () => {
+      for (const w of pool) w.terminate();
+    };
+    const fail = (err) => {
+      if (done) return;
+      done = true;
+      shutdown();
+      reject(err);
+    };
+    const dispatch = (w) => {
+      if (done || next >= jobs.length) return;
+      const id = next++;
+      w.postMessage({ id, job: jobs[id] });
+    };
+    for (let i = 0; i < poolSize; i++) {
+      const w = new Worker(workerUrl, { type: "module" });
+      pool.push(w);
+      w.onmessage = (ev) => {
+        const res = ev.data;
+        if (done) return;
+        if (!res.ok) {
+          fail(new Error(res.error ?? "worker job failed"));
+          return;
+        }
+        results[res.id] = res.element;
+        settled++;
+        if (settled === jobs.length) {
+          done = true;
+          shutdown();
+          resolve(results);
+          return;
+        }
+        dispatch(w);
+      };
+      w.onerror = (e) => fail(new Error(e.message || "worker error"));
+    }
+    for (const w of pool) dispatch(w);
+  });
+}
+
 // src/browser/index.ts
 async function init(module_or_path) {
   if (typeof module_or_path === "undefined") {
@@ -335,7 +708,58 @@ function parse2(input, options = {}) {
   return parse(input, options.mode ?? "optimized");
 }
 function convert2(input, options = {}) {
-  return convert(input, options.mode ?? "optimized", options.warnings ?? false, options.plainText ?? false, options.pretty ?? false, options.indent ?? 2);
+  return convert(
+    input,
+    options.inputFormat ?? "auto",
+    options.outputFormat ?? "auto",
+    options.mode ?? "optimized",
+    options.pretty ?? false,
+    options.indent ?? 2,
+    options.spacesAroundValues ?? 1
+  );
+}
+function optimize2(input, options = {}) {
+  return optimize(input, options.pretty ?? false, options.indent ?? 2);
+}
+function fullize2(input, options = {}) {
+  return fullize(input, options.pretty ?? false, options.indent ?? 2);
+}
+var expand = fullize2;
+function canonicalize2(input, options = {}) {
+  return canonicalize(
+    input,
+    options.mode ?? "optimized",
+    options.pretty ?? false,
+    options.indent ?? 2,
+    options.spacesAroundValues ?? 1
+  );
+}
+function countBits(input) {
+  const out = count_bits(input);
+  if (out.startsWith("error:")) throw new Error(out);
+  return Number.parseInt(out, 10);
+}
+function splitBits(input) {
+  return JSON.parse(split_bits(input));
+}
+function transform2(input, options = {}) {
+  if (options.preHook || options.postHook) {
+    return runHookedTransform(bitmark_wasm_exports, input, options);
+  }
+  const patchJson = options.patch === void 0 ? "" : typeof options.patch === "string" ? options.patch : JSON.stringify(options.patch);
+  return transform(
+    input,
+    options.inputFormat ?? "auto",
+    options.outputFormat ?? "json",
+    options.mode ?? "optimized",
+    patchJson,
+    options.pretty ?? false,
+    options.indent ?? 2,
+    options.spacesAroundValues ?? 1
+  );
+}
+function transformParallel(input, options = {}) {
+  return orchestrateParallel(bitmark_wasm_exports, input, options, runJobsParallel);
 }
 function breakscapeText(input, options = {}) {
   const format = options.format ?? "bitmark++";
@@ -358,12 +782,20 @@ function info2(options = {}) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   breakscapeText,
+  canonicalize,
   convert,
+  countBits,
+  expand,
+  fullize,
   info,
   init,
   initSync,
   lex,
+  optimize,
   parse,
+  splitBits,
+  transform,
+  transformParallel,
   unbreakscapeText,
   version
 });