react-native-enriched-markdown-scaffold 0.7.4-scaffold.9 → 1.0.2-scaffold.10

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

@@ -0,0 +1,177 @@
+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.SpannableStringBuilder
+import android.text.Spanned
+import android.text.TextPaint
+import android.text.style.LineBackgroundSpan
+import android.text.style.ReplacementSpan
+import com.swmansion.enriched.markdown.styles.LinkChipStyle
+import kotlin.math.max
+import kotlin.math.min
+import kotlin.math.roundToInt
+
+/**
+ * Reserves a link's `paddingHorizontal` at one outer edge. It covers one [LinkSpacers.CHAR]
+ * inserted by `LinkRenderer`: U+00A0 is line-break class GL, so a break is allowed before it
+ * after a space but never after it, and never before it after a non-space — the spacer always
+ * travels with the link's first (or last) glyph, never orphaned at a wrap.
+ *
+ * Layout-only: every text exit point strips spacers by this span ([LinkSpacers.strip]).
+ */
+class LinkSpacerSpan(
+  private val width: Float,
+) : ReplacementSpan() {
+  override fun getSize(
+    paint: Paint,
+    text: CharSequence?,
+    start: Int,
+    end: Int,
+    fm: Paint.FontMetricsInt?,
+  ): Int {
+    // Keep the line metrics of the surrounding text.
+    if (fm != null) paint.getFontMetricsInt(fm)
+    return width.roundToInt()
+  }
+
+  override fun draw(
+    canvas: Canvas,
+    text: CharSequence?,
+    start: Int,
+    end: Int,
+    x: Float,
+    top: Int,
+    y: Int,
+    bottom: Int,
+    paint: Paint,
+  ) = Unit
+}
+
+object LinkSpacers {
+  const val CHAR = '\u00A0'
+
+  /** [text] without link spacers (returns [text] itself when it has none). */
+  fun strip(text: CharSequence): CharSequence {
+    if (text !is Spanned) return text
+    val spacers = text.getSpans(0, text.length, LinkSpacerSpan::class.java)
+    if (spacers.isEmpty()) return text
+    val builder = SpannableStringBuilder(text)
+    spacers
+      .map { builder.getSpanStart(it) to builder.getSpanEnd(it) }
+      .filter { (start, end) -> start in 0 until end }
+      .sortedByDescending { it.first }
+      .forEach { (start, end) -> builder.delete(start, end) }
+    return builder
+  }
+
+  /** True when [start, end) lies inside a spacer (a segment exporters must skip). */
+  fun isSpacer(
+    text: Spanned,
+    start: Int,
+    end: Int,
+  ): Boolean = end > start && text.getSpans(start, end, LinkSpacerSpan::class.java).isNotEmpty()
+}
+
+/**
+ * Paints a link chip (background + border) behind the link glyphs. One instance per link,
+ * spanning the link including its spacers, so the chip already covers `paddingHorizontal`.
+ * Vertically the chip spans the link font's ascent..descent ± `paddingVertical`; the vertical
+ * padding only bleeds into the surrounding line spacing and never changes the line box.
+ */
+class LinkChipBackgroundSpan(
+  val chip: LinkChipStyle,
+) : LineBackgroundSpan {
+  private val rect = RectF()
+  private val path = Path()
+  private val backgroundPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { style = Paint.Style.FILL }
+  private val borderPaint =
+    Paint(Paint.ANTI_ALIAS_FLAG).apply {
+      style = Paint.Style.STROKE
+      strokeJoin = Paint.Join.ROUND
+      strokeCap = Paint.Cap.ROUND
+    }
+
+  override fun drawBackground(
+    canvas: Canvas,
+    p: Paint,
+    left: Int,
+    right: Int,
+    top: Int,
+    baseline: Int,
+    bottom: Int,
+    text: CharSequence,
+    start: Int,
+    end: Int,
+    lineNum: Int,
+  ) {
+    if (!chip.isVisible || text !is Spanned) return
+
+    val spanStart = text.getSpanStart(this)
+    val spanEnd = text.getSpanEnd(this)
+    if (spanStart !in 0 until spanEnd || spanEnd <= start || spanStart >= end) return
+
+    val isFirst = spanStart >= start
+    val isLast = spanEnd <= end
+
+    val leadingMargin = InlineChipPainter.leadingMarginAt(text, start)
+    val fragmentStart = max(spanStart, start)
+    val fragmentEnd = trimTrailingWhitespace(text, fragmentStart, min(spanEnd, end))
+    val startX = InlineChipPainter.horizontalOffset(text, start, end, fragmentStart, p, leadingMargin) + left
+    val endX = InlineChipPainter.horizontalOffset(text, start, end, fragmentEnd, p, leadingMargin) + left
+
+    val (ascent, descent) = linkFontMetrics(text, spanStart, spanEnd, p)
+    rect.set(
+      min(startX, endX),
+      baseline + ascent - chip.paddingVertical,
+      max(startX, endX),
+      baseline + descent + chip.paddingVertical,
+    )
+
+    backgroundPaint.color = chip.backgroundColor
+    borderPaint.color = chip.borderColor
+    borderPaint.strokeWidth = chip.borderWidth
+    InlineChipPainter.draw(
+      canvas,
+      rect,
+      path,
+      chip.borderRadius,
+      backgroundPaint.takeIf { android.graphics.Color.alpha(chip.backgroundColor) > 0 },
+      borderPaint.takeIf { android.graphics.Color.alpha(chip.borderColor) > 0 && chip.borderWidth > 0f },
+      isFirst,
+      isLast,
+      strokeInset = true,
+    )
+  }
+
+  companion object {
+    /** A wrapped fragment ends before the whitespace the line break hangs. */
+    fun trimTrailingWhitespace(
+      text: CharSequence,
+      start: Int,
+      end: Int,
+    ): Int {
+      var index = end
+      while (index > start && text[index - 1] != LinkSpacers.CHAR && text[index - 1].isWhitespace()) index--
+      return index
+    }
+
+    /**
+     * Ascent/descent of the link's own font: [LinkSpan] sets its size and typeface at draw
+     * time only, so the base paint [p] alone would report the paragraph's metrics.
+     */
+    fun linkFontMetrics(
+      text: Spanned,
+      spanStart: Int,
+      spanEnd: Int,
+      p: Paint,
+    ): Pair<Float, Float> {
+      val paint = TextPaint(p)
+      text.getSpans(spanStart, spanEnd, LinkSpan::class.java).firstOrNull()?.updateDrawState(paint)
+      val metrics = paint.fontMetrics
+      return metrics.ascent to metrics.descent
+    }
+  }
+}

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

