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

package/dist/display/chat-markdown/page-break/remarkMatrxPageBreak.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Remark plugin: renders a markdown page-break directive as a visible
+ * "Page break" divider — the on-screen half of the print system's page break.
+ *
+ * The grammar is NOT defined here. It is `isBreakLine` (page OR section break) from
+ * `@ai-matrx/print/directives` — the same function the print converters use,
+ * so what previews as a page break is exactly what prints as one:
+ *
+ *   <!-- pagebreak -->   (canonical)   \pagebreak   \newpage
+ *   <!-- newpage -->   <div style="page-break-after: always"></div>
+ *
+ * Screen and paper must agree line for line, so the rules mirror the printer:
+ *  - Only TOP-LEVEL lines are directives (the printer reads lines; a `> \newpage`
+ *    or `- \newpage` is a quote/list item there, so it is one here too).
+ *  - A directive is judged on its RAW source line (so an escaped `\\newpage`
+ *    stays text, as it does on paper), for both shapes it can take in the AST:
+ *    an `html` node (comment / `<div>` on its own line) or a `paragraph`
+ *    (`\newpage`, or a `<div …>` the chat preprocessing escaped to entities).
+ *  - `isolatePageBreakLines` runs on the SOURCE before parsing, so a directive
+ *    written directly under a line of text becomes its own block instead of
+ *    melting into that paragraph (the printer breaks there; so must we).
+ *
+ * Code spans and fences are never touched: they are `code` / `inlineCode`
+ * nodes, and the isolation pass skips fenced regions.
+ *
+ * The divider carries the `matrx-page-break` class (the print package's class)
+ * so a browser print of the page breaks there too — see the print rule at the
+ * end of `app/globals.css`.
+ */
+interface MdastNode {
+    type: string;
+    value?: string;
+    children?: MdastNode[];
+    data?: Record<string, unknown>;
+    position?: {
+        start: {
+            offset?: number;
+        };
+        end: {
+            offset?: number;
+        };
+    };
+    [key: string]: unknown;
+}
+interface SourceFile {
+    value?: unknown;
+}
+/**
+ * Give every directive line its own block: blank lines around it, outside
+ * fenced code. Pure and idempotent; returns the input untouched when there is
+ * no directive (the common case costs one scan).
+ */
+export declare function isolatePageBreakLines(source: string): string;
+export default function remarkMatrxPageBreak(): (tree: MdastNode, file?: SourceFile) => void;
+export {};

package/dist/display/chat-markdown/page-break/remarkMatrxPageBreak.js

@@ -0,0 +1,108 @@
+import {
+  PAGE_BREAK_CLASS,
+  PAGE_BREAK_LABEL,
+  isBreakLine
+} from "@ai-matrx/print/directives";
+import { fenceLineKinds } from "@ai-matrx/content-ir/source";
+function isolatePageBreakLines(source) {
+  if (!source) return source;
+  const lines = source.split("\n");
+  const kinds = fenceLineKinds(source);
+  let changed = false;
+  const out = [];
+  for (const [i, line] of lines.entries()) {
+    if (kinds[i] === "prose" && isBreakLine(line)) {
+      if (out.length > 0 && (out[out.length - 1] ?? "").trim() !== "") out.push("");
+      out.push(line, "");
+      changed = true;
+      continue;
+    }
+    out.push(line);
+  }
+  return changed ? out.join("\n") : source;
+}
+const RULE_CLASS = [
+  "h-0",
+  "flex-1",
+  "border-t-2",
+  "border-dashed",
+  "border-muted-foreground/40"
+];
+function pageBreakNode() {
+  const rule = {
+    type: "element",
+    tagName: "span",
+    properties: { className: RULE_CLASS, ariaHidden: "true" },
+    children: []
+  };
+  return {
+    type: "paragraph",
+    children: [],
+    data: {
+      hName: "div",
+      hProperties: {
+        className: [
+          PAGE_BREAK_CLASS,
+          "not-prose",
+          "my-8",
+          "flex",
+          "items-center",
+          "gap-3",
+          "select-none"
+        ],
+        role: "separator",
+        ariaLabel: PAGE_BREAK_LABEL,
+        dataMatrxPageBreak: ""
+      },
+      hChildren: [
+        rule,
+        {
+          type: "element",
+          tagName: "span",
+          properties: {
+            className: [
+              "text-[10px]",
+              "font-semibold",
+              "uppercase",
+              "tracking-[0.08em]",
+              "text-muted-foreground"
+            ]
+          },
+          children: [{ type: "text", value: PAGE_BREAK_LABEL }]
+        },
+        { ...rule }
+      ]
+    }
+  };
+}
+function rawSource(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 decodeTagEntities(text) {
+  return text.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"');
+}
+function isDirectiveNode(node, file) {
+  if (node.type !== "html" && node.type !== "paragraph") return false;
+  const raw = rawSource(node, file);
+  if (raw !== null) return isBreakLine(decodeTagEntities(raw));
+  if (node.type === "html") return isBreakLine(node.value ?? "");
+  if (!node.children?.length || !node.children.every((c) => c.type === "text")) return false;
+  return isBreakLine(node.children.map((c) => c.value ?? "").join(""));
+}
+function remarkMatrxPageBreak() {
+  return (tree, file) => {
+    const children = tree.children;
+    if (!children) return;
+    for (let i = 0; i < children.length; i++) {
+      if (isDirectiveNode(children[i], file)) children[i] = pageBreakNode();
+    }
+  };
+}
+export {
+  remarkMatrxPageBreak as default,
+  isolatePageBreakLines
+};

package/dist/display/chat-markdown/rehypeSafeRawHtml.d.ts

@@ -0,0 +1,59 @@
+/**
+ * rehype-safe-raw-html — render a curated allow-list of raw HTML tags that
+ * models commonly emit (inline `<img>`, `<table>`…) WITHOUT opening the door to
+ * XSS and WITHOUT the whole-tree serialize/reparse that `rehype-raw` does.
+ *
+ * Why not `rehype-raw`? It re-serializes the entire hast tree and reparses it,
+ * which round-trips our custom `matrx-variable` element (its `data-name` prop
+ * can be renamed away → variables vanish) and the pre-KaTeX `<span class=math>`
+ * nodes. This plugin instead visits ONLY `raw` nodes (the raw-HTML strings
+ * react-markdown leaves in the tree because it runs with `allowDangerousHtml`),
+ * parses each in isolation, sanitizes the result against a tight schema, and
+ * splices the safe elements back in. Element nodes already in the tree
+ * (matrx-variable, math, links, images from the block splitter) are never
+ * touched.
+ *
+ * Must run BEFORE react-markdown's internal `raw`→text transform (which turns
+ * any surviving raw node into literal text) and BEFORE `rehype-katex` (whose
+ * rendered output must not be sanitized). Placement in `rehypePlugins` handles
+ * the first; being listed before rehype-katex handles the second.
+ *
+ * Scope: `<div>` and the `style` attribute are intentionally EXCLUDED — inline
+ * layout HTML (flex/grid via `style`) is a separate, higher-risk concern.
+ *
+ * The parsed/sanitized elements are rendered by the SAME `components` overrides
+ * in BasicMarkdownContent as markdown-native tags — so a raw `<table>` gets our
+ * bordered table styling and a raw `<img>` gets the inline-flow image treatment
+ * for free.
+ */
+import { type Schema } from "hast-util-sanitize";
+import type { Root } from "hast";
+declare module "hast" {
+    interface Data {
+        /**
+         * Set on `<table>` elements this plugin parses from raw HTML. The admin
+         * table-render-path diagnostic in BasicMarkdownContent uses it to STAY
+         * QUIET for HTML tables — they were never markdown pipe tables and are
+         * correctly rendered by the GFM component path, so "not promoted to a
+         * table block" is expected, not a defect. Lives on `data` (not
+         * `properties`) so it never becomes a DOM attribute.
+         */
+        matrxRawHtmlTable?: boolean;
+    }
+}
+/**
+ * Tags a model may emit as raw HTML that we render. Kept in sync with the
+ * pre-escape gate in BasicMarkdownContent (`preprocessContent`) — a tag left
+ * un-escaped there must be allowed here, or it renders as literal text.
+ * Deliberately excludes `div` (layout container — Case 4) and any scripting or
+ * embedding tags (`script`, `style`, `iframe`, `object`, `embed`, `form`…).
+ */
+export declare const ALLOWED_RAW_HTML_TAGS: ReadonlySet<string>;
+/**
+ * Sanitization schema for raw-HTML subtrees. Any tag not listed is dropped, any
+ * attribute not listed is stripped (so `onerror`, `onclick`, inline `style`,
+ * etc. never survive), and `src`/`href` are restricted to safe protocols so
+ * `javascript:` URLs cannot execute. `style` is intentionally omitted.
+ */
+export declare const RAW_HTML_SCHEMA: Schema;
+export default function rehypeSafeRawHtml(): (tree: Root) => void;

package/dist/display/chat-markdown/rehypeSafeRawHtml.js

@@ -0,0 +1,140 @@
+import { visit } from "unist-util-visit";
+import { fromHtml } from "hast-util-from-html";
+import { sanitize } from "hast-util-sanitize";
+function isRawNode(node) {
+  return typeof node === "object" && node !== null && node.type === "raw" && typeof node.value === "string";
+}
+const ALLOWED_RAW_HTML_TAGS = /* @__PURE__ */ new Set([
+  // media
+  "img",
+  // links + breaks + rules
+  "a",
+  "br",
+  "hr",
+  // inline text semantics
+  "span",
+  "p",
+  "strong",
+  "b",
+  "em",
+  "i",
+  "u",
+  "s",
+  "del",
+  "ins",
+  "sup",
+  "sub",
+  "mark",
+  "kbd",
+  "abbr",
+  "small",
+  "code",
+  "pre",
+  // lists + quotes + headings
+  "ul",
+  "ol",
+  "li",
+  "blockquote",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  // tables
+  "table",
+  "thead",
+  "tbody",
+  "tfoot",
+  "tr",
+  "th",
+  "td",
+  "caption",
+  "colgroup",
+  "col",
+  "figure",
+  "figcaption",
+  // collapsible sections (styled by the core's details/summary elements)
+  "details",
+  "summary"
+]);
+const RAW_HTML_SCHEMA = {
+  tagNames: Array.from(ALLOWED_RAW_HTML_TAGS),
+  attributes: {
+    img: ["src", "alt", "title", "width", "height", "loading"],
+    a: ["href", "title", "target", "rel"],
+    th: ["colSpan", "rowSpan", "scope", "align"],
+    td: ["colSpan", "rowSpan", "headers", "align"],
+    col: ["span", "width"],
+    colgroup: ["span"],
+    abbr: ["title"],
+    details: ["open"],
+    "*": ["align"]
+  },
+  protocols: {
+    href: ["http", "https", "mailto", "tel"],
+    src: ["http", "https"]
+  },
+  // Drop these outright (element + subtree) if they ever appear.
+  strip: ["script", "style", "iframe", "object", "embed", "form", "input"],
+  // Keep author ids untouched (no clobber prefix rewriting).
+  clobberPrefix: "",
+  clobber: [],
+  allowComments: false,
+  allowDoctypes: false
+};
+const VOID_TAGS = /* @__PURE__ */ new Set(["br", "hr", "img", "col"]);
+const OPENING_TAG = /^<([a-zA-Z][\w-]*)(?:\s[^<>]*)?>$/;
+function pairInlineTag(node, index, parent) {
+  const open = OPENING_TAG.exec(node.value.trim());
+  if (!open) return false;
+  const tag = (open[1] ?? "").toLowerCase();
+  if (!ALLOWED_RAW_HTML_TAGS.has(tag) || VOID_TAGS.has(tag)) return false;
+  const closer = new RegExp(`^</${tag}\\s*>$`, "i");
+  let depth = 0;
+  for (let j = index + 1; j < parent.children.length; j++) {
+    const sibling = parent.children[j];
+    if (!isRawNode(sibling)) continue;
+    const value = sibling.value.trim();
+    const again = OPENING_TAG.exec(value);
+    if (again && (again[1] ?? "").toLowerCase() === tag) depth++;
+    else if (closer.test(value)) {
+      if (depth > 0) {
+        depth--;
+        continue;
+      }
+      const shell = sanitize(fromHtml(`${node.value}</${tag}>`, { fragment: true }), RAW_HTML_SCHEMA);
+      const element = shell.children.length === 1 ? shell.children[0] : null;
+      if (!element || element.type !== "element" || element.tagName !== tag) return false;
+      element.children = parent.children.slice(index + 1, j);
+      parent.children.splice(index, j - index + 1, element);
+      return true;
+    }
+  }
+  return false;
+}
+function rehypeSafeRawHtml() {
+  return (tree) => {
+    visit(tree, (node, index, parent) => {
+      if (!isRawNode(node) || !parent || typeof index !== "number") return;
+      if (pairInlineTag(node, index, parent)) return index;
+      const fragment = fromHtml(node.value, { fragment: true });
+      const clean = sanitize(fragment, RAW_HTML_SCHEMA);
+      visit(clean, "element", (el) => {
+        if (el.tagName !== "table") return;
+        if (!el.data) {
+          el.data = { position: {} };
+        }
+        el.data.matrxRawHtmlTable = true;
+      });
+      const safeChildren = clean.children;
+      parent.children.splice(index, 1, ...safeChildren);
+      return index;
+    });
+  };
+}
+export {
+  ALLOWED_RAW_HTML_TAGS,
+  RAW_HTML_SCHEMA,
+  rehypeSafeRawHtml as default
+};

package/dist/display/markdown-classification/processors/bock-processors/parse-markdown-table.d.ts

@@ -0,0 +1,14 @@
+import { MarkdownTableData } from "../../../types.js";
+type NormalizedTableData = Array<{
+    [key: string]: string;
+}>;
+export declare const parseMarkdownTable: (content: string, isStreamActive?: boolean) => {
+    markdown: MarkdownTableData | null;
+    data: NormalizedTableData | null;
+};
+export declare const parseMarkdownTables: (content: string) => Array<{
+    markdown: MarkdownTableData | null;
+    data: NormalizedTableData | null;
+    startIndex: number;
+}>;
+export {};

package/dist/display/markdown-classification/processors/bock-processors/parse-markdown-table.js

@@ -0,0 +1,171 @@
+import { unwrapCodeSpans } from "@ai-matrx/content-ir/source";
+import {
+  continuesTable,
+  findTableEnd,
+  findTableStart,
+  isGfmDelimiterRow,
+  rowCells,
+  tableContainerIndent,
+  tableStartsAt
+} from "../utils/gfm-table-lines.js";
+const tableCache = /* @__PURE__ */ new Map();
+const analyzeTableCompletion = (content, isStreamActive = false) => {
+  const lines = content.split("\n").filter((line) => line.trim().length > 0);
+  const tableStartIndex = findTableStart(lines);
+  if (tableStartIndex === -1) {
+    return { isComplete: false, completeRows: [], bufferRow: [], totalRows: 0, completeRowCount: 0 };
+  }
+  const tableLines = lines.slice(tableStartIndex);
+  if (tableLines.length < 3) {
+    return { isComplete: false, completeRows: [], bufferRow: [], totalRows: 0, completeRowCount: 0 };
+  }
+  const dataLines = tableLines.slice(2);
+  const completeRows = [];
+  let bufferRow = [];
+  let totalRows = 0;
+  const processRow = rowCells;
+  const container = tableContainerIndent(lines, tableStartIndex);
+  for (let i = 0; i < dataLines.length; i++) {
+    const line = dataLines[i].trim();
+    if (continuesTable(dataLines[i], container)) {
+      totalRows++;
+      const row = processRow(line);
+      const isCompleteRow = line.endsWith("|") || i < dataLines.length - 1;
+      if (isCompleteRow) {
+        completeRows.push(row);
+      } else if (isStreamActive) {
+        bufferRow = row;
+      } else {
+        completeRows.push(row);
+      }
+    }
+  }
+  const isComplete = !isStreamActive || bufferRow.length === 0;
+  return {
+    isComplete,
+    completeRows,
+    bufferRow,
+    totalRows,
+    completeRowCount: completeRows.length
+  };
+};
+const parseMarkdownTable = (content, isStreamActive = false) => {
+  try {
+    const tableState = analyzeTableCompletion(content, isStreamActive);
+    const contentHash = `${tableState.completeRowCount}-${tableState.isComplete}`;
+    const cacheKey = `table-${contentHash}`;
+    const cached = tableCache.get(cacheKey);
+    const lines = content.split("\n").filter((line) => line.trim().length > 0);
+    const tableStartIndex = findTableStart(lines);
+    if (tableStartIndex === -1) return { markdown: null, data: null };
+    const tableLines = lines.slice(tableStartIndex);
+    if (tableLines.length < 3) return { markdown: null, data: null };
+    const separatorLine = tableLines[1].trim();
+    if (!isGfmDelimiterRow(separatorLine) || !tableStartsAt(lines, tableStartIndex)) {
+      if (!isStreamActive && true) {
+        console.warn("Invalid table separator format:", separatorLine);
+      }
+      return { markdown: null, data: null };
+    }
+    const processRow = rowCells;
+    const headers = processRow(tableLines[0]);
+    if (headers.length === 0) return { markdown: null, data: null };
+    let rowsToProcess;
+    if (isStreamActive) {
+      rowsToProcess = tableState.completeRows;
+    } else {
+      rowsToProcess = tableLines.slice(2).map(processRow).filter((row) => row.some((cell) => cell.length > 0));
+    }
+    if (rowsToProcess.length === 0) return { markdown: null, data: null };
+    const hasValidStructure = rowsToProcess.every(
+      (row) => row.length > 0 && row.length <= Math.max(headers.length * 2, 10)
+    );
+    if (!hasValidStructure) {
+      if (!isStreamActive && true) {
+        console.warn("Table structure validation failed - inconsistent row lengths");
+      }
+      return { markdown: null, data: null };
+    }
+    const cleanText = (text) => {
+      return unwrapCodeSpans(text).replace(/\*\*([^*]+)\*\*/g, "$1").replace(/\*([^*]+)\*/g, "$1").replace(/(?<![A-Za-z0-9])_([^_\n]+?)_(?![A-Za-z0-9])/g, "$1").replace(/\[([^\]]+)\]\(([^)]+)\)/g, "$1|$2").replace(/#{1,6}\s*/g, "").trim();
+    };
+    const normalizedData = rowsToProcess.map((row) => {
+      const rowData = {};
+      headers.forEach((header, index) => {
+        const cleanHeader = cleanText(header);
+        rowData[cleanHeader] = index < row.length ? cleanText(row[index]) : "";
+      });
+      return rowData;
+    });
+    const result = {
+      markdown: { headers, rows: rowsToProcess },
+      data: normalizedData
+    };
+    if (isStreamActive) {
+      tableCache.set(cacheKey, {
+        markdown: result.markdown,
+        data: result.data,
+        hash: contentHash
+      });
+    }
+    return result;
+  } catch (error) {
+    return { markdown: null, data: null };
+  }
+};
+const parseMarkdownTables = (content) => {
+  try {
+    const lines = content.split("\n");
+    const tables = [];
+    let currentIndex = 0;
+    while (currentIndex < lines.length) {
+      const globalStartIndex = findTableStart(lines, currentIndex);
+      if (globalStartIndex === -1) break;
+      const tableLines = lines.slice(globalStartIndex, findTableEnd(lines, globalStartIndex));
+      if (tableLines.length < 3) {
+        currentIndex = globalStartIndex + 1;
+        continue;
+      }
+      if (!tableStartsAt(lines, globalStartIndex)) {
+        currentIndex = globalStartIndex + 1;
+        continue;
+      }
+      const processRow = rowCells;
+      const headers = processRow(tableLines[0]);
+      if (headers.length === 0) {
+        currentIndex = globalStartIndex + 1;
+        continue;
+      }
+      const rows = tableLines.slice(2).map(processRow).filter((row) => row.some((cell) => cell.length > 0));
+      const tableLength = tableLines.length;
+      if (rows.length === 0) {
+        currentIndex = globalStartIndex + tableLength;
+        continue;
+      }
+      const cleanText = (text) => {
+        return unwrapCodeSpans(text).replace(/\*\*([^*]+)\*\*/g, "$1").replace(/\*([^*]+)\*/g, "$1").replace(/(?<![A-Za-z0-9])_([^_\n]+?)_(?![A-Za-z0-9])/g, "$1").replace(/\[([^\]]+)\]\(([^)]+)\)/g, "$1|$2").replace(/#{1,6}\s*/g, "").trim();
+      };
+      const normalizedData = rows.map((row) => {
+        const rowData = {};
+        headers.forEach((header, index) => {
+          const cleanHeader = cleanText(header);
+          rowData[cleanHeader] = index < row.length ? cleanText(row[index]) : "";
+        });
+        return rowData;
+      });
+      tables.push({
+        markdown: { headers, rows },
+        data: normalizedData,
+        startIndex: globalStartIndex
+      });
+      currentIndex = globalStartIndex + tableLength;
+    }
+    return tables;
+  } catch (error) {
+    return [];
+  }
+};
+export {
+  parseMarkdownTable,
+  parseMarkdownTables
+};

