@mathers101/react-native-render-rich-text 0.1.9 → 0.1.14

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

@@ -1,216 +1,216 @@
-package com.renderrichtext.spans
-
-import android.content.Context
-import android.graphics.Canvas
-import android.graphics.Paint
-import android.graphics.Path
-import android.graphics.RectF
-import android.text.Layout
-import android.text.Spanned
-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.renderrichtext.renderer.SpanStyleCache
-import com.renderrichtext.styles.CodeBlockStyle
-import com.renderrichtext.utils.text.extensions.applyCodeBlockTextStyle
-import com.renderrichtext.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,
-  // Recovered by a tap on this span for onCodeBlockPress; unused by drawing.
-  val code: String = "",
-  val language: String = "",
-) : MetricAffectingSpan(),
-  LineBackgroundSpan,
-  LeadingMarginSpan {
-  private val path = Path()
-  private val rect = RectF()
-  private val arcRect = RectF()
-  private val radiiArray = FloatArray(8)
-
-  companion object {
-    private val sharedBackgroundPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { style = Paint.Style.FILL }
-    private val sharedBorderPaint =
-      Paint(Paint.ANTI_ALIAS_FLAG).apply {
-        style = Paint.Style.STROKE
-        strokeCap = Paint.Cap.BUTT
-        strokeJoin = Paint.Join.ROUND
-      }
-  }
-
-  private fun configureBackgroundPaint(): Paint =
-    sharedBackgroundPaint.apply {
-      color = codeBlockStyle.backgroundColor
-    }
-
-  private fun configureBorderPaint(): Paint =
-    sharedBorderPaint.apply {
-      strokeWidth = codeBlockStyle.borderWidth
-      color = codeBlockStyle.borderColor
-    }
-
-  override fun getLeadingMargin(first: Boolean): Int = codeBlockStyle.padding.toInt() + leadingIndent
-
-  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?,
-  ) { /* Leading margin is handled by getLeadingMargin */ }
-
-  override fun updateMeasureState(tp: TextPaint) = applyTextStyle(tp)
-
-  override fun updateDrawState(tp: TextPaint) = applyTextStyle(tp)
-
-  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 (text !is Spanned) return
-
-    val spanStart = text.getSpanStart(this)
-    val spanEnd = text.getSpanEnd(this)
-    if (spanStart !in 0 until spanEnd) return
-
-    val isFirstLine = start == spanStart
-    val isLastLine = isLastDrawnLine(text, end, spanEnd)
-
-    val inset = codeBlockStyle.borderWidth / 2f
-
-    rect.set(
-      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
-
-    // Reset and fill radii array based on boundary state
-    radiiArray.fill(0f)
-    if (isFirstLine) {
-      radiiArray[0] = adjRadius
-      radiiArray[1] = adjRadius // Top-Left
-      radiiArray[2] = adjRadius
-      radiiArray[3] = adjRadius // Top-Right
-    }
-    if (isLastLine) {
-      radiiArray[4] = adjRadius
-      radiiArray[5] = adjRadius // Bottom-Right
-      radiiArray[6] = adjRadius
-      radiiArray[7] = adjRadius // Bottom-Left
-    }
-
-    path.reset()
-    path.addRoundRect(rect, radiiArray, Path.Direction.CW)
-
-    val backgroundPaint = configureBackgroundPaint()
-    val borderPaint = configureBorderPaint()
-
-    canvas.withSave {
-      drawPath(path, backgroundPaint)
-
-      if (codeBlockStyle.borderWidth > 0) {
-        val bLeft = rect.left
-        val bRight = rect.right
-        val bTop = rect.top
-        val bBottom = rect.bottom
-
-        when {
-          // Case: Single-line code block
-          isFirstLine && isLastLine -> {
-            drawPath(path, borderPaint)
-          }
-
-          // Case: Top of a multi-line block
-          isFirstLine -> {
-            drawLine(bLeft + adjRadius, bTop, bRight - adjRadius, bTop, borderPaint)
-            drawLine(bLeft, bTop + adjRadius, bLeft, bBottom, borderPaint)
-            drawLine(bRight, bTop + adjRadius, bRight, bBottom, borderPaint)
-
-            arcRect.set(bLeft, bTop, bLeft + 2 * adjRadius, bTop + 2 * adjRadius)
-            drawArc(arcRect, 180f, 90f, false, borderPaint)
-
-            arcRect.set(bRight - 2 * adjRadius, bTop, bRight, bTop + 2 * adjRadius)
-            drawArc(arcRect, 270f, 90f, false, borderPaint)
-          }
-
-          // Case: Bottom of a multi-line block
-          isLastLine -> {
-            drawLine(bLeft + adjRadius, bBottom, bRight - adjRadius, bBottom, borderPaint)
-            drawLine(bLeft, bTop, bLeft, bBottom - adjRadius, borderPaint)
-            drawLine(bRight, bTop, bRight, bBottom - adjRadius, borderPaint)
-
-            arcRect.set(bLeft, bBottom - 2 * adjRadius, bLeft + 2 * adjRadius, bBottom)
-            drawArc(arcRect, 90f, 90f, false, borderPaint)
-
-            arcRect.set(bRight - 2 * adjRadius, bBottom - 2 * adjRadius, bRight, bBottom)
-            drawArc(arcRect, 0f, 90f, false, borderPaint)
-          }
-
-          // Case: Middle lines only need vertical sides
-          else -> {
-            drawLine(bLeft, bTop, bLeft, bBottom, borderPaint)
-            drawLine(bRight, bTop, bRight, bBottom, borderPaint)
-          }
-        }
-      }
-    }
-  }
-
-  private fun applyTextStyle(tp: TextPaint) {
-    tp.applyCodeBlockTextStyle(codeBlockStyle, context)
-
-    tp.applyColorPreserving(codeBlockStyle.color, *styleCache.colorsToPreserve)
-  }
-}
-
-/**
- * True when [lineEnd] is the last drawn line of a span ending at [spanEnd].
- *
- * The span range can include a trailing '\n' that belongs to the last content
- * line rather than forming a line of its own, and the margin newline after the
- * span can push the line end past getSpanEnd. Compare against the end of the
- * visible content, same as [BlockquoteSpan]'s last-line check.
- */
-internal fun isLastDrawnLine(
-  text: CharSequence,
-  lineEnd: Int,
-  spanEnd: Int,
-): Boolean {
-  var visibleEnd = spanEnd.coerceAtMost(text.length)
-  while (visibleEnd > 0 && text[visibleEnd - 1] == '\n') {
-    visibleEnd--
-  }
-  return lineEnd >= visibleEnd
-}
+package com.renderrichtext.spans
+
+import android.content.Context
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.graphics.Path
+import android.graphics.RectF
+import android.text.Layout
+import android.text.Spanned
+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.renderrichtext.renderer.SpanStyleCache
+import com.renderrichtext.styles.CodeBlockStyle
+import com.renderrichtext.utils.text.extensions.applyCodeBlockTextStyle
+import com.renderrichtext.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,
+  // Recovered by a tap on this span for onCodeBlockPress; unused by drawing.
+  val code: String = "",
+  val language: String = "",
+) : MetricAffectingSpan(),
+  LineBackgroundSpan,
+  LeadingMarginSpan {
+  private val path = Path()
+  private val rect = RectF()
+  private val arcRect = RectF()
+  private val radiiArray = FloatArray(8)
+
+  companion object {
+    private val sharedBackgroundPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { style = Paint.Style.FILL }
+    private val sharedBorderPaint =
+      Paint(Paint.ANTI_ALIAS_FLAG).apply {
+        style = Paint.Style.STROKE
+        strokeCap = Paint.Cap.BUTT
+        strokeJoin = Paint.Join.ROUND
+      }
+  }
+
+  private fun configureBackgroundPaint(): Paint =
+    sharedBackgroundPaint.apply {
+      color = codeBlockStyle.backgroundColor
+    }
+
+  private fun configureBorderPaint(): Paint =
+    sharedBorderPaint.apply {
+      strokeWidth = codeBlockStyle.borderWidth
+      color = codeBlockStyle.borderColor
+    }
+
+  override fun getLeadingMargin(first: Boolean): Int = codeBlockStyle.padding.toInt() + leadingIndent
+
+  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?,
+  ) { /* Leading margin is handled by getLeadingMargin */ }
+
+  override fun updateMeasureState(tp: TextPaint) = applyTextStyle(tp)
+
+  override fun updateDrawState(tp: TextPaint) = applyTextStyle(tp)
+
+  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 (text !is Spanned) return
+
+    val spanStart = text.getSpanStart(this)
+    val spanEnd = text.getSpanEnd(this)
+    if (spanStart !in 0 until spanEnd) return
+
+    val isFirstLine = start == spanStart
+    val isLastLine = isLastDrawnLine(text, end, spanEnd)
+
+    val inset = codeBlockStyle.borderWidth / 2f
+
+    rect.set(
+      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
+
+    // Reset and fill radii array based on boundary state
+    radiiArray.fill(0f)
+    if (isFirstLine) {
+      radiiArray[0] = adjRadius
+      radiiArray[1] = adjRadius // Top-Left
+      radiiArray[2] = adjRadius
+      radiiArray[3] = adjRadius // Top-Right
+    }
+    if (isLastLine) {
+      radiiArray[4] = adjRadius
+      radiiArray[5] = adjRadius // Bottom-Right
+      radiiArray[6] = adjRadius
+      radiiArray[7] = adjRadius // Bottom-Left
+    }
+
+    path.reset()
+    path.addRoundRect(rect, radiiArray, Path.Direction.CW)
+
+    val backgroundPaint = configureBackgroundPaint()
+    val borderPaint = configureBorderPaint()
+
+    canvas.withSave {
+      drawPath(path, backgroundPaint)
+
+      if (codeBlockStyle.borderWidth > 0) {
+        val bLeft = rect.left
+        val bRight = rect.right
+        val bTop = rect.top
+        val bBottom = rect.bottom
+
+        when {
+          // Case: Single-line code block
+          isFirstLine && isLastLine -> {
+            drawPath(path, borderPaint)
+          }
+
+          // Case: Top of a multi-line block
+          isFirstLine -> {
+            drawLine(bLeft + adjRadius, bTop, bRight - adjRadius, bTop, borderPaint)
+            drawLine(bLeft, bTop + adjRadius, bLeft, bBottom, borderPaint)
+            drawLine(bRight, bTop + adjRadius, bRight, bBottom, borderPaint)
+
+            arcRect.set(bLeft, bTop, bLeft + 2 * adjRadius, bTop + 2 * adjRadius)
+            drawArc(arcRect, 180f, 90f, false, borderPaint)
+
+            arcRect.set(bRight - 2 * adjRadius, bTop, bRight, bTop + 2 * adjRadius)
+            drawArc(arcRect, 270f, 90f, false, borderPaint)
+          }
+
+          // Case: Bottom of a multi-line block
+          isLastLine -> {
+            drawLine(bLeft + adjRadius, bBottom, bRight - adjRadius, bBottom, borderPaint)
+            drawLine(bLeft, bTop, bLeft, bBottom - adjRadius, borderPaint)
+            drawLine(bRight, bTop, bRight, bBottom - adjRadius, borderPaint)
+
+            arcRect.set(bLeft, bBottom - 2 * adjRadius, bLeft + 2 * adjRadius, bBottom)
+            drawArc(arcRect, 90f, 90f, false, borderPaint)
+
+            arcRect.set(bRight - 2 * adjRadius, bBottom - 2 * adjRadius, bRight, bBottom)
+            drawArc(arcRect, 0f, 90f, false, borderPaint)
+          }
+
+          // Case: Middle lines only need vertical sides
+          else -> {
+            drawLine(bLeft, bTop, bLeft, bBottom, borderPaint)
+            drawLine(bRight, bTop, bRight, bBottom, borderPaint)
+          }
+        }
+      }
+    }
+  }
+
+  private fun applyTextStyle(tp: TextPaint) {
+    tp.applyCodeBlockTextStyle(codeBlockStyle, context)
+
+    tp.applyColorPreserving(codeBlockStyle.color, *styleCache.colorsToPreserve)
+  }
+}
+
+/**
+ * True when [lineEnd] is the last drawn line of a span ending at [spanEnd].
+ *
+ * The span range can include a trailing '\n' that belongs to the last content
+ * line rather than forming a line of its own, and the margin newline after the
+ * span can push the line end past getSpanEnd. Compare against the end of the
+ * visible content, same as [BlockquoteSpan]'s last-line check.
+ */
+internal fun isLastDrawnLine(
+  text: CharSequence,
+  lineEnd: Int,
+  spanEnd: Int,
+): Boolean {
+  var visibleEnd = spanEnd.coerceAtMost(text.length)
+  while (visibleEnd > 0 && text[visibleEnd - 1] == '\n') {
+    visibleEnd--
+  }
+  return lineEnd >= visibleEnd
+}

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

