@ai-matrx/rich-content 0.0.0 → 0.2.3

package/dist/display/markdown-classification/processors/utils/content-splitter-v2.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Content Splitter V2 — the CLIENT entry of the production block splitter.
+ *
+ * The splitter itself lives in content-splitter-core.ts (environment-neutral). This entry binds
+ * the HOST's kind-envelope hooks (`configureRichContent({ splitterEnvelopes })`; matrx-frontend
+ * binds its kind registry), so complete JSON / fence / XML regions carry the canonical
+ * content-IR envelope on `metadata.__ir`. A bare host splits with NO_SPLITTER_ENVELOPES: the
+ * same blocks, no envelope metadata. The server rich-content level imports the core directly.
+ */
+import { type SplitterBlock, type SplitterEnvelopes } from "./content-splitter-core.js";
+export * from "./content-splitter-core.js";
+/** The envelope hooks every client split uses: the host's, else none. */
+export declare function clientSplitterEnvelopes(): SplitterEnvelopes;
+export declare const splitContentIntoBlocksV2: (mdContent: string) => SplitterBlock[];
+export declare function recoverEmbeddedKindJsonBlocks(input: SplitterBlock[]): SplitterBlock[];

package/dist/display/markdown-classification/processors/utils/content-splitter-v2.js

@@ -0,0 +1,19 @@
+import { hostSplitterEnvelopes } from "../../../../host/splitter-envelopes.js";
+import {
+  NO_SPLITTER_ENVELOPES,
+  recoverEmbeddedKindJsonBlocksWith,
+  splitContentIntoBlocksWith
+} from "./content-splitter-core.js";
+export * from "./content-splitter-core.js";
+function clientSplitterEnvelopes() {
+  return hostSplitterEnvelopes() ?? NO_SPLITTER_ENVELOPES;
+}
+const splitContentIntoBlocksV2 = (mdContent) => splitContentIntoBlocksWith(mdContent, clientSplitterEnvelopes());
+function recoverEmbeddedKindJsonBlocks(input) {
+  return recoverEmbeddedKindJsonBlocksWith(input, clientSplitterEnvelopes());
+}
+export {
+  clientSplitterEnvelopes,
+  recoverEmbeddedKindJsonBlocks,
+  splitContentIntoBlocksV2
+};

package/dist/display/markdown-classification/processors/utils/expand-text-blocks.d.ts

@@ -0,0 +1,9 @@
+import type { RenderBlock } from "../../../render-block.js";
+/**
+ * Re-run the V2 splitter on `text` blocks so embedded tables, code fences,
+ * etc. promote to typed blocks. The unified-slots streaming path already does
+ * this for `render_block` rows with type "text"; the processedBlocks /
+ * hasClientBlocks fast path did not — which left tables as plain GFM markdown
+ * inside BasicMarkdownContent instead of StreamingTableRenderer.
+ */
+export declare function expandTextBlocksInList(blocks: RenderBlock[]): RenderBlock[];

package/dist/display/markdown-classification/processors/utils/expand-text-blocks.js

@@ -0,0 +1,36 @@
+import { splitContentIntoBlocksV2 } from "./content-splitter-v2.js";
+function expandTextBlocksInList(blocks) {
+  const out = [];
+  for (const block of blocks) {
+    if (block.type === "text" && block.content?.trim()) {
+      try {
+        const sub = splitContentIntoBlocksV2(block.content);
+        const shouldExpand = sub.length > 1 || sub.length === 1 && sub[0].type !== "text";
+        if (shouldExpand) {
+          let lastReasoningIdx = -1;
+          for (let j = sub.length - 1; j >= 0; j--) {
+            if (sub[j].type === "reasoning" || sub[j].type === "thinking") {
+              lastReasoningIdx = j;
+              break;
+            }
+          }
+          sub.forEach((piece, j) => {
+            const isReasoningPiece = piece.type === "reasoning" || piece.type === "thinking";
+            out.push({
+              ...piece,
+              content: piece.content ?? "",
+              isStreamingBlock: isReasoningPiece && j !== lastReasoningIdx ? false : block.isStreamingBlock
+            });
+          });
+          continue;
+        }
+      } catch {
+      }
+    }
+    out.push(block);
+  }
+  return out;
+}
+export {
+  expandTextBlocksInList
+};

package/dist/display/markdown-classification/processors/utils/gfm-table-lines.d.ts

