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

package/src/fence/render-api-provider.js

@@ -1,9 +1,9 @@
 import {
-  classifyShikiScopeKeyword,
+  classifyShikiScopeRole,
   getShikiRawScopeName,
-  normalizeShikiKeywordLangAliasMap,
-  resolveShikiKeywordLangForFence,
-} from '../custom-highlight/shiki-keyword.js'
+  normalizeShikiRoleLangAliasMap,
+  resolveShikiRoleLangForFence,
+} from '../custom-highlight/shiki-role.js'
 import {
   escapeHtmlAttr,
   getCustomHighlightPayloadMap,
@@ -20,6 +20,7 @@ import {
 } from '../custom-highlight/scope-name.js'
 import {
   commentLineClass,
+  getCommentLineRanges,
   normalizeEmphasisRanges,
 } from './render-shared.js'
 import {
@@ -46,9 +47,9 @@ const defaultCustomHighlightOpt = {
   scopePrefix: 'hl',
   includeScopeStyles: true,
   shikiScopeMode: 'auto',
-  shikiKeywordClassifier: null,
-  shikiKeywordLangResolver: null,
-  shikiKeywordLangAliases: null,
+  shikiRoleClassifier: null,
+  shikiRoleLangResolver: null,
+  shikiRoleLangAliases: null,
 }
 
 const normalizeCustomHighlightProvider = (provider) => {
@@ -60,7 +61,7 @@ const normalizeCustomHighlightProvider = (provider) => {
 const normalizeShikiScopeMode = (mode) => {
   const key = String(mode || '').trim().toLowerCase()
   if (!key) return null
-  if (key === 'keyword') return 'keyword'
+  if (key === 'role') return 'role'
   if (key === 'semantic') return 'semantic'
   if (key === 'color') return 'color'
   if (key === 'auto') return 'auto'
@@ -135,7 +136,7 @@ const buildShikiInternalLangAliasMap = (highlighter) => {
     } catch (e) {}
     rawMap[rawName] = canonical
   }
-  return normalizeShikiKeywordLangAliasMap(rawMap)
+  return normalizeShikiRoleLangAliasMap(rawMap)
 }
 
 const normalizeCustomHighlightOpt = (opt = {}) => {
@@ -162,11 +163,11 @@ const normalizeCustomHighlightOpt = (opt = {}) => {
   } else {
     next.theme = normalizedTheme.singleTheme || null
   }
-  if (typeof next.shikiKeywordClassifier !== 'function') next.shikiKeywordClassifier = null
-  if (typeof next.shikiKeywordLangResolver !== 'function') next.shikiKeywordLangResolver = null
-  next.shikiKeywordLangAliases = normalizeShikiKeywordLangAliasMap(next.shikiKeywordLangAliases)
+  if (typeof next.shikiRoleClassifier !== 'function') next.shikiRoleClassifier = null
+  if (typeof next.shikiRoleLangResolver !== 'function') next.shikiRoleLangResolver = null
+  next.shikiRoleLangAliases = normalizeShikiRoleLangAliasMap(next.shikiRoleLangAliases)
   next._shikiInternalLangAliasMap =
-    (next.provider === 'shiki' && next.shikiScopeMode === 'keyword')
+    (next.provider === 'shiki' && next.shikiScopeMode === 'role')
       ? buildShikiInternalLangAliasMap(next.highlighter)
       : null
   const fallbackOn = Array.isArray(next.fallbackOn) ? next.fallbackOn : fallbackOnDefault
@@ -272,19 +273,20 @@ const sameScopeStyles = (a, b) => {
   return true
 }
 
-const getLogicalLinesAndOffsets = (text) => {
-  const rawLines = text.split('\n')
-  const logicalLineCount = rawLines.length > 0 && rawLines[rawLines.length - 1] === '' ? rawLines.length - 1 : rawLines.length
-  const lines = new Array(logicalLineCount)
-  const offsets = new Array(logicalLineCount)
-  let cursor = 0
-  for (let i = 0; i < logicalLineCount; i++) {
-    const line = rawLines[i]
-    lines[i] = line
-    offsets[i] = [cursor, cursor + line.length]
-    cursor += line.length + 1
+const getLogicalLineOffsets = (text) => {
+  const str = String(text ?? '')
+  const offsets = []
+  if (!str) return offsets
+  let lineStart = 0
+  for (let i = 0; i < str.length; i++) {
+    const code = str.charCodeAt(i)
+    if (code !== 10 && code !== 13) continue
+    offsets.push([lineStart, i])
+    if (code === 13 && i + 1 < str.length && str.charCodeAt(i + 1) === 10) i++
+    lineStart = i + 1
   }
-  return { lines, offsets }
+  if (lineStart < str.length) offsets.push([lineStart, str.length])
+  return offsets
 }
 
 const getShikiTokenStyle = (token) => {
@@ -459,21 +461,21 @@ const hasShikiOffsets = (tokenLines) => {
   return false
 }
 
-const getShikiScopeName = (tok, lang, style, opt, preResolvedKeywordLang = '') => {
+const getShikiScopeName = (tok, lang, style, opt, preResolvedRoleLang = '') => {
   const scopeMode = (opt && opt.shikiScopeMode) || 'auto'
   const rawScope = getShikiRawScopeName(tok)
-  let customKeywordName = null
-  const isKeywordScopeMode = scopeMode === 'keyword'
-  if (isKeywordScopeMode && opt && typeof opt.shikiKeywordClassifier === 'function') {
+  let customRoleName = null
+  const isRoleScopeMode = scopeMode === 'role'
+  if (isRoleScopeMode && opt && typeof opt.shikiRoleClassifier === 'function') {
     try {
-      const customName = opt.shikiKeywordClassifier(rawScope, tok, { lang, style, scopeMode })
-      if (customName != null && customName !== '') customKeywordName = String(customName)
+      const customName = opt.shikiRoleClassifier(rawScope, tok, { lang, style, scopeMode })
+      if (customName != null && customName !== '') customRoleName = String(customName)
     } catch (e) {}
   }
-  if (isKeywordScopeMode) {
-    if (customKeywordName) return 'shiki-' + customKeywordName
-    const bucket = classifyShikiScopeKeyword(rawScope, tok, lang, opt, preResolvedKeywordLang)
-    return 'shiki-' + bucket
+  if (isRoleScopeMode) {
+    if (customRoleName) return 'shiki-role-' + customRoleName
+    const bucket = classifyShikiScopeRole(rawScope, tok, lang, opt, preResolvedRoleLang)
+    return 'shiki-role-' + bucket
   }
   if (scopeMode === 'semantic') {
     if (rawScope) return 'shiki-' + rawScope
@@ -515,11 +517,11 @@ const createRangesFromShikiTokens = (lang, tokenLines, opt) => {
     scopeMode === 'auto' ||
     scopeMode === 'color' ||
     scopeMode === 'semantic' ||
-    (scopeMode === 'keyword' && !!(opt && typeof opt.shikiKeywordClassifier === 'function'))
+    (scopeMode === 'role' && !!(opt && typeof opt.shikiRoleClassifier === 'function'))
   const needTokenStyle = includeScopeStyles || needStyleForScopeName
-  let preResolvedKeywordLang = ''
-  if (scopeMode === 'keyword' && (!opt || typeof opt.shikiKeywordLangResolver !== 'function')) {
-    preResolvedKeywordLang = resolveShikiKeywordLangForFence(lang, opt)
+  let preResolvedRoleLang = ''
+  if (scopeMode === 'role' && (!opt || typeof opt.shikiRoleLangResolver !== 'function')) {
+    preResolvedRoleLang = resolveShikiRoleLangForFence(lang, opt)
   }
   let cursor = 0
   for (let i = 0; i < tokenLines.length; i++) {
@@ -534,7 +536,7 @@ const createRangesFromShikiTokens = (lang, tokenLines, opt) => {
       const start = hasOffset ? tok.offset : cursor
       const end = start + content.length
       const style = needTokenStyle ? getShikiTokenStyle(tok) : null
-      const scope = getShikiScopeName(tok, lang, style, opt, preResolvedKeywordLang)
+      const scope = getShikiScopeName(tok, lang, style, opt, preResolvedRoleLang)
       entries.push({ scope, start, end, style })
       cursor = end
     }
@@ -551,6 +553,7 @@ const normalizeCustomProviderRanges = (result) => {
   const entries = []
   for (const range of source.ranges) {
     let scope
+    let scopeIndex = null
     let start
     let end
     let style
@@ -567,10 +570,11 @@ const normalizeCustomProviderRanges = (result) => {
     } else {
       continue
     }
-    if (typeof scope === 'number' && scopes && scopes[scope] != null) scope = scopes[scope]
+    if (Number.isSafeInteger(scope)) scopeIndex = scope
+    if (scopeIndex != null && scopes && scopes[scopeIndex] != null) scope = scopes[scopeIndex]
     if (scope == null) continue
     if (!style && scopeStyles) {
-      if (typeof scope === 'number' && Array.isArray(scopeStyles)) style = scopeStyles[scope]
+      if (scopeIndex != null && Array.isArray(scopeStyles)) style = scopeStyles[scopeIndex]
       else style = scopeStyles[String(scope)]
     }
     entries.push({ scope: String(scope), start, end, style: normalizeScopeStyle(style) })
@@ -609,7 +613,12 @@ const buildApiPayload = (entries, text, lang, engine, scopePrefix, includeScopeS
       }
       scopeKeyToIndex.set(key, scopeIndex)
     }
-    ranges.push([scopeIndex, start, end])
+    const previousRange = ranges.length ? ranges[ranges.length - 1] : null
+    if (previousRange && previousRange[0] === scopeIndex && previousRange[2] === start) {
+      previousRange[2] = end
+    } else {
+      ranges.push([scopeIndex, start, end])
+    }
   }
   const payload = {
     v: customHighlightPayloadSchemaVersion,
@@ -629,8 +638,8 @@ const pushLineFeatureRanges = (entries, content, emphasizeLines, setEmphasizeLin
   const needsEmphasis = !!(setEmphasizeLines && emphasizeLines && emphasizeLines.length > 0)
   const needsCommentScan = !!(commentMarkValue && content.indexOf(commentMarkValue) !== -1)
   if (!needsEmphasis && !needsCommentScan) return
-  const { lines, offsets } = getLogicalLinesAndOffsets(content)
-  const maxLine = lines.length
+  const offsets = needsEmphasis ? getLogicalLineOffsets(content) : null
+  const maxLine = offsets ? offsets.length : 0
   if (needsEmphasis) {
     const normalized = normalizeEmphasisRanges(emphasizeLines, maxLine)
     for (const [s, e] of normalized) {
@@ -640,11 +649,11 @@ const pushLineFeatureRanges = (entries, content, emphasizeLines, setEmphasizeLin
     }
   }
   if (needsCommentScan) {
-    for (let i = 0; i < lines.length; i++) {
-      if (lines[i].trimStart().startsWith(commentMarkValue)) {
-        const [start, end] = offsets[i]
-        if (end > start) entries.push({ scope: commentLineClass, start, end })
-      }
+    const ranges = getCommentLineRanges(content, commentMarkValue)
+    if (!ranges) return
+    for (let i = 0; i < ranges.length; i++) {
+      const [start, end] = ranges[i]
+      entries.push({ scope: commentLineClass, start, end })
     }
   }
 }

package/src/fence/render-api-renderer.js

@@ -28,7 +28,7 @@ import {
   renderFenceMarkup,
 } from './render-markup.js'
 
-const apiDisableLineFeatureList = Object.freeze(['setLineNumber', 'line-number-skip', 'line-number-set', 'lineEndSpanThreshold', 'line-notes'])
+const apiDisableLineFeatureList = Object.freeze(['setLineNumber', 'line-number-skip', 'line-number-set', 'setEmphasizeLines', 'lineEndSpanThreshold', 'comment-mark', 'line-notes'])
 
 let fallbackCustomHighlightSeq = 0
 
@@ -49,8 +49,7 @@ const buildApiPreAttrs = (preWrapValue, wrapEnabled, opt) => {
   return preAttrs
 }
 
-const renderFenceApiOrPlain = (token, lang, md, opt, slf, env, startNumber, emphasizeLines, lineNumberSkipValue, lineNumberSetValue, wrapEnabled, preWrapValue, commentMarkValue, lineNotes, lineNoteIdPrefix, includePayload, timings) => {
-  const isSamp = opt._sampReg.test(lang)
+const renderFenceApiOrPlain = (token, lang, isSamp, md, opt, slf, env, startNumber, emphasizeLines, lineNumberSkipValue, lineNumberSetValue, wrapEnabled, preWrapValue, commentMarkValue, lineNotes, lineNoteIdPrefix, includePayload, timings) => {
   const tag = isSamp ? 'samp' : 'code'
   let content = md.utils.escapeHtml(token.content)
   const lineStrategy = opt.customHighlight.lineFeatureStrategy
@@ -119,6 +118,7 @@ const getFenceHtml = (context, md, opt, slf, env) => {
   const commentMarkValue = context.commentMarkValue
   const lineNotes = context.lineNotes
   const lineNoteIdPrefix = context.lineNoteIdPrefix
+  const isSamp = context.isSamp
 
   const apiDecisionBase = {
     renderer: 'api',
@@ -130,12 +130,13 @@ const getFenceHtml = (context, md, opt, slf, env) => {
       : [],
   }
   try {
-    const html = renderFenceApiOrPlain(token, lang, md, opt, slf, env, startNumber, emphasizeLines, lineNumberSkipValue, lineNumberSetValue, wrapEnabled, preWrapValue, commentMarkValue, lineNotes, lineNoteIdPrefix, true, timings)
+    const html = renderFenceApiOrPlain(token, lang, isSamp, md, opt, slf, env, startNumber, emphasizeLines, lineNumberSkipValue, lineNumberSetValue, wrapEnabled, preWrapValue, commentMarkValue, lineNotes, lineNoteIdPrefix, true, timings)
     if (timingEnabled) apiDecisionBase.timings = finalizeFenceTimings(timings, fenceStartedAt)
     emitFenceDecision(opt, apiDecisionBase)
     return html
   } catch (err) {
-    if (opt.customHighlight.fallback === 'plain' && shouldApplyApiFallbackForReason(opt.customHighlight, 'provider-error')) {
+    if (!shouldApplyApiFallbackForReason(opt.customHighlight, 'provider-error')) throw err
+    if (opt.customHighlight.fallback === 'plain') {
       const fallbackDecision = {
         renderer: 'api',
         includePayload: false,
@@ -144,7 +145,7 @@ const getFenceHtml = (context, md, opt, slf, env) => {
         reason: 'provider-error',
         lineFeatureStrategy: opt.customHighlight.lineFeatureStrategy,
       }
-      const html = renderFenceApiOrPlain(token, lang, md, opt, slf, env, startNumber, emphasizeLines, lineNumberSkipValue, lineNumberSetValue, wrapEnabled, preWrapValue, commentMarkValue, lineNotes, lineNoteIdPrefix, false, timings)
+      const html = renderFenceApiOrPlain(token, lang, isSamp, md, opt, slf, env, startNumber, emphasizeLines, lineNumberSkipValue, lineNumberSetValue, wrapEnabled, preWrapValue, commentMarkValue, lineNotes, lineNoteIdPrefix, false, timings)
       if (timingEnabled) fallbackDecision.timings = finalizeFenceTimings(timings, fenceStartedAt)
       emitFenceDecision(opt, fallbackDecision)
       return html

package/src/fence/render-api.js

@@ -40,6 +40,9 @@ const shouldRuntimeFallback = (reason, opt = {}) => {
   return shouldApplyApiFallbackForReason(chOpt, reason)
 }
 
+const customHighlightEnvInitInstalledKey = '__rendererFenceCustomHighlightEnvInitInstalled'
+const customHighlightEnvInitOptionKey = '__rendererFenceCustomHighlightEnvInitOption'
+
 const mditRendererFenceCustomHighlight = (md, option) => {
   const opt = {
     ...createCommonFenceOptionDefaults(md),
@@ -69,7 +72,7 @@ const mditRendererFenceCustomHighlight = (md, option) => {
     opt.customHighlight._hasShikiHighlighter = !!(opt.customHighlight.highlighter && typeof opt.customHighlight.highlighter.codeToTokens === 'function')
     const tokenOptionBase = {}
     if (opt.customHighlight._singleTheme) tokenOptionBase.theme = opt.customHighlight._singleTheme
-    if (opt.customHighlight.shikiScopeMode === 'semantic' || opt.customHighlight.shikiScopeMode === 'keyword') {
+    if (opt.customHighlight.shikiScopeMode === 'semantic' || opt.customHighlight.shikiScopeMode === 'role') {
       tokenOptionBase.includeExplanation = 'scopeName'
     }
     opt.customHighlight._shikiTokenOptionBase = Object.keys(tokenOptionBase).length ? tokenOptionBase : null
@@ -78,17 +81,22 @@ const mditRendererFenceCustomHighlight = (md, option) => {
   finalizeCommonFenceOption(opt)
   installLineNotesCoreRule(md)
 
-  md.core.ruler.before('block', customHighlightEnvInitRuleName, (state) => {
-    const env = state && state.env
-    if (!env || typeof env !== 'object') return
-    if (opt.customHighlight.transport === 'env') {
-      env[customHighlightDataEnvKey] = {}
-      env[customHighlightSeqEnvKey] = 0
-      return
-    }
-    delete env[customHighlightDataEnvKey]
-    delete env[customHighlightSeqEnvKey]
-  })
+  md[customHighlightEnvInitOptionKey] = opt.customHighlight
+  if (!md[customHighlightEnvInitInstalledKey]) {
+    md[customHighlightEnvInitInstalledKey] = true
+    md.core.ruler.before('block', customHighlightEnvInitRuleName, (state) => {
+      const env = state && state.env
+      if (!env || typeof env !== 'object') return
+      const chOpt = md[customHighlightEnvInitOptionKey]
+      if (chOpt && chOpt.transport === 'env') {
+        env[customHighlightDataEnvKey] = {}
+        env[customHighlightSeqEnvKey] = 0
+        return
+      }
+      delete env[customHighlightDataEnvKey]
+      delete env[customHighlightSeqEnvKey]
+    })
+  }
 
   md.renderer.rules.fence = (tokens, idx, options, env, slf) => {
     const context = prepareFenceRenderContext(tokens, idx, opt)

package/src/fence/render-markup.js

@@ -8,6 +8,7 @@ import {
   commentLineClass,
   emitFenceDecision,
   finalizeFenceTimings,
+  getCommentLineFlags,
   getLogicalLineCount,
   getNowMs,
   normalizeEmphasisRanges,
@@ -40,7 +41,7 @@ const renderFenceMarkup = (context, md, opt, slf) => {
   const lineNotes = context.lineNotes
   const lineNoteIdPrefix = context.lineNoteIdPrefix
 
-  const isSamp = opt._sampReg.test(lang)
+  const isSamp = context.isSamp
   const sourceContent = token.content
   let content = sourceContent
   let commentLines
@@ -140,14 +141,8 @@ const renderFenceMarkup = (context, md, opt, slf) => {
   if (!useHighlightPre && commentMarkValue && sourceContent.indexOf(commentMarkValue) !== -1) {
     ensureLogicalLineCounts()
     if (highlightedLogicalLineCount === sourceLogicalLineCount) {
-      const rawLines = sourceContent.split('\n')
-      for (let i = 0; i < rawLines.length; i++) {
-        if (rawLines[i].trimStart().startsWith(commentMarkValue)) {
-          if (!commentLines) commentLines = []
-          commentLines[i] = true
-          needComment = true
-        }
-      }
+      commentLines = getCommentLineFlags(sourceContent, commentMarkValue)
+      needComment = !!commentLines
     }
   }
 

package/src/fence/render-shared.js

@@ -103,7 +103,13 @@ const createCommonFenceOptionDefaults = (md) => {
 }
 
 const finalizeCommonFenceOption = (opt) => {
-  opt._sampReg = new RegExp('^(?:samp|' + opt.sampLang.split(',').join('|') + ')$')
+  const sampLangs = ['samp']
+  const extraSampLangs = String(opt.sampLang ?? '').split(',')
+  for (let i = 0; i < extraSampLangs.length; i++) {
+    const lang = extraSampLangs[i].trim()
+    if (lang) sampLangs.push(lang)
+  }
+  opt._sampLangSet = new Set(sampLangs)
   opt._attrOrderIndex = createAttrOrderIndexGetter(opt.attrsOrder || [])
   opt._attrOrderRankCache = new Map()
   return opt
@@ -132,6 +138,8 @@ const parsePositiveLineIndex = (val) => {
   return num
 }
 
+const isTruthyAttrValue = (val) => val !== 'false' && val !== '0'
+
 const escapeHtmlText = (value) => {
   return String(value ?? '')
     .replace(/&/g, '&amp;')
@@ -154,6 +162,62 @@ const getLogicalLineCount = (text) => {
   return count
 }
 
+const isLineStartWhitespaceCode = (code) => {
+  return code <= 32 || code === 160 || code === 0xFEFF
+}
+
+const lineStartsWithAfterIndent = (str, start, end, marker) => {
+  let pos = start
+  while (pos < end && isLineStartWhitespaceCode(str.charCodeAt(pos))) pos++
+  return str.startsWith(marker, pos)
+}
+
+const scanLogicalLineBounds = (str, onLine) => {
+  let lineStart = 0
+  let lineIndex = 0
+
+  for (let i = 0; i <= str.length; i++) {
+    const code = i < str.length ? str.charCodeAt(i) : 10
+    if (code !== 10 && code !== 13) continue
+    onLine(lineStart, i, lineIndex)
+    if (code === 13 && i + 1 < str.length && str.charCodeAt(i + 1) === 10) i++
+    lineStart = i + 1
+    lineIndex++
+  }
+}
+
+const getCommentLineFlags = (text, commentMarkValue) => {
+  const str = String(text ?? '')
+  const marker = String(commentMarkValue ?? '')
+  if (!str || !marker) return null
+  const flags = []
+  let hasComment = false
+
+  scanLogicalLineBounds(str, (lineStart, lineEnd, lineIndex) => {
+    if (lineStartsWithAfterIndent(str, lineStart, lineEnd, marker)) {
+      flags[lineIndex] = true
+      hasComment = true
+    }
+  })
+
+  return hasComment ? flags : null
+}
+
+const getCommentLineRanges = (text, commentMarkValue) => {
+  const str = String(text ?? '')
+  const marker = String(commentMarkValue ?? '')
+  if (!str || !marker) return null
+  const ranges = []
+
+  scanLogicalLineBounds(str, (lineStart, lineEnd) => {
+    if (lineEnd > lineStart && lineStartsWithAfterIndent(str, lineStart, lineEnd, marker)) {
+      ranges.push([lineStart, lineEnd])
+    }
+  })
+
+  return ranges.length ? ranges : null
+}
+
 const parseLineRangeList = (attrVal, parseValue) => {
   const str = String(attrVal ?? '')
   if (!str) return []
@@ -179,14 +243,8 @@ const parseLineRangeList = (attrVal, parseValue) => {
   return result
 }
 
-const parsePositiveLineNumber = (val) => {
-  const num = Number(val)
-  if (!Number.isFinite(num) || num <= 0) return null
-  return num
-}
-
 const getEmphasizeLines = (attrVal) => {
-  return parseLineRangeList(attrVal, parsePositiveLineNumber)
+  return parseLineRangeList(attrVal, parsePositiveLineIndex)
 }
 
 const getLineNumberSkipRanges = (attrVal) => {
@@ -537,6 +595,7 @@ const prepareFenceRenderContext = (tokens, idx, opt) => {
   let wrapEnabled = false
   let preWrapValue
   let commentMarkValue
+  let tagOverride = ''
   const lineNotes = getTokenLineNotes(token)
   const lineNoteIdPrefix = lineNotes && lineNotes.length ? getLineNoteIdPrefix(token, idx) : ''
   const attrNormalizeStartedAt = timingEnabled ? getNowMs() : 0
@@ -592,6 +651,7 @@ const prepareFenceRenderContext = (tokens, idx, opt) => {
           }
           break
         case 'data-pre-emphasis':
+          if (opt.setEmphasizeLines) emphasizeLines = getEmphasizeLines(val)
           dataPreEmphasisIndex = newAttrs.length
           newAttrs.push(attr)
           break
@@ -628,6 +688,12 @@ const prepareFenceRenderContext = (tokens, idx, opt) => {
             sawCommentMark = true
           }
           break
+        case 'samp':
+          tagOverride = isTruthyAttrValue(val) ? 'samp' : ''
+          break
+        case 'code':
+          tagOverride = isTruthyAttrValue(val) ? 'code' : ''
+          break
         case 'line-number-skip':
         case 'pre-line-number-skip':
           lineNumberSkipValue = val
@@ -695,10 +761,12 @@ const prepareFenceRenderContext = (tokens, idx, opt) => {
 
   if (timingEnabled) addTimingMs(timings, 'attrNormalizeMs', getNowMs() - attrNormalizeStartedAt)
   if (lineNotes && lineNotes.length) token.attrSet('data-pre-line-notes', 'true')
+  const isSamp = tagOverride ? tagOverride === 'samp' : opt._sampLangSet.has(lang)
 
   return {
     token,
     lang,
+    isSamp,
     startNumber,
     emphasizeLines,
     lineNumberSkipValue,
@@ -722,6 +790,8 @@ export {
   emitFenceDecision,
   finalizeCommonFenceOption,
   finalizeFenceTimings,
+  getCommentLineFlags,
+  getCommentLineRanges,
   getLogicalLineCount,
   getNowMs,
   getEmphasizeLines,

package/theme/_shared/rf-core.css

@@ -0,0 +1,164 @@
+/*! Renderer Fence shared base | MIT License */
+
+:root {
+  color-scheme: light dark;
+
+  --rf-code-bg: oklch(99.4% 0 0);
+  --rf-code-fg: oklch(4% 0 0);
+  --rf-code-muted: oklch(42% 0 0);
+  --rf-code-border: oklch(86% 0 0);
+
+  --rf-samp-bg: oklch(18% 0 0);
+  --rf-samp-fg: oklch(95% 0 0);
+  --rf-samp-muted: oklch(76% 0 0);
+  --rf-samp-border: oklch(41% 0 0);
+  --rf-samp-prompt: oklch(78% 0.13 285);
+
+  --rf-accent: oklch(50% 0.18 285);
+  --rf-accent-soft: oklch(94% 0.035 285);
+  --rf-accent-border: oklch(82% 0.08 285);
+
+  --rf-syntax-keyword: oklch(38% 0.255 25);
+  --rf-syntax-string: oklch(34% 0.235 250);
+  --rf-syntax-number: oklch(36% 0.245 260);
+  --rf-syntax-comment: oklch(39% 0.026 255);
+  --rf-syntax-type: oklch(38% 0.235 295);
+  --rf-syntax-title: oklch(39% 0.27 305);
+  --rf-syntax-variable: oklch(37% 0.205 80);
+  --rf-syntax-literal: oklch(36% 0.245 260);
+  --rf-syntax-tag: oklch(34% 0.18 150);
+  --rf-syntax-attribute: oklch(36% 0.23 260);
+  --rf-syntax-punctuation: oklch(12% 0.018 255);
+  --rf-syntax-meta: oklch(12% 0.018 255);
+
+  --rf-samp-syntax-keyword: oklch(78% 0.08 25);
+  --rf-samp-syntax-string: oklch(82% 0.055 250);
+  --rf-samp-syntax-number: oklch(80% 0.07 255);
+  --rf-samp-syntax-comment: oklch(75% 0.01 255);
+  --rf-samp-syntax-type: oklch(81% 0.06 295);
+  --rf-samp-syntax-title: oklch(82% 0.07 305);
+  --rf-samp-syntax-variable: oklch(82% 0.075 90);
+  --rf-samp-syntax-literal: oklch(80% 0.07 255);
+  --rf-samp-syntax-tag: oklch(81% 0.065 150);
+  --rf-samp-syntax-attribute: oklch(80% 0.07 255);
+  --rf-samp-syntax-punctuation: oklch(86% 0.012 255);
+
+  --rf-line-emphasis-bg: color-mix(in oklch, var(--rf-accent-soft) 70%, transparent);
+  --rf-line-number-fg: var(--rf-code-muted);
+  --rf-line-number-rule: color-mix(in oklch, var(--rf-code-border) 85%, transparent);
+  --rf-line-comment-bg: color-mix(in oklch, var(--rf-syntax-comment) 12%, transparent);
+  --rf-line-note-bg: oklch(100% 0 0);
+  --rf-line-note-border: var(--rf-accent-border);
+  --rf-line-note-fg: var(--rf-code-muted);
+}
+
+@media (prefers-color-scheme: dark) {
+  :root {
+    --rf-code-bg: oklch(18% 0 0);
+    --rf-code-fg: oklch(95% 0 0);
+    --rf-code-muted: oklch(76% 0 0);
+    --rf-code-border: oklch(38% 0 0);
+
+    --rf-samp-bg: oklch(99.4% 0 0);
+    --rf-samp-fg: oklch(4% 0 0);
+    --rf-samp-muted: oklch(42% 0 0);
+    --rf-samp-border: oklch(86% 0 0);
+    --rf-samp-prompt: oklch(50% 0.18 285);
+
+    --rf-accent: oklch(78% 0.13 285);
+    --rf-accent-soft: oklch(27% 0.05 285);
+    --rf-accent-border: oklch(48% 0.11 285);
+
+    --rf-syntax-keyword: oklch(78% 0.08 25);
+    --rf-syntax-string: oklch(82% 0.055 250);
+    --rf-syntax-number: oklch(80% 0.07 255);
+    --rf-syntax-comment: oklch(75% 0.01 255);
+    --rf-syntax-type: oklch(81% 0.06 295);
+    --rf-syntax-title: oklch(82% 0.07 305);
+    --rf-syntax-variable: oklch(82% 0.075 90);
+    --rf-syntax-literal: oklch(80% 0.07 255);
+    --rf-syntax-tag: oklch(81% 0.065 150);
+    --rf-syntax-attribute: oklch(80% 0.07 255);
+    --rf-syntax-punctuation: oklch(86% 0.012 255);
+    --rf-syntax-meta: oklch(86% 0.012 255);
+
+    --rf-samp-syntax-keyword: oklch(38% 0.255 25);
+    --rf-samp-syntax-string: oklch(34% 0.235 250);
+    --rf-samp-syntax-number: oklch(36% 0.245 260);
+    --rf-samp-syntax-comment: oklch(39% 0.026 255);
+    --rf-samp-syntax-type: oklch(38% 0.235 295);
+    --rf-samp-syntax-title: oklch(39% 0.27 305);
+    --rf-samp-syntax-variable: oklch(37% 0.205 80);
+    --rf-samp-syntax-literal: oklch(36% 0.245 260);
+    --rf-samp-syntax-tag: oklch(34% 0.18 150);
+    --rf-samp-syntax-attribute: oklch(36% 0.23 260);
+    --rf-samp-syntax-punctuation: oklch(12% 0.018 255);
+
+    --rf-line-emphasis-bg: color-mix(in oklch, var(--rf-accent-soft) 70%, transparent);
+    --rf-line-number-fg: var(--rf-code-muted);
+    --rf-line-number-rule: color-mix(in oklch, var(--rf-code-border) 85%, transparent);
+    --rf-line-comment-bg: color-mix(in oklch, var(--rf-syntax-comment) 16%, transparent);
+    --rf-line-note-bg: oklch(24% 0.01 255);
+    --rf-line-note-border: var(--rf-accent-border);
+    --rf-line-note-fg: var(--rf-code-muted);
+  }
+}
+
+pre {
+  margin: 0;
+  padding: 1rem;
+  overflow: auto;
+  color: var(--rf-code-fg);
+  background: var(--rf-code-bg);
+  border: 1px solid var(--rf-code-border);
+  border-radius: 0.5rem;
+}
+
+pre code,
+pre samp {
+  color: inherit;
+  background: transparent;
+  font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, "Liberation Mono", monospace;
+}
+
+.pre-lines-emphasis {
+  background: var(--rf-line-emphasis-bg);
+}
+
+.pre-line-comment {
+  color: var(--rf-syntax-comment);
+  background: var(--rf-line-comment-bg);
+  padding-block: 0.04em;
+  line-height: 1.45;
+  -webkit-box-decoration-break: clone;
+  box-decoration-break: clone;
+}
+
+pre:has(> samp) {
+  --rf-syntax-keyword: var(--rf-samp-syntax-keyword);
+  --rf-syntax-string: var(--rf-samp-syntax-string);
+  --rf-syntax-number: var(--rf-samp-syntax-number);
+  --rf-syntax-comment: var(--rf-samp-syntax-comment);
+  --rf-syntax-type: var(--rf-samp-syntax-type);
+  --rf-syntax-title: var(--rf-samp-syntax-title);
+  --rf-syntax-variable: var(--rf-samp-syntax-variable);
+  --rf-syntax-literal: var(--rf-samp-syntax-literal);
+  --rf-syntax-tag: var(--rf-samp-syntax-tag);
+  --rf-syntax-attribute: var(--rf-samp-syntax-attribute);
+  --rf-syntax-punctuation: var(--rf-samp-syntax-punctuation);
+  --rf-syntax-meta: var(--rf-samp-syntax-punctuation);
+  --line-number-color: var(--rf-samp-muted);
+  --line-number-rule-color: var(--rf-samp-border);
+  --line-note-color: var(--rf-samp-muted);
+  --line-note-label-color: var(--rf-samp-muted);
+  --line-note-border-color: var(--rf-samp-border);
+  --line-note-background: color-mix(in oklch, var(--rf-samp-bg) 92%, var(--rf-samp-fg));
+  color: var(--rf-samp-fg);
+  background: var(--rf-samp-bg);
+  border-color: var(--rf-samp-border);
+}
+
+pre:has(> samp) .pre-line-comment {
+  color: var(--rf-samp-muted);
+  background: color-mix(in oklch, var(--rf-samp-muted) 18%, transparent);
+}