react-native-enriched-markdown-scaffold 0.7.4-scaffold.9 → 1.0.2-scaffold.2

package/android/src/main/java/com/swmansion/enriched/markdown/input/styles/HeadingBlockHandler.kt

@@ -0,0 +1,27 @@
+package com.swmansion.enriched.markdown.input.styles
+
+import com.swmansion.enriched.markdown.input.model.BlockRange
+import com.swmansion.enriched.markdown.input.model.BlockType
+import com.swmansion.enriched.markdown.input.model.InputFormatterStyle
+import com.swmansion.enriched.markdown.input.spans.InputHeadingSpan
+
+/**
+ * Block handler for ATX headings (H1-H6). A single instance serves all six levels:
+ * it reads the H-level from each [BlockRange.level], so it is registered in the
+ * [com.swmansion.enriched.markdown.input.formatting.InputFormatter] under every
+ * `HEADING_n` key. The level — not [blockType] — drives styling and serialization,
+ * so [blockType] is only a nominal interface value and never consulted by the
+ * formatter (it dispatches on `range.type`).
+ */
+class HeadingBlockHandler : BlockHandler {
+  override val blockType: BlockType = BlockType.HEADING_1
+
+  override fun createSpans(
+    blockRange: BlockRange,
+    style: InputFormatterStyle,
+  ): List<Any> = listOf(InputHeadingSpan(blockRange.level, style))
+
+  override fun spanClasses(): List<Class<*>> = listOf(InputHeadingSpan::class.java)
+
+  override fun markdownLinePrefix(blockRange: BlockRange): String = "#".repeat(blockRange.level.coerceIn(1, 6)) + " "
+}

package/android/src/main/java/com/swmansion/enriched/markdown/input/styles/OrderedListBlockHandler.kt

@@ -0,0 +1,38 @@
+package com.swmansion.enriched.markdown.input.styles
+
+import com.swmansion.enriched.markdown.input.model.BlockRange
+import com.swmansion.enriched.markdown.input.model.BlockType
+import com.swmansion.enriched.markdown.input.model.InputFormatterStyle
+import com.swmansion.enriched.markdown.input.spans.InputListItemSpacingSpan
+import com.swmansion.enriched.markdown.input.spans.InputOrderedListMarkerSpan
+
+/**
+ * Block handler for ordered list items. One instance serves every nesting depth —
+ * the 0-based depth rides in [BlockRange.level] and the displayed number in
+ * [BlockRange.ordinal], both maintained by the block store.
+ */
+class OrderedListBlockHandler(
+  private val density: Float,
+) : BlockHandler {
+  override val blockType: BlockType = BlockType.ORDERED_LIST_ITEM
+
+  override val continuesOnNewline: Boolean = true
+
+  override fun createSpans(
+    blockRange: BlockRange,
+    style: InputFormatterStyle,
+  ): List<Any> {
+    val spans = mutableListOf<Any>(InputOrderedListMarkerSpan(blockRange.level, blockRange.ordinal, density))
+    val spacingPx = (style.listItemSpacing * density).toInt()
+    if (spacingPx > 0) {
+      spans.add(InputListItemSpacingSpan(spacingPx))
+    }
+    return spans
+  }
+
+  override fun spanClasses(): List<Class<*>> = listOf(InputOrderedListMarkerSpan::class.java, InputListItemSpacingSpan::class.java)
+
+  /** `"1. "` numbering from the range's ordinal, indented three spaces per nesting depth. */
+  override fun markdownLinePrefix(blockRange: BlockRange): String =
+    "   ".repeat(blockRange.level.coerceAtLeast(0)) + "${blockRange.ordinal}. "
+}

package/android/src/main/java/com/swmansion/enriched/markdown/input/styles/UnorderedListBlockHandler.kt

