@peaceroad/markdown-it-strong-ja 0.3.1 → 0.3.3

package/index.js

@@ -1,4 +1,4 @@
-const hasSlashFlag = (state, start) => {
+const hasBackslash = (state, start) => {
   let slashNum = 0
   let i = start - 1
   while(i >= 0) {
@@ -12,7 +12,7 @@ const hasSlashFlag = (state, start) => {
 const setToken = (state, inlines) => {
   let i = 0
   while (i < inlines.length) {
-    const type = inlines[i].type
+    let type = inlines[i].type
     const tag = type.replace(/(?:_open|_close)$/, '')
 
     if (/_open$/.test(type)) {
@@ -20,20 +20,26 @@ const setToken = (state, inlines) => {
       startToken.markup = tag === 'strong' ? '**' : '*'
     }
 
+    if (type === 'html_inline') {
+      type = 'text'
+    }
     if (type === 'text') {
       const content = state.src.slice(inlines[i].s, inlines[i].e + 1)
       if (/^\**$/.test(content)) {
         //console.log('asterisk process::')
         const asteriskToken = state.push(type, '', 0)
         asteriskToken.content = content
-        //console.log('asteriskToken: ' + asteriskToken.content)
         i++
         continue
       }
+
       const childTokens = state.md.parseInline(content, state.env)
       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)
           const token = state.push(t.type, t.tag, t.nesting)
           token.attrs = t.attrs
           token.map = t.map
@@ -58,52 +64,113 @@ const setToken = (state, inlines) => {
   }
 }
 
-const inlinesPush = (inlines, s, e, len, type) => {
-  inlines.push({
+const inlinesPush = (inlines, s, e, len, type, tag, tagType) => {
+  const inline = {
     s: s,
     sp: s,
     e: e,
     ep: e,
     len: len,
     type: type,
-  })
+  }
+  if (tag) inline.tag = [tag, tagType]
+  inlines.push(inline)
+}
+
+const hasNextSymbol = (state, n, max, symbol, noMark) => {
+  let nextSymbolPos = -1
+  if (state.src.charCodeAt(n) === symbol && !hasBackslash(state, n)) {
+    let i = n + 1
+    let tempNoMark = noMark
+    while (i < max) {
+      tempNoMark += state.src[i]
+      if (state.src.charCodeAt(i) === symbol && !hasBackslash(state, i)) {
+        noMark += state.src[n]
+        nextSymbolPos = i
+        break
+      }
+      i++
+    }
+  }
+  return nextSymbolPos
 }
 
-const crateInlines = (state, start, max) => {
+const createInlines = (state, start, max, opt) => {
   let n = start
   let inlines = []
   let noMark = ''
-  let mark = ''
-  let beforeIsMark = true
+  let isInStartMark = true
+  let textStart = n
+
   while (n < max) {
-    if (state.src.charCodeAt(n) === 0x2A) {
-      if (hasSlashFlag(state, n)) {
-        beforeIsMark = false
-        noMark += state.src[n]
-        if (n === max - 1) {
-          inlinesPush(inlines, n - noMark.length + 1, n, noMark.length, 'text')
+    let nextSymbolPos = hasNextSymbol(state, n, max, 0x60, noMark)  // '`'
+    if (nextSymbolPos !== -1) {
+      n = nextSymbolPos + 1
+      continue
+    }
+    if (opt.dollarMath) {
+      nextSymbolPos = hasNextSymbol(state, n, max, 0x24, noMark)  // '$'
+      if (nextSymbolPos !== -1) {
+        n = nextSymbolPos + 1
+        continue
+      }
+    }
+
+    if (state.md.options.html) {
+      if (state.src.charCodeAt(n) === 0x3C && !hasBackslash(state, n)) { // '<'
+        let i = n + 1
+        while (i < max) {
+          if (state.src.charCodeAt(i) === 0x3E && !hasBackslash(state, i)) { // '>'
+            if (noMark.length !== 0) {
+              inlinesPush(inlines, textStart, n - 1, n - textStart, 'text')
+            }
+            let tag = state.src.slice(n + 1, i)
+            let tagType = ''
+            if (/^\//.test(tag)) {
+              tag = tag.slice(1)
+              tagType = 'close'
+            } else {
+              tagType = 'open'
+            }
+            inlinesPush(inlines, n, i, i - n + 1, 'html_inline', tag, tagType)
+            textStart = i + 1
+            break
+          }
+          i++
         }
-        n++
+        n = i + 1
         continue
       }
-      beforeIsMark = true
-      mark += '*'
-      if (n !== start && noMark !== '') {
-        inlinesPush(inlines, n - noMark.length, n - 1, noMark.length, 'text')
+    }
+
+    if (state.src.charCodeAt(n) === 0x2A && !hasBackslash(state, n)) { // '*'
+      if (!isInStartMark) {
+        inlinesPush(inlines, textStart, n - 1, n - textStart, 'text')
       }
-      noMark = ''
       if (n === max - 1) {
-        inlinesPush(inlines, n - mark.length + 1, n, mark.length, '')
+        inlinesPush(inlines, n,  n, 1 , '')
+        break
       }
-    } else {
-      noMark += state.src[n]
-      if (state.src[n-1] === '*' && beforeIsMark) {
-        inlinesPush(inlines, n - mark.length, n - 1, mark.length, '')
-        mark = ''
-      }
-      if (n === max - 1) {
-        inlinesPush(inlines, n - noMark.length + 1, n, noMark.length, 'text')
+      let i = n + 1
+      while (i < max) {
+        if (state.src.charCodeAt(i) === 0x2A) {
+          if (i === max - 1) inlinesPush(inlines, n,  i, i - n + 1 , '')
+          i++
+          continue
+        }
+        inlinesPush(inlines, n,  i - 1, i - n, '')
+        textStart = i
+        break
       }
+      n = i
+      continue
+    }
+    isInStartMark = false
+    noMark += state.src[n]
+    //console.log('noMark: ' + noMark)
+    if (n === max - 1 || max < 3) {
+      inlinesPush(inlines, textStart, n, n - textStart + 1, 'text')
+      break
     }
     n++
   }
@@ -121,7 +188,6 @@ const marksPush = (marks, nest, s, e, len, outsideLen, type) => {
     oLen: outsideLen,
     type: type,
   }
-  //let i = marks.findIndex(o => o.s > s)
   let i = marks.findIndex(o => o.s > s)
   if (i === -1) {
     marks.push(np)
@@ -131,17 +197,27 @@ const marksPush = (marks, nest, s, e, len, outsideLen, type) => {
 }
 
 const setStrong = (inlines, marks, n, memo) => {
-  let i = n + 2
+  let i = n + 1
   let j = 0
   let nest = 0
+  let insideTagsIsClose = 1
   while (i < inlines.length) {
-    if (inlines[i].len === 0) { i += 2; continue }
+    if (inlines[i].len === 0) { i++; continue }
+    if (memo.html) {
+      if (inlines[i].type === 'html_inline') {
+        insideTagsIsClose = isJumpTag(inlines, i, memo)
+        //console.log('insideTagsIsClose: ' + insideTagsIsClose )
+        if (insideTagsIsClose === -1) return n, nest, memo
+        if (insideTagsIsClose === 0) { i++; continue }
+      }
+    }
+    if (inlines[i].type !== '') { i++; continue }
+
     //console.log('n: ' + n +  ' [strong]: inlines[n].len: ' + inlines[n].len + ', i: ' + i + ', inlines[i].len: ' + inlines[i].len)
 
     nest = checkNest(inlines, marks, n, i)
     //console.log('n: ' + n +  ' [strong]: nest: ' + nest)
     if (nest === -1) return n, nest, memo
-
     if (inlines[i].len === 1 && inlines[n].len > 2) {
       //console.log('n: ' + n +  ' [strong]: check em inside strong: ' + nest)
       marksPush(marks, nest, inlines[n].ep, inlines[n].ep, 1, inlines[n].len - 1, 'em_open')
@@ -150,17 +226,21 @@ const setStrong = (inlines, marks, n, memo) => {
       inlines[n].ep -= 1
       inlines[i].len = 0
       inlines[i].sp += 1
-      if (i + 2 < inlines.length) {
-        i += 2
+      if (i++ < inlines.length) {
+        i++
         nest++
       } else {
         return n, nest, memo
       }
-      //console.log(marks)
-      //console.log('n: ' + n +  ' [strong]: check em inside strong end.')
+      if (i > inlines.length - 1) return n, nest, memo
     }
 
+    if (memo.html && !insideTagsIsClose && inlines[i].len !== 1) {
+      memo.htmlTags = {}
+      return n, nest, memo
+    }
     let strongNum = Math.trunc(Math.min(inlines[n].len, inlines[i].len) / 2)
+
     if (inlines[i].len > 1) {
       //console.log('n: ' + n +  ' [strong]: normal push, nest: ' + nest)
       j = 0
@@ -175,16 +255,15 @@ const setStrong = (inlines, marks, n, memo) => {
         //console.log(marks)
         j++
       }
-
       if (inlines[n].len === 0) return n, nest, memo
     }
 
     if (inlines[n].len === 1) {
-      //console.log('check em that warp strong: ')
+      //console.log('check em that warp strong.')
       nest++
-      n, nest, memo= setEm(inlines, marks, n, memo, nest)
+      n, nest, memo = setEm(inlines, marks, n, memo, nest)
       if (memo.hasEmThatWrapStrong) {
-        //console.log('fix strong wrapped em:')
+        //console.log('set em that wrap strong.')
         let k = 0
         while (k < strongNum) {
             marks[marks.length - 2 - k * 2 - 1].nest += 1
@@ -193,19 +272,57 @@ const setStrong = (inlines, marks, n, memo) => {
         }
       }
     }
-
     if (inlines[n].len === 0) return n, nest, memo
-    i += 2
+    i++
   }
   return n, nest, memo
 }
 
+const isJumpTag = (inlines, n, memo) => {
+  //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
+  }
+   //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
+  //memo.htmlTags = {}
+  return 0
+}
+
 const setEm = (inlines, marks, n, memo, sNest) => {
-  let i = n + 2
+  let i = n + 1
   let nest = 0
   let strongPNum = 0
+  let insideTagsIsClose = 1
   while (i < inlines.length) {
-    if (inlines[i].len === 0) { i += 2; continue }
+    if (inlines[i].len === 0) { i++; continue }
+    if (memo.isEm && memo.html) {
+      if (inlines[i].type === 'html_inline') {
+        insideTagsIsClose = isJumpTag(inlines, i, memo)
+        //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)
     if (memo.isEm && emNum !== 1) return n, sNest, memo
     //console.log('n: ' + n +  ' [em]: inlines[n].len: ' + inlines[n].len + ', i: ' + i,  ', inlines[i].len: ' + inlines[i].len + ', isEm: ' + memo.isEm)
@@ -213,7 +330,7 @@ const setEm = (inlines, marks, n, memo, sNest) => {
 
     if (memo.isEm && inlines[i].len === 2) {
       strongPNum++
-      i += 2
+      i++
       continue
     }
 
@@ -226,6 +343,11 @@ 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) {
+        memo.htmlTags = {}
+        return n, nest, memo
+      }
       //console.log('n: ' + n +  ' [em]: normal push, nest: ' + nest)
       //console.log('strongPNum: ' + strongPNum)
       //console.log(inlines[n].ep, inlines[n].sp, inlines[n].s)
@@ -249,9 +371,8 @@ const setEm = (inlines, marks, n, memo, sNest) => {
       if (inlines[n].len === 0) return n, nest, memo
     }
 
-    i += 2
+    i++
   }
-
   return n, nest, memo
 }
 
@@ -302,90 +423,125 @@ const checkNest = (inlines, marks, n, i) => {
   return nest
 }
 
-const createMarks = (inlines, inlinesStart, inlinesEnd, memo) => {
+const createMarks = (inlines, start, end, memo) => {
   let marks = []
-  let n = inlinesStart
-  while (n < inlinesEnd) {
-    if (inlines[n].type !== '') { n += 2; continue }
-    if (inlines[n].len === 0) { n += 2; continue }
-    memo.isEm =  inlines[n].len === 1 ? true : false
+  let n = start
+  while (n < end) {
+    if (inlines[n].type !== '' || inlines[n].len === 0) { n++; continue }
+    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.length: ' + inlines.length + ', memo.isEm: ' + memo.isEm)
     if (!memo.isEm) {
       n, nest, memo = setStrong(inlines, marks, n, memo)
     }
     n, nest, memo = setEm(inlines, marks, n, memo)
 
     if (inlines[n].len !== 0) setText(inlines, marks, n, nest)
-    n += 2
+    n++
   }
   return marks
 }
 
-const strongJa = (state, silent) => {
-  const max = state.posMax
-  const start = state.pos
-  if (silent) return false
-  if (start > max) return false
-  if (state.src.charCodeAt(start) !== 0x2A) return false
-  if (hasSlashFlag(state, start)) return false
-  //console.log('state.src.length: ' + state.src.length + ', start: ' + start +  ', state.src: ' + state.src)
-  let inlines = crateInlines(state, start, max)
-  //console.log('inlines: ')
-  //console.log(inlines)
-
-  const memo = {
-    isEm: false,
-    hasEmThatWrapStrong: false,
-    noSetStrongEnd: false,
-    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)
-  //console.log('marks: ')
-  //console.log(marks)
-
+const fixInlines = (inlines, marks) => {
   let n = 0
   while (n < inlines.length) {
     if (inlines[n].type !== '') { n++; continue }
     let i = 0
     //console.log('n: ' + n + ', inlines[n].s: ' + inlines[n].s + ', inlines[n].e: ' + inlines[n].e)
-    let c = 0
     while (i < marks.length) {
-      //console.log(marks[i].s, inlines[n].e, marks[i].e, inlines[n].e)
+      //console.log(marks[i].type, marks[i].s, inlines[n].e, marks[i].e, inlines[n].e)
       //console.log(marks[i].s >= inlines[n].s ,  marks[i].e <= inlines[n].e)
       if (marks[i].s >= inlines[n].s && marks[i].e <= inlines[n].e) {
         //console.log('n: ' + n + ', i: ' + i + ', marks[i].type: ' + marks[i].type)
         inlines.splice(n + i + 1, 0, marks[i])
-        c++
         i++
         continue
       }
       break
     }
     if (marks.length) {
-      marks.splice(0, c)
+      marks.splice(0, i)
       inlines.splice(n, 1)
-      n += c
+      n += i
     } else {
-      inlines[n].type = 'text'
+      //if (inlines[n].type === '') inlines[n].type = 'text'
       n++
     }
   }
+}
+
+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) {
+      max = state.src.slice(0, attributesSrc.index).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)
+  let inlines = createInlines(state, start, max, opt)
+  //console.log('inlines: ')
+  //console.log(inlines)
+
+  const memo = {
+    isEm: false,
+    hasEmThatWrapStrong: false,
+    noSetStrongEnd: false,
+    html: state.md.options.html,
+    htmlTags: {},
+    inlineMarkStart: state.src.charCodeAt(0) === 0x2A ? true : false,
+    inlineMarkEnd: state.src.charCodeAt(max - 1) === 0x2A ? true : false,
+  }
+  /*
+  if (memo.html) {
+    let beforeInlines = createInlines(state, 0, start - 1, opt)
+    isJumpTag(beforeInlines, beforeInlines.length - 1, memo)
+  }*/
+  let marks = createMarks(inlines, 0, inlines.length, memo)
+  //console.log('marks: ')
+  //console.log(marks)
 
+  fixInlines(inlines, marks)
   //console.log('fix inlines:')
   //console.log(inlines)
+
   setToken(state, inlines)
 
-  //console.log('state.pos: ' + state.pos + ', inlines[inlines.length - 1].e + 1: ' + (inlines[inlines.length - 1].e + 1) + ', max: ' + max)
-  state.pos = max + 1
+  if (attributesSrc) {
+    //console.log('attributesSrc[1].length: ' + attributesSrc[1].length)
+    if (attributesSrc[1].length > 1) {
+      state.pos = max + attributesSrc[1].length
+    } else {
+      state.pos = max
+    }
+  } else {
+    state.pos = max + 1
+  }
   return true
 }
 
-const mditStrongJa = (md) => {
+const mditStrongJa = (md, option) => {
+  const opt = {
+    dollarMath: true,
+  }
+  if (option !== undefined) {
+    for (let o in option) {
+        opt[o] = option[o]
+    }
+  }
   md.inline.ruler.before('emphasis', 'strong_ja', (state, silent) => {
-    return strongJa(state, silent)
+    return strongJa(state, silent, opt)
   })
 }
 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.3.1",
+  "version": "0.3.3",
   "main": "index.js",
   "type": "module",
   "scripts": {
@@ -11,6 +11,7 @@
   "author": "peaceroad <peaceroad@gmail.com>",
   "license": "MIT",
   "devDependencies": {
-    "markdown-it": "^14.1.0"
+    "markdown-it": "^14.1.0",
+    "markdown-it-attrs": "^4.2.0"
   }
 }

package/test/example-complex.txt

@@ -139,3 +139,122 @@ a[*](https://example.com)*b
 a[*](https://example*.com)*b*
 [HTML]
 <p>a<a href="https://example*.com">*</a><em>b</em></p>
+
+[Markdown]
+**重要な文・文節や語句**は`**`を使って囲みます。*文脈上強調する語句*は`*`を使って囲みます。
+[HTML]
+<p><strong>重要な文・文節や語句</strong>は<code>**</code>を使って囲みます。<em>文脈上強調する語句</em>は<code>*</code>を使って囲みます。</p>
+
+[Markdown]
+インラインコードは`*`と`*`で*囲みます*。
+[HTML]
+<p>インラインコードは<code>*</code>と<code>*</code>で<em>囲みます</em>。</p>
+
+[Markdown]
+[node_modules/*](#)の*はすべてを意味します。
+[HTML]
+<p><a href="#">node_modules/*</a>の*はすべてを意味します。</p>
+
+[Markdown]
+**test** {.style}
+[HTML]
+<p class="style"><strong>test</strong></p>
+
+[Markdown]
+a**test**b {.style}
+[HTML]
+<p class="style">a<strong>test</strong>b</p>
+
+[Markdown]
+z*a**test**{.style}b*c*d
+[HTML]
+<p>z<em>a<strong class="style">test</strong>b</em>c*d</p>
+
+[Markdown]
+a**b**c{.style}
+[HTML]
+<p class="style">a<strong>b</strong>c</p>
+
+[Markdown]
+a**b**{.style}
+[HTML]
+<p>a<strong class="style">b</strong></p>
+
+[Markdown]
+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*a<span>b*c</span>d*e</p>
+
+[Markdown]
+a<span>b*c</span>d*e*f
+[HTML]
+<p>a&lt;span&gt;b<em>c&lt;/span&gt;d</em>e*f</p>
+[HTML:true]
+<p>a<span>b*c</span>d<em>e</em>f</p>
+
+[Markdown]
+a*a<span>b</span>c*c
+[HTML:false]
+<p>a<em>a&lt;span&gt;b&lt;/span&gt;c</em>c</p>
+[HTML:true]
+<p>a<em>a<span>b</span>c</em>c</p>
+
+[Markdown]
+aa<span>b*ef*</span>cc
+[HTML:false]
+<p>aa&lt;span&gt;b<em>ef</em>&lt;/span&gt;cc</p>
+[HTML:true]
+<p>aa<span>b<em>ef</em></span>cc</p>
+
+[Markdown]
+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>
+
+
+[Markdown]
+a***a<span>b</span>c***c
+[HTML:false]
+<p>a<em><strong>a&lt;span&gt;b&lt;/span&gt;c</strong></em>c</p>
+[HTML:true]
+<p>a<em><strong>a<span>b</span>c</strong></em>c</p>
+
+
+[Markdown]
+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>
+
+[Markdown]
+aa<span>b*e<s>f</s>*</span>cc
+[HTML:false]
+<p>aa&lt;span&gt;b<em>e&lt;s&gt;f&lt;/s&gt;</em>&lt;/span&gt;cc</p>
+[HTML:true]
+<p>aa<span>b<em>e<s>f</s></em></span>cc</p>
+
+[Markdown]
+**aa<span>b*e<s>f</s>*</span>cc**
+[HTML:false]
+<p><strong>aa&lt;span&gt;b<em>e&lt;s&gt;f&lt;/s&gt;</em>&lt;/span&gt;cc</strong></p>
+[HTML:true]
+<p><strong>aa<span>b<em>e<s>f</s></em></span>cc</strong></p>
+
+
+[Markdown]
+*aa<span>b**e<s>f</s>**</span>cc*
+[HTML:false]
+<p><em>aa&lt;span&gt;b<strong>e&lt;s&gt;f&lt;/s&gt;</strong>&lt;/span&gt;cc</em></p>
+[HTML:true]
+<p><em>aa<span>b<strong>e<s>f</s></strong></span>cc</em></p>

package/test/example-strong.txt

@@ -21,8 +21,7 @@ HTMLは**「HyperText *Markup* `Language`」**の略です。
 [HTML]
 <p>HTMLは<strong>「HyperText <em>Markup</em> <code>Language</code>」</strong>の略です。</p>
 
-
-[Markdown]
+[Markdown: 5]
 HTMLは**「HyperText Mark
 
 up Language」**の略です。

package/test/test.js

@@ -4,16 +4,18 @@ import path from 'path'
 import url from 'url'
 
 import mdit from 'markdown-it'
+import mditAttrs from 'markdown-it-attrs'
 import mditStrongJa from '../index.js'
 
 const __dirname = path.dirname(url.fileURLToPath(import.meta.url)).replace(/\\/g, '/')
 
 const check = (ms, example) => {
-  const md = mdit().use(mditStrongJa)
-  const mdWithHtml = mdit({html: true}).use(mditStrongJa)
+  const md = mdit().use(mditStrongJa).use(mditAttrs)
+  const mdWithHtml = mdit({html: true}).use(mditStrongJa).use(mditAttrs)
   let n = 1
   while (n < ms.length) {
-   //if (n != 1 ) { n++; continue }
+    //if (n !== 43 ) { n++; continue }
+    //if (n !== 36 ) { n++; continue }
     const m = ms[n].markdown
     console.log('Test [' + n + ', HTML: false] >>>')
     const h = md.render(m)
@@ -22,7 +24,6 @@ const check = (ms, example) => {
     } catch(e) {
       console.log('Input: ' + ms[n].markdown + '\nConvert: ' + h + 'Correct: ' + ms[n].html)
     }
-
     if (ms[n].htmlWithHtmlTrue) {
       console.log('Test [' + n + ', HTML: true] >>>')
       const hh = mdWithHtml.render(m)