react-native-jet-markdown 0.2.1 → 0.2.2

package/android/src/main/java/com/jetmarkdown/editor/JetMarkdownEditorView.kt

@@ -1,1736 +0,0 @@
-package com.jetmarkdown.editor
-
-import android.annotation.SuppressLint
-import android.content.Context
-import android.graphics.Canvas
-import android.graphics.Color
-import android.graphics.Paint
-import android.graphics.Typeface
-import android.os.Build
-import android.text.Editable
-import android.text.InputType
-import android.text.Spanned
-import android.text.TextPaint
-import android.text.TextWatcher
-import android.util.TypedValue
-import android.view.Gravity
-import android.view.View
-import android.view.inputmethod.InputMethodManager
-import android.widget.EditText
-import com.facebook.react.bridge.Arguments
-import com.facebook.react.bridge.ReactContext
-import com.facebook.react.bridge.WritableMap
-import com.facebook.react.uimanager.StateWrapper
-import com.facebook.react.uimanager.UIManagerHelper
-import com.facebook.react.uimanager.events.Event
-import com.jetmarkdown.JetMarkdownNative
-import com.jetmarkdown.style.StyleConfig
-
-/**
- * WYSIWYG markdown editor: an EditText that publishes its content height
- * into the shadow-node state (autogrow) and emits editing events. Root text
- * attributes come from the same base/paragraph cascade the viewer uses.
- */
-@SuppressLint("AppCompatCustomView")
-class JetMarkdownEditorView(context: Context) : EditText(context) {
-  var stateWrapper: StateWrapper? = null
-
-  private var stylesJson: String = ""
-  private var defaultValueApplied = false
-
-  var allowFontScaling = true
-    set(value) {
-      if (field != value) {
-        field = value
-        applyTextStyles()
-        refreshDisplaySpans(text)
-        invalidate()
-      }
-    }
-
-  private var multiline = true
-  private var autoCorrectEnabled = true
-  private var capitalizeMode = "sentences"
-  private var pendingAutoFocus = false
-  private var lastPublishedHeight = 0f
-
-  // Autogrow cap (px); 0 = unbounded. Past it the editor scrolls
-  // internally like a textarea.
-  private var maxHeightPx = 0
-  private var contentExceedsMax = false
-  private var scrollAllowed = true
-
-  // Marks armed for text typed at the collapsed cursor; re-derived from the
-  // character before the caret whenever the selection moves outside an edit.
-  private var pendingMarks = 0
-
-  // Caret position where marks were explicitly toggled. The IME re-syncs
-  // its selection asynchronously after external text mutations; a selection
-  // event at the SAME position must not wipe a just-armed mark.
-  private var pendingArmedAt = -1
-  private var lastStateKey = -1L
-  private var editInProgress = false
-  private var suppressWatcher = false
-  private var changeStart = 0
-  private var changeInserted = 0
-  private var changeReplaced = 0
-
-  // Per-character mark flags of the region an IME re-commit is about to
-  // replace ("a" → "ab" replaces the composing word): SSB collapses spans
-  // whose whole run is swapped out, so the prefix's marks are restored from
-  // this snapshot afterwards.
-  private var replacedMarkFlags: IntArray? = null
-
-  private fun markFlagsAt(spanned: Spanned, offset: Int): Int {
-    var flags = 0
-    for (span in spanned.getSpans(offset, offset + 1, EditorMarkSpan::class.java)) {
-      if (spanned.getSpanStart(span) <= offset && spanned.getSpanEnd(span) > offset) {
-        flags = flags or span.mark
-      }
-    }
-    return flags
-  }
-
-  // TextView's constructor fires onSelectionChanged before any of this
-  // class's fields exist; nothing below may run until init completes.
-  private var constructed = false
-
-  // Source of truth for per-line blocks (packed type shl 8 or level, one
-  // entry per text line). Spliced in the TextWatcher as lines come and go.
-  private val lineBlocks = ArrayList<Int>()
-  private var editLine = 0
-  private var removedNewlines = 0
-  private var insertedNewlines = 0
-
-  // Mention trigger session.
-  var mentionTriggers: List<String> = emptyList()
-  private var mentionActive = false
-  private var mentionTrigger = ""
-  private var mentionStart = 0
-  private var lastMentionQuery: String? = null
-  private var linkColor = DEFAULT_LINK_COLOR
-
-  // Resolved lineHeight per context (px); 0 = natural. Headings and code
-  // use their own element style, everything else the base/paragraph
-  // cascade.
-  private var lineHeightPx = 0
-  private val headingLineHeightsPx = IntArray(7)
-  private var codeLineHeightPx = 0
-
-  // Drawn manually: Fabric never drives onMeasure, and TextView's native
-  // hint rendering depends on measure-time layout construction.
-  private var placeholderText: String? = null
-  private var placeholderColor: Int = DEFAULT_PLACEHOLDER_COLOR
-  private val placeholderPaint = TextPaint(Paint.ANTI_ALIAS_FLAG)
-
-  private val density = context.resources.displayMetrics.density
-  private val defaultHighlightColor = highlightColor
-
-  // Fabric assigns exact frames and never runs a parent measure/layout pass,
-  // so TextView's internal Layout is not rebuilt after programmatic setText
-  // or hint changes. Re-run measure/layout in place against the current
-  // frame (the standard fix for text-bearing custom views under Fabric).
-  private var relayoutPending = false
-
-  private val measureAndLayout = Runnable {
-    relayoutPending = false
-    if (width > 0 && height > 0) {
-      measure(
-        MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY),
-        MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY),
-      )
-      layout(left, top, right, bottom)
-    }
-  }
-
-  override fun requestLayout() {
-    super.requestLayout()
-    if (!relayoutPending) {
-      relayoutPending = true
-      post(measureAndLayout)
-    }
-  }
-
-  init {
-    background = null
-    gravity = Gravity.TOP or Gravity.START
-    applyTextStyles()
-    applyInputType()
-
-    addTextChangedListener(object : TextWatcher {
-      override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) {
-        editInProgress = true
-        replacedMarkFlags = null
-        if (suppressWatcher || s == null) {
-          return
-        }
-        editLine = countNewlines(s, 0, start)
-        removedNewlines = countNewlines(s, start, start + count)
-        // Word-sized replacements that grow are IME re-commits; snapshot the
-        // replaced characters' marks so the prefix can be restored. The size
-        // cap keeps selection replacements (e.g. a clipboard-chip paste over
-        // a long selection) out of this path — composing words are short.
-        if (count in 1..48 && after >= count && s is Spanned) {
-          replacedMarkFlags = IntArray(count) { markFlagsAt(s, start + it) }
-        }
-      }
-
-      override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {
-        if (suppressWatcher || s == null) {
-          // A nested programmatic edit (block exit) must not clobber the
-          // outer edit's bookkeeping mid-afterTextChanged.
-          return
-        }
-        changeStart = start
-        changeInserted = count
-        changeReplaced = before
-        insertedNewlines = countNewlines(s, start, start + count)
-      }
-
-      override fun afterTextChanged(s: Editable?) {
-        editInProgress = false
-        if (suppressWatcher || s == null) {
-          return
-        }
-        spliceLineBlocks()
-        if (s.isEmpty()) {
-          // Deleting all content resets the document to one plain line;
-          // a block must not haunt an empty editor.
-          lineBlocks.clear()
-          ensureLineBlocks()
-          pendingMarks = 0
-        }
-        var exitedList = false
-        if (insertedNewlines == 1 && changeInserted == 1 && removedNewlines == 0) {
-          val block = lineBlocks.getOrElse(editLine) { 0 }
-          // The Enter split the line at the caret: editLine holds the text
-          // before the caret, editLine + 1 the text after it.
-          val beforeEmpty = lineContentRange(editLine).isEmpty()
-          val afterEmpty = lineContentRange(editLine + 1).isEmpty()
-          if (block != 0 && beforeEmpty && afterEmpty) {
-            // Enter on any empty formatted line (list item, quote, code
-            // block, heading) exits the block instead of continuing it.
-            lineBlocks[editLine] = 0
-            lineBlocks.removeAt(editLine + 1)
-            suppressWatcher = true
-            s.delete(changeStart, changeStart + 1)
-            suppressWatcher = false
-            exitedList = true
-          } else if (EditorBlocks.type(block) == EditorBlocks.HEADING) {
-            if (beforeEmpty) {
-              // Enter at the start of a heading: the heading stays with its
-              // text and a plain empty line opens above it.
-              lineBlocks[editLine] = 0
-            } else if (afterEmpty) {
-              // Enter at the end of a heading does not continue it.
-              lineBlocks[editLine + 1] = 0
-            }
-            // Mid-heading splits keep the heading on both halves.
-          }
-        }
-        // The IME often re-commits a whole composing word to append one
-        // character ("a" → "ab"). Stamping pending marks over the full
-        // insertion would restyle the re-committed prefix (whose spans SSB
-        // already preserved), so only the genuinely new suffix is stamped.
-        if (!exitedList && changeInserted > changeReplaced && pendingMarks != 0) {
-          val stampStart = changeStart + changeReplaced
-          for (mark in EditorMarks.ALL) {
-            if (pendingMarks and mark != 0) {
-              applyMark(s, mark, stampStart, changeStart + changeInserted)
-            }
-          }
-        }
-        // Restore the re-committed prefix's marks from the snapshot (the
-        // replacement collapsed any span that covered exactly that run).
-        val restored = replacedMarkFlags
-        if (restored != null && changeReplaced == restored.size &&
-          changeInserted >= changeReplaced
-        ) {
-          for (i in 0 until changeReplaced) {
-            val flags = restored[i]
-            if (flags == 0) {
-              continue
-            }
-            for (mark in EditorMarks.ALL) {
-              if (flags and mark != 0) {
-                applyMark(s, mark, changeStart + i, changeStart + i + 1)
-              }
-            }
-          }
-        }
-        replacedMarkFlags = null
-        // Typing strictly inside an atomic token demotes it to plain text.
-        if (changeInserted > 0) {
-          for (span in s.getSpans(changeStart, changeStart, LinkDataSpan::class.java)) {
-            if (span.atomic && s.getSpanStart(span) < changeStart &&
-              s.getSpanEnd(span) > changeStart + changeInserted
-            ) {
-              s.removeSpan(span)
-            }
-          }
-        }
-        if (insertedNewlines == 0 && removedNewlines == 0 && s.isNotEmpty()) {
-          // Plain in-line keystroke: derived spans on other lines are still
-          // valid; rebuilding them all would reflow the whole document.
-          refreshDisplaySpansAround(s, changeStart, changeStart + changeInserted)
-        } else {
-          refreshDisplaySpans(s)
-        }
-        // The armed-mark guard is positional; any text edit invalidates it.
-        pendingArmedAt = -1
-        emitContentChanged()
-        if (changeInserted == 1 && changeStart < s.length && isWordBreak(s[changeStart])) {
-          detectLinkBefore(changeStart)
-        }
-        updateMentionSession()
-        emitState()
-      }
-    })
-
-    setOnFocusChangeListener { _, hasFocus ->
-      emitEvent(if (hasFocus) "topEditorFocus" else "topEditorBlur") { }
-    }
-
-    constructed = true
-  }
-
-  // Root text attributes: base (style prop text keys) then paragraph,
-  // floored at 16pt black — the same cascade root the viewer uses.
-  private fun applyTextStyles() {
-    val styles = StyleConfig.from(stylesJson)
-
-    var fontSize = 16f
-    var fontFamily: String? = null
-    var color = Color.BLACK
-    var lineHeight = 0f
-    for (key in listOf("base", "paragraph")) {
-      val spec = styles.textStyleFor(key) ?: continue
-      spec.fontSize?.let { fontSize = it }
-      spec.fontFamily?.let { fontFamily = it }
-      spec.color?.let { color = it }
-      spec.lineHeight?.let { lineHeight = it }
-    }
-    // Must match the shadow node's fontSizeMultiplier (the system scale).
-    val fontScale =
-      if (allowFontScaling) resources.configuration.fontScale else 1.0f
-    fontSize *= fontScale
-    lineHeight *= fontScale
-    lineHeightPx = (lineHeight * density).toInt()
-    for (level in 1..6) {
-      headingLineHeightsPx[level] =
-        ((styles.textStyleFor("h$level")?.lineHeight ?: 0f) * density * fontScale).toInt()
-    }
-    codeLineHeightPx =
-      styles.textStyleFor("codeBlock")?.lineHeight
-        ?.let { (it * density * fontScale).toInt() }
-        ?: lineHeightPx
-
-    setTextSize(TypedValue.COMPLEX_UNIT_PX, fontSize * density)
-    setTextColor(color)
-    // ReactFontManager understands RN/Expo custom fonts; Typeface.create
-    // silently falls back to the system default for them.
-    typeface = com.jetmarkdown.style.Fonts.resolve(context, fontFamily, 400, italic = false)
-    styles.textStyleFor("link")?.color?.let { linkColor = it }
-
-    setPadding(
-      (styles.paddingLeft * density).toInt(),
-      (styles.paddingTop * density).toInt(),
-      (styles.paddingRight * density).toInt(),
-      (styles.paddingBottom * density).toInt(),
-    )
-    styles.backgroundColor?.let { setBackgroundColor(it) }
-
-    publishHeight()
-  }
-
-  // Autocorrect/autocapitalize/suggestions are suppressed while the caret
-  // is in a code context (`let` must not become `Let`).
-  private var codeContextActive = false
-
-  private fun lineIsCode(line: Int): Boolean =
-    EditorBlocks.type(lineBlocks.getOrElse(line) { 0 }) == EditorBlocks.CODE
-
-  private fun caretInCodeContext(): Boolean {
-    if (pendingMarks and EditorMarks.INLINE_CODE != 0) {
-      return true
-    }
-    return lineIsCode(lineIndexAt(selectionStart.coerceAtLeast(0)))
-  }
-
-  private fun updateInputTypeForContext() {
-    val inCode = caretInCodeContext()
-    if (inCode != codeContextActive) {
-      codeContextActive = inCode
-      applyInputType()
-    }
-  }
-
-  // Setting inputType resets the typeface, so callers reapply styles after.
-  private fun applyInputType() {
-    var type = InputType.TYPE_CLASS_TEXT
-    if (multiline) {
-      type = type or InputType.TYPE_TEXT_FLAG_MULTI_LINE
-    }
-    if (autoCorrectEnabled && !codeContextActive) {
-      type = type or InputType.TYPE_TEXT_FLAG_AUTO_CORRECT
-    }
-    if (codeContextActive) {
-      type = type or InputType.TYPE_TEXT_FLAG_NO_SUGGESTIONS
-    }
-    type = type or when (if (codeContextActive) "none" else capitalizeMode) {
-      "words" -> InputType.TYPE_TEXT_FLAG_CAP_WORDS
-      "characters" -> InputType.TYPE_TEXT_FLAG_CAP_CHARACTERS
-      "none" -> 0
-      else -> InputType.TYPE_TEXT_FLAG_CAP_SENTENCES
-    }
-    val selection = selectionStart
-    val selectionUpper = selectionEnd
-    inputType = type
-    isSingleLine = !multiline
-    if (selection in 0..text.length && selectionUpper in selection..text.length) {
-      setSelection(selection, selectionUpper)
-    }
-    applyTextStyles()
-  }
-
-  fun setStylesJson(value: String?) {
-    val json = value ?: ""
-    if (json != stylesJson) {
-      stylesJson = json
-      applyTextStyles()
-      // Existing derived spans carry the OLD line heights / link color; a
-      // theme change must restyle content that is already there.
-      refreshDisplaySpans(text)
-      invalidate()
-    }
-  }
-
-  fun setDefaultValue(value: String?) {
-    if (!defaultValueApplied) {
-      defaultValueApplied = true
-      if (!value.isNullOrEmpty()) {
-        setMarkdownValue(value)
-      }
-    }
-  }
-
-  /** Parsed as markdown into text + inline-mark spans + line blocks. */
-  fun setMarkdownValue(markdown: String) {
-    val decoded = JetMarkdownNative.editorFromMarkdown(markdown)
-    suppressWatcher = true
-    setText(decoded.text)
-    suppressWatcher = false
-    val editable = text
-    applyRuns(editable, decoded.runs)
-    for ((index, url) in decoded.linkUrls.withIndex()) {
-      val start = decoded.linkRanges[index * 2].coerceIn(0, editable.length)
-      val end = decoded.linkRanges[index * 2 + 1].coerceIn(start, editable.length)
-      if (end > start) {
-        editable.setSpan(
-          LinkDataSpan(url, atomic = false),
-          start,
-          end,
-          Spanned.SPAN_EXCLUSIVE_EXCLUSIVE,
-        )
-      }
-    }
-    lineBlocks.clear()
-    var index = 0
-    while (index + 2 <= decoded.lineBlocks.size) {
-      lineBlocks.add(
-        EditorBlocks.pack(decoded.lineBlocks[index], decoded.lineBlocks[index + 1]),
-      )
-      index += 2
-    }
-    ensureLineBlocks()
-    refreshDisplaySpans(editable)
-    setSelection(text.length)
-    emitContentChanged()
-    emitState()
-  }
-
-  private fun applyRuns(editable: Editable, runs: IntArray) {
-    var index = 0
-    while (index + 3 <= runs.size) {
-      val start = runs[index].coerceIn(0, editable.length)
-      val end = runs[index + 1].coerceIn(start, editable.length)
-      val flags = runs[index + 2]
-      if (end > start) {
-        for (mark in EditorMarks.ALL) {
-          if (flags and mark != 0) {
-            editable.setSpan(
-              EditorMarkSpan(mark),
-              start,
-              end,
-              Spanned.SPAN_EXCLUSIVE_EXCLUSIVE,
-            )
-          }
-        }
-      }
-      index += 3
-    }
-  }
-
-  private fun countNewlines(s: CharSequence, from: Int, to: Int): Int {
-    var count = 0
-    for (i in from.coerceAtLeast(0) until to.coerceAtMost(s.length)) {
-      if (s[i] == '\n') {
-        count++
-      }
-    }
-    return count
-  }
-
-  private fun lineCount(): Int = countNewlines(text, 0, text.length) + 1
-
-  private fun lineIndexAt(offset: Int): Int = countNewlines(text, 0, offset)
-
-  private fun lineStartOffset(index: Int): Int {
-    var start = 0
-    var line = 0
-    while (line < index) {
-      val newline = text.indexOf('\n', start)
-      if (newline == -1) {
-        return text.length
-      }
-      start = newline + 1
-      line++
-    }
-    return start
-  }
-
-  private fun lineContentRange(index: Int): IntRange {
-    val start = lineStartOffset(index)
-    val newline = text.indexOf('\n', start)
-    val end = if (newline == -1) text.length else newline
-    return start until end
-  }
-
-  private fun ensureLineBlocks() {
-    val count = lineCount()
-    while (lineBlocks.size < count) {
-      lineBlocks.add(0)
-    }
-    while (lineBlocks.size > count) {
-      lineBlocks.removeAt(lineBlocks.size - 1)
-    }
-  }
-
-  // Keeps lineBlocks aligned as the edit adds/removes lines: new lines
-  // inherit the edited line's block so lists and quotes continue on Enter.
-  private fun spliceLineBlocks() {
-    if (lineBlocks.isEmpty()) {
-      ensureLineBlocks()
-      return
-    }
-    val anchor = editLine.coerceIn(0, lineBlocks.size - 1)
-    val inherited = lineBlocks[anchor]
-    repeat(removedNewlines) {
-      if (anchor + 1 < lineBlocks.size) {
-        lineBlocks.removeAt(anchor + 1)
-      }
-    }
-    repeat(insertedNewlines) {
-      lineBlocks.add((anchor + 1).coerceAtMost(lineBlocks.size), inherited)
-    }
-    ensureLineBlocks()
-  }
-
-  /** Toggles a block over every line the selection touches. */
-  fun toggleBlock(type: Int, level: Int) {
-    ensureLineBlocks()
-    val target = EditorBlocks.pack(type, level)
-    val startLine = lineIndexAt(selectionStart.coerceAtLeast(0))
-    val endLine = lineIndexAt(selectionEnd.coerceAtLeast(selectionStart.coerceAtLeast(0)))
-    val all = (startLine..endLine).all { lineBlocks.getOrElse(it) { 0 } == target }
-    val next = if (all) 0 else target
-    for (index in startLine..endLine) {
-      if (index < lineBlocks.size) {
-        lineBlocks[index] = next
-      }
-    }
-    if (EditorBlocks.type(next) == EditorBlocks.CODE) {
-      // A code fence carries raw text only: inline marks and links on the
-      // converted lines would be dropped by the serializer, so shed them
-      // now rather than displaying formatting that cannot survive.
-      val editable = text
-      val rangeStart = lineStartOffset(startLine)
-      val rangeEnd = lineContentRange(endLine).last + 1
-      for (mark in EditorMarks.ALL) {
-        removeMark(editable, mark, rangeStart, rangeEnd)
-      }
-      for (span in editable.getSpans(rangeStart, rangeEnd, LinkDataSpan::class.java)) {
-        editable.removeSpan(span)
-      }
-      pendingMarks = 0
-    }
-    refreshDisplaySpans(text)
-    updateInputTypeForContext()
-    invalidate()
-    emitContentChanged()
-    emitState()
-  }
-
-  // Backspace at the start of a formatted line clears the block first
-  // (intercepted at the InputConnection level; TextWatcher cannot veto).
-  override fun onCreateInputConnection(outAttrs: android.view.inputmethod.EditorInfo):
-    android.view.inputmethod.InputConnection? {
-    val base = super.onCreateInputConnection(outAttrs) ?: return null
-    return object : android.view.inputmethod.InputConnectionWrapper(base, true) {
-      override fun deleteSurroundingText(beforeLength: Int, afterLength: Int): Boolean {
-        if (beforeLength == 1 && afterLength == 0 && interceptBackspace()) {
-          return true
-        }
-        return super.deleteSurroundingText(beforeLength, afterLength)
-      }
-
-      override fun sendKeyEvent(event: android.view.KeyEvent): Boolean {
-        if (event.action == android.view.KeyEvent.ACTION_DOWN &&
-          event.keyCode == android.view.KeyEvent.KEYCODE_DEL &&
-          interceptBackspace()
-        ) {
-          return true
-        }
-        return super.sendKeyEvent(event)
-      }
-    }
-  }
-
-  private fun interceptBackspace(): Boolean {
-    val start = selectionStart
-    if (start != selectionEnd || start < 0) {
-      return false
-    }
-    val editable = text
-    if (start > 0) {
-      // Backspacing into an atomic token removes the whole token.
-      for (span in editable.getSpans(start - 1, start, LinkDataSpan::class.java)) {
-        if (!span.atomic) {
-          continue
-        }
-        val spanStart = editable.getSpanStart(span)
-        val spanEnd = editable.getSpanEnd(span)
-        if (start - 1 in spanStart until spanEnd) {
-          editable.removeSpan(span)
-          editable.delete(spanStart, spanEnd)
-          return true
-        }
-      }
-    }
-    // Backspace at a line start (including the document start) clears the
-    // line's block before deleting anything.
-    if (start > 0 && text[start - 1] != '\n') {
-      return false
-    }
-    val line = lineIndexAt(start)
-    if (lineBlocks.getOrElse(line) { 0 } == 0) {
-      return false
-    }
-    lineBlocks[line] = 0
-    refreshDisplaySpans(text)
-    updateInputTypeForContext()
-    invalidate()
-    emitContentChanged()
-    emitState()
-    return true
-  }
-
-  // Paste never inserts directly: the clipboard is reported to JS, which
-  // owns the default insertion (via insertMarkdown) unless prevented.
-  override fun onTextContextMenuItem(id: Int): Boolean {
-    if (id == android.R.id.paste || id == android.R.id.pasteAsPlainText) {
-      reportPaste()
-      return true
-    }
-    return super.onTextContextMenuItem(id)
-  }
-
-  private fun reportPaste() {
-    val clipboard =
-      context.getSystemService(Context.CLIPBOARD_SERVICE) as? android.content.ClipboardManager
-    val clip = clipboard?.primaryClip ?: return
-    var textContent = ""
-    val images = Arguments.createArray()
-    for (index in 0 until clip.itemCount) {
-      val item = clip.getItemAt(index)
-      val uri = item.uri
-      if (uri != null) {
-        val options = android.graphics.BitmapFactory.Options().apply {
-          inJustDecodeBounds = true
-        }
-        runCatching {
-          context.contentResolver.openInputStream(uri)?.use { stream ->
-            android.graphics.BitmapFactory.decodeStream(stream, null, options)
-          }
-        }
-        if (options.outWidth > 0) {
-          images.pushMap(
-            Arguments.createMap().apply {
-              putString("url", uri.toString())
-              putDouble("width", options.outWidth.toDouble())
-              putDouble("height", options.outHeight.toDouble())
-            },
-          )
-          continue
-        }
-      }
-      if (textContent.isEmpty()) {
-        textContent = item.coerceToText(context)?.toString() ?: ""
-      }
-    }
-    emitEvent("topEditorPaste") {
-      putString("text", textContent)
-      putArray("images", images)
-    }
-  }
-
-  /** Parses markdown and inserts it at the cursor / over the selection. */
-  fun insertMarkdownAt(markdown: String) {
-    if (markdown.isEmpty()) {
-      return
-    }
-    val decoded = JetMarkdownNative.editorFromMarkdown(markdown)
-    val start = selectionStart.coerceAtLeast(0)
-    val end = selectionEnd.coerceAtLeast(start)
-    val startLine = lineIndexAt(start)
-    val editable = text
-    val removedLines = countNewlines(editable, start, end)
-    val decodedLineCount = decoded.lineBlocks.size / 2
-    suppressWatcher = true
-    editable.replace(start, end, decoded.text)
-    suppressWatcher = false
-    // The replace ran under suppressWatcher, so the watcher's lineBlocks
-    // splice never happened. Splice here or every line AFTER the paste
-    // point keeps a stale block entry (a heading below the caret would be
-    // silently stripped by the block-copy loop overwriting shifted
-    // indices).
-    repeat(removedLines) {
-      if (startLine + 1 < lineBlocks.size) {
-        lineBlocks.removeAt(startLine + 1)
-      }
-    }
-    repeat((decodedLineCount - 1).coerceAtLeast(0)) {
-      lineBlocks.add((startLine + 1).coerceAtMost(lineBlocks.size), 0)
-    }
-    ensureLineBlocks()
-
-    var runIndex = 0
-    while (runIndex + 3 <= decoded.runs.size) {
-      val runStart = (decoded.runs[runIndex] + start).coerceIn(0, editable.length)
-      val runEnd = (decoded.runs[runIndex + 1] + start).coerceIn(runStart, editable.length)
-      val flags = decoded.runs[runIndex + 2]
-      if (runEnd > runStart) {
-        for (mark in EditorMarks.ALL) {
-          if (flags and mark != 0) {
-            editable.setSpan(
-              EditorMarkSpan(mark),
-              runStart,
-              runEnd,
-              Spanned.SPAN_EXCLUSIVE_EXCLUSIVE,
-            )
-          }
-        }
-      }
-      runIndex += 3
-    }
-    for ((index, url) in decoded.linkUrls.withIndex()) {
-      val linkStart = (decoded.linkRanges[index * 2] + start).coerceIn(0, editable.length)
-      val linkEnd =
-        (decoded.linkRanges[index * 2 + 1] + start).coerceIn(linkStart, editable.length)
-      if (linkEnd > linkStart) {
-        editable.setSpan(
-          LinkDataSpan(url, atomic = false),
-          linkStart,
-          linkEnd,
-          Spanned.SPAN_EXCLUSIVE_EXCLUSIVE,
-        )
-      }
-    }
-    for (k in 0 until decodedLineCount) {
-      val lineIndex = startLine + k
-      if (lineIndex >= lineBlocks.size) {
-        break
-      }
-      val block = EditorBlocks.pack(decoded.lineBlocks[k * 2], decoded.lineBlocks[k * 2 + 1])
-      // The first pasted line joins the current line; its existing block
-      // wins unless it is a plain paragraph.
-      if (k > 0 || lineBlocks[lineIndex] == 0) {
-        lineBlocks[lineIndex] = block
-      }
-    }
-
-    refreshDisplaySpans(editable)
-    setSelection((start + decoded.text.length).coerceAtMost(editable.length))
-    emitContentChanged()
-    emitState()
-  }
-
-  // Hardware keyboard formatting shortcuts (Ctrl+B / Ctrl+I).
-  override fun onKeyShortcut(keyCode: Int, event: android.view.KeyEvent): Boolean {
-    when (keyCode) {
-      android.view.KeyEvent.KEYCODE_B -> {
-        toggleMark(EditorMarks.BOLD)
-        return true
-      }
-      android.view.KeyEvent.KEYCODE_I -> {
-        toggleMark(EditorMarks.ITALIC)
-        return true
-      }
-      else -> return super.onKeyShortcut(keyCode, event)
-    }
-  }
-
-  /** Links the selection, or inserts a linked label at the caret. */
-  fun insertLink(url: String, label: String) {
-    if (url.isEmpty()) {
-      return
-    }
-    val start = selectionStart.coerceAtLeast(0)
-    val end = selectionEnd.coerceAtLeast(start)
-    val editable = text
-    if (start == end) {
-      val content = label.ifEmpty { url }
-      suppressWatcher = true
-      editable.insert(start, content)
-      suppressWatcher = false
-      ensureLineBlocks()
-      editable.setSpan(
-        LinkDataSpan(url, atomic = false),
-        start,
-        start + content.length,
-        Spanned.SPAN_EXCLUSIVE_EXCLUSIVE,
-      )
-      setSelection(start + content.length)
-    } else {
-      editable.setSpan(
-        LinkDataSpan(url, atomic = false),
-        start,
-        end,
-        Spanned.SPAN_EXCLUSIVE_EXCLUSIVE,
-      )
-      setSelection(end)
-    }
-    refreshDisplaySpans(editable)
-    emitContentChanged()
-  }
-
-  /** Removes the link covering the selection or the caret. */
-  fun removeLink() {
-    val start = selectionStart.coerceAtLeast(0)
-    val end = selectionEnd.coerceAtLeast(start)
-    val editable = text
-    val probeStart = if (start == end) (start - 1).coerceAtLeast(0) else start
-    var removed = false
-    for (span in editable.getSpans(probeStart, end, LinkDataSpan::class.java)) {
-      editable.removeSpan(span)
-      removed = true
-    }
-    if (removed) {
-      refreshDisplaySpans(editable)
-      emitContentChanged()
-    }
-  }
-
-  /** Inserts an atomic mention token, replacing any active query. */
-  fun insertMention(trigger: String, label: String, url: String) {
-    if (label.isEmpty() || url.isEmpty()) {
-      return
-    }
-    val editable = text
-    val caret = selectionStart.coerceAtLeast(0)
-    val start = if (mentionActive) mentionStart else caret
-    val end = caret.coerceAtLeast(start)
-    val token = trigger + label
-    suppressWatcher = true
-    editable.replace(start, end, "$token ")
-    suppressWatcher = false
-    ensureLineBlocks()
-    editable.setSpan(
-      LinkDataSpan(url, atomic = true),
-      start,
-      start + token.length,
-      Spanned.SPAN_EXCLUSIVE_EXCLUSIVE,
-    )
-    endMentionSession()
-    setSelection(start + token.length + 1)
-    refreshDisplaySpans(editable)
-    emitContentChanged()
-  }
-
-  private fun endMentionSession() {
-    if (!mentionActive) {
-      return
-    }
-    mentionActive = false
-    lastMentionQuery = null
-    emitEvent("topEditorMentionEnd") { putString("trigger", mentionTrigger) }
-  }
-
-  private fun isWordBreak(c: Char): Boolean = c == ' ' || c == '\t' || c == '\n'
-
-  // Starts, updates, or ends the mention session from the text between the
-  // trigger and the caret.
-  private fun updateMentionSession() {
-    if (mentionTriggers.isEmpty()) {
-      return
-    }
-    val editable = text
-    val start = selectionStart
-    val end = selectionEnd
-    if (start != end || start < 0) {
-      endMentionSession()
-      return
-    }
-
-    if (mentionActive) {
-      var valid = mentionStart < editable.length && start > mentionStart
-      if (valid && mentionTrigger != editable[mentionStart].toString()) {
-        valid = false
-      }
-      var query = ""
-      if (valid) {
-        query = editable.substring(mentionStart + 1, start)
-        if (query.any { isWordBreak(it) }) {
-          valid = false
-        }
-      }
-      if (!valid) {
-        endMentionSession()
-        return
-      }
-      if (query == lastMentionQuery) {
-        return
-      }
-      lastMentionQuery = query
-      emitEvent("topEditorMentionChange") {
-        putString("query", query)
-        putString("trigger", mentionTrigger)
-      }
-      return
-    }
-
-    if (start == 0) {
-      return
-    }
-    val last = editable[start - 1].toString()
-    if (last !in mentionTriggers) {
-      return
-    }
-    if (start >= 2 && !isWordBreak(editable[start - 2])) {
-      return
-    }
-    mentionActive = true
-    mentionTrigger = last
-    mentionStart = start - 1
-    emitEvent("topEditorMentionStart") { putString("trigger", last) }
-  }
-
-  // After a word break lands, reports a bare URL the completed word forms.
-  private fun detectLinkBefore(position: Int) {
-    val editable = text
-    if (position > editable.length) {
-      return
-    }
-    var wordStart = position
-    while (wordStart > 0 && !isWordBreak(editable[wordStart - 1])) {
-      wordStart--
-    }
-    if (wordStart >= position) {
-      return
-    }
-    val word = editable.substring(wordStart, position)
-    if (!word.startsWith("http://") && !word.startsWith("https://")) {
-      return
-    }
-    if (word == "http://" || word == "https://") {
-      return
-    }
-    if (editable.getSpans(wordStart, position, LinkDataSpan::class.java).isNotEmpty()) {
-      return
-    }
-    // Linkify in place: a bare URL re-parses as an autolink in any markdown
-    // renderer, so the editor must show it as a link too (WYSIWYG). The app
-    // can still restyle or remove it from the onLinkDetected callback.
-    if (!lineIsCode(lineIndexAt(wordStart))) {
-      editable.setSpan(
-        LinkDataSpan(word, atomic = false),
-        wordStart,
-        position,
-        Spanned.SPAN_EXCLUSIVE_EXCLUSIVE,
-      )
-      refreshDisplaySpansAround(editable, wordStart, position)
-      emitContentChanged()
-    }
-    emitEvent("topEditorLinkDetected") { putString("url", word) }
-  }
-
-  /** Toggles a mark over the selection, or arms it for typed text. */
-  fun toggleMark(mark: Int) {
-    val start = selectionStart.coerceAtLeast(0)
-    val end = selectionEnd.coerceAtLeast(start)
-    // A code fence carries raw text only — marks applied there would render
-    // in the editor but silently vanish from the markdown, so refuse them.
-    for (line in lineIndexAt(start)..lineIndexAt(end)) {
-      if (EditorBlocks.type(lineBlocks.getOrElse(line) { 0 }) == EditorBlocks.CODE) {
-        return
-      }
-    }
-    // Superscript and subscript are mutually exclusive: a glyph cannot sit
-    // above and below the baseline, and combined they serialize to nested
-    // ^~…~^ that does not round-trip.
-    val exclusive = when (mark) {
-      EditorMarks.SUPERSCRIPT -> EditorMarks.SUBSCRIPT
-      EditorMarks.SUBSCRIPT -> EditorMarks.SUPERSCRIPT
-      else -> 0
-    }
-    if (start == end) {
-      pendingMarks = pendingMarks xor mark
-      if (pendingMarks and mark != 0) {
-        pendingMarks = pendingMarks and exclusive.inv()
-      }
-      pendingArmedAt = start
-      updateInputTypeForContext()
-      emitState()
-      return
-    }
-    val editable = text
-    if (commonMarksInRange(editable, start, end) and mark != 0) {
-      removeMark(editable, mark, start, end)
-    } else {
-      if (exclusive != 0) {
-        removeMark(editable, exclusive, start, end)
-      }
-      applyMark(editable, mark, start, end)
-    }
-    refreshDisplaySpans(editable)
-    setSelection(start, end)
-    emitContentChanged()
-    emitState()
-  }
-
-  /** Adds a mark over [start, end), merging with touching same-mark spans. */
-  private fun applyMark(editable: Editable, mark: Int, start: Int, end: Int) {
-    var newStart = start
-    var newEnd = end
-    for (span in editable.getSpans(start, end, EditorMarkSpan::class.java)) {
-      if (span.mark != mark) {
-        continue
-      }
-      newStart = minOf(newStart, editable.getSpanStart(span))
-      newEnd = maxOf(newEnd, editable.getSpanEnd(span))
-      editable.removeSpan(span)
-    }
-    editable.setSpan(
-      EditorMarkSpan(mark),
-      newStart,
-      newEnd,
-      Spanned.SPAN_EXCLUSIVE_EXCLUSIVE,
-    )
-  }
-
-  private fun removeMark(editable: Editable, mark: Int, start: Int, end: Int) {
-    for (span in editable.getSpans(start, end, EditorMarkSpan::class.java)) {
-      if (span.mark != mark) {
-        continue
-      }
-      val spanStart = editable.getSpanStart(span)
-      val spanEnd = editable.getSpanEnd(span)
-      editable.removeSpan(span)
-      if (spanStart < start) {
-        editable.setSpan(
-          EditorMarkSpan(mark),
-          spanStart,
-          start,
-          Spanned.SPAN_EXCLUSIVE_EXCLUSIVE,
-        )
-      }
-      if (spanEnd > end) {
-        editable.setSpan(
-          EditorMarkSpan(mark),
-          end,
-          spanEnd,
-          Spanned.SPAN_EXCLUSIVE_EXCLUSIVE,
-        )
-      }
-    }
-  }
-
-  /** Marks present across the ENTIRE range (the AND). */
-  private fun commonMarksInRange(editable: Editable, start: Int, end: Int): Int {
-    var common = 0
-    for (mark in EditorMarks.ALL) {
-      val intervals = editable.getSpans(start, end, EditorMarkSpan::class.java)
-        .filter { it.mark == mark }
-        .map { editable.getSpanStart(it) to editable.getSpanEnd(it) }
-        .sortedBy { it.first }
-      var covered = start
-      for ((spanStart, spanEnd) in intervals) {
-        if (spanStart > covered) {
-          break
-        }
-        covered = maxOf(covered, spanEnd)
-      }
-      if (covered >= end) {
-        common = common or mark
-      }
-    }
-    return common
-  }
-
-  private fun marksAt(editable: Editable, position: Int): Int {
-    if (position < 0 || position >= editable.length) {
-      return 0
-    }
-    var flags = 0
-    for (span in editable.getSpans(position, position + 1, EditorMarkSpan::class.java)) {
-      if (editable.getSpanStart(span) <= position && editable.getSpanEnd(span) > position) {
-        flags = flags or span.mark
-      }
-    }
-    return flags
-  }
-
-  /**
-   * Rebuilds the derived visual spans inside [regionStart, regionEnd):
-   * inline spans from the data mark spans (boundary points partition the
-   * text into constant-flag intervals), and per-line block spans from
-   * lineBlocks. The default region is the whole document.
-   */
-  private fun refreshDisplaySpans(
-    editable: Editable,
-    regionStart: Int = 0,
-    regionEnd: Int = editable.length,
-  ) {
-    for (span in editable.getSpans(regionStart, regionEnd, EditorDerivedSpan::class.java)) {
-      if (editable.getSpanStart(span) < regionEnd && editable.getSpanEnd(span) > regionStart) {
-        editable.removeSpan(span)
-      }
-    }
-
-    for (span in editable.getSpans(regionStart, regionEnd, LinkDataSpan::class.java)) {
-      val start = editable.getSpanStart(span)
-      val end = editable.getSpanEnd(span)
-      if (start >= regionEnd || end <= regionStart) {
-        continue
-      }
-      if (end > start) {
-        editable.setSpan(
-          LinkDisplaySpan(linkColor),
-          start,
-          end,
-          Spanned.SPAN_EXCLUSIVE_EXCLUSIVE,
-        )
-      }
-    }
-
-    val marks = editable.getSpans(regionStart, regionEnd, EditorMarkSpan::class.java)
-      .filter { editable.getSpanStart(it) < regionEnd && editable.getSpanEnd(it) > regionStart }
-    if (marks.isNotEmpty()) {
-      // Sweep over sorted edges instead of rescanning every mark span per
-      // interval (that scan was O(spans²) per keystroke).
-      val starts = marks.map { editable.getSpanStart(it).coerceIn(0, editable.length) to it.mark }
-        .sortedBy { it.first }
-      val ends = marks.map { editable.getSpanEnd(it).coerceIn(0, editable.length) to it.mark }
-        .sortedBy { it.first }
-      val cuts = sortedSetOf(regionStart, regionEnd)
-      for ((position, _) in starts) {
-        cuts.add(position)
-      }
-      for ((position, _) in ends) {
-        cuts.add(position)
-      }
-      val bitCounts = IntArray(32)
-      var startIdx = 0
-      var endIdx = 0
-      var active = 0
-      val points = cuts.toIntArray()
-      for (i in 0 until points.size - 1) {
-        val start = points[i]
-        val end = points[i + 1]
-        if (end <= start) {
-          continue
-        }
-        while (endIdx < ends.size && ends[endIdx].first <= start) {
-          val mark = ends[endIdx].second
-          for (bit in 0 until 32) {
-            if (mark and (1 shl bit) != 0 && --bitCounts[bit] == 0) {
-              active = active and (1 shl bit).inv()
-            }
-          }
-          endIdx++
-        }
-        while (startIdx < starts.size && starts[startIdx].first <= start) {
-          val mark = starts[startIdx].second
-          for (bit in 0 until 32) {
-            if (mark and (1 shl bit) != 0 && bitCounts[bit]++ == 0) {
-              active = active or (1 shl bit)
-            }
-          }
-          startIdx++
-        }
-        if (active != 0) {
-          editable.setSpan(
-            EditorDisplaySpan(active),
-            start,
-            end,
-            Spanned.SPAN_EXCLUSIVE_EXCLUSIVE,
-          )
-        }
-      }
-    }
-
-    ensureLineBlocks()
-    var lineStart = lineStartOffset(lineIndexAt(regionStart))
-    var index = lineIndexAt(regionStart)
-    // Ordered markers number from the start of their contiguous group,
-    // which may sit before the region; recover the count from lineBlocks.
-    var orderedNumber = 0
-    var probe = index - 1
-    while (probe >= 0 && EditorBlocks.type(lineBlocks.getOrElse(probe) { 0 }) == EditorBlocks.ORDERED) {
-      orderedNumber++
-      probe--
-    }
-    while (true) {
-      val newline = editable.indexOf('\n', lineStart)
-      val lineEnd = if (newline == -1) editable.length else newline
-      val block = lineBlocks.getOrElse(index) { 0 }
-      val type = EditorBlocks.type(block)
-      orderedNumber = if (type == EditorBlocks.ORDERED) orderedNumber + 1 else 0
-      if (lineEnd > lineStart) {
-        val span: Any? = when (type) {
-          EditorBlocks.HEADING -> HeadingDisplaySpan(EditorBlocks.level(block))
-          EditorBlocks.QUOTE -> QuoteDisplaySpan(density)
-          EditorBlocks.CODE -> CodeLineDisplaySpan()
-          EditorBlocks.BULLET -> ListMarkerDisplaySpan("•", density)
-          EditorBlocks.ORDERED -> ListMarkerDisplaySpan("$orderedNumber.", density)
-          else -> null
-        }
-        if (span != null) {
-          editable.setSpan(span, lineStart, lineEnd, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE)
-        }
-      }
-      if (newline != -1) {
-        // The heading's newline must not extend the heading's font run, or
-        // the trailing empty line's caret inherits heading metrics.
-        if (type == EditorBlocks.HEADING) {
-          editable.setSpan(
-            NewlineResetSpan(),
-            newline,
-            newline + 1,
-            Spanned.SPAN_EXCLUSIVE_EXCLUSIVE,
-          )
-        }
-      }
-      // Line height from the styles cascade: headings/code use their
-      // element style, everything else base/paragraph (0 = natural).
-      val lineHeight = when (type) {
-        EditorBlocks.HEADING -> headingLineHeightsPx[EditorBlocks.level(block).coerceIn(1, 6)]
-        EditorBlocks.CODE -> codeLineHeightPx
-        else -> lineHeightPx
-      }
-      val spanEnd = if (newline == -1) lineEnd else newline + 1
-      if (lineHeight > 0 && spanEnd > lineStart) {
-        editable.setSpan(
-          EditorLineHeightSpan(lineHeight),
-          lineStart,
-          spanEnd,
-          Spanned.SPAN_EXCLUSIVE_EXCLUSIVE,
-        )
-      }
-      if (newline == -1 || newline + 1 >= regionEnd) {
-        break
-      }
-      lineStart = newline + 1
-      index++
-    }
-  }
-
-  /**
-   * Scoped refresh for plain in-line keystrokes: expands the edit to whole
-   * lines plus any span it touches, so derived spans elsewhere (and their
-   * DynamicLayout reflows) are left alone. Structural edits (newlines,
-   * empty doc) take the full-document path — ordered-list renumbering can
-   * ripple arbitrarily far.
-   */
-  private fun refreshDisplaySpansAround(editable: Editable, editStart: Int, editEnd: Int) {
-    var start = editStart.coerceIn(0, editable.length)
-    var end = editEnd.coerceIn(start, editable.length)
-    while (true) {
-      var expandedStart = start
-      var expandedEnd = end
-      // getSpans also returns spans merely TOUCHING the probe; absorbing
-      // those would chain across adjacent line-height spans to the whole
-      // document, so only strict overlaps expand the region.
-      for (span in editable.getSpans(start, end, EditorDerivedSpan::class.java)) {
-        if (editable.getSpanStart(span) < end && editable.getSpanEnd(span) > start) {
-          expandedStart = minOf(expandedStart, editable.getSpanStart(span))
-          expandedEnd = maxOf(expandedEnd, editable.getSpanEnd(span))
-        }
-      }
-      for (span in editable.getSpans(start, end, EditorMarkSpan::class.java)) {
-        if (editable.getSpanStart(span) < end && editable.getSpanEnd(span) > start) {
-          expandedStart = minOf(expandedStart, editable.getSpanStart(span))
-          expandedEnd = maxOf(expandedEnd, editable.getSpanEnd(span))
-        }
-      }
-      for (span in editable.getSpans(start, end, LinkDataSpan::class.java)) {
-        if (editable.getSpanStart(span) < end && editable.getSpanEnd(span) > start) {
-          expandedStart = minOf(expandedStart, editable.getSpanStart(span))
-          expandedEnd = maxOf(expandedEnd, editable.getSpanEnd(span))
-        }
-      }
-      while (expandedStart > 0 && editable[expandedStart - 1] != '\n') {
-        expandedStart--
-      }
-      while (expandedEnd < editable.length && editable[expandedEnd] != '\n') {
-        expandedEnd++
-      }
-      if (expandedEnd < editable.length) {
-        // Include the newline: line-height spans cover it.
-        expandedEnd++
-      }
-      if (expandedStart == start && expandedEnd == end) {
-        break
-      }
-      start = expandedStart.coerceIn(0, editable.length)
-      end = expandedEnd.coerceIn(start, editable.length)
-    }
-    refreshDisplaySpans(editable, start, end)
-  }
-
-  private fun serializedMarkdown(): String {
-    val editable = text
-    val spans = editable.getSpans(0, editable.length, EditorMarkSpan::class.java)
-    val runs = IntArray(spans.size * 3)
-    for ((index, span) in spans.withIndex()) {
-      runs[index * 3] = editable.getSpanStart(span)
-      runs[index * 3 + 1] = editable.getSpanEnd(span)
-      runs[index * 3 + 2] = span.mark
-    }
-    ensureLineBlocks()
-    val blocks = IntArray(lineBlocks.size * 2)
-    for ((index, block) in lineBlocks.withIndex()) {
-      blocks[index * 2] = EditorBlocks.type(block)
-      blocks[index * 2 + 1] = EditorBlocks.level(block)
-    }
-    val links = editable.getSpans(0, editable.length, LinkDataSpan::class.java)
-      .sortedBy { editable.getSpanStart(it) }
-    val linkRanges = IntArray(links.size * 2)
-    val linkUrls = ArrayList<String>(links.size)
-    for ((index, span) in links.withIndex()) {
-      linkRanges[index * 2] = editable.getSpanStart(span)
-      linkRanges[index * 2 + 1] = editable.getSpanEnd(span)
-      linkUrls.add(span.url)
-    }
-    return JetMarkdownNative.markdownFromEditor(
-      editable.toString(),
-      runs,
-      blocks,
-      linkRanges,
-      linkUrls,
-    )
-  }
-
-  private var markdownEmitPending = false
-
-  private fun emitContentChanged() {
-    publishHeight()
-    emitEvent("topEditorChangeText") { putString("text", text.toString()) }
-    // Serializing the whole document (spans + JNI round trip) per keystroke
-    // is the expensive half; coalesce bursts to one emission per frame.
-    if (!markdownEmitPending) {
-      markdownEmitPending = true
-      post {
-        markdownEmitPending = false
-        if (stateWrapper != null) {
-          emitEvent("topEditorChangeMarkdown") { putString("markdown", serializedMarkdown()) }
-        }
-      }
-    }
-  }
-
-  private fun emitState() {
-    val start = selectionStart.coerceAtLeast(0)
-    val end = selectionEnd.coerceAtLeast(start)
-    val flags = if (start == end) pendingMarks else commonMarksInRange(text, start, end)
-    val block = lineBlocks.getOrElse(lineIndexAt(start)) { 0 }
-    val stateKey = (block.toLong() shl 32) or flags.toLong()
-    if (stateKey == lastStateKey) {
-      return
-    }
-    lastStateKey = stateKey
-    val type = EditorBlocks.type(block)
-    emitEvent("topEditorChangeState") {
-      putInt(
-        "headingLevel",
-        if (type == EditorBlocks.HEADING) EditorBlocks.level(block) else 0,
-      )
-      putBoolean("isBlockQuote", type == EditorBlocks.QUOTE)
-      putBoolean("isBold", flags and EditorMarks.BOLD != 0)
-      putBoolean("isCodeBlock", type == EditorBlocks.CODE)
-      putBoolean("isInlineCode", flags and EditorMarks.INLINE_CODE != 0)
-      putBoolean("isItalic", flags and EditorMarks.ITALIC != 0)
-      putBoolean("isOrderedList", type == EditorBlocks.ORDERED)
-      putBoolean("isSpoiler", flags and EditorMarks.SPOILER != 0)
-      putBoolean("isStrikethrough", flags and EditorMarks.STRIKETHROUGH != 0)
-      putBoolean("isSubscript", flags and EditorMarks.SUBSCRIPT != 0)
-      putBoolean("isSuperscript", flags and EditorMarks.SUPERSCRIPT != 0)
-      putBoolean("isUnorderedList", type == EditorBlocks.BULLET)
-    }
-  }
-
-  fun setMultiline(value: Boolean) {
-    if (multiline != value) {
-      multiline = value
-      applyInputType()
-    }
-  }
-
-  fun setAutoCorrectEnabled(value: Boolean) {
-    if (autoCorrectEnabled != value) {
-      autoCorrectEnabled = value
-      applyInputType()
-    }
-  }
-
-  fun setCapitalizeMode(value: String?) {
-    val mode = value ?: "sentences"
-    if (capitalizeMode != mode) {
-      capitalizeMode = mode
-      applyInputType()
-    }
-  }
-
-  fun setPlaceholderText(value: String?) {
-    if (placeholderText != value) {
-      placeholderText = value
-      // Fabric never renders TextView's own hint (drawn manually in
-      // onDraw), but TalkBack still announces it.
-      hint = value
-      invalidate()
-    }
-  }
-
-  fun setPlaceholderColor(value: Int) {
-    val next = if (value != 0) value else DEFAULT_PLACEHOLDER_COLOR
-    if (placeholderColor != next) {
-      placeholderColor = next
-      invalidate()
-    }
-  }
-
-  private val decorationPaint = Paint(Paint.ANTI_ALIAS_FLAG)
-  private val decorationTextPaint = TextPaint(Paint.ANTI_ALIAS_FLAG)
-  private val placeholderMetrics = Paint.FontMetrics()
-
-  override fun onDraw(canvas: Canvas) {
-    drawBlockDecorations(canvas)
-    super.onDraw(canvas)
-    val hint = placeholderText
-    if (!hint.isNullOrEmpty() && text.isEmpty()) {
-      placeholderPaint.textSize = textSize
-      placeholderPaint.typeface = typeface
-      placeholderPaint.color = placeholderColor
-      placeholderPaint.getFontMetrics(placeholderMetrics)
-      canvas.drawText(
-        hint,
-        compoundPaddingLeft.toFloat(),
-        compoundPaddingTop - placeholderMetrics.top,
-        placeholderPaint,
-      )
-    }
-  }
-
-  /**
-   * Block visuals spans cannot provide: the full-width code stripe (drawn
-   * per contiguous code GROUP, empty lines included) and markers/bars for
-   * empty block lines (spans need at least one character).
-   */
-  private fun drawBlockDecorations(canvas: Canvas) {
-    val textLayout = layout ?: return
-    // Plain-paragraph documents (the common case) draw nothing; skip the
-    // per-line text scan the cursor-blink invalidations would otherwise pay.
-    if (lineBlocks.none { it != 0 }) {
-      return
-    }
-    val offsetY = compoundPaddingTop.toFloat()
-    val contentLeft = compoundPaddingLeft.toFloat()
-    val stripeLeft = (contentLeft - 6 * density).coerceAtLeast(0f)
-    val stripeRight =
-      (width - compoundPaddingRight + 6 * density).coerceAtMost(width.toFloat())
-    val markerColor = (currentTextColor and 0x00FFFFFF) or -0x67000000
-
-    var lineStart = 0
-    var index = 0
-    var orderedNumber = 0
-    var groupTop = -1f
-    var groupBottom = 0f
-
-    fun flushCodeGroup() {
-      if (groupTop >= 0f) {
-        decorationPaint.color = 0x14808080
-        canvas.drawRoundRect(
-          stripeLeft,
-          groupTop - 2 * density,
-          stripeRight,
-          groupBottom + 2 * density,
-          6 * density,
-          6 * density,
-          decorationPaint,
-        )
-        groupTop = -1f
-      }
-    }
-
-    while (true) {
-      val newline = text.indexOf('\n', lineStart)
-      val lineEnd = if (newline == -1) text.length else newline
-      val block = lineBlocks.getOrElse(index) { 0 }
-      val type = EditorBlocks.type(block)
-      orderedNumber = if (type == EditorBlocks.ORDERED) orderedNumber + 1 else 0
-
-      val layoutLine = textLayout.getLineForOffset(lineStart)
-      val top = textLayout.getLineTop(layoutLine) + offsetY
-      val bottom =
-        textLayout.getLineBottom(textLayout.getLineForOffset(lineEnd)) + offsetY
-
-      if (type == EditorBlocks.CODE) {
-        if (groupTop < 0f) {
-          groupTop = top
-        }
-        groupBottom = bottom
-      } else {
-        flushCodeGroup()
-      }
-
-      if (lineEnd == lineStart && block != 0) {
-        when (type) {
-          EditorBlocks.QUOTE -> {
-            decorationPaint.color = markerColor
-            val barLeft = contentLeft + 4 * density
-            canvas.drawRect(barLeft, top, barLeft + 3 * density, bottom, decorationPaint)
-          }
-          EditorBlocks.BULLET, EditorBlocks.ORDERED -> {
-            val marker = if (type == EditorBlocks.BULLET) "•" else "$orderedNumber."
-            decorationTextPaint.textSize = textSize
-            decorationTextPaint.typeface = typeface
-            decorationTextPaint.color = markerColor
-            val markerWidth = decorationTextPaint.measureText(marker)
-            canvas.drawText(
-              marker,
-              contentLeft + (24 - 6) * density - markerWidth,
-              textLayout.getLineBaseline(layoutLine) + offsetY,
-              decorationTextPaint,
-            )
-          }
-          else -> Unit
-        }
-      }
-
-      if (newline == -1) {
-        break
-      }
-      lineStart = newline + 1
-      index++
-    }
-    flushCodeGroup()
-  }
-
-  fun setCursorColorInt(value: Int) {
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-      if (value != 0) {
-        textCursorDrawable?.setTint(value)
-      } else {
-        textCursorDrawable?.setTintList(null)
-      }
-    }
-  }
-
-  fun setSelectionColorInt(value: Int) {
-    highlightColor = if (value != 0) value else defaultHighlightColor
-  }
-
-  fun setAutoFocus(value: Boolean) {
-    pendingAutoFocus = value
-    if (value && isAttachedToWindow) {
-      focusAndShowKeyboard()
-    }
-  }
-
-  fun setEditorSelection(start: Int, end: Int) {
-    val length = text.length
-    val clampedStart = start.coerceIn(0, length)
-    val clampedEnd = end.coerceIn(clampedStart, length)
-    setSelection(clampedStart, clampedEnd)
-  }
-
-  fun focusAndShowKeyboard() {
-    requestFocus()
-    val manager =
-      context.getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager
-    manager?.showSoftInput(this, InputMethodManager.SHOW_IMPLICIT)
-  }
-
-  fun blurAndHideKeyboard() {
-    clearFocus()
-    val manager =
-      context.getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager
-    manager?.hideSoftInputFromWindow(windowToken, 0)
-  }
-
-  fun resetForRecycle() {
-    // The next tenant's props arrive after this; every prop-backed field
-    // must return to its default or state leaks between list items. The
-    // clear runs watcher-silent: emitting change events for a view being
-    // recycled would reach the OLD component's JS handlers.
-    stateWrapper = null
-    suppressWatcher = true
-    setText("")
-    suppressWatcher = false
-    stylesJson = ""
-    defaultValueApplied = false
-    pendingAutoFocus = false
-    lastPublishedHeight = 0f
-    maxHeightPx = 0
-    contentExceedsMax = false
-    scrollAllowed = true
-    isVerticalScrollBarEnabled = false
-    pendingMarks = 0
-    pendingArmedAt = -1
-    lastStateKey = -1L
-    lineBlocks.clear()
-    ensureLineBlocks()
-    mentionActive = false
-    lastMentionQuery = null
-    mentionTriggers = emptyList()
-    placeholderText = null
-    hint = null
-    placeholderColor = DEFAULT_PLACEHOLDER_COLOR
-    linkColor = DEFAULT_LINK_COLOR
-    isEnabled = true
-    highlightColor = defaultHighlightColor
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-      textCursorDrawable?.setTintList(null)
-    }
-    val inputDirty = codeContextActive || !multiline || !autoCorrectEnabled ||
-      capitalizeMode != "sentences"
-    codeContextActive = false
-    multiline = true
-    autoCorrectEnabled = true
-    capitalizeMode = "sentences"
-    if (inputDirty) {
-      applyInputType()
-    }
-    applyTextStyles()
-  }
-
-  override fun onAttachedToWindow() {
-    super.onAttachedToWindow()
-    if (pendingAutoFocus) {
-      pendingAutoFocus = false
-      post { focusAndShowKeyboard() }
-    }
-  }
-
-  override fun onSelectionChanged(selStart: Int, selEnd: Int) {
-    super.onSelectionChanged(selStart, selEnd)
-    if (!constructed) {
-      return
-    }
-    // Sticky typing state: inherit the marks of the character before the
-    // caret. Skipped mid-edit — afterTextChanged has not applied the pending
-    // marks to the inserted text yet, so reading here would clear them.
-    // Marks end at the paragraph break: a newline never carries them
-    // forward.
-    if (!editInProgress && selStart == selEnd && text != null &&
-      selStart != pendingArmedAt
-    ) {
-      pendingArmedAt = -1
-      pendingMarks = if (selStart > 0 && text[selStart - 1] == '\n') {
-        0
-      } else {
-        marksAt(text, selStart - 1)
-      }
-      updateInputTypeForContext()
-    }
-    if (!editInProgress) {
-      updateMentionSession()
-    }
-    emitState()
-    emitEvent("topEditorChangeSelection") {
-      putInt("start", selStart)
-      putInt("end", selEnd)
-    }
-  }
-
-  override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
-    super.onLayout(changed, left, top, right, bottom)
-    publishHeight()
-  }
-
-  fun setMaxContentHeight(dp: Double) {
-    val px = (dp * density).toInt()
-    if (px != maxHeightPx) {
-      maxHeightPx = px
-      publishHeight()
-    }
-  }
-
-  override fun onTouchEvent(event: android.view.MotionEvent): Boolean {
-    // While capped, drags scroll the editor's own content — the parent
-    // scroll view must not steal them.
-    if (event.actionMasked == android.view.MotionEvent.ACTION_DOWN &&
-      contentExceedsMax && scrollAllowed
-    ) {
-      parent?.requestDisallowInterceptTouchEvent(true)
-    }
-    return super.onTouchEvent(event)
-  }
-
-  fun setScrollAllowed(value: Boolean) {
-    if (scrollAllowed != value) {
-      scrollAllowed = value
-      isVerticalScrollBarEnabled = contentExceedsMax && scrollAllowed
-    }
-  }
-
-  private fun publishHeight() {
-    val wrapper = stateWrapper ?: return
-    val currentWidth = width
-    if (currentWidth <= 0) {
-      return
-    }
-    measure(
-      MeasureSpec.makeMeasureSpec(currentWidth, MeasureSpec.EXACTLY),
-      MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED),
-    )
-    var heightPx = measuredHeight
-    contentExceedsMax = maxHeightPx in 1 until heightPx
-    if (contentExceedsMax) {
-      heightPx = maxHeightPx
-    }
-    isVerticalScrollBarEnabled = contentExceedsMax && scrollAllowed
-    val heightDp = heightPx / density
-    if (kotlin.math.abs(heightDp - lastPublishedHeight) < 0.5f) {
-      return
-    }
-    lastPublishedHeight = heightDp
-    wrapper.updateState(Arguments.createMap().apply { putDouble("height", heightDp.toDouble()) })
-  }
-
-  private companion object {
-    const val DEFAULT_PLACEHOLDER_COLOR = 0x4D000000
-    const val DEFAULT_LINK_COLOR = -0xbd5a0b // #4285F5-ish; styles override
-  }
-
-  private inline fun emitEvent(name: String, crossinline builder: WritableMap.() -> Unit) {
-    val reactContext = context as? ReactContext ?: return
-    val dispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, id) ?: return
-    val surfaceId = UIManagerHelper.getSurfaceId(reactContext)
-    dispatcher.dispatchEvent(object : Event<Nothing>(surfaceId, id) {
-      override fun getEventName(): String = name
-
-      override fun getEventData(): WritableMap = Arguments.createMap().apply(builder)
-    })
-  }
-}