@ai-matrx/rich-content 0.2.4 → 0.2.7

package/dist/display/blocks/tree/TreeBlock.js

@@ -0,0 +1,163 @@
+"use client";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { useClipboard } from "@ai-matrx/kit/clipboard";
+import { toast } from "../../../host/toast.js";
+import { useState } from "react";
+import { cn } from "@ai-matrx/design-system";
+import { Copy, Check } from "lucide-react";
+import { useCanvasPresentation } from "@ai-matrx/canvas/react";
+import { treeWrapsLines } from "../canvas-adaptive.js";
+import { Button } from "@ai-matrx/design-system/controls";
+const CONNECTORS = [
+  "\u251C\u2500",
+  "\u2514\u2500",
+  "\u2502",
+  "\u251C\u2500\u2500",
+  "\u2514\u2500\u2500",
+  "\u251C\u2500 ",
+  "\u2514\u2500 ",
+  "+--",
+  "|--",
+  "|  ",
+  "+- ",
+  "|- "
+];
+const ARROW = /\s*[→➜➔\->]+\s*/;
+function parseTreeLines(content) {
+  return content.split("\n").map((line) => {
+    if (!line.trim()) {
+      return {
+        text: line,
+        depth: 0,
+        connector: "",
+        label: line,
+        hasHighlight: false
+      };
+    }
+    let depth = 0;
+    let pos = 0;
+    let connector = "";
+    while (pos < line.length) {
+      const rest = line.slice(pos);
+      let foundConnector = false;
+      for (const c of CONNECTORS) {
+        if (rest.startsWith(c)) {
+          if (c === "\u2502" || c === "|  " || c === "|") {
+            depth++;
+            pos += c.length;
+            foundConnector = true;
+            break;
+          } else {
+            connector = c;
+            pos += c.length;
+            foundConnector = true;
+            break;
+          }
+        }
+      }
+      if (!foundConnector) {
+        if (rest[0] === " " || rest[0] === "	") {
+          pos++;
+        } else {
+          break;
+        }
+      }
+      if (connector) break;
+    }
+    const label = line.slice(pos).trim();
+    const arrowMatch = label.match(ARROW);
+    let hasHighlight = false;
+    let highlightText;
+    if (arrowMatch) {
+      const afterArrow = label.slice(arrowMatch.index + arrowMatch[0].length).trim();
+      if (afterArrow.startsWith("**") && afterArrow.endsWith("**")) {
+        hasHighlight = true;
+        highlightText = afterArrow.slice(2, -2);
+      }
+    }
+    return { text: line, depth, connector, label, hasHighlight, highlightText };
+  });
+}
+const DEPTH_COLORS = [
+  "text-blue-500 dark:text-blue-400",
+  "text-green-500 dark:text-green-400",
+  "text-amber-500 dark:text-amber-400",
+  "text-purple-500 dark:text-purple-400",
+  "text-cyan-500 dark:text-cyan-400",
+  "text-rose-500 dark:text-rose-400"
+];
+const TreeBlock = ({ content, className }) => {
+  const { copyText } = useClipboard({
+    notify: (message, kind) => kind === "error" ? toast.error(message) : toast.success(message)
+  });
+  const [copied, setCopied] = useState(false);
+  const lines = parseTreeLines(content);
+  const wrap = treeWrapsLines(useCanvasPresentation());
+  const handleCopy = async () => {
+    await copyText(content);
+    setCopied(true);
+    setTimeout(() => setCopied(false), 2e3);
+  };
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: cn(
+        "my-3 rounded-lg border border-border bg-card overflow-hidden",
+        className
+      ),
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-between px-3 py-1.5 border-b border-border/50 bg-muted/30", children: [
+          /* @__PURE__ */ jsx("span", { className: "text-xs font-mono font-semibold text-teal-600 dark:text-teal-400", children: "Tree" }),
+          /* @__PURE__ */ jsx(Button, { variant: "quiet", icon: copied ? /* @__PURE__ */ jsx(Check, {}) : /* @__PURE__ */ jsx(Copy, {}), glyphTone: copied ? "success" : void 0, onClick: handleCopy, "aria-label": "Copy" })
+        ] }),
+        /* @__PURE__ */ jsx(
+          "div",
+          {
+            "data-tree-wrap": wrap ? "wrap" : "scroll",
+            className: cn(
+              "px-4 py-3 font-mono text-sm leading-relaxed",
+              wrap ? "overflow-x-hidden" : "overflow-x-auto"
+            ),
+            children: lines.map((line, idx) => {
+              if (!line.text.trim()) {
+                return /* @__PURE__ */ jsx("div", { className: "h-2" }, idx);
+              }
+              const depthColor = DEPTH_COLORS[line.depth % DEPTH_COLORS.length];
+              const raw = line.text;
+              const labelStart = raw.indexOf(line.label);
+              if (labelStart <= 0) {
+                return /* @__PURE__ */ jsx("div", { className: "text-foreground font-semibold", children: line.label }, idx);
+              }
+              const prefix = raw.slice(0, labelStart);
+              const arrowMatch = line.label.match(ARROW);
+              return /* @__PURE__ */ jsxs(
+                "div",
+                {
+                  className: cn(
+                    "hover:bg-muted/20 rounded-sm transition-colors",
+                    wrap ? "whitespace-pre-wrap break-words [overflow-wrap:anywhere]" : "whitespace-pre"
+                  ),
+                  children: [
+                    /* @__PURE__ */ jsx("span", { className: cn("select-none", depthColor), children: prefix }),
+                    arrowMatch ? /* @__PURE__ */ jsxs(Fragment, { children: [
+                      /* @__PURE__ */ jsx("span", { className: "text-foreground", children: line.label.slice(0, arrowMatch.index) }),
+                      /* @__PURE__ */ jsx("span", { className: "text-muted-foreground", children: arrowMatch[0] }),
+                      line.hasHighlight && line.highlightText ? /* @__PURE__ */ jsx("span", { className: "font-semibold text-primary-ink bg-primary/10 px-1 rounded", children: line.highlightText }) : /* @__PURE__ */ jsx("span", { className: "text-foreground", children: line.label.slice(
+                        arrowMatch.index + arrowMatch[0].length
+                      ) })
+                    ] }) : /* @__PURE__ */ jsx("span", { className: "text-foreground", children: line.label })
+                  ]
+                },
+                idx
+              );
+            })
+          }
+        )
+      ]
+    }
+  );
+};
+var TreeBlock_default = TreeBlock;
+export {
+  TreeBlock_default as default
+};

