@peaceroad/markdown-it-numbering-ul-regarded-as-ol 0.4.0 → 0.4.2

package/src/phase5-spans.js

@@ -9,16 +9,12 @@ import { buildListCloseIndexMap, findMatchingClose } from './list-helpers.js'
  * @param {Array} tokens - Token array
  * @param {Object} opt - Options
  */
-export function generateSpans(tokens, opt) {
+export function generateSpans(tokens, opt, initialListCloseByOpen = null) {
   if (opt.useCounterStyle) {
     return
   }
-  const rawSpanClass = opt?.markerSpanClass
-  const normalizedSpanClass = typeof rawSpanClass === 'string'
-    ? rawSpanClass.trim()
-    : ''
-  const spanClass = normalizedSpanClass || 'li-num'
-  let listCloseByOpen = null
+  const spanClass = opt.markerSpanClass || 'li-num'
+  let listCloseByOpen = initialListCloseByOpen
   const getListCloseByOpen = () => {
     if (!listCloseByOpen) {
       listCloseByOpen = buildListCloseIndexMap(tokens).listCloseByOpen
@@ -58,15 +54,17 @@ function addMarkerSpans(tokens, listToken, listIndex, markerInfo, opt, spanClass
   }
   if (listCloseIndex === -1) return
   
+  const markerCount = markerInfo.markers.length
+  const listItemLevel = (listToken.level || 0) + 1
   let markerIndex = 0
   let inListItem = false
   let listItemInlineFound = false
   
-  for (let i = listIndex + 1; i < listCloseIndex && markerIndex < markerInfo.markers.length; i++) {
+  for (let i = listIndex + 1; i < listCloseIndex && markerIndex < markerCount; i++) {
     const token = tokens[i]
     
     // When list_item_open is found, prepare to add marker to next inline
-    if (token.type === 'list_item_open' && token.level === (listToken.level || 0) + 1) {
+    if (token.type === 'list_item_open' && token.level === listItemLevel) {
       inListItem = true
       listItemInlineFound = false
     }
@@ -77,12 +75,13 @@ function addMarkerSpans(tokens, listToken, listIndex, markerInfo, opt, spanClass
         listItemInlineFound = true
         continue
       }
+      const TokenClass = token.constructor
       // Insert span_open, text, span_close before inline token
-      const spanOpen = new tokens[i].constructor('span_open', 'span', 1)
+      const spanOpen = new TokenClass('span_open', 'span', 1)
       spanOpen.attrSet('class', spanClass)
       spanOpen.attrSet('aria-hidden', 'true')
       
-      const text = new tokens[i].constructor('text', '', 0)
+      const text = new TokenClass('text', '', 0)
       
       // Determine marker content
       // If marker.number exists, get correct symbol based on it
@@ -112,7 +111,7 @@ function addMarkerSpans(tokens, listToken, listIndex, markerInfo, opt, spanClass
       // Use markerContent as-is (prefix+symbol+suffix) for alwaysMarkerSpan
       text.content = markerContent
       
-      const spanClose = new tokens[i].constructor('span_close', 'span', -1)
+      const spanClose = new TokenClass('span_close', 'span', -1)
       
       // Initialize children if not exist
       if (!token.children) {
@@ -124,14 +123,14 @@ function addMarkerSpans(tokens, listToken, listIndex, markerInfo, opt, spanClass
       
       // Add space before content if exists
       if (token.content) {
-        const spaceToken = new tokens[i].constructor('text', '', 0)
+        const spaceToken = new TokenClass('text', '', 0)
         spaceToken.content = ' '
         token.children.push(spaceToken)
       }
       listItemInlineFound = true  // First inline of this list_item is processed
     }
     // When list_item_close is found, go to next list_item
-    else if (token.type === 'list_item_close' && token.level === (listToken.level || 0) + 1) {
+    else if (token.type === 'list_item_close' && token.level === listItemLevel) {
       inListItem = false
       markerIndex++  // Move to next marker
     }

package/src/preprocess-literal-lists.js

@@ -91,46 +91,32 @@ const hasLikelyLiteralMarkerToken = (token) => {
   return core.length <= 4
 }
 
-const hasLikelyLiteralLineHint = (content) => {
+const scanLiteralLineHints = (content) => {
   if (typeof content !== 'string' || !content.includes('\n')) {
-    return false
+    return { hasInlineLiteralHint: false, hasOverIndentedMarkerHint: false, lines: null }
   }
   const lines = content.split('\n')
+  let hasInlineLiteralHint = false
+  let hasOverIndentedMarkerHint = false
   for (let i = 1; i < lines.length; i++) {
     const line = lines[i]
     if (!line || line.trim().length === 0) {
       continue
     }
     const tokenInfo = getLineTokenWithIndent(line)
-    if (!tokenInfo || tokenInfo.indentWidth > MAX_LITERAL_INLINE_INDENT) {
-      continue
-    }
-    if (hasLikelyLiteralMarkerToken(tokenInfo.token)) {
-      return true
-    }
-  }
-  return false
-}
-
-const hasOverIndentedMarkerLikeLine = (content) => {
-  if (typeof content !== 'string' || !content.includes('\n')) {
-    return false
-  }
-  const lines = content.split('\n')
-  for (let i = 1; i < lines.length; i++) {
-    const line = lines[i]
-    if (!line || line.trim().length === 0) {
+    if (!tokenInfo || !hasLikelyLiteralMarkerToken(tokenInfo.token)) {
       continue
     }
-    const tokenInfo = getLineTokenWithIndent(line)
-    if (!tokenInfo || tokenInfo.indentWidth <= MAX_LITERAL_INLINE_INDENT) {
-      continue
+    if (tokenInfo.indentWidth > MAX_LITERAL_INLINE_INDENT) {
+      hasOverIndentedMarkerHint = true
+    } else {
+      hasInlineLiteralHint = true
     }
-    if (hasLikelyLiteralMarkerToken(tokenInfo.token)) {
-      return true
+    if (hasInlineLiteralHint && hasOverIndentedMarkerHint) {
+      break
     }
   }
-  return false
+  return { hasInlineLiteralHint, hasOverIndentedMarkerHint, lines }
 }
 
 /**
@@ -196,19 +182,20 @@ export function normalizeLiteralOrderedLists(tokens, opt) {
           j = paragraphCloseIdx + 1
           continue
         }
-        if (!hasLikelyLiteralLineHint(inlineToken.content)) {
+        const literalHints = scanLiteralLineHints(inlineToken.content)
+        if (!literalHints.hasInlineLiteralHint) {
           j = paragraphCloseIdx + 1
           continue
         }
         // Be conservative when deeply-indented marker-like lines are present.
         // These lines are often code blocks; partial literal conversion is more surprising
         // than preserving markdown-it's original rendering in this ambiguous case.
-        if (hasOverIndentedMarkerLikeLine(inlineToken.content)) {
+        if (literalHints.hasOverIndentedMarkerHint) {
           j = paragraphCloseIdx + 1
           continue
         }
         const baseLine = tokens[j].map ? tokens[j].map[0] : null
-        const segments = parseSegments(inlineToken.content, markerWidth, baseLine)
+        const segments = parseSegments(literalHints.lines, markerWidth, baseLine)
         if (!segments.hasLiteral) {
           j = paragraphCloseIdx + 1
           continue
@@ -247,12 +234,15 @@ export function normalizeLiteralOrderedLists(tokens, opt) {
   }
 }
 
-function parseSegments(content, markerWidth, baseLine = null) {
-  if (!content) {
+function parseSegments(contentOrLines, markerWidth, baseLine = null) {
+  if (!contentOrLines) {
     return { hasLiteral: false, list: [{ type: 'text', text: '', tight: false }] }
   }
 
-  const lines = content.split('\n')
+  const lines = Array.isArray(contentOrLines) ? contentOrLines : contentOrLines.split('\n')
+  if (lines.length === 0) {
+    return { hasLiteral: false, list: [{ type: 'text', text: '', tight: false }] }
+  }
   const literalCache = new Array(lines.length)
   const segments = []
   let buffer = []
@@ -280,8 +270,7 @@ function parseSegments(content, markerWidth, baseLine = null) {
 
   while (idx < lines.length) {
     const isFirstLine = idx === 0
-    const trimmedLine = lines[idx].trim()
-    if (isFirstLine && trimmedLine.length > 0) {
+    if (isFirstLine && lines[idx].trim().length > 0) {
       buffer.push(lines[idx])
       idx++
       continue
@@ -334,7 +323,7 @@ function detectLiteralLine(line, markerWidth) {
   if (!trimmed.startsWith(markerInfo.marker)) {
     return null
   }
-  const remainder = trimmed.slice(markerInfo.marker.length).replace(/^\s+/, '')
+  const remainder = trimmed.slice(markerInfo.marker.length).trimStart()
   const safeMarkerWidth = Number.isFinite(markerWidth) ? markerWidth : 1
   return {
     indent: safeMarkerWidth + indentWidth,
@@ -458,7 +447,7 @@ function buildReplacementTokens(segments, listItemLevel, TokenClass, paragraphOp
       for (const listNode of segment.lists) {
         const relativeIndex = tokens.length
         tokens.push(...buildListTokens(listNode, listItemLevel + 1, TokenClass))
-        literalListPositions.push({ relativeIndex, level: listItemLevel + 1 })
+        literalListPositions.push({ relativeIndex })
       }
       templateUsed = true
     }

package/src/types-utility.js

@@ -2,27 +2,6 @@
 
 import types from '../listTypes.json' with { type: 'json' }
 
-/**
- * Check if a marker type is convertible in default mode
- * Exotic markers that aren't commonly used are excluded from conversion
- * @param {string} markerType - The marker type name (e.g., 'decimal', 'lower-greek')
- * @returns {boolean} True if the marker type should be converted in default mode
- */
-export const isConvertibleMarkerType = (markerType) => {
-  if (!markerType) return false
-  
-  // Exclude exotic markers that should remain as <ul> in default mode
-  // These are rarely used and may not be well-supported
-  const excludedTypes = [
-    'fullwidth-lower-roman',
-    'fullwidth-upper-roman',
-    'squared-upper-latin',
-    'filled-squared-upper-latin'
-  ]
-  
-  return !excludedTypes.includes(markerType)
-}
-
 const escapeRegExp = (string) => {
   return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
 }
@@ -304,10 +283,9 @@ export const detectSequencePattern = (allContents) => {
   const allSame = pureSymbols.every(s => s === pureSymbols[0])
   
   // Cache type lookups
-  const { typeInfoByName } = getTypeSeparation()
-  const irohaType = typeInfoByName.get('katakana-iroha')
-  const katakanaType = typeInfoByName.get('katakana')
-  const upperRomanType = typeInfoByName.get('upper-roman')
+  const irohaType = _TYPE_INFO_BY_NAME.get('katakana-iroha')
+  const katakanaType = _TYPE_INFO_BY_NAME.get('katakana')
+  const upperRomanType = _TYPE_INFO_BY_NAME.get('upper-roman')
   
   // Get symbol sequences from listTypes.json
   if (irohaType?.symbols) {
@@ -407,8 +385,7 @@ export const detectMarkerTypeWithContext = (content, contextResult = null) => {
  * @returns {string|null} The symbol for that number, or null if not found
  */
 export const getSymbolForNumber = (markerType, number) => {
-  const { typeInfoByName } = getTypeSeparation()
-  const typeInfo = typeInfoByName.get(markerType)
+  const typeInfo = _TYPE_INFO_BY_NAME.get(markerType)
   if (!typeInfo) {
     return null
   }
@@ -444,51 +421,19 @@ export const getSymbolForNumber = (markerType, number) => {
   return null
 }
 
-/**
- * Get the default prefix/suffix pattern for a marker type
- * @param {string} markerType - The marker type name (e.g., 'lower-roman', 'decimal')
- * @returns {Object} Object with prefix and suffix properties
- */
-export const getDefaultPatternForType = (markerType) => {
-  const { typeInfoByName } = getTypeSeparation()
-  const typeInfo = typeInfoByName.get(markerType)
-  if (!typeInfo) {
-    return { prefix: '', suffix: '.' }
-  }
-  
-  // Get patterns for this type (prefer `pattern` property)
-  const patternRef = typeInfo.pattern || null
-  const patterns = getPatternsByName(patternRef)
-  if (!patterns || patterns.length === 0) {
-    return { prefix: '', suffix: '.' }
-  }
-  
-  // Return the first pattern as the default
-  return {
-    prefix: patterns[0].prefix || '',
-    suffix: patterns[0].suffix || '.'
-  }
-}
-
-const prefixs = [
+const prefixLabels = [
   ['(', 'round'],
-  //['[', 'square'],
-  //['{', 'curly'],
-  //['<', 'angle'],
-  ['（', 'fullround'],
+  ['（', 'fullround']
 ]
 
-const suffixs = [
+const suffixLabels = [
   [')', 'round'],
-  //[']', 'square'],
-  //['}', 'curly'],
-  //['>', 'angle'],
-  ['）', 'fullround'],
+  ['）', 'fullround']
 ]
 
 // Build Maps for O(1) lookups (faster than .find on every call)
-const prefixMap = new Map(prefixs)
-const suffixMap = new Map(suffixs)
+const prefixMap = new Map(prefixLabels)
+const suffixMap = new Map(suffixLabels)
 
 const generateClassName = (baseClass, prefix, suffix) => {
   // fast path: no prefix and no suffix
@@ -523,8 +468,7 @@ const CUSTOM_TYPES_NO_SUFFIX = new Set([
 ])
 
 export const getTypeAttributes = (markerType, markerInfo = null, opt = {}) => {
-  const { typeInfoByName } = getTypeSeparation()
-  const type = typeInfoByName.get(markerType)
+  const type = _TYPE_INFO_BY_NAME.get(markerType)
   if (!type) {
     return { type: '1', class: 'ol-decimal', suffix: '.' }
   }
@@ -637,20 +581,13 @@ const createPatternTail = (pattern) => {
 // Process patterns for symbols
 const processSymbolPatterns = (patterns, symbols, typePatterns, type) => {
   // Pre-compute escaped prefixes, suffixes and regex tail once
-  const patternCache = new Map()
-  typePatterns.forEach((pattern, index) => {
-    const escapedPrefix = pattern.prefix ? escapeRegExp(pattern.prefix) : ''
-    const escapedSuffix = pattern.suffix ? escapeRegExp(pattern.suffix) : ''
-    const tail = createPatternTail(pattern)
-    patternCache.set(index, {
-      prefix: pattern.prefix,
-      suffix: pattern.suffix,
-      space: pattern.space,
-      escapedPrefix,
-      escapedSuffix,
-      tail
-    })
-  })
+  const patternCache = typePatterns.map(pattern => ({
+    prefix: pattern.prefix,
+    suffix: pattern.suffix,
+    escapedPrefix: pattern.prefix ? escapeRegExp(pattern.prefix) : '',
+    escapedSuffix: pattern.suffix ? escapeRegExp(pattern.suffix) : '',
+    tail: createPatternTail(pattern)
+  }))
   
   // Use pre-computed cache for faster pattern generation
   const symbolsLength = symbols.length
@@ -661,7 +598,7 @@ const processSymbolPatterns = (patterns, symbols, typePatterns, type) => {
     const processedSym = sym.replace(/^\\\\/,'\\')
     
     for (let patternIndex = 0; patternIndex < patternsLength; patternIndex++) {
-      const cached = patternCache.get(patternIndex)
+      const cached = patternCache[patternIndex]
       // Original suffix variant
       const symbolPartOrig = cached.escapedPrefix + processedSym + cached.escapedSuffix
       const regexStrOrig = `^(${symbolPartOrig})${cached.tail}`
@@ -767,16 +704,13 @@ export const compiledTypes = (() => {
   }
 })()
 
-// Map of compiled types by name for O(1) lookup
-// Build a map of compiled types by name once for fast lookups
+// Build a map of compiled types by name once for fast lookups.
 const _COMPILED_BY_NAME = (() => {
   const m = new Map()
   for (const t of compiledTypes()) m.set(t.name, t)
   return m
 })()
 
-export const compiledTypesByName = () => _COMPILED_BY_NAME
-
 // Build a flattened pattern list (preserve previous priority: sortedSymbolTypes then rangeBasedTypes)
 const _FLATTENED_PATTERNS = (() => {
   const arr = []
@@ -791,8 +725,6 @@ const _FLATTENED_PATTERNS = (() => {
         suffix: p.suffix,
         typeName: compiledType.name,
         symbolIndex: p.symbolIndex,
-        num: p.num,
-        isRange: p.isRange,
         compiled: compiled || null
       })
     }
@@ -800,6 +732,74 @@ const _FLATTENED_PATTERNS = (() => {
   return arr
 })()
 
+const _TYPE_INFO_BY_NAME = getTypeSeparation().typeInfoByName
+const ASCII_DIGIT_LEADS = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
+
+const getFirstCodePointChar = (text) => {
+  if (typeof text !== 'string' || text.length === 0) {
+    return null
+  }
+  const firstCodePoint = text.codePointAt(0)
+  if (firstCodePoint === undefined) {
+    return null
+  }
+  return firstCodePoint > 0xFFFF ? text.slice(0, 2) : text[0]
+}
+
+const buildEntryLeadingChars = (entry) => {
+  const prefixedLead = getFirstCodePointChar(entry.prefix)
+  if (prefixedLead) {
+    return [prefixedLead]
+  }
+
+  const typeInfo = _TYPE_INFO_BY_NAME.get(entry.typeName)
+  if (!typeInfo) {
+    return []
+  }
+
+  if (Array.isArray(typeInfo.symbols)) {
+    const symbol = typeInfo.symbols[entry.symbolIndex]
+    const symbolLead = getFirstCodePointChar(symbol)
+    return symbolLead ? [symbolLead] : []
+  }
+
+  if (!Array.isArray(typeInfo.range) || typeInfo.range.length !== 2) {
+    return []
+  }
+
+  if (typeof typeInfo.range[0] === 'number') {
+    return ASCII_DIGIT_LEADS
+  }
+
+  const start = typeInfo.range[0]?.codePointAt(0)
+  const end = typeInfo.range[1]?.codePointAt(0)
+  if (typeof start !== 'number' || typeof end !== 'number' || end < start) {
+    return []
+  }
+
+  const leadingChars = []
+  for (let codePoint = start; codePoint <= end; codePoint++) {
+    leadingChars.push(String.fromCodePoint(codePoint))
+  }
+  return leadingChars
+}
+
+const _FLATTENED_PATTERNS_BY_LEAD = (() => {
+  const buckets = new Map()
+  for (const entry of _FLATTENED_PATTERNS) {
+    const leadingChars = buildEntryLeadingChars(entry)
+    for (const leadingChar of leadingChars) {
+      let bucket = buckets.get(leadingChar)
+      if (!bucket) {
+        bucket = []
+        buckets.set(leadingChar, bucket)
+      }
+      bucket.push(entry)
+    }
+  }
+  return buckets
+})()
+
 const tryMatchAgainstType = (trimmed, typeName) => {
   if (!typeName) return null
   const compiled = _COMPILED_BY_NAME.get(typeName)
@@ -813,7 +813,12 @@ const tryMatchAgainstType = (trimmed, typeName) => {
 
 // Fast matcher over flattened list
 const tryMatchAgainstFlattened = (trimmed) => {
-  for (const entry of _FLATTENED_PATTERNS) {
+  const leadingChar = getFirstCodePointChar(trimmed)
+  const candidates = leadingChar ? _FLATTENED_PATTERNS_BY_LEAD.get(leadingChar) : null
+  if (!candidates) {
+    return null
+  }
+  for (const entry of candidates) {
     const m = matchRegexEntry(trimmed, entry.typeName, entry)
     if (m) return m
   }
@@ -828,155 +833,9 @@ const matchRegexEntry = (trimmed, typeName, entry) => {
 
   const detectedMarker = result[1]
   const pureSymbol = extractPureSymbol(detectedMarker, entry.prefix, entry.suffix)
-  const { typeInfoByName } = getTypeSeparation()
-  const typeInfo = typeInfoByName.get(typeName)
+  const typeInfo = _TYPE_INFO_BY_NAME.get(typeName)
   const compiledForCalc = entry.compiled || _COMPILED_BY_NAME.get(typeName)
   const number = calculateNumber(typeInfo, pureSymbol, compiledForCalc)
 
   return createMarkerResult(typeName, detectedMarker, number, entry.prefix, entry.suffix)
 }
-
-// Analyze list context to determine optimal marker type for ambiguous cases
-export const analyzeListMarkerContext = (markerInfos) => {
-  if (!markerInfos || markerInfos.length === 0) return markerInfos
-  
-  const { symbolBasedTypes, typeInfoByName } = getTypeSeparation()
-  
-  // Create typeInfo lookup cache
-  const typeInfoCache = new Map()
-  for (const compiledType of symbolBasedTypes) {
-    const typeInfo = typeInfoByName.get(compiledType.name)
-    if (typeInfo?.symbols) {
-      typeInfoCache.set(compiledType.name, typeInfo)
-    }
-  }
-  
-  // Group markers by possible types
-  const candidateTypes = new Map()
-  
-  markerInfos.forEach((markerInfo, index) => {
-    if (!markerInfo.marker) return
-    
-    // Extract the actual symbol without prefix/suffix
-    const actualSymbol = extractPureSymbol(markerInfo.marker, markerInfo.prefix, markerInfo.suffix)
-    
-    // Find all possible types for this marker
-    const possibleTypes = []
-      for (const [typeName, typeInfo] of typeInfoCache) {
-        let symbolIndex = -1
-        const compiled = _COMPILED_BY_NAME.get(typeName)
-        if (compiled && compiled.symbolIndexMap) {
-          const idx = compiled.symbolIndexMap.get(actualSymbol)
-          symbolIndex = idx !== undefined ? idx : -1
-        } else {
-          symbolIndex = typeInfo.symbols.indexOf(actualSymbol)
-        }
-
-      if (symbolIndex !== -1) {
-        const expectedNumber = symbolIndex + getStartValue(typeInfo)
-
-        possibleTypes.push({
-          typeName,
-          symbolIndex,
-          expectedNumber,
-          actualPosition: index + 1
-        })
-      }
-    }
-    
-    possibleTypes.forEach(pt => {
-      if (!candidateTypes.has(pt.typeName)) {
-        candidateTypes.set(pt.typeName, { 
-          matches: 0, 
-          totalItems: markerInfos.length,
-          positions: []
-        })
-      }
-      
-      const candidate = candidateTypes.get(pt.typeName)
-      candidate.matches++
-      candidate.positions.push({
-        index,
-        expectedNumber: pt.expectedNumber,
-        actualPosition: pt.actualPosition,
-        marker: markerInfo.marker
-      })
-    })
-  })
-  
-  // Score each candidate type
-  let bestType = null
-  let bestScore = -1
-  
-  for (const [typeName, candidate] of candidateTypes) {
-    let score = 0
-    
-    // Check if positions form a consecutive sequence starting from 1
-    candidate.positions.sort((a, b) => a.index - b.index)
-    let isConsecutiveFrom1 = true
-    let expectedStart = 1
-    
-    for (let i = 0; i < candidate.positions.length; i++) {
-      const pos = candidate.positions[i]
-      if (pos.expectedNumber !== expectedStart + i) {
-        isConsecutiveFrom1 = false
-        break
-      }
-    }
-    
-    // Higher score for consecutive sequences starting from 1
-    if (isConsecutiveFrom1 && candidate.positions.length > 0 && candidate.positions[0].expectedNumber === 1) {
-      score += 100
-    }
-    
-    // Higher score for more matches
-    score += candidate.matches * 10
-    
-    // Higher score for covering all items
-    if (candidate.matches === candidate.totalItems) {
-      score += 50
-    }
-    
-    if (score > bestScore) {
-      bestScore = score
-      bestType = typeName
-    }
-  }
-  
-  // If we found a better type, update all marker infos
-  if (bestType && candidateTypes.get(bestType).matches > 0) {
-    const typeInfo = typeInfoCache.get(bestType)
-    if (typeInfo) {
-      const updatedMarkerInfos = markerInfos.map((markerInfo, index) => {
-        if (!markerInfo.marker) return markerInfo
-        
-        // Extract the actual symbol without prefix/suffix
-        const actualSymbol = extractPureSymbol(markerInfo.marker, markerInfo.prefix, markerInfo.suffix)
-        
-        // Use precomputed symbolIndexMap if available
-        const compiled = _COMPILED_BY_NAME.get(bestType)
-        let symbolIndex = -1
-        if (compiled && compiled.symbolIndexMap) {
-          const idx = compiled.symbolIndexMap.get(actualSymbol)
-          symbolIndex = idx !== undefined ? idx : -1
-        } else {
-          symbolIndex = typeInfo.symbols.indexOf(actualSymbol)
-        }
-        if (symbolIndex !== -1) {
-          const number = calculateNumber(typeInfo, actualSymbol)
-
-          return {
-            ...markerInfo,
-            type: bestType,
-            number: number
-          }
-        }
-        return markerInfo
-      })
-      
-      return updatedMarkerInfos
-    }
-  }
-  
-  return markerInfos
-}