@tensor_1/react 2.17.0 → 2.19.0

package/dist/markdown-model.js

@@ -0,0 +1,438 @@
+const ASCII_PUNCT = /[!-/:-@[-`{-~]/;
+const WORD = /[\p{L}\p{N}]/u;
+const NAMED_ENTITIES = {
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'",
+  nbsp: "\xA0",
+  copy: "\xA9",
+  reg: "\xAE",
+  hellip: "\u2026",
+  mdash: "\u2014",
+  ndash: "\u2013"
+};
+const ENTITY_RE = /^&(?:#(\d{1,7})|#[xX]([\da-fA-F]{1,6})|([a-zA-Z][a-zA-Z\d]{1,31}));/;
+const ENTITY_GLOBAL = /&(?:#\d{1,7}|#[xX][\da-fA-F]{1,6}|[a-zA-Z][a-zA-Z\d]{1,31});/g;
+const BARE_URL_RE = /^https?:\/\/[^\s<>()]+/;
+const BR_RE = /^<br\s*\/?>/i;
+const AUTOLINK_RE = /^<((?:https?:|mailto:)[^\s<>]*)>/i;
+const 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;
+};
+const MAX_SCAN = 2e3;
+const MAX_DEPTH = 12;
+const 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;
+};
+const 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 };
+};
+const backtickRun = (text, at) => {
+  let end = at;
+  while (text[end] === "`") end += 1;
+  return text.slice(at, end);
+};
+const 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;
+};
+const 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("");
+}
+const FENCE_RE = /^(`{3,}|~{3,})\s*([^`\s]*)/;
+const HEADING_RE = /^(#{1,6})\s+(.*?)(?:\s+#+)?$/;
+const RULE_RE = /^(?:(?:\*\s*){3,}|(?:-\s*){3,}|(?:_\s*){3,})$/;
+const BULLET_RE = /^(\s*)([-*+])\s+(.*)$/;
+const ORDERED_RE = /^(\s*)(\d{1,9})[.)]\s+(.*)$/;
+const TASK_RE = /^\[([ xX])\]\s+(.*)$/;
+const DELIMITER_ROW_RE = /^\s*\|?\s*:?-+:?\s*(?:\|\s*:?-+:?\s*)*\|?\s*$/;
+const 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;
+}
+const alignOf = (cell) => {
+  const c = cell.trim();
+  const left = c.startsWith(":");
+  const right = c.endsWith(":");
+  return left && right ? "center" : right ? "right" : left ? "left" : null;
+};
+const 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;
+};
+const toItem = (text) => {
+  const task = TASK_RE.exec(text);
+  return task ? { checked: task[1] !== " ", children: parseInline(task[2]), lists: [] } : { checked: null, children: parseInline(text), lists: [] };
+};
+const 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;
+}
+export {
+  parseInline,
+  parseMarkdown,
+  plainText,
+  splitTableRow
+};