package/dist/display/blocks/xml/XmlBlock.d.ts

@@ -0,0 +1,23 @@
+import React from "react";
+interface XmlBlockProps {
+    content: string;
+    language?: string;
+    className?: string;
+    /**
+     * Prose segments ALREADY RENDERED by a static root (server level / SSR'd
+     * share leaf), keyed by token index from the shared tokenizer
+     * (xml-tokenize.ts), so a card's text is in the server HTML. Missing keys
+     * render client-side through NestedRichContent, as before.
+     */
+    renderedProse?: Record<number, React.ReactNode>;
+    /**
+     * Whether this card SHOWS SOURCE — a ```xml fence, the model quoting source
+     * (ruling (a)): a kind in its prose stays as written. False for an XML TAG
+     * the model wrapped content in (`isQuotedSourceXmlBlock`, ruling (b)): its
+     * prose is data and a kind there renders as the kind. Default true — a
+     * caller that cannot tell keeps the source view.
+     */
+    quotedSource?: boolean;
+}
+declare const XmlBlock: React.FC<XmlBlockProps>;
+export default XmlBlock;

package/dist/display/blocks/xml/XmlBlock.js

@@ -0,0 +1,197 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useClipboard } from "@ai-matrx/kit/clipboard";
+import { toast } from "../../../host/toast.js";
+import { useState } from "react";
+import { ChevronRight, ChevronDown, Copy, Check } from "lucide-react";
+import { NestedRichContent } from "../../../levels/standard/NestedRichContent.js";
+import { KindSourceView } from "../../chat-markdown/KindTextGate.js";
+import { cn } from "@ai-matrx/design-system";
+import { tokenizeXml } from "./xml-tokenize.js";
+import { useMarkdownStreaming } from "../../../markdown-core/streaming-context.js";
+import { Button } from "@ai-matrx/design-system/controls";
+function renderAttributes(attrs) {
+  return attrs.map((attr, i) => /* @__PURE__ */ jsxs("span", { children: [
+    " ",
+    /* @__PURE__ */ jsx("span", { className: "text-amber-600 dark:text-amber-400", children: attr.name }),
+    /* @__PURE__ */ jsx("span", { className: "text-muted-foreground", children: "=" }),
+    /* @__PURE__ */ jsxs("span", { className: "text-green-600 dark:text-green-400", children: [
+      '"',
+      attr.value,
+      '"'
+    ] })
+  ] }, i));
+}
+const XmlBlock = ({
+  content,
+  language = "xml",
+  className,
+  renderedProse,
+  quotedSource = true
+}) => {
+  const { copyText } = useClipboard({
+    notify: (message, kind) => kind === "error" ? toast.error(message) : toast.success(message)
+  });
+  const [copied, setCopied] = useState(false);
+  const [collapsed, setCollapsed] = useState(/* @__PURE__ */ new Set());
+  const [cardCollapsed, setCardCollapsed] = useState(false);
+  const tokens = tokenizeXml(content);
+  const isStreaming = useMarkdownStreaming();
+  const handleCopy = async () => {
+    await copyText(content);
+    setCopied(true);
+    setTimeout(() => setCopied(false), 2e3);
+  };
+  const toggleCollapse = (idx) => {
+    setCollapsed((prev) => {
+      const next = new Set(prev);
+      if (next.has(idx)) next.delete(idx);
+      else next.add(idx);
+      return next;
+    });
+  };
+  const findMatchingClose = (openIdx) => {
+    const openToken = tokens[openIdx];
+    if (openToken.type !== "open" || !openToken.tagName) return null;
+    let depth = 1;
+    for (let j = openIdx + 1; j < tokens.length; j++) {
+      const t = tokens[j];
+      if (t.type === "open" && t.tagName === openToken.tagName) depth++;
+      if (t.type === "close" && t.tagName === openToken.tagName) {
+        depth--;
+        if (depth === 0) return j;
+      }
+    }
+    return null;
+  };
+  const rootOpenIndex = tokens.findIndex(
+    (token) => token.type === "open" || token.type === "selfClose"
+  );
+  const rootCloseIndex = rootOpenIndex === -1 ? null : findMatchingClose(rootOpenIndex);
+  const rootTagName = rootOpenIndex === -1 ? void 0 : tokens[rootOpenIndex]?.tagName;
+  const hasCardBody = tokens.some(
+    (_, idx) => idx !== rootOpenIndex && idx !== rootCloseIndex
+  );
+  const hiddenRanges = /* @__PURE__ */ new Set();
+  for (const idx of collapsed) {
+    const end = findMatchingClose(idx);
+    for (let j = idx + 1; j < (end ?? tokens.length); j++) {
+      hiddenRanges.add(j);
+    }
+  }
+  if (!tokens.some((token) => token.type !== "markdown")) {
+    if (isStreaming) return null;
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        "data-xml-fragment": true,
+        className: cn("my-2 whitespace-pre-wrap break-words", className),
+        children: content
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: cn(
+        "my-3 rounded-lg border border-border bg-card overflow-hidden",
+        className
+      ),
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-between px-3 py-1.5 border-b border-border/50 bg-muted/30", children: [
+          /* @__PURE__ */ jsxs("div", { className: "flex min-w-0 items-center gap-2", children: [
+            /* @__PURE__ */ jsx("span", { className: "text-xs font-mono font-semibold text-orange-600 dark:text-orange-400", children: language.toUpperCase() }),
+            rootTagName ? hasCardBody ? /* @__PURE__ */ jsx(Button, { variant: "quiet", icon: cardCollapsed ? /* @__PURE__ */ jsx(ChevronRight, {}) : /* @__PURE__ */ jsx(ChevronDown, {}), "aria-label": `${cardCollapsed ? "Expand" : "Collapse"} ${rootTagName}`, "aria-expanded": !cardCollapsed, onClick: () => setCardCollapsed((previous) => !previous), className: "size-11 min-w-0 lg:size-auto", children: /* @__PURE__ */ jsx("span", { className: "truncate", children: rootTagName }) }) : /* @__PURE__ */ jsx(
+              "span",
+              {
+                "data-xml-root-name": true,
+                className: "truncate font-mono text-sm text-blue-600 dark:text-blue-400",
+                children: rootTagName
+              }
+            ) : null
+          ] }),
+          /* @__PURE__ */ jsx(Button, { variant: "quiet", icon: copied ? /* @__PURE__ */ jsx(Check, {}) : /* @__PURE__ */ jsx(Copy, {}), glyphTone: copied ? "success" : void 0, "aria-label": "Copy XML", onClick: handleCopy, className: "size-11 lg:size-auto" })
+        ] }),
+        !cardCollapsed && /* @__PURE__ */ jsx(
+          "div",
+          {
+            "data-xml-card-body": true,
+            className: "px-3 py-2 font-mono text-sm leading-relaxed overflow-x-auto",
+            children: tokens.map((token, idx) => {
+              if (idx === rootOpenIndex || idx === rootCloseIndex) return null;
+              if (hiddenRanges.has(idx)) return null;
+              const style = { paddingLeft: token.indent * 8 };
+              if (token.type === "markdown" && !token.text?.trim()) {
+                return /* @__PURE__ */ jsx("div", { className: "h-3" }, idx);
+              }
+              if (token.type === "comment") {
+                return /* @__PURE__ */ jsx(
+                  "div",
+                  {
+                    className: "text-muted-foreground italic",
+                    style,
+                    children: token.text
+                  },
+                  idx
+                );
+              }
+              if (token.type === "declaration" || token.type === "cdata") {
+                return /* @__PURE__ */ jsx("div", { className: "text-muted-foreground", style, children: token.text }, idx);
+              }
+              if (token.type === "markdown") {
+                return /* @__PURE__ */ jsx(
+                  "div",
+                  {
+                    className: "xml-markdown-content prose prose-sm max-w-none overflow-x-auto font-sans text-foreground dark:prose-invert",
+                    style,
+                    children: renderedProse && idx in renderedProse && !isStreaming ? renderedProse[idx] : quotedSource ? /* @__PURE__ */ jsx(KindSourceView, { children: /* @__PURE__ */ jsx(NestedRichContent, { source: token.text ?? "" }) }) : /* @__PURE__ */ jsx(NestedRichContent, { source: token.text ?? "", isStreaming })
+                  },
+                  idx
+                );
+              }
+              if (token.type === "close") {
+                return /* @__PURE__ */ jsxs("div", { style, children: [
+                  /* @__PURE__ */ jsx("span", { className: "text-muted-foreground", children: "</" }),
+                  /* @__PURE__ */ jsx("span", { className: "text-red-600 dark:text-red-400", children: token.tagName }),
+                  /* @__PURE__ */ jsx("span", { className: "text-muted-foreground", children: ">" })
+                ] }, idx);
+              }
+              if (token.type === "selfClose") {
+                return /* @__PURE__ */ jsxs("div", { style, children: [
+                  /* @__PURE__ */ jsx("span", { className: "text-muted-foreground", children: "<" }),
+                  /* @__PURE__ */ jsx("span", { className: "text-blue-600 dark:text-blue-400", children: token.tagName }),
+                  token.attributes && renderAttributes(token.attributes),
+                  /* @__PURE__ */ jsx("span", { className: "text-muted-foreground", children: " />" })
+                ] }, idx);
+              }
+              const isCollapsed = collapsed.has(idx);
+              const hasChildren = idx + 1 < tokens.length && tokens[idx + 1].type !== "close";
+              return /* @__PURE__ */ jsxs(
+                "div",
+                {
+                  className: "flex items-start group/line hover:bg-muted/30 rounded-sm -mx-1 px-1",
+                  style,
+                  children: [
+                    hasChildren ? /* @__PURE__ */ jsx(Button, { variant: "quiet", icon: isCollapsed ? /* @__PURE__ */ jsx(ChevronRight, {}) : /* @__PURE__ */ jsx(ChevronDown, {}), "aria-label": `${isCollapsed ? "Expand" : "Collapse"} ${token.tagName}`, onClick: () => toggleCollapse(idx), className: "mr-1 size-11 lg:mt-0.5 lg:size-auto" }) : /* @__PURE__ */ jsx("span", { className: "w-[18px] flex-shrink-0" }),
+                    /* @__PURE__ */ jsxs("span", { children: [
+                      /* @__PURE__ */ jsx("span", { className: "text-muted-foreground", children: "<" }),
+                      /* @__PURE__ */ jsx("span", { className: "text-blue-600 dark:text-blue-400", children: token.tagName }),
+                      token.attributes && renderAttributes(token.attributes),
+                      /* @__PURE__ */ jsx("span", { className: "text-muted-foreground", children: ">" }),
+                      isCollapsed && /* @__PURE__ */ jsx("span", { className: "ml-1 text-xs text-muted-foreground bg-muted px-1.5 py-0.5 rounded", children: "..." })
+                    ] })
+                  ]
+                },
+                idx
+              );
+            })
+          }
+        )
+      ]
+    }
+  );
+};
+var XmlBlock_default = XmlBlock;
+export {
+  XmlBlock_default as default
+};

