@ai-matrx/rich-content 0.0.0 → 0.2.3

package/dist/markdown-core/syntax/frontmatter.js

@@ -0,0 +1,72 @@
+import { parse as parseYaml } from "yaml";
+import { parse as parseToml } from "smol-toml";
+const OPEN = { "---": "yaml", "+++": "toml" };
+function splitFrontmatter(source) {
+  if (!source) return null;
+  const bom = source.charCodeAt(0) === 65279 ? 1 : 0;
+  const firstBreak = source.indexOf("\n");
+  if (firstBreak < 0) return null;
+  const opener = source.slice(bom, firstBreak).replace(/\r$/, "");
+  const format = OPEN[opener];
+  if (!format) return null;
+  let pos = firstBreak + 1;
+  while (pos <= source.length) {
+    const next = source.indexOf("\n", pos);
+    const lineEnd = next < 0 ? source.length : next;
+    const line = source.slice(pos, lineEnd).replace(/\r$/, "");
+    if (line === opener || format === "yaml" && line === "...") {
+      const end = next < 0 ? source.length : next + 1;
+      return {
+        format,
+        raw: source.slice(0, end),
+        inner: source.slice(firstBreak + 1, pos).replace(/\r?\n$/, ""),
+        body: source.slice(end)
+      };
+    }
+    if (next < 0) break;
+    pos = next + 1;
+  }
+  return null;
+}
+function hasUnclosedFrontmatter(source) {
+  if (!/^(---|\+\+\+)(\r?\n|$)/.test(source)) return false;
+  return splitFrontmatter(source) === null;
+}
+const EMPTY = { properties: {}, format: null, raw: null, error: null };
+function extractFrontmatter(source) {
+  const split = splitFrontmatter(source);
+  if (!split) return EMPTY;
+  try {
+    const parsed = split.format === "yaml" ? parseYaml(split.inner) : parseToml(split.inner);
+    if (parsed === null || parsed === void 0) {
+      return { properties: {}, format: split.format, raw: split.raw, error: null };
+    }
+    if (typeof parsed !== "object" || Array.isArray(parsed)) {
+      return {
+        properties: {},
+        format: split.format,
+        raw: split.raw,
+        error: `The ${split.format.toUpperCase()} front matter is not a set of "key: value" properties.`
+      };
+    }
+    return {
+      properties: parsed,
+      format: split.format,
+      raw: split.raw,
+      error: null
+    };
+  } catch (err) {
+    const why = err instanceof Error ? err.message.split("\n")[0] : String(err);
+    return {
+      properties: {},
+      format: split.format,
+      raw: split.raw,
+      error: `The ${split.format.toUpperCase()} front matter could not be read: ${why}`
+    };
+  }
+}
+export {
+  extractFrontmatter,
+  hasUnclosedFrontmatter,
+  splitFrontmatter
+};

package/dist/markdown-core/syntax/gfm-cell-pipes.d.ts

@@ -0,0 +1,11 @@
+/**
+ * GFM's ONE table-cell rule for pipes (spec example 200; GitHub renders it so):
+ * a row is split into cells FIRST, then the `\|` that kept a pipe inside a
+ * cell is unescaped — inside code spans too. Every surface that shows a table
+ * cell goes through this: Studio/Preview (remark-table-code-pipes, on code in
+ * a table cell), the chat and artifact table (StreamingTableRenderer, on each
+ * cell's inline source before the inline core reads it) and the table writer's
+ * read-back (rich-editor/core/table-source). verify-RC-B4 R4-3, R5-2.
+ * The rule itself lives in @ai-matrx/content-ir/source; this is its door here.
+ */
+export { unescapeCellPipes } from "@ai-matrx/content-ir/source";

package/dist/markdown-core/syntax/gfm-cell-pipes.js

@@ -0,0 +1,4 @@
+import { unescapeCellPipes } from "@ai-matrx/content-ir/source";
+export {
+  unescapeCellPipes
+};

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

