@peaceroad/markdown-it-strong-ja 0.3.4 → 0.3.6

package/README.md

@@ -2,22 +2,24 @@
 
 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.
 
-Notice: this is slightly different from the commonmark processing.
-
 ## Use
 
 ```js
 import mdit from 'markdown-it'
 import mditStrongJa from '@peaceroad/markdown-it-strong-ja'
-const md = mdit().use(mditStrongJa)
+import mditAttrs from 'markdown-it-attrs'
+const md = mdit().use(mditStrongJa).use(mditAttrs)
 
 md.render('HTMLは**「HyperText Markup Language」**の略です。')
 // <p>HTMLは<strong>「HyperText Markup Language」</strong>の略です。</p>
 
+
 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})`.
+
 ## Example
 
 The following examples is for strong. The process for em is roughly the same.
@@ -150,4 +152,33 @@ a****b
 a****
 [HTML]
 <p>a****</p>
-~~~
+~~~
+
+---
+
+Warning. Commonmark converts it as follows, but the current plugin cannot convert it. (It converts it based on the first *. I don't think it's that bad in terms of appearance...)
+
+~~~
+[Markdown]
+z*<>*a*b
+[HTML:false]
+<p>z*&lt;&gt;<em>a</em>b</p>
+[HTML:true]
+<p>z*&lt;&gt;<em>a</em>b</p>
+
+[Markdown]
+z*<span>*a*b
+[HTML:false]
+<p>z*&lt;span&gt;<em>a</em>b</p>
+[HTML:true]
+<p>z*<span><em>a</em>b</p>
+
+[Markdown]
+z*<span>*a*b</span>
+[HTML:false]
+<p>z*&lt;span&gt;<em>a</em>b&lt;/span&gt;</p>
+[HTML:true]
+<p>z*<span><em>a</em>b</span></p>
+~~~
+
+---

package/index.js

@@ -2,44 +2,91 @@ const hasBackslash = (state, start) => {
   let slashNum = 0
   let i = start - 1
   while(i >= 0) {
-    /// if (state.src.charCodeAt(i) === 0x2A) { i--; continue }
     if (state.src.charCodeAt(i) === 0x5C) { slashNum++; i--; continue }
     break
   }
   return slashNum % 2 === 1 ? true : false
 }
 
