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

package/android/src/main/java/com/renderrichtext/spans/ThematicBreakSpan.kt

@@ -0,0 +1,69 @@
+package com.renderrichtext.spans
+
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.text.style.ReplacementSpan
+
+class ThematicBreakSpan(
+  private val lineColor: Int,
+  private val lineHeight: Float,
+  private val marginTop: Float,
+  private val marginBottom: Float,
+) : ReplacementSpan() {
+  override fun getSize(
+    paint: Paint,
+    text: CharSequence?,
+    start: Int,
+    end: Int,
+    fm: Paint.FontMetricsInt?,
+  ): Int {
+    val totalHeight = (marginTop + lineHeight + marginBottom).toInt()
+
+    fm?.apply {
+      ascent = -totalHeight
+      top = -totalHeight
+      descent = 0
+      bottom = 0
+    }
+
+    return 0
+  }
+
+  override fun draw(
+    canvas: Canvas,
+    text: CharSequence?,
+    start: Int,
+    end: Int,
+    x: Float,
+    top: Int,
+    y: Int,
+    bottom: Int,
+    paint: Paint,
+  ) {
+    paint.withStyle(lineColor, lineHeight) {
+      val lineY = top + marginTop + (lineHeight / 2f)
+
+      canvas.drawLine(0f, lineY, canvas.width.toFloat(), lineY, paint)
+    }
+  }
+
+  private inline fun Paint.withStyle(
+    color: Int,
+    width: Float,
+    action: () -> Unit,
+  ) {
+    val oldColor = this.color
+    val oldWidth = this.strokeWidth
+    val oldStyle = this.style
+
+    this.color = color
+    this.strokeWidth = width
+    this.style = Paint.Style.STROKE
+
+    action()
+
+    this.color = oldColor
+    this.strokeWidth = oldWidth
+    this.style = oldStyle
+  }
+}

package/android/src/main/java/com/renderrichtext/spans/UnorderedListSpan.kt

@@ -0,0 +1,96 @@
+package com.renderrichtext.spans
+
+import android.content.Context
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.text.Layout
+import com.renderrichtext.renderer.BlockStyle
+import com.renderrichtext.renderer.SpanStyleCache
+import com.renderrichtext.styles.ListStyle
+
+class UnorderedListSpan(
+  private val listStyle: ListStyle,
+  depth: Int,
+  context: Context,
+  styleCache: SpanStyleCache,
+  drawsMarker: Boolean = true,
+  ancestorMarkerOffset: Float = 0f,
+  parentMarkerWidth: Float? = null,
+) : BaseListSpan(
+    depth = depth,
+    context = context,
+    styleCache = styleCache,
+    blockStyle =
+      BlockStyle(
+        fontSize = listStyle.fontSize,
+        fontFamily = listStyle.fontFamily,
+        fontWeight = listStyle.fontWeight,
+        color = listStyle.color,
+      ),
+    marginLeft = listStyle.marginLeft,
+    gapWidth = listStyle.gapWidth,
+    drawsMarker = drawsMarker,
+    ancestorMarkerOffset = ancestorMarkerOffset,
+    parentMarkerWidth = parentMarkerWidth,
+  ) {
+  companion object {
+    private val sharedBulletPaint =
+      Paint(Paint.ANTI_ALIAS_FLAG).apply {
+        style = Paint.Style.FILL
+      }
+  }
+
+  private val radius: Float = listStyle.bulletSize / 2f
+  private val ringStrokeWidth: Float = radius * 0.3f
+  // Same column an ordered list reserves for `99.`, so both lists indent equally.
+  private val markerColumnWidth: Float = OrderedListSpan.defaultMarkerColumnWidth(listStyle, context)
+
+  private fun configureBulletPaint(): Paint =
+    sharedBulletPaint.apply {
+      color = listStyle.bulletColor
+      style = Paint.Style.FILL
+      strokeWidth = 0f
+    }
+
+  override fun getMarkerWidth(): Float = markerColumnWidth
+
+  override fun drawMarker(
+    canvas: Canvas,
+    paint: Paint,
+    x: Int,
+    dir: Int,
+    top: Int,
+    baseline: Int,
+    bottom: Int,
+    layout: Layout?,
+    start: Int,
+  ) {
+    val bulletPaint = configureBulletPaint()
+    // Right-align the bullet in the same column as a number, so its right edge
+    // meets the gap instead of sitting halfway into it.
+    val bulletX = x + (depth * marginLeft + ancestorMarkerOffset + markerColumnWidth - radius) * dir
+    val bulletY = baseline + (markerFontMetrics.ascent + markerFontMetrics.descent) / 2f
+
+    when (depth) {
+      0 -> {
+        canvas.drawCircle(bulletX, bulletY, radius, bulletPaint)
+      }
+
+      1 -> {
+        bulletPaint.style = Paint.Style.STROKE
+        bulletPaint.strokeWidth = ringStrokeWidth
+        canvas.drawCircle(bulletX, bulletY, radius - ringStrokeWidth / 2f, bulletPaint)
+      }
+
+      else -> {
+        canvas.drawRect(
+          bulletX - radius,
+          bulletY - radius,
+          bulletX + radius,
+          bulletY + radius,
+          bulletPaint,
+        )
+      }
+    }
+  }
+}