@@ -1,7 +1,6 @@
 package com.swmansion.enriched.markdown.spans
 
 import android.content.Context
-import android.graphics.Color
 import android.text.TextPaint
 import android.text.style.ClickableSpan
 import android.view.View
@@ -57,10 +56,6 @@ class LinkSpan(
 
     textPaint.color = variant?.color ?: styleCache.linkColor
     textPaint.isUnderlineText = variant?.underline ?: styleCache.linkUnderline
-
-    val backgroundColor = variant?.backgroundColor ?: styleCache.linkBackgroundColor
-    if (Color.alpha(backgroundColor) > 0) {
-      textPaint.bgColor = backgroundColor
-    }
+    // The background is painted as a chip by LinkChipBackgroundSpan.
   }
 }

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

@@ -0,0 +1,33 @@
+package com.swmansion.enriched.markdown.spans
+
+import android.graphics.Paint
+import android.text.Spanned
+import android.text.style.LineHeightSpan
+
+/**
+ * Adds vertical spacing between list items using LineHeightSpan.
+ *
+ * Attached over the newline that separates two items; extends only the line
+ * ending at that newline so the gap appears below the preceding item.
+ *
+ * @param spacing The spacing in pixels to add below the line (0 = no spacing)
+ */
+class ListItemSpacingSpan(
+  val spacing: Float,
+) : LineHeightSpan {
+  override fun chooseHeight(
+    text: CharSequence,
+    start: Int,
+    end: Int,
+    spanstartv: Int,
+    lineHeight: Int,
+    fm: Paint.FontMetricsInt,
+  ) {
+    val spanEnd = (text as? Spanned)?.getSpanEnd(this) ?: return
+    if (end != spanEnd) return
+
+    val spacingPixels = spacing.toInt()
+    fm.descent += spacingPixels
+    fm.bottom += spacingPixels
+  }
+}

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

