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

package/README.md

@@ -98,6 +98,14 @@ Terms used below:
 - Run: a contiguous group of the same marker (`*`, `**`, `***`, ...).
 - Line: text split by `\n`.
 
+### TL;DR
+
+- Baseline: start from plain `markdown-it` delimiter pairing.
+- Local helper path: only `*` runs with local Japanese context enter strong-ja boundary logic.
+- Mixed-text guard: `japanese-boundary-guard` additionally suppresses mixed JA/EN over-conversion.
+- Postprocess: token-only repairs run only for malformed link/reference-adjacent spans.
+
+
 ### Step 1: Build the baseline with plain `markdown-it`
 
 `markdown-it` runs first. If it can already parse a pattern (including cross-line `**...**`), that baseline structure is kept.
@@ -368,6 +376,7 @@ Supporting visuals:
 - Default: `true`
 - Set `false` to disable link/reference postprocess repairs.
 - In `mode: 'compatible'`, repairs are skipped even when this is `true`.
+- Repairs stay local to malformed link/reference-adjacent spans; valid inputs such as `[w](u) *string*  [w](u)` are left unchanged.
 
 ### `coreRulesBeforePostprocess`
 
@@ -388,6 +397,9 @@ 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.
-- This is an ESM plugin (`type: module`) and works in Node.js, browser bundlers, and VS Code extension pipelines that use `markdown-it` ESM.
+- 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.
+- 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

@@ -1,32 +1,49 @@
-import { hasCjkBreaksRule, normalizeCoreRulesBeforePostprocess, ensureCoreRuleOrder, deriveModeInfo } from './src/token-utils.js'
+import { hasCjkBreaksRule, ensureCoreRuleOrder, deriveOptionInfo } from './src/token-utils.js'
 import { patchScanDelims } from './src/token-core.js'
 import { registerTokenCompat } from './src/token-compat.js'
 import { registerTokenPostprocess } from './src/token-postprocess.js'
 
+const DEFAULT_OPTION = {
+  mditAttrs: true, // assume markdown-it-attrs integration by default
+  mode: 'japanese', // 'japanese'(->japanese-boundary-guard) | 'japanese-boundary' | 'japanese-boundary-guard' | 'aggressive' | 'compatible'
+  coreRulesBeforePostprocess: [], // e.g. ['cjk_breaks'] to keep rules ahead of postprocess
+  postprocess: true, // enable link/ref reconstruction pass
+  patchCorePush: true // keep restore-softbreaks after late cjk_breaks
+}
+
+const buildNormalizedOption = (md, option) => {
+  const opt = { ...DEFAULT_OPTION }
+  if (option) Object.assign(opt, option)
+  opt.hasCjkBreaks = hasCjkBreaksRule(md)
+  deriveOptionInfo(opt)
+  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)')
-  }
-  const opt = {
-    mditAttrs: true, // assume markdown-it-attrs integration by default
-    mode: 'japanese', // 'japanese'(->japanese-boundary-guard) | 'japanese-boundary' | 'japanese-boundary-guard' | 'aggressive' | 'compatible'
-    coreRulesBeforePostprocess: [], // e.g. ['cjk_breaks'] to keep rules ahead of postprocess
-    postprocess: true, // enable link/ref reconstruction pass
-    patchCorePush: true // keep restore-softbreaks after late cjk_breaks
-  }
-  if (option) Object.assign(opt, option)
-  opt.hasCjkBreaks = hasCjkBreaksRule(md)
-  deriveModeInfo(opt)
-
+  if (option && typeof option.engine === 'string' && option.engine !== 'token') {
+    throw new Error('mditStrongJa: legacy engine was removed; use token (default)')
+  }
+  const nextOpt = buildNormalizedOption(md, option)
+  const opt = md.__strongJaTokenOpt && typeof md.__strongJaTokenOpt === 'object'
+    ? writeSharedOption(md.__strongJaTokenOpt, nextOpt)
+    : nextOpt
+
   md.__strongJaTokenOpt = opt
   patchScanDelims(md)
   registerTokenCompat(md, opt)
 
   registerTokenPostprocess(md, opt)
-  const coreRulesBeforePostprocess = normalizeCoreRulesBeforePostprocess(opt.coreRulesBeforePostprocess)
-  ensureCoreRuleOrder(md, coreRulesBeforePostprocess, 'strong_ja_token_postprocess')
+  ensureCoreRuleOrder(md, opt.__strongJaNormalizedCoreRulesBeforePostprocess, 'strong_ja_token_postprocess')
 
   return md
 }