@@ -0,0 +1,37 @@
+package com.swmansion.enriched.markdown.input.styles
+
+import com.swmansion.enriched.markdown.input.model.BlockRange
+import com.swmansion.enriched.markdown.input.model.BlockType
+import com.swmansion.enriched.markdown.input.model.InputFormatterStyle
+import com.swmansion.enriched.markdown.input.spans.InputBulletSpan
+import com.swmansion.enriched.markdown.input.spans.InputListItemSpacingSpan
+
+/**
+ * Block handler for unordered (bullet) list items. One instance serves every
+ * nesting depth — the 0-based depth rides in [BlockRange.level] and drives the
+ * indent, marker glyph, and serialized indentation.
+ */
+class UnorderedListBlockHandler(
+  private val density: Float,
+) : BlockHandler {
+  override val blockType: BlockType = BlockType.UNORDERED_LIST_ITEM
+
+  override val continuesOnNewline: Boolean = true
+
+  override fun createSpans(
+    blockRange: BlockRange,
+    style: InputFormatterStyle,
+  ): List<Any> {
+    val spans = mutableListOf<Any>(InputBulletSpan(blockRange.level, density))
+    val spacingPx = (style.listItemSpacing * density).toInt()
+    if (spacingPx > 0) {
+      spans.add(InputListItemSpacingSpan(spacingPx))
+    }
+    return spans
+  }
+
+  override fun spanClasses(): List<Class<*>> = listOf(InputBulletSpan::class.java, InputListItemSpacingSpan::class.java)
+
+  /** `"- "` for a top-level item, indented three spaces per nesting depth (wide enough for ordered markers). */
+  override fun markdownLinePrefix(blockRange: BlockRange): String = "   ".repeat(blockRange.level.coerceAtLeast(0)) + "- "
+}

package/android/src/main/java/com/swmansion/enriched/markdown/input/toolbar/InputContextMenu.kt

@@ -10,8 +10,8 @@ import android.view.MenuItem
 import android.widget.EditText
 import androidx.appcompat.app.AlertDialog
 import com.swmansion.enriched.markdown.input.EnrichedMarkdownTextInputView
+import com.swmansion.enriched.markdown.input.MarkdownClipboard
 import com.swmansion.enriched.markdown.input.formatting.MarkdownSerializer
