react-native-marcus 0.1.0

package/android/src/main/java/app/getbullet/marcus/MarkdownFormatter.kt

@@ -0,0 +1,333 @@
+package app.getbullet.marcus
+
+import android.content.res.AssetManager
+import android.os.Trace
+import android.text.SpannableStringBuilder
+import android.text.Spanned
+import android.text.TextPaint
+import android.text.style.MetricAffectingSpan
+import app.getbullet.marcus.spans.MarkdownBackgroundColorSpan
+import app.getbullet.marcus.spans.MarkdownBackgroundSpan
+import app.getbullet.marcus.spans.MarkdownBlockIndentSpan
+import app.getbullet.marcus.spans.MarkdownBoldSpan
+import app.getbullet.marcus.spans.MarkdownFontFamilySpan
+import app.getbullet.marcus.spans.MarkdownFontSizeSpan
+import app.getbullet.marcus.spans.MarkdownForegroundColorSpan
+import app.getbullet.marcus.spans.MarkdownGapSpan
+import app.getbullet.marcus.spans.MarkdownItalicSpan
+import app.getbullet.marcus.spans.MarkdownLineHeightSpan
+import app.getbullet.marcus.spans.MarkdownSpan
+import app.getbullet.marcus.spans.MarkdownStrikethroughSpan
+import app.getbullet.marcus.spans.MarkdownUnderlineSpan
+import com.facebook.react.uimanager.PixelUtil
+
+class MarkdownFormatter(private val assetManager: AssetManager) {
+
+  fun format(
+    ssb: SpannableStringBuilder,
+    markdownRanges: List<MarkdownRange>,
+    markdownStyle: MarkdownStyle,
+    textPaint: TextPaint?
+  ) {
+    try {
+      Trace.beginSection("format")
+      removeSpans(ssb)
+      applyRanges(ssb, markdownRanges, markdownStyle, textPaint)
+    } finally {
+      Trace.endSection()
+    }
+  }
+
+  private fun removeSpans(ssb: SpannableStringBuilder) {
+    try {
+      Trace.beginSection("removeSpans")
+      // We shouldn't use `removeSpans()` because it also removes SpellcheckSpan, SuggestionSpan etc.
+      for (span in ssb.getSpans(0, ssb.length, MarkdownSpan::class.java)) {
+        ssb.removeSpan(span)
+      }
+    } finally {
+      Trace.endSection()
+    }
+  }
+
+  private fun applyRanges(
+    ssb: SpannableStringBuilder,
+    markdownRanges: List<MarkdownRange>,
+    markdownStyle: MarkdownStyle,
+    textPaint: TextPaint?
+  ) {
+    try {
+      Trace.beginSection("applyRanges")
+      // Containers arrive per line, outermost first, each preceded by the run of
+      // text its own marker takes up on that line.
+      val line = BlockLayout(markdownStyle, textPaint)
+      var prefix: MarkdownRange? = null
+
+      for (markdownRange in markdownRanges) {
+        if (markdownRange.type == "block-prefix") {
+          prefix = markdownRange
+          continue
+        }
+
+        val gutter = gutterOf(markdownRange, markdownStyle)
+
+        if (gutter != null) {
+          line.add(ssb, markdownRange, gutter, prefix)
+          prefix = null
+          continue
+        }
+
+        applyRange(ssb, markdownRange, markdownStyle)
+      }
+    } finally {
+      Trace.endSection()
+    }
+  }
+
+  /** The gutter a container reserves for itself, or null if it is not one. */
+  private fun gutterOf(markdownRange: MarkdownRange, markdownStyle: MarkdownStyle): Float? {
+    val step = when (markdownRange.type) {
+      "blockquote" ->
+        markdownStyle.blockquoteMarginLeft +
+          markdownStyle.blockquoteBorderWidth +
+          markdownStyle.blockquotePaddingLeft
+
+      "list-ordered" ->
+        markdownStyle.orderedListMarginLeft + markdownStyle.orderedListPaddingLeft
+
+      "list-unordered" ->
+        markdownStyle.unorderedListMarginLeft + markdownStyle.unorderedListPaddingLeft
+
+      else -> return null
+    }
+
+    return PixelUtil.toPixelFromDIP(step) * markdownRange.depth
+  }
+
+  /**
+   * Places the containers of one line, left to right.
+   *
+   * Each container reserves a gutter and is then followed by its own marker,
+   * which is text and so has to be stepped over rather than reserved: the
+   * container nested inside it starts after the marker, not in front of it. That
+   * is what puts a quote's ribbons after a list bullet, and a list's indent
+   * after a quote's `>`.
+   *
+   * A line continuing a block carries no marker of its own, and reuses the one
+   * that opened it -- otherwise its text, and any ribbon beside it, would sit at
+   * a different offset than the line above and break the block in two.
+   */
+  private class BlockLayout(
+    private val markdownStyle: MarkdownStyle,
+    private val textPaint: TextPaint?
+  ) {
+    /** Scratch paint, reset from [textPaint] before each measurement. */
+    private val measurePaint = TextPaint()
+
+    /** Last marker seen for each container type, for the lines that continue it. */
+    private val markers = HashMap<String, MarkdownRange>()
+    private var lineStart = -1
+    /** Offset reached so far, from the line's own left edge. */
+    private var offset = 0f
+    /**
+     * Where the line's first marker begins, if it has one. The text starts
+     * there; everything past it is held open with padding instead.
+     */
+    private var textStart = -1f
+    /** Marker of the container placed most recently, if it is on this line. */
+    private var padded: MarkdownRange? = null
+    private var span: MarkdownBlockIndentSpan? = null
+
+    fun add(
+      ssb: SpannableStringBuilder,
+      markdownRange: MarkdownRange,
+      gutter: Float,
+      prefix: MarkdownRange?
+    ) {
+      if (markdownRange.start != lineStart) {
+        lineStart = markdownRange.start
+        offset = 0f
+        textStart = -1f
+        padded = null
+        span = MarkdownBlockIndentSpan(
+          markdownStyle.blockquoteBorderColor,
+          PixelUtil.toPixelFromDIP(markdownStyle.blockquoteBorderWidth),
+          PixelUtil.toPixelFromDIP(
+            markdownStyle.blockquoteMarginLeft +
+              markdownStyle.blockquoteBorderWidth +
+              markdownStyle.blockquotePaddingLeft
+          )
+        ).also {
+          ssb.setSpan(it, markdownRange.start, markdownRange.end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE)
+        }
+      }
+
+      val indent = span ?: return
+
+      padded?.let {
+        ssb.setSpan(
+          MarkdownGapSpan(gutter, markdownStyle.syntaxColor),
+          it.end - 1,
+          it.end,
+          Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
+        )
+      }
+
+      if (markdownRange.type == "blockquote") {
+        indent.ribbonOffset = offset + PixelUtil.toPixelFromDIP(markdownStyle.blockquoteMarginLeft)
+        indent.depth = markdownRange.depth
+      }
+
+      offset += gutter
+
+      if (prefix != null) {
+        markers[markdownRange.type] = prefix
+        if (textStart < 0f) {
+          textStart = offset
+        }
+      }
+
+      (prefix ?: markers[markdownRange.type])?.let {
+        offset += measure(ssb, it.start, it.end)
+      }
+
+      padded = prefix
+      indent.firstLineIndent = if (textStart >= 0f) textStart else offset
+      indent.indent = offset
+    }
+
+    /**
+     * Width a marker renders at.
+     *
+     * The view's paint carries the text size while the measure path has none and
+     * leaves it on the spannable, so the metric spans are folded in either way.
+     * Padding added after a marker is a replacement span, which contributes
+     * nothing here -- it belongs to the container that follows, not the marker.
+     */
+    private fun measure(ssb: SpannableStringBuilder, start: Int, end: Int): Float {
+      if (textPaint != null) {
+        measurePaint.set(textPaint)
+      } else {
+        measurePaint.reset()
+      }
+
+      for (span in ssb.getSpans(start, end, MetricAffectingSpan::class.java)) {
+        span.updateMeasureState(measurePaint)
+      }
+
+      return measurePaint.measureText(ssb, start, end)
+    }
+  }
+
+  private fun applyRange(
+    ssb: SpannableStringBuilder,
+    markdownRange: MarkdownRange,
+    markdownStyle: MarkdownStyle
+  ) {
+    val start = markdownRange.start
+    val end = markdownRange.end
+    when (markdownRange.type) {
+      "bold" -> setSpan(ssb, MarkdownBoldSpan(), start, end)
+
+      "italic" -> setSpan(ssb, MarkdownItalicSpan(), start, end)
+
+      "strikethrough" -> setSpan(ssb, MarkdownStrikethroughSpan(), start, end)
+
+      "emoji" -> {
+        setSpan(
+          ssb,
+          MarkdownFontFamilySpan(markdownStyle.emojiFontFamily, assetManager),
+          start,
+          end
+        )
+        setSpan(ssb, MarkdownFontSizeSpan(markdownStyle.emojiFontSize), start, end)
+      }
+
+      "mention-here" -> {
+        setSpan(ssb, MarkdownForegroundColorSpan(markdownStyle.mentionHereColor), start, end)
+        setSpan(
+          ssb,
+          MarkdownBackgroundSpan(
+            markdownStyle.mentionHereBackgroundColor,
+            markdownStyle.mentionHereBorderRadius,
+            start,
+            end
+          ),
+          start,
+          end
+        )
+      }
+
+      "mention-user" -> {
+        // TODO: change mention color when it mentions current user
+        setSpan(ssb, MarkdownForegroundColorSpan(markdownStyle.mentionUserColor), start, end)
+        setSpan(
+          ssb,
+          MarkdownBackgroundSpan(
+            markdownStyle.mentionUserBackgroundColor,
+            markdownStyle.mentionUserBorderRadius,
+            start,
+            end
+          ),
+          start,
+          end
+        )
+      }
+
+      "mention-report" -> {
+        setSpan(ssb, MarkdownForegroundColorSpan(markdownStyle.mentionReportColor), start, end)
+        setSpan(
+          ssb,
+          MarkdownBackgroundSpan(
+            markdownStyle.mentionReportBackgroundColor,
+            markdownStyle.mentionReportBorderRadius,
+            start,
+            end
+          ),
+          start,
+          end
+        )
+      }
+
+      "syntax" -> setSpan(ssb, MarkdownForegroundColorSpan(markdownStyle.syntaxColor), start, end)
+
+      "link" -> {
+        setSpan(ssb, MarkdownUnderlineSpan(), start, end)
+        setSpan(ssb, MarkdownForegroundColorSpan(markdownStyle.linkColor), start, end)
+      }
+
+      "code" -> {
+        setSpan(ssb, MarkdownFontFamilySpan(markdownStyle.codeFontFamily, assetManager), start, end)
+        setSpan(ssb, MarkdownFontSizeSpan(markdownStyle.codeFontSize), start, end)
+        setSpan(ssb, MarkdownForegroundColorSpan(markdownStyle.codeColor), start, end)
+        setSpan(ssb, MarkdownBackgroundColorSpan(markdownStyle.codeBackgroundColor), start, end)
+      }
+
+      "pre" -> {
+        setSpan(ssb, MarkdownFontFamilySpan(markdownStyle.preFontFamily, assetManager), start, end)
+        setSpan(ssb, MarkdownFontSizeSpan(markdownStyle.preFontSize), start, end)
+        setSpan(ssb, MarkdownForegroundColorSpan(markdownStyle.preColor), start, end)
+        setSpan(ssb, MarkdownBackgroundColorSpan(markdownStyle.preBackgroundColor), start, end)
+      }
+
+      "heading" -> {
+        setSpan(ssb, MarkdownBoldSpan(), start, end)
+        // Level N is the base size scaled N-1 times, so a single pair of style
+        // values covers all six.
+        var fontSize = markdownStyle.headingFontSize
+        repeat(maxOf(markdownRange.depth, 1) - 1) { fontSize *= markdownStyle.headingScale }
+        val lineHeight = ReactLineHeight.find(ssb)
+        if (lineHeight >= 0) {
+          setSpan(ssb, MarkdownLineHeightSpan(lineHeight * (fontSize / markdownStyle.headingFontSize) * 1.5f), start, end)
+        }
+        // NOTE: size span must be set after line height span to avoid height jumps
+        setSpan(ssb, MarkdownFontSizeSpan(fontSize), start, end)
+      }
+
+    }
+  }
+
+  private fun setSpan(ssb: SpannableStringBuilder, span: MarkdownSpan, start: Int, end: Int) {
+    ssb.setSpan(span, start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE)
+  }
+}

