@tensor_1/react 2.18.0 → 2.19.1

package/dist/markdown.cjs

@@ -0,0 +1,585 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/markdown.ts
+var markdown_exports = {};
+__export(markdown_exports, {
+  Markdown: () => Markdown,
+  defaultMarkdownIsSafeUrl: () => defaultMarkdownIsSafeUrl,
+  parseInline: () => parseInline,
+  parseMarkdown: () => parseMarkdown,
+  plainText: () => plainText
+});
+module.exports = __toCommonJS(markdown_exports);
+
+// src/cx.ts
+function cx(...args) {
+  return args.filter(Boolean).join(" ");
+}
+
+// src/markdown-model.ts
+var ASCII_PUNCT = /[!-/:-@[-`{-~]/;
+var WORD = /[\p{L}\p{N}]/u;
+var NAMED_ENTITIES = {
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'",
+  nbsp: "\xA0",
+  copy: "\xA9",
+  reg: "\xAE",
+  hellip: "\u2026",
+  mdash: "\u2014",
+  ndash: "\u2013"
+};
+var ENTITY_RE = /^&(?:#(\d{1,7})|#[xX]([\da-fA-F]{1,6})|([a-zA-Z][a-zA-Z\d]{1,31}));/;
+var ENTITY_GLOBAL = /&(?:#\d{1,7}|#[xX][\da-fA-F]{1,6}|[a-zA-Z][a-zA-Z\d]{1,31});/g;
+var BARE_URL_RE = /^https?:\/\/[^\s<>()]+/;
+var BR_RE = /^<br\s*\/?>/i;
+var AUTOLINK_RE = /^<((?:https?:|mailto:)[^\s<>]*)>/i;
+var decodeEntity = (match) => {
+  const [, dec, hex, name] = match;
+  const code = dec ? Number(dec) : hex ? parseInt(hex, 16) : void 0;
+  if (code !== void 0) return code > 0 && code <= 1114111 ? String.fromCodePoint(code) : "\uFFFD";
+  return name && Object.prototype.hasOwnProperty.call(NAMED_ENTITIES, name) ? NAMED_ENTITIES[name] : null;
+};
+var MAX_SCAN = 2e3;
+var MAX_DEPTH = 12;
+var findBracketEnd = (text, open) => {
+  let depth = 0;
+  const stop = Math.min(text.length, open + MAX_SCAN);
+  for (let i = open; i < stop; i += 1) {
+    const ch = text[i];
+    if (ch === "\\") {
+      i += 1;
+      continue;
+    }
+    if (ch === "`") {
+      const close = text.indexOf("`", i + 1);
+      if (close > 0) {
+        i = close;
+        continue;
+      }
+    }
+    if (ch === "[") depth += 1;
+    else if (ch === "]") {
+      depth -= 1;
+      if (depth === 0) return i;
+    }
+  }
+  return -1;
+};
+var readDestination = (text, open) => {
+  if (text[open] !== "(") return null;
+  let depth = 0;
+  let end = -1;
+  const stop = Math.min(text.length, open + MAX_SCAN);
+  for (let i = open; i < stop; i += 1) {
+    const ch = text[i];
+    if (ch === "\\") {
+      i += 1;
+      continue;
+    }
+    if (ch === "(") depth += 1;
+    else if (ch === ")") {
+      depth -= 1;
+      if (depth === 0) {
+        end = i;
+        break;
+      }
+    }
+  }
+  if (end < 0) return null;
+  const inner = text.slice(open + 1, end).trim();
+  const titled = /^(\S+)\s+(?:"([^"]*)"|'([^']*)')$/.exec(inner);
+  const rawUrl = titled ? titled[1] : inner;
+  const url = rawUrl.replace(/^<(.*)>$/, "$1").replace(/\\([!-/:-@[-`{-~])/g, "$1").replace(ENTITY_GLOBAL, (match) => decodeEntity(ENTITY_RE.exec(match)) ?? match);
+  const title = titled ? titled[2] ?? titled[3] : void 0;
+  return title === void 0 ? { url, end } : { url, title, end };
+};
+var backtickRun = (text, at) => {
+  let end = at;
+  while (text[end] === "`") end += 1;
+  return text.slice(at, end);
+};
+var findCloser = (text, from, delim, misses) => {
+  if (from >= (misses.get(delim) ?? Infinity)) return -1;
+  for (let i = from; i < text.length; i += 1) {
+    const ch = text[i];
+    if (ch === "\\") {
+      i += 1;
+      continue;
+    }
+    if (ch === "`") {
+      const run = backtickRun(text, i);
+      const close = text.indexOf(run, i + run.length);
+      if (close > 0) {
+        i = close + run.length - 1;
+        continue;
+      }
+    }
+    if (text.startsWith(delim, i) && i > from && !/\s/u.test(text[i - 1])) {
+      if (delim[0] === "_" && WORD.test(text[i + delim.length] ?? "")) continue;
+      if (delim.length === 1 && text[i + 1] === delim) {
+        i += 1;
+        continue;
+      }
+      return i;
+    }
+  }
+  misses.set(delim, Math.min(from, misses.get(delim) ?? Infinity));
+  return -1;
+};
+var pushText = (out, value) => {
+  if (!value) return;
+  const last = out[out.length - 1];
+  if (last?.type === "text") last.value += value;
+  else out.push({ type: "text", value });
+};
+function parseInline(text, depth = 0) {
+  const out = [];
+  if (depth > MAX_DEPTH) {
+    pushText(out, text);
+    return out;
+  }
+  const misses = /* @__PURE__ */ new Map();
+  let i = 0;
+  while (i < text.length) {
+    const ch = text[i];
+    const rest = text.slice(i);
+    if (ch === "\\" && ASCII_PUNCT.test(text[i + 1] ?? "")) {
+      pushText(out, text[i + 1]);
+      i += 2;
+      continue;
+    }
+    if (ch === "\n") {
+      out.push({ type: "br" });
+      i += 1;
+      continue;
+    }
+    if (ch === "`") {
+      const run = backtickRun(text, i);
+      const close = text.indexOf(run, i + run.length);
+      if (close > 0 && text[close + run.length] !== "`") {
+        let value = text.slice(i + run.length, close).replace(/\n/g, " ");
+        if (/^ .* $/.test(value) && value.trim()) value = value.slice(1, -1);
+        out.push({ type: "code", value });
+        i = close + run.length;
+        continue;
+      }
+      pushText(out, run);
+      i += run.length;
+      continue;
+    }
+    if (ch === "!" && text[i + 1] === "[") {
+      const end = findBracketEnd(text, i + 1);
+      const dest = end > 0 ? readDestination(text, end + 1) : null;
+      if (dest) {
+        const alt = plainText(parseInline(text.slice(i + 2, end), depth + 1));
+        out.push(dest.title === void 0 ? { type: "image", src: dest.url, alt } : { type: "image", src: dest.url, alt, title: dest.title });
+        i = dest.end + 1;
+        continue;
+      }
+    }
+    if (ch === "[") {
+      const end = findBracketEnd(text, i);
+      const dest = end > 0 ? readDestination(text, end + 1) : null;
+      if (dest) {
+        const children = parseInline(text.slice(i + 1, end), depth + 1);
+        out.push(dest.title === void 0 ? { type: "link", href: dest.url, children } : { type: "link", href: dest.url, title: dest.title, children });
+        i = dest.end + 1;
+        continue;
+      }
+    }
+    if (ch === "<") {
+      const br = BR_RE.exec(rest);
+      if (br) {
+        out.push({ type: "br" });
+        i += br[0].length;
+        continue;
+      }
+      const auto = AUTOLINK_RE.exec(rest);
+      if (auto) {
+        out.push({ type: "link", href: auto[1], children: [{ type: "text", value: auto[1].replace(/^mailto:/i, "") }], bare: true });
+        i += auto[0].length;
+        continue;
+      }
+    }
+    if (ch === "&") {
+      const entity = ENTITY_RE.exec(rest);
+      const decoded = entity ? decodeEntity(entity) : null;
+      if (entity && decoded !== null) {
+        pushText(out, decoded);
+        i += entity[0].length;
+        continue;
+      }
+    }
+    if (ch === "~" && text[i + 1] === "~" && text[i + 2] && !/\s/u.test(text[i + 2])) {
+      const close = findCloser(text, i + 2, "~~", misses);
+      if (close > 0) {
+        out.push({ type: "del", children: parseInline(text.slice(i + 2, close), depth + 1) });
+        i = close + 2;
+        continue;
+      }
+    }
+    if (ch === "*" || ch === "_") {
+      const leftOk = ch === "*" || !WORD.test(text[i - 1] ?? "");
+      const double = text[i + 1] === ch;
+      const delim = double ? ch + ch : ch;
+      const after = text[i + delim.length];
+      if (leftOk && after && !/\s/u.test(after)) {
+        const close = findCloser(text, i + delim.length, delim, misses);
+        if (close > 0) {
+          const children = parseInline(text.slice(i + delim.length, close), depth + 1);
+          out.push(double ? { type: "strong", children } : { type: "em", children });
+          i = close + delim.length;
+          continue;
+        }
+      }
+      const run = new RegExp(`^\\${ch}+`).exec(rest)[0];
+      pushText(out, run);
+      i += run.length;
+      continue;
+    }
+    if (ch === "h" && !WORD.test(text[i - 1] ?? "")) {
+      const bare = BARE_URL_RE.exec(rest);
+      if (bare) {
+        const url = bare[0].replace(/[.,;:!?'"]+$/, "");
+        out.push({ type: "link", href: url, children: [{ type: "text", value: url }], bare: true });
+        i += url.length;
+        continue;
+      }
+    }
+    pushText(out, ch);
+    i += 1;
+  }
+  return out;
+}
+function plainText(nodes) {
+  return nodes.map((n) => {
+    switch (n.type) {
+      case "text":
+      case "code":
+        return n.value;
+      case "br":
+        return " ";
+      case "image":
+        return n.alt;
+      default:
+        return plainText(n.children);
+    }
+  }).join("");
+}
+var FENCE_RE = /^(`{3,}|~{3,})\s*([^`\s]*)/;
+var HEADING_RE = /^(#{1,6})\s+(.*?)(?:\s+#+)?$/;
+var RULE_RE = /^(?:(?:\*\s*){3,}|(?:-\s*){3,}|(?:_\s*){3,})$/;
+var BULLET_RE = /^(\s*)([-*+])\s+(.*)$/;
+var ORDERED_RE = /^(\s*)(\d{1,9})[.)]\s+(.*)$/;
+var TASK_RE = /^\[([ xX])\]\s+(.*)$/;
+var DELIMITER_ROW_RE = /^\s*\|?\s*:?-+:?\s*(?:\|\s*:?-+:?\s*)*\|?\s*$/;
+var indentOf = (s) => s.replace(/\t/g, "    ").length;
+function splitTableRow(line) {
+  let row = line.trim();
+  if (row.startsWith("|")) row = row.slice(1);
+  if (row.endsWith("|") && !row.endsWith("\\|")) row = row.slice(0, -1);
+  const cells = [];
+  let cell = "";
+  let inCode = false;
+  for (let i = 0; i < row.length; i += 1) {
+    const ch = row[i];
+    if (ch === "\\" && row[i + 1] === "|") {
+      cell += "|";
+      i += 1;
+      continue;
+    }
+    if (ch === "`") inCode = !inCode;
+    if (ch === "|" && !inCode) {
+      cells.push(cell.trim());
+      cell = "";
+      continue;
+    }
+    cell += ch;
+  }
+  cells.push(cell.trim());
+  return cells;
+}
+var alignOf = (cell) => {
+  const c = cell.trim();
+  const left = c.startsWith(":");
+  const right = c.endsWith(":");
+  return left && right ? "center" : right ? "right" : left ? "left" : null;
+};
+var matchListLine = (line) => {
+  const bullet = BULLET_RE.exec(line);
+  if (bullet && !RULE_RE.test(line.trim())) return { indent: indentOf(bullet[1]), ordered: false, number: 1, text: bullet[3] };
+  const ordered = ORDERED_RE.exec(line);
+  if (ordered) return { indent: indentOf(ordered[1]), ordered: true, number: Number(ordered[2]), text: ordered[3] };
+  return null;
+};
+var toItem = (text) => {
+  const task = TASK_RE.exec(text);
+  return task ? { checked: task[1] !== " ", children: parseInline(task[2]), lists: [] } : { checked: null, children: parseInline(text), lists: [] };
+};
+var buildList = (lines) => {
+  const lists = [];
+  const stack = [];
+  for (const line of lines) {
+    while (stack.length && line.indent < stack[stack.length - 1].indent) stack.pop();
+    let top = stack[stack.length - 1];
+    if (top && line.indent > top.indent) {
+      const parentItem = top.list.items[top.list.items.length - 1];
+      const nested = { type: "list", ordered: line.ordered, start: line.number, items: [] };
+      parentItem.lists.push(nested);
+      stack.push({ list: nested, indent: line.indent });
+      top = stack[stack.length - 1];
+    } else if (!top || top.list.ordered !== line.ordered) {
+      const list = { type: "list", ordered: line.ordered, start: line.number, items: [] };
+      if (stack.length <= 1) {
+        lists.push(list);
+        stack.length = 0;
+      } else {
+        stack.pop();
+        const parent = stack[stack.length - 1].list;
+        parent.items[parent.items.length - 1].lists.push(list);
+      }
+      stack.push({ list, indent: line.indent });
+      top = stack[stack.length - 1];
+    }
+    top.list.items.push(toItem(line.text));
+  }
+  return lists;
+};
+function parseMarkdown(source) {
+  const lines = source.replace(/\r\n?/g, "\n").split("\n");
+  const blocks = [];
+  let paragraph = [];
+  let i = 0;
+  const flush = () => {
+    if (paragraph.length) {
+      blocks.push({ type: "paragraph", children: parseInline(paragraph.join("\n")) });
+      paragraph = [];
+    }
+  };
+  while (i < lines.length) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (trimmed === "") {
+      flush();
+      i += 1;
+      continue;
+    }
+    const fence = FENCE_RE.exec(trimmed);
+    if (fence) {
+      flush();
+      const marker = fence[1];
+      const body = [];
+      i += 1;
+      while (i < lines.length && !lines[i].trim().startsWith(marker)) {
+        body.push(lines[i]);
+        i += 1;
+      }
+      i += 1;
+      blocks.push({ type: "code", lang: fence[2] ?? "", value: body.join("\n") });
+      continue;
+    }
+    const heading = HEADING_RE.exec(trimmed);
+    if (heading) {
+      flush();
+      blocks.push({ type: "heading", level: heading[1].length, children: parseInline(heading[2]) });
+      i += 1;
+      continue;
+    }
+    if (RULE_RE.test(trimmed)) {
+      flush();
+      blocks.push({ type: "rule" });
+      i += 1;
+      continue;
+    }
+    if (trimmed.startsWith(">")) {
+      flush();
+      const quote = [];
+      while (i < lines.length && lines[i].trim().startsWith(">")) {
+        quote.push(lines[i].trim().replace(/^>\s?/, ""));
+        i += 1;
+      }
+      blocks.push({ type: "quote", children: parseInline(quote.join(" ")) });
+      continue;
+    }
+    if (trimmed.includes("|") && i + 1 < lines.length && DELIMITER_ROW_RE.test(lines[i + 1]) && lines[i + 1].includes("-")) {
+      const head = splitTableRow(line);
+      const delimiters = splitTableRow(lines[i + 1]);
+      if (delimiters.length === head.length) {
+        flush();
+        const rows = [];
+        i += 2;
+        while (i < lines.length && lines[i].trim() !== "" && lines[i].includes("|")) {
+          const cells = splitTableRow(lines[i]);
+          rows.push(head.map((_, c) => parseInline(cells[c] ?? "")));
+          i += 1;
+        }
+        blocks.push({ type: "table", align: delimiters.map(alignOf), head: head.map((c) => parseInline(c)), rows });
+        continue;
+      }
+    }
+    const first = matchListLine(line);
+    if (first) {
+      flush();
+      const listLines = [];
+      while (i < lines.length) {
+        const current = lines[i];
+        const item = matchListLine(current);
+        if (item) {
+          if (listLines.length && item.indent <= listLines[0].indent && item.ordered !== listLines[0].ordered) break;
+          listLines.push(item);
+        } else if (current.trim() !== "" && indentOf(current) > listLines[0].indent && listLines.length) {
+          listLines[listLines.length - 1].text += `
+${current.trim()}`;
+        } else {
+          break;
+        }
+        i += 1;
+      }
+      const base = Math.min(...listLines.map((l) => l.indent));
+      blocks.push(...buildList(listLines.map((l) => ({ ...l, indent: l.indent - base }))));
+      continue;
+    }
+    paragraph.push(trimmed);
+    i += 1;
+  }
+  flush();
+  return blocks;
+}
+
+// src/url-policy.ts
+var ALLOWED_START = /^(https?:|mailto:|\/|#|\.\/|\.\.\/)/i;
+var CONTROL_OR_BACKSLASH = /[\x00-\x1f\x7f\\]/;
+var PROTOCOL_RELATIVE = /^[/\\]{2}/;
+function defaultIsSafeUrl(url) {
+  const candidate = url.replace(/[\t\n\r]/g, "").trim();
+  if (CONTROL_OR_BACKSLASH.test(candidate) || PROTOCOL_RELATIVE.test(candidate)) return false;
+  return ALLOWED_START.test(candidate);
+}
+
+// src/components/Markdown.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var defaultMarkdownIsSafeUrl = defaultIsSafeUrl;
+var isExternal = (href) => /^https?:/i.test(href.trim());
+function renderInlines(nodes, policy) {
+  return nodes.map((node, i) => {
+    switch (node.type) {
+      case "text":
+        return node.value;
+      case "br":
+        return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("br", {}, i);
+      case "code":
+        return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("code", { children: node.value }, i);
+      case "strong":
+        return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("strong", { children: renderInlines(node.children, policy) }, i);
+      case "em":
+        return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("em", { children: renderInlines(node.children, policy) }, i);
+      case "del":
+        return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("del", { children: renderInlines(node.children, policy) }, i);
+      case "link": {
+        const children = renderInlines(node.children, policy);
+        if (!node.href.trim() || !policy.isSafeUrl(node.href)) return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { children }, i);
+        return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+          "a",
+          {
+            href: node.href.trim(),
+            title: node.title,
+            ...isExternal(node.href) ? { target: "_blank", rel: "noopener noreferrer" } : {},
+            children
+          },
+          i
+        );
+      }
+      case "image": {
+        const resolved = policy.resolveImageSrc?.(node.src) ?? null;
+        if (resolved) {
+          return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("img", { src: resolved, alt: node.alt, title: node.title, loading: "lazy", decoding: "async" }, i);
+        }
+        const label = node.alt || node.src;
+        if (!node.src.trim() || !policy.isSafeUrl(node.src)) return label;
+        return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("a", { href: node.src.trim(), ...isExternal(node.src) ? { target: "_blank", rel: "noopener noreferrer" } : {}, children: label }, i);
+      }
+    }
+  });
+}
+function renderList(list, policy, key) {
+  const items = list.items.map((item, i) => {
+    const content = renderInlines(item.children, policy);
+    const nested = item.lists.map((sub, n) => renderList(sub, policy, n));
+    if (item.checked === null) {
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("li", { children: [
+        content,
+        nested
+      ] }, i);
+    }
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("li", { className: "uix-markdown__task", "data-checked": item.checked || void 0, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)("input", { type: "checkbox", defaultChecked: item.checked, disabled: true, "aria-label": plainText(item.children) }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { children: content }),
+      nested
+    ] }, i);
+  });
+  const hasTasks = list.items.some((item) => item.checked !== null);
+  const className = hasTasks ? "uix-markdown__tasks" : void 0;
+  return list.ordered ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)("ol", { className, start: list.start !== 1 ? list.start : void 0, children: items }, key) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)("ul", { className, children: items }, key);
+}
+function renderBlock(block, policy, headingOffset, key) {
+  switch (block.type) {
+    case "paragraph":
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", { children: renderInlines(block.children, policy) }, key);
+    case "heading": {
+      const Tag = `h${Math.min(Math.max(block.level + headingOffset, 1), 6)}`;
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Tag, { children: renderInlines(block.children, policy) }, key);
+    }
+    case "code":
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("pre", { children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("code", { "data-language": block.lang || void 0, children: block.value }) }, key);
+    case "quote":
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("blockquote", { children: renderInlines(block.children, policy) }, key);
+    case "rule":
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("hr", {}, key);
+    case "list":
+      return renderList(block, policy, key);
+    case "table":
+      return (
+        // A scrollable region must be reachable from the keyboard.
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "uix-markdown__table", tabIndex: 0, children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("table", { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("thead", { children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("tr", { children: block.head.map((cell, c) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)("th", { scope: "col", style: block.align[c] ? { textAlign: block.align[c] } : void 0, children: renderInlines(cell, policy) }, c)) }) }),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("tbody", { children: block.rows.map((row, r) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)("tr", { children: row.map((cell, c) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)("td", { style: block.align[c] ? { textAlign: block.align[c] } : void 0, children: renderInlines(cell, policy) }, c)) }, r)) })
+        ] }) }, key)
+      );
+  }
+}
+function Markdown({ children, className, isSafeUrl = defaultMarkdownIsSafeUrl, resolveImageSrc, headingOffset = 2 }) {
+  const source = typeof children === "string" ? children : "";
+  if (source.trim() === "") return null;
+  const policy = { isSafeUrl, resolveImageSrc };
+  const blocks = parseMarkdown(source);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: cx("uix-prose", "uix-markdown", className), "data-component": "markdown", children: blocks.map((block, i) => renderBlock(block, policy, headingOffset, i)) });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Markdown,
+  defaultMarkdownIsSafeUrl,
+  parseInline,
+  parseMarkdown,
+  plainText
+});