@@ -1,32 +1,32 @@
-package com.renderrichtext.spans
-
-import android.graphics.Typeface
-import android.text.TextPaint
-import android.text.style.MetricAffectingSpan
-import com.renderrichtext.renderer.BlockStyle
-import com.renderrichtext.renderer.SpanStyleCache
-
-class CodeSpan(
-  private val styleCache: SpanStyleCache,
-  private val blockStyle: BlockStyle,
-) : MetricAffectingSpan() {
-  override fun updateDrawState(tp: TextPaint) {
-    applyMonospacedFont(tp)
-    tp.color = styleCache.codeColor
-  }
-
-  override fun updateMeasureState(tp: TextPaint) {
-    applyMonospacedFont(tp)
-  }
-
-  private fun applyMonospacedFont(paint: TextPaint) {
-    paint.textSize = if (styleCache.codeFontSize > 0) styleCache.codeFontSize else blockStyle.fontSize
-    val preservedStyle = (paint.typeface?.style ?: 0) and (Typeface.BOLD or Typeface.ITALIC)
-    paint.typeface =
-      if (styleCache.codeFontFamily.isNotEmpty()) {
-        styleCache.getTypeface(styleCache.codeFontFamily, preservedStyle)
-      } else {
-        SpanStyleCache.getMonospaceTypeface(preservedStyle)
-      }
-  }
-}
+package com.renderrichtext.spans
+
+import android.graphics.Typeface
+import android.text.TextPaint
+import android.text.style.MetricAffectingSpan
+import com.renderrichtext.renderer.BlockStyle
+import com.renderrichtext.renderer.SpanStyleCache
+
+class CodeSpan(
+  private val styleCache: SpanStyleCache,
+  private val blockStyle: BlockStyle,
+) : MetricAffectingSpan() {
+  override fun updateDrawState(tp: TextPaint) {
+    applyMonospacedFont(tp)
+    tp.color = styleCache.codeColor
+  }
+
+  override fun updateMeasureState(tp: TextPaint) {
+    applyMonospacedFont(tp)
+  }
+
+  private fun applyMonospacedFont(paint: TextPaint) {
+    paint.textSize = if (styleCache.codeFontSize > 0) styleCache.codeFontSize else blockStyle.fontSize
+    val preservedStyle = (paint.typeface?.style ?: 0) and (Typeface.BOLD or Typeface.ITALIC)
+    paint.typeface =
+      if (styleCache.codeFontFamily.isNotEmpty()) {
+        styleCache.getTypeface(styleCache.codeFontFamily, preservedStyle)
+      } else {
+        SpanStyleCache.getMonospaceTypeface(preservedStyle)
+      }
+  }
+}

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

