@mathers101/react-native-render-rich-text 0.0.0-stage → 0.1.10

package/android/src/main/java/com/renderrichtext/styles/LinkVariantEntry.kt

@@ -0,0 +1,34 @@
+package com.renderrichtext.styles
+
+import com.facebook.react.bridge.ReadableMap
+
+/**
+ * Resolved style for a single URL-pattern variant.
+ * The `pattern` field is a regex tested against the full URL in normalized order.
+ * Fields are pre-merged with the base link style by the JS normalizer — native code
+ * uses them directly without any additional fallback logic.
+ */
+data class LinkVariantEntry(
+  val pattern: String,
+  val color: Int,
+  val underline: Boolean,
+  val backgroundColor: Int,
+  val fontFamily: String = "",
+  /** Pill presentation for links matching this variant; null renders an ordinary link. */
+  val pill: LinkPillStyle? = null,
+) {
+  companion object {
+    fun fromReadableMap(
+      map: ReadableMap,
+      parser: StyleParser,
+    ): LinkVariantEntry =
+      LinkVariantEntry(
+        pattern = map.getString("pattern") ?: "",
+        color = parser.parseColor(map, "color"),
+        underline = parser.parseBoolean(map, "underline"),
+        backgroundColor = parser.parseColor(map, "backgroundColor"),
+        fontFamily = parser.parseString(map, "fontFamily"),
+        pill = map.getMap("pill")?.let { LinkPillStyle.fromReadableMap(it, parser) },
+      )
+  }
+}

package/android/src/main/java/com/renderrichtext/styles/ListStyle.kt

@@ -0,0 +1,65 @@
+package com.renderrichtext.styles
+
+import com.facebook.react.bridge.ReadableMap
+
+data class ListStyle(
+  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 bulletColor: Int,
+  val bulletSize: Float,
+  val markerMinWidth: Float,
+  val markerColor: Int,
+  val markerFontWeight: String,
+  val gapWidth: Float,
+  val marginLeft: Float,
+  val itemSpacing: Float,
+) : BaseBlockStyle {
+  fun effectiveMarkerWidth(naturalWidth: Float): Float = naturalWidth.coerceAtLeast(markerMinWidth)
+
+  companion object {
+    fun fromReadableMap(
+      map: ReadableMap,
+      parser: StyleParser,
+    ): ListStyle {
+      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 = parser.toPixelFromSP(lineHeightRaw)
+      val bulletColor = parser.parseColor(map, "bulletColor")
+      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,
+        fontFamily,
+        fontWeight,
+        color,
+        marginTop,
+        marginBottom,
+        lineHeight,
+        bulletColor,
+        bulletSize,
+        markerMinWidth,
+        markerColor,
+        markerFontWeight,
+        gapWidth,
+        marginLeft,
+        itemSpacing,
+      )
+    }
+  }
+}

package/android/src/main/java/com/renderrichtext/styles/MathStyle.kt

@@ -0,0 +1,29 @@
+package com.renderrichtext.styles
+
+import com.facebook.react.bridge.ReadableMap
+
+data class MathStyle(
+  val fontSize: Float,
+  val color: Int,
+  val backgroundColor: Int,
+  val padding: Float,
+  val marginTop: Float,
+  val marginBottom: Float,
+  val textAlign: String,
+) {
+  companion object {
+    fun fromReadableMap(
+      map: ReadableMap,
+      parser: StyleParser,
+    ): MathStyle {
+      val fontSize = parser.toPixelFromSP(map.getDouble("fontSize").toFloat())
+      val color = parser.parseColor(map, "color")
+      val backgroundColor = parser.parseColor(map, "backgroundColor")
+      val padding = parser.toPixelFromDIP(map.getDouble("padding").toFloat())
+      val marginTop = parser.toPixelFromDIP(map.getDouble("marginTop").toFloat())
+      val marginBottom = parser.toPixelFromDIP(map.getDouble("marginBottom").toFloat())
+      val textAlign = parser.parseString(map, "textAlign", "center")
+      return MathStyle(fontSize, color, backgroundColor, padding, marginTop, marginBottom, textAlign)
+    }
+  }
+}

package/android/src/main/java/com/renderrichtext/styles/MentionStyle.kt

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

package/android/src/main/java/com/renderrichtext/styles/ParagraphStyle.kt

