@astryxdesign/core 0.6.2-canary.bfee8a4 → 0.6.2-canary.d4cc232

package/dist/Markdown/parser.js

@@ -2,12 +2,10 @@
 
 /**
  * @file parser.ts
- * @input Markdown string
- * @output Array of MarkdownNode AST nodes, including opt-in math; heading slug
- *   helpers
- *   (inlineText, slugify, uniqueSlug) shared by Markdown rendering and
- *   Outline's parseOutlineFromMarkdown
- * @position Core parser; consumed by Markdown.tsx and Outline
+ * @input Markdown string and released parse options
+ * @output Canonical MDAST-aligned nodes for internal consumers plus unchanged
+ *   released parser-node projections; shared heading slug helpers
+ * @position Core parser and compatibility boundary; consumed by Markdown and Outline
  */
 
 // ---------------------------------------------------------------------------
@@ -36,6 +34,207 @@
  * optional fields without breaking anyone.
  */
 
+function projectRange(position) {
+  const start = position?.start.offset;
+  const end = position?.end.offset;
+  return start == null || end == null ? {} : {
+    range: {
+      start,
+      end
+    }
+  };
+}
+function projectInlineNode(node, cache) {
+  const cached = cache.get(node);
+  if (cached != null) {
+    return cached;
+  }
+  let projected;
+  switch (node.type) {
+    case 'text':
+      projected = {
+        type: 'text',
+        content: node.value
+      };
+      break;
+    case 'strong':
+      projected = {
+        type: 'bold',
+        children: node.children.map(child => projectInlineNode(child, cache))
+      };
+      break;
+    case 'emphasis':
+      projected = {
+        type: 'italic',
+        children: node.children.map(child => projectInlineNode(child, cache))
+      };
+      break;
+    case 'delete':
+      projected = {
+        type: 'strikethrough',
+        children: node.children.map(child => projectInlineNode(child, cache))
+      };
+      break;
+    case 'inlineCode':
+      projected = {
+        type: 'code',
+        content: node.value
+      };
+      break;
+    case 'inlineMath':
+      projected = {
+        type: 'math',
+        value: node.value
+      };
+      break;
+    case 'link':
+      projected = {
+        type: 'link',
+        href: node.url,
+        children: node.children.map(child => projectInlineNode(child, cache))
+      };
+      break;
+    case 'image':
+      projected = {
+        type: 'image',
+        src: node.url,
+        alt: node.alt
+      };
+      break;
+    case 'citation':
+      projected = {
+        type: 'citation',
+        sourceId: node.sourceId
+      };
+      break;
+    case 'break':
+      projected = {
+        type: 'break'
+      };
+      break;
+  }
+  cache.set(node, projected);
+  return projected;
+}
+function projectTableCell(node, cache) {
+  const cached = cache.get(node);
+  if (cached != null) {
+    return cached;
+  }
+  const projected = {
+    children: node.children.map(child => projectInlineNode(child, cache))
+  };
+  cache.set(node, projected);
+  return projected;
+}
+function projectListItem(node, cache) {
+  const cached = cache.get(node);
+  if (cached != null) {
+    return cached;
+  }
+  const projected = {
+    checked: node.checked,
+    children: node.children.map(child => projectBlockNode(child, cache))
+  };
+  cache.set(node, projected);
+  return projected;
+}
+function projectBlockNode(node, cache) {
+  const cached = cache.get(node);
+  if (cached != null) {
+    return cached;
+  }
+  const metadata = projectRange(node.position);
+  let projected;
+  switch (node.type) {
+    case 'heading':
+      projected = {
+        type: 'heading',
+        level: node.depth,
+        children: node.children.map(child => projectInlineNode(child, cache)),
+        ...metadata
+      };
+      break;
+    case 'paragraph':
+      projected = {
+        type: 'paragraph',
+        children: node.children.map(child => projectInlineNode(child, cache)),
+        ...metadata
+      };
+      break;
+    case 'code':
+      projected = {
+        type: 'codeblock',
+        language: node.lang ?? 'plaintext',
+        content: node.value,
+        ...metadata
+      };
+      break;
+    case 'math':
+      projected = {
+        type: 'math',
+        value: node.value,
+        ...metadata
+      };
+      break;
+    case 'blockquote':
+      projected = {
+        type: 'blockquote',
+        children: node.children.map(child => projectBlockNode(child, cache)),
+        ...metadata
+      };
+      break;
+    case 'list':
+      projected = {
+        type: 'list',
+        ordered: node.ordered,
+        start: node.start,
+        delimiter: node.delimiter,
+        loose: node.spread,
+        items: node.children.map(item => projectListItem(item, cache)),
+        ...metadata
+      };
+      break;
+    case 'table':
+      {
+        const [header = {
+          type: 'tableRow',
+          children: []
+        }, ...rows] = node.children;
+        projected = {
+          type: 'table',
+          headers: header.children.map(cell => projectTableCell(cell, cache)),
+          alignments: [...node.align],
+          rows: rows.map(row => row.children.map(cell => projectTableCell(cell, cache))),
+          ...metadata
+        };
+        break;
+      }
+    case 'thematicBreak':
+      projected = {
+        type: 'hr',
+        ...metadata
+      };
+      break;
+    case 'image':
+      projected = {
+        type: 'image',
+        alt: node.alt,
+        src: node.url,
+        ...metadata
+      };
+      break;
+  }
+  cache.set(node, projected);
+  return projected;
+}
+function projectInlineNodes(nodes, cache = new WeakMap()) {
+  return nodes.map(node => projectInlineNode(node, cache));
+}
+function projectMarkdownRoot(root, cache = new WeakMap()) {
+  return root.children.map(node => projectBlockNode(node, cache));
+}
+
 // ---------------------------------------------------------------------------
 // Parse options
 // ---------------------------------------------------------------------------
