fancy-ui-react 0.2.0

package/dist/internals/markdown/Markdown.js

@@ -0,0 +1,53 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Fragment } from "react";
+import { cn } from "../../utils.js";
+import { parseMarkdown } from "../markdown.js";
+import { MarkdownInline } from "./MarkdownInline.js";
+/* empty css             */
+function renderBlock(block, cursor) {
+  switch (block.type) {
+    case "paragraph":
+      return /* @__PURE__ */ jsxs("p", { className: "ft-md-p", children: [
+        /* @__PURE__ */ jsx(MarkdownInline, { tokens: block.children }),
+        cursor
+      ] });
+    case "heading": {
+      const Heading = `h${block.depth}`;
+      return /* @__PURE__ */ jsxs(Heading, { className: "ft-md-h", "data-depth": block.depth, children: [
+        /* @__PURE__ */ jsx(MarkdownInline, { tokens: block.children }),
+        cursor
+      ] });
+    }
+    case "code":
+      return /* @__PURE__ */ jsx("pre", { className: "ft-md-pre", "data-lang": block.lang || void 0, children: /* @__PURE__ */ jsx("code", { children: block.text }) });
+    case "list": {
+      const items = block.items.map((item, itemIndex) => /* @__PURE__ */ jsxs("li", { children: [
+        /* @__PURE__ */ jsx(MarkdownInline, { tokens: item }),
+        itemIndex === block.items.length - 1 ? cursor : void 0
+      ] }, itemIndex));
+      return block.ordered ? /* @__PURE__ */ jsx("ol", { className: "ft-md-ol", start: block.start, children: items }) : /* @__PURE__ */ jsx("ul", { className: "ft-md-ul", children: items });
+    }
+    case "blockquote":
+      return /* @__PURE__ */ jsx("blockquote", { className: "ft-md-quote", children: /* @__PURE__ */ jsx(Markdown, { blocks: block.children, trailingCursor: cursor }) });
+    case "table":
+      return /* @__PURE__ */ jsx("div", { className: "ft-md-table-scroll", children: /* @__PURE__ */ jsxs("table", { className: "ft-md-table", children: [
+        /* @__PURE__ */ jsx("thead", { children: /* @__PURE__ */ jsx("tr", { children: block.header.map((cell, i) => /* @__PURE__ */ jsx("th", { style: { textAlign: block.align[i] ?? void 0 }, children: /* @__PURE__ */ jsx(MarkdownInline, { tokens: cell }) }, i)) }) }),
+        /* @__PURE__ */ jsx("tbody", { children: block.rows.map((row, rowIndex) => /* @__PURE__ */ jsx("tr", { children: row.map((cell, i) => /* @__PURE__ */ jsx("td", { style: { textAlign: block.align[i] ?? void 0 }, children: /* @__PURE__ */ jsx(MarkdownInline, { tokens: cell }) }, i)) }, rowIndex)) })
+      ] }) });
+    case "hr":
+      return /* @__PURE__ */ jsx("hr", { className: "ft-md-hr" });
+  }
+}
+function Markdown({ text = "", className, blocks, trailingCursor }) {
+  const nodes = blocks ?? parseMarkdown(text);
+  const lastIndex = nodes.length - 1;
+  return /* @__PURE__ */ jsx("div", { className: cn("ft-md", className), children: nodes.map((block, index) => (
+    // Blocks have no identity beyond their position; a streamed document
+    // is re-parsed and re-rendered whole on every chunk.
+    /* @__PURE__ */ jsx(Fragment, { children: renderBlock(block, index === lastIndex ? trailingCursor : void 0) }, index)
+  )) });
+}
+export {
+  Markdown
+};

package/dist/internals/markdown/MarkdownInline.d.ts

@@ -0,0 +1,5 @@
+import type { InlineToken } from "../markdown.js";
+export interface MarkdownInlineProps {
+    tokens: InlineToken[];
+}
+export declare function MarkdownInline({ tokens }: MarkdownInlineProps): import("react").JSX.Element;

package/dist/internals/markdown/MarkdownInline.js

