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

package/README.md

@@ -2,7 +2,7 @@
 
 Markdown's default ordered list markers are limited. This plugin extends Markdown's unordered lists so they can use many kinds of ordered markers.
 
-Also, this plugin option provides a description-list conversion. Unordered list items whose first line is wrapped in `**` and followed by two spaces are converted into `<dl>` elements.
+Also, this plugin option provides a description-list conversion. Unordered list items whose first line is wrapped in `**` and followed by a description separator (two spaces, `\\`, or a blank line) are converted into `<dl>` elements.
 
 ## Ordered lists conversion behavior
 
@@ -72,6 +72,10 @@ After the marker separator, an ASCII space is normally expected. For `fullwidth`
 - Marker type detection is deterministic: gather all markers at a nesting level, match them against the canonical definitions, keep the type that explains the most items while preserving numeric continuity, and use the order in `listTypes.json` only as a final tiebreaker.
 - Flattening: A pattern like `- 1.` is represented by the default `ul > li > ol` nesting structure in markdown-it, but this plugin simplifies it to a single `ol` by default to match the representation of other markers.
 
+### Source map behavior
+
+The flattener uses `token.map` (markdown-it source line numbers) to preserve loose list output for `- 1.` style lists. markdown-it normally assigns `map` to block tokens, but it can be missing if tokens are constructed manually, cloned without `map`, or stripped by upstream plugins to save memory. In that case, the plugin falls back to markdown-it's `paragraph.hidden` flags and `- 1.` lists with blank lines may render as tight lists (no `<p>` wrappers). Avoid stripping `map` data or set `unremoveUlNest: true` if exact loose rendering is required.
+
 Note: For custom marker lists (those rendered with `role="list"`) the plugin assumes you will hide the native marker via CSS (for example `ol[role="list"] { list-style: none; }`). The `hasListStyleNone` option can be enabled to add `style="list-style: none;"` directly to generated `<ol>` elements.
 
 ### Behavior customization
@@ -85,17 +89,19 @@ You can customize the conversion using options.
 - `hasListStyleNone` (boolean) — When the plugin emits `role="list"`, also add `style="list-style: none;"` to the `<ol>`.
 - `omitMarkerMetadata` (boolean) — If `true`, omit the `data-marker-prefix` / `data-marker-suffix` attributes.
 - `addMarkerStyleToClass` (boolean) — When `true`, append suffix-style information to the generated class name (e.g. `ol-decimal-with-round-round`). When `false` (default) the class stays as `ol-decimal`.
+- `enableLiteralNumberingFix` (boolean) — Enable literal nested list recovery (for example, nested lists starting with 2 or greater). This is opt-in; it only applies inside list items, evaluates indentation relative to the parent list marker (marker width + 0–3 spaces), and does not convert code blocks (indent >= marker width + 4).
 
 ## Description lists conversion behavior
 
 When the `descriptionList` option is enabled the plugin converts specially formatted bullet lists into HTML description lists (`<dl>`).
 
 - Each list item must start with a `**Term**` line.