-import com.swmansion.enriched.markdown.input.model.FormattingRange
 import com.swmansion.enriched.markdown.input.model.StyleType
 
 data class InputSelectionMenuConfig(
@@ -112,7 +112,9 @@ class InputContextMenu(
           if (customIndex in customItemTexts.indices) {
             val start = view.selectionStart
             val end = view.selectionEnd
-            val selectedText = if (start < end) view.text?.substring(start, end) ?: "" else ""
+            // Strip the internal ZWSP anchor so it never reaches JS (a selection can
+            // span an empty anchored list line).
+            val selectedText = if (start < end) MarkdownSerializer.stripZwsp(view.text?.substring(start, end) ?: "") else ""
             view.eventEmitter.emitContextMenuItemPress(customItemTexts[customIndex], selectedText, start, end)
             mode.finish()
             return true
@@ -171,32 +173,12 @@ class InputContextMenu(
       .show()
   }
 
-  private fun markdownForSelectedRange(): String? {
-    val selStart = view.selectionStart
-    val selEnd = view.selectionEnd
-    if (selStart >= selEnd) return null
-
-    val editable = view.text ?: return null
-    val selected = editable.subSequence(selStart, selEnd) as? android.text.Spanned ?: return null
-
-    val clippedRanges = mutableListOf<FormattingRange>()
-    for (range in view.formattingStore.allRanges) {
-      if (range.end <= selStart || range.start >= selEnd) continue
-
-      val clippedStart = maxOf(range.start, selStart)
-      val clippedEnd = minOf(range.end, selEnd)
-      clippedRanges.add(
-        FormattingRange(range.type, clippedStart - selStart, clippedEnd - selStart, range.url),
-      )
-    }
-
-    return MarkdownSerializer.serialize(selected, clippedRanges, view.mathChipController)
-  }
-
+  // Explicit "Copy as Markdown": the user asked for markdown syntax, so it is
+  // also the plain-text representation external targets receive.
   fun copyAsMarkdown() {
-    val markdown = markdownForSelectedRange() ?: return
+    val markdown = view.markdownForSelectedRange() ?: return
     val clipboard = view.context.getSystemService(Context.CLIPBOARD_SERVICE) as? ClipboardManager ?: return
-    clipboard.setPrimaryClip(ClipData.newPlainText("Markdown", markdown))
+    clipboard.setPrimaryClip(MarkdownClipboard.newMarkdownClip(markdown, markdown))
   }
 
   companion object {

package/android/src/main/java/com/swmansion/enriched/markdown/parser/MarkdownASTNode.kt

@@ -37,6 +37,7 @@ data class MarkdownASTNode(
     Superscript,
     Subscript,
     Highlight,
+    SoftBreak,
   }
 
   fun getAttribute(key: String): String? = attributes[key]

package/android/src/main/java/com/swmansion/enriched/markdown/parser/Parser.kt

@@ -10,6 +10,7 @@ data class Md4cFlags(
   val subscript: Boolean = false,
   val highlight: Boolean = false,
   val permissiveAutolinks: Boolean = true,
+  val hardSoftBreaks: Boolean = false,
 ) {
   companion object {
     val DEFAULT = Md4cFlags()

package/android/src/main/java/com/swmansion/enriched/markdown/renderer/BlockStyleContext.kt

@@ -42,6 +42,9 @@ class BlockStyleContext {
   var listType: ListType? = null
   var listItemNumber = 0
   var taskItemCount = 0
+  var accumulatedIndent = 0
+
+  val listItemStarts = mutableListOf<Int>()
 
   private val orderedListItemNumbers = ArrayDeque<Int>()
 
@@ -106,8 +109,10 @@ class BlockStyleContext {
     listItemNumber++
   }
 
-  fun resetListItemNumber() {
-    listItemNumber = 0
+  fun resetListItemNumber(startNumber: Int = 1) {
+    // ListItemRenderer pre-increments, so the counter starts one below the
+    // first rendered number.
+    listItemNumber = startNumber - 1
   }
 
   fun pushOrderedListItemNumber() {
@@ -147,6 +152,8 @@ class BlockStyleContext {
     listType = null
     listItemNumber = 0
     taskItemCount = 0
+    accumulatedIndent = 0
+    listItemStarts.clear()
     orderedListItemNumbers.clear()
   }
 }

package/android/src/main/java/com/swmansion/enriched/markdown/renderer/BlockquoteRenderer.kt

@@ -1,13 +1,16 @@
 package com.swmansion.enriched.markdown.renderer
 
+import android.graphics.Paint
 import android.text.SpannableStringBuilder
+import android.text.Spanned
+import android.text.style.LineHeightSpan
 import com.swmansion.enriched.markdown.parser.MarkdownASTNode
 import com.swmansion.enriched.markdown.spans.BlockquoteSpan
 import com.swmansion.enriched.markdown.utils.text.span.SPAN_FLAGS_CONTAINER_BACKGROUND
 import com.swmansion.enriched.markdown.utils.text.span.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
+import com.swmansion.enriched.markdown.utils.text.span.applyLineHeightSkippingImages
 import com.swmansion.enriched.markdown.utils.text.span.applyMarginBottom
 import com.swmansion.enriched.markdown.utils.text.span.applyMarginTop
-import com.swmansion.enriched.markdown.utils.text.span.createLineHeightSpan
 
 class BlockquoteRenderer(
   private val config: RendererConfig,
@@ -19,6 +22,10 @@ class BlockquoteRenderer(
     onLinkLongPress: ((String) -> Unit)?,
     factory: RendererFactory,
   ) {
+    if (builder.isNotEmpty() && builder.last() != '\n') {
+      builder.append("\n")
+    }
+
     val start = builder.length
     val style = config.style.blockquoteStyle
     val context = factory.blockStyleContext
@@ -36,19 +43,31 @@ class BlockquoteRenderer(
     }
 
     if (builder.length == start) return
-    val end = builder.length
+    var end = builder.length
+    val padding = style.padding.toInt()
+
+    var contentStart = start
+    if (padding > 0) {
+      builder.insert(start, "\n")
+      builder.setSpan(
+        BlockquotePaddingSpacerSpan(padding),
+        start,
+        start + 1,
+        SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+      )
+      contentStart = start + 1
+      end += 1
+    }
 
     // Find immediately nested quotes to exclude them from this level's line-height/margins
     val nestedRanges =
       builder
-        .getSpans(start, end, BlockquoteSpan::class.java)
+        .getSpans(contentStart, end, BlockquoteSpan::class.java)
         .filter { it.depth == depth + 1 }
         .map { builder.getSpanStart(it) to builder.getSpanEnd(it) }
         .sortedBy { it.first }
 
-    // The accent bar span covers the full range for visual continuity.
-    // SPAN_FLAGS_CONTAINER_BACKGROUND keeps the blockquote fill under any
-    // inline chip/pill backgrounds on the same line.
+    // The accent bar / background span covers the full box, incl. the top spacer.
     builder.setSpan(
       BlockquoteSpan(style, depth, factory.context, factory.styleCache),
       start,
@@ -56,8 +75,16 @@ class BlockquoteRenderer(
       SPAN_FLAGS_CONTAINER_BACKGROUND,
     )
 
-    // Apply styling only to segments that are NOT nested quotes
-    applySpansExcludingNested(builder, nestedRanges, start, end, createLineHeightSpan(style.lineHeight))
+    applyLineHeightExcludingNested(builder, nestedRanges, contentStart, end, style.lineHeight)
+
+    if (padding > 0) {
+      builder.setSpan(
+        BlockquoteBoundaryPaddingSpan(padding),
+        contentStart,
+        end,
+        SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+      )
+    }
 
     // Margins are only applied by the outermost (root) quote
     if (depth == 0) {
@@ -66,22 +93,83 @@ class BlockquoteRenderer(
     }
   }
 
-  private fun applySpansExcludingNested(
+  /**
+   * A blockquote's top padding, rendered as a standalone spacer line of exactly
+   * [padding] px.
+   *
+   * Top padding cannot be added by growing the first content line's ascent:
+   * StaticLayout reuses one FontMetricsInt across a paragraph's soft-wrapped lines,
+   * so the inflated first-line metrics leak into the wrapped continuation line, where
+   * the line-height clamp then skews them into overlapping baselines. A spacer sits in
+   * its own paragraph, and setting absolute metrics keeps it fixed regardless of that
+   * reuse.
+   */
+  private class BlockquotePaddingSpacerSpan(
+    private val padding: Int,
+  ) : LineHeightSpan {
+    override fun chooseHeight(
+      text: CharSequence,
+      startLine: Int,
+      endLine: Int,
+      spanstartv: Int,
+      v: Int,
+      fm: Paint.FontMetricsInt,
+    ) {
+      fm.top = 0
+      fm.ascent = 0
+      fm.descent = padding
+      fm.bottom = padding
+    }
+  }
+
+  /**
+   * A blockquote's bottom padding, grown onto the last content line's descent (safe
+   * because no later line inherits its metrics; top padding uses
+   * [BlockquotePaddingSpacerSpan]).
+   *
+   * The span range can include trailing '\n'(s) that form no visible line, so the last
+   * drawn line ends before getSpanEnd; the comparison uses the visible content end.
+   */
+  private class BlockquoteBoundaryPaddingSpan(
+    private val padding: Int,
+  ) : LineHeightSpan {
+    override fun chooseHeight(
+      text: CharSequence,
+      startLine: Int,
+      endLine: Int,
+      spanstartv: Int,
+      v: Int,
+      fm: Paint.FontMetricsInt,
+    ) {
+      if (text !is Spanned) return
+
+      var contentEnd = text.getSpanEnd(this)
+      while (contentEnd > 0 && text[contentEnd - 1] == '\n') {
+        contentEnd--
+      }
+      if (endLine >= contentEnd) {
+        fm.descent += padding
+        fm.bottom += padding
+      }
+    }
+  }
+
+  private fun applyLineHeightExcludingNested(
     builder: SpannableStringBuilder,
     nestedRanges: List<Pair<Int, Int>>,
     start: Int,
     end: Int,
-    span: Any,
+    lineHeight: Float,
   ) {
     var currentPos = start
     for ((nestedStart, nestedEnd) in nestedRanges) {
       if (currentPos < nestedStart) {
-        builder.setSpan(span, currentPos, nestedStart, SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE)
+        applyLineHeightSkippingImages(builder, currentPos, nestedStart, lineHeight)
       }
       currentPos = nestedEnd
     }
     if (currentPos < end) {
-      builder.setSpan(span, currentPos, end, SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE)
+      applyLineHeightSkippingImages(builder, currentPos, end, lineHeight)
     }
   }
 }

package/android/src/main/java/com/swmansion/enriched/markdown/renderer/CodeBlockRenderer.kt

@@ -7,6 +7,8 @@ import android.text.style.LineHeightSpan
 import com.swmansion.enriched.markdown.parser.MarkdownASTNode
 import com.swmansion.enriched.markdown.spans.CodeBlockSpan
 import com.swmansion.enriched.markdown.spans.MarginBottomSpan
+import com.swmansion.enriched.markdown.utils.common.CodeBlockHighlighter
+import com.swmansion.enriched.markdown.utils.common.CodeBlockNode
 import com.swmansion.enriched.markdown.utils.text.span.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
 import com.swmansion.enriched.markdown.utils.text.span.applyMarginTop
 
@@ -20,6 +22,10 @@ class CodeBlockRenderer(
     onLinkLongPress: ((String) -> Unit)?,
     factory: RendererFactory,
   ) {
+    if (builder.isNotEmpty() && builder.last() != '\n') {
+      builder.append("\n")
+    }
+
     val start = builder.length
     val style = config.style.codeBlockStyle
     val context = factory.blockStyleContext
@@ -40,11 +46,20 @@ class CodeBlockRenderer(
     if (builder.length == contentStart) return
 
     val end = builder.length
+
+    CodeBlockHighlighter.highlight(
+      builder,
+      CodeBlockNode.extractCode(node),
+      CodeBlockNode.language(node),
+      style,
+      contentStart,
+    )
+
     val padding = style.padding.toInt()
 
     // Apply background, borders, and horizontal padding to content only
     builder.setSpan(
-      CodeBlockSpan(style, factory.context, factory.styleCache),
+      CodeBlockSpan(style, factory.context, factory.styleCache, context.accumulatedIndent),
       contentStart,
       end,
       SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,

package/android/src/main/java/com/swmansion/enriched/markdown/renderer/HeadingRenderer.kt

@@ -19,6 +19,10 @@ class HeadingRenderer(
     onLinkLongPress: ((String) -> Unit)?,
     factory: RendererFactory,
   ) {
+    if (builder.isNotEmpty() && builder.last() != '\n') {
+      builder.append("\n")
+    }
+
     val level = node.getAttribute("level")?.toIntOrNull() ?: 1
     val start = builder.length
 

package/android/src/main/java/com/swmansion/enriched/markdown/renderer/ListContextManager.kt

@@ -36,6 +36,7 @@ class ListContextManager(
   fun enterList(
     listType: BlockStyleContext.ListType,
     style: ListStyle,
+    startNumber: Int = 1,
   ): ListEntryState {
     val previousDepth = context.listDepth
     val isNested = previousDepth > 0
@@ -58,7 +59,7 @@ class ListContextManager(
         context.setUnorderedListStyle(style)
       }
     }
-    context.resetListItemNumber()
+    context.resetListItemNumber(startNumber)
 
     return ListEntryState(
       previousDepth = previousDepth,

package/android/src/main/java/com/swmansion/enriched/markdown/renderer/ListItemRenderer.kt

@@ -5,6 +5,8 @@ import android.text.style.ForegroundColorSpan
 import android.text.style.StrikethroughSpan
 import com.swmansion.enriched.markdown.parser.MarkdownASTNode
 import com.swmansion.enriched.markdown.spans.BaseListSpan
+import com.swmansion.enriched.markdown.spans.CodeBlockSpan
+import com.swmansion.enriched.markdown.spans.ListMarkerAnchorSpan
 import com.swmansion.enriched.markdown.spans.OrderedListSpan
 import com.swmansion.enriched.markdown.spans.TaskListSpan
 import com.swmansion.enriched.markdown.spans.UnorderedListSpan
@@ -33,19 +35,10 @@ class ListItemRenderer(
 
     val taskIndex = if (isTask) styleContext.taskItemCount++ else -1
 
-    factory.renderChildren(node, builder, onLinkPress, onLinkLongPress)
-
-    if (builder.length == start || builder.substring(start).isBlank()) return
-
-    while (builder.length > start && builder.last() == '\n') {
-      builder.delete(builder.length - 1, builder.length)
-    }
-    builder.append("\n")
-
     val depth = styleContext.listDepth - 1
     val listStyle = config.style.listStyle
-    val itemEnd = builder.length
-    val span =
+
+    fun makeSpan(drawsMarker: Boolean): BaseListSpan =
       if (isTask) {
         TaskListSpan(
           taskStyle = config.style.taskListStyle,
@@ -55,22 +48,85 @@ class ListItemRenderer(
           styleCache = factory.styleCache,
           taskIndex = taskIndex,
           isChecked = isChecked,
+          drawsMarker = drawsMarker,
         )
       } else {
         when (listType) {
           BlockStyleContext.ListType.UNORDERED -> {
-            UnorderedListSpan(listStyle, depth, factory.context, factory.styleCache)
+            UnorderedListSpan(listStyle, depth, factory.context, factory.styleCache, drawsMarker)
           }
 
           BlockStyleContext.ListType.ORDERED -> {
-            OrderedListSpan(listStyle, depth, factory.context, factory.styleCache).apply {
+            OrderedListSpan(listStyle, depth, factory.context, factory.styleCache, drawsMarker).apply {
               setItemNumber(styleContext.listItemNumber)
             }
           }
         }
       }
 
-    builder.setSpan(span, start, itemEnd, SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE)
+    val markerSpan = makeSpan(drawsMarker = true)
+
+    val prevIndent = styleContext.accumulatedIndent
+    styleContext.accumulatedIndent = prevIndent + markerSpan.getLeadingMargin(false)
+    try {
+      factory.renderChildren(node, builder, onLinkPress, onLinkLongPress)
+    } finally {
+      styleContext.accumulatedIndent = prevIndent
+    }
+
+    if (builder.length == start || builder.substring(start).isBlank()) return
+
+    styleContext.listItemStarts.add(start)
+
+    if (builder.last() != '\n') {
+      builder.append("\n")
+    }
+
+    val itemEnd = builder.length
+
+    // Anchor the marker on the first content character so items that open with
+    // a code block or nested sublist still get their marker.
+    var anchor = start
+    while (anchor < itemEnd && builder[anchor].isWhitespace()) anchor++
+    if (anchor == itemEnd) anchor = start
+
+    val plainAnchor =
+      builder.getSpans(anchor, anchor + 1, CodeBlockSpan::class.java).isEmpty() &&
+        builder.getSpans(anchor, anchor + 1, BaseListSpan::class.java).none { it.depth > depth }
+
+    val codeBlockRanges =
+      builder
+        .getSpans(start, itemEnd, CodeBlockSpan::class.java)
+        .map { builder.getSpanStart(it) to builder.getSpanEnd(it) }
+        .filter { it.first < it.second }
+        .sortedBy { it.first }
+
+    var pos = start
+    var isFirstSegment = true
+    for ((cbStart, cbEnd) in codeBlockRanges) {
+      if (pos < cbStart) {
+        builder.setSpan(
+          if (isFirstSegment && plainAnchor) markerSpan else makeSpan(drawsMarker = false),
+          pos,
+          cbStart,
+          SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+        )
+        isFirstSegment = false
+      }
+      pos = maxOf(pos, cbEnd)
+    }
+    if (pos < itemEnd) {
+      builder.setSpan(
+        if (isFirstSegment && plainAnchor) markerSpan else makeSpan(drawsMarker = false),
+        pos,
+        itemEnd,
+        SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+      )
+    }
+
+    if (!plainAnchor) {
+      builder.setSpan(ListMarkerAnchorSpan(markerSpan), anchor, anchor + 1, SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE)
+    }
 
     if (isTask && isChecked) {
       applyCheckedDecorations(builder, start, itemEnd, depth)
@@ -90,10 +146,10 @@ class ListItemRenderer(
     if (checkedTextColor == 0 && !strikethrough) return
 
     val excludedRanges =
-      builder
-        .getSpans(itemStart, itemEnd, BaseListSpan::class.java)
-        .filter { it.depth > itemDepth }
-        .map { builder.getSpanStart(it) to builder.getSpanEnd(it) }
+      (
+        builder.getSpans(itemStart, itemEnd, BaseListSpan::class.java).filter { it.depth > itemDepth } +
+          builder.getSpans(itemStart, itemEnd, CodeBlockSpan::class.java).toList()
+      ).map { builder.getSpanStart(it) to builder.getSpanEnd(it) }
         .sortedBy { it.first }
 
     var currentPos = itemStart

package/android/src/main/java/com/swmansion/enriched/markdown/renderer/ListRenderer.kt

@@ -2,7 +2,9 @@ package com.swmansion.enriched.markdown.renderer
 
 import android.text.SpannableStringBuilder
 import com.swmansion.enriched.markdown.parser.MarkdownASTNode
+import com.swmansion.enriched.markdown.spans.ListItemSpacingSpan
 import com.swmansion.enriched.markdown.spans.MarginBottomSpan
+import com.swmansion.enriched.markdown.styles.ListStyle
 import com.swmansion.enriched.markdown.utils.text.span.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
 import com.swmansion.enriched.markdown.utils.text.span.applyLineHeightSkippingImages
 import com.swmansion.enriched.markdown.utils.text.span.applyMarginTop
@@ -22,8 +24,15 @@ class ListRenderer(
     val listStyle = config.style.listStyle
     val listType = if (isOrdered) BlockStyleContext.ListType.ORDERED else BlockStyleContext.ListType.UNORDERED
 
+    val startNumber =
+      if (isOrdered) {
+        node.getAttribute("start")?.toIntOrNull()?.coerceAtLeast(0) ?: 1
+      } else {
+        1
+      }
+
     val contextManager = ListContextManager(factory.blockStyleContext)
-    val entryState = contextManager.enterList(listType, listStyle)
+    val entryState = contextManager.enterList(listType, listStyle, startNumber)
 
     // For top-level lists, insert marginTop spacer before rendering content
     if (entryState.previousDepth == 0) {
@@ -45,7 +54,7 @@ class ListRenderer(
     }
 
     if (builder.length > contentStart) {
-      applyListSpacing(builder, contentStart, entryState.previousDepth, listStyle)
+      applyListSpacing(builder, contentStart, entryState.previousDepth, listStyle, factory.blockStyleContext)
     }
   }
 
@@ -53,15 +62,18 @@ class ListRenderer(
     builder: SpannableStringBuilder,
     start: Int,
     depth: Int,
-    style: com.swmansion.enriched.markdown.styles.BaseBlockStyle,
+    style: ListStyle,
+    styleContext: BlockStyleContext,
   ) {
     // TODO: LineHeightSpan may also clip superscript/subscript glyphs that extend
     // outside the normal line bounds. A similar "skip" strategy as for images may
     // be needed here once super/subscript usage in practice is better understood.
     applyLineHeightSkippingImages(builder, start, builder.length, style.lineHeight)
 
-    // External bottom margin is only handled by the root-level list
+    // Item spacing and external bottom margin are only handled by the root-level list
     if (depth == 0) {
+      applyItemSpacing(builder, start, style.itemSpacing, styleContext)
+
       builder.append("\n")
       builder.setSpan(
         MarginBottomSpan(style.marginBottom),
@@ -71,4 +83,31 @@ class ListRenderer(
       )
     }
   }
+
+  // Inserts the vertical gap between consecutive items (including nested ones)
+  // by spanning the newline that precedes each item start. The first item of
+  // the root list gets no spacing above it.
+  private fun applyItemSpacing(
+    builder: SpannableStringBuilder,
+    start: Int,
+    itemSpacing: Float,
+    styleContext: BlockStyleContext,
+  ) {
+    if (itemSpacing <= 0f) return
+
+    val itemStarts =
+      styleContext.listItemStarts
+        .filter { it in start until builder.length }
+        .distinct()
+        .sorted()
+
+    for (itemStart in itemStarts.drop(1)) {
+      builder.setSpan(
+        ListItemSpacingSpan(itemSpacing),
+        itemStart - 1,
+        itemStart,
+        SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+      )
+    }
+  }
 }