@gmb/bitmark-parser 6.9.0 → 6.10.1

package/dist/index.cjs

@@ -30,12 +30,16 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  NotInitializedError: () => NotInitializedError,
+  UnsupportedFeatureError: () => UnsupportedFeatureError,
   bitmarkToObjects: () => bitmarkToObjects,
   breakscapeText: () => breakscapeText,
   canonicalize: () => canonicalize,
   convert: () => convert,
   countBits: () => countBits,
   info: () => info,
+  init: () => init,
+  initSync: () => initSync,
   legacy: () => legacy_exports,
   lex: () => lex,
   objectsToBitmark: () => objectsToBitmark,
@@ -44,6 +48,7 @@ __export(src_exports, {
   transform: () => transform,
   transformParallel: () => transformParallel,
   unbreakscapeText: () => unbreakscapeText,
+  variant: () => variant,
   version: () => version
 });
 module.exports = __toCommonJS(src_exports);
@@ -58,12 +63,46 @@ var import_node_module = require("module");
 // src/generated/package_info.ts
 var PACKAGE_INFO = {
   "name": "@gmb/bitmark-parser",
-  "version": "6.9.0",
+  "version": "6.10.1",
   "author": "Get More Brain Ltd <info@getmorebrain.com>",
   "license": "ISC",
   "description": "A parser for bitmark text, powered by WebAssembly."
 };
 
+// src/core/facade.ts
+var NotInitializedError = class extends Error {
+  constructor() {
+    super("wasm not initialised: call init() (or init({ feature: \u2026 })) first");
+    this.name = "NotInitializedError";
+  }
+};
+var UnsupportedFeatureError = class extends Error {
+  constructor(what, active2) {
+    super(
+      `${what} is not available in the loaded wasm module${active2 ? ` (feature: "${active2}")` : ""}; init({ feature: "full" }) to load it`
+    );
+    this.name = "UnsupportedFeatureError";
+  }
+};
+var active;
+var activeFeature;
+var lazyLoader;
+function getActive() {
+  if (!active && lazyLoader) lazyLoader();
+  if (!active) throw new NotInitializedError();
+  return active;
+}
+function setActive(feature, module2) {
+  active = module2;
+  activeFeature = feature;
+}
+function setLazyLoader(loader) {
+  lazyLoader = loader;
+}
+function variant() {
+  return activeFeature;
+}
+
 // src/core/hooked-transform.ts
 function isError(s) {
   return s.startsWith("error:");
@@ -84,9 +123,9 @@ function normalisePatch(patch) {
   }
   return patch;
 }
