react-native-enriched-markdown-scaffold 0.6.0-scaffold.4

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

@@ -0,0 +1,92 @@
+package com.swmansion.enriched.markdown.styles
+
+import android.content.Context
+import com.facebook.react.bridge.ColorPropConverter
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.uimanager.PixelUtil
+
+class StyleParser(
+  private val context: Context,
+  private val allowFontScaling: Boolean,
+  private val maxFontSizeMultiplier: Float,
+) {
+  fun parseOptionalColor(
+    map: ReadableMap,
+    key: String,
+  ): Int? {
+    if (!map.hasKey(key) || map.isNull(key)) {
+      return null
+    }
+    val colorValue = map.getDouble(key)
+    return ColorPropConverter.getColor(colorValue, context)
+  }
+
+  fun parseColor(
+    map: ReadableMap,
+    key: String,
+  ): Int =
+    parseOptionalColor(map, key)
+      ?: throw IllegalArgumentException("Color key '$key' is missing, null, or invalid")
+
+  fun parseOptionalDouble(
+    map: ReadableMap,
+    key: String,
+    default: Double = 0.0,
+  ): Double =
+    if (map.hasKey(key) && !map.isNull(key)) {
+      map.getDouble(key)
+    } else {
+      default
+    }
+
+  fun parseOptionalInt(
+    map: ReadableMap,
+    key: String,
+    default: Int = 0,
+  ): Int =
+    if (map.hasKey(key) && !map.isNull(key)) {
+      map.getInt(key)
+    } else {
+      default
+    }
+
+  fun parseString(
+    map: ReadableMap,
+    key: String,
+    default: String = "",
+  ): String = map.getString(key) ?: default
+
+  fun parseBoolean(
+    map: ReadableMap,
+    key: String,
+    default: Boolean = false,
+  ): Boolean =
+    if (map.hasKey(key) && !map.isNull(key)) {
+      map.getBoolean(key)
+    } else {
+      default
+    }
+
+  fun toPixelFromSP(value: Float): Float {
+    val metrics = context.resources.displayMetrics
+    val baseDensity = metrics.density
+
+    if (!allowFontScaling) {
+      return value * baseDensity
+    }
+
+    var fontScale = metrics.scaledDensity / baseDensity
+    if (maxFontSizeMultiplier >= 1.0f && fontScale > maxFontSizeMultiplier) {
+      fontScale = maxFontSizeMultiplier
+    }
+
+    return value * baseDensity * fontScale
+  }
+
+  fun toPixelFromDIP(value: Float): Float = PixelUtil.toPixelFromDIP(value)
+
+  fun parseTextAlign(
+    map: ReadableMap,
+    key: String,
+  ): TextAlignment = TextAlignment.fromString(parseString(map, key, "left"))
+}

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

@@ -0,0 +1,16 @@
+package com.swmansion.enriched.markdown.styles
+
+import com.facebook.react.bridge.ReadableMap
+
+data class SubscriptStyle(
+  val fontScale: Float,
+  val baselineOffsetScale: Float,
+) {
+  companion object {
+    fun fromReadableMap(map: ReadableMap): SubscriptStyle =
+      SubscriptStyle(
+        fontScale = map.getDouble("fontScale").toFloat(),
+        baselineOffsetScale = map.getDouble("baselineOffsetScale").toFloat(),
+      )
+  }
+}

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

@@ -0,0 +1,16 @@
+package com.swmansion.enriched.markdown.styles
+
+import com.facebook.react.bridge.ReadableMap
+
+data class SuperscriptStyle(
+  val fontScale: Float,
+  val baselineOffsetScale: Float,
+) {
+  companion object {
+    fun fromReadableMap(map: ReadableMap): SuperscriptStyle =
+      SuperscriptStyle(
+        fontScale = map.getDouble("fontScale").toFloat(),
+        baselineOffsetScale = map.getDouble("baselineOffsetScale").toFloat(),
+      )
+  }
+}

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