package/android/src/main/java/com/renderrichtext/spoiler/SpoilerStubs.kt

@@ -0,0 +1,46 @@
+package com.renderrichtext.spoiler
+
+import android.graphics.Canvas
+import android.text.Spanned
+import android.view.View
+import com.renderrichtext.spans.SpoilerSpan
+
+enum class SpoilerOverlay {
+  NONE,
+  PARTICLES,
+  ;
+
+  companion object {
+    fun fromString(value: String?): SpoilerOverlay = NONE
+  }
+}
+
+class SpoilerOverlayDrawer {
+  fun draw(canvas: Canvas) {}
+
+  fun stop() {}
+
+  fun revealSpan(
+    span: SpoilerSpan,
+    onDone: () -> Unit,
+  ) {
+  }
+
+  companion object {
+    fun setupIfNeeded(
+      view: View,
+      text: CharSequence?,
+      current: SpoilerOverlayDrawer?,
+      overlay: SpoilerOverlay,
+    ): SpoilerOverlayDrawer? = null
+  }
+}
+
+interface SpoilerCapable {
+  val spoilerOverlayDrawer: SpoilerOverlayDrawer?
+}
+
+fun Spanned.isConcealedBySpoiler(
+  start: Int,
+  end: Int,
+): Boolean = false

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

@@ -0,0 +1,11 @@
+package com.renderrichtext.styles
+
+interface BaseBlockStyle {
+  val fontSize: Float
+  val fontFamily: String
+  val fontWeight: String
+  val color: Int
+  val marginTop: Float
+  val marginBottom: Float
+  val lineHeight: Float
+}

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

@@ -0,0 +1,83 @@
+package com.renderrichtext.styles
+
+import com.facebook.react.bridge.ReadableMap
+
+/** Per-admonition-type colors. [color] tints border/title/icon; [backgroundColor] null = transparent. */
+data class AdmonitionColors(
+  val color: Int,
+  val backgroundColor: Int?,
+)
+
+data class BlockquoteStyle(
+  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 borderColor: Int,
+  val borderWidth: Float,
+  val gapWidth: Float,
+  val backgroundColor: Int?,
+  val borderRadius: Float,
+  val padding: Float,
+  val admonitions: Map<String, AdmonitionColors>,
+) : BaseBlockStyle {
+  companion object {
+    private fun parseAdmonitions(
+      map: ReadableMap,
+      parser: StyleParser,
+    ): Map<String, AdmonitionColors> {
+      val admonitionsMap = map.getMap("admonitions") ?: return emptyMap()
+      val result = mutableMapOf<String, AdmonitionColors>()
+      for (type in listOf("note", "tip", "important", "warning", "caution")) {
+        val typeMap = admonitionsMap.getMap(type) ?: continue
+        result[type] =
+          AdmonitionColors(
+            parser.parseColor(typeMap, "color"),
+            parser.parseOptionalColor(typeMap, "backgroundColor"),
+          )
+      }
+      return result
+    }
+
+    fun fromReadableMap(
+      map: ReadableMap,
+      parser: StyleParser,
+    ): BlockquoteStyle {
+      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 borderColor = parser.parseColor(map, "borderColor")
+      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())
+      val admonitions = parseAdmonitions(map, parser)
+
+      return BlockquoteStyle(
+        fontSize,
+        fontFamily,
+        fontWeight,
+        color,
+        marginTop,
+        marginBottom,
+        lineHeight,
+        borderColor,
+        borderWidth,
+        gapWidth,
+        backgroundColor,
+        borderRadius,
+        padding,
+        admonitions,
+      )
+    }
+  }
+}

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

