@gmb/bitmark-parser 6.10.1 → 6.11.1

package/dist/index.js

@@ -10,19 +10,26 @@ import { createRequire } from "module";
 // src/generated/package_info.ts
 var PACKAGE_INFO = {
   "name": "@gmb/bitmark-parser",
-  "version": "6.10.1",
+  "version": "6.11.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 NODE_DEFAULT_FEATURE = "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(
@@ -34,15 +41,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 setLazyLoader(loader) {
   lazyLoader = loader;
 }
@@ -62,13 +77,10 @@ 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 patchJsonOf(patch) {
+  if (patch === void 0) return "";
+  if (typeof patch === "string") return patch.trim();
+  return JSON.stringify(patch);
 }
 function buildUnits(wasm, input, inputIsBitmark) {
   if (inputIsBitmark) {
@@ -98,28 +110,56 @@ function planTransform(wasm, input, options) {
   const sel = options.inputFormat ?? "auto";
   const inputIsBitmark = sel === "bitmark" || sel !== "json" && wasm.is_bitmark(input);
   const inputFormat = inputIsBitmark ? "bitmark" : "json";
-  const staticPatch = normalisePatch(options.patch);
   const units = buildUnits(wasm, input, inputIsBitmark);
   const total = units.length;
-  const jobs = [];
-  const views = [];
+  const hooked = [];
   for (let index = 0; index < total; index++) {
-    const { view, source } = units[index];
+    const { view } = 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);
+    hooked.push(result.drop ? null : { patches: result.patches ?? [], outputFormat: result.outputFormat ?? output });
+  }
+  const patchJson = patchJsonOf(options.patch);
+  let resolved;
+  if (patchJson === "") {
+    resolved = units.map((_, index) => ({ source: index, bit: null, patch: [] }));
+  } else {
+    const out = wasm.resolve_patch_document(input, patchJson);
+    if (isError(out)) throw new Error(out);
+    resolved = JSON.parse(out);
+  }
+  const jobs = [];
+  const views = [];
+  for (const item of resolved) {
+    if (item.source !== null) {
+      const hook = hooked[item.source];
+      if (!hook) continue;
+      jobs.push({
+        index: item.source,
+        source: units[item.source].source,
+        inputFormat,
+        outputFormat: hook.outputFormat,
+        mode,
+        // The document's patches first, the hook's after (the hook contract).
+        patchJson: JSON.stringify([...item.patch, ...hook.patches]),
+        spacesAroundValues
+      });
+      views.push(units[item.source].view);
+    } else {
+      const bit = item.bit ?? {};
+      const index = jobs.length;
+      jobs.push({
+        index,
+        source: JSON.stringify([{ bit }]),
+        inputFormat: "json",
+        outputFormat: output,
+        mode,
+        patchJson: JSON.stringify(item.patch),
+        spacesAroundValues
+      });
+      views.push({ format: "json", index, total, bit });
+    }
   }
   return { jobs, views, output, pretty, indent };
 }
@@ -621,7 +661,7 @@ var Builder = class {
     const wasm = getLegacyWasm();
     if (bitType !== void 0) {
       try {
-        const info2 = JSON.parse(wasm.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 {
       }
@@ -720,7 +760,7 @@ var BitmarkParserGenerator = class {
     const format = opts.outputFormat ?? "text";
     const { pretty, indent } = prettyIndent(opts.prettify);
     const coreFormat = format === "pojo" ? "json" : format;
-    const out = wasm.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;
@@ -1303,7 +1343,7 @@ var bitTypeCache;
 function loadBitTypes() {
   if (!bitTypeCache) {
     const wasm = getLegacyWasm();
-    const all = JSON.parse(wasm.info("all", "json", "", false, 2, true, false, false));
+    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;
@@ -1374,6 +1414,7 @@ var StreamWriter = stubClass("StreamWriter", INTERNAL_REASON);
 function patchEntry(path2, op, value) {
   return value === void 0 ? { path: path2, op } : { path: path2, op, value };
 }
+var ALL_LANGUAGES = "all";
 
 // src/core/api.ts
 function lex(input, options = {}) {
@@ -1462,6 +1503,26 @@ function transform(input, options = {}) {
     options.spacesAroundValues ?? 1
   );
 }
+function diff(a, b, options = {}) {
+  const wasm = getActive();
+  if (typeof wasm.diff !== "function") throw new UnsupportedFeatureError("diff", variant());
+  const out = wasm.diff(
+    a,
+    b,
+    options.inputFormat ?? "auto",
+    options.outputFormat ?? "bitmark",
+    options.context ?? 3,
+    options.locate ?? false,
+    options.similarity ?? 0.6,
+    options.bboxTolerance ?? 8,
+    options.spacesAroundValues ?? 0
+  );
+  if (out.startsWith("error:")) throw new Error(out.slice("error:".length).trim());
+  return out;
+}
+function diffBits(a, b, options = {}) {
+  return JSON.parse(diff(a, b, { ...options, outputFormat: "json" }));
+}
 function breakscapeText(input, options = {}) {
   const format = options.format ?? "bitmark++";
   const location = options.location ?? "body";
@@ -1481,41 +1542,66 @@ function info(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 register(options) {
+  const result = getActive().register(options.type, options.data);
+  if (result) throw new RegisterError(result.replace(/^error:\s*/, ""));
+  rememberRegistration(options.type, options.data);
 }
 
 // src/index.ts
 var require2 = createRequire(import.meta.url);
 var VARIANT_GLUE = {
   full: "../wasm/bitmark_wasm.js",
+  "browser-full": "../wasm-browser-full/bitmark_browser_full_wasm.js",
   "bitmark-json": "../wasm-bitmark-json/bitmark_json_wasm.js"
 };
 function loadVariant(feature) {
   const module = require2(VARIANT_GLUE[feature]);
   setActive(feature, module);
 }
-setLazyLoader(() => loadVariant("full"));
+setLazyLoader(() => loadVariant(NODE_DEFAULT_FEATURE));
 async function init(options = {}) {
-  loadVariant(options.feature ?? "full");
+  loadVariant(options.feature ?? NODE_DEFAULT_FEATURE);
 }
 function initSync(options = {}) {
-  loadVariant(options.feature ?? "full");
+  loadVariant(options.feature ?? NODE_DEFAULT_FEATURE);
 }
 initLegacyNode(() => getActive());
 function version() {
   return PACKAGE_INFO.version;
 }
 function transformParallel(input, options = {}) {
-  return runParallelTransform(getActive(), input, options);
+  return runParallelTransform(
+    getActive(),
+    input,
+    options
+  );
 }
 export {
+  ALL_LANGUAGES,
   NotInitializedError,
+  RegisterError,
   UnsupportedFeatureError,
   bitmarkToObjects,
   breakscapeText,
   canonicalize,
   convert,
   countBits,
+  diff,
+  diffBits,
   info,
   init,
   initSync,
@@ -1523,6 +1609,7 @@ export {
   lex,
   objectsToBitmark,
   patchEntry,
+  register,
   splitBits,
   transform,
   transformParallel,