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

package/src/preprocess-literal-lists.js

@@ -5,6 +5,12 @@ import { findMatchingClose, findListItemEnd } from './list-helpers.js'
 
 // markdown-it treats indent >= marker width + 4 as code blocks inside list items.
 const MAX_LITERAL_INLINE_INDENT = 3
+const LITERAL_SUFFIX_CHARS = new Set(['.', ')', '．', '）', '、'])
+const LITERAL_OPEN_CLOSE_PAIRS = new Map([
+  ['(', ')'],
+  ['（', '）']
+])
+const ASCII_ALNUM_OR_FULLWIDTH_DIGIT_REGEX = /^[A-Za-z0-9０-９]+$/
 const getIndentWidth = (indentText) => indentText.replace(/\t/g, '    ').length
 const buildLineMap = (startLine, endLine = null) => {
   if (typeof startLine !== 'number') {
@@ -24,6 +30,109 @@ const getListItemMarkerWidth = (listItem) => {
   return markerLength > 0 ? markerLength + 1 : 1
 }
 
+const getLineTokenWithIndent = (line) => {
+  if (typeof line !== 'string' || line.length === 0) {
+    return null
+  }
+  const match = line.match(/^([ \t]*)(\S+)(?:\s|$)/)
+  if (!match) {
+    return null
+  }
+  return {
+    indentWidth: getIndentWidth(match[1]),
+    token: match[2]
+  }
+}
+
+const hasLikelyLiteralMarkerToken = (token) => {
+  if (typeof token !== 'string' || token.length === 0) {
+    return false
+  }
+
+  let core = token
+  let hasSuffix = false
+  const firstChar = core[0]
+  const closingPair = LITERAL_OPEN_CLOSE_PAIRS.get(firstChar)
+  if (closingPair) {
+    const closeIdx = core.indexOf(closingPair, 1)
+    if (closeIdx <= 1) {
+      return false
+    }
+    const inner = core.slice(1, closeIdx)
+    const rest = core.slice(closeIdx + 1)
+    if (rest.length > 1) {
+      return false
+    }
+    if (rest.length === 1) {
+      if (!LITERAL_SUFFIX_CHARS.has(rest)) {
+        return false
+      }
+      hasSuffix = true
+    }
+    core = inner
+  } else {
+    const tail = core[core.length - 1]
+    if (LITERAL_SUFFIX_CHARS.has(tail)) {
+      core = core.slice(0, -1)
+      hasSuffix = true
+    }
+  }
+
+  if (!core) {
+    return false
+  }
+
+  // For ASCII tokens, require explicit suffix to avoid treating normal words as list markers.
+  if (ASCII_ALNUM_OR_FULLWIDTH_DIGIT_REGEX.test(core)) {
+    return hasSuffix
+  }
+
+  // Non-ASCII marker cores (circled digits, kana, kanji, etc.) are typically short.
+  return core.length <= 4
+}
+
+const hasLikelyLiteralLineHint = (content) => {
+  if (typeof content !== 'string' || !content.includes('\n')) {
+    return false
+  }
+  const lines = content.split('\n')
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i]
+    if (!line || line.trim().length === 0) {
+      continue
+    }
+    const tokenInfo = getLineTokenWithIndent(line)
+    if (!tokenInfo || tokenInfo.indentWidth > MAX_LITERAL_INLINE_INDENT) {
+      continue
+    }
+    if (hasLikelyLiteralMarkerToken(tokenInfo.token)) {
+      return true
+    }
+  }
+  return false
+}
+
+const hasOverIndentedMarkerLikeLine = (content) => {
+  if (typeof content !== 'string' || !content.includes('\n')) {
+    return false
+  }
+  const lines = content.split('\n')
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i]
+    if (!line || line.trim().length === 0) {
+      continue
+    }
+    const tokenInfo = getLineTokenWithIndent(line)
+    if (!tokenInfo || tokenInfo.indentWidth <= MAX_LITERAL_INLINE_INDENT) {
+      continue
+    }
+    if (hasLikelyLiteralMarkerToken(tokenInfo.token)) {
+      return true
+    }
+  }
+  return false
+}
+
 /**
  * Normalize literal nested ordered lists inside list items.
  * Converts indented numeric lines into proper ordered_list tokens before Phase 1.
@@ -71,11 +180,6 @@ export function normalizeLiteralOrderedLists(tokens, opt) {
     let j = i + 1
     while (j < listItemClose) {
       const current = tokens[j]
-      if (current.type !== 'paragraph_open') {
-        j++
-        continue
-      }
-
       if (current.type === 'paragraph_open') {
         const inlineIdx = j + 1
         const paragraphCloseIdx = j + 2
@@ -92,6 +196,17 @@ export function normalizeLiteralOrderedLists(tokens, opt) {
           j = paragraphCloseIdx + 1
           continue
         }
+        if (!hasLikelyLiteralLineHint(inlineToken.content)) {
+          j = paragraphCloseIdx + 1
+          continue
+        }
+        // Be conservative when deeply-indented marker-like lines are present.
+        // These lines are often code blocks; partial literal conversion is more surprising
+        // than preserving markdown-it's original rendering in this ambiguous case.
+        if (hasOverIndentedMarkerLikeLine(inlineToken.content)) {
+          j = paragraphCloseIdx + 1
+          continue
+        }
         const baseLine = tokens[j].map ? tokens[j].map[0] : null
         const segments = parseSegments(inlineToken.content, markerWidth, baseLine)
         if (!segments.hasLiteral) {
@@ -126,14 +241,6 @@ export function normalizeLiteralOrderedLists(tokens, opt) {
         continue
       }
 
-      if (current.type === 'ordered_list_open' &&
-          current.level === (tokens[i].level ?? 0) + 1) {
-        const delta = splitOrderedListForLiteralChildren(tokens, j, TokenClass)
-        listItemClose += delta
-        j++
-        continue
-      }
-
       j++
     }
     i = listItemClose
@@ -166,19 +273,16 @@ function parseSegments(content, markerWidth, baseLine = null) {
       }
     }
     const textValue = buffer.join('\n')
-    const hasBlankLine = hadBlankLine
-    segments.push({ type: 'text', text: textValue, tight: !hasBlankLine })
+    segments.push({ type: 'text', text: textValue, tight: !hadBlankLine })
     buffer = []
     blankLinesInBuffer = 0
   }
 
   while (idx < lines.length) {
     const isFirstLine = idx === 0
-    if (isFirstLine && lines[idx].trim().length > 0) {
+    const trimmedLine = lines[idx].trim()
+    if (isFirstLine && trimmedLine.length > 0) {
       buffer.push(lines[idx])
-      if (lines[idx].trim().length === 0) {
-        blankLinesInBuffer++
-      }
       idx++
       continue
     }
@@ -646,89 +750,3 @@ function markLiteralListLoose(tokens, listOpenIndex, listCloseIndex = null) {
     }
   }
 }
-
-function splitOrderedListForLiteralChildren(tokens, listOpenIndex, TokenClass) {
-  const listToken = tokens[listOpenIndex]
-  const listCloseIndex = findMatchingClose(tokens, listOpenIndex, 'ordered_list_open', 'ordered_list_close')
-  if (listCloseIndex === -1) {
-    return 0
-  }
-  const childLevel = (listToken.level ?? 0) + 1
-  const ranges = []
-  let currentOpen = -1
-  for (let idx = listOpenIndex + 1; idx < listCloseIndex; idx++) {
-    const token = tokens[idx]
-    if (token.type === 'list_item_open' && token.level === childLevel) {
-      currentOpen = idx
-      continue
-    }
-    if (token.type === 'list_item_close' && token.level === childLevel) {
-      if (currentOpen !== -1) {
-        ranges.push({ open: currentOpen, close: idx })
-        currentOpen = -1
-      }
-    }
-  }
-
-  if (ranges.length <= 1) {
-    return 0
-  }
-
-  const extraRanges = ranges.slice(1)
-  const childTokens = []
-  let removedCount = 0
-
-  for (const range of extraRanges) {
-    childTokens.push(...tokens.slice(range.open, range.close + 1))
-  }
-
-  for (let k = extraRanges.length - 1; k >= 0; k--) {
-    const range = extraRanges[k]
-    const len = range.close - range.open + 1
-    tokens.splice(range.open, len)
-    removedCount += len
-  }
-
-  if (listToken._markerInfo) {
-    delete listToken._markerInfo
-  }
-
-  const levelShift = 2
-  for (const token of childTokens) {
-    if (typeof token.level === 'number') {
-      token.level += levelShift
-    }
-  }
-
-  const nestedListOpen = new TokenClass('ordered_list_open', 'ol', 1)
-  nestedListOpen.level = (listToken.level ?? 0) + 2
-  nestedListOpen.block = true
-  nestedListOpen.markup = listToken.markup
-  nestedListOpen.attrs = null
-  nestedListOpen._literalList = true
-  if (Array.isArray(listToken.map)) {
-    nestedListOpen.map = listToken.map.slice()
-  }
-
-  const firstChild = childTokens.find(t => t.type === 'list_item_open')
-  if (firstChild?.info) {
-    const num = parseInt(firstChild.info, 10)
-    if (!Number.isNaN(num) && num !== 1) {
-      nestedListOpen.attrs = [['start', String(num)]]
-    }
-  }
-
-  const nestedListClose = new TokenClass('ordered_list_close', 'ol', -1)
-  nestedListClose.level = nestedListOpen.level
-  nestedListClose.block = true
-  nestedListClose.markup = listToken.markup
-  if (Array.isArray(listToken.map)) {
-    nestedListClose.map = listToken.map.slice()
-  }
-
-  const insertionIndex = ranges[0].close
-  tokens.splice(insertionIndex, 0, nestedListOpen, ...childTokens, nestedListClose)
-
-  const addedCount = childTokens.length + 2
-  return addedCount - removedCount
-}

package/src/types-utility.js

@@ -371,21 +371,6 @@ const createMarkerResult = (type, marker, number, prefix, suffix) => ({
   suffix
 })
 
-/**
- * Try to match content against compiled type patterns
- * @param {string} trimmed - Trimmed content
- * @param {Object} compiledType - Compiled type info
- * @param {Object} typeInfo - Type info from listTypes.json
- * @returns {Object|null} Match result or null
- */
-const tryMatchPattern = (trimmed, compiledType, typeInfo) => {
-  for (const pattern of compiledType.patterns) {
-    const m = matchRegexEntry(trimmed, compiledType.name, pattern)
-    if (m) return m
-  }
-  return null
-}
-
 // Enhanced marker type detection with context awareness
 export const detectMarkerType = (content, allContents = null) => {
   let contextResult = null

package/src/phase6-attrs-migration.js

@@ -1,184 +0,0 @@
-// Phase 6: Attribute Migration
-// Runs after markdown-it-attrs processing to handle nested list attributes
-// This phase moves custom attributes from child lists to parent lists
-// in flattened `- 1. Parent\n    - a. Child\n{.class}` patterns
-
-import { buildListCloseIndexMap } from './list-helpers.js'
-
-/**
- * Move custom attributes from nested child ordered_list to parent ordered_list
- * 
- * Background:
- * - Plugin flattens `ul > li > ol` structure to `ol > li` (simplifyNestedBulletLists)
- * - markdown-it-attrs runs on original structure, applies {.class} to child list
- * - Users expect {.class} after nested list to apply to parent list
- * 
- * Algorithm:
- * 1. Find top-level ordered_list_open tokens (level 0 or 2)
- * 2. Locate child ordered_list_open within first list_item
- * 3. Extract custom attributes (exclude plugin-generated: type, data-marker-*, role, ol-* classes)
- * 4. Move custom classes to parent's class list
- * 5. Move other custom attrs to parent
- * 6. Remove moved attrs from child
- * 
- * @param {Array} tokens - Token array to process
- */
-export function moveNestedListAttributes(tokens) {
-  const tokensLength = tokens.length
-  const closeMap = buildListCloseIndexMap(tokens)
-  const listCloseByOpen = closeMap.listCloseByOpen
-  const listItemCloseByOpen = closeMap.listItemCloseByOpen
-  
-  // Single pass: find top-level ordered_lists and process immediately
-  for (let i = 0; i < tokensLength; i++) {
-    const token = tokens[i]
-    
-    // Skip non-top-level ordered lists
-    if (token.type !== 'ordered_list_open' || (token.level !== 0 && token.level !== 2)) {
-      continue
-    }
-    
-    const parentToken = token
-    const parentLevel = token.level
-    
-    // Find list end
-    let listEndIndex = listCloseByOpen[i]
-    if (typeof listEndIndex !== 'number' || listEndIndex === -1) {
-      listEndIndex = tokensLength
-      let depth = 1
-      for (let j = i + 1; j < tokensLength; j++) {
-        if (tokens[j].type === 'ordered_list_open') depth++
-        else if (tokens[j].type === 'ordered_list_close') {
-          depth--
-          if (depth === 0) {
-            listEndIndex = j
-            break
-          }
-        }
-      }
-    }
-    
-    // Find first list_item
-    let firstItemOpen = -1
-    let firstItemClose = -1
-    
-    for (let j = i + 1; j < listEndIndex; j++) {
-      const t = tokens[j]
-      
-      if (t.type === 'list_item_open' && t.level === parentLevel + 1) {
-        firstItemOpen = j
-        firstItemClose = listItemCloseByOpen[j]
-        if (typeof firstItemClose !== 'number' || firstItemClose === -1) {
-          // Find matching close
-          let itemDepth = 1
-          for (let k = j + 1; k < tokensLength; k++) {
-            if (tokens[k].type === 'list_item_open') itemDepth++
-            else if (tokens[k].type === 'list_item_close') {
-              itemDepth--
-              if (itemDepth === 0) {
-                firstItemClose = k
-                break
-              }
-            }
-          }
-        }
-        break
-      }
-    }
-    
-    if (firstItemOpen === -1 || firstItemClose === -1) continue
-    
-    // Find child ordered_list within first list_item
-    let childListOpen = -1
-    for (let j = firstItemOpen + 1; j < firstItemClose && j < tokensLength; j++) {
-      if (tokens[j].type === 'ordered_list_open' && tokens[j].level > parentLevel) {
-        childListOpen = j
-        break
-      }
-    }
-    
-    if (childListOpen === -1) continue
-    
-    const childToken = tokens[childListOpen]
-    if (!childToken.attrs || childToken.attrs.length === 0) continue
-    
-    // Extract custom attributes (exclude plugin-generated)
-    const customAttrs = []
-    const remainingAttrs = []
-    
-    for (let j = 0; j < childToken.attrs.length; j++) {
-      const [key, value] = childToken.attrs[j]
-      
-      // Exclude plugin-generated attributes
-      if (key === 'type' || key === 'role' || key === 'style' || key === 'start' || key.startsWith('data-marker-')) {
-        remainingAttrs.push([key, value])
-        continue
-      }
-      
-      // Handle class attribute specially
-      if (key === 'class') {
-        const classes = value.split(/\s+/)
-        const pluginClasses = []
-        const customClasses = []
-        
-        for (let k = 0; k < classes.length; k++) {
-          // Treat ol-* as plugin-generated (should remain on child)
-          if (classes[k].startsWith('ol-')) {
-            pluginClasses.push(classes[k])
-          } else {
-            customClasses.push(classes[k])
-          }
-        }
-        
-        if (pluginClasses.length > 0) {
-          remainingAttrs.push(['class', pluginClasses.join(' ')])
-        }
-        if (customClasses.length > 0) {
-          customAttrs.push(['class', customClasses.join(' ')])
-        }
-        continue
-      }
-      
-      // All other attributes are custom
-      customAttrs.push([key, value])
-    }
-    
-    if (customAttrs.length === 0) continue
-    
-    // Move custom attributes to parent
-    if (!parentToken.attrs) {
-      parentToken.attrs = []
-    }
-    
-    // Merge attributes
-    for (let j = 0; j < customAttrs.length; j++) {
-      const [key, value] = customAttrs[j]
-      
-      if (key === 'class') {
-        // Find existing class attribute
-        let existingClassIdx = -1
-        for (let k = 0; k < parentToken.attrs.length; k++) {
-          if (parentToken.attrs[k][0] === 'class') {
-            existingClassIdx = k
-            break
-          }
-        }
-        
-        if (existingClassIdx !== -1) {
-          const existingClasses = parentToken.attrs[existingClassIdx][1].split(/\s+/)
-          const newClasses = value.split(/\s+/)
-          // Use Set for deduplication
-          const mergedClasses = [...new Set([...existingClasses, ...newClasses])]
-          parentToken.attrs[existingClassIdx][1] = mergedClasses.join(' ')
-        } else {
-          parentToken.attrs.push(['class', value])
-        }
-      } else {
-        parentToken.attrs.push([key, value])
-      }
-    }
-    
-    // Update child token attrs
-    childToken.attrs = remainingAttrs.length > 0 ? remainingAttrs : null
-  }
-}