react-native-enriched-markdown-scaffold 0.7.4-scaffold.1 → 0.7.4-scaffold.10

package/android/build.gradle

@@ -67,6 +67,10 @@ android {
       }
     }
   }
+
+  testOptions {
+    unitTests.includeAndroidResources = true
+  }
 }
 
 repositories {
@@ -85,6 +89,7 @@ dependencies {
   if (enableMath) {
     implementation("io.github.erweixin:ratex-android:0.1.10")
   }
+  testImplementation "junit:junit:4.13.2"
 }
 
 react {

package/android/generated/java/com/facebook/react/viewmanagers/EnrichedMarkdownTextInputManagerDelegate.java

@@ -44,6 +44,9 @@ public class EnrichedMarkdownTextInputManagerDelegate<T extends View, U extends
       case "scrollEnabled":
         mViewManager.setScrollEnabled(view, value == null ? false : (boolean) value);
         break;
+      case "blockSyntax":
+        mViewManager.setBlockSyntax(view, value == null ? false : (boolean) value);
+        break;
       case "autoCapitalize":
         mViewManager.setAutoCapitalize(view, value == null ? null : (String) value);
         break;

package/android/generated/java/com/facebook/react/viewmanagers/EnrichedMarkdownTextInputManagerInterface.java

@@ -22,6 +22,7 @@ public interface EnrichedMarkdownTextInputManagerInterface<T extends View> exten
   void setEditable(T view, boolean value);
   void setAutoFocus(T view, boolean value);
   void setScrollEnabled(T view, boolean value);
+  void setBlockSyntax(T view, boolean value);
   void setAutoCapitalize(T view, @Nullable String value);
   void setMultiline(T view, boolean value);
   void setCursorColor(T view, @Nullable Integer value);

package/android/generated/jni/react/renderer/components/EnrichedMarkdownTextSpec/Props.cpp

@@ -144,6 +144,7 @@ EnrichedMarkdownTextInputProps::EnrichedMarkdownTextInputProps(
     editable(convertRawProp(context, rawProps, "editable", sourceProps.editable, {false})),
     autoFocus(convertRawProp(context, rawProps, "autoFocus", sourceProps.autoFocus, {false})),
     scrollEnabled(convertRawProp(context, rawProps, "scrollEnabled", sourceProps.scrollEnabled, {false})),
+    blockSyntax(convertRawProp(context, rawProps, "blockSyntax", sourceProps.blockSyntax, {false})),
     autoCapitalize(convertRawProp(context, rawProps, "autoCapitalize", sourceProps.autoCapitalize, {})),
     multiline(convertRawProp(context, rawProps, "multiline", sourceProps.multiline, {false})),
     cursorColor(convertRawProp(context, rawProps, "cursorColor", sourceProps.cursorColor, {})),
@@ -202,6 +203,10 @@ folly::dynamic EnrichedMarkdownTextInputProps::getDiffProps(
     result["scrollEnabled"] = scrollEnabled;
   }
     
+  if (blockSyntax != oldProps->blockSyntax) {
+    result["blockSyntax"] = blockSyntax;
+  }
+    
   if (autoCapitalize != oldProps->autoCapitalize) {
     result["autoCapitalize"] = autoCapitalize;
   }

package/android/generated/jni/react/renderer/components/EnrichedMarkdownTextSpec/Props.h

@@ -1534,6 +1534,7 @@ struct EnrichedMarkdownMarkdownStyleMathStruct {
   Float marginTop{0.0};
   Float marginBottom{0.0};
   std::string textAlign{};
+  std::string fontWeight{};
 
 
 #ifdef RN_SERIALIZABLE_STATE
@@ -1548,6 +1549,7 @@ struct EnrichedMarkdownMarkdownStyleMathStruct {
     result["marginTop"] = marginTop;
     result["marginBottom"] = marginBottom;
     result["textAlign"] = textAlign;
+    result["fontWeight"] = fontWeight;
     return result;
   }
 #endif
@@ -1584,6 +1586,10 @@ static inline void fromRawValue(const PropsParserContext& context, const RawValu
   if (tmp_textAlign != map.end()) {
     fromRawValue(context, tmp_textAlign->second, result.textAlign);
   }
+  auto tmp_fontWeight = map.find("fontWeight");
+  if (tmp_fontWeight != map.end()) {
+    fromRawValue(context, tmp_fontWeight->second, result.fontWeight);
+  }
 }
 
 static inline std::string toString(const EnrichedMarkdownMarkdownStyleMathStruct &value) {
@@ -1598,6 +1604,8 @@ static inline folly::dynamic toDynamic(const EnrichedMarkdownMarkdownStyleMathSt
 
 struct EnrichedMarkdownMarkdownStyleInlineMathStruct {
   SharedColor color{};
+  Float paddingVertical{0.0};
+  std::string fontWeight{};
 
 
 #ifdef RN_SERIALIZABLE_STATE
@@ -1606,6 +1614,8 @@ struct EnrichedMarkdownMarkdownStyleInlineMathStruct {
   folly::dynamic toDynamic() const {
     folly::dynamic result = folly::dynamic::object();
     result["color"] = ::facebook::react::toDynamic(color);
+    result["paddingVertical"] = paddingVertical;
+    result["fontWeight"] = fontWeight;
     return result;
   }
 #endif
@@ -1618,6 +1628,14 @@ static inline void fromRawValue(const PropsParserContext& context, const RawValu
   if (tmp_color != map.end()) {
     fromRawValue(context, tmp_color->second, result.color);
   }
+  auto tmp_paddingVertical = map.find("paddingVertical");
+  if (tmp_paddingVertical != map.end()) {
+    fromRawValue(context, tmp_paddingVertical->second, result.paddingVertical);
+  }
+  auto tmp_fontWeight = map.find("fontWeight");
+  if (tmp_fontWeight != map.end()) {
+    fromRawValue(context, tmp_fontWeight->second, result.fontWeight);
+  }
 }
 
 static inline std::string toString(const EnrichedMarkdownMarkdownStyleInlineMathStruct &value) {
@@ -2804,6 +2822,7 @@ struct EnrichedMarkdownTextInputMarkdownStyleMathStruct {
   Float paddingVertical{0.0};
   SharedColor selectedBackgroundColor{};
   SharedColor selectedBorderColor{};
+  std::string fontWeight{};
 
 
 #ifdef RN_SERIALIZABLE_STATE
@@ -2821,6 +2840,7 @@ struct EnrichedMarkdownTextInputMarkdownStyleMathStruct {
     result["paddingVertical"] = paddingVertical;
     result["selectedBackgroundColor"] = ::facebook::react::toDynamic(selectedBackgroundColor);
     result["selectedBorderColor"] = ::facebook::react::toDynamic(selectedBorderColor);
+    result["fontWeight"] = fontWeight;
     return result;
   }
 #endif
@@ -2869,6 +2889,10 @@ static inline void fromRawValue(const PropsParserContext& context, const RawValu
   if (tmp_selectedBorderColor != map.end()) {
     fromRawValue(context, tmp_selectedBorderColor->second, result.selectedBorderColor);
   }
+  auto tmp_fontWeight = map.find("fontWeight");
+  if (tmp_fontWeight != map.end()) {
+    fromRawValue(context, tmp_fontWeight->second, result.fontWeight);
+  }
 }
 
 static inline std::string toString(const EnrichedMarkdownTextInputMarkdownStyleMathStruct &value) {
@@ -2892,6 +2916,7 @@ struct EnrichedMarkdownTextInputMarkdownStyleMathBlockStruct {
   Float paddingVertical{0.0};
   SharedColor selectedBackgroundColor{};
   SharedColor selectedBorderColor{};
+  std::string fontWeight{};
   Float marginTop{0.0};
   Float marginBottom{0.0};
   std::string alignment{};
@@ -2912,6 +2937,7 @@ struct EnrichedMarkdownTextInputMarkdownStyleMathBlockStruct {
     result["paddingVertical"] = paddingVertical;
     result["selectedBackgroundColor"] = ::facebook::react::toDynamic(selectedBackgroundColor);
     result["selectedBorderColor"] = ::facebook::react::toDynamic(selectedBorderColor);
+    result["fontWeight"] = fontWeight;
     result["marginTop"] = marginTop;
     result["marginBottom"] = marginBottom;
     result["alignment"] = alignment;
@@ -2963,6 +2989,10 @@ static inline void fromRawValue(const PropsParserContext& context, const RawValu
   if (tmp_selectedBorderColor != map.end()) {
     fromRawValue(context, tmp_selectedBorderColor->second, result.selectedBorderColor);
   }
+  auto tmp_fontWeight = map.find("fontWeight");
+  if (tmp_fontWeight != map.end()) {
+    fromRawValue(context, tmp_fontWeight->second, result.fontWeight);
+  }
   auto tmp_marginTop = map.find("marginTop");
   if (tmp_marginTop != map.end()) {
     fromRawValue(context, tmp_marginTop->second, result.marginTop);
@@ -3329,6 +3359,7 @@ class EnrichedMarkdownTextInputProps final : public ViewProps {
   bool editable{false};
   bool autoFocus{false};
   bool scrollEnabled{false};
+  bool blockSyntax{false};
   std::string autoCapitalize{};
   bool multiline{false};
   SharedColor cursorColor{};
@@ -4872,6 +4903,7 @@ struct EnrichedMarkdownTextMarkdownStyleMathStruct {
   Float marginTop{0.0};
   Float marginBottom{0.0};
   std::string textAlign{};
+  std::string fontWeight{};
 
 
 #ifdef RN_SERIALIZABLE_STATE
@@ -4886,6 +4918,7 @@ struct EnrichedMarkdownTextMarkdownStyleMathStruct {
     result["marginTop"] = marginTop;
     result["marginBottom"] = marginBottom;
     result["textAlign"] = textAlign;
+    result["fontWeight"] = fontWeight;
     return result;
   }
 #endif
@@ -4922,6 +4955,10 @@ static inline void fromRawValue(const PropsParserContext& context, const RawValu
   if (tmp_textAlign != map.end()) {
     fromRawValue(context, tmp_textAlign->second, result.textAlign);
   }
+  auto tmp_fontWeight = map.find("fontWeight");
+  if (tmp_fontWeight != map.end()) {
+    fromRawValue(context, tmp_fontWeight->second, result.fontWeight);
+  }
 }
 
 static inline std::string toString(const EnrichedMarkdownTextMarkdownStyleMathStruct &value) {
@@ -4936,6 +4973,8 @@ static inline folly::dynamic toDynamic(const EnrichedMarkdownTextMarkdownStyleMa
 
 struct EnrichedMarkdownTextMarkdownStyleInlineMathStruct {
   SharedColor color{};
+  Float paddingVertical{0.0};
+  std::string fontWeight{};
 
 
 #ifdef RN_SERIALIZABLE_STATE
@@ -4944,6 +4983,8 @@ struct EnrichedMarkdownTextMarkdownStyleInlineMathStruct {
   folly::dynamic toDynamic() const {
     folly::dynamic result = folly::dynamic::object();
     result["color"] = ::facebook::react::toDynamic(color);
+    result["paddingVertical"] = paddingVertical;
+    result["fontWeight"] = fontWeight;
     return result;
   }
 #endif
@@ -4956,6 +4997,14 @@ static inline void fromRawValue(const PropsParserContext& context, const RawValu
   if (tmp_color != map.end()) {
     fromRawValue(context, tmp_color->second, result.color);
   }
+  auto tmp_paddingVertical = map.find("paddingVertical");
+  if (tmp_paddingVertical != map.end()) {
+    fromRawValue(context, tmp_paddingVertical->second, result.paddingVertical);
+  }
+  auto tmp_fontWeight = map.find("fontWeight");
+  if (tmp_fontWeight != map.end()) {
+    fromRawValue(context, tmp_fontWeight->second, result.fontWeight);
+  }
 }
 
 static inline std::string toString(const EnrichedMarkdownTextMarkdownStyleInlineMathStruct &value) {

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

@@ -25,6 +25,7 @@ import com.swmansion.enriched.markdown.utils.common.RenderedSegment
 import com.swmansion.enriched.markdown.utils.common.StreamingMarkdownFilter
 import com.swmansion.enriched.markdown.utils.common.TableStreamingMode
 import com.swmansion.enriched.markdown.utils.common.getBooleanOrDefault
+import com.swmansion.enriched.markdown.utils.common.getFloatOrDefault
 import com.swmansion.enriched.markdown.utils.common.getMapOrNull
 import com.swmansion.enriched.markdown.utils.common.getStringOrDefault
 import com.swmansion.enriched.markdown.utils.common.splitASTIntoSegments
@@ -299,7 +300,6 @@ object MeasurementStore {
 
     // 2. Render & Measure
     val spannable = tryRenderMarkdown(markdown, styleMap, context, md4cFlags, allowFontScaling, maxFontSizeMultiplier)
-    spannable?.replaceMathSpansWithPlaceholders(context)
     val textToMeasure = spannable ?: markdown
     val (size, _) = measureWithLayout(width, textToMeasure, measurePaint, id)
 
@@ -420,7 +420,7 @@ object MeasurementStore {
 
         when (segment) {
           is RenderedSegment.Text -> {
-            segment.styledText.replaceMathSpansWithPlaceholders(context)
+            segment.styledText.replaceMathSpansWithPlaceholders(context, style.inlineMathStyle.paddingVertical)
 
             val layout = createStaticLayout(segment.styledText, fontSize, widthPx, id)
             totalHeightPx += layout.height
@@ -503,7 +503,9 @@ object MeasurementStore {
       val ast = Parser.shared.parseMarkdown(markdown, md4cFlags) ?: return null
       val style = StyleConfig(styleMap, context, allowFontScaling, maxFontSizeMultiplier)
       measureRenderer.configure(style, context)
-      measureRenderer.renderDocument(ast, null)
+      measureRenderer.renderDocument(ast, null).apply {
+        replaceMathSpansWithPlaceholders(context, style.inlineMathStyle.paddingVertical)
+      }
     } catch (e: Exception) {
       Log.w(TAG, "Failed to render markdown for measurement, falling back to raw text", e)
       null
@@ -517,7 +519,7 @@ object MeasurementStore {
     fontScale: Float,
     maxFontSizeMultiplier: Float,
   ): Float {
-    val fontSizeSp = styleMap?.getMap("paragraph")?.getDouble("fontSize")?.toFloat() ?: 16f
+    val fontSizeSp = styleMap.getMapOrNull("paragraph").getFloatOrDefault("fontSize", 16f)
     val density = context.resources.displayMetrics.density
 
     if (!allowFontScaling) {

package/android/src/main/java/com/swmansion/enriched/markdown/input/EnrichedMarkdownTextInputManager.kt

@@ -57,6 +57,13 @@ class EnrichedMarkdownTextInputManager :
     stateWrapper: StateWrapper?,
   ): Any? {
     view.stateWrapper = stateWrapper
+    // Fabric applies props before it hands over the state wrapper, so every layout
+    // invalidation raised during the mount transaction was dropped. Replay it now that we can
+    // actually push state — otherwise the shadow node keeps the initialMeasure() estimate,
+    // which ignores math chips, until the first keystroke.
+    if (stateWrapper != null) {
+      view.layoutManager.flushPendingInvalidation()
+    }
     return super.updateState(view, props, stateWrapper)
   }
 
@@ -69,6 +76,11 @@ class EnrichedMarkdownTextInputManager :
     view.dismissActiveMention()
     super.onDropViewInstance(view)
     view.layoutManager.release()
+    // Unreachable while view recycling is off — it needs a `setupViewRecycling()` call from this
+    // constructor *and* ReactNativeFeatureFlags.enableViewRecycling(). Kept because the flush
+    // above turns a recycled view into a view that pushes state at mount: without this, it would
+    // push into the shadow node it was dropped from.
+    view.stateWrapper = null
   }
 
   override fun measure(
@@ -158,6 +170,14 @@ class EnrichedMarkdownTextInputManager :
     view?.isVerticalScrollBarEnabled = value
   }
 
+  @ReactProp(name = "blockSyntax", defaultBoolean = true)
+  override fun setBlockSyntax(
+    view: EnrichedMarkdownTextInputView?,
+    value: Boolean,
+  ) {
+    view?.blockSyntax = value
+  }
+
   @ReactProp(name = "autoCapitalize")
   override fun setAutoCapitalize(
     view: EnrichedMarkdownTextInputView?,

package/android/src/main/java/com/swmansion/enriched/markdown/input/EnrichedMarkdownTextInputView.kt

@@ -97,6 +97,17 @@ class EnrichedMarkdownTextInputView(
   private var detectScrollMovement = false
   var scrollEnabled: Boolean = true
 
+  // The markdown last handed over by JS, kept so `blockSyntax` can re-parse it. @ReactProp
+  // setters fire in undefined order, so `defaultValue` regularly lands before the flag does.
+  private var lastMarkdownFromJS: String? = null
+
+  var blockSyntax: Boolean = true
+    set(value) {
+      if (field == value) return
+      field = value
+      lastMarkdownFromJS?.let { setValueFromJS(it) }
+    }
+
   private var mentionIndicators: LinkedHashSet<String> = linkedSetOf()
   private var activeMentionIndicator: String? = null
   private var activeMentionStart = -1
@@ -634,7 +645,8 @@ class EnrichedMarkdownTextInputView(
   }
 
   fun setValueFromJS(markdown: String) {
-    val parsed = InputParser.parseToPlainTextAndRanges(markdown)
+    lastMarkdownFromJS = markdown
+    val parsed = InputParser.parseToPlainTextAndRanges(markdown, blockSyntax)
     blockEmitting = true
     try {
       runAsATransaction {
@@ -708,8 +720,16 @@ class EnrichedMarkdownTextInputView(
       }
       invalidate()
       requestLayout()
+      // Chips only reach the text here when `defaultValue` landed before `markdownStyle`
+      // (@ReactProp order is undefined). requestLayout() cannot change a height Fabric owns —
+      // the shadow tree has to re-measure text that now carries the spans.
+      layoutManager.invalidateLayout()
     } else if (mathStyleChanged) {
       refreshAllMathChips()
+      // A math font size / padding change resizes every chip, so the measured height moves.
+      // Colour-only changes end up here too; store() then measures the same size and skips
+      // the state update.
+      layoutManager.invalidateLayout()
     }
     return changed
   }
@@ -848,18 +868,36 @@ class EnrichedMarkdownTextInputView(
     return true
   }
 
-  private fun computeChipBounds(
+  /** Chip glyph rect in [Layout] coordinates — no padding, no scroll offset. */
+  private fun chipBoundsInLayout(
     layout: Layout,
     start: Int,
   ): Rect {
     val line = layout.getLineForOffset(start)
-    val xStart = (layout.getPrimaryHorizontal(start)).toInt() + totalPaddingLeft - scrollX
-    val xEnd = (layout.getPrimaryHorizontal(start + 1)).toInt() + totalPaddingLeft - scrollX
-    val top = layout.getLineTop(line) + totalPaddingTop - scrollY
-    val bottom = layout.getLineBottom(line) + totalPaddingTop - scrollY
-    return Rect(xStart, top, xEnd, bottom)
+    val xStart = layout.getPrimaryHorizontal(start).toInt()
+    val xEnd = layout.getPrimaryHorizontal(start + 1).toInt()
+    // Ordered, not raw start/end: in an RTL run xStart > xEnd, which would make an
+    // inverted Rect that contains() always rejects.
+    val left = xStart.coerceAtMost(xEnd)
+    var right = xStart.coerceAtLeast(xEnd)
+    if (right <= left) {
+      // A chip that is the last character has start + 1 == length, where some layouts
+      // report the same horizontal for both offsets. Fall back to the line's content edge
+      // so the rect keeps a real width instead of collapsing.
+      right = layout.getLineRight(line).toInt()
+    }
+    return Rect(left, layout.getLineTop(line), right, layout.getLineBottom(line))
   }
 
+  /** Chip glyph rect in view coordinates, for reporting to JS. */
+  private fun computeChipBounds(
+    layout: Layout,
+    start: Int,
+  ): Rect =
+    chipBoundsInLayout(layout, start).apply {
+      offset(totalPaddingLeft - scrollX, totalPaddingTop - scrollY)
+    }
+
   fun mathChipPositionAtTouch(
     x: Float,
     y: Float,
@@ -869,13 +907,21 @@ class EnrichedMarkdownTextInputView(
     val layoutNow = layout ?: return -1
     val adjustedX = (x - totalPaddingLeft + scrollX).toInt()
     val adjustedY = (y - totalPaddingTop + scrollY).toInt()
-    if (adjustedY < 0) return -1
+    // getLineForVertical and getOffsetForHorizontal both clamp into the laid-out text, so
+    // a touch in the padding or in the blank space below the last line resolves onto the
+    // nearest character. Bound the touch to the text box, then require it to land inside
+    // the chip's own rect — otherwise a tap beside a chip reads as a tap on it.
+    if (adjustedY < 0 || adjustedY > layoutNow.height) return -1
     val line = layoutNow.getLineForVertical(adjustedY)
     val offset = layoutNow.getOffsetForHorizontal(line, adjustedX.toFloat())
-    if (offset < 0 || offset >= editable.length) return -1
+    if (offset < 0) return -1
     val candidates = intArrayOf(offset, offset - 1).filter { it in 0 until editable.length }
     for (candidate in candidates) {
       val range = controller.chipRangeAt(editable, candidate) ?: continue
+      // An empty rect means the layout could not give us the chip's extent; accept the
+      // candidate then, rather than making the chip untappable.
+      val bounds = chipBoundsInLayout(layoutNow, range.first)
+      if (!bounds.isEmpty && !bounds.contains(adjustedX, adjustedY)) continue
       return range.first
     }
     return -1

package/android/src/main/java/com/swmansion/enriched/markdown/input/formatting/BlockSyntaxSentinel.kt

@@ -0,0 +1,69 @@
+package com.swmansion.enriched.markdown.input.formatting
+
+/**
+ * Hides block-level markdown structure from md4c so a document parses as a single
+ * `Paragraph`. Used by `blockSyntax = false` on `EnrichedMarkdownTextInput`.
+ *
+ * Every newline is swapped for a vertical tab (`0x0B`) and one more is prepended.
+ * md4c treats VT as ordinary whitespace, never as a line break, so no line ever
+ * starts at a position where a list marker, `#`, `>` or an indented code block can
+ * be recognised — including line 1, which is what the leading sentinel is for.
+ * Inline syntax (`$...$`, `**...**`, links) still parses normally.
+ *
+ * The transform is 1:1 in characters *and* in UTF-8 bytes (VT and `\n` are both one
+ * of each), so offsets coming back out of the parser only need a flat -1 shift for
+ * the leading sentinel. iOS relies on the same property to keep its byte-to-UTF16
+ * map valid.
+ */
+internal object BlockSyntaxSentinel {
+  const val SENTINEL = '\u000B'
+
+  /**
+   * `\r\n` / `\r` collapse to `\n` (md4c normalizes line endings this way regardless,
+   * so this is pre-existing lossiness, not a new one), and any `0x0B` already present
+   * is dropped — leaving it in would make [decode] silently turn it into a newline.
+   */
+  fun canonicalize(markdown: String): String {
+    val out = StringBuilder(markdown.length)
+    var i = 0
+    while (i < markdown.length) {
+      when (markdown[i]) {
+        '\r' -> {
+          out.append('\n')
+          if (i + 1 < markdown.length && markdown[i + 1] == '\n') i++
+        }
+
+        SENTINEL -> {}
+
+        else -> {
+          out.append(markdown[i])
+        }
+      }
+      i++
+    }
+    return out.toString()
+  }
+
+  /** Prepends one sentinel and replaces every `\n` with one. Length grows by exactly 1. */
+  fun encode(canonical: String): String {
+    val out = StringBuilder(canonical.length + 1)
+    out.append(SENTINEL)
+    for (c in canonical) out.append(if (c == '\n') SENTINEL else c)
+    return out.toString()
+  }
+
+  /**
+   * Reverses [encode] on the parser's plain text. Returns `null` when the leading
+   * sentinel is missing — the caller then falls back to the canonical source with no
+   * ranges rather than emitting text shifted by an offset that no longer holds.
+   */
+  fun decode(plainText: String): String? {
+    if (plainText.isEmpty() || plainText[0] != SENTINEL) return null
+    val out = StringBuilder(plainText.length - 1)
+    for (i in 1 until plainText.length) {
+      val c = plainText[i]
+      out.append(if (c == SENTINEL) '\n' else c)
+    }
+    return out.toString()
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/input/formatting/InputParser.kt

@@ -22,19 +22,73 @@ object InputParser {
   // A source paragraph break: a newline followed by one or more blank lines.
   private val PARAGRAPH_BREAK_RE = Regex("\\n[ \\t]*(?:\\n[ \\t]*)+")
 
-  fun parseToPlainTextAndRanges(markdown: String): ParseResult {
+  fun parseToPlainTextAndRanges(
+    markdown: String,
+    blockSyntax: Boolean = true,
+  ): ParseResult {
     if (markdown.isEmpty()) {
       return ParseResult("", emptyList())
     }
 
-    val completed = InputRemend.complete(markdown)
+    if (!blockSyntax) {
+      return parseWithoutBlockSyntax(markdown)
+    }
+
+    return parseCompleted(InputRemend.complete(markdown), markdown, blockSeparators = true)
+  }
+
+  /**
+   * Parses with every block construct hidden behind [BlockSyntaxSentinel], so the whole
+   * document lands in one `Paragraph` and list markers, `#`, `>` and friends stay in the
+   * text verbatim. `InputRemend` is skipped as well: its speculative closing delimiters
+   * are the other source of characters the serializer cannot replay.
+   */
+  private fun parseWithoutBlockSyntax(markdown: String): ParseResult {
+    val canonical = BlockSyntaxSentinel.canonicalize(markdown)
+    if (canonical.isEmpty()) {
+      return ParseResult("", emptyList())
+    }
+
+    // No block separators: the encoded text has no newline for md4c to drop, so every
+    // newline the replay would add is spurious. `$$...$$` is the case that proves it —
+    // md4c reports display math as a top-level block even mid-line under the sentinel.
+    val parsed = parseCompleted(BlockSyntaxSentinel.encode(canonical), canonical, blockSeparators = false)
+    val decoded =
+      BlockSyntaxSentinel.decode(parsed.plainText)
+        ?: return ParseResult(canonical, emptyList())
+
+    // Only the leading sentinel is removed, so every offset shifts by exactly one.
+    val ranges =
+      parsed.formattingRanges.mapNotNull { range ->
+        val start = range.start - 1
+        val end = range.end - 1
+        if (start < 0 || end > decoded.length || end <= start) {
+          null
+        } else {
+          FormattingRange(range.type, start, end, range.url)
+        }
+      }
+    val atoms =
+      parsed.mathAtoms.mapNotNull { atom ->
+        val position = atom.position - 1
+        if (position < 0 || position >= decoded.length) null else atom.copy(position = position)
+      }
+
+    return ParseResult(decoded, ranges, atoms)
+  }
+
+  private fun parseCompleted(
+    completed: String,
+    fallback: String,
+    blockSeparators: Boolean,
+  ): ParseResult {
     val flags =
       Md4cFlags(
         underline = true,
         latexMath = FeatureFlags.IS_MATH_ENABLED,
         permissiveAutolinks = false,
       )
-    val ast = Parser.shared.parseMarkdown(completed, flags) ?: return ParseResult(markdown, emptyList())
+    val ast = Parser.shared.parseMarkdown(completed, flags) ?: return ParseResult(fallback, emptyList())
 
     val plainText = StringBuilder()
     val ranges = mutableListOf<FormattingRange>()
@@ -43,14 +97,18 @@ object InputParser {
     // md4c collapses any blank-line run into a single break, unlike iOS which keeps them.
     // Re-read the real runs so each break replays its original number of newlines.
     val blankRuns =
-      ArrayDeque(
-        PARAGRAPH_BREAK_RE
-          .findAll(completed.trim())
-          .map { match -> match.value.count { it == '\n' } }
-          .toList(),
-      )
+      if (blockSeparators) {
+        ArrayDeque(
+          PARAGRAPH_BREAK_RE
+            .findAll(completed.trim())
+            .map { match -> match.value.count { it == '\n' } }
+            .toList(),
+        )
+      } else {
+        ArrayDeque()
+      }
 
-    walkNode(ast, plainText, ranges, mathAtoms, ArrayDeque(), blankRuns)
+    walkNode(ast, plainText, ranges, mathAtoms, ArrayDeque(), blankRuns, blockSeparators)
 
     return ParseResult(plainText.toString(), ranges, mathAtoms)
   }
@@ -62,6 +120,7 @@ object InputParser {
     mathAtoms: MutableList<MathAtom>,
     activeStyles: ArrayDeque<ActiveStyle>,
     blankRuns: ArrayDeque<Int>,
+    blockSeparators: Boolean,
   ) {
     if (node.type == NodeType.LatexMathInline || node.type == NodeType.LatexMathDisplay) {
       val latex = extractLatex(node)
@@ -92,10 +151,10 @@ object InputParser {
 
     for ((index, child) in node.children.withIndex()) {
       // Keep the source's blank lines between top-level blocks (md4c drops them, iOS keeps them).
-      if (index > 0 && child.type.isTopLevelBlock() && plainText.isNotEmpty()) {
+      if (blockSeparators && index > 0 && child.type.isTopLevelBlock() && plainText.isNotEmpty()) {
         plainText.append("\n".repeat(blankRuns.removeFirstOrNull() ?: 2))
       }
-      walkNode(child, plainText, ranges, mathAtoms, activeStyles, blankRuns)
+      walkNode(child, plainText, ranges, mathAtoms, activeStyles, blankRuns, blockSeparators)
     }
 
     if (styleType != null) {

package/android/src/main/java/com/swmansion/enriched/markdown/input/layout/InputLayoutManager.kt

@@ -8,21 +8,49 @@ class InputLayoutManager(
 ) {
   private var forceHeightRecalculationCounter = 0
 
+  /**
+   * An invalidation that arrived before `stateWrapper` existed. Fabric applies every prop
+   * (and runs `onAfterUpdateTransaction`) inside `ViewManager.updateProperties`, which runs
+   * *before* `updateState` assigns the wrapper — so the whole mount transaction invalidates
+   * into the void. Without this flag the measurement store stays empty and Yoga keeps the
+   * `initialMeasure()` approximation until the next text/prop change.
+   */
+  private var pending = false
+
   fun invalidateLayout() {
-    if (view.stateWrapper == null) return
+    val stateWrapper = view.stateWrapper
+    if (stateWrapper == null) {
+      pending = true
+      return
+    }
+    pending = false
 
     val text = view.text
     val paint = view.paint
 
+    // First call for this view measures against cachedWidth = 0 and stores a throwaway size;
+    // Yoga immediately re-measures through getMeasureById() with the real width and overwrites
+    // it. The state update below is what makes that second pass happen.
     val needUpdate = InputMeasurementStore.store(view.id, text, paint)
     if (!needUpdate) return
 
     val state = Arguments.createMap()
     state.putInt("forceHeightRecalculationCounter", forceHeightRecalculationCounter++)
-    view.stateWrapper?.updateState(state)
+    stateWrapper.updateState(state)
+  }
+
+  /**
+   * Replays an invalidation that was dropped while `stateWrapper` was null. Called once the
+   * wrapper is assigned, i.e. after every prop of the mount transaction has been applied — so
+   * the text carries its math chips and the paint carries the resolved typeface/size.
+   */
+  fun flushPendingInvalidation() {
+    if (!pending) return
+    invalidateLayout()
   }
 
   fun release() {
+    pending = false
     InputMeasurementStore.release(view.id)
   }
 }