@peaceroad/markdown-it-strong-ja 0.8.0 → 0.9.0

package/src/token-core.js

@@ -10,13 +10,15 @@ import {
   MODE_FLAG_COMPATIBLE,
   MODE_FLAG_AGGRESSIVE,
   MODE_FLAG_JAPANESE_PLUS,
-  getRuntimeOpt
+  getRuntimeOpt,
+  hasRuntimeOverride
 } from './token-utils.js'
 
 const SCAN_DELIMS_PATCHED = Symbol.for('strongJaTokenScanDelimsPatched')
 const SINGLE_STAR_LOOKAROUND_MAX = 16
 const PREV_STAR_HAS_OPENER = 1
 const PREV_STAR_HAS_JP_BETWEEN = 2
+const SCAN_DELIMS_LOOKUP_KEY = Symbol.for('strongJaTokenScanDelimsLookup')
 
 const isSoftSpaceCode = (code) => {
   return code === CHAR_SPACE || code === CHAR_TAB || code === CHAR_IDEOGRAPHIC_SPACE
@@ -194,6 +196,28 @@ const rebuildInlineLevels = (tokens) => {
   }
 }
 
+const rebuildInlineLevelsFrom = (tokens, startIdx = 0) => {
+  if (!tokens || tokens.length === 0) return
+  let from = startIdx > 0 ? startIdx : 0
+  if (from >= tokens.length) return
+  let level = 0
+  if (from > 0) {
+    const prev = tokens[from - 1]
+    if (prev) {
+      level = prev.level
+      if (prev.nesting === 1) level++
+      else if (prev.nesting === -1) level--
+    }
+  }
+  for (let i = from; i < tokens.length; i++) {
+    const t = tokens[i]
+    if (!t) continue
+    t.level = level
+    if (t.nesting === 1) level++
+    else if (t.nesting === -1) level--
+  }
+}
+
 const findLinkOpen = (tokens, closeIdx) => {
   let depth = 0
   for (let i = closeIdx; i >= 0; i--) {
@@ -258,7 +282,58 @@ const isAsciiGuardCloseWrapper = (code) => {
     code === 0x60 // `
 }
 
-const findPrevNonSpaceIndex = (src, start) => {
+const buildScanDelimsLookupCache = (src) => {
+  const len = typeof src === 'string' ? src.length : 0
+  const prevNonSpaceSameLine = new Int32Array(len)
+  const nextNonSpaceSameLine = new Int32Array(len)
+  prevNonSpaceSameLine.fill(-1)
+  nextNonSpaceSameLine.fill(-1)
+
+  let prev = -1
+  for (let i = 0; i < len; i++) {
+    const code = src.charCodeAt(i)
+    if (code === CHAR_NEWLINE) {
+      prev = -1
+      continue
+    }
+    if (!isSoftSpaceCode(code)) prev = i
+    prevNonSpaceSameLine[i] = prev
+  }
+
+  let next = -1
+  for (let i = len - 1; i >= 0; i--) {
+    const code = src.charCodeAt(i)
+    if (code === CHAR_NEWLINE) {
+      next = -1
+      continue
+    }
+    if (!isSoftSpaceCode(code)) next = i
+    nextNonSpaceSameLine[i] = next
+  }
+
+  return {
+    src,
+    prevNonSpaceSameLine,
+    nextNonSpaceSameLine
+  }
+}
+
+const getScanDelimsLookupCache = (state) => {
+  if (!state || typeof state.src !== 'string') return null
+  const cached = state[SCAN_DELIMS_LOOKUP_KEY]
+  if (cached && cached.src === state.src) return cached
+  const next = buildScanDelimsLookupCache(state.src)
+  state[SCAN_DELIMS_LOOKUP_KEY] = next
+  return next
+}
+
+const findPrevNonSpaceIndex = (src, start, lookupCache = null) => {
+  if (start < 0) return -1
+  if (lookupCache &&
+      lookupCache.src === src &&
+      start < lookupCache.prevNonSpaceSameLine.length) {
+    return lookupCache.prevNonSpaceSameLine[start]
+  }
   for (let i = start; i >= 0; i--) {
     const code = src.charCodeAt(i)
     if (code === CHAR_NEWLINE) return -1
@@ -268,7 +343,14 @@ const findPrevNonSpaceIndex = (src, start) => {
   return -1
 }
 
-const findNextNonSpaceIndex = (src, start, max) => {
+const findNextNonSpaceIndex = (src, start, max, lookupCache = null) => {
+  if (lookupCache &&
+      lookupCache.src === src &&
+      start >= 0 &&
+      start < lookupCache.nextNonSpaceSameLine.length) {
+    const next = lookupCache.nextNonSpaceSameLine[start]
+    return next !== -1 && next < max ? next : -1
+  }
   for (let i = start; i < max; i++) {
     const code = src.charCodeAt(i)
     if (code === CHAR_NEWLINE) return -1
@@ -278,26 +360,26 @@ const findNextNonSpaceIndex = (src, start, max) => {
   return -1
 }
 
-const hasAsciiStartAfterOptionalOpenWrappers = (src, index, max) => {
+const hasAsciiStartAfterOptionalOpenWrappers = (src, index, max, lookupCache = null) => {
   let i = index
   // Two wrappers are enough for common shapes: * [ "word" ]*
   for (let wrappers = 0; wrappers < 2 && i >= 0 && i < max; wrappers++) {
     const code = src.charCodeAt(i)
     if (!isAsciiGuardOpenWrapper(code)) break
-    i = findNextNonSpaceIndex(src, i + 1, max)
+    i = findNextNonSpaceIndex(src, i + 1, max, lookupCache)
     if (i === -1) return false
   }
   if (i < 0 || i >= max) return false
   return isAsciiAlphaNum(src.charCodeAt(i))
 }
 
-const hasAsciiEndBeforeOptionalCloseWrappers = (src, index) => {
+const hasAsciiEndBeforeOptionalCloseWrappers = (src, index, lookupCache = null) => {
   let i = index
   // Two wrappers are enough for common shapes: *["word"] *
   for (let wrappers = 0; wrappers < 2 && i >= 0; wrappers++) {
     const code = src.charCodeAt(i)
     if (!isAsciiGuardCloseWrapper(code)) break
-    i = findPrevNonSpaceIndex(src, i - 1)
+    i = findPrevNonSpaceIndex(src, i - 1, lookupCache)
     if (i === -1) return false
   }
   if (i < 0) return false
@@ -331,7 +413,17 @@ const isSentenceBoundaryStop = (code) => {
     code === 0x2049 // ⁉
 }
 
-const findPrevNonSpaceLimited = (src, start, maxLook) => {
+const findPrevNonSpaceLimited = (src, start, maxLook, lookupCache = null) => {
+  if (lookupCache &&
+      lookupCache.src === src &&
+      start >= 0 &&
+      start < lookupCache.prevNonSpaceSameLine.length) {
+    const prev = lookupCache.prevNonSpaceSameLine[start]
+    if (prev !== -1 && (start - prev) < maxLook) {
+      return src.charCodeAt(prev)
+    }
+    return 0
+  }
   let looked = 0
   for (let i = start; i >= 0; i--) {
     if (looked >= maxLook) break
@@ -344,7 +436,17 @@ const findPrevNonSpaceLimited = (src, start, maxLook) => {
   return 0
 }
 
-const findNextNonSpaceLimited = (src, start, max, maxLook) => {
+const findNextNonSpaceLimited = (src, start, max, maxLook, lookupCache = null) => {
+  if (lookupCache &&
+      lookupCache.src === src &&
+      start >= 0 &&
+      start < lookupCache.nextNonSpaceSameLine.length) {
+    const next = lookupCache.nextNonSpaceSameLine[start]
+    if (next !== -1 && next < max && (next - start) < maxLook) {
+      return src.charCodeAt(next)
+    }
+    return 0
+  }
   let looked = 0
   for (let i = start; i < max; i++) {
     if (looked >= maxLook) break
@@ -357,13 +459,13 @@ const findNextNonSpaceLimited = (src, start, max, maxLook) => {
   return 0
 }
 
-const hasJapaneseContextForBracketWrapper = (src, start, pos, max, lastChar, nextChar) => {
+const hasJapaneseContextForBracketWrapper = (src, start, pos, max, lastChar, nextChar, lookupCache = null) => {
   if (isWrapperOpenLike(nextChar)) {
-    const right = findNextNonSpaceLimited(src, pos, max, SINGLE_STAR_LOOKAROUND_MAX)
+    const right = findNextNonSpaceLimited(src, pos, max, SINGLE_STAR_LOOKAROUND_MAX, lookupCache)
     if (isJapaneseChar(right)) return true
   }
   if (isWrapperCloseLike(lastChar)) {
-    const left = findPrevNonSpaceLimited(src, start - 2, SINGLE_STAR_LOOKAROUND_MAX)
+    const left = findPrevNonSpaceLimited(src, start - 2, SINGLE_STAR_LOOKAROUND_MAX, lookupCache)
     if (isJapaneseChar(left)) return true
   }
   return false
@@ -393,10 +495,11 @@ const scanPrevSingleStarContextFlags = (src, start) => {
 }
 
 const ensurePrevStarFlags = (src, start, prevStarFlags) => {
-  return prevStarFlags >= 0 ? prevStarFlags : scanPrevSingleStarContextFlags(src, start)
+  if (prevStarFlags >= 0) return prevStarFlags
+  return scanPrevSingleStarContextFlags(src, start)
 }
 
-const fixTrailingStrong = (tokens) => {
+const fixTrailingStrong = (tokens, onChangeStart = null) => {
   let changed = false
   for (let i = 1; i < tokens.length; i++) {
     const token = tokens[i]
@@ -435,21 +538,23 @@ const fixTrailingStrong = (tokens) => {
         tokens[innerOpenIdx + 2] && tokens[innerOpenIdx + 2].type === 'em_close' &&
         tokens[innerOpenIdx + 3] && tokens[innerOpenIdx + 3].type === 'text' &&
         closeIdx === innerOpenIdx + 4) {
-      tokens.splice(innerOpenIdx + 2, 1)
-      tokens.splice(innerOpenIdx, 1)
       const movedOpen = new Token('em_open', 'em', 1)
       movedOpen.markup = '*'
       const movedClose = new Token('em_close', 'em', -1)
       movedClose.markup = '*'
-      tokens.splice(innerOpenIdx + 1, 0, movedOpen)
-      tokens.splice(innerOpenIdx + 3, 0, movedClose)
+      const innerReplacement = [
+        tokens[innerOpenIdx + 1],
+        movedOpen,
+        tokens[innerOpenIdx + 3],
+        movedClose
+      ]
+      tokens.splice(innerOpenIdx, 4, ...innerReplacement)
     }
 
     const before = token.content.slice(0, starIdx)
     const after = token.content.slice(starIdx + 2)
 
-    tokens.splice(closeIdx, 1)
-    if (closeIdx < i) i--
+    if (onChangeStart) onChangeStart(openIdx)
 
     const openToken = tokens[openIdx]
     if (!openToken) continue
@@ -458,28 +563,27 @@ const fixTrailingStrong = (tokens) => {
     openToken.markup = '**'
     openToken.nesting = 1
 
+    const strongClose = new Token('strong_close', 'strong', -1)
+    strongClose.markup = '**'
+    const trailingReplacement = []
     if (before) {
       token.content = before
-    } else {
-      tokens.splice(i, 1)
-      i--
+      trailingReplacement.push(token)
     }
-
-    const insertAt = i + 1
-    const strongClose = new Token('strong_close', 'strong', -1)
-    strongClose.markup = '**'
-    tokens.splice(insertAt, 0, strongClose)
+    trailingReplacement.push(strongClose)
     if (after) {
       const tail = new Token('text', '', 0)
       tail.content = after
-      tokens.splice(insertAt + 1, 0, tail)
+      trailingReplacement.push(tail)
     }
+    tokens.splice(closeIdx, 2, ...trailingReplacement)
+    i = closeIdx + trailingReplacement.length - 1
     changed = true
   }
   return changed
 }
 
-function fixEmOuterStrongSequence(tokens) {
+function fixEmOuterStrongSequence(tokens, onChangeStart = null) {
   let changed = false
   let i = 0
   while (i < tokens.length) {
@@ -536,6 +640,7 @@ function fixEmOuterStrongSequence(tokens) {
       continue
     }
 
+    if (onChangeStart) onChangeStart(idx0)
     t0.type = 'strong_open'
     t0.tag = 'strong'
     t0.markup = '**'
@@ -548,28 +653,23 @@ function fixEmOuterStrongSequence(tokens) {
     const strongClose = new Token('strong_close', 'strong', -1)
     strongClose.markup = '**'
 
-    tokens.splice(idx7, 1)
-    tokens.splice(idx5, 1)
-    tokens.splice(idx3, 1)
-    tokens.splice(idx1, 1)
-
-    const idx4AfterRemove = idx4 - 2
-    const idx6AfterRemove = idx6 - 3
-    tokens.splice(idx4AfterRemove, 0, emOpen)
-
-    const idx6BeforeEmClose = idx6AfterRemove + 1
-    tokens.splice(idx6BeforeEmClose, 0, emClose)
-
-    const idx6AfterEmClose = idx6BeforeEmClose + 1
-    tokens.splice(idx6AfterEmClose + 1, 0, strongClose)
+    const replacement = [
+      ...tokens.slice(idx1 + 1, idx3),
+      emOpen,
+      ...tokens.slice(idx3 + 1, idx5),
+      emClose,
+      ...tokens.slice(idx5 + 1, idx7),
+      strongClose
+    ]
+    tokens.splice(idx1, idx7 - idx1 + 1, ...replacement)
 
     changed = true
-    i = idx6AfterEmClose + 2
+    i = idx1 + replacement.length
   }
   return changed
 }
 
-const shiftEmWithLeadingStar = (tokens, rangeStart, rangeEnd, closeIdx) => {
+const shiftEmWithLeadingStar = (tokens, rangeStart, rangeEnd, closeIdx, onChangeStart = null) => {
   let openIdx = findMatchingEmOpen(tokens, closeIdx)
   if (openIdx === -1 || openIdx < rangeStart || openIdx >= rangeEnd) return false
 
@@ -598,33 +698,26 @@ const shiftEmWithLeadingStar = (tokens, rangeStart, rangeEnd, closeIdx) => {
   const starToken = tokens[starTokenIdx]
   const before = starToken.content.slice(0, starPos)
   const after = starToken.content.slice(starPos + 1)
-  let insertAt = starTokenIdx
-  if (before) {
-    starToken.content = before
-    insertAt = starTokenIdx + 1
-  } else {
-    tokens.splice(starTokenIdx, 1)
-    if (starTokenIdx < openIdx) {
-      openIdx--
-      closeIdx--
-    }
-  }
+  if (onChangeStart) onChangeStart(starTokenIdx)
 
   const emOpen = new Token('em_open', 'em', 1)
   emOpen.markup = '*'
-  tokens.splice(insertAt, 0, emOpen)
-  if (insertAt <= openIdx) {
-    openIdx++
-    closeIdx++
+  const prefixReplacement = []
+  if (before) {
+    starToken.content = before
+    prefixReplacement.push(starToken)
   }
+  prefixReplacement.push(emOpen)
   if (after) {
     const afterToken = new Token('text', '', 0)
     afterToken.content = after
-    tokens.splice(insertAt + 1, 0, afterToken)
-    if (insertAt + 1 <= openIdx) {
-      openIdx++
-      closeIdx++
-    }
+    prefixReplacement.push(afterToken)
+  }
+  const prefixDelta = prefixReplacement.length - 1
+  tokens.splice(starTokenIdx, 1, ...prefixReplacement)
+  if (starTokenIdx < openIdx) {
+    openIdx += prefixDelta
+    closeIdx += prefixDelta
   }
 
   const openToken = tokens[openIdx]
@@ -634,19 +727,20 @@ const shiftEmWithLeadingStar = (tokens, rangeStart, rangeEnd, closeIdx) => {
   openToken.markup = '*'
   openToken.nesting = -1
 
-  tokens.splice(closeIdx, 1)
+  const tailReplacement = []
   const tailIdx = closeIdx - 1
   if (tailIdx >= 0 && tokens[tailIdx] && tokens[tailIdx].type === 'text') {
     tokens[tailIdx].content += '*'
   } else {
     const tail = new Token('text', '', 0)
     tail.content = '*'
-    tokens.splice(closeIdx, 0, tail)
+    tailReplacement.push(tail)
   }
+  tokens.splice(closeIdx, 1, ...tailReplacement)
   return true
 }
 
-const fixLeadingAsteriskEm = (tokens) => {
+const fixLeadingAsteriskEm = (tokens, onChangeStart = null) => {
   let changed = false
   for (let i = 0; i < tokens.length; i++) {
     const t = tokens[i]
@@ -656,7 +750,7 @@ const fixLeadingAsteriskEm = (tokens) => {
     const linkCloseIdx = nextIdx
     const linkOpenIdx = findLinkOpen(tokens, linkCloseIdx)
     if (linkOpenIdx === -1) continue
-    if (shiftEmWithLeadingStar(tokens, linkOpenIdx + 1, linkCloseIdx, i)) {
+    if (shiftEmWithLeadingStar(tokens, linkOpenIdx + 1, linkCloseIdx, i, onChangeStart)) {
       changed = true
       i = linkCloseIdx
     }
@@ -683,7 +777,7 @@ const patchScanDelims = (md) => {
 
     const baseOpt = this.md ? this.md.__strongJaTokenOpt : null
     const overrideOpt = this.env && this.env.__strongJaTokenOpt
-    const opt = overrideOpt ? getRuntimeOpt(this, baseOpt) : baseOpt
+    const opt = hasRuntimeOverride(overrideOpt) ? getRuntimeOpt(this, baseOpt) : baseOpt
     if (!opt) {
       return base
     }
@@ -694,6 +788,7 @@ const patchScanDelims = (md) => {
     const plusMode = (modeFlags & MODE_FLAG_JAPANESE_PLUS) !== 0
     const aggressiveMode = (modeFlags & MODE_FLAG_AGGRESSIVE) !== 0
     const max = this.posMax
+    let lookupCache = null
     const lastChar = start > 0 ? src.charCodeAt(start - 1) : 0x20
 
     const count = base && base.length ? base.length : 1
@@ -706,7 +801,15 @@ const patchScanDelims = (md) => {
     const rightJapanese = isJapaneseChar(nextChar)
     let hasJapaneseContext = leftJapanese || rightJapanese
     if (!hasJapaneseContext && count === 1) {
-      hasJapaneseContext = hasJapaneseContextForBracketWrapper(src, start, pos, max, lastChar, nextChar)
+      hasJapaneseContext = hasJapaneseContextForBracketWrapper(
+        src,
+        start,
+        pos,
+        max,
+        lastChar,
+        nextChar,
+        lookupCache || (lookupCache = getScanDelimsLookupCache(this))
+      )
     }
     if (!hasJapaneseContext && count === 1 && isExtraSingleStarClosePunct(lastChar)) {
       prevStarFlags = ensurePrevStarFlags(src, start, prevStarFlags)
@@ -721,22 +824,31 @@ const patchScanDelims = (md) => {
     let isLastWhiteSpace = isWhiteSpace(lastChar) || isSoftSpaceCode(lastChar)
     let isNextWhiteSpace = isWhiteSpace(nextChar) || isSoftSpaceCode(nextChar)
     if (isLastWhiteSpace && isSoftSpaceCode(lastChar)) {
-      const prevNonSpaceIdx = findPrevNonSpaceIndex(src, start - 2)
+      const prevNonSpaceIdx = findPrevNonSpaceIndex(
+        src,
+        start - 2,
+        lookupCache || (lookupCache = getScanDelimsLookupCache(this))
+      )
       if (prevNonSpaceIdx !== -1) {
         const prevNonSpaceLocal = src.charCodeAt(prevNonSpaceIdx)
         const plusStrictAsciiBoundary = plusMode &&
-          hasAsciiEndBeforeOptionalCloseWrappers(src, prevNonSpaceIdx)
+          hasAsciiEndBeforeOptionalCloseWrappers(src, prevNonSpaceIdx, lookupCache)
         if (prevNonSpaceLocal !== CHAR_ASTERISK && !plusStrictAsciiBoundary) {
           isLastWhiteSpace = false
         }
       }
     }
     if (isNextWhiteSpace && isSoftSpaceCode(nextChar)) {
-      const nextNonSpaceIdx = findNextNonSpaceIndex(src, pos, max)
+      const nextNonSpaceIdx = findNextNonSpaceIndex(
+        src,
+        pos,
+        max,
+        lookupCache || (lookupCache = getScanDelimsLookupCache(this))
+      )
       if (nextNonSpaceIdx !== -1) {
         const nextNonSpace = src.charCodeAt(nextNonSpaceIdx)
         const plusStrictAsciiBoundary = plusMode &&
-          hasAsciiStartAfterOptionalOpenWrappers(src, nextNonSpaceIdx, max)
+          hasAsciiStartAfterOptionalOpenWrappers(src, nextNonSpaceIdx, max, lookupCache)
         if (nextNonSpace !== CHAR_ASTERISK && !plusStrictAsciiBoundary) {
           isNextWhiteSpace = false
         }
@@ -805,6 +917,7 @@ const patchScanDelims = (md) => {
 
 export {
   rebuildInlineLevels,
+  rebuildInlineLevelsFrom,
   findLinkOpen,
   nextNonEmptyIndex,
   fixTrailingStrong,