package/dist/markdown.d.cts

@@ -0,0 +1,115 @@
+import * as react from 'react';
+
+/**
+ * Allows http(s), mailto and same-app references (`/path`, `#anchor`, `./x`, `../x`).
+ * Browsers drop tabs and newlines inside URLs and read `\` as `/`, so those are removed
+ * or refused first: `//evil.test`, `/\evil.test` and `/<TAB>/evil.test` are not
+ * same-app paths.
+ */
+declare function defaultIsSafeUrl(url: string): boolean;
+
+/** Default link policy: http(s), mailto and same-app paths (`/`, `#`, `./`, `../`); never `//host`. */
+declare const defaultMarkdownIsSafeUrl: typeof defaultIsSafeUrl;
+interface MarkdownProps {
+    /** Raw markdown source. Empty or whitespace-only input renders nothing. */
+    children: string;
+    className?: string;
+    /** Link policy. Unsafe links render as their text, never as an anchor. */
+    isSafeUrl?: (url: string) => boolean;
+    /**
+     * Image policy. Return the URL to load, or `null` to show the image as a link
+     * (subject to `isSafeUrl`). Without it, no `<img>` is ever rendered.
+     */
+    resolveImageSrc?: (src: string) => string | null;
+    /**
+     * Added to markdown heading levels so content headings sit below the page's own
+     * (`#` → `<h3>` by default, as in TENSOR's original renderer). Capped at `<h6>`.
+     */
+    headingOffset?: number;
+}
+/**
+ * Safe markdown viewer over `.uix-prose`. It never produces an HTML string and never
+ * uses `dangerouslySetInnerHTML`: author text only becomes React text nodes, raw HTML
+ * shows as literal text, and link/image URLs pass the policy props first.
+ *
+ * Supports headings, paragraphs (single newline = line break), bold, italic,
+ * strikethrough, inline and fenced code, links and bare http(s) URLs, blockquotes,
+ * horizontal rules, nested bulleted/numbered lists, read-only task lists, GFM tables
+ * (in a keyboard-scrollable wrapper) and images gated by `resolveImageSrc`.
+ * Server-component safe.
+ */
+declare function Markdown({ children, className, isSafeUrl, resolveImageSrc, headingOffset }: MarkdownProps): react.JSX.Element | null;
+
+type MarkdownInline = {
+    type: 'text';
+    value: string;
+} | {
+    type: 'code';
+    value: string;
+} | {
+    type: 'strong';
+    children: MarkdownInline[];
+} | {
+    type: 'em';
+    children: MarkdownInline[];
+} | {
+    type: 'del';
+    children: MarkdownInline[];
+} | {
+    type: 'link';
+    href: string;
+    title?: string;
+    children: MarkdownInline[];
+    bare?: boolean;
+} | {
+    type: 'image';
+    src: string;
+    alt: string;
+    title?: string;
+} | {
+    type: 'br';
+};
+type TableAlign = 'left' | 'center' | 'right' | null;
+interface MarkdownListItem {
+    /** `null` for a plain item, otherwise the task state. */
+    checked: boolean | null;
+    children: MarkdownInline[];
+    /** Nested lists. */
+    lists: MarkdownList[];
+}
+interface MarkdownList {
+    type: 'list';
+    ordered: boolean;
+    start: number;
+    items: MarkdownListItem[];
+}
+type MarkdownBlock = {
+    type: 'paragraph';
+    children: MarkdownInline[];
+} | {
+    type: 'heading';
+    level: number;
+    children: MarkdownInline[];
+} | {
+    type: 'code';
+    lang: string;
+    value: string;
+} | {
+    type: 'quote';
+    children: MarkdownInline[];
+} | {
+    type: 'rule';
+} | MarkdownList | {
+    type: 'table';
+    align: TableAlign[];
+    head: MarkdownInline[][];
+    rows: MarkdownInline[][][];
+};
+/** Inline markdown to nodes. Newlines become line breaks. */
+declare function parseInline(text: string, depth?: number): MarkdownInline[];
+/** The text a reader sees, for accessible names and image alt text. */
+declare function plainText(nodes: ReadonlyArray<MarkdownInline>): string;
+/** Markdown source to blocks. Empty or whitespace-only input yields no blocks. */
+declare function parseMarkdown(source: string): MarkdownBlock[];
+
+export { Markdown, type MarkdownBlock, type MarkdownInline, type MarkdownList, type MarkdownListItem, type MarkdownProps, type TableAlign, defaultMarkdownIsSafeUrl, parseInline, parseMarkdown, plainText };