@@ -0,0 +1,5 @@
+/**
+ * THE GFM table rule and its streaming line helpers live in `@ai-matrx/content-ir/source`
+ * (chat-package-move P14); kept for its many app importers.
+ */
+export { continuesTable, findTableEnd, findTableStart, isGfmDelimiterRow, isPipeLedRow, lineIndent, opensTable, rowCells, splitRowSegments, startsHtmlBlock, startsPipelessTable, tableContainerIndent, tableStartsAt, unescapeCellPipes, findWholeTableStart, startsLikeTableRow, isGrowingDelimiterRow, trailingTableStart, } from "@ai-matrx/content-ir/source";

package/dist/display/markdown-classification/processors/utils/gfm-table-lines.js

@@ -0,0 +1,40 @@
+import {
+  continuesTable,
+  findTableEnd,
+  findTableStart,
+  isGfmDelimiterRow,
+  isPipeLedRow,
+  lineIndent,
+  opensTable,
+  rowCells,
+  splitRowSegments,
+  startsHtmlBlock,
+  startsPipelessTable,
+  tableContainerIndent,
+  tableStartsAt,
+  unescapeCellPipes,
+  findWholeTableStart,
+  startsLikeTableRow,
+  isGrowingDelimiterRow,
+  trailingTableStart
+} from "@ai-matrx/content-ir/source";
+export {
+  continuesTable,
+  findTableEnd,
+  findTableStart,
+  findWholeTableStart,
+  isGfmDelimiterRow,
+  isGrowingDelimiterRow,
+  isPipeLedRow,
+  lineIndent,
+  opensTable,
+  rowCells,
+  splitRowSegments,
+  startsHtmlBlock,
+  startsLikeTableRow,
+  startsPipelessTable,
+  tableContainerIndent,
+  tableStartsAt,
+  trailingTableStart,
+  unescapeCellPipes
+};

package/dist/display/markdown-classification/processors/utils/gfm-table-vector-inputs.d.ts

@@ -0,0 +1,16 @@
+export declare const DOCUMENT_INPUTS: ReadonlyArray<{
+    name: string;
+    text: string;
+}>;
+/** Tag names: which CommonMark reads as an HTML BLOCK (content-ir isHtmlBlockTagName). */
+export declare const HTML_TAG_NAME_INPUTS: readonly string[];
+export declare const ROW_INPUTS: readonly string[];
+export declare const CELL_INPUTS: readonly string[];
+export declare const TABLE_INPUTS: readonly string[];
+export declare const TABLE_END_INPUTS: ReadonlyArray<{
+    lines: string[];
+    start: number;
+}>;
+export declare const TABLE_START_INPUTS: ReadonlyArray<string[]>;
+/** Where a table can open at the FIRST line (header + delimiter as GFM pairs them). */
+export declare const TABLE_OPEN_INPUTS: ReadonlyArray<string[]>;

package/dist/display/markdown-classification/processors/utils/gfm-table-vector-inputs.js

