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

package/README.md

@@ -45,6 +45,7 @@ The plugin supports the following marker types.
     - filled-squared-upper-latin: `🅰`, `🅱`, `🅲`, pattern: enclosed
     - fullwidth-lower-roman: `ⅰ`, `ⅱ`, `ⅲ`, pattern: fullwidth
     - fullwidth-upper-roman: `Ⅰ`, `Ⅱ`, `Ⅲ`, pattern: fullwidth
+    - fullwidth-decimal: `０`, `１`, `２`, pattern: fullwidth
     - japanese-informal: `一`, `二`, `三`, pattern: fullwidth
     - katakana: `ア`, `イ`, `ウ`, pattern: fullwidth
     - katakana-iroha: `イ`, `ロ`, `ハ`, pattern: fullwidth
@@ -91,7 +92,7 @@ You can customize the conversion using options.
 - `omitMarkerMetadata` (boolean) — If `true`, omit the `data-marker-prefix` / `data-marker-suffix` attributes.
 - `addMarkerStyleToClass` (boolean) — When `true`, append suffix-style information to the generated class name (e.g. `ol-decimal-with-round-round`). When `false` (default) the class stays as `ol-decimal`.
 - `enableLiteralNumberingFix` (boolean) — Enable literal nested list recovery (for example, nested lists starting with 2 or greater). Default is `false` (legacy-compatible); set it to `true` to normalize literal nested numbering. It only applies inside list items, evaluates indentation relative to the parent list marker (marker width + 0–3 spaces), and does not convert code blocks (indent >= marker width + 4).
-  - Compatibility note: compared with the default/legacy mode (`enableLiteralNumberingFix: false`), enabling `true` changes rendered HTML by design. On the current test corpus (`395` markdown cases), `19` cases change.
+  - Compatibility note: compared with the default/legacy mode (`enableLiteralNumberingFix: false`), enabling `true` changes rendered HTML by design. On the current test corpus (`399` markdown cases), `19` cases change.
   - Changed files in that comparison: `examples-default-14-repeated-numbers.txt` (`7`), `examples-option-literal-numbering-attrs-disabled.txt` (`1`), `examples-option-literal-numbering-attrs.txt` (`1`), `examples-option-literal-numbering-fix-disabled.txt` (`2`), `examples-option-literal-numbering-fix.txt` (`4`), `examples-option-literal-numbering-indent.txt` (`4`).
   - Migration tip: if you enable `enableLiteralNumberingFix: true`, treat it as a breaking-output change for snapshots/downstream HTML.
   - Detailed notes: `docs/enable-literal-numbering-fix.md`.
@@ -146,7 +147,7 @@ Custom marker conversion example:
 - ③ Third
 
 [HTML]
-<ol role="list" class="ol-filled-circled-decimal">
+<ol role="list" class="ol-circled-decimal">
 <li><span class="li-num" aria-hidden="true">①</span> First</li>
 <li><span class="li-num" aria-hidden="true">②</span> Second</li>
 <li><span class="li-num" aria-hidden="true">③</span> Third</li>
@@ -269,9 +270,9 @@ When description lists are enabled the plugin can convert the following patterns
 
 ```
 [Markdown]
-- **Term 1**  
+- **Term 1**
 Description text for term 1
-- **Term 2**  
+- **Term 2**
 Description text for term 2
 
 [HTML]
@@ -350,3 +351,5 @@ md.use(mditNumberingUl)
 const html = md.render(`- a. First\n- b. Second`)
 console.log(html)
 ```
+
+Register this plugin only once per `markdown-it` instance. A second registration fails fast because running the conversion pipeline twice on the same token stream would corrupt already-converted lists.

package/index.js

@@ -7,7 +7,17 @@ import { processHtmlBlocks } from './src/phase4-html-blocks.js'
 import { generateSpans } from './src/phase5-spans.js'
 import { normalizeLiteralOrderedLists } from './src/preprocess-literal-lists.js'
 
