@peaceroad/markdown-it-renderer-fence 0.7.0 → 0.8.0

package/src/custom-highlight/{shiki-keyword.js → shiki-role.js}

@@ -1,9 +1,10 @@
 import {
-  applyKeywordV4Rules,
-  applyShikiKeywordLegacyPostRules,
-} from './shiki-keyword-rules.js'
+  applyRoleV4Rules,
+  applyShikiRoleLegacyPostRules,
+} from './shiki-role-rules.js'
+import { resolveRendererFenceShikiThemeRoleBucket } from './shiki-theme-role.js'
 
-const shikiKeywordBucketScoreV3 = {
+const shikiRoleBucketScore = {
   comment: 210,
   'meta-shebang': 206,
   'tag-delimiter': 202,
@@ -37,7 +38,7 @@ const shikiGlobalLiteralTokenSet = new Set(['true', 'false', 'null', 'undefined'
 const shikiShellKeywordTokenSet = new Set(['case', 'coproc', 'do', 'done', 'elif', 'else', 'esac', 'export', 'fi', 'for', 'function', 'if', 'in', 'local', 'readonly', 'select', 'then', 'time', 'typeset', 'until', 'while'])
 const shikiHclKeywordTokenSet = new Set(['terraform', 'resource', 'data', 'module', 'provider', 'variable', 'output', 'locals', 'backend', 'dynamic', 'for_each', 'count', 'provisioner', 'connection', 'if', 'for', 'in'])
 
-const shikiKeywordTokensByLang = {
+const shikiLangKeywordTokens = {
   javascript: new Set(['await', 'async', 'break', 'case', 'catch', 'class', 'const', 'continue', 'debugger', 'default', 'delete', 'do', 'else', 'export', 'extends', 'finally', 'for', 'from', 'function', 'if', 'import', 'in', 'instanceof', 'let', 'new', 'of', 'return', 'static', 'super', 'switch', 'this', 'throw', 'try', 'typeof', 'var', 'void', 'while', 'with', 'yield']),
   typescript: new Set(['abstract', 'as', 'asserts', 'async', 'await', 'break', 'case', 'catch', 'class', 'const', 'continue', 'debugger', 'declare', 'default', 'delete', 'do', 'else', 'enum', 'export', 'extends', 'finally', 'for', 'from', 'function', 'if', 'implements', 'import', 'in', 'infer', 'instanceof', 'interface', 'is', 'keyof', 'let', 'namespace', 'new', 'of', 'override', 'private', 'protected', 'public', 'readonly', 'return', 'satisfies', 'static', 'super', 'switch', 'this', 'throw', 'try', 'type', 'typeof', 'var', 'void', 'while', 'with', 'yield']),
   python: new Set(['and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']),
@@ -61,26 +62,26 @@ const shikiNumberTokenReg = /^(?:0[xob][0-9a-f_]+|\d[\d_]*(?:\.\d[\d_]*)?(?:e[+-
 const shikiPunctuationTokenReg = /^[()[\]{}<>.,;:!?~`'"@#$%^&*+=|/\\-]+$/
 const shikiSimpleIdentifierReg = /^[A-Za-z_$][\w$]*$/
 const shikiScopeLangReg = /(?:^|\.)(?:source|text)\.([A-Za-z0-9_#+-]+)/g
-const shikiKeywordLangSanitizeReg = /[^a-z0-9#+-]+/g
+const shikiRoleLangSanitizeReg = /[^a-z0-9#+-]+/g
 const hyphenMultiReg = /-+/g
-const shikiScopeKeywordSingleV3Cache = new Map()
+const shikiScopeRoleCache = new Map()
 
-const normalizeShikiKeywordLangKey = (lang) => {
+const normalizeShikiRoleLangKey = (lang) => {
   let key = String(lang || '').trim().toLowerCase()
   if (!key) return ''
   if (key.startsWith('language-')) key = key.slice('language-'.length)
   key = key.replace(/\s+/g, '-').replace(/[./]+/g, '-').replace(/_+/g, '-')
-  key = key.replace(shikiKeywordLangSanitizeReg, '')
+  key = key.replace(shikiRoleLangSanitizeReg, '')
   key = key.replace(hyphenMultiReg, '-').replace(/^-+|-+$/g, '')
   return key
 }
 
-const normalizeShikiKeywordLangAliasMap = (input) => {
+const normalizeShikiRoleLangAliasMap = (input) => {
   if (!input || typeof input !== 'object') return null
   const map = {}
   for (const key of Object.keys(input)) {
-    const from = normalizeShikiKeywordLangKey(key)
-    const to = normalizeShikiKeywordLangKey(input[key])
+    const from = normalizeShikiRoleLangKey(key)
+    const to = normalizeShikiRoleLangKey(input[key])
     if (!from || !to) continue
     map[from] = to
   }
@@ -106,7 +107,7 @@ const getShikiRawScopeName = (tok) => {
   return null
 }
 
-const extractShikiKeywordLangCandidatesFromScope = (scope) => {
+const extractShikiRoleLangCandidatesFromScope = (scope) => {
   const out = []
   const text = String(scope || '')
   if (!text) return out
@@ -177,10 +178,10 @@ const createScopePatternMatcher = (lowerScopeCandidates) => {
   }
 }
 
-const classifyShikiScopeKeywordSingleV3 = (scope) => {
+const classifyShikiScopeRoleSingle = (scope) => {
   const s = String(scope || '').toLowerCase()
   if (!s) return 'text'
-  const cached = shikiScopeKeywordSingleV3Cache.get(s)
+  const cached = shikiScopeRoleCache.get(s)
   if (cached) return cached
   let bucket = 'text'
   if (s.includes('comment')) return 'comment'
@@ -190,7 +191,7 @@ const classifyShikiScopeKeywordSingleV3 = (scope) => {
   if (s.includes('entity.name.tag')) return 'tag'
   if (s.includes('string.unquoted')) return 'string-unquoted'
   if (s.includes('regexp') || s.includes('regex') || s.includes('string') || s.includes('punctuation.definition.string')) return 'string'
-  if (s.includes('constant.other.color') || s.includes('support.constant.property-value')) return 'number'
+  if (s.includes('constant.other.color')) return 'number'
   if (s.includes('constant.numeric') || s.includes('number')) return 'number'
   if (s.includes('constant.language') || s.includes('boolean') || s.includes('null') || s.includes('undefined') || s.includes('none')) return 'literal'
   if (s.includes('entity.name.scope-resolution') || s.includes('entity.name.namespace')) return 'namespace'
@@ -207,14 +208,14 @@ const classifyShikiScopeKeywordSingleV3 = (scope) => {
   if (s.includes('entity.name.class') || s.includes('entity.name.type.class')) return 'title-class'
   if (s.includes('storage.type.built-in.primitive')) return 'type-primitive'
   if (s.includes('entity.name.type.namespace') || s.includes('entity.name.type') || s.includes('support.class')) return 'type-name'
-  if (s.includes('support.type') || s.includes('storage.modifier') || s.includes('keyword.type')) return 'type'
+  if (s.includes('support.type')) return 'type'
   if (s.includes('storage') || s.includes('keyword') || s.includes('operator') || s.includes('control') || s.includes('modifier')) return 'keyword'
   if (s.includes('variable')) return 'variable'
   if (s.includes('punctuation')) return 'punctuation'
   if (s.includes('source.')) bucket = 'text'
   else if (s.includes('meta')) bucket = 'meta'
-  shikiScopeKeywordSingleV3Cache.set(s, bucket)
-  if (shikiScopeKeywordSingleV3Cache.size > 8192) shikiScopeKeywordSingleV3Cache.clear()
+  shikiScopeRoleCache.set(s, bucket)
+  if (shikiScopeRoleCache.size > 8192) shikiScopeRoleCache.clear()
   return bucket
 }
 
@@ -228,7 +229,7 @@ const hasJsonYamlPropertyNameScope = (scopeCandidates) => {
   return false
 }
 
-const classifyShikiHclKeywordBucketV3 = (lowerScopeCandidates, hasAnyPattern) => {
+const classifyShikiHclRoleBucket = (lowerScopeCandidates, hasAnyPattern) => {
   const hasAny = (typeof hasAnyPattern === 'function') ? hasAnyPattern : (patterns) => hasAnyScopePattern(lowerScopeCandidates, patterns)
   if (!Array.isArray(lowerScopeCandidates) || lowerScopeCandidates.length === 0) return null
   if (hasAny(['entity.name.type.hcl', 'entity-name-type-hcl'])) return 'title-class'
@@ -243,10 +244,10 @@ const classifyShikiHclKeywordBucketV3 = (lowerScopeCandidates, hasAnyPattern) =>
   return null
 }
 
-const resolveShikiKeywordLang = (lang, scopeCandidates, tok, opt) => {
+const resolveShikiRoleLang = (lang, scopeCandidates, tok, opt) => {
   const queue = []
   const seen = new Set()
-  const customAliasMap = opt && opt.shikiKeywordLangAliases
+  const customAliasMap = opt && opt.shikiRoleLangAliases
   const shikiInternalAliasMap = opt && opt._shikiInternalLangAliasMap
   const resolveAlias = (key) => {
     if (customAliasMap && customAliasMap[key]) return customAliasMap[key]
@@ -254,46 +255,46 @@ const resolveShikiKeywordLang = (lang, scopeCandidates, tok, opt) => {
     return ''
   }
   const pushCandidate = (value) => {
-    const key = normalizeShikiKeywordLangKey(value)
+    const key = normalizeShikiRoleLangKey(value)
     if (!key || seen.has(key)) return
     seen.add(key)
     queue.push(key)
   }
-  if (opt && typeof opt.shikiKeywordLangResolver === 'function') {
+  if (opt && typeof opt.shikiRoleLangResolver === 'function') {
     try {
-      const resolved = opt.shikiKeywordLangResolver(lang, scopeCandidates, tok)
+      const resolved = opt.shikiRoleLangResolver(lang, scopeCandidates, tok)
       if (resolved != null && resolved !== '') pushCandidate(resolved)
     } catch (e) {}
   }
   pushCandidate(lang)
   if (Array.isArray(scopeCandidates)) {
     for (let i = 0; i < scopeCandidates.length; i++) {
-      const candidates = extractShikiKeywordLangCandidatesFromScope(scopeCandidates[i])
+      const candidates = extractShikiRoleLangCandidatesFromScope(scopeCandidates[i])
       for (let j = 0; j < candidates.length; j++) pushCandidate(candidates[j])
     }
   }
   for (let i = 0; i < queue.length; i++) {
     const key = queue[i]
-    if (shikiKeywordTokensByLang[key]) return key
+    if (shikiLangKeywordTokens[key]) return key
     const aliased = resolveAlias(key)
     if (aliased) {
-      if (shikiKeywordTokensByLang[aliased]) return aliased
+      if (shikiLangKeywordTokens[aliased]) return aliased
       pushCandidate(aliased)
     }
     const compact = key.replace(/-/g, '')
-    if (shikiKeywordTokensByLang[compact]) return compact
+    if (shikiLangKeywordTokens[compact]) return compact
     const compactAliased = resolveAlias(compact)
     if (compactAliased) {
-      if (shikiKeywordTokensByLang[compactAliased]) return compactAliased
+      if (shikiLangKeywordTokens[compactAliased]) return compactAliased
       pushCandidate(compactAliased)
     }
     const parts = key.split('-')
     for (let n = parts.length - 1; n >= 1; n--) {
       const head = parts.slice(0, n).join('-')
-      if (shikiKeywordTokensByLang[head]) return head
+      if (shikiLangKeywordTokens[head]) return head
       const headAliased = resolveAlias(head)
       if (headAliased) {
-        if (shikiKeywordTokensByLang[headAliased]) return headAliased
+        if (shikiLangKeywordTokens[headAliased]) return headAliased
         pushCandidate(headAliased)
       }
     }
@@ -301,7 +302,7 @@ const resolveShikiKeywordLang = (lang, scopeCandidates, tok, opt) => {
   return ''
 }
 
-const classifyShikiKeywordByToken = (content, langKey) => {
+const classifyShikiRoleByToken = (content, langKey) => {
   const text = String(content || '')
   const trimmed = text.trim()
   if (!trimmed) return 'text'
@@ -309,20 +310,20 @@ const classifyShikiKeywordByToken = (content, langKey) => {
   if (lower.startsWith('#!')) return 'meta'
   if (langKey !== 'sql' && shikiGlobalLiteralTokenSet.has(lower)) return 'literal'
   if (shikiNumberTokenReg.test(lower)) return 'number'
-  const set = shikiKeywordTokensByLang[langKey]
+  const set = shikiLangKeywordTokens[langKey]
   if (set && set.has(lower)) return 'keyword'
   if (langKey === 'css' && lower.startsWith('@')) return 'keyword'
   if (shikiPunctuationTokenReg.test(trimmed)) return 'punctuation'
   return null
 }
 
-const buildShikiKeywordContext = (rawScope, tok, lang, opt, preResolvedLangKey = '', tokenContentArg, tokenTrimArg, tokenLowerArg) => {
+const buildShikiRoleContext = (rawScope, tok, lang, opt, preResolvedLangKey = '', tokenContentArg, tokenTrimArg, tokenLowerArg) => {
   const token = (tok && typeof tok === 'object') ? tok : {}
   const tokenContent = (typeof tokenContentArg === 'string') ? tokenContentArg : String(token.content || '')
   const tokenTrim = (typeof tokenTrimArg === 'string') ? tokenTrimArg : tokenContent.trim()
   const tokenLower = (typeof tokenLowerArg === 'string') ? tokenLowerArg : tokenTrim.toLowerCase()
   const scopeCandidates = getShikiScopeCandidates(token, rawScope)
-  const langKey = preResolvedLangKey || resolveShikiKeywordLang(lang, scopeCandidates, token, opt)
+  const langKey = preResolvedLangKey || resolveShikiRoleLang(lang, scopeCandidates, token, opt)
   const lowerScopeCandidates = toLowerScopeCandidates(scopeCandidates)
   const hasAnyScopePatternCached = createScopePatternMatcher(lowerScopeCandidates)
   return {
@@ -342,10 +343,10 @@ const buildShikiKeywordContext = (rawScope, tok, lang, opt, preResolvedLangKey =
   }
 }
 
-const classifyShikiScopeKeywordBaseFromContext = (context) => {
+const classifyShikiScopeRoleBaseFromContext = (context) => {
   if (!context || typeof context !== 'object') return 'text'
   let best = 'text'
-  let bestScore = shikiKeywordBucketScoreV3.text
+  let bestScore = shikiRoleBucketScore.text
   const candidates = Array.isArray(context.scopeCandidates) ? context.scopeCandidates : []
   const lowerScopeCandidates = Array.isArray(context.lowerScopeCandidates) ? context.lowerScopeCandidates : []
   const hasAnyPattern = (context && typeof context.hasAnyScopePattern === 'function')
@@ -357,61 +358,68 @@ const classifyShikiScopeKeywordBaseFromContext = (context) => {
   const langKey = String(context.langKey || '')
   const tokenContent = context.tokenContent
   if (langKey === 'hcl' || langKey === 'terraform') {
-    const hclBucket = classifyShikiHclKeywordBucketV3(lowerScopeCandidates, hasAnyPattern)
+    const hclBucket = classifyShikiHclRoleBucket(lowerScopeCandidates, hasAnyPattern)
     if (hclBucket) return hclBucket
   }
   if (hasJsonYamlPropertyNameScope(candidates)) return 'type'
   if (langKey === 'yaml' && hasScope('entity.name.tag.yaml')) return 'tag'
   for (let i = 0; i < lowerScopeCandidates.length; i++) {
-    const bucket = classifyShikiScopeKeywordSingleV3(lowerScopeCandidates[i])
-    const score = shikiKeywordBucketScoreV3[bucket] || shikiKeywordBucketScoreV3.text
+    const bucket = classifyShikiScopeRoleSingle(lowerScopeCandidates[i])
+    const score = shikiRoleBucketScore[bucket] || shikiRoleBucketScore.text
     if (score > bestScore) {
       best = bucket
       bestScore = score
     }
   }
-  const tokenBucket = classifyShikiKeywordByToken(tokenContent, langKey)
+  if (bestScore <= shikiRoleBucketScore.text) {
+    const themeRoleBucket = resolveRendererFenceShikiThemeRoleBucket(lowerScopeCandidates)
+    if (themeRoleBucket) {
+      best = themeRoleBucket
+      bestScore = shikiRoleBucketScore.text + 1
+    }
+  }
+  const tokenBucket = classifyShikiRoleByToken(tokenContent, langKey)
   if (tokenBucket) {
-    const tokenScore = (shikiKeywordBucketScoreV3[tokenBucket] || shikiKeywordBucketScoreV3.text) + 1
-    if (tokenScore > bestScore) best = tokenBucket
+    const tokenScore = (shikiRoleBucketScore[tokenBucket] || shikiRoleBucketScore.text) + 1
+    if (best !== 'string' && best !== 'string-unquoted' && tokenScore > bestScore) best = tokenBucket
   }
   return best
 }
 
-const resolveShikiKeywordLangForFence = (lang, opt) => {
-  return resolveShikiKeywordLang(lang, null, null, opt)
+const resolveShikiRoleLangForFence = (lang, opt) => {
+  return resolveShikiRoleLang(lang, null, null, opt)
 }
 
-const classifyShikiScopeKeyword = (rawScope, tok, lang, opt, preResolvedKeywordLang = '') => {
+const classifyShikiScopeRole = (rawScope, tok, lang, opt, preResolvedRoleLang = '') => {
   const token = (tok && typeof tok === 'object') ? tok : {}
   const tokenContent = String(token.content || '')
   const tokenTrim = tokenContent.trim()
   if (!tokenTrim) return 'text'
   const tokenLower = tokenTrim.toLowerCase()
-  const context = buildShikiKeywordContext(
+  const context = buildShikiRoleContext(
     rawScope,
     token,
     lang,
     opt,
-    preResolvedKeywordLang,
+    preResolvedRoleLang,
     tokenContent,
     tokenTrim,
     tokenLower,
   )
-  const baseBucket = classifyShikiScopeKeywordBaseFromContext(context)
+  const baseBucket = classifyShikiScopeRoleBaseFromContext(context)
   const postHelpers = {
-    classifyToken: classifyShikiKeywordByToken,
+    classifyToken: classifyShikiRoleByToken,
     hasAnyScopePattern: context.hasAnyScopePattern,
     hasScopePattern: context.hasScopePattern,
   }
-  const postBucket = applyShikiKeywordLegacyPostRules(baseBucket, context, postHelpers)
-  const finalBucket = applyKeywordV4Rules(postBucket, context)
+  const postBucket = applyShikiRoleLegacyPostRules(baseBucket, context, postHelpers)
+  const finalBucket = applyRoleV4Rules(postBucket, context)
   return finalBucket || postBucket || baseBucket
 }
 
 export {
-  classifyShikiScopeKeyword,
+  classifyShikiScopeRole,
   getShikiRawScopeName,
-  normalizeShikiKeywordLangAliasMap,
-  resolveShikiKeywordLangForFence,
+  normalizeShikiRoleLangAliasMap,
+  resolveShikiRoleLangForFence,
 }

package/src/custom-highlight/shiki-theme-role.js

@@ -0,0 +1,176 @@
+const freezeScopeGroups = (groups) => Object.freeze(Object.fromEntries(
+  Object.entries(groups).map(([key, scopes]) => [key, Object.freeze(scopes.slice())]),
+))
+
+const rendererFenceShikiThemeScopeGroups = freezeScopeGroups({
+  comment: [
+    'comment',
+    'punctuation.definition.comment',
+    'string.comment',
+  ],
+  string: [
+    'string',
+    'constant.other.symbol',
+    'constant.other.key',
+  ],
+  number: [
+    'constant.numeric',
+    'constant.numeric.integer',
+    'constant.numeric.float',
+    'constant.other.color',
+  ],
+  literal: [
+    'constant.language',
+    'constant.character',
+    'support.constant',
+    'variable.language',
+  ],
+  keyword: [
+    'keyword',
+    'storage.modifier',
+    'storage.type',
+    'storage.type.function',
+  ],
+  punctuation: [
+    // Keep this intentionally narrower than all of keyword.operator.
+    // Some grammars classify word-like tokens under keyword.operator; mapping the
+    // whole parent scope to punctuation can demote real keywords such as "new".
+    'keyword.operator.accessor',
+    'keyword.operator.arithmetic',
+    'keyword.operator.assignment',
+    'keyword.operator.bitwise',
+    'keyword.operator.comparison',
+    'keyword.operator.expression',
+    'keyword.operator.logical',
+    'keyword.operator.nullish',
+    'keyword.operator.optional',
+    'keyword.operator.spread',
+    'keyword.operator.ternary',
+    'punctuation',
+    'meta.brace',
+    'meta.delimiter',
+  ],
+  title: [
+    'entity.name.function',
+    'support.function',
+  ],
+  type: [
+    'entity.name.class',
+    'entity.name.type',
+    'entity.name.namespace',
+    'support.class',
+    'support.type',
+    'support.type.primitive',
+    'meta.type',
+  ],
+  variable: [
+    'variable',
+    'variable.other',
+    'variable.parameter',
+    'meta.object-literal.key',
+  ],
+  tag: [
+    'entity.name.tag',
+    'meta.tag',
+  ],
+  attribute: [
+    'entity.other.attribute-name',
+    'meta.attribute',
+  ],
+})
+
+const rendererFenceShikiThemeRoleBuckets = Object.freeze({
+  comment: 'comment',
+  string: 'string',
+  number: 'number',
+  literal: 'literal',
+  keyword: 'keyword',
+  punctuation: 'punctuation',
+  title: 'title-function',
+  type: 'type',
+  variable: 'variable',
+  tag: 'tag',
+  attribute: 'attribute',
+})
+
+const rendererFenceShikiThemeRoleScores = Object.freeze({
+  comment: 210,
+  attribute: 200,
+  tag: 198,
+  keyword: 194,
+  type: 188,
+  number: 186,
+  literal: 184,
+  string: 182,
+  title: 172,
+  variable: 156,
+  punctuation: 140,
+})
+
+const shikiThemeRolePatternEntries = Object.freeze(
+  Object.entries(rendererFenceShikiThemeScopeGroups).flatMap(([role, patterns]) => {
+    const bucket = rendererFenceShikiThemeRoleBuckets[role] || role
+    const score = rendererFenceShikiThemeRoleScores[role] || 0
+    return patterns.map((pattern) => Object.freeze({
+      bucket,
+      pattern,
+      patternLength: pattern.length,
+      score,
+    }))
+  }),
+)
+
+const shikiThemeRoleNoHit = Object.freeze({
+  bucket: '',
+  patternLength: -1,
+  score: -1,
+})
+
+const shikiThemeRoleSingleCache = new Map()
+
+const resolveRendererFenceShikiThemeRoleSingle = (scope) => {
+  const s = String(scope || '')
+  if (!s) return shikiThemeRoleNoHit
+  const cached = shikiThemeRoleSingleCache.get(s)
+  if (cached) return cached
+
+  let best = shikiThemeRoleNoHit
+  for (let i = 0; i < shikiThemeRolePatternEntries.length; i++) {
+    const entry = shikiThemeRolePatternEntries[i]
+    if (!s.includes(entry.pattern)) continue
+    if (
+      entry.score > best.score ||
+      (entry.score === best.score && entry.patternLength > best.patternLength)
+    ) {
+      best = entry
+    }
+  }
+  if (shikiThemeRoleSingleCache.size >= 8192) shikiThemeRoleSingleCache.clear()
+  shikiThemeRoleSingleCache.set(s, best)
+  return best
+}
+
+const resolveRendererFenceShikiThemeRoleBucket = (lowerScopeCandidates) => {
+  if (!Array.isArray(lowerScopeCandidates) || lowerScopeCandidates.length === 0) return null
+  let bestBucket = null
+  let bestScore = -1
+  let bestPatternLength = -1
+  for (let i = 0; i < lowerScopeCandidates.length; i++) {
+    const hit = resolveRendererFenceShikiThemeRoleSingle(lowerScopeCandidates[i])
+    if (!hit.bucket) continue
+    if (
+      hit.score > bestScore ||
+      (hit.score === bestScore && hit.patternLength > bestPatternLength)
+    ) {
+      bestBucket = hit.bucket
+      bestScore = hit.score
+      bestPatternLength = hit.patternLength
+    }
+  }
+  return bestBucket
+}
+
+export {
+  rendererFenceShikiThemeScopeGroups,
+  resolveRendererFenceShikiThemeRoleBucket,
+}

package/src/fence/line-notes.js

@@ -5,17 +5,36 @@ import {
 const lineNotesRuleName = 'renderer_fence_line_notes'
 const lineNotesMetaKey = '__rendererFenceLineNotes'
 const lineNotesInstalledKey = '__rendererFenceLineNotesInstalled'
-const fenceInfoNameReg = /^([^{\s]*)/
 const lineNoteHeaderReg = /^\s*([1-9]\d*)(?:\s*-\s*([1-9]\d*))?\s*[:：]\s*(.*)$/
 const lineNoteContinuationReg = /^(?: {2,}|\t)/
-const lineNoteFenceNameSet = new Set(['line-notes', 'notes'])
 const lineNoteAttrsReg = /^(.*?)(?:\s+\{([^{}]+)\})\s*$/
 const lineNoteAttrsOnlyReg = /^\{([^{}]+)\}\s*$/
 const lineNoteWidthReg = /^(?:\d+(?:\.\d+)?|\.\d+)(?:px|em|rem|ch|vw|svw|lvw|dvw|%)$/
 
-const getFenceInfoName = (info) => {
-  const match = String(info ?? '').trim().match(fenceInfoNameReg)
-  return match ? match[1] : ''
+const canContainLineNotes = (state) => {
+  const src = state && state.src
+  return typeof src === 'string' && src.indexOf('notes') !== -1
+}
+
+const isInfoWhitespaceCode = (code) => {
+  return code === 32 || code === 9 || code === 10 || code === 13 || code === 12
+}
+
+const isInfoNameEnd = (str, pos) => {
+  if (pos >= str.length) return true
+  const code = str.charCodeAt(pos)
+  return code === 123 || isInfoWhitespaceCode(code)
+}
+
+const infoNameStartsWith = (info, name) => {
+  const str = String(info ?? '')
+  let pos = 0
+  while (pos < str.length && isInfoWhitespaceCode(str.charCodeAt(pos))) pos++
+  return str.startsWith(name, pos) && isInfoNameEnd(str, pos + name.length)
+}
+
+const isLineNoteFenceInfo = (info) => {
+  return infoNameStartsWith(info, 'line-notes') || infoNameStartsWith(info, 'notes')
 }
 
 const stripContinuationIndent = (line) => {
@@ -155,6 +174,7 @@ const installLineNotesCoreRule = (md) => {
   if (!md || md[lineNotesInstalledKey]) return
   md[lineNotesInstalledKey] = true
   md.core.ruler.after('block', lineNotesRuleName, (state) => {
+    if (!canContainLineNotes(state)) return
     const tokens = state && state.tokens
     if (!Array.isArray(tokens) || tokens.length < 2) return
 
@@ -162,10 +182,8 @@ const installLineNotesCoreRule = (md) => {
       const token = tokens[i]
       const next = tokens[i + 1]
       if (!token || token.type !== 'fence' || !next || next.type !== 'fence') continue
-      const nextName = getFenceInfoName(next.info)
-      if (!lineNoteFenceNameSet.has(nextName)) continue
-      const currentName = getFenceInfoName(token.info)
-      if (lineNoteFenceNameSet.has(currentName)) continue
+      if (!isLineNoteFenceInfo(next.info)) continue
+      if (isLineNoteFenceInfo(token.info)) continue
       const notes = parseLineNotesContent(next.content)
       if (!notes || !notes.length) continue
       setTokenLineNotes(token, notes)