@gmb/bitmark-parser 6.10.0 → 6.11.0

package/dist/browser/esm/index.js

@@ -20,6 +20,7 @@ __export(bitmark_wasm_exports, {
   is_bitmark: () => is_bitmark,
   lex: () => lex,
   prettify: () => prettify,
+  register: () => register,
   split_bits: () => split_bits,
   split_json_bits: () => split_json_bits,
   transform: () => transform,
@@ -158,9 +159,9 @@ function unbreakscape_text(input, format, location) {
     wasm.__wbindgen_export_2(deferred4_0, deferred4_1, 1);
   }
 }
-function info(info_type, format, bit, pretty, indent, include_deprecated, only_deprecated, full) {
-  let deferred4_0;
-  let deferred4_1;
+function info(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);
@@ -169,15 +170,41 @@ function info(info_type, format, bit, pretty, indent, include_deprecated, only_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);
+  }
+}
+function convert_text(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);
   }
 }
 function transform(input, input_format_sel, output_format_sel, mode, patch_json, pretty, indent, spaces_around_values) {
@@ -206,6 +233,26 @@ function transform(input, input_format_sel, output_format_sel, mode, patch_json,
     wasm.__wbindgen_export_2(deferred6_0, deferred6_1, 1);
   }
 }
+function register(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);
+  }
+}
 function convert(input, input_format_sel, output_format_sel, mode, pretty, indent, spaces_around_values, include_unknown_properties, mapping_report) {
   let deferred5_0;
   let deferred5_1;
@@ -330,30 +377,6 @@ function prettify(json, indent) {
     wasm.__wbindgen_export_2(deferred2_0, deferred2_1, 1);
   }
 }
