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

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

@@ -80,6 +80,7 @@ class RendererFactory(
 
   private val textRenderer = TextRenderer()
   private val lineBreakRenderer = LineBreakRenderer()
+  private val softBreakRenderer = SoftBreakRenderer()
 
   private val renderers: Map<MarkdownASTNode.NodeType, NodeRenderer> by lazy {
     buildMap {
@@ -103,13 +104,20 @@ class RendererFactory(
       put(MarkdownASTNode.NodeType.Code, CodeRenderer(config))
       put(MarkdownASTNode.NodeType.Image, ImageRenderer())
       put(MarkdownASTNode.NodeType.LineBreak, lineBreakRenderer)
+      put(MarkdownASTNode.NodeType.SoftBreak, softBreakRenderer)
       put(MarkdownASTNode.NodeType.ThematicBreak, ThematicBreakRenderer(config))
       put(MarkdownASTNode.NodeType.Spoiler, SpoilerRenderer())
       if (FeatureFlags.IS_MATH_ENABLED) {
         try {
           val mathInlineRendererClass = Class.forName("com.swmansion.enriched.markdown.renderer.MathInlineRenderer")
           val constructor = mathInlineRendererClass.getConstructor(RendererConfig::class.java, Context::class.java)
-          put(MarkdownASTNode.NodeType.LatexMathInline, constructor.newInstance(config, context) as NodeRenderer)
+          val mathInlineRenderer = constructor.newInstance(config, context) as NodeRenderer
+          put(MarkdownASTNode.NodeType.LatexMathInline, mathInlineRenderer)
+          // Isolated display math is promoted to a block segment in the parser
+          // (see promoteDisplayMathFromParagraphs). What reaches the factory is
+          // genuinely mid-line display math (e.g. `a $$x$$ b`); render it inline
+          // rather than dropping it via the TextRenderer fallback.
+          put(MarkdownASTNode.NodeType.LatexMathDisplay, mathInlineRenderer)
         } catch (_: Exception) {
           // math not available
         }

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

@@ -0,0 +1,16 @@
+package com.swmansion.enriched.markdown.renderer
+
+import android.text.SpannableStringBuilder
+import com.swmansion.enriched.markdown.parser.MarkdownASTNode
+
+class SoftBreakRenderer : NodeRenderer {
+  override fun render(
+    node: MarkdownASTNode,
+    builder: SpannableStringBuilder,
+    onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
+    factory: RendererFactory,
+  ) {
+    builder.append(" ")
+  }
+}

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

@@ -1,6 +1,9 @@
 package com.swmansion.enriched.markdown.renderer
 
+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.LinkVariantEntry
 import com.swmansion.enriched.markdown.styles.StyleConfig
 
@@ -8,6 +11,8 @@ import com.swmansion.enriched.markdown.styles.StyleConfig
 class SpanStyleCache(
   style: StyleConfig,
 ) {
+  private val assetManager: AssetManager = style.assetManager
+
   // Colors to preserve when applying inline styles (links, code, strong, emphasis)
   val colorsToPreserve: IntArray = buildColorsToPreserve(style)
 
@@ -95,36 +100,34 @@ class SpanStyleCache(
     return compiledVariantPatterns.firstOrNull { (regex, _) -> regex.containsMatchIn(url) }?.second
   }
 
+  /**
+   * Cached typeface for font family + style (BOLD, ITALIC, BOLD_ITALIC).
+   *
+   * Loads the base custom font at its NORMAL weight (via applyStyles/ReactFontManager)
+   * so the bundled assets/fonts file resolves, then synthesizes bold/italic on that real
+   * typeface. Requesting bold/italic directly makes ReactFontManager look for `_bold`/
+   * `_italic` asset variants that single-file custom fonts don't have — and it then falls
+   * back to a default system face, dropping the custom font entirely.
+   */
+  fun getTypeface(
+    fontFamily: String,
+    style: Int,
+  ): Typeface =
+    typefaceCache.getOrPut("family|$fontFamily|$style") {
+      val base =
+        applyStyles(
+          null,
+          ReactConstants.UNSET,
+          ReactConstants.UNSET,
+          fontFamily.takeIf { it.isNotEmpty() },
+          assetManager,
+        )
+      if (style == Typeface.NORMAL) base else Typeface.create(base, style)
+    }
+
   companion object {
     private val typefaceCache = mutableMapOf<String, Typeface>()
 
-    /** Cached typeface for font family + style (BOLD, ITALIC, BOLD_ITALIC) */
-    fun getTypeface(
-      fontFamily: String,
-      style: Int,
-    ): Typeface =
-      typefaceCache.getOrPut("$fontFamily|$style") {
-        val base =
-          fontFamily
-            .takeIf { it.isNotEmpty() }
-            ?.let { Typeface.create(it, Typeface.NORMAL) }
-            ?: Typeface.DEFAULT
-        Typeface.create(base, style)
-      }
-
-    /** Cached typeface using weight string (e.g., "bold", "700") */
-    fun getTypefaceWithWeight(
-      fontFamily: String,
-      fontWeight: String,
-    ): Typeface {
-      val style =
-        when (fontWeight.lowercase()) {
-          "bold", "700", "800", "900" -> Typeface.BOLD
-          else -> Typeface.NORMAL
-        }
-      return getTypeface(fontFamily, style)
-    }
-
     /** Cached monospace typeface preserving bold/italic */
     fun getMonospaceTypeface(currentStyle: Int): Typeface =
       typefaceCache.getOrPut("monospace|$currentStyle") {

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

@@ -22,11 +22,20 @@ abstract class BaseListSpan(
   protected val blockStyle: BlockStyle,
   protected val marginLeft: Float,
   protected val gapWidth: Float,
+  internal val drawsMarker: Boolean = true,
 ) : MetricAffectingSpan(),
   LeadingMarginSpan {
   private var cachedText: CharSequence? = null
   private var cachedHasDeeperSpanByPosition = mutableMapOf<Int, Boolean>()
 
+  val markerFontMetrics: Paint.FontMetrics by lazy {
+    TextPaint()
+      .apply {
+        applyBlockStyleFont(blockStyle, context)
+        textSize = blockStyle.fontSize
+      }.fontMetrics
+  }
+
   protected abstract fun getMarkerWidth(): Float
 
   override fun updateMeasureState(textPaint: TextPaint) = applyTextStyle(textPaint)
@@ -55,6 +64,7 @@ abstract class BaseListSpan(
     first: Boolean,
     layout: Layout?,
   ) {
+    if (!drawsMarker) return
     if (!first || shouldSkipDrawing(text, start) || !hasContent(text, start, end)) return
 
     // Only draw the marker on the true first line of this span.
@@ -62,6 +72,20 @@ abstract class BaseListSpan(
     // but only the line at the span start should get a bullet/number.
     if (text is Spanned && text.getSpanStart(this) != start) return
 
+    drawMarkerAt(canvas, paint, x, dir, top, baseline, bottom, layout, start)
+  }
+
+  fun drawMarkerAt(
+    canvas: Canvas,
+    paint: Paint,
+    x: Int,
+    dir: Int,
+    top: Int,
+    baseline: Int,
+    bottom: Int,
+    layout: Layout?,
+    start: Int,
+  ) {
     val originalStyle = paint.style
     val originalColor = paint.color
     drawMarker(canvas, paint, x, dir, top, baseline, bottom, layout, start)

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

@@ -5,6 +5,8 @@ import android.content.Context
 import android.graphics.Canvas
 import android.graphics.Color
 import android.graphics.Paint
+import android.graphics.Path
+import android.graphics.RectF
 import android.graphics.Typeface
 import android.text.Layout
 import android.text.Spanned
@@ -12,6 +14,7 @@ import android.text.TextPaint
 import android.text.style.LeadingMarginSpan
 import android.text.style.LineBackgroundSpan
 import android.text.style.MetricAffectingSpan
+import androidx.core.graphics.withSave
 import com.swmansion.enriched.markdown.renderer.BlockStyle
 import com.swmansion.enriched.markdown.renderer.SpanStyleCache
 import com.swmansion.enriched.markdown.styles.BlockquoteStyle
@@ -37,7 +40,13 @@ class BlockquoteSpan(
 
   // Cache for shouldSkipDrawing to avoid repeated getSpans() calls during draw passes
   private var cachedText: CharSequence? = null
-  private var cachedMaxDepthByPosition = mutableMapOf<Int, Int>()
+  private var cachedSpansByPosition = mutableMapOf<Int, Array<BlockquoteSpan>>()
+  private var boxLeft = 0f
+  private var boxRight = 0f
+
+  private val path = Path()
+  private val rect = RectF()
+  private val radiiArray = FloatArray(8)
 
   override fun updateMeasureState(tp: TextPaint) = applyTextStyle(tp)
 
@@ -63,13 +72,56 @@ class BlockquoteSpan(
     if (shouldSkipDrawing(text, start)) return
 
     val borderPaint = configureBorderPaint()
-    val borderTop = top.toFloat()
-    val borderBottom = bottom.toFloat()
+    val radius = blockquoteStyle.borderRadius
+    val spanned = text as? Spanned
+
+    if (spanned == null) {
+      drawBorders(c, x, dir, top, bottom, borderPaint)
+      return
+    }
+
+    val rootSpan = spanAtMinDepth(spanned, start)
+    val clipToRoot =
+      radius > 0f && boxRight > boxLeft && rootSpan != null && isBoundaryLine(spanned, start, end, rootSpan)
+
+    val padding = blockquoteStyle.padding
+    var topInset = 0f
+    var bottomInset = 0f
 
     for (level in 0..depth) {
       val borderX = x + (levelSpacing * level * dir)
       val borderRight = borderX + (blockquoteStyle.borderWidth * dir)
-      c.drawRect(minOf(borderX, borderRight), borderTop, maxOf(borderX, borderRight), borderBottom, borderPaint)
+      val stripeLeft = minOf(borderX, borderRight)
+      val stripeRight = maxOf(borderX, borderRight)
+      val stripeTop = top.toFloat() + topInset
+      val stripeBottom = bottom.toFloat() - bottomInset
+
+      val levelSpan = if (level == 0) rootSpan else spanAtDepth(spanned, start, level)
+      val clipToOwn =
+        radius > 0f && level > 0 && levelSpan != null && isBoundaryLine(spanned, start, end, levelSpan)
+
+      if (!clipToRoot && !clipToOwn) {
+        c.drawRect(stripeLeft, stripeTop, stripeRight, stripeBottom, borderPaint)
+      } else {
+        c.withSave {
+          if (clipToRoot) {
+            buildBoundaryPath(spanned, start, end, rootSpan!!, boxLeft, top.toFloat(), boxRight, bottom.toFloat())
+            clipPath(path)
+          }
+          if (clipToOwn) {
+            val clipLeft = if (dir >= 0) stripeLeft else boxLeft
+            val clipRight = if (dir >= 0) boxRight else stripeRight
+            buildBoundaryPath(spanned, start, end, levelSpan!!, clipLeft, stripeTop, clipRight, stripeBottom)
+            clipPath(path)
+          }
+          drawRect(stripeLeft, stripeTop, stripeRight, stripeBottom, borderPaint)
+        }
+      }
+
+      if (padding > 0 && levelSpan != null) {
+        if (start == spanned.getSpanStart(levelSpan)) topInset += padding
+        if (isLastLineOf(spanned, end, levelSpan)) bottomInset += padding
+      }
     }
   }
 
@@ -87,7 +139,40 @@ class BlockquoteSpan(
     lineNum: Int,
   ) {
     if (shouldSkipDrawing(text, start)) return
-    drawBackground(canvas, left, top, bottom, right)
+
+    boxLeft = left.toFloat()
+    boxRight = right.toFloat()
+
+    val bgColor = blockquoteStyle.backgroundColor?.takeIf { it != Color.TRANSPARENT } ?: return
+    val backgroundPaint = configureBackgroundPaint(bgColor)
+    val radius = blockquoteStyle.borderRadius
+    val rootSpan = (text as? Spanned)?.let { spanAtMinDepth(it, start) }
+
+    if (radius <= 0f || rootSpan == null) {
+      canvas.drawRect(left.toFloat(), top.toFloat(), right.toFloat(), bottom.toFloat(), backgroundPaint)
+      return
+    }
+
+    buildBoundaryPath(text as Spanned, start, end, rootSpan, left.toFloat(), top.toFloat(), right.toFloat(), bottom.toFloat())
+    canvas.drawPath(path, backgroundPaint)
+  }
+
+  private fun drawBorders(
+    c: Canvas,
+    x: Int,
+    dir: Int,
+    top: Int,
+    bottom: Int,
+    borderPaint: Paint,
+  ) {
+    val borderTop = top.toFloat()
+    val borderBottom = bottom.toFloat()
+
+    for (level in 0..depth) {
+      val borderX = x + (levelSpacing * level * dir)
+      val borderRight = borderX + (blockquoteStyle.borderWidth * dir)
+      c.drawRect(minOf(borderX, borderRight), borderTop, maxOf(borderX, borderRight), borderBottom, borderPaint)
+    }
   }
 
   @SuppressLint("WrongConstant") // Result of mask is always valid: 0, 1, 2, or 3
@@ -118,35 +203,100 @@ class BlockquoteSpan(
       color = bgColor
     }
 
+  private fun spansAt(
+    text: Spanned,
+    start: Int,
+  ): Array<BlockquoteSpan> {
+    if (cachedText !== text) {
+      cachedText = text
+      cachedSpansByPosition.clear()
+    }
+    return cachedSpansByPosition.getOrPut(start) {
+      text.getSpans(start, start + 1, BlockquoteSpan::class.java)
+    }
+  }
+
   private fun shouldSkipDrawing(
     text: CharSequence?,
     start: Int,
   ): Boolean {
     if (text !is Spanned) return false
+    val maxDepth = spansAt(text, start).maxOfOrNull { it.depth } ?: -1
+    return maxDepth > depth
+  }
 
-    if (cachedText !== text) {
-      cachedText = text
-      cachedMaxDepthByPosition.clear()
-    }
+  private fun spanAtMinDepth(
+    text: Spanned,
+    start: Int,
+  ): BlockquoteSpan? = spansAt(text, start).minByOrNull { it.depth }
 
-    val maxDepth =
-      cachedMaxDepthByPosition.getOrPut(start) {
-        val spans = text.getSpans(start, start + 1, BlockquoteSpan::class.java)
-        spans.maxOfOrNull { it.depth } ?: -1
-      }
+  private fun spanAtDepth(
+    text: Spanned,
+    start: Int,
+    level: Int,
+  ): BlockquoteSpan? = spansAt(text, start).firstOrNull { it.depth == level }
 
-    return maxDepth > depth
+  /**
+   * The span range can include trailing '\n'(s) that form no visible line (e.g. a
+   * paragraph break closing the quote), so the last drawn line ends before getSpanEnd;
+   * this compares against the end of visible content instead.
+   */
+  private fun isLastLineOf(
+    text: Spanned,
+    lineEnd: Int,
+    box: BlockquoteSpan,
+  ): Boolean {
+    var boxEnd = text.getSpanEnd(box)
+    while (boxEnd > 0 && text[boxEnd - 1] == '\n') {
+      boxEnd--
+    }
+    return lineEnd >= boxEnd
   }
 
-  private fun drawBackground(
-    c: Canvas,
-    left: Int,
-    top: Int,
-    bottom: Int,
-    right: Int,
+  private fun isBoundaryLine(
+    text: Spanned,
+    lineStart: Int,
+    lineEnd: Int,
+    box: BlockquoteSpan,
+  ): Boolean {
+    val boxStart = text.getSpanStart(box)
+    val boxEnd = text.getSpanEnd(box)
+    if (boxStart !in 0 until boxEnd) return false
+    return lineStart == boxStart || isLastLineOf(text, lineEnd, box)
+  }
+
+  private fun buildBoundaryPath(
+    text: Spanned,
+    lineStart: Int,
+    lineEnd: Int,
+    box: BlockquoteSpan,
+    left: Float,
+    top: Float,
+    right: Float,
+    bottom: Float,
   ) {
-    val bgColor = blockquoteStyle.backgroundColor?.takeIf { it != Color.TRANSPARENT } ?: return
-    val backgroundPaint = configureBackgroundPaint(bgColor)
-    c.drawRect(left.toFloat(), top.toFloat(), right.toFloat(), bottom.toFloat(), backgroundPaint)
+    val boxStart = text.getSpanStart(box)
+
+    val isFirstLine = lineStart == boxStart
+    val isLastLine = isLastLineOf(text, lineEnd, box)
+
+    val radius = blockquoteStyle.borderRadius
+    radiiArray.fill(0f)
+    if (isFirstLine) {
+      radiiArray[0] = radius
+      radiiArray[1] = radius // Top-Left
+      radiiArray[2] = radius
+      radiiArray[3] = radius // Top-Right
+    }
+    if (isLastLine) {
+      radiiArray[4] = radius
+      radiiArray[5] = radius // Bottom-Right
+      radiiArray[6] = radius
+      radiiArray[7] = radius // Bottom-Left
+    }
+
+    rect.set(left, top, right, bottom)
+    path.reset()
+    path.addRoundRect(rect, radiiArray, Path.Direction.CW)
   }
 }

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

@@ -7,6 +7,7 @@ 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
@@ -58,8 +59,9 @@ class CodeBackgroundSpan(
 
     // 2. Calculate coordinates
     val finalBottom = adjustBottomForMargin(text, end, bottom)
-    val startX = if (isFirst) getHorizontalOffset(text, start, end, spanStart, p) + left else left.toFloat()
-    val endX = if (isLast) getHorizontalOffset(text, start, end, spanEnd, p) + left else right.toFloat()
+    val leadingMargin = leadingMarginAt(text, start)
+    val startX = if (isFirst) getHorizontalOffset(text, start, end, spanStart, p, leadingMargin) + left else left.toFloat() + leadingMargin
+    val endX = if (isLast) getHorizontalOffset(text, start, end, spanEnd, p, leadingMargin) + left else right.toFloat()
 
     rect.set(min(startX, endX), top.toFloat(), max(startX, endX), finalBottom.toFloat())
 
@@ -71,14 +73,23 @@ 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,
     lineEnd: Int,
     index: Int,
     paint: Paint,
+    leadingMargin: Int,
   ): Float {
-    if (index <= lineStart) return 0f
+    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()
@@ -164,6 +175,19 @@ class CodeBackgroundSpan(
     }
   }
 
+  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
+  }
+
   private fun adjustBottomForMargin(
     text: Spanned,
     lineEnd: Int,

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

@@ -12,27 +12,25 @@ import android.text.style.LeadingMarginSpan
 import android.text.style.LineBackgroundSpan
 import android.text.style.MetricAffectingSpan
 import androidx.core.graphics.withSave
-import com.swmansion.enriched.markdown.renderer.BlockStyle
 import com.swmansion.enriched.markdown.renderer.SpanStyleCache
 import com.swmansion.enriched.markdown.styles.CodeBlockStyle
-import com.swmansion.enriched.markdown.utils.text.extensions.applyBlockStyleFont
+import com.swmansion.enriched.markdown.utils.text.extensions.applyCodeBlockTextStyle
 import com.swmansion.enriched.markdown.utils.text.extensions.applyColorPreserving
 
+/**
+ * Draws the commonmark-flavor code block box as per-line strips. The visual
+ * conventions (half-stroke border inset, radius reduced by that inset) must
+ * stay in sync with the whole-rect box the github flavor draws in
+ * CodeBlockContainerView.
+ */
 class CodeBlockSpan(
   private val codeBlockStyle: CodeBlockStyle,
   private val context: Context,
   private val styleCache: SpanStyleCache,
+  private val leadingIndent: Int = 0,
 ) : MetricAffectingSpan(),
   LineBackgroundSpan,
   LeadingMarginSpan {
-  private val blockStyle =
-    BlockStyle(
-      fontSize = codeBlockStyle.fontSize,
-      fontFamily = codeBlockStyle.fontFamily,
-      fontWeight = codeBlockStyle.fontWeight,
-      color = codeBlockStyle.color,
-    )
-
   private val path = Path()
   private val rect = RectF()
   private val arcRect = RectF()
@@ -59,7 +57,7 @@ class CodeBlockSpan(
       color = codeBlockStyle.borderColor
     }
 
-  override fun getLeadingMargin(first: Boolean): Int = codeBlockStyle.padding.toInt()
+  override fun getLeadingMargin(first: Boolean): Int = codeBlockStyle.padding.toInt() + leadingIndent
 
   override fun drawLeadingMargin(
     c: Canvas?,
@@ -105,11 +103,12 @@ class CodeBlockSpan(
     val inset = codeBlockStyle.borderWidth / 2f
 
     rect.set(
-      left.toFloat() + inset,
+      left.toFloat() + leadingIndent + inset,
       top.toFloat() + (if (isFirstLine) inset else 0f),
       right.toFloat() - inset,
       bottom.toFloat() - (if (isLastLine) inset else 0f),
     )
+    if (rect.left >= rect.right) return
 
     val radius = codeBlockStyle.borderRadius
     val adjRadius = if (radius > inset) radius - inset else radius
@@ -187,10 +186,8 @@ class CodeBlockSpan(
   }
 
   private fun applyTextStyle(tp: TextPaint) {
-    tp.textSize = blockStyle.fontSize
-
-    tp.applyBlockStyleFont(blockStyle, context)
+    tp.applyCodeBlockTextStyle(codeBlockStyle, context)
 
-    tp.applyColorPreserving(blockStyle.color, *styleCache.colorsToPreserve)
+    tp.applyColorPreserving(codeBlockStyle.color, *styleCache.colorsToPreserve)
   }
 }

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

@@ -24,7 +24,7 @@ class CodeSpan(
     val preservedStyle = (paint.typeface?.style ?: 0) and (Typeface.BOLD or Typeface.ITALIC)
     paint.typeface =
       if (styleCache.codeFontFamily.isNotEmpty()) {
-        SpanStyleCache.getTypeface(styleCache.codeFontFamily, preservedStyle)
+        styleCache.getTypeface(styleCache.codeFontFamily, preservedStyle)
       } else {
         SpanStyleCache.getMonospaceTypeface(preservedStyle)
       }

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

@@ -27,7 +27,7 @@ class EmphasisSpan(
     tp.typeface =
       if (styleCache.emphasisFontFamily.isNotEmpty()) {
         val resolvedStyle = if (styleCache.emphasisFontStyle == "normal") Typeface.NORMAL else style
-        SpanStyleCache.getTypeface(styleCache.emphasisFontFamily, resolvedStyle)
+        styleCache.getTypeface(styleCache.emphasisFontFamily, resolvedStyle)
       } else if (styleCache.emphasisFontStyle == "normal") {
         currentTypeface
       } else {