@@ -1,42 +1,42 @@
-package com.renderrichtext.spans
-
-import android.graphics.Typeface
-import android.text.TextPaint
-import android.text.style.MetricAffectingSpan
-import com.renderrichtext.renderer.BlockStyle
-import com.renderrichtext.renderer.SpanStyleCache
-import com.renderrichtext.utils.text.extensions.applyColorPreserving
-
-class EmphasisSpan(
-  private val styleCache: SpanStyleCache,
-  private val blockStyle: BlockStyle,
-) : MetricAffectingSpan() {
-  override fun updateDrawState(tp: TextPaint) {
-    applyEmphasisStyle(tp)
-    applyEmphasisColor(tp)
-  }
-
-  override fun updateMeasureState(tp: TextPaint) {
-    applyEmphasisStyle(tp)
-  }
-
-  private fun applyEmphasisStyle(tp: TextPaint) {
-    val currentTypeface = tp.typeface ?: Typeface.DEFAULT
-    val isBold = (currentTypeface.style) and Typeface.BOLD != 0
-    val style = if (isBold) Typeface.BOLD_ITALIC else Typeface.ITALIC
-    tp.typeface =
-      if (styleCache.emphasisFontFamily.isNotEmpty()) {
-        val resolvedStyle = if (styleCache.emphasisFontStyle == "normal") Typeface.NORMAL else style
-        styleCache.getTypeface(styleCache.emphasisFontFamily, resolvedStyle)
-      } else if (styleCache.emphasisFontStyle == "normal") {
-        currentTypeface
-      } else {
-        Typeface.create(currentTypeface, style)
-      }
-  }
-
-  private fun applyEmphasisColor(tp: TextPaint) {
-    val colorToUse = styleCache.getEmphasisColorFor(blockStyle.color, tp.color)
-    tp.applyColorPreserving(colorToUse, *styleCache.colorsToPreserve)
-  }
-}
+package com.renderrichtext.spans
+
+import android.graphics.Typeface
+import android.text.TextPaint
+import android.text.style.MetricAffectingSpan
+import com.renderrichtext.renderer.BlockStyle
+import com.renderrichtext.renderer.SpanStyleCache
+import com.renderrichtext.utils.text.extensions.applyColorPreserving
+
+class EmphasisSpan(
+  private val styleCache: SpanStyleCache,
+  private val blockStyle: BlockStyle,
+) : MetricAffectingSpan() {
+  override fun updateDrawState(tp: TextPaint) {
+    applyEmphasisStyle(tp)
+    applyEmphasisColor(tp)
+  }
+
+  override fun updateMeasureState(tp: TextPaint) {
+    applyEmphasisStyle(tp)
+  }
+
+  private fun applyEmphasisStyle(tp: TextPaint) {
+    val currentTypeface = tp.typeface ?: Typeface.DEFAULT
+    val isBold = (currentTypeface.style) and Typeface.BOLD != 0
+    val style = if (isBold) Typeface.BOLD_ITALIC else Typeface.ITALIC
+    tp.typeface =
+      if (styleCache.emphasisFontFamily.isNotEmpty()) {
+        val resolvedStyle = if (styleCache.emphasisFontStyle == "normal") Typeface.NORMAL else style
+        styleCache.getTypeface(styleCache.emphasisFontFamily, resolvedStyle)
+      } else if (styleCache.emphasisFontStyle == "normal") {
+        currentTypeface
+      } else {
+        Typeface.create(currentTypeface, style)
+      }
+  }
+
+  private fun applyEmphasisColor(tp: TextPaint) {
+    val colorToUse = styleCache.getEmphasisColorFor(blockStyle.color, tp.color)
+    tp.applyColorPreserving(colorToUse, *styleCache.colorsToPreserve)
+  }
+}

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

