@openeditor/react-native-prose-editor 0.0.6 → 0.0.8

package/android/src/main/java/com/apollohg/editor/RenderBridge.kt

@@ -1,2172 +0,0 @@
-package com.openeditor.editor
-
-import android.graphics.Bitmap
-import android.graphics.BitmapFactory
-import android.graphics.Canvas
-import android.graphics.Color
-import android.graphics.Paint
-import android.graphics.RectF
-import android.graphics.Typeface
-import android.util.Base64
-import android.util.Log
-import android.util.LruCache
-import android.text.Annotation
-import android.text.Layout
-import android.text.SpannableStringBuilder
-import android.text.Spanned
-import android.text.style.AbsoluteSizeSpan
-import android.text.style.BackgroundColorSpan
-import android.text.style.ForegroundColorSpan
-import android.text.style.LeadingMarginSpan
-import android.text.style.LineBackgroundSpan
-import android.text.style.LineHeightSpan
-import android.text.style.ReplacementSpan
-import android.text.style.StrikethroughSpan
-import android.text.style.StyleSpan
-import android.text.style.TypefaceSpan
-import android.text.style.UnderlineSpan
-import android.widget.TextView
-import org.json.JSONArray
-import org.json.JSONObject
-import java.lang.ref.WeakReference
-import java.net.URL
-import java.util.concurrent.LinkedBlockingQueue
-import java.util.concurrent.ThreadPoolExecutor
-import java.util.concurrent.TimeUnit
-
-object LayoutConstants {
-    /** Base indentation per depth level (pixels at base scale). */
-    const val INDENT_PER_DEPTH: Float = 24f
-
-    /** Width reserved for the list bullet/number (pixels at base scale). */
-    const val LIST_MARKER_WIDTH: Float = 36f
-
-    /** Gap between the list marker and the text that follows (pixels at base scale). */
-    const val LIST_MARKER_TEXT_GAP: Float = 8f
-
-    /** Height of the horizontal rule separator line (pixels). */
-    const val HORIZONTAL_RULE_HEIGHT: Float = 1f
-
-    /** Vertical padding above and below the horizontal rule (pixels). */
-    const val HORIZONTAL_RULE_VERTICAL_PADDING: Float = 8f
-
-    /** Total leading inset reserved for each blockquote depth. */
-    const val BLOCKQUOTE_INDENT: Float = 18f
-
-    /** Width of the rendered blockquote border bar (pixels at base scale). */
-    const val BLOCKQUOTE_BORDER_WIDTH: Float = 3f
-
-    /** Gap between the blockquote border bar and the text that follows. */
-    const val BLOCKQUOTE_MARKER_GAP: Float = 8f
-
-    /** Bullet character for unordered list items. */
-    const val UNORDERED_LIST_BULLET: String = "\u2022 "
-
-    /** Scale factor applied only to unordered list marker glyphs. */
-    const val UNORDERED_LIST_MARKER_FONT_SCALE: Float = 2.0f
-
-    /** Default visual treatment for link text when no explicit theme color exists. */
-    const val DEFAULT_LINK_COLOR: Int = 0xFF1B73E8.toInt()
-
-    /** Object replacement character used for void block elements. */
-    const val OBJECT_REPLACEMENT_CHARACTER: String = "\uFFFC"
-
-    /** Zero-width placeholder used to preserve trailing hard-break lines. */
-    const val SYNTHETIC_PLACEHOLDER_CHARACTER: String = "\u200B"
-
-    /** Background color for inline code spans (light gray). */
-    const val CODE_BACKGROUND_COLOR: Int = 0x1A000000  // 10% black
-
-}
-
-data class BlockContext(
-    val nodeType: String,
-    val depth: Int,
-    val listContext: JSONObject?,
-    val topLevelChildIndex: Int? = null,
-    var markerPending: Boolean = false,
-    var renderStart: Int = 0
-)
-
-private data class PendingLeadingMargin(
-    val indentPx: Int,
-    val restIndentPx: Int?,
-    val blockquoteIndentPx: Int = 0,
-    val blockquoteStripeColor: Int? = null,
-    val blockquoteStripeWidthPx: Int = 0,
-    val blockquoteGapWidthPx: Int = 0,
-    val blockquoteBaseIndentPx: Int = 0
-)
-
-private data class PendingCodeBlockSpan(
-    val start: Int,
-    val end: Int
-)
-
-class BlockquoteSpan(
-    private val baseIndentPx: Int,
-    private val totalIndentPx: Int,
-    private val stripeColor: Int,
-    private val stripeWidthPx: Int,
-    private val gapWidthPx: Int
-    ) : LeadingMarginSpan {
-
-    override fun getLeadingMargin(first: Boolean): Int = totalIndentPx
-
-    override fun drawLeadingMargin(
-        canvas: Canvas,
-        paint: Paint,
-        x: Int,
-        dir: Int,
-        top: Int,
-        baseline: Int,
-        bottom: Int,
-        text: CharSequence,
-        start: Int,
-        end: Int,
-        first: Boolean,
-        layout: android.text.Layout?
-    ) {
-        if (!lineContainsQuotedContent(text, start, end)) {
-            return
-        }
-
-        val savedColor = paint.color
-        val savedStyle = paint.style
-
-        paint.color = stripeColor
-        paint.style = Paint.Style.FILL
-
-        val stripeStart = x + (dir * baseIndentPx)
-        val stripeLeft = if (dir > 0) stripeStart.toFloat() else (stripeStart - stripeWidthPx).toFloat()
-        val stripeRight = if (dir > 0) stripeLeft + stripeWidthPx else stripeLeft + stripeWidthPx
-        val stripeBottom = resolvedStripeBottom(
-            text = text,
-            start = start,
-            end = end,
-            baseline = baseline,
-            bottom = bottom,
-            layout = layout,
-            paint = paint
-        )
-        canvas.drawRect(
-            stripeLeft,
-            top.toFloat(),
-            stripeRight,
-            stripeBottom,
-            paint
-        )
-
-        paint.color = savedColor
-        paint.style = savedStyle
-    }
-
-    private fun lineContainsQuotedContent(text: CharSequence, start: Int, end: Int): Boolean {
-        if (start >= end || text !is Spanned) return true
-        for (index in start until end.coerceAtMost(text.length)) {
-            val ch = text[index]
-            if (ch == '\n' || ch == '\r') continue
-            val quoted = text.getSpans(index, index + 1, Annotation::class.java).any {
-                it.key == RenderBridge.NATIVE_BLOCKQUOTE_ANNOTATION
-            }
-            if (quoted) {
-                return true
-            }
-        }
-        return false
-    }
-
-    internal fun resolvedStripeBottom(
-        text: CharSequence,
-        start: Int,
-        end: Int,
-        baseline: Int,
-        bottom: Int,
-        layout: android.text.Layout?,
-        paint: Paint? = null
-    ): Float {
-        if (layout == null || text.isEmpty()) {
-            return bottom.toFloat()
-        }
-        val lineIndex = safeLineForOffset(layout, start, text.length)
-        val nextLine = lineIndex + 1
-        if (nextLine >= layout.lineCount) {
-            return trimmedTextBottom(baseline, layout, lineIndex, paint)
-        }
-
-        val nextLineStart = layout.getLineStart(nextLine)
-        val nextLineEnd = layout.getLineEnd(nextLine)
-        return if (lineContainsQuotedContent(text, nextLineStart, nextLineEnd)) {
-            bottom.toFloat()
-        } else {
-            trimmedTextBottom(baseline, layout, lineIndex, paint)
-        }
-    }
-
-    private fun trimmedTextBottom(
-        baseline: Int,
-        layout: Layout,
-        lineIndex: Int,
-        paint: Paint?
-    ): Float {
-        val fontDescent = paint?.fontMetrics?.descent
-        return if (fontDescent != null) {
-            baseline + fontDescent
-        } else {
-            (baseline + layout.getLineDescent(lineIndex)).toFloat()
-        }
-    }
-
-    private fun safeLineForOffset(layout: Layout, offset: Int, textLength: Int): Int {
-        if (textLength <= 0) return 0
-        val safeStart = offset.coerceIn(0, textLength - 1)
-        return layout.getLineForOffset(safeStart)
-    }
-}
-
-class CodeBlockSpan(
-    private val backgroundColor: Int,
-    private val cornerRadiusPx: Float,
-    private val paddingHorizontalPx: Int,
-    private val paddingVerticalPx: Int
-) : LeadingMarginSpan, LineBackgroundSpan {
-    var spanStart: Int = 0
-    var spanEnd: Int = 0
-
-    override fun getLeadingMargin(first: Boolean): Int = paddingHorizontalPx
-
-    override fun drawBackground(
-        canvas: Canvas,
-        paint: Paint,
-        left: Int,
-        right: Int,
-        top: Int,
-        baseline: Int,
-        bottom: Int,
-        text: CharSequence,
-        start: Int,
-        end: Int,
-        lineNumber: Int
-    ) {
-        if (start >= spanEnd || end <= spanStart) return
-
-        val isFirstLine = start <= spanStart
-        val isLastLine = end >= spanEnd
-        val rect = RectF(
-            left.toFloat(),
-            if (isFirstLine) top.toFloat() - paddingVerticalPx else top.toFloat(),
-            (right - paddingHorizontalPx).toFloat(),
-            if (isLastLine) bottom.toFloat() + paddingVerticalPx else bottom.toFloat()
-        )
-
-        val savedColor = paint.color
-        val savedStyle = paint.style
-        paint.color = backgroundColor
-        paint.style = Paint.Style.FILL
-
-        when {
-            isFirstLine && isLastLine -> canvas.drawRoundRect(rect, cornerRadiusPx, cornerRadiusPx, paint)
-            isFirstLine -> {
-                canvas.drawRoundRect(rect, cornerRadiusPx, cornerRadiusPx, paint)
-                canvas.drawRect(rect.left, rect.centerY(), rect.right, rect.bottom, paint)
-            }
-            isLastLine -> {
-                canvas.drawRoundRect(rect, cornerRadiusPx, cornerRadiusPx, paint)
-                canvas.drawRect(rect.left, rect.top, rect.right, rect.centerY(), paint)
-            }
-            else -> canvas.drawRect(rect, paint)
-        }
-
-        paint.color = savedColor
-        paint.style = savedStyle
-    }
-}
-
-class HorizontalRuleSpan(
-    private val lineColor: Int,
-    private val lineHeight: Float = LayoutConstants.HORIZONTAL_RULE_HEIGHT,
-    private val verticalPadding: Float = LayoutConstants.HORIZONTAL_RULE_VERTICAL_PADDING
-) : ReplacementSpan(), LeadingMarginSpan {
-
-    override fun getLeadingMargin(first: Boolean): Int = 0
-
-    override fun getSize(
-        paint: Paint,
-        text: CharSequence,
-        start: Int,
-        end: Int,
-        fm: Paint.FontMetricsInt?
-    ): Int {
-        if (fm != null) {
-            val totalHeight = kotlin.math.ceil(lineHeight + (verticalPadding * 2)).toInt()
-            val halfHeight = totalHeight / 2
-            fm.ascent = -halfHeight
-            fm.top = fm.ascent
-            fm.descent = totalHeight - halfHeight
-            fm.bottom = fm.descent
-        }
-        // Keep the placeholder atom in the text model without reserving
-        // visible glyph width, so Android does not paint a tofu/OBJ box.
-        return 0
-    }
-
-    override fun drawLeadingMargin(
-        canvas: Canvas,
-        paint: Paint,
-        x: Int,
-        dir: Int,
-        top: Int,
-        baseline: Int,
-        bottom: Int,
-        text: CharSequence,
-        start: Int,
-        end: Int,
-        first: Boolean,
-        layout: android.text.Layout?
-    ) {
-        val savedColor = paint.color
-        val savedStyle = paint.style
-
-        paint.color = lineColor
-        paint.style = Paint.Style.FILL
-
-        val lineY = (top + bottom) / 2f
-        val lineWidth = layout?.width?.toFloat() ?: canvas.width.toFloat()
-        canvas.drawRect(
-            x.toFloat(),
-            lineY - lineHeight / 2f,
-            lineWidth,
-            lineY + lineHeight / 2f,
-            paint
-        )
-
-        paint.color = savedColor
-        paint.style = savedStyle
-    }
-
-    override fun draw(
-        canvas: Canvas,
-        text: CharSequence,
-        start: Int,
-        end: Int,
-        x: Float,
-        top: Int,
-        y: Int,
-        bottom: Int,
-        paint: Paint
-    ) {
-        // Intentionally empty: drawLeadingMargin renders the separator line,
-        // and ReplacementSpan suppresses drawing the underlying FFFC glyph.
-    }
-}
-
-internal object RenderImageDecoder {
-    private const val MAX_DECODE_DIMENSION_PX = 2048
-    internal const val LOG_TAG = "NativeEditorImage"
-
-    fun decodeSource(source: String): Bitmap? {
-        decodeDataUrlBytes(source)?.let { bytes ->
-            val decoded = decodeBitmap(bytes)
-            if (decoded == null) {
-                Log.w(LOG_TAG, "decodeSource: failed to decode data URL bytes (${sourceSummary(source)})")
-            } else {
-                Log.d(
-                    LOG_TAG,
-                    "decodeSource: decoded data URL ${sourceSummary(source)} -> ${decoded.width}x${decoded.height}"
-                )
-            }
-            return decoded
-        }
-        val remoteBytes = runCatching {
-            URL(source).openStream().use { input ->
-                input.readBytes()
-            }
-        }.getOrNull() ?: run {
-            Log.w(LOG_TAG, "decodeSource: failed to load remote image (${sourceSummary(source)})")
-            return null
-        }
-        val decoded = decodeBitmap(remoteBytes)
-        if (decoded == null) {
-            Log.w(LOG_TAG, "decodeSource: failed to decode remote bytes (${sourceSummary(source)})")
-        }
-        return decoded
-    }
-
-    fun decodeDataUrlBytes(source: String): ByteArray? {
-        val trimmed = source.trim()
-        if (!trimmed.startsWith("data:image/", ignoreCase = true)) return null
-        val commaIndex = trimmed.indexOf(',')
-        if (commaIndex <= 0) return null
-        val metadata = trimmed.substring(0, commaIndex).lowercase()
-        if (!metadata.contains(";base64")) return null
-        val payload = trimmed.substring(commaIndex + 1)
-            .filterNot(Char::isWhitespace)
-
-        val decodeFlags = intArrayOf(
-            Base64.DEFAULT,
-            Base64.NO_WRAP,
-            Base64.URL_SAFE or Base64.NO_WRAP,
-            Base64.URL_SAFE
-        )
-        for (flags in decodeFlags) {
-            val bytes = runCatching { Base64.decode(payload, flags) }.getOrNull()
-            if (bytes != null) {
-                return bytes
-            }
-        }
-        Log.w(LOG_TAG, "decodeDataUrlBytes: unsupported base64 payload (${sourceSummary(source)})")
-        return null
-    }
-
-    fun calculateInSampleSize(
-        width: Int,
-        height: Int,
-        maxWidth: Int = MAX_DECODE_DIMENSION_PX,
-        maxHeight: Int = MAX_DECODE_DIMENSION_PX
-    ): Int {
-        if (width <= 0 || height <= 0) return 1
-
-        var sampleSize = 1
-        var sampledWidth = width
-        var sampledHeight = height
-        while (sampledWidth > maxWidth || sampledHeight > maxHeight) {
-            sampleSize *= 2
-            sampledWidth = width / sampleSize
-            sampledHeight = height / sampleSize
-        }
-        return sampleSize.coerceAtLeast(1)
-    }
-
-    private fun decodeBitmap(bytes: ByteArray): Bitmap? {
-        val bounds = BitmapFactory.Options().apply {
-            inJustDecodeBounds = true
-        }
-        BitmapFactory.decodeByteArray(bytes, 0, bytes.size, bounds)
-        if (bounds.outWidth <= 0 || bounds.outHeight <= 0) {
-            Log.w(LOG_TAG, "decodeBitmap: invalid image bounds for ${bytes.size} bytes")
-            return null
-        }
-
-        val options = BitmapFactory.Options().apply {
-            inSampleSize = calculateInSampleSize(bounds.outWidth, bounds.outHeight)
-        }
-        return BitmapFactory.decodeByteArray(bytes, 0, bytes.size, options)
-    }
-
-    private fun sourceSummary(source: String): String {
-        val trimmed = source.trim()
-        if (!trimmed.startsWith("data:image/", ignoreCase = true)) {
-            return "urlLength=${trimmed.length}"
-        }
-        val commaIndex = trimmed.indexOf(',')
-        if (commaIndex <= 0) {
-            return "dataUrlLength=${trimmed.length}"
-        }
-        val metadata = trimmed.substring(0, commaIndex)
-        val payloadLength = trimmed.length - commaIndex - 1
-        return "$metadata payloadLength=$payloadLength"
-    }
-}
-
-internal object RenderImageLoader {
-    private val cache = object : LruCache<String, Bitmap>(32 * 1024 * 1024) {
-        override fun sizeOf(key: String, value: Bitmap): Int = value.byteCount
-    }
-    private val executor =
-        ThreadPoolExecutor(
-            2,
-            2,
-            30L,
-            TimeUnit.SECONDS,
-            LinkedBlockingQueue()
-        )
-    private val lock = Any()
-    private val inFlight = mutableMapOf<String, MutableList<(Bitmap?) -> Unit>>()
-
-    @Volatile
-    internal var decodeSourceOverride: ((String) -> Bitmap?)? = null
-
-    fun cached(source: String): Bitmap? = synchronized(cache) { cache.get(source) }
-
-    internal fun resetForTesting() {
-        synchronized(cache) {
-            cache.evictAll()
-        }
-        synchronized(lock) {
-            inFlight.clear()
-        }
-        decodeSourceOverride = null
-    }
-
-    fun load(source: String, onLoaded: (Bitmap?) -> Unit) {
-        cached(source)?.let {
-            onLoaded(it)
-            return
-        }
-
-        if (source.trim().startsWith("data:image/", ignoreCase = true)) {
-            val bitmap = decode(source)
-            if (bitmap != null) {
-                synchronized(cache) {
-                    cache.put(source, bitmap)
-                }
-            }
-            onLoaded(bitmap)
-            return
-        }
-
-        synchronized(lock) {
-            val existing = inFlight[source]
-            if (existing != null) {
-                existing += onLoaded
-                return
-            }
-            inFlight[source] = mutableListOf(onLoaded)
-        }
-
-        executor.execute {
-            val bitmap = decode(source)
-            if (bitmap != null) {
-                synchronized(cache) {
-                    cache.put(source, bitmap)
-                }
-            }
-            val callbacks = synchronized(lock) {
-                inFlight.remove(source) ?: mutableListOf()
-            }
-            callbacks.forEach { it(bitmap) }
-        }
-    }
-
-    private fun decode(source: String): Bitmap? {
-        return decodeSourceOverride?.invoke(source) ?: RenderImageDecoder.decodeSource(source)
-    }
-}
-
-internal class BlockImageSpan(
-    private val source: String,
-    hostView: TextView?,
-    private val density: Float,
-    private val preferredWidthDp: Float?,
-    private val preferredHeightDp: Float?
-) : ReplacementSpan() {
-    private val hostRef = WeakReference(hostView)
-
-    @Volatile
-    private var bitmap: Bitmap? = RenderImageLoader.cached(source)
-    @Volatile
-    private var lastDrawRect: RectF? = null
-
-    init {
-        if (bitmap == null) {
-            RenderImageLoader.load(source) { loaded ->
-                if (loaded == null) {
-                    Log.w(
-                        RenderImageDecoder.LOG_TAG,
-                        "BlockImageSpan: loader returned null for image source"
-                    )
-                    return@load
-                }
-                bitmap = loaded
-                hostRef.get()?.post {
-                    hostRef.get()?.requestLayout()
-                    hostRef.get()?.invalidate()
-                    (hostRef.get() as? EditorEditText)?.onSelectionOrContentMayChange?.invoke()
-                }
-            }
-        }
-    }
-
-    override fun getSize(
-        paint: Paint,
-        text: CharSequence,
-        start: Int,
-        end: Int,
-        fm: Paint.FontMetricsInt?
-    ): Int {
-        val (widthPx, heightPx) = currentSizePx()
-        if (fm != null) {
-            fm.ascent = -heightPx
-            fm.descent = 0
-            fm.top = fm.ascent
-            fm.bottom = 0
-        }
-        return widthPx
-    }
-
-    override fun draw(
-        canvas: Canvas,
-        text: CharSequence,
-        start: Int,
-        end: Int,
-        x: Float,
-        top: Int,
-        y: Int,
-        bottom: Int,
-        paint: Paint
-    ) {
-        val (widthPx, heightPx) = currentSizePx()
-        val rect = RectF(
-            x,
-            (bottom - heightPx).toFloat(),
-            x + widthPx,
-            bottom.toFloat()
-        )
-        val host = hostRef.get()
-        lastDrawRect = RectF(rect).apply {
-            if (host != null) {
-                offset(host.compoundPaddingLeft.toFloat(), host.extendedPaddingTop.toFloat())
-            }
-        }
-        val loadedBitmap = bitmap
-        if (loadedBitmap != null) {
-            canvas.drawBitmap(loadedBitmap, null, rect, null)
-            return
-        }
-
-        val previousColor = paint.color
-        val previousStyle = paint.style
-        paint.color = Color.argb(24, 0, 0, 0)
-        paint.style = Paint.Style.FILL
-        canvas.drawRoundRect(rect, 16f * density, 16f * density, paint)
-        paint.color = Color.argb(120, 0, 0, 0)
-        val iconRadius = minOf(rect.width(), rect.height()) * 0.12f
-        canvas.drawCircle(rect.centerX(), rect.centerY(), iconRadius, paint)
-        paint.color = previousColor
-        paint.style = previousStyle
-    }
-
-    internal fun currentSizePx(): Pair<Int, Int> {
-        val maxWidth = resolvedMaxWidth()
-        val loadedBitmap = bitmap
-        val fallbackAspectRatio = if (loadedBitmap != null && loadedBitmap.width > 0 && loadedBitmap.height > 0) {
-            loadedBitmap.height.toFloat() / loadedBitmap.width.toFloat()
-        } else {
-            0.56f
-        }
-
-        var widthPx = preferredWidthDp?.takeIf { it > 0f }?.times(density)
-        var heightPx = preferredHeightDp?.takeIf { it > 0f }?.times(density)
-
-        if (widthPx == null && heightPx == null && loadedBitmap != null && loadedBitmap.width > 0 && loadedBitmap.height > 0) {
-            widthPx = loadedBitmap.width.toFloat()
-            heightPx = loadedBitmap.height.toFloat()
-        } else if (widthPx == null && heightPx != null) {
-            widthPx = heightPx / fallbackAspectRatio
-        } else if (heightPx == null && widthPx != null) {
-            heightPx = widthPx * fallbackAspectRatio
-        }
-
-        if (widthPx == null || heightPx == null) {
-            val placeholderWidth = maxWidth.coerceAtLeast(160f * density)
-            val placeholderHeight = minOf(
-                180f * density,
-                placeholderWidth * fallbackAspectRatio
-            ).coerceAtLeast(96f * density)
-            widthPx = placeholderWidth
-            heightPx = placeholderHeight
-        }
-
-        val scale = minOf(1f, maxWidth / widthPx.coerceAtLeast(1f))
-        return Pair(
-            (widthPx * scale).toInt().coerceAtLeast(1),
-            (heightPx * scale).toInt().coerceAtLeast(1)
-        )
-    }
-
-    internal fun currentDrawRect(): RectF? = lastDrawRect?.let(::RectF)
-
-    private fun resolvedMaxWidth(): Float {
-        val host = hostRef.get()
-        val hostWidth = host?.let {
-            maxOf(it.width, it.measuredWidth) - it.totalPaddingLeft - it.totalPaddingRight
-        } ?: 0
-        return if (hostWidth > 0) hostWidth.toFloat() else 240f * density
-    }
-}
-
-class FixedLineHeightSpan(
-    private val lineHeightPx: Int
-) : LineHeightSpan {
-    override fun chooseHeight(
-        text: CharSequence,
-        start: Int,
-        end: Int,
-        spanstartv: Int,
-        v: Int,
-        fm: android.graphics.Paint.FontMetricsInt
-    ) {
-        val currentHeight = fm.descent - fm.ascent
-        if (lineHeightPx <= 0 || currentHeight <= 0) return
-        if (lineHeightPx == currentHeight) return
-
-        val extra = lineHeightPx - currentHeight
-        fm.descent += extra
-        fm.bottom = fm.descent
-    }
-}
-
-/**
- * Adds vertical spacing after a paragraph by increasing the descent of the
- * inter-block newline character.
- *
- * Uses [ReplacementSpan] (not [LineHeightSpan]/[android.text.style.ParagraphStyle])
- * because Android's StaticLayout normalizes ParagraphStyle metrics across all
- * lines in a paragraph, making per-line spacing impossible.
- *
- * ReplacementSpan only affects the single character it covers, so the extra
- * descent applies only to the newline's line — creating a gap below the
- * preceding paragraph without inflating other lines.
- */
-class ParagraphSpacerSpan(
-    private val spacingPx: Int,
-    private val baseFontSize: Int,
-    private val textColor: Int
-) : ReplacementSpan() {
-    override fun getSize(
-        paint: Paint,
-        text: CharSequence,
-        start: Int,
-        end: Int,
-        fm: Paint.FontMetricsInt?
-    ): Int {
-        if (fm != null && spacingPx > 0) {
-            // Keep the natural ascent/top (from baseFontSize) so the newline
-            // line doesn't shrink above the baseline. Add spacing as descent.
-            val savedSize = paint.textSize
-            paint.textSize = baseFontSize.toFloat()
-            paint.getFontMetricsInt(fm)
-            paint.textSize = savedSize
-            fm.descent += spacingPx
-            fm.bottom = fm.descent
-        }
-        return 0
-    }
-
-    override fun draw(
-        canvas: Canvas,
-        text: CharSequence,
-        start: Int,
-        end: Int,
-        x: Float,
-        top: Int,
-        y: Int,
-        bottom: Int,
-        paint: Paint
-    ) {
-        // Draw nothing — pure spacing.
-    }
-}
-
-class CenteredBulletSpan(
-    private val textColor: Int,
-    private val markerWidthPx: Float,
-    private val bulletRadiusPx: Float,
-    private val bodyFontSizePx: Float,
-    private val markerGapToTextPx: Float
-) : ReplacementSpan() {
-    override fun getSize(
-        paint: Paint,
-        text: CharSequence,
-        start: Int,
-        end: Int,
-        fm: Paint.FontMetricsInt?
-    ): Int {
-        return kotlin.math.ceil(markerWidthPx).toInt()
-    }
-
-    override fun draw(
-        canvas: Canvas,
-        text: CharSequence,
-        start: Int,
-        end: Int,
-        x: Float,
-        top: Int,
-        y: Int,
-        bottom: Int,
-        paint: Paint
-    ) {
-        val previousColor = paint.color
-        val previousStyle = paint.style
-        val previousSize = paint.textSize
-
-        paint.color = textColor
-        paint.style = Paint.Style.FILL
-
-        // Use body text metrics (not the marker's inflated font) for centering.
-        paint.textSize = bodyFontSizePx
-        val fm = paint.fontMetrics
-        val centerX = resolvedCenterX(x)
-        val centerY = y + (fm.ascent + fm.descent) / 2f
-        canvas.drawCircle(centerX, centerY, bulletRadiusPx, paint)
-
-        paint.color = previousColor
-        paint.style = previousStyle
-        paint.textSize = previousSize
-    }
-
-    fun textSideGapPx(x: Float): Float {
-        return (x + markerWidthPx) - (resolvedCenterX(x) + bulletRadiusPx)
-    }
-
-    private fun resolvedCenterX(x: Float): Float {
-        return x + markerWidthPx - markerGapToTextPx - bulletRadiusPx
-    }
-}
-
-object RenderBridge {
-    internal const val NATIVE_BLOCKQUOTE_ANNOTATION = "nativeBlockquote"
-    internal const val NATIVE_TOP_LEVEL_CHILD_INDEX_ANNOTATION = "nativeTopLevelChildIndex"
-    internal const val NATIVE_LINK_HREF_ANNOTATION = "nativeLinkHref"
-    private const val NATIVE_SYNTHETIC_PLACEHOLDER_ANNOTATION = "nativeSyntheticPlaceholder"
-
-    private data class RenderBuildState(
-        val result: SpannableStringBuilder = SpannableStringBuilder(),
-        val blockStack: MutableList<BlockContext> = mutableListOf(),
-        val pendingLeadingMargins: MutableMap<Int, PendingLeadingMargin> = linkedMapOf(),
-        val pendingCodeBlockSpans: MutableList<PendingCodeBlockSpan> = mutableListOf(),
-        var isFirstBlock: Boolean = true,
-        var nextBlockSpacingBefore: Float? = null
-    )
-
-    fun buildSpannable(
-        json: String,
-        baseFontSize: Float,
-        textColor: Int,
-        theme: EditorTheme? = null,
-        density: Float = 1f,
-        hostView: TextView? = null
-    ): SpannableStringBuilder {
-        val elements = try {
-            JSONArray(json)
-        } catch (_: Exception) {
-            return SpannableStringBuilder()
-        }
-
-        return buildSpannableFromArray(elements, baseFontSize, textColor, theme, density, hostView)
-    }
-
-    fun buildSpannableFromArray(
-        elements: JSONArray,
-        baseFontSize: Float,
-        textColor: Int,
-        theme: EditorTheme? = null,
-        density: Float = 1f,
-        hostView: TextView? = null
-    ): SpannableStringBuilder {
-        val state = RenderBuildState()
-        appendElements(
-            state = state,
-            elements = elements,
-            baseFontSize = baseFontSize,
-            textColor = textColor,
-            theme = theme,
-            density = density,
-            hostView = hostView
-        )
-        applyPendingLeadingMargins(state.result, state.pendingLeadingMargins)
-        applyPendingCodeBlockSpans(state.result, state.pendingCodeBlockSpans, theme, density)
-        return state.result
-    }
-
-    fun buildSpannableFromBlocks(
-        blocks: JSONArray,
-        startIndex: Int = 0,
-        baseFontSize: Float,
-        textColor: Int,
-        theme: EditorTheme? = null,
-        density: Float = 1f,
-        hostView: TextView? = null
-    ): SpannableStringBuilder {
-        val state = RenderBuildState()
-        for (blockOffset in 0 until blocks.length()) {
-            val blockElements = blocks.optJSONArray(blockOffset) ?: continue
-            appendElements(
-                state = state,
-                elements = blockElements,
-                baseFontSize = baseFontSize,
-                textColor = textColor,
-                theme = theme,
-                density = density,
-                hostView = hostView,
-                topLevelChildIndex = startIndex + blockOffset
-            )
-        }
-        applyPendingLeadingMargins(state.result, state.pendingLeadingMargins)
-        applyPendingCodeBlockSpans(state.result, state.pendingCodeBlockSpans, theme, density)
-        return state.result
-    }
-
-    fun measureHeight(
-        json: String,
-        themeJson: String?,
-        width: Float,
-        density: Float
-    ): Float {
-        if (width <= 0) return 0f
-
-        val theme = EditorTheme.fromJson(themeJson)
-        val baseFontSize = theme?.text?.fontSize
-            ?: theme?.paragraph?.fontSize
-            ?: 16f
-
-        val spannable = buildSpannable(
-            json = json,
-            baseFontSize = baseFontSize,
-            textColor = android.graphics.Color.BLACK,
-            theme = theme,
-            density = density,
-            hostView = null
-        )
-
-        if (spannable.isEmpty()) return 0f
-
-        val contentInsets = theme?.contentInsets
-        val topInset = ((contentInsets?.top ?: 0f) * density).toInt()
-        val bottomInset = ((contentInsets?.bottom ?: 0f) * density).toInt()
-        val leftInset = ((contentInsets?.left ?: 0f) * density).toInt()
-        val rightInset = ((contentInsets?.right ?: 0f) * density).toInt()
-
-        val paint = android.text.TextPaint().apply {
-            textSize = baseFontSize * density
-            isAntiAlias = true
-        }
-
-        val availableWidth = (width - leftInset - rightInset).coerceAtLeast(0f).toInt()
-
-        val staticLayout = android.text.StaticLayout.Builder
-            .obtain(spannable, 0, spannable.length, paint, availableWidth)
-            .setAlignment(android.text.Layout.Alignment.ALIGN_NORMAL)
-            .setIncludePad(true)
-            .build()
-
-        val height = staticLayout.height + topInset + bottomInset
-        return height.toFloat()
-    }
-
-    private fun appendElements(
-        state: RenderBuildState,
-        elements: JSONArray,
-        baseFontSize: Float,
-        textColor: Int,
-        theme: EditorTheme?,
-        density: Float,
-        hostView: TextView?,
-        topLevelChildIndex: Int? = null
-    ) {
-        for (i in 0 until elements.length()) {
-            val element = elements.optJSONObject(i) ?: continue
-            val type = element.optString("type", "")
-
-            when (type) {
-                "textRun" -> {
-                    val text = element.optString("text", "")
-                    val marksArray = element.optJSONArray("marks")
-                    val marks = parseMarks(marksArray)
-                    appendStyledText(
-                        state.result,
-                        text,
-                        marks,
-                        baseFontSize,
-                        textColor,
-                        state.blockStack,
-                        state.pendingLeadingMargins,
-                        theme,
-                        density
-                    )
-                }
-
-                "voidInline" -> {
-                    val nodeType = element.optString("nodeType", "")
-                    appendVoidInline(
-                        state.result,
-                        nodeType,
-                        baseFontSize,
-                        textColor,
-                        state.blockStack,
-                        state.pendingLeadingMargins,
-                        theme,
-                        density
-                    )
-                }
-
-                "voidBlock" -> {
-                    val nodeType = element.optString("nodeType", "")
-                    val attrs = element.optJSONObject("attrs")
-                    if (!state.isFirstBlock) {
-                        val spacingPx = ((state.nextBlockSpacingBefore ?: 0f) * density).toInt()
-                        appendInterBlockNewline(
-                            state.result,
-                            baseFontSize,
-                            textColor,
-                            spacingPx,
-                            topLevelChildIndex = topLevelChildIndex
-                        )
-                    }
-                    state.isFirstBlock = false
-                    val spacingBefore = theme?.effectiveTextStyle(nodeType)?.spacingAfter
-                        ?: theme?.list?.itemSpacing
-                    state.nextBlockSpacingBefore = spacingBefore
-                    appendVoidBlock(
-                        state.result,
-                        nodeType,
-                        attrs,
-                        baseFontSize,
-                        textColor,
-                        theme,
-                        density,
-                        spacingBefore,
-                        hostView,
-                        topLevelChildIndex
-                    )
-                }
-
-                "opaqueInlineAtom" -> {
-                    val nodeType = element.optString("nodeType", "")
-                    val label = element.optString("label", "?")
-                    val docPos = element.optInt("docPos", 0)
-                    val mentionTheme = EditorMentionTheme.fromJson(
-                        element.optJSONObject("mentionTheme")
-                    )
-                    appendOpaqueInlineAtom(
-                        state.result,
-                        nodeType,
-                        label,
-                        docPos,
-                        baseFontSize,
-                        textColor,
-                        state.blockStack,
-                        state.pendingLeadingMargins,
-                        theme,
-                        mentionTheme,
-                        density
-                    )
-                }
-
-                "opaqueBlockAtom" -> {
-                    val nodeType = element.optString("nodeType", "")
-                    val label = element.optString("label", "?")
-                    val docPos = element.optInt("docPos", 0)
-                    val blockSpacing = theme?.effectiveTextStyle(nodeType)?.spacingAfter
-                    if (!state.isFirstBlock) {
-                        val spacingPx = ((state.nextBlockSpacingBefore ?: 0f) * density).toInt()
-                        appendInterBlockNewline(
-                            state.result,
-                            baseFontSize,
-                            textColor,
-                            spacingPx,
-                            topLevelChildIndex = topLevelChildIndex
-                        )
-                    }
-                    state.isFirstBlock = false
-                    state.nextBlockSpacingBefore = blockSpacing
-                    appendOpaqueBlockAtom(
-                        state.result,
-                        nodeType,
-                        label,
-                        docPos,
-                        baseFontSize,
-                        textColor,
-                        theme,
-                        blockSpacing,
-                        topLevelChildIndex
-                    )
-                }
-
-                "blockStart" -> {
-                    val nodeType = element.optString("nodeType", "")
-                    val depth = element.optInt("depth", 0)
-                    val listContext = element.optJSONObject("listContext")
-                    val isListItemContainer = isListItemNodeType(nodeType) && listContext != null
-                    val isTransparentContainer = isTransparentContainer(nodeType)
-                    val nestedListItemContainer =
-                        isListItemContainer &&
-                            state.blockStack.any {
-                                isListItemNodeType(it.nodeType) && it.listContext != null
-                            }
-                    val blockSpacing = if (isListItemContainer) {
-                        null
-                    } else {
-                        theme?.effectiveTextStyle(nodeType)?.spacingAfter
-                            ?: (if (listContext != null) theme?.list?.itemSpacing else null)
-                    }
-
-                    if (!isListItemContainer && !isTransparentContainer) {
-                        if (!state.isFirstBlock) {
-                            val spacingPx = ((state.nextBlockSpacingBefore ?: 0f) * density).toInt()
-                            val nextBlockStack = state.blockStack + BlockContext(
-                                nodeType = nodeType,
-                                depth = depth,
-                                listContext = listContext,
-                                topLevelChildIndex = topLevelChildIndex,
-                                markerPending = isListItemContainer,
-                                renderStart = state.result.length
-                            )
-                            val inBlockquoteSeparator =
-                                blockquoteDepth(nextBlockStack) > 0f && trailingRenderedContentHasBlockquote(state.result)
-                            appendInterBlockNewline(
-                                state.result,
-                                baseFontSize,
-                                textColor,
-                                spacingPx,
-                                inBlockquote = inBlockquoteSeparator,
-                                topLevelChildIndex = topLevelChildIndex
-                            )
-                        }
-                        state.isFirstBlock = false
-                        state.nextBlockSpacingBefore = blockSpacing
-                    } else if (nestedListItemContainer && theme?.list?.itemSpacing != null) {
-                        state.nextBlockSpacingBefore = theme.list.itemSpacing
-                    }
-
-                    val ctx = BlockContext(
-                        nodeType = nodeType,
-                        depth = depth,
-                        listContext = listContext,
-                        topLevelChildIndex = topLevelChildIndex,
-                        markerPending = isListItemContainer,
-                        renderStart = state.result.length
-                    )
-                    state.blockStack.add(ctx)
-
-                    val markerListContext = when {
-                        isListItemContainer -> null
-                        listContext != null -> listContext
-                        else -> consumePendingListMarker(state.blockStack, state.result.length)
-                    }
-
-                    if (markerListContext != null) {
-                        val ordered = markerListContext.optBoolean("ordered", false)
-                        val isTask = markerListContext.optString("kind", "") == "task"
-                        val marker = listMarkerString(markerListContext)
-                        val markerBaseSize =
-                            resolveTextStyle(
-                                nodeType,
-                                theme,
-                                blockquoteDepth(state.blockStack) > 0
-                            ).fontSize?.times(density) ?: baseFontSize
-                        val resolvedMarkerBaseSize = if (isTask) {
-                            markerBaseSize * 1.55f
-                        } else {
-                            markerBaseSize
-                        }
-                        val markerTextStyle = resolveTextStyle(
-                            nodeType,
-                            theme,
-                            blockquoteDepth(state.blockStack) > 0
-                        )
-                        appendStyledText(
-                            state.result,
-                            marker,
-                            emptyList(),
-                            resolvedMarkerBaseSize,
-                            theme?.list?.markerColor ?: textColor,
-                            state.blockStack,
-                            state.pendingLeadingMargins,
-                            null,
-                            density,
-                            applyBlockSpans = false
-                        )
-                        val markerStart = state.result.length - marker.length
-                        val markerEnd = state.result.length
-                        annotateTopLevelChild(state.result, markerStart, markerEnd, topLevelChildIndex)
-                        if (!ordered && !isTask) {
-                            val markerScale =
-                                theme?.list?.markerScale ?: LayoutConstants.UNORDERED_LIST_MARKER_FONT_SCALE
-                            val markerWidth = calculateMarkerWidth(density)
-                            val bulletRadius = ((markerBaseSize * markerScale) * 0.16f).coerceAtLeast(2f * density)
-                            state.result.setSpan(
-                                CenteredBulletSpan(
-                                textColor = theme?.list?.markerColor ?: textColor,
-                                markerWidthPx = markerWidth,
-                                bulletRadiusPx = bulletRadius,
-                                bodyFontSizePx = resolvedMarkerBaseSize,
-                                markerGapToTextPx = LayoutConstants.LIST_MARKER_TEXT_GAP * density
-                            ),
-                                markerStart,
-                                markerEnd,
-                                Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
-                            )
-                        }
-                        applyLineHeightSpan(
-                            builder = state.result,
-                            start = markerStart,
-                            end = markerEnd,
-                            lineHeight = markerTextStyle.lineHeight,
-                            density = density
-                        )
-                    }
-                }
-
-                "blockEnd" -> {
-                    if (state.blockStack.isNotEmpty()) {
-                        val endedBlock = state.blockStack.removeAt(state.blockStack.lastIndex)
-                        appendTrailingHardBreakPlaceholderIfNeeded(
-                            builder = state.result,
-                            endedBlock = endedBlock,
-                            remainingBlockStack = state.blockStack,
-                            baseFontSize = baseFontSize,
-                            textColor = textColor,
-                            theme = theme,
-                            density = density,
-                            pendingLeadingMargins = state.pendingLeadingMargins
-                        )
-                        if (isListItemNodeType(endedBlock.nodeType) && endedBlock.listContext != null) {
-                            state.nextBlockSpacingBefore = theme?.list?.itemSpacing
-                        }
-                        if (endedBlock.nodeType == "codeBlock" && endedBlock.renderStart < state.result.length) {
-                            state.pendingCodeBlockSpans.add(
-                                PendingCodeBlockSpan(
-                                    start = endedBlock.renderStart,
-                                    end = state.result.length
-                                )
-                            )
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    /**
-     * Apply spans to a text run based on its mark names and append to the builder.
-     *
-     * Supported marks:
-     * - `bold` / `strong` -> [StyleSpan] with [Typeface.BOLD]
-     * - `italic` / `em` -> [StyleSpan] with [Typeface.ITALIC]
-     * - `underline` -> [UnderlineSpan]
-     * - `strike` / `strikethrough` -> [StrikethroughSpan]
-     * - `code` -> [TypefaceSpan] with "monospace" + [BackgroundColorSpan]
-     * - `link` -> [URLSpan] (when mark is an object with `href`)
-     *
-     * Multiple marks are combined on the same range.
-     */
-    private fun appendStyledText(
-        builder: SpannableStringBuilder,
-        text: String,
-        marks: List<Any>, // String or JSONObject for link marks
-        baseFontSize: Float,
-        textColor: Int,
-        blockStack: MutableList<BlockContext>,
-        pendingLeadingMargins: MutableMap<Int, PendingLeadingMargin>,
-        theme: EditorTheme?,
-        density: Float,
-        applyBlockSpans: Boolean = true
-    ) {
-        val start = builder.length
-        builder.append(text)
-        val end = builder.length
-
-        if (start == end) return
-
-        val currentBlock = effectiveBlockContext(blockStack)
-        val isCodeBlock = currentBlock?.nodeType == "codeBlock"
-        val textStyle = currentBlock?.let {
-            resolveTextStyle(
-                it.nodeType,
-                theme,
-                blockquoteDepth(blockStack) > 0
-            )
-        } ?: theme?.effectiveTextStyle("paragraph", inBlockquote = blockquoteDepth(blockStack) > 0)
-
-        // Determine which marks are active.
-        var markBold = false
-        var markItalic = false
-        var markUnderline = false
-        var hasStrike = false
-        var hasCode = false
-        var isLink = false
-        var linkHref: String? = null
-        for (mark in marks) {
-            when {
-                mark is String -> when (mark) {
-                    "bold", "strong" -> markBold = true
-                    "italic", "em" -> markItalic = true
-                    "underline" -> markUnderline = true
-                    "strike", "strikethrough" -> hasStrike = true
-                    "code" -> hasCode = true
-                }
-                mark is JSONObject -> {
-                    val markType = mark.optString("type", "")
-                    if (markType == "link") {
-                        isLink = true
-                        linkHref = mark.optString("href", "").takeIf { it.isNotBlank() }
-                    }
-                }
-            }
-        }
-        val linkTheme = if (isLink) theme?.links else null
-        val effectiveTextStyle = textStyle?.mergedWith(linkTheme?.asTextStyle())
-            ?: linkTheme?.asTextStyle()
-        val resolvedTextSize = effectiveTextStyle?.fontSize?.times(density) ?: baseFontSize
-        val resolvedTextColor = if (isLink) {
-            effectiveTextStyle?.color ?: LayoutConstants.DEFAULT_LINK_COLOR
-        } else {
-            effectiveTextStyle?.color ?: textColor
-        }
-
-        // Apply base styling.
-        builder.setSpan(
-            ForegroundColorSpan(resolvedTextColor),
-            start, end,
-            Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
-        )
-        builder.setSpan(
-            AbsoluteSizeSpan(resolvedTextSize.toInt(), false),
-            start, end,
-            Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
-        )
-        linkTheme?.backgroundColor?.let { backgroundColor ->
-            builder.setSpan(
-                BackgroundColorSpan(backgroundColor),
-                start,
-                end,
-                Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
-            )
-        }
-        linkHref?.let { href ->
-            builder.setSpan(
-                Annotation(NATIVE_LINK_HREF_ANNOTATION, href),
-                start,
-                end,
-                Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
-            )
-        }
-
-        val typefaceStyle = effectiveTextStyle?.typefaceStyle()
-        val hasBold = markBold ||
-            typefaceStyle?.let { it == Typeface.BOLD || it == Typeface.BOLD_ITALIC } == true
-        val hasItalic = markItalic ||
-            typefaceStyle?.let { it == Typeface.ITALIC || it == Typeface.BOLD_ITALIC } == true
-        val hasUnderline = markUnderline || (isLink && (linkTheme?.underline ?: true))
-
-        // Apply bold/italic as a combined StyleSpan.
-        if (hasBold && hasItalic) {
-            builder.setSpan(
-                StyleSpan(Typeface.BOLD_ITALIC), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
-            )
-        } else if (hasBold) {
-            builder.setSpan(
-                StyleSpan(Typeface.BOLD), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
-            )
-        } else if (hasItalic) {
-            builder.setSpan(
-                StyleSpan(Typeface.ITALIC), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
-            )
-        }
-
-        val fontFamily = effectiveTextStyle?.fontFamily
-        if (!hasCode && !isCodeBlock && !fontFamily.isNullOrBlank()) {
-            builder.setSpan(
-                TypefaceSpan(fontFamily),
-                start,
-                end,
-                Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
-            )
-        }
-
-        if (hasUnderline) {
-            builder.setSpan(UnderlineSpan(), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE)
-        }
-
-        if (hasStrike) {
-            builder.setSpan(StrikethroughSpan(), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE)
-        }
-
-        if (hasCode || isCodeBlock) {
-            builder.setSpan(
-                TypefaceSpan("monospace"), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
-            )
-            if (hasCode && !isCodeBlock) {
-                builder.setSpan(
-                    BackgroundColorSpan(LayoutConstants.CODE_BACKGROUND_COLOR),
-                    start,
-                    end,
-                    Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
-                )
-            }
-        }
-
-        // Apply block-level indentation spans if in a block context.
-        if (applyBlockSpans) {
-            applyBlockStyle(builder, start, end, blockStack, pendingLeadingMargins, theme, density)
-        }
-    }
-
-    /**
-     * Append a void inline element (e.g. hardBreak) to the builder.
-     *
-     * A hardBreak is rendered as a newline character. Unknown void inlines
-     * are rendered as the object replacement character.
-     */
-    private fun appendVoidInline(
-        builder: SpannableStringBuilder,
-        nodeType: String,
-        baseFontSize: Float,
-        textColor: Int,
-        blockStack: MutableList<BlockContext>,
-        pendingLeadingMargins: MutableMap<Int, PendingLeadingMargin>,
-        theme: EditorTheme?,
-        density: Float
-    ) {
-        when (nodeType) {
-            "hardBreak" -> {
-                val start = builder.length
-                builder.append("\n")
-                val end = builder.length
-                builder.setSpan(
-                    Annotation("nativeVoidNodeType", nodeType),
-                    start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
-                )
-                builder.setSpan(
-                    ForegroundColorSpan(resolveInlineTextColor(blockStack, textColor, theme)),
-                    start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
-                )
-                applyBlockStyle(builder, start, end, blockStack, pendingLeadingMargins, theme, density)
-            }
-            else -> {
-                val start = builder.length
-                builder.append(LayoutConstants.OBJECT_REPLACEMENT_CHARACTER)
-                val end = builder.length
-                builder.setSpan(
-                    ForegroundColorSpan(resolveInlineTextColor(blockStack, textColor, theme)),
-                    start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
-                )
-                applyBlockStyle(builder, start, end, blockStack, pendingLeadingMargins, theme, density)
-            }
-        }
-    }
-
-    /**
-     * Append a void block element (e.g. horizontalRule) to the builder.
-     *
-     * Horizontal rules are rendered as the object replacement character
-     * with a [HorizontalRuleSpan] that draws a separator line.
-     */
-    private fun appendVoidBlock(
-        builder: SpannableStringBuilder,
-        nodeType: String,
-        attrs: JSONObject?,
-        baseFontSize: Float,
-        textColor: Int,
-        theme: EditorTheme?,
-        density: Float,
-        spacingBefore: Float?,
-        hostView: TextView?,
-        topLevelChildIndex: Int?
-    ) {
-        when (nodeType) {
-            "horizontalRule" -> {
-                val start = builder.length
-                builder.append(LayoutConstants.OBJECT_REPLACEMENT_CHARACTER)
-                val end = builder.length
-                // Apply a dim version of the text color for the rule line.
-                val ruleColor = theme?.horizontalRule?.color ?: Color.argb(
-                    (Color.alpha(textColor) * 0.3f).toInt(),
-                    Color.red(textColor),
-                    Color.green(textColor),
-                    Color.blue(textColor)
-                )
-                builder.setSpan(
-                    HorizontalRuleSpan(
-                        lineColor = ruleColor,
-                        lineHeight = (theme?.horizontalRule?.thickness ?: LayoutConstants.HORIZONTAL_RULE_HEIGHT) * density,
-                        verticalPadding = (theme?.horizontalRule?.verticalMargin ?: LayoutConstants.HORIZONTAL_RULE_VERTICAL_PADDING) * density
-                    ),
-                    start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
-                )
-                annotateTopLevelChild(builder, start, end, topLevelChildIndex)
-            }
-            "image" -> {
-                val source = if (attrs != null && attrs.has("src") && !attrs.isNull("src")) {
-                    attrs.optString("src", "").trim()
-                } else {
-                    ""
-                }
-                val preferredWidthDp = attrs?.optPositiveFloat("width")
-                val preferredHeightDp = attrs?.optPositiveFloat("height")
-                if (source.isEmpty()) {
-                    builder.append(LayoutConstants.OBJECT_REPLACEMENT_CHARACTER)
-                    return
-                }
-                val start = builder.length
-                builder.append(LayoutConstants.OBJECT_REPLACEMENT_CHARACTER)
-                val end = builder.length
-                builder.setSpan(
-                    BlockImageSpan(
-                        source = source,
-                        hostView = hostView,
-                        density = density,
-                        preferredWidthDp = preferredWidthDp,
-                        preferredHeightDp = preferredHeightDp
-                    ),
-                    start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
-                )
-                annotateTopLevelChild(builder, start, end, topLevelChildIndex)
-            }
-            else -> {
-                val start = builder.length
-                builder.append(LayoutConstants.OBJECT_REPLACEMENT_CHARACTER)
-                annotateTopLevelChild(builder, start, builder.length, topLevelChildIndex)
-            }
-        }
-    }
-
-    private fun appendOpaqueInlineAtom(
-        builder: SpannableStringBuilder,
-        nodeType: String,
-        label: String,
-        docPos: Int,
-        baseFontSize: Float,
-        textColor: Int,
-        blockStack: MutableList<BlockContext>,
-        pendingLeadingMargins: MutableMap<Int, PendingLeadingMargin>,
-        theme: EditorTheme?,
-        mentionTheme: EditorMentionTheme?,
-        density: Float
-    ) {
-        val isMention = nodeType == "mention"
-        val text = if (isMention) label else "[$label]"
-        val start = builder.length
-        builder.append(text)
-        val end = builder.length
-        val resolvedMentionTheme = if (isMention) {
-            theme?.mentions?.mergedWith(mentionTheme) ?: mentionTheme
-        } else {
-            null
-        }
-        val inlineTextColor = if (isMention) {
-            resolvedMentionTheme?.textColor ?: resolveInlineTextColor(blockStack, textColor, theme)
-        } else {
-            resolveInlineTextColor(blockStack, textColor, theme)
-        }
-        builder.setSpan(
-            ForegroundColorSpan(inlineTextColor),
-            start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
-        )
-        builder.setSpan(
-            BackgroundColorSpan(
-                if (isMention) {
-                    resolvedMentionTheme?.backgroundColor ?: 0x1f1d4ed8
-                } else {
-                    0x20000000
-                }
-            ),
-            start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
-        )
-        builder.setSpan(
-            Annotation("nativeVoidNodeType", nodeType),
-            start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
-        )
-        builder.setSpan(
-            Annotation("nativeDocPos", docPos.toString()),
-            start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
-        )
-        if (isMention && (resolvedMentionTheme?.fontWeight == "bold" ||
-                resolvedMentionTheme?.fontWeight?.toIntOrNull()?.let { it >= 600 } == true)
-        ) {
-            builder.setSpan(
-                StyleSpan(Typeface.BOLD),
-                start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
-            )
-        }
-        applyBlockStyle(builder, start, end, blockStack, pendingLeadingMargins, theme, density)
-    }
-
-    private fun appendOpaqueBlockAtom(
-        builder: SpannableStringBuilder,
-        nodeType: String,
-        label: String,
-        docPos: Int,
-        baseFontSize: Float,
-        textColor: Int,
-        theme: EditorTheme?,
-        spacingBefore: Float?,
-        topLevelChildIndex: Int?
-    ) {
-        val text = if (nodeType == "mention") label else "[$label]"
-        val start = builder.length
-        builder.append(text)
-        val end = builder.length
-        builder.setSpan(
-            ForegroundColorSpan(theme?.effectiveTextStyle("paragraph")?.color ?: textColor),
-            start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
-        )
-        builder.setSpan(
-            BackgroundColorSpan(0x20000000), // light gray
-            start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
-        )
-        builder.setSpan(
-            Annotation("nativeVoidNodeType", nodeType),
-            start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
-        )
-        builder.setSpan(
-            Annotation("nativeDocPos", docPos.toString()),
-            start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
-        )
-        annotateTopLevelChild(builder, start, end, topLevelChildIndex)
-    }
-
-    private fun applyBlockStyle(
-        builder: SpannableStringBuilder,
-        start: Int,
-        end: Int,
-        blockStack: List<BlockContext>,
-        pendingLeadingMargins: MutableMap<Int, PendingLeadingMargin>,
-        theme: EditorTheme?,
-        density: Float
-    ) {
-        val currentBlock = effectiveBlockContext(blockStack) ?: return
-        val indent = calculateIndent(currentBlock, blockStack, theme, density)
-        val markerWidth = calculateMarkerWidth(density)
-        val quoteDepth = blockquoteDepth(blockStack)
-        val indentPerDepth = (theme?.list?.indent ?: LayoutConstants.INDENT_PER_DEPTH) * density
-        val listBaseIndentAdjustment =
-            calculateListBaseIndentAdjustment(currentBlock, theme, density)
-        val quoteStripeColor = if (quoteDepth > 0) {
-            theme?.blockquote?.borderColor ?: Color.argb(
-                (Color.alpha(resolveInlineTextColor(blockStack, Color.BLACK, theme)) * 0.3f).toInt(),
-                Color.red(resolveInlineTextColor(blockStack, Color.BLACK, theme)),
-                Color.green(resolveInlineTextColor(blockStack, Color.BLACK, theme)),
-                Color.blue(resolveInlineTextColor(blockStack, Color.BLACK, theme))
-            )
-        } else {
-            null
-        }
-        val quoteStripeWidth = ((theme?.blockquote?.borderWidth
-            ?: LayoutConstants.BLOCKQUOTE_BORDER_WIDTH) * density).toInt()
-        val quoteGapWidth = ((theme?.blockquote?.markerGap
-            ?: LayoutConstants.BLOCKQUOTE_MARKER_GAP) * density).toInt()
-        val quoteIndent = maxOf(
-            theme?.blockquote?.indent ?: LayoutConstants.BLOCKQUOTE_INDENT,
-            (theme?.blockquote?.markerGap ?: LayoutConstants.BLOCKQUOTE_MARKER_GAP) +
-                (theme?.blockquote?.borderWidth ?: LayoutConstants.BLOCKQUOTE_BORDER_WIDTH)
-        ) * density
-        val blockquoteIndentPx = (quoteDepth * quoteIndent).toInt()
-        val quoteBaseIndent = if (quoteDepth > 0) {
-            ((currentBlock.depth * indentPerDepth)
-                - (quoteDepth * indentPerDepth)
-                + listBaseIndentAdjustment
-                + ((quoteDepth - 1f) * quoteIndent)).toInt()
-        } else {
-            0
-        }
-        val paragraphStart = renderedParagraphStart(
-            builder = builder,
-            candidateStart = effectiveParagraphStart(blockStack)
-        )
-        if (paragraphStart < end) {
-            if (currentBlock.listContext != null) {
-                pendingLeadingMargins[paragraphStart] = PendingLeadingMargin(
-                    indentPx = indent.toInt(),
-                    restIndentPx = (indent + markerWidth).toInt(),
-                    blockquoteIndentPx = blockquoteIndentPx,
-                    blockquoteStripeColor = quoteStripeColor,
-                    blockquoteStripeWidthPx = quoteStripeWidth,
-                    blockquoteGapWidthPx = quoteGapWidth,
-                    blockquoteBaseIndentPx = quoteBaseIndent
-                )
-            } else if (indent > 0) {
-                pendingLeadingMargins[paragraphStart] = PendingLeadingMargin(
-                    indentPx = indent.toInt(),
-                    restIndentPx = null,
-                    blockquoteIndentPx = blockquoteIndentPx,
-                    blockquoteStripeColor = quoteStripeColor,
-                    blockquoteStripeWidthPx = quoteStripeWidth,
-                    blockquoteGapWidthPx = quoteGapWidth,
-                    blockquoteBaseIndentPx = quoteBaseIndent
-                )
-            }
-        }
-
-        if (quoteDepth > 0f) {
-            builder.setSpan(
-                Annotation(NATIVE_BLOCKQUOTE_ANNOTATION, "1"),
-                start,
-                end,
-                Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
-            )
-        }
-        annotateTopLevelChild(builder, start, end, currentBlock.topLevelChildIndex)
-
-        val lineHeight = resolveTextStyle(
-            currentBlock.nodeType,
-            theme,
-            quoteDepth > 0
-        ).lineHeight
-        applyLineHeightSpan(builder, start, end, lineHeight, density)
-    }
-
-    private fun applyLineHeightSpan(
-        builder: SpannableStringBuilder,
-        start: Int,
-        end: Int,
-        lineHeight: Float?,
-        density: Float
-    ) {
-        if (lineHeight == null || lineHeight <= 0 || start >= end) {
-            return
-        }
-        builder.setSpan(
-            FixedLineHeightSpan((lineHeight * density).toInt()),
-            start,
-            end,
-            Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
-        )
-    }
-
-    private fun applyPendingLeadingMargins(
-        builder: SpannableStringBuilder,
-        pendingLeadingMargins: Map<Int, PendingLeadingMargin>
-    ) {
-        if (pendingLeadingMargins.isEmpty()) return
-
-        val text = builder.toString()
-        val entries = pendingLeadingMargins.toSortedMap().entries.toList()
-        var index = 0
-        while (index < entries.size) {
-            val paragraphStart = entries[index].key
-            val spec = entries[index].value
-            if (paragraphStart >= builder.length) {
-                index += 1
-                continue
-            }
-            if (spec.blockquoteStripeColor != null) {
-                val paragraphEnd = blockquoteSpanEnd(builder, text, paragraphStart)
-                val quoteEntries = mutableListOf(entries[index])
-                var nextIndex = index + 1
-                while (nextIndex < entries.size && entries[nextIndex].key < paragraphEnd) {
-                    quoteEntries.add(entries[nextIndex])
-                    nextIndex += 1
-                }
-                index = nextIndex
-
-                builder
-                    .getSpans(0, builder.length, LeadingMarginSpan::class.java)
-                    .filter { builder.getSpanStart(it) == paragraphStart }
-                    .forEach(builder::removeSpan)
-
-                builder.setSpan(
-                    BlockquoteSpan(
-                        baseIndentPx = spec.blockquoteBaseIndentPx,
-                        totalIndentPx = spec.blockquoteIndentPx,
-                        stripeColor = spec.blockquoteStripeColor,
-                        stripeWidthPx = spec.blockquoteStripeWidthPx,
-                        gapWidthPx = spec.blockquoteGapWidthPx
-                    ),
-                    paragraphStart,
-                    paragraphEnd,
-                    Spanned.SPAN_PARAGRAPH
-                )
-
-                quoteEntries.forEach { (entryStart, entrySpec) ->
-                    applyAdditionalLeadingMargin(
-                        builder = builder,
-                        text = text,
-                        paragraphStart = entryStart,
-                        spec = entrySpec
-                    )
-                }
-            } else {
-                index += 1
-                val paragraphEnd = defaultParagraphEnd(text, builder.length, paragraphStart)
-                val span = spec.restIndentPx?.let {
-                    LeadingMarginSpan.Standard(spec.indentPx, it)
-                } ?: LeadingMarginSpan.Standard(spec.indentPx)
-
-                builder
-                    .getSpans(0, builder.length, LeadingMarginSpan::class.java)
-                    .filter { builder.getSpanStart(it) == paragraphStart }
-                    .forEach(builder::removeSpan)
-
-                builder.setSpan(span, paragraphStart, paragraphEnd, Spanned.SPAN_PARAGRAPH)
-            }
-        }
-    }
-
-    private fun applyPendingCodeBlockSpans(
-        builder: SpannableStringBuilder,
-        pendingCodeBlockSpans: List<PendingCodeBlockSpan>,
-        theme: EditorTheme?,
-        density: Float
-    ) {
-        if (pendingCodeBlockSpans.isEmpty()) return
-
-        val backgroundColor = theme?.codeBlock?.backgroundColor ?: LayoutConstants.CODE_BACKGROUND_COLOR
-        val cornerRadiusPx = (theme?.codeBlock?.borderRadius ?: 8f) * density
-        val paddingHorizontalPx = ((theme?.codeBlock?.paddingHorizontal ?: 12f) * density).toInt()
-        val paddingVerticalPx = ((theme?.codeBlock?.paddingVertical ?: 8f) * density).toInt()
-
-        for (pending in pendingCodeBlockSpans) {
-            if (pending.start >= pending.end || pending.start >= builder.length) {
-                continue
-            }
-            val spanEnd = pending.end.coerceAtMost(builder.length)
-            val span = CodeBlockSpan(
-                backgroundColor = backgroundColor,
-                cornerRadiusPx = cornerRadiusPx,
-                paddingHorizontalPx = paddingHorizontalPx,
-                paddingVerticalPx = paddingVerticalPx
-            ).also {
-                it.spanStart = pending.start
-                it.spanEnd = spanEnd
-            }
-            builder.setSpan(
-                span,
-                pending.start,
-                spanEnd,
-                Spanned.SPAN_PARAGRAPH
-            )
-        }
-    }
-
-    private fun applyAdditionalLeadingMargin(
-        builder: SpannableStringBuilder,
-        text: String,
-        paragraphStart: Int,
-        spec: PendingLeadingMargin
-    ) {
-        val extraFirstIndent = (spec.indentPx - spec.blockquoteIndentPx).coerceAtLeast(0)
-        val extraRestIndent = spec.restIndentPx?.let {
-            (it - spec.blockquoteIndentPx).coerceAtLeast(0)
-        }
-        if (extraRestIndent != null) {
-            builder.setSpan(
-                LeadingMarginSpan.Standard(extraFirstIndent, extraRestIndent),
-                paragraphStart,
-                defaultParagraphEnd(text, builder.length, paragraphStart),
-                Spanned.SPAN_PARAGRAPH
-            )
-        } else if (extraFirstIndent > 0) {
-            builder.setSpan(
-                LeadingMarginSpan.Standard(extraFirstIndent),
-                paragraphStart,
-                defaultParagraphEnd(text, builder.length, paragraphStart),
-                Spanned.SPAN_PARAGRAPH
-            )
-        }
-    }
-
-
-    private fun calculateIndent(
-        context: BlockContext,
-        blockStack: List<BlockContext>,
-        theme: EditorTheme?,
-        density: Float
-    ): Float {
-        val indentPerDepth = (theme?.list?.indent ?: LayoutConstants.INDENT_PER_DEPTH) * density
-        val quoteDepth = blockquoteDepth(blockStack)
-        val columnsDepth = columnContainerDepth(blockStack)
-        val quoteIndent = maxOf(
-            theme?.blockquote?.indent ?: LayoutConstants.BLOCKQUOTE_INDENT,
-            (theme?.blockquote?.markerGap ?: LayoutConstants.BLOCKQUOTE_MARKER_GAP) +
-                (theme?.blockquote?.borderWidth ?: LayoutConstants.BLOCKQUOTE_BORDER_WIDTH)
-        ) * density
-        val listBaseIndentAdjustment = calculateListBaseIndentAdjustment(context, theme, density)
-        return (context.depth * indentPerDepth) -
-            (quoteDepth * indentPerDepth) +
-            -(columnsDepth * indentPerDepth) +
-            listBaseIndentAdjustment +
-            (quoteDepth * quoteIndent)
-    }
-
-    private fun calculateListBaseIndentAdjustment(
-        context: BlockContext,
-        theme: EditorTheme?,
-        density: Float
-    ): Float {
-        if (context.listContext == null) {
-            return 0f
-        }
-
-        val indentPerDepth = (theme?.list?.indent ?: LayoutConstants.INDENT_PER_DEPTH) * density
-        val listBaseIndentMultiplier = maxOf(theme?.list?.baseIndentMultiplier ?: 1f, 0f)
-        return (listBaseIndentMultiplier - 1f) * indentPerDepth
-    }
-
-    private fun effectiveBlockContext(blockStack: List<BlockContext>): BlockContext? {
-        val currentBlock = blockStack.lastOrNull() ?: return null
-        if (currentBlock.listContext != null) {
-            return currentBlock
-        }
-        val inheritedListBlock = blockStack
-            .dropLast(1)
-            .asReversed()
-            .firstOrNull { it.listContext != null }
-            ?: return currentBlock
-        return currentBlock.copy(
-            depth = currentBlock.depth,
-            listContext = inheritedListBlock.listContext,
-            markerPending = false
-        )
-    }
-
-    private fun effectiveParagraphStart(blockStack: List<BlockContext>): Int {
-        val currentBlock = blockStack.lastOrNull() ?: return 0
-        if (currentBlock.listContext != null) {
-            return currentBlock.renderStart
-        }
-        return blockStack
-            .dropLast(1)
-            .asReversed()
-            .firstOrNull { it.listContext != null }
-            ?.renderStart
-            ?: currentBlock.renderStart
-    }
-
-    private fun renderedParagraphStart(
-        builder: CharSequence,
-        candidateStart: Int
-    ): Int {
-        val boundedStart = candidateStart.coerceIn(0, builder.length)
-        if (boundedStart == 0) return 0
-
-        for (index in boundedStart - 1 downTo 0) {
-            if (builder[index] == '\n') {
-                return index + 1
-            }
-        }
-        return 0
-    }
-
-    private fun consumePendingListMarker(
-        blockStack: MutableList<BlockContext>,
-        markerRenderStart: Int
-    ): JSONObject? {
-        if (blockStack.size < 2) return null
-        for (idx in blockStack.lastIndex - 1 downTo 0) {
-            val context = blockStack[idx]
-            if (!context.markerPending) continue
-            context.markerPending = false
-            context.renderStart = markerRenderStart
-            return context.listContext
-        }
-        return null
-    }
-
-    private fun calculateMarkerWidth(density: Float): Float {
-        return LayoutConstants.LIST_MARKER_WIDTH * density
-    }
-
-    private fun blockquoteDepth(blockStack: List<BlockContext>): Float {
-        return blockStack.count { it.nodeType == "blockquote" }.toFloat()
-    }
-
-    private fun columnContainerDepth(blockStack: List<BlockContext>): Float {
-        return blockStack.count { it.nodeType == "columns" || it.nodeType == "column" }.toFloat()
-    }
-
-    private fun isTransparentContainer(nodeType: String): Boolean {
-        return nodeType == "blockquote" || nodeType == "columns" || nodeType == "column"
-    }
-
-    private fun resolveTextStyle(
-        nodeType: String,
-        theme: EditorTheme?,
-        inBlockquote: Boolean = false
-    ): EditorTextStyle {
-        return theme?.effectiveTextStyle(nodeType, inBlockquote) ?: EditorTextStyle()
-    }
-
-    private fun resolveInlineTextColor(
-        blockStack: List<BlockContext>,
-        fallbackColor: Int,
-        theme: EditorTheme?
-    ): Int {
-        val nodeType = effectiveBlockContext(blockStack)?.nodeType ?: "paragraph"
-        return resolveTextStyle(nodeType, theme, blockquoteDepth(blockStack) > 0).color ?: fallbackColor
-    }
-
-    fun listMarkerString(listContext: JSONObject): String {
-        if (listContext.optString("kind", "") == "task") {
-            return if (listContext.optBoolean("checked", false)) "\u2611 " else "\u2610 "
-        }
-        val ordered = listContext.optBoolean("ordered", false)
-        return if (ordered) {
-            val index = listContext.optInt("index", 1)
-            "$index. "
-        } else {
-            LayoutConstants.UNORDERED_LIST_BULLET
-        }
-    }
-
-    private fun isListItemNodeType(nodeType: String): Boolean {
-        return nodeType == "listItem" || nodeType == "taskItem"
-    }
-
-    /**
-     * Parse a [JSONArray] of marks into a list of mark identifiers.
-     *
-     * Each mark can be either a plain string (e.g. "bold") or a JSON object
-     * (e.g. `{"type": "link", "href": "https://..."}`). Returns a mixed list
-     * of [String] and [JSONObject].
-     */
-    private fun parseMarks(marksArray: JSONArray?): List<Any> {
-        if (marksArray == null || marksArray.length() == 0) return emptyList()
-        val marks = mutableListOf<Any>()
-        for (i in 0 until marksArray.length()) {
-            when (val mark = marksArray.opt(i)) {
-                is String -> marks.add(mark)
-                is JSONObject -> marks.add(mark)
-            }
-        }
-        return marks
-    }
-
-    /**
-     * Append a newline used between blocks (inter-block separator).
-     *
-     * When [spacingPx] > 0, applies a [ParagraphSpacerSpan] to the newline
-     * character to create vertical spacing after the preceding block.
-     */
-    private fun appendInterBlockNewline(
-        builder: SpannableStringBuilder,
-        baseFontSize: Float,
-        textColor: Int,
-        spacingPx: Int = 0,
-        inBlockquote: Boolean = false,
-        topLevelChildIndex: Int? = null
-    ) {
-        val start = builder.length
-        builder.append("\n")
-        val end = builder.length
-        if (spacingPx > 0) {
-            builder.setSpan(
-                ParagraphSpacerSpan(spacingPx, baseFontSize.toInt(), textColor),
-                start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
-            )
-        } else {
-            builder.setSpan(
-                ForegroundColorSpan(textColor),
-                start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
-            )
-            builder.setSpan(
-                AbsoluteSizeSpan(baseFontSize.toInt(), false),
-                start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
-            )
-        }
-        annotateTopLevelChild(builder, start, end, topLevelChildIndex)
-        if (inBlockquote) {
-            builder.setSpan(
-                Annotation(NATIVE_BLOCKQUOTE_ANNOTATION, "1"),
-                start,
-                end,
-                Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
-            )
-        }
-    }
-
-    private fun appendTrailingHardBreakPlaceholderIfNeeded(
-        builder: SpannableStringBuilder,
-        endedBlock: BlockContext,
-        remainingBlockStack: List<BlockContext>,
-        baseFontSize: Float,
-        textColor: Int,
-        theme: EditorTheme?,
-        density: Float,
-        pendingLeadingMargins: MutableMap<Int, PendingLeadingMargin>
-    ) {
-        if (builder.isEmpty()) return
-        if (isListItemNodeType(endedBlock.nodeType)) return
-        if (!lastCharacterIsHardBreak(builder)) return
-
-        val start = builder.length
-        builder.append(LayoutConstants.SYNTHETIC_PLACEHOLDER_CHARACTER)
-        val end = builder.length
-        builder.setSpan(
-            Annotation(NATIVE_SYNTHETIC_PLACEHOLDER_ANNOTATION, "1"),
-            start,
-            end,
-            Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
-        )
-        builder.setSpan(
-            ForegroundColorSpan(resolveInlineTextColor(remainingBlockStack + endedBlock, textColor, theme)),
-            start,
-            end,
-            Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
-        )
-        applyBlockStyle(
-            builder,
-            start,
-            end,
-            remainingBlockStack + endedBlock,
-            pendingLeadingMargins,
-            theme,
-            density
-        )
-    }
-
-    private fun lastCharacterIsHardBreak(builder: SpannableStringBuilder): Boolean {
-        if (builder.isEmpty()) return false
-        val lastIndex = builder.length - 1
-        return builder.getSpans(lastIndex, builder.length, Annotation::class.java).any {
-            it.key == "nativeVoidNodeType" && it.value == "hardBreak"
-        }
-    }
-
-    private fun annotateTopLevelChild(
-        builder: SpannableStringBuilder,
-        start: Int,
-        end: Int,
-        topLevelChildIndex: Int?
-    ) {
-        if (topLevelChildIndex == null || start >= end) return
-        builder.setSpan(
-            Annotation(NATIVE_TOP_LEVEL_CHILD_INDEX_ANNOTATION, topLevelChildIndex.toString()),
-            start,
-            end,
-            Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
-        )
-    }
-
-    private fun trailingRenderedContentHasBlockquote(builder: Spanned): Boolean {
-        for (index in builder.length - 1 downTo 0) {
-            val ch = builder[index]
-            if (ch == '\n' || ch == '\r') continue
-            return hasBlockquoteAnnotationAt(builder, index)
-        }
-        return false
-    }
-
-    private fun defaultParagraphEnd(text: String, length: Int, paragraphStart: Int): Int {
-        val newlineIndex = text.indexOf('\n', paragraphStart)
-        return if (newlineIndex >= 0) newlineIndex + 1 else length
-    }
-
-    private fun blockquoteSpanEnd(
-        builder: Spanned,
-        text: String,
-        paragraphStart: Int
-    ): Int {
-        var cursor = paragraphStart
-        while (cursor < builder.length) {
-            val newlineIndex = text.indexOf('\n', cursor)
-            if (newlineIndex < 0) {
-                return builder.length
-            }
-            val newlineQuoted = hasBlockquoteAnnotationAt(builder, newlineIndex)
-            val nextIndex = newlineIndex + 1
-            val nextQuoted = nextIndex < builder.length && hasBlockquoteAnnotationAt(builder, nextIndex)
-
-            if (!newlineQuoted && !nextQuoted) {
-                return nextIndex
-            }
-            cursor = nextIndex
-        }
-        return builder.length
-    }
-
-    private fun hasBlockquoteAnnotationAt(text: Spanned, index: Int): Boolean {
-        if (index < 0 || index >= text.length) return false
-        return text.getSpans(index, index + 1, Annotation::class.java).any {
-            it.key == NATIVE_BLOCKQUOTE_ANNOTATION
-        }
-    }
-}
-
-private fun JSONObject.optPositiveFloat(key: String): Float? {
-    if (!has(key) || isNull(key)) return null
-    val value = optDouble(key, Double.NaN)
-    if (value.isNaN() || value <= 0.0) return null
-    return value.toFloat()
-}