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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@peaceroad/markdown-it-strong-ja",
   "description": "Extends asterisk emphasis handling for Japanese text while keeping markdown-it behavior as close as practical.",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "main": "index.js",
   "type": "module",
   "files": [
@@ -26,6 +26,7 @@
     "test:all": "node test/test-all.js",
     "bench:scan": "node test/material/perf-scan-delims.mjs",
     "bench:postprocess": "node test/material/perf-postprocess.mjs",
+    "bench:isolated": "node test/material/bench-isolated.mjs",
     "analyze:postprocess-calls": "node test/material/analyze-postprocess-calls.mjs",
     "analyze:fastpath": "node test/material/analyze-fastpath-hits.mjs"
   },
@@ -46,4 +47,3 @@
     "p7d-markdown-it-p-captions": "^0.21.0"
   }
 }
-

package/src/token-compat.js

@@ -2,6 +2,7 @@ import Token from 'markdown-it/lib/token.mjs'
 import {
   REG_ATTRS,
   isJapaneseChar,
+  isAsciiWordCode,
   hasCjkBreaksRule,
   isCjkBreaksRuleName,
   getRuntimeOpt,
@@ -9,12 +10,6 @@ import {
   moveRuleAfter
 } from './token-utils.js'
 
-const isAsciiWordCode = (code) => {
-  return (code >= 0x30 && code <= 0x39) ||
-    (code >= 0x41 && code <= 0x5A) ||
-    (code >= 0x61 && code <= 0x7A)
-}
-
 const trimTrailingSpaceTab = (text) => {
   if (!text) return text
   let end = text.length

package/src/token-core.js

@@ -2,16 +2,15 @@ import { isWhiteSpace } from 'markdown-it/lib/common/utils.mjs'
 import Token from 'markdown-it/lib/token.mjs'
 import {
   CHAR_ASTERISK,
-  CHAR_SPACE,
-  CHAR_TAB,
   CHAR_NEWLINE,
-  CHAR_IDEOGRAPHIC_SPACE,
   isJapaneseChar,
+  isAsciiWordCode,
+  isSoftSpaceCode,
   MODE_FLAG_COMPATIBLE,
   MODE_FLAG_AGGRESSIVE,
   MODE_FLAG_JAPANESE_PLUS,
-  getRuntimeOpt,
-  hasRuntimeOverride
+  hasRuntimeOverride,
+  getRuntimeOpt
 } from './token-utils.js'
 
 const SCAN_DELIMS_PATCHED = Symbol.for('strongJaTokenScanDelimsPatched')
@@ -20,10 +19,6 @@ const PREV_STAR_HAS_OPENER = 1
 const PREV_STAR_HAS_JP_BETWEEN = 2
 const SCAN_DELIMS_LOOKUP_KEY = Symbol.for('strongJaTokenScanDelimsLookup')
 
-const isSoftSpaceCode = (code) => {
-  return code === CHAR_SPACE || code === CHAR_TAB || code === CHAR_IDEOGRAPHIC_SPACE
-}
-
 const isPlusQuoteWrapperOpen = (code) => {
   return code === 0x2018 || // ‘
     code === 0x201C || // “
@@ -256,12 +251,6 @@ const isSingleStarClosingBoundary = (code) => {
     isClosingBracketLike(code)
 }
 
-const isAsciiAlphaNum = (code) => {
-  return (code >= 0x30 && code <= 0x39) ||
-    (code >= 0x41 && code <= 0x5A) ||
-    (code >= 0x61 && code <= 0x7A)
-}
-
 const isAsciiGuardOpenWrapper = (code) => {
   return code === 0x22 || // "
     code === 0x27 || // '
@@ -370,7 +359,7 @@ const hasAsciiStartAfterOptionalOpenWrappers = (src, index, max, lookupCache = n
     if (i === -1) return false
   }
   if (i < 0 || i >= max) return false
-  return isAsciiAlphaNum(src.charCodeAt(i))
+  return isAsciiWordCode(src.charCodeAt(i))
 }
 
 const hasAsciiEndBeforeOptionalCloseWrappers = (src, index, lookupCache = null) => {
@@ -383,7 +372,7 @@ const hasAsciiEndBeforeOptionalCloseWrappers = (src, index, lookupCache = null)
     if (i === -1) return false
   }
   if (i < 0) return false
-  return isAsciiAlphaNum(src.charCodeAt(i))
+  return isAsciiWordCode(src.charCodeAt(i))
 }
 
 const isMarkdownStructuralOpenWrapper = (code) => {
@@ -870,8 +859,10 @@ const patchScanDelims = (md) => {
     if (!aggressiveMode && count === 1) {
       // Keep local directionality to avoid degrading markdown-it-valid runs,
       // e.g. `[。*a**](u)` where the first `*` should remain opener-only.
-      const rightIsBoundary = isSingleStarClosingBoundary(nextChar) || isWrapperOpenLike(nextChar)
-      const leftIsBoundary = isSingleStarBoundary(lastChar) || isWrapperCloseLike(lastChar)
+      const rightIsOpenWrapper = isWrapperOpenLike(nextChar)
+      const leftIsCloseWrapper = isWrapperCloseLike(lastChar)
+      const rightIsBoundary = isSingleStarClosingBoundary(nextChar) || rightIsOpenWrapper
+      const leftIsBoundary = isSingleStarBoundary(lastChar) || leftIsCloseWrapper
       if (leftJapanese && !rightJapanese && !rightIsBoundary) {
         prevStarFlags = ensurePrevStarFlags(src, start, prevStarFlags)
         if ((prevStarFlags & PREV_STAR_HAS_OPENER) === 0) {
@@ -880,28 +871,30 @@ const patchScanDelims = (md) => {
       } else if (!leftJapanese && rightJapanese && !leftIsBoundary) {
         relaxedOpen = false
       }
-      const rightIsOpenWrapper = isWrapperOpenLike(nextChar)
-      const leftIsCloseWrapper = isWrapperCloseLike(lastChar)
-      prevStarFlags = ensurePrevStarFlags(src, start, prevStarFlags)
-      const hasPrevJapaneseOpener = (prevStarFlags & PREV_STAR_HAS_OPENER) !== 0
-      const hasJapaneseSincePrevStar = (prevStarFlags & PREV_STAR_HAS_JP_BETWEEN) !== 0
       const leftIsExtraClosePunct = isExtraSingleStarClosePunct(lastChar)
-      const canForceCloseByPunct = leftIsExtraClosePunct && hasJapaneseSincePrevStar
-      if (leftJapanese &&
-          rightIsOpenWrapper &&
-          !hasPrevJapaneseOpener &&
-          !isMarkdownStructuralOpenWrapper(nextChar)) {
-        forceOpen = true
-        forceClose = false
-      } else if (leftIsCloseWrapper && rightJapanese && hasPrevJapaneseOpener) {
-        forceOpen = false
-        forceClose = true
-      } else if ((leftIsCloseWrapper || canForceCloseByPunct) &&
-          !rightJapanese &&
-          !rightIsBoundary &&
-          hasPrevJapaneseOpener) {
-        forceOpen = false
-        forceClose = true
+      const canCheckForceOpen =
+        leftJapanese && rightIsOpenWrapper && !isMarkdownStructuralOpenWrapper(nextChar)
+      const canCheckForceClose =
+        (leftIsCloseWrapper && rightJapanese) ||
+        ((leftIsCloseWrapper || leftIsExtraClosePunct) && !rightJapanese && !rightIsBoundary)
+      if (canCheckForceOpen || canCheckForceClose) {
+        prevStarFlags = ensurePrevStarFlags(src, start, prevStarFlags)
+        const hasPrevJapaneseOpener = (prevStarFlags & PREV_STAR_HAS_OPENER) !== 0
+        const hasJapaneseSincePrevStar = (prevStarFlags & PREV_STAR_HAS_JP_BETWEEN) !== 0
+        const canForceCloseByPunct = leftIsExtraClosePunct && hasJapaneseSincePrevStar
+        if (canCheckForceOpen && !hasPrevJapaneseOpener) {
+          forceOpen = true
+          forceClose = false
+        } else if (leftIsCloseWrapper && rightJapanese && hasPrevJapaneseOpener) {
+          forceOpen = false
+          forceClose = true
+        } else if ((leftIsCloseWrapper || canForceCloseByPunct) &&
+            !rightJapanese &&
+            !rightIsBoundary &&
+            hasPrevJapaneseOpener) {
+          forceOpen = false
+          forceClose = true
+        }
       }
     }
     const finalOpen = forceOpen === null ? ((base && base.can_open) || relaxedOpen) : forceOpen

package/src/token-link-utils.js

@@ -1,6 +1,6 @@
 import Token from 'markdown-it/lib/token.mjs'
 import { isWhiteSpace } from 'markdown-it/lib/common/utils.mjs'
-import { getReferenceCount } from './token-utils.js'
+import { cloneMap, getReferenceCount } from './token-utils.js'
 
 const CHAR_OPEN_BRACKET = 0x5B // [
 const CHAR_CLOSE_BRACKET = 0x5D // ]
@@ -80,11 +80,6 @@ const getNormalizeRef = (state) => {
 }
 
 
-const cloneMap = (map) => {
-  if (!map || !Array.isArray(map)) return null
-  return [map[0], map[1]]
-}
-
 const getMapFromTokenRange = (tokens, startIdx, endIdx) => {
   if (!tokens || startIdx > endIdx) return null
   let startLine = null

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'
 
 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
@@ -389,13 +394,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 +414,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 +465,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 +504,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
 }

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,
@@ -11,68 +11,35 @@ import {
 import {
   getRuntimeOpt,
   hasRuntimeOverride,
-  getReferenceCount
+  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
@@ -81,14 +48,17 @@ 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: preScan.hasCodeInline,
+    hasJapaneseContext: preScan.hasJapaneseContext,
+    repairMask: preScan.repairMask,
     linkCloseMap: undefined,
     wrapperPrefixStats: undefined,
     rebuildLevelStart: undefined
@@ -159,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) => {
@@ -232,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)
@@ -245,19 +210,9 @@ const cloneTextToken = (source, content) => {
   return token
 }
 
-const isSoftSpaceCode = (code) => {
-  return code === 0x20 || code === 0x09 || code === 0x3000
-}
-
 const CHAR_ASTERISK = 0x2A // *
 const CHAR_BACKSLASH = 0x5C // \
 
-const isAsciiWordCode = (code) => {
-  return (code >= 0x30 && code <= 0x39) ||
-    (code >= 0x41 && code <= 0x5A) ||
-    (code >= 0x61 && code <= 0x7A)
-}
-
 const textEndsAsciiWord = (text) => {
   if (!text || text.length === 0) return false
   return isAsciiWordCode(text.charCodeAt(text.length - 1))
@@ -459,46 +414,78 @@ const shouldRunInlineBrokenRefRepair = (facts, inlineContent, state) => {
   return getReferenceCount(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 }
-}
-
 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,
     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 = getPostprocessMetrics(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
 }
 
@@ -507,33 +494,17 @@ const shouldRunInlineCollapsedRefRepair = (facts, state) => {
   return getReferenceCount(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
-}
-
 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 &&
@@ -541,8 +512,7 @@ const shouldSkipInlinePostprocessToken = (children, facts, isJapaneseMode) => {
       !facts.hasCodeInline) {
     return true
   }
-  if (isJapaneseMode &&
-      !hasJapaneseContextInRange(children, 0, children.length - 1)) {
+  if (isJapaneseMode && !facts.hasJapaneseContext) {
     return true
   }
   return false
@@ -569,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
 }
 
@@ -583,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,

package/src/token-utils.js

@@ -1,10 +1,10 @@
-const CHAR_ASTERISK = 0x2A // *
-const CHAR_SPACE = 0x20 // ' '
-const CHAR_TAB = 0x09 // '\t'
-const CHAR_NEWLINE = 0x0A // '\n'
-const CHAR_IDEOGRAPHIC_SPACE = 0x3000 // fullwidth space
-const MODE_FLAG_COMPATIBLE = 1 << 0
-const MODE_FLAG_AGGRESSIVE = 1 << 1
+const CHAR_ASTERISK = 0x2A // *
+const CHAR_SPACE = 0x20 // ' '
+const CHAR_TAB = 0x09 // '\t'
+const CHAR_NEWLINE = 0x0A // '\n'
+const CHAR_IDEOGRAPHIC_SPACE = 0x3000 // fullwidth space
+const MODE_FLAG_COMPATIBLE = 1 << 0
+const MODE_FLAG_AGGRESSIVE = 1 << 1
 const MODE_FLAG_JAPANESE_BASE = 1 << 2
 const MODE_FLAG_JAPANESE_PLUS = 1 << 3
 const MODE_FLAG_JAPANESE_ANY = MODE_FLAG_JAPANESE_BASE | MODE_FLAG_JAPANESE_PLUS
@@ -16,25 +16,40 @@ const VALID_CANONICAL_MODES = new Set([
   'japanese-boundary',
   'japanese-boundary-guard'
 ])
-const REG_JAPANESE = /[\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Han}\u3000-\u303F\uFF00-\uFFEF]/u
-const REG_ATTRS = /{[^{}\n!@#%^&*()]+?}$/
-
+const REG_JAPANESE = /[\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Han}\u3000-\u303F\uFF00-\uFFEF]/u
+const REG_ATTRS = /{[^{}\n!@#%^&*()]+?}$/
+
 const isJapaneseChar = (ch) => {
-  if (!ch) return false
-  const code = typeof ch === 'string' ? ch.charCodeAt(0) : ch
-  if (code < 128) return false
-  if (code >= 0x3040 && code <= 0x309F) return true
-  if (code >= 0x30A0 && code <= 0x30FF) return true
-  // Han + CJK punctuation/fullwidth ranges are common hot-path hits.
-  // Keep these as cheap numeric checks before the fallback regex.
-  if (code >= 0x3400 && code <= 0x4DBF) return true
-  if (code >= 0x4E00 && code <= 0x9FFF) return true
-  if (code >= 0xF900 && code <= 0xFAFF) return true
-  if (code >= 0x3000 && code <= 0x303F) return true
-  if (code >= 0xFF00 && code <= 0xFFEF) return true
+  if (!ch) return false
+  const code = typeof ch === 'string' ? ch.charCodeAt(0) : ch
+  if (code < 128) return false
+  if (code >= 0x3040 && code <= 0x309F) return true
+  if (code >= 0x30A0 && code <= 0x30FF) return true
+  // Han + CJK punctuation/fullwidth ranges are common hot-path hits.
+  // Keep these as cheap numeric checks before the fallback regex.
+  if (code >= 0x3400 && code <= 0x4DBF) return true
+  if (code >= 0x4E00 && code <= 0x9FFF) return true
+  if (code >= 0xF900 && code <= 0xFAFF) return true
+  if (code >= 0x3000 && code <= 0x303F) return true
+  if (code >= 0xFF00 && code <= 0xFFEF) return true
   return REG_JAPANESE.test(String.fromCharCode(code))
 }
 
+const isAsciiWordCode = (code) => {
+  return (code >= 0x30 && code <= 0x39) ||
+    (code >= 0x41 && code <= 0x5A) ||
+    (code >= 0x61 && code <= 0x7A)
+}
+
+const isSoftSpaceCode = (code) => {
+  return code === CHAR_SPACE || code === CHAR_TAB || code === CHAR_IDEOGRAPHIC_SPACE
+}
+
+const cloneMap = (map) => {
+  if (!map || !Array.isArray(map)) return null
+  return [map[0], map[1]]
+}
+
 const hasCjkBreaksRule = (md) => {
   if (!md || !md.core || !md.core.ruler || !Array.isArray(md.core.ruler.__rules__)) return false
   if (md.__strongJaHasCjkBreaks === true) return true
@@ -59,7 +74,7 @@ const hasCjkBreaksRule = (md) => {
 const isCjkBreaksRuleName = (name) => {
   return typeof name === 'string' && REG_CJK_BREAKS_RULE_NAME.test(name)
 }
-
+
 const resolveMode = (opt) => {
   const raw = opt && typeof opt.mode === 'string' ? opt.mode : 'japanese'
   const normalized = raw.toLowerCase()
@@ -70,9 +85,9 @@ const resolveMode = (opt) => {
     `mditStrongJa: unknown mode "${raw}". Valid modes: japanese, japanese-boundary, japanese-boundary-guard, aggressive, compatible`
   )
 }
-
-const getModeFlags = (mode) => {
-  switch (mode) {
+
+const getModeFlags = (mode) => {
+  switch (mode) {
     case 'compatible':
       return MODE_FLAG_COMPATIBLE
     case 'aggressive':
@@ -81,26 +96,26 @@ const getModeFlags = (mode) => {
       return MODE_FLAG_JAPANESE_BASE
     case 'japanese-boundary-guard':
       return MODE_FLAG_JAPANESE_PLUS
-    default:
-      return 0
-  }
-}
-
-const deriveModeInfo = (opt) => {
-  if (!opt || typeof opt !== 'object') return opt
-  const rawMode = opt.mode
-  if (opt.__strongJaModeRaw === rawMode &&
-      typeof opt.__strongJaMode === 'string' &&
-      typeof opt.__strongJaModeFlags === 'number') {
-    return opt
-  }
-  const mode = resolveMode(opt)
-  opt.__strongJaModeRaw = rawMode
-  opt.__strongJaMode = mode
-  opt.__strongJaModeFlags = getModeFlags(mode)
-  return opt
-}
-
+    default:
+      return 0
+  }
+}
+
+const deriveModeInfo = (opt) => {
+  if (!opt || typeof opt !== 'object') return opt
+  const rawMode = opt.mode
+  if (opt.__strongJaModeRaw === rawMode &&
+      typeof opt.__strongJaMode === 'string' &&
+      typeof opt.__strongJaModeFlags === 'number') {
+    return opt
+  }
+  const mode = resolveMode(opt)
+  opt.__strongJaModeRaw = rawMode
+  opt.__strongJaMode = mode
+  opt.__strongJaModeFlags = getModeFlags(mode)
+  return opt
+}
+
 const deriveOptionInfo = (opt) => {
   if (!opt || typeof opt !== 'object') return opt
   deriveModeInfo(opt)
@@ -135,21 +150,29 @@ const hasRuntimeOverride = (override) => {
 
 const getRuntimeOpt = (state, baseOpt) => {
   const override = state && state.env ? state.env.__strongJaTokenOpt : null
-  if (!hasRuntimeOverride(override)) return deriveOptionInfo(baseOpt)
-  if (state.__strongJaTokenRuntimeOpt &&
+  const hasOverride = hasRuntimeOverride(override)
+  if (state &&
+      state.__strongJaTokenRuntimeOpt &&
       state.__strongJaTokenRuntimeBase === baseOpt &&
-      state.__strongJaTokenRuntimeOverride === override) {
+      state.__strongJaTokenRuntimeOverride === override &&
+      state.__strongJaTokenRuntimeHasOverride === hasOverride) {
     return state.__strongJaTokenRuntimeOpt
   }
-  const merged = baseOpt && typeof baseOpt === 'object' ? { ...baseOpt } : {}
-  if (HAS_OWN.call(override, 'mode') && override.mode !== undefined) merged.mode = override.mode
-  if (HAS_OWN.call(override, 'postprocess') && override.postprocess !== undefined) merged.postprocess = override.postprocess
-  state.__strongJaTokenRuntimeOpt = deriveOptionInfo(merged)
+  let resolved = deriveOptionInfo(baseOpt)
+  if (hasOverride) {
+    const merged = baseOpt && typeof baseOpt === 'object' ? { ...baseOpt } : {}
+    if (HAS_OWN.call(override, 'mode') && override.mode !== undefined) merged.mode = override.mode
+    if (HAS_OWN.call(override, 'postprocess') && override.postprocess !== undefined) merged.postprocess = override.postprocess
+    resolved = deriveOptionInfo(merged)
+  }
+  if (!state) return resolved
+  state.__strongJaTokenRuntimeOpt = resolved
   state.__strongJaTokenRuntimeBase = baseOpt
   state.__strongJaTokenRuntimeOverride = override
-  return state.__strongJaTokenRuntimeOpt
+  state.__strongJaTokenRuntimeHasOverride = hasOverride
+  return resolved
 }
-
+
 const getReferenceCount = (state) => {
   if (!state) return 0
   let referenceCount = state.__strongJaReferenceCount
@@ -167,74 +190,77 @@ const getReferenceCount = (state) => {
   return referenceCount
 }
 
-function normalizeCoreRulesBeforePostprocess(value) {
-  if (!value) return []
-  const list = Array.isArray(value) ? value : [value]
-  const normalized = []
-  const seen = new Set()
-  for (let idx = 0; idx < list.length; idx++) {
-    const raw = list[idx]
-    if (typeof raw !== 'string') continue
-    const trimmed = raw.trim()
-    if (!trimmed || seen.has(trimmed)) continue
-    seen.add(trimmed)
-    normalized.push(trimmed)
-  }
-  return normalized
-}
-
-function ensureCoreRuleOrder(md, ruleNames, targetRuleName) {
-  if (!md || !md.core || !md.core.ruler) return
-  if (!ruleNames || ruleNames.length === 0) return
-  for (let idx = 0; idx < ruleNames.length; idx++) {
-    moveRuleBefore(md.core.ruler, ruleNames[idx], targetRuleName)
-  }
-}
-
-function moveRuleBefore(ruler, ruleName, beforeName) {
-  if (!ruler || !ruler.__rules__) return
-  const rules = ruler.__rules__
-  let fromIdx = -1
-  let beforeIdx = -1
-  for (let idx = 0; idx < rules.length; idx++) {
-    if (rules[idx].name === ruleName) fromIdx = idx
-    if (rules[idx].name === beforeName) beforeIdx = idx
-    if (fromIdx !== -1 && beforeIdx !== -1) break
-  }
-  // Ensure ruleName is before beforeName; keep existing order if already earlier.
-  if (fromIdx === -1 || beforeIdx === -1 || fromIdx < beforeIdx) return
-
-  const rule = rules.splice(fromIdx, 1)[0]
-  rules.splice(beforeIdx, 0, rule)
-  ruler.__cache__ = null
-}
-
-function moveRuleAfter(ruler, ruleName, afterName) {
-  if (!ruler || !ruler.__rules__) return
-  const rules = ruler.__rules__
-  let fromIdx = -1
-  let afterIdx = -1
-  for (let idx = 0; idx < rules.length; idx++) {
-    if (rules[idx].name === ruleName) fromIdx = idx
-    if (rules[idx].name === afterName) afterIdx = idx
-    if (fromIdx !== -1 && afterIdx !== -1) break
-  }
-  if (fromIdx === -1 || afterIdx === -1 || fromIdx === afterIdx + 1) return
-
-  const rule = rules.splice(fromIdx, 1)[0]
-  const targetIdx = fromIdx < afterIdx ? afterIdx - 1 : afterIdx
-  rules.splice(targetIdx + 1, 0, rule)
-  ruler.__cache__ = null
-}
-
-export {
-  CHAR_ASTERISK,
-  CHAR_SPACE,
-  CHAR_TAB,
-  CHAR_NEWLINE,
-  CHAR_IDEOGRAPHIC_SPACE,
+function normalizeCoreRulesBeforePostprocess(value) {
+  if (!value) return []
+  const list = Array.isArray(value) ? value : [value]
+  const normalized = []
+  const seen = new Set()
+  for (let idx = 0; idx < list.length; idx++) {
+    const raw = list[idx]
+    if (typeof raw !== 'string') continue
+    const trimmed = raw.trim()
+    if (!trimmed || seen.has(trimmed)) continue
+    seen.add(trimmed)
+    normalized.push(trimmed)
+  }
+  return normalized
+}
+
+function ensureCoreRuleOrder(md, ruleNames, targetRuleName) {
+  if (!md || !md.core || !md.core.ruler) return
+  if (!ruleNames || ruleNames.length === 0) return
+  for (let idx = 0; idx < ruleNames.length; idx++) {
+    moveRuleBefore(md.core.ruler, ruleNames[idx], targetRuleName)
+  }
+}
+
+function moveRuleBefore(ruler, ruleName, beforeName) {
+  if (!ruler || !ruler.__rules__) return
+  const rules = ruler.__rules__
+  let fromIdx = -1
+  let beforeIdx = -1
+  for (let idx = 0; idx < rules.length; idx++) {
+    if (rules[idx].name === ruleName) fromIdx = idx
+    if (rules[idx].name === beforeName) beforeIdx = idx
+    if (fromIdx !== -1 && beforeIdx !== -1) break
+  }
+  // Ensure ruleName is before beforeName; keep existing order if already earlier.
+  if (fromIdx === -1 || beforeIdx === -1 || fromIdx < beforeIdx) return
+
+  const rule = rules.splice(fromIdx, 1)[0]
+  rules.splice(beforeIdx, 0, rule)
+  ruler.__cache__ = null
+}
+
+function moveRuleAfter(ruler, ruleName, afterName) {
+  if (!ruler || !ruler.__rules__) return
+  const rules = ruler.__rules__
+  let fromIdx = -1
+  let afterIdx = -1
+  for (let idx = 0; idx < rules.length; idx++) {
+    if (rules[idx].name === ruleName) fromIdx = idx
+    if (rules[idx].name === afterName) afterIdx = idx
+    if (fromIdx !== -1 && afterIdx !== -1) break
+  }
+  if (fromIdx === -1 || afterIdx === -1 || fromIdx === afterIdx + 1) return
+
+  const rule = rules.splice(fromIdx, 1)[0]
+  const targetIdx = fromIdx < afterIdx ? afterIdx - 1 : afterIdx
+  rules.splice(targetIdx + 1, 0, rule)
+  ruler.__cache__ = null
+}
+
+export {
+  CHAR_ASTERISK,
+  CHAR_SPACE,
+  CHAR_TAB,
+  CHAR_NEWLINE,
+  CHAR_IDEOGRAPHIC_SPACE,
   REG_ATTRS,
   isJapaneseChar,
+  isAsciiWordCode,
+  isSoftSpaceCode,
+  cloneMap,
   hasCjkBreaksRule,
   isCjkBreaksRuleName,
   resolveMode,
@@ -243,14 +269,14 @@ export {
   deriveOptionInfo,
   hasRuntimeOverride,
   MODE_FLAG_COMPATIBLE,
-  MODE_FLAG_AGGRESSIVE,
-  MODE_FLAG_JAPANESE_BASE,
-  MODE_FLAG_JAPANESE_PLUS,
+  MODE_FLAG_AGGRESSIVE,
+  MODE_FLAG_JAPANESE_BASE,
+  MODE_FLAG_JAPANESE_PLUS,
   MODE_FLAG_JAPANESE_ANY,
   getRuntimeOpt,
   getReferenceCount,
-  normalizeCoreRulesBeforePostprocess,
-  ensureCoreRuleOrder,
-  moveRuleBefore,
-  moveRuleAfter
-}
+  normalizeCoreRulesBeforePostprocess,
+  ensureCoreRuleOrder,
+  moveRuleBefore,
+  moveRuleAfter
+}