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

package/src/phase2-convert.js

@@ -22,13 +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) {
-      const listInfoMap = buildListInfoMap(listInfos)
-      simplifyNestedBulletLists(tokens, opt, listInfoMap)
+    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
  */
@@ -86,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
               }
               
@@ -104,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)
 
@@ -143,11 +158,11 @@ const LEADING_SPACE_REGEX = /^\s+/
  * When the middle list_item is empty (contains only the inner list),
  * remove the outer ul and the intermediate li.
  * @param {Array} tokens - Token array
- * @param {Object} opt - Options
- * @param {Map} listInfoMap - Map of listInfo keyed by startIndex
  */
-function simplifyNestedBulletLists(tokens, opt, listInfoMap = null) {
+function simplifyNestedBulletLists(tokens) {
   let modified = true
+  // token.map is stable across passes; used to decide map-based blank-line checks.
+  const hasTokenMaps = tokens.some(token => token && token.map && token.map.length)
   
   // ===== Phase 1: Simplify ul>li>ol structure (multiple passes needed) =====
   while (modified) {
@@ -183,16 +198,28 @@ function simplifyNestedBulletLists(tokens, opt, listInfoMap = null) {
       // 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
@@ -217,43 +244,51 @@ function simplifyNestedBulletLists(tokens, opt, listInfoMap = null) {
             }
           }
           
-          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 innerListInfo = listInfoMap?.get(innerListOpen)
-            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,
-              innerListInfo,
-              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 {
@@ -262,9 +297,11 @@ function simplifyNestedBulletLists(tokens, opt, listInfoMap = null) {
       }
       
       // Check if outer ul is convertible (has markers)
-      const outerListInfo = listInfoMap ? listInfoMap.get(i) : null
+      const outerListToken = tokens[i]
+      const outerShouldConvert = !!outerListToken?._shouldConvert
+      const outerMarkerInfo = outerListToken?._markerInfo || null
 
-      if (outerListInfo?.shouldConvert) {
+      if (outerShouldConvert) {
         for (const flattenedItem of itemIndices) {
           const closeIdx = flattenedItem.innerListOpen - 1
           const inlineIdx = closeIdx - 1
@@ -289,10 +326,7 @@ function simplifyNestedBulletLists(tokens, opt, listInfoMap = null) {
       // 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)
@@ -309,8 +343,8 @@ function simplifyNestedBulletLists(tokens, opt, listInfoMap = null) {
         const allMarkers = []
         
         // Use outer listInfo marker info if available
-        if (outerListInfo && outerListInfo.markerInfo && outerListInfo.markerInfo.markers) {
-          allMarkers.push(...outerListInfo.markerInfo.markers)
+        if (outerMarkerInfo && outerMarkerInfo.markers) {
+          allMarkers.push(...outerMarkerInfo.markers)
         }
         
         for (const item of itemIndices) {
@@ -325,7 +359,7 @@ function simplifyNestedBulletLists(tokens, opt, listInfoMap = null) {
             allMarkers.push(...innerListToken._markerInfo.markers)
           } 
           // If originally ordered_list, get marker info from start attribute and markup
-          else if (!outerListInfo || !outerListInfo.markerInfo) {
+          else if (!outerMarkerInfo) {
             // Only get from inner if outer has no marker info
             // Get start attribute and markup
             const startAttr = innerListToken.attrs?.find(attr => attr[0] === 'start')
@@ -352,13 +386,8 @@ function simplifyNestedBulletLists(tokens, opt, listInfoMap = null) {
           }
         }
         
-        // 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]
@@ -371,7 +400,7 @@ function simplifyNestedBulletLists(tokens, opt, listInfoMap = null) {
         
         // If outer ul is convertible, convert inner list to ordered_list
         // (Don't limit to bullet_list as inner list might already be ordered_list)
-        if (outerListInfo && outerListInfo.shouldConvert) {
+        if (outerShouldConvert) {
           if (firstListToken.type === 'bullet_list_open') {
             firstListToken.type = 'ordered_list_open'
             firstListToken.tag = 'ol'
@@ -380,7 +409,7 @@ function simplifyNestedBulletLists(tokens, opt, listInfoMap = null) {
           // If already ordered_list, use as is (already converted)
         }
         
-        newTokens.push(firstListToken)
+        replacementTokens.push(firstListToken)
         
         // Merge and save marker info
         if (allMarkers.length > 0) {
@@ -420,6 +449,11 @@ function simplifyNestedBulletLists(tokens, opt, listInfoMap = null) {
             }
           }
         }
+
+        // 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,
@@ -430,7 +464,7 @@ function simplifyNestedBulletLists(tokens, opt, listInfoMap = null) {
         // Single item is always tight
         if (itemIndices.length === 1) {
           outerUlIsLoose = false
-        } else {
+        } else if (hasTokenMaps) {
           // For multiple items, check blank lines with map info
           for (let itemIdx = 0; itemIdx < itemIndices.length - 1; itemIdx++) {
             const currentItem = itemIndices[itemIdx]
@@ -458,6 +492,9 @@ function simplifyNestedBulletLists(tokens, opt, listInfoMap = null) {
               }
             }
           }
+        } else {
+          // Mapless fallback: reuse Phase 1 loose/tight decision for the outer list.
+          outerUlIsLoose = !!outerListToken?._isLoose
         }
         
         // ===== Nested list overall loose/tight determination =====
@@ -472,46 +509,38 @@ function simplifyNestedBulletLists(tokens, opt, listInfoMap = null) {
         // In flattened pattern (`- 1.` etc), each outer list_item has one inner ol
         // Check if there are blank lines between list_items in inner ol
         // (Blank lines between outer list_items already checked by outerUlIsLoose)
-        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 })
-            }
-          }
-          
-          // 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]
-              
-              // Get currentItem end line
-              let currentEndLine = null
-              for (let m = currentItem.close - 1; m > currentItem.open; m--) {
-                if (tokens[m].map && tokens[m].map[1]) {
-                  currentEndLine = tokens[m].map[1]
-                  break
+        // 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 listItemRanges = listItemRangesByItem[itemIdx]
+
+            // Check blank lines between list_items in inner list
+            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
+                for (let m = currentItem.close - 1; m > currentItem.open; m--) {
+                  if (tokens[m].map && tokens[m].map[1]) {
+                    currentEndLine = tokens[m].map[1]
+                    break
+                  }
                 }
-              }
-              
-              const nextMap = tokens[nextItem.open].map
-              
-              if (currentEndLine !== null && nextMap) {
-                const lineGap = nextMap[0] - currentEndLine
-                if (lineGap > 0) {
-                  innerListIsLooseDueToBlankLines = true
-                  break
+                
+                const nextMap = tokens[nextItem.open].map
+                
+                if (currentEndLine !== null && nextMap) {
+                  const lineGap = nextMap[0] - currentEndLine
+                  if (lineGap > 0) {
+                    innerListIsLooseDueToBlankLines = true
+                    break
+                  }
                 }
               }
+              if (innerListIsLooseDueToBlankLines) break
             }
-            if (innerListIsLooseDueToBlankLines) break
           }
         }
         
@@ -519,21 +548,11 @@ function simplifyNestedBulletLists(tokens, opt, listInfoMap = null) {
         // 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++) {
@@ -561,24 +580,20 @@ function simplifyNestedBulletLists(tokens, opt, listInfoMap = null) {
         // 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
               }
             }
           }
@@ -590,18 +605,10 @@ function simplifyNestedBulletLists(tokens, opt, listInfoMap = null) {
         // ===== 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
           }
@@ -613,7 +620,7 @@ function simplifyNestedBulletLists(tokens, opt, listInfoMap = null) {
           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
@@ -639,9 +646,8 @@ function simplifyNestedBulletLists(tokens, opt, listInfoMap = null) {
             }
             
             // Whether this item's first paragraph is loose
-            // is obtained from Phase1-analyzed listInfo.items[itemIdx]
-            const listItem = outerListInfo?.items?.[itemIdx]
-            const firstParagraphIsLoose = listItem?.firstParagraphIsLoose || false
+            // Use metadata recorded on the outer list_item token.
+            const firstParagraphIsLoose = !!tokens[item.outerItemOpen]?._firstParagraphIsLoose
 
             // Make loose when parent structure is loose or this item has extra block elements
             // - However, consider cases with multiple paragraphs in item (firstParagraphIsLoose) or
@@ -663,7 +669,7 @@ function simplifyNestedBulletLists(tokens, opt, listInfoMap = null) {
             // - 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
@@ -681,13 +687,13 @@ function simplifyNestedBulletLists(tokens, opt, listInfoMap = null) {
                   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)
                 
@@ -712,7 +718,7 @@ function simplifyNestedBulletLists(tokens, opt, listInfoMap = null) {
                 } 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 {
@@ -721,9 +727,9 @@ function simplifyNestedBulletLists(tokens, opt, listInfoMap = null) {
                   }
                 }
                 
-                newTokens.push(tokenToPush)
+                replacementTokens.push(tokenToPush)
               } else {
-                newTokens.push(tokenToPush)
+                replacementTokens.push(tokenToPush)
               }
             }
             
@@ -758,7 +764,7 @@ function simplifyNestedBulletLists(tokens, opt, listInfoMap = null) {
                   }
                 }
                 
-                newTokens.push(tokenToPush)
+                replacementTokens.push(tokenToPush)
               }
             }
             
@@ -775,15 +781,15 @@ function simplifyNestedBulletLists(tokens, opt, listInfoMap = null) {
                 item.innerListClose,
                 levelShift,
                 markerStartIndex,
-                item.innerListInfo
+                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])
           }
         }
         
@@ -792,7 +798,7 @@ function simplifyNestedBulletLists(tokens, opt, listInfoMap = null) {
         const lastListCloseToken = tokens[lastItem.innerListClose]
         
         // If outer ul is convertible, also convert close token
-        if (outerListInfo && outerListInfo.shouldConvert) {
+        if (outerShouldConvert) {
           if (lastListCloseToken.type === 'bullet_list_close') {
             lastListCloseToken.type = 'ordered_list_close'
             lastListCloseToken.tag = 'ol'
@@ -800,29 +806,20 @@ function simplifyNestedBulletLists(tokens, opt, listInfoMap = null) {
           // 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)
             }
           }
         }
@@ -884,19 +881,6 @@ function simplifyNestedBulletLists(tokens, opt, listInfoMap = null) {
   }
 }
 
-function buildListInfoMap(listInfos) {
-  const map = new Map()
-  if (!Array.isArray(listInfos)) {
-    return map
-  }
-  for (const info of listInfos) {
-    if (info && typeof info.startIndex === 'number') {
-      map.set(info.startIndex, info)
-    }
-  }
-  return map
-}
-
 function collectListItemRanges(tokens, listOpenIdx, listCloseIdx, listItemCloseByOpen = null) {
   const ranges = []
   if (listOpenIdx === -1 || listCloseIdx === -1 || listCloseIdx <= listOpenIdx) {
@@ -922,13 +906,13 @@ function collectListItemRanges(tokens, listOpenIdx, listCloseIdx, listItemCloseB
   return ranges
 }
 
-function buildNestedListTokens(tokens, childRanges, innerListOpenIdx, innerListCloseIdx, levelShift, markerStartIndex, innerListInfo) {
+function buildNestedListTokens(tokens, childRanges, innerListOpenIdx, innerListCloseIdx, levelShift, markerStartIndex, markerInfo) {
   if (!Array.isArray(childRanges) || childRanges.length === 0) {
     return []
   }
   const nestedTokens = []
   const nestedOpen = cloneToken(tokens[innerListOpenIdx], { levelShift })
-  const markerInfoSlice = createMarkerInfoSlice(innerListInfo?.markerInfo, markerStartIndex)
+  const markerInfoSlice = createMarkerInfoSlice(markerInfo, markerStartIndex)
   if (markerInfoSlice) {
     nestedOpen._markerInfo = markerInfoSlice
     const firstMarker = markerInfoSlice.markers?.[0]
@@ -940,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 })
@@ -949,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
@@ -963,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