react-native-enriched-markdown-scaffold 1.0.2-scaffold.1 → 1.0.2-scaffold.10

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

@@ -7,6 +7,7 @@ import android.text.SpannableString
 import android.text.StaticLayout
 import android.text.TextPaint
 import android.util.Log
+import androidx.emoji2.text.EmojiCompat
 import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.uimanager.PixelUtil
 import com.facebook.yoga.YogaMeasureMode
@@ -92,6 +93,38 @@ object MeasurementStore {
   }
 
   private val measurePaint = TextPaint()
+
+  @Volatile
+  private var emojiInitCallbackRegistered = false
+
+  // A view measured before EmojiCompat loaded keeps a size without its emoji glyphs.
+  private val emojiInitCallback =
+    object : EmojiCompat.InitCallback() {
+      override fun onInitialized() {
+        data.clear()
+      }
+    }
+
+  // AppCompatTextView draws emoji the system font lacks through EmojiCompat, which can be
+  // wider than the fallback glyph and wrap a line earlier; measure the same glyphs.
+  private fun withEmojiSpans(text: CharSequence): CharSequence {
+    if (text.isEmpty() || !EmojiCompat.isConfigured()) return text
+    val emojiCompat = EmojiCompat.get()
+    if (emojiCompat.loadState != EmojiCompat.LOAD_STATE_SUCCEEDED) {
+      if (!emojiInitCallbackRegistered) {
+        emojiInitCallbackRegistered = true
+        emojiCompat.registerInitCallback(emojiInitCallback)
+      }
+      return text
+    }
+    return try {
+      emojiCompat.process(SpannableString(text)) ?: text
+    } catch (e: IllegalStateException) {
+      Log.w(TAG, "EmojiCompat processing failed, measuring raw text", e)
+      text
+    }
+  }
+
   private val measureRenderer = Renderer()
 
   @Volatile
