@peaceroad/markdown-it-renderer-fence 0.4.1 → 0.5.0

package/src/fence/render-api.js

@@ -0,0 +1,117 @@
+import {
+  getCustomHighlightPayloadMap,
+} from '../custom-highlight/payload-utils.js'
+import {
+  applyLineEndAlias,
+  finalizeCommonFenceOption,
+  prepareFenceRenderContext,
+} from './render-shared.js'
+import {
+  customHighlightDataEnvKey,
+  customHighlightEnvInitRuleName,
+  customHighlightPayloadSchemaVersion,
+  customHighlightPayloadSupportedVersions,
+  runtimeFallbackReasonSet,
+  customHighlightSeqEnvKey,
+} from './render-api-constants.js'
+import {
+  isNormalizedCustomHighlightOpt,
+  normalizeCustomHighlightOpt,
+  renderCustomHighlightPayloadScript,
+  renderCustomHighlightScopeStyleTag,
+  shouldApplyApiFallbackForReason,
+} from './render-api-provider.js'
+import {
+  getFenceHtml,
+} from './render-api-renderer.js'
+import {
+  applyCustomHighlights,
+  clearCustomHighlights,
+  observeCustomHighlights,
+} from './render-api-runtime.js'
+
+const shouldRuntimeFallback = (reason, opt = {}) => {
+  const chOpt = isNormalizedCustomHighlightOpt(opt) ? opt : normalizeCustomHighlightOpt(opt)
+  if (!runtimeFallbackReasonSet.has(reason)) return false
+  return shouldApplyApiFallbackForReason(chOpt, reason)
+}
+
+const mditRendererFenceCustomHighlight = (md, option) => {
+  const opt = {
+    attrsOrder: ['class', 'id', 'data-*', 'style'],
+    setHighlight: true,
+    setLineNumber: true,
+    setEmphasizeLines: true,
+    lineEndSpanThreshold: 0,
+    lineEndSpanClass: 'pre-lineend-spacer',
+    setPreWrapStyle: true,
+    useHighlightPre: false,
+    onFenceDecision: null,
+    onFenceDecisionTiming: false,
+    sampLang: 'shell,console',
+    langPrefix: md.options.langPrefix || 'language-',
+    customHighlight: null,
+  }
+  if (option) {
+    Object.assign(opt, option)
+    applyLineEndAlias(opt, option)
+  }
+
+  const rawCustomHighlightOpt = (opt.customHighlight && typeof opt.customHighlight === 'object')
+    ? opt.customHighlight
+    : {}
+  opt.customHighlight = normalizeCustomHighlightOpt(rawCustomHighlightOpt)
+  if (opt.customHighlight.provider === 'custom') {
+    opt.customHighlight._customGetRanges = (typeof opt.customHighlight.getRanges === 'function')
+      ? opt.customHighlight.getRanges
+      : null
+  } else if (opt.customHighlight.provider === 'hljs') {
+    opt.customHighlight._hljsHighlightFn =
+      (typeof opt.customHighlight.hljsHighlight === 'function')
+        ? opt.customHighlight.hljsHighlight
+        : ((typeof opt.customHighlight.highlight === 'function')
+          ? opt.customHighlight.highlight
+          : ((md && md.options && typeof md.options.highlight === 'function') ? md.options.highlight : null))
+  } else if (opt.customHighlight.provider === 'shiki') {
+    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') {
+      tokenOptionBase.includeExplanation = 'scopeName'
+    }
+    opt.customHighlight._shikiTokenOptionBase = Object.keys(tokenOptionBase).length ? tokenOptionBase : null
+  }
+
+  finalizeCommonFenceOption(opt)
+
+  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.renderer.rules.fence = (tokens, idx, options, env, slf) => {
+    const context = prepareFenceRenderContext(tokens, idx, opt)
+    return getFenceHtml(context, md, opt, slf, env)
+  }
+}
+
+export {
+  applyCustomHighlights,
+  clearCustomHighlights,
+  customHighlightPayloadSchemaVersion,
+  customHighlightPayloadSupportedVersions,
+  getCustomHighlightPayloadMap,
+  observeCustomHighlights,
+  renderCustomHighlightPayloadScript,
+  renderCustomHighlightScopeStyleTag,
+  shouldRuntimeFallback,
+}
+
+export default mditRendererFenceCustomHighlight

package/src/fence/render-markup.js

