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

package/src/phase2-convert.js

@@ -22,12 +22,28 @@ export function convertLists(tokens, listInfos, opt) {
   // Runs after conversion, so already-converted ordered_lists are also processed
   if (!opt.unremoveUlNest) {
     const hasBulletLists = listInfos.some(info => info.originalType === 'bullet_list_open')
-    if (hasBulletLists) {
+    if (hasBulletLists && hasSimplifiableBulletStructure(tokens)) {
       simplifyNestedBulletLists(tokens)
     }
   }
 }
 
+function hasSimplifiableBulletStructure(tokens) {
+  for (let i = 0; i < tokens.length - 2; i++) {
+    if (tokens[i].type !== 'bullet_list_open') {
+      continue
+    }
+    const firstItem = tokens[i + 1]
+    const firstChild = tokens[i + 2]
+    if (firstItem?.type === 'list_item_open' &&
+        firstChild?.type === 'ordered_list_open' &&
+        !firstChild._literalList) {
+      return true
+    }
+  }
+  return false
+}
+
 /**
  * Convert bullet_list to ordered_list
  */
@@ -85,7 +101,7 @@ function convertBulletToOrdered(tokens, listInfo) {
               // Compare parent item's marker type with child list's marker type
               // Don't propagate if different (will be flattened)
               const childMarkerInfo = nestedList.items && nestedList.items[0] && nestedList.items[0].markerInfo
-              if (!childMarkerInfo || item.markerInfo.markerType !== childMarkerInfo.markerType) {
+              if (!childMarkerInfo || item.markerInfo.type !== childMarkerInfo.type) {
                 continue  // Skip if marker types differ
               }
               
@@ -103,14 +119,14 @@ function convertBulletToOrdered(tokens, listInfo) {
   
   // Remove marker text from inline tokens
   if (markerInfo && markerInfo.markers) {
-    removeMarkersFromContent(tokens, startIndex, endIndex, markerInfo, listInfo)
+    removeMarkersFromContent(tokens, startIndex, endIndex, markerInfo)
   }
 }
 
 /**
  * Remove markers from inline token content
  */
-function removeMarkersFromContent(tokens, startIndex, endIndex, markerInfo, listInfo) {
+function removeMarkersFromContent(tokens, startIndex, endIndex, markerInfo) {
   const listToken = tokens[startIndex]
   const targetLevel = (listToken.level || 0) + 3  // list_open(0) -> list_item(1) -> paragraph(2) -> inline(3)
 
@@ -182,16 +198,28 @@ function simplifyNestedBulletLists(tokens) {
       // Check if this bullet_list is all ul>li>ol/ul pattern
       const listCloseIdx = getListClose(i)
       if (listCloseIdx === -1) continue
+
+      // Fast reject: flattening requires the first list item to start with ordered_list_open.
+      const firstItemOpen = i + 1
+      const firstItemChild = i + 2
+      if (tokens[firstItemOpen]?.type !== 'list_item_open' ||
+          tokens[firstItemChild]?.type !== 'ordered_list_open' ||
+          tokens[firstItemChild]?._literalList) {
+        continue
+      }
       
       // Check all list_items in bullet_list
       const itemIndices = []
-      let totalItems = 0
       let idx = i + 1
+      let allItemsHaveDirectInnerList = true
       
       while (idx < listCloseIdx) {
         if (tokens[idx].type === 'list_item_open') {
-          totalItems++
           const itemCloseIdx = getListItemClose(idx)
+          if (itemCloseIdx === -1) {
+            allItemsHaveDirectInnerList = false
+            break
+          }
           
                   
           // Find inner list within list_item
@@ -216,43 +244,51 @@ function simplifyNestedBulletLists(tokens) {
             }
           }
           
-          if (innerListOpen !== -1) {
-            if (innerListCloseIdx === -1) {
-              innerListCloseIdx = getListClose(innerListOpen)
-            }
-            
-            // Check if there's extra content before/after ol (whether it's only ol)
-            const beforeContent = innerListOpen - (idx + 1)  // Token count from after list_item_open to ol
-            const afterContent = itemCloseIdx - (innerListCloseIdx + 1)  // Token count from after ol to list_item_close
-            const hasExtraContent = beforeContent > 0 || afterContent > 0
-            const literalNumber = extractFirstListItemNumber(tokens, innerListOpen, innerListCloseIdx)
-            
-            const innerListMarkerInfo = tokens[innerListOpen]?._markerInfo
-            const isSimpleMarkerParagraph = (() => {
-              const precedingCount = innerListOpen - (idx + 1)
-              if (precedingCount !== 3) return false
-              const paraOpen = tokens[idx + 1]
-              const inlineToken = tokens[idx + 2]
-              const paraClose = tokens[idx + 3]
-              return paraOpen?.type === 'paragraph_open' &&
-                inlineToken?.type === 'inline' &&
-                paraClose?.type === 'paragraph_close'
-            })()
+          if (innerListOpen === -1 || innerListOpen !== idx + 1) {
+            // Flattening requires every list item to contain only one direct child list.
+            allItemsHaveDirectInnerList = false
+            break
+          }
 
-            itemIndices.push({
-              outerItemOpen: idx,
-              outerItemClose: itemCloseIdx,
-              innerListOpen: innerListOpen,
-              innerListClose: innerListCloseIdx,
-              innerListType: innerListType,
-              hasExtraContent: hasExtraContent,
-              extraContentStart: innerListCloseIdx + 1,
-              extraContentEnd: itemCloseIdx,
-              innerListMarkerInfo,
-              literalNumber,
-              flattenFirstParagraph: isSimpleMarkerParagraph
-            })
+          if (innerListCloseIdx === -1) {
+            innerListCloseIdx = getListClose(innerListOpen)
           }
+          if (innerListCloseIdx === -1) {
+            allItemsHaveDirectInnerList = false
+            break
+          }
+          
+          // Check if there's extra content before/after ol (whether it's only ol)
+          const beforeContent = innerListOpen - (idx + 1)  // Token count from after list_item_open to ol
+          const afterContent = itemCloseIdx - (innerListCloseIdx + 1)  // Token count from after ol to list_item_close
+          const hasExtraContent = beforeContent > 0 || afterContent > 0
+          const literalNumber = extractFirstListItemNumber(tokens, innerListOpen, innerListCloseIdx)
+          
+          const innerListMarkerInfo = tokens[innerListOpen]?._markerInfo
+          const isSimpleMarkerParagraph = (() => {
+            const precedingCount = innerListOpen - (idx + 1)
+            if (precedingCount !== 3) return false
+            const paraOpen = tokens[idx + 1]
+            const inlineToken = tokens[idx + 2]
+            const paraClose = tokens[idx + 3]
+            return paraOpen?.type === 'paragraph_open' &&
+              inlineToken?.type === 'inline' &&
+              paraClose?.type === 'paragraph_close'
+          })()
+
+          itemIndices.push({
+            outerItemOpen: idx,
+            outerItemClose: itemCloseIdx,
+            innerListOpen: innerListOpen,
+            innerListClose: innerListCloseIdx,
+            innerListType: innerListType,
+            hasExtraContent: hasExtraContent,
+            extraContentStart: innerListCloseIdx + 1,
+            extraContentEnd: itemCloseIdx,
+            innerListMarkerInfo,
+            literalNumber,
+            flattenFirstParagraph: isSimpleMarkerParagraph
+          })
          
           idx = itemCloseIdx + 1
         } else {
@@ -290,10 +326,7 @@ function simplifyNestedBulletLists(tokens) {
       // 1. Every list_item has a nested list (the classic `- 1.` pattern)
       // 2. That nested list appears as the very first child (no preceding paragraph text)
       //    This prevents flattening normal `* Parent` lists that intentionally nest an ordered list.
-      const allItemsHaveInnerList = itemIndices.length > 0 && itemIndices.length === totalItems
-      const innerListIsFirstChild = allItemsHaveInnerList &&
-        itemIndices.every(item => item.innerListOpen === item.outerItemOpen + 1)
-      const shouldSimplify = allItemsHaveInnerList && innerListIsFirstChild
+      const shouldSimplify = allItemsHaveDirectInnerList && itemIndices.length > 0
       
       if (shouldSimplify && itemIndices.length > 0) {
         const allSameType = itemIndices.every(item => item.innerListType === itemIndices[0].innerListType)
@@ -353,13 +386,8 @@ function simplifyNestedBulletLists(tokens) {
           }
         }
         
-        // Build new token array
-        const newTokens = []
-        
-        // Tokens before bullet_list_open
-        for (let j = 0; j < i; j++) {
-          newTokens.push(tokens[j])
-        }
+        // Build replacement tokens for this list block only.
+        const replacementTokens = []
         
         // Add first inner list open token and save merged marker info
         const firstListToken = tokens[itemIndices[0].innerListOpen]
@@ -381,7 +409,7 @@ function simplifyNestedBulletLists(tokens) {
           // If already ordered_list, use as is (already converted)
         }
         
-        newTokens.push(firstListToken)
+        replacementTokens.push(firstListToken)
         
         // Merge and save marker info
         if (allMarkers.length > 0) {
@@ -421,6 +449,11 @@ function simplifyNestedBulletLists(tokens) {
             }
           }
         }
+
+        // Cache top-level list-item ranges for each inner list to avoid repeated scans.
+        const listItemRangesByItem = itemIndices.map(item =>
+          collectListItemRanges(tokens, item.innerListOpen, item.innerListClose, listItemCloseByOpen)
+        )
         
         // ===== Outer UL (Level 0 after conversion) loose/tight determination =====
         // In flattened pattern (`- 1.` etc), no direct paragraph in outer list_item,
@@ -479,24 +512,13 @@ function simplifyNestedBulletLists(tokens) {
         // When map is missing, skip map-based blank-line checks and fall back to paragraph.hidden.
         if (hasTokenMaps) {
           for (let itemIdx = 0; itemIdx < itemIndices.length; itemIdx++) {
-            const item = itemIndices[itemIdx]
-            
-            // Collect list_items in inner list
-            const innerListItems = []
-            for (let j = item.innerListOpen + 1; j < item.innerListClose; j++) {
-              if (tokens[j].type === 'list_item_open' && 
-                  tokens[j].level === tokens[item.innerListOpen].level + 1) {
-                const itemOpen = j
-                const itemClose = getListItemClose(j)
-                innerListItems.push({ open: itemOpen, close: itemClose })
-              }
-            }
-            
+            const listItemRanges = listItemRangesByItem[itemIdx]
+
             // Check blank lines between list_items in inner list
-            if (innerListItems.length > 1) {
-              for (let k = 0; k < innerListItems.length - 1; k++) {
-                const currentItem = innerListItems[k]
-                const nextItem = innerListItems[k + 1]
+            if (listItemRanges.length > 1) {
+              for (let k = 0; k < listItemRanges.length - 1; k++) {
+                const currentItem = listItemRanges[k]
+                const nextItem = listItemRanges[k + 1]
                 
                 // Get currentItem end line
                 let currentEndLine = null
@@ -526,21 +548,11 @@ function simplifyNestedBulletLists(tokens) {
         // If inner list has paragraph with hidden=false, it's loose
         if (!innerListIsLooseDueToBlankLines) {
           for (let itemIdx = 0; itemIdx < itemIndices.length; itemIdx++) {
-            const item = itemIndices[itemIdx]
-            
-            let innerListItemOpen = -1
-            let innerListItemClose = -1
-            
-            for (let j = item.innerListOpen + 1; j < item.innerListClose; j++) {
-              if (tokens[j].type === 'list_item_open' && 
-                  tokens[j].level === tokens[item.innerListOpen].level + 1) {
-                innerListItemOpen = j
-                innerListItemClose = getListItemClose(j)
-                break
-              }
-            }
-            
-            if (innerListItemOpen !== -1 && innerListItemClose !== -1) {
+            const listItemRanges = listItemRangesByItem[itemIdx]
+            const firstRange = listItemRanges[0]
+            if (firstRange) {
+              const innerListItemOpen = firstRange.open
+              const innerListItemClose = firstRange.close
               // Check hidden of first paragraph in inner list item
               let nestedListDepth = 0
               for (let j = innerListItemOpen + 1; j < innerListItemClose; j++) {
@@ -568,24 +580,20 @@ function simplifyNestedBulletLists(tokens) {
         // This must be executed AFTER innerListIsLooseDueToBlankLines determination
         if (outerUlIsLoose && !(itemIndices.length === 1)) {
           for (let itemIdx = 0; itemIdx < itemIndices.length; itemIdx++) {
-            const item = itemIndices[itemIdx]
-            // Find list_items in inner list
-            for (let j = item.innerListOpen + 1; j < item.innerListClose; j++) {
-              if (tokens[j].type === 'list_item_open' && 
-                  tokens[j].level === tokens[item.innerListOpen].level + 1) {
-                // Find first paragraph in list_item
-                const listItemOpen = j
-                const listItemClose = getListItemClose(j)
-                for (let k = listItemOpen + 1; k < listItemClose; k++) {
-                  if (tokens[k].type === 'paragraph_open' && 
-                      tokens[k].level === tokens[listItemOpen].level + 1) {
-                    if (!tokens[k]._literalTight) {
-                      tokens[k].hidden = false
-                    }
-                    break // Only first paragraph
-                  }
+            const listItemRanges = listItemRangesByItem[itemIdx]
+            const firstRange = listItemRanges[0]
+            if (!firstRange) {
+              continue
+            }
+            const listItemOpen = firstRange.open
+            const listItemClose = firstRange.close
+            for (let k = listItemOpen + 1; k < listItemClose; k++) {
+              if (tokens[k].type === 'paragraph_open' && 
+                  tokens[k].level === tokens[listItemOpen].level + 1) {
+                if (!tokens[k]._literalTight) {
+                  tokens[k].hidden = false
                 }
-                break // Only first list_item of inner list
+                break // Only first paragraph
               }
             }
           }
@@ -597,18 +605,10 @@ function simplifyNestedBulletLists(tokens) {
         // ===== Merge each inner list's contents and place extra content appropriately =====
         for (let itemIdx = 0; itemIdx < itemIndices.length; itemIdx++) {
           const item = itemIndices[itemIdx]
-          
-          // Count list_items in this inner list (ordered_list)
-          let innerListItemCount = 0
-          for (let j = item.innerListOpen + 1; j < item.innerListClose; j++) {
-            if (tokens[j].type === 'list_item_open' && 
-                tokens[j].level === tokens[item.innerListOpen].level + 1) {
-              innerListItemCount++
-            }
-          }
-          
+
+          const listItemRanges = listItemRangesByItem[itemIdx]
+          const innerListItemCount = listItemRanges.length
           const innerListToken = tokens[item.innerListOpen]
-          const listItemRanges = collectListItemRanges(tokens, item.innerListOpen, item.innerListClose, listItemCloseByOpen)
           if (listItemRanges.length === 0) {
             continue
           }
@@ -620,7 +620,7 @@ function simplifyNestedBulletLists(tokens) {
           if (innerListItemOpen !== -1 && innerListItemClose !== -1) {
             // Add list_item_open (use original token to preserve info)
             // Note: value attribute is added in Phase3 (not during simplification)
-            newTokens.push(tokens[innerListItemOpen])
+            replacementTokens.push(tokens[innerListItemOpen])
             
             // This item's loose/tight determination
             // If entire list is loose, this item is also loose
@@ -669,7 +669,7 @@ function simplifyNestedBulletLists(tokens) {
             // - firstParagraphIsLoose: blank line after parent item's first paragraph (same marker type only)
             // Note: hasExtraContent makes parent item loose but doesn't affect child lists
             // Note: outerUlIsLoose excluded (Test 25: handle case where parent is loose but child is tight)
-            const shouldPropagateLooseToChildren = innerListIsLooseDueToBlankLines || token._parentIsLoose || firstParagraphIsLoose || false
+            const shouldPropagateLooseToChildren = innerListIsLooseDueToBlankLines || token._parentIsLoose || firstParagraphIsLoose
             
             // Copy tokens in inner list item (exclude nested list paragraphs)
             let nestedListDepth = 0
@@ -687,13 +687,13 @@ function simplifyNestedBulletLists(tokens) {
                   if (shouldPropagateLooseToChildren) {
                     // Set _parentIsLoose flag (optimize with direct property assignment)
                     tokenToPush._parentIsLoose = true
-                    newTokens.push(tokenToPush)
+                    replacementTokens.push(tokenToPush)
                   } else {
-                    newTokens.push(tokenToPush)
+                    replacementTokens.push(tokenToPush)
                   }
               } else if (tokenToPush.type === 'bullet_list_close' || tokenToPush.type === 'ordered_list_close') {
                 nestedListDepth--
-                newTokens.push(tokenToPush)
+                replacementTokens.push(tokenToPush)
               } else if (nestedListDepth === 0 && (tokenToPush.type === 'paragraph_open' || tokenToPush.type === 'paragraph_close')) {
                 // Update paragraph_open/close hidden state (only outside nested lists)
                 
@@ -718,7 +718,7 @@ function simplifyNestedBulletLists(tokens) {
                 } else {
                   // Match paragraph_close hidden state to corresponding paragraph_open
                   // Reference preceding paragraph_open's hidden state
-                  const prevToken = newTokens[newTokens.length - 2] // Skip preceding inline, get paragraph_open before it
+                  const prevToken = replacementTokens[replacementTokens.length - 2] // Skip preceding inline, get paragraph_open before it
                   if (prevToken && prevToken.type === 'paragraph_open') {
                     tokenToPush.hidden = prevToken.hidden
                   } else {
@@ -727,9 +727,9 @@ function simplifyNestedBulletLists(tokens) {
                   }
                 }
                 
-                newTokens.push(tokenToPush)
+                replacementTokens.push(tokenToPush)
               } else {
-                newTokens.push(tokenToPush)
+                replacementTokens.push(tokenToPush)
               }
             }
             
@@ -764,7 +764,7 @@ function simplifyNestedBulletLists(tokens) {
                   }
                 }
                 
-                newTokens.push(tokenToPush)
+                replacementTokens.push(tokenToPush)
               }
             }
             
@@ -784,12 +784,12 @@ function simplifyNestedBulletLists(tokens) {
                 item.innerListMarkerInfo
               )
               for (const nestedToken of nestedTokens) {
-                newTokens.push(nestedToken)
+                replacementTokens.push(nestedToken)
               }
             }
             
             // Add list_item_close
-            newTokens.push(tokens[innerListItemClose])
+            replacementTokens.push(tokens[innerListItemClose])
           }
         }
         
@@ -806,29 +806,20 @@ function simplifyNestedBulletLists(tokens) {
           // If already ordered_list_close, use as is
         }
         
-        newTokens.push(lastListCloseToken)
+        replacementTokens.push(lastListCloseToken)
         
-        // Tokens after bullet_list_close
-        for (let j = listCloseIdx + 1; j < tokens.length; j++) {
-          newTokens.push(tokens[j])
-        }
-        
-        // Replace token array
-        tokens.length = 0
-        tokens.push(...newTokens)
+        // Replace only the current outer bullet-list range.
+        tokens.splice(i, listCloseIdx - i + 1, ...replacementTokens)
         
         // Remove markers from merged list
         if (firstListToken._markerInfo && firstListToken._markerInfo.markers) {
-          let listStartIdx = 0
-          while (listStartIdx < tokens.length && tokens[listStartIdx] !== firstListToken) {
-            listStartIdx++
-          }
+          const listStartIdx = i
           if (listStartIdx < tokens.length) {
             const listEndIdx = findMatchingClose(tokens, listStartIdx, 
               firstListToken.type, 
-              firstListToken.type.replace('_open', '_close'), false)
+              firstListToken.type.replace('_open', '_close'))
             if (listEndIdx !== -1) {
-              removeMarkersFromContent(tokens, listStartIdx, listEndIdx, firstListToken._markerInfo, null)
+              removeMarkersFromContent(tokens, listStartIdx, listEndIdx, firstListToken._markerInfo)
             }
           }
         }
@@ -933,7 +924,7 @@ function buildNestedListTokens(tokens, childRanges, innerListOpenIdx, innerListC
   nestedTokens.push(nestedOpen)
   for (const range of childRanges) {
     for (let i = range.open; i <= range.close; i++) {
-      nestedTokens.push(cloneToken(tokens[i], { levelShift, deep: true }))
+      nestedTokens.push(cloneToken(tokens[i], { levelShift }))
     }
   }
   const nestedClose = cloneToken(tokens[innerListCloseIdx], { levelShift })
@@ -942,7 +933,7 @@ function buildNestedListTokens(tokens, childRanges, innerListOpenIdx, innerListC
 }
 
 function cloneToken(token, options = {}) {
-  const { levelShift = 0, deep = false } = options
+  const { levelShift = 0 } = options
   const TokenClass = token.constructor
   const cloned = new TokenClass(token.type, token.tag, token.nesting)
   cloned.attrs = token.attrs ? token.attrs.map(([name, value]) => [name, value]) : null
@@ -956,7 +947,7 @@ function cloneToken(token, options = {}) {
   cloned.hidden = token.hidden
   if (Array.isArray(token.children)) {
     cloned.children = token.children.length > 0
-      ? token.children.map(child => cloneToken(child, { levelShift, deep: true }))
+      ? token.children.map(child => cloneToken(child, { levelShift }))
       : []
   } else {
     cloned.children = token.children ?? null

package/src/phase3-attributes.js

@@ -12,6 +12,7 @@ import { buildListCloseIndexMap, findMatchingClose } from './list-helpers.js'
 export function addAttributes(tokens, opt) {
   const closeMap = buildListCloseIndexMap(tokens)
   const listCloseByOpen = closeMap.listCloseByOpen
+  let hasAnyListItemValue = false
   
   // Traverse token array and add attributes to ordered_list_open tokens
   // Token array may have been rebuilt in Phase2,
@@ -21,13 +22,31 @@ export function addAttributes(tokens, opt) {
     
     if (token.type === 'ordered_list_open') {
       addListAttributesForToken(tokens, token, i, opt, listCloseByOpen)
+      continue
+    }
+    if (!hasAnyListItemValue && token.type === 'list_item_open' && hasValueAttr(token)) {
+      hasAnyListItemValue = true
     }
   }
   
   // Normalize value attributes of ordered_list generated by markdown-it
   // Remove unnecessary value attributes after Phase2 simplification
   // Normalize value attributes and marker metadata for all ordered lists
-  normalizeAndConvertValueAttributes(tokens, opt, listCloseByOpen)
+  if (hasAnyListItemValue) {
+    normalizeAndConvertValueAttributes(tokens, listCloseByOpen)
+  }
+}
+
+function hasValueAttr(token) {
+  if (!Array.isArray(token.attrs)) {
+    return false
+  }
+  for (const [name] of token.attrs) {
+    if (name === 'value') {
+      return true
+    }
+  }
+  return false
 }
 
 /**
@@ -75,13 +94,10 @@ function addListAttributesForToken(tokens, token, tokenIndex, opt, listCloseByOp
   
   // 1. type attribute or role attribute (add first)
   // Always use role="list" for alwaysMarkerSpan
-  if (opt.useCounterStyle) {
-    // When user chooses @counter-style, we avoid role and inline styles.
-    // Still add class so users can target with CSS (e.g., counter-reset/counter-increment or @counter-style usage).
-    // Do not add type attribute (counter-style will handle visuals)
-  } else if (typeAttrs.type && !opt.alwaysMarkerSpan) {
+  if (!opt.useCounterStyle && typeAttrs.type && !opt.alwaysMarkerSpan) {
     addAttr(token, 'type', typeAttrs.type)
-  } else {
+  } else if (!opt.useCounterStyle) {
+    // In non-counter-style mode, custom markers (or alwaysMarkerSpan) use role=list.
     addAttr(token, 'role', 'list')
     if (opt.hasListStyleNone) {
       addAttr(token, 'style', 'list-style: none;')
@@ -117,12 +133,6 @@ function addListAttributesForToken(tokens, token, tokenIndex, opt, listCloseByOp
       addAttr(token, 'class', typeAttrs.class)
     }
   }
-
-  // If user requested @counter-style, add a helper class to identify lists
-  if (opt.useCounterStyle) {
-    // Do not add helper class when using counter-style; user CSS should target generated ol-* classes.
-  }
-  
   // 4. data-marker-prefix/suffix
   if (!opt.omitMarkerMetadata) {
     if (markerInfo.markers[0].prefix) {
@@ -197,9 +207,8 @@ function addListItemValues(tokens, listOpenIndex, markerInfo, listCloseByOpen =
  * Normalize value attributes generated by markdown-it for ordered lists.
  * Remove value attributes for consecutive numbers.
  * @param {Array} tokens - Token array
- * @param {Object} opt - Plugin options
  */
-function normalizeAndConvertValueAttributes(tokens, opt, listCloseByOpen = null) {
+function normalizeAndConvertValueAttributes(tokens, listCloseByOpen = null) {
   for (let i = 0; i < tokens.length; i++) {
     const token = tokens[i]
 

package/src/phase5-spans.js

@@ -13,8 +13,18 @@ export function generateSpans(tokens, opt) {
   if (opt.useCounterStyle) {
     return
   }
-  const closeMap = buildListCloseIndexMap(tokens)
-  const listCloseByOpen = closeMap.listCloseByOpen
+  const rawSpanClass = opt?.markerSpanClass
+  const normalizedSpanClass = typeof rawSpanClass === 'string'
+    ? rawSpanClass.trim()
+    : ''
+  const spanClass = normalizedSpanClass || 'li-num'
+  let listCloseByOpen = null
+  const getListCloseByOpen = () => {
+    if (!listCloseByOpen) {
+      listCloseByOpen = buildListCloseIndexMap(tokens).listCloseByOpen
+    }
+    return listCloseByOpen
+  }
 
   // Traverse token array and add spans to ordered_list_open tokens
   for (let i = 0; i < tokens.length; i++) {
@@ -22,12 +32,16 @@ export function generateSpans(tokens, opt) {
     
     if (token.type === 'ordered_list_open' && token._markerInfo) {
       const markerInfo = token._markerInfo
+      if (opt.alwaysMarkerSpan) {
+        addMarkerSpans(tokens, token, i, markerInfo, opt, spanClass, getListCloseByOpen())
+        continue
+      }
       const firstMarker = markerInfo.markers[0]
       const typeAttrs = getTypeAttributes(markerInfo.type, firstMarker, opt)
       
-      // Generate span if no type attribute (custom marker) or alwaysMarkerSpan mode
-      if (!typeAttrs.type || opt.alwaysMarkerSpan) {
-        addMarkerSpans(tokens, token, i, markerInfo, opt, listCloseByOpen)
+      // Generate span for custom marker lists.
+      if (!typeAttrs.type) {
+        addMarkerSpans(tokens, token, i, markerInfo, opt, spanClass, getListCloseByOpen())
       }
     }
   }
@@ -36,7 +50,7 @@ export function generateSpans(tokens, opt) {
 /**
  * Add marker <span> to the first inline token of each list item.
  */
-function addMarkerSpans(tokens, listToken, listIndex, markerInfo, opt, listCloseByOpen = null) {
+function addMarkerSpans(tokens, listToken, listIndex, markerInfo, opt, spanClass, listCloseByOpen = null) {
   // Find end position of this ordered_list
   let listCloseIndex = listCloseByOpen ? listCloseByOpen[listIndex] : -1
   if (typeof listCloseIndex !== 'number' || listCloseIndex === -1) {
@@ -65,7 +79,6 @@ function addMarkerSpans(tokens, listToken, listIndex, markerInfo, opt, listClose
       }
       // Insert span_open, text, span_close before inline token
       const spanOpen = new tokens[i].constructor('span_open', 'span', 1)
-      const spanClass = (opt && opt.markerSpanClass) ? String(opt.markerSpanClass) : 'li-num'
       spanOpen.attrSet('class', spanClass)
       spanOpen.attrSet('aria-hidden', 'true')