package/dist/display/blocks/xml/readXmlTag.d.ts

@@ -0,0 +1 @@
+export * from "@ai-matrx/content-ir/source";

package/dist/display/blocks/xml/readXmlTag.js

@@ -0,0 +1 @@
+export * from "@ai-matrx/content-ir/source";

package/dist/display/blocks/xml/xml-tokenize.d.ts

@@ -0,0 +1,13 @@
+export interface XmlToken {
+    type: "open" | "close" | "selfClose" | "markdown" | "comment" | "declaration" | "cdata";
+    tagName?: string;
+    attributes?: Array<{
+        name: string;
+        value: string;
+    }>;
+    text?: string;
+    raw: string;
+    indent: number;
+}
+/** Lex XML chrome without parsing or executing the text between tags. */
+export declare function tokenizeXml(content: string): XmlToken[];

package/dist/display/blocks/xml/xml-tokenize.js

@@ -0,0 +1,169 @@
+import { readXmlTag } from "./readXmlTag.js";
+function indentAt(content, offset) {
+  const lineStart = content.lastIndexOf("\n", offset - 1) + 1;
+  return content.slice(lineStart, offset).search(/\S|$/);
+}
+function fenceAtLineStart(content, offset) {
+  if (offset !== 0 && content[offset - 1] !== "\n") return null;
+  let markerStart = offset;
+  while (content[markerStart] === " " || content[markerStart] === "	")
+    markerStart++;
+  const markerCharacter = content[markerStart];
+  if (markerCharacter !== "`" && markerCharacter !== "~") return null;
+  let markerEnd = markerStart;
+  while (content[markerEnd] === markerCharacter) markerEnd++;
+  if (markerEnd - markerStart < 3) return null;
+  const lineEnd = content.indexOf("\n", markerEnd);
+  return {
+    marker: content.slice(markerStart, markerEnd),
+    contentStart: lineEnd === -1 ? content.length : lineEnd + 1
+  };
+}
+function fenceEnd(content, start, marker) {
+  const closing = new RegExp(
+    `^[ \\t]*${marker[0]}{${marker.length},}[ \\t]*(?:\\n|$)`,
+    "m"
+  );
+  const match = closing.exec(content.slice(start));
+  return match ? start + match.index + match[0].length : content.length;
+}
+function normalizeMarkdownIndentation(raw) {
+  const lines = raw.split("\n");
+  let indent;
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    const current = line.match(/^[ \t]*/)?.[0].length ?? 0;
+    indent = indent === void 0 ? current : Math.min(indent, current);
+  }
+  const resolvedIndent = indent ?? 0;
+  if (!resolvedIndent) return { text: raw, indent: 0 };
+  return {
+    text: lines.map((line) => line.slice(resolvedIndent)).join("\n"),
+    indent: resolvedIndent
+  };
+}
+function isEscaped(content, offset) {
+  let slashCount = 0;
+  for (let index = offset - 1; content[index] === "\\"; index--) slashCount++;
+  return slashCount % 2 === 1;
+}
+function inlineCodeEnd(content, start) {
+  if (isEscaped(content, start)) return null;
+  let markerEnd = start;
+  while (content[markerEnd] === "`") markerEnd++;
+  const markerLength = markerEnd - start;
+  for (let index = markerEnd; index < content.length; ) {
+    if (content[index] !== "`") {
+      index++;
+      continue;
+    }
+    let runEnd = index;
+    while (content[runEnd] === "`") runEnd++;
+    if (runEnd - index === markerLength) return runEnd;
+    index = runEnd;
+  }
+  return markerEnd;
+}
+function tokenizeXml(content) {
+  const tokens = [];
+  let textStart = 0;
+  let cursor = 0;
+  let scannedRegionStart = -1;
+  let scannedLineEnd = 0;
+  let baseIndent;
+  let cachedLineStart = -1;
+  let cachedLineEnd = -1;
+  let currentIndent = 0;
+  const isIndentedMarkdownCode = (offset) => {
+    if (offset > cachedLineEnd) {
+      cachedLineStart = content.lastIndexOf("\n", offset - 1) + 1;
+      const nextNewline = content.indexOf("\n", offset);
+      cachedLineEnd = nextNewline === -1 ? content.length : nextNewline;
+      currentIndent = 0;
+      while (content[cachedLineStart + currentIndent] === " " || content[cachedLineStart + currentIndent] === "	")
+        currentIndent++;
+    }
+    const lineStart = cachedLineStart;
+    if (scannedRegionStart !== textStart) {
+      scannedRegionStart = textStart;
+      scannedLineEnd = textStart;
+      baseIndent = void 0;
+    }
+    while (scannedLineEnd < lineStart) {
+      const end = content.indexOf("\n", scannedLineEnd);
+      const line = content.slice(scannedLineEnd, end);
+      if (line.trim()) {
+        const indent = line.match(/^[ \t]*/)?.[0].length ?? 0;
+        baseIndent = baseIndent === void 0 ? indent : Math.min(baseIndent, indent);
+      }
+      scannedLineEnd = end + 1;
+    }
+    return baseIndent !== void 0 && currentIndent >= baseIndent + 4;
+  };
+  const pushMarkdown = (end) => {
+    if (end <= textStart) return;
+    const raw = content.slice(textStart, end);
+    const markdown = normalizeMarkdownIndentation(raw);
+    tokens.push({
+      type: "markdown",
+      text: markdown.text,
+      raw,
+      indent: markdown.indent
+    });
+  };
+  while (cursor < content.length) {
+    const fence = fenceAtLineStart(content, cursor);
+    if (fence) {
+      cursor = fenceEnd(content, fence.contentStart, fence.marker);
+      continue;
+    }
+    if (content[cursor] === "`") {
+      cursor = inlineCodeEnd(content, cursor) ?? cursor + 1;
+      continue;
+    }
+    if (content.startsWith("<!--", cursor) || content.startsWith("<![CDATA[", cursor) || content.startsWith("<?", cursor)) {
+      const [kind, terminator, afterStart] = content.startsWith("<!--", cursor) ? ["comment", "-->", 4] : content.startsWith("<![CDATA[", cursor) ? ["cdata", "]]>", 9] : ["declaration", "?>", 2];
+      const endMarker = content.indexOf(terminator, cursor + afterStart);
+      const end = endMarker === -1 ? content.length : endMarker + terminator.length;
+      pushMarkdown(cursor);
+      const raw = content.slice(cursor, end);
+      tokens.push({
+        type: kind,
+        text: raw,
+        raw,
+        indent: indentAt(content, cursor)
+      });
+      cursor = end;
+      textStart = end;
+      continue;
+    }
+    if (content[cursor] !== "<") {
+      cursor++;
+      continue;
+    }
+    if (isIndentedMarkdownCode(cursor)) {
+      cursor++;
+      continue;
+    }
+    const tag = readXmlTag(content, cursor);
+    if (!tag) {
+      cursor++;
+      continue;
+    }
+    pushMarkdown(cursor);
+    tokens.push({
+      type: tag.isClosing ? "close" : tag.isSelfClosing ? "selfClose" : "open",
+      tagName: tag.tagName,
+      attributes: tag.attributes,
+      raw: tag.raw,
+      indent: indentAt(content, cursor)
+    });
+    cursor += tag.raw.length;
+    textStart = cursor;
+  }
+  pushMarkdown(content.length);
+  return tokens;
+}
+export {
+  tokenizeXml
+};

package/dist/display/blocks/yaml/YamlBlock.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+interface YamlBlockProps {
+    content: string;
+    className?: string;
+}
+declare const YamlBlock: React.FC<YamlBlockProps>;
+export default YamlBlock;