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

package/android/src/main/java/com/swmansion/enriched/markdown/parser/MarkdownASTNode.kt

@@ -0,0 +1,43 @@
+package com.swmansion.enriched.markdown.parser
+
+data class MarkdownASTNode(
+  val type: NodeType,
+  val content: String = "",
+  val attributes: Map<String, String> = emptyMap(),
+  val children: List<MarkdownASTNode> = emptyList(),
+) {
+  enum class NodeType {
+    Document,
+    Paragraph,
+    Text,
+    Link,
+    Heading,
+    LineBreak,
+    Strong,
+    Emphasis,
+    Strikethrough,
+    Underline,
+    Code,
+    Image,
+    Blockquote,
+    UnorderedList,
+    OrderedList,
+    ListItem,
+    CodeBlock,
+    ThematicBreak,
+    Table,
+    TableHead,
+    TableBody,
+    TableRow,
+    TableHeaderCell,
+    TableCell,
+    LatexMathInline,
+    LatexMathDisplay,
+    Spoiler,
+    Superscript,
+    Subscript,
+    Highlight,
+  }
+
+  fun getAttribute(key: String): String? = attributes[key]
+}

package/android/src/main/java/com/swmansion/enriched/markdown/parser/Parser.kt

@@ -0,0 +1,68 @@
+package com.swmansion.enriched.markdown.parser
+
+import android.util.Log
+import com.swmansion.enriched.markdown.utils.common.FeatureFlags
+
+data class Md4cFlags(
+  val underline: Boolean = false,
+  val latexMath: Boolean = FeatureFlags.IS_MATH_ENABLED,
+  val superscript: Boolean = false,
+  val subscript: Boolean = false,
+  val highlight: Boolean = false,
+  val permissiveAutolinks: Boolean = true,
+) {
+  companion object {
+    val DEFAULT = Md4cFlags()
+  }
+}
+
+class Parser {
+  companion object {
+    init {
+      try {
+        // Library name must follow react_codegen_<ComponentName> convention
+        // required by React Native Fabric's CMake build system.
+        // md4c parser is bundled in the same shared library to avoid
+        // multiple library loading and complex linking dependencies.
+        System.loadLibrary("react_codegen_EnrichedMarkdownTextSpec")
+      } catch (e: UnsatisfiedLinkError) {
+        Log.e("MarkdownParser", "Failed to load native library", e)
+      }
+    }
+
+    @JvmStatic
+    private external fun nativeParseMarkdown(
+      markdown: String,
+      flags: Md4cFlags,
+    ): MarkdownASTNode?
+
+    /**
+     * Shared parser instance. Parser is stateless and thread-safe, so it can be reused
+     * across all EnrichedMarkdownText instances to avoid unnecessary allocations.
+     */
+    val shared: Parser = Parser()
+  }
+
+  fun parseMarkdown(
+    markdown: String,
+    flags: Md4cFlags = Md4cFlags.DEFAULT,
+  ): MarkdownASTNode? {
+    if (markdown.isBlank()) {
+      return null
+    }
+
+    try {
+      val ast = nativeParseMarkdown(markdown, flags)
+
+      if (ast != null) {
+        return ast
+      } else {
+        Log.w("MarkdownParser", "Native parser returned null")
+        return null
+      }
+    } catch (e: Exception) {
+      Log.e("MarkdownParser", "MD4C parsing failed: ${e.message}", e)
+      return null
+    }
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/renderer/BaselineShiftRenderer.kt

@@ -0,0 +1,44 @@
+package com.swmansion.enriched.markdown.renderer
+
+import android.text.SpannableStringBuilder
+import com.swmansion.enriched.markdown.parser.MarkdownASTNode
+import com.swmansion.enriched.markdown.spans.BaselineShiftSpan
+
+abstract class BaselineShiftRenderer : NodeRenderer {
+  abstract fun fontScale(factory: RendererFactory): Float
+
+  abstract fun baselineOffsetScale(factory: RendererFactory): Float
+
+  abstract fun spanType(): BaselineShiftSpan.SpanType
+
+  override fun render(
+    node: MarkdownASTNode,
+    builder: SpannableStringBuilder,
+    onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
+    factory: RendererFactory,
+  ) {
+    val start = builder.length
+    factory.renderChildren(node, builder, onLinkPress, onLinkLongPress)
+    val end = builder.length
+
+    if (end > start) {
+      // Block renderers (ListItemRenderer, BlockquoteRenderer, …) add their
+      // MetricAffectingSpan AFTER rendering children because they need the full range.
+      // Android applies spans in insertion order, so block spans that set tp.textSize
+      // absolutely always run last and override fontScale. Deferring this span ensures
+      // it is inserted after all block spans and wins.
+      //
+      // TODO: consider pre-registering each block span with an empty range before
+      // renderChildren(), then update the range in-place with a second setSpan() call.
+      // SpannableStringBuilder updates the range without moving the span in the array,
+      // so block spans stay first and inline spans naturally follow. Once done, remove
+      // the deferredSpans mechanism.
+      factory.registerDeferredSpan(
+        BaselineShiftSpan(fontScale(factory), baselineOffsetScale(factory), spanType()),
+        start,
+        end,
+      )
+    }
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/renderer/BlockStyleContext.kt

@@ -0,0 +1,152 @@
+package com.swmansion.enriched.markdown.renderer
+
+import com.swmansion.enriched.markdown.styles.BaseBlockStyle
+import com.swmansion.enriched.markdown.styles.BlockquoteStyle
+import com.swmansion.enriched.markdown.styles.CodeBlockStyle
+import com.swmansion.enriched.markdown.styles.HeadingStyle
+import com.swmansion.enriched.markdown.styles.ListStyle
+import com.swmansion.enriched.markdown.styles.ParagraphStyle
+
+enum class BlockType {
+  NONE,
+  PARAGRAPH,
+  HEADING,
+  BLOCKQUOTE,
+  UNORDERED_LIST,
+  ORDERED_LIST,
+  CODE_BLOCK,
+}
+
+data class BlockStyle(
+  val fontSize: Float,
+  val fontFamily: String,
+  val fontWeight: String,
+  val color: Int,
+)
+
+private data class BlockStyleEntry(
+  val blockType: BlockType,
+  val blockStyle: BlockStyle,
+  val headingLevel: Int,
+)
+
+class BlockStyleContext {
+  var currentBlockType = BlockType.NONE
+    private set
+
+  private var currentHeadingLevel = 0
+  private val blockStyleStack = ArrayDeque<BlockStyleEntry>()
+
+  var blockquoteDepth = 0
+  var listDepth = 0
+  var listType: ListType? = null
+  var listItemNumber = 0
+  var taskItemCount = 0
+
+  private val orderedListItemNumbers = ArrayDeque<Int>()
+
+  enum class ListType { UNORDERED, ORDERED }
+
+  private fun pushBlockStyle(
+    type: BlockType,
+    style: BaseBlockStyle,
+    headingLevel: Int = 0,
+  ) {
+    val entry =
+      BlockStyleEntry(
+        blockType = type,
+        blockStyle = BlockStyle(style.fontSize, style.fontFamily, style.fontWeight, style.color),
+        headingLevel = headingLevel,
+      )
+
+    blockStyleStack.addLast(entry)
+    currentBlockType = type
+    currentHeadingLevel = headingLevel
+  }
+
+  fun popBlockStyle() {
+    if (blockStyleStack.isNotEmpty()) {
+      blockStyleStack.removeLast()
+    }
+
+    val parentStyle = blockStyleStack.lastOrNull()
+    if (parentStyle != null) {
+      currentBlockType = parentStyle.blockType
+      currentHeadingLevel = parentStyle.headingLevel
+    } else {
+      currentBlockType = BlockType.NONE
+      currentHeadingLevel = 0
+    }
+  }
+
+  fun setParagraphStyle(style: ParagraphStyle) = pushBlockStyle(BlockType.PARAGRAPH, style)
+
+  fun setHeadingStyle(
+    style: HeadingStyle,
+    level: Int,
+  ) = pushBlockStyle(BlockType.HEADING, style, level)
+
+  fun setBlockquoteStyle(style: BlockquoteStyle) = pushBlockStyle(BlockType.BLOCKQUOTE, style)
+
+  fun setUnorderedListStyle(style: ListStyle) {
+    listType = ListType.UNORDERED
+    pushBlockStyle(BlockType.UNORDERED_LIST, style)
+  }
+
+  fun setOrderedListStyle(style: ListStyle) {
+    listType = ListType.ORDERED
+    pushBlockStyle(BlockType.ORDERED_LIST, style)
+  }
+
+  fun setCodeBlockStyle(style: CodeBlockStyle) = pushBlockStyle(BlockType.CODE_BLOCK, style)
+
+  fun isInsideBlockElement(): Boolean = blockquoteDepth > 0 || listDepth > 0
+
+  fun incrementListItemNumber() {
+    listItemNumber++
+  }
+
+  fun resetListItemNumber() {
+    listItemNumber = 0
+  }
+
+  fun pushOrderedListItemNumber() {
+    orderedListItemNumbers.addLast(listItemNumber)
+  }
+
+  fun popOrderedListItemNumber() {
+    if (orderedListItemNumbers.isNotEmpty()) {
+      listItemNumber = orderedListItemNumbers.removeLast()
+    }
+  }
+
+  fun clearListStyle() {
+    popBlockStyle()
+
+    if (listDepth == 0) {
+      listType = null
+      listItemNumber = 0
+      orderedListItemNumbers.clear()
+    }
+  }
+
+  fun requireBlockStyle(): BlockStyle {
+    val entry = blockStyleStack.lastOrNull()
+    return entry?.blockStyle
+      ?: throw IllegalStateException(
+        "BlockStyle is null. Inline renderers must be used within a block context.",
+      )
+  }
+
+  fun resetForNewRender() {
+    blockStyleStack.clear()
+    currentBlockType = BlockType.NONE
+    currentHeadingLevel = 0
+    blockquoteDepth = 0
+    listDepth = 0
+    listType = null
+    listItemNumber = 0
+    taskItemCount = 0
+    orderedListItemNumbers.clear()
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/renderer/BlockquoteRenderer.kt

@@ -0,0 +1,87 @@
+package com.swmansion.enriched.markdown.renderer
+
+import android.text.SpannableStringBuilder
+import com.swmansion.enriched.markdown.parser.MarkdownASTNode
+import com.swmansion.enriched.markdown.spans.BlockquoteSpan
+import com.swmansion.enriched.markdown.utils.text.span.SPAN_FLAGS_CONTAINER_BACKGROUND
+import com.swmansion.enriched.markdown.utils.text.span.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
+import com.swmansion.enriched.markdown.utils.text.span.applyMarginBottom
+import com.swmansion.enriched.markdown.utils.text.span.applyMarginTop
+import com.swmansion.enriched.markdown.utils.text.span.createLineHeightSpan
+
+class BlockquoteRenderer(
+  private val config: RendererConfig,
+) : NodeRenderer {
+  override fun render(
+    node: MarkdownASTNode,
+    builder: SpannableStringBuilder,
+    onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
+    factory: RendererFactory,
+  ) {
+    val start = builder.length
+    val style = config.style.blockquoteStyle
+    val context = factory.blockStyleContext
+    val depth = context.blockquoteDepth
+
+    // Track depth to handle nested indentation levels
+    context.blockquoteDepth = depth + 1
+    context.setBlockquoteStyle(style)
+
+    try {
+      factory.renderChildren(node, builder, onLinkPress, onLinkLongPress)
+    } finally {
+      context.popBlockStyle()
+      context.blockquoteDepth = depth
+    }
+
+    if (builder.length == start) return
+    val end = builder.length
+
+    // Find immediately nested quotes to exclude them from this level's line-height/margins
+    val nestedRanges =
+      builder
+        .getSpans(start, end, BlockquoteSpan::class.java)
+        .filter { it.depth == depth + 1 }
+        .map { builder.getSpanStart(it) to builder.getSpanEnd(it) }
+        .sortedBy { it.first }
+
+    // The accent bar span covers the full range for visual continuity.
+    // SPAN_FLAGS_CONTAINER_BACKGROUND keeps the blockquote fill under any
+    // inline chip/pill backgrounds on the same line.
+    builder.setSpan(
+      BlockquoteSpan(style, depth, factory.context, factory.styleCache),
+      start,
+      end,
+      SPAN_FLAGS_CONTAINER_BACKGROUND,
+    )
+
+    // Apply styling only to segments that are NOT nested quotes
+    applySpansExcludingNested(builder, nestedRanges, start, end, createLineHeightSpan(style.lineHeight))
+
+    // Margins are only applied by the outermost (root) quote
+    if (depth == 0) {
+      applyMarginTop(builder, start, style.marginTop)
+      applyMarginBottom(builder, style.marginBottom)
+    }
+  }
+
+  private fun applySpansExcludingNested(
+    builder: SpannableStringBuilder,
+    nestedRanges: List<Pair<Int, Int>>,
+    start: Int,
+    end: Int,
+    span: Any,
+  ) {
+    var currentPos = start
+    for ((nestedStart, nestedEnd) in nestedRanges) {
+      if (currentPos < nestedStart) {
+        builder.setSpan(span, currentPos, nestedStart, SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE)
+      }
+      currentPos = nestedEnd
+    }
+    if (currentPos < end) {
+      builder.setSpan(span, currentPos, end, SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE)
+    }
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/renderer/CodeBlockRenderer.kt

@@ -0,0 +1,104 @@
+package com.swmansion.enriched.markdown.renderer
+
+import android.graphics.Paint
+import android.text.SpannableStringBuilder
+import android.text.Spanned
+import android.text.style.LineHeightSpan
+import com.swmansion.enriched.markdown.parser.MarkdownASTNode
+import com.swmansion.enriched.markdown.spans.CodeBlockSpan
+import com.swmansion.enriched.markdown.spans.MarginBottomSpan
+import com.swmansion.enriched.markdown.utils.text.span.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
+import com.swmansion.enriched.markdown.utils.text.span.applyMarginTop
+
+class CodeBlockRenderer(
+  private val config: RendererConfig,
+) : NodeRenderer {
+  override fun render(
+    node: MarkdownASTNode,
+    builder: SpannableStringBuilder,
+    onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
+    factory: RendererFactory,
+  ) {
+    val start = builder.length
+    val style = config.style.codeBlockStyle
+    val context = factory.blockStyleContext
+
+    applyMarginTop(builder, start, style.marginTop)
+
+    // Content starts after the potential 1-character marginTop spacer
+    val contentStart = start + (if (style.marginTop > 0) 1 else 0)
+
+    context.setCodeBlockStyle(style)
+
+    try {
+      factory.renderChildren(node, builder, onLinkPress, onLinkLongPress)
+    } finally {
+      context.popBlockStyle()
+    }
+
+    if (builder.length == contentStart) return
+
+    val end = builder.length
+    val padding = style.padding.toInt()
+
+    // Apply background, borders, and horizontal padding to content only
+    builder.setSpan(
+      CodeBlockSpan(style, factory.context, factory.styleCache),
+      contentStart,
+      end,
+      SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+    )
+
+    // Apply vertical padding via line height manipulation
+    builder.setSpan(
+      CodeBlockBoundaryPaddingSpan(padding),
+      contentStart,
+      end,
+      SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+    )
+
+    val marginStart = builder.length
+    builder.append("\n")
+    builder.setSpan(
+      MarginBottomSpan(style.marginBottom),
+      marginStart,
+      builder.length,
+      SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+    )
+  }
+
+  /**
+   * Internal span to handle top/bottom padding by modifying font metrics.
+   */
+  private class CodeBlockBoundaryPaddingSpan(
+    private val padding: Int,
+  ) : LineHeightSpan {
+    override fun chooseHeight(
+      text: CharSequence,
+      startLine: Int,
+      endLine: Int,
+      spanstartv: Int,
+      v: Int,
+      fm: Paint.FontMetricsInt,
+    ) {
+      if (text !is Spanned) return
+
+      val spanStart = text.getSpanStart(this)
+      val spanEnd = text.getSpanEnd(this)
+
+      // Adjust ascent/top for the first line to create internal top padding
+      if (startLine == spanStart) {
+        fm.ascent -= padding
+        fm.top -= padding
+      }
+
+      // Adjust descent/bottom for the last line (handling trailing newlines)
+      val isLastLine = endLine == spanEnd || (spanEnd <= endLine && text[spanEnd - 1] == '\n')
+      if (isLastLine) {
+        fm.descent += padding
+        fm.bottom += padding
+      }
+    }
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/renderer/CodeRenderer.kt

@@ -0,0 +1,36 @@
+package com.swmansion.enriched.markdown.renderer
+
+import android.text.SpannableStringBuilder
+import com.swmansion.enriched.markdown.parser.MarkdownASTNode
+import com.swmansion.enriched.markdown.spans.CodeBackgroundSpan
+import com.swmansion.enriched.markdown.spans.CodeSpan
+import com.swmansion.enriched.markdown.utils.text.span.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
+
+class CodeRenderer(
+  private val config: RendererConfig,
+) : NodeRenderer {
+  override fun render(
+    node: MarkdownASTNode,
+    builder: SpannableStringBuilder,
+    onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
+    factory: RendererFactory,
+  ) {
+    if (node.children.isEmpty() || node.children.all { it.content.isEmpty() }) return
+
+    factory.renderWithSpan(builder, { node.children.forEach { builder.append(it.content) } }) { start, end, blockStyle ->
+      builder.setSpan(
+        CodeSpan(factory.styleCache, blockStyle),
+        start,
+        end,
+        SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+      )
+      builder.setSpan(
+        CodeBackgroundSpan(config.style),
+        start,
+        end,
+        SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+      )
+    }
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/renderer/DocumentRenderer.kt

@@ -0,0 +1,16 @@
+package com.swmansion.enriched.markdown.renderer
+
+import android.text.SpannableStringBuilder
+import com.swmansion.enriched.markdown.parser.MarkdownASTNode
+
+class DocumentRenderer : NodeRenderer {
+  override fun render(
+    node: MarkdownASTNode,
+    builder: SpannableStringBuilder,
+    onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
+    factory: RendererFactory,
+  ) {
+    factory.renderChildren(node, builder, onLinkPress, onLinkLongPress)
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/renderer/EmphasisRenderer.kt

@@ -0,0 +1,27 @@
+package com.swmansion.enriched.markdown.renderer
+
+import android.text.SpannableStringBuilder
+import com.swmansion.enriched.markdown.parser.MarkdownASTNode
+import com.swmansion.enriched.markdown.spans.EmphasisSpan
+import com.swmansion.enriched.markdown.utils.text.span.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
+
+class EmphasisRenderer(
+  private val config: RendererConfig,
+) : NodeRenderer {
+  override fun render(
+    node: MarkdownASTNode,
+    builder: SpannableStringBuilder,
+    onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
+    factory: RendererFactory,
+  ) {
+    factory.renderWithSpan(builder, { factory.renderChildren(node, builder, onLinkPress, onLinkLongPress) }) { start, end, blockStyle ->
+      builder.setSpan(
+        EmphasisSpan(factory.styleCache, blockStyle),
+        start,
+        end,
+        SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+      )
+    }
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/renderer/HeadingRenderer.kt

@@ -0,0 +1,71 @@
+package com.swmansion.enriched.markdown.renderer
+
+import android.text.SpannableStringBuilder
+import android.text.style.AlignmentSpan
+import com.swmansion.enriched.markdown.parser.MarkdownASTNode
+import com.swmansion.enriched.markdown.spans.HeadingSpan
+import com.swmansion.enriched.markdown.utils.text.span.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
+import com.swmansion.enriched.markdown.utils.text.span.applyMarginBottom
+import com.swmansion.enriched.markdown.utils.text.span.applyMarginTop
+import com.swmansion.enriched.markdown.utils.text.span.createLineHeightSpan
+
+class HeadingRenderer(
+  private val config: RendererConfig,
+) : NodeRenderer {
+  override fun render(
+    node: MarkdownASTNode,
+    builder: SpannableStringBuilder,
+    onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
+    factory: RendererFactory,
+  ) {
+    val level = node.getAttribute("level")?.toIntOrNull() ?: 1
+    val start = builder.length
+
+    val headingStyle = config.style.headingStyles[level]!!
+    val blockStyleContext = factory.blockStyleContext
+    blockStyleContext.setHeadingStyle(headingStyle, level)
+
+    try {
+      factory.renderChildren(node, builder, onLinkPress, onLinkLongPress)
+    } finally {
+      blockStyleContext.popBlockStyle()
+    }
+
+    val end = builder.length
+    val contentLength = end - start
+
+    if (contentLength > 0) {
+      builder.setSpan(
+        HeadingSpan(
+          level,
+          config.style,
+        ),
+        start,
+        end,
+        SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+      )
+
+      builder.setSpan(
+        createLineHeightSpan(headingStyle.lineHeight),
+        start,
+        end,
+        SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+      )
+
+      // Only apply AlignmentSpan for non-default alignments (Center/Right).
+      // Justify is handled at the TextView level (API 26+).
+      if (headingStyle.textAlign.needsAlignmentSpan) {
+        builder.setSpan(
+          AlignmentSpan.Standard(headingStyle.textAlign.layoutAlignment),
+          start,
+          end,
+          SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+        )
+      }
+
+      applyMarginTop(builder, start, headingStyle.marginTop)
+      applyMarginBottom(builder, headingStyle.marginBottom)
+    }
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/renderer/HighlightRenderer.kt

@@ -0,0 +1,25 @@
+package com.swmansion.enriched.markdown.renderer
+
+import android.text.SpannableStringBuilder
+import com.swmansion.enriched.markdown.parser.MarkdownASTNode
+import com.swmansion.enriched.markdown.spans.HighlightSpan
+import com.swmansion.enriched.markdown.utils.text.span.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
+
+class HighlightRenderer : NodeRenderer {
+  override fun render(
+    node: MarkdownASTNode,
+    builder: SpannableStringBuilder,
+    onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
+    factory: RendererFactory,
+  ) {
+    factory.renderWithSpan(builder, { factory.renderChildren(node, builder, onLinkPress, onLinkLongPress) }) { start, end, blockStyle ->
+      builder.setSpan(
+        HighlightSpan(factory.styleCache, blockStyle),
+        start,
+        end,
+        SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+      )
+    }
+  }
+}