package/android/src/main/java/app/getbullet/marcus/MarkdownParseResult.kt

@@ -0,0 +1,12 @@
+package app.getbullet.marcus
+
+/**
+ * What [MarkdownParser.nativeParse] hands back across JNI. Constructed from C++ via fbjni
+ * `newInstance`, so the constructor signature is load-bearing:
+ * `([Lapp/getbullet/marcus/MarkdownRange;Ljava/lang/String;)V`.
+ */
+class MarkdownParseResult(
+  @JvmField val ranges: Array<MarkdownRange>,
+  /** Non-null when the worklet returned something that did not match the expected schema. */
+  @JvmField val schemaError: String?
+)

package/android/src/main/java/app/getbullet/marcus/MarkdownParser.kt

@@ -0,0 +1,89 @@
+package app.getbullet.marcus
+
+import android.os.Trace
+import app.getbullet.marcus.MarkdownParser.Companion.shared
+import com.facebook.soloader.SoLoader
+
+/**
+ * Runs the registered markdown parser worklet and caches its output.
+ *
+ * Use [shared]. Each markdown input has two independent callers, the decorator view's
+ * TextWatcher and CustomFabricUIManager's measureText, and one cache shared between them
+ * beats one cache each. Note this is not a 2x saving: tracing shows a keystroke produces
+ * four parse calls but only one worklet run, because they all ask for the same text.
+ *
+ * Knows nothing about ReactContext or logging: it outlives every reload, so holding a context
+ * would leak it, and reporting is left to the caller via [onSchemaError].
+ */
+class MarkdownParser private constructor() {
+
+  private data class CacheKey(val text: String, val parserId: Int)
+
+  private val lock = Any()
+
+  private val cache =
+    object : LinkedHashMap<CacheKey, List<MarkdownRange>>(CACHE_CAPACITY, 0.75f, true) {
+      override fun removeEldestEntry(
+        eldest: MutableMap.MutableEntry<CacheKey, List<MarkdownRange>>
+      ): Boolean = size > CACHE_CAPACITY
+    }
+
+  // Registered from C++ by JMarkdownParser::registerNatives in MarkdownParser.cpp. Must stay
+  // an instance method to match the `alias_ref<JMarkdownParser>` first parameter there.
+  private external fun nativeParse(text: String, parserId: Int): MarkdownParseResult
+
+  fun parse(
+    text: String,
+    parserId: Int,
+    onSchemaError: (String) -> Unit
+  ): List<MarkdownRange> {
+    try {
+      Trace.beginSection("parse")
+
+      val key = CacheKey(text, parserId)
+      synchronized(lock) { cache[key] }?.let { return it }
+
+      // Deliberately outside the lock. nativeParse waits on the markdown worklet runtime,
+      // and holding a lock across that wait is what let a background parse block the main
+      // thread until iOS killed the app (Expensify/react-native-live-markdown#772). Android
+      // has no watchdog to make it fatal, but it is the same defect.
+      val ranges = parseUncached(text, parserId, onSchemaError)
+
+      synchronized(lock) { cache[key] = ranges }
+      return ranges
+    } finally {
+      Trace.endSection()
+    }
+  }
+
+  private fun parseUncached(
+    text: String,
+    parserId: Int,
+    onSchemaError: (String) -> Unit
+  ): List<MarkdownRange> {
+    val result = try {
+      Trace.beginSection("nativeParse")
+      nativeParse(text, parserId)
+    } catch (e: Exception) {
+      // Skip formatting, runGuarded will show the error in LogBox
+      return emptyList()
+    } finally {
+      Trace.endSection()
+    }
+
+    result.schemaError?.let(onSchemaError)
+
+    return result.ranges.asList()
+  }
+
+  companion object {
+    private const val CACHE_CAPACITY = 8
+
+    init {
+      SoLoader.loadLibrary("marcus")
+    }
+
+    @JvmStatic
+    val shared: MarkdownParser = MarkdownParser()
+  }
+}