@@ -0,0 +1,385 @@
+const INTRO = "Here is tonight's handover for the Harbor warehouse.";
+const OUTRO = "Omar signs off once bay B3 is re-scanned.";
+const THREE = "Step | Task | Who\n--- | --- | ---\n1 | Drain the print queue | Tom\n2 | Swap the label printer | Ines";
+const TWO = "Bay | Status\n:--- | ---:\nB3 | re-scan\nB4 | clear";
+const ESCAPED = "Rule | Pattern\n--- | ---\nalerts | `err\\|warn`";
+const PIPED = "| Rule | Pattern |\n| --- | --- |\n| alerts | `err\\|warn` |\n| audit | a \\| b |";
+const DOCUMENT_INPUTS = [
+  { name: "pipe-less, three columns", text: `${INTRO}
+
+${THREE}
+
+${OUTRO}` },
+  { name: "pipe-less, two columns, aligned", text: `${INTRO}
+
+${TWO}
+
+${OUTRO}` },
+  { name: "pipe-less, escaped pipe in code", text: `${INTRO}
+
+${ESCAPED}
+
+${OUTRO}` },
+  { name: "pipe-less, right after a prose line", text: `${INTRO}
+${THREE}
+
+${OUTRO}` },
+  { name: "pipe-less, table opens the message", text: `${TWO}
+
+${OUTRO}` },
+  { name: "pipe-led table (unchanged rule)", text: `${INTRO}
+
+${PIPED}
+
+${OUTRO}` },
+  {
+    name: "a list item ends a pipe-less table (verify-RC-B4 R5-1 shape)",
+    text: `${INTRO}
+
+Step | Task | Who
+--- | --- | ---
+1 | Drain the print queue | Tom
+- | Re-scan bay B3 | Omar
+
+${OUTRO}`
+  },
+  { name: "prose with a pipe and no delimiter row", text: `${INTRO}
+Use a | b for either.
+
+${OUTRO}` },
+  { name: "header wider than its delimiter row", text: `${INTRO}
+
+Bay | Status | Crew
+--- | ---
+B3 | re-scan | Omar
+
+${OUTRO}` },
+  { name: "list item with a pipe over a rule", text: `${INTRO}
+
+- keep a | b
+--- | ---
+
+${OUTRO}` },
+  { name: "a 'delimiter' with no dashes is not a table", text: `${INTRO}
+
+| Bay | Status |
+| | |
+| B3 | re-scan |
+
+${OUTRO}` },
+  { name: "a pipe-less row continues a pipe-led table", text: `${INTRO}
+
+| Bay | Status |
+| --- | --- |
+B3 | re-scan
+
+${OUTRO}` },
+  // GFM spec example 202 (verify-RC-B4 R7-2): a line without a pipe is a row; a quote line ends the table.
+  { name: "a line without a pipe continues the table (GFM 202)", text: `${INTRO}
+
+| Bay | Status |
+| --- | --- |
+| B3 | re-scan |
+B4 clear
+
+${OUTRO}` },
+  { name: "a quote line ends a pipe-less table", text: `${INTRO}
+
+Zone | Temp
+--- | ---
+A | 4C
+> 8C | alarm
+
+${OUTRO}` },
+  // verify-RC-B4 round 8: a backtick run whose info string holds a backtick is a code span, not a fence (CommonMark 4.5).
+  { name: "a four-backtick code span row continues the table", text: `${INTRO}
+
+Step | Task
+--- | ---
+1 | Drain the queue
+${"````"} code ${"````"} | b
+
+${OUTRO}` },
+  // verify-RC-B4 round 9: an HTML block start (CommonMark 4.6, conditions 2, 6, 7) and indented code end a table.
+  { name: "an HTML comment ends the table", text: `${INTRO}
+
+| Bay | Status |
+| --- | --- |
+| B3 | re-scan |
+<!-- shift note -->
+
+${OUTRO}` },
+  { name: "a block tag ends the table", text: `${INTRO}
+
+| Bay | Status |
+| --- | --- |
+| B3 | re-scan |
+</details>
+
+${OUTRO}` },
+  { name: "a closing tag alone on its line ends the table", text: `${INTRO}
+
+| Bay | Status |
+| --- | --- |
+| B3 | re-scan |
+</artifact>
+
+${OUTRO}` },
+  { name: "a tag with text after it is a row", text: `${INTRO}
+
+| Bay | Status |
+| --- | --- |
+| B3 | re-scan |
+<span>B4</span> clear
+
+${OUTRO}` },
+  { name: "an indented line ends the table", text: `${INTRO}
+
+| Bay | Status |
+| --- | --- |
+| B3 | re-scan |
+    B4 clear
+
+${OUTRO}` },
+  { name: "a pipe-led header wider than its delimiter is no table", text: `${INTRO}
+
+| Bay | Status |
+|---|
+| B3 | re-scan |
+
+${OUTRO}` },
+  { name: "a header with no pipe over |---| is a one-column table", text: `${INTRO}
+
+Notes
+|---|
+Dock B closed
+
+${OUTRO}` },
+  { name: "a table under a list item's text is that item's text", text: `${INTRO}
+
+- Dock B is closed tonight
+| Bay | Status |
+| --- | --- |
+| B3 | re-scan |
+
+${OUTRO}` },
+  // verify-RC-B4 round 9: an HTML block tag is HTML (GFM), never a custom XML container;
+  // an ASCII tree needs dash connectors; a custom XML container keeps its block.
+  { name: "an unclosed <div> line ends at the blank line", text: `${INTRO}
+
+<div>
+
+${OUTRO}` },
+  { name: "a closed <section> container is one block", text: `${INTRO}
+
+<section>
+Bay B3 re-scan.
+</section>
+
+${OUTRO}` },
+  { name: "an ASCII tree with dash connectors is a tree", text: `${INTRO}
+
+harbor
+|-- docks
+|   |-- B3
+|   +-- B4
++-- yard
+
+${OUTRO}` },
+  { name: "a footnote definition under a row ends the table", text: `${INTRO}
+
+| Bay | Count |
+| --- | --- |
+| A1 | 12 |
+[^1]: counted Monday
+| A2 | 9 |
+
+${OUTRO}` },
+  { name: "a custom XML container keeps its block", text: `${INTRO}
+
+<shift_note>
+Bay B3 re-scan.
+</shift_note>
+
+${OUTRO}` }
+];
+const HTML_TAG_NAME_INPUTS = [
+  "div",
+  "DIV",
+  "section",
+  "details",
+  "dl",
+  "dt",
+  "dd",
+  "h3",
+  "script",
+  "textarea",
+  "search",
+  "span",
+  "artifact",
+  "widget",
+  "thinking",
+  "shift_note",
+  "h7",
+  "divx"
+];
+const ROW_INPUTS = [
+  "a | b",
+  "| a | b |",
+  "| a \\| b | c |",
+  "| `x\\|y` | z |",
+  "a \\\\| b",
+  "a \\\\\\| b | c",
+  "|x|",
+  "| a | b",
+  "--- | :-: | --:",
+  "",
+  "|",
+  "| | |"
+];
+const CELL_INPUTS = [
+  "`err\\|warn`",
+  "a \\| b",
+  "plain",
+  "\\\\\\|",
+  "`a \\| b` and err\\|warn"
+];
+const TABLE_INPUTS = [
+  THREE,
+  TWO,
+  ESCAPED,
+  PIPED,
+  "Bay | Status\n--- | ---\n | \nB4 | clear",
+  "| Bay | Status |\n| | |\n| B3 | re-scan |",
+  // verify-RC-B4 round 9: a trailing lone `|` is an empty row GFM shows, not dropped.
+  "| Bay | Status |\n| --- | --- |\n| B3 | re-scan |\n |"
+];
+const HANDOVER = ["| Bay | Status |", "| --- | --- |", "| B3 | re-scan |"];
+const after = (line) => ({ lines: [...HANDOVER, line, "Omar signs off."], start: 0 });
+const TABLE_END_INPUTS = [
+  after("<script>"),
+  // 1
+  after("<PRE"),
+  // 1, end of line
+  after("<textarea>notes"),
+  // 1, text after
+  after("<!-- shift note -->"),
+  // 2
+  after("<?php echo 1 ?>"),
+  // 3
+  after("<!DOCTYPE html>"),
+  // 4
+  after("<!-x | b"),
+  // not 4: no letter after <!
+  after("<![CDATA[ raw ]]>"),
+  // 5
+  after("<![CDATA | b"),
+  // not 5
+  after("<div>"),
+  // 6
+  after("</details>"),
+  // 6
+  after("<div>moved to B4"),
+  // 6, text after
+  after("   <section>"),
+  // 6, 3 spaces
+  after("</artifact>"),
+  // 7
+  after('<artifact id="1">'),
+  // 7
+  after("<br />"),
+  // 7
+  after("<a :b>"),
+  // 7
+  after("<span>B4</span> clear"),
+  // not 7: text after the tag
+  after("<a b=>"),
+  // not 7: no attribute value
+  after("<x:y>"),
+  // not 7: a colon in the name
+  after("    | B4 | clear |"),
+  // indented code
+  after("	| B4 | clear |"),
+  // a tab
+  after(" 	 B4"),
+  // a space then a tab
+  after("   | B4 | clear |"),
+  // 3 spaces: a row
+  after("|"),
+  // a lone pipe: an empty row
+  after("[^1]: counted Monday"),
+  // a footnote definition ends the table (R9-1)
+  after("[1]: https://harbor.example/bays"),
+  // a link reference definition is a row
+  { lines: ["- item", "", "    | a | b |", "    |---|---|", "    | 1 | 2 |", "    | 3 | 4 |"], start: 2 },
+  { lines: ["- item", "", "    | a | b |", "    |---|---|", "    | 1 | 2 |", "      | 3 | 4 |"], start: 2 },
+  { lines: ["- item", "  | a | b |", "  |---|---|", "  | 1 | 2 |", "    | 3 | 4 |"], start: 1 },
+  { lines: ["1. item", "   - sub", "", "     | a | b |", "     |---|---|", "     | 1 | 2 |", "         | 3 | 4 |"], start: 3 },
+  { lines: ["  | a | b |", "  |---|---|", "  | 1 | 2 |", "    | 3 | 4 |"], start: 0 }
+];
+const ROWS = ["| Bay | Status |", "|---|---|", "| B3 | re-scan |"];
+const under = (...above) => [...above, ...ROWS];
+const nested = (by, ...above) => [...above, ...ROWS.map((row) => by + row)];
+const TABLE_START_INPUTS = [
+  under("- Dock B is closed tonight"),
+  under("- Dock B is closed tonight", ""),
+  under("- Dock B is closed tonight", "  and reopens at six"),
+  nested("  ", "- Dock B is closed tonight"),
+  under("1. Drain the print queue"),
+  nested("  ", "1. Drain the print queue"),
+  nested("   ", "1. Drain the print queue"),
+  under("> Omar signs off"),
+  under("> Omar signs off", ""),
+  under("- Dock B is closed tonight", "# Bays"),
+  under("- Dock B is closed tonight", "---"),
+  under("- Docks", "  - B is closed"),
+  under("Tonight's bays:"),
+  under("- Dock B", "", "  closed until six"),
+  under("-"),
+  // verify-RC-B4 round 9 (R9-5): a table never opens inside an HTML block.
+  under("<details>"),
+  under("<div>"),
+  under("<span>"),
+  under("text <b>B3</b> first"),
+  under("<!-- shift note -->"),
+  under("<script>x<\/script>"),
+  under("<details>", ""),
+  under("Tonight's bays:", "<span>"),
+  under("<div>", "hello"),
+  under("</div>"),
+  under("<!DOCTYPE html>"),
+  // verify-RC-B4 round 16 ruling — THE ONE DELIBERATE GFM DEVIATION: a block whose
+  // element every sanitizer strips ends at its own line (content-ir
+  // opensStrippedHtmlBlock), so a table right under it opens; GFM would keep it raw.
+  under('<link rel="canonical" href="https://harbor.example/bays" />'),
+  under("<nav>"),
+  under("<nav>", "Tonight's bays:"),
+  under("</header>")
+];
+const TABLE_OPEN_INPUTS = [
+  ["Notes", "|---|", "Dock B closed"],
+  // no pipe in the header: a one-column table
+  ["| Notes", "| -", "| Dock B closed"],
+  // one pipe
+  ["| Bay | Status |", "|---|", "| B3 | re-scan |"],
+  // header wider than its delimiter
+  ["| Bay |", "|---|---|", "| B3 |"],
+  // header narrower than its delimiter
+  ["| Bay | Status |", "- | -", "| B3 | re-scan |"],
+  // a list item is no delimiter
+  ["Bay | Status", "- | -", "B3 | re-scan"],
+  ["Bay | Status", "-|-", "B3 | re-scan"],
+  // no space after the dash: a delimiter
+  ["    | Bay | Status |", "    |---|---|", "    | B3 | re-scan |"]
+  // indented code
+];
+export {
+  CELL_INPUTS,
+  DOCUMENT_INPUTS,
+  HTML_TAG_NAME_INPUTS,
+  ROW_INPUTS,
+  TABLE_END_INPUTS,
+  TABLE_INPUTS,
+  TABLE_OPEN_INPUTS,
+  TABLE_START_INPUTS
+};

