@bendyline/squisq 2.12.0 → 2.12.2

package/dist/{chunk-B3AFOXMA.js → chunk-MPEGJKFJ.js}

@@ -1,10 +1,14 @@
 import {
   extractPlainText,
+  findBlockVideoEmbed,
   findNodesByType,
+  isSvgIslandLang,
   isVideoEmbedUrl,
   mediaKindForUrl,
+  parseTimeSeconds,
+  sanitizeUrl,
   walkMarkdownTree
-} from "./chunk-NNJA7ICB.js";
+} from "./chunk-MWSGNEH6.js";
 
 // src/doc/asciiDiagram/chars.ts
 function toCells(s) {
@@ -1207,6 +1211,277 @@ function isLattice(diagram) {
   );
 }
 
+// src/doc/templates/diagramLayout.ts
+var DEFAULT_OPTS = {
+  gapX: 260,
+  gapY: 140,
+  gridPad: 80,
+  gridOriginX: 80,
+  gridOriginY: 80
+};
+function computeDiagramLayout(children, options = {}) {
+  const opts = { ...DEFAULT_OPTS, ...options };
+  const warnings = [];
+  const entries = [];
+  const unpositionedIdx = [];
+  for (let i = 0; i < children.length; i++) {
+    const c = children[i];
+    const hasX = typeof c.x === "number";
+    const hasY = typeof c.y === "number";
+    if (hasX && hasY) {
+      entries.push({ child: c, pinned: true, x: c.x, y: c.y });
+    } else {
+      entries.push({ child: c, pinned: false, x: 0, y: 0 });
+      unpositionedIdx.push(i);
+    }
+  }
+  if (unpositionedIdx.length > 0) {
+    const cols = Math.max(1, Math.ceil(Math.sqrt(unpositionedIdx.length)));
+    let baseX = opts.gridOriginX;
+    let baseY = opts.gridOriginY;
+    const pinned = entries.filter((e) => e.pinned);
+    if (pinned.length > 0) {
+      const minX = Math.min(...pinned.map((e) => e.x));
+      const maxY = Math.max(...pinned.map((e) => e.y));
+      baseX = minX;
+      baseY = maxY + opts.gridPad + opts.gapY;
+    }
+    unpositionedIdx.forEach((entryIdx, k) => {
+      const col = k % cols;
+      const row = Math.floor(k / cols);
+      entries[entryIdx].x = baseX + col * opts.gapX;
+      entries[entryIdx].y = baseY + row * opts.gapY;
+    });
+  }
+  const nodes = entries.map((e) => ({
+    id: e.child.id,
+    label: e.child.title ?? e.child.id,
+    x: e.x,
+    y: e.y,
+    pinned: e.pinned,
+    ...e.child.classes && e.child.classes.length > 0 ? { classes: e.child.classes } : {}
+  }));
+  const nodeIds = new Set(nodes.map((n) => n.id));
+  const edges = [];
+  const seenEdgeIds = /* @__PURE__ */ new Set();
+  for (const child of children) {
+    if (!child.connectsTo) continue;
+    for (const conn of child.connectsTo) {
+      if (!nodeIds.has(conn.target)) {
+        warnings.push(`Edge from "${child.id}" to "${conn.target}" dropped: no such sibling node`);
+        continue;
+      }
+      const edgeId = makeEdgeId(child.id, conn);
+      if (seenEdgeIds.has(edgeId)) continue;
+      seenEdgeIds.add(edgeId);
+      edges.push({
+        id: edgeId,
+        source: child.id,
+        target: conn.target,
+        ...conn.type ? { type: conn.type } : {}
+      });
+    }
+  }
+  return { nodes, edges, warnings };
+}
+function makeEdgeId(source, conn) {
+  return conn.type ? `${source}->${conn.target}:${conn.type}` : `${source}->${conn.target}`;
+}
+
+// src/doc/asciiDiagram/types.ts
+var ASCII_CHAR_W = 14;
+var ASCII_CHAR_H = 28;
+
+// src/doc/asciiDiagram/mapping.ts
+function asciiCellToCanvas(col, row) {
+  return { x: col * ASCII_CHAR_W, y: row * ASCII_CHAR_H };
+}
+function canvasToAsciiCell(x, y) {
+  return {
+    col: Math.max(0, Math.round(x / ASCII_CHAR_W)),
+    row: Math.max(0, Math.round(y / ASCII_CHAR_H))
+  };
+}
+function asciiDiagramToTemplateData(diagram) {
+  const nodes = diagram.nodes.map((n) => ({
+    id: n.id,
+    label: n.label,
+    ...asciiCellToCanvas(n.col, n.row),
+    w: n.wCols * ASCII_CHAR_W,
+    h: n.hRows * ASCII_CHAR_H,
+    ...n.containerId ? { container: n.containerId } : {}
+  }));
+  const anchors = inferEdgeAnchors(nodes, diagram.edges);
+  const edges = diagram.edges.map((e, index) => ({
+    source: e.source,
+    target: e.target,
+    ...e.label ? { label: e.label } : {},
+    ...e.directed ? {} : { directed: false },
+    ...anchors[index],
+    routing: "orthogonal"
+  }));
+  return { nodes, edges };
+}
+function inferEdgeAnchors(nodes, edges) {
+  const nodeById = new Map(nodes.map((node) => [node.id, node]));
+  const pairs = edges.map((edge) => {
+    const source = nodeById.get(edge.source);
+    const target = nodeById.get(edge.target);
+    if (!source || !target) {
+      return {
+        sourceAnchor: { side: "right", offset: 0.5 },
+        targetAnchor: { side: "left", offset: 0.5 }
+      };
+    }
+    const sourceW = source.w ?? ASCII_CHAR_W * 12;
+    const sourceH = source.h ?? ASCII_CHAR_H * 3;
+    const targetW = target.w ?? ASCII_CHAR_W * 12;
+    const targetH = target.h ?? ASCII_CHAR_H * 3;
+    const dx = target.x + targetW / 2 - (source.x + sourceW / 2);
+    const dy = target.y + targetH / 2 - (source.y + sourceH / 2);
+    const horizontalDistance = Math.abs(dx) / Math.max(1, (sourceW + targetW) / 2);
+    const verticalDistance = Math.abs(dy) / Math.max(1, (sourceH + targetH) / 2);
+    if (verticalDistance >= horizontalDistance) {
+      return dy >= 0 ? {
+        sourceAnchor: { side: "bottom", offset: 0.5 },
+        targetAnchor: { side: "top", offset: 0.5 }
+      } : {
+        sourceAnchor: { side: "top", offset: 0.5 },
+        targetAnchor: { side: "bottom", offset: 0.5 }
+      };
+    }
+    return dx >= 0 ? {
+      sourceAnchor: { side: "right", offset: 0.5 },
+      targetAnchor: { side: "left", offset: 0.5 }
+    } : {
+      sourceAnchor: { side: "left", offset: 0.5 },
+      targetAnchor: { side: "right", offset: 0.5 }
+    };
+  });
+  distributeOffsets(pairs, edges, nodes, "source");
+  distributeOffsets(pairs, edges, nodes, "target");
+  coalesceAlignedFanOutAnchors(pairs, edges, nodes);
+  return pairs;
+}
+function coalesceAlignedFanOutAnchors(pairs, edges, nodes) {
+  const nodeById = new Map(nodes.map((node) => [node.id, node]));
+  const groups = /* @__PURE__ */ new Map();
+  edges.forEach((edge, index) => {
+    const group = groups.get(edge.source) ?? [];
+    group.push(index);
+    groups.set(edge.source, group);
+  });
+  for (const [sourceId, indexes] of groups) {
+    if (indexes.length < 2) continue;
+    const source = nodeById.get(sourceId);
+    const targets = indexes.map((index) => nodeById.get(edges[index].target)).filter((node) => node !== void 0);
+    if (!source || targets.length !== indexes.length) continue;
+    const sourceW = source.w ?? ASCII_CHAR_W * 12;
+    const sourceH = source.h ?? ASCII_CHAR_H * 3;
+    const sourceRight = source.x + sourceW;
+    const sourceBottom = source.y + sourceH;
+    const targetRight = (target) => target.x + (target.w ?? ASCII_CHAR_W * 12);
+    const targetBottom = (target) => target.y + (target.h ?? ASCII_CHAR_H * 3);
+    let sourceSide;
+    let targetSide;
+    if (targets.every((target) => target.y >= sourceBottom)) {
+      sourceSide = "bottom";
+      targetSide = "top";
+    } else if (targets.every((target) => targetBottom(target) <= source.y)) {
+      sourceSide = "top";
+      targetSide = "bottom";
+    } else if (targets.every((target) => target.x >= sourceRight)) {
+      sourceSide = "right";
+      targetSide = "left";
+    } else if (targets.every((target) => targetRight(target) <= source.x)) {
+      sourceSide = "left";
+      targetSide = "right";
+    }
+    if (!sourceSide || !targetSide) continue;
+    for (const index of indexes) {
+      pairs[index] = {
+        sourceAnchor: { side: sourceSide, offset: 0.5 },
+        targetAnchor: { side: targetSide, offset: 0.5 }
+      };
+    }
+  }
+}
+function distributeOffsets(pairs, edges, nodes, endpoint) {
+  const nodeById = new Map(nodes.map((node) => [node.id, node]));
+  const groups = /* @__PURE__ */ new Map();
+  for (let index = 0; index < edges.length; index++) {
+    const edge = edges[index];
+    const anchor = endpoint === "source" ? pairs[index].sourceAnchor : pairs[index].targetAnchor;
+    const nodeId = endpoint === "source" ? edge.source : edge.target;
+    const key = `${nodeId}:${anchor.side}`;
+    const group = groups.get(key) ?? [];
+    group.push(index);
+    groups.set(key, group);
+  }
+  for (const indexes of groups.values()) {
+    if (indexes.length < 2) continue;
+    const side = endpoint === "source" ? pairs[indexes[0]].sourceAnchor.side : pairs[indexes[0]].targetAnchor.side;
+    indexes.sort((a, b) => {
+      const oppositeA = nodeById.get(endpoint === "source" ? edges[a].target : edges[a].source);
+      const oppositeB = nodeById.get(endpoint === "source" ? edges[b].target : edges[b].source);
+      const axisA = side === "top" || side === "bottom" ? oppositeA?.x ?? 0 : oppositeA?.y ?? 0;
+      const axisB = side === "top" || side === "bottom" ? oppositeB?.x ?? 0 : oppositeB?.y ?? 0;
+      return axisA - axisB || a - b;
+    });
+    indexes.forEach((edgeIndex, rank) => {
+      const anchor = endpoint === "source" ? pairs[edgeIndex].sourceAnchor : pairs[edgeIndex].targetAnchor;
+      anchor.offset = (rank + 1) / (indexes.length + 1);
+    });
+  }
+}
+function asciiDiagramFromTemplateData(nodes, edges, options = {}) {
+  const ids = new Set(nodes.map((n) => n.id));
+  const outNodes = nodes.map((n) => {
+    const { col, row } = canvasToAsciiCell(n.x, n.y);
+    const labelLines = n.label.length > 0 ? n.label.split("\n") : [];
+    const innerW = labelLines.reduce((w, l) => Math.max(w, l.length), 0);
+    const wCols = typeof n.w === "number" ? Math.max(3, Math.round(n.w / ASCII_CHAR_W)) : innerW + 4;
+    const hRows = typeof n.h === "number" ? Math.max(3, Math.round(n.h / ASCII_CHAR_H)) : labelLines.length + 2;
+    return {
+      id: n.id,
+      label: n.label,
+      col,
+      row,
+      wCols: Math.max(wCols, 3),
+      hRows: Math.max(hRows, 3),
+      ...n.container && ids.has(n.container) && n.container !== n.id ? { containerId: n.container } : {}
+    };
+  });
+  return {
+    nodes: outNodes,
+    edges: edges.filter((e) => ids.has(e.source) && ids.has(e.target)).map((e) => ({
+      source: e.source,
+      target: e.target,
+      ...e.label ? { label: e.label } : {},
+      directed: e.directed !== false
+    })),
+    style: options.style ?? "unicode",
+    warnings: []
+  };
+}
+function asciiDiagramFromBlocks(children, options = {}) {
+  const layout = computeDiagramLayout(children);
+  const nodes = layout.nodes.map((n) => ({
+    id: n.id,
+    label: n.label,
+    x: n.x,
+    y: n.y
+  }));
+  const edges = layout.edges.map((e) => ({
+    source: e.source,
+    target: e.target,
+    ...e.type ? { label: e.type } : {}
+  }));
+  const diagram = asciiDiagramFromTemplateData(nodes, edges, options);
+  diagram.warnings.push(...layout.warnings);
+  return diagram;
+}
+
 // src/doc/asciiTimeline/wrappedFlow.ts
 var UNDERLINE_RE = /[─━═-]{6,}/gu;
 var FLOW_CHAR_RE = /[─━═│|►◄→←┌┐└┘├┤]/u;