-function convert_text(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);
-  }
-}
 async function __wbg_load(module, imports) {
   if (typeof Response === "function" && module instanceof Response) {
     if (typeof WebAssembly.instantiateStreaming === "function") {
@@ -431,19 +454,21 @@ async function __wbg_init(module_or_path) {
 }
 var bitmark_wasm_default = __wbg_init;
 
-// wasm-web-bitmark-json/bitmark_json_wasm.js
-var bitmark_json_wasm_exports = {};
-__export(bitmark_json_wasm_exports, {
+// wasm-web-browser-full/bitmark_browser_full_wasm.js
+var bitmark_browser_full_wasm_exports = {};
+__export(bitmark_browser_full_wasm_exports, {
   breakscape_text: () => breakscape_text2,
   canonicalize: () => canonicalize2,
   convert: () => convert2,
   convert_text: () => convert_text2,
   count_bits: () => count_bits2,
-  default: () => bitmark_json_wasm_default,
+  default: () => bitmark_browser_full_wasm_default,
   info: () => info2,
   initSync: () => initSync2,
   is_bitmark: () => is_bitmark2,
+  lex: () => lex2,
   prettify: () => prettify2,
+  register: () => register2,
   split_bits: () => split_bits2,
   split_json_bits: () => split_json_bits2,
   transform: () => transform2,
@@ -518,6 +543,26 @@ function getStringFromWasm02(ptr, len) {
   ptr = ptr >>> 0;
   return cachedTextDecoder2.decode(getUint8ArrayMemory02().subarray(ptr, ptr + len));
 }
+function lex2(input, stage) {
+  let deferred3_0;
+  let deferred3_1;
+  try {
+    const retptr = wasm2.__wbindgen_add_to_stack_pointer(-16);
+    const ptr0 = passStringToWasm02(input, wasm2.__wbindgen_export_0, wasm2.__wbindgen_export_1);
+    const len0 = WASM_VECTOR_LEN2;
+    const ptr1 = passStringToWasm02(stage, wasm2.__wbindgen_export_0, wasm2.__wbindgen_export_1);
+    const len1 = WASM_VECTOR_LEN2;
+    wasm2.lex(retptr, ptr0, len0, ptr1, len1);
+    var r0 = getDataViewMemory02().getInt32(retptr + 4 * 0, true);
+    var r1 = getDataViewMemory02().getInt32(retptr + 4 * 1, true);
+    deferred3_0 = r0;
+    deferred3_1 = r1;
+    return getStringFromWasm02(r0, r1);
+  } finally {
+    wasm2.__wbindgen_add_to_stack_pointer(16);
+    wasm2.__wbindgen_export_2(deferred3_0, deferred3_1, 1);
+  }
+}
 function breakscape_text2(input, format, location) {
   let deferred4_0;
   let deferred4_1;
@@ -562,9 +607,9 @@ function unbreakscape_text2(input, format, location) {
     wasm2.__wbindgen_export_2(deferred4_0, deferred4_1, 1);
   }
 }
-function info2(info_type, format, bit, pretty, indent, include_deprecated, only_deprecated, full) {
-  let deferred4_0;
-  let deferred4_1;
+function info2(info_type, format, bit, pretty, indent, include_deprecated, only_deprecated, full, language) {
+  let deferred5_0;
+  let deferred5_1;
   try {
     const retptr = wasm2.__wbindgen_add_to_stack_pointer(-16);
     const ptr0 = passStringToWasm02(info_type, wasm2.__wbindgen_export_0, wasm2.__wbindgen_export_1);
@@ -573,15 +618,87 @@ function info2(info_type, format, bit, pretty, indent, include_deprecated, only_
     const len1 = WASM_VECTOR_LEN2;
     const ptr2 = passStringToWasm02(bit, wasm2.__wbindgen_export_0, wasm2.__wbindgen_export_1);
     const len2 = WASM_VECTOR_LEN2;
-    wasm2.info(retptr, ptr0, len0, ptr1, len1, ptr2, len2, pretty, indent, include_deprecated, only_deprecated, full);
+    const ptr3 = passStringToWasm02(language, wasm2.__wbindgen_export_0, wasm2.__wbindgen_export_1);
+    const len3 = WASM_VECTOR_LEN2;
+    wasm2.info(retptr, ptr0, len0, ptr1, len1, ptr2, len2, pretty, indent, include_deprecated, only_deprecated, full, ptr3, len3);
     var r0 = getDataViewMemory02().getInt32(retptr + 4 * 0, true);
     var r1 = getDataViewMemory02().getInt32(retptr + 4 * 1, true);
-    deferred4_0 = r0;
-    deferred4_1 = r1;
+    deferred5_0 = r0;
+    deferred5_1 = r1;
     return getStringFromWasm02(r0, r1);
   } finally {
     wasm2.__wbindgen_add_to_stack_pointer(16);
-    wasm2.__wbindgen_export_2(deferred4_0, deferred4_1, 1);
+    wasm2.__wbindgen_export_2(deferred5_0, deferred5_1, 1);
+  }
+}
+function convert_text2(input, direction, format, location) {
+  let deferred5_0;
+  let deferred5_1;
+  try {
+    const retptr = wasm2.__wbindgen_add_to_stack_pointer(-16);
+    const ptr0 = passStringToWasm02(input, wasm2.__wbindgen_export_0, wasm2.__wbindgen_export_1);
+    const len0 = WASM_VECTOR_LEN2;
+    const ptr1 = passStringToWasm02(direction, wasm2.__wbindgen_export_0, wasm2.__wbindgen_export_1);
+    const len1 = WASM_VECTOR_LEN2;
+    const ptr2 = passStringToWasm02(format, wasm2.__wbindgen_export_0, wasm2.__wbindgen_export_1);
+    const len2 = WASM_VECTOR_LEN2;
+    const ptr3 = passStringToWasm02(location, wasm2.__wbindgen_export_0, wasm2.__wbindgen_export_1);
+    const len3 = WASM_VECTOR_LEN2;
+    wasm2.convert_text(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+    var r0 = getDataViewMemory02().getInt32(retptr + 4 * 0, true);
+    var r1 = getDataViewMemory02().getInt32(retptr + 4 * 1, true);
+    deferred5_0 = r0;
+    deferred5_1 = r1;
+    return getStringFromWasm02(r0, r1);
+  } finally {
+    wasm2.__wbindgen_add_to_stack_pointer(16);
+    wasm2.__wbindgen_export_2(deferred5_0, deferred5_1, 1);
+  }
+}
+function transform2(input, input_format_sel, output_format_sel, mode, patch_json, pretty, indent, spaces_around_values) {
+  let deferred6_0;
+  let deferred6_1;
+  try {
+    const retptr = wasm2.__wbindgen_add_to_stack_pointer(-16);
+    const ptr0 = passStringToWasm02(input, wasm2.__wbindgen_export_0, wasm2.__wbindgen_export_1);
+    const len0 = WASM_VECTOR_LEN2;
+    const ptr1 = passStringToWasm02(input_format_sel, wasm2.__wbindgen_export_0, wasm2.__wbindgen_export_1);
+    const len1 = WASM_VECTOR_LEN2;
+    const ptr2 = passStringToWasm02(output_format_sel, wasm2.__wbindgen_export_0, wasm2.__wbindgen_export_1);
+    const len2 = WASM_VECTOR_LEN2;
+    const ptr3 = passStringToWasm02(mode, wasm2.__wbindgen_export_0, wasm2.__wbindgen_export_1);
+    const len3 = WASM_VECTOR_LEN2;
+    const ptr4 = passStringToWasm02(patch_json, wasm2.__wbindgen_export_0, wasm2.__wbindgen_export_1);
+    const len4 = WASM_VECTOR_LEN2;
+    wasm2.transform(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, pretty, indent, spaces_around_values);
+    var r0 = getDataViewMemory02().getInt32(retptr + 4 * 0, true);
+    var r1 = getDataViewMemory02().getInt32(retptr + 4 * 1, true);
+    deferred6_0 = r0;
+    deferred6_1 = r1;
+    return getStringFromWasm02(r0, r1);
+  } finally {
+    wasm2.__wbindgen_add_to_stack_pointer(16);
+    wasm2.__wbindgen_export_2(deferred6_0, deferred6_1, 1);
+  }
+}
+function register2(data_type, data) {
+  let deferred3_0;
+  let deferred3_1;
+  try {
+    const retptr = wasm2.__wbindgen_add_to_stack_pointer(-16);
+    const ptr0 = passStringToWasm02(data_type, wasm2.__wbindgen_export_0, wasm2.__wbindgen_export_1);
+    const len0 = WASM_VECTOR_LEN2;
+    const ptr1 = passStringToWasm02(data, wasm2.__wbindgen_export_0, wasm2.__wbindgen_export_1);
+    const len1 = WASM_VECTOR_LEN2;
+    wasm2.register(retptr, ptr0, len0, ptr1, len1);
+    var r0 = getDataViewMemory02().getInt32(retptr + 4 * 0, true);
+    var r1 = getDataViewMemory02().getInt32(retptr + 4 * 1, true);
+    deferred3_0 = r0;
+    deferred3_1 = r1;
+    return getStringFromWasm02(r0, r1);
+  } finally {
+    wasm2.__wbindgen_add_to_stack_pointer(16);
+    wasm2.__wbindgen_export_2(deferred3_0, deferred3_1, 1);
   }
 }
 function convert2(input, input_format_sel, output_format_sel, mode, pretty, indent, spaces_around_values, include_unknown_properties, mapping_report) {
@@ -708,56 +825,6 @@ function prettify2(json, indent) {
     wasm2.__wbindgen_export_2(deferred2_0, deferred2_1, 1);
   }
 }
-function convert_text2(input, direction, format, location) {
-  let deferred5_0;
-  let deferred5_1;
-  try {
-    const retptr = wasm2.__wbindgen_add_to_stack_pointer(-16);
-    const ptr0 = passStringToWasm02(input, wasm2.__wbindgen_export_0, wasm2.__wbindgen_export_1);
-    const len0 = WASM_VECTOR_LEN2;
-    const ptr1 = passStringToWasm02(direction, wasm2.__wbindgen_export_0, wasm2.__wbindgen_export_1);
-    const len1 = WASM_VECTOR_LEN2;
-    const ptr2 = passStringToWasm02(format, wasm2.__wbindgen_export_0, wasm2.__wbindgen_export_1);
-    const len2 = WASM_VECTOR_LEN2;
-    const ptr3 = passStringToWasm02(location, wasm2.__wbindgen_export_0, wasm2.__wbindgen_export_1);
-    const len3 = WASM_VECTOR_LEN2;
-    wasm2.convert_text(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
-    var r0 = getDataViewMemory02().getInt32(retptr + 4 * 0, true);
-    var r1 = getDataViewMemory02().getInt32(retptr + 4 * 1, true);
-    deferred5_0 = r0;
-    deferred5_1 = r1;
-    return getStringFromWasm02(r0, r1);
-  } finally {
-    wasm2.__wbindgen_add_to_stack_pointer(16);
-    wasm2.__wbindgen_export_2(deferred5_0, deferred5_1, 1);
-  }
-}
-function transform2(input, input_format_sel, output_format_sel, mode, patch_json, pretty, indent, spaces_around_values) {
-  let deferred6_0;
-  let deferred6_1;
-  try {
-    const retptr = wasm2.__wbindgen_add_to_stack_pointer(-16);
-    const ptr0 = passStringToWasm02(input, wasm2.__wbindgen_export_0, wasm2.__wbindgen_export_1);
-    const len0 = WASM_VECTOR_LEN2;
-    const ptr1 = passStringToWasm02(input_format_sel, wasm2.__wbindgen_export_0, wasm2.__wbindgen_export_1);
-    const len1 = WASM_VECTOR_LEN2;
-    const ptr2 = passStringToWasm02(output_format_sel, wasm2.__wbindgen_export_0, wasm2.__wbindgen_export_1);
-    const len2 = WASM_VECTOR_LEN2;
-    const ptr3 = passStringToWasm02(mode, wasm2.__wbindgen_export_0, wasm2.__wbindgen_export_1);
-    const len3 = WASM_VECTOR_LEN2;
-    const ptr4 = passStringToWasm02(patch_json, wasm2.__wbindgen_export_0, wasm2.__wbindgen_export_1);
-    const len4 = WASM_VECTOR_LEN2;
-    wasm2.transform(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, pretty, indent, spaces_around_values);
-    var r0 = getDataViewMemory02().getInt32(retptr + 4 * 0, true);
-    var r1 = getDataViewMemory02().getInt32(retptr + 4 * 1, true);
-    deferred6_0 = r0;
-    deferred6_1 = r1;
-    return getStringFromWasm02(r0, r1);
-  } finally {
-    wasm2.__wbindgen_add_to_stack_pointer(16);
-    wasm2.__wbindgen_export_2(deferred6_0, deferred6_1, 1);
-  }
-}
 async function __wbg_load2(module, imports) {
   if (typeof Response === "function" && module instanceof Response) {
     if (typeof WebAssembly.instantiateStreaming === "function") {
@@ -823,7 +890,7 @@ async function __wbg_init2(module_or_path) {
     }
   }
   if (typeof module_or_path === "undefined") {
-    module_or_path = new URL("bitmark_json_wasm_bg.wasm", import.meta.url);
+    module_or_path = new URL("bitmark_browser_full_wasm_bg.wasm", import.meta.url);
   }
   const imports = __wbg_get_imports2();
   if (typeof module_or_path === "string" || typeof Request === "function" && module_or_path instanceof Request || typeof URL === "function" && module_or_path instanceof URL) {
@@ -833,24 +900,458 @@ async function __wbg_init2(module_or_path) {
   const { instance, module } = await __wbg_load2(await module_or_path, imports);
   return __wbg_finalize_init2(instance, module);
 }
-var bitmark_json_wasm_default = __wbg_init2;
+var bitmark_browser_full_wasm_default = __wbg_init2;
+
+// wasm-web-bitmark-json/bitmark_json_wasm.js
+var bitmark_json_wasm_exports = {};
+__export(bitmark_json_wasm_exports, {
+  breakscape_text: () => breakscape_text3,
+  canonicalize: () => canonicalize3,
+  convert: () => convert3,
+  convert_text: () => convert_text3,
+  count_bits: () => count_bits3,
+  default: () => bitmark_json_wasm_default,
+  info: () => info3,
+  initSync: () => initSync3,
+  is_bitmark: () => is_bitmark3,
+  prettify: () => prettify3,
+  register: () => register3,
+  split_bits: () => split_bits3,
+  split_json_bits: () => split_json_bits3,
+  transform: () => transform3,
+  unbreakscape_text: () => unbreakscape_text3
+});
+var wasm3;
+var WASM_VECTOR_LEN3 = 0;
+var cachedUint8ArrayMemory03 = null;
+function getUint8ArrayMemory03() {
+  if (cachedUint8ArrayMemory03 === null || cachedUint8ArrayMemory03.byteLength === 0) {
+    cachedUint8ArrayMemory03 = new Uint8Array(wasm3.memory.buffer);
+  }
+  return cachedUint8ArrayMemory03;
+}
+var cachedTextEncoder3 = typeof TextEncoder !== "undefined" ? new TextEncoder("utf-8") : { encode: () => {
+  throw Error("TextEncoder not available");
+} };
+var encodeString3 = typeof cachedTextEncoder3.encodeInto === "function" ? function(arg, view) {
+  return cachedTextEncoder3.encodeInto(arg, view);
+} : function(arg, view) {
+  const buf = cachedTextEncoder3.encode(arg);
+  view.set(buf);
+  return {
+    read: arg.length,
+    written: buf.length
+  };
+};
+function passStringToWasm03(arg, malloc, realloc) {
+  if (realloc === void 0) {
+    const buf = cachedTextEncoder3.encode(arg);
+    const ptr2 = malloc(buf.length, 1) >>> 0;
+    getUint8ArrayMemory03().subarray(ptr2, ptr2 + buf.length).set(buf);
+    WASM_VECTOR_LEN3 = buf.length;
+    return ptr2;
+  }
+  let len = arg.length;
+  let ptr = malloc(len, 1) >>> 0;
+  const mem = getUint8ArrayMemory03();
+  let offset = 0;
+  for (; offset < len; offset++) {
+    const code = arg.charCodeAt(offset);
+    if (code > 127) 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 = getUint8ArrayMemory03().subarray(ptr + offset, ptr + len);
+    const ret = encodeString3(arg, view);
+    offset += ret.written;
+    ptr = realloc(ptr, len, offset, 1) >>> 0;
+  }
+  WASM_VECTOR_LEN3 = offset;
+  return ptr;
+}
+var cachedDataViewMemory03 = null;
+function getDataViewMemory03() {
+  if (cachedDataViewMemory03 === null || cachedDataViewMemory03.buffer.detached === true || cachedDataViewMemory03.buffer.detached === void 0 && cachedDataViewMemory03.buffer !== wasm3.memory.buffer) {
+    cachedDataViewMemory03 = new DataView(wasm3.memory.buffer);
+  }
+  return cachedDataViewMemory03;
+}
+var cachedTextDecoder3 = typeof TextDecoder !== "undefined" ? new TextDecoder("utf-8", { ignoreBOM: true, fatal: true }) : { decode: () => {
+  throw Error("TextDecoder not available");
+} };
+if (typeof TextDecoder !== "undefined") {
+  cachedTextDecoder3.decode();
+}
+function getStringFromWasm03(ptr, len) {
+  ptr = ptr >>> 0;
+  return cachedTextDecoder3.decode(getUint8ArrayMemory03().subarray(ptr, ptr + len));
+}
+function breakscape_text3(input, format, location) {
+  let deferred4_0;
+  let deferred4_1;
+  try {
+    const retptr = wasm3.__wbindgen_add_to_stack_pointer(-16);
+    const ptr0 = passStringToWasm03(input, wasm3.__wbindgen_export_0, wasm3.__wbindgen_export_1);
+    const len0 = WASM_VECTOR_LEN3;
+    const ptr1 = passStringToWasm03(format, wasm3.__wbindgen_export_0, wasm3.__wbindgen_export_1);
+    const len1 = WASM_VECTOR_LEN3;
+    const ptr2 = passStringToWasm03(location, wasm3.__wbindgen_export_0, wasm3.__wbindgen_export_1);
+    const len2 = WASM_VECTOR_LEN3;
+    wasm3.breakscape_text(retptr, ptr0, len0, ptr1, len1, ptr2, len2);
+    var r0 = getDataViewMemory03().getInt32(retptr + 4 * 0, true);
+    var r1 = getDataViewMemory03().getInt32(retptr + 4 * 1, true);
+    deferred4_0 = r0;
+    deferred4_1 = r1;
+    return getStringFromWasm03(r0, r1);
+  } finally {
+    wasm3.__wbindgen_add_to_stack_pointer(16);
+    wasm3.__wbindgen_export_2(deferred4_0, deferred4_1, 1);
+  }
+}
+function unbreakscape_text3(input, format, location) {
+  let deferred4_0;
+  let deferred4_1;
+  try {
+    const retptr = wasm3.__wbindgen_add_to_stack_pointer(-16);
+    const ptr0 = passStringToWasm03(input, wasm3.__wbindgen_export_0, wasm3.__wbindgen_export_1);
+    const len0 = WASM_VECTOR_LEN3;
+    const ptr1 = passStringToWasm03(format, wasm3.__wbindgen_export_0, wasm3.__wbindgen_export_1);
+    const len1 = WASM_VECTOR_LEN3;
+    const ptr2 = passStringToWasm03(location, wasm3.__wbindgen_export_0, wasm3.__wbindgen_export_1);
+    const len2 = WASM_VECTOR_LEN3;
+    wasm3.unbreakscape_text(retptr, ptr0, len0, ptr1, len1, ptr2, len2);
+    var r0 = getDataViewMemory03().getInt32(retptr + 4 * 0, true);
+    var r1 = getDataViewMemory03().getInt32(retptr + 4 * 1, true);
+    deferred4_0 = r0;
+    deferred4_1 = r1;
+    return getStringFromWasm03(r0, r1);
+  } finally {
+    wasm3.__wbindgen_add_to_stack_pointer(16);
+    wasm3.__wbindgen_export_2(deferred4_0, deferred4_1, 1);
+  }
+}
+function info3(info_type, format, bit, pretty, indent, include_deprecated, only_deprecated, full, language) {
+  let deferred5_0;
+  let deferred5_1;
+  try {
+    const retptr = wasm3.__wbindgen_add_to_stack_pointer(-16);
+    const ptr0 = passStringToWasm03(info_type, wasm3.__wbindgen_export_0, wasm3.__wbindgen_export_1);
+    const len0 = WASM_VECTOR_LEN3;
+    const ptr1 = passStringToWasm03(format, wasm3.__wbindgen_export_0, wasm3.__wbindgen_export_1);
+    const len1 = WASM_VECTOR_LEN3;
+    const ptr2 = passStringToWasm03(bit, wasm3.__wbindgen_export_0, wasm3.__wbindgen_export_1);
+    const len2 = WASM_VECTOR_LEN3;
+    const ptr3 = passStringToWasm03(language, wasm3.__wbindgen_export_0, wasm3.__wbindgen_export_1);
+    const len3 = WASM_VECTOR_LEN3;
+    wasm3.info(retptr, ptr0, len0, ptr1, len1, ptr2, len2, pretty, indent, include_deprecated, only_deprecated, full, ptr3, len3);
+    var r0 = getDataViewMemory03().getInt32(retptr + 4 * 0, true);
+    var r1 = getDataViewMemory03().getInt32(retptr + 4 * 1, true);
+    deferred5_0 = r0;
+    deferred5_1 = r1;
+    return getStringFromWasm03(r0, r1);
+  } finally {
+    wasm3.__wbindgen_add_to_stack_pointer(16);
+    wasm3.__wbindgen_export_2(deferred5_0, deferred5_1, 1);
+  }
+}
+function register3(data_type, data) {
+  let deferred3_0;
+  let deferred3_1;
+  try {
+    const retptr = wasm3.__wbindgen_add_to_stack_pointer(-16);
+    const ptr0 = passStringToWasm03(data_type, wasm3.__wbindgen_export_0, wasm3.__wbindgen_export_1);
+    const len0 = WASM_VECTOR_LEN3;
+    const ptr1 = passStringToWasm03(data, wasm3.__wbindgen_export_0, wasm3.__wbindgen_export_1);
+    const len1 = WASM_VECTOR_LEN3;
+    wasm3.register(retptr, ptr0, len0, ptr1, len1);
+    var r0 = getDataViewMemory03().getInt32(retptr + 4 * 0, true);
+    var r1 = getDataViewMemory03().getInt32(retptr + 4 * 1, true);
+    deferred3_0 = r0;
+    deferred3_1 = r1;
+    return getStringFromWasm03(r0, r1);
+  } finally {
+    wasm3.__wbindgen_add_to_stack_pointer(16);
+    wasm3.__wbindgen_export_2(deferred3_0, deferred3_1, 1);
+  }
+}
+function transform3(input, input_format_sel, output_format_sel, mode, patch_json, pretty, indent, spaces_around_values) {
+  let deferred6_0;
+  let deferred6_1;
+  try {
+    const retptr = wasm3.__wbindgen_add_to_stack_pointer(-16);
+    const ptr0 = passStringToWasm03(input, wasm3.__wbindgen_export_0, wasm3.__wbindgen_export_1);
+    const len0 = WASM_VECTOR_LEN3;
+    const ptr1 = passStringToWasm03(input_format_sel, wasm3.__wbindgen_export_0, wasm3.__wbindgen_export_1);
+    const len1 = WASM_VECTOR_LEN3;
+    const ptr2 = passStringToWasm03(output_format_sel, wasm3.__wbindgen_export_0, wasm3.__wbindgen_export_1);
+    const len2 = WASM_VECTOR_LEN3;
+    const ptr3 = passStringToWasm03(mode, wasm3.__wbindgen_export_0, wasm3.__wbindgen_export_1);
+    const len3 = WASM_VECTOR_LEN3;
+    const ptr4 = passStringToWasm03(patch_json, wasm3.__wbindgen_export_0, wasm3.__wbindgen_export_1);
+    const len4 = WASM_VECTOR_LEN3;
+    wasm3.transform(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, pretty, indent, spaces_around_values);
+    var r0 = getDataViewMemory03().getInt32(retptr + 4 * 0, true);
+    var r1 = getDataViewMemory03().getInt32(retptr + 4 * 1, true);
+    deferred6_0 = r0;
+    deferred6_1 = r1;
+    return getStringFromWasm03(r0, r1);
+  } finally {
+    wasm3.__wbindgen_add_to_stack_pointer(16);
+    wasm3.__wbindgen_export_2(deferred6_0, deferred6_1, 1);
+  }
+}
+function convert3(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 = wasm3.__wbindgen_add_to_stack_pointer(-16);
+    const ptr0 = passStringToWasm03(input, wasm3.__wbindgen_export_0, wasm3.__wbindgen_export_1);
+    const len0 = WASM_VECTOR_LEN3;
+    const ptr1 = passStringToWasm03(input_format_sel, wasm3.__wbindgen_export_0, wasm3.__wbindgen_export_1);
+    const len1 = WASM_VECTOR_LEN3;
+    const ptr2 = passStringToWasm03(output_format_sel, wasm3.__wbindgen_export_0, wasm3.__wbindgen_export_1);
+    const len2 = WASM_VECTOR_LEN3;
+    const ptr3 = passStringToWasm03(mode, wasm3.__wbindgen_export_0, wasm3.__wbindgen_export_1);
+    const len3 = WASM_VECTOR_LEN3;
+    wasm3.convert(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, pretty, indent, spaces_around_values, include_unknown_properties, mapping_report);
+    var r0 = getDataViewMemory03().getInt32(retptr + 4 * 0, true);
+    var r1 = getDataViewMemory03().getInt32(retptr + 4 * 1, true);
+    deferred5_0 = r0;
+    deferred5_1 = r1;
+    return getStringFromWasm03(r0, r1);
+  } finally {
+    wasm3.__wbindgen_add_to_stack_pointer(16);
+    wasm3.__wbindgen_export_2(deferred5_0, deferred5_1, 1);
+  }
+}
+function canonicalize3(input, input_format_sel, mode, pretty, indent, spaces_around_values) {
+  let deferred4_0;
+  let deferred4_1;
+  try {
+    const retptr = wasm3.__wbindgen_add_to_stack_pointer(-16);
+    const ptr0 = passStringToWasm03(input, wasm3.__wbindgen_export_0, wasm3.__wbindgen_export_1);
+    const len0 = WASM_VECTOR_LEN3;
+    const ptr1 = passStringToWasm03(input_format_sel, wasm3.__wbindgen_export_0, wasm3.__wbindgen_export_1);
+    const len1 = WASM_VECTOR_LEN3;
+    const ptr2 = passStringToWasm03(mode, wasm3.__wbindgen_export_0, wasm3.__wbindgen_export_1);
+    const len2 = WASM_VECTOR_LEN3;
+    wasm3.canonicalize(retptr, ptr0, len0, ptr1, len1, ptr2, len2, pretty, indent, spaces_around_values);
+    var r0 = getDataViewMemory03().getInt32(retptr + 4 * 0, true);
+    var r1 = getDataViewMemory03().getInt32(retptr + 4 * 1, true);
+    deferred4_0 = r0;
+    deferred4_1 = r1;
+    return getStringFromWasm03(r0, r1);
+  } finally {
+    wasm3.__wbindgen_add_to_stack_pointer(16);
+    wasm3.__wbindgen_export_2(deferred4_0, deferred4_1, 1);
+  }
+}
+function count_bits3(input) {
+  let deferred2_0;
+  let deferred2_1;
+  try {
+    const retptr = wasm3.__wbindgen_add_to_stack_pointer(-16);
+    const ptr0 = passStringToWasm03(input, wasm3.__wbindgen_export_0, wasm3.__wbindgen_export_1);
+    const len0 = WASM_VECTOR_LEN3;
+    wasm3.count_bits(retptr, ptr0, len0);
+    var r0 = getDataViewMemory03().getInt32(retptr + 4 * 0, true);
+    var r1 = getDataViewMemory03().getInt32(retptr + 4 * 1, true);
+    deferred2_0 = r0;
+    deferred2_1 = r1;
+    return getStringFromWasm03(r0, r1);
+  } finally {
+    wasm3.__wbindgen_add_to_stack_pointer(16);
+    wasm3.__wbindgen_export_2(deferred2_0, deferred2_1, 1);
+  }
+}
+function split_bits3(input) {
+  let deferred2_0;
+  let deferred2_1;
+  try {
+    const retptr = wasm3.__wbindgen_add_to_stack_pointer(-16);
+    const ptr0 = passStringToWasm03(input, wasm3.__wbindgen_export_0, wasm3.__wbindgen_export_1);
+    const len0 = WASM_VECTOR_LEN3;
+    wasm3.split_bits(retptr, ptr0, len0);
+    var r0 = getDataViewMemory03().getInt32(retptr + 4 * 0, true);
+    var r1 = getDataViewMemory03().getInt32(retptr + 4 * 1, true);
+    deferred2_0 = r0;
+    deferred2_1 = r1;
+    return getStringFromWasm03(r0, r1);
+  } finally {
+    wasm3.__wbindgen_add_to_stack_pointer(16);
+    wasm3.__wbindgen_export_2(deferred2_0, deferred2_1, 1);
+  }
+}
+function is_bitmark3(input) {
+  const ptr0 = passStringToWasm03(input, wasm3.__wbindgen_export_0, wasm3.__wbindgen_export_1);
+  const len0 = WASM_VECTOR_LEN3;
+  const ret = wasm3.is_bitmark(ptr0, len0);
+  return ret !== 0;
+}
+function split_json_bits3(input) {
+  let deferred2_0;
+  let deferred2_1;
+  try {
+    const retptr = wasm3.__wbindgen_add_to_stack_pointer(-16);
+    const ptr0 = passStringToWasm03(input, wasm3.__wbindgen_export_0, wasm3.__wbindgen_export_1);
+    const len0 = WASM_VECTOR_LEN3;
+    wasm3.split_json_bits(retptr, ptr0, len0);
+    var r0 = getDataViewMemory03().getInt32(retptr + 4 * 0, true);
+    var r1 = getDataViewMemory03().getInt32(retptr + 4 * 1, true);
+    deferred2_0 = r0;
+    deferred2_1 = r1;
+    return getStringFromWasm03(r0, r1);
+  } finally {
+    wasm3.__wbindgen_add_to_stack_pointer(16);
+    wasm3.__wbindgen_export_2(deferred2_0, deferred2_1, 1);
+  }
+}
+function prettify3(json, indent) {
+  let deferred2_0;
+  let deferred2_1;
+  try {
+    const retptr = wasm3.__wbindgen_add_to_stack_pointer(-16);
+    const ptr0 = passStringToWasm03(json, wasm3.__wbindgen_export_0, wasm3.__wbindgen_export_1);
+    const len0 = WASM_VECTOR_LEN3;
+    wasm3.prettify(retptr, ptr0, len0, indent);
+    var r0 = getDataViewMemory03().getInt32(retptr + 4 * 0, true);
+    var r1 = getDataViewMemory03().getInt32(retptr + 4 * 1, true);
+    deferred2_0 = r0;
+    deferred2_1 = r1;
+    return getStringFromWasm03(r0, r1);
+  } finally {
+    wasm3.__wbindgen_add_to_stack_pointer(16);
+    wasm3.__wbindgen_export_2(deferred2_0, deferred2_1, 1);
+  }
+}
+function convert_text3(input, direction, format, location) {
+  let deferred5_0;
+  let deferred5_1;
+  try {
+    const retptr = wasm3.__wbindgen_add_to_stack_pointer(-16);
+    const ptr0 = passStringToWasm03(input, wasm3.__wbindgen_export_0, wasm3.__wbindgen_export_1);
+    const len0 = WASM_VECTOR_LEN3;
+    const ptr1 = passStringToWasm03(direction, wasm3.__wbindgen_export_0, wasm3.__wbindgen_export_1);
+    const len1 = WASM_VECTOR_LEN3;
+    const ptr2 = passStringToWasm03(format, wasm3.__wbindgen_export_0, wasm3.__wbindgen_export_1);
+    const len2 = WASM_VECTOR_LEN3;
+    const ptr3 = passStringToWasm03(location, wasm3.__wbindgen_export_0, wasm3.__wbindgen_export_1);
+    const len3 = WASM_VECTOR_LEN3;
+    wasm3.convert_text(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+    var r0 = getDataViewMemory03().getInt32(retptr + 4 * 0, true);
+    var r1 = getDataViewMemory03().getInt32(retptr + 4 * 1, true);
+    deferred5_0 = r0;
+    deferred5_1 = r1;
+    return getStringFromWasm03(r0, r1);
+  } finally {
+    wasm3.__wbindgen_add_to_stack_pointer(16);
+    wasm3.__wbindgen_export_2(deferred5_0, deferred5_1, 1);
+  }
+}
+async function __wbg_load3(module, imports) {
+  if (typeof Response === "function" && module instanceof Response) {
+    if (typeof WebAssembly.instantiateStreaming === "function") {
+      try {
+        return await WebAssembly.instantiateStreaming(module, imports);
+      } catch (e) {
+        if (module.headers.get("Content-Type") != "application/wasm") {
+          console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+        } else {
+          throw e;
+        }
+      }
+    }
+    const bytes = await module.arrayBuffer();
+    return await WebAssembly.instantiate(bytes, imports);
+  } else {
+    const instance = await WebAssembly.instantiate(module, imports);
+    if (instance instanceof WebAssembly.Instance) {
+      return { instance, module };
+    } else {
+      return instance;
+    }
+  }
+}
+function __wbg_get_imports3() {
+  const imports = {};
+  imports.wbg = {};
+  return imports;
+}
+function __wbg_init_memory3(imports, memory) {
+}
+function __wbg_finalize_init3(instance, module) {
+  wasm3 = instance.exports;
+  __wbg_init3.__wbindgen_wasm_module = module;
+  cachedDataViewMemory03 = null;
+  cachedUint8ArrayMemory03 = null;
+  return wasm3;
+}
+function initSync3(module) {
+  if (wasm3 !== void 0) return wasm3;
+  if (typeof module !== "undefined") {
+    if (Object.getPrototypeOf(module) === Object.prototype) {
+      ({ module } = module);
+    } else {
+      console.warn("using deprecated parameters for `initSync()`; pass a single object instead");
+    }
+  }
+  const imports = __wbg_get_imports3();
+  __wbg_init_memory3(imports);
+  if (!(module instanceof WebAssembly.Module)) {
+    module = new WebAssembly.Module(module);
+  }
+  const instance = new WebAssembly.Instance(module, imports);
+  return __wbg_finalize_init3(instance, module);
+}
+async function __wbg_init3(module_or_path) {
+  if (wasm3 !== void 0) return wasm3;
+  if (typeof module_or_path !== "undefined") {
+    if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+      ({ module_or_path } = module_or_path);
+    } else {
+      console.warn("using deprecated parameters for the initialization function; pass a single object instead");
+    }
+  }
+  if (typeof module_or_path === "undefined") {
+    module_or_path = new URL("bitmark_json_wasm_bg.wasm", import.meta.url);
+  }
+  const imports = __wbg_get_imports3();
+  if (typeof module_or_path === "string" || typeof Request === "function" && module_or_path instanceof Request || typeof URL === "function" && module_or_path instanceof URL) {
+    module_or_path = fetch(module_or_path);
+  }
+  __wbg_init_memory3(imports);
+  const { instance, module } = await __wbg_load3(await module_or_path, imports);
+  return __wbg_finalize_init3(instance, module);
+}
+var bitmark_json_wasm_default = __wbg_init3;
 
 // src/generated/package_info.ts
 var PACKAGE_INFO = {
   "name": "@gmb/bitmark-parser",
-  "version": "6.10.0",
+  "version": "6.11.0",
   "author": "Get More Brain Ltd <info@getmorebrain.com>",
   "license": "ISC",
   "description": "A parser for bitmark text, powered by WebAssembly."
 };
 
 // src/core/facade.ts
+var BROWSER_DEFAULT_FEATURE = "browser-full";
 var NotInitializedError = class extends Error {
   constructor() {
     super("wasm not initialised: call init() (or init({ feature: \u2026 })) first");
     this.name = "NotInitializedError";
   }
 };
+var RegisterError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RegisterError";
+  }
+};
 var UnsupportedFeatureError = class extends Error {
   constructor(what, active2) {
     super(
@@ -862,15 +1363,23 @@ var UnsupportedFeatureError = class extends Error {
 var active;
 var activeFeature;
 var lazyLoader;
+var registrations = /* @__PURE__ */ new Map();
 function getActive() {
   if (!active && lazyLoader) lazyLoader();
   if (!active) throw new NotInitializedError();
   return active;
 }
 function setActive(feature, module) {
+  for (const [type, data] of registrations) {
+    const error = module.register(type, data);
+    if (error) throw new RegisterError(error.replace(/^error:\s*/, ""));
+  }
   active = module;
   activeFeature = feature;
 }
+function rememberRegistration(type, data) {
+  registrations.set(type, data);
+}
 function variant() {
   return activeFeature;
 }
@@ -895,9 +1404,9 @@ function normalisePatch(patch) {
   }
   return patch;
 }
-function buildUnits(wasm3, input, inputIsBitmark) {
+function buildUnits(wasm4, input, inputIsBitmark) {
   if (inputIsBitmark) {
-    const out2 = wasm3.split_bits(input);
+    const out2 = wasm4.split_bits(input);
     if (isError(out2)) throw new Error(out2);
     const slices = JSON.parse(out2);
     return slices.map((s) => ({
@@ -905,7 +1414,7 @@ function buildUnits(wasm3, input, inputIsBitmark) {
       source: s.source
     }));
   }
-  const out = wasm3.split_json_bits(input);
+  const out = wasm4.split_json_bits(input);
   if (isError(out)) throw new Error(out);
   const envelopes = JSON.parse(out);
   return envelopes.map((env, index) => ({
@@ -914,17 +1423,17 @@ function buildUnits(wasm3, input, inputIsBitmark) {
     source: JSON.stringify([env])
   }));
 }
-function planTransform(wasm3, input, options) {
+function planTransform(wasm4, 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" && wasm3.is_bitmark(input);
+  const inputIsBitmark = sel === "bitmark" || sel !== "json" && wasm4.is_bitmark(input);
   const inputFormat = inputIsBitmark ? "bitmark" : "json";
   const staticPatch = normalisePatch(options.patch);
-  const units = buildUnits(wasm3, input, inputIsBitmark);
+  const units = buildUnits(wasm4, input, inputIsBitmark);
   const total = units.length;
   const jobs = [];
   const views = [];
@@ -948,8 +1457,8 @@ function planTransform(wasm3, input, options) {
   }
   return { jobs, views, output, pretty, indent };
 }
-function computeBit(wasm3, job) {
-  const out = wasm3.transform(
+function computeBit(wasm4, job) {
+  const out = wasm4.transform(
     job.source,
     job.inputFormat,
     job.outputFormat,
@@ -962,33 +1471,33 @@ function computeBit(wasm3, job) {
   if (isError(out)) return out;
   return job.outputFormat === "json" ? stripArray(out) : out;
 }
-function recombine(wasm3, elements, output, pretty, indent) {
+function recombine(wasm4, elements, output, pretty, indent) {
   if (output === "bitmark" || output === "text") return elements.join("\n");
   const arr = `[${elements.join(",")}]`;
-  return pretty ? wasm3.prettify(arr, indent) : arr;
+  return pretty ? wasm4.prettify(arr, indent) : arr;
 }
-function runHookedTransform(wasm3, input, options) {
+function runHookedTransform(wasm4, input, options) {
   let plan;
   try {
-    plan = planTransform(wasm3, input, options);
+    plan = planTransform(wasm4, input, options);
   } catch (e) {
     return errorString(e);
   }
   const rendered = [];
   for (let i = 0; i < plan.jobs.length; i++) {
-    const element = computeBit(wasm3, plan.jobs[i]);
+    const element = computeBit(wasm4, plan.jobs[i]);
     if (isError(element)) return element;
     options.postHook?.(plan.views[i], element);
     rendered.push(element);
   }
-  return recombine(wasm3, rendered, plan.output, plan.pretty, plan.indent);
+  return recombine(wasm4, rendered, plan.output, plan.pretty, plan.indent);
 }
 
 // src/core/parallel.ts
-async function orchestrateParallel(wasm3, input, options, runJobs) {
+async function orchestrateParallel(wasm4, input, options, runJobs) {
   let plan;
   try {
-    plan = planTransform(wasm3, input, options);
+    plan = planTransform(wasm4, input, options);
   } catch (e) {
     return errorString(e);
   }
@@ -1002,7 +1511,7 @@ async function orchestrateParallel(wasm3, input, options, runJobs) {
     if (isError(elements[i])) return elements[i];
     options.postHook?.(plan.views[i], elements[i]);
   }
-  return recombine(wasm3, elements, plan.output, plan.pretty, plan.indent);
+  return recombine(wasm4, elements, plan.output, plan.pretty, plan.indent);
 }
 
 // src/legacy/runtime.ts
@@ -1149,9 +1658,9 @@ function validateJsonOptions(o) {
   if (o.textAsPlainText) unsupportedOption("jsonOptions.textAsPlainText", V3_ONLY);
   if (o.debugGenerationInline) unsupportedOption("jsonOptions.debugGenerationInline");
 }
-function prettyIndent(prettify3) {
-  if (prettify3 === true) return { pretty: true, indent: 2 };
-  if (typeof prettify3 === "number" && prettify3 > 0) return { pretty: true, indent: prettify3 };
+function prettyIndent(prettify4) {
+  if (prettify4 === true) return { pretty: true, indent: 2 };
+  if (typeof prettify4 === "number" && prettify4 > 0) return { pretty: true, indent: prettify4 };
   return { pretty: false, indent: 2 };
 }
 function spacesAround(v) {
@@ -1251,7 +1760,7 @@ var Builder = class {
    * more than one resource, use the first one").
    */
   buildBit(data, _options) {
-    const wasm3 = getLegacyWasm();
+    const wasm4 = getLegacyWasm();
     const src = { ...data };
     const bitType = src.bitType;
     const bitConfig = this.getBitConfig(bitType);
@@ -1312,7 +1821,7 @@ var Builder = class {
       }
     }
     this.parseStringTexts(bit);
-    const out = wasm3.convert(JSON.stringify([{ bit }]), "json", "json", "optimized", false, 2, 1, false, false);
+    const out = wasm4.convert(JSON.stringify([{ bit }]), "json", "json", "optimized", false, 2, 1, false, false);
     if (out.startsWith("error:")) {
       throw new Error(out.slice("error:".length).trim());
     }
@@ -1368,10 +1877,10 @@ var Builder = class {
    * (bpg TextParser.toAst ignores format; only location matters).
    */
   parseStringTexts(bit) {
-    const wasm3 = getLegacyWasm();
+    const wasm4 = getLegacyWasm();
     const toAst = (s, location) => {
       if (s === "") return s;
-      const out = wasm3.convert_text(s, "textToAst", "bitmark++", location);
+      const out = wasm4.convert_text(s, "textToAst", "bitmark++", location);
       try {
         return JSON.parse(out);
       } catch {
@@ -1401,11 +1910,11 @@ var Builder = class {
    * unknown-bit-type error (`Config.getBitConfig` parity).
    */
   getBitConfig(bitType) {
-    const wasm3 = getLegacyWasm();
+    const wasm4 = getLegacyWasm();
     if (bitType !== void 0) {
       try {
-        const info4 = JSON.parse(wasm3.info("bit", "json", bitType, false, 2, false, false, true));
-        if (info4.error === void 0) return { bodyFormat: info4.body?.format };
+        const info5 = JSON.parse(wasm4.info("bit", "json", bitType, false, 2, false, false, true, ""));
+        if (info5.error === void 0) return { bodyFormat: info5.body?.format };
       } catch {
       }
     }
@@ -1444,7 +1953,7 @@ var BitmarkParserGenerator = class {
     validateBitmarkOptions(bitmarkOptions);
     validateJsonOptions(jsonOptions);
     this.checkBrowserFileWrite(opts.outputFile);
-    const wasm3 = getLegacyWasm();
+    const wasm4 = getLegacyWasm();
     const { source, isBitmark } = this.resolveInput(input, opts.inputFormat);
     const outputFormat = opts.outputFormat ?? (isBitmark ? "json" : "bitmark");
     const coreFormat = outputFormat === "ast" ? "json" : outputFormat;
@@ -1452,7 +1961,7 @@ var BitmarkParserGenerator = class {
     const emit = coreFormat === "bitmark" ? prettyIndent(bitmarkOptions.prettifyJson) : { pretty, indent };
     const spaces = spacesAround(bitmarkOptions.spacesAroundValues);
     const includeUnknown = !jsonOptions.excludeUnknownProperties;
-    const out = wasm3.convert(source, isBitmark ? "bitmark" : "json", coreFormat, "optimized", emit.pretty, emit.indent, spaces, includeUnknown, false);
+    const out = wasm4.convert(source, isBitmark ? "bitmark" : "json", coreFormat, "optimized", emit.pretty, emit.indent, spaces, includeUnknown, false);
     this.throwOnError(out);
     if (outputFormat === "bitmark" || outputFormat === "text") {
       return this.deliver(out, opts.outputFile, opts.fileOptions);
@@ -1480,13 +1989,13 @@ var BitmarkParserGenerator = class {
     validateBitmarkOptions(bitmarkOptions);
     validateJsonOptions(jsonOptions);
     this.checkBrowserFileWrite(opts.outputFile);
-    const wasm3 = getLegacyWasm();
+    const wasm4 = getLegacyWasm();
     const { source, isBitmark } = this.resolveInput(input, opts.inputFormat);
     const { pretty, indent } = prettyIndent(
       isBitmark ? bitmarkOptions.prettifyJson : jsonOptions.prettify
     );
     const spaces = spacesAround(bitmarkOptions.spacesAroundValues);
-    const out = wasm3.canonicalize(source, isBitmark ? "bitmark" : "json", "optimized", pretty, indent, spaces);
+    const out = wasm4.canonicalize(source, isBitmark ? "bitmark" : "json", "optimized", pretty, indent, spaces);
     this.throwOnError(out);
     if (isBitmark) return this.deliver(out, opts.outputFile, opts.fileOptions);
     if (opts.outputFile) return this.deliver(out, opts.outputFile, opts.fileOptions);
@@ -1498,12 +2007,12 @@ var BitmarkParserGenerator = class {
    */
   info(options) {
     const opts = Object.assign({}, options);
-    const wasm3 = getLegacyWasm();
+    const wasm4 = getLegacyWasm();
     const type = opts.type ?? "list";
     const format = opts.outputFormat ?? "text";
     const { pretty, indent } = prettyIndent(opts.prettify);
     const coreFormat = format === "pojo" ? "json" : format;
-    const out = wasm3.info(type, coreFormat, opts.bit ?? "", pretty, indent, false, false, true);
+    const out = wasm4.info(type, coreFormat, opts.bit ?? "", pretty, indent, false, false, true, "");
     this.throwOnError(out);
     if (format === "pojo") return JSON.parse(out);
     return out;
@@ -1531,12 +2040,12 @@ var BitmarkParserGenerator = class {
     if (opts.keepUnknownTags) unsupportedOption("keepUnknownTags");
     if (opts.noBreakscaping) unsupportedOption("noBreakscaping");
     this.checkBrowserFileWrite(opts.outputFile);
-    const wasm3 = getLegacyWasm();
+    const wasm4 = getLegacyWasm();
     const inStr = typeof input === "string" ? this.maybeReadFile(input, void 0) : "";
     const isHtmlInput = opts.inputFormat === "html" || opts.inputFormat === void 0 && typeof input === "string" && /<table[\s>]/iu.test(inStr);
     if (!isHtmlInput) {
       const { source, isBitmark } = this.resolveInput(input, void 0);
-      const out2 = wasm3.convert(source, isBitmark ? "bitmark" : "json", "html", "optimized", false, 2, 1, false, false);
+      const out2 = wasm4.convert(source, isBitmark ? "bitmark" : "json", "html", "optimized", false, 2, 1, false, false);
       this.throwOnError(out2);
       return this.deliver(extractHtmlTables(out2).join("\n"), opts.outputFile, opts.fileOptions);
     }
@@ -1546,12 +2055,12 @@ var BitmarkParserGenerator = class {
     const { pretty, indent } = prettyIndent(jsonOptions.prettify);
     const spaces = spacesAround(bitmarkOptions.spacesAroundValues);
     if (outputFormat === "html") {
-      const out2 = wasm3.convert(wrapped, "html", "html", "optimized", false, 2, 1, false, false);
+      const out2 = wasm4.convert(wrapped, "html", "html", "optimized", false, 2, 1, false, false);
       this.throwOnError(out2);
       return this.deliver(extractHtmlTables(out2).join("\n"), opts.outputFile, opts.fileOptions);
     }
     const coreFormat = outputFormat === "ast" ? "json" : outputFormat;
-    const out = wasm3.convert(wrapped, "html", coreFormat, "optimized", pretty, indent, spaces, false, false);
+    const out = wasm4.convert(wrapped, "html", coreFormat, "optimized", pretty, indent, spaces, false, false);
     this.throwOnError(out);
     if (outputFormat === "bitmark" || outputFormat === "text") {
       return this.deliver(out, opts.outputFile, opts.fileOptions);
@@ -1574,9 +2083,9 @@ var BitmarkParserGenerator = class {
    */
   createAst(input, options) {
     const opts = Object.assign({}, options);
-    const wasm3 = getLegacyWasm();
+    const wasm4 = getLegacyWasm();
     const { source, isBitmark } = this.resolveInput(input, opts.inputFormat);
-    const out = wasm3.convert(source, isBitmark ? "bitmark" : "json", "json", "optimized", false, 2, 1, true, false);
+    const out = wasm4.convert(source, isBitmark ? "bitmark" : "json", "json", "optimized", false, 2, 1, true, false);
     this.throwOnError(out);
     return makePseudoAst(JSON.parse(out));
   }
@@ -1587,9 +2096,9 @@ var BitmarkParserGenerator = class {
     if (!input) return input;
     const opts = Object.assign({}, options);
     this.checkBrowserFileWrite(opts.outputFile);
-    const wasm3 = getLegacyWasm();
+    const wasm4 = getLegacyWasm();
     const inStr = this.maybeReadFile(input, opts.inputFormat);
-    const res = wasm3.breakscape_text(inStr, mapTextFormat(opts.textFormat), opts.textLocation ?? "body");
+    const res = wasm4.breakscape_text(inStr, mapTextFormat(opts.textFormat), opts.textLocation ?? "body");
     return this.deliver(res, opts.outputFile, opts.fileOptions);
   }
   /**
@@ -1599,9 +2108,9 @@ var BitmarkParserGenerator = class {
     if (!input) return input;
     const opts = Object.assign({}, options);
     this.checkBrowserFileWrite(opts.outputFile);
-    const wasm3 = getLegacyWasm();
+    const wasm4 = getLegacyWasm();
     const inStr = this.maybeReadFile(input, opts.inputFormat);
-    const res = wasm3.unbreakscape_text(inStr, mapTextFormat(opts.textFormat), opts.textLocation ?? "body");
+    const res = wasm4.unbreakscape_text(inStr, mapTextFormat(opts.textFormat), opts.textLocation ?? "body");
     return this.deliver(res, opts.outputFile, opts.fileOptions);
   }
   /**
@@ -1615,7 +2124,7 @@ var BitmarkParserGenerator = class {
     const opts = Object.assign({}, options);
     const jsonOptions = Object.assign({}, opts.jsonOptions);
     this.checkBrowserFileWrite(opts.outputFile);
-    const wasm3 = getLegacyWasm();
+    const wasm4 = getLegacyWasm();
     const isBitmarkText = opts.textFormat === void 0 || mapTextFormat(opts.textFormat) === "bitmark++";
     const textLocation = opts.textLocation ?? "body";
     let inStr;
@@ -1628,14 +2137,14 @@ var BitmarkParserGenerator = class {
       ast = Array.isArray(input) ? input : void 0;
     }
     if (ast !== void 0) {
-      const out2 = isBitmarkText ? wasm3.convert_text(JSON.stringify(ast), "astToText", "bitmark++", textLocation) : wasm3.convert_text(JSON.stringify(ast), "astToPlainText", "plainText", textLocation);
+      const out2 = isBitmarkText ? wasm4.convert_text(JSON.stringify(ast), "astToText", "bitmark++", textLocation) : wasm4.convert_text(JSON.stringify(ast), "astToPlainText", "plainText", textLocation);
       this.throwOnError(out2);
       return this.deliver(out2, opts.outputFile, opts.fileOptions);
     }
-    const out = wasm3.convert_text(inStr, "textToAst", isBitmarkText ? "bitmark++" : "plainText", "body");
+    const out = wasm4.convert_text(inStr, "textToAst", isBitmarkText ? "bitmark++" : "plainText", "body");
     this.throwOnError(out);
     const { pretty, indent } = prettyIndent(jsonOptions.prettify);
-    const outStr = pretty ? wasm3.prettify(out, indent) : out;
+    const outStr = pretty ? wasm4.prettify(out, indent) : out;
     if (opts.outputFile) return this.deliver(outStr, opts.outputFile, opts.fileOptions);
     if (pretty) return outStr;
     return JSON.parse(out);
@@ -1644,8 +2153,8 @@ var BitmarkParserGenerator = class {
    * Convert a text AST to plain text (bpg-compatible `textAstToPlainText`).
    */
   textAstToPlainText(textAst, _options) {
-    const wasm3 = getLegacyWasm();
-    const out = wasm3.convert_text(
+    const wasm4 = getLegacyWasm();
+    const out = wasm4.convert_text(
       typeof textAst === "string" ? textAst : JSON.stringify(textAst),
       "astToPlainText",
       "bitmark++",
@@ -1659,17 +2168,17 @@ var BitmarkParserGenerator = class {
    */
   extractPlainText(input, options) {
     const inputFormat = options?.inputFormat;
-    const wasm3 = getLegacyWasm();
+    const wasm4 = getLegacyWasm();
     if (inputFormat === "plainText") {
       return typeof input === "string" ? String(input) : "";
     }
     if (inputFormat === "bitmarkText") {
-      const ast = wasm3.convert_text(String(input), "textToAst", "bitmark++", "body");
-      const out2 = wasm3.convert_text(ast, "astToPlainText", "bitmark++", "body");
+      const ast = wasm4.convert_text(String(input), "textToAst", "bitmark++", "body");
+      const out2 = wasm4.convert_text(ast, "astToPlainText", "bitmark++", "body");
       this.throwOnError(out2);
       return out2;
     }
-    if (typeof input === "string" && this.parseTextAstString(input) === void 0 && !wasm3.is_bitmark(input)) {
+    if (typeof input === "string" && this.parseTextAstString(input) === void 0 && !wasm4.is_bitmark(input)) {
       const looksJson = (() => {
         try {
           JSON.parse(input);
@@ -1683,7 +2192,7 @@ var BitmarkParserGenerator = class {
       }
     }
     const { source, isBitmark } = this.resolveInput(input, void 0);
-    const out = wasm3.convert(source, isBitmark ? "bitmark" : "json", "text", "optimized", false, 2, 1, false, false);
+    const out = wasm4.convert(source, isBitmark ? "bitmark" : "json", "text", "optimized", false, 2, 1, false, false);
     this.throwOnError(out);
     return out;
   }
@@ -1717,8 +2226,8 @@ var BitmarkParserGenerator = class {
       };
     }
     const inStr = this.maybeReadFile(input, inputFormat);
-    const wasm3 = getLegacyWasm();
-    if (wasm3.is_bitmark(inStr)) return { source: inStr, isBitmark: true };
+    const wasm4 = getLegacyWasm();
+    if (wasm4.is_bitmark(inStr)) return { source: inStr, isBitmark: true };
     try {
       const parsed = JSON.parse(inStr);
       const entries = this.jsonEntries(parsed);
@@ -2087,8 +2596,8 @@ function bitNameToKey(name) {
 var bitTypeCache;
 function loadBitTypes() {
   if (!bitTypeCache) {
-    const wasm3 = getLegacyWasm();
-    const all = JSON.parse(wasm3.info("all", "json", "", false, 2, true, false, false));
+    const wasm4 = getLegacyWasm();
+    const all = JSON.parse(wasm4.info("all", "json", "", false, 2, true, false, false, ""));
     const map = { _standard: "_standard" };
     for (const { name } of all) {
       map[bitNameToKey(name)] = name;
@@ -2159,12 +2668,13 @@ var StreamWriter = stubClass("StreamWriter", INTERNAL_REASON);
 function patchEntry(path, op, value) {
   return value === void 0 ? { path, op } : { path, op, value };
 }
+var ALL_LANGUAGES = "all";
 
 // src/core/api.ts
-function lex2(input, options = {}) {
-  const wasm3 = getActive();
-  if (typeof wasm3.lex !== "function") throw new UnsupportedFeatureError("lex", variant());
-  return wasm3.lex(input, options.stage ?? "lex");
+function lex3(input, options = {}) {
+  const wasm4 = getActive();
+  if (typeof wasm4.lex !== "function") throw new UnsupportedFeatureError("lex", variant());
+  return wasm4.lex(input, options.stage ?? "lex");
 }
 function bitmarkToObjects(input, options = {}) {
   const out = getActive().convert(
@@ -2199,7 +2709,7 @@ function objectsToBitmark(bits, options = {}) {
   if (out.startsWith("error:")) throw new Error(out.slice("error:".length).trim());
   return out;
 }
-function convert3(input, options = {}) {
+function convert4(input, options = {}) {
   return getActive().convert(
     input,
     options.inputFormat ?? "auto",
@@ -2212,7 +2722,7 @@ function convert3(input, options = {}) {
     options.mappingReport ?? false
   );
 }
-function canonicalize3(input, options = {}) {
+function canonicalize4(input, options = {}) {
   return getActive().canonicalize(
     input,
     options.inputFormat ?? "auto",
@@ -2230,13 +2740,13 @@ function countBits(input) {
 function splitBits(input) {
   return JSON.parse(getActive().split_bits(input));
 }
-function transform3(input, options = {}) {
-  const wasm3 = getActive();
+function transform4(input, options = {}) {
+  const wasm4 = getActive();
   if (options.preHook || options.postHook) {
-    return runHookedTransform(wasm3, input, options);
+    return runHookedTransform(wasm4, input, options);
   }
   const patchJson = options.patch === void 0 ? "" : typeof options.patch === "string" ? options.patch : JSON.stringify(options.patch);
-  return wasm3.transform(
+  return wasm4.transform(
     input,
     options.inputFormat ?? "auto",
     options.outputFormat ?? "json",
@@ -2257,7 +2767,7 @@ function unbreakscapeText(input, options = {}) {
   const location = options.location ?? "body";
   return getActive().unbreakscape_text(input, format, location);
 }
-function info3(options = {}) {
+function info4(options = {}) {
   const infoType = options.infoType ?? "list";
   const format = options.format ?? "text";
   const bit = options.bit ?? "";
@@ -2266,10 +2776,27 @@ function info3(options = {}) {
   const includeDeprecated = options.includeDeprecated ?? false;
   const onlyDeprecated = options.onlyDeprecated ?? false;
   const full = options.full ?? false;
-  return getActive().info(infoType, format, bit, pretty, indent, includeDeprecated, onlyDeprecated, full);
+  const language = typeof options.language === "string" ? options.language : options.language?.join(",") ?? "";
+  return getActive().info(
+    infoType,
+    format,
+    bit,
+    pretty,
+    indent,
+    includeDeprecated,
+    onlyDeprecated,
+    full,
+    language
+  );
+}
+function register4(options) {
+  const result = getActive().register(options.type, options.data);
+  if (result) throw new RegisterError(result.replace(/^error:\s*/, ""));
+  rememberRegistration(options.type, options.data);
 }
 
 // src/browser/index.ts
+var WASM_BASE = true ? "../wasm/" : "./";
 var VARIANTS = {
   full: {
     init: bitmark_wasm_default,
@@ -2277,20 +2804,33 @@ var VARIANTS = {
     ns: bitmark_wasm_exports,
     wasmFile: "bitmark_wasm_bg.wasm"
   },
+  "browser-full": {
+    init: bitmark_browser_full_wasm_default,
+    initSync: initSync2,
+    ns: bitmark_browser_full_wasm_exports,
+    wasmFile: "bitmark_browser_full_wasm_bg.wasm"
+  },
   "bitmark-json": {
     init: bitmark_json_wasm_default,
-    initSync: initSync2,
+    initSync: initSync3,
     ns: bitmark_json_wasm_exports,
     wasmFile: "bitmark_json_wasm_bg.wasm"
   }
 };
 setLegacyWasmProvider(() => getActive());
+function defaultFeatureFor(module_or_path) {
+  return module_or_path === void 0 ? BROWSER_DEFAULT_FEATURE : "full";
+}
 function normalizeInit(arg) {
   if (arg !== null && typeof arg === "object" && !(arg instanceof URL) && ("feature" in arg || "module_or_path" in arg)) {
     const o = arg;
-    return { feature: o.feature ?? "full", module_or_path: o.module_or_path };
+    return {
+      feature: o.feature ?? defaultFeatureFor(o.module_or_path),
+      module_or_path: o.module_or_path
+    };
   }
-  return { feature: "full", module_or_path: arg ?? void 0 };
+  const module_or_path = arg ?? void 0;
+  return { feature: defaultFeatureFor(module_or_path), module_or_path };
 }
 var initSeq = 0;
 var activeOut;
@@ -2303,7 +2843,7 @@ async function init(options) {
   }
   const mySeq = ++initSeq;
   const v = VARIANTS[feature];
-  const source = module_or_path ?? new URL(`${v.wasmFile}?v=${PACKAGE_INFO.version}`, import.meta.url);
+  const source = module_or_path ?? new URL(`${WASM_BASE}${v.wasmFile}?v=${PACKAGE_INFO.version}`, import.meta.url);
   const promise = (async () => {
     try {
       const out = await v.init(source);
@@ -2321,8 +2861,8 @@ async function init(options) {
   inflight = { feature, seq: mySeq, promise };
   return promise;
 }
-function initSync3(module, options = {}) {
-  const feature = options.feature ?? "full";
+function initSync4(module, options = {}) {
+  const feature = options.feature ?? defaultFeatureFor(module);
   const v = VARIANTS[feature];
   const out = v.initSync(module);
   setActive(feature, v.ns);
@@ -2333,32 +2873,35 @@ function version() {
   return PACKAGE_INFO.version;
 }
 function transformParallel(input, options = {}) {
-  const wasm3 = getActive();
-  const feature = variant() ?? "full";
+  const wasm4 = getActive();
+  const feature = variant() ?? BROWSER_DEFAULT_FEATURE;
   return orchestrateParallel(
-    wasm3,
+    wasm4,
     input,
     options,
     (jobs, workers) => runJobsParallel(jobs, workers, feature)
   );
 }
 export {
+  ALL_LANGUAGES,
   NotInitializedError,
+  RegisterError,
   UnsupportedFeatureError,
   bitmarkToObjects,
   breakscapeText,
-  canonicalize3 as canonicalize,
-  convert3 as convert,
+  canonicalize4 as canonicalize,
+  convert4 as convert,
   countBits,
-  info3 as info,
+  info4 as info,
   init,
-  initSync3 as initSync,
+  initSync4 as initSync,
   legacy_exports as legacy,
-  lex2 as lex,
+  lex3 as lex,
   objectsToBitmark,
   patchEntry,
+  register4 as register,
   splitBits,
-  transform3 as transform,
+  transform4 as transform,
   transformParallel,
   unbreakscapeText,
   variant,