@@ -0,0 +1,40 @@
+"use client";
+import { jsx, Fragment } from "react/jsx-runtime";
+import { Fragment as Fragment$1 } from "react";
+/* empty css             */
+function renderToken(token) {
+  switch (token.type) {
+    case "text":
+      return token.text;
+    case "code":
+      return /* @__PURE__ */ jsx("code", { className: "ft-md-code", children: token.text });
+    case "strong":
+      return /* @__PURE__ */ jsx("strong", { children: /* @__PURE__ */ jsx(MarkdownInline, { tokens: token.children }) });
+    case "em":
+      return /* @__PURE__ */ jsx("em", { children: /* @__PURE__ */ jsx(MarkdownInline, { tokens: token.children }) });
+    case "del":
+      return /* @__PURE__ */ jsx("del", { children: /* @__PURE__ */ jsx(MarkdownInline, { tokens: token.children }) });
+    case "link":
+      return token.href !== null ? /* @__PURE__ */ jsx(
+        "a",
+        {
+          className: "ft-md-link",
+          href: token.href,
+          rel: "noopener noreferrer nofollow ugc",
+          target: "_blank",
+          children: /* @__PURE__ */ jsx(MarkdownInline, { tokens: token.children })
+        }
+      ) : /* @__PURE__ */ jsx(MarkdownInline, { tokens: token.children });
+  }
+}
+function MarkdownInline({ tokens }) {
+  return /* @__PURE__ */ jsx(Fragment, { children: tokens.map((token, index) => (
+    // A token list has no stable identity of its own; the index is the
+    // only key available, and the tree is re-rendered wholesale on every
+    // streamed chunk anyway.
+    /* @__PURE__ */ jsx(Fragment$1, { children: renderToken(token) }, index)
+  )) });
+}
+export {
+  MarkdownInline
+};

package/dist/internals/markdown.d.ts

@@ -0,0 +1,66 @@
+/**
+ * A deliberately small markdown reader for chat / assistant message surfaces.
+ *
+ * It produces a token tree, never a string of HTML: the renderer walks the
+ * tokens with plain Svelte markup, so anything that is not an explicitly
+ * supported construct ends up as escaped text instead of live markup.
+ *
+ * Supported: paragraphs, ATX headings, fenced code, flat lists, blockquotes,
+ * thematic breaks, pipe tables, and inline strong / em / del / code / link.
+ * Everything else (nested lists, setext headings, images, raw HTML, autolinks,
+ * footnotes) degrades to text rather than being parsed.
+ *
+ * Every entry point is total: it returns a value for any input, including
+ * half-written markdown from a stream.
+ */
+export type InlineToken = {
+    type: "text";
+    text: string;
+} | {
+    type: "code";
+    text: string;
+} | {
+    type: "strong" | "em" | "del";
+    children: InlineToken[];
+} | {
+    type: "link";
+    href: string | null;
+    children: InlineToken[];
+};
+export type TableAlign = "left" | "center" | "right" | null;
+export type BlockToken = {
+    type: "paragraph";
+    children: InlineToken[];
+} | {
+    type: "heading";
+    depth: 1 | 2 | 3 | 4 | 5 | 6;
+    children: InlineToken[];
+} | {
+    type: "code";
+    lang: string;
+    text: string;
+} | {
+    type: "list";
+    ordered: boolean;
+    start: number;
+    items: InlineToken[][];
+} | {
+    type: "blockquote";
+    children: BlockToken[];
+} | {
+    type: "table";
+    align: TableAlign[];
+    header: InlineToken[][];
+    rows: InlineToken[][][];
+} | {
+    type: "hr";
+};
+/**
+ * Returns a URL safe to put in an `href`, or `null` when the scheme is not one
+ * we are willing to link to. Entities are never decoded first — a browser
+ * decodes them after the attribute is set, so decoding here would let
+ * `javascript:` through a check that the raw string fails.
+ */
+export declare function sanitizeHref(raw: string): string | null;
+export declare function parseInline(src: string): InlineToken[];
+export declare function parseMarkdown(src: string): BlockToken[];

