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

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.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"
   },
@@ -36,14 +37,13 @@
     "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",
     "p7d-markdown-it-p-captions": "^0.21.0"
   }
 }
-

package/src/token-compat.js

@@ -2,18 +2,14 @@ import Token from 'markdown-it/lib/token.mjs'
 import {
   REG_ATTRS,
   isJapaneseChar,
+  isAsciiWordCode,
   hasCjkBreaksRule,
   isCjkBreaksRuleName,
   getRuntimeOpt,
+  hasRuntimeOverride,
   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
@@ -25,10 +21,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 +82,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 +166,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 +238,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

@@ -2,14 +2,14 @@ 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,
+  hasRuntimeOverride,
   getRuntimeOpt
 } from './token-utils.js'
 
@@ -17,10 +17,7 @@ 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 isSoftSpaceCode = (code) => {
-  return code === CHAR_SPACE || code === CHAR_TAB || code === CHAR_IDEOGRAPHIC_SPACE
-}
+const SCAN_DELIMS_LOOKUP_KEY = Symbol.for('strongJaTokenScanDelimsLookup')
 
 const isPlusQuoteWrapperOpen = (code) => {
   return code === 0x2018 || // ‘
@@ -254,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 || // '
@@ -280,7 +271,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 +332,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,30 +349,30 @@ 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))
+  return isAsciiWordCode(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
-  return isAsciiAlphaNum(src.charCodeAt(i))
+  return isAsciiWordCode(src.charCodeAt(i))
 }
 
 const isMarkdownStructuralOpenWrapper = (code) => {
@@ -353,7 +402,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 +425,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 +448,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 +484,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 +766,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 +777,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 +790,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 +813,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
         }
@@ -771,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) {
@@ -781,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
@@ -120,10 +115,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 +633,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