@@ -0,0 +1,26 @@
+import { KBD_CLASS } from "./containers.js";
+import { type MNode } from "./mdast-helpers.js";
+/** What the numbering pass knows about each label in this document. */
+export interface XrefTarget {
+    kind: "fig" | "tbl" | "eq" | "sec";
+    /** "Figure 2", "Table 1", "(3)", or the section's heading text. */
+    display: string;
+}
+export interface InlineContext {
+    xrefs: Map<string, XrefTarget>;
+    /** Footnote identifiers DEFINED in this tree (a `[^x]` left as text is defined elsewhere). */
+    footnotes: Set<string>;
+    /**
+     * The document's footnote numbers (DocumentNumbering.footnotes): a `[^x]`
+     * left as text becomes a reference only when the DOCUMENT defines and cites
+     * `x`; an undefined label stays text, as GFM leaves it.
+     */
+    documentFootnotes?: ReadonlyMap<string, number>;
+}
+export declare function xrefNode(label: string, kindHint: XrefTarget["kind"] | null, ctx: InlineContext, style: "at" | "eqref" | "ref"): MNode;
+/** Split one string into text + element nodes. */
+export declare function scanInline(value: string, ctx: InlineContext): MNode[] | null;
+/** Run the inline scanner over every eligible text node in the tree. */
+export declare function transformInline(node: MNode, ctx: InlineContext): void;
+/** `:kbd[…]`'s class, re-exported for the raw `<kbd>` default element. */
+export { KBD_CLASS };

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

