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

package/README.md

@@ -71,6 +71,7 @@ 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.
+- With `markdown-it-attrs`, attr blocks follow that plugin's nearest-block behavior. This plugin does not reassign list attrs after flattening.
 
 ### Source map behavior
 
@@ -90,14 +91,22 @@ You can customize the conversion using options.
 - `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).
+  - Compatibility note: switching the default from `false` to `true` changes rendered HTML by design. On the current test corpus (`394` markdown cases), `18` cases change.
+  - Changed files in that comparison: `examples-default-14-repeated-numbers.txt` (`7`), `examples-option-literal-numbering-attrs.txt` (`1`), `examples-option-literal-numbering-fix-disabled.txt` (`2`), `examples-option-literal-numbering-fix.txt` (`3`), `examples-option-literal-numbering-indent.txt` (`4`).
+  - Recommendation: keep the default as `false` for patch/minor releases; if changing the default to `true`, treat it as a breaking change and release a major version.
 
 ## Description lists conversion behavior
 
-When the `descriptionList` option is enabled the plugin converts specially formatted bullet lists into HTML description lists (`<dl>`).
+When `descriptionList` or `descriptionListWithDiv` is enabled, the plugin converts specially formatted bullet lists into HTML description lists (`<dl>`).
 
 - Each list item must start with a `**Term**` line.
+  - The `**Term**` line must be the first direct block inside that list item (term-like text inside nested sub-lists does not trigger conversion).
   - 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).
+  - Same-line descriptions such as `- **Term** Description` are not converted.
+  - Same-line backslash forms such as `- **Term**\ Description` are also not converted (the hard break marker must be followed by an actual newline).
+  - Term-line attrs can be written in multiple adjacent blocks (`**Term** {.a} {#id} {data-x=1}`) and are merged onto `<dt>`.
+  - Attr-like braces are kept as description text only when your plugin chain does not parse them as attributes. With `markdown-it-attrs`, forms like `{foo}` may be treated as boolean attributes.
 
 In the conversion the `**Term**` line becomes a `<dt>` and the subsequent lines become the corresponding `<dd>`.
 
@@ -106,7 +115,7 @@ Note: Text descriptions are wrapped in `<p>` elements; additional paragraphs and
 ### Description list options
 
 - `descriptionList` (boolean) — Enable conversion of `**Term**` list patterns into `<dl>` description lists.
-- `descriptionListWithDiv` (boolean) — Wrap `<dt>/<dd>` pairs in a `<div>` when enabled.
+- `descriptionListWithDiv` (boolean) — Wrap `<dt>/<dd>` pairs in a `<div>` when enabled. This option also enables description-list conversion even when `descriptionList` is `false`.
 - `descriptionListDivClass` (string) — Class applied to the wrapper `<div>` when `descriptionListWithDiv` is enabled (empty string disables the class).
 
 ## Examples: Ordered Lists

package/index.js

@@ -5,7 +5,6 @@ import { convertLists } from './src/phase2-convert.js'
 import { addAttributes } from './src/phase3-attributes.js'
 import { processHtmlBlocks } from './src/phase4-html-blocks.js'
 import { generateSpans } from './src/phase5-spans.js'
-import { moveNestedListAttributes } from './src/phase6-attrs-migration.js'
 import { normalizeLiteralOrderedLists } from './src/preprocess-literal-lists.js'
 
 const mditNumberingUl = (md, option) => {
@@ -73,7 +72,17 @@ const mditNumberingUl = (md, option) => {
     
     // ===== PHASE 4: HTML Block Processing =====
     // Remove indents from HTML blocks in lists and normalize line breaks
-    processHtmlBlocks(state)
+    let hasNestedHtmlBlock = false
+    for (let i = 0; i < tokens.length; i++) {
+      const token = tokens[i]
+      if (token.type === 'html_block' && token.level > 0) {
+        hasNestedHtmlBlock = true
+        break
+      }
+    }
+    if (hasNestedHtmlBlock) {
+      processHtmlBlocks(state)
+    }
     
     // ===== PHASE 5: Span Generation =====
     // Generate marker spans in alwaysMarkerSpan mode
@@ -85,16 +94,6 @@ const mditNumberingUl = (md, option) => {
   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
-    const nestedListAttrProcessor = (state) => {
-      moveNestedListAttributes(state.tokens)
-      return true
-    }
-    
-    addRuleAfter(md.core.ruler, 'curly_attributes', 'numbering_ul_nested_attrs', nestedListAttrProcessor)
-  }
-  
   // Description list: Move paragraph attributes to dl and add custom renderers
   if (opt.descriptionList || opt.descriptionListWithDiv) {
     // Move paragraph attributes to dl (after inline and any attribute plugins)

package/package.json

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

package/src/phase0-description-list.js

@@ -8,34 +8,141 @@ 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
@@ -47,7 +154,6 @@ const copyMap = (target, source) => {
  * 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) {
@@ -61,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++
     }
@@ -108,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
  */
@@ -137,59 +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 (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
-            }
-          }
-          
-          // 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 }
     }
   }
   
@@ -217,14 +336,11 @@ const isDLPattern = (content) => {
   
   const afterStrong = match[2]  // Text after closing **
   
-  // Pattern 1: **Term**  description (2+ spaces, including newlines)
-  // 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) || 
-                  /^\\/.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 }
 }
@@ -319,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 }
   
@@ -345,21 +457,15 @@ const convertListItemToDtDd = (tokens, itemStart, itemEnd, parentLevel, opt) =>
     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}")
@@ -372,9 +478,9 @@ 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/backslash, then trim each line
@@ -394,7 +500,9 @@ const convertListItemToDtDd = (tokens, itemStart, itemEnd, parentLevel, opt) =>
     divOpen.level = parentLevel + 1
     divOpen.block = true
     copyMap(divOpen, tokens[firstPara])
-    const divClass = typeof opt.descriptionListDivClass === 'string' ? opt.descriptionListDivClass : ''
+    const divClass = typeof opt.descriptionListDivClass === 'string'
+      ? opt.descriptionListDivClass.trim()
+      : ''
     if (divClass) {
       divOpen.attrs = [['class', divClass]]
     }
@@ -434,7 +542,6 @@ const convertListItemToDtDd = (tokens, itemStart, itemEnd, parentLevel, opt) =>
   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
@@ -457,7 +564,6 @@ const convertListItemToDtDd = (tokens, itemStart, itemEnd, parentLevel, opt) =>
     copyMap(pClose, tokens[firstPara])
     result.push(pClose)
     
-    hasFirstParagraph = true
   }
   
   // Add remaining content in dd (paragraphs, lists, etc.)
@@ -467,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