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

package/src/token-link-utils.js

@@ -1,23 +1,33 @@
 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'
 
 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
 }
 
-// Collapsed reference helpers
 const buildReferenceLabelRange = (tokens, startIdx, endIdx) => {
   if (startIdx > endIdx) return ''
   let label = ''
@@ -28,23 +38,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,10 +58,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
@@ -102,12 +100,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 = false
+  } 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 +135,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,40 +185,26 @@ 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 wrapLabelTokensWithLink = (tokens, labelStartIdx, labelEndIdx, linkOpenToken, linkCloseToken) => {
   const wrapperPairs = []
   let startIdx = labelStartIdx
   let endIdx = labelEndIdx
@@ -250,7 +212,7 @@ const wrapLabelTokensWithLink = (tokens, labelStartIdx, labelEndIdx, linkOpenTok
     const prevToken = tokens[startIdx - 1]
     const nextToken = tokens[endIdx + 1]
     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({
@@ -266,17 +228,7 @@ const wrapLabelTokensWithLink = (tokens, labelStartIdx, labelEndIdx, linkOpenTok
     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
-    }
-  }
+  if (startIdx > endIdx) return startIdx
 
   let labelLength = endIdx - startIdx + 1
   const firstLabelToken = tokens[startIdx]
@@ -320,282 +272,23 @@ const wrapLabelTokensWithLink = (tokens, labelStartIdx, labelEndIdx, linkOpenTok
   return startIdx + labelLength + 2
 }
 
-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
-
-  let href = ''
-  let destPos = pos
-  if (pos < max && content.charCodeAt(pos) === CHAR_CLOSE_PAREN) {
-    href = ''
-  } 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
-  }
-
-  while (pos < max) {
-    const code = content.charCodeAt(pos)
-    if (!isSpace(code) && code !== 0x0A) break
-    pos++
-  }
-
-  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++
-    }
-  }
-
-  if (pos >= max || content.charCodeAt(pos) !== CHAR_CLOSE_PAREN) {
-    return null
-  }
-  pos++
-  return { href, title, consumed: pos }
-}
-
-const INLINE_LINK_BRACKET_SPLIT_OPTIONS = { splitEmptyPair: true }
-
-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)
-        }
-      }
-      break
-    }
-    if (!/_close$/.test(token.type)) {
-      break
-    }
-    idx++
-  }
-}
-
-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 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()
-  }
-  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)
-    }
-
-    if (labelSources && labelSources.length > 0) {
-      if (labelSourceIndex < labelSources.length) {
-        labelSourceIndex++
-      }
-    }
-    i = nextIndex
-  }
-  if (labelSources) {
-    tokens.__strongJaInlineLabelIndex = labelSourceIndex
-  }
-}
-
 const convertCollapsedReferenceLinks = (tokens, state) => {
   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) {
+  let referenceCount = state.__strongJaReferenceCount
+  if (referenceCount === undefined) {
+    referenceCount = Object.keys(references).length
+    state.__strongJaReferenceCount = referenceCount
+  }
+  if (referenceCount === 0) {
     return
   }
 
   let i = 0
+  let linkCloseMap = null
   while (i < tokens.length) {
     if (splitBracketToken(tokens, i)) {
+      linkCloseMap = null
       continue
     }
     if (!isBracketToken(tokens[i], '[')) {
@@ -604,10 +297,12 @@ const convertCollapsedReferenceLinks = (tokens, state) => {
     }
     let closeIdx = i + 1
     while (closeIdx < tokens.length && !isBracketToken(tokens[closeIdx], ']')) {
-      if (splitBracketToken(tokens, closeIdx)) {
+      const closeToken = tokens[closeIdx]
+      if (closeToken && closeToken.type === 'text' && splitBracketToken(tokens, closeIdx)) {
+        linkCloseMap = null
         continue
       }
-      if (tokens[closeIdx].type === 'link_open') {
+      if (closeToken && closeToken.type === 'link_open') {
         closeIdx = -1
         break
       }
@@ -627,13 +322,18 @@ const convertCollapsedReferenceLinks = (tokens, state) => {
     const labelEnd = closeIdx - 1
     const labelLength = closeIdx - i - 1
     const labelText = buildReferenceLabelRange(tokens, labelStart, labelEnd)
-    const cleanedLabel = cleanLabelText(labelText)
+    if (labelText.indexOf('*') === -1 && labelText.indexOf('_') === -1) {
+      i++
+      continue
+    }
     const whitespaceStart = closeIdx + 1
     let refRemoveStart = whitespaceStart
     while (refRemoveStart < tokens.length && isWhitespaceToken(tokens[refRemoveStart])) {
       refRemoveStart++
     }
-    if (splitBracketToken(tokens, refRemoveStart)) {
+    const refStartToken = tokens[refRemoveStart]
+    if (refStartToken && refStartToken.type === 'text' && splitBracketToken(tokens, refRemoveStart)) {
+      linkCloseMap = null
       continue
     }
     const whitespaceCount = refRemoveStart - whitespaceStart
@@ -643,7 +343,7 @@ const convertCollapsedReferenceLinks = (tokens, state) => {
     let existingLinkClose = null
     const nextToken = tokens[refRemoveStart]
     if (isBracketToken(nextToken, '[]')) {
-      refKey = normalizeReferenceCandidate(state, cleanedLabel)
+      refKey = normalizeReferenceCandidate(state, labelText)
       refRemoveCount = 1
     } else if (isBracketToken(nextToken, '[')) {
       let refCloseIdx = refRemoveStart + 1
@@ -657,14 +357,17 @@ const convertCollapsedReferenceLinks = (tokens, state) => {
       const refStart = refRemoveStart + 1
       const refEnd = refCloseIdx - 1
       if (refStart > refEnd) {
-        refKey = normalizeReferenceCandidate(state, cleanedLabel)
+        refKey = normalizeReferenceCandidate(state, labelText)
       } 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 (linkCloseMap === null) {
+        linkCloseMap = buildLinkCloseMap(tokens, refRemoveStart, tokens.length - 1)
+      }
+      const linkCloseIdx = linkCloseMap.get(refRemoveStart) ?? -1
       if (linkCloseIdx === -1) {
         i++
         continue
@@ -679,6 +382,7 @@ const convertCollapsedReferenceLinks = (tokens, state) => {
     let linkOpenToken = null
     let linkCloseToken = null
     if (existingLinkOpen && existingLinkClose) {
+      linkCloseMap = null
       if (whitespaceCount > 0) {
         tokens.splice(whitespaceStart, whitespaceCount)
         refRemoveStart -= whitespaceCount
@@ -698,6 +402,7 @@ const convertCollapsedReferenceLinks = (tokens, state) => {
         i++
         continue
       }
+      linkCloseMap = null
       if (whitespaceCount > 0) {
         tokens.splice(whitespaceStart, whitespaceCount)
         refRemoveStart -= whitespaceCount
@@ -722,12 +427,12 @@ const convertCollapsedReferenceLinks = (tokens, state) => {
   }
 }
 
-// Link cleanup helpers
 const mergeBrokenMarksAroundLinks = (tokens) => {
   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
     }
@@ -766,8 +471,7 @@ const mergeBrokenMarksAroundLinks = (tokens) => {
 
 export {
   normalizeReferenceCandidate,
-  restoreLabelWhitespace,
-  convertInlineLinks,
+  buildLinkCloseMap,
   convertCollapsedReferenceLinks,
   mergeBrokenMarksAroundLinks,
   getMapFromTokenRange