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

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 {

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

@@ -7,6 +7,7 @@ import android.graphics.Color
 import android.graphics.Paint
 import android.graphics.Path
 import android.graphics.drawable.Drawable
+import android.net.Uri
 import android.os.Build
 import android.text.Spannable
 import android.text.Spanned
@@ -17,9 +18,12 @@ import androidx.core.graphics.createBitmap
 import androidx.core.graphics.drawable.toDrawable
 import androidx.core.graphics.withClip
 import androidx.core.graphics.withSave
+import com.swmansion.enriched.markdown.EnrichedMarkdown
+import com.swmansion.enriched.markdown.EnrichedMarkdownText
 import com.swmansion.enriched.markdown.styles.StyleConfig
 import com.swmansion.enriched.markdown.utils.text.ImageCache
 import com.swmansion.enriched.markdown.utils.text.ImageDownloader
+import com.swmansion.enriched.markdown.utils.text.LocalImageLoader
 import java.lang.ref.WeakReference
 import java.util.concurrent.Executors
 import android.text.style.ImageSpan as AndroidImageSpan
@@ -39,36 +43,84 @@ class ImageSpan(
   AndroidLineHeightSpan {
   private var loadedDrawable: Drawable? = null
   private val height: Int = if (isInline) styleConfig.inlineImageStyle.size.toInt() else styleConfig.imageStyle.height.toInt()
-  private val borderRadiusPx: Int = (styleConfig.imageStyle.borderRadius * context.resources.displayMetrics.density).toInt()
+
+  private val borderRadiusPx: Int = styleConfig.imageStyle.borderRadius.toInt()
+  private val maxHeightPx: Int = if (isInline) 0 else styleConfig.imageStyle.maxHeight.toInt()
+  private val aspectRatio: Float = if (isInline) 0f else styleConfig.imageStyle.aspectRatio
+  private val resizeMode: String = if (isInline) "" else styleConfig.imageStyle.resizeMode
+
+  // so legacy always implies a fixed height box.
+  private val legacySizing: Boolean = resizeMode.isEmpty()
+
+  private val dynamicBoxHeight: Boolean = !isInline && (maxHeightPx > 0 || aspectRatio > 0f)
+
+  private var boxHeight: Int =
+    when {
+      isInline -> height
+      maxHeightPx > 0 -> maxHeightPx
+      else -> height
+    }
+
+  private val requestHeaders: Map<String, String> = styleConfig.imageRequestHeaders
+  private val requestKey: String = ImageCache.requestKey(imageUrl, requestHeaders)
 
   private var cachedWidth: Int = 0
   private var viewRef: WeakReference<TextView>? = null
   private var sourceDrawable: Drawable? = null
 
+  private fun intrinsicImageSize(): Pair<Int, Int> {
+    sourceDrawable?.let { return it.intrinsicWidth to it.intrinsicHeight }
+    val cached = ImageCache.getOriginal(imageUrl) ?: return 0 to 0
+    return cached.width to cached.height
+  }
+
+  // Sizing precedence: aspectRatio > maxHeight > height. Returns the legacy fixed
+  // height when no new knob is set.
+  private fun resolveBoxHeight(targetWidth: Int): Int {
+    if (isInline) return height
+    if (aspectRatio > 0f && targetWidth > 0) {
+      return (targetWidth / aspectRatio).toInt().coerceAtLeast(1)
+    }
+    if (maxHeightPx > 0) {
+      val (intrinsicWidth, intrinsicHeight) = intrinsicImageSize()
+      if (targetWidth > 0 && intrinsicWidth > 0 && intrinsicHeight > 0) {
+        val fitted = targetWidth.toFloat() * intrinsicHeight / intrinsicWidth
+        return minOf(maxHeightPx.toFloat(), fitted).toInt().coerceAtLeast(1)
+      }
+      return maxHeightPx
+    }
+    return height
+  }
+
+  fun prepareForMeasurement(
+    text: Spanned,
+    widthPx: Int,
+  ) {
+    if (!dynamicBoxHeight || widthPx <= 0) return
+    val available = availableWidthIn(text, widthPx)
+    if (available > 0) boxHeight = resolveBoxHeight(available)
+  }
+
   init {
     loadImage()
   }
 
   private fun loadImage() {
-    if (imageUrl.startsWith("http")) {
-      ImageDownloader.download(context, imageUrl) { bitmap ->
+    val scheme = Uri.parse(imageUrl).scheme?.lowercase()
+    if (scheme == "http" || scheme == "https") {
+      ImageDownloader.download(context, imageUrl, requestHeaders) { bitmap ->
         if (bitmap != null) {
           sourceDrawable = bitmap.toDrawable(context.resources)
           wrapAndAssignDrawable()
         }
       }
     } else {
-      val path = imageUrl.removePrefix("file://")
-      try {
-        val cached = ImageCache.getOriginal(imageUrl)
-        val bitmap = cached ?: ImageDownloader.decodeFileDownsampled(context, path)
-        if (bitmap != null) {
-          if (cached == null) ImageCache.putOriginal(imageUrl, bitmap)
-          sourceDrawable = bitmap.toDrawable(context.resources)
-          wrapAndAssignDrawable()
-        }
-      } catch (e: Exception) {
-        Log.w(TAG, "Failed to load local image: $path", e)
+      val cached = ImageCache.getOriginal(imageUrl)
+      val bitmap = cached ?: LocalImageLoader.load(context, imageUrl)
+      if (bitmap != null) {
+        if (cached == null) ImageCache.putOriginal(imageUrl, bitmap)
+        sourceDrawable = bitmap.toDrawable(context.resources)
+        wrapAndAssignDrawable()
       }
     }
   }
@@ -83,21 +135,26 @@ class ImageSpan(
         available.coerceAtLeast(0)
       }
 
-    val cachedBitmap = ImageCache.getProcessed(imageUrl, targetWidth, height, borderRadiusPx)
+    boxHeight = resolveBoxHeight(targetWidth)
+
+    val cachedBitmap = ImageCache.getProcessed(requestKey, targetWidth, boxHeight, borderRadiusPx, resizeMode)
+
     if (cachedBitmap != null) {
       loadedDrawable =
         cachedBitmap.toDrawable(context.resources).apply {
-          setBounds(0, 0, targetWidth, height)
+          setBounds(0, 0, targetWidth, boxHeight)
         }
     } else {
       loadedDrawable =
         ScaledImageDrawable(
           imageDrawable = base,
           targetWidth = targetWidth,
-          targetHeight = height,
+          targetHeight = boxHeight,
           borderRadius = borderRadiusPx,
           isBlockImage = !isInline,
-          cacheKey = CacheKey(imageUrl, targetWidth, height, borderRadiusPx),
+          resizeMode = resizeMode,
+          legacySizing = legacySizing,
+          cacheKey = CacheKey(requestKey, targetWidth, boxHeight, borderRadiusPx, resizeMode),
         )
     }
     requestReflow()
@@ -116,6 +173,22 @@ class ImageSpan(
       view.invalidate()
       view.requestLayout()
     }
+    notifyBoxHeightMayHaveChanged(view)
+  }
+
+  // With maxHeight/aspectRatio the box height can change after the image loads
+  // (maxHeight fitted, aspectRatio at a late width). The React container height
+  // was measured with the pre-load value, so ask the owning component to
+  // re-measure; it only propagates when the stored height actually changed.
+  private fun notifyBoxHeightMayHaveChanged(view: TextView) {
+    if (!dynamicBoxHeight) return
+    if (view is EnrichedMarkdownText) {
+      view.layoutManager.invalidateLayout()
+      return
+    }
+    var parent = view.parent
+    while (parent != null && parent !is EnrichedMarkdown) parent = parent.parent
+    parent?.onImageLayoutChanged()
   }
 
   fun registerTextView(view: TextView) {
@@ -137,12 +210,27 @@ class ImageSpan(
     cachedWidth = newWidth
     if (sourceDrawable != null) {
       wrapAndAssignDrawable()
+      return
+    }
+    if (dynamicBoxHeight) {
+      val newBoxHeight = resolveBoxHeight(newWidth)
+      if (newBoxHeight != boxHeight) {
+        boxHeight = newBoxHeight
+        requestReflow()
+      }
     }
   }
 
   private fun getAvailableWidth(view: TextView): Int {
     val baseWidth = (view.layout?.width ?: view.width).coerceAtLeast(0)
     val text = view.text as? Spanned ?: return baseWidth
+    return availableWidthIn(text, baseWidth)
+  }
+
+  private fun availableWidthIn(
+    text: Spanned,
+    baseWidth: Int,
+  ): Int {
     val start = text.getSpanStart(this).takeIf { it >= 0 } ?: return baseWidth
     val end = text.getSpanEnd(this).coerceAtLeast(start)
     // Subtract leading margins (list bullet/indent, blockquote bar) that consume
@@ -159,7 +247,7 @@ class ImageSpan(
     val drawable = loadedDrawable ?: transparentDrawable
     if (drawable !is ScaledImageDrawable) {
       val drawableWidth = if (isInline) height else cachedWidth.takeIf { it > 0 } ?: drawable.intrinsicWidth
-      drawable.setBounds(0, 0, drawableWidth.coerceAtLeast(0), height.coerceAtLeast(0))
+      drawable.setBounds(0, 0, drawableWidth.coerceAtLeast(0), boxHeight.coerceAtLeast(0))
     }
     return drawable
   }
@@ -182,8 +270,8 @@ class ImageSpan(
   ) {
     if (fm == null || isInline) return
     val currentLineHeight = fm.descent - fm.ascent
-    if (height > currentLineHeight) {
-      val extraHeight = height - currentLineHeight
+    if (boxHeight > currentLineHeight) {
+      val extraHeight = boxHeight - currentLineHeight
       fm.descent += extraHeight
       fm.bottom += extraHeight
     }
@@ -217,6 +305,7 @@ class ImageSpan(
     val width: Int,
     val height: Int,
     val borderRadius: Int,
+    val resizeMode: String,
   )
 
   private class ScaledImageDrawable(
@@ -225,6 +314,8 @@ class ImageSpan(
     private val targetHeight: Int,
     private val borderRadius: Int,
     isBlockImage: Boolean,
+    private val resizeMode: String = "",
+    private val legacySizing: Boolean = true,
     private val cacheKey: CacheKey? = null,
   ) : Drawable() {
     private val clipPath: Path?
@@ -235,14 +326,26 @@ class ImageSpan(
       val intrinsicWidth = imageDrawable.intrinsicWidth
       val intrinsicHeight = imageDrawable.intrinsicHeight
 
+      // New sizing needs a clip to the box so cropping
+      // modes don't spill over neighbouring lines.
+      val clipToBox = isBlockImage && !legacySizing
+
       val (scaledWidth, scaledHeight) =
         if (intrinsicWidth > 0 && intrinsicHeight > 0) {
-          if (isBlockImage) {
-            val scale = targetWidth.toFloat() / intrinsicWidth
-            targetWidth to (intrinsicHeight * scale).toInt()
-          } else {
-            val scale = minOf(targetWidth.toFloat() / intrinsicWidth, targetHeight.toFloat() / intrinsicHeight)
-            (intrinsicWidth * scale).toInt() to (intrinsicHeight * scale).toInt()
+          when {
+            !isBlockImage -> {
+              val scale = minOf(targetWidth.toFloat() / intrinsicWidth, targetHeight.toFloat() / intrinsicHeight)
+              (intrinsicWidth * scale).toInt() to (intrinsicHeight * scale).toInt()
+            }
+
+            legacySizing -> {
+              val scale = targetWidth.toFloat() / intrinsicWidth
+              targetWidth to (intrinsicHeight * scale).toInt()
+            }
+
+            else -> {
+              resizeModeSize(intrinsicWidth, intrinsicHeight)
+            }
           }
         } else {
           targetWidth to targetHeight
@@ -252,26 +355,53 @@ class ImageSpan(
       val top = (targetHeight - scaledHeight) / 2
       imageDrawable.setBounds(left, top, left + scaledWidth, top + scaledHeight)
 
+      val clipLeft = maxOf(0, left).toFloat()
+      val clipTop = maxOf(0, top).toFloat()
+      val clipRight = minOf(targetWidth, left + scaledWidth).toFloat()
+      val clipBottom = minOf(targetHeight, top + scaledHeight).toFloat()
       clipPath =
-        if (borderRadius > 0) {
-          val clipLeft = maxOf(0, left).toFloat()
-          val clipTop = maxOf(0, top).toFloat()
-          val clipRight = minOf(targetWidth, left + scaledWidth).toFloat()
-          val clipBottom = minOf(targetHeight, top + scaledHeight).toFloat()
-          Path().apply {
-            addRoundRect(
-              clipLeft,
-              clipTop,
-              clipRight,
-              clipBottom,
-              borderRadius.toFloat(),
-              borderRadius.toFloat(),
-              Path.Direction.CW,
-            )
+        when {
+          borderRadius > 0 -> {
+            Path().apply {
+              addRoundRect(
+                clipLeft,
+                clipTop,
+                clipRight,
+                clipBottom,
+                borderRadius.toFloat(),
+                borderRadius.toFloat(),
+                Path.Direction.CW,
+              )
+            }
           }
-        } else {
-          null
+
+          clipToBox -> {
+            Path().apply {
+              addRect(clipLeft, clipTop, clipRight, clipBottom, Path.Direction.CW)
+            }
+          }
+
+          else -> {
+            null
+          }
+        }
+    }
+
+    private fun resizeModeSize(
+      intrinsicWidth: Int,
+      intrinsicHeight: Int,
+    ): Pair<Int, Int> {
+      if (resizeMode == "stretch") return targetWidth to targetHeight
+      val widthScale = targetWidth.toFloat() / intrinsicWidth
+      val heightScale = targetHeight.toFloat() / intrinsicHeight
+      val scale =
+        when (resizeMode) {
+          "contain" -> minOf(widthScale, heightScale)
+          "center" -> minOf(1f, minOf(widthScale, heightScale))
+          "none" -> 1f
+          else -> maxOf(widthScale, heightScale) // cover (default)
         }
+      return (intrinsicWidth * scale).toInt() to (intrinsicHeight * scale).toInt()
     }
 
     override fun draw(canvas: Canvas) {
@@ -303,7 +433,14 @@ class ImageSpan(
           } else {
             source.draw(offscreen)
           }
-          ImageCache.putProcessed(cachedKey.url, cachedKey.width, cachedKey.height, cachedKey.borderRadius, bitmap)
+          ImageCache.putProcessed(
+            cachedKey.url,
+            cachedKey.width,
+            cachedKey.height,
+            cachedKey.borderRadius,
+            cachedKey.resizeMode,
+            bitmap,
+          )
         } catch (_: OutOfMemoryError) {
           Log.e("ScaledImageDrawable", "OOM caching bitmap ${width}x$height")
         }
@@ -328,7 +465,6 @@ class ImageSpan(
   }
 
   companion object {
-    private const val TAG = "ImageSpan"
     private val transparentDrawable by lazy { Color.TRANSPARENT.toDrawable() }
     private val cacheExecutor = Executors.newSingleThreadExecutor()
   }

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

@@ -0,0 +1,140 @@
+package com.swmansion.enriched.markdown.spans
+
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.graphics.Path
+import android.graphics.RectF
+import android.text.Spanned
+import android.text.StaticLayout
+import android.text.TextPaint
+import android.text.style.LeadingMarginSpan
+
+/**
+ * Shared geometry and drawing for inline "chips" painted from a [android.text.style.LineBackgroundSpan]
+ * (inline code, link chips). For a chip that wraps, only the outer ends are rounded and the border
+ * stays open where a fragment is cut.
+ */
+internal object InlineChipPainter {
+  /**
+   * 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.
+   */
+  fun horizontalOffset(
+    text: CharSequence,
+    lineStart: Int,
+    lineEnd: Int,
+    index: Int,
+    paint: Paint,
+    leadingMargin: Int,
+  ): Float {
+    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()
+    return layout.getPrimaryHorizontal(index - lineStart)
+  }
+
+  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
+  }
+
+  /**
+   * Fills [rect] and strokes its border. [strokeInset] keeps a closed border inside [rect]
+   * (link chips); otherwise it is centered on the edge (inline code, kept for pixel parity).
+   * [path] is caller-owned scratch space to avoid per-draw allocations.
+   */
+  fun draw(
+    canvas: Canvas,
+    rect: RectF,
+    path: Path,
+    cornerRadius: Float,
+    backgroundPaint: Paint?,
+    borderPaint: Paint?,
+    isFirst: Boolean,
+    isLast: Boolean,
+    strokeInset: Boolean,
+  ) {
+    val r = minOf(maxOf(cornerRadius, 0f), minOf(rect.width(), rect.height()) / 2f)
+
+    if (backgroundPaint != null) {
+      path.reset()
+      path.addRoundRect(rect, radii(r, isFirst, isLast), Path.Direction.CW)
+      canvas.drawPath(path, backgroundPaint)
+    }
+
+    if (borderPaint == null || borderPaint.strokeWidth <= 0f) return
+
+    path.reset()
+    if (isFirst && isLast) {
+      if (strokeInset) {
+        val inset = borderPaint.strokeWidth / 2f
+        val insetRect = RectF(rect.left + inset, rect.top + inset, rect.right - inset, rect.bottom - inset)
+        path.addRoundRect(insetRect, radii(maxOf(r - inset, 0f), true, true), Path.Direction.CW)
+      } else {
+        path.addRoundRect(rect, radii(r, true, true), Path.Direction.CW)
+      }
+    } else {
+      val inset = if (strokeInset) borderPaint.strokeWidth / 2f else 0f
+      addOpenBorder(path, rect, r, inset, isFirst, isLast)
+    }
+    canvas.drawPath(path, borderPaint)
+  }
+
+  private fun addOpenBorder(
+    path: Path,
+    rect: RectF,
+    r: Float,
+    inset: Float,
+    isFirst: Boolean,
+    isLast: Boolean,
+  ) {
+    val left = rect.left + inset
+    val top = rect.top + inset
+    val right = rect.right - inset
+    val bottom = rect.bottom - inset
+
+    if (isFirst) {
+      path.moveTo(rect.right, top)
+      path.lineTo(left + r, top)
+      path.quadTo(left, top, left, top + r)
+      path.lineTo(left, bottom - r)
+      path.quadTo(left, bottom, left + r, bottom)
+      path.lineTo(rect.right, bottom)
+    } else if (isLast) {
+      path.moveTo(rect.left, top)
+      path.lineTo(right - r, top)
+      path.quadTo(right, top, right, top + r)
+      path.lineTo(right, bottom - r)
+      path.quadTo(right, bottom, right - r, bottom)
+      path.lineTo(rect.left, bottom)
+    } else {
+      path.moveTo(rect.left, top)
+      path.lineTo(rect.right, top)
+      path.moveTo(rect.left, bottom)
+      path.lineTo(rect.right, bottom)
+    }
+  }
+
+  private fun radii(
+    r: Float,
+    isFirst: Boolean,
+    isLast: Boolean,
+  ): FloatArray {
+    val left = if (isFirst) r else 0f
+    val right = if (isLast) r else 0f
+    return floatArrayOf(left, left, right, right, right, right, left, left)
+  }
+}