-const setToken = (state, inlines) => {
+const setToken = (state, inlines, opt) => {
   let i = 0
+  let attrsIsText = {
+    val: false,
+    tag: '',
+  }
   while (i < inlines.length) {
     let type = inlines[i].type
+    //console.log(i, type)
     const tag = type.replace(/(?:_open|_close)$/, '')
 
     if (/_open$/.test(type)) {
       const startToken = state.push(type, tag, 1)
       startToken.markup = tag === 'strong' ? '**' : '*'
+      attrsIsText = {
+        val: true,
+        tag: tag,
+      }
     }
 
     if (type === 'html_inline') {
       type = 'text'
     }
     if (type === 'text') {
-      const content = state.src.slice(inlines[i].s, inlines[i].e + 1)
-      if (/^\**$/.test(content)) {
+      let content = state.src.slice(inlines[i].s, inlines[i].e + 1)
+      //console.log('content: ' + content)
+      if (/^\*+$/.test(content)) {
         //console.log('asterisk process::')
         const asteriskToken = state.push(type, '', 0)
         asteriskToken.content = content
         i++
         continue
       }
+      if (opt.mditAttrs && attrsIsText.val && i + 1 < inlines.length) {
+        const hasImmediatelyAfterAsteriskClose = inlines[i+1].type === attrsIsText.tag + '_close'
+        //console.log(hasImmediatelyAfterAsteriskClose, inlines[i+1].type, /^[\s\S]*{[^{}\n!@#%^&*()]+?}$/.test(content))
+        if (hasImmediatelyAfterAsteriskClose && /{[^{}\n!@#%^&*()]+?}$/.test(content)) {
+          const attrsToken = state.push(type, '', 0)
+
+          const hasBackslashBeforeCurlyAttribute = content.match(/(\\+){/)
+          if (hasBackslashBeforeCurlyAttribute) {
+            if (hasBackslashBeforeCurlyAttribute[1].length === 1) {
+              attrsToken.content = content.replace(/\\{/, '{')
+            } else {
+              let backSlashNum = Math.floor(hasBackslashBeforeCurlyAttribute[1].length / 2)
+              let k = 0
+              let backSlash = ''
+              while (k < backSlashNum) {
+                backSlash +=  '\\'
+                k++
+              }
+              //console.log(backSlashNum, backSlash)
+              attrsToken.content = content.replace(/\\+{/, backSlash + '{')
+            }
+          } else {
+            attrsToken.content = content
+          }
+          attrsIsText.val = false
+          i++
+          continue
+        }
+      }
 
       const childTokens = state.md.parseInline(content, state.env)
+      //console.log(childTokens)
+      //console.log(childTokens[0].children)
       if (childTokens[0] && childTokens[0].children) {
-        //console.log(state.tokens) 
-        //console.log(state.tokens[state.tokens.length - 1])
-        state.tokens[state.tokens.length - 1].children = childTokens[0].children
-        childTokens[0].children.forEach(t => {
-          //console.log('t.type: ' + t.type + ', t.tag: ' + t.tag + ', t.nesting: ' + t.nesting)
+        let j = 0
+        while (j < childTokens[0].children.length) {
+          const t = childTokens[0].children[j]
+          if (t.type === 'softbreak') {
+            t.type = 'text'
+            t.tag = ''
+            t.content = '\n'
+          }
+          if (!opt.mditAttrs && t.tag === 'br') {
+            t.tag = ''
+            t.content = '\n'
+          }
           const token = state.push(t.type, t.tag, t.nesting)
           token.attrs = t.attrs
           token.map = t.map
@@ -51,13 +98,18 @@ const setToken = (state, inlines) => {
           token.meta = t.meta
           token.block = t.block
           token.hidden = t.hidden
-        })
+          j++
+        }
       }
     }
 
     if (/_close$/.test(type)) {
       const closeToken = state.push(type, tag, -1)
       closeToken.markup = tag === 'strong' ? '**' : '*'
+      attrsIsText = {
+        val: false,
+        tag: '',
+      }
     }
 
     i++
@@ -85,32 +137,40 @@ const hasNextSymbol = (state, n, max, symbol, noMark) => {
     while (i < max) {
       tempNoMark += state.src[i]
       if (state.src.charCodeAt(i) === symbol && !hasBackslash(state, i)) {
-        noMark += state.src[n]
+        noMark += state.src.substring(n, i + 1)
         nextSymbolPos = i
         break
       }
       i++
     }
   }
-  return nextSymbolPos
+  return [nextSymbolPos, noMark]
 }
 
 const createInlines = (state, start, max, opt) => {
   let n = start
   let inlines = []
   let noMark = ''
-  let isInStartMark = true
   let textStart = n
-
   while (n < max) {
-    let nextSymbolPos = hasNextSymbol(state, n, max, 0x60, noMark)  // '`'
+    //console.log('n: ' + n + ', state.src[n]: ' + state.src[n] + ', noMark: ' + noMark)
+    let nextSymbolPos = -1;
+    [nextSymbolPos, noMark] = hasNextSymbol(state, n, max, 0x60, noMark)  // '`'
     if (nextSymbolPos !== -1) {
+      if (nextSymbolPos === max - 1) {
+        inlinesPush(inlines, textStart, nextSymbolPos, nextSymbolPos - textStart + 1, 'text')
+        break
+      }
       n = nextSymbolPos + 1
       continue
     }
     if (opt.dollarMath) {
-      nextSymbolPos = hasNextSymbol(state, n, max, 0x24, noMark)  // '$'
+      [nextSymbolPos, noMark] = hasNextSymbol(state, n, max, 0x24, noMark)  // '$'
       if (nextSymbolPos !== -1) {
+        if (nextSymbolPos === max - 1) {
+          inlinesPush(inlines, textStart, nextSymbolPos, nextSymbolPos - textStart + 1, 'text')
+          break
+        }
         n = nextSymbolPos + 1
         continue
       }
@@ -122,7 +182,9 @@ const createInlines = (state, start, max, opt) => {
         while (i < max) {
           if (state.src.charCodeAt(i) === 0x3E && !hasBackslash(state, i)) { // '>'
             if (noMark.length !== 0) {
+              // Add the text before the tag to inlines
               inlinesPush(inlines, textStart, n - 1, n - textStart, 'text')
+              noMark = ''
             }
             let tag = state.src.slice(n + 1, i)
             let tagType = ''
@@ -144,8 +206,18 @@ const createInlines = (state, start, max, opt) => {
     }
 
     if (state.src.charCodeAt(n) === 0x2A && !hasBackslash(state, n)) { // '*'
-      if (!isInStartMark) {
+      /*
+      if (/[!-)+-/:-@[-`{-~]/.test(state.src[n + 1])) {
+        inlinesPush(inlines, textStart, n, n - textStart + 1, 'text')
+        noMark = ''
+        n++
+        textStart = n
+        continue
+      }*/
+      if (n !== 0) {
+        //Add text before asterisk to inlines
         inlinesPush(inlines, textStart, n - 1, n - textStart, 'text')
+        noMark = ''
       }
       if (n === max - 1) {
         inlinesPush(inlines, n,  n, 1 , '')
@@ -165,10 +237,9 @@ const createInlines = (state, start, max, opt) => {
       n = i
       continue
     }
-    isInStartMark = false
+
     noMark += state.src[n]
-    //console.log('noMark: ' + noMark)
-    if (n === max - 1 || max < 3) {
+    if (n === max - 1) {
       inlinesPush(inlines, textStart, n, n - textStart + 1, 'text')
       break
     }
@@ -196,16 +267,17 @@ const marksPush = (marks, nest, s, e, len, outsideLen, type) => {
   }
 }
 
-const setStrong = (inlines, marks, n, memo) => {
+const setStrong = (state, inlines, marks, n, memo, opt) => {
   let i = n + 1
   let j = 0
   let nest = 0
   let insideTagsIsClose = 1
+  let prevHtmlTags = {...memo.htmlTags}
   while (i < inlines.length) {
     if (inlines[i].len === 0) { i++; continue }
     if (memo.html) {
       if (inlines[i].type === 'html_inline') {
-        insideTagsIsClose = isJumpTag(inlines, i, memo)
+        insideTagsIsClose = isJumpTag(inlines, i, memo, prevHtmlTags)
         //console.log('insideTagsIsClose: ' + insideTagsIsClose )
         if (insideTagsIsClose === -1) return n, nest, memo
         if (insideTagsIsClose === 0) { i++; continue }
@@ -236,9 +308,11 @@ const setStrong = (inlines, marks, n, memo) => {
     }
 
     //console.log('memo.html: ' + memo.html + 'insideTagsIsClose: ' + insideTagsIsClose + 'inlines[i].len: ' + inlines[i].len)
-    if (memo.html && !insideTagsIsClose && inlines[i].len !== 1) {
-      i++; continue
+    //if (memo.html && !insideTagsIsClose && inlines[i].len !== 1) {
+    if (memo.html && inlines[i].len < 2) {
+      i++; continue;
     }
+
     let strongNum = Math.trunc(Math.min(inlines[n].len, inlines[i].len) / 2)
 
     if (inlines[i].len > 1) {
@@ -262,13 +336,13 @@ const setStrong = (inlines, marks, n, memo) => {
     if ((inlines[n].len > 0 && inlines[i] === 1) || (inlines[n].len === 1 && inlines[i].len > 0)) {
       //console.log('check em that warp strong.')
       nest++
-      n, nest, memo = setEm(inlines, marks, n, memo, nest)
+      n, nest, memo = setEm(state, inlines, marks, n, memo, opt, nest)
       if (memo.hasEmThatWrapStrong) {
         //console.log('set em that wrap strong.')
         let k = 0
         while (k < strongNum) {
-            marks[marks.length - 2 - k * 2 - 1].nest += 1
-            marks[marks.length - 2 - k * 2].nest += 1
+          marks[marks.length - 2 - k * 2 - 1].nest += 1
+          marks[marks.length - 2 - k * 2].nest += 1
           k++
         }
       }
@@ -279,49 +353,56 @@ const setStrong = (inlines, marks, n, memo) => {
   return n, nest, memo
 }
 
-const isJumpTag = (inlines, n, memo) => {
+const isJumpTag = (inlines, n, memo, prevHtmlTags) => {
   //console.log(n, 'before::memo.htmlTags: ' + JSON.stringify(memo.htmlTags))
-  const hasSet = Object.keys(memo.htmlTags).some(tag => {
-    if (tag === inlines[n].tag[0]) {
-      if (inlines[n].tag[1] === 'open') {
-        memo.htmlTags[tag]++ }
-      else {
-        memo.htmlTags[tag]--
-      }
-      return true
-    }
-    return false
-  })
-  if (!hasSet && !memo.htmlTags[inlines[n].tag[0]]) {
-    if (inlines[n].tag[1] === 'close') {
-      memo.htmlTags = {}
-      return -1
-    }
-    memo.htmlTags[inlines[n].tag[0]] = 1
+  if (inlines[n].tag === undefined) return 0
+  if (memo.htmlTags[inlines[n].tag[0]] === undefined) {
+    memo.htmlTags[inlines[n].tag[0]] = 0
+  }
+  //console.log('prevHtmlTags: ' + JSON.stringify(prevHtmlTags))
+  //console.log('memo.htmlTags: ' + JSON.stringify(memo.htmlTags) + ', inlines[n].tag[1]: ' + inlines[n].tag[1])
+  if (inlines[n].tag[1] === 'open') {
+    memo.htmlTags[inlines[n].tag[0]] += 1
+  }
+  if (inlines[n].tag[1] === 'close') {
+    memo.htmlTags[inlines[n].tag[0]] -= 1
   }
-   //console.log(n, 'after::memo.htmlTags: ' + JSON.stringify(memo.htmlTags))
+  //console.log('prevHtmlTags: ' + JSON.stringify(prevHtmlTags))
+  //console.log('memo.htmlTags: ' + JSON.stringify(memo.htmlTags))
+  if (prevHtmlTags[inlines[n].tag[0]] === undefined) prevHtmlTags[inlines[n].tag[0]] = 0
+  if (memo.htmlTags[inlines[n].tag[0]] < prevHtmlTags[inlines[n].tag[0]]) {
+    return -1
+  }
+  //console.log(n, 'after::memo.htmlTags: ' + JSON.stringify(memo.htmlTags))
   const closeAllTags = Object.values(memo.htmlTags).every(val => val === 0)
   //console.log('closeAllTags: ' + closeAllTags)
   if (closeAllTags) return 1
+  // if (inlines[n].tag[1] === 'close') return -1
   //memo.htmlTags = {}
   return 0
 }
 
-const setEm = (inlines, marks, n, memo, sNest) => {
+const setEm = (state, inlines, marks, n, memo, opt, sNest) => {
   let i = n + 1
   let nest = 0
   let strongPNum = 0
-  let insideTagsIsClose = 1
+  let insideTagsIsClose = 1 //true
+  let prevHtmlTags = {...memo.htmlTags}
+  //console.log('memo.prevHtmlTags: ' + JSON.stringify(memo.prevHtmlTags))
   while (i < inlines.length) {
+    //console.log('i: ' + i + ', src: ' + state.src.slice(inlines[i].sp, inlines[i].ep + 1) + ', inlines[i]: ' + JSON.stringify(inlines[i]))
     if (inlines[i].len === 0) { i++; continue }
+   //console.log('      memo.isEm: ' + memo.isEm + ', memo.html: ' + memo.html + ', inlines[i].type: ' + inlines[i].type)
     if (memo.isEm && memo.html) {
       if (inlines[i].type === 'html_inline') {
-        insideTagsIsClose = isJumpTag(inlines, i, memo)
-        //console.log('insideTagsIsClose: ' + insideTagsIsClose )
+        insideTagsIsClose = isJumpTag(inlines, i, memo, prevHtmlTags)
+        //console.log('insideTagsIsClose: ' + insideTagsIsClose)
         if (insideTagsIsClose === -1) return n, nest, memo
         if (insideTagsIsClose === 0) { i++; continue }
       }
     }
+
+
     if (inlines[i].type !== '') { i++; continue }
 
     const emNum = Math.min(inlines[n].len, inlines[i].len)
@@ -329,7 +410,23 @@ const setEm = (inlines, marks, n, memo, sNest) => {
     //console.log('n: ' + n +  ' [em]: inlines[n].len: ' + inlines[n].len + ', i: ' + i,  ', inlines[i].len: ' + inlines[i].len + ', isEm: ' + memo.isEm)
     //console.log(marks)
 
-    if (memo.isEm && inlines[i].len === 2) {
+    let curlyProcess = false
+    if (opt.mditAttrs) {
+      const checkText = state.src.slice(inlines[i-1].sp, inlines[i-1].ep + 1)
+      if (/{[^{}\n!@#%^&*()]+?}$/.test(checkText)) {
+        curlyProcess = true
+      }
+    }
+    //if (memo.isEm && !curlyProcess && inlines[i].len === 2 && !memo.inlineMarkStart) {
+    const hasMarkersAtStartAndEnd = (i) => {
+      let flag =  memo.inlineMarkStart
+      if (!flag) return false
+      inlines.length - 1 === i ? flag = true : flag = false
+      if (!flag) return false
+      inlines[i].len > 1 ? flag = true : flag = false
+      return flag
+    }
+    if (memo.isEm && !curlyProcess && inlines[i].len === 2 && !hasMarkersAtStartAndEnd(i)) {
       strongPNum++
       i++
       continue
@@ -344,12 +441,12 @@ const setEm = (inlines, marks, n, memo, sNest) => {
     if (nest === -1) return n, nest, memo
 
     if (emNum === 1) {
-      //console.log(n, i, 'insideTagsIsClose: ' + insideTagsIsClose)
-      if (memo.html && !insideTagsIsClose && inlines[i].len !== 2) {
+      //console.log(n, i, 'insideTagsIsClose: ' + insideTagsIsClose, !insideTagsIsClose, inlines[i].len)
+      if (memo.html && inlines[i].len < 1) {
         i++; continue;
       }
-      //console.log('n: ' + n +  ' [em]: normal push, nest: ' + nest)
-      //console.log('strongPNum: ' + strongPNum)
+
+      //console.log('n: ' + n +  ' [em]: Normal push, nest: ' + nest, ', strongPNum: ' + strongPNum)
       //console.log(inlines[n].ep, inlines[n].sp, inlines[n].s)
 
       marksPush(marks, nest, inlines[n].ep, inlines[n].ep, 1, inlines[n].len - 1, 'em_open')
@@ -363,7 +460,6 @@ const setEm = (inlines, marks, n, memo, sNest) => {
         marksPush(marks, nest, inlines[i].ep, inlines[i].ep, 1, inlines[i].len - 1, 'em_close')
         inlines[i].sp = inlines[i].ep - 1
         inlines[i].ep -= 1
-
       }
       inlines[i].len -= 1
       //console.log(marks)
@@ -378,9 +474,7 @@ const setEm = (inlines, marks, n, memo, sNest) => {
 
 const setText = (inlines, marks, n, nest) => {
   //console.log('n: ' + n + ' [text]: inlines[n].len: ' + inlines[n].len)
-  //marksPush(marks, -1, inlines[n].sp + 1, inlines[n].ep, inlines[n].len, -1, 'text')
   marksPush(marks, nest, inlines[n].sp, inlines[n].ep, inlines[n].len, -1, 'text')
-  //inlines[n].sp +=  1
   inlines[n].len = 0
 }
 
@@ -430,7 +524,7 @@ const checkNest = (inlines, marks, n, i) => {
   return nest
 }
 
-const createMarks = (inlines, start, end, memo) => {
+const createMarks = (state, inlines, start, end, memo, opt) => {
   let marks = []
   let n = start
   while (n < end) {
@@ -438,11 +532,11 @@ const createMarks = (inlines, start, end, memo) => {
     memo.isEm = inlines[n].len === 1 ? true : false
     memo.wrapEm = 0
     let nest = 0
-    //console.log('n: ' + n +  ' ----- inlines.length: ' + inlines.length + ', memo.isEm: ' + memo.isEm)
+    //console.log('n: ' + n +  ' ----- inlines:: src: ' + state.src.slice(inlines[n].sp, inlines[n].ep + 1) + ', inlines[n].sp: ' + inlines[n].sp + ', inlines.length: ' + inlines.length + ', memo.isEm: ' + memo.isEm)
     if (!memo.isEm) {
-      n, nest, memo = setStrong(inlines, marks, n, memo)
+      n, nest, memo = setStrong(state, inlines, marks, n, memo, opt)
     }
-    n, nest, memo = setEm(inlines, marks, n, memo)
+    n, nest, memo = setEm(state, inlines, marks, n, memo, opt)
     if (inlines[n].len !== 0) setText(inlines, marks, n, nest)
     //console.log(marks)
     n++
@@ -482,21 +576,30 @@ const strongJa = (state, silent, opt) => {
   if (silent) return false
   const start = state.pos
   let max = state.posMax
-  const hasCurlyAttributes = state.md.core.ruler.__rules__.filter(rule => {
-    rule.name === 'curly_attributes' // markdown-it-attrs
-  })
   let attributesSrc
-  if (hasCurlyAttributes) {
-    attributesSrc = state.src.match(/( *){.*?}$/)
-    if (attributesSrc) {
+  if (start > max) return false
+  if (state.src.charCodeAt(start) !== 0x2A) return false
+  if (hasBackslash(state, start)) return false
+
+  if (opt.mditAttrs) {
+    attributesSrc = state.src.match(/((\n)? *){([^{}\n!@#%^&*()]+?)} *$/)
+    if (attributesSrc && attributesSrc[3] !== '.') {
       max = state.src.slice(0, attributesSrc.index).length
+      if (attributesSrc[2] === '\n') {
+        max = state.src.slice(0, attributesSrc.index - 1).length
+      }
+      if(hasBackslash(state, attributesSrc.index) && attributesSrc[2] === '' && attributesSrc[1].length === 0) {
+        max = state.posMax
+      }
+    } else {
+      let endCurlyKet = state.src.match(/(\n *){([^{}\n!@#%^&*()]*?)}.*(} *?)$/)
+      if (endCurlyKet) {
+        max -= endCurlyKet[3].length
+      }
     }
   }
-  if (start > max) return false
-  if (state.src.charCodeAt(start) !== 0x2A) return false
 
-  if (hasBackslash(state, start)) return false
-  //console.log('state.src.length: ' + state.src.length + ', start: ' + start +  ', state.src: ' + state.src)
+  //console.log('state.src.length(max): ' + state.src.length + (state.src.length === max ? '' : '(' + max + ')') + ', start: ' + start +  ', state.src: ' + state.src)
   let inlines = createInlines(state, start, max, opt)
   //console.log('inlines: ')
   //console.log(inlines)
@@ -510,7 +613,8 @@ const strongJa = (state, silent, opt) => {
     inlineMarkStart: state.src.charCodeAt(0) === 0x2A ? true : false,
     inlineMarkEnd: state.src.charCodeAt(max - 1) === 0x2A ? true : false,
   }
-  let marks = createMarks(inlines, 0, inlines.length, memo)
+
+  let marks = createMarks(state, inlines, 0, inlines.length, memo, opt)
   //console.log('marks: ')
   //console.log(marks)
 
@@ -518,10 +622,16 @@ const strongJa = (state, silent, opt) => {
   //console.log('fix inlines:')
   //console.log(inlines)
 
-  setToken(state, inlines)
+  setToken(state, inlines, opt)
+
+  //console.log ('End process:: max:' + max + ', state.posMax: ' + state.posMax + ', opt.mditAttrs: ' + opt.mditAttrs)
 
-  if (attributesSrc) {
-    //console.log('attributesSrc[1].length: ' + attributesSrc[1].length)
+  if (opt.mditAttrs && max !== state.posMax) {
+    if (!attributesSrc) {
+      state.pos = max
+      return true
+    }
+   //console.log('start: ' + start + ', attributesSrc[0]::' + attributesSrc[0] + ', attributesSrc[1].length: ' + attributesSrc[1].length)
     if (attributesSrc[1].length > 1) {
       state.pos = max + attributesSrc[1].length
     } else {
@@ -530,12 +640,14 @@ const strongJa = (state, silent, opt) => {
   } else {
     state.pos = max + 1
   }
+  //console.log(state.tokens)
   return true
 }
 
 const mditStrongJa = (md, option) => {
   const opt = {
-    dollarMath: true,
+    dollarMath: true, //inline math $...$
+    mditAttrs: true, //markdown-it-attrs
   }
   if (option !== undefined) {
     for (let o in option) {

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.3.4",
+  "version": "0.3.6",
   "main": "index.js",
   "type": "module",
   "scripts": {
@@ -11,6 +11,7 @@
   "author": "peaceroad <peaceroad@gmail.com>",
   "license": "MIT",
   "devDependencies": {
+    "@sup39/markdown-it-cjk-breaks": "^1.2.0",
     "markdown-it": "^14.1.0",
     "markdown-it-attrs": "^4.2.0"
   }

package/test/example-complex.txt

@@ -85,11 +85,10 @@ HTMLは**「*HyperText* Markup *Language*」**の略です。
 [HTML]
 <p><em>a<strong>b</strong>c<strong>d</strong>e</em></p>
 
-
 [Markdown]
 *aa**
-[HTML commomark: <p><em>aa</em>*</p>]
-<p>*aa**</p>
+[HTML]
+<p><em>aa</em>*</p>
 
 [Markdown]
 a*aa**
@@ -185,13 +184,12 @@ a**b**c  {.style}
 [HTML]
 <p class="style">a<strong>b</strong>c</p>
 
-
 [Markdown]
 z*a<span>b*c</span>d*e
 [HTML]
 <p>z<em>a&lt;span&gt;b</em>c&lt;/span&gt;d*e</p>
 [HTML:true]
-<p>z<em>a<span>b*c</span>d</em>e</p>
+<p>z<em>a<span>b</em>c</span>d*e</p>
 
 [Markdown]
 a<span>b*c</span>d*e*f
@@ -218,9 +216,8 @@ aa<span>b*ef*</span>cc
 a*a<span>b*ef*</span>c*c
 [HTML:false]
 <p>a<em>a&lt;span&gt;b</em>ef<em>&lt;/span&gt;c</em>c</p>
-[HTML:true, commonmark: <p>a<em>a<span>b</em>ef*</span>c*c</p>]
-<p>a<em>a<span>b<em>ef</em></span>c</em>c</p>
-
+[HTML:true]
+<p>a<em>a<span>b</em>ef*</span>c*c</p>
 
 [Markdown]
 a***a<span>b</span>c***c
@@ -235,7 +232,7 @@ a***a<span>b***e</span>cc
 [HTML:false]
 <p>a<em><strong>a&lt;span&gt;b</strong></em>e&lt;/span&gt;cc</p>
 [HTML:true]
-<p>a***a<span>b***e</span>cc</p>
+<p>a<em><strong>a<span>b</strong></em>e</span>cc</p>
 
 [Markdown]
 aa<span>b*e<s>f</s>*</span>cc
@@ -336,3 +333,31 @@ b<span>c</span>*
 <p>*<em><em><span>a</span></em>b</em></p>
 
 
+[Markdown]
+*`a`*
+[HTML]
+<p><em><code>a</code></em></p>
+
+[Markdown]
+**z`a`b**
+[HTML]
+<p><strong>z<code>a</code>b</strong></p>
+
+[Markdown]
+**`a`
+[HTML]
+<p>**<code>a</code></p>
+
+[Markdown]
+**<b>a</b>**
+[HTML:false]
+<p><strong>&lt;b&gt;a&lt;/b&gt;</strong></p>
+[HTML:true]
+<p><strong><b>a</b></strong></p>
+
+[Markdown]
+**<br>
+[HTML:false]
+<p>**&lt;br&gt;</p>
+[HTML:true]
+<p>**<br></p>