package/android/src/main/java/app/getbullet/marcus/MarkdownRange.kt

@@ -0,0 +1,11 @@
+package app.getbullet.marcus
+
+data class MarkdownRange(
+  val type: String,
+  val start: Int,
+  val length: Int,
+  val depth: Int
+) {
+  val end: Int
+    get() = start + length
+}

package/android/src/main/java/app/getbullet/marcus/MarkdownStyle.kt

@@ -0,0 +1,81 @@
+package app.getbullet.marcus
+
+import android.content.Context
+import androidx.annotation.ColorInt
+import com.facebook.react.bridge.ColorPropConverter
+import com.facebook.react.bridge.JSApplicationCausedNativeException
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+
+class MarkdownStyle(map: ReadableMap, context: Context) {
+  private val screenDensity = context.resources.displayMetrics.density
+
+  @ColorInt val syntaxColor = parseColor(map, "syntax", "color", context)
+  @ColorInt val linkColor = parseColor(map, "link", "color", context)
+
+  val headingFontSize = parseFloat(map, "heading", "fontSize")
+
+  val headingScale = parseFloat(map, "heading", "scale")
+
+  val emojiFontSize = parseFloat(map, "emoji", "fontSize")
+  val emojiFontFamily = parseString(map, "emoji", "fontFamily")
+
+  @ColorInt val blockquoteBorderColor = parseColor(map, "blockquote", "borderColor", context)
+  val blockquoteBorderWidth = parseFloat(map, "blockquote", "borderWidth")
+  val blockquoteMarginLeft = parseFloat(map, "blockquote", "marginLeft")
+  val blockquotePaddingLeft = parseFloat(map, "blockquote", "paddingLeft")
+
+  val orderedListMarginLeft = parseFloat(map, "orderedList", "marginLeft")
+  val orderedListPaddingLeft = parseFloat(map, "orderedList", "paddingLeft")
+
+  val unorderedListMarginLeft = parseFloat(map, "unorderedList", "marginLeft")
+  val unorderedListPaddingLeft = parseFloat(map, "unorderedList", "paddingLeft")
+
+  val codeFontFamily = parseString(map, "code", "fontFamily")
+  val codeFontSize = parseFloat(map, "code", "fontSize")
+  @ColorInt val codeColor = parseColor(map, "code", "color", context)
+  @ColorInt val codeBackgroundColor = parseColor(map, "code", "backgroundColor", context)
+
+  val preFontFamily = parseString(map, "pre", "fontFamily")
+  val preFontSize = parseFloat(map, "pre", "fontSize")
+  @ColorInt val preColor = parseColor(map, "pre", "color", context)
+  @ColorInt val preBackgroundColor = parseColor(map, "pre", "backgroundColor", context)
+
+  @ColorInt val mentionHereColor = parseColor(map, "mentionHere", "color", context)
+  @ColorInt val mentionHereBackgroundColor = parseColor(map, "mentionHere", "backgroundColor", context)
+  val mentionHereBorderRadius = parseFloat(map, "mentionHere", "borderRadius") * screenDensity
+
+  @ColorInt val mentionUserColor = parseColor(map, "mentionUser", "color", context)
+  @ColorInt val mentionUserBackgroundColor = parseColor(map, "mentionUser", "backgroundColor", context)
+  val mentionUserBorderRadius = parseFloat(map, "mentionUser", "borderRadius") * screenDensity
+
+  @ColorInt val mentionReportColor = parseColor(map, "mentionReport", "color", context)
+  @ColorInt val mentionReportBackgroundColor = parseColor(map, "mentionReport", "backgroundColor", context)
+  val mentionReportBorderRadius = parseFloat(map, "mentionReport", "borderRadius") * screenDensity
+
+  private companion object {
+    fun style(map: ReadableMap, key: String): ReadableMap =
+      requireNotNull(map.getMap(key)) { "[react-native-marcus] markdownStyle.$key is missing" }
+
+    @ColorInt
+    fun parseColor(map: ReadableMap, key: String, prop: String, context: Context): Int {
+      val value = style(map, key).getDynamic(prop)
+      val color = when (value.type) {
+        ReadableType.Number -> ColorPropConverter.getColor(value.asDouble(), context)
+        ReadableType.Map -> ColorPropConverter.getColor(value.asMap(), context)
+        else -> throw JSApplicationCausedNativeException("ColorValue: the value must be a number or Object.")
+      }
+      return requireNotNull(color) {
+        "[react-native-marcus] markdownStyle.$key.$prop could not be resolved to a color"
+      }
+    }
+
+    fun parseFloat(map: ReadableMap, key: String, prop: String): Float =
+      style(map, key).getDouble(prop).toFloat()
+
+    fun parseString(map: ReadableMap, key: String, prop: String): String =
+      requireNotNull(style(map, key).getString(prop)) {
+        "[react-native-marcus] markdownStyle.$key.$prop is missing"
+      }
+  }
+}