@@ -359,7 +558,7 @@ function matchReferenceLink(text, start, linkDefs, opts) {
         return {
           node: {
             type: 'link',
-            href,
+            url: href,
             children: parseInlineImpl(linkText, opts)
           },
           end: labelClose + 1
@@ -380,7 +579,7 @@ function matchReferenceLink(text, start, linkDefs, opts) {
   return {
     node: {
       type: 'link',
-      href,
+      url: href,
       children: parseInlineImpl(linkText, opts)
     },
     end: textClose + 1
@@ -404,7 +603,7 @@ function matchReferenceImage(text, start, linkDefs) {
         return {
           node: {
             type: 'image',
-            src,
+            url: src,
             alt
           },
           end: labelClose + 1
@@ -423,7 +622,7 @@ function matchReferenceImage(text, start, linkDefs) {
   return {
     node: {
       type: 'image',
-      src,
+      url: src,
       alt
     },
     end: altClose + 1
@@ -571,6 +770,11 @@ function matchBracketCitation(text, i, opts) {
   };
 }
 export function parseInline(text, arg) {
+  return projectInlineNodes(parseInlineAst(text, arg));
+}
+
+/** @internal Canonical inline parse used by Markdown rendering. */
+export function parseInlineAst(text, arg) {
   return parseInlineEntry(text, resolveOptions(arg));
 }
 
@@ -595,7 +799,7 @@ function parseInlineImpl(text, opts) {
     if (text[i] === '\\' && i + 1 < text.length) {
       nodes.push({
         type: 'text',
-        content: text[i + 1]
+        value: text[i + 1]
       });
       i += 2;
       continue;
@@ -608,8 +812,8 @@ function parseInlineImpl(text, opts) {
       const closeIndex = text.indexOf('`'.repeat(tickCount), openIndex);
       if (closeIndex !== -1) {
         nodes.push({
-          type: 'code',
-          content: text.slice(openIndex, closeIndex)
+          type: 'inlineCode',
+          value: text.slice(openIndex, closeIndex)
         });
         i = closeIndex + tickCount;
         continue;
@@ -621,7 +825,7 @@ function parseInlineImpl(text, opts) {
       const closeIndex = findInlineMathEnd(text, i);
       if (closeIndex !== -1) {
         nodes.push({
-          type: 'math',
+          type: 'inlineMath',
           value: text.slice(i + 1, closeIndex)
         });
         i = closeIndex + 1;
@@ -653,12 +857,12 @@ function parseInlineImpl(text, opts) {
             // Dangerous scheme — emit as plain text.
             nodes.push({
               type: 'text',
-              content: text.slice(i, srcClose + 1)
+              value: text.slice(i, srcClose + 1)
             });
           } else {
             nodes.push({
               type: 'image',
-              src,
+              url: src,
               alt: text.slice(i + 2, altClose)
             });
           }
@@ -702,12 +906,12 @@ function parseInlineImpl(text, opts) {
             // Dangerous scheme — emit as plain text instead of a link.
             nodes.push({
               type: 'text',
-              content: text.slice(i, urlClose + 1)
+              value: text.slice(i, urlClose + 1)
             });
           } else {
             nodes.push({
               type: 'link',
-              href,
+              url: href,
               children: parseInlineImpl(text.slice(i + 1, textClose), opts)
             });
           }
@@ -737,9 +941,9 @@ function parseInlineImpl(text, opts) {
         const closeIndex = text.indexOf(marker, i + 3);
         if (closeIndex !== -1 && (!isUnderscore || !isWordChar(text[closeIndex + 3]))) {
           nodes.push({
-            type: 'bold',
+            type: 'strong',
             children: [{
-              type: 'italic',
+              type: 'emphasis',
               children: parseInlineImpl(text.slice(i + 3, closeIndex), opts)
             }]
           });
@@ -759,7 +963,7 @@ function parseInlineImpl(text, opts) {
         const closeIndex = text.indexOf(marker, i + 2);
         if (closeIndex !== -1 && (!isUnderscore || !isWordChar(text[closeIndex + 2]))) {
           nodes.push({
-            type: 'bold',
+            type: 'strong',
             children: parseInlineImpl(text.slice(i + 2, closeIndex), opts)
           });
           i = closeIndex + 2;
@@ -773,7 +977,7 @@ function parseInlineImpl(text, opts) {
       const closeIndex = text.indexOf('~~', i + 2);
       if (closeIndex !== -1) {
         nodes.push({
-          type: 'strikethrough',
+          type: 'delete',
           children: parseInlineImpl(text.slice(i + 2, closeIndex), opts)
         });
         i = closeIndex + 2;
@@ -790,7 +994,7 @@ function parseInlineImpl(text, opts) {
         const closeIndex = text.indexOf(text[i], i + 1);
         if (closeIndex !== -1 && closeIndex > i + 1 && (!isUnderscore || !isWordChar(text[closeIndex + 1]))) {
           nodes.push({
-            type: 'italic',
+            type: 'emphasis',
             children: parseInlineImpl(text.slice(i + 1, closeIndex), opts)
           });
           i = closeIndex + 1;
@@ -813,11 +1017,14 @@ function parseInlineImpl(text, opts) {
         if (trimmed.length > 0) {
           const last = nodes[nodes.length - 1];
           if (last?.type === 'text') {
-            last.content += trimmed;
+            nodes[nodes.length - 1] = {
+              ...last,
+              value: last.value + trimmed
+            };
           } else {
             nodes.push({
               type: 'text',
-              content: trimmed
+              value: trimmed
             });
           }
         }
@@ -830,11 +1037,14 @@ function parseInlineImpl(text, opts) {
     }
     const last = nodes[nodes.length - 1];
     if (last?.type === 'text') {
-      last.content += content;
+      nodes[nodes.length - 1] = {
+        ...last,
+        value: last.value + content
+      };
     } else {
       nodes.push({
         type: 'text',
-        content
+        value: content
       });
     }
     i = end;
@@ -1063,7 +1273,7 @@ function splitTextOnAutolinks(content) {
   if (matches.length === 0) {
     return [{
       type: 'text',
-      content
+      value: content
     }];
   }
   const out = [];
@@ -1072,15 +1282,15 @@ function splitTextOnAutolinks(content) {
     if (m.start > cursor) {
       out.push({
         type: 'text',
-        content: content.slice(cursor, m.start)
+        value: content.slice(cursor, m.start)
       });
     }
     out.push({
       type: 'link',
-      href: m.href,
+      url: m.href,
       children: [{
         type: 'text',
-        content: m.display
+        value: m.display
       }]
     });
     cursor = m.end;
@@ -1088,7 +1298,7 @@ function splitTextOnAutolinks(content) {
   if (cursor < content.length) {
     out.push({
       type: 'text',
-      content: content.slice(cursor)
+      value: content.slice(cursor)
     });
   }
   return out;
@@ -1106,16 +1316,19 @@ function transformAutolinks(nodes) {
   const out = [];
   for (const node of nodes) {
     if (node.type === 'text') {
-      const split = splitTextOnAutolinks(node.content);
+      const split = splitTextOnAutolinks(node.value);
       for (const seg of split) {
         const last = out[out.length - 1];
         if (seg.type === 'text' && last?.type === 'text') {
-          last.content += seg.content;
+          out[out.length - 1] = {
+            ...last,
+            value: last.value + seg.value
+          };
         } else {
           out.push(seg);
         }
       }
-    } else if (node.type === 'bold' || node.type === 'italic' || node.type === 'strikethrough') {
+    } else if (node.type === 'strong' || node.type === 'emphasis' || node.type === 'delete') {
       out.push({
         ...node,
         children: transformAutolinks(node.children)
@@ -1271,6 +1484,7 @@ function splitTableRow(line) {
 }
 function parseTable(lines, lineIndex, opts) {
   const headers = splitTableRow(lines[lineIndex]).map(cell => ({
+    type: 'tableCell',
     children: parseInlineEntry(cell, opts)
   }));
   const alignments = splitTableRow(lines[lineIndex + 1]).map(cell => {
@@ -1282,17 +1496,23 @@ function parseTable(lines, lineIndex, opts) {
   const rows = [];
   let rowIndex = lineIndex + 2;
   while (rowIndex < lines.length && lines[rowIndex].includes('|') && lines[rowIndex].trim() !== '') {
-    rows.push(splitTableRow(lines[rowIndex]).map(cell => ({
-      children: parseInlineEntry(cell, opts)
-    })));
+    rows.push({
+      type: 'tableRow',
+      children: splitTableRow(lines[rowIndex]).map(cell => ({
+        type: 'tableCell',
+        children: parseInlineEntry(cell, opts)
+      }))
+    });
     rowIndex++;
   }
   return {
     node: {
       type: 'table',
-      headers,
-      alignments,
-      rows
+      align: alignments,
+      children: [{
+        type: 'tableRow',
+        children: headers
+      }, ...rows]
     },
     nextIndex: rowIndex
   };
@@ -1335,6 +1555,7 @@ function parseList(lines, startIndex, ordered, opts) {
       itemText += '\n' + deindented.join('\n');
     }
     items.push({
+      type: 'listItem',
       checked,
       children: parseMarkdownImpl(itemText, nested(opts))
     });
@@ -1357,8 +1578,8 @@ function parseList(lines, startIndex, ordered, opts) {
       ordered,
       start,
       delimiter: ordered ? delim : undefined,
-      loose: loose || undefined,
-      items
+      spread: loose || undefined,
+      children: items
     },
     nextIndex: index
   };
@@ -1369,7 +1590,15 @@ function parseList(lines, startIndex, ordered, opts) {
 // ---------------------------------------------------------------------------
 
 export function parseMarkdown(input, arg) {
-  return parseMarkdownImpl(input, resolveOptions(arg));
+  return projectMarkdownRoot(parseMarkdownAst(input, arg));
+}
+
+/** @internal Canonical block parse used by Markdown and Outline rendering. */
+export function parseMarkdownAst(input, arg) {
+  return {
+    type: 'root',
+    children: parseMarkdownImpl(input, resolveOptions(arg))
+  };
 }
 function parseMarkdownImpl(input, baseOpts) {
   // Collect this input's link reference definitions and strip their lines,
@@ -1425,7 +1654,7 @@ function parseMarkdownImpl(input, baseOpts) {
     const fenceMatch = line.match(/^(`{3,}|~{3,})(\w*)/);
     if (fenceMatch) {
       const fence = fenceMatch[1];
-      const language = fenceMatch[2] || 'plaintext';
+      const language = fenceMatch[2] || null;
       const codeLines = [];
       index++;
       while (index < lines.length && !lines[index].startsWith(fence)) {
@@ -1437,9 +1666,9 @@ function parseMarkdownImpl(input, baseOpts) {
       // can end on them, so it states its own end rather than letting the
       // positional derivation trim them off.
       pushBlock({
-        type: 'codeblock',
-        language,
-        content: codeLines.join('\n')
+        type: 'code',
+        lang: language,
+        value: codeLines.join('\n')
       }, Math.min(index, lines.length) - 1);
       continue;
     }
@@ -1462,7 +1691,7 @@ function parseMarkdownImpl(input, baseOpts) {
     if (headingMatch) {
       pushBlock({
         type: 'heading',
-        level: headingMatch[1].length,
+        depth: headingMatch[1].length,
         children: parseInlineEntry(headingMatch[2], opts)
       });
       index++;
@@ -1472,7 +1701,7 @@ function parseMarkdownImpl(input, baseOpts) {
     // --- HR (must precede list check to handle `- - -`, `* * *`, `_ _ _`) ---
     if (isHorizontalRule(line)) {
       pushBlock({
-        type: 'hr'
+        type: 'thematicBreak'
       });
       index++;
       continue;
@@ -1486,7 +1715,7 @@ function parseMarkdownImpl(input, baseOpts) {
       pushBlock({
         type: 'image',
         alt: imageMatch[1],
-        src: imageMatch[2]
+        url: imageMatch[2]
       });
       index++;
       continue;
@@ -1586,9 +1815,13 @@ function stampSourceRanges(blocks, blockStartLines, blockEndLines, lines, lineMa
     const end = lineStart(endLine) + lines[endLine].length;
     blocks[i] = {
       ...blocks[i],
-      range: {
-        start: lineStart(startLine),
-        end
+      position: {
+        start: {
+          offset: lineStart(startLine)
+        },
+        end: {
+          offset: end
+        }
       }
     };
   }
@@ -1609,6 +1842,11 @@ function makeIncrementalCache(state) {
     tailLinkDefs: new Map(),
     linkDefs: defs,
     linkDefsKey: linkDefsSignature(defs),
+    settledAstBlocks: [],
+    settledRevision: 0,
+    projectedRevision: -1,
+    projectedSettledBlocks: [],
+    projectionCache: new WeakMap(),
     work: {
       splitCharacters: 0,
       boundaryLines: 0,
@@ -2066,14 +2304,13 @@ function mergeSettledBlocks(prev, delta) {
       ordered: prevLast.ordered,
       start: prevLast.start,
       delimiter: prevLast.delimiter,
-      loose: true,
-      items: [...prevLast.items, ...deltaFirst.items],
-      // One list now, so one range: from where the first half started to
-      // where the second half ended.
-      ...(prevLast.range != null && deltaFirst.range != null ? {
-        range: {
-          start: prevLast.range.start,
-          end: deltaFirst.range.end
+      spread: true,
+      children: [...prevLast.children, ...deltaFirst.children],
+      // One list now, so one position spans both halves.
+      ...(prevLast.position != null && deltaFirst.position != null ? {
+        position: {
+          start: prevLast.position.start,
+          end: deltaFirst.position.end
         }
       } : null)
     };
@@ -2085,11 +2322,11 @@ function mergeSettledBlocks(prev, delta) {
 /** Append a newly-settled slice without copying the already-settled prefix. */
 function appendSettledBlocks(prev, delta) {
   if (delta.length === 0) {
-    return;
+    return false;
   }
   if (prev.length === 0) {
     prev.push(...delta);
-    return;
+    return false;
   }
   const prevLast = prev[prev.length - 1];
   const deltaFirst = delta[0];
@@ -2099,19 +2336,20 @@ function appendSettledBlocks(prev, delta) {
       ordered: prevLast.ordered,
       start: prevLast.start,
       delimiter: prevLast.delimiter,
-      loose: true,
-      items: [...prevLast.items, ...deltaFirst.items],
-      ...(prevLast.range != null && deltaFirst.range != null ? {
-        range: {
-          start: prevLast.range.start,
-          end: deltaFirst.range.end
+      spread: true,
+      children: [...prevLast.children, ...deltaFirst.children],
+      ...(prevLast.position != null && deltaFirst.position != null ? {
+        position: {
+          start: prevLast.position.start,
+          end: deltaFirst.position.end
         }
       } : null)
     };
     prev.push(...delta.slice(1));
-    return;
+    return true;
   }
   prev.push(...delta);
+  return false;
 }
 function sameUnsettledDefinitions(previous, next, settled) {
   for (const [label, destination] of previous) {
@@ -2138,6 +2376,11 @@ function resetIncrementalCache(state, cache) {
   cache.tailLinkDefs = new Map();
   cache.linkDefs = new Map();
   cache.linkDefsKey = '';
+  cache.settledAstBlocks = [];
+  cache.settledRevision++;
+  cache.projectedRevision = -1;
+  cache.projectedSettledBlocks = [];
+  cache.projectionCache = new WeakMap();
   cache.work = {
     splitCharacters: 0,
     boundaryLines: 0,
@@ -2159,6 +2402,25 @@ function resetIncrementalCache(state, cache) {
  */
 
 export function parseMarkdownIncremental(input, state, arg) {
+  const root = parseMarkdownAstIncremental(input, state, arg);
+  const cache = incrementalCaches.get(state) ?? makeIncrementalCache(state);
+  const projected = projectMarkdownRoot(root, cache.projectionCache);
+  if (cache.projectedRevision !== cache.settledRevision) {
+    cache.projectedSettledBlocks = cache.settledAstBlocks.map(block => projectBlockNode(block, cache.projectionCache));
+    cache.projectedRevision = cache.settledRevision;
+  }
+  state.settledBlocks = cache.projectedSettledBlocks;
+  return projected;
+}
+
+/** @internal Canonical incremental parse used by Markdown rendering. */
+export function parseMarkdownAstIncremental(input, state, arg) {
+  return {
+    type: 'root',
+    children: parseMarkdownIncrementalAstBlocks(input, state, arg)
+  };
+}
+function parseMarkdownIncrementalAstBlocks(input, state, arg) {
   const opts = resolveOptions(arg);
   const cache = incrementalCaches.get(state) ?? makeIncrementalCache(state);
   let reparseSettled = false;
@@ -2262,12 +2524,27 @@ export function parseMarkdownIncremental(input, state, arg) {
   const unsettledText = openFence ? unsettledRaw : openMath ? trimOpenDisplayMath(unsettledRaw) : trimUnsettledStructural(unsettledRaw);
   let parsedSettledBlocks = 0;
   if (reparseSettled) {
-    state.settledBlocks = state.settledText ? parseMarkdownImpl(state.settledText, parseOpts) : [];
-    parsedSettledBlocks = state.settledBlocks.length;
+    cache.settledAstBlocks = state.settledText ? parseMarkdownImpl(state.settledText, parseOpts) : [];
+    parsedSettledBlocks = cache.settledAstBlocks.length;
+    cache.settledRevision++;
+    cache.projectedSettledBlocks = cache.settledAstBlocks.map(block => projectBlockNode(block, cache.projectionCache));
+    cache.projectedRevision = cache.settledRevision;
   } else if (settledDelta !== '') {
     const deltaBlocks = parseMarkdownImpl(settledDelta, atOffset(parseOpts, oldSettledEnd));
-    appendSettledBlocks(state.settledBlocks, deltaBlocks);
+    const mergeIndex = cache.settledAstBlocks.length - 1;
+    const mergedList = appendSettledBlocks(cache.settledAstBlocks, deltaBlocks);
     parsedSettledBlocks = deltaBlocks.length;
+    cache.settledRevision++;
+    const projectedDelta = deltaBlocks.map(block => projectBlockNode(block, cache.projectionCache));
+    if (mergedList) {
+      const canonicalMerged = cache.settledAstBlocks[mergeIndex];
+      const projectedMerged = projectBlockNode(canonicalMerged, cache.projectionCache);
+      cache.projectedSettledBlocks[mergeIndex] = projectedMerged;
+      cache.projectedSettledBlocks.push(...projectedDelta.slice(1));
+    } else {
+      cache.projectedSettledBlocks.push(...projectedDelta);
+    }
+    cache.projectedRevision = cache.settledRevision;
   }
 
   // The unsettled tail is trimmed before parsing, so its offset in the
@@ -2290,7 +2567,7 @@ export function parseMarkdownIncremental(input, state, arg) {
     definitionCharacters: settledDelta.length + unsettledInput.length,
     renderedBlocks: parsedSettledBlocks + unsettledBlocks.length
   };
-  return mergeSettledBlocks(state.settledBlocks, unsettledBlocks);
+  return mergeSettledBlocks(cache.settledAstBlocks, unsettledBlocks);
 }
 
 // ---------------------------------------------------------------------------
@@ -2301,28 +2578,6 @@ export function parseMarkdownIncremental(input, state, arg) {
 // derives its item ids from the same functions, so outline hash links always
 // resolve to a rendered heading by construction.
 
-/** Flatten inline nodes into their plain text content. */
-export function inlineText(nodes) {
-  return nodes.map(node => {
-    switch (node.type) {
-      case 'text':
-      case 'code':
-      case 'math':
-        return node.type === 'math' ? node.value : node.content;
-      case 'bold':
-      case 'italic':
-      case 'strikethrough':
-      case 'link':
-        return inlineText(node.children);
-      case 'image':
-        return node.alt;
-      case 'citation':
-      case 'break':
-        return '';
-    }
-  }).join('');
-}
-
 /** Turn heading text into a URL-safe slug (lowercase, hyphen-separated). */
 export function slugify(value) {
   return value.trim().toLowerCase().replace(/['"]/g, '').replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');