+const INSTALL_FLAG = Symbol.for('@peaceroad/markdown-it-numbering-ul-regarded-as-ol/installed')
+
 const mditNumberingUl = (md, option) => {
+  if (md[INSTALL_FLAG]) {
+    throw new Error('@peaceroad/markdown-it-numbering-ul-regarded-as-ol is already registered on this markdown-it instance')
+  }
+  Object.defineProperty(md, INSTALL_FLAG, {
+    value: true,
+    configurable: false
+  })
+
   const opt = {
     // Core options
     descriptionList: false,       // Convert **Term** patterns to <dl>/<dt>/<dd>
@@ -21,7 +31,7 @@ const mditNumberingUl = (md, option) => {
     useCounterStyle: false,       // true=users will use @counter-style; suppress marker spans and role attr
     addMarkerStyleToClass: false, // true=append -with-* marker style suffix to class names
     enableLiteralNumberingFix: false, // true=normalize nested lists that don't start at 1 (opt-in)
-    
+
     // Override with user options
     ...option
   }
@@ -68,11 +78,11 @@ const mditNumberingUl = (md, option) => {
     if (opt.enableLiteralNumberingFix) {
       normalizeLiteralOrderedLists(tokens, opt)
     }
-    
+
     // ===== PHASE 1: List Structure Analysis =====
     // Analyze marker detection and structure without token conversion
     const listInfos = analyzeListStructure(tokens)
-    
+
     // ===== PHASE 2: Token Conversion =====
     // Convert bullet_list to ordered_list based on Phase1 analysis
     // Note: simplifyNestedBulletLists removes tokens, changing indices
@@ -92,32 +102,33 @@ const mditNumberingUl = (md, option) => {
         break
       }
     }
-    
+
     // ===== PHASE 3: Add Attributes =====
     // Add type, class, data-* attributes to converted lists
     // Use markerInfo stored on list tokens (safe after Phase2 mutations)
+    let closeMap = null
     if (hasOrderedList) {
-      addAttributes(tokens, opt)
+      closeMap = addAttributes(tokens, opt)
     }
-    
+
     // ===== PHASE 4: HTML Block Processing =====
     // Remove indents from HTML blocks in lists and normalize line breaks
     if (hasNestedHtmlBlock) {
       processHtmlBlocks(state)
     }
-    
+
     // ===== PHASE 5: Span Generation =====
     // Generate marker spans in alwaysMarkerSpan mode
     if (hasOrderedList && !opt.useCounterStyle) {
-      generateSpans(tokens, opt)
+      generateSpans(tokens, opt, closeMap?.listCloseByOpen || null)
     }
-    
+
     return true
   }
 
   md.core.ruler.before('inline', 'numbering_dl_parser', dlProcessor)
   md.core.ruler.after('numbering_dl_parser', 'numbering_ul_phases', listProcessor)
-  
+
   // Description list: Move paragraph attributes to dl and add custom renderers
   if (opt.descriptionList || opt.descriptionListWithDiv) {
     // Move paragraph attributes to dl (after inline and any attribute plugins)
@@ -125,7 +136,7 @@ const mditNumberingUl = (md, option) => {
       moveParagraphAttributesToDL(state.tokens)
       return true
     }
-    
+
     addRuleAfter(md.core.ruler, 'curly_attributes', 'numbering_dl_attrs', dlAttrProcessor)
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peaceroad/markdown-it-numbering-ul-regarded-as-ol",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "description": "This markdown-it plugin regard ul element with numbering lists as ol element.",
   "main": "index.js",
   "type": "module",
@@ -27,8 +27,8 @@
   },
   "homepage": "https://github.com/peaceroad/p7d-markdown-it-numbering-ul-regarded-as-ol#readme",
   "devDependencies": {
-    "@peaceroad/markdown-it-cjk-breaks-mod": "^0.1.8",
-    "@peaceroad/markdown-it-strong-ja": "^0.8.0",
+    "@peaceroad/markdown-it-cjk-breaks-mod": "^0.1.10",
+    "@peaceroad/markdown-it-strong-ja": "^0.9.0",
     "markdown-it": "^14.1.0",
     "markdown-it-attrs": "^4.3.1",
     "markdown-it-deflist": "^3.0.0"

package/src/list-helpers.js

@@ -49,11 +49,13 @@ export function findListItemEnd(tokens, startIndex) {
 /**
  * Build close-index maps for list and list_item tokens.
  * @param {Array} tokens - Token array
- * @returns {{ listCloseByOpen: number[], listItemCloseByOpen: number[] }}
+ * @returns {{ listCloseByOpen: Int32Array, listItemCloseByOpen: Int32Array }}
  */
 export function buildListCloseIndexMap(tokens) {
-  const listCloseByOpen = new Array(tokens.length).fill(-1)
-  const listItemCloseByOpen = new Array(tokens.length).fill(-1)
+  const listCloseByOpen = new Int32Array(tokens.length)
+  listCloseByOpen.fill(-1)
+  const listItemCloseByOpen = new Int32Array(tokens.length)
+  listItemCloseByOpen.fill(-1)
   const bulletStack = []
   const orderedStack = []
   const listItemStack = []

package/src/phase1-analyze.js

@@ -3,69 +3,6 @@
 import { detectMarkerType, detectMarkerTypeWithContext, detectSequencePattern } from './types-utility.js'
 import { buildListCloseIndexMap, findMatchingClose } from './list-helpers.js'
 
-/**
- * Pre-compute DL scope (identify all DL ranges in O(n))
- * @param {Array} tokens - Token array
- * @returns {Array<[number, number]>} DL range pairs [[start, end], ...]
- */
-function buildDLStateMap(tokens) {
-  const state = new Uint8Array(tokens.length)
-  let dlDepth = 0
-  let htmlDdDepth = 0
-  
-  for (let i = 0; i < tokens.length; i++) {
-    const token = tokens[i]
-    
-    if (dlDepth > 0 || htmlDdDepth > 0) {
-      state[i] = 1
-    }
-    
-    if (token.type === 'dl_open') {
-      state[i] = 1
-      dlDepth++
-      continue
-    }
-    
-    if (token.type === 'dl_close') {
-      state[i] = 1
-      if (dlDepth > 0) {
-        dlDepth--
-      }
-      continue
-    }
-    
-    if (token.type === 'html_block') {
-      if (token.content === '<dd>\n') {
-        state[i] = 1
-        htmlDdDepth++
-        continue
-      }
-      if (token.content === '</dd>\n') {
-        state[i] = 1
-        if (htmlDdDepth > 0) {
-          htmlDdDepth--
-        }
-        continue
-      }
-    }
-  }
-  
-  return state
-}
-
-/**
- * Check if token at specified index is inside DL
- * @param {number} index - Index to check
- * @param {Array<[number, number]>} dlRanges - DL range pairs
- * @returns {boolean} True if inside DL
- */
-function isInsideDL(index, dlState) {
-  if (!dlState || index < 0 || index >= dlState.length) {
-    return false
-  }
-  return dlState[index] === 1
-}
-
 /**
  * Collect list information from token array
  * @param {Array} tokens - markdown-it token array
@@ -74,36 +11,18 @@ function isInsideDL(index, dlState) {
 export function analyzeListStructure(tokens) {
   const listInfos = []
   const closeMap = buildListCloseIndexMap(tokens)
-  
-  // Check DL existence (O(n) but optimized with early return)
-  let hasDL = false
-  for (let i = 0; i < tokens.length; i++) {
-    if (tokens[i].type === 'dl_open' || 
-        (tokens[i].type === 'html_block' && tokens[i].content === '<dd>\n')) {
-      hasDL = true
-      break
-    }
-  }
-  
-  // Pre-compute DL scope flags (only when DL exists)
-  const dlScope = hasDL ? buildDLStateMap(tokens) : null
-  
-  // Process only top-level lists (nested lists collected recursively)
-  // Also process lists inside DL
+
+  // Process every list root in the token stream, including lists nested in
+  // containers such as blockquotes or description-list descriptions. Nested
+  // lists inside an already-analyzed list are collected recursively, then the
+  // scan jumps to that list's close token to avoid duplicate processing.
   for (let i = 0; i < tokens.length; i++) {
     const token = tokens[i]
     if (!token) {
       continue
     }
-    
-    // Process level-0 lists or lists at any level inside DD
-    const isTopLevelList = (token.type === 'bullet_list_open' || token.type === 'ordered_list_open') && 
-                           (token.level === 0 || token.level === undefined)
-    const isListInDD = (token.type === 'bullet_list_open' || token.type === 'ordered_list_open') && 
-                       token.level > 0 && 
-                       isInsideDL(i, dlScope)
-    
-    if (isTopLevelList || isListInDD) {
+
+    if (token.type === 'bullet_list_open' || token.type === 'ordered_list_open') {
       const listInfo = analyzeList(tokens, i, closeMap)
       if (listInfo) {
         listInfos.push(listInfo)
@@ -217,10 +136,9 @@ function analyzeListItems(tokens, startIndex, endIndex, closeMap) {
  * Analyze a single list item
  */
 function analyzeListItem(tokens, startIndex, endIndex, closeMap) {
-  let content = ''
   let markerInfo = null
   let hasNestedList = false
-  let nestedLists = []
+  const nestedLists = []
   let firstParagraphIsLoose = false
   let lastInlineContent = ''
   
@@ -267,7 +185,6 @@ function analyzeListItem(tokens, startIndex, endIndex, closeMap) {
   if (firstParagraphIsLoose && hasNestedList && lastInlineContent) {
     markerInfo = detectMarkerType(lastInlineContent)
   }
-  content = lastInlineContent
 
   if (tokens[startIndex]) {
     tokens[startIndex]._firstParagraphIsLoose = firstParagraphIsLoose
@@ -276,7 +193,7 @@ function analyzeListItem(tokens, startIndex, endIndex, closeMap) {
   return {
     startIndex,
     endIndex,
-    content,
+    content: lastInlineContent,
     markerInfo,
     hasNestedList,
     nestedLists,
@@ -348,35 +265,32 @@ function extractMarkerInfo(tokens, startIndex, endIndex) {
     // Detect markers using full context
     let sequentialNumber = 1  // Sequential number counter
     for (const token of inlineTokens) {
-      // Process only inline tokens of direct child items of this list
-      if (token.type === 'inline' && token.content && token.level === targetLevel) {
-        const markerInfo = detectMarkerTypeWithContext(token.content, contextResult)
-        if (markerInfo && markerInfo.type) {
-          // Use sequential numbers when same marker continues
-          // (e.g., "イ. イ. イ." → interpreted as "イ、ロ、ハ")
-          const adjustedMarkerInfo = { ...markerInfo }
-          adjustedMarkerInfo.originalNumber = markerInfo.number
-          
-          // Assign sequential numbers based on first marker's number
-          if (markers.length === 0) {
-            // Use first marker as-is
-            sequentialNumber = markerInfo.number || 1
+      const markerInfo = detectMarkerTypeWithContext(token.content, contextResult)
+      if (markerInfo && markerInfo.type) {
+        // Use sequential numbers when same marker continues
+        // (e.g., "イ. イ. イ." → interpreted as "イ、ロ、ハ")
+        const adjustedMarkerInfo = { ...markerInfo }
+        adjustedMarkerInfo.originalNumber = markerInfo.number
+
+        // Assign sequential numbers based on first marker's number
+        if (markers.length === 0) {
+          // Use first marker as-is
+          sequentialNumber = markerInfo.number || 1
+        } else {
+          // For 2nd and later, use sequential number if same as previous marker
+          const prevMarker = markers[markers.length - 1]
+          if (markerInfo.marker === prevMarker.marker &&
+              markerInfo.type === prevMarker.type) {
+            // Assign sequential number when same marker continues
+            sequentialNumber++
+            adjustedMarkerInfo.number = sequentialNumber
           } else {
-            // For 2nd and later, use sequential number if same as previous marker
-            const prevMarker = markers[markers.length - 1]
-            if (markerInfo.marker === prevMarker.marker && 
-                markerInfo.type === prevMarker.type) {
-              // Assign sequential number when same marker continues
-              sequentialNumber++
-              adjustedMarkerInfo.number = sequentialNumber
-            } else {
-              // For different marker, use detected number
-              sequentialNumber = markerInfo.number || sequentialNumber + 1
-            }
+            // For different marker, use detected number
+            sequentialNumber = markerInfo.number || sequentialNumber + 1
           }
-          
-          markers.push(adjustedMarkerInfo)
         }
+
+        markers.push(adjustedMarkerInfo)
       }
     }
   }

package/src/phase2-convert.js

@@ -167,10 +167,9 @@ function removeMarkersFromContent(tokens, startIndex, endIndex, markerInfo) {
 }
 
 /**
- * Simplify nested ul>li>ul and ul>li>ol structures.
+ * Simplify nested ul>li>ol structures.
  *
- * Pattern 1: bullet_list_open → list_item_open → bullet_list_open → ...
- * Pattern 2: bullet_list_open → list_item_open → ordered_list_open → ... (repeated)
+ * Pattern: bullet_list_open → list_item_open → ordered_list_open → ... (repeated)
  *
  * When the middle list_item is empty (contains only the inner list),
  * remove the outer ul and the intermediate li.

package/src/phase3-attributes.js

@@ -37,6 +37,8 @@ export function addAttributes(tokens, opt) {
   if (hasAnyListItemValue) {
     normalizeAndConvertValueAttributes(tokens, listCloseByOpen)
   }
+
+  return closeMap
 }
 
 function hasValueAttr(token) {
@@ -55,15 +57,14 @@ function hasValueAttr(token) {
  * Add attributes to a single list token
  */
 function addListAttributesForToken(tokens, token, tokenIndex, opt, listCloseByOpen = null) {
-  // Initialize attribute array
-  if (!token.attrs) {
-    token.attrs = []
-  }
-  
   // Get marker info
   const markerInfo = token._markerInfo
   
   if (!markerInfo) {
+    if (!token.attrs) {
+      token.attrs = []
+    }
+
     // Default attributes for lists without markerInfo
     if (opt.useCounterStyle) {
       // Do not add type attribute; add class so user CSS/@counter-style can target
@@ -85,7 +86,7 @@ function addListAttributesForToken(tokens, token, tokenIndex, opt, listCloseByOp
   
   // Attributes according to marker type
   // Pass first marker's prefix/suffix info to determine class name
-  const firstMarker = markerInfo.markers[0]
+  const firstMarker = markerInfo.markers?.[0]
   const typeAttrs = getTypeAttributes(markerInfo.type, firstMarker, opt)
   
   // Reset attribute array
@@ -121,19 +122,7 @@ function addListAttributesForToken(tokens, token, tokenIndex, opt, listCloseByOp
   
   // 3. Add class attribute
   if (typeAttrs.class) {
-    // Merge or add class; preserve existing classes and append
-    let classAttr = null
-    for (let i = 0; i < token.attrs.length; i++) {
-      if (token.attrs[i][0] === 'class') {
-        classAttr = token.attrs[i]
-        break
-      }
-    }
-    if (classAttr) {
-      classAttr[1] = (classAttr[1] + ' ' + typeAttrs.class).trim()
-    } else {
-      addAttr(token, 'class', typeAttrs.class)
-    }
+    addAttr(token, 'class', typeAttrs.class)
   }
   // 4. data-marker-prefix/suffix
   if (!opt.omitMarkerMetadata) {

package/src/phase5-spans.js

@@ -9,12 +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 spanClass = opt.markerSpanClass || 'li-num'
-  let listCloseByOpen = null
+  let listCloseByOpen = initialListCloseByOpen
   const getListCloseByOpen = () => {
     if (!listCloseByOpen) {
       listCloseByOpen = buildListCloseIndexMap(tokens).listCloseByOpen

package/src/types-utility.js

@@ -2,26 +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
-
-  return !EXCLUDED_MARKER_TYPES.has(markerType)
-}
-
-// Exclude exotic markers that should remain as <ul> in default mode.
-const EXCLUDED_MARKER_TYPES = new Set([
-  'fullwidth-lower-roman',
-  'fullwidth-upper-roman',
-  'squared-upper-latin',
-  'filled-squared-upper-latin'
-])
-
 const escapeRegExp = (string) => {
   return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
 }
@@ -441,50 +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 typeInfo = _TYPE_INFO_BY_NAME.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
@@ -632,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
@@ -656,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}`
@@ -762,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 = []
@@ -786,8 +725,6 @@ const _FLATTENED_PATTERNS = (() => {
         suffix: p.suffix,
         typeName: compiledType.name,
         symbolIndex: p.symbolIndex,
-        num: p.num,
-        isRange: p.isRange,
         compiled: compiled || null
       })
     }
@@ -796,6 +733,72 @@ const _FLATTENED_PATTERNS = (() => {
 })()
 
 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
@@ -810,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
   }
@@ -831,148 +839,3 @@ const matchRegexEntry = (trimmed, typeName, entry) => {
 
   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 } = getTypeSeparation()
-  
-  // Create typeInfo lookup cache
-  const typeInfoCache = new Map()
-  for (const compiledType of symbolBasedTypes) {
-    const typeInfo = _TYPE_INFO_BY_NAME.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
-}