@@ -0,0 +1,69 @@
+package com.swmansion.enriched.markdown.styles
+
+import com.facebook.react.bridge.ReadableMap
+
+data class TableStyle(
+  override val fontSize: Float,
+  override val fontFamily: String,
+  override val fontWeight: String,
+  override val color: Int,
+  override val marginTop: Float,
+  override val marginBottom: Float,
+  override val lineHeight: Float,
+  val headerFontFamily: String,
+  val headerBackgroundColor: Int,
+  val headerTextColor: Int,
+  val rowEvenBackgroundColor: Int,
+  val rowOddBackgroundColor: Int,
+  val borderColor: Int,
+  val borderWidth: Float,
+  val borderRadius: Float,
+  val cellPaddingHorizontal: Float,
+  val cellPaddingVertical: Float,
+) : BaseBlockStyle {
+  companion object {
+    fun fromReadableMap(
+      map: ReadableMap,
+      parser: StyleParser,
+    ): TableStyle {
+      val fontSize = parser.toPixelFromSP(map.getDouble("fontSize").toFloat())
+      val fontFamily = parser.parseString(map, "fontFamily")
+      val fontWeight = parser.parseString(map, "fontWeight", "normal")
+      val color = parser.parseColor(map, "color")
+      val marginTop = parser.toPixelFromDIP(map.getDouble("marginTop").toFloat())
+      val marginBottom = parser.toPixelFromDIP(map.getDouble("marginBottom").toFloat())
+      val lineHeightRaw = map.getDouble("lineHeight").toFloat()
+      val lineHeight = if (lineHeightRaw > 0f) parser.toPixelFromSP(lineHeightRaw) else 0f
+      val headerFontFamily = parser.parseString(map, "headerFontFamily")
+      val headerBackgroundColor = parser.parseColor(map, "headerBackgroundColor")
+      val headerTextColor = parser.parseColor(map, "headerTextColor")
+      val rowEvenBackgroundColor = parser.parseColor(map, "rowEvenBackgroundColor")
+      val rowOddBackgroundColor = parser.parseColor(map, "rowOddBackgroundColor")
+      val borderColor = parser.parseColor(map, "borderColor")
+      val borderWidth = parser.toPixelFromDIP(map.getDouble("borderWidth").toFloat())
+      val borderRadius = parser.toPixelFromDIP(map.getDouble("borderRadius").toFloat())
+      val cellPaddingHorizontal = parser.toPixelFromDIP(map.getDouble("cellPaddingHorizontal").toFloat())
+      val cellPaddingVertical = parser.toPixelFromDIP(map.getDouble("cellPaddingVertical").toFloat())
+
+      return TableStyle(
+        fontSize = fontSize,
+        fontFamily = fontFamily,
+        fontWeight = fontWeight,
+        color = color,
+        marginTop = marginTop,
+        marginBottom = marginBottom,
+        lineHeight = lineHeight,
+        headerFontFamily = headerFontFamily,
+        headerBackgroundColor = headerBackgroundColor,
+        headerTextColor = headerTextColor,
+        rowEvenBackgroundColor = rowEvenBackgroundColor,
+        rowOddBackgroundColor = rowOddBackgroundColor,
+        borderColor = borderColor,
+        borderWidth = borderWidth,
+        borderRadius = borderRadius,
+        cellPaddingHorizontal = cellPaddingHorizontal,
+        cellPaddingVertical = cellPaddingVertical,
+      )
+    }
+  }
+}

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

@@ -0,0 +1,29 @@
+package com.swmansion.enriched.markdown.styles
+
+import com.facebook.react.bridge.ReadableMap
+
+data class TaskListStyle(
+  val checkedColor: Int,
+  val borderColor: Int,
+  val checkboxSize: Float,
+  val checkboxBorderRadius: Float,
+  val checkmarkColor: Int,
+  val checkedTextColor: Int,
+  val checkedStrikethrough: Boolean,
+) {
+  companion object {
+    fun fromReadableMap(
+      map: ReadableMap,
+      parser: StyleParser,
+    ): TaskListStyle =
+      TaskListStyle(
+        checkedColor = parser.parseColor(map, "checkedColor"),
+        borderColor = parser.parseColor(map, "borderColor"),
+        checkboxSize = parser.toPixelFromDIP(map.getDouble("checkboxSize").toFloat()),
+        checkboxBorderRadius = parser.toPixelFromDIP(map.getDouble("checkboxBorderRadius").toFloat()),
+        checkmarkColor = parser.parseColor(map, "checkmarkColor"),
+        checkedTextColor = parser.parseColor(map, "checkedTextColor"),
+        checkedStrikethrough = map.getBoolean("checkedStrikethrough"),
+      )
+  }
+}

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

