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

package/src/token-postprocess/broken-ref.js

@@ -1,7 +1,7 @@
 import { buildLinkCloseMap } from '../token-link-utils.js'
 import {
   isAsteriskEmphasisToken,
-  hasTextMarkerCharsInRange,
+  buildBrokenRefWrapperRangeSignals,
   buildAsteriskWrapperPrefixStats,
   shouldAttemptBrokenRefRewrite
 } from './guards.js'
@@ -115,14 +115,14 @@ const expandSegmentEndForWrapperBalance = (tokens, startIdx, endIdx) => {
   return balance.total > 0 ? -1 : expandedEnd
 }
 
-const bumpBrokenRefMetric = (metrics, bucket, key) => {
-  if (!metrics || !bucket || !key) return
+const bumpBrokenRefMetric = (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 ensureBrokenRefLinkCloseMap = (tokens, facts = null, hooks = null, fallbackCache = null) => {
@@ -190,23 +190,36 @@ const resolveBrokenRefCandidateGuardFlow = (
   children,
   brokenRefCandidate,
   segmentEnd,
+  metrics = null,
   facts = null,
   hooks = null,
   fallbackCache = null
 ) => {
-  if (!hasTextMarkerCharsInRange(children, brokenRefCandidate.start, segmentEnd, brokenRefCandidate.startTextOffset)) {
+  const wrapperSignals = buildBrokenRefWrapperRangeSignals(
+    children,
+    brokenRefCandidate.start,
+    segmentEnd,
+    brokenRefCandidate.startTextOffset
+  )
+  if (!wrapperSignals.hasTextMarker) {
     return BROKEN_REF_FLOW_SKIP_NO_TEXT_MARKER
   }
+  if (!hasBrokenRefActiveFastPathTokenSignal(wrapperSignals)) {
+    bumpBrokenRefMetric(metrics, 'brokenRefCandidateFlow', 'no-active-signature')
+    return BROKEN_REF_FLOW_SKIP_NO_ACTIVE_SIGNATURE
+  }
   const wrapperPrefixStats = ensureBrokenRefWrapperPrefixStats(children, facts, hooks, fallbackCache)
   if (!shouldAttemptBrokenRefRewrite(
     children,
     brokenRefCandidate.start,
     segmentEnd,
     brokenRefCandidate.startTextOffset,
-    wrapperPrefixStats
+    wrapperPrefixStats,
+    wrapperSignals
   )) {
     return BROKEN_REF_FLOW_SKIP_GUARD
   }
+  bumpBrokenRefMetric(metrics, 'brokenRefCandidateFlow', 'guard-passed')
   return null
 }
 
@@ -225,12 +238,16 @@ const resolveBrokenRefFastPathFlow = (
     metrics,
     bumpBrokenRefMetric
   )
+  bumpBrokenRefMetric(metrics, 'brokenRefCandidateFlow', 'fastpath-dispatch')
   if (fastPathResult === BROKEN_REF_FAST_PATH_RESULT_NO_ACTIVE_SIGNATURE) {
+    bumpBrokenRefMetric(metrics, 'brokenRefCandidateFlow', 'no-active-signature')
     return BROKEN_REF_FLOW_SKIP_NO_ACTIVE_SIGNATURE
   }
   if (fastPathResult === BROKEN_REF_FAST_PATH_RESULT_NO_MATCH) {
+    bumpBrokenRefMetric(metrics, 'brokenRefCandidateFlow', 'no-fastpath-match')
     return BROKEN_REF_FLOW_SKIP_NO_FASTPATH_MATCH
   }
+  bumpBrokenRefMetric(metrics, 'brokenRefCandidateFlow', 'repaired')
   return BROKEN_REF_FLOW_REPAIRED
 }
 
@@ -249,6 +266,7 @@ const runBrokenRefCandidateRewrite = (
     children,
     brokenRefCandidate,
     segmentEnd,
+    metrics,
     facts,
     hooks,
     fallbackCache
@@ -301,7 +319,7 @@ const createBrokenRefPassSignals = (seedSignals = null) => {
 const observeBrokenRefTextToken = (passSignals, candidateState, text, tokenIdx, scanState) => {
   const hasOpenBracket = text.indexOf('[') !== -1
   const hasCloseBracket = text.indexOf(']') !== -1
-  if (!passSignals.hasBracketText && (hasOpenBracket || hasCloseBracket)) {
+  if (passSignals && !passSignals.hasBracketText && (hasOpenBracket || hasCloseBracket)) {
     passSignals.hasBracketText = true
   }
   if (candidateState.start === -1) {
@@ -376,6 +394,7 @@ const tryRepairBrokenRefCandidateAtLinkOpen = (
   const closeIdx = linkCloseMap.get(childIdx) ?? -1
   if (closeIdx === -1) return null
   bumpBrokenRefMetric(metrics, 'brokenRefFlow', 'candidate')
+  bumpBrokenRefMetric(metrics, 'brokenRefCandidateFlow', 'candidate')
   const flowResult = runBrokenRefCandidateRewrite(
     children,
     brokenRefCandidate,
@@ -430,46 +449,123 @@ const runBrokenRefRepairPass = (children, scanState, metrics = null, facts = nul
   return buildBrokenRefRepairPassResult(false, passSignals)
 }
 
-const computeMaxBrokenRefRepairPass = (children, scanState) => {
+const hasPotentialBrokenRefRepairPass = (children, scanState) => {
   resetBrokenRefScanState(scanState)
-  let maxRepairPass = 0
   for (let j = 0; j < children.length; j++) {
     const child = children[j]
     if (!child || child.type !== 'text' || !child.content) continue
     if (child.content.indexOf('[') === -1) continue
     if (scanBrokenRefState(child.content, scanState).brokenEnd) {
-      maxRepairPass++
+      return true
     }
   }
-  return maxRepairPass
+  return false
+}
+
+const hasBrokenRefActiveFastPathTokenSignal = (wrapperSignals) => {
+  if (!wrapperSignals) return false
+  // Current broken-ref fast paths are all strong-token driven.
+  return wrapperSignals.strongOpenInRange > 0 || wrapperSignals.strongCloseInRange > 0
 }
 
-const runBrokenRefRepairs = (children, maxRepairPass, scanState, metrics = null, facts = null, hooks = null) => {
+const countGuardedBrokenRefRepairPasses = (children, scanState, facts = null, hooks = null) => {
+  resetBrokenRefScanState(scanState)
+  const brokenRefCandidate = resetBrokenRefCandidateState({ start: -1, depth: 0, startTextOffset: 0 })
+  const fallbackCache = {
+    linkCloseMap: undefined,
+    wrapperPrefixStats: undefined
+  }
   let repairPassCount = 0
+  for (let j = 0; j < children.length; j++) {
+    const child = children[j]
+    if (!child) continue
+    if (child.type === 'text' && child.content) {
+      observeBrokenRefTextToken(null, brokenRefCandidate, child.content, j, scanState)
+    }
+    if (child.type !== 'link_open' || brokenRefCandidate.start === -1) continue
+    if (brokenRefCandidate.depth <= 0) {
+      resetBrokenRefCandidateState(brokenRefCandidate)
+      continue
+    }
+    const linkCloseMap = ensureBrokenRefLinkCloseMap(children, facts, hooks, fallbackCache)
+    const closeIdx = linkCloseMap.get(j) ?? -1
+    if (closeIdx === -1) continue
+    const segmentEnd = resolveBrokenRefSegmentEnd(children, brokenRefCandidate, closeIdx)
+    const wrapperSignals = buildBrokenRefWrapperRangeSignals(
+      children,
+      brokenRefCandidate.start,
+      segmentEnd,
+      brokenRefCandidate.startTextOffset
+    )
+    if (!wrapperSignals.hasTextMarker || !hasBrokenRefActiveFastPathTokenSignal(wrapperSignals)) {
+      resetBrokenRefCandidateState(brokenRefCandidate)
+      continue
+    }
+    const wrapperPrefixStats = ensureBrokenRefWrapperPrefixStats(children, facts, hooks, fallbackCache)
+    if (shouldAttemptBrokenRefRewrite(
+      children,
+      brokenRefCandidate.start,
+      segmentEnd,
+      brokenRefCandidate.startTextOffset,
+      wrapperPrefixStats,
+      wrapperSignals
+    )) {
+      repairPassCount++
+    }
+    resetBrokenRefCandidateState(brokenRefCandidate)
+  }
+  return repairPassCount
+}
+
+const buildBrokenRefRepairsResult = (changed, passSignals) => {
+  return {
+    changed,
+    hasBracketText: passSignals.hasBracketText,
+    hasEmphasis: passSignals.hasEmphasis,
+    hasLinkClose: passSignals.hasLinkClose
+  }
+}
+
+const runBrokenRefRepairs = (children, scanState, metrics = null, facts = null, hooks = null) => {
+  const seedSignals = createBrokenRefPassSignals(createBrokenRefSignalSeed(facts))
+  if (!hasPotentialBrokenRefRepairPass(children, scanState)) {
+    return buildBrokenRefRepairsResult(false, seedSignals)
+  }
+
   let changed = false
-  while (repairPassCount < maxRepairPass) {
-    const pass = runBrokenRefRepairPass(children, scanState, metrics, facts, hooks)
+  bumpBrokenRefMetric(metrics, 'brokenRefPasses', 'budgeted')
+  bumpBrokenRefMetric(metrics, 'brokenRefPasses', 'executed')
+
+  let pass = runBrokenRefRepairPass(children, scanState, metrics, facts, hooks)
+  if (!pass.didRepair) {
+    bumpBrokenRefMetric(metrics, 'brokenRefPasses', 'stopped-no-repair')
+    return buildBrokenRefRepairsResult(changed, pass)
+  }
+
+  changed = true
+  bumpBrokenRefMetric(metrics, 'brokenRefPasses', 'repaired')
+
+  const remainingBudget = countGuardedBrokenRefRepairPasses(children, scanState, facts, hooks)
+  if (remainingBudget > 0) {
+    bumpBrokenRefMetric(metrics, 'brokenRefPasses', 'budgeted', remainingBudget)
+  }
+
+  let repairPassCount = 0
+  while (repairPassCount < remainingBudget) {
+    bumpBrokenRefMetric(metrics, 'brokenRefPasses', 'executed')
+    pass = runBrokenRefRepairPass(children, scanState, metrics, facts, hooks)
     if (!pass.didRepair) {
-      return {
-        changed,
-        hasBracketText: pass.hasBracketText,
-        hasEmphasis: pass.hasEmphasis,
-        hasLinkClose: pass.hasLinkClose
-      }
+      bumpBrokenRefMetric(metrics, 'brokenRefPasses', 'stopped-no-repair')
+      return buildBrokenRefRepairsResult(changed, pass)
     }
     changed = true
     repairPassCount++
+    bumpBrokenRefMetric(metrics, 'brokenRefPasses', 'repaired')
   }
   const finalSignals = collectBrokenRefPassSignals(children, createBrokenRefSignalSeed(facts))
-  return {
-    changed,
-    hasBracketText: finalSignals.hasBracketText,
-    hasEmphasis: finalSignals.hasEmphasis,
-    hasLinkClose: finalSignals.hasLinkClose
-  }
+  return buildBrokenRefRepairsResult(changed, finalSignals)
 }
 
 export {
-  computeMaxBrokenRefRepairPass,
   runBrokenRefRepairs
 }

package/src/token-postprocess/emphasis-balance.js

@@ -0,0 +1,50 @@
+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
+}
+
+export { sanitizeEmStrongBalance }

package/src/token-postprocess/fastpaths.js

@@ -1,9 +1,5 @@
 import Token from 'markdown-it/lib/token.mjs'
-
-const cloneMap = (map) => {
-  if (!map || !Array.isArray(map)) return null
-  return [map[0], map[1]]
-}
+import { cloneMap } from '../token-utils.js'
 
 const cloneTextLike = (source, content) => {
   const token = new Token('text', '', 0)

package/src/token-postprocess/guards.js

@@ -1,17 +1,16 @@
 import { isJapaneseChar } from '../token-utils.js'
 
+const CHAR_ASTERISK = 0x2A // *
+const INLINE_REPAIR_EM_OUTER_STRONG_SEQUENCE = 1 << 0
+const INLINE_REPAIR_TAIL_AFTER_LINK = 1 << 1
+const INLINE_REPAIR_LEADING_ASTERISK_EM = 1 << 2
+const INLINE_REPAIR_TRAILING_STRONG = 1 << 3
+const INLINE_REPAIR_BALANCE_SANITIZE = 1 << 4
+
 const hasMarkerChars = (text) => {
   return !!text && text.indexOf('*') !== -1
 }
 
-const contentHasMarkerCharsFrom = (content, from) => {
-  if (!content) return false
-  const start = from > 0 ? from : 0
-  if (start === 0) return hasMarkerChars(content)
-  if (start >= content.length) return false
-  return content.indexOf('*', start) !== -1
-}
-
 const isAsteriskEmphasisToken = (token) => {
   if (!token || !token.type) return false
   if (token.type !== 'strong_open' &&
@@ -78,20 +77,6 @@ const hasEmphasisSignalInRange = (tokens, startIdx, endIdx) => {
   return false
 }
 
-const hasTextMarkerCharsInRange = (tokens, startIdx, endIdx, firstTextOffset = 0) => {
-  if (!tokens || startIdx < 0 || endIdx < startIdx) return false
-  for (let i = startIdx; i <= endIdx && i < tokens.length; i++) {
-    const token = tokens[i]
-    if (!token || token.type !== 'text' || !token.content) continue
-    if (i === startIdx && firstTextOffset > 0) {
-      if (contentHasMarkerCharsFrom(token.content, firstTextOffset)) return true
-      continue
-    }
-    if (textTokenHasMarkerChars(token)) return true
-  }
-  return false
-}
-
 const isStrongRunSoftSpace = (code) => {
   return code === 0x20 || code === 0x09 || code === 0x0A || code === 0x3000
 }
@@ -107,21 +92,24 @@ const isStrongRunTextLike = (code) => {
   return isStrongRunAsciiWord(code) || isJapaneseChar(code)
 }
 
-const countDelimiterLikeStrongRuns = (content, marker, from = 0, limit = 0) => {
+const countDelimiterLikeStrongRuns = (content, from = 0, limit = 0) => {
   let at = from > 0 ? from : 0
   const len = content.length
-  const markerCode = marker.charCodeAt(0)
   let count = 0
-  while (at < len) {
-    const pos = content.indexOf(marker, at)
-    if (pos === -1) break
+  while (at + 1 < len) {
+    if (content.charCodeAt(at) !== CHAR_ASTERISK ||
+        content.charCodeAt(at + 1) !== CHAR_ASTERISK) {
+      at++
+      continue
+    }
+    const pos = at
     const prevCode = pos > 0 ? content.charCodeAt(pos - 1) : 0
-    const nextPos = pos + marker.length
+    const nextPos = pos + 2
     const nextCode = nextPos < len ? content.charCodeAt(nextPos) : 0
-    const prevSameMarker = prevCode === markerCode
-    const nextSameMarker = nextCode === markerCode
+    const prevSameMarker = prevCode === CHAR_ASTERISK
+    const nextSameMarker = nextCode === CHAR_ASTERISK
     if (prevSameMarker || nextSameMarker) {
-      at = pos + marker.length
+      at = pos + 2
       continue
     }
     const prevSoft = prevCode !== 0 && isStrongRunSoftSpace(prevCode)
@@ -131,92 +119,50 @@ const countDelimiterLikeStrongRuns = (content, marker, from = 0, limit = 0) => {
     const nextTextLike = isStrongRunTextLike(nextCode)
     const hasTextNeighbor = prevTextLike || nextTextLike
     if (!hasTextNeighbor) {
-      at = pos + marker.length
+      at = pos + 2
       continue
     }
     const atBoundary = prevCode === 0 || nextCode === 0
     if (!atBoundary && (!prevTextLike || !nextTextLike)) {
-      at = pos + marker.length
+      at = pos + 2
       continue
     }
     if (hasPrevOrNext && !prevSoft && !nextSoft) {
       count++
       if (limit > 0 && count >= limit) return count
     }
-    at = pos + marker.length
+    at = pos + 2
   }
   return count
 }
 
-const countStrongMarkerRunsInTextRange = (tokens, startIdx, endIdx, firstTextOffset = 0, limit = 0) => {
-  if (!tokens || startIdx < 0 || endIdx < startIdx) return 0
-  let total = 0
-  for (let i = startIdx; i <= endIdx && i < tokens.length; i++) {
-    const token = tokens[i]
-    if (!token || token.type !== 'text' || !token.content) continue
-    const content = token.content
-    const scanFrom = i === startIdx && firstTextOffset > 0 ? firstTextOffset : 0
-    if (scanFrom >= content.length) continue
-    const remain = limit > 0 ? (limit - total) : 0
-    total += countDelimiterLikeStrongRuns(content, '**', scanFrom, remain)
-    if (limit > 0 && total >= limit) {
-      return total
-    }
-  }
-  return total
-}
-
 const buildAsteriskWrapperPrefixStats = (tokens) => {
   const len = Array.isArray(tokens) ? tokens.length : 0
   const strongDepthPrefix = new Array(len + 1)
   const emDepthPrefix = new Array(len + 1)
-  const strongOpenPrefix = new Array(len + 1)
-  const strongClosePrefix = new Array(len + 1)
-  const emOpenPrefix = new Array(len + 1)
-  const emClosePrefix = new Array(len + 1)
   let strongDepth = 0
   let emDepthCount = 0
-  let strongOpenCount = 0
-  let strongCloseCount = 0
-  let emOpenCount = 0
-  let emCloseCount = 0
   strongDepthPrefix[0] = 0
   emDepthPrefix[0] = 0
-  strongOpenPrefix[0] = 0
-  strongClosePrefix[0] = 0
-  emOpenPrefix[0] = 0
-  emClosePrefix[0] = 0
   for (let i = 0; i < len; i++) {
     const token = tokens[i]
     if (token && token.type && isAsteriskEmphasisToken(token)) {
       if (token.type === 'strong_open') {
         strongDepth++
-        strongOpenCount++
       } else if (token.type === 'strong_close') {
         if (strongDepth > 0) strongDepth--
-        strongCloseCount++
       } else if (token.type === 'em_open') {
         emDepthCount++
-        emOpenCount++
       } else if (token.type === 'em_close') {
         if (emDepthCount > 0) emDepthCount--
-        emCloseCount++
       }
     }
     strongDepthPrefix[i + 1] = strongDepth
     emDepthPrefix[i + 1] = emDepthCount
-    strongOpenPrefix[i + 1] = strongOpenCount
-    strongClosePrefix[i + 1] = strongCloseCount
-    emOpenPrefix[i + 1] = emOpenCount
-    emClosePrefix[i + 1] = emCloseCount
   }
   return {
     strongDepth: strongDepthPrefix,
-    emDepth: emDepthPrefix,
-    strongOpen: strongOpenPrefix,
-    strongClose: strongClosePrefix,
-    emOpen: emOpenPrefix,
-    emClose: emClosePrefix
+    emDepth: emDepthPrefix
   }
 }
 
@@ -229,6 +175,8 @@ const createBrokenRefWrapperRangeSignals = () => {
     hasUnderscoreText: false,
     hasCodeInline: false,
     hasUnderscoreEmphasisToken: false,
+    hasTextMarker: false,
+    strongRunCount: 0,
     strongOpenInRange: 0,
     strongCloseInRange: 0,
     emOpenInRange: 0,
@@ -239,17 +187,25 @@ const createBrokenRefWrapperRangeSignals = () => {
 const updateBrokenRefTextRangeSignals = (signals, token, tokenIdx, startIdx, firstTextOffset) => {
   if (!token || token.type !== 'text' || !token.content) return
   const content = token.content
+  const scanFrom = tokenIdx === startIdx && firstTextOffset > 0 ? firstTextOffset : 0
   // Keep this at 0 (instead of firstTextOffset) so historical fail-safe
   // behavior around noisy leading chains in the first text token stays unchanged.
   if (!signals.hasLongStarNoise && content.indexOf('***') !== -1) {
     signals.hasLongStarNoise = true
   }
   if (!signals.hasUnderscoreText) {
-    const scanFrom = tokenIdx === startIdx && firstTextOffset > 0 ? firstTextOffset : 0
     if (scanFrom < content.length && content.indexOf('_', scanFrom) !== -1) {
       signals.hasUnderscoreText = true
     }
   }
+  if (!signals.hasTextMarker) {
+    signals.hasTextMarker = scanFrom === 0
+      ? textTokenHasMarkerChars(token)
+      : content.indexOf('*', scanFrom) !== -1
+  }
+  if (signals.strongRunCount < 2 && scanFrom < content.length) {
+    signals.strongRunCount += countDelimiterLikeStrongRuns(content, scanFrom, 2 - signals.strongRunCount)
+  }
 }
 
 const updateBrokenRefWrapperTokenSignals = (signals, token, isAsteriskEmphasis) => {
@@ -343,18 +299,10 @@ const hasPreexistingWrapperCloseOnlyInRange = (tokens, startIdx, endIdx, prefixS
   const hasPrefix =
     !!prefixStats &&
     Array.isArray(prefixStats.strongDepth) &&
-    Array.isArray(prefixStats.emDepth) &&
-    Array.isArray(prefixStats.strongOpen) &&
-    Array.isArray(prefixStats.strongClose) &&
-    Array.isArray(prefixStats.emOpen) &&
-    Array.isArray(prefixStats.emClose)
+    Array.isArray(prefixStats.emDepth)
   if (hasPrefix &&
       startIdx < prefixStats.strongDepth.length &&
-      startIdx < prefixStats.emDepth.length &&
-      (endIdx + 1) < prefixStats.strongOpen.length &&
-      (endIdx + 1) < prefixStats.strongClose.length &&
-      (endIdx + 1) < prefixStats.emOpen.length &&
-      (endIdx + 1) < prefixStats.emClose.length) {
+      startIdx < prefixStats.emDepth.length) {
     if (needsStrongCloseOnly) {
       preStrongDepth = prefixStats.strongDepth[startIdx] || 0
       if (preStrongDepth > 0) return true
@@ -434,8 +382,8 @@ const isLowConfidenceBrokenRefRange = (tokens, startIdx, endIdx, firstTextOffset
   return hasBrokenRefLowConfidenceWrapperRisk(tokens, startIdx, endIdx, wrapperPrefixStats, signals)
 }
 
-const hasBrokenRefStrongRunEvidence = (tokens, startIdx, endIdx, firstTextOffset = 0) => {
-  return countStrongMarkerRunsInTextRange(tokens, startIdx, endIdx, firstTextOffset, 2) >= 2
+const hasBrokenRefStrongRunEvidence = (wrapperSignals) => {
+  return !!wrapperSignals && wrapperSignals.strongRunCount >= 2
 }
 
 const hasBrokenRefExplicitAsteriskSignal = (wrapperSignals) => {
@@ -446,31 +394,67 @@ const hasBrokenRefImmediateRewriteSignal = (wrapperSignals) => {
   return wrapperSignals.hasImbalance && hasBrokenRefExplicitAsteriskSignal(wrapperSignals)
 }
 
-const shouldRejectBalancedBrokenRefRewrite = (wrapperSignals) => {
-  return !wrapperSignals.hasImbalance && hasBrokenRefExplicitAsteriskSignal(wrapperSignals)
-}
-
-const shouldAttemptBrokenRefRewriteFromSignals = (tokens, startIdx, endIdx, firstTextOffset, wrapperSignals) => {
+const shouldAttemptBrokenRefRewriteFromSignals = (wrapperSignals) => {
   if (hasBrokenRefImmediateRewriteSignal(wrapperSignals)) return true
-  if (shouldRejectBalancedBrokenRefRewrite(wrapperSignals)) return false
-  return hasBrokenRefStrongRunEvidence(tokens, startIdx, endIdx, firstTextOffset)
+  if (!wrapperSignals.hasImbalance && hasBrokenRefExplicitAsteriskSignal(wrapperSignals)) return false
+  return hasBrokenRefStrongRunEvidence(wrapperSignals)
 }
 
-const shouldAttemptBrokenRefRewrite = (tokens, startIdx, endIdx, firstTextOffset = 0, wrapperPrefixStats = null) => {
-  const wrapperSignals = buildBrokenRefWrapperRangeSignals(tokens, startIdx, endIdx, firstTextOffset)
-  if (isLowConfidenceBrokenRefRange(tokens, startIdx, endIdx, firstTextOffset, wrapperPrefixStats, wrapperSignals)) return false
-  return shouldAttemptBrokenRefRewriteFromSignals(tokens, startIdx, endIdx, firstTextOffset, wrapperSignals)
+const shouldAttemptBrokenRefRewrite = (
+  tokens,
+  startIdx,
+  endIdx,
+  firstTextOffset = 0,
+  wrapperPrefixStats = null,
+  wrapperSignals = null
+) => {
+  const signals = wrapperSignals || buildBrokenRefWrapperRangeSignals(tokens, startIdx, endIdx, firstTextOffset)
+  if (!signals.hasTextMarker) return false
+  if (isLowConfidenceBrokenRefRange(tokens, startIdx, endIdx, firstTextOffset, wrapperPrefixStats, signals)) return false
+  return shouldAttemptBrokenRefRewriteFromSignals(signals)
 }
 
-const scanInlinePostprocessSignals = (children) => {
+const scanInlinePostprocessSignals = (children, collectJapaneseContext = false) => {
   let hasEmphasis = false
   let hasLinkOpen = false
   let hasLinkClose = false
+  let hasCodeInline = false
+  let hasJapaneseContext = false
+  let hasTextStrongMarker = false
+  let strongOpenCount = 0
+  let strongCloseCount = 0
+  let emOpenCount = 0
+  let emCloseCount = 0
+  let hasAsteriskWrapperImbalance = false
+  const emphasisStack = []
   for (let j = 0; j < children.length; j++) {
     const child = children[j]
     if (!child) continue
-    if (!hasEmphasis && isAsteriskEmphasisToken(child)) {
+    if (collectJapaneseContext && !hasJapaneseContext && tokenHasJapaneseChars(child)) {
+      hasJapaneseContext = true
+    }
+    if (!hasTextStrongMarker && child.type === 'text' && child.content && child.content.indexOf('**') !== -1) {
+      hasTextStrongMarker = true
+    }
+    const isAsteriskEmphasis = isAsteriskEmphasisToken(child)
+    if (isAsteriskEmphasis) {
       hasEmphasis = true
+      if (child.type === 'strong_open') strongOpenCount++
+      else if (child.type === 'strong_close') strongCloseCount++
+      else if (child.type === 'em_open') emOpenCount++
+      else if (child.type === 'em_close') emCloseCount++
+      if (!hasAsteriskWrapperImbalance) {
+        if (child.type === 'strong_open' || child.type === 'em_open') {
+          emphasisStack.push(child.type)
+        } else {
+          const expected = child.type === 'strong_close' ? 'strong_open' : 'em_open'
+          if (emphasisStack.length > 0 && emphasisStack[emphasisStack.length - 1] === expected) {
+            emphasisStack.pop()
+          } else {
+            hasAsteriskWrapperImbalance = true
+          }
+        }
+      }
     }
     if (!hasLinkOpen && child.type === 'link_open') {
       hasLinkOpen = true
@@ -478,12 +462,37 @@ const scanInlinePostprocessSignals = (children) => {
     if (!hasLinkClose && child.type === 'link_close') {
       hasLinkClose = true
     }
-    if (hasEmphasis && hasLinkOpen && hasLinkClose) break
+    if (!hasCodeInline && child.type === 'code_inline') {
+      hasCodeInline = true
+    }
+  }
+  if (!hasAsteriskWrapperImbalance && emphasisStack.length > 0) {
+    hasAsteriskWrapperImbalance = true
+  }
+  let repairMask = 0
+  if (emOpenCount >= 2 && emCloseCount >= 2 && strongOpenCount > 0) {
+    repairMask |= INLINE_REPAIR_EM_OUTER_STRONG_SEQUENCE
+  }
+  if (hasLinkClose && strongCloseCount > 0) {
+    repairMask |= INLINE_REPAIR_TAIL_AFTER_LINK
+  }
+  if (hasLinkClose && emCloseCount > 0) {
+    repairMask |= INLINE_REPAIR_LEADING_ASTERISK_EM
+  }
+  if (emOpenCount > 0 && emCloseCount > 0 && hasTextStrongMarker) {
+    repairMask |= INLINE_REPAIR_TRAILING_STRONG
+  }
+  if (hasAsteriskWrapperImbalance) {
+    repairMask |= INLINE_REPAIR_BALANCE_SANITIZE
   }
   return {
     hasEmphasis,
     hasLinkOpen,
-    hasLinkClose
+    hasLinkClose,
+    hasCodeInline,
+    hasJapaneseContext,
+    repairMask,
+    hasAsteriskWrapperImbalance
   }
 }
 
@@ -492,8 +501,13 @@ export {
   isAsteriskEmphasisToken,
   hasJapaneseContextInRange,
   hasEmphasisSignalInRange,
-  hasTextMarkerCharsInRange,
   buildAsteriskWrapperPrefixStats,
+  buildBrokenRefWrapperRangeSignals,
   shouldAttemptBrokenRefRewrite,
-  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
 }