package/dist/internals/markdown.js

@@ -0,0 +1,467 @@
+"use client";
+const ALLOWED_SCHEMES = /* @__PURE__ */ new Set(["http", "https", "mailto"]);
+const ESCAPABLE = "\\`*_{}[]()#+-.!>~|";
+const MAX_INLINE_DEPTH = 12;
+const MAX_BLOCK_DEPTH = 8;
+const MAX_LINK_LABEL = 999;
+const MAX_LINK_DEST = 2048;
+const MAX_INPUT = 1e5;
+const RE_HR = /^ {0,3}-{3,}[ \t]*$/;
+const RE_HEADING = /^ {0,3}(#{1,6})(?:[ \t]+(.*))?$/;
+const RE_QUOTE = /^ {0,3}>/;
+const RE_QUOTE_STRIP = /^ {0,3}> ?/;
+const RE_BULLET = /^ {0,3}([-*])(?:[ \t]+(.*))?$/;
+const RE_ORDERED = /^ {0,3}(\d{1,9})[.)](?:[ \t]+(.*))?$/;
+const RE_ALIGN_CELL = /^:?-+:?$/;
+function stripClosingHashes(raw) {
+  const content = raw.trimEnd();
+  let end = content.length;
+  while (end > 0 && content[end - 1] === "#") end--;
+  if (end === content.length) return content;
+  if (end === 0) return "";
+  const before = content[end - 1];
+  if (before === " " || before === "	") return content.slice(0, end).trimEnd();
+  return content;
+}
+function sanitizeHref(raw) {
+  if (typeof raw !== "string") return null;
+  const cleaned = raw.replace(/^[\u0000-\u0020]+/, "").replace(/[\u0000-\u001F\u007F]/g, "");
+  if (cleaned === "") return null;
+  const scheme = /^([a-zA-Z][a-zA-Z0-9+.-]*):/.exec(cleaned);
+  if (scheme && !ALLOWED_SCHEMES.has(scheme[1].toLowerCase())) return null;
+  return cleaned;
+}
+function parseInline(src) {
+  return parseInlineAt(typeof src === "string" ? src : "", 0, false);
+}
+function parseInlineAt(src, depth, inLink) {
+  if (src === "") return [];
+  if (depth > MAX_INLINE_DEPTH) return [{ type: "text", text: src }];
+  const out = [];
+  let buf = "";
+  let i = 0;
+  let nextClose = -2;
+  let nextParen = -2;
+  function hasCloseAhead(from) {
+    if (nextClose === -1) return false;
+    if (nextClose < from) nextClose = src.indexOf("]", from);
+    return nextClose !== -1;
+  }
+  function hasParenAhead(from) {
+    if (nextParen === -1) return false;
+    if (nextParen < from) nextParen = src.indexOf(")", from);
+    return nextParen !== -1;
+  }
+  let failedSpanRuns = null;
+  let starRunEnd = -1;
+  function starRun(from) {
+    if (from >= starRunEnd) {
+      let end = from;
+      while (src[end] === "*") end++;
+      starRunEnd = end;
+    }
+    return starRunEnd - from;
+  }
+  function flush() {
+    if (buf !== "") {
+      out.push({ type: "text", text: buf });
+      buf = "";
+    }
+  }
+  while (i < src.length) {
+    const c = src[i];
+    if (c === "\\" && i + 1 < src.length && ESCAPABLE.includes(src[i + 1])) {
+      buf += src[i + 1];
+      i += 2;
+      continue;
+    }
+    if (c === "`") {
+      let runEnd = i + 1;
+      while (runEnd < src.length && src[runEnd] === "`") runEnd++;
+      const runLen = runEnd - i;
+      if (!failedSpanRuns?.has(runLen)) {
+        const span = matchCodeSpan(src, i);
+        if (span) {
+          flush();
+          out.push({ type: "code", text: span.text });
+          i = span.end;
+          continue;
+        }
+        (failedSpanRuns ??= /* @__PURE__ */ new Set()).add(runLen);
+      }
+      buf += src.slice(i, runEnd);
+      i = runEnd;
+      continue;
+    }
+    if (c === "!" && src[i + 1] === "[" && hasCloseAhead(i + 1) && hasParenAhead(i + 1)) {
+      const image = matchLink(src, i + 1);
+      if (image) {
+        flush();
+        out.push(...parseInlineAt(image.label, depth + 1, inLink));
+        i = image.end;
+        continue;
+      }
+    }
+    if (c === "[" && !inLink && hasCloseAhead(i) && hasParenAhead(i)) {
+      const link = matchLink(src, i);
+      if (link) {
+        flush();
+        out.push({
+          type: "link",
+          href: sanitizeHref(link.dest),
+          children: parseInlineAt(link.label, depth + 1, true)
+        });
+        i = link.end;
+        continue;
+      }
+    }
+    if (c === "*") {
+      const emphasis = matchEmphasis(src, i, starRun(i));
+      if (emphasis) {
+        flush();
+        out.push({
+          type: emphasis.strong ? "strong" : "em",
+          children: parseInlineAt(emphasis.inner, depth + 1, inLink)
+        });
+        i = emphasis.end;
+        continue;
+      }
+    }
+    if (c === "~" && src[i + 1] === "~") {
+      const close = findCloser(src, i + 2, "~~");
+      if (close > i + 2) {
+        flush();
+        out.push({
+          type: "del",
+          children: parseInlineAt(src.slice(i + 2, close), depth + 1, inLink)
+        });
+        i = close + 2;
+        continue;
+      }
+    }
+    buf += c;
+    i++;
+  }
+  flush();
+  return out;
+}
+function countRun(src, i, ch) {
+  let run = 0;
+  while (src[i + run] === ch) run++;
+  return run;
+}
+function findCloser(src, from, delim) {
+  let i = from;
+  while (i < src.length) {
+    const c = src[i];
+    if (c === "\\") {
+      i += 2;
+      continue;
+    }
+    if (c === "`") {
+      const span = matchCodeSpan(src, i);
+      if (span) {
+        i = span.end;
+        continue;
+      }
+    }
+    if (src.startsWith(delim, i)) return i;
+    i++;
+  }
+  return -1;
+}
+function matchCodeSpan(src, i) {
+  let run = 0;
+  while (src[i + run] === "`") run++;
+  const open = i + run;
+  let j = open;
+  while (j < src.length) {
+    if (src[j] !== "`") {
+      j++;
+      continue;
+    }
+    let close = 0;
+    while (src[j + close] === "`") close++;
+    if (close === run) return { text: normalizeCodeSpan(src.slice(open, j)), end: j + close };
+    j += close;
+  }
+  return null;
+}
+function normalizeCodeSpan(raw) {
+  const text = raw.replace(/\r?\n/g, " ");
+  if (text.length > 2 && text.startsWith(" ") && text.endsWith(" ") && text.trim() !== "") {
+    return text.slice(1, -1);
+  }
+  return text;
+}
+function matchEmphasis(src, i, run = countRun(src, i, "*")) {
+  if (run >= 3) {
+    const close2 = findCloser(src, i + 3, "***");
+    if (close2 > i + 3) {
+      return { strong: true, inner: `*${src.slice(i + 3, close2)}*`, end: close2 + 3 };
+    }
+  }
+  if (run >= 2) {
+    const close2 = findCloser(src, i + 2, "**");
+    if (close2 > i + 2) return { strong: true, inner: src.slice(i + 2, close2), end: close2 + 2 };
+  }
+  const close = findCloser(src, i + 1, "*");
+  if (close > i + 1) return { strong: false, inner: src.slice(i + 1, close), end: close + 1 };
+  return null;
+}
+function matchLink(src, i) {
+  if (src[i] !== "[") return null;
+  let bracket = 0;
+  let j = i;
+  let labelEnd = -1;
+  while (j < src.length) {
+    if (j - i > MAX_LINK_LABEL) return null;
+    const c = src[j];
+    if (c === "\\") {
+      j += 2;
+      continue;
+    }
+    if (c === "`") {
+      const span = matchCodeSpan(src, j);
+      if (span) {
+        j = span.end;
+        continue;
+      }
+    }
+    if (c === "[") bracket++;
+    else if (c === "]") {
+      bracket--;
+      if (bracket === 0) {
+        labelEnd = j;
+        break;
+      }
+    }
+    j++;
+  }
+  if (labelEnd < 0 || src[labelEnd + 1] !== "(") return null;
+  let k = labelEnd + 2;
+  let paren = 1;
+  let dest = "";
+  while (k < src.length) {
+    if (dest.length > MAX_LINK_DEST) return null;
+    const c = src[k];
+    if (c === "\n") return null;
+    if (c === "\\" && k + 1 < src.length) {
+      dest += src[k + 1];
+      k += 2;
+      continue;
+    }
+    if (c === "(") paren++;
+    else if (c === ")") {
+      paren--;
+      if (paren === 0) break;
+    }
+    dest += c;
+    k++;
+  }
+  if (paren !== 0) return null;
+  return { label: src.slice(i + 1, labelEnd), dest: stripDestination(dest), end: k + 1 };
+}
+function stripDestination(dest) {
+  const trimmed = dest.trim();
+  const space = trimmed.search(/\s/);
+  const url = space === -1 ? trimmed : trimmed.slice(0, space);
+  if (url.length > 1 && url.startsWith("<") && url.endsWith(">")) return url.slice(1, -1);
+  return url;
+}
+function parseMarkdown(src) {
+  if (typeof src !== "string" || src === "") return [];
+  const bounded = src.length > MAX_INPUT ? src.slice(0, MAX_INPUT) : src;
+  return parseBlocks(bounded.split(/\r\n|\r|\n/), 0);
+}
+function parseBlocks(lines, depth) {
+  const out = [];
+  if (depth > MAX_BLOCK_DEPTH) {
+    const text = lines.join("\n").trim();
+    if (text !== "") out.push({ type: "paragraph", children: parseInline(text) });
+    return out;
+  }
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (line.trim() === "") {
+      i++;
+      continue;
+    }
+    const fence = matchFence(line);
+    if (fence) {
+      const body = [];
+      i++;
+      while (i < lines.length && !isFenceClose(lines[i], fence.width)) {
+        body.push(lines[i]);
+        i++;
+      }
+      if (i < lines.length) i++;
+      out.push({ type: "code", lang: fence.lang, text: body.join("\n") });
+      continue;
+    }
+    if (RE_HR.test(line)) {
+      out.push({ type: "hr" });
+      i++;
+      continue;
+    }
+    const heading = RE_HEADING.exec(line);
+    if (heading) {
+      const content = stripClosingHashes(heading[2] ?? "");
+      out.push({
+        type: "heading",
+        depth: heading[1].length,
+        children: parseInline(content)
+      });
+      i++;
+      continue;
+    }
+    if (RE_QUOTE.test(line)) {
+      const inner = [];
+      while (i < lines.length && RE_QUOTE.test(lines[i])) {
+        inner.push(lines[i].replace(RE_QUOTE_STRIP, ""));
+        i++;
+      }
+      out.push({ type: "blockquote", children: parseBlocks(inner, depth + 1) });
+      continue;
+    }
+    const table = matchTable(lines, i);
+    if (table) {
+      out.push(table.token);
+      i = table.end;
+      continue;
+    }
+    const list = matchList(lines, i);
+    if (list) {
+      out.push(list.token);
+      i = list.end;
+      continue;
+    }
+    const parts = [line.trim()];
+    i++;
+    while (i < lines.length && lines[i].trim() !== "" && !startsBlock(lines, i)) {
+      parts.push(lines[i].trim());
+      i++;
+    }
+    out.push({ type: "paragraph", children: parseInline(parts.join("\n")) });
+  }
+  return out;
+}
+function startsBlock(lines, i) {
+  const line = lines[i];
+  return matchFence(line) !== null || RE_HR.test(line) || RE_HEADING.test(line) || RE_QUOTE.test(line) || matchListItem(line) !== null || isTableStart(lines, i);
+}
+function matchFence(line) {
+  const m = /^ {0,3}(`{3,})(.*)$/.exec(line);
+  if (!m || m[2].includes("`")) return null;
+  const lang = (m[2].trim().split(/\s+/)[0] ?? "").replace(/[^a-zA-Z0-9_+#.-]/g, "").slice(0, 32);
+  return { width: m[1].length, lang };
+}
+function isFenceClose(line, width) {
+  const m = /^ {0,3}(`{3,})[ \t]*$/.exec(line);
+  return m !== null && m[1].length >= width;
+}
+function matchListItem(line) {
+  if (RE_HR.test(line)) return null;
+  const bullet = RE_BULLET.exec(line);
+  if (bullet) return { ordered: false, start: 1, content: bullet[2] ?? "" };
+  const ordered = RE_ORDERED.exec(line);
+  if (ordered) {
+    return { ordered: true, start: Number.parseInt(ordered[1], 10), content: ordered[2] ?? "" };
+  }
+  return null;
+}
+function matchList(lines, from) {
+  const first = matchListItem(lines[from]);
+  if (!first) return null;
+  const ordered = first.ordered;
+  const items = [];
+  let raw = [first.content];
+  let i = from + 1;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (line.trim() === "") {
+      const next = i + 1 < lines.length ? matchListItem(lines[i + 1]) : null;
+      if (next && next.ordered === ordered) {
+        i++;
+        continue;
+      }
+      break;
+    }
+    const item = matchListItem(line);
+    if (item) {
+      if (item.ordered !== ordered) break;
+      items.push(parseInline(raw.join("\n")));
+      raw = [item.content];
+      i++;
+      continue;
+    }
+    if (startsBlock(lines, i)) break;
+    raw.push(line.trim());
+    i++;
+  }
+  items.push(parseInline(raw.join("\n")));
+  return { token: { type: "list", ordered, start: first.start, items }, end: i };
+}
+function parseAlignRow(line) {
+  if (line === void 0 || !line.includes("|") || !line.includes("-")) return null;
+  const cells = splitTableRow(line);
+  const align = [];
+  for (const cell of cells) {
+    if (!RE_ALIGN_CELL.test(cell)) return null;
+    const left = cell.startsWith(":");
+    const right = cell.endsWith(":");
+    align.push(left && right ? "center" : right ? "right" : left ? "left" : null);
+  }
+  return align.length > 0 ? align : null;
+}
+function isTableStart(lines, i) {
+  const line = lines[i];
+  if (!line.includes("|")) return false;
+  const align = parseAlignRow(lines[i + 1]);
+  return align !== null && splitTableRow(line).length === align.length;
+}
+function matchTable(lines, from) {
+  if (!isTableStart(lines, from)) return null;
+  const align = parseAlignRow(lines[from + 1]);
+  const header = splitTableRow(lines[from]).map((cell) => parseInline(cell));
+  const rows = [];
+  let i = from + 2;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (line.trim() === "" || !line.includes("|")) break;
+    if (matchFence(line) || RE_HEADING.test(line) || RE_QUOTE.test(line)) break;
+    const cells = splitTableRow(line);
+    rows.push(align.map((_, c) => parseInline(cells[c] ?? "")));
+    i++;
+  }
+  return { token: { type: "table", align, header, rows }, end: i };
+}
+function splitTableRow(line) {
+  let s = line.trim();
+  if (s.startsWith("|")) s = s.slice(1);
+  if (s.endsWith("|") && !s.endsWith("\\|")) s = s.slice(0, -1);
+  const cells = [];
+  let cell = "";
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i];
+    if (c === "\\" && s[i + 1] === "|") {
+      cell += "|";
+      i++;
+      continue;
+    }
+    if (c === "|") {
+      cells.push(cell.trim());
+      cell = "";
+      continue;
+    }
+    cell += c;
+  }
+  cells.push(cell.trim());
+  return cells;
+}
+export {
+  parseInline,
+  parseMarkdown,
+  sanitizeHref
+};