@peaceroad/markdown-it-strong-ja 0.3.5 → 0.4.0

package/index.js

@@ -1,45 +1,98 @@
+const REG_ASTERISKS = /^\*+$/
+const REG_ATTRS = /{[^{}\n!@#%^&*()]+?}$/
+const REG_PUNCTUATION = /[!-/:-@[-`{-~ ]/
+
 const hasBackslash = (state, start) => {
   let slashNum = 0
   let i = start - 1
+  const src = state.src
   while(i >= 0) {
-    /// if (state.src.charCodeAt(i) === 0x2A) { i--; continue }
-    if (state.src.charCodeAt(i) === 0x5C) { slashNum++; i--; continue }
+    if (src.charCodeAt(i) === 0x5C) { slashNum++; i--; continue }
     break
   }
-  return slashNum % 2 === 1 ? true : false
+  return slashNum % 2 === 1
 }
 
-const setToken = (state, inlines) => {
+const setToken = (state, inlines, opt) => {
+  const src = state.src
   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 = src.slice(inlines[i].s, inlines[i].e + 1)
+      //console.log('content: ' + content)
+      if (REG_ASTERISKS.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 && REG_ATTRS.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,20 +104,25 @@ 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++
   }
 }
 
-const inlinesPush = (inlines, s, e, len, type, tag, tagType) => {
+const pushInlines = (inlines, s, e, len, type, tag, tagType) => {
   const inline = {
     s: s,
     sp: s,
@@ -72,6 +130,7 @@ const inlinesPush = (inlines, s, e, len, type, tag, tagType) => {
     ep: e,
     len: len,
     type: type,
+    check: type === 'text' ? true : false,
   }
   if (tag) inline.tag = [tag, tagType]
   inlines.push(inline)
@@ -79,13 +138,14 @@ const inlinesPush = (inlines, s, e, len, type, tag, tagType) => {
 
 const hasNextSymbol = (state, n, max, symbol, noMark) => {
   let nextSymbolPos = -1
-  if (state.src.charCodeAt(n) === symbol && !hasBackslash(state, n)) {
+  const src = state.src
+  if (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.substring(n, i + 1)
+      tempNoMark += src[i]
+      if (src.charCodeAt(i) === symbol && !hasBackslash(state, i)) {
+        noMark += src.substring(n, i + 1)
         nextSymbolPos = i
         break
       }
@@ -96,26 +156,29 @@ const hasNextSymbol = (state, n, max, symbol, noMark) => {
 }
 
 const createInlines = (state, start, max, opt) => {
+  const src = state.src
+  const srcLen = max;
   let n = start
   let inlines = []
   let noMark = ''
   let textStart = n
-  while (n < max) {
+  while (n < srcLen) {
+    //console.log('n: ' + n + ', state.src[n]: ' + state.src[n] + ', noMark: ' + noMark)
     let nextSymbolPos = -1;
-    [nextSymbolPos, noMark] = hasNextSymbol(state, n, max, 0x60, noMark)  // '`'
+    [nextSymbolPos, noMark] = hasNextSymbol(state, n, srcLen, 0x60, noMark)  // '`'
     if (nextSymbolPos !== -1) {
-      if (nextSymbolPos === max - 1) {
-        inlinesPush(inlines, textStart, nextSymbolPos, nextSymbolPos - textStart + 1, 'text')
+      if (nextSymbolPos === srcLen - 1) {
+        pushInlines(inlines, textStart, nextSymbolPos, nextSymbolPos - textStart + 1, 'text')
         break
       }
       n = nextSymbolPos + 1
       continue
     }
     if (opt.dollarMath) {
-      [nextSymbolPos, noMark] = hasNextSymbol(state, n, max, 0x24, noMark)  // '$'
+      [nextSymbolPos, noMark] = hasNextSymbol(state, n, srcLen, 0x24, noMark)  // '$'
       if (nextSymbolPos !== -1) {
-        if (nextSymbolPos === max - 1) {
-          inlinesPush(inlines, textStart, nextSymbolPos, nextSymbolPos - textStart + 1, 'text')
+        if (nextSymbolPos === srcLen - 1) {
+          pushInlines(inlines, textStart, nextSymbolPos, nextSymbolPos - textStart + 1, 'text')
           break
         }
         n = nextSymbolPos + 1
@@ -124,14 +187,15 @@ const createInlines = (state, start, max, opt) => {
     }
 
     if (state.md.options.html) {
-      if (state.src.charCodeAt(n) === 0x3C && !hasBackslash(state, n)) { // '<'
+      if (src.charCodeAt(n) === 0x3C && !hasBackslash(state, n)) { // '<'
         let i = n + 1
-        while (i < max) {
-          if (state.src.charCodeAt(i) === 0x3E && !hasBackslash(state, i)) { // '>'
+        while (i < srcLen) {
+          if (src.charCodeAt(i) === 0x3E && !hasBackslash(state, i)) { // '>'
             if (noMark.length !== 0) {
-              inlinesPush(inlines, textStart, n - 1, n - textStart, 'text')
+              pushInlines(inlines, textStart, n - 1, n - textStart, 'text')
+              noMark = ''
             }
-            let tag = state.src.slice(n + 1, i)
+            let tag = src.slice(n + 1, i)
             let tagType = ''
             if (/^\//.test(tag)) {
               tag = tag.slice(1)
@@ -139,7 +203,7 @@ const createInlines = (state, start, max, opt) => {
             } else {
               tagType = 'open'
             }
-            inlinesPush(inlines, n, i, i - n + 1, 'html_inline', tag, tagType)
+            pushInlines(inlines, n, i, i - n + 1, 'html_inline', tag, tagType)
             textStart = i + 1
             break
           }
@@ -149,31 +213,34 @@ const createInlines = (state, start, max, opt) => {
         continue
       }
     }
-    if (state.src.charCodeAt(n) === 0x2A && !hasBackslash(state, n)) { // '*'
-      if (n !== 0) {
-        inlinesPush(inlines, textStart, n - 1, n - textStart, 'text')
+
+    if (src.charCodeAt(n) === 0x2A && !hasBackslash(state, n)) { // '*'
+      if (n !== 0 && noMark.length !== 0) {
+        pushInlines(inlines, textStart, n - 1, n - textStart, 'text')
+        noMark = ''
       }
-      if (n === max - 1) {
-        inlinesPush(inlines, n,  n, 1 , '')
+      if (n === srcLen - 1) {
+        pushInlines(inlines, n,  n, 1 , '')
         break
       }
       let i = n + 1
-      while (i < max) {
-        if (state.src.charCodeAt(i) === 0x2A) {
-          if (i === max - 1) inlinesPush(inlines, n,  i, i - n + 1 , '')
+      while (i < srcLen) {
+        if (src.charCodeAt(i) === 0x2A) {
+          if (i === srcLen - 1) pushInlines(inlines, n,  i, i - n + 1 , '')
           i++
           continue
         }
-        inlinesPush(inlines, n,  i - 1, i - n, '')
+        pushInlines(inlines, n,  i - 1, i - n, '')
         textStart = i
         break
       }
       n = i
       continue
     }
-    noMark += state.src[n]
-    if (n === max - 1) {
-      inlinesPush(inlines, textStart, n, n - textStart + 1, 'text')
+
+    noMark += src[n]
+    if (n === srcLen - 1) {
+      pushInlines(inlines, textStart, n, n - textStart + 1, 'text')
       break
     }
     n++
@@ -181,159 +248,214 @@ const createInlines = (state, start, max, opt) => {
   return inlines
 }
 
-const marksPush = (marks, nest, s, e, len, outsideLen, type) => {
-  //console.log('before marks:')
-  //console.log(marks)
-  const np = {
-    nest: nest,
-    s: s,
-    e: e,
-    len: len,
-    oLen: outsideLen,
-    type: type,
-  }
-  let i = marks.findIndex(o => o.s > s)
-  if (i === -1) {
-    marks.push(np)
-  } else {
-    marks.splice(i, 0, np)
+const pushMark = (marks, opts) => {
+  //binary search
+  let left = 0, right = marks.length
+  while (left < right) {
+    const mid = (left + right) >> 1
+    if (marks[mid].s > opts.s) {
+      right = mid
+    } else {
+      left = mid + 1
+    }
   }
+  marks.splice(left, 0, { ...opts });
 }
 
-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 insideTagsIsClose = 1 // 1: closed, 0: open still, -1: error
   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)
-        //console.log('insideTagsIsClose: ' + insideTagsIsClose )
-        if (insideTagsIsClose === -1) return n, nest, memo
-        if (insideTagsIsClose === 0) { i++; continue }
-      }
+   //console.log('[strong] i: ' + i + ', inlines[i].len: ' + inlines[i].len + ', inlines[i].type: ' + inlines[i].type)
+    if (inlines[i].len === 0 || inlines[i].check) { i++; continue }
+    if (inlines[i].type === 'html_inline') {
+      inlines[i].check = true
+      insideTagsIsClose = checkInsideTags(inlines, i, memo)
+      //console.log('    nest: ' + nest + ', insideTagsIsClose: ' + insideTagsIsClose )
+      if (insideTagsIsClose === -1) return n, nest
+      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
+    //console.log('    check nest: ' + nest)
+    if (nest === -1) return n, nest
+
     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')
-      marksPush(marks, nest, inlines[i].sp, inlines[i].ep, 1, inlines[i].len - 1, 'em_close')
+     //console.log('    check em inside strong:: i: ' + i)
+      pushMark(marks, {
+        nest: nest,
+        s: inlines[n].ep,
+        e: inlines[n].ep,
+        len: 1,
+        oLen: inlines[n].len - 1,
+        type: 'em_open'
+      })
+      pushMark(marks, {
+        nest: nest,
+        s: inlines[i].sp,
+        e: inlines[i].ep,
+        len: 1,
+        oLen: inlines[i].len - 1,
+        type: 'em_close'
+      })
       inlines[n].len -= 1
       inlines[n].ep -= 1
-      inlines[i].len = 0
-      inlines[i].sp += 1
-      if (i++ < inlines.length) {
-        i++
-        nest++
-      } else {
-        return n, nest, memo
+      inlines[i].len -= 1
+      if (inlines[i].len > 0) inlines[i].sp += 1
+      if (insideTagsIsClose === 1) {
+        n, nest = setEm(state, inlines, marks, n, memo, opt)
       }
-      if (i > inlines.length - 1) return n, nest, 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
+      //console.log(marks)
     }
+    //console.log('    check len:: inlines[n].len: ' + inlines[n].len + ', inlines[i].len: ' + inlines[i].len)
     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)
+     //console.log('    hasPunctuation: ' + hasPunctuation(state, inlines, n, i) + ', memo.inlineMarkEnd: ' + memo.inlineMarkEnd)
+      if (hasPunctuation(state, inlines, n, i)) {
+        if (memo.inlineMarkEnd) {
+         //console.log('check nest em.')
+         //console.log('~~~~~~~~~~~~~~~~~')
+          marks.push(...createMarks(state, inlines, i, inlines.length - 1, memo, opt))
+         //console.log('~~~~~~~~~~~~~~~~~')
+          if (inlines[i].len === 0) { i++; continue }
+        } else {
+          return n, nest
+        }
+      }
+     //console.log('    ===> strong normal push. n: ' + n + ', i: ' + i +  ' , nest: ' + nest + ',strongNum: ' + strongNum)
+
       j = 0
       while (j < strongNum) {
-        //console.log('j: ' + j + ', inlines[i].sp: ' + inlines[i].sp)
-        marksPush(marks, nest + strongNum - 1 - j , inlines[n].ep - 1, inlines[n].ep, 2, inlines[n].len - 2,'strong_open')
+        //console.log('    - j: ' + j + ', inlines[i].sp: ' + inlines[i].sp)
+        pushMark(marks, {
+          nest: nest + strongNum - 1 - j,
+          s: inlines[n].ep - 1,
+          e: inlines[n].ep,
+          len: 2,
+          oLen: inlines[n].len - 2,
+          type: 'strong_open'
+        })
         inlines[n].ep -= 2
         inlines[n].len -= 2
-        marksPush(marks, nest + strongNum - 1 - j, inlines[i].sp, inlines[i].sp + 1, 2, inlines[i].len - 2,'strong_close')
+        pushMark(marks, {
+          nest: nest + strongNum - 1 - j,
+          s: inlines[i].sp,
+          e: inlines[i].sp + 1,
+          len: 2,
+          oLen: inlines[i].len - 2,
+          type: 'strong_close'
+        })
         inlines[i].sp += 2
         inlines[i].len -= 2
-        //console.log(marks)
         j++
       }
-      if (inlines[n].len === 0) return n, nest, memo
+      if (inlines[n].len === 0) return n, nest
     }
 
-    //console.log('len: ', inlines[n].len, inlines[i].len)
-    if ((inlines[n].len > 0 && inlines[i] === 1) || (inlines[n].len === 1 && inlines[i].len > 0)) {
-      //console.log('check em that warp strong.')
+    if (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)
-      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
-          k++
-        }
-      }
+      n, nest = setEm(state, inlines, marks, n, memo, opt, nest)
     }
-    if (inlines[n].len === 0) return n, nest, memo
+
     i++
   }
-  return n, nest, memo
+
+  if (n == 0 && memo.inlineMarkEnd) {
+   //console.log('check nest em(inlineMarkEnd).')
+    //console.log('===============================')
+    marks.push(...createMarks(state, inlines, n + 1 , inlines.length - 1, memo, opt))
+    //console.log(marks)
+    //console.log('===============================')
+  }
+  return n, nest
 }
 
-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
+const checkInsideTags = (inlines, i, memo) => {
+  //console.log('isJumTag before::memo.htmlTags: ' + JSON.stringify(memo.htmlTags))
+  if (inlines[i].tag === undefined) return 0
+  const tagName = inlines[i].tag[0].toLowerCase()
+  if (memo.htmlTags[tagName] === undefined) {
+    memo.htmlTags[tagName] = 0
   }
-   //console.log(n, 'after::memo.htmlTags: ' + JSON.stringify(memo.htmlTags))
+  //console.log('memo.htmlTags: ' + JSON.stringify(memo.htmlTags) + ', inlines[i]: ' + JSON.stringify(inlines[i]) + ', inlines[i]')
+  if (inlines[i].tag[1] === 'open') {
+    memo.htmlTags[tagName] += 1
+  }
+  if (inlines[i].tag[1] === 'close') {
+    memo.htmlTags[tagName] -= 1
+  }
+  //console.log('    i: ' + i + ', tagName: ' + tagName + ', memo.htmlTags[tagName]: ' + memo.htmlTags[tagName] + ', prevHtmlTags[tagName]: ' + prevHtmlTags[tagName])
+  if (memo.htmlTags[tagName] < 0) {
+    return -1
+  }
+  //console.log('isJumTag 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) => {
+const isPunctuation = (ch) => {
+  return REG_PUNCTUATION.test(ch)
+}
+
+const hasPunctuation = (state, inlines, n, i) => {
+  const src = state.src
+  const openNextChar = isPunctuation(src[inlines[n].e + 1] || '')
+  //const openPrevChar = isPunctuation(src[inlines[n].s - 1] || '') || n === 0
+  let closePrevChar = isPunctuation(src[inlines[i].s - 1] || '')
+  if (i + 1 < inlines.length) {
+    //closePrevChar = closePrevChar && inlines[i+1] !== 'html_inline'
+  }
+  let closeNextChar = isPunctuation(src[inlines[i].e + 1] || '') || i === inlines.length - 1
+  //const lastCharIsAsterisk = memo.inlineMarkEnd
+  //const firstCharIsAsterisk = memo.inlineMarkStart
+
+  //console.log('openPrevChar: ' + openPrevChar + ', openNextChar: ' + openNextChar + ', closePrevChar: ' + closePrevChar + ', closeNextChar: ' + closeNextChar + ', lastCharIsAsterisk: ' + lastCharIsAsterisk + ', firstCharIsAsterisk: ' + firstCharIsAsterisk + ', next condition: ' + ((openNextChar || closePrevChar) && !closeNextChar))
+  //if ((openNextChar || closePrevChar) && !closeNextChar) {
+  if ((openNextChar || closePrevChar) && !closeNextChar) {
+    return true
+  } else {
+    return false
+  }
+}
+
+const setEm = (state, inlines, marks, n, memo, opt, sNest) => {
   let i = n + 1
   let nest = 0
   let strongPNum = 0
   let insideTagsIsClose = 1
   while (i < inlines.length) {
-    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 }
-      }
+    //console.log('[em] i: ' + i + ', src: ' + state.src.slice(inlines[i].sp, inlines[i].ep + 1) + ', inlines[i]: ' + JSON.stringify(inlines[i]))
+    //console.log(inlines[i].type, JSON.stringify(memo.htmlTags))
+    if (inlines[i].len === 0 || inlines[i].check) { i++; continue }
+    if (!sNest && inlines[i].type === 'html_inline') {
+      inlines.check = true
+      insideTagsIsClose = checkInsideTags(inlines, i, memo)
+      //console.log('    i: ' + i + ', insideTagsIsClose: ' + insideTagsIsClose)
+      if (insideTagsIsClose === -1) return n, nest
+      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)
-    //console.log(marks)
 
-    if (memo.isEm && inlines[i].len === 2) {
+    //console.log('sNest: ' + sNest + ', emNum: ' + emNum)
+    if (!sNest && emNum !== 1) return n, sNest, memo
+
+    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 (!sNest && inlines[i].len === 2 && !hasMarkersAtStartAndEnd(i)) {
       strongPNum++
       i++
       continue
@@ -344,47 +466,83 @@ const setEm = (inlines, marks, n, memo, sNest) => {
     } else {
       nest = checkNest(inlines, marks, n, i)
     }
-    //console.log('n: ' + n +  ' [em]: nest: ' + nest)
-    if (nest === -1) return n, nest, memo
+    //console.log('    nest: ' + nest + ', emNum: ' + emNum)
+    if (nest === -1) return n, nest
 
     if (emNum === 1) {
-      //console.log(n, i, 'insideTagsIsClose: ' + insideTagsIsClose)
-      if (memo.html && !insideTagsIsClose && inlines[i].len !== 2) {
+      //console.log('    hasPunctuation: ' + hasPunctuation(state, inlines, n, i) + ', memo.inlineMarkEnd: ' + memo.inlineMarkEnd)
+      if (hasPunctuation(state, inlines, n, i)) {
+        if (memo.inlineMarkEnd) {
+          //console.log('check nest em.')
+          //console.log('~~~~~~~~~~~~~~~~~')
+          marks.push(...createMarks(state, inlines, i, inlines.length - 1, memo, opt))
+          //console.log('~~~~~~~~~~~~~~~~~')
+
+          if (inlines[i].len === 0) { i++; continue }
+        } else {
+          return n, nest
+        }
+      }
+      //console.log('inlines[i].len: ' + inlines[i].len)
+      if (inlines[i].len < 1) { // memo.html
         i++; continue;
       }
-      //console.log('n: ' + n +  ' [em]: normal push, nest: ' + nest)
-      //console.log('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')
+      //console.log('    ===> em Normal push. n: ' + n + ', i: ' + i + ', nest: ' + nest, ', strongPNum: ' + strongPNum)
+      //console.log(inlines[n].ep, inlines[n].sp, inlines[n].s)
+      pushMark(marks, {
+        nest: nest,
+        s: inlines[n].ep,
+        e: inlines[n].ep,
+        len: 1,
+        oLen: inlines[n].len - 1,
+        type: 'em_open'
+      })
       inlines[n].ep -= 1
       inlines[n].len -= 1
 
       if (strongPNum % 2 === 0 || inlines[i].len < 2) {
-        marksPush(marks, nest, inlines[i].sp, inlines[i].sp, 1, inlines[i].len - 1, 'em_close')
+        pushMark(marks, {
+          nest: nest,
+          s: inlines[i].sp,
+          e: inlines[i].sp,
+          len: 1,
+          oLen: inlines[i].len - 1,
+          type: 'em_close'
+        })
         inlines[i].sp += 1
       } else {
-        marksPush(marks, nest, inlines[i].ep, inlines[i].ep, 1, inlines[i].len - 1, 'em_close')
+        pushMark(marks, {
+          nest: nest,
+          s: inlines[i].ep,
+          e: inlines[i].ep,
+          len: 1,
+          oLen: inlines[i].len - 1,
+          type: 'em_close'
+        })
         inlines[i].sp = inlines[i].ep - 1
         inlines[i].ep -= 1
-
       }
       inlines[i].len -= 1
       //console.log(marks)
-      if (!memo.isEm) memo.hasEmThatWrapStrong = true
-      if (inlines[n].len === 0) return n, nest, memo
+      if (inlines[n].len === 0) return n, nest
     }
 
     i++
   }
-  return n, nest, memo
+  return n, nest
 }
 
 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
+  pushMark(marks, {
+    nest: nest,
+    s: inlines[n].sp,
+    e: inlines[n].ep,
+    len: inlines[n].len,
+    oLen: -1,
+    type: 'text'
+  })
   inlines[n].len = 0
 }
 
@@ -413,7 +571,6 @@ const checkNest = (inlines, marks, n, i) => {
   if (parentCloseN < marks.length) {
     while (parentCloseN < marks.length) {
       if (marks[parentCloseN].nest === parentNest) break
-      //if (marks.length - 1 == parentCloseN) break
       parentCloseN++
     }
     //console.log('parentCloseN: ' + parentCloseN)
@@ -434,121 +591,127 @@ 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) {
-    if (inlines[n].type !== '' || inlines[n].len === 0) { n++; continue }
-    memo.isEm = inlines[n].len === 1 ? true : false
-    memo.wrapEm = 0
+    if (inlines[n].type !== '') { n++; continue }
     let nest = 0
-    //console.log('n: ' + n +  ' ----- inlines.length: ' + inlines.length + ', memo.isEm: ' + memo.isEm)
-    if (!memo.isEm) {
-      n, nest, memo = setStrong(inlines, marks, n, memo)
+   //console.log('n: ' + n +  ' ----- inlines:: src: ' + state.src.slice(inlines[n].sp, inlines[n].ep + 1) + ', inlines[n].sp: ' + inlines[n].sp + ', inlines[n].len: ' + inlines[n].len + ', memo.isEm: ' + memo.isEm)
+    if (inlines[n].len > 1) {
+      n, nest = setStrong(state, inlines, marks, n, memo, opt)
+    }
+    if (inlines[n].len !== 0) {
+      n, nest = setEm(state, inlines, marks, n, memo, opt)
+    }
+    if (inlines[n].len !== 0) {
+      setText(inlines, marks, n, nest)
     }
-    n, nest, memo = setEm(inlines, marks, n, memo)
-    if (inlines[n].len !== 0) setText(inlines, marks, n, nest)
-    //console.log(marks)
     n++
   }
   return 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)
-    while (i < marks.length) {
-      //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])
-        i++
-        continue
+
+const mergeInlinesAndMarks = (inlines, marks) => {
+  marks.sort((a, b) => a.s - b.s)
+  const merged = []
+  let markIndex = 0
+  for (const token of inlines) {
+    if (token.type === '') {
+      while (markIndex < marks.length && marks[markIndex].s >= token.s && marks[markIndex].e <= token.e) {
+        merged.push(marks[markIndex])
+        markIndex++
       }
-      break
-    }
-    if (marks.length) {
-      marks.splice(0, i)
-      inlines.splice(n, 1)
-      n += i
     } else {
-      //if (inlines[n].type === '') inlines[n].type = 'text'
-      n++
+      merged.push(token)
     }
   }
+  while (markIndex < marks.length) {
+    merged.push(marks[markIndex++])
+  }
+  return merged
 }
 
 const strongJa = (state, silent, opt) => {
   if (silent) return false
   const start = state.pos
   let max = state.posMax
+  const src = state.src
   let attributesSrc
-  if (opt.hasCurlyAttributes) {
-    attributesSrc = state.src.match(/( *){.*?}$/)
-    if (attributesSrc) {
-      max = state.src.slice(0, attributesSrc.index).length
+  if (start > max) return false
+  if (src.charCodeAt(start) !== 0x2A) return false
+  if (hasBackslash(state, start)) return false
+
+  if (opt.mditAttrs) {
+    attributesSrc = src.match(/((\n)? *){([^{}\n!@#%^&*()]+?)} *$/)
+    if (attributesSrc && attributesSrc[3] !== '.') {
+      max = src.slice(0, attributesSrc.index).length
+      if (attributesSrc[2] === '\n') {
+        max = src.slice(0, attributesSrc.index - 1).length
+      }
+      if(hasBackslash(state, attributesSrc.index) && attributesSrc[2] === '' && attributesSrc[1].length === 0) {
+        max = state.posMax
+      }
+    } else {
+      let endCurlyKet = 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)
 
   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,
+    inlineMarkStart: src.charCodeAt(0) === 0x2A ? true : false,
+    inlineMarkEnd: 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)
 
-  fixInlines(inlines, marks)
+  inlines = mergeInlinesAndMarks(inlines, marks)
   //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 {
       state.pos = max
     }
   } else {
-    state.pos = max + 1
+    state.pos = max
   }
+  //console.log(state.tokens)
   return true
 }
 
 const mditStrongJa = (md, option) => {
   const opt = {
-    dollarMath: true,
-    hasCurlyAttributes: false,
-  }
-  opt.hasCurlyAttributes = md.core.ruler.__rules__.filter(rule => {
-    rule.name === 'curly_attributes' // markdown-it-attrs
-  })
-  if (option !== undefined) {
-    for (let o in option) {
-        opt[o] = option[o]
-    }
+    dollarMath: true, //inline math $...$
+    mditAttrs: true, //markdown-it-attrs
   }
+  if (option) Object.assign(opt, option)
+
   md.inline.ruler.before('emphasis', 'strong_ja', (state, silent) => {
     return strongJa(state, silent, opt)
   })
 }
-export default mditStrongJa
+  export default mditStrongJa