@@ -0,0 +1,161 @@
+import {
+  appendStyleValue,
+  mergeAttrSets,
+  parseHtmlAttrs,
+} from '../utils/attr-utils.js'
+import {
+  addTimingMs,
+  commentLineClass,
+  emitFenceDecision,
+  finalizeFenceTimings,
+  getLogicalLineCount,
+  getNowMs,
+  normalizeEmphasisRanges,
+  orderTokenAttrs,
+  preWrapStyle,
+  splitFenceBlockToLines,
+} from './render-shared.js'
+import {
+  parsePreCodeWrapper,
+} from '../utils/pre-code-wrapper-parser.js'
+
+const renderFenceMarkup = (context, md, opt, slf) => {
+  const token = context.token
+  const lang = context.lang
+  const timingEnabled = context.timingEnabled
+  const timings = context.timings
+  const fenceStartedAt = context.fenceStartedAt
+  const startNumber = context.startNumber
+  const emphasizeLines = context.emphasizeLines
+  const wrapEnabled = context.wrapEnabled
+  const preWrapValue = context.preWrapValue
+  const commentMarkValue = context.commentMarkValue
+
+  const isSamp = opt._sampReg.test(lang)
+  const sourceContent = token.content
+  let content = sourceContent
+  let commentLines
+  let needComment = false
+
+  if (opt.setHighlight && md.options.highlight) {
+    const highlightStartedAt = timingEnabled ? getNowMs() : 0
+    if (lang && lang !== 'samp') {
+      content = md.options.highlight(content, lang)
+    } else {
+      content = md.utils.escapeHtml(sourceContent)
+    }
+    if (timingEnabled) addTimingMs(timings, 'highlightMs', getNowMs() - highlightStartedAt)
+  } else {
+    content = md.utils.escapeHtml(sourceContent)
+  }
+
+  let preAttrsFromHighlight
+  let hasHighlightPre = false
+  const hasPreTag = (content.indexOf('<pre') !== -1 || content.indexOf('<PRE') !== -1)
+  if (hasPreTag) {
+    const preMatch = parsePreCodeWrapper(content)
+    if (preMatch) {
+      hasHighlightPre = true
+      preAttrsFromHighlight = parseHtmlAttrs(preMatch.preAttrsText)
+      const codeAttrsFromHighlight = parseHtmlAttrs(preMatch.codeAttrsText)
+      content = preMatch.content
+      if (codeAttrsFromHighlight.length) {
+        if (!token.attrs) token.attrs = []
+        mergeAttrSets(token.attrs, codeAttrsFromHighlight)
+      }
+    }
+  }
+
+  if (opt.useHighlightPre && hasPreTag && !hasHighlightPre) {
+    const decision = {
+      renderer: 'markup',
+      useHighlightPre: true,
+      passthrough: true,
+      passthroughReason: 'pre-code-parse-failed',
+      hasHighlightPre: false,
+      disabledFeatures: ['setLineNumber', 'setEmphasizeLines', 'lineEndSpanThreshold', 'comment-mark', 'samp'],
+    }
+    if (timingEnabled) decision.timings = finalizeFenceTimings(timings, fenceStartedAt)
+    emitFenceDecision(opt, decision)
+    return content.endsWith('\n') ? content : content + '\n'
+  }
+
+  orderTokenAttrs(token, opt)
+
+  const preAttrs = preAttrsFromHighlight ? preAttrsFromHighlight.slice() : []
+  if (preWrapValue !== undefined) {
+    const idx = preAttrs.findIndex((attr) => attr[0] === 'data-pre-wrap')
+    if (idx === -1) {
+      preAttrs.push(['data-pre-wrap', preWrapValue])
+    } else {
+      preAttrs[idx][1] = preWrapValue
+    }
+  }
+  if (wrapEnabled && opt.setPreWrapStyle !== false) {
+    const idx = preAttrs.findIndex((attr) => attr[0] === 'style')
+    if (idx === -1) {
+      preAttrs.push(['style', preWrapStyle])
+    } else {
+      preAttrs[idx][1] = appendStyleValue(preAttrs[idx][1], preWrapStyle)
+    }
+  }
+  if (preAttrs.length) orderTokenAttrs({ attrs: preAttrs }, opt)
+  const preAttrsText = preAttrs.length ? slf.renderAttrs({ attrs: preAttrs }) : ''
+
+  const needLineNumber = opt.setLineNumber && startNumber >= 0
+  const normalizedEmphasis = (opt.setEmphasizeLines && emphasizeLines.length > 0)
+    ? normalizeEmphasisRanges(emphasizeLines, getLogicalLineCount(content))
+    : []
+  const needEmphasis = normalizedEmphasis.length > 0
+  const needEndSpan = opt.lineEndSpanThreshold > 0
+  const useHighlightPre = opt.useHighlightPre && hasHighlightPre
+
+  if (!useHighlightPre && commentMarkValue && sourceContent.indexOf(commentMarkValue) !== -1) {
+    const sourceLogicalLineCount = getLogicalLineCount(sourceContent)
+    const highlightedLogicalLineCount = getLogicalLineCount(content)
+    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
+        }
+      }
+    }
+  }
+
+  if (!useHighlightPre && (needLineNumber || needEmphasis || needEndSpan || needComment)) {
+    const splitStartedAt = timingEnabled ? getNowMs() : 0
+    const nlIndex = content.indexOf('\n')
+    const br = nlIndex > 0 && content[nlIndex - 1] === '\r' ? '\r\n' : '\n'
+    content = splitFenceBlockToLines(
+      content,
+      normalizedEmphasis,
+      needLineNumber,
+      needEmphasis,
+      needEndSpan,
+      opt.lineEndSpanThreshold,
+      opt.lineEndSpanClass,
+      br,
+      commentLines,
+      commentLineClass,
+    )
+    if (timingEnabled) addTimingMs(timings, 'lineSplitMs', getNowMs() - splitStartedAt)
+  }
+
+  const tag = isSamp ? 'samp' : 'code'
+  const decision = {
+    renderer: 'markup',
+    useHighlightPre,
+    hasHighlightPre,
+    disabledFeatures: useHighlightPre ? ['setLineNumber', 'setEmphasizeLines', 'lineEndSpanThreshold', 'comment-mark', 'samp'] : [],
+  }
+  if (timingEnabled) decision.timings = finalizeFenceTimings(timings, fenceStartedAt)
+  emitFenceDecision(opt, decision)
+  return `<pre${preAttrsText}><${tag}${slf.renderAttrs(token)}>${content}</${tag}></pre>\n`
+}
+
+export {
+  renderFenceMarkup,
+}

