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

package/src/fence/render-api.js

@@ -0,0 +1,107 @@
+import {
+  getCustomHighlightPayloadMap,
+} from '../custom-highlight/payload-utils.js'
+import {
+  applyLineEndAlias,
+  createCommonFenceOptionDefaults,
+  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 = {
+    ...createCommonFenceOptionDefaults(md),
+    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,177 @@
+import {
+  appendStyleValue,
+  mergeAttrSets,
+  parseHtmlAttrs,
+} from '../utils/attr-utils.js'
+import {
+  addTimingMs,
+  commentLineClass,
+  emitFenceDecision,
+  finalizeFenceTimings,
+  getLogicalLineCount,
+  getNowMs,
+  normalizeEmphasisRanges,
+  orderTokenAttrs,
+  preWrapStyle,
+  resolveAdvancedLineNumberPlan,
+  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 lineNumberSkipValue = context.lineNumberSkipValue
+  const lineNumberResetValue = context.lineNumberResetValue
+  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
+  let sourceLogicalLineCount = -1
+  let highlightedLogicalLineCount = -1
+  const ensureLogicalLineCounts = () => {
+    if (sourceLogicalLineCount === -1) sourceLogicalLineCount = getLogicalLineCount(sourceContent)
+    if (highlightedLogicalLineCount === -1) highlightedLogicalLineCount = getLogicalLineCount(content)
+  }
+  let normalizedEmphasis = []
+  if (opt.setEmphasizeLines && emphasizeLines.length > 0) {
+    ensureLogicalLineCounts()
+    normalizedEmphasis = normalizeEmphasisRanges(emphasizeLines, highlightedLogicalLineCount)
+  }
+  let lineNumberPlan = null
+  if (needLineNumber && (lineNumberSkipValue !== undefined || lineNumberResetValue !== undefined)) {
+    ensureLogicalLineCounts()
+    lineNumberPlan = resolveAdvancedLineNumberPlan(lineNumberSkipValue, lineNumberResetValue, sourceLogicalLineCount, highlightedLogicalLineCount)
+  }
+  const needEmphasis = normalizedEmphasis.length > 0
+  const needEndSpan = opt.lineEndSpanThreshold > 0
+  const useHighlightPre = opt.useHighlightPre && hasHighlightPre
+
+  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
+        }
+      }
+    }
+  }
+
+  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,
+      lineNumberPlan,
+    )
+    if (timingEnabled) addTimingMs(timings, 'lineSplitMs', getNowMs() - splitStartedAt)
+  }
+
+  const tag = isSamp ? 'samp' : 'code'
+  const decision = {
+    renderer: 'markup',
+    useHighlightPre,
+    hasHighlightPre,
+    disabledFeatures: useHighlightPre ? ['setLineNumber', 'line-number-skip', 'line-number-reset', '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,
+}