feat(markdown-parser): implement link and list item normalization plugins; update version to 0.0.9

Author: Simon-He95

package.json

@@ -2,7 +2,7 @@
   "name": "vue-renderer-markdown",
   "type": "module",
   "version": "0.0.61-beta.0",
-  "packageManager": "pnpm@10.19.0",
+  "packageManager": "pnpm@10.20.0",
   "description": "Vue 3 Markdown renderer optimized for large docs: progressive Mermaid, streaming diff code blocks, and fast real-time preview.",
   "author": "Simon He",
   "license": "MIT",
@@ -103,13 +103,13 @@
   },
   "dependencies": {
     "@floating-ui/dom": "^1.7.4",
-    "stream-markdown-parser": "^0.0.8"
+    "stream-markdown-parser": "^0.0.9"
   },
   "devDependencies": {
     "@antfu/eslint-config": "^5.4.1",
     "@types/node": "^18.19.130",
     "@vitejs/plugin-vue": "^5.2.4",
-    "@vitest/ui": "^4.0.3",
+    "@vitest/ui": "^4.0.4",
     "@vue/test-utils": "^2.4.6",
     "autoprefixer": "^10.4.21",
     "bumpp": "^8.2.1",
@@ -129,7 +129,7 @@
     "vite-plugin-dts": "^4.5.4",
     "vite-plugin-pages": "^0.33.1",
     "vite-svg-loader": "^5.1.0",
-    "vitest": "^4.0.3",
+    "vitest": "^4.0.4",
     "vue": "^3.5.22",
     "vue-tsc": "^2.2.12"
   },

packages/markdown-parser/package.json

@@ -1,8 +1,8 @@
 {
   "name": "stream-markdown-parser",
   "type": "module",
-  "version": "0.0.8",
-  "packageManager": "pnpm@10.19.0",
+  "version": "0.0.9",
+  "packageManager": "pnpm@10.20.0",
   "description": "Pure markdown parser and renderer utilities with streaming support - framework agnostic",
   "author": "Simon He",
   "license": "MIT",
@@ -63,8 +63,8 @@
   },
   "devDependencies": {
     "@types/markdown-it": "^14.1.2",
-    "@types/node": "^22.18.12",
-    "tsdown": "^0.15.10",
+    "@types/node": "^22.18.13",
+    "tsdown": "^0.15.11",
     "typescript": "^5.9.3",
     "vitest": "^3.2.4"
   }

packages/markdown-parser/src/factory.ts

@@ -2,6 +2,11 @@ import type { MathOptions } from './config'
 import MarkdownIt from 'markdown-it'
 import { getDefaultMathOptions } from './config'
 import { applyContainers } from './plugins/containers'
+import { applyFixLinkInline } from './plugins/fixLinkInline'
+import { applyFixLinkTokens } from './plugins/fixLinkTokens'
+import { applyFixListItem } from './plugins/fixListItem'
+import { applyFixStrongTokens } from './plugins/fixStrongTokens'
+import { applyFixTableTokens } from './plugins/fixTableTokens'
 import { applyMath } from './plugins/math'
 import { applyRenderRules } from './renderers'
 
@@ -26,6 +31,20 @@ export function factory(opts: FactoryOptions = {}): MarkdownIt {
   }
   if (opts.enableContainers ?? true)
     applyContainers(md)
+  // Apply link-fixing plugin early so tokens produced during parsing
+  // have corrected inline children. This runs during markdown-it's
+  // core stage (after inline tokenization) instead of after parse.
+  // Install inline-level link tokenizer before the built-in 'link' rule
+  applyFixLinkInline(md)
+  // Retain the core-stage fix as a fallback for any cases the inline
+  // tokenizer does not handle.
+  applyFixLinkTokens(md)
+  // Also apply strong-token normalization at the same stage.
+  applyFixStrongTokens(md)
+  // Apply list-item inline normalization as well.
+  applyFixListItem(md)
+  // Apply table token normalization at block stage.
+  applyFixTableTokens(md)
   applyRenderRules(md)
 
   return md

packages/markdown-parser/src/parser/index.ts

