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

package/README.md

@@ -396,10 +396,10 @@ Supporting visuals:
 
 ## Notes
 
-- Use `state.env.__strongJaTokenOpt` to override options per render.
-- Overrides are merged with plugin options, but setup-time behavior (such as rule registration/order) cannot be switched at render time and cannot be retrofitted after the first `.use(...)` on the same `MarkdownIt` instance.
-- `mode` and `postprocess` are runtime-effective. `mditAttrs`, `patchCorePush`, and `coreRulesBeforePostprocess` are setup-time effective after the first `.use(...)` on a `MarkdownIt` instance.
+- Use `state.env.__strongJaTokenOpt` to override runtime-effective options per render.
+- Repeated `.use(...)` on the same `MarkdownIt` instance is treated as first-install-wins no-op. Create a new `MarkdownIt` instance for a different plugin option set.
+- Runtime-effective override keys are merged with plugin options, but setup-time behavior (such as rule registration/order) cannot be switched at render time and cannot be retrofitted after the first `.use(...)` on the same `MarkdownIt` instance.
+- `mode` and `postprocess` are runtime-effective via initial install or per-render override. `mditAttrs`, `patchCorePush`, and `coreRulesBeforePostprocess` are setup-time effective after the first `.use(...)` on a `MarkdownIt` instance.
 - This is an ESM plugin (`type: module`) and is tested against `markdown-it` 14.x in Node.js, browser bundlers, and VS Code extension pipelines that use `markdown-it` ESM.
 - The implementation relies on `markdown-it` internal ESM modules / core rule internals (`lib/token.mjs`, `lib/common/utils.mjs`, `ruler.__rules__`) plus a `scanDelims` prototype patch, so internal `markdown-it` changes may require plugin updates.
 - `scanDelims` patch is applied once per `MarkdownIt` prototype in the same process.
-

package/index.js

@@ -19,31 +19,23 @@ const buildNormalizedOption = (md, option) => {
   return opt
 }
 
-const writeSharedOption = (target, source) => {
-  for (const key of Object.keys(target)) {
-    delete target[key]
-  }
-  Object.assign(target, source)
-  return target
-}
-
 const mditStrongJa = (md, option) => {
   if (option && typeof option.engine === 'string' && option.engine !== 'token') {
     throw new Error('mditStrongJa: legacy engine was removed; use token (default)')
   }
+  if (md.__strongJaTokenInstalled) {
+    return md
+  }
   const nextOpt = buildNormalizedOption(md, option)
-  const opt = md.__strongJaTokenOpt && typeof md.__strongJaTokenOpt === 'object'
-    ? writeSharedOption(md.__strongJaTokenOpt, nextOpt)
-    : nextOpt
-
-  md.__strongJaTokenOpt = opt
+  md.__strongJaTokenOpt = nextOpt
   patchScanDelims(md)
-  registerTokenCompat(md, opt)
+  registerTokenCompat(md, nextOpt)
 
-  registerTokenPostprocess(md, opt)
-  ensureCoreRuleOrder(md, opt.__strongJaNormalizedCoreRulesBeforePostprocess, 'strong_ja_token_postprocess')
+  registerTokenPostprocess(md, nextOpt)
+  ensureCoreRuleOrder(md, nextOpt.__strongJaNormalizedCoreRulesBeforePostprocess, 'strong_ja_token_postprocess')
+  md.__strongJaTokenInstalled = true
 
   return md
 }
 