@@ -0,0 +1,80 @@
+package com.renderrichtext.styles
+
+import com.facebook.react.bridge.ReadableMap
+
+data class CodeBlockStyle(
+  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 backgroundColor: Int,
+  val borderColor: Int,
+  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,
+    ): CodeBlockStyle {
+      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 backgroundColor = parser.parseColor(map, "backgroundColor")
+      val borderColor = parser.parseColor(map, "borderColor")
+      val borderRadius = parser.toPixelFromDIP(map.getDouble("borderRadius").toFloat())
+      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,
+        fontWeight,
+        color,
+        marginTop,
+        marginBottom,
+        lineHeight,
+        backgroundColor,
+        borderColor,
+        borderRadius,
+        borderWidth,
+        padding,
+        syntaxColors,
+      )
+    }
+  }
+}

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

@@ -0,0 +1,26 @@
+package com.renderrichtext.styles
+
+import com.facebook.react.bridge.ReadableMap
+
+data class CodeStyle(
+  val fontFamily: String,
+  val fontSize: Float,
+  val color: Int,
+  val backgroundColor: Int,
+  val borderColor: Int,
+) {
+  companion object {
+    fun fromReadableMap(
+      map: ReadableMap,
+      parser: StyleParser,
+    ): CodeStyle {
+      val fontFamily = parser.parseString(map, "fontFamily")
+      val fontSizeRaw = parser.parseOptionalDouble(map, "fontSize").toFloat()
+      val fontSize = if (fontSizeRaw > 0) parser.toPixelFromSP(fontSizeRaw) else 0f
+      val color = parser.parseColor(map, "color")
+      val backgroundColor = parser.parseColor(map, "backgroundColor")
+      val borderColor = parser.parseColor(map, "borderColor")
+      return CodeStyle(fontFamily, fontSize, color, backgroundColor, borderColor)
+    }
+  }
+}

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

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

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

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

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

@@ -0,0 +1,33 @@
+package com.renderrichtext.styles
+
+import com.facebook.react.bridge.ReadableMap
+
+data class HeadingStyle(
+  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,
+    ): HeadingStyle {
+      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 HeadingStyle(fontSize, fontFamily, fontWeight, color, marginTop, marginBottom, lineHeight, textAlign)
+    }
+  }
+}

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

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

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

@@ -0,0 +1,29 @@
+package com.renderrichtext.styles
+
+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,
+) {
+  companion object {
+    fun fromReadableMap(
+      map: ReadableMap,
+      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, maxHeight, aspectRatio, resizeMode, borderRadius, marginTop, marginBottom)
+    }
+  }
+}

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

@@ -0,0 +1,17 @@
+package com.renderrichtext.styles
+
+import com.facebook.react.bridge.ReadableMap
+
+data class InlineImageStyle(
+  val size: Float,
+) {
+  companion object {
+    fun fromReadableMap(
+      map: ReadableMap,
+      parser: StyleParser,
+    ): InlineImageStyle {
+      val size = parser.toPixelFromDIP(map.getDouble("size").toFloat())
+      return InlineImageStyle(size)
+    }
+  }
+}

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

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

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

