@peaceroad/markdown-it-strong-ja 0.9.0 → 0.9.2

package/src/token-postprocess/broken-ref.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,6 +190,7 @@ const resolveBrokenRefCandidateGuardFlow = (
   children,
   brokenRefCandidate,
   segmentEnd,
+  metrics = null,
   facts = null,
   hooks = null,
   fallbackCache = null
@@ -203,6 +204,10 @@ const resolveBrokenRefCandidateGuardFlow = (
   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,
@@ -214,6 +219,7 @@ const resolveBrokenRefCandidateGuardFlow = (
   )) {
     return BROKEN_REF_FLOW_SKIP_GUARD
   }
+  bumpBrokenRefMetric(metrics, 'brokenRefCandidateFlow', 'guard-passed')
   return null
 }
 
@@ -232,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
 }
 
@@ -256,6 +266,7 @@ const runBrokenRefCandidateRewrite = (
     children,
     brokenRefCandidate,
     segmentEnd,
+    metrics,
     facts,
     hooks,
     fallbackCache
@@ -308,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) {
@@ -383,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,
@@ -437,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,6 +1,11 @@
-import { isJapaneseChar } from '../token-utils.js'
+import { codePointAtSafe, codePointBeforeSafe, codePointSize, 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
@@ -41,11 +46,13 @@ const tokenHasJapaneseChars = (token) => {
     return token.__strongJaHasJapaneseChar
   }
   let hasJapanese = false
-  for (let i = 0; i < content.length; i++) {
-    if (isJapaneseChar(content.charCodeAt(i))) {
+  for (let i = 0; i < content.length;) {
+    const code = codePointAtSafe(content, i)
+    if (isJapaneseChar(code)) {
       hasJapanese = true
       break
     }
+    i += codePointSize(code)
   }
   token.__strongJaJapaneseSource = content
   token.__strongJaHasJapaneseChar = hasJapanese
@@ -98,9 +105,9 @@ const countDelimiterLikeStrongRuns = (content, from = 0, limit = 0) => {
       continue
     }
     const pos = at
-    const prevCode = pos > 0 ? content.charCodeAt(pos - 1) : 0
+    const prevCode = codePointBeforeSafe(content, pos, 0)
     const nextPos = pos + 2
-    const nextCode = nextPos < len ? content.charCodeAt(nextPos) : 0
+    const nextCode = codePointAtSafe(content, nextPos, 0)
     const prevSameMarker = prevCode === CHAR_ASTERISK
     const nextSameMarker = nextCode === CHAR_ASTERISK
     if (prevSameMarker || nextSameMarker) {
@@ -389,13 +396,9 @@ const hasBrokenRefImmediateRewriteSignal = (wrapperSignals) => {
   return wrapperSignals.hasImbalance && hasBrokenRefExplicitAsteriskSignal(wrapperSignals)
 }
 
-const shouldRejectBalancedBrokenRefRewrite = (wrapperSignals) => {
-  return !wrapperSignals.hasImbalance && hasBrokenRefExplicitAsteriskSignal(wrapperSignals)
-}
-
 const shouldAttemptBrokenRefRewriteFromSignals = (wrapperSignals) => {
   if (hasBrokenRefImmediateRewriteSignal(wrapperSignals)) return true
-  if (shouldRejectBalancedBrokenRefRewrite(wrapperSignals)) return false
+  if (!wrapperSignals.hasImbalance && hasBrokenRefExplicitAsteriskSignal(wrapperSignals)) return false
   return hasBrokenRefStrongRunEvidence(wrapperSignals)
 }
 
@@ -413,16 +416,47 @@ const shouldAttemptBrokenRefRewrite = (
   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
@@ -433,13 +467,34 @@ const scanInlinePostprocessSignals = (children) => {
     if (!hasCodeInline && child.type === 'code_inline') {
       hasCodeInline = true
     }
-    if (hasEmphasis && hasLinkOpen && hasLinkClose) break
+  }
+  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,
-    hasCodeInline
+    hasCodeInline,
+    hasJapaneseContext,
+    repairMask,
+    hasAsteriskWrapperImbalance
   }
 }
 
@@ -451,5 +506,10 @@ export {
   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
 }