-export default mditStrongJa
+export default mditStrongJa

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.8.1",
+  "version": "0.9.0",
   "main": "index.js",
   "type": "module",
   "files": [
@@ -36,10 +36,10 @@
     "markdown-it": "^14.1.0"
   },
   "devDependencies": {
-    "@peaceroad/markdown-it-cjk-breaks-mod": "^0.1.8",
-    "@peaceroad/markdown-it-hr-sandwiched-semantic-container": "^0.10.0",
+    "@peaceroad/markdown-it-cjk-breaks-mod": "^0.1.10",
+    "@peaceroad/markdown-it-hr-sandwiched-semantic-container": "^0.11.0",
     "@peaceroad/markdown-it-renderer-image": "^0.12.0",
-    "@peaceroad/markdown-it-renderer-inline-text": "^0.7.0",
+    "@peaceroad/markdown-it-renderer-inline-text": "^0.8.0",
     "markdown-it-attrs": "^4.3.1",
     "markdown-it-sub": "^2.0.0",
     "markdown-it-sup": "^2.0.0",

package/src/token-compat.js

@@ -5,6 +5,7 @@ import {
   hasCjkBreaksRule,
   isCjkBreaksRuleName,
   getRuntimeOpt,
+  hasRuntimeOverride,
   moveRuleAfter
 } from './token-utils.js'
 
@@ -25,10 +26,14 @@ const trimTrailingSpaceTab = (text) => {
   return end === text.length ? text : text.slice(0, end)
 }
 
+const getStateSource = (state) => {
+  return state && typeof state.src === 'string' ? state.src : ''
+}
+
 const registerTokenCompat = (md, baseOpt) => {
   const isCompatibleMode = (state) => {
     const override = state && state.env && state.env.__strongJaTokenOpt
-    if (!override) return baseOpt.__strongJaIsCompatibleMode === true
+    if (!hasRuntimeOverride(override)) return baseOpt.__strongJaIsCompatibleMode === true
     const opt = getRuntimeOpt(state, baseOpt)
     return opt.__strongJaIsCompatibleMode === true
   }
@@ -82,6 +87,8 @@ const registerTokenCompat = (md, baseOpt) => {
     const normalizeSoftbreakSpacing = (state) => {
       if (isCompatibleMode(state)) return
       if (!state) return
+      const src = getStateSource(state)
+      if (!src || src.indexOf('\n') === -1) return
       if (baseOpt.hasCjkBreaks !== true && state.md) {
         baseOpt.hasCjkBreaks = hasCjkBreaksRule(state.md)
       }
@@ -164,11 +171,8 @@ const registerTokenCompat = (md, baseOpt) => {
   const restoreSoftbreaksAfterCjk = (state) => {
     if (isCompatibleMode(state)) return
     if (!state) return
-    const overrideOpt = state.env && state.env.__strongJaTokenOpt
-    if (overrideOpt) {
-      const opt = getRuntimeOpt(state, baseOpt)
-      if (opt.mditAttrs !== false) return
-    }
+    const src = getStateSource(state)
+    if (!src || src.indexOf('\n') === -1 || src.indexOf('{') === -1) return
     if (!state.md || state.md.__strongJaRestoreSoftbreaksForAttrs !== true) return
     if (baseOpt.hasCjkBreaks !== true && state.md) {
       baseOpt.hasCjkBreaks = hasCjkBreaksRule(state.md)
@@ -239,11 +243,8 @@ const registerTokenCompat = (md, baseOpt) => {
     md.core.ruler.before('linkify', 'strong_ja_token_pre_attrs', (state) => {
       if (isCompatibleMode(state)) return
       if (!state || !state.tokens) return
-      const overrideOpt = state.env && state.env.__strongJaTokenOpt
-      if (overrideOpt) {
-        const opt = getRuntimeOpt(state, baseOpt)
-        if (opt.mditAttrs === false) return
-      }
+      const src = getStateSource(state)
+      if (!src || src.indexOf('{') === -1 || src.indexOf('}') === -1) return
       for (let i = 0; i < state.tokens.length; i++) {
         const token = state.tokens[i]
         if (!token || token.type !== 'inline' || !token.children || token.children.length === 0) continue

package/src/token-core.js

@@ -10,13 +10,15 @@ import {
   MODE_FLAG_COMPATIBLE,
   MODE_FLAG_AGGRESSIVE,
   MODE_FLAG_JAPANESE_PLUS,
-  getRuntimeOpt
+  getRuntimeOpt,
+  hasRuntimeOverride
 } from './token-utils.js'
 
 const SCAN_DELIMS_PATCHED = Symbol.for('strongJaTokenScanDelimsPatched')
 const SINGLE_STAR_LOOKAROUND_MAX = 16
 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
@@ -280,7 +282,58 @@ const isAsciiGuardCloseWrapper = (code) => {
     code === 0x60 // `
 }
 
-const findPrevNonSpaceIndex = (src, start) => {
+const buildScanDelimsLookupCache = (src) => {
+  const len = typeof src === 'string' ? src.length : 0
+  const prevNonSpaceSameLine = new Int32Array(len)
+  const nextNonSpaceSameLine = new Int32Array(len)
+  prevNonSpaceSameLine.fill(-1)
+  nextNonSpaceSameLine.fill(-1)
+
+  let prev = -1
+  for (let i = 0; i < len; i++) {
+    const code = src.charCodeAt(i)
+    if (code === CHAR_NEWLINE) {
+      prev = -1
+      continue
+    }
+    if (!isSoftSpaceCode(code)) prev = i
+    prevNonSpaceSameLine[i] = prev
+  }
+
+  let next = -1
+  for (let i = len - 1; i >= 0; i--) {
+    const code = src.charCodeAt(i)
+    if (code === CHAR_NEWLINE) {
+      next = -1
+      continue
+    }
+    if (!isSoftSpaceCode(code)) next = i
+    nextNonSpaceSameLine[i] = next
+  }
+
+  return {
+    src,
+    prevNonSpaceSameLine,
+    nextNonSpaceSameLine
+  }
+}
+
+const getScanDelimsLookupCache = (state) => {
+  if (!state || typeof state.src !== 'string') return null
+  const cached = state[SCAN_DELIMS_LOOKUP_KEY]
+  if (cached && cached.src === state.src) return cached
+  const next = buildScanDelimsLookupCache(state.src)
+  state[SCAN_DELIMS_LOOKUP_KEY] = next
+  return next
+}
+
+const findPrevNonSpaceIndex = (src, start, lookupCache = null) => {
+  if (start < 0) return -1
+  if (lookupCache &&
+      lookupCache.src === src &&
+      start < lookupCache.prevNonSpaceSameLine.length) {
+    return lookupCache.prevNonSpaceSameLine[start]
+  }
   for (let i = start; i >= 0; i--) {
     const code = src.charCodeAt(i)
     if (code === CHAR_NEWLINE) return -1
@@ -290,7 +343,14 @@ const findPrevNonSpaceIndex = (src, start) => {
   return -1
 }
 
-const findNextNonSpaceIndex = (src, start, max) => {
+const findNextNonSpaceIndex = (src, start, max, lookupCache = null) => {
+  if (lookupCache &&
+      lookupCache.src === src &&
+      start >= 0 &&
+      start < lookupCache.nextNonSpaceSameLine.length) {
+    const next = lookupCache.nextNonSpaceSameLine[start]
+    return next !== -1 && next < max ? next : -1
+  }
   for (let i = start; i < max; i++) {
     const code = src.charCodeAt(i)
     if (code === CHAR_NEWLINE) return -1
@@ -300,26 +360,26 @@ const findNextNonSpaceIndex = (src, start, max) => {
   return -1
 }
 
-const hasAsciiStartAfterOptionalOpenWrappers = (src, index, max) => {
+const hasAsciiStartAfterOptionalOpenWrappers = (src, index, max, lookupCache = null) => {
   let i = index
   // Two wrappers are enough for common shapes: * [ "word" ]*
   for (let wrappers = 0; wrappers < 2 && i >= 0 && i < max; wrappers++) {
     const code = src.charCodeAt(i)
     if (!isAsciiGuardOpenWrapper(code)) break
-    i = findNextNonSpaceIndex(src, i + 1, max)
+    i = findNextNonSpaceIndex(src, i + 1, max, lookupCache)
     if (i === -1) return false
   }
   if (i < 0 || i >= max) return false
   return isAsciiAlphaNum(src.charCodeAt(i))
 }
 
-const hasAsciiEndBeforeOptionalCloseWrappers = (src, index) => {
+const hasAsciiEndBeforeOptionalCloseWrappers = (src, index, lookupCache = null) => {
   let i = index
   // Two wrappers are enough for common shapes: *["word"] *
   for (let wrappers = 0; wrappers < 2 && i >= 0; wrappers++) {
     const code = src.charCodeAt(i)
     if (!isAsciiGuardCloseWrapper(code)) break
-    i = findPrevNonSpaceIndex(src, i - 1)
+    i = findPrevNonSpaceIndex(src, i - 1, lookupCache)
     if (i === -1) return false
   }
   if (i < 0) return false
@@ -353,7 +413,17 @@ const isSentenceBoundaryStop = (code) => {
     code === 0x2049 // ⁉
 }
 
-const findPrevNonSpaceLimited = (src, start, maxLook) => {
+const findPrevNonSpaceLimited = (src, start, maxLook, lookupCache = null) => {
+  if (lookupCache &&
+      lookupCache.src === src &&
+      start >= 0 &&
+      start < lookupCache.prevNonSpaceSameLine.length) {
+    const prev = lookupCache.prevNonSpaceSameLine[start]
+    if (prev !== -1 && (start - prev) < maxLook) {
+      return src.charCodeAt(prev)
+    }
+    return 0
+  }
   let looked = 0
   for (let i = start; i >= 0; i--) {
     if (looked >= maxLook) break
@@ -366,7 +436,17 @@ const findPrevNonSpaceLimited = (src, start, maxLook) => {
   return 0
 }
 
-const findNextNonSpaceLimited = (src, start, max, maxLook) => {
+const findNextNonSpaceLimited = (src, start, max, maxLook, lookupCache = null) => {
+  if (lookupCache &&
+      lookupCache.src === src &&
+      start >= 0 &&
+      start < lookupCache.nextNonSpaceSameLine.length) {
+    const next = lookupCache.nextNonSpaceSameLine[start]
+    if (next !== -1 && next < max && (next - start) < maxLook) {
+      return src.charCodeAt(next)
+    }
+    return 0
+  }
   let looked = 0
   for (let i = start; i < max; i++) {
     if (looked >= maxLook) break
@@ -379,13 +459,13 @@ const findNextNonSpaceLimited = (src, start, max, maxLook) => {
   return 0
 }
 
-const hasJapaneseContextForBracketWrapper = (src, start, pos, max, lastChar, nextChar) => {
+const hasJapaneseContextForBracketWrapper = (src, start, pos, max, lastChar, nextChar, lookupCache = null) => {
   if (isWrapperOpenLike(nextChar)) {
-    const right = findNextNonSpaceLimited(src, pos, max, SINGLE_STAR_LOOKAROUND_MAX)
+    const right = findNextNonSpaceLimited(src, pos, max, SINGLE_STAR_LOOKAROUND_MAX, lookupCache)
     if (isJapaneseChar(right)) return true
   }
   if (isWrapperCloseLike(lastChar)) {
-    const left = findPrevNonSpaceLimited(src, start - 2, SINGLE_STAR_LOOKAROUND_MAX)
+    const left = findPrevNonSpaceLimited(src, start - 2, SINGLE_STAR_LOOKAROUND_MAX, lookupCache)
     if (isJapaneseChar(left)) return true
   }
   return false
@@ -415,7 +495,8 @@ const scanPrevSingleStarContextFlags = (src, start) => {
 }
 
 const ensurePrevStarFlags = (src, start, prevStarFlags) => {
-  return prevStarFlags >= 0 ? prevStarFlags : scanPrevSingleStarContextFlags(src, start)
+  if (prevStarFlags >= 0) return prevStarFlags
+  return scanPrevSingleStarContextFlags(src, start)
 }
 
 const fixTrailingStrong = (tokens, onChangeStart = null) => {
@@ -696,7 +777,7 @@ const patchScanDelims = (md) => {
 
     const baseOpt = this.md ? this.md.__strongJaTokenOpt : null
     const overrideOpt = this.env && this.env.__strongJaTokenOpt
-    const opt = overrideOpt ? getRuntimeOpt(this, baseOpt) : baseOpt
+    const opt = hasRuntimeOverride(overrideOpt) ? getRuntimeOpt(this, baseOpt) : baseOpt
     if (!opt) {
       return base
     }
@@ -707,6 +788,7 @@ const patchScanDelims = (md) => {
     const plusMode = (modeFlags & MODE_FLAG_JAPANESE_PLUS) !== 0
     const aggressiveMode = (modeFlags & MODE_FLAG_AGGRESSIVE) !== 0
     const max = this.posMax
+    let lookupCache = null
     const lastChar = start > 0 ? src.charCodeAt(start - 1) : 0x20
 
     const count = base && base.length ? base.length : 1
@@ -719,7 +801,15 @@ const patchScanDelims = (md) => {
     const rightJapanese = isJapaneseChar(nextChar)
     let hasJapaneseContext = leftJapanese || rightJapanese
     if (!hasJapaneseContext && count === 1) {
-      hasJapaneseContext = hasJapaneseContextForBracketWrapper(src, start, pos, max, lastChar, nextChar)
+      hasJapaneseContext = hasJapaneseContextForBracketWrapper(
+        src,
+        start,
+        pos,
+        max,
+        lastChar,
+        nextChar,
+        lookupCache || (lookupCache = getScanDelimsLookupCache(this))
+      )
     }
     if (!hasJapaneseContext && count === 1 && isExtraSingleStarClosePunct(lastChar)) {
       prevStarFlags = ensurePrevStarFlags(src, start, prevStarFlags)
@@ -734,22 +824,31 @@ const patchScanDelims = (md) => {
     let isLastWhiteSpace = isWhiteSpace(lastChar) || isSoftSpaceCode(lastChar)
     let isNextWhiteSpace = isWhiteSpace(nextChar) || isSoftSpaceCode(nextChar)
     if (isLastWhiteSpace && isSoftSpaceCode(lastChar)) {
-      const prevNonSpaceIdx = findPrevNonSpaceIndex(src, start - 2)
+      const prevNonSpaceIdx = findPrevNonSpaceIndex(
+        src,
+        start - 2,
+        lookupCache || (lookupCache = getScanDelimsLookupCache(this))
+      )
       if (prevNonSpaceIdx !== -1) {
         const prevNonSpaceLocal = src.charCodeAt(prevNonSpaceIdx)
         const plusStrictAsciiBoundary = plusMode &&
-          hasAsciiEndBeforeOptionalCloseWrappers(src, prevNonSpaceIdx)
+          hasAsciiEndBeforeOptionalCloseWrappers(src, prevNonSpaceIdx, lookupCache)
         if (prevNonSpaceLocal !== CHAR_ASTERISK && !plusStrictAsciiBoundary) {
           isLastWhiteSpace = false
         }
       }
     }
     if (isNextWhiteSpace && isSoftSpaceCode(nextChar)) {
-      const nextNonSpaceIdx = findNextNonSpaceIndex(src, pos, max)
+      const nextNonSpaceIdx = findNextNonSpaceIndex(
+        src,
+        pos,
+        max,
+        lookupCache || (lookupCache = getScanDelimsLookupCache(this))
+      )
       if (nextNonSpaceIdx !== -1) {
         const nextNonSpace = src.charCodeAt(nextNonSpaceIdx)
         const plusStrictAsciiBoundary = plusMode &&
-          hasAsciiStartAfterOptionalOpenWrappers(src, nextNonSpaceIdx, max)
+          hasAsciiStartAfterOptionalOpenWrappers(src, nextNonSpaceIdx, max, lookupCache)
         if (nextNonSpace !== CHAR_ASTERISK && !plusStrictAsciiBoundary) {
           isNextWhiteSpace = false
         }

package/src/token-link-utils.js

@@ -120,10 +120,7 @@ const cloneTextToken = (source, content) => {
 }
 
 const applyBracketSegmentFlags = (token, seg) => {
-  if (seg === '[' || seg === ']') {
-    token.__strongJaHasBracket = true
-    token.__strongJaBracketAtomic = true
-  } else if (seg === '[]') {
+  if (seg === '[' || seg === ']' || seg === '[]') {
     token.__strongJaHasBracket = true
     token.__strongJaBracketAtomic = true
   } else {
@@ -641,16 +638,21 @@ const collectBrokenMarkLinkMergeRemovals = (tokens) => {
 
 const applyBrokenMarkLinkMergeRemovals = (tokens, removals, onChangeStart = null) => {
   if (!removals || removals.length === 0) return false
-  const removeFlags = new Array(tokens.length).fill(false)
   for (let idx = removals.length - 1; idx >= 0; idx--) {
-    const removal = removals[idx]
-    if (onChangeStart) onChangeStart(removal.closeIdx)
-    removeFlags[removal.closeIdx] = true
-    removeFlags[removal.reopenIdx] = true
+    if (onChangeStart) onChangeStart(removals[idx].closeIdx)
   }
   const kept = []
+  let removalIdx = 0
+  let nextRemoval = removals[removalIdx]
   for (let idx = 0; idx < tokens.length; idx++) {
-    if (!removeFlags[idx]) kept.push(tokens[idx])
+    if (nextRemoval && (idx === nextRemoval.closeIdx || idx === nextRemoval.reopenIdx)) {
+      if (idx === nextRemoval.reopenIdx) {
+        removalIdx++
+        nextRemoval = removals[removalIdx]
+      }
+      continue
+    }
+    kept.push(tokens[idx])
   }
   tokens.splice(0, tokens.length, ...kept)
   return true

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'
@@ -194,7 +194,13 @@ const resolveBrokenRefCandidateGuardFlow = (
   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
   }
   const wrapperPrefixStats = ensureBrokenRefWrapperPrefixStats(children, facts, hooks, fallbackCache)
@@ -203,7 +209,8 @@ const resolveBrokenRefCandidateGuardFlow = (
     brokenRefCandidate.start,
     segmentEnd,
     brokenRefCandidate.startTextOffset,
-    wrapperPrefixStats
+    wrapperPrefixStats,
+    wrapperSignals
   )) {
     return BROKEN_REF_FLOW_SKIP_GUARD
   }

package/src/token-postprocess/guards.js

@@ -1,17 +1,11 @@
 import { isJapaneseChar } from '../token-utils.js'
 
+const CHAR_ASTERISK = 0x2A // *
+
 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 +72,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 +87,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 +114,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 +170,8 @@ const createBrokenRefWrapperRangeSignals = () => {
     hasUnderscoreText: false,
     hasCodeInline: false,
     hasUnderscoreEmphasisToken: false,
+    hasTextMarker: false,
+    strongRunCount: 0,
     strongOpenInRange: 0,
     strongCloseInRange: 0,
     emOpenInRange: 0,
@@ -239,17 +182,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 +294,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 +377,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) => {
@@ -450,22 +393,31 @@ 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)
+  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) => {
   let hasEmphasis = false
   let hasLinkOpen = false
   let hasLinkClose = false
+  let hasCodeInline = false
   for (let j = 0; j < children.length; j++) {
     const child = children[j]
     if (!child) continue
@@ -478,12 +430,16 @@ const scanInlinePostprocessSignals = (children) => {
     if (!hasLinkClose && child.type === 'link_close') {
       hasLinkClose = true
     }
+    if (!hasCodeInline && child.type === 'code_inline') {
+      hasCodeInline = true
+    }
     if (hasEmphasis && hasLinkOpen && hasLinkClose) break
   }
   return {
     hasEmphasis,
     hasLinkOpen,
-    hasLinkClose
+    hasLinkClose,
+    hasCodeInline
   }
 }
 
@@ -492,8 +448,8 @@ export {
   isAsteriskEmphasisToken,
   hasJapaneseContextInRange,
   hasEmphasisSignalInRange,
-  hasTextMarkerCharsInRange,
   buildAsteriskWrapperPrefixStats,
+  buildBrokenRefWrapperRangeSignals,
   shouldAttemptBrokenRefRewrite,
   scanInlinePostprocessSignals
 }

package/src/token-postprocess/orchestrator.js

@@ -10,6 +10,7 @@ import {
 } from '../token-core.js'
 import {
   getRuntimeOpt,
+  hasRuntimeOverride,
   getReferenceCount
 } from '../token-utils.js'
 import {
@@ -87,46 +88,13 @@ const buildInlinePostprocessFacts = (children, inlineContent) => {
     hasEmphasis: preScan.hasEmphasis,
     hasLinkOpen: preScan.hasLinkOpen,
     hasLinkClose: preScan.hasLinkClose,
-    hasCodeInline: undefined,
-    referenceCount: undefined,
-    metrics: undefined,
+    hasCodeInline: preScan.hasCodeInline,
     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)
@@ -281,6 +249,9 @@ 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) ||
@@ -299,7 +270,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 +278,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 +445,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,7 +456,7 @@ 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
+  return getReferenceCount(state) > 0
 }
 
 const applyBrokenRefRepairFacts = (facts, repairs) => {
@@ -508,7 +479,7 @@ const runInlineBrokenRefRepairStage = (children, facts, inlineContent, state) =>
     children,
     maxRepairPass,
     scanState,
-    ensureInlineMetrics(facts, state),
+    getPostprocessMetrics(state),
     facts,
     BROKEN_REF_REPAIR_HOOKS
   )
@@ -522,7 +493,7 @@ const runInlineEmphasisRepairStage = (children, facts, state, isJapaneseMode) =>
   const markChangedFrom = createInlineChangeMarker(facts)
   if (fixEmOuterStrongSequence(children, markChangedFrom)) changed = true
   if (facts.hasLinkClose) {
-    const metrics = ensureInlineMetrics(facts, state)
+    const metrics = getPostprocessMetrics(state)
     if (fixTailAfterLinkStrongClose(children, isJapaneseMode, metrics, markChangedFrom)) changed = true
     if (fixLeadingAsteriskEm(children, markChangedFrom)) changed = true
   }
@@ -533,7 +504,7 @@ const runInlineEmphasisRepairStage = (children, facts, state, isJapaneseMode) =>
 
 const shouldRunInlineCollapsedRefRepair = (facts, state) => {
   if (!facts || !facts.hasBracketText) return false
-  return ensureInlineReferenceCount(facts, state) > 0
+  return getReferenceCount(state) > 0
 }
 
 const applyCollapsedRefRepairFacts = (facts) => {
@@ -567,7 +538,7 @@ const shouldSkipInlinePostprocessToken = (children, facts, isJapaneseMode) => {
       !facts.hasBracketText &&
       !facts.hasLinkOpen &&
       !facts.hasLinkClose &&
-      !ensureInlineHasCodeInline(facts, children)) {
+      !facts.hasCodeInline) {
     return true
   }
   if (isJapaneseMode &&
@@ -655,7 +626,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

package/src/token-utils.js

@@ -8,6 +8,7 @@ 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
+const HAS_OWN = Object.prototype.hasOwnProperty
 const REG_CJK_BREAKS_RULE_NAME = /(^|[_-])cjk_breaks([_-]|$)/
 const VALID_CANONICAL_MODES = new Set([
   'compatible',
@@ -126,27 +127,42 @@ const deriveOptionInfo = (opt) => {
   return opt
 }
 
-const getRuntimeOpt = (state, baseOpt) => {
-  if (!state || !state.env || !state.env.__strongJaTokenOpt) return deriveOptionInfo(baseOpt)
-  const override = state.env.__strongJaTokenOpt
-  if (state.__strongJaTokenRuntimeOpt &&
-      state.__strongJaTokenRuntimeBase === baseOpt &&
-      state.__strongJaTokenRuntimeOverride === override) {
-    return state.__strongJaTokenRuntimeOpt
-  }
-  const merged = { ...baseOpt, ...override }
-  state.__strongJaTokenRuntimeOpt = deriveOptionInfo(merged)
-  state.__strongJaTokenRuntimeBase = baseOpt
-  state.__strongJaTokenRuntimeOverride = override
-  return state.__strongJaTokenRuntimeOpt
-}
+const hasRuntimeOverride = (override) => {
+  if (!override || typeof override !== 'object') return false
+  return (HAS_OWN.call(override, 'mode') && override.mode !== undefined) ||
+    (HAS_OWN.call(override, 'postprocess') && override.postprocess !== undefined)
+}
+
+const getRuntimeOpt = (state, baseOpt) => {
+  const override = state && state.env ? state.env.__strongJaTokenOpt : null
+  if (!hasRuntimeOverride(override)) return deriveOptionInfo(baseOpt)
+  if (state.__strongJaTokenRuntimeOpt &&
+      state.__strongJaTokenRuntimeBase === baseOpt &&
+      state.__strongJaTokenRuntimeOverride === override) {
+    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)
+  state.__strongJaTokenRuntimeBase = baseOpt
+  state.__strongJaTokenRuntimeOverride = override
+  return state.__strongJaTokenRuntimeOpt
+}
 
 const getReferenceCount = (state) => {
   if (!state) return 0
   let referenceCount = state.__strongJaReferenceCount
   if (referenceCount !== undefined) return referenceCount
   const references = state.env && state.env.references
-  referenceCount = references ? Object.keys(references).length : 0
+  if (!references) {
+    state.__strongJaReferenceCount = 0
+    return 0
+  }
+  referenceCount = 0
+  for (const key in references) {
+    if (HAS_OWN.call(references, key)) referenceCount++
+  }
   state.__strongJaReferenceCount = referenceCount
   return referenceCount
 }
@@ -223,9 +239,10 @@ export {
   isCjkBreaksRuleName,
   resolveMode,
   getModeFlags,
-  deriveModeInfo,
-  deriveOptionInfo,
-  MODE_FLAG_COMPATIBLE,
+  deriveModeInfo,
+  deriveOptionInfo,
+  hasRuntimeOverride,
+  MODE_FLAG_COMPATIBLE,
   MODE_FLAG_AGGRESSIVE,
   MODE_FLAG_JAPANESE_BASE,
   MODE_FLAG_JAPANESE_PLUS,