@peaceroad/markdown-it-strong-ja 0.7.2 → 0.8.1

package/src/token-link-utils.js

@@ -1,23 +1,54 @@
 import Token from 'markdown-it/lib/token.mjs'
-import { parseLinkDestination, parseLinkTitle } from 'markdown-it/lib/helpers/index.mjs'
-import { isSpace, isWhiteSpace } from 'markdown-it/lib/common/utils.mjs'
+import { isWhiteSpace } from 'markdown-it/lib/common/utils.mjs'
+import { getReferenceCount } from './token-utils.js'
 
 const CHAR_OPEN_BRACKET = 0x5B // [
 const CHAR_CLOSE_BRACKET = 0x5D // ]
-const CHAR_OPEN_PAREN = 0x28 // (
-const CHAR_CLOSE_PAREN = 0x29 // )
 
 const isWhitespaceToken = (token) => {
   if (!token || token.type !== 'text') return false
   const content = token.content
-  if (!content) return true
+  if (token.__strongJaWhitespaceSource === content &&
+      typeof token.__strongJaIsWhitespace === 'boolean') {
+    return token.__strongJaIsWhitespace
+  }
+  if (!content) {
+    token.__strongJaWhitespaceSource = content
+    token.__strongJaIsWhitespace = true
+    return true
+  }
+  let isWhitespace = true
   for (let i = 0; i < content.length; i++) {
-    if (!isWhiteSpace(content.charCodeAt(i))) return false
+    if (!isWhiteSpace(content.charCodeAt(i))) {
+      isWhitespace = false
+      break
+    }
   }
-  return true
+  token.__strongJaWhitespaceSource = content
+  token.__strongJaIsWhitespace = isWhitespace
+  return isWhitespace
+}
+
+const hasReferenceLabelMarkerRange = (tokens, startIdx, endIdx) => {
+  if (startIdx > endIdx) return false
+  for (let idx = startIdx; idx <= endIdx; idx++) {
+    const token = tokens[idx]
+    if (!token || !token.type) continue
+    if (token.type === 'text' || token.type === 'code_inline') {
+      const content = token.content
+      if (content && (content.indexOf('*') !== -1 || content.indexOf('_') !== -1)) return true
+      continue
+    }
+    if (token.type === 'softbreak' || token.type === 'hardbreak') continue
+    if (token.markup &&
+        (token.type.endsWith('_open') || token.type.endsWith('_close')) &&
+        (token.markup.indexOf('*') !== -1 || token.markup.indexOf('_') !== -1)) {
+      return true
+    }
+  }
+  return false
 }
 
-// Collapsed reference helpers
 const buildReferenceLabelRange = (tokens, startIdx, endIdx) => {
   if (startIdx > endIdx) return ''
   let label = ''
@@ -28,23 +59,15 @@ const buildReferenceLabelRange = (tokens, startIdx, endIdx) => {
       label += token.content
     } else if (token.type === 'softbreak' || token.type === 'hardbreak') {
       label += ' '
-    } else if (token.type && token.type.endsWith('_open') && token.markup) {
-      label += token.markup
-    } else if (token.type && token.type.endsWith('_close') && token.markup) {
+    } else if (token.type && token.markup && (token.type.endsWith('_open') || token.type.endsWith('_close'))) {
       label += token.markup
     }
   }
   return label
 }
 