@@ -2213,6 +2488,33 @@ function isAsciiTimelineFence(node) {
   return detectAsciiTimeline(node.value, { explicit: isExplicitTimelineLang(node.lang) }).isTimeline;
 }
 
+// src/doc/asciiTimeline/mapping.ts
+function asciiTimelineToTemplateData(timeline) {
+  const globalStart = timeline.tracks.length > 0 ? Math.min(...timeline.tracks.map((track) => track.startColumn)) : 0;
+  const globalEnd = timeline.tracks.length > 0 ? Math.max(...timeline.tracks.map((track) => track.endColumn)) : 1;
+  const span = Math.max(1, globalEnd - globalStart);
+  const tracks = timeline.tracks.map((track) => ({
+    id: track.id,
+    ...track.label ? { label: track.label } : {},
+    ...track.endLabel ? { endLabel: track.endLabel } : {},
+    events: track.events.map((event) => ({
+      id: event.id,
+      label: event.label,
+      ...event.description ? { description: event.description } : {},
+      position: clamp01((event.column - globalStart) / span),
+      ...event.side ? { side: event.side } : {},
+      ...event.descriptionSide ? { descriptionSide: event.descriptionSide } : {},
+      ...event.callout === false ? { callout: false } : {},
+      ...event.marker ? { marker: event.marker } : {}
+    }))
+  }));
+  const links = timeline.links.map((link) => ({ ...link }));
+  return { tracks, links };
+}
+function clamp01(value) {
+  return Math.max(0, Math.min(1, value));
+}
+
 // src/doc/treeview/chars.ts
 var RAIL_CHARS = /* @__PURE__ */ new Set(["\u2502", "\u2503", "\u254E", "\u254F", "\u2551", "|"]);
 var BRANCH_TEE = /* @__PURE__ */ new Set(["\u251C", "\u2523", "\u2520", "\u251D", "\u2560", "\u255E"]);