@@ -0,0 +1,33 @@
+package com.renderrichtext.styles
+
+import com.facebook.react.bridge.ReadableMap
+
+data class ParagraphStyle(
+  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 textAlign: TextAlignment,
+) : BaseBlockStyle {
+  companion object {
+    fun fromReadableMap(
+      map: ReadableMap,
+      parser: StyleParser,
+    ): ParagraphStyle {
+      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 = parser.toPixelFromSP(lineHeightRaw)
+      val textAlign = parser.parseTextAlign(map, "textAlign")
+
+      return ParagraphStyle(fontSize, fontFamily, fontWeight, color, marginTop, marginBottom, lineHeight, textAlign)
+    }
+  }
+}

package/android/src/main/java/com/renderrichtext/styles/SpoilerStyle.kt

@@ -0,0 +1,27 @@
+package com.renderrichtext.styles
+
+import com.facebook.react.bridge.ReadableMap
+
+data class SpoilerStyle(
+  val color: Int,
+  val particleDensity: Float,
+  val particleSpeed: Float,
+  val solidBorderRadius: Float,
+) {
+  companion object {
+    fun fromReadableMap(
+      map: ReadableMap,
+      parser: StyleParser,
+    ): SpoilerStyle {
+      val color = parser.parseColor(map, "color")
+      val particlesMap = map.getMap("particles")!!
+      val solidMap = map.getMap("solid")!!
+      return SpoilerStyle(
+        color = color,
+        particleDensity = particlesMap.getDouble("density").toFloat(),
+        particleSpeed = particlesMap.getDouble("speed").toFloat(),
+        solidBorderRadius = solidMap.getDouble("borderRadius").toFloat(),
+      )
+    }
+  }
+}

package/android/src/main/java/com/renderrichtext/styles/StrikethroughStyle.kt

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

package/android/src/main/java/com/renderrichtext/styles/StrongStyle.kt

@@ -0,0 +1,21 @@
+package com.renderrichtext.styles
+
+import com.facebook.react.bridge.ReadableMap
+
+data class StrongStyle(
+  val fontFamily: String,
+  val fontWeight: String,
+  val color: Int?,
+) {
+  companion object {
+    fun fromReadableMap(
+      map: ReadableMap,
+      parser: StyleParser,
+    ): StrongStyle {
+      val fontFamily = parser.parseString(map, "fontFamily")
+      val fontWeight = parser.parseString(map, "fontWeight")
+      val color = parser.parseOptionalColor(map, "color")
+      return StrongStyle(fontFamily, fontWeight, color)
+    }
+  }
+}

package/android/src/main/java/com/renderrichtext/styles/StyleConfig.kt

