@ai-matrx/rich-content 0.0.0-stage → 0.2.2

package/dist/markdown-core/syntax/prepare-syntax-source.js

@@ -0,0 +1,78 @@
+import { resolveCalloutType } from "./callout-types.js";
+import { CONTAINER_DIRECTIVES } from "./names.js";
+import { fenceLineKinds } from "@ai-matrx/content-ir/source";
+const MKDOCS_OPEN = /^(!!!|\?\?\?\+?)[ \t]+([A-Za-z][\w-]*)(?:[ \t]+[\w-]+)*(?:[ \t]+"((?:[^"\\]|\\.)*)")?[ \t]*$/;
+const DOCUSAURUS_TITLED = /^(:{3,})([A-Za-z][\w-]*)[ \t]+([^\s{[][^\n]*?)[ \t]*$/;
+const INDENT = /^(?: {4}|\t|(?:\u00A0){8})/;
+const BLANKISH = /^[ \t\u00A0]*$|^ $/;
+function escapeLabel(text) {
+  return text.replace(/\\"/g, '"').replace(/([[\]])/g, "\\$1");
+}
+function longestColonRun(lines) {
+  let max = 0;
+  for (const line of lines) {
+    const m = /^[ \t]*(:{3,})/.exec(line);
+    if (m && m[1].length > max) max = m[1].length;
+  }
+  return max;
+}
+function rewriteContainerSpellings(source) {
+  if (!source || !source.includes("!!!") && !source.includes("???") && !source.includes(":::")) {
+    return source;
+  }
+  const lines = source.split("\n");
+  const kinds = fenceLineKinds(source);
+  const out = [];
+  let changed = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    if (kinds[i] !== "prose") {
+      out.push(line);
+      continue;
+    }
+    const mk = MKDOCS_OPEN.exec(line);
+    if (mk && resolveCalloutType(mk[2])) {
+      const opener = mk[1];
+      const type = mk[2].toLowerCase();
+      const title = mk[3];
+      const body = [];
+      let j = i + 1;
+      while (j < lines.length) {
+        const candidate = lines[j] ?? "";
+        if (INDENT.test(candidate)) {
+          body.push(candidate.replace(INDENT, ""));
+          j++;
+          continue;
+        }
+        if (BLANKISH.test(candidate)) {
+          let k = j;
+          while (k < lines.length && BLANKISH.test(lines[k] ?? "")) k++;
+          if (k < lines.length && INDENT.test(lines[k] ?? "")) {
+            for (let b = j; b < k; b++) body.push("");
+            j = k;
+            continue;
+          }
+        }
+        break;
+      }
+      const colons = ":".repeat(Math.max(3, longestColonRun(body) + 1));
+      const label = title && title.length > 0 ? `[${escapeLabel(title)}]` : "";
+      const attrs = opener === "???" ? "{fold}" : opener === "???+" ? "{fold=open}" : "";
+      out.push(`${colons}${type}${label}${attrs}`, ...body, colons);
+      i = j - 1;
+      changed = true;
+      continue;
+    }
+    const docu = DOCUSAURUS_TITLED.exec(line);
+    if (docu && (resolveCalloutType(docu[2]) || CONTAINER_DIRECTIVES.has(docu[2].toLowerCase()))) {
+      out.push(`${docu[1]}${docu[2]}[${escapeLabel(docu[3])}]`);
+      changed = true;
+      continue;
+    }
+    out.push(line);
+  }
+  return changed ? out.join("\n") : source;
+}
+export {
+  rewriteContainerSpellings
+};

package/dist/markdown-core/syntax/rehype-matrx-syntax.d.ts

@@ -0,0 +1,9 @@
+import type { Root } from "hast";
+import type { DocumentNumbering } from "./document-numbering.js";
+export interface RehypeMatrxSyntaxOptions {
+    /** The whole document's numbering — footnotes are numbered document-wide from it. */
+    numbering?: DocumentNumbering | null;
+}
+export default function rehypeMatrxSyntax(options?: RehypeMatrxSyntaxOptions): (tree: Root) => void;
+/** The prefix GitHub puts on every id an author controls. */
+export declare const USER_ID_PREFIX = "user-content-";

package/dist/markdown-core/syntax/rehype-matrx-syntax.js

@@ -0,0 +1,180 @@
+import { toString as hastToString } from "hast-util-to-string";
+const HEADINGS = /* @__PURE__ */ new Set(["h1", "h2", "h3", "h4", "h5", "h6"]);
+function isElement(node) {
+  return node.type === "element";
+}
+function walk(node, visit) {
+  for (const child of node.children) {
+    if (isElement(child)) {
+      visit(child, node);
+      walk(child, visit);
+    }
+  }
+}
+function classList(el) {
+  const cls = el.properties?.className;
+  if (Array.isArray(cls)) return cls.map(String);
+  return typeof cls === "string" ? String(cls).split(/\s+/) : [];
+}
+const ANCHOR_CLASS = [
+  "matrx-heading-anchor",
+  "relative",
+  "left-2",
+  "inline-block",
+  "w-0",
+  "whitespace-nowrap",
+  "[@media(hover:none)]:hidden",
+  "select-none",
+  "text-[0.8em]",
+  "font-normal",
+  "text-muted-foreground",
+  "no-underline",
+  "opacity-0",
+  "transition-opacity",
+  "hover:text-primary",
+  "focus:opacity-100",
+  "[:hover>&]:opacity-100",
+  "after:content-['#']"
+];
+function tocList(entries) {
+  const min = Math.min(...entries.map((e) => e.depth));
+  const root = { type: "element", tagName: "ol", properties: { className: ["matrx-toc-list", "space-y-0.5"] }, children: [] };
+  const stack = [{ depth: min, list: root }];
+  for (const entry of entries) {
+    while (stack.length > 1 && entry.depth < stack[stack.length - 1].depth) stack.pop();
+    let top = stack[stack.length - 1];
+    if (entry.depth > top.depth) {
+      const nested = { type: "element", tagName: "ol", properties: { className: ["ml-4", "mt-0.5", "space-y-0.5"] }, children: [] };
+      const lastItem = top.list.children[top.list.children.length - 1];
+      if (lastItem && isElement(lastItem)) lastItem.children.push(nested);
+      else top.list.children.push(nested);
+      stack.push({ depth: entry.depth, list: nested });
+      top = stack[stack.length - 1];
+    }
+    top.list.children.push({
+      type: "element",
+      tagName: "li",
+      properties: {},
+      children: [
+        {
+          type: "element",
+          tagName: "a",
+          properties: { href: `#${entry.id}`, className: ["text-foreground/80", "hover:text-primary", "no-underline"] },
+          children: [{ type: "text", value: entry.text }]
+        }
+      ]
+    });
+  }
+  return root;
+}
+function rehypeMatrxSyntax(options = {}) {
+  const numbering = options.numbering ?? null;
+  return (tree) => {
+    const headings = [];
+    const tocs = [];
+    let taskIndex = 0;
+    walk(tree, (el) => {
+      if (HEADINGS.has(el.tagName)) {
+        const id = el.properties?.id;
+        if (typeof id === "string" && id !== "footnote-label" && !classList(el).includes("sr-only")) {
+          headings.push({ id, depth: Number(el.tagName.slice(1)), text: hastToString(el).trim() });
+          el.children.push({
+            type: "element",
+            tagName: "a",
+            // data-content-chrome: renderer-added UI, not the source's words (the annotation text mapper skips it).
+            // The "#" is drawn by CSS and the link is hidden from assistive
+            // tech: it used to join the heading's accessible name and copied
+            // text ("Clinic intake checklist#"). The heading's id stays the
+            // link target; the hover "#" is a mouse convenience.
+            properties: { href: `#${id}`, className: ANCHOR_CLASS, ariaHidden: "true", tabIndex: -1, title: "Link to this section", dataHeadingAnchor: true, dataContentChrome: true },
+            children: []
+          });
+        }
+        return;
+      }
+      if (el.tagName === "matrx-toc") {
+        tocs.push(el);
+        return;
+      }
+      if (el.tagName === "li" && classList(el).includes("task-list-item")) {
+        const input = findCheckbox(el);
+        if (input) {
+          input.properties = {
+            ...input.properties,
+            dataTaskIndex: taskIndex++,
+            dataTaskText: taskText(el)
+          };
+        }
+        return;
+      }
+      if (el.tagName === "section" && el.properties?.dataFootnotes !== void 0) {
+        el.properties = {
+          ...el.properties,
+          className: [...classList(el), "matrx-footnotes", "mt-6", "border-t", "border-border", "pt-3", "text-sm", "text-muted-foreground"]
+        };
+      }
+    });
+    for (const toc of tocs) {
+      const entries = headings.filter((h) => h.depth <= 4);
+      toc.properties = { ...toc.properties, dataTocCount: entries.length };
+      toc.children = entries.length > 0 ? [tocList(entries)] : [];
+    }
+    if (numbering && numbering.footnotes.size > 0) numberFootnotes(tree, numbering.footnotes);
+    prefixAuthorIds(tree);
+  };
+}
+const FN_PREFIX = "user-content-fn-";
+function footnoteId(href) {
+  const at = href.indexOf(FN_PREFIX);
+  if (at < 0) return null;
+  try {
+    return decodeURIComponent(href.slice(at + FN_PREFIX.length)).toLowerCase();
+  } catch {
+    return href.slice(at + FN_PREFIX.length).toLowerCase();
+  }
+}
+function numberFootnotes(tree, numbers) {
+  walk(tree, (el) => {
+    if (el.tagName === "a" && el.properties?.dataFootnoteRef !== void 0) {
+      const id = footnoteId(String(el.properties?.href ?? ""));
+      const n = id ? numbers.get(id) : void 0;
+      if (n !== void 0) el.children = [{ type: "text", value: String(n) }];
+      return;
+    }
+    if (el.tagName === "li") {
+      const id = footnoteId(String(el.properties?.id ?? ""));
+      const n = id ? numbers.get(id) : void 0;
+      if (n !== void 0) el.properties = { ...el.properties, value: String(n) };
+    }
+  });
+}
+const USER_ID_PREFIX = "user-content-";
+function prefixAuthorIds(tree) {
+  walk(tree, (el) => {
+    const id = el.properties?.id;
+    if (typeof id !== "string" || !id || id === "footnote-label" || id.startsWith(USER_ID_PREFIX)) return;
+    el.properties = { ...el.properties, id: `${USER_ID_PREFIX}${id}` };
+  });
+}
+function findCheckbox(li) {
+  for (const child of li.children) {
+    if (!isElement(child)) continue;
+    if (child.tagName === "input" && child.properties?.type === "checkbox") return child;
+    if (child.tagName === "p") {
+      const inner = findCheckbox(child);
+      if (inner) return inner;
+    }
+  }
+  return null;
+}
+function taskText(li) {
+  const own = {
+    ...li,
+    children: li.children.filter((c) => !(isElement(c) && (c.tagName === "ul" || c.tagName === "ol")))
+  };
+  return hastToString(own).replace(/\s+/g, " ").trim();
+}
+export {
+  USER_ID_PREFIX,
+  rehypeMatrxSyntax as default
+};

package/dist/markdown-core/syntax/remark-inline-only.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Parse INLINE constructs only — what a GFM table cell is (verify-RC-B4 R6-1).
+ *
+ * GFM splits a table row into cells and parses each cell's text as INLINE
+ * content: `> 90%` is the text "> 90%", `- n/a` is "- n/a", `# 3` is "# 3",
+ * `1. first` is "1. first". The inline level of <RichContent> parses its source
+ * as a document (then draws block elements as spans), so a cell starting with
+ * block syntax lost its first characters. This turns every block-level
+ * construct off in the parser for that one source, so the core reads a cell
+ * exactly as GFM does — no stripping, no escaping of the source.
+ *
+ * Used by the `chat-cell` preset (markdown-core-presets.ts), reached through
+ * `<RichContent level="inline" gfmCell>`.
+ */
+type ProcessorData = {
+    micromarkExtensions?: unknown[];
+};
+/** Block constructs a table cell never contains (names from micromark and its extensions). */
+export declare const BLOCK_CONSTRUCTS: readonly ["blockQuote", "codeFenced", "codeIndented", "definition", "headingAtx", "htmlFlow", "list", "setextUnderline", "thematicBreak", "gfmFootnoteDefinition", "mathFlow", "directiveContainer", "directiveLeaf", "frontmatter", "table"];
+export default function remarkInlineOnly(this: {
+    data: () => ProcessorData;
+}): void;
+export {};

package/dist/markdown-core/syntax/remark-inline-only.js

@@ -0,0 +1,25 @@
+const BLOCK_CONSTRUCTS = [
+  "blockQuote",
+  "codeFenced",
+  "codeIndented",
+  "definition",
+  "headingAtx",
+  "htmlFlow",
+  "list",
+  "setextUnderline",
+  "thematicBreak",
+  "gfmFootnoteDefinition",
+  "mathFlow",
+  "directiveContainer",
+  "directiveLeaf",
+  "frontmatter",
+  "table"
+];
+function remarkInlineOnly() {
+  const data = this.data();
+  (data.micromarkExtensions ??= []).push({ disable: { null: [...BLOCK_CONSTRUCTS] } });
+}
+export {
+  BLOCK_CONSTRUCTS,
+  remarkInlineOnly as default
+};

package/dist/markdown-core/syntax/remark-matrx-syntax.d.ts

@@ -0,0 +1,7 @@
+import { type DocumentNumbering } from "./document-numbering.js";
+import { type MNode, type SyntaxFile } from "./mdast-helpers.js";
+export interface RemarkMatrxSyntaxOptions {
+    /** The whole document's numbering (computeDocumentNumbering), when this tree is one block of it. */
+    numbering?: DocumentNumbering | null;
+}
+export default function remarkMatrxSyntax(options?: RemarkMatrxSyntaxOptions): (tree: MNode, file: SyntaxFile) => void;

package/dist/markdown-core/syntax/remark-matrx-syntax.js

@@ -0,0 +1,351 @@
+import { isTocLine } from "@ai-matrx/print/directives";
+import { extractFrontmatter } from "./frontmatter.js";
+import { captionKey, DOCUMENT_FOOTNOTES_MARKER } from "./document-numbering.js";
+import { transformContainers } from "./containers.js";
+import { trailingHeadingId } from "./linear-scan.js";
+import { transformMentions } from "./mentions.js";
+import { transformInline } from "./inline-syntax.js";
+import { el, rawOf, text, toText, walkParents } from "./mdast-helpers.js";
+function stripFrontmatter(tree, file) {
+  const children = tree.children ?? [];
+  const first = children[0];
+  if (!first || first.type !== "yaml" && first.type !== "toml") return;
+  tree.children = children.slice(1);
+  if (file) {
+    const source = typeof file.value === "string" ? file.value : "";
+    file.data = { ...file.data ?? {}, matrxFrontmatter: extractFrontmatter(source) };
+  }
+}
+const DEFLIST_ELEMENTS = {
+  defList: { tag: "dl", className: ["matrx-dl", "my-3", "space-y-1"] },
+  defListTerm: { tag: "dt", className: ["font-semibold", "text-foreground"] },
+  defListDescription: { tag: "dd", className: ["ml-5", "mb-2", "text-foreground/90", "[&>p]:mb-1"] }
+};
+function tagDefinitionLists(tree) {
+  walkParents(tree, (parent) => {
+    for (const child of parent.children ?? []) {
+      const spec = DEFLIST_ELEMENTS[child.type];
+      if (spec) child.data = { ...child.data ?? {}, hName: spec.tag, hProperties: { className: spec.className } };
+    }
+  });
+}
+const ABBR_LINE = /^\*\[([^\]\n]+)\]:[ \t]*(\S[^\n]*)$/;
+function collectAbbreviations(tree, file) {
+  const found = /* @__PURE__ */ new Map();
+  walkParents(tree, (parent) => {
+    const kept = [];
+    let removed = false;
+    for (const child of parent.children ?? []) {
+      if (child.type === "paragraph") {
+        const raw = rawOf(child, file) ?? toText(child);
+        const lines = raw.split("\n").map((l) => l.trim()).filter(Boolean);
+        const parsed = lines.map((l) => ABBR_LINE.exec(l));
+        if (lines.length > 0 && parsed.every(Boolean)) {
+          for (const m of parsed) if (m) found.set((m[1] ?? "").trim(), (m[2] ?? "").trim());
+          removed = true;
+          continue;
+        }
+      }
+      kept.push(child);
+    }
+    if (removed) parent.children = kept;
+  });
+  return found;
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function applyAbbreviations(tree, abbrs) {
+  if (abbrs.size === 0) return;
+  const keys = [...abbrs.keys()].sort((a, b) => b.length - a.length).map(escapeRegExp);
+  const re = new RegExp(`(?<![\\w])(${keys.join("|")})(?![\\w])`, "g");
+  const visit = (node) => {
+    if (!node.children || node.type === "link" || node.type === "inlineCode" || node.data?.hName === "abbr") return;
+    const next = [];
+    let changed = false;
+    for (const child of node.children) {
+      if (child.type !== "text") {
+        visit(child);
+        next.push(child);
+        continue;
+      }
+      const value = child.value ?? "";
+      let pos = 0;
+      re.lastIndex = 0;
+      let m;
+      while ((m = re.exec(value)) !== null) {
+        if (m.index > pos) next.push(text(value.slice(pos, m.index)));
+        next.push(el("abbr", { title: abbrs.get(m[1] ?? ""), className: ["cursor-help", "underline", "decoration-dotted", "underline-offset-2"] }, [text(m[1] ?? "")]));
+        pos = m.index + m[0].length;
+        changed = true;
+      }
+      if (pos === 0) next.push(child);
+      else if (pos < value.length) next.push(text(value.slice(pos)));
+    }
+    if (changed) node.children = next;
+  };
+  visit(tree);
+}
+function applyHeadingIds(tree) {
+  walkParents(tree, (parent) => {
+    for (const child of parent.children ?? []) {
+      if (child.type !== "heading") continue;
+      const last = child.children?.[child.children.length - 1];
+      if (!last || last.type !== "text") continue;
+      const m = trailingHeadingId(last.value ?? "");
+      if (!m) continue;
+      last.value = (last.value ?? "").slice(0, m.index);
+      child.data = {
+        ...child.data ?? {},
+        hProperties: { ...child.data?.hProperties ?? {}, id: m.id }
+      };
+    }
+  });
+}
+function titledImageFigures(tree) {
+  const visit = (parent) => {
+    const children = parent.children;
+    if (!children || parent.type === "matrxFigure") return;
+    for (let i = 0; i < children.length; i++) {
+      const child = children[i];
+      if (child.type === "paragraph") {
+        const meaningful = (child.children ?? []).filter((n) => !(n.type === "text" && !(n.value ?? "").trim()));
+        const only = meaningful.length === 1 ? meaningful[0] : null;
+        const title = only?.type === "image" && typeof only.title === "string" ? only.title.trim() : "";
+        if (only && title) {
+          const figure = el("figure", { className: ["matrx-figure", "my-4", "text-center"] }, [only], "matrxFigure");
+          figure.matrxFigure = { kind: "fig", caption: [text(title)], id: null };
+          figure.position = child.position;
+          children[i] = figure;
+          continue;
+        }
+      }
+      visit(child);
+    }
+  };
+  visit(tree);
+}
+function setMathValue(node, value) {
+  const previous = node.value;
+  node.value = value;
+  const patch = (list) => {
+    for (const child of list ?? []) {
+      const c = child;
+      if (c.type === "text" && c.value === previous) c.value = value;
+      patch(c.children);
+    }
+  };
+  patch(node.data?.hChildren);
+}
+const LABEL_RE = /\\label\{([^{}]+)\}/g;
+const TAG_RE = /\\tag\*?\{([^{}]*)\}/;
+function numberTargets(tree, numbering) {
+  const xrefs = new Map(numbering ? numbering.byLabel : []);
+  const captionCursor = /* @__PURE__ */ new Map();
+  let figures = 0;
+  let tables = 0;
+  let equations = 0;
+  const visit = (parent) => {
+    const children = parent.children;
+    if (!children) return;
+    for (let i = 0; i < children.length; i++) {
+      const child = children[i];
+      const meta = child.matrxFigure;
+      if (meta) {
+        const n = meta.kind === "fig" ? ++figures : ++tables;
+        const word = meta.kind === "fig" ? "Figure" : "Table";
+        let display = `${word} ${n}`;
+        if (numbering) {
+          if (meta.id) display = numbering.byLabel.get(meta.id)?.display ?? display;
+          else {
+            const key = captionKey(meta.kind, toText({ type: "root", children: meta.caption }));
+            const seen = captionCursor.get(key) ?? 0;
+            const global = numbering.byCaption.get(key)?.[seen];
+            captionCursor.set(key, seen + 1);
+            if (global) display = global;
+          }
+        }
+        if (meta.id) xrefs.set(meta.id, { kind: meta.kind, display });
+        const hp = child.data?.hProperties ?? {};
+        child.data = { ...child.data ?? {}, hProperties: { ...hp, dataXrefLabel: display } };
+        const caption = el(
+          "figcaption",
+          { className: ["mt-1.5", "text-center", "text-sm", "text-muted-foreground"] },
+          [el("span", { className: ["font-semibold", "text-foreground"], dataContentChrome: true }, [text(`${display}.`)]), ...meta.caption.length > 0 ? [text(" "), ...meta.caption] : []]
+        );
+        const body = child.children ?? [];
+        child.children = meta.kind === "tbl" ? [caption, ...body] : [...body, caption];
+        delete child.matrxFigure;
+      }
+      if (child.type === "heading") {
+        const id = child.data?.hProperties?.id;
+        if (typeof id === "string" && id.startsWith("sec:")) {
+          xrefs.set(id, { kind: "sec", display: toText(child).trim() });
+        }
+      }
+      if (child.type === "math" && typeof child.value === "string" && child.value.includes("\\label")) {
+        const labels = [...child.value.matchAll(LABEL_RE)].map((m) => (m[1] ?? "").trim());
+        const explicit = TAG_RE.exec(child.value);
+        let number;
+        if (explicit) {
+          number = explicit[1] ?? "";
+          setMathValue(child, child.value.replace(LABEL_RE, ""));
+        } else {
+          const local = String(++equations);
+          const global = labels[0] ? numbering?.byLabel.get(labels[0]) : void 0;
+          number = global?.kind === "eq" ? global.display.replace(/[()]/g, "") : local;
+          let first = true;
+          setMathValue(
+            child,
+            child.value.replace(LABEL_RE, () => {
+              if (!first) return "";
+              first = false;
+              return `\\tag{${number}}`;
+            })
+          );
+        }
+        const display = `(${number})`;
+        const label = labels[0];
+        if (label) {
+          xrefs.set(label, { kind: "eq", display });
+          children.splice(i, 0, el("span", { id: label, className: ["matrx-eq-anchor", "block", "h-0"], dataXrefLabel: `Equation ${display}` }));
+          i++;
+        }
+      }
+      visit(child);
+    }
+  };
+  visit(tree);
+  return xrefs;
+}
+function resolveMathRefs(tree, xrefs) {
+  const visit = (node) => {
+    if ((node.type === "math" || node.type === "inlineMath") && typeof node.value === "string" && /\\(eq)?ref\{/.test(node.value)) {
+      setMathValue(
+        node,
+        node.value.replace(/\\(eqref|ref)\{([^{}]+)\}/g, (_m, kind, label) => {
+          const target = xrefs.get(label.trim());
+          const shown = target ? target.display.replace(/[()]/g, "") : "??";
+          return kind === "eqref" ? `\\text{(${shown})}` : `\\text{${shown}}`;
+        })
+      );
+    }
+    node.children?.forEach(visit);
+  };
+  visit(tree);
+}
+function applyTocMarkers(tree, file) {
+  walkParents(tree, (parent) => {
+    const children = parent.children ?? [];
+    for (let i = 0; i < children.length; i++) {
+      const child = children[i];
+      if (child.type !== "paragraph" && child.type !== "html") continue;
+      const raw = rawOf(child, file) ?? (child.type === "html" ? child.value ?? "" : toText(child));
+      if (!raw.includes("\n") && isTocLine(raw)) children[i] = el("matrx-toc", {}, [], "matrxToc");
+    }
+  });
+}
+function applyCsvFences(tree) {
+  walkParents(tree, (parent) => {
+    const children = parent.children ?? [];
+    for (let i = 0; i < children.length; i++) {
+      const child = children[i];
+      if (child.type !== "code") continue;
+      const lang = (child.lang ?? "").toLowerCase();
+      if (lang !== "csv" && lang !== "tsv") continue;
+      children[i] = el("matrx-csv", { dataSource: child.value ?? "", dataDelimiter: lang === "tsv" ? "tab" : "comma" }, [], "matrxCsv");
+    }
+  });
+}
+function footnoteIds(tree) {
+  const defined = /* @__PURE__ */ new Set();
+  const referenced = /* @__PURE__ */ new Set();
+  const visit = (node) => {
+    if (node.type === "footnoteDefinition" && node.identifier) defined.add(node.identifier.toLowerCase());
+    if (node.type === "footnoteReference" && node.identifier) referenced.add(node.identifier.toLowerCase());
+    node.children?.forEach(visit);
+  };
+  visit(tree);
+  return { defined, referenced };
+}
+function renderFootnoteSection(tree, numbers) {
+  if (!numbers) return;
+  const children = tree.children ?? [];
+  const isSection = children.some((c) => c.type === "html" && (c.value ?? "").trim() === DOCUMENT_FOOTNOTES_MARKER);
+  const notes = [];
+  const kept = [];
+  for (const child of children) {
+    if (child.type === "html" && (child.value ?? "").trim() === DOCUMENT_FOOTNOTES_MARKER) continue;
+    const n = child.type === "footnoteDefinition" && child.identifier ? numbers.get(child.identifier.toLowerCase()) : void 0;
+    if (n === void 0) {
+      kept.push(child);
+      continue;
+    }
+    if (isSection && !notes.some((note) => note.n === n)) notes.push({ n, def: child });
+  }
+  tree.children = kept;
+  if (notes.length === 0) return;
+  notes.sort((a, b) => a.n - b.n);
+  const items = notes.map(({ n, def }) => {
+    const id = encodeURIComponent((def.identifier ?? "").toLowerCase());
+    const back = el(
+      "a",
+      { href: `#user-content-fnref-${id}`, dataFootnoteBackref: "", ariaLabel: `Back to reference ${n}`, className: ["data-footnote-backref"] },
+      [text("\u21A9")]
+    );
+    const body = [...def.children ?? []];
+    const tail = body[body.length - 1];
+    if (tail?.type === "paragraph") {
+      body[body.length - 1] = { ...tail, children: [...tail.children ?? [], text(" "), back] };
+    } else {
+      body.push(back);
+    }
+    return el("li", { id: `user-content-fn-${id}`, value: n }, body);
+  });
+  tree.children.push(
+    el("section", { dataFootnotes: true, className: ["footnotes"] }, [
+      el("h2", { id: "footnote-label", className: ["sr-only"] }, [text("Footnotes")]),
+      el("ol", {}, items)
+    ])
+  );
+}
+function unwrapStandaloneEmbeds(tree) {
+  walkParents(tree, (parent) => {
+    const children = parent.children ?? [];
+    for (let i = 0; i < children.length; i++) {
+      const child = children[i];
+      if (child.type !== "paragraph") continue;
+      const meaningful = (child.children ?? []).filter((n) => !(n.type === "text" && !(n.value ?? "").trim()));
+      const only = meaningful.length === 1 ? meaningful[0] : null;
+      if (only?.data?.hName === "matrx-embed") {
+        only.data.hProperties = { ...only.data.hProperties ?? {}, dataBlock: true };
+        children[i] = only;
+      }
+    }
+  });
+}
+function remarkMatrxSyntax(options = {}) {
+  const numbering = options.numbering ?? null;
+  return (tree, file) => {
+    stripFrontmatter(tree, file);
+    transformContainers(tree, file);
+    tagDefinitionLists(tree);
+    const abbrs = collectAbbreviations(tree, file);
+    applyHeadingIds(tree);
+    applyTocMarkers(tree, file);
+    titledImageFigures(tree);
+    const xrefs = numberTargets(tree, numbering);
+    resolveMathRefs(tree, xrefs);
+    const { defined } = footnoteIds(tree);
+    const ctx = { xrefs, footnotes: defined, documentFootnotes: numbering?.footnotes };
+    transformMentions(tree);
+    transformInline(tree, ctx);
+    unwrapStandaloneEmbeds(tree);
+    applyAbbreviations(tree, abbrs);
+    applyCsvFences(tree);
+    renderFootnoteSection(tree, numbering?.footnotes ?? null);
+  };
+}
+export {
+  remarkMatrxSyntax as default
+};

package/dist/markdown-core/syntax/remark-table-code-pipes.d.ts

@@ -0,0 +1,7 @@
+type Node = {
+    type: string;
+    value?: string;
+    children?: Node[];
+};
+export default function remarkTableCodePipes(): (tree: Node) => void;
+export {};