react-native-enriched-markdown-scaffold 0.7.4-scaffold.7 → 0.7.4-scaffold.9

package/android/src/math/java/com/swmansion/enriched/markdown/spans/MathTypeface.kt

@@ -0,0 +1,30 @@
+package com.swmansion.enriched.markdown.spans
+
+import android.graphics.Typeface
+import com.swmansion.enriched.markdown.styles.MathFontWeight
+import io.ratex.RaTeXFontLoader
+
+/**
+ * Typeface supplier for [io.ratex.RaTeXRenderer]. RaTeX resolves every glyph to
+ * a KaTeX font id and asks us for the face to draw it with.
+ *
+ * Takes the raw `fontWeight` string the style model carries — the same shape
+ * every other `fontWeight` prop keeps — and is the single place on Android that
+ * narrows it to a weight we can draw. Consumers pass the style through; nothing
+ * upstream has to know that only two weights are reachable today.
+ *
+ * Bold is SYNTHETIC: asking for [Typeface.BOLD] on a single-weight asset makes
+ * the platform embolden it, which preserves the advances RaTeX already laid the
+ * glyphs out with. Substituting the bundled KaTeX bold faces instead would not
+ * — their advances run up to 15% wider than the regular ones the layout
+ * reserved, so glyphs would collide. iOS reaches the same result by stroking
+ * the glyph outline; see ENRMRaTeXBridge.
+ */
+internal fun ratexTypefaceLoader(fontWeight: String): (String) -> Typeface? =
+  when (MathFontWeight.fromString(fontWeight)) {
+    MathFontWeight.NORMAL -> { fontId -> RaTeXFontLoader.getTypeface(fontId) }
+
+    MathFontWeight.BOLD -> { fontId ->
+      RaTeXFontLoader.getTypeface(fontId)?.let { Typeface.create(it, Typeface.BOLD) }
+    }
+  }

package/android/src/math/java/com/swmansion/enriched/markdown/views/MathContainerView.kt

@@ -15,6 +15,7 @@ import com.swmansion.enriched.markdown.accessibility.AccessibilityLabels
 import com.swmansion.enriched.markdown.spans.MathMeasureHelper
 import com.swmansion.enriched.markdown.spans.MathMeasureRequest
 import com.swmansion.enriched.markdown.spans.MathRenderMode
+import com.swmansion.enriched.markdown.spans.ratexTypefaceLoader
 import com.swmansion.enriched.markdown.styles.MathStyle
 import com.swmansion.enriched.markdown.styles.StyleConfig
 import io.ratex.RaTeXEngine