-function buildUnits(wasm2, input, inputIsBitmark) {
+function buildUnits(wasm, input, inputIsBitmark) {
   if (inputIsBitmark) {
-    const out2 = wasm2.split_bits(input);
+    const out2 = wasm.split_bits(input);
     if (isError(out2)) throw new Error(out2);
     const slices = JSON.parse(out2);
     return slices.map((s) => ({
@@ -94,7 +133,7 @@ function buildUnits(wasm2, input, inputIsBitmark) {
       source: s.source
     }));
   }
-  const out = wasm2.split_json_bits(input);
+  const out = wasm.split_json_bits(input);
   if (isError(out)) throw new Error(out);
   const envelopes = JSON.parse(out);
   return envelopes.map((env, index) => ({
@@ -103,17 +142,17 @@ function buildUnits(wasm2, input, inputIsBitmark) {
     source: JSON.stringify([env])
   }));
 }
-function planTransform(wasm2, input, options) {
+function planTransform(wasm, 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 inputIsBitmark = sel === "bitmark" || sel !== "json" && wasm.is_bitmark(input);
   const inputFormat = inputIsBitmark ? "bitmark" : "json";
   const staticPatch = normalisePatch(options.patch);
-  const units = buildUnits(wasm2, input, inputIsBitmark);
+  const units = buildUnits(wasm, input, inputIsBitmark);
   const total = units.length;
   const jobs = [];
   const views = [];
@@ -137,8 +176,8 @@ function planTransform(wasm2, input, options) {
   }
   return { jobs, views, output, pretty, indent };
 }
-function computeBit(wasm2, job) {
-  const out = wasm2.transform(
+function computeBit(wasm, job) {
+  const out = wasm.transform(
     job.source,
     job.inputFormat,
     job.outputFormat,
@@ -151,33 +190,33 @@ function computeBit(wasm2, job) {
   if (isError(out)) return out;
   return job.outputFormat === "json" ? stripArray(out) : out;
 }
-function recombine(wasm2, elements, output, pretty, indent) {
+function recombine(wasm, elements, output, pretty, indent) {
   if (output === "bitmark" || output === "text") return elements.join("\n");
   const arr = `[${elements.join(",")}]`;
-  return pretty ? wasm2.prettify(arr, indent) : arr;
+  return pretty ? wasm.prettify(arr, indent) : arr;
 }
-function runHookedTransform(wasm2, input, options) {
+function runHookedTransform(wasm, input, options) {
   let plan;
   try {
-    plan = planTransform(wasm2, input, options);
+    plan = planTransform(wasm, 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]);
+    const element = computeBit(wasm, 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);
+  return recombine(wasm, rendered, plan.output, plan.pretty, plan.indent);
 }
 
 // src/core/parallel.ts
-async function orchestrateParallel(wasm2, input, options, runJobs) {
+async function orchestrateParallel(wasm, input, options, runJobs) {
   let plan;
   try {
-    plan = planTransform(wasm2, input, options);
+    plan = planTransform(wasm, input, options);
   } catch (e) {
     return errorString(e);
   }
@@ -191,7 +230,7 @@ async function orchestrateParallel(wasm2, input, options, runJobs) {
     if (isError(elements[i])) return elements[i];
     options.postHook?.(plan.views[i], elements[i]);
   }
-  return recombine(wasm2, elements, plan.output, plan.pretty, plan.indent);
+  return recombine(wasm, elements, plan.output, plan.pretty, plan.indent);
 }
 
 // src/node/pool.ts
@@ -200,7 +239,7 @@ var import_node_worker_threads = require("worker_threads");
 function workerPath() {
   return (0, import_node_url.fileURLToPath)(new URL("./worker-entry.cjs", importMetaUrl));
 }
-function runJobsParallel(jobs, workers) {
+function runJobsParallel(jobs, workers, feature) {
   if (jobs.length === 0) return Promise.resolve([]);
   const poolSize = Math.max(1, Math.min(workers, jobs.length));
   const path2 = workerPath();
@@ -226,7 +265,7 @@ function runJobsParallel(jobs, workers) {
       w.postMessage({ id, job: jobs[id] });
     };
     for (let i = 0; i < poolSize; i++) {
-      const w = new import_node_worker_threads.Worker(path2);
+      const w = new import_node_worker_threads.Worker(path2, { workerData: { feature } });
       pool.push(w);
       w.on("message", (res) => {
         if (done) return;
@@ -254,8 +293,14 @@ function runJobsParallel(jobs, workers) {
 }
 
 // src/node/transform-parallel.ts
-function runParallelTransform(wasm2, input, options) {
-  return orchestrateParallel(wasm2, input, options, runJobsParallel);
+function runParallelTransform(wasm, input, options) {
+  const feature = variant() ?? "full";
+  return orchestrateParallel(
+    wasm,
+    input,
+    options,
+    (jobs, workers) => runJobsParallel(jobs, workers, feature)
+  );
 }
 
 // src/node/legacy-init.ts
@@ -263,17 +308,17 @@ var fs = __toESM(require("fs"), 1);
 var path = __toESM(require("path"), 1);
 
 // src/legacy/runtime.ts
-var wasmModule;
-function setLegacyWasm(wasm2) {
-  wasmModule = wasm2;
+var wasmProvider;
+function setLegacyWasmProvider(provider) {
+  wasmProvider = provider;
 }
 function getLegacyWasm() {
-  if (!wasmModule) {
+  if (!wasmProvider) {
     throw new Error(
       "legacy API not initialised: the WASM module has not been provided (browser consumers must call init() first)"
     );
   }
-  return wasmModule;
+  return wasmProvider();
 }
 var fileIo;
 function setLegacyFileIo(io) {
@@ -284,8 +329,8 @@ function getLegacyFileIo() {
 }
 
 // src/node/legacy-init.ts
-function initLegacyNode(wasm2) {
-  setLegacyWasm(wasm2);
+function initLegacyNode(provider) {
+  setLegacyWasmProvider(provider);
   setLegacyFileIo({
     existsSync: (p) => fs.existsSync(p),
     readFileSync: (p, encoding) => fs.readFileSync(p, { encoding }),
@@ -476,7 +521,7 @@ var Builder = class {
    * more than one resource, use the first one").
    */
   buildBit(data, _options) {
-    const wasm2 = getLegacyWasm();
+    const wasm = getLegacyWasm();
     const src = { ...data };
     const bitType = src.bitType;
     const bitConfig = this.getBitConfig(bitType);
@@ -537,7 +582,7 @@ var Builder = class {
       }
     }
     this.parseStringTexts(bit);
-    const out = wasm2.convert(JSON.stringify([{ bit }]), "json", "json", "optimized", false, 2, 1, false, false);
+    const out = wasm.convert(JSON.stringify([{ bit }]), "json", "json", "optimized", false, 2, 1, false, false);
     if (out.startsWith("error:")) {
       throw new Error(out.slice("error:".length).trim());
     }
@@ -593,10 +638,10 @@ var Builder = class {
    * (bpg TextParser.toAst ignores format; only location matters).
    */
   parseStringTexts(bit) {
-    const wasm2 = getLegacyWasm();
+    const wasm = getLegacyWasm();
     const toAst = (s, location) => {
       if (s === "") return s;
-      const out = wasm2.convert_text(s, "textToAst", "bitmark++", location);
+      const out = wasm.convert_text(s, "textToAst", "bitmark++", location);
       try {
         return JSON.parse(out);
       } catch {
@@ -626,10 +671,10 @@ var Builder = class {
    * unknown-bit-type error (`Config.getBitConfig` parity).
    */
   getBitConfig(bitType) {
-    const wasm2 = getLegacyWasm();
+    const wasm = getLegacyWasm();
     if (bitType !== void 0) {
       try {
-        const info2 = JSON.parse(wasm2.info("bit", "json", bitType, false, 2, false, false, true));
+        const info2 = JSON.parse(wasm.info("bit", "json", bitType, false, 2, false, false, true));
         if (info2.error === void 0) return { bodyFormat: info2.body?.format };
       } catch {
       }
@@ -669,7 +714,7 @@ var BitmarkParserGenerator = class {
     validateBitmarkOptions(bitmarkOptions);
     validateJsonOptions(jsonOptions);
     this.checkBrowserFileWrite(opts.outputFile);
-    const wasm2 = getLegacyWasm();
+    const wasm = getLegacyWasm();
     const { source, isBitmark } = this.resolveInput(input, opts.inputFormat);
     const outputFormat = opts.outputFormat ?? (isBitmark ? "json" : "bitmark");
     const coreFormat = outputFormat === "ast" ? "json" : outputFormat;
@@ -677,7 +722,7 @@ var BitmarkParserGenerator = class {
     const emit = coreFormat === "bitmark" ? prettyIndent(bitmarkOptions.prettifyJson) : { pretty, indent };
     const spaces = spacesAround(bitmarkOptions.spacesAroundValues);
     const includeUnknown = !jsonOptions.excludeUnknownProperties;
-    const out = wasm2.convert(source, isBitmark ? "bitmark" : "json", coreFormat, "optimized", emit.pretty, emit.indent, spaces, includeUnknown, false);
+    const out = wasm.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);
@@ -705,13 +750,13 @@ var BitmarkParserGenerator = class {
     validateBitmarkOptions(bitmarkOptions);
     validateJsonOptions(jsonOptions);
     this.checkBrowserFileWrite(opts.outputFile);
-    const wasm2 = getLegacyWasm();
+    const wasm = 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 = wasm2.canonicalize(source, isBitmark ? "bitmark" : "json", "optimized", pretty, indent, spaces);
+    const out = wasm.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);
@@ -723,12 +768,12 @@ var BitmarkParserGenerator = class {
    */
   info(options) {
     const opts = Object.assign({}, options);
-    const wasm2 = getLegacyWasm();
+    const wasm = 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 = wasm2.info(type, coreFormat, opts.bit ?? "", pretty, indent, false, false, true);
+    const out = wasm.info(type, coreFormat, opts.bit ?? "", pretty, indent, false, false, true);
     this.throwOnError(out);
     if (format === "pojo") return JSON.parse(out);
     return out;
@@ -756,12 +801,12 @@ var BitmarkParserGenerator = class {
     if (opts.keepUnknownTags) unsupportedOption("keepUnknownTags");
     if (opts.noBreakscaping) unsupportedOption("noBreakscaping");
     this.checkBrowserFileWrite(opts.outputFile);
-    const wasm2 = getLegacyWasm();
+    const wasm = 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 = wasm2.convert(source, isBitmark ? "bitmark" : "json", "html", "optimized", false, 2, 1, false, false);
+      const out2 = wasm.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);
     }
@@ -771,12 +816,12 @@ var BitmarkParserGenerator = class {
     const { pretty, indent } = prettyIndent(jsonOptions.prettify);
     const spaces = spacesAround(bitmarkOptions.spacesAroundValues);
     if (outputFormat === "html") {
-      const out2 = wasm2.convert(wrapped, "html", "html", "optimized", false, 2, 1, false, false);
+      const out2 = wasm.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 = wasm2.convert(wrapped, "html", coreFormat, "optimized", pretty, indent, spaces, false, false);
+    const out = wasm.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);
@@ -799,9 +844,9 @@ var BitmarkParserGenerator = class {
    */
   createAst(input, options) {
     const opts = Object.assign({}, options);
-    const wasm2 = getLegacyWasm();
+    const wasm = getLegacyWasm();
     const { source, isBitmark } = this.resolveInput(input, opts.inputFormat);
-    const out = wasm2.convert(source, isBitmark ? "bitmark" : "json", "json", "optimized", false, 2, 1, true, false);
+    const out = wasm.convert(source, isBitmark ? "bitmark" : "json", "json", "optimized", false, 2, 1, true, false);
     this.throwOnError(out);
     return makePseudoAst(JSON.parse(out));
   }
@@ -812,9 +857,9 @@ var BitmarkParserGenerator = class {
     if (!input) return input;
     const opts = Object.assign({}, options);
     this.checkBrowserFileWrite(opts.outputFile);
-    const wasm2 = getLegacyWasm();
+    const wasm = getLegacyWasm();
     const inStr = this.maybeReadFile(input, opts.inputFormat);
-    const res = wasm2.breakscape_text(inStr, mapTextFormat(opts.textFormat), opts.textLocation ?? "body");
+    const res = wasm.breakscape_text(inStr, mapTextFormat(opts.textFormat), opts.textLocation ?? "body");
     return this.deliver(res, opts.outputFile, opts.fileOptions);
   }
   /**
@@ -824,9 +869,9 @@ var BitmarkParserGenerator = class {
     if (!input) return input;
     const opts = Object.assign({}, options);
     this.checkBrowserFileWrite(opts.outputFile);
-    const wasm2 = getLegacyWasm();
+    const wasm = getLegacyWasm();
     const inStr = this.maybeReadFile(input, opts.inputFormat);
-    const res = wasm2.unbreakscape_text(inStr, mapTextFormat(opts.textFormat), opts.textLocation ?? "body");
+    const res = wasm.unbreakscape_text(inStr, mapTextFormat(opts.textFormat), opts.textLocation ?? "body");
     return this.deliver(res, opts.outputFile, opts.fileOptions);
   }
   /**
@@ -840,7 +885,7 @@ var BitmarkParserGenerator = class {
     const opts = Object.assign({}, options);
     const jsonOptions = Object.assign({}, opts.jsonOptions);
     this.checkBrowserFileWrite(opts.outputFile);
-    const wasm2 = getLegacyWasm();
+    const wasm = getLegacyWasm();
     const isBitmarkText = opts.textFormat === void 0 || mapTextFormat(opts.textFormat) === "bitmark++";
     const textLocation = opts.textLocation ?? "body";
     let inStr;
@@ -853,14 +898,14 @@ var BitmarkParserGenerator = class {
       ast = Array.isArray(input) ? input : void 0;
     }
     if (ast !== void 0) {
-      const out2 = isBitmarkText ? wasm2.convert_text(JSON.stringify(ast), "astToText", "bitmark++", textLocation) : wasm2.convert_text(JSON.stringify(ast), "astToPlainText", "plainText", textLocation);
+      const out2 = isBitmarkText ? wasm.convert_text(JSON.stringify(ast), "astToText", "bitmark++", textLocation) : wasm.convert_text(JSON.stringify(ast), "astToPlainText", "plainText", textLocation);
       this.throwOnError(out2);
       return this.deliver(out2, opts.outputFile, opts.fileOptions);
     }
-    const out = wasm2.convert_text(inStr, "textToAst", isBitmarkText ? "bitmark++" : "plainText", "body");
+    const out = wasm.convert_text(inStr, "textToAst", isBitmarkText ? "bitmark++" : "plainText", "body");
     this.throwOnError(out);
     const { pretty, indent } = prettyIndent(jsonOptions.prettify);
-    const outStr = pretty ? wasm2.prettify(out, indent) : out;
+    const outStr = pretty ? wasm.prettify(out, indent) : out;
     if (opts.outputFile) return this.deliver(outStr, opts.outputFile, opts.fileOptions);
     if (pretty) return outStr;
     return JSON.parse(out);
@@ -869,8 +914,8 @@ var BitmarkParserGenerator = class {
    * Convert a text AST to plain text (bpg-compatible `textAstToPlainText`).
    */
   textAstToPlainText(textAst, _options) {
-    const wasm2 = getLegacyWasm();
-    const out = wasm2.convert_text(
+    const wasm = getLegacyWasm();
+    const out = wasm.convert_text(
       typeof textAst === "string" ? textAst : JSON.stringify(textAst),
       "astToPlainText",
       "bitmark++",
@@ -884,17 +929,17 @@ var BitmarkParserGenerator = class {
    */
   extractPlainText(input, options) {
     const inputFormat = options?.inputFormat;
-    const wasm2 = getLegacyWasm();
+    const wasm = getLegacyWasm();
     if (inputFormat === "plainText") {
       return typeof input === "string" ? String(input) : "";
     }
     if (inputFormat === "bitmarkText") {
-      const ast = wasm2.convert_text(String(input), "textToAst", "bitmark++", "body");
-      const out2 = wasm2.convert_text(ast, "astToPlainText", "bitmark++", "body");
+      const ast = wasm.convert_text(String(input), "textToAst", "bitmark++", "body");
+      const out2 = wasm.convert_text(ast, "astToPlainText", "bitmark++", "body");
       this.throwOnError(out2);
       return out2;
     }
-    if (typeof input === "string" && this.parseTextAstString(input) === void 0 && !wasm2.is_bitmark(input)) {
+    if (typeof input === "string" && this.parseTextAstString(input) === void 0 && !wasm.is_bitmark(input)) {
       const looksJson = (() => {
         try {
           JSON.parse(input);
@@ -908,7 +953,7 @@ var BitmarkParserGenerator = class {
       }
     }
     const { source, isBitmark } = this.resolveInput(input, void 0);
-    const out = wasm2.convert(source, isBitmark ? "bitmark" : "json", "text", "optimized", false, 2, 1, false, false);
+    const out = wasm.convert(source, isBitmark ? "bitmark" : "json", "text", "optimized", false, 2, 1, false, false);
     this.throwOnError(out);
     return out;
   }
@@ -942,8 +987,8 @@ var BitmarkParserGenerator = class {
       };
     }
     const inStr = this.maybeReadFile(input, inputFormat);
-    const wasm2 = getLegacyWasm();
-    if (wasm2.is_bitmark(inStr)) return { source: inStr, isBitmark: true };
+    const wasm = getLegacyWasm();
+    if (wasm.is_bitmark(inStr)) return { source: inStr, isBitmark: true };
     try {
       const parsed = JSON.parse(inStr);
       const entries = this.jsonEntries(parsed);
@@ -1310,8 +1355,8 @@ function bitNameToKey(name) {
 var bitTypeCache;
 function loadBitTypes() {
   if (!bitTypeCache) {
-    const wasm2 = getLegacyWasm();
-    const all = JSON.parse(wasm2.info("all", "json", "", false, 2, true, false, false));
+    const wasm = getLegacyWasm();
+    const all = JSON.parse(wasm.info("all", "json", "", false, 2, true, false, false));
     const map = { _standard: "_standard" };
     for (const { name } of all) {
       map[bitNameToKey(name)] = name;
@@ -1383,18 +1428,14 @@ function patchEntry(path2, op, value) {
   return value === void 0 ? { path: path2, op } : { path: path2, op, value };
 }
 
-// src/index.ts
-var require2 = (0, import_node_module.createRequire)(importMetaUrl);
-var wasm = require2("../wasm/bitmark_wasm.js");
-initLegacyNode(wasm);
-function version() {
-  return PACKAGE_INFO.version;
-}
+// src/core/api.ts
 function lex(input, options = {}) {
+  const wasm = getActive();
+  if (typeof wasm.lex !== "function") throw new UnsupportedFeatureError("lex", variant());
   return wasm.lex(input, options.stage ?? "lex");
 }
 function bitmarkToObjects(input, options = {}) {
-  const out = wasm.convert(
+  const out = getActive().convert(
     input,
     "bitmark",
     "json",
@@ -1412,7 +1453,7 @@ function objectsToBitmark(bits, options = {}) {
   const entries = bits.map(
     (b) => b !== null && typeof b === "object" && "bit" in b && typeof b.bit === "object" ? b : { bit: b }
   );
-  const out = wasm.convert(
+  const out = getActive().convert(
     JSON.stringify(entries),
     "json",
     "bitmark",
@@ -1427,7 +1468,7 @@ function objectsToBitmark(bits, options = {}) {
   return out;
 }
 function convert(input, options = {}) {
-  return wasm.convert(
+  return getActive().convert(
     input,
     options.inputFormat ?? "auto",
     options.outputFormat ?? "auto",
@@ -1440,7 +1481,7 @@ function convert(input, options = {}) {
   );
 }
 function canonicalize(input, options = {}) {
-  return wasm.canonicalize(
+  return getActive().canonicalize(
     input,
     options.inputFormat ?? "auto",
     options.mode ?? "optimized",
@@ -1450,14 +1491,15 @@ function canonicalize(input, options = {}) {
   );
 }
 function countBits(input) {
-  const out = wasm.count_bits(input);
+  const out = getActive().count_bits(input);
   if (out.startsWith("error:")) throw new Error(out);
   return Number.parseInt(out, 10);
 }
 function splitBits(input) {
-  return JSON.parse(wasm.split_bits(input));
+  return JSON.parse(getActive().split_bits(input));
 }
 function transform(input, options = {}) {
+  const wasm = getActive();
   if (options.preHook || options.postHook) {
     return runHookedTransform(wasm, input, options);
   }
@@ -1473,18 +1515,15 @@ function transform(input, options = {}) {
     options.spacesAroundValues ?? 1
   );
 }
-function transformParallel(input, options = {}) {
-  return runParallelTransform(wasm, input, options);
-}
 function breakscapeText(input, options = {}) {
   const format = options.format ?? "bitmark++";
   const location = options.location ?? "body";
-  return wasm.breakscape_text(input, format, location);
+  return getActive().breakscape_text(input, format, location);
 }
 function unbreakscapeText(input, options = {}) {
   const format = options.format ?? "bitmark++";
   const location = options.location ?? "body";
-  return wasm.unbreakscape_text(input, format, location);
+  return getActive().unbreakscape_text(input, format, location);
 }
 function info(options = {}) {
   const infoType = options.infoType ?? "list";
@@ -1495,16 +1534,45 @@ function info(options = {}) {
   const includeDeprecated = options.includeDeprecated ?? false;
   const onlyDeprecated = options.onlyDeprecated ?? false;
   const full = options.full ?? false;
-  return wasm.info(infoType, format, bit, pretty, indent, includeDeprecated, onlyDeprecated, full);
+  return getActive().info(infoType, format, bit, pretty, indent, includeDeprecated, onlyDeprecated, full);
+}
+
+// src/index.ts
+var require2 = (0, import_node_module.createRequire)(importMetaUrl);
+var VARIANT_GLUE = {
+  full: "../wasm/bitmark_wasm.js",
+  "bitmark-json": "../wasm-bitmark-json/bitmark_json_wasm.js"
+};
+function loadVariant(feature) {
+  const module2 = require2(VARIANT_GLUE[feature]);
+  setActive(feature, module2);
+}
+setLazyLoader(() => loadVariant("full"));
+async function init(options = {}) {
+  loadVariant(options.feature ?? "full");
+}
+function initSync(options = {}) {
+  loadVariant(options.feature ?? "full");
+}
+initLegacyNode(() => getActive());
+function version() {
+  return PACKAGE_INFO.version;
+}
+function transformParallel(input, options = {}) {
+  return runParallelTransform(getActive(), input, options);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  NotInitializedError,
+  UnsupportedFeatureError,
   bitmarkToObjects,
   breakscapeText,
   canonicalize,
   convert,
   countBits,
   info,
+  init,
+  initSync,
   legacy,
   lex,
   objectsToBitmark,
@@ -1513,6 +1581,7 @@ function info(options = {}) {
   transform,
   transformParallel,
   unbreakscapeText,
+  variant,
   version
 });
 //# sourceMappingURL=index.cjs.map