@@ -0,0 +1,163 @@
+import { KBD_CLASS, MARK_CLASS } from "./containers.js";
+import { el, text } from "./mdast-helpers.js";
+const XREF_PREFIX = { fig: "fig", tbl: "tbl", eq: "eq", sec: "sec" };
+const XREF_WORD = { fig: "figure", tbl: "table", eq: "equation", sec: "section" };
+function xrefNode(label, kindHint, ctx, style) {
+  const target = ctx.xrefs.get(label);
+  const kind = target?.kind ?? kindHint ?? "sec";
+  let shown;
+  if (target) {
+    shown = style === "ref" && target.kind === "eq" ? target.display.replace(/[()]/g, "") : target.display;
+  } else {
+    shown = style === "at" ? `@${label}` : `(${label})`;
+  }
+  return el(
+    "matrx-xref",
+    {
+      href: `#${label}`,
+      dataXref: label,
+      dataXrefKind: kind,
+      dataXrefStyle: style,
+      dataXrefResolved: target ? "true" : "false",
+      title: target ? void 0 : `No ${XREF_WORD[kind]} labelled "${label}" in this document`
+    },
+    [text(shown)]
+  );
+}
+function wikiTarget(inner) {
+  const cut = inner.search(/\\?\|/);
+  if (cut < 0) return { target: inner.trim(), alias: null };
+  const sepLength = inner[cut] === "\\" ? 2 : 1;
+  return { target: inner.slice(0, cut).trim(), alias: inner.slice(cut + sepLength).trim() || null };
+}
+const RULES = [
+  {
+    // Wikilink / embed. Target: no brackets, no newline.
+    re: /(!?)\[\[([^[\]\n]+?)\]\]/g,
+    build: (m) => {
+      const { target, alias } = wikiTarget(m[2] ?? "");
+      if (!target) return null;
+      const embed = m[1] === "!";
+      return el(
+        embed ? "matrx-embed" : "matrx-wikilink",
+        { dataTarget: target, ...alias ? { dataAlias: alias } : {} },
+        [text(alias ?? target)]
+      );
+    }
+  },
+  {
+    re: /(^|[^\w@])@(fig|tbl|eq|sec):([\w.-]*[\w])/g,
+    build: (m, ctx) => {
+      const label = `${m[2]}:${m[3]}`;
+      return xrefNode(label, XREF_PREFIX[m[2] ?? ""] ?? null, ctx, "at");
+    }
+  },
+  {
+    re: /\\(eqref|ref)\{([^{}\s]+)\}/g,
+    build: (m, ctx) => xrefNode(m[2] ?? "", m[1] === "eqref" ? "eq" : null, ctx, m[1] === "eqref" ? "eqref" : "ref")
+  },
+  {
+    // ==highlight== — no space just inside either marker, never part of `===`.
+    re: /(?<![=\\])==(?=[^\s=])([^\n]*?[^\s=\\])==(?!=)/g,
+    build: (m) => el("mark", { className: MARK_CLASS }, [text(m[1] ?? "")], "matrxMark")
+  },
+  {
+    // x^2^ — Pandoc superscript: no whitespace inside.
+    re: /(?<![\\^])\^([^\s^]+?)\^/g,
+    build: (m) => el("sup", {}, [text(m[1] ?? "")], "matrxSup")
+  },
+  {
+    // H~2~O — Pandoc subscript (single tilde; GFM's ~~strike~~ is parsed first).
+    re: /(?<![\\~])~([^\s~]+?)~(?!~)/g,
+    build: (m) => el("sub", {}, [text(m[1] ?? "")], "matrxSub")
+  },
+  {
+    // A footnote reference whose definition lives in another rendered block
+    // (the document defines it; an undefined `[^x]` stays text).
+    re: /\[\^([^\]\s]+)\](?!:)/g,
+    build: (m, ctx) => {
+      const id = m[1] ?? "";
+      if (ctx.footnotes.has(id.toLowerCase()) || !ctx.documentFootnotes?.has(id.toLowerCase())) return null;
+      return el("sup", { className: ["matrx-fnref"] }, [
+        // The id is the note's back-link target when this is the first reference.
+        el("a", { href: `#user-content-fn-${encodeURIComponent(id.toLowerCase())}`, id: `user-content-fnref-${encodeURIComponent(id.toLowerCase())}`, dataFootnoteRef: true, ariaDescribedBy: "footnote-label" }, [text(id)])
+      ]);
+    }
+  }
+];
+function leadingContext(m, rule) {
+  return rule === RULES[1] ? m[1] ?? "" : "";
+}
+function scanInline(value, ctx) {
+  if (!value) return null;
+  if (!/[[=^~@\\]/.test(value)) return null;
+  const out = [];
+  let pos = 0;
+  let changed = false;
+  while (pos < value.length) {
+    let best = null;
+    for (const rule of RULES) {
+      rule.re.lastIndex = pos;
+      const m = rule.re.exec(value);
+      if (!m) continue;
+      const start2 = m.index + leadingContext(m, rule).length;
+      if (!best || start2 < best.m.index + leadingContext(best.m, best.rule).length) best = { m, rule };
+    }
+    if (!best) break;
+    const lead = leadingContext(best.m, best.rule);
+    const start = best.m.index + lead.length;
+    const end = best.m.index + best.m[0].length;
+    const node = best.rule.build(best.m, ctx);
+    if (!node) {
+      out.push(text(value.slice(pos, start + 1)));
+      pos = start + 1;
+      continue;
+    }
+    if (start > pos) out.push(text(value.slice(pos, start)));
+    if (node.type === "matrxMark" || node.type === "matrxSup" || node.type === "matrxSub") {
+      const inner = node.children?.[0]?.value ?? "";
+      const nested = scanInline(inner, ctx);
+      if (nested) node.children = nested;
+    }
+    out.push(node);
+    pos = end;
+    changed = true;
+  }
+  if (!changed) return null;
+  if (pos < value.length) out.push(text(value.slice(pos)));
+  const merged = [];
+  for (const n of out) {
+    const prev = merged[merged.length - 1];
+    if (n.type === "text" && prev?.type === "text") prev.value = (prev.value ?? "") + (n.value ?? "");
+    else merged.push(n);
+  }
+  return merged;
+}
+const SKIP_TYPES = /* @__PURE__ */ new Set(["link", "linkReference", "inlineCode", "code", "math", "inlineMath", "html", "matrxMark", "matrxSup", "matrxSub"]);
+const SKIP_ELEMENTS = /* @__PURE__ */ new Set(["matrx-wikilink", "matrx-embed", "matrx-xref", "matrx-mention", "a", "kbd", "code", "matrx-csv"]);
+function transformInline(node, ctx) {
+  const children = node.children;
+  if (!children || SKIP_TYPES.has(node.type)) return;
+  if (node.data?.hName && SKIP_ELEMENTS.has(node.data.hName)) return;
+  let next = null;
+  children.forEach((child, i) => {
+    if (child.type === "text") {
+      const replaced = scanInline(child.value ?? "", ctx);
+      if (replaced) {
+        next ??= children.slice(0, i);
+        next.push(...replaced);
+        return;
+      }
+    } else {
+      transformInline(child, ctx);
+    }
+    next?.push(child);
+  });
+  if (next) node.children = next;
+}
+export {
+  KBD_CLASS,
+  scanInline,
+  transformInline,
+  xrefNode
+};

package/dist/markdown-core/syntax/linear-scan.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Linear-time stand-ins for regexes on the markdown render hot path that
+ * backtracked super-linearly (kind-never-raw round 11, F1 sweep). Each
+ * function is EXACTLY the regex named in its doc (differentially fuzzed
+ * against it) and runs in time linear in its input. Guard:
+ * `components/markdown-core/__tests__/regex-linear-time.guard.test.ts`.
+ */
+/** Exactly `text.replace(/[ \t]+$/, "")`. */
+export declare function trimTrailingSpaceTab(text: string): string;
+/**
+ * Exactly `/[ \t]*\{#([\w:.-]+)\}[ \t]*$/.exec(text)` as `{ index, id }`: a
+ * trailing `{#id}` attribute (an id never holds `{` or `}`, so it is the LAST
+ * `{#`), its match starting at the spaces before it.
+ */
+export declare function trailingHeadingId(text: string): {
+    index: number;
+    id: string;
+} | null;
+/**
+ * Exactly `/^#{1,6}[ \t]+(.*?)[ \t]*\{#(sec:[\w:.-]+)\}[ \t]*$/.exec(line)` as
+ * `[title, id]` (title = capture 1, the spaces around it excluded).
+ */
+export declare function sectionHeading(line: string): [string, string] | null;
+/**
+ * Exactly capture 1 of `/^(#{1,6}[ \t].*?)[ \t]*\{#[^}\n]*$/.exec(line)` — a
+ * heading whose `{#id` attribute is still arriving — or null.
+ */
+export declare function unfinishedHeadingIdHead(line: string): string | null;
+/**
+ * Exactly `text.replace(/(!?)\[([^\]\n]*)\]\[([^\]\n]+)\]/g, fn)` (the
+ * reference-style use `![alt][id]` / `[text][id]`), linear: every `[` of one
+ * label run closes at the same `]`, so a failed run is skipped whole.
+ */
+export declare function replaceReferenceUses(text: string, fn: (whole: string, bang: string, label: string, id: string, offset: number) => string): string;
+/**
+ * Exactly `/(?<!\])(!?)\[([^\]\n]*)\](\[[^\]\n]*)?$/.exec(text)` as
+ * `{ index, whole, bang, label, reference }` — a closed `[text]` / `![alt]`
+ * at the very end, optionally followed by an unfinished `[id`.
+ */
+export declare function trailingBracketedTail(text: string): {
+    index: number;
+    whole: string;
+    bang: string;
+    label: string;
+    reference: string | undefined;
+} | null;

package/dist/markdown-core/syntax/linear-scan.js

@@ -0,0 +1,129 @@
+const isSpaceTab = (ch) => ch === " " || ch === "	";
+const isLineTerminator = (ch) => ch === "\n" || ch === "\r" || ch === "\u2028" || ch === "\u2029";
+const ID_TEXT = /^[\w:.-]+$/;
+function trimTrailingSpaceTab(text) {
+  let end = text.length;
+  while (end > 0 && isSpaceTab(text[end - 1])) end--;
+  return end === text.length ? text : text.slice(0, end);
+}
+function trailingHeadingId(text) {
+  const body = trimTrailingSpaceTab(text);
+  if (!body.endsWith("}")) return null;
+  const open = body.lastIndexOf("{#");
+  if (open === -1) return null;
+  const id = body.slice(open + 2, -1);
+  if (!ID_TEXT.test(id)) return null;
+  let index = open;
+  while (index > 0 && isSpaceTab(body[index - 1])) index--;
+  return { index, id };
+}
+function atxHeadLength(line) {
+  let hashes = 0;
+  while (line[hashes] === "#") hashes++;
+  if (hashes < 1 || hashes > 6 || !isSpaceTab(line[hashes])) return -1;
+  return hashes;
+}
+function sectionHeading(line) {
+  const hashes = atxHeadLength(line);
+  if (hashes < 0) return null;
+  const tail = trailingHeadingId(line);
+  if (!tail || !tail.id.startsWith("sec:") || tail.id.length <= 4) return null;
+  let start = hashes;
+  while (isSpaceTab(line[start])) start++;
+  if (start === hashes) return null;
+  const title = start >= tail.index ? "" : line.slice(start, tail.index);
+  for (const ch of title) if (isLineTerminator(ch)) return null;
+  return [title, tail.id];
+}
+function unfinishedHeadingIdHead(line) {
+  const hashes = atxHeadLength(line);
+  if (hashes < 0) return null;
+  const minEnd = hashes + 1;
+  let lastStop = -1;
+  for (let i = line.length - 1; i >= 0; i--) {
+    if (line[i] === "}" || line[i] === "\n") {
+      lastStop = i;
+      break;
+    }
+  }
+  const open = line.indexOf("{#", Math.max(lastStop + 1, minEnd));
+  if (open === -1) return null;
+  let end = open;
+  while (end > minEnd && isSpaceTab(line[end - 1])) end--;
+  for (let i = minEnd; i < end; i++) if (isLineTerminator(line[i])) return null;
+  return line.slice(0, end);
+}
+function forwardFinder(text, chars) {
+  let askedFrom = -1;
+  let answer = -1;
+  return (from) => {
+    if (askedFrom >= 0 && from >= askedFrom && (answer === -1 || answer >= from)) return answer;
+    askedFrom = from;
+    answer = -1;
+    for (let i = from; i < text.length; i++) {
+      if (chars.includes(text[i])) {
+        answer = i;
+        break;
+      }
+    }
+    return answer;
+  };
+}
+function replaceReferenceUses(text, fn) {
+  if (!text.includes("][")) return text;
+  const stop = forwardFinder(text, "]\n");
+  let out = "";
+  let copied = 0;
+  let at = text.indexOf("[");
+  while (at !== -1) {
+    const labelEnd = stop(at + 1);
+    if (labelEnd === -1) break;
+    let matched = false;
+    if (text[labelEnd] === "]" && text[labelEnd + 1] === "[") {
+      const idEnd = stop(labelEnd + 2);
+      if (idEnd > labelEnd + 2 && text[idEnd] === "]") {
+        const start = at > copied && text[at - 1] === "!" ? at - 1 : at;
+        const bang = start < at ? "!" : "";
+        out += text.slice(copied, start) + fn(text.slice(start, idEnd + 1), bang, text.slice(at + 1, labelEnd), text.slice(labelEnd + 2, idEnd), start);
+        copied = idEnd + 1;
+        matched = true;
+      }
+    }
+    at = text.indexOf("[", matched ? copied : Math.max(at + 1, labelEnd));
+  }
+  return copied === 0 ? text : out + text.slice(copied);
+}
+function trailingBracketedTail(text) {
+  const lastStop = (end) => {
+    for (let i = end - 1; i >= 0; i--) if (text[i] === "]" || text[i] === "\n") return i;
+    return -1;
+  };
+  let close;
+  let reference;
+  if (text.endsWith("]")) {
+    close = text.length - 1;
+  } else {
+    const stop = lastStop(text.length);
+    if (stop === -1 || text[stop] !== "]" || text[stop + 1] !== "[") return null;
+    close = stop;
+    reference = text.slice(stop + 1);
+  }
+  for (let x = lastStop(close) + 1; x < close; x++) {
+    if (text[x - 1] === "]") continue;
+    if (text[x] === "[") {
+      return { index: x, whole: text.slice(x), bang: "", label: text.slice(x + 1, close), reference };
+    }
+    if (text[x] === "!" && text[x + 1] === "[" && x + 1 < close) {
+      return { index: x, whole: text.slice(x), bang: "!", label: text.slice(x + 2, close), reference };
+    }
+  }
+  return null;
+}
+export {
+  replaceReferenceUses,
+  sectionHeading,
+  trailingBracketedTail,
+  trailingHeadingId,
+  trimTrailingSpaceTab,
+  unfinishedHeadingIdHead
+};

package/dist/markdown-core/syntax/mdast-helpers.d.ts

@@ -0,0 +1,48 @@
+export interface MData {
+    hName?: string;
+    hProperties?: Record<string, unknown>;
+    hChildren?: unknown[];
+    directiveLabel?: boolean;
+    [key: string]: unknown;
+}
+export interface MNode {
+    type: string;
+    value?: string;
+    children?: MNode[];
+    data?: MData;
+    position?: {
+        start: {
+            offset?: number;
+        };
+        end: {
+            offset?: number;
+        };
+    };
+    name?: string;
+    attributes?: Record<string, string | null | undefined> | null;
+    lang?: string | null;
+    meta?: string | null;
+    depth?: number;
+    identifier?: string;
+    label?: string | null;
+    checked?: boolean | null;
+    url?: string;
+    [key: string]: unknown;
+}
+export interface SyntaxFile {
+    value?: unknown;
+    data?: Record<string, unknown>;
+}
+/** An mdast node that becomes the hast element `tag` with `props`. */
+export declare function el(tag: string, props: Record<string, unknown>, children?: MNode[], type?: string): MNode;
+export declare function text(value: string): MNode;
+/** Plain text of a node (mdast-util-to-string semantics, minus images' alt). */
+export declare function toText(node: MNode | undefined): string;
+/** The node's own source text, when the parser recorded where it came from. */
+export declare function rawOf(node: MNode, file: SyntaxFile | undefined): string | null;
+/** Merge adjacent text nodes (after a pass restored literal text). */
+export declare function mergeText(children: MNode[]): MNode[];
+/** Depth-first, pre-order walk over every parent's children array. */
+export declare function walkParents(node: MNode, visit: (parent: MNode) => void): void;
+/** Id-safe slug for a label the author wrote (`fig:growth` stays `fig:growth`). */
+export declare function safeId(label: string): string;

package/dist/markdown-core/syntax/mdast-helpers.js

@@ -0,0 +1,48 @@
+function el(tag, props, children = [], type = "matrxElement") {
+  return { type, data: { hName: tag, hProperties: props }, children };
+}
+function text(value) {
+  return { type: "text", value };
+}
+function toText(node) {
+  if (!node) return "";
+  if (typeof node.value === "string") return node.value;
+  if (!node.children) return "";
+  return node.children.map(toText).join("");
+}
+function rawOf(node, file) {
+  const source = typeof file?.value === "string" ? file.value : null;
+  const start = node.position?.start.offset;
+  const end = node.position?.end.offset;
+  if (source === null || start === void 0 || end === void 0) return null;
+  return source.slice(start, end);
+}
+function mergeText(children) {
+  const out = [];
+  for (const child of children) {
+    const prev = out[out.length - 1];
+    if (child.type === "text" && prev && prev.type === "text" && !prev.data && !child.data) {
+      out[out.length - 1] = { type: "text", value: (prev.value ?? "") + (child.value ?? "") };
+    } else {
+      out.push(child);
+    }
+  }
+  return out;
+}
+function walkParents(node, visit) {
+  if (!node.children) return;
+  visit(node);
+  for (const child of node.children) walkParents(child, visit);
+}
+function safeId(label) {
+  return label.trim().replace(/\s+/g, "-").replace(/[^\w:.\-]/g, "");
+}
+export {
+  el,
+  mergeText,
+  rawOf,
+  safeId,
+  text,
+  toText,
+  walkParents
+};

package/dist/markdown-core/syntax/mentions.d.ts

@@ -0,0 +1,2 @@
+import { type MNode } from "./mdast-helpers.js";
+export declare function transformMentions(node: MNode): void;

package/dist/markdown-core/syntax/mentions.js

@@ -0,0 +1,42 @@
+import { el, text, toText } from "./mdast-helpers.js";
+import { isUuidShape } from "@ai-matrx/kit/uuid";
+const ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
+const SCHEME = /^([a-z][a-z0-9_]*):(.+)$/;
+function mentionFor(link) {
+  const m = SCHEME.exec(link.url ?? "");
+  if (!m) return null;
+  const scheme = m[1];
+  const value = m[2];
+  const label = toText(link).trim();
+  if (!label) return null;
+  if (scheme === "user") {
+    return isUuidShape(value) ? el("matrx-mention", { dataKind: "person", dataId: value.toLowerCase(), dataLabel: label }, [text(label)]) : null;
+  }
+  if (scheme === "date") {
+    return ISO_DATE.test(value) ? el("matrx-mention", { dataKind: "date", dataId: value, dataLabel: label }, [text(label)]) : null;
+  }
+  if (isUuidShape(value)) {
+    return el("matrx-wikilink", { dataTarget: `${scheme}:${value.toLowerCase()}`, dataAlias: label, dataMention: true }, [text(label)]);
+  }
+  return null;
+}
+function transformMentions(node) {
+  const children = node.children;
+  if (!children || node.type === "link" || node.type === "inlineCode" || node.type === "code") return;
+  for (let i = 0; i < children.length; i++) {
+    const child = children[i];
+    const prev = children[i - 1];
+    if (child.type === "link" && prev?.type === "text" && (prev.value ?? "").endsWith("@")) {
+      const mention = mentionFor(child);
+      if (mention) {
+        prev.value = (prev.value ?? "").slice(0, -1);
+        children[i] = mention;
+        continue;
+      }
+    }
+    transformMentions(child);
+  }
+}
+export {
+  transformMentions
+};

package/dist/markdown-core/syntax/names.d.ts

@@ -0,0 +1,6 @@
+/** `:::name` containers with their own rendering. */
+export declare const CONTAINER_DIRECTIVES: Set<string>;
+/** `::name` leaf directives. */
+export declare const LEAF_DIRECTIVES: Set<string>;
+/** `:name[text]{…}` inline directives. */
+export declare const TEXT_DIRECTIVES: Set<string>;

package/dist/markdown-core/syntax/names.js

@@ -0,0 +1,18 @@
+const CONTAINER_DIRECTIVES = /* @__PURE__ */ new Set([
+  "details",
+  "columns",
+  "column",
+  "tabs",
+  "tab",
+  "figure",
+  "table",
+  "aside",
+  "toc"
+]);
+const LEAF_DIRECTIVES = /* @__PURE__ */ new Set(["toc"]);
+const TEXT_DIRECTIVES = /* @__PURE__ */ new Set(["span", "mark", "kbd", "abbr", "sup", "sub"]);
+export {
+  CONTAINER_DIRECTIVES,
+  LEAF_DIRECTIVES,
+  TEXT_DIRECTIVES
+};

package/dist/markdown-core/syntax/prepare-syntax-source.d.ts

@@ -0,0 +1 @@
+export declare function rewriteContainerSpellings(source: string): string;