@gmb/bitmark-parser 6.1.3 → 6.1.4

package/dist/legacy.js

@@ -0,0 +1,1095 @@
+// src/legacy-entry.ts
+import { createRequire } from "module";
+
+// src/node/legacy-init.ts
+import * as fs from "fs";
+import * as path from "path";
+
+// src/legacy/runtime.ts
+var wasmModule;
+function setLegacyWasm(wasm2) {
+  wasmModule = wasm2;
+}
+function getLegacyWasm() {
+  if (!wasmModule) {
+    throw new Error(
+      "legacy API not initialised: the WASM module has not been provided (browser consumers must call init() first)"
+    );
+  }
+  return wasmModule;
+}
+var fileIo;
+function setLegacyFileIo(io) {
+  fileIo = io;
+}
+function getLegacyFileIo() {
+  return fileIo;
+}
+
+// src/node/legacy-init.ts
+function initLegacyNode(wasm2) {
+  setLegacyWasm(wasm2);
+  setLegacyFileIo({
+    existsSync: (p) => fs.existsSync(p),
+    readFileSync: (p, encoding) => fs.readFileSync(p, { encoding }),
+    writeFile: (p, data, opts) => {
+      fs.mkdirSync(path.dirname(p), { recursive: true });
+      fs.writeFileSync(p, data, {
+        encoding: opts.encoding ?? "utf8",
+        flag: opts.append ? "a" : "w"
+      });
+    }
+  });
+}
+
+// src/generated/package_info.ts
+var PACKAGE_INFO = {
+  "name": "@gmb/bitmark-parser",
+  "version": "6.1.4",
+  "author": "Get More Brain Ltd <info@getmorebrain.com>",
+  "license": "ISC",
+  "description": "A parser for bitmark text, powered by WebAssembly."
+};
+
+// src/legacy/errors.ts
+var LegacyUnsupportedError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LegacyUnsupportedError";
+  }
+};
+function unsupportedMember(member, reason) {
+  throw new LegacyUnsupportedError(
+    `'${member}' is not supported by the @gmb/bitmark-parser legacy API` + (reason ? `: ${reason}` : "")
+  );
+}
+function unsupportedOption(option, reason) {
+  throw new LegacyUnsupportedError(
+    `Option '${option}' is not supported by the @gmb/bitmark-parser legacy API` + (reason ? `: ${reason}` : "")
+  );
+}
+
+// src/legacy/translate.ts
+var V3_ONLY = "bitmark v2 output is not supported (this parser is bitmark v3 only)";
+function validateVersionOptions(opts) {
+  if (opts.bitmarkVersion === 2) unsupportedOption("bitmarkVersion: 2", V3_ONLY);
+}
+function validateBitmarkOptions(o) {
+  if (o.explicitTextFormat) unsupportedOption("bitmarkOptions.explicitTextFormat");
+  if (o.prettifyJson !== void 0 && o.prettifyJson !== false) {
+    unsupportedOption("bitmarkOptions.prettifyJson", "embedded-JSON body prettification is not supported");
+  }
+  if (o.cardSetVersion === 1) unsupportedOption("bitmarkOptions.cardSetVersion: 1", V3_ONLY);
+  if (o.debugGenerationInline) unsupportedOption("bitmarkOptions.debugGenerationInline");
+  if (o.noBreakscaping) unsupportedOption("bitmarkOptions.noBreakscaping");
+}
+function validateJsonOptions(o) {
+  if (o.textAsPlainText) unsupportedOption("jsonOptions.textAsPlainText", V3_ONLY);
+  if (o.excludeUnknownProperties) unsupportedOption("jsonOptions.excludeUnknownProperties");
+  if (o.debugGenerationInline) unsupportedOption("jsonOptions.debugGenerationInline");
+}
+function prettyIndent(prettify) {
+  if (prettify === true) return { pretty: true, indent: 2 };
+  if (typeof prettify === "number" && prettify > 0) return { pretty: true, indent: prettify };
+  return { pretty: false, indent: 2 };
+}
+function spacesAround(v) {
+  if (v === void 0 || v === true) return 1;
+  if (v === false) return 0;
+  return Math.max(0, Math.min(10, v));
+}
+function mapTextFormat(f) {
+  switch (f) {
+    case "text":
+    case "latex":
+    case "json":
+    case "xml":
+      return "plainText";
+    default:
+      return "bitmark++";
+  }
+}
+
+// src/legacy/pseudo-ast.ts
+var PSEUDO_AST_MARKER = /* @__PURE__ */ Symbol.for("@gmb/bitmark-parser/legacy-pseudo-ast");
+function makePseudoAst(bits) {
+  const ast = { bits };
+  Object.defineProperty(ast, PSEUDO_AST_MARKER, { value: true, enumerable: false });
+  return ast;
+}
+function isPseudoAst(v) {
+  return v !== null && typeof v === "object" && (PSEUDO_AST_MARKER in v || Array.isArray(v.bits));
+}
+
+// src/legacy/builder.ts
+var BUILT_BIT_PARSER = /* @__PURE__ */ Symbol.for("@gmb/bitmark-parser/legacy-built-bit-parser");
+var DATA_KEY_TO_JSON_KEY = {
+  bitType: "type",
+  textFormat: "format",
+  flashcards: "cards",
+  markConfig: "marks"
+};
+var DEPRECATED_TEXT_FORMATS = {
+  "bitmark--": "bitmark++",
+  "bitmark+": "bitmark++"
+};
+var TAG_TEXT_KEYS = [
+  "title",
+  "subtitle",
+  "item",
+  "lead",
+  "pageNumber",
+  "marginNumber",
+  "hint",
+  "instruction",
+  "caption"
+];
+var Builder = class {
+  /**
+   * Build bitmark AST envelope (bpg-compatible `buildBitmark`).
+   */
+  buildBitmark(data) {
+    const ast = makePseudoAst(data.bits ?? []);
+    if (data.errors !== void 0) {
+      ast.errors = data.errors;
+    }
+    return ast;
+  }
+  /**
+   * Build a bit (bpg-compatible `buildBit`).
+   *
+   * Accepts the full bpg data shape (flat, ~250 optional fields, values in
+   * the JSON model types). Returns the normalized bit JSON. Throws
+   * `No config found for bit: X` for unknown bit types, as bpg does.
+   *
+   * NOTE (documented divergences from bpg):
+   * - the return value is bit JSON, not bpg's internal AST node model;
+   * - `resourceType` (an inference hint in bpg) is not carried into the
+   *   JSON — the attached `resource` object is authoritative;
+   * - more than one entry in `resources` passes through under a
+   *   `resources` key (kept visible, not silently dropped) — the canonical
+   *   single attachment is `resource`.
+   */
+  buildBit(data, _options) {
+    const wasm2 = getLegacyWasm();
+    const src = { ...data };
+    const bitType = src.bitType;
+    this.assertKnownBitType(bitType);
+    const bit = {};
+    bit.type = bitType;
+    if (src.isCommented) {
+      bit.type = "_comment";
+      bit.originalType = bitType;
+    }
+    delete src.bitType;
+    delete src.isCommented;
+    const textFormat = src.textFormat;
+    if (textFormat !== void 0) {
+      bit.format = DEPRECATED_TEXT_FORMATS[textFormat] ?? textFormat;
+      delete src.textFormat;
+    }
+    delete src.resourceType;
+    const body = src.body;
+    if (body !== void 0 && body !== null && typeof body === "object" && "body" in body) {
+      bit.body = body.body;
+      delete src.body;
+    }
+    if (src.example !== void 0) {
+      bit.isExample = true;
+      bit.example = src.example;
+      delete src.example;
+      delete src.__isDefaultExample;
+    } else if (src.__isDefaultExample) {
+      bit.isExample = true;
+      delete src.__isDefaultExample;
+    }
+    const resources = src.resources;
+    if (resources !== void 0) {
+      if (Array.isArray(resources)) {
+        if (resources.length === 1) bit.resource = resources[0];
+        else if (resources.length > 1) bit.resources = resources;
+      } else {
+        bit.resource = resources;
+      }
+      delete src.resources;
+    }
+    const parser = src.parser;
+    delete src.parser;
+    const extraProperties = src.extraProperties;
+    delete src.extraProperties;
+    for (const [key, value] of Object.entries(src)) {
+      if (value === void 0) continue;
+      bit[DATA_KEY_TO_JSON_KEY[key] ?? key] = value;
+    }
+    if (extraProperties) {
+      for (const [key, value] of Object.entries(extraProperties)) {
+        if (!(key in bit)) bit[key] = value;
+      }
+    }
+    this.parseStringTexts(bit);
+    const out = wasm2.convert(JSON.stringify([{ bit }]), "json", "json", "optimized", false, 2, 1);
+    if (out.startsWith("error:")) {
+      throw new Error(out.slice("error:".length).trim());
+    }
+    const entries = JSON.parse(out);
+    const built = entries[0]?.bit ?? bit;
+    for (const [key, value] of Object.entries(bit)) {
+      if (key in built) continue;
+      if (value === false || value === "" || value === null || Array.isArray(value) && value.length === 0) {
+        continue;
+      }
+      built[key] = value;
+    }
+    if (parser !== void 0) {
+      Object.defineProperty(built, BUILT_BIT_PARSER, { value: parser, enumerable: false });
+    }
+    return built;
+  }
+  /**
+   * Build a highlight body bit (bpg-compatible `buildHighlight`).
+   * Shapes the HighlightJson body-bit; unset optionals are omitted.
+   */
+  buildHighlight(_context, data) {
+    if (!data) return void 0;
+    const src = { ...data };
+    const attrs = src.attrs;
+    if (attrs) Object.assign(src, attrs);
+    const texts = Array.isArray(src.texts) ? src.texts.filter((t) => t != null).map((t) => ({
+      text: t.text ?? "",
+      isCorrect: t.isCorrect ?? false,
+      isHighlighted: t.isHighlighted ?? false,
+      ...stripUndefined(t, ["text", "isCorrect", "isHighlighted"])
+    })) : [];
+    const node = {
+      type: "highlight",
+      texts,
+      prefix: src.prefix ?? "",
+      postfix: src.postfix ?? "",
+      ...stripUndefined(src, ["type", "texts", "prefix", "postfix", "attrs"]),
+      attrs: {}
+    };
+    return node;
+  }
+  /**
+   * bpg's builder parses string-valued JsonText fields as bitmark text
+   * (inline marks become TextAst marks); the composer would otherwise treat
+   * them as literal text. Converts top-level JsonText fields in place.
+   * Nested (card-content) strings are left literal — documented divergence.
+   */
+  parseStringTexts(bit) {
+    const wasm2 = getLegacyWasm();
+    const toAst = (s, location) => {
+      if (s === "") return s;
+      const out = wasm2.convert_text(s, "textToAst", "bitmark++", location);
+      try {
+        return JSON.parse(out);
+      } catch {
+        return s;
+      }
+    };
+    const format = bit.format;
+    const bitmarkBody = format === void 0 || format === "bitmark++" || format === "bitmark+";
+    if (typeof bit.body === "string" && bitmarkBody) {
+      bit.body = toAst(bit.body, "body");
+    }
+    for (const key of TAG_TEXT_KEYS) {
+      const v = bit[key];
+      if (typeof v === "string") bit[key] = toAst(v, "tag");
+    }
+  }
+  /** Throw bpg's exact unknown-bit-type error (`Config.getBitConfig` parity). */
+  assertKnownBitType(bitType) {
+    const wasm2 = getLegacyWasm();
+    let known = false;
+    if (bitType !== void 0) {
+      try {
+        const info = JSON.parse(wasm2.info("bit", "json", bitType, false, 2));
+        known = info.error === void 0;
+      } catch {
+        known = false;
+      }
+    }
+    if (!known) {
+      throw new Error(`No config found for bit: ${bitType}`);
+    }
+  }
+};
+function stripUndefined(src, exclude) {
+  const out = {};
+  for (const [k, v] of Object.entries(src)) {
+    if (v !== void 0 && !exclude.includes(k)) out[k] = v;
+  }
+  return out;
+}
+
+// src/legacy/bpg-class.ts
+var BitmarkParserGenerator = class {
+  /**
+   * Get the version of the library.
+   *
+   * Reports the @gmb/bitmark-parser version (not a bpg version string).
+   */
+  version() {
+    return PACKAGE_INFO.version;
+  }
+  /**
+   * Convert bitmark from bitmark to JSON, or JSON to bitmark (bpg-compatible).
+   *
+   * Input detection order matches bpg: AST → JSON → assume bitmark.
+   * Default output: bitmark input → json; json/ast input → bitmark.
+   */
+  convert(input, options) {
+    const opts = Object.assign({}, options);
+    const jsonOptions = Object.assign({}, opts.jsonOptions);
+    const bitmarkOptions = Object.assign({}, opts.bitmarkOptions);
+    validateVersionOptions(opts);
+    validateBitmarkOptions(bitmarkOptions);
+    validateJsonOptions(jsonOptions);
+    this.checkBrowserFileWrite(opts.outputFile);
+    const wasm2 = getLegacyWasm();
+    const { source, isBitmark } = this.resolveInput(input, opts.inputFormat);
+    const outputFormat = opts.outputFormat ?? (isBitmark ? "json" : "bitmark");
+    const coreFormat = outputFormat === "ast" ? "json" : outputFormat;
+    const { pretty, indent } = prettyIndent(jsonOptions.prettify);
+    const spaces = spacesAround(bitmarkOptions.spacesAroundValues);
+    const out = wasm2.convert(source, isBitmark ? "bitmark" : "json", coreFormat, "optimized", pretty, indent, spaces);
+    this.throwOnError(out);
+    if (outputFormat === "bitmark" || outputFormat === "text") {
+      return this.deliver(out, opts.outputFile, opts.fileOptions);
+    }
+    if (outputFormat === "json") {
+      if (opts.outputFile) return this.deliver(out, opts.outputFile, opts.fileOptions);
+      if (pretty || jsonOptions.stringify) return out;
+      return JSON.parse(out);
+    }
+    const ast = makePseudoAst(JSON.parse(out));
+    if (opts.outputFile) {
+      return this.deliver(JSON.stringify(ast), opts.outputFile, opts.fileOptions);
+    }
+    return ast;
+  }
+  /**
+   * Upgrade (prettify / canonicalize) bitmark or JSON to the latest version
+   * of itself (bpg-compatible `upgrade`).
+   */
+  upgrade(input, options) {
+    const opts = Object.assign({}, options);
+    const jsonOptions = Object.assign({}, opts.jsonOptions);
+    const bitmarkOptions = Object.assign({}, opts.bitmarkOptions);
+    validateVersionOptions(opts);
+    validateBitmarkOptions(bitmarkOptions);
+    validateJsonOptions(jsonOptions);
+    this.checkBrowserFileWrite(opts.outputFile);
+    const wasm2 = getLegacyWasm();
+    const { source, isBitmark } = this.resolveInput(input, opts.inputFormat);
+    const { pretty, indent } = prettyIndent(jsonOptions.prettify);
+    const spaces = spacesAround(bitmarkOptions.spacesAroundValues);
+    const out = wasm2.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);
+    if (pretty || jsonOptions.stringify) return out;
+    return JSON.parse(out);
+  }
+  /**
+   * Get information about the bitmark language (bpg-compatible `info`).
+   */
+  info(options) {
+    const opts = Object.assign({}, options);
+    const wasm2 = 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);
+    this.throwOnError(out);
+    if (format === "pojo") return JSON.parse(out);
+    return out;
+  }
+  /** Not supported: bpg-internal development tool. */
+  generateConfig(_options) {
+    unsupportedMember("BitmarkParserGenerator.generateConfig", "bpg-internal development tool");
+  }
+  /**
+   * Convert between HTML tables and bitmark tables (bpg-compatible
+   * `convertHtmlTable`).
+   *
+   * Backed by the core's schema-driven html mapping: HTML input has each
+   * `<table>` wrapped in the core's `<bitmark-bit>` envelope and parsed;
+   * bits input is emitted as html and the `<table>` fragments extracted
+   * (the envelope stripped). The markup *inside* `<table>` follows this
+   * parser's html mapping, which may differ from bpg's in detail.
+   */
+  convertHtmlTable(input, options) {
+    const opts = Object.assign({}, options);
+    const jsonOptions = Object.assign({}, opts.jsonOptions);
+    const bitmarkOptions = Object.assign({}, opts.bitmarkOptions);
+    validateBitmarkOptions(bitmarkOptions);
+    validateJsonOptions(jsonOptions);
+    if (opts.keepUnknownTags) unsupportedOption("keepUnknownTags");
+    if (opts.noBreakscaping) unsupportedOption("noBreakscaping");
+    this.checkBrowserFileWrite(opts.outputFile);
+    const wasm2 = 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);
+      this.throwOnError(out2);
+      return this.deliver(extractHtmlTables(out2).join("\n"), opts.outputFile, opts.fileOptions);
+    }
+    const bitType = opts.tableFormat === "table" ? "table" : "table-extended";
+    const wrapped = extractHtmlTables(inStr).map((t) => `<bitmark-bit data-type="${bitType}" data-format="bitmark++">${t}</bitmark-bit>`).join("");
+    const outputFormat = opts.outputFormat ?? "bitmark";
+    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);
+      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);
+    this.throwOnError(out);
+    if (outputFormat === "bitmark" || outputFormat === "text") {
+      return this.deliver(out, opts.outputFile, opts.fileOptions);
+    }
+    if (outputFormat === "json") {
+      if (opts.outputFile) return this.deliver(out, opts.outputFile, opts.fileOptions);
+      if (pretty || jsonOptions.stringify) return out;
+      return JSON.parse(out);
+    }
+    const ast = makePseudoAst(JSON.parse(out));
+    if (opts.outputFile) return this.deliver(JSON.stringify(ast), opts.outputFile, opts.fileOptions);
+    return ast;
+  }
+  /**
+   * Create a bit-JSON pseudo-AST from bitmark or JSON input (PLAN-126 §3.1).
+   *
+   * NOTE: the returned structure is the bit JSON (wrapper entries), not
+   * bpg's internal TS AST node model. It round-trips through `convert` but
+   * is not walkable with bpg's `Ast`/`NodeType`.
+   */
+  createAst(input, options) {
+    const opts = Object.assign({}, options);
+    const wasm2 = getLegacyWasm();
+    const { source, isBitmark } = this.resolveInput(input, opts.inputFormat);
+    const out = wasm2.convert(source, isBitmark ? "bitmark" : "json", "json", "optimized", false, 2, 1);
+    this.throwOnError(out);
+    return makePseudoAst(JSON.parse(out));
+  }
+  /**
+   * Breakscape text (bpg-compatible `breakscapeText`).
+   */
+  breakscapeText(input, options) {
+    if (!input) return input;
+    const opts = Object.assign({}, options);
+    this.checkBrowserFileWrite(opts.outputFile);
+    const wasm2 = getLegacyWasm();
+    const inStr = this.maybeReadFile(input, opts.inputFormat);
+    const res = wasm2.breakscape_text(inStr, mapTextFormat(opts.textFormat), opts.textLocation ?? "body");
+    return this.deliver(res, opts.outputFile, opts.fileOptions);
+  }
+  /**
+   * Unbreakscape text (bpg-compatible `unbreakscapeText`).
+   */
+  unbreakscapeText(input, options) {
+    if (!input) return input;
+    const opts = Object.assign({}, options);
+    this.checkBrowserFileWrite(opts.outputFile);
+    const wasm2 = getLegacyWasm();
+    const inStr = this.maybeReadFile(input, opts.inputFormat);
+    const res = wasm2.unbreakscape_text(inStr, mapTextFormat(opts.textFormat), opts.textLocation ?? "body");
+    return this.deliver(res, opts.outputFile, opts.fileOptions);
+  }
+  /**
+   * Convert bitmark text ↔ text AST (bpg-compatible `convertText`).
+   *
+   * Direction is auto-detected: TextAst (JSON) input generates bitmark
+   * text; anything else parses as bitmark text and returns the TextAst
+   * (plain JS object; a string when `jsonOptions.prettify` is set).
+   */
+  convertText(input, options) {
+    const opts = Object.assign({}, options);
+    const jsonOptions = Object.assign({}, opts.jsonOptions);
+    this.checkBrowserFileWrite(opts.outputFile);
+    const wasm2 = getLegacyWasm();
+    const isBitmarkText = opts.textFormat === void 0 || mapTextFormat(opts.textFormat) === "bitmark++";
+    const textLocation = opts.textLocation ?? "body";
+    let inStr;
+    let ast;
+    if (typeof input === "string") {
+      inStr = this.maybeReadFile(input, opts.inputFormat);
+      ast = this.parseTextAstString(inStr);
+    } else {
+      inStr = JSON.stringify(input);
+      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);
+      this.throwOnError(out2);
+      return this.deliver(out2, opts.outputFile, opts.fileOptions);
+    }
+    const out = wasm2.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;
+    if (opts.outputFile) return this.deliver(outStr, opts.outputFile, opts.fileOptions);
+    if (pretty) return outStr;
+    return JSON.parse(out);
+  }
+  /**
+   * Convert a text AST to plain text (bpg-compatible `textAstToPlainText`).
+   */
+  textAstToPlainText(textAst, _options) {
+    const wasm2 = getLegacyWasm();
+    const out = wasm2.convert_text(
+      typeof textAst === "string" ? textAst : JSON.stringify(textAst),
+      "astToPlainText",
+      "bitmark++",
+      "body"
+    );
+    this.throwOnError(out);
+    return out;
+  }
+  /**
+   * Extract plain text from bitmark or bitmark JSON (bpg-compatible).
+   */
+  extractPlainText(input, options) {
+    const inputFormat = options?.inputFormat;
+    const wasm2 = 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");
+      this.throwOnError(out2);
+      return out2;
+    }
+    if (typeof input === "string" && this.parseTextAstString(input) === void 0 && !wasm2.is_bitmark(input)) {
+      const looksJson = (() => {
+        try {
+          JSON.parse(input);
+          return true;
+        } catch {
+          return false;
+        }
+      })();
+      if (!looksJson) {
+        return this.extractPlainText(input, { inputFormat: "bitmarkText" });
+      }
+    }
+    const { source, isBitmark } = this.resolveInput(input, void 0);
+    const out = wasm2.convert(source, isBitmark ? "bitmark" : "json", "text", "optimized", false, 2, 1);
+    this.throwOnError(out);
+    return out;
+  }
+  /** If `s` parses as a TextAst JSON array, return it. */
+  parseTextAstString(s) {
+    const t = s.trim();
+    if (!t.startsWith("[")) return void 0;
+    try {
+      const v = JSON.parse(t);
+      if (Array.isArray(v) && v.every((n) => n !== null && typeof n === "object" && "type" in n)) {
+        return v;
+      }
+    } catch {
+    }
+    return void 0;
+  }
+  // ------------------------------------------------------------------
+  // Internal helpers
+  // ------------------------------------------------------------------
+  /**
+   * Resolve bpg input (string | file path | JSON value | pseudo-AST) to a
+   * source string for the WASM core, classified per bpg's detection order:
+   * AST → JSON → assume bitmark (PLAN-126 F-10).
+   */
+  resolveInput(input, inputFormat) {
+    if (typeof input !== "string") {
+      const entries = this.jsonEntries(input);
+      return {
+        source: JSON.stringify(entries ? entries.map((b) => this.toWrapperEntry(b)) : input),
+        isBitmark: false
+      };
+    }
+    const inStr = this.maybeReadFile(input, inputFormat);
+    const wasm2 = getLegacyWasm();
+    if (wasm2.is_bitmark(inStr)) return { source: inStr, isBitmark: true };
+    try {
+      const parsed = JSON.parse(inStr);
+      const entries = this.jsonEntries(parsed);
+      if (entries) {
+        return {
+          source: JSON.stringify(entries.map((b) => this.toWrapperEntry(b))),
+          isBitmark: false
+        };
+      }
+    } catch {
+      return { source: inStr, isBitmark: true };
+    }
+    return { source: inStr, isBitmark: false };
+  }
+  /**
+   * Normalise the JSON shapes bpg accepts to a bits/entries array:
+   * wrapper array, `{ bits: [...] }` AST envelope, single `{ bit: ... }`
+   * wrapper, or a bare bit object (`{ type: ... }`).
+   */
+  jsonEntries(v) {
+    if (Array.isArray(v)) return v;
+    if (v !== null && typeof v === "object") {
+      const o = v;
+      if (Array.isArray(o.bits)) return o.bits;
+      if ("bit" in o) return [o];
+      if (typeof o.type === "string") return [{ bit: o }];
+    }
+    return void 0;
+  }
+  /**
+   * Normalise a pseudo-AST bits entry to a `{ bit, parser? }` wrapper.
+   * `Builder.buildBit` returns bare bit JSON (with any parser metadata
+   * attached under a non-enumerable symbol); parsed forward output is
+   * already wrapper-shaped.
+   */
+  toWrapperEntry(entry) {
+    if (entry !== null && typeof entry === "object" && "bit" in entry) return entry;
+    const wrapper = { bit: entry };
+    const parser = entry?.[BUILT_BIT_PARSER];
+    if (parser !== void 0) wrapper.parser = parser;
+    return wrapper;
+  }
+  /** bpg parity: read `input` as a file when it names one (Node only). */
+  maybeReadFile(input, inputFormat) {
+    if (inputFormat === "string") return input;
+    const io = getLegacyFileIo();
+    if (!io) return input;
+    try {
+      if (io.existsSync(input)) return io.readFileSync(input, "utf8");
+    } catch {
+    }
+    return input;
+  }
+  /** bpg parity: writing a file is impossible in the browser. */
+  checkBrowserFileWrite(outputFile) {
+    if (outputFile && !getLegacyFileIo()) {
+      throw new Error("Cannot write to file in browser environment");
+    }
+  }
+  /** Return `data`, or write it to `outputFile` (returning void), as bpg does. */
+  deliver(data, outputFile, fileOptions) {
+    if (!outputFile) return data;
+    const io = getLegacyFileIo();
+    if (!io) throw new Error("Cannot write to file in browser environment");
+    io.writeFile(outputFile, data, {
+      append: fileOptions?.append,
+      encoding: fileOptions?.encoding ?? "utf8"
+    });
+  }
+  /** The core reports failures as `error:`-prefixed strings; bpg throws. */
+  throwOnError(out) {
+    if (out.startsWith("error:")) {
+      throw new Error(out.slice("error:".length).trim());
+    }
+  }
+};
+function extractHtmlTables(html) {
+  const tables = [];
+  const lower = html.toLowerCase();
+  let i = 0;
+  for (; ; ) {
+    const start = lower.indexOf("<table", i);
+    if (start === -1) break;
+    let depth = 0;
+    let j = start;
+    let end = -1;
+    while (j < html.length) {
+      const open = lower.indexOf("<table", j);
+      const close = lower.indexOf("</table", j);
+      if (close === -1) break;
+      if (open !== -1 && open < close) {
+        depth++;
+        j = open + "<table".length;
+      } else {
+        depth--;
+        const closeEnd = lower.indexOf(">", close);
+        j = closeEnd === -1 ? html.length : closeEnd + 1;
+        if (depth === 0) {
+          end = j;
+          break;
+        }
+      }
+    }
+    if (end === -1) break;
+    tables.push(html.slice(start, end));
+    i = end;
+  }
+  return tables;
+}
+function bitmarkTextParse(text) {
+  const out = getLegacyWasm().convert_text(text, "textToAst", "bitmark++", "body");
+  if (out.startsWith("error:")) throw new Error(out.slice("error:".length).trim());
+  return JSON.parse(out);
+}
+
+// src/legacy/resource-builder.ts
+var RESOURCE_SPECS = {
+  imageResource: { type: "image", key: "image", valueField: "src" },
+  imageLinkResource: { type: "image-link", key: "imageLink", valueField: "url" },
+  audioResource: { type: "audio", key: "audio", valueField: "src" },
+  audioEmbedResource: { type: "audio-embed", key: "audioEmbed", valueField: "src" },
+  audioLinkResource: { type: "audio-link", key: "audioLink", valueField: "url" },
+  videoResource: { type: "video", key: "video", valueField: "src" },
+  videoEmbedResource: { type: "video-embed", key: "videoEmbed", valueField: "url" },
+  videoLinkResource: { type: "video-link", key: "videoLink", valueField: "url" },
+  stillImageFilmEmbedResource: {
+    type: "still-image-film-embed",
+    key: "stillImageFilmEmbed",
+    valueField: "url"
+  },
+  stillImageFilmLinkResource: {
+    type: "still-image-film-link",
+    key: "stillImageFilmLink",
+    valueField: "url"
+  },
+  articleResource: { type: "article", key: "article", valueField: "body" },
+  documentResource: { type: "document", key: "document", valueField: "url" },
+  documentEmbedResource: { type: "document-embed", key: "documentEmbed", valueField: "url" },
+  documentLinkResource: { type: "document-link", key: "documentLink", valueField: "url" },
+  documentDownloadResource: {
+    type: "document-download",
+    key: "documentDownload",
+    valueField: "url"
+  },
+  appLinkResource: { type: "app-link", key: "appLink", valueField: "url" },
+  websiteLinkResource: { type: "website-link", key: "websiteLink", valueField: "url" }
+};
+function buildResource(spec) {
+  return (_context, data, _typeAlias) => {
+    if (!data) return void 0;
+    const { value, ...rest } = data;
+    const inner = { [spec.valueField]: value ?? "" };
+    for (const [k, v] of Object.entries(rest)) {
+      if (v !== void 0) inner[k] = v;
+    }
+    return { type: spec.type, [spec.key]: inner };
+  };
+}
+var SPEC_BY_TYPE = Object.fromEntries(
+  Object.values(RESOURCE_SPECS).map((s) => [s.type, s])
+);
+var ResourceBuilder = class {
+  /**
+   * Normalise existing ResourceJson wrapper(s) (bpg-compatible).
+   * Unknown resource types are dropped (bpg parity: it skips invalid types).
+   */
+  resourceFromResourceJson(_context, resource) {
+    if (!resource) return void 0;
+    const single = !Array.isArray(resource);
+    const list = single ? [resource] : resource;
+    const nodes = [];
+    for (const wrapper of list) {
+      const spec = SPEC_BY_TYPE[wrapper.type];
+      if (!spec) continue;
+      const inner = wrapper[spec.key] ?? {};
+      const { [spec.valueField]: value, ...rest } = inner;
+      const built = buildResource(spec)(void 0, { value, ...rest });
+      if (built) nodes.push(built);
+    }
+    if (nodes.length === 0) return void 0;
+    return single ? nodes[0] : nodes;
+  }
+  /**
+   * Build a resource wrapper from a bare ResourceDataJson (bpg-compatible).
+   * `data` may also be a plain string (used as the url/src/body value).
+   */
+  resourceFromResourceDataJson(context, type, data) {
+    if (!data) return void 0;
+    const spec = SPEC_BY_TYPE[type];
+    if (!spec) return void 0;
+    const asString = typeof data === "string" ? data : void 0;
+    const obj = typeof data === "object" ? data : {};
+    const { url, src, body, ...rest } = obj;
+    const value = url ?? src ?? body ?? asString;
+    return buildResource(spec)(context, { value, ...rest });
+  }
+  imageResource = buildResource(RESOURCE_SPECS.imageResource);
+  imageLinkResource = buildResource(RESOURCE_SPECS.imageLinkResource);
+  audioResource = buildResource(RESOURCE_SPECS.audioResource);
+  audioEmbedResource = buildResource(RESOURCE_SPECS.audioEmbedResource);
+  audioLinkResource = buildResource(RESOURCE_SPECS.audioLinkResource);
+  videoResource = buildResource(RESOURCE_SPECS.videoResource);
+  videoEmbedResource = buildResource(RESOURCE_SPECS.videoEmbedResource);
+  videoLinkResource = buildResource(RESOURCE_SPECS.videoLinkResource);
+  stillImageFilmEmbedResource = buildResource(
+    RESOURCE_SPECS.stillImageFilmEmbedResource
+  );
+  stillImageFilmLinkResource = buildResource(
+    RESOURCE_SPECS.stillImageFilmLinkResource
+  );
+  articleResource = buildResource(RESOURCE_SPECS.articleResource);
+  documentResource = buildResource(RESOURCE_SPECS.documentResource);
+  documentEmbedResource = buildResource(RESOURCE_SPECS.documentEmbedResource);
+  documentLinkResource = buildResource(RESOURCE_SPECS.documentLinkResource);
+  documentDownloadResource = buildResource(
+    RESOURCE_SPECS.documentDownloadResource
+  );
+  appLinkResource = buildResource(RESOURCE_SPECS.appLinkResource);
+  websiteLinkResource = buildResource(RESOURCE_SPECS.websiteLinkResource);
+};
+
+// src/legacy/options.ts
+var Input = {
+  /** Input is as a string */
+  string: "string",
+  /** Input is as a file path */
+  file: "file"
+};
+var Output = {
+  /** Output bitmark string */
+  bitmark: "bitmark",
+  /** Output JSON as a plain JS object, or a file */
+  json: "json",
+  /** Output AST as a plain JS object, or a file */
+  ast: "ast",
+  /** Output plain text as a string, or a file */
+  text: "text"
+};
+var InputFormat = {
+  bitmark: "bitmark",
+  bitmarkText: "bitmarkText",
+  plainText: "plainText",
+  html: "html"
+};
+var BitmarkVersion = {
+  v2: 2,
+  v3: 3
+};
+var CardSetVersion = {
+  v1: 1,
+  v2: 2
+};
+var BitmarkParserType = {
+  peggy: "peggy"
+};
+var InfoType = {
+  list: "list",
+  deprecated: "deprecated",
+  all: "all",
+  bit: "bit"
+};
+var InfoFormat = {
+  text: "text",
+  json: "json",
+  pojo: "pojo"
+};
+var BodyTextFormat = {
+  plainText: "text",
+  latex: "latex",
+  json: "json",
+  xml: "xml",
+  bitmarkPlusPlus: "bitmark++"
+};
+var TextLocation = {
+  tag: "tag",
+  body: "body"
+};
+
+// src/legacy/enums-extra.ts
+var TextMarkType = {
+  bold: "bold",
+  light: "light",
+  italic: "italic",
+  highlight: "highlight",
+  highlightOrange: "highlightOrange",
+  highlightYellow: "highlightYellow",
+  highlightGreen: "highlightGreen",
+  highlightBlue: "highlightBlue",
+  highlightPurple: "highlightPurple",
+  highlightPink: "highlightPink",
+  highlightBrown: "highlightBrown",
+  highlightBlack: "highlightBlack",
+  highlightWhite: "highlightWhite",
+  highlightGray: "highlightGray",
+  strike: "strike",
+  subscript: "subscript",
+  superscript: "superscript",
+  ins: "ins",
+  del: "del",
+  underline: "underline",
+  doubleUnderline: "doubleUnderline",
+  circle: "circle",
+  languageEmRed: "languageEmRed",
+  languageEmOrange: "languageEmOrange",
+  languageEmYellow: "languageEmYellow",
+  languageEmGreen: "languageEmGreen",
+  languageEmBlue: "languageEmBlue",
+  languageEmPurple: "languageEmPurple",
+  languageEmPink: "languageEmPink",
+  languageEmBrown: "languageEmBrown",
+  languageEmBlack: "languageEmBlack",
+  languageEmWhite: "languageEmWhite",
+  languageEmGray: "languageEmGray",
+  languageEm: "languageEm",
+  userUnderline: "userUnderline",
+  userDoubleUnderline: "userDoubleUnderline",
+  userStrike: "userStrike",
+  userCircle: "userCircle",
+  userHighlight: "userHighlight",
+  notranslate: "notranslate",
+  link: "link",
+  ref: "ref",
+  xref: "xref",
+  extref: "extref",
+  footnote: "footnote",
+  footnoteStar: "footnote*",
+  symbol: "symbol",
+  var: "var",
+  code: "code",
+  timer: "timer",
+  duration: "duration",
+  color: "color",
+  colorPicker: "colorPicker",
+  comment: "comment"
+};
+var TextNodeType = {
+  text: "text",
+  hardBreak: "hardBreak",
+  paragraph: "paragraph",
+  heading: "heading",
+  section: "section",
+  noBulletList: "noBulletList",
+  bulletList: "bulletList",
+  orderedList: "orderedList",
+  orderedListRoman: "orderedListRoman",
+  orderedListRomanLower: "orderedListRomanLower",
+  letteredList: "letteredList",
+  letteredListLower: "letteredListLower",
+  taskList: "taskList",
+  listItem: "listItem",
+  taskItem: "taskItem",
+  image: "image",
+  imageInline: "imageInline",
+  codeBlock: "codeBlock",
+  latex: "latex",
+  gap: "gap",
+  select: "select",
+  highlight: "highlight",
+  mark: "mark"
+};
+function bitNameToKey(name) {
+  return name.replace(/-([a-z0-9])/gu, (_, c) => c.toUpperCase());
+}
+var bitTypeCache;
+function loadBitTypes() {
+  if (!bitTypeCache) {
+    const wasm2 = getLegacyWasm();
+    const all = JSON.parse(wasm2.info("all", "json", "", false, 2));
+    const map = { _standard: "_standard" };
+    for (const { name } of all) {
+      map[bitNameToKey(name)] = name;
+    }
+    bitTypeCache = map;
+  }
+  return bitTypeCache;
+}
+var BitType = new Proxy(
+  {},
+  {
+    get: (_t, prop) => typeof prop === "string" ? loadBitTypes()[prop] : void 0,
+    has: (_t, prop) => typeof prop === "string" && prop in loadBitTypes(),
+    ownKeys: () => Reflect.ownKeys(loadBitTypes()),
+    getOwnPropertyDescriptor: (_t, prop) => typeof prop === "string" && prop in loadBitTypes() ? { value: loadBitTypes()[prop], enumerable: true, configurable: true, writable: false } : void 0
+  }
+);
+function unsupportedEnum(name, reason) {
+  return new Proxy(
+    {},
+    {
+      get: (_t, prop) => {
+        if (prop === Symbol.toPrimitive || prop === "toString" || prop === Symbol.toStringTag) {
+          return () => `[unsupported ${name}]`;
+        }
+        return unsupportedMember(name, reason);
+      },
+      has: () => unsupportedMember(name, reason),
+      ownKeys: () => unsupportedMember(name, reason)
+    }
+  );
+}
+var NodeType = unsupportedEnum(
+  "NodeType",
+  "it names bpg's internal AST nodes; the legacy AST is bit JSON (see createAst)"
+);
+var BoundingBoxIndex = unsupportedEnum(
+  "BoundingBoxIndex",
+  "bpg-internal bounding-box utility"
+);
+
+// src/legacy/stubs.ts
+function stubClass(name, reason) {
+  return class {
+    constructor() {
+      unsupportedMember(name, reason);
+    }
+  };
+}
+var WALKER_REASON = "the legacy AST is bit JSON, not bpg's internal node model; walking it with bpg NodeType names would silently misbehave";
+var INTERNAL_REASON = "internal class of bpg's TS implementation";
+var Ast = stubClass("Ast", WALKER_REASON);
+var BitmarkGenerator = stubClass("BitmarkGenerator", INTERNAL_REASON);
+var BitmarkStringGenerator = stubClass("BitmarkStringGenerator", INTERNAL_REASON);
+var BitmarkFileGenerator = stubClass("BitmarkFileGenerator", INTERNAL_REASON);
+var JsonGenerator = stubClass("JsonGenerator", INTERNAL_REASON);
+var JsonStringGenerator = stubClass("JsonStringGenerator", INTERNAL_REASON);
+var JsonFileGenerator = stubClass("JsonFileGenerator", INTERNAL_REASON);
+var HtmlTableGenerator = stubClass("HtmlTableGenerator", INTERNAL_REASON);
+var HtmlTableParser = stubClass("HtmlTableParser", INTERNAL_REASON);
+var BitmarkParser = stubClass("BitmarkParser", INTERNAL_REASON);
+var JsonParser = stubClass("JsonParser", INTERNAL_REASON);
+var StringWriter = stubClass("StringWriter", INTERNAL_REASON);
+var FileWriter = stubClass("FileWriter", INTERNAL_REASON);
+var StreamWriter = stubClass("StreamWriter", INTERNAL_REASON);
+
+// src/legacy-entry.ts
+var require2 = createRequire(import.meta.url);
+var wasm = require2("../wasm/bitmark_wasm.js");
+initLegacyNode(wasm);
+export {
+  Ast,
+  BitType,
+  BitmarkFileGenerator,
+  BitmarkGenerator,
+  BitmarkParser,
+  BitmarkParserGenerator,
+  BitmarkParserType,
+  BitmarkStringGenerator,
+  BitmarkVersion,
+  BodyTextFormat,
+  BoundingBoxIndex,
+  Builder,
+  CardSetVersion,
+  FileWriter,
+  HtmlTableGenerator,
+  HtmlTableParser,
+  InfoFormat,
+  InfoType,
+  Input,
+  InputFormat,
+  JsonFileGenerator,
+  JsonGenerator,
+  JsonParser,
+  JsonStringGenerator,
+  LegacyUnsupportedError,
+  NodeType,
+  Output,
+  ResourceBuilder,
+  StreamWriter,
+  StringWriter,
+  TextLocation,
+  TextMarkType,
+  TextNodeType,
+  bitmarkTextParse,
+  isPseudoAst
+};
+//# sourceMappingURL=legacy.js.map