@@ -2450,6 +2752,61 @@ function countNodes(nodes) {
   return n;
 }
 
+// src/doc/treeview/mapping.ts
+function treeToTemplateData(tree) {
+  return { items: tree.roots.map(toItem) };
+}
+function toItem(node) {
+  return {
+    id: node.id,
+    label: node.label,
+    ...node.isDir ? { isDir: true } : {},
+    ...node.comment ? { comment: node.comment } : {},
+    children: node.children.map(toItem)
+  };
+}
+function treeFromTemplateData(items, options = {}) {
+  const roots = items.map(fromItem);
+  return { roots, style: options.style ?? "unicode", warnings: [] };
+}
+function fromItem(item) {
+  const children = Array.isArray(item.children) ? item.children.map(fromItem) : [];
+  return {
+    id: typeof item.id === "string" && item.id ? item.id : "node",
+    label: typeof item.label === "string" ? item.label : "",
+    children,
+    isDir: item.isDir === true || children.length > 0,
+    ...item.comment ? { comment: item.comment } : {}
+  };
+}
+function treeFromMarkdownList(list) {
+  const usedIds = /* @__PURE__ */ new Map();
+  const slugify3 = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "node";
+  const idFor = (label) => {
+    const base = slugify3(label.replace(/\/$/, ""));
+    const count = usedIds.get(base) ?? 0;
+    usedIds.set(base, count + 1);
+    return count === 0 ? base : `${base}-${count + 1}`;
+  };
+  const itemToNode = (item) => {
+    const labelNode = item.children.find((c) => c.type !== "list");
+    const label = labelNode ? extractPlainText(labelNode).trim() : "";
+    const childLists = item.children.filter((c) => c.type === "list");
+    const children = [];
+    for (const cl of childLists) for (const ci of cl.children) children.push(itemToNode(ci));
+    return {
+      id: idFor(label),
+      label,
+      children,
+      isDir: label.endsWith("/") || children.length > 0
+    };
+  };
+  return { roots: list.children.map(itemToNode), style: "unicode", warnings: [] };
+}
+function findFirstList(contents) {
+  return contents?.find((n) => n.type === "list");
+}
+
 // src/recommend/numberHighlight.ts
 var NUMBER_HIGHLIGHT_RE = /(?:[$€£¥]\s?\d+(?:[.,]\d+)*(?:\s?(?:[MBK]|million|billion|thousand))?|\d+(?:[.,]\d+)*\s?(?:%|‰|x|×|[MBK]|million|billion|thousand|percent|years?|days?|hours?)|\d{3,}(?:[.,]\d+)*)/i;
 function matchNumberHighlight(text) {
@@ -2462,6 +2819,649 @@ function matchNumberHighlight(text) {
   };
 }
 