package/android/src/main/java/app/getbullet/marcus/MarkdownTextWatcher.kt

@@ -0,0 +1,17 @@
+package app.getbullet.marcus
+
+import android.text.Editable
+import android.text.SpannableStringBuilder
+import android.text.TextWatcher
+
+class MarkdownTextWatcher(private val markdownUtils: MarkdownUtils) : TextWatcher {
+  override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) {}
+
+  override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {}
+
+  override fun afterTextChanged(editable: Editable) {
+    if (editable is SpannableStringBuilder) {
+      markdownUtils.applyMarkdownFormatting(editable)
+    }
+  }
+}

package/android/src/main/java/app/getbullet/marcus/MarkdownUtils.kt

@@ -0,0 +1,84 @@
+package app.getbullet.marcus
+
+import android.os.Trace
+import android.text.SpannableStringBuilder
+import android.text.Spanned
+import android.text.TextPaint
+import android.text.TextUtils
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.util.RNLog
+
+/**
+ * @param textPaint the view's own paint, held live rather than copied: the
+ *   formatter measures block markers with it to work out where the containers
+ *   nested inside them start, and has to see the size the text is drawn at.
+ *   Null on the measure path, which has no view yet and carries the size on the
+ *   spannable instead.
+ */
+class MarkdownUtils @JvmOverloads constructor(
+  private val reactContext: ReactContext,
+  private val textPaint: TextPaint? = null
+) {
+  private val markdownFormatter = MarkdownFormatter(reactContext.assets)
+
+  // Hoisted rather than built per call: applyMarkdownFormatting runs several times per
+  // keystroke, and this is only ever needed for a warning that normally never fires.
+  private val onSchemaError: (String) -> Unit = { error ->
+    RNLog.w(reactContext, "[react-native-marcus] Incorrect schema of worklet parser output: $error")
+  }
+
+  var markdownStyle: MarkdownStyle? = null
+  var parserId: Int = 0
+
+  /**
+   * Records what the markdown spans currently on a spannable were built from.
+   *
+   * Held as a span rather than a field so that it is invalidated by exactly the things that
+   * invalidate the formatting itself. Anything that replaces the spannable's content drops
+   * this along with the markdown spans, and the next pass rebuilds both. A field would
+   * survive that and we would skip a pass that was actually needed.
+   */
+  private class Fingerprint(val text: String, val parserId: Int, val style: MarkdownStyle)
+
+  fun applyMarkdownFormatting(ssb: SpannableStringBuilder) {
+    try {
+      Trace.beginSection("applyMarkdownFormatting")
+      val style = checkNotNull(markdownStyle) { "[react-native-marcus] markdownStyle is null" }
+
+      // A single keystroke drives four passes: two from the edit itself and two from React
+      // Native's state round-trip. They all ask for the same text, so only the first has any
+      // work to do.
+      if (isUpToDate(ssb, style)) {
+        return
+      }
+
+      val text = ssb.toString()
+      val markdownRanges = MarkdownParser.shared.parse(text, parserId, onSchemaError)
+      markdownFormatter.format(ssb, markdownRanges, style, textPaint)
+      stamp(ssb, text, style)
+    } finally {
+      Trace.endSection()
+    }
+  }
+
+  private fun isUpToDate(ssb: SpannableStringBuilder, style: MarkdownStyle): Boolean {
+    val fingerprint =
+      ssb.getSpans(0, ssb.length, Fingerprint::class.java).singleOrNull() ?: return false
+    return fingerprint.parserId == parserId &&
+      // Identity, not equality: MarkdownStyle is rebuilt whenever the prop arrives, so a
+      // different instance means the style may have changed and we re-apply to be safe.
+      fingerprint.style === style &&
+      // Compares the CharSequence in place. ssb.toString() would copy the whole document on
+      // a path whose entire purpose is to do no work.
+      TextUtils.equals(ssb, fingerprint.text)
+  }
+
+  private fun stamp(ssb: SpannableStringBuilder, text: String, style: MarkdownStyle) {
+    // Fingerprint is not a MarkdownSpan, so MarkdownFormatter.removeSpans leaves it alone
+    // and stale ones have to be cleared here or they would accumulate.
+    for (stale in ssb.getSpans(0, ssb.length, Fingerprint::class.java)) {
+      ssb.removeSpan(stale)
+    }
+    ssb.setSpan(Fingerprint(text, parserId, style), 0, ssb.length, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE)
+  }
+}