-
-export default mditStrongJa
+
+export default mditStrongJa

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@peaceroad/markdown-it-strong-ja",
-  "description": "This is a plugin for markdown-it. It is an alternative to the standard `**` (strong)  and `*` (em) processing. It also processes strings that cannot be converted by the standard.",
-  "version": "0.8.0",
+  "description": "Extends asterisk emphasis handling for Japanese text while keeping markdown-it behavior as close as practical.",
+  "version": "0.8.1",
   "main": "index.js",
   "type": "module",
   "files": [
@@ -18,6 +18,7 @@
     "test:postprocess-fastpath": "node test/post-processing-fastpath.test.js",
     "test:postprocess-fastpath-roster": "node test/post-processing-fastpath-roster.test.js",
     "test:postprocess-flow": "node test/post-processing-flow.test.js",
+    "test:postprocess-link-helper": "node test/post-processing-link-helper.test.js",
     "test:postprocess-gate": "node test/postprocess-gate.js",
     "test:tokenonly-progress": "node test/post-processing-progress.test.js",
     "test:readme": "node test/test-readme.js",
@@ -35,13 +36,14 @@
     "markdown-it": "^14.1.0"
   },
   "devDependencies": {
-    "@peaceroad/markdown-it-cjk-breaks-mod": "^0.1.7",
-    "@peaceroad/markdown-it-hr-sandwiched-semantic-container": "^0.8.5",
-    "@peaceroad/markdown-it-renderer-image": "^0.10.0",
-    "@peaceroad/markdown-it-renderer-inline-text": "^0.6.0",
+    "@peaceroad/markdown-it-cjk-breaks-mod": "^0.1.8",
+    "@peaceroad/markdown-it-hr-sandwiched-semantic-container": "^0.10.0",
+    "@peaceroad/markdown-it-renderer-image": "^0.12.0",
+    "@peaceroad/markdown-it-renderer-inline-text": "^0.7.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

@@ -4,8 +4,6 @@ import {
   isJapaneseChar,
   hasCjkBreaksRule,
   isCjkBreaksRuleName,
-  deriveModeInfo,
-  MODE_FLAG_COMPATIBLE,
   getRuntimeOpt,
   moveRuleAfter
 } from './token-utils.js'
@@ -28,15 +26,11 @@ const trimTrailingSpaceTab = (text) => {
 }
 
 const registerTokenCompat = (md, baseOpt) => {
-  const baseModeFlags = typeof baseOpt.__strongJaModeFlags === 'number'
-    ? baseOpt.__strongJaModeFlags
-    : deriveModeInfo(baseOpt).__strongJaModeFlags
-  const baseCompatible = (baseModeFlags & MODE_FLAG_COMPATIBLE) !== 0
   const isCompatibleMode = (state) => {
     const override = state && state.env && state.env.__strongJaTokenOpt
-    if (!override) return baseCompatible
+    if (!override) return baseOpt.__strongJaIsCompatibleMode === true
     const opt = getRuntimeOpt(state, baseOpt)
-    return (opt.__strongJaModeFlags & MODE_FLAG_COMPATIBLE) !== 0
+    return opt.__strongJaIsCompatibleMode === true
   }
 
   let hasTextJoinRule = false

package/src/token-core.js

@@ -194,6 +194,28 @@ const rebuildInlineLevels = (tokens) => {
   }
 }
 
+const rebuildInlineLevelsFrom = (tokens, startIdx = 0) => {
+  if (!tokens || tokens.length === 0) return
+  let from = startIdx > 0 ? startIdx : 0
+  if (from >= tokens.length) return
+  let level = 0
+  if (from > 0) {
+    const prev = tokens[from - 1]
+    if (prev) {
+      level = prev.level
+      if (prev.nesting === 1) level++
+      else if (prev.nesting === -1) level--
+    }
+  }
+  for (let i = from; i < tokens.length; i++) {
+    const t = tokens[i]
+    if (!t) continue
+    t.level = level
+    if (t.nesting === 1) level++
+    else if (t.nesting === -1) level--
+  }
+}
+
 const findLinkOpen = (tokens, closeIdx) => {
   let depth = 0
   for (let i = closeIdx; i >= 0; i--) {
@@ -396,7 +418,7 @@ const ensurePrevStarFlags = (src, start, prevStarFlags) => {
   return prevStarFlags >= 0 ? prevStarFlags : scanPrevSingleStarContextFlags(src, start)
 }
 
-const fixTrailingStrong = (tokens) => {
+const fixTrailingStrong = (tokens, onChangeStart = null) => {
   let changed = false
   for (let i = 1; i < tokens.length; i++) {
     const token = tokens[i]
@@ -435,21 +457,23 @@ const fixTrailingStrong = (tokens) => {
         tokens[innerOpenIdx + 2] && tokens[innerOpenIdx + 2].type === 'em_close' &&
         tokens[innerOpenIdx + 3] && tokens[innerOpenIdx + 3].type === 'text' &&
         closeIdx === innerOpenIdx + 4) {
-      tokens.splice(innerOpenIdx + 2, 1)
-      tokens.splice(innerOpenIdx, 1)
       const movedOpen = new Token('em_open', 'em', 1)
       movedOpen.markup = '*'
       const movedClose = new Token('em_close', 'em', -1)
       movedClose.markup = '*'
-      tokens.splice(innerOpenIdx + 1, 0, movedOpen)
-      tokens.splice(innerOpenIdx + 3, 0, movedClose)
+      const innerReplacement = [
+        tokens[innerOpenIdx + 1],
+        movedOpen,
+        tokens[innerOpenIdx + 3],
+        movedClose
+      ]
+      tokens.splice(innerOpenIdx, 4, ...innerReplacement)
     }
 
     const before = token.content.slice(0, starIdx)
     const after = token.content.slice(starIdx + 2)
 
-    tokens.splice(closeIdx, 1)
-    if (closeIdx < i) i--
+    if (onChangeStart) onChangeStart(openIdx)
 
     const openToken = tokens[openIdx]
     if (!openToken) continue
@@ -458,28 +482,27 @@ const fixTrailingStrong = (tokens) => {
     openToken.markup = '**'
     openToken.nesting = 1
 
+    const strongClose = new Token('strong_close', 'strong', -1)
+    strongClose.markup = '**'
+    const trailingReplacement = []
     if (before) {
       token.content = before
-    } else {
-      tokens.splice(i, 1)
-      i--
+      trailingReplacement.push(token)
     }
-
-    const insertAt = i + 1
-    const strongClose = new Token('strong_close', 'strong', -1)
-    strongClose.markup = '**'
-    tokens.splice(insertAt, 0, strongClose)
+    trailingReplacement.push(strongClose)
     if (after) {
       const tail = new Token('text', '', 0)
       tail.content = after
-      tokens.splice(insertAt + 1, 0, tail)
+      trailingReplacement.push(tail)
     }
+    tokens.splice(closeIdx, 2, ...trailingReplacement)
+    i = closeIdx + trailingReplacement.length - 1
     changed = true
   }
   return changed
 }
 
-function fixEmOuterStrongSequence(tokens) {
+function fixEmOuterStrongSequence(tokens, onChangeStart = null) {
   let changed = false
   let i = 0
   while (i < tokens.length) {
@@ -536,6 +559,7 @@ function fixEmOuterStrongSequence(tokens) {
       continue
     }
 
+    if (onChangeStart) onChangeStart(idx0)
     t0.type = 'strong_open'
     t0.tag = 'strong'
     t0.markup = '**'
@@ -548,28 +572,23 @@ function fixEmOuterStrongSequence(tokens) {
     const strongClose = new Token('strong_close', 'strong', -1)
     strongClose.markup = '**'
 
-    tokens.splice(idx7, 1)
-    tokens.splice(idx5, 1)
-    tokens.splice(idx3, 1)
-    tokens.splice(idx1, 1)
-
-    const idx4AfterRemove = idx4 - 2
-    const idx6AfterRemove = idx6 - 3
-    tokens.splice(idx4AfterRemove, 0, emOpen)
-
-    const idx6BeforeEmClose = idx6AfterRemove + 1
-    tokens.splice(idx6BeforeEmClose, 0, emClose)
-
-    const idx6AfterEmClose = idx6BeforeEmClose + 1
-    tokens.splice(idx6AfterEmClose + 1, 0, strongClose)
+    const replacement = [
+      ...tokens.slice(idx1 + 1, idx3),
+      emOpen,
+      ...tokens.slice(idx3 + 1, idx5),
+      emClose,
+      ...tokens.slice(idx5 + 1, idx7),
+      strongClose
+    ]
+    tokens.splice(idx1, idx7 - idx1 + 1, ...replacement)
 
     changed = true
-    i = idx6AfterEmClose + 2
+    i = idx1 + replacement.length
   }
   return changed
 }
 
-const shiftEmWithLeadingStar = (tokens, rangeStart, rangeEnd, closeIdx) => {
+const shiftEmWithLeadingStar = (tokens, rangeStart, rangeEnd, closeIdx, onChangeStart = null) => {
   let openIdx = findMatchingEmOpen(tokens, closeIdx)
   if (openIdx === -1 || openIdx < rangeStart || openIdx >= rangeEnd) return false
 
@@ -598,33 +617,26 @@ const shiftEmWithLeadingStar = (tokens, rangeStart, rangeEnd, closeIdx) => {
   const starToken = tokens[starTokenIdx]
   const before = starToken.content.slice(0, starPos)
   const after = starToken.content.slice(starPos + 1)
-  let insertAt = starTokenIdx
-  if (before) {
-    starToken.content = before
-    insertAt = starTokenIdx + 1
-  } else {
-    tokens.splice(starTokenIdx, 1)
-    if (starTokenIdx < openIdx) {
-      openIdx--
-      closeIdx--
-    }
-  }
+  if (onChangeStart) onChangeStart(starTokenIdx)
 
   const emOpen = new Token('em_open', 'em', 1)
   emOpen.markup = '*'
-  tokens.splice(insertAt, 0, emOpen)
-  if (insertAt <= openIdx) {
-    openIdx++
-    closeIdx++
+  const prefixReplacement = []
+  if (before) {
+    starToken.content = before
+    prefixReplacement.push(starToken)
   }
+  prefixReplacement.push(emOpen)
   if (after) {
     const afterToken = new Token('text', '', 0)
     afterToken.content = after
-    tokens.splice(insertAt + 1, 0, afterToken)
-    if (insertAt + 1 <= openIdx) {
-      openIdx++
-      closeIdx++
-    }
+    prefixReplacement.push(afterToken)
+  }
+  const prefixDelta = prefixReplacement.length - 1
+  tokens.splice(starTokenIdx, 1, ...prefixReplacement)
+  if (starTokenIdx < openIdx) {
+    openIdx += prefixDelta
+    closeIdx += prefixDelta
   }
 
   const openToken = tokens[openIdx]
@@ -634,19 +646,20 @@ const shiftEmWithLeadingStar = (tokens, rangeStart, rangeEnd, closeIdx) => {
   openToken.markup = '*'
   openToken.nesting = -1
 
-  tokens.splice(closeIdx, 1)
+  const tailReplacement = []
   const tailIdx = closeIdx - 1
   if (tailIdx >= 0 && tokens[tailIdx] && tokens[tailIdx].type === 'text') {
     tokens[tailIdx].content += '*'
   } else {
     const tail = new Token('text', '', 0)
     tail.content = '*'
-    tokens.splice(closeIdx, 0, tail)
+    tailReplacement.push(tail)
   }
+  tokens.splice(closeIdx, 1, ...tailReplacement)
   return true
 }
 
-const fixLeadingAsteriskEm = (tokens) => {
+const fixLeadingAsteriskEm = (tokens, onChangeStart = null) => {
   let changed = false
   for (let i = 0; i < tokens.length; i++) {
     const t = tokens[i]
@@ -656,7 +669,7 @@ const fixLeadingAsteriskEm = (tokens) => {
     const linkCloseIdx = nextIdx
     const linkOpenIdx = findLinkOpen(tokens, linkCloseIdx)
     if (linkOpenIdx === -1) continue
-    if (shiftEmWithLeadingStar(tokens, linkOpenIdx + 1, linkCloseIdx, i)) {
+    if (shiftEmWithLeadingStar(tokens, linkOpenIdx + 1, linkCloseIdx, i, onChangeStart)) {
       changed = true
       i = linkCloseIdx
     }
@@ -805,6 +818,7 @@ const patchScanDelims = (md) => {
 
 export {
   rebuildInlineLevels,
+  rebuildInlineLevelsFrom,
   findLinkOpen,
   nextNonEmptyIndex,
   fixTrailingStrong,