+// src/doc/templateInputs.ts
+var VIDEO_FILE_RE = /\.(?:webm|mp4|mov|m4v|ogv)(?:[?#].*)?$/i;
+function extractHostedVideos(contents, limit = Infinity) {
+  const found = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const node of contents ?? []) {
+    if (found.length >= limit) break;
+    const video = findBlockVideoEmbed(node);
+    if (!video || seen.has(video.embed.watchUrl)) continue;
+    seen.add(video.embed.watchUrl);
+    found.push({
+      url: video.embed.watchUrl,
+      title: video.title,
+      aspectRatio: video.embed.aspectRatio
+    });
+  }
+  return found;
+}
+function isPictureFence(node) {
+  if (node.type !== "code") return false;
+  return node.lang?.trim().toLowerCase() === "mermaid" || isSvgIslandLang(node.lang);
+}
+function isMaterializedMediaNode(node) {
+  if (node.type === "code") return isPictureFence(node);
+  return findBlockVideoEmbed(node) !== null;
+}
+function extractBodyPlainText(contents) {
+  if (!contents || contents.length === 0) return "";
+  return contents.filter((node) => !isMaterializedMediaNode(node)).map((n) => extractPlainText(n)).join("\n").trim();
+}
+function extractListItems(contents) {
+  return extractRichListItems(contents).map((item) => item.text);
+}
+function escapeInlineHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function renderInlineHtml(nodes) {
+  return nodes.map((node) => {
+    switch (node.type) {
+      case "text":
+        return escapeInlineHtml(node.value);
+      case "emphasis":
+        return `<em>${renderInlineHtml(node.children)}</em>`;
+      case "strong":
+        return `<strong>${renderInlineHtml(node.children)}</strong>`;
+      case "delete":
+        return `<del>${renderInlineHtml(node.children)}</del>`;
+      case "superscript":
+        return `<sup>${renderInlineHtml(node.children)}</sup>`;
+      case "subscript":
+        return `<sub>${renderInlineHtml(node.children)}</sub>`;
+      case "inlineCode":
+        return `<code>${escapeInlineHtml(node.value)}</code>`;
+      case "link": {
+        const label = renderInlineHtml(node.children);
+        const href = sanitizeUrl(node.url, "link");
+        if (!href) return label;
+        const title = node.title ? ` title="${escapeInlineHtml(node.title)}"` : "";
+        return `<a href="${escapeInlineHtml(href)}"${title}>${label}</a>`;
+      }
+      case "break":
+        return "<br>";
+      case "image":
+        return escapeInlineHtml(node.alt ?? "");
+      case "inlineMath":
+        return escapeInlineHtml(`$${node.value}$`);
+      case "footnoteReference":
+        return escapeInlineHtml(`[^${node.label ?? node.identifier}]`);
+      case "linkReference":
+      case "textDirective":
+        return renderInlineHtml(node.children);
+      case "imageReference":
+        return escapeInlineHtml(node.alt ?? "");
+      case "mention":
+        return escapeInlineHtml(`@${node.displayName}`);
+      case "inlineIcon":
+        return `<i class="fa-${node.family} fa-${node.name}" aria-hidden="true"></i>`;
+      case "htmlInline":
+        return escapeInlineHtml(node.rawHtml);
+    }
+  }).join("");
+}
+function renderMarkdownBlocksHtml(nodes, builds) {
+  const renderBlocks = (blocks) => blocks.map((node, index) => {
+    const previous = blocks[index - 1];
+    const extraBlankLines = previous ? Math.max(0, markdownBlockSeparatorLines(previous, node) - 2) : 0;
+    const sourceGap = '<div data-squisq-source-gap aria-hidden="true"><br></div>'.repeat(
+      extraBlankLines
+    );
+    const html = renderBlock(node);
+    const step = builds?.targets.get(node);
+    return `${sourceGap}${step === void 0 ? html : `<div data-squisq-build-step="${step}">${html}</div>`}`;
+  }).join("");
+  const renderList = (node) => {
+    const tag = node.ordered ? "ol" : "ul";
+    const start = node.ordered && node.start != null ? ` start="${node.start}"` : "";
+    const items = node.children.map((item, index) => {
+      const taskMarker = item.checked == null ? "" : `<span>${item.checked ? "[x]" : "[ ]"} </span>`;
+      const step = builds?.targets.get(item);
+      if (step === void 0) return `<li>${taskMarker}${renderBlocks(item.children)}</li>`;
+      const marker = item.checked == null ? node.ordered ? `${(node.start ?? 1) + index}.` : "\u2022" : item.checked ? "[x]" : "[ ]";
+      let first = true;
+      let own = [];
+      const fragments = [];
+      const flush = () => {
+        if (!first && !own.length) return;
+        fragments.push(
+          `<div data-squisq-build-step="${step}" data-squisq-build-row><span aria-hidden="true">${first ? marker : ""}</span><div>${renderBlocks(own)}</div></div>`
+        );
+        first = false;
+        own = [];
+      };
+      for (const child of item.children) {
+        if (child.type === "list") {
+          flush();
+          fragments.push(renderList(child));
+        } else own.push(child);
+      }
+      flush();
+      return `<li data-squisq-build-item>${fragments.join("")}</li>`;
+    }).join("");
+    return `<${tag}${start}>${items}</${tag}>`;
+  };
+  const renderBlock = (node) => {
+    switch (node.type) {
+      case "paragraph":
+        return `<p>${renderInlineHtml(node.children)}</p>`;
+      case "heading":
+        return `<h${node.depth}>${renderInlineHtml(node.children)}</h${node.depth}>`;
+      case "blockquote":
+        return `<blockquote>${renderBlocks(node.children)}</blockquote>`;
+      case "list":
+        return renderList(node);
+      case "code":
+        return `<pre><code>${escapeInlineHtml(node.value)}</code></pre>`;
+      case "thematicBreak":
+        return "<hr>";
+      case "table": {
+        const [head, ...body] = node.children;
+        const row = (cells, header) => `<tr>${cells.map((cell, columnIndex) => {
+          const tag = header ? "th" : "td";
+          const alignment = node.align?.[columnIndex];
+          const alignAttribute = alignment ? ` align="${alignment}"` : "";
+          return `<${tag}${alignAttribute}>${renderInlineHtml(cell.children)}</${tag}>`;
+        }).join("")}</tr>`;
+        const thead = head ? `<thead>${row(head.children, true)}</thead>` : "";
+        const tbody = body.length ? `<tbody>${body.map((item) => row(item.children, false)).join("")}</tbody>` : "";
+        return `<div data-squisq-table-scroll role="region" aria-label="Scrollable data table"><table>${thead}${tbody}</table></div>`;
+      }
+      case "math":
+        return `<pre><code>${escapeInlineHtml(node.value)}</code></pre>`;
+      case "definition":
+        return "";
+      default: {
+        const text = extractPlainText(node).trim();
+        return text ? `<p>${escapeInlineHtml(text)}</p>` : "";
+      }
+    }
+  };
+  return renderBlocks(nodes);
+}
+function markdownBlockSeparatorLines(previous, next) {
+  const previousEndLine = previous.position?.end.line;
+  const nextStartLine = next.position?.start.line;
+  if (previousEndLine == null || nextStartLine == null || nextStartLine <= previousEndLine) {
+    return 2;
+  }
+  return Math.max(2, nextStartLine - previousEndLine);
+}
+function renderListItemHtml(markdown) {
+  return markdown.map(
+    (node) => node.type === "paragraph" || node.type === "heading" ? renderInlineHtml(node.children) : escapeInlineHtml(extractPlainText(node))
+  ).join("<br>");
+}
+function extractRichListItems(contents) {
+  if (!contents) return [];
+  const items = [];
+  for (const node of contents) {
+    if (node.type !== "list") continue;
+    for (const item of node.children) {
+      const text = extractPlainText(item).trim();
+      if (!text) continue;
+      const html = renderListItemHtml(item.children);
+      const plainHtml = escapeInlineHtml(text).replace(/\r?\n/g, "<br>");
+      items.push({
+        text,
+        markdown: item.children,
+        ...html && html !== plainHtml ? { html } : {}
+      });
+    }
+  }
+  return items;
+}
+function parseDim(raw) {
+  if (raw === void 0) return void 0;
+  const n = parseFloat(raw);
+  return Number.isFinite(n) && n > 0 ? n : void 0;
+}
+function extractImages(contents, limit = Infinity) {
+  if (!contents || contents.length === 0) return [];
+  const found = [];
+  function fromHtml(nodes) {
+    for (const node of nodes) {
+      if (found.length >= limit) return;
+      if (!node || typeof node !== "object") continue;
+      const n = node;
+      if (n.type === "htmlElement" && n.tagName === "img") {
+        const attrs = n.attributes;
+        if (attrs && typeof attrs.src === "string" && attrs.src) {
+          found.push({
+            src: attrs.src,
+            alt: typeof attrs.alt === "string" ? attrs.alt : "",
+            width: parseDim(attrs.width),
+            height: parseDim(attrs.height)
+          });
+        }
+      }
+      if (Array.isArray(n.children)) fromHtml(n.children);
+    }
+  }
+  function walk(node) {
+    if (found.length >= limit) return;
+    if (!node || typeof node !== "object") return;
+    const n = node;
+    if (n.type === "image" && typeof n.url === "string" && n.url) {
+      if (!mediaKindForUrl(n.url)) {
+        found.push({ src: n.url, alt: typeof n.alt === "string" ? n.alt : "" });
+      }
+      return;
+    }
+    if ((n.type === "htmlBlock" || n.type === "htmlInline") && Array.isArray(n.htmlChildren)) {
+      fromHtml(n.htmlChildren);
+    }
+    if (Array.isArray(n.children)) {
+      for (const child of n.children) walk(child);
+    }
+  }
+  for (const node of contents) {
+    if (found.length >= limit) break;
+    walk(node);
+  }
+  return found;
+}
+function extractFirstImage(contents) {
+  return extractImages(contents, 1)[0] ?? null;
+}
+function extractEmbeddedVideos(contents, limit = Infinity) {
+  if (!contents || contents.length === 0) return [];
+  const found = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (video) => {
+    if (!video.src || found.length >= limit || seen.has(video.src)) return;
+    seen.add(video.src);
+    found.push(video);
+  };
+  function nestedSource(children) {
+    if (!Array.isArray(children)) return void 0;
+    for (const child of children) {
+      if (!child || typeof child !== "object") continue;
+      const node = child;
+      if (node.tagName === "source") {
+        const attrs = node.attributes;
+        if (typeof attrs?.src === "string" && attrs.src) return attrs.src;
+      }
+      const nested = nestedSource(node.children);
+      if (nested) return nested;
+    }
+    return void 0;
+  }
+  function walk(node) {
+    if (found.length >= limit || !node || typeof node !== "object") return;
+    const n = node;
+    if (n.type === "htmlElement" && n.tagName === "video") {
+      const attrs = n.attributes;
+      const src = attrs?.src || nestedSource(n.children);
+      if (src) {
+        const startAt = attrs?.["data-squisq-video-start-at"] ? parseTimeSeconds(attrs["data-squisq-video-start-at"]) : null;
+        const clipStart = attrs?.["data-squisq-video-clip-start"] ? parseTimeSeconds(attrs["data-squisq-video-clip-start"]) : null;
+        const clipEnd = attrs?.["data-squisq-video-clip-end"] ? parseTimeSeconds(attrs["data-squisq-video-clip-end"]) : null;
+        add({
+          src,
+          ...attrs?.poster ? { posterSrc: attrs.poster } : {},
+          alt: attrs?.["aria-label"] || attrs?.title || attrs?.alt || "",
+          ...startAt != null ? { startAt } : {},
+          ...clipStart != null ? { clipStart } : {},
+          ...clipEnd != null ? { clipEnd } : {}
+        });
+      }
+    } else if ((n.type === "link" || n.type === "image") && typeof n.url === "string" && VIDEO_FILE_RE.test(n.url)) {
+      add({
+        src: n.url,
+        alt: typeof n.alt === "string" ? n.alt : extractPlainText(n).trim()
+      });
+    }
+    if (Array.isArray(n.children)) n.children.forEach(walk);
+    if (Array.isArray(n.htmlChildren)) n.htmlChildren.forEach(walk);
+  }
+  contents.forEach(walk);
+  return found;
+}
+function extractFirstEmbeddedVideo(contents) {
+  return extractEmbeddedVideos(contents, 1)[0] ?? null;
+}
+function extractTableFromContents(contents) {
+  if (!contents) return null;
+  for (const node of contents) {
+    if (node.type === "table") {
+      const table = node;
+      const [headerRow, ...bodyRows] = table.children;
+      if (!headerRow) return null;
+      const headers = headerRow.children.map((cell) => extractPlainText(cell).trim());
+      const rows = bodyRows.map((row) => row.children.map((cell) => extractPlainText(cell).trim()));
+      return { headers, rows, align: table.align };
+    }
+  }
+  return null;
+}
+function extractBlockquoteText(contents) {
+  if (!contents) return "";
+  for (const node of contents) {
+    if (node.type === "blockquote") return extractPlainText(node).trim();
+  }
+  return "";
+}
+function firstParagraph(contents) {
+  if (!contents) return null;
+  const index = contents.findIndex((node) => node.type === "paragraph");
+  if (index < 0) return null;
+  return {
+    node: contents[index],
+    index
+  };
+}
+function leadingStrongStat(paragraph) {
+  for (const child of paragraph.children) {
+    if (child.type === "text" && child.value.trim() === "") continue;
+    if (child.type !== "strong") return null;
+    const text = extractPlainText(child).trim();
+    const match = text.match(/^(?:[$€£¥]\s*)?[+-]?\d+(?:[.,]\d+)*(?:\s?(?:[%‰x×]|[A-Za-z]+))?/);
+    return match?.[0].trim() || null;
+  }
+  return null;
+}
+function removeStatPhrase(text, start, end) {
+  const before = text.slice(0, start).trim();
+  let after = text.slice(end);
+  if (!before) after = after.replace(/^\s*(?:[-–—:]\s*)?/, "");
+  else after = after.trim();
+  return [before, after].filter(Boolean).join(" ").trim();
+}
+function bodyWithoutParagraphStat(contents, paragraphIndex, paragraphText, start, end) {
+  if (!contents) return "";
+  return contents.map(
+    (node, index) => index === paragraphIndex ? removeStatPhrase(paragraphText, start, end) : extractPlainText(node).trim()
+  ).filter(Boolean).join("\n").trim();
+}
+function deriveStatHighlightInputs(headingText, contents, bodyText) {
+  const paragraph = firstParagraph(contents);
+  if (paragraph) {
+    const paragraphText = extractPlainText(paragraph.node).trim();
+    const strongStat = leadingStrongStat(paragraph.node);
+    if (strongStat) {
+      const start = paragraphText.indexOf(strongStat);
+      const description = bodyWithoutParagraphStat(
+        contents,
+        paragraph.index,
+        paragraphText,
+        start,
+        start + strongStat.length
+      );
+      return {
+        stat: strongStat,
+        description: description || headingText || strongStat
+      };
+    }
+  }
+  const trimmedHeading = headingText.trim();
+  const headingStat = matchNumberHighlight(trimmedHeading);
+  if (headingStat && headingStat.index === 0 && headingStat.end === trimmedHeading.length) {
+    return { stat: headingText, description: bodyText || headingText };
+  }
+  if (paragraph) {
+    const paragraphText = extractPlainText(paragraph.node).trim();
+    const bodyStat = matchNumberHighlight(paragraphText);
+    if (bodyStat) {
+      const description = bodyWithoutParagraphStat(
+        contents,
+        paragraph.index,
+        paragraphText,
+        bodyStat.index,
+        bodyStat.end
+      );
+      return {
+        stat: bodyStat.value,
+        description: description || headingText || bodyStat.value
+      };
+    }
+  }
+  return { stat: headingText, description: bodyText || headingText };
+}
+function normalizeCoverageText(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function autoTemplatePreservesContent(templateName, contents) {
+  const nodes = contents ?? [];
+  switch (templateName) {
+    case "quote":
+      return nodes.length === 1 && nodes[0]?.type === "blockquote";
+    case "dataTable":
+      return nodes.length === 1 && nodes[0]?.type === "table";
+    case "list":
+      return nodes.length === 1 && nodes[0]?.type === "list";
+    case "diagram":
+    case "timeline":
+      return nodes.length === 1 && nodes[0]?.type === "code";
+    case "tree":
+      return nodes.length === 1 && (nodes[0]?.type === "code" || nodes[0]?.type === "list");
+    case "photoGrid": {
+      const images = extractImages(nodes);
+      if (images.length < 2 || images.length > 4) return false;
+      const bodyText = normalizeCoverageText(extractBodyPlainText(nodes));
+      const representedText = normalizeCoverageText(
+        images.map((image) => image.alt).filter(Boolean).join(" ")
+      );
+      return bodyText === "" || bodyText === representedText;
+    }
+    case "videoWithCaption": {
+      const videos = extractEmbeddedVideos(nodes);
+      if (videos.length + extractHostedVideos(nodes).length !== 1) return false;
+      const bodyText = normalizeCoverageText(extractBodyPlainText(nodes));
+      return bodyText === normalizeCoverageText(videos[0]?.alt ?? "");
+    }
+    case "leftFeature":
+    case "rightFeature":
+    case "statHighlight":
+      return nodes.length > 0 && nodes.every((node) => node.type === "paragraph");
+    default:
+      return false;
+  }
+}
+function deriveTemplateInputs(templateName, headingText, contents, options = {}) {
+  const placeholders = options.placeholders === true;
+  const bodyText = extractBodyPlainText(contents);
+  switch (templateName) {
+    case "statHighlight": {
+      const inputs = deriveStatHighlightInputs(headingText, contents, bodyText);
+      if (options.preserveSourceHeading && headingText && inputs.stat !== headingText && inputs.description !== headingText) {
+        return {
+          ...inputs,
+          description: headingText,
+          ...inputs.description ? { detail: inputs.description } : {}
+        };
+      }
+      return inputs;
+    }
+    case "transcript": {
+      const text = extractBlockquoteText(contents) || bodyText;
+      if (!text && !headingText) {
+        return placeholders ? { speaker: "Speaker", text: "Message" } : null;
+      }
+      return {
+        speaker: headingText || (placeholders ? "Speaker" : ""),
+        text: text || (placeholders ? "Message" : "")
+      };
+    }
+    case "quote": {
+      const quote = extractBlockquoteText(contents) || bodyText;
+      if (quote) return { quote, ...headingText ? { title: headingText } : {} };
+      return { quote: headingText };
+    }
+    case "fullBleedQuote": {
+      const text = extractBlockquoteText(contents) || bodyText || headingText;
+      return { text };
+    }
+    case "pullQuote": {
+      const text = extractBlockquoteText(contents) || bodyText || headingText;
+      const img = extractFirstImage(contents);
+      return {
+        text,
+        ...img ? { backgroundImage: { src: img.src, alt: img.alt || headingText } } : {}
+      };
+    }
+    case "videoPullQuote": {
+      const text = extractBlockquoteText(contents) || bodyText || headingText;
+      const video = extractFirstEmbeddedVideo(contents);
+      return {
+        text,
+        ...video ? {
+          backgroundVideo: {
+            src: video.src,
+            ...video.posterSrc ? { posterSrc: video.posterSrc } : {},
+            alt: video.alt || headingText,
+            ...video.clipStart != null ? { clipStart: video.clipStart } : {},
+            ...video.clipEnd != null ? { clipEnd: video.clipEnd } : {}
+          }
+        } : {}
+      };
+    }
+    case "factCard":
+      return { fact: headingText, explanation: bodyText };
+    case "twoColumn":
+      return headingText ? { header: headingText } : placeholders ? {} : null;
+    case "comparisonBar":
+      return placeholders ? { leftLabel: "A", leftValue: 60, rightLabel: "B", rightValue: 40 } : null;
+    case "list": {
+      const items = extractListItems(contents);
+      const firstList = (contents ?? []).find((n) => n.type === "list");
+      if (items.length > 0) {
+        return {
+          items,
+          // Bullets stay bullets: only a numbered source list renders `1.` markers.
+          ordered: firstList?.ordered === true,
+          ...headingText ? { title: headingText } : {}
+        };
+      }
+      return placeholders ? { items: ["Item 1", "Item 2", "Item 3"] } : null;
+    }
+    case "definitionCard":
+      return { term: headingText, definition: bodyText };
+    case "dateEvent":
+      return { date: headingText, description: bodyText };
+    case "dataTable": {
+      const tableData = extractTableFromContents(contents);
+      if (tableData) return { ...tableData, ...headingText ? { title: headingText } : {} };
+      return placeholders ? { headers: ["Column"], rows: [["Data"]] } : null;
+    }
+    case "barChart":
+    case "columnChart":
+    case "pieChart":
+    case "donutChart":
+    case "lineChart":
+    case "areaChart":
+    case "scatterChart": {
+      const tableData = extractTableFromContents(contents);
+      if (tableData) {
+        return {
+          headers: tableData.headers,
+          rows: tableData.rows,
+          ...headingText ? { title: headingText } : {}
+        };
+      }
+      return placeholders && !bodyText.trim() ? {
+        headers: ["Quarter", "Revenue", "Costs"],
+        rows: [
+          ["Q1", "40", "28"],
+          ["Q2", "55", "31"],
+          ["Q3", "48", "30"],
+          ["Q4", "62", "35"]
+        ],
+        ...headingText ? { title: headingText } : {}
+      } : null;
+    }
+    case "imageWithCaption": {
+      const img = extractFirstImage(contents);
+      if (!img) return placeholders ? { caption: headingText } : null;
+      return { imageSrc: img.src, imageAlt: img.alt || headingText, caption: headingText };
+    }
+    case "bigText": {
+      const img = extractFirstImage(contents);
+      return {
+        title: headingText,
+        ...img ? { imageSrc: img.src, imageAlt: img.alt || headingText } : {}
+      };
+    }
+    case "photoGrid": {
+      const images = extractImages(contents, 4);
+      if (images.length < 2) return placeholders ? {} : null;
+      return {
+        images: images.map((i) => ({ src: i.src, alt: i.alt })),
+        caption: headingText
+      };
+    }
+    case "videoWithCaption": {
+      const video = extractFirstEmbeddedVideo(contents);
+      if (!video) {
+        const hosted = extractHostedVideos(contents, 1)[0];
+        if (hosted) {
+          return {
+            videoSrc: hosted.url,
+            videoAlt: hosted.title || headingText,
+            caption: headingText
+          };
+        }
+        return placeholders ? { caption: headingText } : null;
+      }
+      return {
+        videoSrc: video.src,
+        posterSrc: video.posterSrc,
+        videoAlt: video.alt || headingText,
+        caption: headingText
+      };
+    }
+    case "leftFeature":
+    case "rightFeature": {
+      const img = extractFirstImage(contents);
+      if (!img && !placeholders) return null;
+      return {
+        imageSrc: img?.src ?? "",
+        imageAlt: img?.alt || headingText,
+        imageWidth: img?.width,
+        imageHeight: img?.height,
+        title: headingText,
+        body: bodyText
+      };
+    }
+    case "diagram": {
+      const fences = (contents ?? []).filter((n) => n.type === "code");
+      const fence = fences.length === 1 && isEligibleAsciiFenceLang(fences[0].lang) ? fences[0] : void 0;
+      const detection = fence ? detectAsciiDiagram(fence.value, { explicit: isExplicitDiagramLang(fence.lang) }) : void 0;
+      if (!detection?.isDiagram || !detection.diagram) return placeholders ? {} : null;
+      const { nodes, edges } = asciiDiagramToTemplateData(detection.diagram);
+      return { nodes, edges, ...headingText ? { title: headingText } : {} };
+    }
+    case "timeline": {
+      const fences = (contents ?? []).filter((n) => n.type === "code");
+      const fence = fences.length === 1 && isEligibleAsciiTimelineFenceLang(fences[0].lang) ? fences[0] : void 0;
+      const detection = fence ? detectAsciiTimeline(fence.value, { explicit: true }) : void 0;
+      if (!detection?.isTimeline || !detection.timeline) return placeholders ? {} : null;
+      const { tracks, links } = asciiTimelineToTemplateData(detection.timeline);
+      return { tracks, links, ...headingText ? { title: headingText } : {} };
+    }
+    case "tree": {
+      const fences = (contents ?? []).filter((n) => n.type === "code");
+      const fence = fences.length === 1 && isEligibleTreeFenceLang(fences[0].lang) ? fences[0] : void 0;
+      if (fence) {
+        const detection = detectTree(fence.value, { explicit: isExplicitTreeLang(fence.lang) });
+        if (detection.isTree && detection.tree) {
+          const { items } = treeToTemplateData(detection.tree);
+          return { items, ...headingText ? { title: headingText } : {} };
+        }
+      }
+      const list = findFirstList(contents);
+      if (list) {
+        const { items } = treeToTemplateData(treeFromMarkdownList(list));
+        if (items.length > 0) return { items, ...headingText ? { title: headingText } : {} };
+      }
+      return placeholders ? {} : null;
+    }
+    default:
+      return placeholders ? {} : null;
+  }
+}
+
 // src/recommend/templates.ts
 var EMPTY_PROFILE = Object.freeze({
   hasImage: false,
@@ -2516,7 +3516,7 @@ function profileBlockContents(nodes) {
     if (findNodesByType(node, "blockquote").length > 0) hasBlockquote = true;
     if (findNodesByType(node, "list").length > 0) hasList = true;
     if (findNodesByType(node, "table").length > 0) hasTable = true;
-    plainParts.push(extractPlainText(node));
+    if (!isPictureFence(node)) plainParts.push(extractPlainText(node));
   }
   const root = { type: "document", children: nodes };
   const imgTags = htmlElementsByTag(root, /* @__PURE__ */ new Set(["img"]));
@@ -2697,7 +3697,6 @@ function recommendTemplatesForBlock(profile, allNames) {
 }
 
 export {
-  matchNumberHighlight,
   toCells,
   cellWidth,
   isHoriz,
@@ -2716,6 +3715,14 @@ export {
   isExplicitDiagramLang,
   detectAsciiDiagram,
   isAsciiDiagramFence,
+  computeDiagramLayout,
+  ASCII_CHAR_W,
+  ASCII_CHAR_H,
+  asciiCellToCanvas,
+  canvasToAsciiCell,
+  asciiDiagramToTemplateData,
+  asciiDiagramFromTemplateData,
+  asciiDiagramFromBlocks,
   parseWrappedFlowTimeline,
   isWrappedFlowTimelineSource,
   parseAsciiTimeline,
@@ -2725,6 +3732,7 @@ export {
   isExplicitTimelineLang,
   detectAsciiTimeline,
   isAsciiTimelineFence,
+  asciiTimelineToTemplateData,
   UNICODE_TREE_VOCAB,
   ASCII_TREE_VOCAB,
   parseTree,
@@ -2733,6 +3741,26 @@ export {
   isExplicitTreeLang,
   detectTree,
   isTreeFence,
+  treeToTemplateData,
+  treeFromTemplateData,
+  treeFromMarkdownList,
+  findFirstList,
+  extractHostedVideos,
+  isPictureFence,
+  isMaterializedMediaNode,
+  extractBodyPlainText,
+  extractListItems,
+  renderMarkdownBlocksHtml,
+  markdownBlockSeparatorLines,
+  extractRichListItems,
+  extractImages,
+  extractFirstImage,
+  extractEmbeddedVideos,
+  extractFirstEmbeddedVideo,
+  extractTableFromContents,
+  extractBlockquoteText,
+  autoTemplatePreservesContent,
+  deriveTemplateInputs,
   profileBlockContents,
   pickAutoTemplate,
   recommendTemplatesForBlock