-  - If the Term line is not separated from the description by a blank line, then the Term line must end with two ASCII spaces (a Markdown line-break) or a backslash `\` to indicate the description follows.
+  - If the description continues on the next line without a blank line, the Term line must end with two ASCII spaces (a Markdown line-break) or a backslash `\`. Inline `{.attrs}` immediately after the term are allowed.
+  - If the Term line is followed by a blank line, the description can start in the next paragraph or list (line-break control characters are optional).
 
 In the conversion the `**Term**` line becomes a `<dt>` and the subsequent lines become the corresponding `<dd>`.
 
-Note: Currently the content inside `<dd>` elements is always wrapped in `<p>` elements.
+Note: Text descriptions are wrapped in `<p>` elements; additional paragraphs and lists keep markdown-it's block structure.
 
 ### Description list options
 

package/index.js

@@ -21,13 +21,30 @@ const mditNumberingUl = (md, option) => {
     omitMarkerMetadata: false,    // true=omit data-marker-prefix/suffix attributes
     useCounterStyle: false,       // true=users will use @counter-style; suppress marker spans and role attr
     addMarkerStyleToClass: false, // true=append -with-* marker style suffix to class names
+    enableLiteralNumberingFix: false, // true=normalize nested lists that don't start at 1 (opt-in)
     
     // Override with user options
     ...option
   }
-  
-  // Check if markdown-it-attrs is loaded (detect once at plugin initialization)
-  const hasAttrsPlugin = md.core.ruler.__rules__.some(rule => rule.name === 'curly_attributes')
+
+  const addRuleAfter = (ruler, afterName, ruleName, fn) => {
+    try {
+      ruler.after(afterName, ruleName, fn)
+    } catch {
+      ruler.push(ruleName, fn)
+    }
+  }
+
+  const dlProcessor = (state) => {
+    if (!state.env) {
+      state.env = {}
+    }
+    if (!opt.descriptionList && !opt.descriptionListWithDiv) {
+      return true
+    }
+    processDescriptionList(state.tokens, opt)
+    return true
+  }
 
   const listProcessor = (state) => {
     // Initialize state.env
@@ -36,14 +53,9 @@ const mditNumberingUl = (md, option) => {
     }
 
     const tokens = state.tokens
-    
-    // ===== PHASE 0: Description List =====
-    // Convert **Term**: pattern from paragraph to bullet_list, then to dl/dt/dd
-    // Must run before Phase 1 (parsed as bullet_list)
-    processDescriptionList(tokens, opt)
 
     // Normalize literal nested ordered lists (markdown-it only creates nested lists when they start at 1)
-    normalizeLiteralOrderedLists(tokens)
+    normalizeLiteralOrderedLists(tokens, opt)
     
     // ===== PHASE 1: List Structure Analysis =====
     // Analyze marker detection and structure without token conversion
@@ -56,9 +68,8 @@ const mditNumberingUl = (md, option) => {
     
     // ===== PHASE 3: Add Attributes =====
     // Add type, class, data-* attributes to converted lists
-    // Use original listInfos as tokens may have been removed in Phase2
-    // (Uses markerInfo stored in tokens)
-    addAttributes(tokens, listInfos, opt)
+    // Use markerInfo stored on list tokens (safe after Phase2 mutations)
+    addAttributes(tokens, opt)
     
     // ===== PHASE 4: HTML Block Processing =====
     // Remove indents from HTML blocks in lists and normalize line breaks
@@ -66,12 +77,13 @@ const mditNumberingUl = (md, option) => {
     
     // ===== PHASE 5: Span Generation =====
     // Generate marker spans in alwaysMarkerSpan mode
-    generateSpans(tokens, listInfos, opt)
+    generateSpans(tokens, opt)
     
     return true
   }
 
-  md.core.ruler.before('inline', 'numbering_ul_phases', listProcessor)
+  md.core.ruler.before('inline', 'numbering_dl_parser', dlProcessor)
+  md.core.ruler.after('numbering_dl_parser', 'numbering_ul_phases', listProcessor)
   
   if (!opt.unremoveUlNest) {
     // Move nested list attributes only when flattening is enabled
@@ -80,11 +92,7 @@ const mditNumberingUl = (md, option) => {
       return true
     }
     
-    if (hasAttrsPlugin) {
-      md.core.ruler.after('curly_attributes', 'numbering_ul_nested_attrs', nestedListAttrProcessor)
-    } else {
-      md.core.ruler.push('numbering_ul_nested_attrs', nestedListAttrProcessor)
-    }
+    addRuleAfter(md.core.ruler, 'curly_attributes', 'numbering_ul_nested_attrs', nestedListAttrProcessor)
   }
   
   // Description list: Move paragraph attributes to dl and add custom renderers
@@ -95,30 +103,7 @@ const mditNumberingUl = (md, option) => {
       return true
     }
     
-    if (hasAttrsPlugin) {
-      md.core.ruler.after('curly_attributes', 'numbering_dl_attrs', dlAttrProcessor)
-    } else {
-      md.core.ruler.push('numbering_dl_attrs', dlAttrProcessor)
-    }
-    
-    // Add custom renderers for description list tokens
-    // Helper function to render attributes
-    const renderAttrs = (token) => {
-      if (!token.attrs || token.attrs.length === 0) return ''
-      return ' ' + token.attrs.map(([key, value]) => `${key}="${value}"`).join(' ')
-    }
-    
-    md.renderer.rules.dl_open = (tokens, idx) => `<dl${renderAttrs(tokens[idx])}>\n`
-    md.renderer.rules.dl_close = () => '</dl>\n'
-    md.renderer.rules.dt_open = (tokens, idx) => `<dt${renderAttrs(tokens[idx])}>`
-    md.renderer.rules.dt_close = () => '</dt>\n'
-    md.renderer.rules.dd_open = (tokens, idx) => `<dd${renderAttrs(tokens[idx])}>\n`
-    md.renderer.rules.dd_close = () => '</dd>\n'
-    
-    if (opt.descriptionListWithDiv) {
-      md.renderer.rules.div_open = (tokens, idx) => `<div${renderAttrs(tokens[idx])}>\n`
-      md.renderer.rules.div_close = () => '</div>\n'
-    }
+    addRuleAfter(md.core.ruler, 'curly_attributes', 'numbering_dl_attrs', dlAttrProcessor)
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peaceroad/markdown-it-numbering-ul-regarded-as-ol",
-  "version": "0.2.3",
+  "version": "0.3.0",
   "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.5",
+    "@peaceroad/markdown-it-strong-ja": "^0.6.2",
     "markdown-it": "^14.1.0",
     "markdown-it-attrs": "^4.3.1",
     "markdown-it-deflist": "^3.0.0"

package/src/phase0-description-list.js

@@ -36,6 +36,13 @@ const parseAttrString = (attrStr) => {
   return attrs
 }
 
+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
@@ -150,11 +157,10 @@ const checkAndConvertToDL = (tokens, listStart, listEnd, opt) => {
           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()
+          // Pattern 2: **Term**\ description (backslash escape)
+          if (/^\s{2,}/.test(afterStrong) || /^\\/.test(afterStrong)) {
+            // Remove leading space/backslash and check remaining text
+            const cleaned = afterStrong.replace(/^\s+/, '').replace(/^\\/, '').trim()
             if (cleaned) {
               hasDescription = true
             }
@@ -212,12 +218,10 @@ 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 2: **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
@@ -236,6 +240,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 +300,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
@@ -335,7 +341,8 @@ 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)
@@ -370,8 +377,8 @@ const convertListItemToDtDd = (tokens, itemStart, itemEnd, parentLevel, opt) =>
       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,6 +393,7 @@ const convertListItemToDtDd = (tokens, itemStart, itemEnd, parentLevel, opt) =>
     const divOpen = new tokens[firstPara].constructor('div_open', 'div', 1)
     divOpen.level = parentLevel + 1
     divOpen.block = true
+    copyMap(divOpen, tokens[firstPara])
     const divClass = typeof opt.descriptionListDivClass === 'string' ? opt.descriptionListDivClass : ''
     if (divClass) {
       divOpen.attrs = [['class', divClass]]
@@ -397,6 +405,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,12 +423,14 @@ 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)
@@ -428,6 +439,7 @@ const convertListItemToDtDd = (tokens, itemStart, itemEnd, parentLevel, opt) =>
     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,6 +454,7 @@ 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
@@ -491,6 +504,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 +512,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 {

package/src/phase2-convert.js

@@ -23,8 +23,7 @@ export function convertLists(tokens, listInfos, opt) {
   if (!opt.unremoveUlNest) {
     const hasBulletLists = listInfos.some(info => info.originalType === 'bullet_list_open')
     if (hasBulletLists) {
-      const listInfoMap = buildListInfoMap(listInfos)
-      simplifyNestedBulletLists(tokens, opt, listInfoMap)
+      simplifyNestedBulletLists(tokens)
     }
   }
 }
@@ -143,11 +142,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) {
@@ -228,7 +227,7 @@ function simplifyNestedBulletLists(tokens, opt, listInfoMap = null) {
             const hasExtraContent = beforeContent > 0 || afterContent > 0
             const literalNumber = extractFirstListItemNumber(tokens, innerListOpen, innerListCloseIdx)
             
-            const innerListInfo = listInfoMap?.get(innerListOpen)
+            const innerListMarkerInfo = tokens[innerListOpen]?._markerInfo
             const isSimpleMarkerParagraph = (() => {
               const precedingCount = innerListOpen - (idx + 1)
               if (precedingCount !== 3) return false
@@ -249,7 +248,7 @@ function simplifyNestedBulletLists(tokens, opt, listInfoMap = null) {
               hasExtraContent: hasExtraContent,
               extraContentStart: innerListCloseIdx + 1,
               extraContentEnd: itemCloseIdx,
-              innerListInfo,
+              innerListMarkerInfo,
               literalNumber,
               flattenFirstParagraph: isSimpleMarkerParagraph
             })
@@ -262,9 +261,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
@@ -309,8 +310,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 +326,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')
@@ -371,7 +372,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'
@@ -430,7 +431,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 +459,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 +476,49 @@ 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 })
+        // 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 })
+              }
             }
-          }
-          
-          // 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
+            
+            // 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
+                  }
                 }
-              }
-              
-              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
           }
         }
         
@@ -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
@@ -775,7 +781,7 @@ function simplifyNestedBulletLists(tokens, opt, listInfoMap = null) {
                 item.innerListClose,
                 levelShift,
                 markerStartIndex,
-                item.innerListInfo
+                item.innerListMarkerInfo
               )
               for (const nestedToken of nestedTokens) {
                 newTokens.push(nestedToken)
@@ -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'
@@ -884,19 +890,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 +915,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]