-const cleanLabelText = (label) => {
-  if (label.indexOf('*') === -1 && label.indexOf('_') === -1) return label
-  return label.replace(/^[*_]+/, '').replace(/[*_]+$/, '')
-}
-
-const normalizeReferenceCandidate = (state, text, { useClean = false } = {}) => {
-  const source = useClean ? cleanLabelText(text) : text
-  return normalizeRefKey(state, source)
+const normalizeReferenceCandidate = (state, text) => {
+  return getNormalizeRef(state)(text)
 }
 
 const getNormalizeRef = (state) => {
@@ -56,15 +79,6 @@ const getNormalizeRef = (state) => {
   return normalize
 }
 
-const normalizeRefKey = (state, label) => {
-  return getNormalizeRef(state)(label)
-}
-
-const adjustTokenLevels = (tokens, startIdx, endIdx, delta) => {
-  for (let i = startIdx; i < endIdx; i++) {
-    if (tokens[i]) tokens[i].level += delta
-  }
-}
 
 const cloneMap = (map) => {
   if (!map || !Array.isArray(map)) return null
@@ -102,12 +116,23 @@ const cloneTextToken = (source, content) => {
   Object.assign(newToken, source)
   newToken.content = content
   if (source.meta) newToken.meta = { ...source.meta }
-  if (source.map) newToken.map = source.map
   return newToken
 }
 
-// Split only text tokens that actually contain bracket characters
-const splitBracketToken = (tokens, index, options) => {
+const applyBracketSegmentFlags = (token, seg) => {
+  if (seg === '[' || seg === ']') {
+    token.__strongJaHasBracket = true
+    token.__strongJaBracketAtomic = true
+  } else if (seg === '[]') {
+    token.__strongJaHasBracket = true
+    token.__strongJaBracketAtomic = true
+  } else {
+    token.__strongJaHasBracket = false
+    token.__strongJaBracketAtomic = false
+  }
+}
+
+const splitBracketToken = (tokens, index) => {
   const token = tokens[index]
   if (!token || token.type !== 'text') return false
   if (token.__strongJaBracketAtomic) return false
@@ -126,82 +151,49 @@ const splitBracketToken = (tokens, index, options) => {
     }
     token.__strongJaHasBracket = true
   }
-  const splitEmptyPair = options && options.splitEmptyPair
   const segments = []
-  let buffer = ''
+  const contentLen = content.length
   let pos = 0
-  while (pos < content.length) {
-    if (!splitEmptyPair &&
-        content.charCodeAt(pos) === CHAR_OPEN_BRACKET &&
+  let segmentStart = 0
+  while (pos < contentLen) {
+    const code = content.charCodeAt(pos)
+    if (code === CHAR_OPEN_BRACKET &&
         content.charCodeAt(pos + 1) === CHAR_CLOSE_BRACKET) {
-      if (buffer) {
-        segments.push(buffer)
-        buffer = ''
+      if (segmentStart < pos) {
+        segments.push(content.slice(segmentStart, pos))
       }
       segments.push('[]')
       pos += 2
+      segmentStart = pos
       continue
     }
-    const ch = content[pos]
-    if (ch === '[' || ch === ']') {
-      if (buffer) {
-        segments.push(buffer)
-        buffer = ''
+    if (code === CHAR_OPEN_BRACKET || code === CHAR_CLOSE_BRACKET) {
+      if (segmentStart < pos) {
+        segments.push(content.slice(segmentStart, pos))
       }
-      segments.push(ch)
+      segments.push(code === CHAR_OPEN_BRACKET ? '[' : ']')
       pos++
+      segmentStart = pos
       continue
     }
-    buffer += ch
     pos++
   }
-  if (buffer) segments.push(buffer)
+  if (segmentStart < contentLen) segments.push(content.slice(segmentStart))
   if (segments.length <= 1) {
-    if (segments.length === 0) {
-      token.__strongJaHasBracket = false
-      token.__strongJaBracketAtomic = false
-    } else {
-      const seg = segments[0]
-      if (seg === '[' || seg === ']') {
-        token.__strongJaHasBracket = true
-        token.__strongJaBracketAtomic = true
-      } else if (seg === '[]') {
-        token.__strongJaHasBracket = true
-        token.__strongJaBracketAtomic = false
-      } else {
-        token.__strongJaHasBracket = false
-        token.__strongJaBracketAtomic = false
-      }
-    }
+    applyBracketSegmentFlags(token, segments[0])
     return false
   }
+
   token.content = segments[0]
-  if (token.content === '[' || token.content === ']') {
-    token.__strongJaHasBracket = true
-    token.__strongJaBracketAtomic = true
-  } else if (token.content === '[]') {
-    token.__strongJaHasBracket = true
-    token.__strongJaBracketAtomic = false
-  } else {
-    token.__strongJaHasBracket = false
-    token.__strongJaBracketAtomic = false
-  }
-  let insertIdx = index + 1
+  applyBracketSegmentFlags(token, token.content)
+
+  const replacements = [token]
   for (let s = 1; s < segments.length; s++) {
     const newToken = cloneTextToken(token, segments[s])
-    if (segments[s] === '[' || segments[s] === ']') {
-      newToken.__strongJaHasBracket = true
-      newToken.__strongJaBracketAtomic = true
-    } else if (segments[s] === '[]') {
-      newToken.__strongJaHasBracket = true
-      newToken.__strongJaBracketAtomic = false
-    } else {
-      newToken.__strongJaHasBracket = false
-      newToken.__strongJaBracketAtomic = false
-    }
-    tokens.splice(insertIdx, 0, newToken)
-    insertIdx++
+    applyBracketSegmentFlags(newToken, segments[s])
+    replacements.push(newToken)
   }
+  tokens.splice(index, 1, ...replacements)
   return true
 }
 
@@ -209,48 +201,36 @@ const isBracketToken = (token, bracket) => {
   return token && token.type === 'text' && token.content === bracket
 }
 
-const findLinkCloseIndex = (tokens, startIdx) => {
-  let depth = 0
-  for (let idx = startIdx; idx < tokens.length; idx++) {
-    const token = tokens[idx]
-    if (token.type === 'link_open') depth++
-    if (token.type === 'link_close') {
-      depth--
-      if (depth === 0) return idx
-    }
-  }
-  return -1
-}
-
-const consumeCharactersFromTokens = (tokens, startIdx, count) => {
-  let remaining = count
-  let idx = startIdx
-  while (idx < tokens.length && remaining > 0) {
-    const token = tokens[idx]
-    if (!token || token.type !== 'text') {
-      return false
-    }
-    const len = token.content.length
-    if (remaining >= len) {
-      remaining -= len
-      tokens.splice(idx, 1)
+const buildLinkCloseMap = (tokens, startIdx, endIdx) => {
+  const closeMap = new Map()
+  const stack = []
+  const max = tokens ? tokens.length - 1 : -1
+  const from = startIdx > 0 ? startIdx : 0
+  const to = endIdx < max ? endIdx : max
+  for (let i = from; i <= to; i++) {
+    const token = tokens[i]
+    if (!token) continue
+    if (token.type === 'link_open') {
+      stack.push(i)
       continue
     }
-    token.content = token.content.slice(remaining)
-    remaining = 0
+    if (token.type !== 'link_close' || stack.length === 0) continue
+    closeMap.set(stack.pop(), i)
   }
-  return remaining === 0
+  return closeMap
 }
 
-const wrapLabelTokensWithLink = (tokens, labelStartIdx, labelEndIdx, linkOpenToken, linkCloseToken, labelSource) => {
+const collectWrappedLabelPairs = (tokens, collapsedStartIdx, collapsedEndIdx) => {
   const wrapperPairs = []
-  let startIdx = labelStartIdx
-  let endIdx = labelEndIdx
-  while (startIdx > 0) {
-    const prevToken = tokens[startIdx - 1]
-    const nextToken = tokens[endIdx + 1]
+  while (true) {
+    const wrapperOffset = wrapperPairs.length
+    const closeIdx = collapsedStartIdx - 1 - wrapperOffset
+    const openIdx = collapsedEndIdx + 1 + wrapperOffset
+    if (closeIdx < 0 || openIdx >= tokens.length) break
+    const prevToken = tokens[closeIdx]
+    const nextToken = tokens[openIdx]
     if (!prevToken || !nextToken) break
-    if (!/_close$/.test(prevToken.type)) break
+    if (!prevToken.type || !prevToken.type.endsWith('_close')) break
     const expectedOpen = prevToken.type.replace('_close', '_open')
     if (nextToken.type !== expectedOpen) break
     wrapperPairs.push({
@@ -258,483 +238,377 @@ const wrapLabelTokensWithLink = (tokens, labelStartIdx, labelEndIdx, linkOpenTok
       tag: prevToken.tag,
       markup: prevToken.markup,
       openMap: cloneMap(nextToken.map),
-      closeMap: cloneMap(prevToken.map)
+      closeMap: cloneMap(prevToken.map),
+      closeIdx,
+      openIdx
     })
-    tokens.splice(endIdx + 1, 1)
-    tokens.splice(startIdx - 1, 1)
-    startIdx -= 1
-    endIdx -= 1
-  }
-
-  if (startIdx > endIdx) {
-    if (labelSource !== undefined && labelSource !== null) {
-      const placeholder = new Token('text', '', 0)
-      placeholder.content = labelSource
-      placeholder.level = linkOpenToken.level + 1
-      tokens.splice(startIdx, 0, placeholder)
-      endIdx = startIdx
-    } else {
-      return startIdx
+  }
+  return wrapperPairs
+}
+
+const resolveWrappedLabelReplaceRange = (wrapperPairs, collapsedStartIdx, collapsedEndIdx) => {
+  if (wrapperPairs.length === 0) {
+    return {
+      replaceStart: collapsedStartIdx,
+      replaceEnd: collapsedEndIdx
     }
   }
+  const outerPair = wrapperPairs[wrapperPairs.length - 1]
+  return {
+    replaceStart: outerPair.closeIdx,
+    replaceEnd: outerPair.openIdx
+  }
+}
+
+const resolveInsertedWrapperMap = (pairMap, labelMap) => {
+  return pairMap || labelMap
+}
 
-  let labelLength = endIdx - startIdx + 1
-  const firstLabelToken = tokens[startIdx]
+const buildWrappedLabelReplacement = (labelTokens, linkOpenToken, linkCloseToken, wrapperPairs, labelMap) => {
+  const firstLabelToken = labelTokens[0]
   const linkLevel = firstLabelToken ? Math.max(firstLabelToken.level - 1, 0) : 0
   linkOpenToken.level = linkLevel
   linkCloseToken.level = linkLevel
-  const labelMap = getMapFromTokenRange(tokens, startIdx, endIdx) || getNearbyMap(tokens, startIdx, endIdx)
   if (labelMap) {
     if (!linkOpenToken.map) linkOpenToken.map = cloneMap(labelMap)
     if (!linkCloseToken.map) linkCloseToken.map = cloneMap(labelMap)
   }
-  tokens.splice(startIdx, 0, linkOpenToken)
-  tokens.splice(startIdx + labelLength + 1, 0, linkCloseToken)
-
-  adjustTokenLevels(tokens, startIdx + 1, startIdx + labelLength + 1, 1)
-
-  if (wrapperPairs.length > 0) {
-    let insertIdx = startIdx + 1
-    for (let wp = 0; wp < wrapperPairs.length; wp++) {
-      const pair = wrapperPairs[wp]
-      const innerOpen = new Token(pair.base + '_open', pair.tag, 1)
-      innerOpen.markup = pair.markup
-      innerOpen.level = linkLevel + 1 + wp
-      if (pair.openMap && !innerOpen.map) innerOpen.map = cloneMap(pair.openMap)
-      tokens.splice(insertIdx, 0, innerOpen)
-      insertIdx++
-      labelLength++
-    }
-    let linkClosePos = startIdx + labelLength + 1
-    for (let wp = wrapperPairs.length - 1; wp >= 0; wp--) {
-      const pair = wrapperPairs[wp]
-      const innerClose = new Token(pair.base + '_close', pair.tag, -1)
-      innerClose.markup = pair.markup
-      innerClose.level = linkLevel + 1 + wp
-      if (pair.closeMap && !innerClose.map) innerClose.map = cloneMap(pair.closeMap)
-      tokens.splice(linkClosePos, 0, innerClose)
-      labelLength++
-    }
+  for (let idx = 0; idx < labelTokens.length; idx++) {
+    if (labelTokens[idx]) labelTokens[idx].level += 1
   }
 
-  return startIdx + labelLength + 2
+  const replacement = [linkOpenToken]
+  for (let wp = 0; wp < wrapperPairs.length; wp++) {
+    const pair = wrapperPairs[wp]
+    const innerOpen = new Token(pair.base + '_open', pair.tag, 1)
+    innerOpen.markup = pair.markup
+    innerOpen.level = linkLevel + 1 + wp
+    const openMap = resolveInsertedWrapperMap(pair.openMap, labelMap)
+    if (openMap && !innerOpen.map) innerOpen.map = cloneMap(openMap)
+    replacement.push(innerOpen)
+  }
+  replacement.push(...labelTokens)
+  for (let wp = 0; wp < wrapperPairs.length; wp++) {
+    const pair = wrapperPairs[wp]
+    const innerClose = new Token(pair.base + '_close', pair.tag, -1)
+    innerClose.markup = pair.markup
+    innerClose.level = linkLevel + 1 + wp
+    const closeMap = resolveInsertedWrapperMap(pair.closeMap, labelMap)
+    if (closeMap && !innerClose.map) innerClose.map = cloneMap(closeMap)
+    replacement.push(innerClose)
+  }
+  replacement.push(linkCloseToken)
+  return replacement
 }
 
-const parseInlineLinkTail = (content, md) => {
-  if (!content || content.charCodeAt(0) !== CHAR_OPEN_PAREN) return null
-  const max = content.length
-  let pos = 1
-  while (pos < max) {
-    const code = content.charCodeAt(pos)
-    if (!isSpace(code) && code !== 0x0A) break
-    pos++
-  }
-  if (pos >= max) return null
+const wrapLabelTokensWithLink = (
+  tokens,
+  collapsedStartIdx,
+  collapsedEndIdx,
+  labelStartIdx,
+  labelEndIdx,
+  linkOpenToken,
+  linkCloseToken
+) => {
+  if (labelStartIdx > labelEndIdx) return collapsedStartIdx
+  const labelTokens = tokens.slice(labelStartIdx, labelEndIdx + 1)
+  const wrapperPairs = collectWrappedLabelPairs(tokens, collapsedStartIdx, collapsedEndIdx)
+  const { replaceStart, replaceEnd } = resolveWrappedLabelReplaceRange(
+    wrapperPairs,
+    collapsedStartIdx,
+    collapsedEndIdx
+  )
+  const labelMap = getMapFromTokenRange(tokens, labelStartIdx, labelEndIdx) || getNearbyMap(tokens, replaceStart, replaceEnd)
+  const replacement = buildWrappedLabelReplacement(
+    labelTokens,
+    linkOpenToken,
+    linkCloseToken,
+    wrapperPairs,
+    labelMap
+  )
+  tokens.splice(replaceStart, replaceEnd - replaceStart + 1, ...replacement)
+  return replaceStart + replacement.length
+}
 
-  let href = ''
-  let destPos = pos
-  if (pos < max && content.charCodeAt(pos) === CHAR_CLOSE_PAREN) {
-    href = ''
+const resolveCollapsedReferenceTarget = (
+  tokens,
+  state,
+  refRemoveStart,
+  getLabelText,
+  getLinkCloseMap
+) => {
+  let refKey = null
+  let refRemoveCount = 0
+  let existingLinkOpen = null
+  let existingLinkClose = null
+  const nextToken = tokens[refRemoveStart]
+  if (isBracketToken(nextToken, '[]')) {
+    refKey = normalizeReferenceCandidate(state, getLabelText())
+    refRemoveCount = 1
+  } else if (isBracketToken(nextToken, '[')) {
+    let refCloseIdx = refRemoveStart + 1
+    while (refCloseIdx < tokens.length && !isBracketToken(tokens[refCloseIdx], ']')) {
+      refCloseIdx++
+    }
+    if (refCloseIdx >= tokens.length) return null
+    const refStart = refRemoveStart + 1
+    const refEnd = refCloseIdx - 1
+    if (refStart > refEnd) {
+      refKey = normalizeReferenceCandidate(state, getLabelText())
+    } else {
+      const refLabelText = buildReferenceLabelRange(tokens, refStart, refEnd)
+      refKey = normalizeReferenceCandidate(state, refLabelText)
+    }
+    refRemoveCount = refCloseIdx - refRemoveStart + 1
+  } else if (nextToken && nextToken.type === 'link_open') {
+    const linkCloseMap = getLinkCloseMap(refRemoveStart)
+    const linkCloseIdx = linkCloseMap.get(refRemoveStart) ?? -1
+    if (linkCloseIdx === -1) return null
+    existingLinkOpen = tokens[refRemoveStart]
+    existingLinkClose = tokens[linkCloseIdx]
+    refRemoveCount = linkCloseIdx - refRemoveStart + 1
   } else {
-    const dest = parseLinkDestination(content, pos, max)
-    if (!dest.ok) return null
-    href = md.normalizeLink(dest.str)
-    if (!md.validateLink(href)) {
-      return null
-    }
-    pos = dest.pos
-    destPos = dest.pos
+    return null
   }
-
-  while (pos < max) {
-    const code = content.charCodeAt(pos)
-    if (!isSpace(code) && code !== 0x0A) break
-    pos++
+  return {
+    refKey,
+    refRemoveCount,
+    existingLinkOpen,
+    existingLinkClose
   }
+}
 
-  let title = ''
-  const titleRes = parseLinkTitle(content, pos, max)
-  if (pos < max && pos !== destPos && titleRes.ok) {
-    title = titleRes.str
-    pos = titleRes.pos
-    while (pos < max) {
-      const code = content.charCodeAt(pos)
-      if (!isSpace(code) && code !== 0x0A) break
-      pos++
+const buildAutoCollapsedReferenceLinkPair = (ref) => {
+  if (!ref) return null
+  const linkOpenToken = new Token('link_open', 'a', 1)
+  linkOpenToken.attrs = [['href', ref.href]]
+  if (ref.title) linkOpenToken.attrPush(['title', ref.title])
+  linkOpenToken.markup = '[]'
+  linkOpenToken.info = 'auto'
+
+  const linkCloseToken = new Token('link_close', 'a', -1)
+  linkCloseToken.markup = '[]'
+  linkCloseToken.info = 'auto'
+  return { linkOpenToken, linkCloseToken }
+}
+
+const resolveCollapsedReferenceLinkPair = (references, target) => {
+  if (!target) return null
+  if (target.existingLinkOpen && target.existingLinkClose) {
+    return {
+      linkOpenToken: target.existingLinkOpen,
+      linkCloseToken: target.existingLinkClose
     }
   }
+  if (!target.refKey) return null
+  return buildAutoCollapsedReferenceLinkPair(references[target.refKey])
+}
 
-  if (pos >= max || content.charCodeAt(pos) !== CHAR_CLOSE_PAREN) {
-    return null
-  }
-  pos++
-  return { href, title, consumed: pos }
+const applyCollapsedReferenceRewrite = (
+  tokens,
+  startIdx,
+  labelStart,
+  labelEnd,
+  suffixRemoveCount,
+  linkOpenToken,
+  linkCloseToken
+) => {
+  const labelLength = labelEnd - labelStart + 1
+  const collapsedReplaceCount = labelLength + 2 + suffixRemoveCount
+  const collapsedEnd = startIdx + collapsedReplaceCount - 1
+  linkOpenToken.__strongJaMergeMarksAroundLink = true
+  linkCloseToken.__strongJaMergeMarksAroundLink = true
+  return wrapLabelTokensWithLink(
+    tokens,
+    startIdx,
+    collapsedEnd,
+    labelStart,
+    labelEnd,
+    linkOpenToken,
+    linkCloseToken
+  )
 }
 
-const INLINE_LINK_BRACKET_SPLIT_OPTIONS = { splitEmptyPair: true }
+const COLLAPSED_REFERENCE_SCAN_RETRY = Symbol('collapsed-reference-scan-retry')
+const COLLAPSED_REFERENCE_SCAN_SKIP = Symbol('collapsed-reference-scan-skip')
 
-const removeGhostLabelText = (tokens, linkCloseIndex, labelText) => {
-  if (!labelText) return
-  if (linkCloseIndex === null || linkCloseIndex === undefined) return
-  if (linkCloseIndex < 0 || linkCloseIndex >= tokens.length) return
-  const closeToken = tokens[linkCloseIndex]
-  if (!closeToken || closeToken.type !== 'link_close') return
-  let idx = linkCloseIndex + 1
-  while (idx < tokens.length) {
-    const token = tokens[idx]
-    if (!token) {
-      idx++
-      continue
-    }
-    if (token.type === 'text') {
-      if (token.content.startsWith(labelText)) {
-        if (token.content.length === labelText.length) {
-          tokens.splice(idx, 1)
-        } else {
-          token.content = token.content.slice(labelText.length)
-        }
+const createCollapsedReferenceLinkCloseMapAccessors = (tokens, cache = null) => {
+  let linkCloseMap = null
+  const getLinkCloseMap = (startIdx = 0) => {
+    if (cache) {
+      if (cache.linkCloseMap === undefined) {
+        cache.linkCloseMap = buildLinkCloseMap(tokens, 0, tokens.length - 1)
       }
-      break
+      return cache.linkCloseMap
     }
-    if (!/_close$/.test(token.type)) {
-      break
+    if (linkCloseMap === null) {
+      linkCloseMap = buildLinkCloseMap(tokens, startIdx, tokens.length - 1)
     }
-    idx++
+    return linkCloseMap
+  }
+  const invalidateLinkCloseMap = () => {
+    linkCloseMap = null
+    if (cache) cache.linkCloseMap = undefined
   }
+  return { getLinkCloseMap, invalidateLinkCloseMap }
 }
 
-const restoreLabelWhitespace = (tokens, labelSources) => {
-  if (!tokens || !labelSources || labelSources.length === 0) return
-  let labelIdx = 0
-  for (let i = 0; i < tokens.length && labelIdx < labelSources.length; i++) {
-    if (tokens[i].type !== 'link_open') continue
-    const closeIdx = findLinkCloseIndex(tokens, i)
-    if (closeIdx === -1) continue
-    const labelSource = labelSources[labelIdx] || ''
-    if (!labelSource) {
-      labelIdx++
-      continue
-    }
-    let cursor = 0
-    for (let pos = i + 1; pos < closeIdx; pos++) {
-      const t = tokens[pos]
-      const markup = t.markup || ''
-      const text = t.content || ''
-      const startPos = cursor
-      if (t.type === 'text') {
-        cursor += text.length
-      } else if (t.type === 'code_inline') {
-        cursor += markup.length + text.length + markup.length
-      } else if (markup) {
-        cursor += markup.length
-      }
-      if ((t.type === 'strong_open' || t.type === 'em_open') && startPos > 0) {
-        const prevToken = tokens[pos - 1]
-        if (prevToken && prevToken.type === 'text' && prevToken.content && !prevToken.content.endsWith(' ')) {
-          const hasSpaceBefore = startPos - 1 >= 0 && startPos - 1 < labelSource.length && labelSource[startPos - 1] === ' '
-          const hasSpaceAt = startPos >= 0 && startPos < labelSource.length && labelSource[startPos] === ' '
-          if (hasSpaceBefore || hasSpaceAt) {
-            prevToken.content += ' '
-          }
-        }
-      }
-    }
-    labelIdx++
+const findCollapsedReferenceLabelClose = (tokens, startIdx, invalidateLinkCloseMap) => {
+  let closeIdx = startIdx + 1
+  while (closeIdx < tokens.length) {
+    if (isBracketToken(tokens[closeIdx], ']')) return closeIdx
+    const closeToken = tokens[closeIdx]
+    if (closeToken && closeToken.type === 'text' && splitBracketToken(tokens, closeIdx)) {
+      invalidateLinkCloseMap()
+      return COLLAPSED_REFERENCE_SCAN_RETRY
+    }
+    if (closeToken && closeToken.type === 'link_open') return -1
+    closeIdx++
   }
+  return -1
 }
 
-const convertInlineLinks = (tokens, state) => {
-  if (!tokens || tokens.length === 0) return
-  let labelSources = tokens.__strongJaInlineLabelSources
-  if ((!labelSources || labelSources.length === 0) && state && state.env && Array.isArray(state.env.__strongJaInlineLabelSourceList) && state.env.__strongJaInlineLabelSourceList.length > 0) {
-    labelSources = state.env.__strongJaInlineLabelSourceList.shift()
+const buildCollapsedReferenceCandidate = (
+  tokens,
+  state,
+  startIdx,
+  closeIdx,
+  getLinkCloseMap,
+  invalidateLinkCloseMap
+) => {
+  if (closeIdx === startIdx + 1) return null
+
+  const labelStart = startIdx + 1
+  const labelEnd = closeIdx - 1
+  if (!hasReferenceLabelMarkerRange(tokens, labelStart, labelEnd)) return null
+
+  let labelText = null
+  const getLabelText = () => {
+    if (labelText === null) labelText = buildReferenceLabelRange(tokens, labelStart, labelEnd)
+    return labelText
   }
-  let labelSourceIndex = tokens.__strongJaInlineLabelIndex || 0
-  let i = 0
-  while (i < tokens.length) {
-    if (splitBracketToken(tokens, i, INLINE_LINK_BRACKET_SPLIT_OPTIONS)) {
-      continue
-    }
-    if (!isBracketToken(tokens[i], '[')) {
-      i++
-      continue
-    }
-    let closeIdx = i + 1
-    let invalid = false
-    while (closeIdx < tokens.length && !isBracketToken(tokens[closeIdx], ']')) {
-      if (splitBracketToken(tokens, closeIdx, INLINE_LINK_BRACKET_SPLIT_OPTIONS)) {
-        continue
-      }
-      if (tokens[closeIdx].type === 'link_open') {
-        invalid = true
-        break
-      }
-      closeIdx++
-    }
-    if (invalid || closeIdx >= tokens.length) {
-      i++
-      continue
-    }
-    const currentLabelSource = labelSources && labelSourceIndex < labelSources.length
-      ? labelSources[labelSourceIndex]
-      : undefined
 
-    const labelLength = closeIdx - i - 1
-    const needsPlaceholder = labelLength <= 0
-    if (needsPlaceholder && !currentLabelSource) {
-      i++
-      continue
-    }
-
-    let tailIdx = closeIdx + 1
-    let tailContent = ''
-    let parsedTail = null
-    let tailHasCloseParen = false
-    while (tailIdx < tokens.length) {
-      if (splitBracketToken(tokens, tailIdx, INLINE_LINK_BRACKET_SPLIT_OPTIONS)) {
-        continue
-      }
-      const tailToken = tokens[tailIdx]
-      if (tailToken.type !== 'text' || !tailToken.content) {
-        break
-      }
-      tailContent += tailToken.content
-      if (!tailHasCloseParen) {
-        if (tailToken.content.indexOf(')') === -1) {
-          tailIdx++
-          continue
-        }
-        tailHasCloseParen = true
-      }
-      parsedTail = parseInlineLinkTail(tailContent, state.md)
-      if (parsedTail) break
-      tailIdx++
-    }
-
-    if (!parsedTail) {
-      i++
-      continue
-    }
-
-    if (!consumeCharactersFromTokens(tokens, closeIdx + 1, parsedTail.consumed)) {
-      i++
-      continue
-    }
-
-    tokens.splice(closeIdx, 1)
-    tokens.splice(i, 1)
-
-    const linkOpenToken = new Token('link_open', 'a', 1)
-    linkOpenToken.attrs = [['href', parsedTail.href]]
-    if (parsedTail.title) linkOpenToken.attrPush(['title', parsedTail.title])
-    linkOpenToken.markup = '[]()'
-    linkOpenToken.info = 'auto'
-    const linkCloseToken = new Token('link_close', 'a', -1)
-    linkCloseToken.markup = '[]()'
-    linkCloseToken.info = 'auto'
-
-    const nextIndex = wrapLabelTokensWithLink(tokens, i, i + labelLength - 1, linkOpenToken, linkCloseToken, currentLabelSource)
-    if (nextIndex === i) {
-      i++
-      continue
-    }
-    if (currentLabelSource) {
-      const linkCloseIdx = findLinkCloseIndex(tokens, i)
-      if (linkCloseIdx !== -1) {
-        let cursor = 0
-        for (let pos = i + 1; pos < linkCloseIdx; pos++) {
-          const t = tokens[pos]
-          const markup = t.markup || ''
-          const text = t.content || ''
-          const startPos = cursor
-          if (t.type === 'text') {
-            cursor += text.length
-          } else if (t.type === 'code_inline') {
-            cursor += markup.length + text.length + markup.length
-          } else if (markup) {
-            cursor += markup.length
-          }
-          if ((t.type === 'strong_open' || t.type === 'em_open') && startPos > 0) {
-            const prevToken = tokens[pos - 1]
-            if (prevToken && prevToken.type === 'text' && prevToken.content && !prevToken.content.endsWith(' ')) {
-              const labelHasSpaceBefore = startPos - 1 >= 0 && startPos - 1 < currentLabelSource.length && currentLabelSource[startPos - 1] === ' '
-              const labelHasSpaceAt = startPos >= 0 && startPos < currentLabelSource.length && currentLabelSource[startPos] === ' '
-              if (labelHasSpaceBefore || labelHasSpaceAt) {
-                prevToken.content += ' '
-              }
-            }
-          }
-        }
-      }
-    }
-    if (needsPlaceholder && currentLabelSource) {
-      removeGhostLabelText(tokens, nextIndex - 1, currentLabelSource)
-    }
+  const whitespaceStart = closeIdx + 1
+  let refRemoveStart = whitespaceStart
+  while (refRemoveStart < tokens.length && isWhitespaceToken(tokens[refRemoveStart])) {
+    refRemoveStart++
+  }
+  const refStartToken = tokens[refRemoveStart]
+  if (refStartToken && refStartToken.type === 'text' && splitBracketToken(tokens, refRemoveStart)) {
+    invalidateLinkCloseMap()
+    return COLLAPSED_REFERENCE_SCAN_RETRY
+  }
 
-    if (labelSources && labelSources.length > 0) {
-      if (labelSourceIndex < labelSources.length) {
-        labelSourceIndex++
-      }
-    }
-    i = nextIndex
+  const target = resolveCollapsedReferenceTarget(
+    tokens,
+    state,
+    refRemoveStart,
+    getLabelText,
+    getLinkCloseMap
+  )
+  if (!target) return null
+
+  return {
+    labelStart,
+    labelEnd,
+    suffixRemoveCount: (refRemoveStart - whitespaceStart) + target.refRemoveCount,
+    target
   }
-  if (labelSources) {
-    tokens.__strongJaInlineLabelIndex = labelSourceIndex
+}
+
+const tryConvertCollapsedReferenceAt = (
+  tokens,
+  state,
+  references,
+  startIdx,
+  getLinkCloseMap,
+  invalidateLinkCloseMap,
+  onChangeStart = null
+) => {
+  if (splitBracketToken(tokens, startIdx)) {
+    invalidateLinkCloseMap()
+    return COLLAPSED_REFERENCE_SCAN_RETRY
   }
+  if (!isBracketToken(tokens[startIdx], '[')) return COLLAPSED_REFERENCE_SCAN_SKIP
+
+  const closeIdx = findCollapsedReferenceLabelClose(tokens, startIdx, invalidateLinkCloseMap)
+  if (closeIdx === COLLAPSED_REFERENCE_SCAN_RETRY) return COLLAPSED_REFERENCE_SCAN_RETRY
+  if (closeIdx === -1) return COLLAPSED_REFERENCE_SCAN_SKIP
+
+  const candidate = buildCollapsedReferenceCandidate(
+    tokens,
+    state,
+    startIdx,
+    closeIdx,
+    getLinkCloseMap,
+    invalidateLinkCloseMap
+  )
+  if (candidate === COLLAPSED_REFERENCE_SCAN_RETRY) return COLLAPSED_REFERENCE_SCAN_RETRY
+  if (!candidate) return COLLAPSED_REFERENCE_SCAN_SKIP
+
+  const linkPair = resolveCollapsedReferenceLinkPair(references, candidate.target)
+  if (!linkPair) return COLLAPSED_REFERENCE_SCAN_SKIP
+
+  if (onChangeStart) onChangeStart(startIdx)
+  invalidateLinkCloseMap()
+  return applyCollapsedReferenceRewrite(
+    tokens,
+    startIdx,
+    candidate.labelStart,
+    candidate.labelEnd,
+    candidate.suffixRemoveCount,
+    linkPair.linkOpenToken,
+    linkPair.linkCloseToken
+  )
 }
 
-const convertCollapsedReferenceLinks = (tokens, state) => {
+const convertCollapsedReferenceLinks = (tokens, state, cache = null, onChangeStart = null) => {
   const references = state.env && state.env.references
-  if (!references) return
-  const referenceCount = state.__strongJaReferenceCount
-  if (referenceCount !== undefined) {
-    if (referenceCount === 0) return
-  } else if (Object.keys(references).length === 0) {
-    return
+  if (!references) return false
+  if (getReferenceCount(state) === 0) {
+    return false
   }
 
+  let changed = false
   let i = 0
+  const { getLinkCloseMap, invalidateLinkCloseMap } = createCollapsedReferenceLinkCloseMapAccessors(tokens, cache)
   while (i < tokens.length) {
-    if (splitBracketToken(tokens, i)) {
-      continue
-    }
-    if (!isBracketToken(tokens[i], '[')) {
-      i++
-      continue
-    }
-    let closeIdx = i + 1
-    while (closeIdx < tokens.length && !isBracketToken(tokens[closeIdx], ']')) {
-      if (splitBracketToken(tokens, closeIdx)) {
-        continue
-      }
-      if (tokens[closeIdx].type === 'link_open') {
-        closeIdx = -1
-        break
-      }
-      closeIdx++
-    }
-    if (closeIdx === -1 || closeIdx >= tokens.length) {
-      i++
-      continue
-    }
-
-    if (closeIdx === i + 1) {
+    const nextIndex = tryConvertCollapsedReferenceAt(
+      tokens,
+      state,
+      references,
+      i,
+      getLinkCloseMap,
+      invalidateLinkCloseMap,
+      onChangeStart
+    )
+    if (nextIndex === COLLAPSED_REFERENCE_SCAN_RETRY) continue
+    if (nextIndex === COLLAPSED_REFERENCE_SCAN_SKIP) {
       i++
       continue
     }
-
-    const labelStart = i + 1
-    const labelEnd = closeIdx - 1
-    const labelLength = closeIdx - i - 1
-    const labelText = buildReferenceLabelRange(tokens, labelStart, labelEnd)
-    const cleanedLabel = cleanLabelText(labelText)
-    const whitespaceStart = closeIdx + 1
-    let refRemoveStart = whitespaceStart
-    while (refRemoveStart < tokens.length && isWhitespaceToken(tokens[refRemoveStart])) {
-      refRemoveStart++
-    }
-    if (splitBracketToken(tokens, refRemoveStart)) {
-      continue
-    }
-    const whitespaceCount = refRemoveStart - whitespaceStart
-    let refKey = null
-    let refRemoveCount = 0
-    let existingLinkOpen = null
-    let existingLinkClose = null
-    const nextToken = tokens[refRemoveStart]
-    if (isBracketToken(nextToken, '[]')) {
-      refKey = normalizeReferenceCandidate(state, cleanedLabel)
-      refRemoveCount = 1
-    } else if (isBracketToken(nextToken, '[')) {
-      let refCloseIdx = refRemoveStart + 1
-      while (refCloseIdx < tokens.length && !isBracketToken(tokens[refCloseIdx], ']')) {
-        refCloseIdx++
-      }
-      if (refCloseIdx >= tokens.length) {
-        i++
-        continue
-      }
-      const refStart = refRemoveStart + 1
-      const refEnd = refCloseIdx - 1
-      if (refStart > refEnd) {
-        refKey = normalizeReferenceCandidate(state, cleanedLabel)
-      } else {
-        const refLabelText = buildReferenceLabelRange(tokens, refStart, refEnd)
-        refKey = normalizeReferenceCandidate(state, refLabelText)
-      }
-      refRemoveCount = refCloseIdx - refRemoveStart + 1
-    } else if (nextToken && nextToken.type === 'link_open') {
-      const linkCloseIdx = findLinkCloseIndex(tokens, refRemoveStart)
-      if (linkCloseIdx === -1) {
-        i++
-        continue
-      }
-      existingLinkOpen = tokens[refRemoveStart]
-      existingLinkClose = tokens[linkCloseIdx]
-      refRemoveCount = linkCloseIdx - refRemoveStart + 1
-    } else {
-      i++
-      continue
-    }
-    let linkOpenToken = null
-    let linkCloseToken = null
-    if (existingLinkOpen && existingLinkClose) {
-      if (whitespaceCount > 0) {
-        tokens.splice(whitespaceStart, whitespaceCount)
-        refRemoveStart -= whitespaceCount
-      }
-      if (refRemoveCount > 0) {
-        tokens.splice(refRemoveStart, refRemoveCount)
-      }
-      linkOpenToken = existingLinkOpen
-      linkCloseToken = existingLinkClose
-    } else {
-      if (!refKey) {
-        i++
-        continue
-      }
-      const ref = references[refKey]
-      if (!ref) {
-        i++
-        continue
-      }
-      if (whitespaceCount > 0) {
-        tokens.splice(whitespaceStart, whitespaceCount)
-        refRemoveStart -= whitespaceCount
-      }
-      if (refRemoveCount > 0) {
-        tokens.splice(refRemoveStart, refRemoveCount)
-      }
-      linkOpenToken = new Token('link_open', 'a', 1)
-      linkOpenToken.attrs = [['href', ref.href]]
-      if (ref.title) linkOpenToken.attrPush(['title', ref.title])
-      linkOpenToken.markup = '[]'
-      linkOpenToken.info = 'auto'
-      linkCloseToken = new Token('link_close', 'a', -1)
-      linkCloseToken.markup = '[]'
-      linkCloseToken.info = 'auto'
-    }
-    tokens.splice(closeIdx, 1)
-    tokens.splice(i, 1)
-
-    const nextIndex = wrapLabelTokensWithLink(tokens, i, i + labelLength - 1, linkOpenToken, linkCloseToken)
+    changed = true
     i = nextIndex
   }
+  return changed
 }
 
-// Link cleanup helpers
-const mergeBrokenMarksAroundLinks = (tokens) => {
+const collectBrokenMarkLinkMergeRemovals = (tokens) => {
+  const removals = []
   let i = 0
   while (i < tokens.length) {
     const closeToken = tokens[i]
-    if (!closeToken || !/_close$/.test(closeToken.type)) {
+    if (!closeToken || !closeToken.type ||
+        (closeToken.type !== 'em_close' && closeToken.type !== 'strong_close')) {
       i++
       continue
     }
     const openType = closeToken.type.replace('_close', '_open')
     let j = i + 1
     while (j < tokens.length && isWhitespaceToken(tokens[j])) j++
-    if (j >= tokens.length || tokens[j].type !== 'link_open') {
+    if (j >= tokens.length ||
+        tokens[j].type !== 'link_open' ||
+        tokens[j].__strongJaMergeMarksAroundLink !== true) {
       i++
       continue
     }
@@ -759,15 +633,36 @@ const mergeBrokenMarksAroundLinks = (tokens) => {
       i++
       continue
     }
-    tokens.splice(j, 1)
-    tokens.splice(i, 1)
+    removals.push({ closeIdx: i, reopenIdx: j })
+    i = j + 1
   }
+  return removals
+}
+
+const applyBrokenMarkLinkMergeRemovals = (tokens, removals, onChangeStart = null) => {
+  if (!removals || removals.length === 0) return false
+  const removeFlags = new Array(tokens.length).fill(false)
+  for (let idx = removals.length - 1; idx >= 0; idx--) {
+    const removal = removals[idx]
+    if (onChangeStart) onChangeStart(removal.closeIdx)
+    removeFlags[removal.closeIdx] = true
+    removeFlags[removal.reopenIdx] = true
+  }
+  const kept = []
+  for (let idx = 0; idx < tokens.length; idx++) {
+    if (!removeFlags[idx]) kept.push(tokens[idx])
+  }
+  tokens.splice(0, tokens.length, ...kept)
+  return true
+}
+
+const mergeBrokenMarksAroundLinks = (tokens, onChangeStart = null) => {
+  return applyBrokenMarkLinkMergeRemovals(tokens, collectBrokenMarkLinkMergeRemovals(tokens), onChangeStart)
 }
 
 export {
   normalizeReferenceCandidate,
-  restoreLabelWhitespace,
-  convertInlineLinks,
+  buildLinkCloseMap,
   convertCollapsedReferenceLinks,
   mergeBrokenMarksAroundLinks,
   getMapFromTokenRange