package/dist/display/markdown-classification/processors/utils/gfm-table-vectors.d.ts

@@ -0,0 +1,43 @@
+export interface GfmTableVectors {
+    rows: Array<{
+        line: string;
+        cells: string[];
+    }>;
+    cellPipes: Array<{
+        cell: string;
+        display: string;
+    }>;
+    tables: Array<{
+        table: string;
+        headers: string[];
+        rows: string[][];
+    } | {
+        table: string;
+        notATable: true;
+    }>;
+    documents: Array<{
+        name: string;
+        text: string;
+        blocks: Array<[string, string]>;
+    }>;
+    /** Where a table that opens at `start` ends (index just past its last row). */
+    tableEnds: Array<{
+        lines: string[];
+        start: number;
+        end: number;
+    }>;
+    /** Whether a table opens at the candidate header (the third line from the end). */
+    tableStarts: Array<{
+        lines: string[];
+        index: number;
+        opens: boolean;
+    }>;
+    /** Raw HTML tags the renderer keeps (rehypeSafeRawHtml) — the Python list must equal it. */
+    rawHtmlTags: string[];
+    /** Tag names CommonMark reads as an HTML block (content-ir isHtmlBlockTagName). */
+    htmlBlockTagNames: Array<{
+        name: string;
+        isBlock: boolean;
+    }>;
+}
+export declare function computeGfmTableVectors(): GfmTableVectors;