@@ -1,6 +1,5 @@
 import type MarkdownIt from 'markdown-it'
 import type { MarkdownToken, ParsedNode, ParseOptions } from '../types'
-import { fixTableTokens } from './fixTableTokens'
 import { parseInlineTokens } from './inline-parsers'
 import { parseFenceToken } from './inline-parsers/fence-parser'
 import { parseAdmonition } from './node-parsers/admonition-parser'
@@ -49,6 +48,7 @@ export function parseMarkdownToStructure(
   if (pre && typeof pre === 'function') {
     transformedTokens = pre(tokens) || tokens
   }
+
   // Process the tokens into our structured format
   let result = processTokens(transformedTokens)
 
@@ -81,7 +81,11 @@ export function processTokens(tokens: MarkdownToken[]): ParsedNode[] {
 
   const result: ParsedNode[] = []
   let i = 0
-  tokens = fixTableTokens(tokens)
+  // Note: table token normalization is applied during markdown-it parsing
+  // via the `applyFixTableTokens` plugin (core.ruler.after('block')).
+  // Link/strong/list-item fixes are applied during the inline stage by
+  // their respective plugins. That keeps parsing-time fixes centralized
+  // and avoids ad-hoc post-processing here.
   while (i < tokens.length) {
     const token = tokens[i]
     switch (token.type) {

packages/markdown-parser/src/parser/inline-parsers/fixListItem.ts

@@ -3,9 +3,6 @@ import { parseCheckboxInputToken, parseCheckboxToken } from './checkbox-parser'
 import { parseEmojiToken } from './emoji-parser'
 import { parseEmphasisToken } from './emphasis-parser'
 import { parseFenceToken } from './fence-parser'
-import { fixLinkToken } from './fixLinkToken'
-import { fixListItem } from './fixListItem'
-import { fixStrongTokens } from './fixStrongTokens'
 import { parseFootnoteRefToken } from './footnote-ref-parser'
 import { parseHardbreakToken } from './hardbreak-parser'
 import { parseHighlightToken } from './highlight-parser'
@@ -30,9 +27,10 @@ export function parseInlineTokens(tokens: MarkdownToken[], raw?: string, pPreTok
   let currentTextNode: TextNode | null = null
 
   let i = 0
-  tokens = fixStrongTokens(tokens)
-  tokens = fixListItem(tokens)
-  tokens = fixLinkToken(tokens)
+  // Note: strong-token normalization and list-item normalization are
+  // applied during markdown-it parsing via core rules (plugins that
+  // run after 'inline'). Inline parsers should receive normalized
+  // children and only focus on parsing.
 
   // Helpers to manage text node merging and pushing parsed nodes
   function resetCurrentTextNode() {
@@ -560,8 +558,40 @@ export function parseInlineTokens(tokens: MarkdownToken[], raw?: string, pPreTok
     }
     const { node, nextIndex } = parseLinkToken(tokens, i)
     i = nextIndex
-
-    node.loading = false
+    // Determine loading state conservatively: if the link token parser
+    // marked it as loading already, keep it; otherwise compute from raw
+    // and href as a fallback so unclosed links remain marked as loading.
+    const hrefAttr = token.attrs?.find(([name]) => name === 'href')?.[1]
+    const hrefStr = String(hrefAttr ?? '')
+    // Only override the link parser's default loading state when we
+    // actually have an href to check against the raw source. If the
+    // tokenizer emitted a link_open without an href (partial tokenizers
+    // may do this), prefer the parseLinkToken's initial loading value
+    // (which defaults to true for mid-state links).
+    if (raw && hrefStr) {
+    // More robust: locate the first "](" after the link text and see if
+    // there's a matching ')' that closes the href. This avoids false
+    // positives when other parentheses appear elsewhere in the source.
+      const openIdx = raw.indexOf('](')
+      if (openIdx === -1) {
+      // No explicit link start found in raw — be conservative and keep
+      // the parser's default loading value.
+      }
+      else {
+        const closeIdx = raw.indexOf(')', openIdx + 2)
+        if (closeIdx === -1) {
+          node.loading = true
+        }
+        else {
+        // Check that the href inside the parens corresponds to this token
+          const inside = raw.slice(openIdx + 2, closeIdx)
+          if (inside.includes(hrefStr))
+            node.loading = false
+          else
+            node.loading = true
+        }
+      }
+    }
     pushParsed(node)
   }
 

packages/markdown-parser/src/parser/inline-parsers/index.ts

@@ -0,0 +1,60 @@
+import type MarkdownIt from 'markdown-it'
+
+export function applyFixLinkInline(md: MarkdownIt) {
+  // Inline tokenizer that tries to recognize [text](href) and loading
+  // link forms like "[x](http://a" earlier, producing link_open/text/link_close
+  // tokens so downstream code sees them as links during the inline pass.
+  const rule = (state: unknown, silent: boolean) => {
+    const s = state as unknown as { src: string, pos: number, push: (type: string, tag?: string, nesting?: number) => any }
+    const start = s.pos
+    if (s.src[start] !== '[')
+      return false
+
+    // Don't handle image syntax here
+    if (start > 0 && s.src[start - 1] === '!')
+      return false
+
+    // Look for closing ']' and opening '(' after it
+    const rest = s.src.slice(start)
+    // eslint-disable-next-line regexp/no-useless-quantifier
+    const m = /^\[([^\]]*)\]\(([^)\s]*)?/.exec(rest)
+    if (!m)
+      return false
+
+    if (silent)
+      return true
+
+    const text = m[1] ?? ''
+    const href = m[2] ?? ''
+    // Be conservative: if the link text contains characters that indicate
+    // emphasis or emoji shortcodes (e.g. '*' or ':'), don't pre-tokenize
+    // here — let the core inline parser handle these ambiguous mid-states.
+    if (text.includes('*') || text.includes(':'))
+      return false
+    const idxClose = rest.indexOf(')')
+    const hasClosingParen = idxClose !== -1
+
+    // push link_open
+    const open = s.push('link_open', 'a', 1)
+    open.attrs = [['href', href]]
+    // push inner text
+    const txt = s.push('text', '', 0)
+    txt.content = text
+
+    // only emit link_close if the source actually contained a closing paren
+    if (hasClosingParen) {
+      s.push('link_close', 'a', -1)
+      // consume through the closing paren
+      s.pos += idxClose + 1
+    }
+    else {
+      // consume the matched prefix (e.g. "[x](http://a") but do not
+      // emit a link_close so downstream logic treats this as a loading link
+      s.pos += m[0].length
+    }
+    return true
+  }
+
+  // Insert before default 'link' rule to take precedence
+  md.inline.ruler.before('link', 'fix_link_inline', rule)
+}

packages/markdown-parser/src/plugins/fixLinkInline.ts

@@ -1,12 +1,39 @@
-import type { MarkdownToken } from '../../types'
+import type MarkdownIt from 'markdown-it'
+import type { MarkdownToken } from '../types'
+
+export function applyFixLinkTokens(md: MarkdownIt) {
+  // Run after the inline rule so markdown-it has produced inline tokens
+  // for block-level tokens; we then adjust each inline token's children
+  // so downstream code receives corrected token arrays during the same
+  // parsing pass.
+  md.core.ruler.after('inline', 'fix_link_tokens', (state: unknown) => {
+    const s = state as unknown as { tokens?: Array<{ type?: string, children?: any[] }> }
+    const toks = s.tokens ?? []
+    for (let i = 0; i < toks.length; i++) {
+      const t = toks[i]
+      if (t && t.type === 'inline' && Array.isArray(t.children)) {
+        try {
+          t.children = fixLinkToken(t.children)
+        }
+        catch (e) {
+          // Swallow errors to avoid breaking parsing; keep original children
+          // so parse still succeeds even if our fix fails for an unexpected shape.
+          // Errors should be rare and indicate malformed token arrays.
+
+          console.error('[applyFixLinkTokens] failed to fix inline children', e)
+        }
+      }
+    }
+  })
+}
 
 // narrow helper to reduce non-null assertions on text tokens
 function isTextToken(t?: MarkdownToken): t is MarkdownToken & { type: 'text', content: string } {
   return !!t && t.type === 'text' && typeof (t as any).content === 'string'
 }
 
-export function fixLinkToken(tokens: MarkdownToken[]): MarkdownToken[] {
-  const tokensAny = tokens as unknown as import('../../types').MarkdownToken[]
+function fixLinkToken(tokens: MarkdownToken[]): MarkdownToken[] {
+  const tokensAny = tokens as unknown as MarkdownToken[]
   tokens = fixLinkToken4(fixLinkToken3(tokens))
   if (tokens.length < 5)
     return tokens
@@ -50,8 +77,8 @@ export function fixLinkToken(tokens: MarkdownToken[]): MarkdownToken[] {
   return tokens
 }
 
-export function fixLinkTokens2(tokens: MarkdownToken[]): MarkdownToken[] {
-  const tokensAny = tokens as unknown as import('../../types').MarkdownToken[]
+function fixLinkTokens2(tokens: MarkdownToken[]): MarkdownToken[] {
+  const tokensAny = tokens as unknown as MarkdownToken[]
   if (tokens.length < 8)
     return tokens
   let length = tokens.length
@@ -98,8 +125,8 @@ export function fixLinkTokens2(tokens: MarkdownToken[]): MarkdownToken[] {
   return tokens
 }
 
-export function fixLinkToken3(tokens: MarkdownToken[]): MarkdownToken[] {
-  const tokensAny = tokens as unknown as import('../../types').MarkdownToken[]
+function fixLinkToken3(tokens: MarkdownToken[]): MarkdownToken[] {
+  const tokensAny = tokens as unknown as MarkdownToken[]
   const last = tokens[tokens.length - 1]
   const preLast = tokens[tokens.length - 2]
   const fixedTokens = [...tokens]
@@ -128,8 +155,8 @@ export function fixLinkToken3(tokens: MarkdownToken[]): MarkdownToken[] {
   return fixedTokens
 }
 
-export function fixLinkToken4(tokens: MarkdownToken[]): MarkdownToken[] {
-  const tokensAny = tokens as unknown as import('../../types').MarkdownToken[]
+function fixLinkToken4(tokens: MarkdownToken[]): MarkdownToken[] {
+  const tokensAny = tokens as unknown as MarkdownToken[]
   const fixedTokens = [...tokens]
   for (let i = tokens.length - 1; i >= 3; i--) {
     const token = tokens[i]

packages/markdown-parser/src/parser/inline-parsers/fixLinkToken.ts renamed to packages/markdown-parser/src/plugins/fixLinkTokens.ts

@@ -0,0 +1,35 @@
+import type MarkdownIt from 'markdown-it'
+import type { MarkdownToken } from '../types'
+
+export function applyFixListItem(md: MarkdownIt) {
+  // Normalize list-item related inline tokens after inline tokenization
+  // so downstream parsers see corrected children.
+  md.core.ruler.after('inline', 'fix_list_item_tokens', (state: unknown) => {
+    const s = state as unknown as { tokens?: Array<{ type?: string, children?: any[] }> }
+    const toks = s.tokens ?? []
+    for (let i = 0; i < toks.length; i++) {
+      const t = toks[i]
+      if (t && t.type === 'inline' && Array.isArray(t.children)) {
+        try {
+          t.children = fixListItem(t.children)
+        }
+        catch (e) {
+          // Keep original children on error to avoid breaking parsing
+
+          console.error('[applyFixListItem] failed to fix inline children', e)
+        }
+      }
+    }
+  })
+}
+
+function fixListItem(tokens: MarkdownToken[]): MarkdownToken[] {
+  const last = tokens[tokens.length - 1]
+  const lastContent = String(last?.content ?? '')
+
+  if (last?.type === 'text' && (/^\s*\d+\.\s*$/.test(lastContent) && tokens[tokens.length - 2]?.tag === 'br')) {
+    tokens.splice(tokens.length - 1, 1)
+  }
+
+  return tokens
+}