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

package/src/phase1-analyze.js

@@ -3,109 +3,27 @@
 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))
- * @param {Array} tokens - Token array
- * @returns {Array<[number, number]>} DL range pairs [[start, end], ...]
- */
-function buildDLStateMap(tokens) {
-  const state = new Array(tokens.length).fill(false)
-  let dlDepth = 0
-  let htmlDdDepth = 0
-  
-  for (let i = 0; i < tokens.length; i++) {
-    const token = tokens[i]
-    
-    if (dlDepth > 0 || htmlDdDepth > 0) {
-      state[i] = true
-    }
-    
-    if (token.type === 'dl_open') {
-      state[i] = true
-      dlDepth++
-      continue
-    }
-    
-    if (token.type === 'dl_close') {
-      state[i] = true
-      if (dlDepth > 0) {
-        dlDepth--
-      }
-      continue
-    }
-    
-    if (token.type === 'html_block') {
-      if (token.content === '<dd>\n') {
-        state[i] = true
-        htmlDdDepth++
-        continue
-      }
-      if (token.content === '</dd>\n') {
-        state[i] = true
-        if (htmlDdDepth > 0) {
-          htmlDdDepth--
-        }
-        continue
-      }
-    }
-  }
-  
-  return state
-}
-
-/**
- * Check if token at specified index is inside DL
- * @param {number} index - Index to check
- * @param {Array<[number, number]>} dlRanges - DL range pairs
- * @returns {boolean} True if inside DL
- */
-function isInsideDL(index, dlState) {
-  if (!dlState || index < 0 || index >= dlState.length) {
-    return false
-  }
-  return dlState[index] === true
-}
-
 /**
  * Collect list information from token array
  * @param {Array} tokens - markdown-it token array
- * @param {Object} opt - Plugin options
  * @returns {Array} Flat array of list information (including nested lists)
  */
