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

package/src/token-postprocess/guards.js

@@ -1,17 +1,11 @@
-import { isJapaneseChar, getInlineWrapperBase } from '../token-utils.js'
+import { isJapaneseChar } from '../token-utils.js'
+
+const CHAR_ASTERISK = 0x2A // *
 
 const hasMarkerChars = (text) => {
   return !!text && text.indexOf('*') !== -1
 }
 
-const contentHasMarkerCharsFrom = (content, from) => {
-  if (!content) return false
-  const start = from > 0 ? from : 0
-  if (start === 0) return hasMarkerChars(content)
-  if (start >= content.length) return false
-  return content.indexOf('*', start) !== -1
-}
-
 const isAsteriskEmphasisToken = (token) => {
   if (!token || !token.type) return false
   if (token.type !== 'strong_open' &&
@@ -78,20 +72,6 @@ const hasEmphasisSignalInRange = (tokens, startIdx, endIdx) => {
   return false
 }
 
-const hasTextMarkerCharsInRange = (tokens, startIdx, endIdx, firstTextOffset = 0) => {
-  if (!tokens || startIdx < 0 || endIdx < startIdx) return false
-  for (let i = startIdx; i <= endIdx && i < tokens.length; i++) {
-    const token = tokens[i]
-    if (!token || token.type !== 'text' || !token.content) continue
-    if (i === startIdx && firstTextOffset > 0) {
-      if (contentHasMarkerCharsFrom(token.content, firstTextOffset)) return true
-      continue
-    }
-    if (textTokenHasMarkerChars(token)) return true
-  }
-  return false
-}
-
 const isStrongRunSoftSpace = (code) => {
   return code === 0x20 || code === 0x09 || code === 0x0A || code === 0x3000
 }
@@ -107,21 +87,24 @@ const isStrongRunTextLike = (code) => {
   return isStrongRunAsciiWord(code) || isJapaneseChar(code)
 }
 
-const countDelimiterLikeStrongRuns = (content, marker, from = 0, limit = 0) => {
+const countDelimiterLikeStrongRuns = (content, from = 0, limit = 0) => {
   let at = from > 0 ? from : 0
   const len = content.length
-  const markerCode = marker.charCodeAt(0)
   let count = 0
-  while (at < len) {
-    const pos = content.indexOf(marker, at)
-    if (pos === -1) break
+  while (at + 1 < len) {
+    if (content.charCodeAt(at) !== CHAR_ASTERISK ||
+        content.charCodeAt(at + 1) !== CHAR_ASTERISK) {
+      at++
+      continue
+    }
+    const pos = at
     const prevCode = pos > 0 ? content.charCodeAt(pos - 1) : 0
-    const nextPos = pos + marker.length
+    const nextPos = pos + 2
     const nextCode = nextPos < len ? content.charCodeAt(nextPos) : 0
-    const prevSameMarker = prevCode === markerCode
-    const nextSameMarker = nextCode === markerCode
+    const prevSameMarker = prevCode === CHAR_ASTERISK
+    const nextSameMarker = nextCode === CHAR_ASTERISK
     if (prevSameMarker || nextSameMarker) {
-      at = pos + marker.length
+      at = pos + 2
       continue
     }
     const prevSoft = prevCode !== 0 && isStrongRunSoftSpace(prevCode)
@@ -131,97 +114,55 @@ const countDelimiterLikeStrongRuns = (content, marker, from = 0, limit = 0) => {
     const nextTextLike = isStrongRunTextLike(nextCode)
     const hasTextNeighbor = prevTextLike || nextTextLike
     if (!hasTextNeighbor) {
-      at = pos + marker.length
+      at = pos + 2
       continue
     }
     const atBoundary = prevCode === 0 || nextCode === 0
     if (!atBoundary && (!prevTextLike || !nextTextLike)) {
-      at = pos + marker.length
+      at = pos + 2
       continue
     }
     if (hasPrevOrNext && !prevSoft && !nextSoft) {
       count++
       if (limit > 0 && count >= limit) return count
     }
-    at = pos + marker.length
+    at = pos + 2
   }
   return count
 }
 
-const countStrongMarkerRunsInTextRange = (tokens, startIdx, endIdx, firstTextOffset = 0, limit = 0) => {
-  if (!tokens || startIdx < 0 || endIdx < startIdx) return 0
-  let total = 0
-  for (let i = startIdx; i <= endIdx && i < tokens.length; i++) {
-    const token = tokens[i]
-    if (!token || token.type !== 'text' || !token.content) continue
-    const content = token.content
-    const scanFrom = i === startIdx && firstTextOffset > 0 ? firstTextOffset : 0
-    if (scanFrom >= content.length) continue
-    const remain = limit > 0 ? (limit - total) : 0
-    total += countDelimiterLikeStrongRuns(content, '**', scanFrom, remain)
-    if (limit > 0 && total >= limit) {
-      return total
-    }
-  }
-  return total
-}
-
 const buildAsteriskWrapperPrefixStats = (tokens) => {
   const len = Array.isArray(tokens) ? tokens.length : 0
   const strongDepthPrefix = new Array(len + 1)
   const emDepthPrefix = new Array(len + 1)
-  const strongOpenPrefix = new Array(len + 1)
-  const strongClosePrefix = new Array(len + 1)
-  const emOpenPrefix = new Array(len + 1)
-  const emClosePrefix = new Array(len + 1)
   let strongDepth = 0
   let emDepthCount = 0
-  let strongOpenCount = 0
-  let strongCloseCount = 0
-  let emOpenCount = 0
-  let emCloseCount = 0
   strongDepthPrefix[0] = 0
   emDepthPrefix[0] = 0
-  strongOpenPrefix[0] = 0
-  strongClosePrefix[0] = 0
-  emOpenPrefix[0] = 0
-  emClosePrefix[0] = 0
   for (let i = 0; i < len; i++) {
     const token = tokens[i]
     if (token && token.type && isAsteriskEmphasisToken(token)) {
       if (token.type === 'strong_open') {
         strongDepth++
-        strongOpenCount++
       } else if (token.type === 'strong_close') {
         if (strongDepth > 0) strongDepth--
-        strongCloseCount++
       } else if (token.type === 'em_open') {
         emDepthCount++
-        emOpenCount++
       } else if (token.type === 'em_close') {
         if (emDepthCount > 0) emDepthCount--
-        emCloseCount++
       }
     }
     strongDepthPrefix[i + 1] = strongDepth
     emDepthPrefix[i + 1] = emDepthCount
-    strongOpenPrefix[i + 1] = strongOpenCount
-    strongClosePrefix[i + 1] = strongCloseCount
-    emOpenPrefix[i + 1] = emOpenCount
-    emClosePrefix[i + 1] = emCloseCount
   }
   return {
     strongDepth: strongDepthPrefix,
-    emDepth: emDepthPrefix,
-    strongOpen: strongOpenPrefix,
-    strongClose: strongClosePrefix,
-    emOpen: emOpenPrefix,
-    emClose: emClosePrefix
+    emDepth: emDepthPrefix
   }
 }
 
-const buildBrokenRefWrapperRangeSignals = (tokens, startIdx, endIdx, firstTextOffset = 0) => {
-  const out = {
+const createBrokenRefWrapperRangeSignals = () => {
+  return {
     hasLeadingUnmatchedClose: false,
     hasImbalance: false,
     hasAsteriskEmphasisToken: false,
@@ -229,123 +170,148 @@ const buildBrokenRefWrapperRangeSignals = (tokens, startIdx, endIdx, firstTextOf
     hasUnderscoreText: false,
     hasCodeInline: false,
     hasUnderscoreEmphasisToken: false,
+    hasTextMarker: false,
+    strongRunCount: 0,
     strongOpenInRange: 0,
     strongCloseInRange: 0,
     emOpenInRange: 0,
     emCloseInRange: 0
   }
-  if (!tokens || startIdx < 0 || endIdx < startIdx) return out
-  const depthMap = new Map()
-  let sawWrapper = false
-  let sawOpen = false
+}
+
+const updateBrokenRefTextRangeSignals = (signals, token, tokenIdx, startIdx, firstTextOffset) => {
+  if (!token || token.type !== 'text' || !token.content) return
+  const content = token.content
+  const scanFrom = tokenIdx === startIdx && firstTextOffset > 0 ? firstTextOffset : 0
+  // Keep this at 0 (instead of firstTextOffset) so historical fail-safe
+  // behavior around noisy leading chains in the first text token stays unchanged.
+  if (!signals.hasLongStarNoise && content.indexOf('***') !== -1) {
+    signals.hasLongStarNoise = true
+  }
+  if (!signals.hasUnderscoreText) {
+    if (scanFrom < content.length && content.indexOf('_', scanFrom) !== -1) {
+      signals.hasUnderscoreText = true
+    }
+  }
+  if (!signals.hasTextMarker) {
+    signals.hasTextMarker = scanFrom === 0
+      ? textTokenHasMarkerChars(token)
+      : content.indexOf('*', scanFrom) !== -1
+  }
+  if (signals.strongRunCount < 2 && scanFrom < content.length) {
+    signals.strongRunCount += countDelimiterLikeStrongRuns(content, scanFrom, 2 - signals.strongRunCount)
+  }
+}
+
+const updateBrokenRefWrapperTokenSignals = (signals, token, isAsteriskEmphasis) => {
+  if (!signals.hasCodeInline && token.type === 'code_inline') {
+    signals.hasCodeInline = true
+  }
+  if (isAsteriskEmphasis) {
+    signals.hasAsteriskEmphasisToken = true
+  }
+  if (!signals.hasUnderscoreEmphasisToken &&
+      (token.type === 'strong_open' ||
+       token.type === 'strong_close' ||
+       token.type === 'em_open' ||
+       token.type === 'em_close') &&
+      (token.markup === '_' || token.markup === '__')) {
+    signals.hasUnderscoreEmphasisToken = true
+  }
+}
+
+const updateBrokenRefWrapperRangeDepthSignals = (signals, token, wrapperState, isAsteriskEmphasis) => {
+  if (!isAsteriskEmphasis) return
+  let depthKey = ''
+  if (token.type === 'strong_open' || token.type === 'strong_close') {
+    depthKey = 'strongDepth'
+  } else if (token.type === 'em_open' || token.type === 'em_close') {
+    depthKey = 'emDepth'
+  } else {
+    return
+  }
+  const isOpen = token.type.endsWith('_open')
+  if (!wrapperState.sawWrapper) {
+    wrapperState.sawWrapper = true
+    if (!isOpen) signals.hasLeadingUnmatchedClose = true
+  }
+  if (isOpen) {
+    wrapperState.sawOpen = true
+    signals.hasLeadingUnmatchedClose = false
+    wrapperState[depthKey]++
+  } else if (wrapperState[depthKey] <= 0) {
+    signals.hasImbalance = true
+  } else {
+    wrapperState[depthKey]--
+  }
+  if (token.type === 'strong_open') signals.strongOpenInRange++
+  else if (token.type === 'strong_close') signals.strongCloseInRange++
+  else if (token.type === 'em_open') signals.emOpenInRange++
+  else if (token.type === 'em_close') signals.emCloseInRange++
+}
+
+const finalizeBrokenRefWrapperRangeSignals = (signals, wrapperState) => {
+  if (!wrapperState.sawWrapper || wrapperState.sawOpen) {
+    signals.hasLeadingUnmatchedClose = false
+  }
+  if (!signals.hasImbalance &&
+      (wrapperState.strongDepth !== 0 || wrapperState.emDepth !== 0)) {
+    signals.hasImbalance = true
+  }
+  return signals
+}
+
+const buildBrokenRefWrapperRangeSignals = (tokens, startIdx, endIdx, firstTextOffset = 0) => {
+  const signals = createBrokenRefWrapperRangeSignals()
+  if (!tokens || startIdx < 0 || endIdx < startIdx) return signals
+  const wrapperState = { sawWrapper: false, sawOpen: false, strongDepth: 0, emDepth: 0 }
   for (let i = startIdx; i <= endIdx && i < tokens.length; i++) {
     const token = tokens[i]
     if (!token || !token.type) continue
-    if (!out.hasCodeInline && token.type === 'code_inline') {
-      out.hasCodeInline = true
-    }
     const isAsteriskEmphasis = isAsteriskEmphasisToken(token)
-    if (isAsteriskEmphasis) out.hasAsteriskEmphasisToken = true
-    if (!out.hasUnderscoreEmphasisToken &&
-        (token.type === 'strong_open' ||
-         token.type === 'strong_close' ||
-         token.type === 'em_open' ||
-         token.type === 'em_close') &&
-        (token.markup === '_' || token.markup === '__')) {
-      out.hasUnderscoreEmphasisToken = true
-    }
-    if (token.type === 'text' && token.content) {
-      const content = token.content
-      // Keep this at 0 (instead of firstTextOffset) so historical fail-safe
-      // behavior around noisy leading chains in the first text token stays unchanged.
-      if (!out.hasLongStarNoise && content.indexOf('***') !== -1) {
-        out.hasLongStarNoise = true
-      }
-      if (!out.hasUnderscoreText) {
-        const scanFrom = i === startIdx && firstTextOffset > 0 ? firstTextOffset : 0
-        if (scanFrom < content.length && content.indexOf('_', scanFrom) !== -1) {
-          out.hasUnderscoreText = true
-        }
-      }
-    }
-    if ((token.type === 'strong_open' || token.type === 'strong_close' || token.type === 'em_open' || token.type === 'em_close') &&
-        !isAsteriskEmphasis) {
-      continue
-    }
-    const base = getInlineWrapperBase(token.type)
-    if (!base) continue
-    const isOpen = token.type.endsWith('_open')
-    if (!sawWrapper) {
-      sawWrapper = true
-      if (!isOpen) out.hasLeadingUnmatchedClose = true
-    }
-    if (isOpen) {
-      sawOpen = true
-      out.hasLeadingUnmatchedClose = false
-      depthMap.set(base, (depthMap.get(base) || 0) + 1)
-    } else {
-      const prev = depthMap.get(base) || 0
-      if (prev <= 0) {
-        out.hasImbalance = true
-      } else {
-        depthMap.set(base, prev - 1)
-      }
-    }
-    if (token.type === 'strong_open') out.strongOpenInRange++
-    else if (token.type === 'strong_close') out.strongCloseInRange++
-    else if (token.type === 'em_open') out.emOpenInRange++
-    else if (token.type === 'em_close') out.emCloseInRange++
-  }
-  if (!sawWrapper || sawOpen) out.hasLeadingUnmatchedClose = false
-  if (!out.hasImbalance) {
-    for (const depth of depthMap.values()) {
-      if (depth !== 0) {
-        out.hasImbalance = true
-        break
-      }
-    }
+    updateBrokenRefWrapperTokenSignals(signals, token, isAsteriskEmphasis)
+    updateBrokenRefTextRangeSignals(signals, token, i, startIdx, firstTextOffset)
+    updateBrokenRefWrapperRangeDepthSignals(signals, token, wrapperState, isAsteriskEmphasis)
   }
-  return out
+  return finalizeBrokenRefWrapperRangeSignals(signals, wrapperState)
+}
+
+const hasRangeCloseOnlyWrapperSignals = (signals) => {
+  if (!signals) return false
+  return (signals.strongCloseInRange > 0 && signals.strongOpenInRange === 0) ||
+    (signals.emCloseInRange > 0 && signals.emOpenInRange === 0)
 }
 
 const hasPreexistingWrapperCloseOnlyInRange = (tokens, startIdx, endIdx, prefixStats = null, wrapperSignals = null) => {
   if (!tokens || startIdx <= 0 || endIdx < startIdx) return false
   const signals = wrapperSignals || buildBrokenRefWrapperRangeSignals(tokens, startIdx, endIdx, 0)
+  if (!hasRangeCloseOnlyWrapperSignals(signals)) return false
+  const needsStrongCloseOnly = signals.strongCloseInRange > 0 && signals.strongOpenInRange === 0
+  const needsEmCloseOnly = signals.emCloseInRange > 0 && signals.emOpenInRange === 0
 
   let preStrongDepth = 0
   let preEmDepth = 0
   const hasPrefix =
     !!prefixStats &&
     Array.isArray(prefixStats.strongDepth) &&
-    Array.isArray(prefixStats.emDepth) &&
-    Array.isArray(prefixStats.strongOpen) &&
-    Array.isArray(prefixStats.strongClose) &&
-    Array.isArray(prefixStats.emOpen) &&
-    Array.isArray(prefixStats.emClose)
+    Array.isArray(prefixStats.emDepth)
   if (hasPrefix &&
       startIdx < prefixStats.strongDepth.length &&
-      startIdx < prefixStats.emDepth.length &&
-      (endIdx + 1) < prefixStats.strongOpen.length &&
-      (endIdx + 1) < prefixStats.strongClose.length &&
-      (endIdx + 1) < prefixStats.emOpen.length &&
-      (endIdx + 1) < prefixStats.emClose.length) {
-    preStrongDepth = prefixStats.strongDepth[startIdx] || 0
-    preEmDepth = prefixStats.emDepth[startIdx] || 0
-    if (preStrongDepth > 0) {
-      const strongOpensInRange = signals.strongOpenInRange
-      const strongClosesInRange = signals.strongCloseInRange
-      if (strongClosesInRange > 0 && strongOpensInRange === 0) return true
+      startIdx < prefixStats.emDepth.length) {
+    if (needsStrongCloseOnly) {
+      preStrongDepth = prefixStats.strongDepth[startIdx] || 0
+      if (preStrongDepth > 0) return true
     }
-    if (preEmDepth > 0) {
-      const emOpensInRange = signals.emOpenInRange
-      const emClosesInRange = signals.emCloseInRange
-      if (emClosesInRange > 0 && emOpensInRange === 0) return true
+    if (needsEmCloseOnly) {
+      preEmDepth = prefixStats.emDepth[startIdx] || 0
+      if (preEmDepth > 0) return true
     }
     return false
-  } else {
-    for (let i = 0; i < startIdx && i < tokens.length; i++) {
-      const token = tokens[i]
-      if (!token || !token.type || !isAsteriskEmphasisToken(token)) continue
+  }
+  for (let i = 0; i < startIdx && i < tokens.length; i++) {
+    const token = tokens[i]
+    if (!token || !token.type || !isAsteriskEmphasisToken(token)) continue
+    if (needsStrongCloseOnly) {
       if (token.type === 'strong_open') {
         preStrongDepth++
         continue
@@ -354,42 +320,100 @@ const hasPreexistingWrapperCloseOnlyInRange = (tokens, startIdx, endIdx, prefixS
         if (preStrongDepth > 0) preStrongDepth--
         continue
       }
+    }
+    if (needsEmCloseOnly) {
       if (token.type === 'em_open') {
         preEmDepth++
         continue
       }
-      if (token.type === 'em_close') {
-        if (preEmDepth > 0) preEmDepth--
+      if (token.type === 'em_close' && preEmDepth > 0) {
+        preEmDepth--
       }
     }
   }
-  if (preStrongDepth > 0 && signals.strongCloseInRange > 0 && signals.strongOpenInRange === 0) return true
-  if (preEmDepth > 0 && signals.emCloseInRange > 0 && signals.emOpenInRange === 0) return true
+  if (needsStrongCloseOnly && preStrongDepth > 0) return true
+  if (needsEmCloseOnly && preEmDepth > 0) return true
   return false
 }
 
+const hasBrokenRefLowConfidenceTextNoise = (signals) => {
+  return signals.hasLongStarNoise || signals.hasUnderscoreText
+}
+
+const hasBrokenRefLowConfidenceInlineSyntax = (signals) => {
+  return signals.hasCodeInline || signals.hasUnderscoreEmphasisToken
+}
+
+const hasBrokenRefLowConfidenceNoise = (signals) => {
+  return hasBrokenRefLowConfidenceTextNoise(signals) || hasBrokenRefLowConfidenceInlineSyntax(signals)
+}
+
+const hasBrokenRefCloseOnlyWrapperRisk = (
+  tokens,
+  startIdx,
+  endIdx,
+  wrapperPrefixStats = null,
+  wrapperSignals = null
+) => {
+  const signals = wrapperSignals || buildBrokenRefWrapperRangeSignals(tokens, startIdx, endIdx, 0)
+  return hasPreexistingWrapperCloseOnlyInRange(tokens, startIdx, endIdx, wrapperPrefixStats, signals)
+}
+
+const hasBrokenRefLowConfidenceWrapperRisk = (
+  tokens,
+  startIdx,
+  endIdx,
+  wrapperPrefixStats = null,
+  wrapperSignals = null
+) => {
+  const signals = wrapperSignals || buildBrokenRefWrapperRangeSignals(tokens, startIdx, endIdx, 0)
+  if (signals.hasLeadingUnmatchedClose) return true
+  return hasBrokenRefCloseOnlyWrapperRisk(tokens, startIdx, endIdx, wrapperPrefixStats, signals)
+}
+
 const isLowConfidenceBrokenRefRange = (tokens, startIdx, endIdx, firstTextOffset = 0, wrapperPrefixStats = null, wrapperSignals = null) => {
   const signals = wrapperSignals || buildBrokenRefWrapperRangeSignals(tokens, startIdx, endIdx, firstTextOffset)
-  if (signals.hasLongStarNoise) return true
-  if (signals.hasUnderscoreText || signals.hasCodeInline || signals.hasUnderscoreEmphasisToken) return true
-  if (signals.hasLeadingUnmatchedClose) return true
-  if (hasPreexistingWrapperCloseOnlyInRange(tokens, startIdx, endIdx, wrapperPrefixStats, signals)) return true
-  return false
+  if (hasBrokenRefLowConfidenceNoise(signals)) return true
+  return hasBrokenRefLowConfidenceWrapperRisk(tokens, startIdx, endIdx, wrapperPrefixStats, signals)
 }
 
-const shouldAttemptBrokenRefRewrite = (tokens, startIdx, endIdx, firstTextOffset = 0, wrapperPrefixStats = null) => {
-  const wrapperSignals = buildBrokenRefWrapperRangeSignals(tokens, startIdx, endIdx, firstTextOffset)
-  if (isLowConfidenceBrokenRefRange(tokens, startIdx, endIdx, firstTextOffset, wrapperPrefixStats, wrapperSignals)) return false
-  if (wrapperSignals.hasImbalance) {
-    if (wrapperSignals.hasAsteriskEmphasisToken) return true
-    return countStrongMarkerRunsInTextRange(tokens, startIdx, endIdx, firstTextOffset, 2) >= 2
-  }
-  if (wrapperSignals.hasAsteriskEmphasisToken) return false
-  return countStrongMarkerRunsInTextRange(tokens, startIdx, endIdx, firstTextOffset, 2) >= 2
+const hasBrokenRefStrongRunEvidence = (wrapperSignals) => {
+  return !!wrapperSignals && wrapperSignals.strongRunCount >= 2
 }
 
-const scanInlinePostprocessSignals = (children, hasBracketTextInContent = false) => {
-  let hasBracketText = hasBracketTextInContent
+const hasBrokenRefExplicitAsteriskSignal = (wrapperSignals) => {
+  return wrapperSignals.hasAsteriskEmphasisToken
+}
+
+const hasBrokenRefImmediateRewriteSignal = (wrapperSignals) => {
+  return wrapperSignals.hasImbalance && hasBrokenRefExplicitAsteriskSignal(wrapperSignals)
+}
+
+const shouldRejectBalancedBrokenRefRewrite = (wrapperSignals) => {
+  return !wrapperSignals.hasImbalance && hasBrokenRefExplicitAsteriskSignal(wrapperSignals)
+}
+
+const shouldAttemptBrokenRefRewriteFromSignals = (wrapperSignals) => {
+  if (hasBrokenRefImmediateRewriteSignal(wrapperSignals)) return true
+  if (shouldRejectBalancedBrokenRefRewrite(wrapperSignals)) return false
+  return hasBrokenRefStrongRunEvidence(wrapperSignals)
+}
+
+const shouldAttemptBrokenRefRewrite = (
+  tokens,
+  startIdx,
+  endIdx,
+  firstTextOffset = 0,
+  wrapperPrefixStats = null,
+  wrapperSignals = null
+) => {
+  const signals = wrapperSignals || buildBrokenRefWrapperRangeSignals(tokens, startIdx, endIdx, firstTextOffset)
+  if (!signals.hasTextMarker) return false
+  if (isLowConfidenceBrokenRefRange(tokens, startIdx, endIdx, firstTextOffset, wrapperPrefixStats, signals)) return false
+  return shouldAttemptBrokenRefRewriteFromSignals(signals)
+}
+
+const scanInlinePostprocessSignals = (children) => {
   let hasEmphasis = false
   let hasLinkOpen = false
   let hasLinkClose = false
@@ -409,14 +433,9 @@ const scanInlinePostprocessSignals = (children, hasBracketTextInContent = false)
     if (!hasCodeInline && child.type === 'code_inline') {
       hasCodeInline = true
     }
-    if (hasBracketText || child.type !== 'text' || !child.content) continue
-    if (child.content.indexOf('[') !== -1 || child.content.indexOf(']') !== -1) {
-      hasBracketText = true
-    }
-    if (hasEmphasis && hasBracketText && hasLinkOpen && hasLinkClose) break
+    if (hasEmphasis && hasLinkOpen && hasLinkClose) break
   }
   return {
-    hasBracketText,
     hasEmphasis,
     hasLinkOpen,
     hasLinkClose,
@@ -429,8 +448,8 @@ export {
   isAsteriskEmphasisToken,
   hasJapaneseContextInRange,
   hasEmphasisSignalInRange,
-  hasTextMarkerCharsInRange,
   buildAsteriskWrapperPrefixStats,
+  buildBrokenRefWrapperRangeSignals,
   shouldAttemptBrokenRefRewrite,
   scanInlinePostprocessSignals
 }