@peaceroad/markdown-it-strong-ja 0.6.2 → 0.7.0

package/README.md

@@ -18,27 +18,32 @@ md.render('HTMLは*「HyperText Markup Language」*の略です。')
 // <p>HTMLは<em>「HyperText Markup Language」</em>の略です。</p>
 ```
 
-Notice. Basically, it is assumed that you will use markdown-it-attrs in conjunction with this. If you do not use it, please use `use(mditStrongJa, {mditAttrs: false})`.
+Note: this plugin assumes `markdown-it-attrs` is used. If you do not use it, pass `use(mditStrongJa, { mditAttrs: false })`.
 
 ### How this differs from vanilla markdown-it
 
-Default output pairs `*` / `**` as it scans left-to-right: when a line contains Japanese (hiragana / katakana / kanji / fullwidth punctuation), japanese-only mode treats the leading `**` aggressively; English-only lines follow markdown-it style pairing. Pick one mode for the examples below:
+Default output pairs `*` / `**` as it scans left-to-right: when a line contains Japanese (hiragana / katakana / kanji (Han) / fullwidth punctuation), japanese mode treats the leading `**` aggressively; English-only lines follow markdown-it style pairing. Pick one mode for the examples below:
 
-- `mode: 'japanese-only'` (default) … Japanese ⇒ aggressive, English-only ⇒ markdown-it compatible
+- `mode: 'japanese'` (default, alias: `'japanese-only'`) … Japanese ⇒ aggressive, English-only ⇒ markdown-it compatible
 - `mode: 'aggressive'` … always aggressive (lead `**` pairs greedily)
 - `mode: 'compatible'` … markdown-it compatible (lead `**` stays literal)
 
 ```js
-const mdDefault = mdit().use(mditStrongJa) // mode: 'japanese-only'
+const mdDefault = mdit().use(mditStrongJa) // mode: 'japanese'
 const mdCompat = mdit().use(mditStrongJa, { mode: 'compatible' }) // markdown-it pairing
 const mdAggressive = mdit().use(mditStrongJa, { mode: 'aggressive' }) // always pair leading **
 ```
 
-Default (japanese-only) pairs aggressively only when Japanese is present in the paragraph (the full inline content); detection is not line-by-line. Aggressive always pairs the leading `**`, and compatible matches markdown-it.
+Default (japanese) pairs aggressively only when Japanese is present in the paragraph (the full inline content); detection is not line-by-line. Aggressive always pairs the leading `**`, and compatible matches markdown-it. Detection keys off hiragana/katakana/kanji (Han) and fullwidth punctuation; it does not treat Hangul as Japanese, so it is not full CJK detection.
+
+Quick mode guide:
+- Pick `compatible` for markdown-it behavior everywhere.
+- Pick `japanese` to be aggressive only when Japanese text is present.
+- Pick `aggressive` if you want leading `**` to always pair.
 
 Japanese-first pairing around punctuation and mixed sentences: leading/trailing Japanese quotes or brackets (`「`, `」`, `（`, `、` etc.) are wrapped in Japanese paragraphs. Mixed sentences here mean one paragraph that contains multiple `*` runs; Japanese text keeps the leading `**` aggressive, while English-only stays compatible unless you pick aggressive mode.
 
-- Punctuation (CJK quotes):
+- Punctuation (Japanese quotes / fullwidth punctuation):
   - Input: `**「test」**`
   - Output (default/aggressive/compatible/markdown-it): `<p><strong>「test」</strong></p>`
   - Input: `これは**「test」**です`
@@ -79,7 +84,7 @@ Notice. The plugin keeps inline HTML / angle-bracket regions intact so rendered
 
 ## Example
 
-The following examples is for strong. The process for em is roughly the same.
+The following examples are for strong. The process for em is roughly the same.
 
 ````markdown
 [Markdown]
@@ -222,13 +227,9 @@ a****
 ````
 
 
-### disallowMixed (legacy)
-
-`disallowMixed: true` is kept for back-compat: it forces compatible pairing for English/mixed contexts that contain markdown links, HTML tags, inline code, or math expressions while staying aggressive for Japanese-only text. Prefer `mode` for new setups; enable this only if you need the legacy compat-first behavior in mixed English.
-
 ### coreRulesBeforePostprocess
 
-`strong_ja_postprocess` runs inside the markdown-it core pipeline. When other plugins register core rules, you can keep their rules ahead of `strong_ja_postprocess` by listing them in `coreRulesBeforePostprocess`. Each name is normalized, deduplicated, and re-ordered once during plugin setup.
+`strong_ja_token_postprocess` runs inside the markdown-it core pipeline. When other plugins register core rules, you can keep their rules ahead of `strong_ja_token_postprocess` by listing them in `coreRulesBeforePostprocess`. Each name is normalized, deduplicated, and re-ordered once during plugin setup.
 
 ```js
 const md = mdit()
@@ -242,4 +243,32 @@ const md = mdit()
 - Specify `['cjk_breaks']` (or other rule names) when you rely on plugins such as `@peaceroad/markdown-it-cjk-breaks-mod` and need them to run first.
 - Pass an empty array if you do not want `mditStrongJa` to reorder any core rules.
 
-Most setups can leave this option untouched; use it only when you must keep another plugin's core rule ahead of `strong_ja_postprocess`.
+Most setups can leave this option untouched; use it only when you must keep another plugin's core rule ahead of `strong_ja_token_postprocess`.
+
+### postprocess
+
+Toggle the link/reference reconstruction pass and the link-adjacent mark cleanup that runs after inline parsing.
+
+```js
+const md = mdit().use(mditStrongJa, {
+  postprocess: false
+})
+```
+
+- Default: `true`
+- Set `false` when you want to minimize core-rule interference and accept that some link/reference + emphasis combinations remain literal (for example, `**[text](url)**`, `[**Text**][]`).
+
+### patchCorePush
+
+Controls whether `mditStrongJa` patches `md.core.ruler.push` to keep `strong_ja_restore_softbreaks` ordered after `cjk_breaks` when other plugins register their core rules after `mditStrongJa` (used only when `mditAttrs: false`).
+
+```js
+const md = mdit().use(mditStrongJa, {
+  mditAttrs: false,
+  patchCorePush: false
+})
+```
+
+- Default: `true`
+- Disable if you want to avoid monkey-patching core rule registration and can guarantee rule ordering (or you do not use `cjk_breaks`).
+- If disabled and `cjk_breaks` is registered later, softbreak normalization can run too early and spacing around CJK punctuation can differ in no-attrs mode.