@peaceroad/markdown-it-strong-ja 0.2.1 → 0.3.0

package/.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+    "cSpell.ignoreWords": [
+        "inlines"
+    ]
+}

package/README.md

@@ -2,14 +2,14 @@
 
 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.
 
-Since em processing was added from 0.2, the package name is strange.
+Notice: this is slightly different from the commonmark processing.
 
 ## Use
 
 ```js
 import mdit from 'markdown-it'
-import mdStrongJa from '@peaceroad/markdown-it-strong-ja'
-const md = mdit().use(mdStrongJa)
+import mditStrongJa from '@peaceroad/markdown-it-strong-ja'
+const md = mdit().use(mditStrongJa)
 
 md.render('HTMLは**「HyperText Markup Language」**の略です。')
 // <p>HTMLは<strong>「HyperText Markup Language」</strong>の略です。</p>

package/index.js

@@ -1,112 +1,391 @@
-const processInlineTokens = (state, start, end, type, max) => {
-  let token
-  const content = type === 'strong' ? state.src.slice(start, end - 1) : state.src.slice(start, end)
-
-  const childTokens = state.md.parseInline(content, state.env)
-
-  token = state.push(`${type}_open`, type, 1)
-  token.markup = type === 'strong' ? '**' : '*'
-
-  if (childTokens[0] && childTokens[0].children) {
-    childTokens[0].children.forEach(t => {
-      token = state.push(t.type, t.tag, t.nesting)
-      token.attrs = t.attrs
-      token.map = t.map
-      token.level = t.level
-      token.children = t.children
-      token.content = t.content
-      token.markup = t.markup
-      token.info = t.info
-      token.meta = t.meta
-      token.block = t.block
-      token.hidden = t.hidden
-    })
+const hasSlashFlag = (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
+}
 
-  token = state.push(`${type}_close`, type, -1)
-  token.markup = type === 'strong' ? '**' : '*'
+const setToken = (state, inlines) => {
+  let i = 0
+  while (i < inlines.length) {
+    const type = inlines[i].type
+    const tag = type.replace(/(?:_open|_close)$/, '')
 
-  state.pos = end + 1
+    if (/_open$/.test(type)) {
+      const startToken = state.push(type, tag, 1)
+      startToken.markup = tag === 'strong' ? '**' : '*'
+    }
 
-  if (state.pos === max) {
-    state.pos = end
-    token = state.push('text', '', 0)
-    token.content = '★mdStrongJa★'
+    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) {
+        state.tokens[state.tokens.length - 1].children = childTokens[0].children
+        childTokens[0].children.forEach(t => {
+          const token = state.push(t.type, t.tag, t.nesting)
+          token.attrs = t.attrs
+          token.map = t.map
+          token.level = t.level
+          token.children = t.children
+          token.content = t.content
+          token.markup = t.markup
+          token.info = t.info
+          token.meta = t.meta
+          token.block = t.block
+          token.hidden = t.hidden
+        })
+      }
+    }
+
+    if (/_close$/.test(type)) {
+      const closeToken = state.push(type, tag, -1)
+      closeToken.markup = tag === 'strong' ? '**' : '*'
+    }
+
+    i++
   }
 }
 
-const strongJa = (state, silent, md) => {
-  let end, type
-  const max = state.posMax
-  const start = state.pos
+const inlinesPush = (inlines, s, e, len, type) => {
+  inlines.push({
+    s: s,
+    sp: s,
+    e: e,
+    ep: e,
+    len: len,
+    type: type,
+  })
+}
 
-  if (silent) return false
-  if (start + 1 > max) return false
-  if (state.src.charCodeAt(start) !== 0x2A)  return false
+const crateInlines = (state, start, max) => {
+  let n = start
+  let inlines = []
+  let noMark = ''
+  let mark = ''
+  let beforeIsMark = true
+  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')
+        }
+        n++
+        continue
+      }
+      beforeIsMark = true
+      mark += '*'
+      if (n !== start && noMark !== '') {
+        inlinesPush(inlines, n - noMark.length, n - 1, noMark.length, 'text')
+      }
+      noMark = ''
+      if (n === max - 1) {
+        inlinesPush(inlines, n - mark.length + 1, n, mark.length, '')
+      }
+    } 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')
+      }
+    }
+    n++
+  }
+  return inlines
+}
 
-  if (state.src.charCodeAt(start + 1) === 0x2A) {
-    end = start + 2
-    type = 'strong'
+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)
+  let i = marks.findIndex(o => o.s > s)
+  if (i === -1) {
+    marks.push(np)
   } else {
-    end = start + 1
-    type = 'em'
+    marks.splice(i, 0, np)
   }
+}
+
+const setStrong = (inlines, marks, n, memo) => {
+  let i = n + 2
+  let j = 0
+  let nest = 0
+  while (i < inlines.length) {
+    if (inlines[i].len === 0) { i += 2; 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')
+      marksPush(marks, nest, inlines[i].sp, inlines[i].ep, 1, inlines[i].len - 1, 'em_close')
+      inlines[n].len -= 1
+      inlines[n].ep -= 1
+      inlines[i].len = 0
+      inlines[i].sp += 1
+      if (i + 2 < inlines.length) {
+        i += 2
+        nest++
+      } else {
+        return n, nest, memo
+      }
+      //console.log(marks)
+      //console.log('n: ' + n +  ' [strong]: check em inside strong end.')
+    }
+
+    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
+      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')
+        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')
+        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 === 1) {
+      //console.log('check em that warp strong: ')
+      nest++
+      n, nest, memo= setEm(inlines, marks, n, memo, nest)
+      if (memo.hasEmThatWrapStrong) {
+        //console.log('fix strong wrapped em:')
+        let k = 0
+        while (k < strongNum) {
+            marks[marks.length - 2 - k * 2 - 1].nest += 1
+            marks[marks.length - 2 - k * 2].nest += 1
+          k++
+        }
+      }
+    }
+
+    if (inlines[n].len === 0) return n, nest, memo
+    i += 2
+  }
+  return n, nest, memo
+}
+
+const setEm = (inlines, marks, n, memo, sNest) => {
+  let i = n + 2
+  let nest = 0
+  let strongPNum = 0
+  while (i < inlines.length) {
+    if (inlines[i].len === 0) { i += 2; 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) {
+      strongPNum++
+      i += 2
+      continue
+    }
+
+    if (sNest) {
+      nest  = sNest - 1
+    } else {
+      nest = checkNest(inlines, marks, n, i)
+    }
+    //console.log('n: ' + n +  ' [em]: nest: ' + nest)
+    if (nest === -1) return n, nest, memo
+
+    if (emNum === 1) {
+      //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')
+      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')
+        inlines[i].sp += 1
+      } else {
+        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
 
-  while (end < max) {
-    if (state.src.charCodeAt(end) === 0x2A) {
-      if (type === 'strong' && state.src.charCodeAt(end + 1) === 0x2A) {
-        end += 1
-        break
-      } else if (type === 'em' && (state.src.charCodeAt(end - 1) === 0x2A || state.src.charCodeAt(end + 1) === 0x2A)) {
-        end++
-        continue
-      } else if (type === 'em') {
-        break
       }
+      inlines[i].len -= 1
+      //console.log(marks)
+      if (!memo.isEm) memo.hasEmThatWrapStrong = true
+      if (inlines[n].len === 0) return n, nest, memo
     }
-    end++
+
+    i += 2
+  }
+
+  return n, nest, memo
+}
+
+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
+}
+
+const checkNest = (inlines, marks, n, i) => {
+  let nest = 1
+  let isRange = true
+  if (marks.length === 0) return nest
+  let strongNest = 0
+  let emNest = 0
+  let j = 0
+  //console.log(marks)
+  //console.log('n: ' + n + ', i: ' + i + ', inlines[n].s: ' + inlines[n].s + ', inlines[i].s: ' + inlines[i].s)
+  while (j < marks.length) {
+    if (marks[j].s <= inlines[n].s) {
+      if (marks[j].type === 'strong_open') strongNest++
+      if (marks[j].type === 'strong_close') strongNest--
+      if (marks[j].type === 'em_open') emNest++
+      if (marks[j].type === 'em_close') emNest--
+    } else { break }
+    j++
   }
-  const noContent = type === 'strong' ? end === start + 3 :end === start + 1
-  if (end >= max || noContent) {
-    state.pos = start
-    return false
+  let parentNest = strongNest + emNest
+  let parentCloseN = j
+  //console.log('strongNest: ' + strongNest + ', emNest: ' + emNest + ', parentNest: ' + parentNest + ', parentCloseN: ' + parentCloseN)
+  if (parentCloseN < marks.length) {
+    while (parentCloseN < marks.length) {
+      if (marks[parentCloseN].nest === parentNest) break
+      parentCloseN++
+    }
+    //console.log(parentCloseN, marks[parentCloseN].s, i, inlines[i].s)
+    if (marks[parentCloseN].s < inlines[i].s) isRange = false
   }
-  //console.log('start: ' + start + ', end: '+ end+ ', state.pos: ' + state.pos)
+  //console.log('isRange: ' + isRange)
 
-  processInlineTokens(state, start + (type === 'strong' ? 2 : 1), end, type, max)
-  //console.log('output:: state.src.length: ' + state.src.length + ', state.posMax: ' + state.posMax + ', state.pos: ' + state.pos)
-  return true
+  if (isRange) {
+    nest = parentNest + 1
+  } else {
+    nest = -1
+  }
+  return nest
 }
 
-const mdStrongJa = (md) => {
-  md.inline.ruler.before('emphasis', 'strong_ja', (state, silent) => {
-    strongJa(state, silent, md)
-  })
+const createMarks = (inlines, inlinesStart, inlinesEnd, 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
+    memo.wrapEm = 0
+    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)
+    }
+    n, nest, memo = setEm(inlines, marks, n, memo)
+
+    if (inlines[n].len !== 0) setText(inlines, marks, n, nest)
+    n += 2
+  }
+  return marks
+}
 
-  md.core.ruler.push('remove_strong_ja_sp_chars', (state) => {
+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)
+
+  let n = 0
+  while (n < inlines.length) {
+    if (inlines[n].type !== '') { n++; continue }
     let i = 0
-    while (i < state.tokens.length) {
-      //console.log(state.tokens[i].type)
-      if (state.tokens[i].type !== 'inline') {
+    //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].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
       }
-      //console.log(state.tokens[i].children)
-      if (state.tokens[i].children) {
-        if (state.tokens[i].children[state.tokens[i].children.length - 1]) {
-          let j = state.tokens[i].children.length - 1
-          while (j > -1) {
-            if (state.tokens[i].children[j].content === '★mdStrongJa★*') {
-              state.tokens[i].children.splice(j, 1)
-              break
-            }
-            j--
-          }
-        }
-      }
-      i++
+      break
     }
-  })
+    if (marks.length) {
+      marks.splice(0, c)
+      inlines.splice(n, 1)
+      n += c
+    } else {
+      inlines[n].type = 'text'
+      n++
+    }
+  }
+
+  //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 = inlines[inlines.length - 1].e + 1
+  return true
 }
 
-export default mdStrongJa
+const mditStrongJa = (md) => {
+  md.inline.ruler.before('emphasis', 'strong_ja', (state, silent) => {
+    return strongJa(state, silent)
+  })
+}
+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.2.1",
+  "version": "0.3.0",
   "main": "index.js",
   "type": "module",
   "scripts": {

package/test/example-complex.txt

@@ -0,0 +1,141 @@
+[Markdown]
+HTMLは「***HyperText Markup Language***」の略です。
+[HTML]
+<p>HTMLは「<em><strong>HyperText Markup Language</strong></em>」の略です。</p>
+
+
+[Markdown]
+HTMLは***「HyperText Markup Language」***の略です。
+[HTML]
+<p>HTMLは<em><strong>「HyperText Markup Language」</strong></em>の略です。</p>
+
+
+[Markdown]
+HTMLは「****HyperText Markup Language****」の略です。
+[HTML]
+<p>HTMLは「<strong><strong>HyperText Markup Language</strong></strong>」の略です。</p>
+
+
+[Markdown]
+HTMLは****「HyperText Markup Language」****の略です。
+[HTML]
+<p>HTMLは<strong><strong>「HyperText Markup Language」</strong></strong>の略です。</p>
+
+
+[Markdown]
+HTMLは**「*HyperText* Markup *Language*」**の略です。
+[HTML]
+<p>HTMLは<strong>「<em>HyperText</em> Markup <em>Language</em>」</strong>の略です。</p>
+
+
+
+[Markdown]
+あ*い**う
+[HTML]
+<p>あ*い**う</p>
+
+
+[Markdown]
+あ**い***う
+[HTML]
+<p>あ<strong>い</strong>*う</p>
+
+[Markdown]
+あ***い****う
+[HTML]
+<p>あ<em><strong>い</strong></em>*う</p>
+
+[Markdown]
+**あ*い**う*
+[HTML]
+<p><strong>あ*い</strong>う*</p>
+
+[Markdown]
+*あ**い*う**
+[HTML]
+<p><em>あ**い</em>う**</p>
+
+
+[Markdown]
+ん*あ**い*う**
+[HTML]
+<p>ん<em>あ**い</em>う**</p>
+
+
+[Markdown]
+***か*
+[HTML]
+<p>**<em>か</em></p>
+
+[Markdown]
+か***き*
+[HTML]
+<p>か**<em>き</em></p>
+
+
+
+[Markdown]
+***さ*し***す*
+[HTML]
+<p><strong><em>さ</em>し</strong><em>す</em></p>
+
+
+[Markdown]
+*a**b**c**d**e*
+[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>
+
+[Markdown]
+a*aa**
+[HTML]
+<p>a*aa**</p>
+
+[Markdown]
+*ee***
+[HTML]
+<p><em>ee</em>**</p>
+
+
+[Markdown]
+*aa***e*
+[HTML]
+<p><em>aa</em>*<em>e</em></p>
+
+
+[Markdown]
+**a*****b**
+[HTML]
+<p><strong>a</strong>*<strong>b</strong></p>
+
+
+[Markdown]
+*ee**ee***
+[HTML]
+<p><em>ee<strong>ee</strong></em></p>
+
+
+[Markdown]
+**a*b**c***d*e**f*
+[HTML]
+<p><strong>a*b</strong>c<strong><em>d</em>e</strong>f*</p>
+
+[Markdown]
+*a**a***b***c**d*e
+[HTML]
+<p><em>a<strong>a</strong></em>b<em><strong>c</strong>d</em>e</p>
+
+[Markdown]
+a[*](https://example.com)*b
+[HTML]
+<p>a<a href="https://example.com">*</a>*b</p>
+
+[Markdown]
+a[*](https://example*.com)*b*
+[HTML]
+<p>a<a href="https://example*.com">*</a><em>b</em></p>

package/test/example-strong.txt

@@ -48,6 +48,11 @@ HTMLは\\\**「HyperText Markup Language」**の略です。
 [HTML]
 <p>HTMLは\**「HyperText Markup Language」**の略です。</p>
 
+[Markdown]
+HTMLは\\\\**「HyperText Markup Language」**の略です。
+[HTML]
+<p>HTMLは\\<strong>「HyperText Markup Language」</strong>の略です。</p>
+
 
 [Markdown]
 HTMLは`**`は**「HyperText Markup Language」**の略です。
@@ -199,4 +204,17 @@ HTMLは[**「HyperText Markup Language」**][]です。
 [HTML]
 <ul>
 <li>HTMLは<strong>「Hyper<a href="https://example.com/">Text</a> Markup Language」</strong></li>
-</ul>
+</ul>
+
+[Markdown]
+aaa><aaa
+[HTML]
+<p>aaa&gt;&lt;aaa</p>
+
+
+[Markdown]
+aaa&lt;/&gt;aaa
+[HTML]
+<p>aaa&lt;/&gt;aaa</p>
+
+

package/test/test.js

@@ -13,10 +13,8 @@ const check = (ms, example) => {
   const mdWithHtml = mdit({html: true}).use(mditStrongJa)
   let n = 1
   while (n < ms.length) {
-    //if (n !== 13) { n++; continue }
-   //if (n !== 28) { n++; continue }
+   //if (n != 1 ) { n++; continue }
     const m = ms[n].markdown
-
     console.log('Test [' + n + ', HTML: false] >>>')
     const h = md.render(m)
     try {
@@ -34,7 +32,6 @@ const check = (ms, example) => {
         console.log('Input: ' + ms[n].markdown + '\nConvert: ' + hh + 'Correct: ' + ms[n].htmlWithHtmlTrue)
       }
     }
-
     n++
   }
 }
@@ -42,12 +39,13 @@ const check = (ms, example) => {
 const examples = {
   strong: __dirname + '/example-strong.txt',
   em: __dirname + '/example-em.txt',
+  complex: __dirname + '/example-complex.txt',
 }
 
 for (let example in examples) {
   const exampleCont = fs.readFileSync(examples[example], 'utf-8').trim()
   let ms = [];
-  let ms0 = exampleCont.split(/\n*\[Markdown\]\n/)
+  let ms0 = exampleCont.split(/\n*\[Markdown[^\]]*?\]\n/)
   let n = 1
   while (n < ms0.length) {
     let mhs = ms0[n].split(/\n+\[HTML[^\]]*?\]\n/)