@@ -100,7 +101,8 @@ class MathContainerView(
     cachedLatex = latex
     try {
       val displayList = RaTeXEngine.parseBlocking(latex, displayMode = true, color = mathStyle.color)
-      mathView.renderer = RaTeXRenderer(displayList, mathStyle.fontSize) { RaTeXFontLoader.getTypeface(it) }
+      mathView.renderer =
+        RaTeXRenderer(displayList, mathStyle.fontSize, ratexTypefaceLoader(mathStyle.fontWeight))
     } catch (e: Exception) {
       Log.e(TAG, "Failed to render LaTeX", e)
       mathView.renderer = null

package/docs/API_REFERENCE.md

@@ -515,6 +515,15 @@ Whether the input is scrollable when content exceeds the visible area.
 | --------- | ------------- | -------- |
 | `boolean` | `true`        | Both     |
 
+### `blockSyntax`
+
+Whether block-level Markdown syntax is interpreted. See
+[Preserving block syntax](./INPUT.md#preserving-block-syntax).
+
+| Type      | Default Value | Platform |
+| --------- | ------------- | -------- |
+| `boolean` | `true`        | Both     |
+
 ### `autoCapitalize`
 
 Auto-capitalization behavior.

package/docs/INPUT.md

@@ -122,6 +122,50 @@ The callback fires only for newly detected links — not for links that were alr
 
 When a manual link is applied (via `setLink` or `insertLink`) over an auto-detected link, the auto-detected link is replaced by the manual one. Auto-link detection skips ranges that already contain a manual link.
 
+## Preserving block syntax
+
+By default the input interprets block-level Markdown: a line starting with `1) `, `- `,
+`# ` or `> ` is consumed as list, heading or quote *structure*, and the marker itself is
+not part of the text. The editor has no block styles to render that structure with and
+the serializer has no way to write the marker back, so the marker is lost on save. Two
+adjacent list items can end up with their formulas touching — `1) $a+b$` and `2) $c+d$`
+save as `$a+b$$c+d$`, where the `$$` now reads as display math.
+
+Set `blockSyntax={false}` when the text must survive the round trip unchanged:
+
+```tsx
+<EnrichedMarkdownTextInput
+  blockSyntax={false}
+  defaultValue={markdown}
+  onChangeMarkdown={setMarkdown}
+/>
+```
+
+In this mode the parser never sees block structure, so markers stay in the text verbatim
+and `onChangeMarkdown` returns what was loaded, byte for byte. Inline syntax is unaffected:
+`**bold**`, `*italic*`, `~~strike~~`, `||spoiler||`, links and `$math$` all still parse and
+style as usual.
+
+What changes:
+
+- **Typing `3) ` no longer starts a list**, and `# ` no longer makes a heading. Nothing
+  block-level is interpreted while typing either — that is the point of the mode.
+- The text is displayed with its markers showing, so an editor with `blockSyntax={false}`
+  and a `EnrichedMarkdownText` rendering the same source look different, even though the
+  stored string is identical.
+- `\r\n` and `\r` are normalized to `\n`, and `U+000B` (vertical tab) is stripped from the
+  input. `U+000B` is used internally to hide line structure from the Markdown parser, so it
+  cannot be carried through as content.
+
+Three inline constructs are still lossy in this mode, exactly as they are with
+`blockSyntax={true}` — they are not regressions introduced by the flag:
+
+| Input | Saved as | Why |
+| --- | --- | --- |
+| `` gõ `x` vào `` | `gõ x vào` | The editor has no inline code style, so the backticks have nothing to round-trip through |
+| `Giá 5\$` | `Giá 5$` | The serializer does not re-escape `\$`, which can leave an unpaired `$` |
+| `A &amp;amp; B` | `A  B` | HTML entity nodes are dropped. A raw `&` is safe |
+
 ## Caret Position Tracking
 
 `EnrichedMarkdownTextInput` can report the caret's pixel position relative to the input, which is useful when the input is embedded in a scrollable container with `scrollEnabled={false}` and you need to keep the caret visible.
@@ -231,3 +275,7 @@ Available style properties:
 - `link.underline` — whether links are underlined (defaults to `true`).
 - `spoiler.color` — text color for spoiler text.
 - `spoiler.backgroundColor` — background color for spoiler text.
+- `math.fontWeight` — `'bold'` | `'normal'` (default `'normal'`); typesets inline formula chips
+  (`$...$`) at bold weight. See [LATEX_MATH.md](./LATEX_MATH.md#bold-formulas).
+- `mathBlock.fontWeight` — same for block formula chips (`$$...$$`); inherits from
+  `math.fontWeight` when unset.

package/docs/LATEX_MATH.md

@@ -47,6 +47,50 @@ what pushes those lines apart. It affects only lines that actually contain inlin
 the line height they had. Set it to `0` to get the old flush behaviour back. Block math (`$$...$$`) has its own
 `math.padding` instead.
 
+### Bold formulas
+
+`math.fontWeight` / `inlineMath.fontWeight` (`'normal'` | `'bold'`, default `'normal'`) typeset a
+formula at bold weight. Set it wherever the surrounding text is bold so the formula follows it.
+
+The embolden is **synthetic on every platform** — no real bold face is ever used.
+
+On **iOS and Android** it is a stroke on the glyph outline and the platform's fake-bold
+respectively, rather than a switch to the bundled KaTeX bold faces. That is deliberate. The native
+engine has no weight parameter, and by the time a style applies, glyph positions are already laid
+out: the bold faces' advances run up to 15% wider than the regular ones the layout reserved, so
+swapping them in would make glyphs collide. Stroking and fake-bold both preserve every advance.
+
+Two consequences worth knowing:
+
+- Fraction bars and rules keep their own thickness, so they do not thicken with the glyphs.
+- On iOS the stroke width also applies to the handful of decorations the engine strokes itself
+  (`\cancel`, `\textcircled`, `\corresponds`, `\imageof`). Prefer turning bold on per surface
+  rather than globally.
+
+On **web** the prop is a plain CSS declaration on the KaTeX output — but the library renders in
+[MathML output mode](#web) and loads no KaTeX stylesheet or fonts, so `font-weight` is resolved by
+the browser's own math font (STIX Two Math, Latin Modern Math, Cambria Math). Most of those ship no
+bold face, so the browser synthesizes one there too. Treat web as synthetic as well, not as a
+reference for how heavy bold "should" look.
+
+`EnrichedMarkdownTextInput` honours the same prop for the formula chips typed into the editor, under
+its own style keys — `math.fontWeight` for inline chips (`$...$`) and `mathBlock.fontWeight` for
+block chips (`$$...$$`). `mathBlock` inherits the weight from `math` when it does not set one of its
+own, the way it already inherits `color` and the border props:
+
+```tsx
+<EnrichedMarkdownTextInput
+  markdownStyle={{
+    math: { fontWeight: 'bold' },       // inline chips bold…
+    mathBlock: { fontWeight: 'normal' }, // …block chips opt back out
+  }}
+/>
+```
+
+The caveats above apply unchanged — the embolden is the same synthetic one, and the chip keeps its
+measured width because fake-bold and stroking both preserve the glyph advances. Editor chips are
+iOS + Android only; there is no web or macOS chip surface.
+
 > [!IMPORTANT]
 > LaTeX commands use backslashes (e.g. `\frac`, `\alpha`). In regular JS strings and template literals, backslashes are escape characters. Use `String.raw` or double backslashes (`\\frac`) to preserve them. Block math (`$$...$$`) must be on its own line to render as a display element.
 
@@ -66,6 +110,11 @@ yarn add katex
 
 KaTeX is loaded lazily the first time a LaTeX node is encountered, so it has no impact on pages that do not render math. No stylesheet or `<link>` tag is needed.
 
+If you load `katex/dist/katex.min.css` anyway — some setups do — its `.katex` rule opens with the
+`font` shorthand, which resets `font-weight` and would drop [`fontWeight`](#bold-formulas) on the
+way down to the formula. The library injects `.katex { font-weight: inherit; }` to keep the prop
+working in that case; nothing is required of you.
+
 > [!NOTE]
 > MathML is supported natively in Chrome 109+, Firefox, and Safari. Older browsers will display the raw LaTeX source as a text fallback.
 

package/docs/STYLES.md

@@ -179,10 +179,12 @@ The library provides sensible default styles for all Markdown elements out of th
       padding: 12,
       marginBottom: 16,
       textAlign: 'center',
+      fontWeight: 'normal',
     },
     inlineMath: {
       color: '#1F2937',
       paddingVertical: 4,
+      fontWeight: 'normal',
     },
     spoiler: {
       color: '#6B7280',

package/ios/attachments/ENRMMathInlineAttachment+macOS.m

@@ -25,7 +25,11 @@
 - (void)renderForMacOS
 {
   RCTUIColor *color = self.mathTextColor ?: [RCTUIColor blackColor];
-  ENRMRaTeXRenderResult *result = [ENRMRaTeXBridge parse:self.latex displayMode:NO fontSize:self.fontSize color:color];
+  ENRMRaTeXRenderResult *result = [ENRMRaTeXBridge parse:self.latex
+                                             displayMode:NO
+                                                fontSize:self.fontSize
+                                                   color:color
+                                                    bold:self.bold];
   if (!result)
     return;
 

package/ios/attachments/ENRMMathInlineAttachment.h

@@ -9,6 +9,9 @@ NS_ASSUME_NONNULL_BEGIN
 @property (nonatomic, assign) CGFloat fontSize;
 @property (nonatomic, strong, nullable) RCTUIColor *mathTextColor;
 
+/// Typeset the glyphs at bold weight (synthetic — see ENRMRaTeXBridge).
+@property (nonatomic, assign) BOOL bold;
+
 /// YES if block math (`$$...$$`), NO for inline (`$...$`).
 @property (nonatomic, assign) BOOL displayMode;
 

package/ios/attachments/ENRMMathInlineAttachment.m

@@ -21,7 +21,8 @@
   ENRMRaTeXRenderResult *result = [ENRMRaTeXBridge parse:self.latex
                                              displayMode:self.displayMode
                                                 fontSize:self.fontSize
-                                                   color:color];
+                                                   color:color
+                                                    bold:self.bold];
   if (!result)
     return;
 

package/ios/generated/ReactCodegen/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/ios/generated/ReactCodegen/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) {
@@ -1599,6 +1605,7 @@ static inline folly::dynamic toDynamic(const EnrichedMarkdownMarkdownStyleMathSt
 struct EnrichedMarkdownMarkdownStyleInlineMathStruct {
   SharedColor color{};
   Float paddingVertical{0.0};
+  std::string fontWeight{};
 
 
 #ifdef RN_SERIALIZABLE_STATE
@@ -1608,6 +1615,7 @@ struct EnrichedMarkdownMarkdownStyleInlineMathStruct {
     folly::dynamic result = folly::dynamic::object();
     result["color"] = ::facebook::react::toDynamic(color);
     result["paddingVertical"] = paddingVertical;
+    result["fontWeight"] = fontWeight;
     return result;
   }
 #endif
@@ -1624,6 +1632,10 @@ static inline void fromRawValue(const PropsParserContext& context, const RawValu
   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) {
@@ -2810,6 +2822,7 @@ struct EnrichedMarkdownTextInputMarkdownStyleMathStruct {
   Float paddingVertical{0.0};
   SharedColor selectedBackgroundColor{};
   SharedColor selectedBorderColor{};
+  std::string fontWeight{};
 
 
 #ifdef RN_SERIALIZABLE_STATE
@@ -2827,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
@@ -2875,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) {
@@ -2898,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{};
@@ -2918,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;
@@ -2969,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);
@@ -3335,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{};
@@ -4878,6 +4903,7 @@ struct EnrichedMarkdownTextMarkdownStyleMathStruct {
   Float marginTop{0.0};
   Float marginBottom{0.0};
   std::string textAlign{};
+  std::string fontWeight{};
 
 
 #ifdef RN_SERIALIZABLE_STATE
@@ -4892,6 +4918,7 @@ struct EnrichedMarkdownTextMarkdownStyleMathStruct {
     result["marginTop"] = marginTop;
     result["marginBottom"] = marginBottom;
     result["textAlign"] = textAlign;
+    result["fontWeight"] = fontWeight;
     return result;
   }
 #endif
@@ -4928,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) {
@@ -4943,6 +4974,7 @@ static inline folly::dynamic toDynamic(const EnrichedMarkdownTextMarkdownStyleMa
 struct EnrichedMarkdownTextMarkdownStyleInlineMathStruct {
   SharedColor color{};
   Float paddingVertical{0.0};
+  std::string fontWeight{};
 
 
 #ifdef RN_SERIALIZABLE_STATE
@@ -4952,6 +4984,7 @@ struct EnrichedMarkdownTextMarkdownStyleInlineMathStruct {
     folly::dynamic result = folly::dynamic::object();
     result["color"] = ::facebook::react::toDynamic(color);
     result["paddingVertical"] = paddingVertical;
+    result["fontWeight"] = fontWeight;
     return result;
   }
 #endif
@@ -4968,6 +5001,10 @@ static inline void fromRawValue(const PropsParserContext& context, const RawValu
   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/ios/input/ENRMBlockSyntaxSentinel.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Vertical tab. md4c treats it as ordinary whitespace, never as a line break.
+extern const unichar ENRMBlockSyntaxSentinelChar;
+
+/// Collapses `\r\n` / `\r` to `\n` and drops any `0x0B` already in the input.
+/// Dropping is deliberate: a pre-existing `0x0B` would come back out of
+/// `ENRMBlockSyntaxDecode` as a newline and silently corrupt the text.
+NSString *ENRMBlockSyntaxCanonicalize(NSString *markdown);
+
+/// Prepends one sentinel and replaces every `\n` with one. Grows the string by
+/// exactly one character and one UTF-8 byte, which is what keeps the parser's
+/// byte-to-UTF16 map valid and the offset correction a flat -1.
+NSString *ENRMBlockSyntaxEncode(NSString *canonical);
+
+/// Reverses `ENRMBlockSyntaxEncode`. Returns nil when the leading sentinel is
+/// missing, so the caller can fall back instead of shifting offsets that no
+/// longer hold.
+NSString *_Nullable ENRMBlockSyntaxDecode(NSString *plainText);
+
+NS_ASSUME_NONNULL_END

package/ios/input/ENRMBlockSyntaxSentinel.mm

@@ -0,0 +1,80 @@
+#import "ENRMBlockSyntaxSentinel.h"
+
+#import <vector>
+
+const unichar ENRMBlockSyntaxSentinelChar = 0x000B;
+
+NSString *ENRMBlockSyntaxCanonicalize(NSString *markdown)
+{
+  NSUInteger length = markdown.length;
+  if (length == 0) {
+    return @"";
+  }
+
+  std::vector<unichar> source(length);
+  [markdown getCharacters:source.data() range:NSMakeRange(0, length)];
+
+  std::vector<unichar> out;
+  out.reserve(length);
+
+  for (NSUInteger i = 0; i < length; i++) {
+    unichar c = source[i];
+    if (c == '\r') {
+      out.push_back('\n');
+      if (i + 1 < length && source[i + 1] == '\n') {
+        i++;
+      }
+    } else if (c != ENRMBlockSyntaxSentinelChar) {
+      out.push_back(c);
+    }
+  }
+
+  // `out.data()` on an empty vector may be null, which -stringWithCharacters: rejects.
+  if (out.empty()) {
+    return @"";
+  }
+
+  return [NSString stringWithCharacters:out.data() length:out.size()];
+}
+
+NSString *ENRMBlockSyntaxEncode(NSString *canonical)
+{
+  NSUInteger length = canonical.length;
+
+  std::vector<unichar> out;
+  out.reserve(length + 1);
+  out.push_back(ENRMBlockSyntaxSentinelChar);
+
+  if (length > 0) {
+    std::vector<unichar> source(length);
+    [canonical getCharacters:source.data() range:NSMakeRange(0, length)];
+    for (NSUInteger i = 0; i < length; i++) {
+      out.push_back(source[i] == '\n' ? ENRMBlockSyntaxSentinelChar : source[i]);
+    }
+  }
+
+  return [NSString stringWithCharacters:out.data() length:out.size()];
+}
+
+NSString *ENRMBlockSyntaxDecode(NSString *plainText)
+{
+  NSUInteger length = plainText.length;
+  if (length == 0 || [plainText characterAtIndex:0] != ENRMBlockSyntaxSentinelChar) {
+    return nil;
+  }
+
+  std::vector<unichar> source(length);
+  [plainText getCharacters:source.data() range:NSMakeRange(0, length)];
+
+  std::vector<unichar> out;
+  out.reserve(length - 1);
+  for (NSUInteger i = 1; i < length; i++) {
+    out.push_back(source[i] == ENRMBlockSyntaxSentinelChar ? '\n' : source[i]);
+  }
+
+  if (out.empty()) {
+    return @"";
+  }
+
+  return [NSString stringWithCharacters:out.data() length:out.size()];
+}

package/ios/input/ENRMInputFormatter.h

@@ -50,6 +50,8 @@ NS_ASSUME_NONNULL_BEGIN
 @property (nonatomic, assign) CGFloat mathPaddingVertical;
 @property (nonatomic, strong, nullable) RCTUIColor *mathSelectedBackgroundColor;
 @property (nonatomic, strong, nullable) RCTUIColor *mathSelectedBorderColor;
+/// Raw `fontWeight` string; narrowed at the draw site (see ENRMMathFontWeight.h).
+@property (nonatomic, copy, nullable) NSString *mathFontWeight;
 
 /// Math block (`$$...$$`)
 @property (nonatomic, strong, nullable) RCTUIColor *mathBlockColor;
@@ -65,6 +67,8 @@ NS_ASSUME_NONNULL_BEGIN
 @property (nonatomic, assign) CGFloat mathBlockMarginTop;
 @property (nonatomic, assign) CGFloat mathBlockMarginBottom;
 @property (nonatomic, assign) NSTextAlignment mathBlockAlignment;
+/// Raw `fontWeight` string; narrowed at the draw site (see ENRMMathFontWeight.h).
+@property (nonatomic, copy, nullable) NSString *mathBlockFontWeight;
 
 - (UIFont *)fontForTraits:(UIFontDescriptorSymbolicTraits)traits;
 - (void)invalidateFontCache;

package/ios/input/ENRMInputFormatter.mm

@@ -56,6 +56,7 @@
   copy.mathPaddingVertical = _mathPaddingVertical;
   copy.mathSelectedBackgroundColor = _mathSelectedBackgroundColor;
   copy.mathSelectedBorderColor = _mathSelectedBorderColor;
+  copy.mathFontWeight = _mathFontWeight;
   copy.mathBlockColor = _mathBlockColor;
   copy.mathBlockFontSize = _mathBlockFontSize;
   copy.mathBlockBackgroundColor = _mathBlockBackgroundColor;
@@ -69,6 +70,7 @@
   copy.mathBlockMarginTop = _mathBlockMarginTop;
   copy.mathBlockMarginBottom = _mathBlockMarginBottom;
   copy.mathBlockAlignment = _mathBlockAlignment;
+  copy.mathBlockFontWeight = _mathBlockFontWeight;
   return copy;
 }
 

package/ios/input/ENRMInputParser.h

@@ -22,6 +22,11 @@ NS_ASSUME_NONNULL_BEGIN
 
 - (ENRMParseResult *)parseToPlainTextAndRanges:(NSString *)markdown;
 
+/// `blockSyntax = NO` hides block structure from md4c (see ENRMBlockSyntaxSentinel)
+/// and skips `ENRMInputRemendComplete`, so list markers, headings and blockquotes
+/// survive as text and the markdown round-trips byte-for-byte.
+- (ENRMParseResult *)parseToPlainTextAndRanges:(NSString *)markdown blockSyntax:(BOOL)blockSyntax;
+
 @end
 
 NS_ASSUME_NONNULL_END