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

package/src/phase0-description-list.js

@@ -8,39 +8,152 @@ import { findMatchingClose, findListEnd as coreFindListEnd } from './list-helper
  * Parse attribute string like ".class1 .class2 #id data-foo="bar""
  * Returns array of [key, value] pairs
  */
+const ATTR_TOKEN_REGEX = /\s*(\.[\w-]+|#[\w-]+|[\w:-]+=(?:"[^"]*"|'[^']*'|[^\s"'{}]+)|[\w:-]+)/y
+const ATTR_KEY_VALUE_REGEX = /^([\w:-]+)=(?:"([^"]*)"|'([^']*)'|([^\s"'{}]+))$/
+const LEADING_ATTR_BLOCK_REGEX = /^[ \t]*\{([^}]+)\}/
+const STANDALONE_ATTR_BLOCK_REGEX = /^\{([^}]+)\}$/
+const TRAILING_TWO_SPACES_REGEX = / {2,}$/
+const TRAILING_BACKSLASH_BREAK_REGEX = /\\\s*$/
+
 const parseAttrString = (attrStr) => {
+  if (!attrStr || typeof attrStr !== 'string') {
+    return []
+  }
+
   const attrs = []
-  const classMatches = attrStr.match(/\.[\w-]+/g)
-  const idMatch = attrStr.match(/#([\w-]+)/)
-  const dataMatches = attrStr.match(/([\w-]+)="([^"]+)"/g)
-  
-  // Collect all classes
-  if (classMatches) {
-    const classes = classMatches.map(c => c.substring(1)).join(' ')
-    attrs.push(['class', classes])
+  const customAttrs = []
+  const classes = []
+  let id = null
+  let cursor = 0
+
+  while (cursor < attrStr.length) {
+    ATTR_TOKEN_REGEX.lastIndex = cursor
+    const match = ATTR_TOKEN_REGEX.exec(attrStr)
+    if (!match) {
+      // Allow only trailing whitespace; otherwise reject as invalid attr syntax.
+      if (/^\s*$/.test(attrStr.slice(cursor))) {
+        break
+      }
+      return []
+    }
+    const token = match[1]
+    cursor = ATTR_TOKEN_REGEX.lastIndex
+    if (token[0] === '.') {
+      const cls = token.slice(1)
+      if (cls) {
+        classes.push(cls)
+      }
+      continue
+    }
+    if (token[0] === '#') {
+      if (!id) {
+        id = token.slice(1)
+      }
+      continue
+    }
+
+    const kv = token.match(ATTR_KEY_VALUE_REGEX)
+    if (!kv) {
+      // markdown-it-attrs boolean attribute (e.g. {foo})
+      customAttrs.push([token, ''])
+      continue
+    }
+    const key = kv[1]
+    const value = kv[2] ?? kv[3] ?? kv[4] ?? ''
+    customAttrs.push([key, value])
   }
-  
-  // Add id
-  if (idMatch) {
-    attrs.push(['id', idMatch[1]])
+
+  if (classes.length > 0) {
+    attrs.push(['class', classes.join(' ')])
   }
-  
-  // Add data attributes
-  if (dataMatches) {
-    dataMatches.forEach(match => {
-      const [, key, value] = match.match(/([\w-]+)="([^"]+)"/)
-      attrs.push([key, value])
-    })
+  if (id) {
+    attrs.push(['id', id])
   }
-  
+  if (customAttrs.length > 0) {
+    attrs.push(...customAttrs)
+  }
+
   return attrs
 }
 
+const consumeLeadingValidAttrBlocks = (text) => {
+  if (typeof text !== 'string' || text.length === 0) {
+    return { rest: text || '', attrs: [] }
+  }
+
+  let rest = text
+  const attrs = []
+  while (true) {
+    const match = rest.match(LEADING_ATTR_BLOCK_REGEX)
+    if (!match) {
+      break
+    }
+    const parsed = parseAttrString(match[1])
+    if (parsed.length === 0) {
+      break
+    }
+    attrs.push(...parsed)
+    rest = rest.slice(match[0].length)
+  }
+
+  return { rest, attrs }
+}
+
+const hasExplicitLineBreakMarker = (afterStrong) => {
+  if (typeof afterStrong !== 'string') {
+    return false
+  }
+  const lineBreakIndex = afterStrong.indexOf('\n')
+  if (lineBreakIndex === -1) {
+    return false
+  }
+  const firstLine = afterStrong.slice(0, lineBreakIndex)
+  return TRAILING_TWO_SPACES_REGEX.test(firstLine) || TRAILING_BACKSLASH_BREAK_REGEX.test(firstLine)
+}
+
+const getDescriptionAfterExplicitLineBreak = (afterStrong) => {
+  if (!hasExplicitLineBreakMarker(afterStrong)) {
+    return null
+  }
+  const lineBreakIndex = afterStrong.indexOf('\n')
+  return afterStrong.slice(lineBreakIndex + 1)
+}
+
+const hasMeaningfulDescriptionContent = (text) => {
+  if (typeof text !== 'string' || text.trim().length === 0) {
+    return false
+  }
+
+  const lines = text.split('\n')
+  const renderedLines = []
+  for (const line of lines) {
+    const trimmed = line.trim()
+    if (!trimmed) {
+      continue
+    }
+    const attrMatch = trimmed.match(STANDALONE_ATTR_BLOCK_REGEX)
+    if (attrMatch) {
+      const parsed = parseAttrString(attrMatch[1])
+      if (parsed.length > 0) {
+        continue
+      }
+    }
+    renderedLines.push(trimmed)
+  }
+  return renderedLines.join('\n').trim().length > 0
+}
+
+const copyMap = (target, source) => {
+  if (!target || !source || !Array.isArray(source.map)) {
+    return
+  }
+  target.map = source.map.slice()
+}
+
 /**
  * Process description list patterns in tokens
  * @param {Array} tokens - Token array
  * @param {Object} opt - Options object
-```
  */
 export const processDescriptionList = (tokens, opt) => {
   if (!opt.descriptionList && !opt.descriptionListWithDiv) {
@@ -54,7 +167,7 @@ export const processDescriptionList = (tokens, opt) => {
     if (tokens[i].type === 'bullet_list_open') {
       const listEnd = findListEnd(tokens, i)
       const dlCheck = checkAndConvertToDL(tokens, i, listEnd, opt)
-      i = dlCheck.nextIndex
+      i = typeof dlCheck?.nextIndex === 'number' ? dlCheck.nextIndex : listEnd + 1
     } else {
       i++
     }
@@ -101,6 +214,21 @@ const collectListItemRanges = (tokens, listStart, listEnd) => {
   return ranges
 }
 
+/**
+ * Return the first direct child token index of a list_item.
+ * Direct child means token.level === list_item.level + 1.
+ */
+const findFirstDirectChildInListItem = (tokens, itemStart, itemEnd) => {
+  const itemLevel = tokens[itemStart]?.level ?? 0
+  const childLevel = itemLevel + 1
+  for (let i = itemStart + 1; i < itemEnd; i++) {
+    if (tokens[i].level === childLevel) {
+      return i
+    }
+  }
+  return -1
+}
+
 /**
  * Find matching dl_close token
  */
@@ -130,60 +258,57 @@ const checkAndConvertToDL = (tokens, listStart, listEnd, opt) => {
     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 firstChild = findFirstDirectChildInListItem(tokens, itemStart, itemEnd)
+    if (firstChild !== -1 && tokens[firstChild].type === 'paragraph_open') {
+      const firstPara = firstChild
       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
-              }
-            }
+      if (!inlineToken || inlineToken.type !== 'inline') {
+        return { nextIndex: listEnd + 1 }
+      }
+
+      const dlCheck = isDLPattern(inlineToken.content)
+      if (!dlCheck.isMatch) {
+        // Not all items are DL pattern - not a description list
+        return { nextIndex: listEnd + 1 }
+      }
+
+      // Check if there's a description
+      let hasDescription = false
+      const afterStrong = dlCheck.afterStrong
+
+      // Pattern 1: Explicit line-break marker after term line (`  ` or `\`) and
+      // description text in the remaining first paragraph content.
+      const explicitBreakDescription = getDescriptionAfterExplicitLineBreak(afterStrong)
+      if (explicitBreakDescription !== null && hasMeaningfulDescriptionContent(explicitBreakDescription)) {
+        hasDescription = true
+      }
+
+      // Pattern 2: Description in next paragraph/list (term-only first paragraph).
+      if (!hasDescription) {
+        // Check for additional paragraphs/lists
+        const itemChildLevel = (tokens[itemStart]?.level ?? 0) + 1
+        for (let k = firstPara + 3; k < itemEnd; k++) {
+          if (tokens[k].level !== itemChildLevel) {
+            continue
           }
-          
-          // If no description, not a DL item
-          if (!hasDescription) {
-            return false
+          if (tokens[k].type === 'paragraph_open' ||
+              tokens[k].type === 'bullet_list_open' ||
+              tokens[k].type === 'ordered_list_open') {
+            hasDescription = true
+            break
           }
-          
-          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 { nextIndex: listEnd + 1 }
+      }
+
+      hasAnyDLItem = true
+    } else {
+      // Any list_item that doesn't start with a paragraph cannot be a DL item.
+      return { nextIndex: listEnd + 1 }
     }
   }
   
@@ -211,16 +336,11 @@ const isDLPattern = (content) => {
   
   const afterStrong = match[2]  // Text after closing **
   
-  // Pattern 1: **Term**  description (2+ spaces, including newlines)
-  // Pattern 2: **Term**: description (colon)
-  // Pattern 3: **Term**\ description (backslash escape)
-  // Pattern 4: **Term** only (no content after)
-  // Pattern 5: **Term** {.attrs} (markdown-it-attrs syntax, optionally with content after)
-  const isMatch = /^\s{2,}/.test(afterStrong) || 
-                  /^\s*:/.test(afterStrong) ||
-                  /^\\/.test(afterStrong) ||
-                  /^\s*$/.test(afterStrong) ||
-                  /^\s*\{[^}]+\}/.test(afterStrong)  // {.class} or {#id} etc
+  // Match only strict description-list starts:
+  // 1) explicit line-break marker after term line (`  ` or `\`) + newline
+  // 2) term-only first line (optionally with valid attrs only), expecting next block as description
+  const { rest: afterAttrs } = consumeLeadingValidAttrBlocks(afterStrong)
+  const isMatch = hasExplicitLineBreakMarker(afterStrong) || /^\s*$/.test(afterAttrs)
   
   return { isMatch, afterStrong }
 }
@@ -236,6 +356,7 @@ const convertBulletListToDL = (tokens, listStart, listEnd, opt, itemRanges = nul
   const dlOpen = new tokens[listStart].constructor('dl_open', 'dl', 1)
   dlOpen.level = listLevel
   dlOpen.block = true
+  copyMap(dlOpen, tokens[listStart])
   
   // Copy attributes from bullet_list_open (e.g., {.class} from markdown-it-attrs)
   if (tokens[listStart].attrs && tokens[listStart].attrs.length > 0) {
@@ -295,6 +416,7 @@ const convertBulletListToDL = (tokens, listStart, listEnd, opt, itemRanges = nul
   const dlClose = new tokens[listStart].constructor('dl_close', 'dl', -1)
   dlClose.level = listLevel
   dlClose.block = true
+  copyMap(dlClose, tokens[listEnd])
   newTokens.push(dlClose)
   
   // Replace tokens
@@ -313,14 +435,10 @@ const convertListItemToDtDd = (tokens, itemStart, itemEnd, parentLevel, opt) =>
   const listItemToken = tokens[itemStart]
   let dtAttrs = listItemToken.attrs ? [...listItemToken.attrs] : null
   
-  // Find first paragraph
-  let firstPara = -1
-  for (let i = itemStart + 1; i < itemEnd; i++) {
-    if (tokens[i].type === 'paragraph_open') {
-      firstPara = i
-      break
-    }
-  }
+  const firstChild = findFirstDirectChildInListItem(tokens, itemStart, itemEnd)
+  const firstPara = firstChild !== -1 && tokens[firstChild].type === 'paragraph_open'
+    ? firstChild
+    : -1
   
   if (firstPara === -1) return { tokens: result, listAttrs }
   
@@ -335,24 +453,19 @@ const convertListItemToDtDd = (tokens, itemStart, itemEnd, parentLevel, opt) =>
   const match = content.match(/^\*\*(.*?)\*\*(.*)/s)  // s flag for including newlines
   
   if (match) {
-    term = match[1]  // Keep spaces for now (will be processed by inline parser)
+    // Trim to avoid leading space when **Term** starts with whitespace (e.g. "** *term*")
+    term = match[1].trim()
     let afterStrong = match[2]
     
-    // Extract {.attrs} from afterStrong if present (markdown-it-attrs hasn't processed yet)
-    // Pattern A: Inline {.attrs} immediately after **Term** like **Term** {.class}
-    const inlineAttrsMatch = afterStrong.match(/^\s*\{([^}]+)\}/)
-    if (inlineAttrsMatch) {
-      // Parse attributes manually
-      const attrString = inlineAttrsMatch[1]
-      const parsedAttrs = parseAttrString(attrString)
-      if (parsedAttrs.length > 0) {
-        if (!dtAttrs) {
-          dtAttrs = []
-        }
-        dtAttrs.push(...parsedAttrs)
+    // Pattern A: one or more leading attr blocks right after **Term**.
+    // These map to <dt> like markdown-it-attrs trailing attrs on a block line.
+    const leadingAttrs = consumeLeadingValidAttrBlocks(afterStrong)
+    if (leadingAttrs.attrs.length > 0) {
+      if (!dtAttrs) {
+        dtAttrs = []
       }
-      // Remove {.attrs} from afterStrong (including trailing newline if attrs-only line)
-      afterStrong = afterStrong.replace(/^\s*\{[^}]+\}\s*/, '')
+      dtAttrs.push(...leadingAttrs.attrs)
+      afterStrong = leadingAttrs.rest
     }
     
     // Pattern B: {.attrs} on last line (e.g., "Description\n{.attrs}")
@@ -365,13 +478,13 @@ const convertListItemToDtDd = (tokens, itemStart, itemEnd, parentLevel, opt) =>
       const parsedAttrs = parseAttrString(attrString)
       if (parsedAttrs.length > 0) {
         listAttrs.push(...parsedAttrs)
+        // Remove {.attrs} line from afterStrong
+        afterStrong = afterStrong.replace(/\n\s*\{[^}]+\}\s*$/, '')
       }
-      // Remove {.attrs} line from afterStrong
-      afterStrong = afterStrong.replace(/\n\s*\{[^}]+\}\s*$/, '')
     }
     
-    // Clean up afterStrong: remove leading spaces/colon/backslash, then trim each line
-    let cleaned = afterStrong.replace(/^[\s:]+/, '').replace(/^\\/, '')
+    // Clean up afterStrong: remove leading spaces/backslash, then trim each line
+    let cleaned = afterStrong.replace(/^\s+/, '').replace(/^\\/, '')
     
     // Remove leading whitespace from each line (remove list indent)
     cleaned = cleaned.split('\n').map(line => line.replace(/^\s+/, '')).join('\n').trim()
@@ -386,7 +499,10 @@ const convertListItemToDtDd = (tokens, itemStart, itemEnd, parentLevel, opt) =>
     const divOpen = new tokens[firstPara].constructor('div_open', 'div', 1)
     divOpen.level = parentLevel + 1
     divOpen.block = true
-    const divClass = typeof opt.descriptionListDivClass === 'string' ? opt.descriptionListDivClass : ''
+    copyMap(divOpen, tokens[firstPara])
+    const divClass = typeof opt.descriptionListDivClass === 'string'
+      ? opt.descriptionListDivClass.trim()
+      : ''
     if (divClass) {
       divOpen.attrs = [['class', divClass]]
     }
@@ -397,6 +513,7 @@ const convertListItemToDtDd = (tokens, itemStart, itemEnd, parentLevel, opt) =>
   const dtOpen = new tokens[firstPara].constructor('dt_open', 'dt', 1)
   dtOpen.level = parentLevel + 1
   dtOpen.block = true
+  copyMap(dtOpen, tokens[firstPara])
   // Add collected attributes to dt_open
   if (dtAttrs && dtAttrs.length > 0) {
     dtOpen.attrs = dtAttrs
@@ -414,20 +531,22 @@ const convertListItemToDtDd = (tokens, itemStart, itemEnd, parentLevel, opt) =>
   const dtClose = new tokens[firstPara].constructor('dt_close', 'dt', -1)
   dtClose.level = parentLevel + 1
   dtClose.block = true
+  copyMap(dtClose, tokens[firstPara])
   result.push(dtClose)
   
   // Create dd_open token
   const ddOpen = new tokens[firstPara].constructor('dd_open', 'dd', 1)
   ddOpen.level = parentLevel + 1
   ddOpen.block = true
+  copyMap(ddOpen, tokens[firstPara])
   result.push(ddOpen)
   
   // First paragraph in dd (if description exists)
-  let hasFirstParagraph = false
   if (descStart.trim()) {
     const pOpen = new tokens[firstPara].constructor('paragraph_open', 'p', 1)
     pOpen.level = parentLevel + 2
     pOpen.block = true  // IMPORTANT: Enable block mode for proper newline rendering
+    copyMap(pOpen, tokens[firstPara])
     result.push(pOpen)
     
     const pInline = new tokens[firstPara].constructor('inline', '', 0)
@@ -442,9 +561,9 @@ const convertListItemToDtDd = (tokens, itemStart, itemEnd, parentLevel, opt) =>
     const pClose = new tokens[firstPara].constructor('paragraph_close', 'p', -1)
     pClose.level = parentLevel + 2
     pClose.block = true  // IMPORTANT: Enable block mode for proper newline rendering
+    copyMap(pClose, tokens[firstPara])
     result.push(pClose)
     
-    hasFirstParagraph = true
   }
   
   // Add remaining content in dd (paragraphs, lists, etc.)
@@ -454,8 +573,6 @@ const convertListItemToDtDd = (tokens, itemStart, itemEnd, parentLevel, opt) =>
     
     // Handle paragraph
     if (token.type === 'paragraph_open') {
-      hasFirstParagraph = true
-      
       result.push(tokens[i])      // paragraph_open
       result.push(tokens[i + 1])  // inline
       result.push(tokens[i + 2])  // paragraph_close
@@ -491,6 +608,7 @@ const convertListItemToDtDd = (tokens, itemStart, itemEnd, parentLevel, opt) =>
   const ddClose = new tokens[firstPara].constructor('dd_close', 'dd', -1)
   ddClose.level = parentLevel + 1
   ddClose.block = true
+  copyMap(ddClose, tokens[firstPara])
   result.push(ddClose)
   
   // Create div_close if descriptionListWithDiv is enabled
@@ -498,6 +616,7 @@ const convertListItemToDtDd = (tokens, itemStart, itemEnd, parentLevel, opt) =>
     const divClose = new tokens[firstPara].constructor('div_close', 'div', -1)
     divClose.level = parentLevel + 1
     divClose.block = true
+    copyMap(divClose, tokens[firstPara])
     result.push(divClose)
   }
   

package/src/phase1-analyze.js

@@ -154,6 +154,9 @@ function analyzeList(tokens, startIndex, opt, closeMap) {
   if (!isLoose) {
     hideFirstParagraphsForTightList(tokens, items, level)
   }
+
+  // Cache loose/tight state for later phases (mapless flattening fallback).
+  listToken._isLoose = isLoose
   
   // Extract marker info (for both bullet_list and ordered_list)
   const markerInfo = extractMarkerInfo(tokens, startIndex, endIndex, opt)
@@ -168,6 +171,13 @@ function analyzeList(tokens, startIndex, opt, closeMap) {
   // Convert even loose lists if markers are consistent
   const shouldConvert = originalType === 'bullet_list_open' && 
                         shouldConvertToOrdered(originalType, markerInfo, opt)
+
+  if (markerInfo) {
+    listToken._markerInfo = markerInfo
+  }
+  if (originalType === 'bullet_list_open') {
+    listToken._shouldConvert = shouldConvert
+  }
   
   return {
     startIndex,
@@ -259,6 +269,10 @@ function analyzeListItem(tokens, startIndex, endIndex, opt, closeMap) {
     markerInfo = detectMarkerType(lastInlineContent)
   }
   content = lastInlineContent
+
+  if (tokens[startIndex]) {
+    tokens[startIndex]._firstParagraphIsLoose = firstParagraphIsLoose
+  }
   
   return {
     startIndex,
@@ -277,9 +291,15 @@ function analyzeListItem(tokens, startIndex, endIndex, opt, closeMap) {
 function extractMarkerInfo(tokens, startIndex, endIndex, opt) {
   const listToken = tokens[startIndex]
   const markers = []
+  const literalMarkerInfo = listToken._literalMarkerInfo || null
   
   // For ordered_list, get numbers from list_item_open's info
   if (listToken.type === 'ordered_list_open') {
+    const literalMarkers = Array.isArray(literalMarkerInfo?.markers) ? literalMarkerInfo.markers : null
+    const literalType = literalMarkerInfo?.type || 'decimal'
+    const literalPrefix = literalMarkers?.[0]?.prefix ?? ''
+    const literalSuffix = literalMarkers?.[0]?.suffix ?? (listToken.markup || '.')
+    let listItemIndex = 0
     for (let i = startIndex + 1; i < endIndex; i++) {
       const token = tokens[i]
       
@@ -287,14 +307,25 @@ function extractMarkerInfo(tokens, startIndex, endIndex, opt) {
         // Get number from info
         const itemNumber = token.info ? parseInt(token.info, 10) : markers.length + 1
         const markup = token.markup || listToken.markup || '.'
-        
-        markers.push({
-          number: itemNumber,
-          originalNumber: itemNumber,
-          prefix: '',
-          suffix: markup,
-          type: 'decimal'  // Default (can be extended to detect from markup)
-        })
+        if (literalMarkers && literalMarkers[listItemIndex]) {
+          const marker = { ...literalMarkers[listItemIndex] }
+          if (typeof marker.originalNumber !== 'number') {
+            marker.originalNumber = itemNumber
+          }
+          if (typeof marker.number !== 'number') {
+            marker.number = itemNumber
+          }
+          markers.push(marker)
+        } else {
+          markers.push({
+            number: itemNumber,
+            originalNumber: itemNumber,
+            prefix: literalPrefix,
+            suffix: literalSuffix || markup,
+            type: literalType
+          })
+        }
+        listItemIndex++
       }
     }
   } else {