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/formatting/InputParser.kt

@@ -1,33 +1,47 @@
 package com.swmansion.enriched.markdown.input.formatting
 
+import com.swmansion.enriched.markdown.input.model.BlockRange
+import com.swmansion.enriched.markdown.input.model.BlockType
 import com.swmansion.enriched.markdown.input.model.FormattingRange
+import com.swmansion.enriched.markdown.input.model.MAX_LIST_DEPTH
 import com.swmansion.enriched.markdown.input.model.MathAtom
+import com.swmansion.enriched.markdown.input.model.OBJECT_REPLACEMENT
 import com.swmansion.enriched.markdown.input.model.StyleType
 import com.swmansion.enriched.markdown.parser.MarkdownASTNode
 import com.swmansion.enriched.markdown.parser.MarkdownASTNode.NodeType
 import com.swmansion.enriched.markdown.parser.Md4cFlags
 import com.swmansion.enriched.markdown.parser.Parser
 import com.swmansion.enriched.markdown.parser.isTopLevelBlock
-import com.swmansion.enriched.markdown.utils.common.FeatureFlags
 
 data class ParseResult(
   val plainText: String,
   val formattingRanges: List<FormattingRange>,
+  val blockRanges: List<BlockRange> = emptyList(),
+  /**
+   * Math nodes, each already represented in [plainText] by a single
+   * [OBJECT_REPLACEMENT] character at [MathAtom.position]. The caller turns them
+   * into chips via [com.swmansion.enriched.markdown.input.math.MathChipController.applyAtoms];
+   * with math disabled md4c never emits the nodes and this stays empty.
+   */
   val mathAtoms: List<MathAtom> = emptyList(),
 )
 
 object InputParser {
-  private const val ATTACHMENT_CHAR = ''
-
   // A source paragraph break: a newline followed by one or more blank lines.
   private val PARAGRAPH_BREAK_RE = Regex("\\n[ \\t]*(?:\\n[ \\t]*)+")
 
   fun parseToPlainTextAndRanges(
-    markdown: String,
+    rawMarkdown: String,
     blockSyntax: Boolean = true,
   ): ParseResult {
+    // U+200B is the editor's reserved empty-list anchor and is stripped from every
+    // output path; strip it from incoming markdown too (web paste, JS-supplied
+    // values) so a foreign copy can't seed a stray anchor into the buffer. Done
+    // before parsing so plain-text offsets and ranges stay consistent — and before
+    // the blockSyntax branch, so both paths see the same scrubbed source.
+    val markdown = MarkdownSerializer.stripZwsp(rawMarkdown)
     if (markdown.isEmpty()) {
-      return ParseResult("", emptyList())
+      return ParseResult("", emptyList(), emptyList())
     }
 
     if (!blockSyntax) {
@@ -74,7 +88,12 @@ object InputParser {
         if (position < 0 || position >= decoded.length) null else atom.copy(position = position)
       }
 
-    return ParseResult(decoded, ranges, atoms)
+    // Block ranges are dropped, not shifted: with block syntax off there are no blocks.
+    // Under the sentinel the AST holds only Paragraphs and top-level display math, and
+    // neither yields a range, so this is a guard rather than a fix — a range that did leak
+    // would reach the BlockStore and the serializer would prefix it, breaking the
+    // byte-for-byte round trip.
+    return ParseResult(decoded, ranges, emptyList(), atoms)
   }
 
   private fun parseCompleted(
@@ -82,16 +101,12 @@ object InputParser {
     fallback: String,
     blockSeparators: Boolean,
   ): ParseResult {
-    val flags =
-      Md4cFlags(
-        underline = true,
-        latexMath = FeatureFlags.IS_MATH_ENABLED,
-        permissiveAutolinks = false,
-      )
-    val ast = Parser.shared.parseMarkdown(completed, flags) ?: return ParseResult(fallback, emptyList())
+    val flags = Md4cFlags(underline = true, permissiveAutolinks = false)
+    val ast = Parser.shared.parseMarkdown(completed, flags) ?: return ParseResult(fallback, emptyList(), emptyList())
 
     val plainText = StringBuilder()
     val ranges = mutableListOf<FormattingRange>()
+    val blockRanges = mutableListOf<BlockRange>()
     val mathAtoms = mutableListOf<MathAtom>()
 
     // md4c collapses any blank-line run into a single break, unlike iOS which keeps them.
@@ -108,28 +123,34 @@ object InputParser {
         ArrayDeque()
       }
 
-    walkNode(ast, plainText, ranges, mathAtoms, ArrayDeque(), blankRuns, blockSeparators)
+    walkNode(ast, plainText, ranges, blockRanges, mathAtoms, ArrayDeque(), blankRuns, 0, false, blockSeparators)
 
-    return ParseResult(plainText.toString(), ranges, mathAtoms)
+    return ParseResult(plainText.toString(), ranges, blockRanges, mathAtoms)
   }
 
   private fun walkNode(
     node: MarkdownASTNode,
     plainText: StringBuilder,
     ranges: MutableList<FormattingRange>,
+    blockRanges: MutableList<BlockRange>,
     mathAtoms: MutableList<MathAtom>,
     activeStyles: ArrayDeque<ActiveStyle>,
     blankRuns: ArrayDeque<Int>,
+    listDepth: Int,
+    orderedContainer: Boolean,
     blockSeparators: Boolean,
   ) {
+    // Math is atomic in the editor: the whole formula occupies one character, so it
+    // takes no style/block bookkeeping and its children are never walked (walking
+    // them would append the raw LaTeX as text). Returning here is what makes the
+    // chip's position a single offset the controller can hang a span on.
     if (node.type == NodeType.LatexMathInline || node.type == NodeType.LatexMathDisplay) {
-      val latex = extractLatex(node)
       val position = plainText.length
-      plainText.append(ATTACHMENT_CHAR)
+      plainText.append(OBJECT_REPLACEMENT)
       mathAtoms.add(
         MathAtom(
           position = position,
-          latex = latex,
+          latex = extractLatex(node),
           displayMode = node.type == NodeType.LatexMathDisplay,
         ),
       )
@@ -143,18 +164,55 @@ object InputParser {
       activeStyles.addLast(ActiveStyle(styleType, plainText.length, url))
     }
 
+    // A list node increments the nesting depth of its items, so a list item's depth
+    // is (enclosing list nodes − 1) — matching the iOS depth derivation. Depth comes
+    // from this AST nesting, never from counting leading spaces.
+    val isListContainer = node.type == NodeType.UnorderedList || node.type == NodeType.OrderedList
+    val childListDepth = if (isListContainer) listDepth + 1 else listDepth
+    val childOrdered = if (isListContainer) node.type == NodeType.OrderedList else orderedContainer
+
+    // Each list item starts on its own line; md4c emits no separator between sibling
+    // items or before a nested sublist, so insert the line break ourselves.
+    if (node.type == NodeType.ListItem && plainText.isNotEmpty() && !plainText.endsWith("\n")) {
+      plainText.append("\n")
+    }
+    val itemStart = if (node.type == NodeType.ListItem) plainText.length else -1
+
+    // Block-level node: record where its text content begins so we can build a
+    // BlockRange on the way back out. PARAGRAPH is the implicit default and is
+    // dropped below, so it produces no stored block range.
+    val blockLevel = node.getAttribute("level")?.toIntOrNull() ?: 0
+    val blockType = nodeTypeToBlockType(node.type, blockLevel)
+    val blockStartPosition = plainText.length
+
     if (node.type == NodeType.Text) {
       plainText.append(node.content)
-    } else if (node.type == NodeType.LineBreak) {
+    } else if (node.type == NodeType.LineBreak || node.type == NodeType.SoftBreak) {
       plainText.append("\n")
     }
 
     for ((index, child) in node.children.withIndex()) {
-      // Keep the source's blank lines between top-level blocks (md4c drops them, iOS keeps them).
-      if (blockSeparators && index > 0 && child.type.isTopLevelBlock() && plainText.isNotEmpty()) {
+      // Keep the source's blank lines between genuinely top-level blocks (md4c drops
+      // them, iOS keeps them). Inside a list, items are separated by a single newline
+      // (inserted above), not blank lines.
+      if (blockSeparators && index > 0 && listDepth == 0 && child.type.isTopLevelBlock() && plainText.isNotEmpty()) {
         plainText.append("\n".repeat(blankRuns.removeFirstOrNull() ?: 2))
       }
-      walkNode(child, plainText, ranges, mathAtoms, activeStyles, blankRuns, blockSeparators)
+      walkNode(child, plainText, ranges, blockRanges, mathAtoms, activeStyles, blankRuns, childListDepth, childOrdered, blockSeparators)
+    }
+
+    // A list item owns its own first line; a nested sublist lives on later lines, so
+    // the item's range ends at the first newline after its start.
+    if (itemStart >= 0) {
+      var lineEnd = plainText.indexOf('\n', itemStart)
+      if (lineEnd < 0) lineEnd = plainText.length
+      if (lineEnd > itemStart) {
+        // The item sees listDepth already incremented by its enclosing list node, so
+        // its 0-based depth is listDepth − 1 (enclosing list nodes − 1, per iOS).
+        val depth = (listDepth - 1).coerceIn(0, MAX_LIST_DEPTH)
+        val itemType = if (orderedContainer) BlockType.ORDERED_LIST_ITEM else BlockType.UNORDERED_LIST_ITEM
+        blockRanges.add(BlockRange(itemType, itemStart, lineEnd, depth))
+      }
     }
 
     if (styleType != null) {
@@ -164,8 +222,22 @@ object InputParser {
         ranges.add(FormattingRange(styleType, activeStyle.startPosition, end, activeStyle.url))
       }
     }
+
+    // Emit the block range for handler-claimed block types only; PARAGRAPH (the
+    // implicit default) yields nothing. List items are emitted above with their own
+    // line bounds, so they are excluded here.
+    if (blockType != null && blockType != BlockType.PARAGRAPH && blockType !in BlockType.LIST_ITEMS) {
+      val end = plainText.length
+      if (end > blockStartPosition) {
+        blockRanges.add(BlockRange(blockType, blockStartPosition, end, blockLevel))
+      }
+    }
   }
 
+  /**
+   * LaTeX source of a math node. md4c may deliver it either as the node's own
+   * content or split across text children, so both are handled.
+   */
   private fun extractLatex(node: MarkdownASTNode): String {
     if (node.content.isNotEmpty()) return node.content
     if (node.children.isEmpty()) return ""
@@ -187,6 +259,28 @@ object InputParser {
       else -> null
     }
 
+  /**
+   * Maps a parser block node to a [BlockType], mirroring [nodeTypeToStyleType]
+   * for inline spans. A heading maps to its per-level `HEADING_n` (from the node's
+   * `level` attribute); an out-of-range level falls back to PARAGRAPH so a
+   * malformed parse degrades gracefully rather than dropping the line.
+   */
+  private fun nodeTypeToBlockType(
+    nodeType: NodeType,
+    level: Int,
+  ): BlockType? =
+    when (nodeType) {
+      NodeType.Paragraph -> BlockType.PARAGRAPH
+
+      NodeType.Heading -> BlockType.forHeadingLevel(level) ?: BlockType.PARAGRAPH
+
+      // List items are recognized here but emitted with their own per-line bounds and
+      // AST-derived nesting depth in the walk above, not via the generic emission.
+      NodeType.ListItem -> BlockType.UNORDERED_LIST_ITEM
+
+      else -> null
+    }
+
   private data class ActiveStyle(
     val type: StyleType,
     val startPosition: Int,

package/android/src/main/java/com/swmansion/enriched/markdown/input/formatting/MarkdownSerializer.kt

@@ -1,68 +1,197 @@
 package com.swmansion.enriched.markdown.input.formatting
 
-import android.text.Spanned
+import android.util.Log
+import com.swmansion.enriched.markdown.input.editing.isLineBreak
 import com.swmansion.enriched.markdown.input.math.MathChipController
+import com.swmansion.enriched.markdown.input.model.BlockRange
+import com.swmansion.enriched.markdown.input.model.BlockType
 import com.swmansion.enriched.markdown.input.model.FormattingRange
+import com.swmansion.enriched.markdown.input.model.OBJECT_REPLACEMENT
 import com.swmansion.enriched.markdown.input.model.StyleType
 
 object MarkdownSerializer {
-  private const val ATTACHMENT_CHAR = ''
+  private const val TAG = "MarkdownSerializer"
+
+  // Zero-width space used by the editor to anchor an empty bullet line; it is an
+  // internal editing aid and must never appear in serialized markdown.
+  private const val ZWSP = "\u200B"
 
   /**
-   * Serialize a [Spanned] view of the storage back to markdown. Math chips
-   * (the `` placeholder + a controller-tracked chip) become `$latex$` or
-   * `$$latex$$` depending on the chip's display mode. Inline formatting
-   * ranges are still applied to character offsets in the underlying text.
+   * Single choke point for scrubbing the empty-line ZWSP anchor out of anything
+   * bound for JS (serialized markdown here, plain text in `InputEventEmitter`).
+   * Route new output paths through this rather than scattering `replace(ZWSP, "")`
+   * calls, so the anchor can never leak because one path forgot to strip.
+   */
+  fun stripZwsp(text: String): String = text.replace(ZWSP, "")
+
+  /**
+   * Math-aware serialization — the single output path for a buffer that may hold
+   * math chips. Each chip's [OBJECT_REPLACEMENT] placeholder expands back to
+   * `$latex$` / `$$latex$$`, and **both** the inline ranges and the block ranges
+   * are translated through the same position map before the block-aware overload
+   * runs. Translating only one of the two is the silent failure this exists to
+   * prevent: one placeholder char becomes n characters, so every block boundary
+   * after a chip would land a line off and `# `/`- `/`1. ` would prefix the wrong
+   * line. [stripZwsp] still happens exactly once, inside the overload below.
+   *
+   * Chips are passed as plain data (not a `Spanned` + controller) so this stays a
+   * pure function over `String` — which is what makes the round-trip testable
+   * without a live editor. Positions must be offsets into [text].
    */
   fun serialize(
-    text: Spanned,
+    text: String,
+    chips: List<MathChipController.ChipInfo>,
     ranges: List<FormattingRange>,
-    mathChipController: MathChipController?,
+    blockRanges: List<BlockRange>,
+    blockPrefixProvider: (BlockRange) -> String,
   ): String {
-    if (mathChipController == null || text.length == 0) {
-      return serialize(text.toString(), ranges)
-    }
-    val chips = mathChipController.allChips(text)
-    if (chips.isEmpty()) {
-      return serialize(text.toString(), ranges)
-    }
+    if (chips.isEmpty()) return serialize(text, ranges, blockRanges, blockPrefixProvider)
 
     val expanded = StringBuilder(text.length)
+    // positionMap[i] = offset in `expanded` of the character that was at `text[i]`.
+    // Length + 1 so an exclusive end offset at text.length maps too.
     val positionMap = IntArray(text.length + 1)
-    val chipByPosition = chips.associateBy { it.position }
-    var expandedPos = 0
-    var i = 0
-    while (i < text.length) {
-      positionMap[i] = expandedPos
-      val c = text[i]
-      val chip = chipByPosition[i]
-      if (c == ATTACHMENT_CHAR && chip != null) {
-        val delim = if (chip.displayMode) "$$" else "$"
-        expanded.append(delim)
-        expanded.append(chip.latex)
-        expanded.append(delim)
-        expandedPos += delim.length * 2 + chip.latex.length
+    val latexByPosition = HashMap<Int, String>(chips.size)
+    for (chip in chips) {
+      if (chip.position < 0 || chip.position >= text.length) continue
+      if (text[chip.position] != OBJECT_REPLACEMENT) continue
+      latexByPosition[chip.position] = mathDelimiters(chip)
+    }
+
+    for (i in text.indices) {
+      positionMap[i] = expanded.length
+      val replacement = latexByPosition[i]
+      if (replacement != null) {
+        expanded.append(replacement)
       } else {
-        expanded.append(c)
-        expandedPos += 1
+        expanded.append(text[i])
       }
-      i++
     }
-    positionMap[text.length] = expandedPos
+    positionMap[text.length] = expanded.length
 
-    val shifted =
+    val shiftedRanges =
       ranges.map { range ->
-        val rangeStart = range.start.coerceIn(0, text.length)
-        val rangeEnd = range.end.coerceIn(0, text.length)
         FormattingRange(
           range.type,
-          positionMap[rangeStart],
-          positionMap[rangeEnd],
+          positionMap[range.start.coerceIn(0, text.length)],
+          positionMap[range.end.coerceIn(0, text.length)],
           range.url,
         )
       }
 
-    return serialize(expanded.toString(), shifted)
+    val shiftedBlockRanges =
+      blockRanges.map { block ->
+        // `ordinal` is not a constructor default — it carries an ordered item's
+        // number, so rebuilding without it renumbers every "1." in the document.
+        BlockRange(
+          block.type,
+          positionMap[block.start.coerceIn(0, text.length)],
+          positionMap[block.end.coerceIn(0, text.length)],
+          block.level,
+          block.ordinal,
+        )
+      }
+
+    return serialize(expanded.toString(), shiftedRanges, shiftedBlockRanges, blockPrefixProvider)
+  }
+
+  /**
+   * The chip's markdown form, delimiters included. Line breaks inside the LaTeX are
+   * collapsed to spaces: a chip is one line box in the editor, and emitting a real
+   * newline would change the serialized line count, which trips the line-count
+   * invariant in [serializeWithAnchors] and silently drops every block prefix in the
+   * document. LaTeX is whitespace-insensitive here, so the formula is unaffected.
+   * A blank formula expands to nothing rather than to a bare `$$` that would
+   * re-parse as literal text.
+   */
+  private fun mathDelimiters(chip: MathChipController.ChipInfo): String {
+    val latex =
+      buildString(chip.latex.length) {
+        var previousWasBreak = false
+        for (char in chip.latex) {
+          if (char.isLineBreak()) {
+            if (!previousWasBreak) append(' ')
+            previousWasBreak = true
+          } else {
+            append(char)
+            previousWasBreak = false
+          }
+        }
+      }.trim()
+    if (latex.isEmpty()) return ""
+    val delimiter = if (chip.displayMode) "$$" else "$"
+    return delimiter + latex + delimiter
+  }
+
+  /**
+   * Block-aware serialization: serializes inline styles exactly as the inline-only
+   * overload, then prepends each line's block prefix. [blockPrefixProvider] is
+   * asked, per block range, for the markdown line marker (e.g. `"# "`, `"- "`);
+   * returning `""` leaves the line unprefixed. With empty [blockRanges] the output
+   * is identical to the inline-only overload. Any ZWSP empty-line anchor is stripped
+   * so an empty bullet still serializes to a bare `"- "` rather than `"- ​"`.
+   */
+  fun serialize(
+    text: String,
+    ranges: List<FormattingRange>,
+    blockRanges: List<BlockRange>,
+    blockPrefixProvider: (BlockRange) -> String,
+  ): String = stripZwsp(serializeWithAnchors(text, ranges, blockRanges, blockPrefixProvider))
+
+  private fun serializeWithAnchors(
+    text: String,
+    ranges: List<FormattingRange>,
+    blockRanges: List<BlockRange>,
+    blockPrefixProvider: (BlockRange) -> String,
+  ): String {
+    val inlineMarkdown = serialize(text, ranges)
+    if (blockRanges.isEmpty()) return inlineMarkdown
+
+    // Block prefixes attach per line. Inline serialization only inserts inline
+    // delimiters (never newlines), so the serialized output has the same line
+    // count as the plain text — we map a block's plain-text range to line indices
+    // and prefix the corresponding serialized lines.
+    val plainLines = text.split("\n")
+    val markdownLines = inlineMarkdown.split("\n").toMutableList()
+
+    // Inline delimiters never cross a newline, so the line partition is preserved.
+    // If this ever breaks, prefixes would land on the wrong lines. Contract on
+    // both platforms: log and fall back to inline-only output — a library must
+    // not crash the host app over lost block prefixes.
+    if (plainLines.size != markdownLines.size) {
+      Log.e(TAG, "Block serialization line-count invariant violated: plain=${plainLines.size} markdown=${markdownLines.size}")
+      return inlineMarkdown
+    }
+
+    // Plain-text character offset at the start of each line.
+    val lineStartOffsets = IntArray(plainLines.size)
+    var runningOffset = 0
+    for (i in plainLines.indices) {
+      lineStartOffsets[i] = runningOffset
+      runningOffset += plainLines[i].length + 1 // +1 for the '\n' separator
+    }
+
+    for (blockRange in blockRanges) {
+      val prefix = blockPrefixProvider(blockRange)
+      if (prefix.isEmpty()) continue
+
+      val isZeroLength = blockRange.length == 0
+      val isListItem = blockRange.type in BlockType.LIST_ITEMS
+      for (lineIndex in plainLines.indices) {
+        val lineStart = lineStartOffsets[lineIndex]
+        val lineEnd = lineStart + plainLines[lineIndex].length
+        val overlaps = if (isZeroLength) lineStart == blockRange.start else lineEnd >= blockRange.start && lineStart < blockRange.end
+        if (overlaps) {
+          // A marker-only list line ("- " with no content) re-parses as a setext
+          // underline for the previous line; emit an empty list line bare. An
+          // empty "# " heading is valid ATX and keeps its prefix.
+          if (isListItem && stripZwsp(plainLines[lineIndex]).isEmpty()) continue
+          markdownLines[lineIndex] = prefix + markdownLines[lineIndex]
+        }
+      }
+    }
+
+    return markdownLines.joinToString("\n")
   }
 
   fun serialize(

package/android/src/main/java/com/swmansion/enriched/markdown/input/formatting/RangeEditAdjustment.kt

@@ -0,0 +1,149 @@
+package com.swmansion.enriched.markdown.input.formatting
+
+import com.swmansion.enriched.markdown.input.model.MutableRangeBounds
+
+internal fun <T : MutableRangeBounds> sortedInsertionIndex(
+  ranges: List<T>,
+  location: Int,
+): Int {
+  var index = 0
+  for (existing in ranges) {
+    if (existing.start > location) break
+    index++
+  }
+  return index
+}
+
+/**
+ * Shared shift/clip logic applied to stored ranges after a text edit. Both
+ * [FormattingStore] and [BlockStore] delegate here so the overlap
+ * classification lives in exactly one place.
+ */
+internal object RangeEditAdjustment {
+  /**
+   * Mutates [ranges] in place to follow an edit that replaced [deletedLength]
+   * characters at [editLocation] with [insertedLength] characters. Ranges
+   * deleted outright or clipped to zero length are removed.
+   *
+   * Insert-only edits at exactly `range.end` do NOT grow the range — the typed
+   * characters stay outside it. An insert at exactly `range.start` grows the
+   * range only when [growsAtStartOnInsert] returns true; otherwise the range
+   * shifts and the typed characters stay outside it. Whether boundary text
+   * otherwise joins the range is decided elsewhere: pending styles for inline
+   * ranges, line re-normalization for block ranges.
+   *
+   * [inheritsReplacementAtStart]: when it returns true for a range whose start
+   * is the edit location, replacement text joins the range (UIKit attribute
+   * inheritance); when false, the old clip/remove behavior applies.
+   *
+   * [growsAtStartOnInsert]: when it returns true, a pure insert at `range.start`
+   * grows the range to cover the inserted text instead of shifting the range
+   * past it. Block ranges own their whole line, so a character typed at the line
+   * start must keep the line's block; inline styles must NOT set this (a
+   * character typed before a bold run must not become bold).
+   */
+  fun <T : MutableRangeBounds> adjustForEdit(
+    ranges: MutableList<T>,
+    editLocation: Int,
+    deletedLength: Int,
+    insertedLength: Int,
+    inheritsReplacementAtStart: (T) -> Boolean = { false },
+    growsAtStartOnInsert: (T) -> Boolean = { false },
+  ) {
+    if (deletedLength == 0 && insertedLength == 0) return
+
+    val deleteEnd = editLocation + deletedLength
+    val indexesToRemove = mutableListOf<Int>()
+
+    for ((idx, range) in ranges.withIndex()) {
+      if (deletedLength > 0) {
+        val inheritsReplacement =
+          insertedLength > 0 && range.start == editLocation && inheritsReplacementAtStart(range)
+        when (classifyOverlap(range.start, range.end, editLocation, deleteEnd)) {
+          EditOverlap.BEFORE_EDIT -> { /* no change */ }
+
+          EditOverlap.AFTER_EDIT -> {
+            range.start = range.start - deletedLength + insertedLength
+            range.end = range.end - deletedLength + insertedLength
+          }
+
+          EditOverlap.FULLY_DELETED -> {
+            if (inheritsReplacement) {
+              range.start = editLocation
+              range.end = editLocation + insertedLength
+            } else {
+              indexesToRemove.add(idx)
+            }
+          }
+
+          EditOverlap.DELETED_INSIDE -> {
+            range.end = range.end - deletedLength + insertedLength
+          }
+
+          EditOverlap.CLIPPED_END -> {
+            val newEnd = editLocation + insertedLength
+            val newLength = if (newEnd > range.start) newEnd - range.start else 0
+            range.end = range.start + newLength
+            if (newLength == 0) indexesToRemove.add(idx)
+          }
+
+          EditOverlap.CLIPPED_START -> {
+            val charsClipped = deleteEnd - range.start
+            val survivingLength = range.end - range.start - charsClipped
+            if (inheritsReplacement) {
+              range.start = editLocation
+              range.end = editLocation + insertedLength + survivingLength
+            } else {
+              range.start = editLocation + insertedLength
+              range.end = range.start + survivingLength
+              if (survivingLength == 0) indexesToRemove.add(idx)
+            }
+          }
+        }
+      } else {
+        when {
+          range.start == editLocation && growsAtStartOnInsert(range) -> {
+            range.end += insertedLength
+          }
+
+          range.start >= editLocation -> {
+            range.start += insertedLength
+            range.end += insertedLength
+          }
+
+          editLocation > range.start && editLocation < range.end -> {
+            range.end += insertedLength
+          }
+        }
+      }
+    }
+
+    for (idx in indexesToRemove.reversed()) {
+      ranges.removeAt(idx)
+    }
+
+    ranges.removeAll { it.end - it.start == 0 }
+  }
+
+  private enum class EditOverlap {
+    BEFORE_EDIT,
+    AFTER_EDIT,
+    FULLY_DELETED,
+    DELETED_INSIDE,
+    CLIPPED_END,
+    CLIPPED_START,
+  }
+
+  private fun classifyOverlap(
+    rangeStart: Int,
+    rangeEnd: Int,
+    editLocation: Int,
+    deleteEnd: Int,
+  ): EditOverlap {
+    if (rangeEnd <= editLocation) return EditOverlap.BEFORE_EDIT
+    if (rangeStart >= deleteEnd) return EditOverlap.AFTER_EDIT
+    if (rangeStart >= editLocation && rangeEnd <= deleteEnd) return EditOverlap.FULLY_DELETED
+    if (rangeStart < editLocation && rangeEnd > deleteEnd) return EditOverlap.DELETED_INSIDE
+    return if (rangeStart < editLocation) EditOverlap.CLIPPED_END else EditOverlap.CLIPPED_START
+  }
+}