@@ -0,0 +1,36 @@
+package com.renderrichtext.styles
+
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+
+/**
+ * What a pill shows: the variant's default, or one specific link's override keyed by
+ * exact URL in the `linkPillContent` prop. Empty strings mean "not set".
+ */
+data class LinkPillContent(
+  val label: String = "",
+  val iconUri: String = "",
+  /** Tint for this link's icon; null means none was set for the link. */
+  val iconTintColor: Int? = null,
+) {
+  /**
+   * Label and icon unset here take their value from [fallback]. The tint is left alone:
+   * a variant's tint is for the variant's own icon, so the span decides when it applies.
+   */
+  fun orElse(fallback: LinkPillContent) =
+    copy(
+      label = label.ifEmpty { fallback.label },
+      iconUri = iconUri.ifEmpty { fallback.iconUri },
+    )
+
+  companion object {
+    fun fromReadableMap(map: ReadableMap): LinkPillContent {
+      val hasTint = map.hasKey("iconTintColor") && map.getType("iconTintColor") == ReadableType.Number
+      return LinkPillContent(
+        label = map.getString("label") ?: "",
+        iconUri = map.getString("iconUri") ?: "",
+        iconTintColor = if (hasTint) map.getDouble("iconTintColor").toInt() else null,
+      )
+    }
+  }
+}

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

@@ -0,0 +1,44 @@
+package com.renderrichtext.styles
+
+import android.graphics.Color
+import android.graphics.ColorFilter
+import android.graphics.PorterDuff
+import android.graphics.PorterDuffColorFilter
+import com.facebook.react.bridge.ReadableMap
+
+/** Geometry and default content of a variant's pill. Dimensions are in pixels. */
+data class LinkPillStyle(
+  val content: LinkPillContent = LinkPillContent(),
+  val borderRadius: Float = 8f,
+  val paddingHorizontal: Float = 6f,
+  val paddingVertical: Float = 2f,
+  /** Minimum line height of a block that holds the pill; 0 when unset. */
+  val lineHeight: Float = 0f,
+  val borderWidth: Float = 0f,
+  val borderColor: Int = Color.TRANSPARENT,
+  val maxWidth: Float = 0f,
+) {
+  /** Replaces the icon's colors and keeps its alpha; shared by every pill of the variant. */
+  val iconTint: ColorFilter? = content.iconTintColor?.let { PorterDuffColorFilter(it, PorterDuff.Mode.SRC_IN) }
+
+  companion object {
+    /** Returns null when the variant does not enable pill presentation. */
+    fun fromReadableMap(
+      map: ReadableMap,
+      parser: StyleParser,
+    ): LinkPillStyle? {
+      if (!parser.parseBoolean(map, "enabled")) return null
+      return LinkPillStyle(
+        content =
+          LinkPillContent.fromReadableMap(map).copy(iconTintColor = parser.parseOptionalColor(map, "iconTintColor")),
+        borderRadius = parser.toPixelFromDIP(parser.parseOptionalDouble(map, "borderRadius", 8.0).toFloat()),
+        paddingHorizontal = parser.toPixelFromDIP(parser.parseOptionalDouble(map, "paddingHorizontal", 6.0).toFloat()),
+        paddingVertical = parser.toPixelFromDIP(parser.parseOptionalDouble(map, "paddingVertical", 2.0).toFloat()),
+        lineHeight = parser.toPixelFromSP(parser.parseOptionalDouble(map, "lineHeight").toFloat()),
+        borderWidth = parser.toPixelFromDIP(parser.parseOptionalDouble(map, "borderWidth").toFloat()),
+        borderColor = parser.parseOptionalColor(map, "borderColor") ?: Color.TRANSPARENT,
+        maxWidth = parser.toPixelFromDIP(parser.parseOptionalDouble(map, "maxWidth").toFloat()),
+      )
+    }
+  }
+}

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

@@ -0,0 +1,23 @@
+package com.renderrichtext.styles
+
+import com.facebook.react.bridge.ReadableMap
+
+data class LinkStyle(
+  val fontFamily: String,
+  val color: Int,
+  val underline: Boolean,
+  val backgroundColor: Int,
+) {
+  companion object {
+    fun fromReadableMap(
+      map: ReadableMap,
+      parser: StyleParser,
+    ): LinkStyle {
+      val fontFamily = parser.parseString(map, "fontFamily")
+      val color = parser.parseColor(map, "color")
+      val underline = map.getBoolean("underline")
+      val backgroundColor = parser.parseColor(map, "backgroundColor")
+      return LinkStyle(fontFamily, color, underline, backgroundColor)
+    }
+  }
+}