@@ -0,0 +1,32 @@
+package com.swmansion.enriched.markdown.styles
+
+import android.text.Layout
+
+enum class TextAlignment(
+  val layoutAlignment: Layout.Alignment,
+  val needsJustify: Boolean,
+) {
+  LEFT(Layout.Alignment.ALIGN_NORMAL, false),
+  CENTER(Layout.Alignment.ALIGN_CENTER, false),
+  RIGHT(Layout.Alignment.ALIGN_OPPOSITE, false),
+  JUSTIFY(Layout.Alignment.ALIGN_NORMAL, true),
+  AUTO(Layout.Alignment.ALIGN_NORMAL, false),
+  ;
+
+  /**
+   * Whether an AlignmentSpan is needed.
+   * Only CENTER and RIGHT need explicit spans; LEFT/AUTO use default, JUSTIFY is handled at TextView level.
+   */
+  val needsAlignmentSpan: Boolean get() = this == CENTER || this == RIGHT
+
+  companion object {
+    fun fromString(value: String): TextAlignment =
+      when (value.lowercase()) {
+        "center" -> CENTER
+        "right" -> RIGHT
+        "justify" -> JUSTIFY
+        "auto" -> AUTO
+        else -> LEFT
+      }
+  }
+}

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

@@ -0,0 +1,23 @@
+package com.swmansion.enriched.markdown.styles
+
+import com.facebook.react.bridge.ReadableMap
+
+data class ThematicBreakStyle(
+  val color: Int,
+  val height: Float,
+  val marginTop: Float,
+  val marginBottom: Float,
+) {
+  companion object {
+    fun fromReadableMap(
+      map: ReadableMap,
+      parser: StyleParser,
+    ): ThematicBreakStyle {
+      val color = parser.parseColor(map, "color")
+      val height = parser.toPixelFromDIP(map.getDouble("height").toFloat())
+      val marginTop = parser.toPixelFromDIP(map.getDouble("marginTop").toFloat())
+      val marginBottom = parser.toPixelFromDIP(map.getDouble("marginBottom").toFloat())
+      return ThematicBreakStyle(color, height, marginTop, marginBottom)
+    }
+  }
+}

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