package/android/src/main/java/app/getbullet/marcus/ReactLineHeight.java

@@ -0,0 +1,29 @@
+package app.getbullet.marcus;
+
+import android.text.Spanned;
+
+import com.facebook.react.views.text.internal.span.CustomLineHeightSpan;
+
+/**
+ * React Native's {@code CustomLineHeightSpan} is declared {@code internal} in Kotlin. It stays
+ * public in the bytecode, so Java can still reach it, but the Kotlin compiler refuses to. This
+ * shim keeps that one lookup in Java.
+ *
+ * <p>The alternatives were worse: reflection breaks silently under R8, and deriving the height by
+ * probing the public {@code LineHeightSpan.chooseHeight} couples us to React Native's internal
+ * metrics maths, which would mis-space h1 lines without failing. If React Native ever renames or
+ * removes the class, this file stops compiling, which is the failure mode we want.
+ */
+public final class ReactLineHeight {
+  private ReactLineHeight() {
+  }
+
+  /**
+   * The line height React Native applied to {@code spanned}, or -1 if it applied none.
+   */
+  public static int find(Spanned spanned) {
+    CustomLineHeightSpan[] spans =
+      spanned.getSpans(0, spanned.length(), CustomLineHeightSpan.class);
+    return spans.length >= 1 ? spans[0].getLineHeight() : -1;
+  }
+}

package/android/src/main/java/app/getbullet/marcus/spans/MarkdownBackgroundColorSpan.kt

@@ -0,0 +1,6 @@
+package app.getbullet.marcus.spans
+
+import android.text.style.BackgroundColorSpan
+import androidx.annotation.ColorInt
+
+class MarkdownBackgroundColorSpan(@ColorInt color: Int) : BackgroundColorSpan(color), MarkdownSpan