@@ -1,29 +1,29 @@
-package com.renderrichtext.spans
-
-import android.os.Build
-import android.text.TextPaint
-import android.text.style.CharacterStyle
-import androidx.annotation.FloatRange
-
-class FadeInSpan : CharacterStyle() {
-  @setparam:FloatRange(from = 0.0, to = 1.0)
-  var alpha: Float = 0f
-
-  override fun updateDrawState(tp: TextPaint) {
-    tp.color = multiplyAlpha(tp.color, alpha)
-    // Public from API 29; below that, underlines are drawn in `color`, which is already faded.
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-      tp.underlineColor = multiplyAlpha(tp.underlineColor, alpha)
-    }
-  }
-
-  private fun multiplyAlpha(
-    color: Int,
-    alpha: Float,
-  ): Int {
-    if (alpha >= 1f) return color
-    if (alpha <= 0f) return color and 0x00FFFFFF
-    val a = ((color ushr 24) * alpha).toInt()
-    return (a shl 24) or (color and 0x00FFFFFF)
-  }
-}
+package com.renderrichtext.spans
+
+import android.os.Build
+import android.text.TextPaint
+import android.text.style.CharacterStyle
+import androidx.annotation.FloatRange
+
+class FadeInSpan : CharacterStyle() {
+  @setparam:FloatRange(from = 0.0, to = 1.0)
+  var alpha: Float = 0f
+
+  override fun updateDrawState(tp: TextPaint) {
+    tp.color = multiplyAlpha(tp.color, alpha)
+    // Public from API 29; below that, underlines are drawn in `color`, which is already faded.
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+      tp.underlineColor = multiplyAlpha(tp.underlineColor, alpha)
+    }
+  }
+
+  private fun multiplyAlpha(
+    color: Int,
+    alpha: Float,
+  ): Int {
+    if (alpha >= 1f) return color
+    if (alpha <= 0f) return color and 0x00FFFFFF
+    val a = ((color ushr 24) * alpha).toInt()
+    return (a shl 24) or (color and 0x00FFFFFF)
+  }
+}