@peaceroad/markdown-it-strong-ja 0.6.2 → 0.7.1

package/package.json

@@ -1,11 +1,12 @@
 {
   "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.6.2",
+  "version": "0.7.1",
   "main": "index.js",
   "type": "module",
   "files": [
     "index.js",
+    "src",
     "README.md",
     "LICENSE"
   ],
@@ -19,8 +20,8 @@
     "markdown-it": "^14.1.0"
   },
   "devDependencies": {
-    "@peaceroad/markdown-it-cjk-breaks-mod": "^0.1.4",
-    "@peaceroad/markdown-it-hr-sandwiched-semantic-container": "^0.8.0",
+    "@peaceroad/markdown-it-cjk-breaks-mod": "^0.1.5",
+    "@peaceroad/markdown-it-hr-sandwiched-semantic-container": "^0.8.2",
     "markdown-it-attrs": "^4.3.1",
     "markdown-it-sub": "^2.0.0",
     "markdown-it-sup": "^2.0.0"

package/src/token-compat.js

@@ -0,0 +1,226 @@
+import Token from 'markdown-it/lib/token.mjs'
+import {
+  REG_ATTRS,
+  isJapaneseChar,
+  hasCjkBreaksRule,
+  getRuntimeOpt,
+  moveRuleAfter
+} from './token-utils.js'
+
+const registerTokenCompat = (md, baseOpt) => {
+  const hasTextJoinRule = Array.isArray(md.core?.ruler?.__rules__)
+    ? md.core.ruler.__rules__.some((rule) => rule && rule.name === 'text_join')
+    : false
+
+  if (!md.__strongJaTokenTrimTrailingRegistered) {
+    md.__strongJaTokenTrimTrailingRegistered = true
+    const trimInlineTrailingSpaces = (state) => {
+      if (!state || !state.tokens) return
+      for (let i = 0; i < state.tokens.length; i++) {
+        const token = state.tokens[i]
+        if (!token || token.type !== 'inline' || !token.children || token.children.length === 0) continue
+        let idx = token.children.length - 1
+        while (idx >= 0 && (!token.children[idx] || (token.children[idx].type === 'text' && token.children[idx].content === ''))) {
+          idx--
+        }
+        if (idx < 0) continue
+        const tail = token.children[idx]
+        if (!tail || tail.type !== 'text' || !tail.content) continue
+        const trimmed = tail.content.replace(/[ \t]+$/, '')
+        if (trimmed !== tail.content) {
+          tail.content = trimmed
+        }
+      }
+    }
+    if (hasTextJoinRule) {
+      md.core.ruler.after('text_join', 'strong_ja_trim_trailing_spaces', trimInlineTrailingSpaces)
+    } else {
+      md.core.ruler.after('inline', 'strong_ja_trim_trailing_spaces', trimInlineTrailingSpaces)
+    }
+  }
+
+  if (!md.__strongJaTokenSoftbreakSpacingRegistered) {
+    md.__strongJaTokenSoftbreakSpacingRegistered = true
+    const normalizeSoftbreakSpacing = (state) => {
+      if (!state) return
+      if (baseOpt.hasCjkBreaks !== true && state.md) {
+        baseOpt.hasCjkBreaks = hasCjkBreaksRule(state.md)
+      }
+      if (baseOpt.hasCjkBreaks !== true) return
+      if (!state.tokens || state.tokens.length === 0) return
+      for (let i = 0; i < state.tokens.length; i++) {
+        const token = state.tokens[i]
+        if (!token || token.type !== 'inline' || !token.children || token.children.length === 0) continue
+        let hasEmphasis = false
+        for (let j = 0; j < token.children.length; j++) {
+          const child = token.children[j]
+          if (!child) continue
+          if (child.type === 'strong_open' || child.type === 'strong_close' || child.type === 'em_open' || child.type === 'em_close') {
+            hasEmphasis = true
+            break
+          }
+        }
+        for (let j = 0; j < token.children.length; j++) {
+          const child = token.children[j]
+          if (!child) continue
+          if (child.type === 'softbreak') {
+            if (!hasEmphasis) continue
+            const prevToken = token.children[j - 1]
+            const nextToken = token.children[j + 1]
+            if (!prevToken || !nextToken) continue
+            if (prevToken.type !== 'text' || !prevToken.content) continue
+            if (nextToken.type !== 'text' || !nextToken.content) continue
+            const prevChar = prevToken.content.slice(-1)
+            const nextChar = nextToken.content.charAt(0)
+            const isAsciiWord = nextChar >= '0' && nextChar <= 'z' && /[A-Za-z0-9]/.test(nextChar)
+            const shouldReplace = isAsciiWord && nextChar !== '{' && nextChar !== '\\' && isJapaneseChar(prevChar) && !isJapaneseChar(nextChar)
+            if (!shouldReplace) continue
+            child.type = 'text'
+            child.tag = ''
+            child.content = ' '
+            child.markup = ''
+            child.info = ''
+            continue
+          }
+          if (child.type !== 'text' || !child.content) continue
+          if (!hasEmphasis) continue
+          if (child.content.indexOf('\n') === -1) continue
+          let normalized = ''
+          for (let idx = 0; idx < child.content.length; idx++) {
+            const ch = child.content[idx]
+            if (ch === '\n') {
+              const prevChar = idx > 0 ? child.content[idx - 1] : ''
+              const nextChar = idx + 1 < child.content.length ? child.content[idx + 1] : ''
+              const isAsciiWord = nextChar && nextChar >= '0' && nextChar <= 'z' && /[A-Za-z0-9]/.test(nextChar)
+              const shouldReplace = isAsciiWord && nextChar !== '{' && nextChar !== '\\' && isJapaneseChar(prevChar) && !isJapaneseChar(nextChar)
+              if (shouldReplace) {
+                normalized += ' '
+                continue
+              }
+            }
+            normalized += ch
+          }
+          if (normalized !== child.content) {
+            child.content = normalized
+          }
+        }
+      }
+    }
+    if (hasTextJoinRule) {
+      md.core.ruler.after('text_join', 'strong_ja_softbreak_spacing', normalizeSoftbreakSpacing)
+    } else {
+      md.core.ruler.after('inline', 'strong_ja_softbreak_spacing', normalizeSoftbreakSpacing)
+    }
+  }
+
+  const restoreSoftbreaksAfterCjk = (state) => {
+    if (!state) return
+    const opt = getRuntimeOpt(state, baseOpt)
+    if (opt.mditAttrs !== false) return
+    if (!state.md || state.md.__strongJaRestoreSoftbreaksForAttrs !== true) return
+    if (baseOpt.hasCjkBreaks !== true && state.md) {
+      baseOpt.hasCjkBreaks = hasCjkBreaksRule(state.md)
+    }
+    if (baseOpt.hasCjkBreaks !== true) return
+    if (!state.tokens || state.tokens.length === 0) return
+    for (let i = 0; i < state.tokens.length; i++) {
+      const token = state.tokens[i]
+      if (!token || token.type !== 'inline' || !token.children || token.children.length === 0) continue
+      const children = token.children
+      for (let j = 0; j < children.length; j++) {
+        const child = children[j]
+        if (!child || child.type !== 'text' || child.content !== '') continue
+        let prevChar = ''
+        for (let k = j - 1; k >= 0; k--) {
+          const prev = children[k]
+          if (prev && prev.type === 'text' && prev.content) {
+            prevChar = prev.content.charAt(prev.content.length - 1)
+            break
+          }
+        }
+        if (!prevChar || !isJapaneseChar(prevChar)) continue
+        const next = children[j + 1]
+        if (!next || next.type !== 'text' || !next.content) continue
+        const nextChar = next.content.charAt(0)
+        if (nextChar !== '{') continue
+        child.type = 'softbreak'
+        child.tag = ''
+        child.content = '\n'
+        child.markup = ''
+        child.info = ''
+      }
+    }
+  }
+
+  const registerRestoreSoftbreaks = () => {
+    if (baseOpt.mditAttrs !== false) return
+    if (md.__strongJaTokenRestoreRegistered) return
+    const anchorRule = hasTextJoinRule ? 'text_join' : 'inline'
+    const added = md.core.ruler.after(anchorRule, 'strong_ja_restore_softbreaks', restoreSoftbreaksAfterCjk)
+    if (added !== false) {
+      md.__strongJaTokenRestoreRegistered = true
+      md.__strongJaRestoreSoftbreaksForAttrs = baseOpt.mditAttrs === false
+      if (baseOpt.hasCjkBreaks) {
+        moveRuleAfter(md.core.ruler, 'strong_ja_restore_softbreaks', 'cjk_breaks')
+      }
+      if (baseOpt.patchCorePush !== false && !md.__strongJaTokenPatchCorePush) {
+        md.__strongJaTokenPatchCorePush = true
+        const originalPush = md.core.ruler.push.bind(md.core.ruler)
+        md.core.ruler.push = (name, fn, options) => {
+          const res = originalPush(name, fn, options)
+          if (name && name.indexOf && name.indexOf('cjk_breaks') !== -1) {
+            baseOpt.hasCjkBreaks = true
+            moveRuleAfter(md.core.ruler, 'strong_ja_restore_softbreaks', name)
+          }
+          return res
+        }
+      }
+      if (baseOpt.hasCjkBreaks) {
+        moveRuleAfter(md.core.ruler, 'strong_ja_restore_softbreaks', 'cjk_breaks')
+      }
+    }
+  }
+  registerRestoreSoftbreaks()
+
+  if (baseOpt.mditAttrs !== false && !md.__strongJaTokenPreAttrsRegistered) {
+    md.__strongJaTokenPreAttrsRegistered = true
+    md.core.ruler.before('linkify', 'strong_ja_token_pre_attrs', (state) => {
+      if (!state || !state.tokens) return
+      const opt = getRuntimeOpt(state, baseOpt)
+      if (opt.mditAttrs === false) return
+      for (let i = 0; i < state.tokens.length; i++) {
+        const token = state.tokens[i]
+        if (!token || token.type !== 'inline' || !token.children || token.children.length === 0) continue
+        const children = token.children
+        let lastMeaningful = children.length - 1
+        while (lastMeaningful >= 0) {
+          const child = children[lastMeaningful]
+          if (!child) {
+            lastMeaningful--
+            continue
+          }
+          if (child.type === 'text' && child.content === '') {
+            lastMeaningful--
+            continue
+          }
+          break
+        }
+        for (let j = 0; j <= lastMeaningful; j++) {
+          const child = children[j]
+          if (!child || child.type !== 'text' || !child.content) continue
+          const content = child.content
+          if (content.charCodeAt(0) !== 0x7B || content.charCodeAt(content.length - 1) !== 0x7D) continue
+          if (REG_ATTRS.test(content)) continue
+          if (j !== lastMeaningful) continue
+          const placeholder = new Token('text', '', 0)
+          placeholder.content = ''
+          children.splice(j + 1, 0, placeholder)
+          lastMeaningful = j
+          j++
+        }
+      }
+    })
+  }
+}
+
+export { registerTokenCompat }

package/src/token-core.js

@@ -0,0 +1,439 @@
+import { isWhiteSpace } from 'markdown-it/lib/common/utils.mjs'
+import Token from 'markdown-it/lib/token.mjs'
+import {
+  CHAR_ASTERISK,
+  CHAR_SPACE,
+  CHAR_TAB,
+  findPrevNonSpace,
+  findNextNonSpace,
+  resolveMode,
+  shouldUseJapaneseRule,
+  getRuntimeOpt
+} from './token-utils.js'
+
+const findMatchingEmOpen = (tokens, closeIdx) => {
+  let depth = 0
+  for (let i = closeIdx; i >= 0; i--) {
+    const t = tokens[i]
+    if (!t) continue
+    if (t.type === 'em_close') depth++
+    if (t.type === 'em_open') {
+      depth--
+      if (depth === 0) return i
+    }
+  }
+  return -1
+}
+
+const rebuildInlineLevels = (tokens) => {
+  let level = 0
+  for (let i = 0; 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 findLinkClose = (tokens, startIdx) => {
+  let depth = 0
+  for (let i = startIdx; i < tokens.length; i++) {
+    const t = tokens[i]
+    if (!t) continue
+    if (t.type === 'link_open') depth++
+    if (t.type === 'link_close') {
+      depth--
+      if (depth === 0) return i
+    }
+  }
+  return -1
+}
+
+const findLinkOpen = (tokens, closeIdx) => {
+  let depth = 0
+  for (let i = closeIdx; i >= 0; i--) {
+    const t = tokens[i]
+    if (!t) continue
+    if (t.type === 'link_close') depth++
+    if (t.type === 'link_open') {
+      depth--
+      if (depth === 0) return i
+    }
+  }
+  return -1
+}
+
+const nextNonEmptyIndex = (tokens, startIdx) => {
+  for (let i = startIdx; i < tokens.length; i++) {
+    const t = tokens[i]
+    if (!t) continue
+    if (t.type !== 'text') return i
+    if (t.content) return i
+  }
+  return -1
+}
+
+const fixTrailingStrong = (tokens) => {
+  let changed = false
+  for (let i = 1; i < tokens.length; i++) {
+    const token = tokens[i]
+    if (!token || token.type !== 'text' || !token.content) continue
+    const starIdx = token.content.indexOf('**')
+    if (starIdx <= 0) continue
+    if (!tokens[i - 1] || tokens[i - 1].type !== 'em_close') continue
+
+    const closeIdx = i - 1
+    const openIdx = findMatchingEmOpen(tokens, closeIdx)
+    if (openIdx === -1) continue
+
+    let hasInnerEm = false
+    let emDepth = 0
+    let hasStrongBetween = false
+    for (let j = openIdx + 1; j < closeIdx; j++) {
+      const t = tokens[j]
+      if (!t) continue
+      if (t.type === 'strong_open' || t.type === 'strong_close') {
+        hasStrongBetween = true
+        break
+      }
+      if (t.type === 'em_open') {
+        if (emDepth === 0) hasInnerEm = true
+        emDepth++
+      } else if (t.type === 'em_close') {
+        if (emDepth > 0) emDepth--
+      }
+    }
+    if (hasStrongBetween || !hasInnerEm) continue
+
+    const innerOpenIdx = openIdx + 1
+    if (innerOpenIdx + 3 < closeIdx &&
+        tokens[innerOpenIdx] && tokens[innerOpenIdx].type === 'em_open' &&
+        tokens[innerOpenIdx + 1] && tokens[innerOpenIdx + 1].type === 'text' &&
+        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 before = token.content.slice(0, starIdx)
+    const after = token.content.slice(starIdx + 2)
+
+    tokens.splice(closeIdx, 1)
+    if (closeIdx < i) i--
+
+    const openToken = tokens[openIdx]
+    if (!openToken) continue
+    openToken.type = 'strong_open'
+    openToken.tag = 'strong'
+    openToken.markup = '**'
+    openToken.nesting = 1
+
+    if (before) {
+      token.content = before
+    } else {
+      tokens.splice(i, 1)
+      i--
+    }
+
+    const insertAt = i + 1
+    const strongClose = new Token('strong_close', 'strong', -1)
+    strongClose.markup = '**'
+    tokens.splice(insertAt, 0, strongClose)
+    if (after) {
+      const tail = new Token('text', '', 0)
+      tail.content = after
+      tokens.splice(insertAt + 1, 0, tail)
+    }
+    changed = true
+  }
+  return changed
+}
+
+function fixEmOuterStrongSequence(tokens) {
+  let changed = false
+  let i = 0
+  while (i < tokens.length) {
+    const idx0 = nextNonEmptyIndex(tokens, i)
+    if (idx0 === -1) break
+    const t0 = tokens[idx0]
+    if (!t0 || t0.type !== 'em_open') {
+      i = idx0 + 1
+      continue
+    }
+    const idx1 = nextNonEmptyIndex(tokens, idx0 + 1)
+    const idx2 = idx1 === -1 ? -1 : nextNonEmptyIndex(tokens, idx1 + 1)
+    const idx3 = idx2 === -1 ? -1 : nextNonEmptyIndex(tokens, idx2 + 1)
+    const idx4 = idx3 === -1 ? -1 : nextNonEmptyIndex(tokens, idx3 + 1)
+    const idx5 = idx4 === -1 ? -1 : nextNonEmptyIndex(tokens, idx4 + 1)
+    const idx6 = idx5 === -1 ? -1 : nextNonEmptyIndex(tokens, idx5 + 1)
+    const idx7 = idx6 === -1 ? -1 : nextNonEmptyIndex(tokens, idx6 + 1)
+    if (idx7 === -1) break
+
+    const t1 = tokens[idx1]
+    const t2 = tokens[idx2]
+    const t3 = tokens[idx3]
+    const t4 = tokens[idx4]
+    const t5 = tokens[idx5]
+    const t6 = tokens[idx6]
+    const t7 = tokens[idx7]
+
+    if (!t1 || !t2 || !t3 || !t4 || !t5 || !t6 || !t7) {
+      i = idx0 + 1
+      continue
+    }
+    if (t1.type !== 'em_open') {
+      i = idx0 + 1
+      continue
+    }
+    if (t3.type !== 'em_close' || t5.type !== 'em_close') {
+      i = idx0 + 1
+      continue
+    }
+    if (t7.type !== 'strong_open') {
+      i = idx0 + 1
+      continue
+    }
+    if (t2.type !== 'text' || !t2.content) {
+      i = idx0 + 1
+      continue
+    }
+    if (t4.type !== 'text' || !t4.content) {
+      i = idx0 + 1
+      continue
+    }
+    if (t6.type !== 'text' || !t6.content) {
+      i = idx0 + 1
+      continue
+    }
+
+    t0.type = 'strong_open'
+    t0.tag = 'strong'
+    t0.markup = '**'
+    t0.nesting = 1
+
+    const emOpen = new Token('em_open', 'em', 1)
+    emOpen.markup = '*'
+    const emClose = new Token('em_close', 'em', -1)
+    emClose.markup = '*'
+    const strongClose = new Token('strong_close', 'strong', -1)
+    strongClose.markup = '**'
+
+    const removeIndices = [idx7, idx5, idx3, idx1].sort((a, b) => b - a)
+    for (const removeIdx of removeIndices) {
+      if (removeIdx >= 0 && removeIdx < tokens.length) {
+        tokens.splice(removeIdx, 1)
+      }
+    }
+
+    const idxT4 = tokens.indexOf(t4)
+    if (idxT4 === -1) {
+      changed = true
+      i = idx0 + 1
+      continue
+    }
+    tokens.splice(idxT4, 0, emOpen)
+
+    let idxT6 = tokens.indexOf(t6)
+    if (idxT6 === -1) {
+      changed = true
+      i = idx0 + 1
+      continue
+    }
+    tokens.splice(idxT6, 0, emClose)
+
+    idxT6 = tokens.indexOf(t6)
+    if (idxT6 === -1) {
+      changed = true
+      i = idx0 + 1
+      continue
+    }
+    tokens.splice(idxT6 + 1, 0, strongClose)
+
+    changed = true
+    i = idxT6 + 2
+  }
+  return changed
+}
+
+const shiftEmWithLeadingStar = (tokens, rangeStart, rangeEnd, closeIdx) => {
+  let openIdx = findMatchingEmOpen(tokens, closeIdx)
+  if (openIdx === -1 || openIdx < rangeStart || openIdx >= rangeEnd) return false
+
+  for (let j = openIdx + 1; j < closeIdx; j++) {
+    if (!tokens[j]) continue
+    if (tokens[j].type === 'em_open' || tokens[j].type === 'em_close') return false
+  }
+
+  let starTokenIdx = -1
+  let starPos = -1
+  for (let i = openIdx - 1; i >= rangeStart; i--) {
+    const t = tokens[i]
+    if (!t || t.type !== 'text' || !t.content) continue
+    const pos = t.content.lastIndexOf('*')
+    if (pos <= 0) continue
+    const prevChar = t.content.charAt(pos - 1)
+    const nextChar = pos + 1 < t.content.length ? t.content.charAt(pos + 1) : ''
+    if (!/\s/.test(prevChar)) continue
+    if (!nextChar || /\s/.test(nextChar) || nextChar === '*') continue
+    starTokenIdx = i
+    starPos = pos
+    break
+  }
+  if (starTokenIdx === -1) return false
+
+  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--
+    }
+  }
+
+  const emOpen = new Token('em_open', 'em', 1)
+  emOpen.markup = '*'
+  tokens.splice(insertAt, 0, emOpen)
+  if (insertAt <= openIdx) {
+    openIdx++
+    closeIdx++
+  }
+  if (after) {
+    const afterToken = new Token('text', '', 0)
+    afterToken.content = after
+    tokens.splice(insertAt + 1, 0, afterToken)
+    if (insertAt + 1 <= openIdx) {
+      openIdx++
+      closeIdx++
+    }
+  }
+
+  const openToken = tokens[openIdx]
+  if (!openToken) return false
+  openToken.type = 'em_close'
+  openToken.tag = 'em'
+  openToken.markup = '*'
+  openToken.nesting = -1
+
+  tokens.splice(closeIdx, 1)
+  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)
+  }
+  return true
+}
+
+const fixLeadingAsteriskEm = (tokens) => {
+  let changed = false
+  for (let i = 0; i < tokens.length; i++) {
+    const t = tokens[i]
+    if (!t || t.type !== 'em_close') continue
+    const nextIdx = nextNonEmptyIndex(tokens, i + 1)
+    if (nextIdx === -1 || tokens[nextIdx].type !== 'link_close') continue
+    const linkCloseIdx = nextIdx
+    const linkOpenIdx = findLinkOpen(tokens, linkCloseIdx)
+    if (linkOpenIdx === -1) continue
+    if (shiftEmWithLeadingStar(tokens, linkOpenIdx + 1, linkCloseIdx, i)) {
+      changed = true
+      i = linkCloseIdx
+    }
+  }
+  return changed
+}
+
+const patchScanDelims = (md) => {
+  if (md.__strongJaTokenScanDelimsPatched) return
+  md.__strongJaTokenScanDelimsPatched = true
+
+  const original = md.inline.State.prototype.scanDelims
+  md.inline.State.prototype.scanDelims = function strongJaTokenScanDelims(start, canSplitWord) {
+    const marker = this.src.charCodeAt(start)
+    if (marker !== CHAR_ASTERISK) {
+      return original.call(this, start, canSplitWord)
+    }
+
+    const baseOpt = this.md && this.md.__strongJaTokenOpt ? this.md.__strongJaTokenOpt : null
+    const opt = getRuntimeOpt(this, baseOpt)
+    if (!opt) {
+      return original.call(this, start, canSplitWord)
+    }
+    const mode = resolveMode(opt)
+    const useJapaneseRule = shouldUseJapaneseRule(this, opt, mode)
+    if (!useJapaneseRule) {
+      return original.call(this, start, canSplitWord)
+    }
+
+    const max = this.posMax
+    const lastChar = start > 0 ? this.src.charCodeAt(start - 1) : 0x20
+
+    let pos = start
+    while (pos < max && this.src.charCodeAt(pos) === marker) { pos++ }
+    const count = pos - start
+
+    const nextChar = pos < max ? this.src.charCodeAt(pos) : 0x20
+
+    const isLastPunctChar = false
+    const isNextPunctChar = false
+
+    let isLastWhiteSpace = isWhiteSpace(lastChar)
+    let isNextWhiteSpace = isWhiteSpace(nextChar)
+    if (useJapaneseRule) {
+      if (isLastWhiteSpace && (lastChar === CHAR_SPACE || lastChar === CHAR_TAB)) {
+        const prevNonSpace = findPrevNonSpace(this.src, start - 2)
+        if (prevNonSpace && prevNonSpace !== CHAR_ASTERISK) {
+          isLastWhiteSpace = false
+        }
+      }
+      if (isNextWhiteSpace && (nextChar === CHAR_SPACE || nextChar === CHAR_TAB)) {
+        const nextNonSpace = findNextNonSpace(this.src, pos, max)
+        if (nextNonSpace && nextNonSpace !== CHAR_ASTERISK) {
+          isNextWhiteSpace = false
+        }
+      }
+    }
+
+    const left_flanking =
+      !isNextWhiteSpace && (!isNextPunctChar || isLastWhiteSpace || isLastPunctChar)
+    const right_flanking =
+      !isLastWhiteSpace && (!isLastPunctChar || isNextWhiteSpace || isNextPunctChar)
+
+    const can_open = left_flanking && (canSplitWord || !right_flanking || isLastPunctChar)
+    const can_close = right_flanking && (canSplitWord || !left_flanking || isNextPunctChar)
+
+    const forbidClose = lastChar === 0x5B || lastChar === 0x28
+    const forbidOpen = nextChar === 0x5D || nextChar === 0x29
+    return {
+      can_open: forbidOpen ? false : can_open,
+      can_close: forbidClose ? false : can_close,
+      length: count
+    }
+  }
+}
+
+export {
+  rebuildInlineLevels,
+  findLinkClose,
+  findLinkOpen,
+  nextNonEmptyIndex,
+  fixTrailingStrong,
+  fixEmOuterStrongSequence,
+  fixLeadingAsteriskEm,
+  patchScanDelims
+}