@@ -0,0 +1,17 @@
+package com.swmansion.enriched.markdown.styles
+
+import com.facebook.react.bridge.ReadableMap
+
+data class UnderlineStyle(
+  val color: Int,
+) {
+  companion object {
+    fun fromReadableMap(
+      map: ReadableMap,
+      parser: StyleParser,
+    ): UnderlineStyle {
+      val color = parser.parseColor(map, "color")
+      return UnderlineStyle(color)
+    }
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/utils/common/BreakStrategyUtils.kt

@@ -0,0 +1,32 @@
+package com.swmansion.enriched.markdown.utils.common
+
+import android.text.Layout
+
+/**
+ * Resolves a textBreakStrategy prop value (string) to the integer constant used
+ * by StaticLayout.Builder.setBreakStrategy() and TextView.setBreakStrategy().
+ *
+ * Stateless on purpose: textBreakStrategy is a per-view prop. Storage lives in
+ * [com.swmansion.enriched.markdown.MeasurementStore] (per viewId), and each
+ * view applies the resolved value to its own TextView. Both measurement and
+ * render paths must use the same value — mismatch causes measured line count
+ * to differ from the rendered line count, sizing the view incorrectly and
+ * causing ScrollingMovementMethod (inherited via LinkMovementMethod) to
+ * silently scroll the overflow.
+ *
+ * Note: call sites in StaticLayout.Builder suppress "WrongConstant" lint. This is
+ * intentional - Layout.BREAK_STRATEGY_SIMPLE and LineBreaker.BREAK_STRATEGY_SIMPLE
+ * are the same integer (0), but the @IntDef annotation on StaticLayout.Builder
+ * .setBreakStrategy() was changed from Layout.* to LineBreaker.* in API 29.
+ * The suppression is safe; the Layout.* constants share the same integer values.
+ */
+object BreakStrategyUtils {
+  const val DEFAULT_STRATEGY = "highQuality"
+
+  fun resolveBreakStrategy(strategy: String?): Int =
+    when (strategy) {
+      "simple" -> Layout.BREAK_STRATEGY_SIMPLE
+      "balanced" -> Layout.BREAK_STRATEGY_BALANCED
+      else -> Layout.BREAK_STRATEGY_HIGH_QUALITY
+    }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/utils/common/FeatureFlags.kt

@@ -0,0 +1,7 @@
+package com.swmansion.enriched.markdown.utils.common
+
+import com.swmansion.enriched.markdown.BuildConfig
+
+object FeatureFlags {
+  const val IS_MATH_ENABLED: Boolean = BuildConfig.ENABLE_MATH
+}

package/android/src/main/java/com/swmansion/enriched/markdown/utils/common/MarkdownSegment.kt

@@ -0,0 +1,56 @@
+package com.swmansion.enriched.markdown.utils.common
+
+import com.swmansion.enriched.markdown.parser.MarkdownASTNode
+
+sealed interface MarkdownSegment {
+  data class Text(
+    val nodes: List<MarkdownASTNode>,
+  ) : MarkdownSegment
+
+  data class Table(
+    val node: MarkdownASTNode,
+  ) : MarkdownSegment
+
+  data class Math(
+    val latex: String,
+    val node: MarkdownASTNode,
+  ) : MarkdownSegment
+}
+
+fun splitASTIntoSegments(root: MarkdownASTNode): List<MarkdownSegment> {
+  val segments = mutableListOf<MarkdownSegment>()
+  val currentTextNodes = mutableListOf<MarkdownASTNode>()
+
+  fun flushTextNodes() {
+    if (currentTextNodes.isNotEmpty()) {
+      segments.add(MarkdownSegment.Text(currentTextNodes.toList()))
+      currentTextNodes.clear()
+    }
+  }
+
+  for (child in root.children) {
+    when (child.type) {
+      MarkdownASTNode.NodeType.Table -> {
+        flushTextNodes()
+        segments.add(MarkdownSegment.Table(child))
+      }
+
+      MarkdownASTNode.NodeType.LatexMathDisplay -> {
+        flushTextNodes()
+        val latex =
+          if (child.children.isNotEmpty()) {
+            child.children.first().content
+          } else {
+            child.content
+          }
+        segments.add(MarkdownSegment.Math(latex, child))
+      }
+
+      else -> {
+        currentTextNodes.add(child)
+      }
+    }
+  }
+  flushTextNodes()
+  return segments
+}

package/android/src/main/java/com/swmansion/enriched/markdown/utils/common/MarkdownViewManagerUtils.kt

@@ -0,0 +1,100 @@
+package com.swmansion.enriched.markdown.utils.common
+
+import android.view.View
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.uimanager.UIManagerHelper
+import com.swmansion.enriched.markdown.events.ContextMenuItemPressEvent
+import com.swmansion.enriched.markdown.events.LinkLongPressEvent
+import com.swmansion.enriched.markdown.events.LinkPressEvent
+import com.swmansion.enriched.markdown.events.TaskListItemPressEvent
+import com.swmansion.enriched.markdown.parser.Md4cFlags
+import com.swmansion.enriched.markdown.utils.text.view.SelectionMenuConfig
+
+fun markdownEventTypeConstants(): MutableMap<String, Any> {
+  val map = mutableMapOf<String, Any>()
+  map[LinkPressEvent.EVENT_NAME] = mapOf("registrationName" to LinkPressEvent.EVENT_NAME)
+  map[LinkLongPressEvent.EVENT_NAME] =
+    mapOf("registrationName" to LinkLongPressEvent.EVENT_NAME)
+  map[TaskListItemPressEvent.EVENT_NAME] =
+    mapOf("registrationName" to TaskListItemPressEvent.EVENT_NAME)
+  map[ContextMenuItemPressEvent.EVENT_NAME] =
+    mapOf("registrationName" to ContextMenuItemPressEvent.EVENT_NAME)
+  return map
+}
+
+fun emitLinkPress(
+  view: View,
+  url: String,
+) {
+  val context = view.context as com.facebook.react.bridge.ReactContext
+  val surfaceId = UIManagerHelper.getSurfaceId(context)
+  val eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(context, view.id)
+  eventDispatcher?.dispatchEvent(LinkPressEvent(surfaceId, view.id, url))
+}
+
+fun emitLinkLongPress(
+  view: View,
+  url: String,
+) {
+  val context = view.context as com.facebook.react.bridge.ReactContext
+  val surfaceId = UIManagerHelper.getSurfaceId(context)
+  val eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(context, view.id)
+  eventDispatcher?.dispatchEvent(LinkLongPressEvent(surfaceId, view.id, url))
+}
+
+fun emitTaskListItemPress(
+  view: View,
+  taskIndex: Int,
+  checked: Boolean,
+  itemText: String,
+) {
+  val context = view.context as com.facebook.react.bridge.ReactContext
+  val surfaceId = UIManagerHelper.getSurfaceId(context)
+  val eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(context, view.id)
+  eventDispatcher?.dispatchEvent(
+    TaskListItemPressEvent(surfaceId, view.id, taskIndex, checked, itemText),
+  )
+}
+
+fun emitContextMenuItemPress(
+  view: View,
+  itemText: String,
+  selectedText: String,
+  selectionStart: Int,
+  selectionEnd: Int,
+) {
+  val context = view.context as com.facebook.react.bridge.ReactContext
+  val surfaceId = UIManagerHelper.getSurfaceId(context)
+  val eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(context, view.id)
+  eventDispatcher?.dispatchEvent(
+    ContextMenuItemPressEvent(
+      surfaceId,
+      view.id,
+      itemText,
+      selectedText,
+      selectionStart,
+      selectionEnd,
+    ),
+  )
+}
+
+fun parseMd4cFlags(flags: ReadableMap?): Md4cFlags =
+  Md4cFlags(
+    underline = flags?.getBoolean("underline") ?: false,
+    latexMath = FeatureFlags.IS_MATH_ENABLED && (flags?.getBoolean("latexMath") ?: true),
+    superscript = flags?.getBoolean("superscript") ?: false,
+    subscript = flags?.getBoolean("subscript") ?: false,
+    highlight = flags?.getBoolean("highlight") ?: false,
+  )
+
+fun parseContextMenuItems(value: ReadableArray?): List<String> =
+  (0 until (value?.size() ?: 0)).mapNotNull { value?.getMap(it)?.getString("text") }
+
+fun parseSelectionMenuConfig(value: ReadableMap?): SelectionMenuConfig {
+  if (value == null) return SelectionMenuConfig()
+  return SelectionMenuConfig(
+    copyAsMarkdown = value.getBoolean("copyAsMarkdown"),
+    copyImageUrl = value.getBoolean("copyImageUrl"),
+  )
+}

package/android/src/main/java/com/swmansion/enriched/markdown/utils/common/MotionPreferences.kt

@@ -0,0 +1,18 @@
+package com.swmansion.enriched.markdown.utils.common
+
+import android.animation.ValueAnimator
+import android.content.Context
+import android.os.Build
+
+/**
+ * Returns true when the user has asked the system to minimise motion.
+ *
+ * On API 26+ delegates to [ValueAnimator.areAnimatorsEnabled], which covers
+ * the "Remove animations" accessibility setting, the "Animator duration scale"
+ * developer toggle, and Battery Saver mode. Older API levels do not expose an
+ * equivalent flag, hence the fall back to allowing animations.
+ */
+fun isReducedMotionEnabled(context: Context): Boolean {
+  if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return false
+  return !ValueAnimator.areAnimatorsEnabled()
+}

package/android/src/main/java/com/swmansion/enriched/markdown/utils/common/ReadableMapExtensions.kt

@@ -0,0 +1,20 @@
+package com.swmansion.enriched.markdown.utils.common
+
+import com.facebook.react.bridge.ReadableMap
+
+fun ReadableMap?.getBooleanOrDefault(
+  key: String,
+  default: Boolean,
+): Boolean = if (this?.hasKey(key) == true) getBoolean(key) else default
+
+fun ReadableMap?.getFloatOrDefault(
+  key: String,
+  default: Float,
+): Float = if (this?.hasKey(key) == true) getDouble(key).toFloat() else default
+
+fun ReadableMap?.getStringOrDefault(
+  key: String,
+  default: String,
+): String = if (this?.hasKey(key) == true) getString(key) ?: default else default
+
+fun ReadableMap?.getMapOrNull(key: String): ReadableMap? = if (this?.hasKey(key) == true) getMap(key) else null

package/android/src/main/java/com/swmansion/enriched/markdown/utils/common/RenderedSegment.kt

@@ -0,0 +1,78 @@
+package com.swmansion.enriched.markdown.utils.common
+
+import android.content.Context
+import android.text.SpannableString
+import com.swmansion.enriched.markdown.parser.MarkdownASTNode
+import com.swmansion.enriched.markdown.renderer.Renderer
+import com.swmansion.enriched.markdown.spans.ImageSpan
+import com.swmansion.enriched.markdown.styles.StyleConfig
+
+sealed interface RenderedSegment {
+  val signature: Long
+
+  data class Text(
+    val styledText: SpannableString,
+    val imageSpans: List<ImageSpan>,
+    val needsJustify: Boolean,
+    val lastElementMarginBottom: Float,
+    override val signature: Long,
+  ) : RenderedSegment
+
+  data class Table(
+    val node: MarkdownASTNode,
+    override val signature: Long,
+  ) : RenderedSegment
+
+  data class Math(
+    val latex: String,
+    override val signature: Long,
+  ) : RenderedSegment
+}
+
+object MarkdownSegmentRenderer {
+  fun render(
+    segments: List<MarkdownSegment>,
+    style: StyleConfig,
+    context: Context,
+    onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
+  ): List<RenderedSegment> =
+    segments.map { segment ->
+      when (segment) {
+        is MarkdownSegment.Text -> {
+          renderTextSegment(segment.nodes, style, context, onLinkPress, onLinkLongPress)
+        }
+
+        is MarkdownSegment.Table -> {
+          val signature = SegmentSignature.signatureForNode(segment.node) xor SegmentSignature.TABLE_KIND_SALT
+          RenderedSegment.Table(segment.node, signature)
+        }
+
+        is MarkdownSegment.Math -> {
+          var signature = SegmentSignature.signatureForNode(null) xor SegmentSignature.MATH_KIND_SALT
+          signature = SegmentSignature.fnvMixString(signature, segment.latex)
+          RenderedSegment.Math(segment.latex, signature)
+        }
+      }
+    }
+
+  private fun renderTextSegment(
+    nodes: List<MarkdownASTNode>,
+    style: StyleConfig,
+    context: Context,
+    onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
+  ): RenderedSegment.Text {
+    val documentWrapper = MarkdownASTNode(type = MarkdownASTNode.NodeType.Document, children = nodes)
+    val renderer = Renderer().apply { configure(style, context) }
+    val signature = SegmentSignature.signatureForNodes(nodes) xor SegmentSignature.TEXT_KIND_SALT
+
+    return RenderedSegment.Text(
+      styledText = renderer.renderDocument(documentWrapper, onLinkPress, onLinkLongPress),
+      imageSpans = renderer.getCollectedImageSpans().toList(),
+      needsJustify = style.needsJustify,
+      lastElementMarginBottom = renderer.getLastElementMarginBottom(),
+      signature = signature,
+    )
+  }
+}