package/dist/display/markdown-classification/processors/utils/gfm-table-vectors.js

@@ -0,0 +1,33 @@
+import { rowCells } from "../../../../utils/table-source.js";
+import { unescapeCellPipes } from "../../../../markdown-core/syntax/gfm-cell-pipes.js";
+import { parseMarkdownTable } from "../../../blocks/table/parseMarkdownTable.js";
+import { splitContentIntoBlocksV2 } from "./content-splitter-v2.js";
+import { findTableEnd, tableStartsAt } from "./gfm-table-lines.js";
+import { isHtmlBlockTagName } from "@ai-matrx/content-ir/source";
+import { ALLOWED_RAW_HTML_TAGS } from "../../../chat-markdown/rehypeSafeRawHtml.js";
+import { CELL_INPUTS, DOCUMENT_INPUTS, HTML_TAG_NAME_INPUTS, ROW_INPUTS, TABLE_END_INPUTS, TABLE_INPUTS, TABLE_OPEN_INPUTS, TABLE_START_INPUTS } from "./gfm-table-vector-inputs.js";
+function computeGfmTableVectors() {
+  return {
+    rows: ROW_INPUTS.map((line) => ({ line, cells: rowCells(line) })),
+    cellPipes: CELL_INPUTS.map((cell) => ({ cell, display: unescapeCellPipes(cell) })),
+    tables: TABLE_INPUTS.map((table) => {
+      const parsed = parseMarkdownTable(table);
+      return parsed ? { table, headers: parsed.headers, rows: parsed.rows } : { table, notATable: true };
+    }),
+    documents: DOCUMENT_INPUTS.map(({ name, text }) => ({
+      name,
+      text,
+      blocks: splitContentIntoBlocksV2(text).filter((block) => block.content.trim()).map((block) => [block.type, block.content.trim()])
+    })),
+    tableEnds: TABLE_END_INPUTS.map(({ lines, start }) => ({ lines: [...lines], start, end: findTableEnd(lines, start) })),
+    tableStarts: [
+      ...TABLE_START_INPUTS.map((lines) => ({ lines: [...lines], index: lines.length - 3, opens: tableStartsAt(lines, lines.length - 3) })),
+      ...TABLE_OPEN_INPUTS.map((lines) => ({ lines: [...lines], index: 0, opens: tableStartsAt(lines, 0) }))
+    ],
+    rawHtmlTags: [...ALLOWED_RAW_HTML_TAGS].sort(),
+    htmlBlockTagNames: HTML_TAG_NAME_INPUTS.map((name) => ({ name, isBlock: isHtmlBlockTagName(name) }))
+  };
+}
+export {
+  computeGfmTableVectors
+};

