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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peaceroad/markdown-it-numbering-ul-regarded-as-ol",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "This markdown-it plugin regard ul element with numbering lists as ol element.",
   "main": "index.js",
   "type": "module",
@@ -27,7 +27,7 @@
   },
   "homepage": "https://github.com/peaceroad/p7d-markdown-it-numbering-ul-regarded-as-ol#readme",
   "devDependencies": {
-    "@peaceroad/markdown-it-strong-ja": "^0.5.1",
+    "@peaceroad/markdown-it-strong-ja": "^0.5.5",
     "markdown-it": "^14.1.0",
     "markdown-it-attrs": "^4.3.1",
     "markdown-it-deflist": "^3.0.0"

package/src/list-helpers.js

@@ -45,3 +45,51 @@ export function findListEnd(tokens, startIndex) {
 export function findListItemEnd(tokens, startIndex) {
   return findMatchingClose(tokens, startIndex, 'list_item_open', 'list_item_close')
 }
+
+/**
+ * Build close-index maps for list and list_item tokens.
+ * @param {Array} tokens - Token array
+ * @returns {{ listCloseByOpen: number[], listItemCloseByOpen: number[] }}
+ */
+export function buildListCloseIndexMap(tokens) {
+  const listCloseByOpen = new Array(tokens.length).fill(-1)
+  const listItemCloseByOpen = new Array(tokens.length).fill(-1)
+  const bulletStack = []
+  const orderedStack = []
+  const listItemStack = []
+
+  for (let i = 0; i < tokens.length; i++) {
+    const type = tokens[i]?.type
+    if (type === 'bullet_list_open') {
+      bulletStack.push(i)
+      continue
+    }
+    if (type === 'bullet_list_close') {
+      if (bulletStack.length > 0) {
+        listCloseByOpen[bulletStack.pop()] = i
+      }
+      continue
+    }
+    if (type === 'ordered_list_open') {
+      orderedStack.push(i)
+      continue
+    }
+    if (type === 'ordered_list_close') {
+      if (orderedStack.length > 0) {
+        listCloseByOpen[orderedStack.pop()] = i
+      }
+      continue
+    }
+    if (type === 'list_item_open') {
+      listItemStack.push(i)
+      continue
+    }
+    if (type === 'list_item_close') {
+      if (listItemStack.length > 0) {
+        listItemCloseByOpen[listItemStack.pop()] = i
+      }
+    }
+  }
+
+  return { listCloseByOpen, listItemCloseByOpen }
+}

package/src/phase0-description-list.js

@@ -2,7 +2,7 @@
 // Converts bullet_list with **Term** pattern to description_list (dl/dt/dd)
 // This must run before Phase 1
 
-import { findMatchingClose, findListEnd as coreFindListEnd, findListItemEnd as coreFindListItemEnd } from './list-helpers.js'
+import { findMatchingClose, findListEnd as coreFindListEnd } from './list-helpers.js'
 
 /**
  * Parse attribute string like ".class1 .class2 #id data-foo="bar""
@@ -73,11 +73,32 @@ const findListEnd = (tokens, startIndex) => {
 }
 
 /**
- * Find matching list_item close token
+ * Collect direct list_item ranges within a list in a single pass.
  */
-const findListItemEnd = (tokens, startIndex) => {
-  const result = coreFindListItemEnd(tokens, startIndex)
-  return result === -1 ? tokens.length - 1 : result
+const collectListItemRanges = (tokens, listStart, listEnd) => {
+  const listToken = tokens[listStart]
+  if (!listToken) {
+    return []
+  }
+  const childLevel = (listToken.level ?? 0) + 1
+  const ranges = []
+  let currentOpen = -1
+
+  for (let i = listStart + 1; i < listEnd; i++) {
+    const token = tokens[i]
+    if (token.type === 'list_item_open' && token.level === childLevel) {
+      currentOpen = i
+      continue
+    }
+    if (token.type === 'list_item_close' && token.level === childLevel) {
+      if (currentOpen !== -1) {
+        ranges.push({ open: currentOpen, close: i })
+        currentOpen = -1
+      }
+    }
+  }
+
+  return ranges
 }
 
 /**
@@ -103,77 +124,72 @@ const findDDEnd = (tokens, startIndex) => {
 const checkAndConvertToDL = (tokens, listStart, listEnd, opt) => {
   // First pass: validate all items match DL pattern
   let hasAnyDLItem = false
-  let i = listStart + 1
-  
-  while (i < listEnd) {
-    if (tokens[i].type === 'list_item_open') {
-      const itemEnd = findListItemEnd(tokens, i)
-      
-      // Find first paragraph
-      let firstPara = -1
-      for (let j = i + 1; j < itemEnd; j++) {
-        if (tokens[j].type === 'paragraph_open') {
-          firstPara = j
-          break
-        }
+  const itemRanges = collectListItemRanges(tokens, listStart, listEnd)
+
+  for (const range of itemRanges) {
+    const itemStart = range.open
+    const itemEnd = range.close
+    
+    // Find first paragraph
+    let firstPara = -1
+    for (let j = itemStart + 1; j < itemEnd; j++) {
+      if (tokens[j].type === 'paragraph_open') {
+        firstPara = j
+        break
       }
-      
-      if (firstPara !== -1) {
-        const inlineToken = tokens[firstPara + 1]
-        if (inlineToken && inlineToken.type === 'inline') {
-          const dlCheck = isDLPattern(inlineToken.content)
-          if (dlCheck.isMatch) {
-            // Check if there's a description
-            let hasDescription = false
-            
-            const afterStrong = dlCheck.afterStrong
-            
-            // Pattern 1: **Term**  description (2+ spaces, including newlines)
-            // Pattern 2: **Term**: description (colon)
-            // Pattern 3: **Term**\ description (backslash escape)
-            if (/^\s{2,}/.test(afterStrong) || /^\s*:/.test(afterStrong) || /^\\/.test(afterStrong)) {
-              // Remove leading space/colon/backslash and check remaining text
-              const cleaned = afterStrong.replace(/^[\s:]+/, '').replace(/^\\/, '').trim()
-              if (cleaned) {
-                hasDescription = true
-              }
+    }
+    
+    if (firstPara !== -1) {
+      const inlineToken = tokens[firstPara + 1]
+      if (inlineToken && inlineToken.type === 'inline') {
+        const dlCheck = isDLPattern(inlineToken.content)
+        if (dlCheck.isMatch) {
+          // Check if there's a description
+          let hasDescription = false
+          
+          const afterStrong = dlCheck.afterStrong
+          
+          // Pattern 1: **Term**  description (2+ spaces, including newlines)
+          // Pattern 2: **Term**: description (colon)
+          // Pattern 3: **Term**\ description (backslash escape)
+          if (/^\s{2,}/.test(afterStrong) || /^\s*:/.test(afterStrong) || /^\\/.test(afterStrong)) {
+            // Remove leading space/colon/backslash and check remaining text
+            const cleaned = afterStrong.replace(/^[\s:]+/, '').replace(/^\\/, '').trim()
+            if (cleaned) {
+              hasDescription = true
             }
-            
-            // Pattern 4: Description in next paragraph (only **Term** in first para)
-            if (!hasDescription) {
-              // Check for additional paragraphs/lists
-              for (let k = firstPara + 3; k < itemEnd; k++) {
-                if (tokens[k].type === 'paragraph_open' || 
-                    tokens[k].type === 'bullet_list_open' || 
-                    tokens[k].type === 'ordered_list_open') {
-                  hasDescription = true
-                  break
-                }
+          }
+          
+          // Pattern 4: Description in next paragraph (only **Term** in first para)
+          if (!hasDescription) {
+            // Check for additional paragraphs/lists
+            for (let k = firstPara + 3; k < itemEnd; k++) {
+              if (tokens[k].type === 'paragraph_open' || 
+                  tokens[k].type === 'bullet_list_open' || 
+                  tokens[k].type === 'ordered_list_open') {
+                hasDescription = true
+                break
               }
             }
-            
-            // If no description, not a DL item
-            if (!hasDescription) {
-              return false
-            }
-            
-            hasAnyDLItem = true
-          } else {
-            // Not all items are DL pattern - not a description list
-            return { nextIndex: listEnd + 1 }
           }
+          
+          // If no description, not a DL item
+          if (!hasDescription) {
+            return false
+          }
+          
+          hasAnyDLItem = true
+        } else {
+          // Not all items are DL pattern - not a description list
+          return { nextIndex: listEnd + 1 }
         }
       }
-      
-      i = itemEnd + 1
-    } else {
-      i++
     }
   }
   
   // If valid DL, convert immediately (avoid re-scanning)
   if (hasAnyDLItem) {
-    convertBulletListToDL(tokens, listStart, listEnd, opt)
+    convertBulletListToDL(tokens, listStart, listEnd, opt, itemRanges)
     // After conversion, tokens are replaced - continue from original listEnd position
     // Note: convertBulletListToDL may change token count, but we use original listEnd
     return { nextIndex: listStart + 1 }  // Re-check from start since tokens changed
@@ -212,7 +228,7 @@ const isDLPattern = (content) => {
 /**
  * Convert bullet_list to dl/dt/dd structure using dl_open/dl_close tokens
  */
-const convertBulletListToDL = (tokens, listStart, listEnd, opt) => {
+const convertBulletListToDL = (tokens, listStart, listEnd, opt, itemRanges = null) => {
   const newTokens = []
   const listLevel = tokens[listStart].level
   
@@ -242,33 +258,31 @@ const convertBulletListToDL = (tokens, listStart, listEnd, opt) => {
   const listAttrsFromItems = []
   
   // Process each list_item
-  let i = listStart + 1
-  while (i < listEnd) {
-    if (tokens[i].type === 'list_item_open') {
-      const itemEnd = findListItemEnd(tokens, i)
-      const result = convertListItemToDtDd(tokens, i, itemEnd, listLevel, opt)
-      
-      // Update metadata
-      dlOpen._dlMetadata.itemCount++
-      
-      // Check for list-level attrs returned from item
-      if (result.listAttrs && result.listAttrs.length > 0) {
-        listAttrsFromItems.push(...result.listAttrs)
-      }
-      
-      if (result.tokens) {
-        // Track last dd_open position (relative to newTokens)
-        for (let j = 0; j < result.tokens.length; j++) {
-          if (result.tokens[j].type === 'dd_open') {
-            dlOpen._dlMetadata.lastDdTokenIndex = newTokens.length + j
-          }
+  const ranges = Array.isArray(itemRanges) && itemRanges.length > 0
+    ? itemRanges
+    : collectListItemRanges(tokens, listStart, listEnd)
+
+  for (const range of ranges) {
+    const itemStart = range.open
+    const itemEnd = range.close
+    const result = convertListItemToDtDd(tokens, itemStart, itemEnd, listLevel, opt)
+    
+    // Update metadata
+    dlOpen._dlMetadata.itemCount++
+    
+    // Check for list-level attrs returned from item
+    if (result.listAttrs && result.listAttrs.length > 0) {
+      listAttrsFromItems.push(...result.listAttrs)
+    }
+    
+    if (result.tokens) {
+      // Track last dd_open position (relative to newTokens)
+      for (let j = 0; j < result.tokens.length; j++) {
+        if (result.tokens[j].type === 'dd_open') {
+          dlOpen._dlMetadata.lastDdTokenIndex = newTokens.length + j
         }
-        newTokens.push(...result.tokens)
       }
-      
-      i = itemEnd + 1
-    } else {
-      i++
+      newTokens.push(...result.tokens)
     }
   }
   

package/src/phase1-analyze.js

@@ -1,7 +1,7 @@
 // Phase 1: List Structure Analysis and Marker Detection
 // Analyze only, no token conversion
-import { detectMarkerType } from './types-utility.js'
-import { findMatchingClose } from './list-helpers.js'
+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))
@@ -74,7 +74,7 @@ function isInsideDL(index, dlState) {
  */
 export function analyzeListStructure(tokens, opt) {
   const listInfos = []
-  const processed = new Set()
+  const closeMap = buildListCloseIndexMap(tokens)
   
   // Check DL existence (O(n) but optimized with early return)
   let hasDL = false
@@ -92,12 +92,11 @@ export function analyzeListStructure(tokens, opt) {
   // Process only top-level lists (nested lists collected recursively)
   // Also process lists inside DL
   for (let i = 0; i < tokens.length; i++) {
-    if (processed.has(i)) {
+    const token = tokens[i]
+    if (!token) {
       continue
     }
     
-    const token = tokens[i]
-    
     // 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)
@@ -106,16 +105,13 @@ export function analyzeListStructure(tokens, opt) {
                        isInsideDL(i, dlScope)
     
     if (isTopLevelList || isListInDD) {
-      const listInfo = analyzeList(tokens, i, opt)
+      const listInfo = analyzeList(tokens, i, opt, closeMap)
       if (listInfo) {
         listInfos.push(listInfo)
-        // Mark this list range as processed
-        for (let j = listInfo.startIndex; j <= listInfo.endIndex; j++) {
-          processed.add(j)
-        }
         
         // Recursively collect nested lists
         collectNestedLists(listInfo, listInfos)
+        i = listInfo.endIndex
       }
     }
   }
@@ -143,9 +139,9 @@ function collectNestedLists(listInfo, listInfos) {
 /**
  * Analyze detailed information of a single list
  */
-function analyzeList(tokens, startIndex, opt) {
+function analyzeList(tokens, startIndex, opt, closeMap) {
   const listToken = tokens[startIndex]
-  const endIndex = findListEnd(tokens, startIndex)
+  const endIndex = findListEnd(tokens, startIndex, closeMap)
   
   if (endIndex === -1) {
     return null
@@ -153,7 +149,7 @@ function analyzeList(tokens, startIndex, opt) {
   
   const level = listToken.level || 0
   const originalType = listToken.type
-  const items = analyzeListItems(tokens, startIndex, endIndex, opt)
+  const items = analyzeListItems(tokens, startIndex, endIndex, opt, closeMap)
   const isLoose = detectLooseList(tokens, startIndex, endIndex, items)
   if (!isLoose) {
     hideFirstParagraphsForTightList(tokens, items, level)
@@ -188,7 +184,7 @@ function analyzeList(tokens, startIndex, opt) {
 /**
  * Analyze list items
  */
-function analyzeListItems(tokens, startIndex, endIndex, opt) {
+function analyzeListItems(tokens, startIndex, endIndex, opt, closeMap) {
   const items = []
   let i = startIndex + 1
   
@@ -196,8 +192,8 @@ function analyzeListItems(tokens, startIndex, endIndex, opt) {
     const token = tokens[i]
     
     if (token.type === 'list_item_open') {
-      const itemEndIndex = findListItemEnd(tokens, i)
-      const item = analyzeListItem(tokens, i, itemEndIndex, opt)
+      const itemEndIndex = findListItemEnd(tokens, i, closeMap)
+      const item = analyzeListItem(tokens, i, itemEndIndex, opt, closeMap)
       items.push(item)
       i = itemEndIndex + 1
     } else {
@@ -211,66 +207,59 @@ function analyzeListItems(tokens, startIndex, endIndex, opt) {
 /**
  * Analyze a single list item
  */
-function analyzeListItem(tokens, startIndex, endIndex, opt) {
+function analyzeListItem(tokens, startIndex, endIndex, opt, closeMap) {
   let content = ''
   let markerInfo = null
   let hasNestedList = false
   let nestedLists = []
   let firstParagraphIsLoose = false
+  let lastInlineContent = ''
   
   // Check if blank line exists right after first paragraph (only before child lists)
   // paragraph.hidden alone is insufficient: when parent list is loose, all paragraphs have hidden=false
   // Need to use map info to verify actual blank line after paragraph
-  let nestedDepth = 0
   let foundParagraph = false
   let firstParagraphIndex = -1
+  let checkedFirstParagraphLoose = false
   
   for (let i = startIndex + 1; i < endIndex; i++) {
     const token = tokens[i]
     
+    if (token.type === 'inline' && token.content) {
+      lastInlineContent = token.content
+    }
+    
+    if (!checkedFirstParagraphLoose && token.type === 'paragraph_open' && !foundParagraph) {
+      foundParagraph = true
+      firstParagraphIndex = i
+    }
+
     if (token.type === 'bullet_list_open' || token.type === 'ordered_list_open') {
-      // When child list starts, check if blank line exists right after first paragraph
-      if (foundParagraph && firstParagraphIndex !== -1) {
+      if (!checkedFirstParagraphLoose && foundParagraph && firstParagraphIndex !== -1) {
         const paragraphToken = tokens[firstParagraphIndex]
         const paragraphEndLine = paragraphToken.map ? paragraphToken.map[1] : undefined
         const nestedListStartLine = token.map
           ? token.map[0]
           : (typeof token._literalStartLine === 'number' ? token._literalStartLine : undefined)
         if (typeof paragraphEndLine === 'number' && typeof nestedListStartLine === 'number') {
-          // Check if blank line exists between paragraph end and child list start
           if (nestedListStartLine > paragraphEndLine) {
             firstParagraphIsLoose = true
           }
         }
-        break
       }
-      nestedDepth++
-    } else if (token.type === 'bullet_list_close' || token.type === 'ordered_list_close') {
-      nestedDepth--
-    } else if (nestedDepth === 0 && token.type === 'paragraph_open') {
-      // First paragraph outside nested lists
-      foundParagraph = true
-      firstParagraphIndex = i
-    }
-  }
-  
-  for (let i = startIndex + 1; i < endIndex; i++) {
-    const token = tokens[i]
-    
-    if (token.type === 'inline' && token.content) {
-      content = token.content
-      // Detect marker
-      markerInfo = detectMarkerType(content, opt)
-    }
-    
-    if (token.type === 'bullet_list_open' || token.type === 'ordered_list_open') {
+      checkedFirstParagraphLoose = true
       hasNestedList = true
-      const nestedListInfo = analyzeList(tokens, i, opt)
+      const nestedListInfo = analyzeList(tokens, i, opt, closeMap)
       nestedLists.push(nestedListInfo)
       i = nestedListInfo.endIndex
     }
   }
   
+  if (firstParagraphIsLoose && hasNestedList && lastInlineContent) {
+    markerInfo = detectMarkerType(lastInlineContent)
+  }
+  content = lastInlineContent
+  
   return {
     startIndex,
     endIndex,
@@ -288,7 +277,6 @@ function analyzeListItem(tokens, startIndex, endIndex, opt) {
 function extractMarkerInfo(tokens, startIndex, endIndex, opt) {
   const listToken = tokens[startIndex]
   const markers = []
-  let level = 0
   
   // For ordered_list, get numbers from list_item_open's info
   if (listToken.type === 'ordered_list_open') {
@@ -314,23 +302,25 @@ function extractMarkerInfo(tokens, startIndex, endIndex, opt) {
     // Target only direct children list_items of this list
     const targetLevel = (listToken.level || 0) + 3  // list_open(0) -> list_item(1) -> paragraph(2) -> inline(3)
     
-    // First, collect all contents (for detecting iroha sequence etc.)
+    // Collect inline tokens and contents once (for detecting iroha sequence etc.)
+    const inlineTokens = []
     const allContents = []
     for (let i = startIndex + 1; i < endIndex; i++) {
       const token = tokens[i]
       if (token.type === 'inline' && token.content && token.level === targetLevel) {
+        inlineTokens.push(token)
         allContents.push(token.content)
       }
     }
     
+    const contextResult = allContents.length > 0 ? detectSequencePattern(allContents) : null
+
     // Detect markers using full context
     let sequentialNumber = 1  // Sequential number counter
-    for (let i = startIndex + 1; i < endIndex; i++) {
-      const token = tokens[i]
-      
+    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 = detectMarkerType(token.content, allContents)
+        const markerInfo = detectMarkerTypeWithContext(token.content, contextResult)
         if (markerInfo && markerInfo.type) {
           // Use sequential numbers when same marker continues
           // (e.g., "イ. イ. イ." → interpreted as "イ、ロ、ハ")
@@ -494,7 +484,11 @@ function hideFirstParagraphsForTightList(tokens, items, level) {
 /**
  * Find list end position
  */
-function findListEnd(tokens, startIndex) {
+function findListEnd(tokens, startIndex, closeMap) {
+  const mapped = closeMap?.listCloseByOpen?.[startIndex]
+  if (typeof mapped === 'number' && mapped !== -1) {
+    return mapped
+  }
   const startToken = tokens[startIndex]
   const openType = startToken.type
   const closeType = openType.replace('_open', '_close')
@@ -505,7 +499,11 @@ function findListEnd(tokens, startIndex) {
 /**
  * Find list item end position
  */
-function findListItemEnd(tokens, startIndex) {
+function findListItemEnd(tokens, startIndex, closeMap) {
+  const mapped = closeMap?.listItemCloseByOpen?.[startIndex]
+  if (typeof mapped === 'number' && mapped !== -1) {
+    return mapped
+  }
   const result = findMatchingClose(tokens, startIndex, 'list_item_open', 'list_item_close')
   return result === -1 ? tokens.length - 1 : result
 }