@@ -0,0 +1,38 @@
+package com.swmansion.enriched.markdown.spans
+
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.text.Layout
+import android.text.Spanned
+import android.text.style.LeadingMarginSpan
+
+// Draws a list marker on a line owned by another block (code block, nested
+// sublist) without contributing any margin of its own.
+class ListMarkerAnchorSpan(
+  internal val marker: BaseListSpan,
+) : LeadingMarginSpan {
+  override fun getLeadingMargin(first: Boolean): Int = 0
+
+  override fun drawLeadingMargin(
+    c: Canvas,
+    p: Paint,
+    x: Int,
+    dir: Int,
+    top: Int,
+    baseline: Int,
+    bottom: Int,
+    text: CharSequence?,
+    start: Int,
+    end: Int,
+    first: Boolean,
+    layout: Layout?,
+  ) {
+    if (!first) return
+    if (text is Spanned && text.getSpanStart(this) != start) return
+
+    // Pass the paragraph origin: drawMarker reconstructs its offset from depth,
+    // matching the x its own span would receive on a plain text line.
+    val originX = if (dir > 0) 0 else layout?.width ?: 0
+    marker.drawMarkerAt(c, p, originX, dir, top, baseline, bottom, layout, start)
+  }
+}

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

@@ -18,6 +18,7 @@ class OrderedListSpan(
   depth: Int,
   context: Context,
   styleCache: SpanStyleCache,
+  drawsMarker: Boolean = true,
 ) : BaseListSpan(
     depth = depth,
     context = context,
@@ -31,6 +32,7 @@ class OrderedListSpan(
       ),
     marginLeft = listStyle.marginLeft,
     gapWidth = listStyle.gapWidth,
+    drawsMarker = drawsMarker,
   ) {
   companion object {
     private val sharedMarkerPaint = TextPaint().apply { isAntiAlias = true }

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

@@ -31,7 +31,7 @@ class StrongSpan(
     tp.typeface =
       if (styleCache.strongFontFamily.isNotEmpty()) {
         val resolvedStyle = if (styleCache.strongFontWeight == "normal") Typeface.NORMAL else style
-        SpanStyleCache.getTypeface(styleCache.strongFontFamily, resolvedStyle)
+        styleCache.getTypeface(styleCache.strongFontFamily, resolvedStyle)
       } else {
         Typeface.create(currentTypeface, style)
       }

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

@@ -19,6 +19,7 @@ class TaskListSpan(
   styleCache: SpanStyleCache,
   val taskIndex: Int,
   val isChecked: Boolean,
+  drawsMarker: Boolean = true,
 ) : BaseListSpan(
     depth = depth,
     context = context,
@@ -32,6 +33,7 @@ class TaskListSpan(
       ),
     marginLeft = listStyle.marginLeft,
     gapWidth = listStyle.gapWidth,
+    drawsMarker = drawsMarker,
   ) {
   private val checkboxSize = taskStyle.checkboxSize
   private val markerColumnWidth = listStyle.effectiveMarkerWidth(checkboxSize)
@@ -69,8 +71,7 @@ class TaskListSpan(
     layout: Layout?,
     start: Int,
   ) {
-    val fontMetrics = paint.fontMetrics
-    val capHeight = -fontMetrics.ascent * CAP_HEIGHT_RATIO
+    val capHeight = -markerFontMetrics.ascent * CAP_HEIGHT_RATIO
     val centerY = baseline - capHeight / HALF_DIVISOR
     // Right-align the checkbox inside the reserved marker column so it hugs
     // the gap before the text. At the default (markerColumnWidth ==

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

@@ -13,6 +13,7 @@ class UnorderedListSpan(
   depth: Int,
   context: Context,
   styleCache: SpanStyleCache,
+  drawsMarker: Boolean = true,
 ) : BaseListSpan(
     depth = depth,
     context = context,
@@ -26,6 +27,7 @@ class UnorderedListSpan(
       ),
     marginLeft = listStyle.marginLeft,
     gapWidth = listStyle.gapWidth,
+    drawsMarker = drawsMarker,
   ) {
   companion object {
     private val sharedBulletPaint =
@@ -64,8 +66,7 @@ class UnorderedListSpan(
     // visually flush-left when the column width equals the bullet radius
     // (the default).
     val bulletX = x + (depth * marginLeft + markerColumnWidth) * dir
-    val fontMetrics = paint.fontMetrics
-    val bulletY = baseline + (fontMetrics.ascent + fontMetrics.descent) / 2f
+    val bulletY = baseline + (markerFontMetrics.ascent + markerFontMetrics.descent) / 2f
 
     when (depth) {
       0 -> {

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

@@ -14,6 +14,8 @@ data class BlockquoteStyle(
   val borderWidth: Float,
   val gapWidth: Float,
   val backgroundColor: Int?,
+  val borderRadius: Float,
+  val padding: Float,
 ) : BaseBlockStyle {
   companion object {
     fun fromReadableMap(
@@ -32,6 +34,8 @@ data class BlockquoteStyle(
       val borderWidth = parser.toPixelFromDIP(map.getDouble("borderWidth").toFloat())
       val gapWidth = parser.toPixelFromDIP(map.getDouble("gapWidth").toFloat())
       val backgroundColor = parser.parseOptionalColor(map, "backgroundColor")
+      val borderRadius = parser.toPixelFromDIP(map.getDouble("borderRadius").toFloat())
+      val padding = parser.toPixelFromDIP(map.getDouble("padding").toFloat())
 
       return BlockquoteStyle(
         fontSize,
@@ -45,6 +49,8 @@ data class BlockquoteStyle(
         borderWidth,
         gapWidth,
         backgroundColor,
+        borderRadius,
+        padding,
       )
     }
   }

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

@@ -15,8 +15,27 @@ data class CodeBlockStyle(
   val borderRadius: Float,
   val borderWidth: Float,
   val padding: Float,
+  val syntaxColors: List<Int>,
 ) : BaseBlockStyle {
   companion object {
+    private val SYNTAX_COLOR_KEYS =
+      listOf(
+        "keyword",
+        "operatorColor",
+        "punctuation",
+        "string",
+        "number",
+        "constant",
+        "comment",
+        "function",
+        "type",
+        "variable",
+        "property",
+        "tag",
+        "attribute",
+        "embedded",
+      )
+
     fun fromReadableMap(
       map: ReadableMap,
       parser: StyleParser,
@@ -35,6 +54,12 @@ data class CodeBlockStyle(
       val borderWidth = parser.toPixelFromDIP(map.getDouble("borderWidth").toFloat())
       val padding = parser.toPixelFromDIP(map.getDouble("padding").toFloat())
 
+      val syntaxMap = map.getMap("syntaxColors")
+      val syntaxColors =
+        SYNTAX_COLOR_KEYS.map { key ->
+          syntaxMap?.let { parser.parseOptionalColor(it, key) } ?: color
+        }
+
       return CodeBlockStyle(
         fontSize,
         fontFamily,
@@ -48,6 +73,7 @@ data class CodeBlockStyle(
         borderRadius,
         borderWidth,
         padding,
+        syntaxColors,
       )
     }
   }

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

@@ -4,6 +4,9 @@ import com.facebook.react.bridge.ReadableMap
 
 data class ImageStyle(
   val height: Float,
+  val maxHeight: Float,
+  val aspectRatio: Float,
+  val resizeMode: String,
   val borderRadius: Float,
   val marginTop: Float,
   val marginBottom: Float,
@@ -14,10 +17,13 @@ data class ImageStyle(
       parser: StyleParser,
     ): ImageStyle {
       val height = parser.toPixelFromDIP(map.getDouble("height").toFloat())
+      val maxHeight = parser.toPixelFromDIP(map.getDouble("maxHeight").toFloat())
+      val aspectRatio = map.getDouble("aspectRatio").toFloat()
+      val resizeMode = map.getString("resizeMode") ?: ""
       val borderRadius = parser.toPixelFromDIP(map.getDouble("borderRadius").toFloat())
       val marginTop = parser.toPixelFromDIP(map.getDouble("marginTop").toFloat())
       val marginBottom = parser.toPixelFromDIP(map.getDouble("marginBottom").toFloat())
-      return ImageStyle(height, borderRadius, marginTop, marginBottom)
+      return ImageStyle(height, maxHeight, aspectRatio, resizeMode, borderRadius, marginTop, marginBottom)
     }
   }
 }

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

@@ -1,12 +1,17 @@
 package com.swmansion.enriched.markdown.styles
 
 import com.facebook.react.bridge.ReadableMap
+import kotlin.math.ceil
 
 data class InlineMathStyle(
   val color: Int,
   val paddingVertical: Float,
   val fontWeight: String,
+  val glyphOverflow: Float = 0f,
 ) {
+  /** Line-box padding the span reports: author padding plus the ink headroom. */
+  val boxPaddingVertical: Float get() = paddingVertical + glyphOverflow
+
   companion object {
     fun fromReadableMap(
       map: ReadableMap,
@@ -15,7 +20,17 @@ data class InlineMathStyle(
       val color = parser.parseColor(map, "color")
       val paddingVertical = parser.toPixelFromDIP(map.getDouble("paddingVertical").toFloat())
       val fontWeight = parser.parseString(map, "fontWeight", "normal")
-      return InlineMathStyle(color, paddingVertical, fontWeight)
+      val glyphOverflow = glyphOverflowPx(parser.parseOptionalDouble(map, "glyphOverflow").toFloat(), parser)
+      return InlineMathStyle(color, paddingVertical, fontWeight, glyphOverflow)
     }
   }
 }
+
+/**
+ * `glyphOverflow` in whole pixels. Rounded up so a measured box and the bitmap or
+ * canvas it holds always grow by the same integer amount on each side.
+ */
+internal fun glyphOverflowPx(
+  dip: Float,
+  parser: StyleParser,
+): Float = if (dip <= 0f) 0f else ceil(parser.toPixelFromDIP(dip))

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

@@ -7,6 +7,7 @@ data class LinkStyle(
   val color: Int,
   val underline: Boolean,
   val backgroundColor: Int,
+  val chip: LinkChipStyle,
 ) {
   companion object {
     fun fromReadableMap(
@@ -17,7 +18,41 @@ data class LinkStyle(
       val color = parser.parseColor(map, "color")
       val underline = map.getBoolean("underline")
       val backgroundColor = parser.parseColor(map, "backgroundColor")
-      return LinkStyle(fontFamily, color, underline, backgroundColor)
+      return LinkStyle(fontFamily, color, underline, backgroundColor, LinkChipStyle.fromReadableMap(map, parser, backgroundColor))
     }
   }
 }
+
+/**
+ * Chip ("box") properties of a link, in pixels. Never inherited from the base link
+ * style by variants — the JS normalizer fills missing values with 0 / transparent.
+ */
+data class LinkChipStyle(
+  val backgroundColor: Int,
+  val borderColor: Int,
+  val borderRadius: Float,
+  val borderWidth: Float,
+  val paddingHorizontal: Float,
+  val paddingVertical: Float,
+) {
+  val isVisible: Boolean
+    get() =
+      android.graphics.Color.alpha(backgroundColor) > 0 ||
+        (android.graphics.Color.alpha(borderColor) > 0 && borderWidth > 0f)
+
+  companion object {
+    fun fromReadableMap(
+      map: ReadableMap,
+      parser: StyleParser,
+      backgroundColor: Int,
+    ): LinkChipStyle =
+      LinkChipStyle(
+        backgroundColor = backgroundColor,
+        borderColor = parser.parseOptionalColor(map, "borderColor") ?: 0,
+        borderRadius = parser.toPixelFromDIP(parser.parseOptionalDouble(map, "borderRadius").toFloat()),
+        borderWidth = parser.toPixelFromDIP(parser.parseOptionalDouble(map, "borderWidth").toFloat()),
+        paddingHorizontal = parser.toPixelFromDIP(parser.parseOptionalDouble(map, "paddingHorizontal").toFloat()),
+        paddingVertical = parser.toPixelFromDIP(parser.parseOptionalDouble(map, "paddingVertical").toFloat()),
+      )
+  }
+}

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

@@ -13,17 +13,21 @@ data class LinkVariantEntry(
   val color: Int,
   val underline: Boolean,
   val backgroundColor: Int,
+  val chip: LinkChipStyle,
 ) {
   companion object {
     fun fromReadableMap(
       map: ReadableMap,
       parser: StyleParser,
-    ): LinkVariantEntry =
-      LinkVariantEntry(
+    ): LinkVariantEntry {
+      val backgroundColor = parser.parseColor(map, "backgroundColor")
+      return LinkVariantEntry(
         pattern = map.getString("pattern") ?: "",
         color = parser.parseColor(map, "color"),
         underline = parser.parseBoolean(map, "underline"),
-        backgroundColor = parser.parseColor(map, "backgroundColor"),
+        backgroundColor = backgroundColor,
+        chip = LinkChipStyle.fromReadableMap(map, parser, backgroundColor),
       )
+    }
   }
 }

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

@@ -17,6 +17,7 @@ data class ListStyle(
   val markerFontWeight: String,
   val gapWidth: Float,
   val marginLeft: Float,
+  val itemSpacing: Float,
 ) : BaseBlockStyle {
   fun effectiveMarkerWidth(naturalWidth: Float): Float = naturalWidth.coerceAtLeast(markerMinWidth)
 
@@ -34,12 +35,13 @@ data class ListStyle(
       val lineHeightRaw = map.getDouble("lineHeight").toFloat()
       val lineHeight = parser.toPixelFromSP(lineHeightRaw)
       val bulletColor = parser.parseColor(map, "bulletColor")
-      val bulletSize = parser.toPixelFromDIP(map.getDouble("bulletSize").toFloat())
+      val bulletSize = parser.toPixelFromSP(map.getDouble("bulletSize").toFloat())
       val markerMinWidth = parser.toPixelFromDIP(map.getDouble("markerMinWidth").toFloat().coerceAtLeast(0f))
       val markerColor = parser.parseColor(map, "markerColor")
       val markerFontWeight = parser.parseString(map, "markerFontWeight", "normal")
       val gapWidth = parser.toPixelFromDIP(map.getDouble("gapWidth").toFloat())
       val marginLeft = parser.toPixelFromDIP(map.getDouble("marginLeft").toFloat())
+      val itemSpacing = parser.toPixelFromDIP(map.getDouble("itemSpacing").toFloat().coerceAtLeast(0f))
 
       return ListStyle(
         fontSize,
@@ -56,6 +58,7 @@ data class ListStyle(
         markerFontWeight,
         gapWidth,
         marginLeft,
+        itemSpacing,
       )
     }
   }

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

@@ -11,6 +11,7 @@ data class MathStyle(
   val marginBottom: Float,
   val textAlign: String,
   val fontWeight: String,
+  val glyphOverflow: Float = 0f,
 ) {
   companion object {
     fun fromReadableMap(
@@ -25,6 +26,7 @@ data class MathStyle(
       val marginBottom = parser.toPixelFromDIP(map.getDouble("marginBottom").toFloat())
       val textAlign = parser.parseString(map, "textAlign", "center")
       val fontWeight = parser.parseString(map, "fontWeight", "normal")
+      val glyphOverflow = glyphOverflowPx(parser.parseOptionalDouble(map, "glyphOverflow").toFloat(), parser)
       return MathStyle(
         fontSize,
         color,
@@ -34,6 +36,7 @@ data class MathStyle(
         marginBottom,
         textAlign,
         fontWeight,
+        glyphOverflow,
       )
     }
   }

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

@@ -20,7 +20,8 @@ class StyleConfig(
   maxFontSizeMultiplier: Float,
 ) {
   private val styleParser = StyleParser(context, allowFontScaling, maxFontSizeMultiplier)
-  private val assets: AssetManager = context.assets
+  internal val assetManager: AssetManager = context.assets
+  private val assets: AssetManager get() = assetManager
 
   private var paragraphStyleOverride: ParagraphStyle? = null
 
@@ -89,8 +90,12 @@ class StyleConfig(
         val fontWeight = parseFontWeight(headingStyle?.fontWeight)
 
         if (fontFamily != null) {
-          // Use applyStyles with null base typeface to load from assets via ReactFontManager
-          applyStyles(null, ReactConstants.UNSET, fontWeight, fontFamily, assets)
+          // Load the base font at NORMAL so the assets/fonts file resolves, then apply the
+          // weight on the real typeface. Requesting the weight up front makes ReactFontManager
+          // look for a `_bold` asset variant that single-file custom fonts lack and silently
+          // fall back to a default system face. See SpanStyleCache.getTypeface.
+          val base = applyStyles(null, ReactConstants.UNSET, ReactConstants.UNSET, fontFamily, assets)
+          applyStyles(base, ReactConstants.UNSET, fontWeight, null, assets)
         } else {
           null
         }
@@ -161,6 +166,8 @@ class StyleConfig(
     ImageStyle.fromReadableMap(map, styleParser)
   }
 
+  var imageRequestHeaders: Map<String, String> = emptyMap()
+
   val inlineImageStyle: InlineImageStyle by lazy {
     val map =
       requireNotNull(style.getMap("inlineImage")) {
@@ -332,7 +339,8 @@ class StyleConfig(
       spoilerStyle == other.spoilerStyle &&
       superscriptStyle == other.superscriptStyle &&
       subscriptStyle == other.subscriptStyle &&
-      highlightStyle == other.highlightStyle
+      highlightStyle == other.highlightStyle &&
+      imageRequestHeaders == other.imageRequestHeaders
   }
 
   override fun hashCode(): Int {
@@ -359,6 +367,7 @@ class StyleConfig(
     result = 31 * result + superscriptStyle.hashCode()
     result = 31 * result + subscriptStyle.hashCode()
     result = 31 * result + highlightStyle.hashCode()
+    result = 31 * result + imageRequestHeaders.hashCode()
     return result
   }
 }