package/dist/display/markdown-classification/processors/utils/table-data-parser.d.ts

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

package/dist/display/markdown-classification/processors/utils/table-data-parser.js

@@ -0,0 +1,30 @@
+import { parseMarkdownTable as parseCanonicalTable } from "../../../blocks/table/parseMarkdownTable.js";
+import { findTableEnd, findWholeTableStart } from "./gfm-table-lines.js";
+const parseMarkdownTable = (content) => {
+  try {
+    const lines = content.split("\n");
+    const tableStartIndex = findWholeTableStart(lines);
+    if (tableStartIndex === -1) return { markdown: null, data: null };
+    const tableLines = lines.slice(tableStartIndex, findTableEnd(lines, tableStartIndex));
+    if (tableLines.length < 3) return { markdown: null, data: null };
+    const parsed = parseCanonicalTable(tableLines.join("\n"));
+    if (!parsed || parsed.headers.length === 0 || parsed.rows.length === 0) return { markdown: null, data: null };
+    const { headers, rows } = parsed;
+    const normalizedData = rows.map((row) => {
+      const rowData = {};
+      headers.forEach((header, index) => {
+        rowData[header] = index < row.length ? row[index] : "";
+      });
+      return rowData;
+    });
+    return {
+      markdown: { headers, rows },
+      data: normalizedData
+    };
+  } catch (error) {
+    return { markdown: null, data: null };
+  }
+};
+export {
+  parseMarkdownTable
+};

package/dist/display/markdown-classification/processors/utils/thinking-parser.d.ts

@@ -0,0 +1,7 @@
+export interface ContentSegment {
+    isThinking: boolean;
+    isQuestionnaire: boolean;
+    isReasoning: boolean;
+    content: string;
+}
+export declare const parseTaggedContent: (content: string) => ContentSegment[];