-export function analyzeListStructure(tokens, opt) {
+export function analyzeListStructure(tokens) {
   const listInfos = []
   const closeMap = buildListCloseIndexMap(tokens)
-  
-  // Check DL existence (O(n) but optimized with early return)
-  let hasDL = false
-  for (let i = 0; i < tokens.length; i++) {
-    if (tokens[i].type === 'dl_open' || 
-        (tokens[i].type === 'html_block' && tokens[i].content === '<dd>\n')) {
-      hasDL = true
-      break
-    }
-  }
-  
-  // Pre-compute DL scope flags (only when DL exists)
-  const dlScope = hasDL ? buildDLStateMap(tokens) : null
-  
-  // Process only top-level lists (nested lists collected recursively)
-  // Also process lists inside DL
+
+  // Process every list root in the token stream, including lists nested in
+  // containers such as blockquotes or description-list descriptions. Nested
+  // lists inside an already-analyzed list are collected recursively, then the
+  // scan jumps to that list's close token to avoid duplicate processing.
   for (let i = 0; i < tokens.length; i++) {
     const token = tokens[i]
     if (!token) {
       continue
     }
-    
-    // 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)
-    const isListInDD = (token.type === 'bullet_list_open' || token.type === 'ordered_list_open') && 
-                       token.level > 0 && 
-                       isInsideDL(i, dlScope)
-    
-    if (isTopLevelList || isListInDD) {
-      const listInfo = analyzeList(tokens, i, opt, closeMap)
+
+    if (token.type === 'bullet_list_open' || token.type === 'ordered_list_open') {
+      const listInfo = analyzeList(tokens, i, closeMap)
       if (listInfo) {
         listInfos.push(listInfo)
         
@@ -139,7 +57,7 @@ function collectNestedLists(listInfo, listInfos) {
 /**
  * Analyze detailed information of a single list
  */
-function analyzeList(tokens, startIndex, opt, closeMap) {
+function analyzeList(tokens, startIndex, closeMap) {
   const listToken = tokens[startIndex]
   const endIndex = findListEnd(tokens, startIndex, closeMap)
   
@@ -149,7 +67,7 @@ function analyzeList(tokens, startIndex, opt, closeMap) {
   
   const level = listToken.level || 0
   const originalType = listToken.type
-  const items = analyzeListItems(tokens, startIndex, endIndex, opt, closeMap)
+  const items = analyzeListItems(tokens, startIndex, endIndex, closeMap)
   const isLoose = detectLooseList(tokens, startIndex, endIndex, items)
   if (!isLoose) {
     hideFirstParagraphsForTightList(tokens, items, level)
@@ -159,7 +77,7 @@ function analyzeList(tokens, startIndex, opt, closeMap) {
   listToken._isLoose = isLoose
   
   // Extract marker info (for both bullet_list and ordered_list)
-  const markerInfo = extractMarkerInfo(tokens, startIndex, endIndex, opt)
+  const markerInfo = extractMarkerInfo(tokens, startIndex, endIndex)
   
   // Recheck marker consistency against item count
   if (markerInfo && markerInfo.count < items.length) {
@@ -170,7 +88,7 @@ function analyzeList(tokens, startIndex, opt, closeMap) {
   // Conversion decision (only consider for bullet_list)
   // Convert even loose lists if markers are consistent
   const shouldConvert = originalType === 'bullet_list_open' && 
-                        shouldConvertToOrdered(originalType, markerInfo, opt)
+                        shouldConvertToOrdered(originalType, markerInfo)
 
   if (markerInfo) {
     listToken._markerInfo = markerInfo
@@ -194,7 +112,7 @@ function analyzeList(tokens, startIndex, opt, closeMap) {
 /**
  * Analyze list items
  */
-function analyzeListItems(tokens, startIndex, endIndex, opt, closeMap) {
+function analyzeListItems(tokens, startIndex, endIndex, closeMap) {
   const items = []
   let i = startIndex + 1
   
@@ -203,7 +121,7 @@ function analyzeListItems(tokens, startIndex, endIndex, opt, closeMap) {
     
     if (token.type === 'list_item_open') {
       const itemEndIndex = findListItemEnd(tokens, i, closeMap)
-      const item = analyzeListItem(tokens, i, itemEndIndex, opt, closeMap)
+      const item = analyzeListItem(tokens, i, itemEndIndex, closeMap)
       items.push(item)
       i = itemEndIndex + 1
     } else {
@@ -217,11 +135,10 @@ function analyzeListItems(tokens, startIndex, endIndex, opt, closeMap) {
 /**
  * Analyze a single list item
  */
-function analyzeListItem(tokens, startIndex, endIndex, opt, closeMap) {
-  let content = ''
+function analyzeListItem(tokens, startIndex, endIndex, closeMap) {
   let markerInfo = null
   let hasNestedList = false
-  let nestedLists = []
+  const nestedLists = []
   let firstParagraphIsLoose = false
   let lastInlineContent = ''
   
@@ -259,7 +176,7 @@ function analyzeListItem(tokens, startIndex, endIndex, opt, closeMap) {
       }
       checkedFirstParagraphLoose = true
       hasNestedList = true
-      const nestedListInfo = analyzeList(tokens, i, opt, closeMap)
+      const nestedListInfo = analyzeList(tokens, i, closeMap)
       nestedLists.push(nestedListInfo)
       i = nestedListInfo.endIndex
     }
@@ -268,7 +185,6 @@ function analyzeListItem(tokens, startIndex, endIndex, opt, closeMap) {
   if (firstParagraphIsLoose && hasNestedList && lastInlineContent) {
     markerInfo = detectMarkerType(lastInlineContent)
   }
-  content = lastInlineContent
 
   if (tokens[startIndex]) {
     tokens[startIndex]._firstParagraphIsLoose = firstParagraphIsLoose
@@ -277,7 +193,7 @@ function analyzeListItem(tokens, startIndex, endIndex, opt, closeMap) {
   return {
     startIndex,
     endIndex,
-    content,
+    content: lastInlineContent,
     markerInfo,
     hasNestedList,
     nestedLists,
@@ -288,7 +204,7 @@ function analyzeListItem(tokens, startIndex, endIndex, opt, closeMap) {
 /**
  * Extract marker information
  */
-function extractMarkerInfo(tokens, startIndex, endIndex, opt) {
+function extractMarkerInfo(tokens, startIndex, endIndex) {
   const listToken = tokens[startIndex]
   const markers = []
   const literalMarkerInfo = listToken._literalMarkerInfo || null
@@ -349,35 +265,32 @@ function extractMarkerInfo(tokens, startIndex, endIndex, opt) {
     // Detect markers using full context
     let sequentialNumber = 1  // Sequential number counter
     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 = detectMarkerTypeWithContext(token.content, contextResult)
-        if (markerInfo && markerInfo.type) {
-          // Use sequential numbers when same marker continues
-          // (e.g., "イ. イ. イ." → interpreted as "イ、ロ、ハ")
-          const adjustedMarkerInfo = { ...markerInfo }
-          adjustedMarkerInfo.originalNumber = markerInfo.number
-          
-          // Assign sequential numbers based on first marker's number
-          if (markers.length === 0) {
-            // Use first marker as-is
-            sequentialNumber = markerInfo.number || 1
+      const markerInfo = detectMarkerTypeWithContext(token.content, contextResult)
+      if (markerInfo && markerInfo.type) {
+        // Use sequential numbers when same marker continues
+        // (e.g., "イ. イ. イ." → interpreted as "イ、ロ、ハ")
+        const adjustedMarkerInfo = { ...markerInfo }
+        adjustedMarkerInfo.originalNumber = markerInfo.number
+
+        // Assign sequential numbers based on first marker's number
+        if (markers.length === 0) {
+          // Use first marker as-is
+          sequentialNumber = markerInfo.number || 1
+        } else {
+          // For 2nd and later, use sequential number if same as previous marker
+          const prevMarker = markers[markers.length - 1]
+          if (markerInfo.marker === prevMarker.marker &&
+              markerInfo.type === prevMarker.type) {
+            // Assign sequential number when same marker continues
+            sequentialNumber++
+            adjustedMarkerInfo.number = sequentialNumber
           } else {
-            // For 2nd and later, use sequential number if same as previous marker
-            const prevMarker = markers[markers.length - 1]
-            if (markerInfo.marker === prevMarker.marker && 
-                markerInfo.type === prevMarker.type) {
-              // Assign sequential number when same marker continues
-              sequentialNumber++
-              adjustedMarkerInfo.number = sequentialNumber
-            } else {
-              // For different marker, use detected number
-              sequentialNumber = markerInfo.number || sequentialNumber + 1
-            }
+            // For different marker, use detected number
+            sequentialNumber = markerInfo.number || sequentialNumber + 1
           }
-          
-          markers.push(adjustedMarkerInfo)
         }
+
+        markers.push(adjustedMarkerInfo)
       }
     }
   }
@@ -411,7 +324,7 @@ function extractMarkerInfo(tokens, startIndex, endIndex, opt) {
 /**
  * Determine if should convert to ordered list
  */
-function shouldConvertToOrdered(originalType, markerInfo, opt) {
+function shouldConvertToOrdered(originalType, markerInfo) {
   // No conversion needed if already ordered_list
   if (originalType === 'ordered_list_open') {
     return false

package/src/phase2-convert.js

@@ -12,7 +12,11 @@ import { buildListCloseIndexMap, findMatchingClose } from './list-helpers.js'
 export function convertLists(tokens, listInfos, opt) {
   // Convert bullet_list to ordered_list
   // listInfos already collected in depth-first order in Phase 1, no sorting needed
+  let hasBulletLists = false
   for (const listInfo of listInfos) {
+    if (!hasBulletLists && listInfo.originalType === 'bullet_list_open') {
+      hasBulletLists = true
+    }
     if (listInfo.shouldConvert) {
       convertBulletToOrdered(tokens, listInfo)
     }
@@ -20,11 +24,8 @@ export function convertLists(tokens, listInfos, opt) {
   
   // In default mode (unremoveUlNest=false), simplify ul>li>ol structure
   // Runs after conversion, so already-converted ordered_lists are also processed
-  if (!opt.unremoveUlNest) {
-    const hasBulletLists = listInfos.some(info => info.originalType === 'bullet_list_open')
-    if (hasBulletLists && hasSimplifiableBulletStructure(tokens)) {
-      simplifyNestedBulletLists(tokens)
-    }
+  if (!opt.unremoveUlNest && hasBulletLists && hasSimplifiableBulletStructure(tokens)) {
+    simplifyNestedBulletLists(tokens)
   }
 }
 
@@ -44,6 +45,26 @@ function hasSimplifiableBulletStructure(tokens) {
   return false
 }
 
+function resolveListClose(tokens, openIdx, listCloseByOpen = null) {
+  const mapped = listCloseByOpen ? listCloseByOpen[openIdx] : -1
+  if (typeof mapped === 'number' && mapped !== -1) {
+    return mapped
+  }
+  const openType = tokens[openIdx]?.type
+  if (!openType) {
+    return -1
+  }
+  return findMatchingClose(tokens, openIdx, openType, openType.replace('_open', '_close'))
+}
+
+function resolveListItemClose(tokens, openIdx, listItemCloseByOpen = null) {
+  const mapped = listItemCloseByOpen ? listItemCloseByOpen[openIdx] : -1
+  if (typeof mapped === 'number' && mapped !== -1) {
+    return mapped
+  }
+  return findMatchingClose(tokens, openIdx, 'list_item_open', 'list_item_close')
+}
+
 /**
  * Convert bullet_list to ordered_list
  */
@@ -138,22 +159,17 @@ function removeMarkersFromContent(tokens, startIndex, endIndex, markerInfo) {
     if (token.type === 'inline' && token.content && token.level === targetLevel) {
       const marker = markers[markerIndex]
       if (marker && marker.marker && token.content.startsWith(marker.marker)) {
-        let newContent = token.content.slice(marker.marker.length)
-        newContent = newContent.replace(LEADING_SPACE_REGEX, '')
-        token.content = newContent
+        token.content = token.content.slice(marker.marker.length).trimStart()
         markerIndex++
       }
     }
   }
 }
 
-const LEADING_SPACE_REGEX = /^\s+/
-
 /**
- * Simplify nested ul>li>ul and ul>li>ol structures.
+ * Simplify nested ul>li>ol structures.
  *
- * Pattern 1: bullet_list_open → list_item_open → bullet_list_open → ...
- * Pattern 2: bullet_list_open → list_item_open → ordered_list_open → ... (repeated)
+ * Pattern: bullet_list_open → list_item_open → ordered_list_open → ... (repeated)
  *
  * When the middle list_item is empty (contains only the inner list),
  * remove the outer ul and the intermediate li.
@@ -168,24 +184,6 @@ function simplifyNestedBulletLists(tokens) {
   while (modified) {
     modified = false
     const { listCloseByOpen, listItemCloseByOpen } = buildListCloseIndexMap(tokens)
-    const getListClose = (openIdx) => {
-      const mapped = listCloseByOpen[openIdx]
-      if (typeof mapped === 'number' && mapped !== -1) {
-        return mapped
-      }
-      const openType = tokens[openIdx]?.type
-      if (!openType) {
-        return -1
-      }
-      return findMatchingClose(tokens, openIdx, openType, openType.replace('_open', '_close'))
-    }
-    const getListItemClose = (openIdx) => {
-      const mapped = listItemCloseByOpen[openIdx]
-      if (typeof mapped === 'number' && mapped !== -1) {
-        return mapped
-      }
-      return findMatchingClose(tokens, openIdx, 'list_item_open', 'list_item_close')
-    }
     
     for (let i = 0; i < tokens.length; i++) {
       const token = tokens[i]
@@ -196,7 +194,7 @@ function simplifyNestedBulletLists(tokens) {
       }
           
       // Check if this bullet_list is all ul>li>ol/ul pattern
-      const listCloseIdx = getListClose(i)
+      const listCloseIdx = resolveListClose(tokens, i, listCloseByOpen)
       if (listCloseIdx === -1) continue
 
       // Fast reject: flattening requires the first list item to start with ordered_list_open.
@@ -215,7 +213,7 @@ function simplifyNestedBulletLists(tokens) {
       
       while (idx < listCloseIdx) {
         if (tokens[idx].type === 'list_item_open') {
-          const itemCloseIdx = getListItemClose(idx)
+	          const itemCloseIdx = resolveListItemClose(tokens, idx, listItemCloseByOpen)
           if (itemCloseIdx === -1) {
             allItemsHaveDirectInnerList = false
             break
@@ -229,7 +227,7 @@ function simplifyNestedBulletLists(tokens) {
           for (let j = idx + 1; j < itemCloseIdx; j++) {
             if (tokens[j].type === 'bullet_list_open' || tokens[j].type === 'ordered_list_open') {
               const candidateType = tokens[j].type
-              const candidateClose = getListClose(j)
+	              const candidateClose = resolveListClose(tokens, j, listCloseByOpen)
               if (tokens[j]._literalList) {
                 if (candidateClose === -1) {
                   break
@@ -250,8 +248,8 @@ function simplifyNestedBulletLists(tokens) {
             break
           }
 
-          if (innerListCloseIdx === -1) {
-            innerListCloseIdx = getListClose(innerListOpen)
+	          if (innerListCloseIdx === -1) {
+	            innerListCloseIdx = resolveListClose(tokens, innerListOpen, listCloseByOpen)
           }
           if (innerListCloseIdx === -1) {
             allItemsHaveDirectInnerList = false
@@ -259,22 +257,16 @@ function simplifyNestedBulletLists(tokens) {
           }
           
           // Check if there's extra content before/after ol (whether it's only ol)
-          const beforeContent = innerListOpen - (idx + 1)  // Token count from after list_item_open to ol
           const afterContent = itemCloseIdx - (innerListCloseIdx + 1)  // Token count from after ol to list_item_close
-          const hasExtraContent = beforeContent > 0 || afterContent > 0
+          const hasExtraContent = afterContent > 0
           const literalNumber = extractFirstListItemNumber(tokens, innerListOpen, innerListCloseIdx)
           
           const innerListMarkerInfo = tokens[innerListOpen]?._markerInfo
-          const isSimpleMarkerParagraph = (() => {
-            const precedingCount = innerListOpen - (idx + 1)
-            if (precedingCount !== 3) return false
-            const paraOpen = tokens[idx + 1]
-            const inlineToken = tokens[idx + 2]
-            const paraClose = tokens[idx + 3]
-            return paraOpen?.type === 'paragraph_open' &&
-              inlineToken?.type === 'inline' &&
-              paraClose?.type === 'paragraph_close'
-          })()
+          const isSimpleMarkerParagraph =
+            innerListOpen - (idx + 1) === 3 &&
+            tokens[idx + 1]?.type === 'paragraph_open' &&
+            tokens[idx + 2]?.type === 'inline' &&
+            tokens[idx + 3]?.type === 'paragraph_close'
 
           itemIndices.push({
             outerItemOpen: idx,
@@ -687,10 +679,8 @@ function simplifyNestedBulletLists(tokens) {
                   if (shouldPropagateLooseToChildren) {
                     // Set _parentIsLoose flag (optimize with direct property assignment)
                     tokenToPush._parentIsLoose = true
-                    replacementTokens.push(tokenToPush)
-                  } else {
-                    replacementTokens.push(tokenToPush)
                   }
+                  replacementTokens.push(tokenToPush)
               } else if (tokenToPush.type === 'bullet_list_close' || tokenToPush.type === 'ordered_list_close') {
                 nestedListDepth--
                 replacementTokens.push(tokenToPush)
@@ -833,37 +823,31 @@ function simplifyNestedBulletLists(tokens) {
   // ===== Propagate ordered_list's _parentIsLoose flag to child lists =====
   // Check all ordered_list_open, and if _parentIsLoose flag exists,
   // propagate to child lists
-  const postCloseMap = buildListCloseIndexMap(tokens)
-  const getPostListClose = (openIdx) => {
-    const mapped = postCloseMap.listCloseByOpen[openIdx]
-    if (typeof mapped === 'number' && mapped !== -1) {
-      return mapped
-    }
-    const openType = tokens[openIdx]?.type
-    if (!openType) {
-      return -1
+  let hasParentLooseList = false
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i]
+    if ((token.type === 'ordered_list_open' || token.type === 'bullet_list_open') && token._parentIsLoose) {
+      hasParentLooseList = true
+      break
     }
-    return findMatchingClose(tokens, openIdx, openType, openType.replace('_open', '_close'))
   }
-  const getPostListItemClose = (openIdx) => {
-    const mapped = postCloseMap.listItemCloseByOpen[openIdx]
-    if (typeof mapped === 'number' && mapped !== -1) {
-      return mapped
-    }
-    return findMatchingClose(tokens, openIdx, 'list_item_open', 'list_item_close')
+  if (!hasParentLooseList) {
+    return
   }
+
+  const postCloseMap = buildListCloseIndexMap(tokens)
   for (let i = 0; i < tokens.length; i++) {
     const token = tokens[i]
     
     if ((token.type === 'ordered_list_open' || token.type === 'bullet_list_open') && token._parentIsLoose) {
       // Find this list's close token
-      const listCloseIdx = getPostListClose(i)
+      const listCloseIdx = resolveListClose(tokens, i, postCloseMap.listCloseByOpen)
       if (listCloseIdx === -1) continue
       
       // Search list_items in this list and set _parentIsLoose flag to child lists in those list_items
       for (let j = i + 1; j < listCloseIdx; j++) {
         if (tokens[j].type === 'list_item_open' && tokens[j].level === token.level + 1) {
-          const itemCloseIdx = getPostListItemClose(j)
+          const itemCloseIdx = resolveListItemClose(tokens, j, postCloseMap.listItemCloseByOpen)
           
           // Search child lists in this list_item
           for (let k = j + 1; k < itemCloseIdx; k++) {

package/src/phase3-attributes.js

@@ -4,6 +4,8 @@
 import { getTypeAttributes } from './types-utility.js'
 import { buildListCloseIndexMap, findMatchingClose } from './list-helpers.js'
 
+const WHITESPACE_SUFFIX_REGEX = /^[ \u3000]+$/
+
 /**
  * Add attributes to lists
  * @param {Array} tokens - Token array
@@ -35,6 +37,8 @@ export function addAttributes(tokens, opt) {
   if (hasAnyListItemValue) {
     normalizeAndConvertValueAttributes(tokens, listCloseByOpen)
   }
+
+  return closeMap
 }
 
 function hasValueAttr(token) {
@@ -53,15 +57,14 @@ function hasValueAttr(token) {
  * Add attributes to a single list token
  */
 function addListAttributesForToken(tokens, token, tokenIndex, opt, listCloseByOpen = null) {
-  // Initialize attribute array
-  if (!token.attrs) {
-    token.attrs = []
-  }
-  
   // Get marker info
   const markerInfo = token._markerInfo
   
   if (!markerInfo) {
+    if (!token.attrs) {
+      token.attrs = []
+    }
+
     // Default attributes for lists without markerInfo
     if (opt.useCounterStyle) {
       // Do not add type attribute; add class so user CSS/@counter-style can target
@@ -83,7 +86,7 @@ function addListAttributesForToken(tokens, token, tokenIndex, opt, listCloseByOp
   
   // Attributes according to marker type
   // Pass first marker's prefix/suffix info to determine class name
-  const firstMarker = markerInfo.markers[0]
+  const firstMarker = markerInfo.markers?.[0]
   const typeAttrs = getTypeAttributes(markerInfo.type, firstMarker, opt)
   
   // Reset attribute array
@@ -112,35 +115,23 @@ function addListAttributesForToken(tokens, token, tokenIndex, opt, listCloseByOp
   } else {
     startOverride = undefined
   }
-  const firstNumber = startOverride ?? (markerInfo.markers[0]?.originalNumber ?? markerInfo.markers[0]?.number)
+  const firstNumber = startOverride ?? (firstMarker?.originalNumber ?? firstMarker?.number)
   if (firstNumber !== undefined && firstNumber !== 1) {
     addAttr(token, 'start', String(firstNumber))
-  } else if (token.attrs) {
-    const startIdx = token.attrs.findIndex(attr => attr[0] === 'start')
-    if (startIdx >= 0) {
-      token.attrs.splice(startIdx, 1)
-      if (token.attrs.length === 0) token.attrs = null
-    }
   }
   
   // 3. Add class attribute
   if (typeAttrs.class) {
-    // Merge or add class; preserve existing classes and append
-    const existing = token.attrs.find(a => a[0] === 'class')
-    if (existing) {
-      existing[1] = (existing[1] + ' ' + typeAttrs.class).trim()
-    } else {
-      addAttr(token, 'class', typeAttrs.class)
-    }
+    addAttr(token, 'class', typeAttrs.class)
   }
   // 4. data-marker-prefix/suffix
   if (!opt.omitMarkerMetadata) {
-    if (markerInfo.markers[0].prefix) {
-      addAttr(token, 'data-marker-prefix', markerInfo.markers[0].prefix)
+    if (firstMarker?.prefix) {
+      addAttr(token, 'data-marker-prefix', firstMarker.prefix)
     }
     // Do not emit data-marker-suffix when suffix is only whitespace (halfwidth or fullwidth)
-    const suffix = markerInfo.markers[0].suffix
-    if (suffix && !/^[ \u3000]+$/.test(suffix)) {
+    const suffix = firstMarker?.suffix
+    if (suffix && !WHITESPACE_SUFFIX_REGEX.test(suffix)) {
       addAttr(token, 'data-marker-suffix', suffix)
     }
   }
@@ -263,10 +254,11 @@ function normalizeAndConvertValueAttributes(tokens, listCloseByOpen = null) {
  * Add or replace an attribute on a token (with duplicate check).
  */
 function addAttr(token, name, value) {
-  const existingIndex = token.attrs.findIndex(attr => attr[0] === name)
-  if (existingIndex >= 0) {
-    token.attrs[existingIndex] = [name, value]
-  } else {
-    token.attrs.push([name, value])
+  for (let i = 0; i < token.attrs.length; i++) {
+    if (token.attrs[i][0] === name) {
+      token.attrs[i] = [name, value]
+      return
+    }
   }
+  token.attrs.push([name, value])
 }