@@ -337,9 +370,12 @@ object MeasurementStore {
       tryRenderMarkdown(markdown, styleMap, context, md4cFlags, allowFontScaling, maxFontSizeMultiplier, imageRequestHeaders)
     // Placeholders must be built with the same inlineMath.paddingVertical the real spans use,
     // or the measured line box won't match the drawn one.
+    val inlineMathMap = styleMap.getMapOrNull("inlineMath")
+    val inlineMathOverflowDip = inlineMathMap.getFloatOrDefault("glyphOverflow", 0f)
     spannable?.replaceMathSpansWithPlaceholders(
       context,
-      PixelUtil.toPixelFromDIP(styleMap.getMapOrNull("inlineMath").getFloatOrDefault("paddingVertical", 0f)),
+      PixelUtil.toPixelFromDIP(inlineMathMap.getFloatOrDefault("paddingVertical", 0f)) +
+        if (inlineMathOverflowDip > 0f) ceil(PixelUtil.toPixelFromDIP(inlineMathOverflowDip)) else 0f,
     )
     val textToMeasure = spannable ?: markdown
     val (size, _) = measureWithLayout(width, textToMeasure, measurePaint, id)
@@ -456,7 +492,8 @@ object MeasurementStore {
         for (i in mathSegmentIndices.indices) {
           val metrics = mathResults[i]
           mathHeightByIndex[mathSegmentIndices[i]] =
-            ceil(metrics.ascent + metrics.descent).toInt() + (style.mathStyle.padding * 2)
+            ceil(metrics.ascent + metrics.descent).toInt() + (style.mathStyle.padding * 2) +
+            (style.mathStyle.glyphOverflow * 2)
         }
       }
 
@@ -471,7 +508,7 @@ object MeasurementStore {
 
         when (segment) {
           is RenderedSegment.Text -> {
-            segment.styledText.replaceMathSpansWithPlaceholders(context, style.inlineMathStyle.paddingVertical)
+            segment.styledText.replaceMathSpansWithPlaceholders(context, style.inlineMathStyle.boxPaddingVertical)
 
             val layout = createStaticLayout(segment.styledText, fontSize, widthPx, id)
             totalHeightPx += layout.height
@@ -546,9 +583,10 @@ object MeasurementStore {
     viewId: Int?,
   ): StaticLayout {
     measurePaint.textSize = fontSize
-    prepareImageSpansForMeasurement(text, widthPx)
+    val content = withEmojiSpans(text)
+    prepareImageSpansForMeasurement(content, widthPx)
     return StaticLayout.Builder
-      .obtain(text, 0, text.length, measurePaint, widthPx)
+      .obtain(content, 0, content.length, measurePaint, widthPx)
       .setIncludePad(false)
       .setLineSpacing(0f, 1f)
       .apply {
@@ -579,7 +617,7 @@ object MeasurementStore {
       style.imageRequestHeaders = imageRequestHeaders
       measureRenderer.configure(style, context)
       measureRenderer.renderDocument(ast, null).apply {
-        replaceMathSpansWithPlaceholders(context, style.inlineMathStyle.paddingVertical)
+        replaceMathSpansWithPlaceholders(context, style.inlineMathStyle.boxPaddingVertical)
       }
     } catch (e: Exception) {
       Log.w(TAG, "Failed to render markdown for measurement, falling back to raw text", e)
@@ -628,7 +666,7 @@ object MeasurementStore {
     paint: TextPaint,
     viewId: Int?,
   ): Long {
-    val content = text ?: ""
+    val content = withEmojiSpans(text ?: "")
     val safeWidth = ceil(maxWidth).toInt().coerceAtLeast(1)
     prepareImageSpansForMeasurement(content, safeWidth)
 
@@ -668,7 +706,7 @@ object MeasurementStore {
     paint: TextPaint,
     viewId: Int?,
   ): Pair<Long, StaticLayout> {
-    val content = text ?: ""
+    val content = withEmojiSpans(text ?: "")
     val widthPx = ceil(maxWidth).toInt().coerceAtLeast(1)
     prepareImageSpansForMeasurement(content, widthPx)
 

package/android/src/main/java/com/swmansion/enriched/markdown/events/CopyRequestEvent.kt

@@ -0,0 +1,28 @@
+package com.swmansion.enriched.markdown.events
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+
+class CopyRequestEvent(
+  surfaceId: Int,
+  viewId: Int,
+  private val source: String,
+  private val markdown: String,
+  private val text: String,
+  private val whole: Boolean,
+) : Event<CopyRequestEvent>(surfaceId, viewId) {
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun getEventData(): WritableMap =
+    Arguments.createMap().apply {
+      putString("source", source)
+      putString("markdown", markdown)
+      putString("text", text)
+      putBoolean("whole", whole)
+    }
+
+  companion object {
+    const val EVENT_NAME: String = "onCopyRequest"
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/events/LinkLayoutEvent.kt

@@ -0,0 +1,36 @@
+package com.swmansion.enriched.markdown.events
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+import com.swmansion.enriched.markdown.utils.text.view.LinkLayoutFragment
+
+class LinkLayoutEvent(
+  surfaceId: Int,
+  viewId: Int,
+  private val fragments: List<LinkLayoutFragment>,
+) : Event<LinkLayoutEvent>(surfaceId, viewId) {
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun getEventData(): WritableMap {
+    val array = Arguments.createArray()
+    fragments.forEach { fragment ->
+      array.pushMap(
+        Arguments.createMap().apply {
+          putInt("linkIndex", fragment.linkIndex)
+          putString("url", fragment.url)
+          putString("text", fragment.text)
+          putDouble("x", fragment.x.toDouble())
+          putDouble("y", fragment.y.toDouble())
+          putDouble("width", fragment.width.toDouble())
+          putDouble("height", fragment.height.toDouble())
+        },
+      )
+    }
+    return Arguments.createMap().apply { putArray("fragments", array) }
+  }
+
+  companion object {
+    const val EVENT_NAME: String = "onLinkLayout"
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/events/SelectionChangeEvent.kt

@@ -0,0 +1,43 @@
+package com.swmansion.enriched.markdown.events
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+import com.swmansion.enriched.markdown.utils.text.view.SelectionRect
+import com.swmansion.enriched.markdown.utils.text.view.SelectionSnapshot
+
+class SelectionChangeEvent(
+  surfaceId: Int,
+  viewId: Int,
+  private val snapshot: SelectionSnapshot,
+) : Event<SelectionChangeEvent>(surfaceId, viewId) {
+  override fun getEventName(): String = EVENT_NAME
+
+  // Every state is distinct (active/inactive flips must all arrive), so never merge.
+  override fun canCoalesce(): Boolean = false
+
+  override fun getEventData(): WritableMap =
+    Arguments.createMap().apply {
+      putBoolean("active", snapshot.active)
+      putString("source", snapshot.source)
+      putString("text", snapshot.text)
+      putString("markdown", snapshot.markdown)
+      putBoolean("whole", snapshot.whole)
+      putMap("rect", snapshot.rect.toWritableMap())
+      putMap("startRect", snapshot.startRect.toWritableMap())
+      putMap("endRect", snapshot.endRect.toWritableMap())
+      putBoolean("adjusting", snapshot.adjusting)
+    }
+
+  private fun SelectionRect.toWritableMap(): WritableMap =
+    Arguments.createMap().apply {
+      putDouble("x", x.toDouble())
+      putDouble("y", y.toDouble())
+      putDouble("width", width.toDouble())
+      putDouble("height", height.toDouble())
+    }
+
+  companion object {
+    const val EVENT_NAME: String = "onSelectionChange"
+  }
+}

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

@@ -796,11 +796,13 @@ class EnrichedMarkdownTextInputView(
   // and block ranges survive the round trip — mirrors iOS's copy:/cut:/paste:
   // overrides. External clips keep default handling.
   //
-  // Paste arrives by two different routes and only the first one is a menu.
+  // Paste arrives by three different routes and only the first one is a menu.
   // This override covers the context menu and the hardware Ctrl+V /
   // KEYCODE_PASTE shortcuts; drag-and-drop, autofill and IME `commitContent`
-  // reach the view through `onReceiveContent` instead. Hooking only one of them
-  // leaves the other pasting straight into the buffer with nobody intercepting.
+  // reach the view through `onReceiveContent` instead, and a keyboard
+  // clipboard chip commits the text through the input connection (see
+  // interceptImePaste). Hooking only some of them leaves the others pasting
+  // straight into the buffer with nobody intercepting.
   override fun onTextContextMenuItem(id: Int): Boolean {
     // Checked before the markdown paste below, which would otherwise insert first.
     if (interceptPaste && (id == android.R.id.paste || id == android.R.id.pasteAsPlainText)) {
@@ -976,6 +978,26 @@ class EnrichedMarkdownTextInputView(
       parts.second
     }
 
+  /**
+   * Keyboard clipboard chips (Gboard, Samsung Keyboard) paste through
+   * `InputConnection.commitText`, a route neither [onTextContextMenuItem] nor
+   * the receive-content listener sees, so the text landed in the buffer with no
+   * `onPaste`. A commit that equals the primary clip is treated as that paste
+   * and reported like the other two routes; the IME commit is then dropped and
+   * JS completes it through [resolvePaste].
+   *
+   * Short typing-sized commits are not compared, so the clipboard is not read
+   * (and Android 12's clipboard toast not shown) while the user types; see
+   * [PasteTextUtils.mayBeImePaste] and [PasteTextUtils.isImePaste].
+   */
+  internal fun interceptImePaste(committed: String): Boolean {
+    if (!interceptPaste || !PasteTextUtils.mayBeImePaste(committed)) return false
+    val clip = readClipboardText()
+    if (!PasteTextUtils.isImePaste(committed, clip)) return false
+    eventEmitter.emitPaste(clip, "")
+    return true
+  }
+
   private fun readClipboardText(): String {
     val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as? ClipboardManager ?: return ""
     val clip = clipboard.primaryClip ?: return ""

package/android/src/main/java/com/swmansion/enriched/markdown/input/editing/InputConnectionWrapper.kt

@@ -106,6 +106,13 @@ class InputConnectionWrapper(
     if (key.length <= 2) {
       dispatchKeyPressOrEnqueue(key.ifEmpty { BACKSPACE_KEY_VALUE })
     }
+    // A keyboard clipboard chip pastes here. When the view claims it as a
+    // paste, the commit is dropped; the composing region is closed first so the
+    // word being typed stays in the buffer instead of being replaced.
+    if (editText.interceptImePaste(key)) {
+      super.finishComposingText()
+      return true
+    }
     return super.commitText(text, newCursorPosition)
   }
 

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

@@ -2,6 +2,9 @@ package com.swmansion.enriched.markdown.renderer
 
 import android.text.SpannableStringBuilder
 import com.swmansion.enriched.markdown.parser.MarkdownASTNode
+import com.swmansion.enriched.markdown.spans.LinkChipBackgroundSpan
+import com.swmansion.enriched.markdown.spans.LinkSpacerSpan
+import com.swmansion.enriched.markdown.spans.LinkSpacers
 import com.swmansion.enriched.markdown.spans.LinkSpan
 import com.swmansion.enriched.markdown.utils.text.span.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
 
@@ -16,14 +19,41 @@ class LinkRenderer(
     factory: RendererFactory,
   ) {
     val url = node.getAttribute("url") ?: return
+    // Chip ("box") properties never fall back to the base link style.
+    val chip = factory.styleCache.linkChipForUrl(url)
+    val padding = chip.paddingHorizontal
 
-    factory.renderWithSpan(builder, { factory.renderChildren(node, builder, onLinkPress, onLinkLongPress) }) { start, end, blockStyle ->
-      builder.setSpan(
-        LinkSpan(url, onLinkPress, onLinkLongPress, factory.styleCache, blockStyle, factory.context),
-        start,
-        end,
-        SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
-      )
+    val start = builder.length
+    // The leading spacer goes in before the children so ranges they register stay valid.
+    if (padding > 0f) appendSpacer(builder, padding)
+    val contentStart = builder.length
+
+    factory.renderChildren(node, builder, onLinkPress, onLinkLongPress)
+
+    if (builder.length == contentStart) {
+      if (contentStart > start) builder.delete(start, contentStart)
+      return
     }
+    if (padding > 0f) appendSpacer(builder, padding)
+    val end = builder.length
+
+    val blockStyle = factory.blockStyleContext.requireBlockStyle()
+    builder.setSpan(
+      LinkSpan(url, onLinkPress, onLinkLongPress, factory.styleCache, blockStyle, factory.context),
+      start,
+      end,
+      SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+    )
+    // One instance per link: also identifies the link for link-layout reporting.
+    builder.setSpan(LinkChipBackgroundSpan(chip), start, end, SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE)
+  }
+
+  private fun appendSpacer(
+    builder: SpannableStringBuilder,
+    width: Float,
+  ) {
+    val position = builder.length
+    builder.append(LinkSpacers.CHAR)
+    builder.setSpan(LinkSpacerSpan(width), position, position + 1, SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE)
   }
 }

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

@@ -4,6 +4,7 @@ import android.content.res.AssetManager
 import android.graphics.Typeface
 import com.facebook.react.common.ReactConstants
 import com.facebook.react.views.text.ReactTypefaceUtils.applyStyles
+import com.swmansion.enriched.markdown.styles.LinkChipStyle
 import com.swmansion.enriched.markdown.styles.LinkVariantEntry
 import com.swmansion.enriched.markdown.styles.StyleConfig
 
@@ -26,7 +27,7 @@ class SpanStyleCache(
   val linkFontFamily: String = style.linkStyle.fontFamily
   val linkColor: Int = style.linkStyle.color
   val linkUnderline: Boolean = style.linkStyle.underline
-  val linkBackgroundColor: Int = style.linkStyle.backgroundColor
+  val linkChip: LinkChipStyle = style.linkStyle.chip
   val linkVariants: List<LinkVariantEntry> = style.linkVariants
 
   private val compiledVariantPatterns: List<Pair<Regex, LinkVariantEntry>> =
@@ -100,6 +101,9 @@ class SpanStyleCache(
     return compiledVariantPatterns.firstOrNull { (regex, _) -> regex.containsMatchIn(url) }?.second
   }
 
+  /** Chip style for [url]: the matching variant's own, else the base link's (never merged). */
+  fun linkChipForUrl(url: String): LinkChipStyle = resolvedVariantForUrl(url)?.chip ?: linkChip
+
   /**
    * Cached typeface for font family + style (BOLD, ITALIC, BOLD_ITALIC).
    *

package/android/src/main/java/com/swmansion/enriched/markdown/spans/CodeBackgroundSpan.kt

@@ -5,9 +5,6 @@ import android.graphics.Paint
 import android.graphics.Path
 import android.graphics.RectF
 import android.text.Spanned
-import android.text.StaticLayout
-import android.text.TextPaint
-import android.text.style.LeadingMarginSpan
 import android.text.style.LineBackgroundSpan
 import com.swmansion.enriched.markdown.styles.StyleConfig
 import kotlin.math.max
@@ -73,14 +70,6 @@ class CodeBackgroundSpan(
     drawShapes(canvas, isFirst, isLast)
   }
 
-  /**
-   * Returns the x position of [index] relative to the line's left edge, including any
-   * leading margin. The measuring StaticLayout is built from a subSequence that keeps
-   * all spans, so LeadingMarginSpans (lists, blockquotes) are already applied to
-   * getPrimaryHorizontal; adding the margin again on top would shift the background
-   * right by the indent. The margin is only added explicitly in the early-return case,
-   * where no layout is built.
-   */
   private fun getHorizontalOffset(
     text: CharSequence,
     lineStart: Int,
@@ -88,105 +77,30 @@ class CodeBackgroundSpan(
     index: Int,
     paint: Paint,
     leadingMargin: Int,
-  ): Float {
-    if (index <= lineStart) return leadingMargin.toFloat()
-    val lineText = text.subSequence(lineStart, lineEnd)
-    val textPaint = paint as? TextPaint ?: TextPaint(paint)
-    val layout = StaticLayout.Builder.obtain(lineText, 0, lineText.length, textPaint, 10000).build()
-    return layout.getPrimaryHorizontal(index - lineStart)
-  }
+  ): Float = InlineChipPainter.horizontalOffset(text, lineStart, lineEnd, index, paint, leadingMargin)
 
   private fun drawShapes(
     canvas: Canvas,
     isFirst: Boolean,
     isLast: Boolean,
   ) {
-    val radii = createRadii(isFirst, isLast)
-
-    path.reset()
-    path.addRoundRect(rect, radii, Path.Direction.CW)
-    canvas.drawPath(path, sharedBackgroundPaint)
-
-    if (isFirst && isLast) {
-      canvas.drawPath(path, sharedBorderPaint)
-    } else {
-      drawOpenBorders(canvas, isFirst, isLast)
-    }
-  }
-
-  private fun drawOpenBorders(
-    canvas: Canvas,
-    isFirst: Boolean,
-    isLast: Boolean,
-  ) {
-    val r = CORNER_RADIUS
-    path.reset()
-
-    if (isFirst) {
-      path.moveTo(rect.right, rect.top)
-      path.lineTo(rect.left + r, rect.top)
-      path.quadTo(rect.left, rect.top, rect.left, rect.top + r)
-      path.lineTo(rect.left, rect.bottom - r)
-      path.quadTo(rect.left, rect.bottom, rect.left + r, rect.bottom)
-      path.lineTo(rect.right, rect.bottom)
-    } else if (isLast) {
-      path.moveTo(rect.left, rect.top)
-      path.lineTo(rect.right - r, rect.top)
-      path.quadTo(rect.right, rect.top, rect.right, rect.top + r)
-      path.lineTo(rect.right, rect.bottom - r)
-      path.quadTo(rect.right, rect.bottom, rect.right - r, rect.bottom)
-      path.lineTo(rect.left, rect.bottom)
-    } else {
-      path.moveTo(rect.left, rect.top)
-      path.lineTo(rect.right, rect.top)
-      path.moveTo(rect.left, rect.bottom)
-      path.lineTo(rect.right, rect.bottom)
-    }
-    canvas.drawPath(path, sharedBorderPaint)
-  }
-
-  private fun createRadii(
-    isFirst: Boolean,
-    isLast: Boolean,
-  ) = when {
-    isFirst && isLast -> {
-      floatArrayOf(
-        CORNER_RADIUS,
-        CORNER_RADIUS,
-        CORNER_RADIUS,
-        CORNER_RADIUS,
-        CORNER_RADIUS,
-        CORNER_RADIUS,
-        CORNER_RADIUS,
-        CORNER_RADIUS,
-      )
-    }
-
-    isFirst -> {
-      floatArrayOf(CORNER_RADIUS, CORNER_RADIUS, 0f, 0f, 0f, 0f, CORNER_RADIUS, CORNER_RADIUS)
-    }
-
-    isLast -> {
-      floatArrayOf(0f, 0f, CORNER_RADIUS, CORNER_RADIUS, CORNER_RADIUS, CORNER_RADIUS, 0f, 0f)
-    }
-
-    else -> {
-      floatArrayOf(0f, 0f, 0f, 0f, 0f, 0f, 0f, 0f)
-    }
+    InlineChipPainter.draw(
+      canvas,
+      rect,
+      path,
+      CORNER_RADIUS,
+      sharedBackgroundPaint,
+      sharedBorderPaint,
+      isFirst,
+      isLast,
+      strokeInset = false,
+    )
   }
 
   private fun leadingMarginAt(
     text: Spanned,
     lineStart: Int,
-  ): Int {
-    if (lineStart >= text.length) return 0
-    val spans = text.getSpans(lineStart, lineStart + 1, LeadingMarginSpan::class.java)
-    var margin = 0
-    for (span in spans) {
-      margin += span.getLeadingMargin(false)
-    }
-    return margin
-  }
+  ): Int = InlineChipPainter.leadingMarginAt(text, lineStart)
 
   private fun adjustBottomForMargin(
     text: Spanned,

package/android/src/main/java/com/swmansion/enriched/markdown/spans/InlineChipPainter.kt

@@ -0,0 +1,140 @@
+package com.swmansion.enriched.markdown.spans
+
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.graphics.Path
+import android.graphics.RectF
+import android.text.Spanned
+import android.text.StaticLayout
+import android.text.TextPaint
+import android.text.style.LeadingMarginSpan
+
+/**
+ * Shared geometry and drawing for inline "chips" painted from a [android.text.style.LineBackgroundSpan]
+ * (inline code, link chips). For a chip that wraps, only the outer ends are rounded and the border
+ * stays open where a fragment is cut.
+ */
+internal object InlineChipPainter {
+  /**
+   * Returns the x position of [index] relative to the line's left edge, including any
+   * leading margin. The measuring StaticLayout is built from a subSequence that keeps
+   * all spans, so LeadingMarginSpans (lists, blockquotes) are already applied to
+   * getPrimaryHorizontal; adding the margin again on top would shift the background
+   * right by the indent. The margin is only added explicitly in the early-return case,
+   * where no layout is built.
+   */
+  fun horizontalOffset(
+    text: CharSequence,
+    lineStart: Int,
+    lineEnd: Int,
+    index: Int,
+    paint: Paint,
+    leadingMargin: Int,
+  ): Float {
+    if (index <= lineStart) return leadingMargin.toFloat()
+    val lineText = text.subSequence(lineStart, lineEnd)
+    val textPaint = paint as? TextPaint ?: TextPaint(paint)
+    val layout = StaticLayout.Builder.obtain(lineText, 0, lineText.length, textPaint, 10000).build()
+    return layout.getPrimaryHorizontal(index - lineStart)
+  }
+
+  fun leadingMarginAt(
+    text: Spanned,
+    lineStart: Int,
+  ): Int {
+    if (lineStart >= text.length) return 0
+    val spans = text.getSpans(lineStart, lineStart + 1, LeadingMarginSpan::class.java)
+    var margin = 0
+    for (span in spans) {
+      margin += span.getLeadingMargin(false)
+    }
+    return margin
+  }
+
+  /**
+   * Fills [rect] and strokes its border. [strokeInset] keeps a closed border inside [rect]
+   * (link chips); otherwise it is centered on the edge (inline code, kept for pixel parity).
+   * [path] is caller-owned scratch space to avoid per-draw allocations.
+   */
+  fun draw(
+    canvas: Canvas,
+    rect: RectF,
+    path: Path,
+    cornerRadius: Float,
+    backgroundPaint: Paint?,
+    borderPaint: Paint?,
+    isFirst: Boolean,
+    isLast: Boolean,
+    strokeInset: Boolean,
+  ) {
+    val r = minOf(maxOf(cornerRadius, 0f), minOf(rect.width(), rect.height()) / 2f)
+
+    if (backgroundPaint != null) {
+      path.reset()
+      path.addRoundRect(rect, radii(r, isFirst, isLast), Path.Direction.CW)
+      canvas.drawPath(path, backgroundPaint)
+    }
+
+    if (borderPaint == null || borderPaint.strokeWidth <= 0f) return
+
+    path.reset()
+    if (isFirst && isLast) {
+      if (strokeInset) {
+        val inset = borderPaint.strokeWidth / 2f
+        val insetRect = RectF(rect.left + inset, rect.top + inset, rect.right - inset, rect.bottom - inset)
+        path.addRoundRect(insetRect, radii(maxOf(r - inset, 0f), true, true), Path.Direction.CW)
+      } else {
+        path.addRoundRect(rect, radii(r, true, true), Path.Direction.CW)
+      }
+    } else {
+      val inset = if (strokeInset) borderPaint.strokeWidth / 2f else 0f
+      addOpenBorder(path, rect, r, inset, isFirst, isLast)
+    }
+    canvas.drawPath(path, borderPaint)
+  }
+
+  private fun addOpenBorder(
+    path: Path,
+    rect: RectF,
+    r: Float,
+    inset: Float,
+    isFirst: Boolean,
+    isLast: Boolean,
+  ) {
+    val left = rect.left + inset
+    val top = rect.top + inset
+    val right = rect.right - inset
+    val bottom = rect.bottom - inset
+
+    if (isFirst) {
+      path.moveTo(rect.right, top)
+      path.lineTo(left + r, top)
+      path.quadTo(left, top, left, top + r)
+      path.lineTo(left, bottom - r)
+      path.quadTo(left, bottom, left + r, bottom)
+      path.lineTo(rect.right, bottom)
+    } else if (isLast) {
+      path.moveTo(rect.left, top)
+      path.lineTo(right - r, top)
+      path.quadTo(right, top, right, top + r)
+      path.lineTo(right, bottom - r)
+      path.quadTo(right, bottom, right - r, bottom)
+      path.lineTo(rect.left, bottom)
+    } else {
+      path.moveTo(rect.left, top)
+      path.lineTo(rect.right, top)
+      path.moveTo(rect.left, bottom)
+      path.lineTo(rect.right, bottom)
+    }
+  }
+
+  private fun radii(
+    r: Float,
+    isFirst: Boolean,
+    isLast: Boolean,
+  ): FloatArray {
+    val left = if (isFirst) r else 0f
+    val right = if (isLast) r else 0f
+    return floatArrayOf(left, left, right, right, right, right, left, left)
+  }
+}