package/src/fence/render-shared.js

@@ -0,0 +1,428 @@
+import {
+  appendStyleValue,
+  createAttrOrderIndexGetter,
+  getInfoAttr,
+  getLangFromClassAttr,
+} from '../utils/attr-utils.js'
+
+const infoReg = /^([^{\s]*)(?:\s*\{(.*)\})?$/
+const tagReg = /<\/?([A-Za-z][A-Za-z0-9-]*)(?:\s+[^>]*?)?\/?\s*>/g
+const preLineTag = '<span class="pre-line">'
+const emphOpenTag = '<span class="pre-lines-emphasis">'
+const commentLineClass = 'pre-line-comment'
+const closeTag = '</span>'
+const closeTagLen = closeTag.length
+const preWrapStyle = 'white-space: pre-wrap; overflow-wrap: anywhere;'
+const voidTags = new Set(['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr'])
+const nonNegativeIntReg = /^\d+$/
+
+const getLineVisualLengthIgnoringTags = (line, threshold) => {
+  let len = 0
+  let inTag = false
+  for (let i = 0; i < line.length; i++) {
+    const code = line.charCodeAt(i)
+    if (inTag) {
+      if (code === 62) inTag = false // >
+      continue
+    }
+    if (code === 60) { // <
+      inTag = true
+      continue
+    }
+    len += code > 255 ? 2 : 1
+    if (len >= threshold) return len
+  }
+  return len
+}
+
+const getNowMs = () => {
+  if (typeof performance !== 'undefined' && performance && typeof performance.now === 'function') return performance.now()
+  return Date.now()
+}
+
+const roundTimingMs = (value) => {
+  return Math.round(value * 1000) / 1000
+}
+
+const addTimingMs = (timings, key, value) => {
+  if (!timings || !key || !Number.isFinite(value) || value <= 0) return
+  timings[key] = (timings[key] || 0) + value
+}
+
+const finalizeFenceTimings = (timings, startedAtMs) => {
+  if (!timings || !Number.isFinite(startedAtMs)) return null
+  const totalMs = getNowMs() - startedAtMs
+  const out = {}
+  if (timings.attrNormalizeMs) out.attrNormalizeMs = roundTimingMs(timings.attrNormalizeMs)
+  if (timings.highlightMs) out.highlightMs = roundTimingMs(timings.highlightMs)
+  if (timings.providerMs) out.providerMs = roundTimingMs(timings.providerMs)
+  if (timings.lineSplitMs) out.lineSplitMs = roundTimingMs(timings.lineSplitMs)
+  out.totalMs = roundTimingMs(totalMs > 0 ? totalMs : 0)
+  return out
+}
+
+const applyLineEndAlias = (opt, sourceOption) => {
+  if (sourceOption && sourceOption.lineEndSpanThreshold == null && sourceOption.setLineEndSpan != null) {
+    opt.lineEndSpanThreshold = sourceOption.setLineEndSpan
+  }
+}
+
+const finalizeCommonFenceOption = (opt) => {
+  opt._sampReg = new RegExp('^(?:samp|' + opt.sampLang.split(',').join('|') + ')$')
+  opt._attrOrderIndex = createAttrOrderIndexGetter(opt.attrsOrder || [])
+  return opt
+}
+
+const emitFenceDecision = (opt, data) => {
+  if (!opt || typeof opt.onFenceDecision !== 'function') return
+  try {
+    opt.onFenceDecision(data)
+  } catch (e) {}
+}
+
+const parseStartNumber = (val) => {
+  const str = String(val ?? '')
+  if (!nonNegativeIntReg.test(str)) return null
+  const num = Number(str)
+  if (!Number.isSafeInteger(num) || num < 0) return null
+  return num
+}
+
+const getLogicalLineCount = (text) => {
+  const str = String(text ?? '')
+  if (!str) return 0
+  let count = 1
+  for (let i = 0; i < str.length; i++) {
+    const ch = str.charCodeAt(i)
+    if (ch !== 10 && ch !== 13) continue
+    if (ch === 13 && i + 1 < str.length && str.charCodeAt(i + 1) === 10) i++
+    count++
+  }
+  const last = str.charCodeAt(str.length - 1)
+  if (last === 10 || last === 13) count--
+  return count
+}
+
+const getEmphasizeLines = (attrVal) => {
+  const str = String(attrVal ?? '')
+  if (!str) return []
+  const result = []
+  for (const partRaw of str.split(',')) {
+    const part = partRaw.trim()
+    if (!part) continue
+    const hyphen = part.indexOf('-')
+    if (hyphen === -1) {
+      const n = Number(part)
+      if (Number.isFinite(n) && n > 0) result.push([n, n])
+      continue
+    }
+    const start = part.slice(0, hyphen).trim()
+    const end = part.slice(hyphen + 1).trim()
+    const s = start ? Number(start) : null
+    const e = end ? Number(end) : null
+    if (s == null && e == null) continue
+    if (s != null && (!Number.isFinite(s) || s <= 0)) continue
+    if (e != null && (!Number.isFinite(e) || e <= 0)) continue
+    result.push([s, e])
+  }
+  return result
+}
+
+const normalizeEmphasisRanges = (emphasizeLines, maxLine) => {
+  const normalized = []
+  if (!emphasizeLines || !emphasizeLines.length || maxLine <= 0) return normalized
+  for (const range of emphasizeLines) {
+    let s = range[0]
+    let e = range[1]
+    if (s == null) s = 1
+    if (e == null) e = maxLine
+    if (!Number.isFinite(s) || !Number.isFinite(e) || s <= 0 || e <= 0) continue
+    if (s > e) {
+      const tmp = s
+      s = e
+      e = tmp
+    }
+    if (s > maxLine || e < 1) continue
+    if (e > maxLine) e = maxLine
+    normalized.push([s, e])
+  }
+  return normalized
+}
+
+const splitFenceBlockToLines = (content, emphasizeLines, needLineNumber, needEmphasis, needEndSpan, threshold, lineEndSpanClass, br, commentLines, commentClass) => {
+  const lines = content.split(br)
+  const max = lines.length
+  let emIdx = 0
+  let emStart = -1
+  let emEnd = -1
+  if (needEmphasis && emphasizeLines && emphasizeLines.length) {
+    emStart = emphasizeLines[0][0]
+    emEnd = emphasizeLines[0][1]
+  } else {
+    needEmphasis = false
+  }
+
+  const endSpanTag = needEndSpan ? `<span class="${lineEndSpanClass}"></span>` : ''
+
+  for (let n = 0; n < max; n++) {
+    let line = lines[n]
+    const notLastLine = n < max - 1
+    const doComment = commentLines && commentLines[n]
+    let hasLt = false
+    let hasLtChecked = false
+
+    if (needEndSpan && threshold > 0) {
+      if (!hasLtChecked) {
+        hasLt = line.indexOf('<') !== -1
+        hasLtChecked = true
+      }
+      let lineLen = 0
+      if (!hasLt) {
+        lineLen = line.length
+      } else {
+        lineLen = getLineVisualLengthIgnoringTags(line, threshold)
+      }
+      if (lineLen >= threshold) {
+        if (line.endsWith(closeTag)) {
+          line = line.slice(0, -closeTagLen) + endSpanTag + closeTag
+        } else {
+          line = line + endSpanTag
+        }
+      }
+    }
+
+    if (needLineNumber && notLastLine) {
+      if (!hasLtChecked) {
+        hasLt = line.indexOf('<') !== -1
+        hasLtChecked = true
+      }
+      if (hasLt && line.indexOf('>') !== -1) {
+        const tagStack = []
+        tagReg.lastIndex = 0
+        let match
+        while ((match = tagReg.exec(line)) !== null) {
+          const fullMatch = match[0]
+          const tagNameLower = match[1].toLowerCase()
+          if (fullMatch.startsWith('</')) {
+            if (tagStack[tagStack.length - 1] === tagNameLower) tagStack.pop()
+          } else if (!fullMatch.endsWith('/>') && !voidTags.has(tagNameLower)) {
+            tagStack.push(tagNameLower)
+          }
+        }
+        for (let i = tagStack.length - 1; i >= 0; i--) {
+          const tagName = tagStack[i]
+          line += `</${tagName}>`
+          lines[n + 1] = `<${tagName}>` + lines[n + 1]
+        }
+      }
+    }
+
+    if (doComment) {
+      line = `<span class="${commentClass}">` + line + closeTag
+    }
+
+    if (needLineNumber && notLastLine) {
+      line = preLineTag + line + closeTag
+    }
+
+    if (needEmphasis && emIdx < emphasizeLines.length && emStart === n + 1) {
+      line = emphOpenTag + line
+    }
+    if (needEmphasis && emIdx < emphasizeLines.length && emEnd === n) {
+      line = closeTag + line
+      emIdx++
+      const nextEmphasis = emphasizeLines[emIdx] || []
+      emStart = nextEmphasis[0]
+      emEnd = nextEmphasis[1]
+    }
+
+    lines[n] = line
+  }
+  return lines.join(br)
+}
+
+const orderTokenAttrs = (token, opt) => {
+  const attrs = token.attrs
+  if (!attrs || attrs.length < 2) return
+  const rankCache = new Map()
+  const getRank = (name) => {
+    let rank = rankCache.get(name)
+    if (rank === undefined) {
+      rank = opt._attrOrderIndex(name)
+      rankCache.set(name, rank)
+    }
+    return rank
+  }
+  attrs.sort((a, b) => getRank(a[0]) - getRank(b[0]))
+}
+
+const prepareFenceRenderContext = (tokens, idx, opt) => {
+  const token = tokens[idx]
+  const match = token.info.trim().match(infoReg)
+  let lang = match ? match[1] : ''
+  const timingEnabled = !!(opt.onFenceDecisionTiming && typeof opt.onFenceDecision === 'function')
+  const fenceStartedAt = timingEnabled ? getNowMs() : 0
+  const timings = timingEnabled ? {} : null
+
+  if (match && match[2]) {
+    const infoAttrs = getInfoAttr(match[2])
+    for (let i = 0; i < infoAttrs.length; i++) {
+      const attr = infoAttrs[i]
+      token.attrJoin(attr[0], attr[1])
+    }
+  }
+  if (lang && lang !== 'samp') {
+    const langClass = opt.langPrefix + lang
+    const existingClass = token.attrGet('class')
+    token.attrSet('class', existingClass ? langClass + ' ' + existingClass : langClass)
+  }
+
+  let startNumber = -1
+  let emphasizeLines = []
+  let wrapEnabled = false
+  let preWrapValue
+  let commentMarkValue
+  const attrNormalizeStartedAt = timingEnabled ? getNowMs() : 0
+
+  if (token.attrs) {
+    const newAttrs = []
+    let dataPreStartIndex = -1
+    let dataPreEmphasisIndex = -1
+    let styleIndex = -1
+    let dataPreCommentIndex = -1
+    let startValue
+    let emphasisValue
+    let styleValue
+    let sawCommentMark = false
+    let sawStartAttr = false
+    let sawEmphasisAttr = false
+    const appendOrder = []
+
+    for (const attr of token.attrs) {
+      const name = attr[0]
+      const val = attr[1]
+
+      switch (name) {
+        case 'class': {
+          const classLang = getLangFromClassAttr(val, opt.langPrefix)
+          if (classLang) lang = classLang
+          newAttrs.push(attr)
+          break
+        }
+        case 'style':
+          styleIndex = newAttrs.length
+          styleValue = val
+          newAttrs.push(attr)
+          break
+        case 'data-pre-start':
+          startNumber = parseStartNumber(val) ?? -1
+          startValue = val
+          dataPreStartIndex = newAttrs.length
+          newAttrs.push(attr)
+          break
+        case 'start':
+        case 'pre-start':
+          startNumber = parseStartNumber(val) ?? -1
+          startValue = val
+          if (!sawStartAttr) {
+            appendOrder.push('start')
+            sawStartAttr = true
+          }
+          break
+        case 'data-pre-emphasis':
+          dataPreEmphasisIndex = newAttrs.length
+          newAttrs.push(attr)
+          break
+        case 'data-pre-comment-mark':
+          dataPreCommentIndex = newAttrs.length
+          commentMarkValue = val
+          newAttrs.push(attr)
+          break
+        case 'em-lines':
+        case 'emphasize-lines':
+          if (opt.setEmphasizeLines) emphasizeLines = getEmphasizeLines(val)
+          emphasisValue = val
+          if (!sawEmphasisAttr) {
+            appendOrder.push('emphasis')
+            sawEmphasisAttr = true
+          }
+          break
+        case 'comment-mark':
+          commentMarkValue = val
+          if (!sawCommentMark) {
+            appendOrder.push('comment')
+            sawCommentMark = true
+          }
+          break
+        case 'data-pre-wrap':
+          preWrapValue = val
+          if (val === '' || val === 'true') wrapEnabled = true
+          break
+        case 'wrap':
+        case 'pre-wrap':
+          if (val === '' || val === 'true') wrapEnabled = true
+          break
+        default:
+          newAttrs.push(attr)
+      }
+    }
+
+    if (startValue !== undefined && dataPreStartIndex >= 0) newAttrs[dataPreStartIndex][1] = startValue
+    if (emphasisValue !== undefined && dataPreEmphasisIndex >= 0) newAttrs[dataPreEmphasisIndex][1] = emphasisValue
+    if (commentMarkValue !== undefined && dataPreCommentIndex >= 0) newAttrs[dataPreCommentIndex][1] = commentMarkValue
+
+    for (const kind of appendOrder) {
+      if (kind === 'start' && dataPreStartIndex === -1 && startValue !== undefined) {
+        newAttrs.push(['data-pre-start', startValue])
+      } else if (kind === 'emphasis' && dataPreEmphasisIndex === -1 && emphasisValue !== undefined) {
+        newAttrs.push(['data-pre-emphasis', emphasisValue])
+      } else if (kind === 'comment' && dataPreCommentIndex === -1 && commentMarkValue !== undefined) {
+        newAttrs.push(['data-pre-comment-mark', commentMarkValue])
+      }
+    }
+
+    if (startNumber !== -1) {
+      styleValue = appendStyleValue(styleValue, 'counter-set:pre-line-number ' + startNumber + ';')
+    }
+    if (styleIndex >= 0) {
+      if (styleValue !== undefined) newAttrs[styleIndex][1] = styleValue
+    } else if (styleValue) {
+      newAttrs.push(['style', styleValue])
+    }
+
+    if (wrapEnabled) preWrapValue = 'true'
+    token.attrs = newAttrs
+  }
+
+  if (timingEnabled) addTimingMs(timings, 'attrNormalizeMs', getNowMs() - attrNormalizeStartedAt)
+
+  return {
+    token,
+    lang,
+    startNumber,
+    emphasizeLines,
+    wrapEnabled,
+    preWrapValue,
+    commentMarkValue,
+    timingEnabled,
+    timings,
+    fenceStartedAt,
+  }
+}
+
+export {
+  addTimingMs,
+  applyLineEndAlias,
+  commentLineClass,
+  emitFenceDecision,
+  finalizeCommonFenceOption,
+  finalizeFenceTimings,
+  getLogicalLineCount,
+  getNowMs,
+  getEmphasizeLines,
+  normalizeEmphasisRanges,
+  orderTokenAttrs,
+  preWrapStyle,
+  prepareFenceRenderContext,
+  splitFenceBlockToLines,
+}