@@ -0,0 +1,411 @@
+package com.renderrichtext.styles
+
+import android.content.Context
+import android.content.res.AssetManager
+import android.graphics.Typeface
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.common.ReactConstants
+import com.facebook.react.views.text.ReactTypefaceUtils.applyStyles
+import com.facebook.react.views.text.ReactTypefaceUtils.parseFontWeight
+
+/**
+ * Main style configuration class that parses and caches all tiptap element styles.
+ * Uses lazy initialization to defer parsing until styles are actually needed,
+ * improving startup time for documents that don't use all tiptap features.
+ */
+class StyleConfig(
+  private val style: ReadableMap,
+  context: Context,
+  allowFontScaling: Boolean,
+  maxFontSizeMultiplier: Float,
+) {
+  private val styleParser = StyleParser(context, allowFontScaling, maxFontSizeMultiplier)
+  internal val assetManager: AssetManager = context.assets
+  private val assets: AssetManager get() = assetManager
+
+  private var paragraphStyleOverride: ParagraphStyle? = null
+
+  val paragraphStyle: ParagraphStyle
+    get() = paragraphStyleOverride ?: paragraphStyleDefault
+
+  private val paragraphStyleDefault: ParagraphStyle by lazy {
+    val map =
+      requireNotNull(style.getMap("paragraph")) {
+        "Paragraph style not found. JS should always provide defaults."
+      }
+    ParagraphStyle.fromReadableMap(map, styleParser)
+  }
+
+  /** Runs block with a temporary paragraph style override for table cell rendering. */
+  fun <T> withParagraphOverride(
+    override: ParagraphStyle,
+    block: () -> T,
+  ): T {
+    paragraphStyleOverride = override
+    try {
+      return block()
+    } finally {
+      paragraphStyleOverride = null
+    }
+  }
+
+  fun tableCellParagraphStyle(
+    tableStyle: TableStyle,
+    isHeader: Boolean,
+  ): ParagraphStyle =
+    paragraphStyleDefault.copy(
+      fontSize = tableStyle.fontSize,
+      fontFamily = if (isHeader && tableStyle.headerFontFamily.isNotEmpty()) tableStyle.headerFontFamily else tableStyle.fontFamily,
+      fontWeight = if (isHeader) "bold" else tableStyle.fontWeight,
+      color = if (isHeader) tableStyle.headerTextColor else tableStyle.color,
+      lineHeight = tableStyle.lineHeight,
+      marginTop = 0f,
+      marginBottom = 0f,
+    )
+
+  val headingStyles: Array<HeadingStyle?> by lazy {
+    Array(7) { index ->
+      if (index == 0) {
+        null
+      } else {
+        val levelKey = "h$index"
+        val map =
+          requireNotNull(style.getMap(levelKey)) {
+            "Style for $levelKey not found. JS should always provide defaults."
+          }
+        HeadingStyle.fromReadableMap(map, styleParser)
+      }
+    }
+  }
+
+  // Cache typefaces for heading levels (1-6) - lazily initialized after headingStyles
+  // Uses React Native's applyStyles to properly load custom fonts from assets
+  val headingTypefaces: Array<Typeface?> by lazy {
+    Array(7) { level ->
+      if (level == 0) {
+        null
+      } else {
+        val headingStyle = headingStyles[level]
+        val fontFamily = headingStyle?.fontFamily?.takeIf { it.isNotEmpty() }
+        val fontWeight = parseFontWeight(headingStyle?.fontWeight)
+
+        if (fontFamily != null) {
+          // 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
+        }
+      }
+    }
+  }
+
+  val linkStyle: LinkStyle by lazy {
+    val map =
+      requireNotNull(style.getMap("link")) {
+        "Link style not found. JS should always provide defaults."
+      }
+    LinkStyle.fromReadableMap(map, styleParser)
+  }
+
+  val linkVariants: List<LinkVariantEntry> by lazy {
+    val array = style.getArray("linkVariants") ?: return@lazy emptyList()
+    (0 until array.size()).mapNotNull { i ->
+      array.getMap(i)?.let { LinkVariantEntry.fromReadableMap(it, styleParser) }
+    }
+  }
+
+  /** Whether any variant can produce a pill; lets per-draw code skip pill lookups. */
+  val hasLinkPills: Boolean by lazy { linkVariants.any { it.pill != null } }
+
+  val strongStyle: StrongStyle by lazy {
+    val map =
+      requireNotNull(style.getMap("strong")) {
+        "Strong style not found. JS should always provide defaults."
+      }
+    StrongStyle.fromReadableMap(map, styleParser)
+  }
+
+  val emphasisStyle: EmphasisStyle by lazy {
+    val map =
+      requireNotNull(style.getMap("em")) {
+        "Emphasis style not found. JS should always provide defaults."
+      }
+    EmphasisStyle.fromReadableMap(map, styleParser)
+  }
+
+  val strikethroughStyle: StrikethroughStyle by lazy {
+    val map =
+      requireNotNull(style.getMap("strikethrough")) {
+        "Strikethrough style not found. JS should always provide defaults."
+      }
+    StrikethroughStyle.fromReadableMap(map, styleParser)
+  }
+
+  val underlineStyle: UnderlineStyle by lazy {
+    val map =
+      requireNotNull(style.getMap("underline")) {
+        "Underline style not found. JS should always provide defaults."
+      }
+    UnderlineStyle.fromReadableMap(map, styleParser)
+  }
+
+  val codeStyle: CodeStyle by lazy {
+    val map =
+      requireNotNull(style.getMap("code")) {
+        "Code style not found. JS should always provide defaults."
+      }
+    CodeStyle.fromReadableMap(map, styleParser)
+  }
+
+  val mentionStyle: MentionStyle by lazy {
+    val map =
+      requireNotNull(style.getMap("mention")) {
+        "Mention style not found. JS should always provide defaults."
+      }
+    MentionStyle.fromReadableMap(map, styleParser)
+  }
+
+  val factoidStyle: FactoidStyle by lazy {
+    val map =
+      requireNotNull(style.getMap("factoid")) {
+        "Factoid style not found. JS should always provide defaults."
+      }
+    FactoidStyle.fromReadableMap(map, styleParser)
+  }
+
+  val imageStyle: ImageStyle by lazy {
+    val map =
+      requireNotNull(style.getMap("image")) {
+        "Image style not found. JS should always provide defaults."
+      }
+    ImageStyle.fromReadableMap(map, styleParser)
+  }
+
+  var imageRequestHeaders: Map<String, String> = emptyMap()
+
+  /** Per-link pill content keyed by exact URL; content, so it lives outside the style map. */
+  var linkPillContent: Map<String, LinkPillContent> = emptyMap()
+
+  val videoStyle: VideoStyle by lazy {
+    val map =
+      requireNotNull(style.getMap("video")) {
+        "Video style not found. JS should always provide defaults."
+      }
+    VideoStyle.fromReadableMap(map, styleParser)
+  }
+
+  val inlineImageStyle: InlineImageStyle by lazy {
+    val map =
+      requireNotNull(style.getMap("inlineImage")) {
+        "InlineImage style not found. JS should always provide defaults."
+      }
+    InlineImageStyle.fromReadableMap(map, styleParser)
+  }
+
+  val blockquoteStyle: BlockquoteStyle by lazy {
+    val map =
+      requireNotNull(style.getMap("blockquote")) {
+        "Blockquote style not found. JS should always provide defaults."
+      }
+    BlockquoteStyle.fromReadableMap(map, styleParser)
+  }
+
+  val listStyle: ListStyle by lazy {
+    val map =
+      requireNotNull(style.getMap("list")) {
+        "List style not found. JS should always provide defaults."
+      }
+    ListStyle.fromReadableMap(map, styleParser)
+  }
+
+  val codeBlockStyle: CodeBlockStyle by lazy {
+    val map =
+      requireNotNull(style.getMap("codeBlock")) {
+        "CodeBlock style not found. JS should always provide defaults."
+      }
+    CodeBlockStyle.fromReadableMap(map, styleParser)
+  }
+
+  val thematicBreakStyle: ThematicBreakStyle by lazy {
+    val map =
+      requireNotNull(style.getMap("thematicBreak")) {
+        "ThematicBreak style not found. JS should always provide defaults."
+      }
+    ThematicBreakStyle.fromReadableMap(map, styleParser)
+  }
+
+  val tableStyle: TableStyle by lazy {
+    val map =
+      requireNotNull(style.getMap("table")) {
+        "Table style not found. JS should always provide defaults."
+      }
+    TableStyle.fromReadableMap(map, styleParser)
+  }
+
+  val taskListStyle: TaskListStyle by lazy {
+    val map =
+      requireNotNull(style.getMap("taskList")) {
+        "TaskList style not found. JS should always provide defaults."
+      }
+    TaskListStyle.fromReadableMap(map, styleParser)
+  }
+
+  val mathStyle: MathStyle by lazy {
+    val map =
+      requireNotNull(style.getMap("math")) {
+        "Math style not found. JS should always provide defaults."
+      }
+    MathStyle.fromReadableMap(map, styleParser)
+  }
+
+  val inlineMathStyle: InlineMathStyle by lazy {
+    val map =
+      requireNotNull(style.getMap("inlineMath")) {
+        "InlineMath style not found. JS should always provide defaults."
+      }
+    InlineMathStyle.fromReadableMap(map, styleParser)
+  }
+
+  val spoilerStyle: SpoilerStyle by lazy {
+    val map =
+      requireNotNull(style.getMap("spoiler")) {
+        "Spoiler style not found. JS should always provide defaults."
+      }
+    SpoilerStyle.fromReadableMap(map, styleParser)
+  }
+
+  val superscriptStyle: SuperscriptStyle by lazy {
+    val map =
+      requireNotNull(style.getMap("superscript")) {
+        "Superscript style not found. JS should always provide defaults."
+      }
+    SuperscriptStyle.fromReadableMap(map)
+  }
+
+  val subscriptStyle: SubscriptStyle by lazy {
+    val map =
+      requireNotNull(style.getMap("subscript")) {
+        "Subscript style not found. JS should always provide defaults."
+      }
+    SubscriptStyle.fromReadableMap(map)
+  }
+
+  val highlightStyle: HighlightStyle by lazy {
+    val map =
+      requireNotNull(style.getMap("highlight")) {
+        "Highlight style not found. JS should always provide defaults."
+      }
+    HighlightStyle.fromReadableMap(map, styleParser)
+  }
+
+  val tableTypeface: Typeface? by lazy {
+    val fontFamily = tableStyle.fontFamily.takeIf { it.isNotEmpty() }
+    val fontWeight = parseFontWeight(tableStyle.fontWeight)
+    if (fontFamily != null) {
+      applyStyles(null, ReactConstants.UNSET, fontWeight, fontFamily, assets)
+    } else {
+      null
+    }
+  }
+
+  val tableHeaderTypeface: Typeface? by lazy {
+    val headerFamily = tableStyle.headerFontFamily.takeIf { it.isNotEmpty() }
+    val baseFamily = tableStyle.fontFamily.takeIf { it.isNotEmpty() }
+
+    when {
+      // 1. Try Header font (specific variant)
+      headerFamily != null -> {
+        applyStyles(null, ReactConstants.UNSET, parseFontWeight("normal"), headerFamily, assets)
+      }
+
+      // 2. Try Table font (forced to bold)
+      baseFamily != null -> {
+        applyStyles(null, ReactConstants.UNSET, parseFontWeight("bold"), baseFamily, assets)
+      }
+
+      // 3. System Fallback
+      else -> {
+        Typeface.DEFAULT_BOLD
+      }
+    }
+  }
+
+  /**
+   * Returns true if any paragraph or heading style uses justify alignment.
+   * Used to enable justification mode on the TextView (API 26+).
+   */
+  val needsJustify: Boolean by lazy {
+    paragraphStyle.textAlign.needsJustify ||
+      headingStyles.filterNotNull().any { it.textAlign.needsJustify }
+  }
+
+  override fun equals(other: Any?): Boolean {
+    if (this === other) return true
+    if (other !is StyleConfig) return false
+
+    return paragraphStyle == other.paragraphStyle &&
+      headingStyles.contentEquals(other.headingStyles) &&
+      linkStyle == other.linkStyle &&
+      linkVariants == other.linkVariants &&
+      strongStyle == other.strongStyle &&
+      emphasisStyle == other.emphasisStyle &&
+      strikethroughStyle == other.strikethroughStyle &&
+      underlineStyle == other.underlineStyle &&
+      codeStyle == other.codeStyle &&
+      mentionStyle == other.mentionStyle &&
+      factoidStyle == other.factoidStyle &&
+      imageStyle == other.imageStyle &&
+      videoStyle == other.videoStyle &&
+      inlineImageStyle == other.inlineImageStyle &&
+      blockquoteStyle == other.blockquoteStyle &&
+      listStyle == other.listStyle &&
+      codeBlockStyle == other.codeBlockStyle &&
+      thematicBreakStyle == other.thematicBreakStyle &&
+      tableStyle == other.tableStyle &&
+      taskListStyle == other.taskListStyle &&
+      mathStyle == other.mathStyle &&
+      inlineMathStyle == other.inlineMathStyle &&
+      spoilerStyle == other.spoilerStyle &&
+      superscriptStyle == other.superscriptStyle &&
+      subscriptStyle == other.subscriptStyle &&
+      highlightStyle == other.highlightStyle &&
+      imageRequestHeaders == other.imageRequestHeaders &&
+      linkPillContent == other.linkPillContent
+  }
+
+  override fun hashCode(): Int {
+    var result = paragraphStyle.hashCode()
+    result = 31 * result + headingStyles.contentHashCode()
+    result = 31 * result + linkStyle.hashCode()
+    result = 31 * result + linkVariants.hashCode()
+    result = 31 * result + strongStyle.hashCode()
+    result = 31 * result + emphasisStyle.hashCode()
+    result = 31 * result + strikethroughStyle.hashCode()
+    result = 31 * result + underlineStyle.hashCode()
+    result = 31 * result + codeStyle.hashCode()
+    result = 31 * result + mentionStyle.hashCode()
+    result = 31 * result + factoidStyle.hashCode()
+    result = 31 * result + imageStyle.hashCode()
+    result = 31 * result + videoStyle.hashCode()
+    result = 31 * result + inlineImageStyle.hashCode()
+    result = 31 * result + blockquoteStyle.hashCode()
+    result = 31 * result + listStyle.hashCode()
+    result = 31 * result + codeBlockStyle.hashCode()
+    result = 31 * result + thematicBreakStyle.hashCode()
+    result = 31 * result + tableStyle.hashCode()
+    result = 31 * result + taskListStyle.hashCode()
+    result = 31 * result + mathStyle.hashCode()
+    result = 31 * result + inlineMathStyle.hashCode()
+    result = 31 * result + spoilerStyle.hashCode()
+    result = 31 * result + superscriptStyle.hashCode()
+    result = 31 * result + subscriptStyle.hashCode()
+    result = 31 * result + highlightStyle.hashCode()
+    result = 31 * result + imageRequestHeaders.hashCode()
+    result = 31 * result + linkPillContent.hashCode()
+    return result
+  }
+}