package/dist/display/markdown-classification/processors/types.d.ts

@@ -0,0 +1,120 @@
+export interface Position {
+    start: {
+        line: number;
+        column: number;
+        offset: number;
+    };
+    end: {
+        line: number;
+        column: number;
+        offset: number;
+    };
+}
+export type NodeType = 'root' | 'paragraph' | 'text' | 'strong' | 'thematicBreak' | 'heading' | 'list' | 'listItem' | 'blockquote' | 'link' | 'image' | 'code' | 'html' | 'emphasis' | 'inlineCode' | 'break' | 'delete' | 'footnote' | 'footnoteDefinition' | 'footnoteReference' | 'definition' | 'table' | 'tableRow' | 'tableCell';
+export interface BaseAstNode {
+    type: NodeType;
+    position?: Position;
+}
+export interface RootNode extends BaseAstNode {
+    type: 'root';
+    children: AstNode[];
+}
+export interface ParagraphNode extends BaseAstNode {
+    type: 'paragraph';
+    children: AstNode[];
+}
+export interface TextNode extends BaseAstNode {
+    type: 'text';
+    value: string;
+}
+export interface StrongNode extends BaseAstNode {
+    type: 'strong';
+    children: AstNode[];
+}
+export interface ThematicBreakNode extends BaseAstNode {
+    type: 'thematicBreak';
+}
+export interface HeadingNode extends BaseAstNode {
+    type: 'heading';
+    depth: number;
+    children: AstNode[];
+}
+export interface ListNode extends BaseAstNode {
+    type: 'list';
+    ordered: boolean;
+    start: number | null;
+    spread: boolean;
+    children: AstNode[];
+}
+export interface ListItemNode extends BaseAstNode {
+    type: 'listItem';
+    spread: boolean;
+    checked: boolean | null;
+    children: AstNode[];
+}
+export interface BlockquoteNode extends BaseAstNode {
+    type: 'blockquote';
+    children: AstNode[];
+}
+export interface LinkNode extends BaseAstNode {
+    type: 'link';
+    url: string;
+    title?: string | null;
+    children: AstNode[];
+}
+export interface ImageNode extends BaseAstNode {
+    type: 'image';
+    url: string;
+    title?: string | null;
+    alt?: string;
+}
+export interface CodeNode extends BaseAstNode {
+    type: 'code';
+    value: string;
+    lang?: string | null;
+    meta?: string | null;
+}
+export interface HtmlNode extends BaseAstNode {
+    type: 'html';
+    value: string;
+}
+export interface EmphasisNode extends BaseAstNode {
+    type: 'emphasis';
+    children: AstNode[];
+}
+export interface InlineCodeNode extends BaseAstNode {
+    type: 'inlineCode';
+    value: string;
+}
+export interface BreakNode extends BaseAstNode {
+    type: 'break';
+}
+export interface DeleteNode extends BaseAstNode {
+    type: 'delete';
+    children: AstNode[];
+}
+export interface TableNode extends BaseAstNode {
+    type: 'table';
+    align?: Array<'left' | 'right' | 'center' | null>;
+    children: AstNode[];
+}
+export interface TableRowNode extends BaseAstNode {
+    type: 'tableRow';
+    children: AstNode[];
+}
+export interface TableCellNode extends BaseAstNode {
+    type: 'tableCell';
+    children: AstNode[];
+}
+export interface DefinitionNode extends BaseAstNode {
+    type: 'definition';
+    identifier: string;
+    label?: string;
+    url: string;
+    title?: string | null;
+}
+export type AstNode = RootNode | ParagraphNode | TextNode | StrongNode | ThematicBreakNode | HeadingNode | ListNode | ListItemNode | BlockquoteNode | LinkNode | ImageNode | CodeNode | HtmlNode | EmphasisNode | InlineCodeNode | BreakNode | DeleteNode | TableNode | TableRowNode | TableCellNode | DefinitionNode;
+export declare function isRoot(node: AstNode): node is RootNode;
+export declare function hasChildren(node: AstNode): node is AstNode & {
+    children: AstNode[];
+};

package/dist/display/markdown-classification/processors/types.js

@@ -0,0 +1,10 @@
+function isRoot(node) {
+  return node.type === "root";
+}
+function hasChildren(node) {
+  return "children" in node && Array.isArray(node.children);
+}
+export {
+  hasChildren,
+  isRoot
+};