@peaceroad/markdown-it-strong-ja 0.8.1 → 0.9.1

package/src/token-postprocess/orchestrator.js

@@ -1,6 +1,6 @@
 import Token from 'markdown-it/lib/token.mjs'
 import { buildLinkCloseMap, convertCollapsedReferenceLinks, mergeBrokenMarksAroundLinks } from '../token-link-utils.js'
-import { computeMaxBrokenRefRepairPass, runBrokenRefRepairs } from './broken-ref.js'
+import { runBrokenRefRepairs } from './broken-ref.js'
 import {
   rebuildInlineLevels,
   rebuildInlineLevelsFrom,
@@ -10,68 +10,36 @@ import {
 } from '../token-core.js'
 import {
   getRuntimeOpt,
-  getReferenceCount
+  hasRuntimeOverride,
+  getReferenceCount,
+  isAsciiWordCode,
+  isSoftSpaceCode,
+  cloneMap
 } from '../token-utils.js'
 import {
   hasMarkerChars,
   hasJapaneseContextInRange,
   hasEmphasisSignalInRange,
   buildAsteriskWrapperPrefixStats,
-  scanInlinePostprocessSignals
+  scanInlinePostprocessSignals,
+  INLINE_REPAIR_EM_OUTER_STRONG_SEQUENCE,
+  INLINE_REPAIR_TAIL_AFTER_LINK,
+  INLINE_REPAIR_LEADING_ASTERISK_EM,
+  INLINE_REPAIR_TRAILING_STRONG,
+  INLINE_REPAIR_BALANCE_SANITIZE
 } from './guards.js'
 import {
   tryFixTailPatternTokenOnly,
   tryFixTailDanglingStrongCloseTokenOnly
 } from './fastpaths.js'
+import { sanitizeEmStrongBalance } from './emphasis-balance.js'
 
-const fallbackMarkupByType = (type) => {
-  if (type === 'strong_open' || type === 'strong_close') return '**'
-  if (type === 'em_open' || type === 'em_close') return '*'
-  return ''
-}
-
-const makeTokenLiteralText = (token) => {
-  if (!token) return
-  const literal = token.markup || fallbackMarkupByType(token.type)
-  token.type = 'text'
-  token.tag = ''
-  token.nesting = 0
-  token.content = literal
-  token.markup = ''
-  token.info = ''
-}
-
-const sanitizeEmStrongBalance = (tokens, onChangeStart = null) => {
-  if (!tokens || tokens.length === 0) return false
-  const stack = []
-  let changed = false
-  for (let i = 0; i < tokens.length; i++) {
-    const token = tokens[i]
-    if (!token || !token.type) continue
-    if (token.type === 'strong_open' || token.type === 'em_open') {
-      stack.push({ type: token.type, idx: i })
-      continue
-    }
-    if (token.type !== 'strong_close' && token.type !== 'em_close') continue
-    const expected = token.type === 'strong_close' ? 'strong_open' : 'em_open'
-    if (stack.length > 0 && stack[stack.length - 1].type === expected) {
-      stack.pop()
-      continue
-    }
-    if (onChangeStart) onChangeStart(i)
-    makeTokenLiteralText(token)
-    changed = true
-  }
-  for (let i = stack.length - 1; i >= 0; i--) {
-    const entry = stack[i]
-    const token = tokens[entry.idx]
-    if (!token) continue
-    if (onChangeStart) onChangeStart(entry.idx)
-    makeTokenLiteralText(token)
-    changed = true
-  }
-  return changed
-}
+const INLINE_REPAIR_ALL_EMPHASIS_FIXERS =
+  INLINE_REPAIR_EM_OUTER_STRONG_SEQUENCE |
+  INLINE_REPAIR_TAIL_AFTER_LINK |
+  INLINE_REPAIR_LEADING_ASTERISK_EM |
+  INLINE_REPAIR_TRAILING_STRONG |
+  INLINE_REPAIR_BALANCE_SANITIZE
 
 const getPostprocessMetrics = (state) => {
   if (!state || !state.env) return null
@@ -80,53 +48,23 @@ const getPostprocessMetrics = (state) => {
   return metrics
 }
 
-const buildInlinePostprocessFacts = (children, inlineContent) => {
-  const preScan = scanInlinePostprocessSignals(children)
+const buildInlinePostprocessFacts = (children, inlineContent, collectJapaneseContext) => {
+  const preScan = scanInlinePostprocessSignals(children, collectJapaneseContext)
   return {
     hasBracketText: inlineContent.indexOf('[') !== -1 || inlineContent.indexOf(']') !== -1,
     hasEmphasis: preScan.hasEmphasis,
+    hasAsteriskWrapperImbalance: preScan.hasAsteriskWrapperImbalance,
     hasLinkOpen: preScan.hasLinkOpen,
     hasLinkClose: preScan.hasLinkClose,
-    hasCodeInline: undefined,
-    referenceCount: undefined,
-    metrics: undefined,
+    hasCodeInline: preScan.hasCodeInline,
+    hasJapaneseContext: preScan.hasJapaneseContext,
+    repairMask: preScan.repairMask,
     linkCloseMap: undefined,
     wrapperPrefixStats: undefined,
     rebuildLevelStart: undefined
   }
 }
 
-const ensureInlineHasCodeInline = (facts, tokens) => {
-  if (facts.hasCodeInline !== undefined) return facts.hasCodeInline
-  let hasCodeInline = false
-  if (tokens && tokens.length > 0) {
-    for (let idx = 0; idx < tokens.length; idx++) {
-      if (tokens[idx] && tokens[idx].type === 'code_inline') {
-        hasCodeInline = true
-        break
-      }
-    }
-  }
-  facts.hasCodeInline = hasCodeInline
-  return hasCodeInline
-}
-
-const ensureInlineReferenceCount = (facts, state) => {
-  if (!facts || !facts.hasBracketText) return 0
-  if (facts.referenceCount === undefined) {
-    facts.referenceCount = getReferenceCount(state)
-  }
-  return facts.referenceCount
-}
-
-const ensureInlineMetrics = (facts, state) => {
-  if (!facts) return null
-  if (facts.metrics === undefined) {
-    facts.metrics = getPostprocessMetrics(state)
-  }
-  return facts.metrics
-}
-
 const ensureInlineLinkCloseMap = (facts, tokens) => {
   if (!tokens || tokens.length === 0) return new Map()
   if (!facts) return buildLinkCloseMap(tokens, 0, tokens.length - 1)
@@ -191,14 +129,14 @@ const BROKEN_REF_REPAIR_HOOKS = {
   markLevelRebuildFrom: markInlineLevelRebuildFrom
 }
 
-const bumpPostprocessMetric = (metrics, bucket, key) => {
-  if (!metrics || !bucket || !key) return
+const bumpPostprocessMetric = (metrics, bucket, key, delta = 1) => {
+  if (!metrics || !bucket || !key || delta <= 0) return
   let table = metrics[bucket]
   if (!table || typeof table !== 'object') {
     table = Object.create(null)
     metrics[bucket] = table
   }
-  table[key] = (table[key] || 0) + 1
+  table[key] = (table[key] || 0) + delta
 }
 
 const scanTailRepairCandidateAfterLinkClose = (tokens, linkCloseIdx) => {
@@ -264,11 +202,6 @@ const fixTailAfterLinkStrongClose = (tokens, isJapaneseMode, metrics = null, onC
   return false
 }
 
-const cloneMap = (map) => {
-  if (!map || !Array.isArray(map)) return null
-  return [map[0], map[1]]
-}
-
 const cloneTextToken = (source, content) => {
   const token = new Token('text', '', 0)
   Object.assign(token, source)
@@ -277,15 +210,8 @@ const cloneTextToken = (source, content) => {
   return token
 }
 
-const isSoftSpaceCode = (code) => {
-  return code === 0x20 || code === 0x09 || code === 0x3000
-}
-
-const isAsciiWordCode = (code) => {
-  return (code >= 0x30 && code <= 0x39) ||
-    (code >= 0x41 && code <= 0x5A) ||
-    (code >= 0x61 && code <= 0x7A)
-}
+const CHAR_ASTERISK = 0x2A // *
+const CHAR_BACKSLASH = 0x5C // \
 
 const textEndsAsciiWord = (text) => {
   if (!text || text.length === 0) return false
@@ -299,7 +225,7 @@ const textStartsAsciiWord = (text) => {
 
 const isEscapedMarkerAt = (content, index) => {
   let slashCount = 0
-  for (let i = index - 1; i >= 0 && content.charCodeAt(i) === 0x5C; i--) {
+  for (let i = index - 1; i >= 0 && content.charCodeAt(i) === CHAR_BACKSLASH; i--) {
     slashCount++
   }
   return (slashCount % 2) === 1
@@ -307,24 +233,24 @@ const isEscapedMarkerAt = (content, index) => {
 
 const findLastStandaloneStrongMarker = (content) => {
   if (!content || content.length < 2) return -1
-  let pos = content.lastIndexOf('**')
-  while (pos !== -1) {
+  for (let pos = content.length - 2; pos >= 0; pos--) {
+    if (content.charCodeAt(pos) !== CHAR_ASTERISK ||
+        content.charCodeAt(pos + 1) !== CHAR_ASTERISK) {
+      continue
+    }
     const prev = pos > 0 ? content.charCodeAt(pos - 1) : 0
     const next = pos + 2 < content.length ? content.charCodeAt(pos + 2) : 0
-    if (prev !== 0x2A &&
-        next !== 0x2A &&
-        !isEscapedMarkerAt(content, pos)) {
-      return pos
-    }
-    pos = content.lastIndexOf('**', pos - 1)
+    if (prev === CHAR_ASTERISK || next === CHAR_ASTERISK) continue
+    if (prev === CHAR_BACKSLASH && isEscapedMarkerAt(content, pos)) continue
+    return pos
   }
   return -1
 }
 
 const hasLeadingStandaloneStrongMarker = (content) => {
   if (!content || content.length < 2) return false
-  if (content.charCodeAt(0) !== 0x2A || content.charCodeAt(1) !== 0x2A) return false
-  if (content.length > 2 && content.charCodeAt(2) === 0x2A) return false
+  if (content.charCodeAt(0) !== CHAR_ASTERISK || content.charCodeAt(1) !== CHAR_ASTERISK) return false
+  if (content.length > 2 && content.charCodeAt(2) === CHAR_ASTERISK) return false
   return true
 }
 
@@ -474,7 +400,7 @@ const tryActivateInlineEmphasis = (
     return true
   }
   if (facts.hasBracketText || facts.hasLinkOpen || facts.hasLinkClose) return false
-  if (!ensureInlineHasCodeInline(facts, children)) return false
+  if (!facts.hasCodeInline) return false
   if (tryPromoteStrongAroundInlineCode(children, strictAsciiCodeGuard, strictAsciiStrongGuard, facts)) {
     facts.hasEmphasis = true
     return true
@@ -485,93 +411,108 @@ const tryActivateInlineEmphasis = (
 const shouldRunInlineBrokenRefRepair = (facts, inlineContent, state) => {
   if (!facts || !facts.hasLinkOpen || !facts.hasLinkClose || !facts.hasBracketText) return false
   if (inlineContent.indexOf('***') !== -1) return false
-  return ensureInlineReferenceCount(facts, state) > 0
-}
-
-const applyBrokenRefRepairFacts = (facts, repairs) => {
-  if (!facts || !repairs) return
-  facts.hasBracketText = repairs.hasBracketText
-  facts.hasEmphasis = repairs.hasEmphasis
-  facts.hasLinkClose = repairs.hasLinkClose
-}
-
-const createBrokenRefScanState = () => {
-  return { depth: 0, brokenEnd: false, tailOpen: -1 }
+  return getReferenceCount(state) > 0
 }
 
 const runInlineBrokenRefRepairStage = (children, facts, inlineContent, state) => {
   if (!shouldRunInlineBrokenRefRepair(facts, inlineContent, state)) return false
-  const scanState = createBrokenRefScanState()
-  const maxRepairPass = computeMaxBrokenRefRepairPass(children, scanState)
-  if (maxRepairPass <= 0) return false
+  const scanState = { depth: 0, brokenEnd: false, tailOpen: -1 }
   const repairs = runBrokenRefRepairs(
     children,
-    maxRepairPass,
     scanState,
-    ensureInlineMetrics(facts, state),
+    getPostprocessMetrics(state),
     facts,
     BROKEN_REF_REPAIR_HOOKS
   )
-  applyBrokenRefRepairFacts(facts, repairs)
+  facts.hasBracketText = repairs.hasBracketText
+  facts.hasEmphasis = repairs.hasEmphasis
+  facts.hasLinkClose = repairs.hasLinkClose
   return repairs.changed
 }
 
-const runInlineEmphasisRepairStage = (children, facts, state, isJapaneseMode) => {
+const runInlineEmphasisRepairStage = (
+  children,
+  facts,
+  state,
+  isJapaneseMode,
+  forceBalanceSanitize = false
+) => {
   if (!facts.hasEmphasis) return false
   let changed = false
   const markChangedFrom = createInlineChangeMarker(facts)
-  if (fixEmOuterStrongSequence(children, markChangedFrom)) changed = true
+  const metrics = getPostprocessMetrics(state)
+  const repairMask = forceBalanceSanitize
+    ? INLINE_REPAIR_ALL_EMPHASIS_FIXERS
+    : (facts.repairMask || 0)
+  if ((repairMask & INLINE_REPAIR_EM_OUTER_STRONG_SEQUENCE) &&
+      fixEmOuterStrongSequence(children, markChangedFrom)) {
+    changed = true
+    bumpPostprocessMetric(metrics, 'emphasisFixers', 'em-outer-strong-sequence')
+  }
   if (facts.hasLinkClose) {
-    const metrics = ensureInlineMetrics(facts, state)
-    if (fixTailAfterLinkStrongClose(children, isJapaneseMode, metrics, markChangedFrom)) changed = true
-    if (fixLeadingAsteriskEm(children, markChangedFrom)) changed = true
+    if ((repairMask & INLINE_REPAIR_TAIL_AFTER_LINK) &&
+        fixTailAfterLinkStrongClose(children, isJapaneseMode, metrics, markChangedFrom)) {
+      changed = true
+    }
+    if ((repairMask & INLINE_REPAIR_LEADING_ASTERISK_EM) &&
+        fixLeadingAsteriskEm(children, markChangedFrom)) {
+      changed = true
+      bumpPostprocessMetric(metrics, 'emphasisFixers', 'leading-asterisk-em')
+    }
+  }
+  if ((repairMask & INLINE_REPAIR_TRAILING_STRONG) &&
+      fixTrailingStrong(children, markChangedFrom)) {
+    changed = true
+    bumpPostprocessMetric(metrics, 'emphasisFixers', 'trailing-strong')
+  }
+  const shouldAttemptSanitize = forceBalanceSanitize ||
+    changed ||
+    facts.hasAsteriskWrapperImbalance ||
+    (repairMask & INLINE_REPAIR_BALANCE_SANITIZE)
+  if (!shouldAttemptSanitize) {
+    bumpPostprocessMetric(metrics, 'emphasisSanitize', 'skipped-balanced')
+    return changed
+  }
+  bumpPostprocessMetric(metrics, 'emphasisSanitize', 'attempted')
+  if (forceBalanceSanitize || changed) {
+    bumpPostprocessMetric(metrics, 'emphasisSanitize', 'attempted-after-change')
+  } else {
+    bumpPostprocessMetric(metrics, 'emphasisSanitize', 'attempted-pre-scan-risk')
+  }
+  if (sanitizeEmStrongBalance(children, markChangedFrom)) {
+    changed = true
+    bumpPostprocessMetric(metrics, 'emphasisFixers', 'sanitize-em-strong-balance')
+    bumpPostprocessMetric(metrics, 'emphasisSanitize', 'repaired')
+  } else {
+    bumpPostprocessMetric(metrics, 'emphasisSanitize', 'no-change')
   }
-  if (fixTrailingStrong(children, markChangedFrom)) changed = true
-  if (sanitizeEmStrongBalance(children, markChangedFrom)) changed = true
   return changed
 }
 
 const shouldRunInlineCollapsedRefRepair = (facts, state) => {
   if (!facts || !facts.hasBracketText) return false
-  return ensureInlineReferenceCount(facts, state) > 0
-}
-
-const applyCollapsedRefRepairFacts = (facts) => {
-  if (!facts) return
-  facts.hasLinkOpen = true
-  facts.hasLinkClose = true
-}
-
-const rewriteInlineCollapsedReferences = (children, facts, state, markChangedFrom) => {
-  const changed = convertCollapsedReferenceLinks(
-    children,
-    state,
-    facts,
-    markChangedFrom
-  )
-  if (!changed) return false
-  applyCollapsedRefRepairFacts(facts)
-  return true
+  return getReferenceCount(state) > 0
 }
 
 const runInlineCollapsedRefStage = (children, facts, state) => {
   if (!shouldRunInlineCollapsedRefRepair(facts, state)) return false
   const markChangedFrom = createInlineChangeMarker(facts)
-  if (!rewriteInlineCollapsedReferences(children, facts, state, markChangedFrom)) return false
+  if (!convertCollapsedReferenceLinks(children, state, facts, markChangedFrom)) return false
+  facts.hasLinkOpen = true
+  facts.hasLinkClose = true
   finalizeInlineLinkRepairStage(children, facts, markChangedFrom)
   return true
 }
 
-const shouldSkipInlinePostprocessToken = (children, facts, isJapaneseMode) => {
+const shouldSkipInlinePostprocessToken = (facts, isJapaneseMode) => {
   if (!facts.hasEmphasis &&
       !facts.hasBracketText &&
       !facts.hasLinkOpen &&
       !facts.hasLinkClose &&
-      !ensureInlineHasCodeInline(facts, children)) {
+      !facts.hasCodeInline) {
     return true
   }
-  if (isJapaneseMode &&
-      !hasJapaneseContextInRange(children, 0, children.length - 1)) {
+  if (isJapaneseMode && !facts.hasJapaneseContext) {
     return true
   }
   return false
@@ -598,7 +539,7 @@ const runInlineCoreRepairStages = (
     return false
   }
   if (runInlineBrokenRefRepairStage(children, facts, inlineContent, state)) changed = true
-  if (runInlineEmphasisRepairStage(children, facts, state, isJapaneseMode)) changed = true
+  if (runInlineEmphasisRepairStage(children, facts, state, isJapaneseMode, changed)) changed = true
   return changed
 }
 
@@ -612,8 +553,8 @@ const processInlinePostprocessToken = (
 ) => {
   if (!token || token.type !== 'inline' || !token.children || token.children.length === 0) return
   const children = token.children
-  const facts = buildInlinePostprocessFacts(children, inlineContent)
-  if (shouldSkipInlinePostprocessToken(children, facts, isJapaneseMode)) return
+  const facts = buildInlinePostprocessFacts(children, inlineContent, isJapaneseMode)
+  if (shouldSkipInlinePostprocessToken(facts, isJapaneseMode)) return
   const changed = runInlineCoreRepairStages(
     children,
     facts,
@@ -655,7 +596,7 @@ const registerTokenPostprocess = (md, baseOpt) => {
   md.core.ruler.after('inline', 'strong_ja_token_postprocess', (state) => {
     if (!state || !state.tokens) return
     const overrideOpt = state.env && state.env.__strongJaTokenOpt
-    const opt = overrideOpt ? getRuntimeOpt(state, baseOpt) : baseOpt
+    const opt = hasRuntimeOverride(overrideOpt) ? getRuntimeOpt(state, baseOpt) : baseOpt
     if (!opt.__strongJaPostprocessActive) return
     const isJapaneseMode = opt.__strongJaIsJapaneseMode
     const strictAsciiCodeGuard = opt.__strongJaStrictAsciiCodeGuard