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

package/ios/input/ENRMInputParser.mm

@@ -1,4 +1,5 @@
 #import "ENRMInputParser.h"
+#import "ENRMBlockSyntaxSentinel.h"
 #import "ENRMFormattingRange.h"
 #import "ENRMInputRemend.h"
 #include "md4c.h"
@@ -14,6 +15,11 @@
 @implementation ENRMParseResult
 @end
 
+@interface ENRMInputParser ()
+/// Shared body of both public entry points. `remend` gates `ENRMInputRemendComplete`.
+- (ENRMParseResult *)parseToPlainTextAndRanges:(NSString *)markdown remend:(BOOL)remend;
+@end
+
 @implementation ENRMMathAtom
 @end
 
@@ -256,9 +262,9 @@ static int onText(MD_TEXTTYPE textType, const MD_CHAR *text, MD_SIZE size, void
   return 0;
 }
 
-static bool runMd4cParse(NSString *markdown, ParseContext &context)
+static bool runMd4cParse(NSString *markdown, ParseContext &context, bool remend)
 {
-  NSString *completed = ENRMInputRemendComplete(markdown);
+  NSString *completed = remend ? ENRMInputRemendComplete(markdown) : markdown;
   const char *completedUTF8 = [completed UTF8String];
   size_t completedLength = strlen(completedUTF8);
   size_t originalLength = [markdown lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
@@ -286,14 +292,14 @@ struct ParsedSpans {
   std::vector<MathSpanInfo> mathSpans;
 };
 
-static NSArray<ENRMInputStyledRange *> *runParseInternal(NSString *markdown, ParsedSpans &out)
+static NSArray<ENRMInputStyledRange *> *runParseInternal(NSString *markdown, ParsedSpans &out, bool remend)
 {
   if (markdown.length == 0) {
     return @[];
   }
 
   ParseContext context;
-  if (!runMd4cParse(markdown, context)) {
+  if (!runMd4cParse(markdown, context, remend)) {
     return @[];
   }
 
@@ -355,10 +361,77 @@ static NSArray<ENRMInputStyledRange *> *runParseInternal(NSString *markdown, Par
 - (NSArray<ENRMInputStyledRange *> *)parse:(NSString *)markdown
 {
   ParsedSpans spans;
-  return runParseInternal(markdown, spans);
+  return runParseInternal(markdown, spans, /* remend */ true);
 }
 
 - (ENRMParseResult *)parseToPlainTextAndRanges:(NSString *)markdown
+{
+  return [self parseToPlainTextAndRanges:markdown remend:YES];
+}
+
+- (ENRMParseResult *)parseToPlainTextAndRanges:(NSString *)markdown blockSyntax:(BOOL)blockSyntax
+{
+  if (blockSyntax) {
+    return [self parseToPlainTextAndRanges:markdown];
+  }
+
+  NSString *canonical = ENRMBlockSyntaxCanonicalize(markdown);
+  if (canonical.length == 0) {
+    ENRMParseResult *empty = [[ENRMParseResult alloc] init];
+    empty.plainText = @"";
+    empty.formattingRanges = @[];
+    empty.mathAtoms = @[];
+    return empty;
+  }
+
+  // Remending is skipped too: its speculative closing delimiters are the other
+  // source of characters the serializer cannot replay.
+  ENRMParseResult *encoded = [self parseToPlainTextAndRanges:ENRMBlockSyntaxEncode(canonical) remend:NO];
+
+  NSString *decoded = ENRMBlockSyntaxDecode(encoded.plainText);
+  ENRMParseResult *result = [[ENRMParseResult alloc] init];
+
+  if (decoded == nil) {
+    result.plainText = canonical;
+    result.formattingRanges = @[];
+    result.mathAtoms = @[];
+    return result;
+  }
+
+  // Only the leading sentinel was removed, so every offset shifts by exactly one.
+  NSUInteger decodedLength = decoded.length;
+
+  NSMutableArray<ENRMFormattingRange *> *shiftedRanges =
+      [NSMutableArray arrayWithCapacity:encoded.formattingRanges.count];
+  for (ENRMFormattingRange *range in encoded.formattingRanges) {
+    NSRange r = range.range;
+    if (r.location == 0 || r.length == 0 || NSMaxRange(r) - 1 > decodedLength) {
+      continue;
+    }
+    [shiftedRanges addObject:[ENRMFormattingRange rangeWithType:range.type
+                                                          range:NSMakeRange(r.location - 1, r.length)
+                                                            url:range.url]];
+  }
+
+  NSMutableArray<ENRMMathAtom *> *shiftedAtoms = [NSMutableArray arrayWithCapacity:encoded.mathAtoms.count];
+  for (ENRMMathAtom *atom in encoded.mathAtoms) {
+    if (atom.position == 0 || atom.position - 1 >= decodedLength) {
+      continue;
+    }
+    ENRMMathAtom *shifted = [[ENRMMathAtom alloc] init];
+    shifted.position = atom.position - 1;
+    shifted.latex = atom.latex;
+    shifted.displayMode = atom.displayMode;
+    [shiftedAtoms addObject:shifted];
+  }
+
+  result.plainText = decoded;
+  result.formattingRanges = shiftedRanges;
+  result.mathAtoms = shiftedAtoms;
+  return result;
+}
+
+- (ENRMParseResult *)parseToPlainTextAndRanges:(NSString *)markdown remend:(BOOL)remend
 {
   ENRMParseResult *parseResult = [[ENRMParseResult alloc] init];
 
@@ -370,7 +443,7 @@ static NSArray<ENRMInputStyledRange *> *runParseInternal(NSString *markdown, Par
   }
 
   ParsedSpans parsedSpans;
-  NSArray<ENRMInputStyledRange *> *styledRanges = runParseInternal(markdown, parsedSpans);
+  NSArray<ENRMInputStyledRange *> *styledRanges = runParseInternal(markdown, parsedSpans, remend);
 
   // Compute byte map + raw byte ranges for math spans so we can strip the
   // entire `$...$` (or `$$...$$`) syntax and inject a single `` at each.

package/ios/input/EnrichedMarkdownTextInput.mm

@@ -13,6 +13,7 @@
 #import "ENRMInputTextView.h"
 #import "ENRMLinkRegexConfig.h"
 #import "ENRMMarkdownSerializer.h"
+#import "ENRMMathFontWeight.h"
 #if ENRICHED_MARKDOWN_MATH
 #import "ENRMMathInlineAttachment.h"
 #endif
@@ -68,6 +69,8 @@ using namespace facebook::react;
   BOOL _isApplyingFormatting;
   BOOL _isTextChanging;
   BOOL _emitMarkdown;
+  BOOL _blockSyntax;
+  NSString *_lastImportedMarkdown;
   CFTimeInterval _lastTextChangeTime;
 
   ENRMPlaceholderLabel *_placeholderLabel;
@@ -142,6 +145,8 @@ using namespace facebook::react;
 
     self.backgroundColor = [RCTUIColor clearColor];
     _blockEmitting = NO;
+    _blockSyntax = YES;
+    _lastImportedMarkdown = nil;
     _heightUpdateCounter = 0;
     _formatter = [[ENRMInputFormatter alloc] init];
     _formatterStyle = [[ENRMInputFormatterStyle alloc] init];
@@ -253,6 +258,20 @@ using namespace facebook::react;
 
 #if ENRICHED_MARKDOWN_MATH && !TARGET_OS_OSX
 
+// Glyph rect of the chip at `index`, in _textView coordinates (the same space
+// `locationInView:_textView` reports). Single source of truth for both the tap
+// hit-test and the rect reported to JS.
+- (CGRect)mathChipRectInTextViewAtIndex:(NSUInteger)index layoutManager:(NSLayoutManager *)lm
+{
+  if (lm == nil)
+    return CGRectNull;
+  NSRange glyphRange = [lm glyphRangeForCharacterRange:NSMakeRange(index, 1) actualCharacterRange:NULL];
+  CGRect rect = [lm boundingRectForGlyphRange:glyphRange inTextContainer:_textView.textContainer];
+  rect.origin.x += _textView.textContainerInset.left;
+  rect.origin.y += _textView.textContainerInset.top;
+  return rect;
+}
+
 - (void)handleTapForMathChip:(UITapGestureRecognizer *)gesture
 {
   if (gesture.state != UIGestureRecognizerStateRecognized)
@@ -265,23 +284,28 @@ using namespace facebook::react;
   if (idx < 0)
     return;
   NSTextStorage *storage = _textView.textStorage;
-  // The closest position can land just past the chip; probe both `idx` and `idx-1`.
+  NSLayoutManager *lm = storage.layoutManagers.firstObject;
+  // The closest position can land just past the chip, so probe both `idx` and `idx-1`.
+  // `closestPositionToPoint:` has no distance bound — it clamps a tap anywhere in the
+  // text view (blank space past the text, textContainerInset padding) onto the nearest
+  // character. Requiring the touch to fall inside the chip's own glyph rect is what
+  // keeps a tap beside a chip from reading as a tap on it.
   ENRMMathInlineAttachment *att = nil;
   NSUInteger chipIdx = NSNotFound;
-  if ((NSUInteger)idx < storage.length) {
-    id v = [storage attribute:NSAttachmentAttributeName atIndex:(NSUInteger)idx effectiveRange:NULL];
-    if ([v isKindOfClass:[ENRMMathInlineAttachment class]]) {
-      att = v;
-      chipIdx = (NSUInteger)idx;
-    }
-  }
-  if (!att && idx > 0) {
-    NSUInteger probe = (NSUInteger)idx - 1;
-    id v = [storage attribute:NSAttachmentAttributeName atIndex:probe effectiveRange:NULL];
-    if ([v isKindOfClass:[ENRMMathInlineAttachment class]]) {
-      att = v;
-      chipIdx = probe;
-    }
+  for (NSInteger probe = idx; probe >= idx - 1; probe--) {
+    if (probe < 0 || (NSUInteger)probe >= storage.length)
+      continue;
+    id v = [storage attribute:NSAttachmentAttributeName atIndex:(NSUInteger)probe effectiveRange:NULL];
+    if (![v isKindOfClass:[ENRMMathInlineAttachment class]])
+      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.
+    CGRect rect = [self mathChipRectInTextViewAtIndex:(NSUInteger)probe layoutManager:lm];
+    if (!CGRectIsEmpty(rect) && !CGRectContainsPoint(rect, loc))
+      continue;
+    att = v;
+    chipIdx = (NSUInteger)probe;
+    break;
   }
   if (!att)
     return;
@@ -290,7 +314,6 @@ using namespace facebook::react;
   [self clearMathChipSelectionsExcept:chipRange];
   att.isSelected = YES;
   [att invalidateRender];
-  NSLayoutManager *lm = storage.layoutManagers.firstObject;
   if (lm) {
     [lm invalidateLayoutForCharacterRange:chipRange actualCharacterRange:NULL];
     [lm ensureLayoutForCharacterRange:chipRange];
@@ -306,10 +329,8 @@ using namespace facebook::react;
   _suppressMathChipClearOnce = YES;
   _textView.selectedRange = NSMakeRange(caretIndex, 0);
 
-  NSRange glyphRange = [lm glyphRangeForCharacterRange:chipRange actualCharacterRange:NULL];
-  CGRect glyphRect = [lm boundingRectForGlyphRange:glyphRange inTextContainer:_textView.textContainer];
-  glyphRect.origin.x += _textView.textContainerInset.left;
-  glyphRect.origin.y += _textView.textContainerInset.top;
+  // Recomputed rather than reused from the hit-test: the layout was invalidated above.
+  CGRect glyphRect = [self mathChipRectInTextViewAtIndex:chipIdx layoutManager:lm];
   CGRect rectInSelf = [self.contentView convertRect:glyphRect fromView:_textView];
 
   [self emitOnMathPressWithLatex:att.latex start:chipIdx end:chipIdx + 1 displayMode:att.displayMode rect:rectInSelf];
@@ -546,11 +567,20 @@ using namespace facebook::react;
     writingDirectionChanged = YES;
   }
 
+  // Must land before the defaultValue import below, so the first parse already sees
+  // the right flag. Assigned unconditionally, not just on change: the generated C++
+  // default is `false` while the JS default is `true`, so `blockSyntax={false}` on the
+  // first render compares equal to the old props and a change-guard would drop it.
+  BOOL blockSyntaxChanged = (_blockSyntax != (BOOL)newViewProps.blockSyntax);
+  _blockSyntax = newViewProps.blockSyntax;
+
   if (newViewProps.defaultValue != oldViewProps.defaultValue) {
     if (!newViewProps.defaultValue.empty() && oldViewProps.defaultValue.empty()) {
       NSString *markdown = [NSString stringWithUTF8String:newViewProps.defaultValue.c_str()];
       [self importMarkdown:markdown];
     }
+  } else if (blockSyntaxChanged && _lastImportedMarkdown != nil) {
+    [self importMarkdown:_lastImportedMarkdown];
   }
 
   if (styleChanged) {
@@ -694,8 +724,9 @@ using namespace facebook::react;
 
 - (void)importMarkdown:(NSString *)markdown
 {
+  _lastImportedMarkdown = [markdown copy];
   ENRMInputParser *parser = [[ENRMInputParser alloc] init];
-  ENRMParseResult *parsed = [parser parseToPlainTextAndRanges:markdown];
+  ENRMParseResult *parsed = [parser parseToPlainTextAndRanges:markdown blockSyntax:_blockSyntax];
 
   _blockEmitting = YES;
 
@@ -754,6 +785,7 @@ using namespace facebook::react;
     att.blockAlignment = _formatterStyle.mathBlockAlignment;
     att.selectedBackgroundColor = _formatterStyle.mathBlockSelectedBackgroundColor;
     att.selectedBorderColor = _formatterStyle.mathBlockSelectedBorderColor;
+    att.bold = ENRMMathFontWeightIsBold(_formatterStyle.mathBlockFontWeight);
   } else {
     att.fontSize = _formatterStyle.mathFontSize > 0 ? _formatterStyle.mathFontSize : 16.0;
     att.mathTextColor = _formatterStyle.mathColor ?: _formatterStyle.baseTextColor;
@@ -768,6 +800,7 @@ using namespace facebook::react;
     att.blockAlignment = NSTextAlignmentNatural;
     att.selectedBackgroundColor = _formatterStyle.mathSelectedBackgroundColor;
     att.selectedBorderColor = _formatterStyle.mathSelectedBorderColor;
+    att.bold = ENRMMathFontWeightIsBold(_formatterStyle.mathFontWeight);
   }
 }
 
@@ -854,7 +887,7 @@ using namespace facebook::react;
 - (void)pasteMarkdown:(NSString *)markdown
 {
   ENRMInputParser *parser = [[ENRMInputParser alloc] init];
-  ENRMParseResult *parsed = [parser parseToPlainTextAndRanges:markdown];
+  ENRMParseResult *parsed = [parser parseToPlainTextAndRanges:markdown blockSyntax:_blockSyntax];
   [self replaceSelectedTextWith:parsed.plainText formattingRanges:parsed.formattingRanges];
 }
 

package/ios/input/InputStylePropsUtils.h

@@ -187,6 +187,12 @@ BOOL applyInputStyleProps(ENRMInputFormatterStyle *style, const InputProps &newP
     style.mathSelectedBorderColor = (sbc && CGColorGetAlpha(sbc.CGColor) > 0) ? sbc : nil;
     changed = YES;
   }
+  if (newProps.markdownStyle.math.fontWeight != oldProps.markdownStyle.math.fontWeight) {
+    if (!newProps.markdownStyle.math.fontWeight.empty()) {
+      style.mathFontWeight = [[NSString alloc] initWithUTF8String:newProps.markdownStyle.math.fontWeight.c_str()];
+      changed = YES;
+    }
+  }
 
   // Math block (`$$...$$`)
   if (newProps.markdownStyle.mathBlock.color != oldProps.markdownStyle.mathBlock.color) {
@@ -237,6 +243,13 @@ BOOL applyInputStyleProps(ENRMInputFormatterStyle *style, const InputProps &newP
     style.mathBlockSelectedBorderColor = (sbc && CGColorGetAlpha(sbc.CGColor) > 0) ? sbc : nil;
     changed = YES;
   }
+  if (newProps.markdownStyle.mathBlock.fontWeight != oldProps.markdownStyle.mathBlock.fontWeight) {
+    if (!newProps.markdownStyle.mathBlock.fontWeight.empty()) {
+      style.mathBlockFontWeight =
+          [[NSString alloc] initWithUTF8String:newProps.markdownStyle.mathBlock.fontWeight.c_str()];
+      changed = YES;
+    }
+  }
   if (newProps.markdownStyle.mathBlock.marginTop != oldProps.markdownStyle.mathBlock.marginTop) {
     style.mathBlockMarginTop = newProps.markdownStyle.mathBlock.marginTop;
     changed = YES;

package/ios/internals/MeasurementCache.h

@@ -131,6 +131,7 @@ template <typename StyleStruct> inline size_t computeStyleFingerprint(const Styl
   hashFields(s.table.headerFontFamily, s.table.cellPaddingHorizontal, s.table.cellPaddingVertical, s.table.borderWidth,
              s.table.borderRadius);
   hashFields(s.math.fontSize, s.math.padding, s.math.marginTop, s.math.marginBottom, s.math.textAlign);
+  hashFields(s.inlineMath.paddingVertical);
   hashFields(s.taskList.checkboxSize, s.taskList.checkboxBorderRadius);
 
   return h;

package/ios/math/ENRMRaTeXBridge.swift

@@ -10,17 +10,45 @@ import AppKit
 private typealias UIColor = NSColor
 #endif
 
+/// Weight a formula is typeset at.
+///
+/// An enum rather than the `BOOL` that crosses the ObjC boundary so the draw
+/// path's switch turns a third weight into a compile error. Mirrors
+/// MathFontWeight.kt on Android.
+private enum MathFontWeight {
+  case normal
+  case bold
+
+  init(bold: Bool) {
+    self = bold ? .bold : .normal
+  }
+
+  /// Stroke added to each glyph outline, as a fraction of the em size. Scales
+  /// with the formula so a display block and an inline fraction read alike.
+  var strokeEmRatio: CGFloat {
+    switch self {
+    case .normal: return 0
+    case .bold: return 0.035
+    }
+  }
+}
+
 @objc(ENRMRaTeXRenderResult)
 public final class ENRMRaTeXRenderResult: NSObject {
   private let renderer: RaTeXRenderer
+  /// Non-zero only in bold mode: half of it grows the glyph ink on each side.
+  private let boldStrokeWidth: CGFloat
+  private let boldStrokeColor: CGColor?
 
   @objc public let width: CGFloat
   @objc public let ascent: CGFloat
   @objc public let descent: CGFloat
   @objc public var totalHeight: CGFloat { ascent + descent }
 
-  init(renderer: RaTeXRenderer) {
+  init(renderer: RaTeXRenderer, boldStrokeWidth: CGFloat, boldStrokeColor: CGColor?) {
     self.renderer = renderer
+    self.boldStrokeWidth = boldStrokeWidth
+    self.boldStrokeColor = boldStrokeColor
     self.width = renderer.width
     self.ascent = renderer.height
     self.descent = renderer.depth
@@ -28,7 +56,22 @@ public final class ENRMRaTeXRenderResult: NSObject {
   }
 
   @objc public func draw(in context: CGContext) {
+    guard boldStrokeWidth > 0, let boldStrokeColor else {
+      renderer.draw(in: context)
+      return
+    }
+    // Synthetic bold: stroke each glyph outline over its fill, the only way to
+    // add weight without moving glyphs whose positions RaTeX has already fixed
+    // (the KaTeX bold faces run up to 15% wider and would collide). It reaches
+    // every glyph because RaTeXRenderer.drawGlyph sets no text drawing mode of
+    // its own, including the paths RaTeX strokes itself (\cancel, \textcircled),
+    // which is why bold is opt-in per surface.
+    context.saveGState()
+    context.setTextDrawingMode(.fillStroke)
+    context.setLineWidth(boldStrokeWidth)
+    context.setStrokeColor(boldStrokeColor)
     renderer.draw(in: context)
+    context.restoreGState()
   }
 }
 
@@ -43,13 +86,19 @@ public final class ENRMRaTeXBridge: NSObject {
     _ latex: String,
     displayMode: Bool,
     fontSize: CGFloat,
-    color: UIColor
+    color: UIColor,
+    bold: Bool
   ) -> ENRMRaTeXRenderResult? {
     RaTeXFontLoader.ensureLoaded()
     do {
       let displayList = try RaTeXEngine.shared.parse(latex, displayMode: displayMode, color: color)
       let renderer = RaTeXRenderer(displayList: displayList, fontSize: fontSize)
-      return ENRMRaTeXRenderResult(renderer: renderer)
+      let strokeWidth = fontSize * MathFontWeight(bold: bold).strokeEmRatio
+      return ENRMRaTeXRenderResult(
+        renderer: renderer,
+        boldStrokeWidth: strokeWidth,
+        boldStrokeColor: strokeWidth > 0 ? color.cgColor : nil
+      )
     } catch {
       NSLog("[RaTeX] Failed to parse LaTeX: %@", error.localizedDescription)
       return nil

package/ios/parser/ENRMMarkdownParser.h

@@ -11,6 +11,14 @@
 
 + (instancetype)defaultFlags;
 
+/// Flags matching the codegen `md4cFlags` Props defaults (every flag off).
+///
+/// Components mirror `md4cFlags` into an ivar with a per-field diff against the
+/// props baseline, so the ivar has to start from the same baseline the props do.
+/// `defaultFlags` enables `latexMath`, which is the right default for the
+/// standalone parser API but would make a `latexMath: false` prop a no-op.
++ (instancetype)propsDefaultFlags;
+
 @end
 
 @interface ENRMMarkdownParser : NSObject

package/ios/parser/ENRMMarkdownParser.mm

@@ -22,6 +22,17 @@ extern MarkdownASTNode *parseMarkdownWithCppParser(NSString *markdown, ENRMMd4cF
   return [[ENRMMd4cFlags alloc] init];
 }
 
++ (instancetype)propsDefaultFlags
+{
+  ENRMMd4cFlags *flags = [[ENRMMd4cFlags alloc] init];
+  flags.underline = NO;
+  flags.latexMath = NO;
+  flags.superscript = NO;
+  flags.subscript = NO;
+  flags.highlight = NO;
+  return flags;
+}
+
 - (id)copyWithZone:(NSZone *)zone
 {
   ENRMMd4cFlags *copy = [[ENRMMd4cFlags allocWithZone:zone] init];

package/ios/renderer/ENRMMathInlineRenderer.m

@@ -1,4 +1,5 @@
 #import "ENRMMathInlineRenderer.h"
+#import "ENRMMathFontWeight.h"
 #import "ENRMMathInlineAttachment.h"
 #import "MarkdownASTNode.h"
 #import "RenderContext.h"
@@ -25,6 +26,8 @@
   attachment.latex = latex;
   attachment.fontSize = currentFont ? currentFont.pointSize : [_config paragraphFontSize];
   attachment.mathTextColor = [_config inlineMathColor];
+  attachment.containerPaddingVertical = [_config inlineMathPaddingVertical];
+  attachment.bold = ENRMMathFontWeightIsBold([_config inlineMathFontWeight]);
 
 #if TARGET_OS_OSX
   // On macOS, NSLayoutManager uses self.image/self.bounds rather than calling

package/ios/renderer/ListItemRenderer.m

@@ -109,15 +109,18 @@ NSString *const TaskIndexAttribute = @"TaskIndex";
                     style.firstLineHeadIndent = totalIndent;
                     style.headIndent = totalIndent;
 
-                    if (lineHeightConfig > 0) {
-                      style.minimumLineHeight = lineHeightConfig;
-                      style.maximumLineHeight = lineHeightConfig;
-                    }
-
                     NSMutableDictionary *attributesToApply = [metadata mutableCopy];
                     attributesToApply[NSParagraphStyleAttributeName] = style;
 
                     [output addAttributes:attributesToApply range:range];
+
+                    // Line height goes through the shared helper so list items get the same math
+                    // carve-out as paragraphs. Setting maximumLineHeight here directly would clamp
+                    // the line fragment below the height an inline math attachment draws at, and the
+                    // overflow paints over the neighbouring lines. applyLineHeight reads back the
+                    // paragraph style we just applied, so the indents above survive, and it
+                    // early-returns on a non-positive line height like the old guard did.
+                    applyLineHeight(output, range, lineHeightConfig);
                   }];
 
   if (isTask && isChecked) {

package/ios/styles/StyleConfig.h

@@ -378,10 +378,16 @@ NS_ASSUME_NONNULL_BEGIN
 - (void)setMathMarginBottom:(CGFloat)newValue;
 - (NSString *)mathTextAlign;
 - (void)setMathTextAlign:(NSString *)newValue;
+- (NSString *)mathFontWeight;
+- (void)setMathFontWeight:(NSString *)newValue;
 
 // Inline Math properties
 - (RCTUIColor *)inlineMathColor;
 - (void)setInlineMathColor:(RCTUIColor *)newValue;
+- (CGFloat)inlineMathPaddingVertical;
+- (void)setInlineMathPaddingVertical:(CGFloat)newValue;
+- (NSString *)inlineMathFontWeight;
+- (void)setInlineMathFontWeight:(NSString *)newValue;
 // Spoiler properties
 - (RCTUIColor *)spoilerColor;
 - (void)setSpoilerColor:(RCTUIColor *)newValue;

package/ios/styles/StyleConfig.mm

@@ -224,8 +224,11 @@ static inline NSString *normalizedFontWeight(NSString *fontWeight)
   CGFloat _mathMarginTop;
   CGFloat _mathMarginBottom;
   NSString *_mathTextAlign;
+  NSString *_mathFontWeight;
   // Inline Math properties
   RCTUIColor *_inlineMathColor;
+  CGFloat _inlineMathPaddingVertical;
+  NSString *_inlineMathFontWeight;
   // Spoiler properties
   RCTUIColor *_spoilerColor;
   CGFloat _spoilerParticleDensity;
@@ -482,7 +485,10 @@ static inline NSString *normalizedFontWeight(NSString *fontWeight)
   copy->_mathMarginTop = _mathMarginTop;
   copy->_mathMarginBottom = _mathMarginBottom;
   copy->_mathTextAlign = [_mathTextAlign copy];
+  copy->_mathFontWeight = [_mathFontWeight copy];
   copy->_inlineMathColor = [_inlineMathColor copy];
+  copy->_inlineMathPaddingVertical = _inlineMathPaddingVertical;
+  copy->_inlineMathFontWeight = [_inlineMathFontWeight copy];
   copy->_spoilerColor = [_spoilerColor copy];
   copy->_spoilerParticleDensity = _spoilerParticleDensity;
   copy->_spoilerParticleSpeed = _spoilerParticleSpeed;
@@ -2430,6 +2436,36 @@ static const CGFloat kDefaultMinGap = 4.0;
   _inlineMathColor = newValue;
 }
 
+- (CGFloat)inlineMathPaddingVertical
+{
+  return _inlineMathPaddingVertical;
+}
+
+- (NSString *)mathFontWeight
+{
+  return _mathFontWeight;
+}
+
+- (void)setMathFontWeight:(NSString *)newValue
+{
+  _mathFontWeight = newValue;
+}
+
+- (NSString *)inlineMathFontWeight
+{
+  return _inlineMathFontWeight;
+}
+
+- (void)setInlineMathFontWeight:(NSString *)newValue
+{
+  _inlineMathFontWeight = newValue;
+}
+
+- (void)setInlineMathPaddingVertical:(CGFloat)newValue
+{
+  _inlineMathPaddingVertical = newValue;
+}
+
 // ── Spoiler ─────────────────────────────────────────────────────────────
 
 - (RCTUIColor *)spoilerColor

package/ios/utils/ENRMMathFontWeight.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#import <Foundation/Foundation.h>
+
+/// Weight a formula can actually be typeset at.
+///
+/// The style config keeps `fontWeight` as an `NSString *`, the way the other 13
+/// `fontWeight` props do, so a value like `@"600"` survives as far as the
+/// renderer. This is the narrowing step at that last hop — the only place on
+/// iOS that decides what "bold" means for math — so the rule lives in one
+/// place instead of at every prop boundary. Mirrors MathFontWeight.kt on
+/// Android.
+///
+/// `nil` (prop never set) reads as normal, which is the documented default.
+static inline BOOL ENRMMathFontWeightIsBold(NSString *_Nullable fontWeight)
+{
+  return [fontWeight isEqualToString:@"bold"];
+}

package/ios/utils/StylePropsUtils.h

@@ -1078,6 +1078,14 @@ BOOL applyMarkdownStyleToConfig(StyleConfig *config, const MarkdownStyle &newSty
     changed = YES;
   }
 
+  if (newStyle.math.fontWeight != oldStyle.math.fontWeight) {
+    if (!newStyle.math.fontWeight.empty()) {
+      NSString *fontWeight = [[NSString alloc] initWithUTF8String:newStyle.math.fontWeight.c_str()];
+      [config setMathFontWeight:fontWeight];
+      changed = YES;
+    }
+  }
+
   if (newStyle.math.textAlign != oldStyle.math.textAlign) {
     [config setMathTextAlign:@(newStyle.math.textAlign.c_str())];
     changed = YES;
@@ -1095,6 +1103,19 @@ BOOL applyMarkdownStyleToConfig(StyleConfig *config, const MarkdownStyle &newSty
     changed = YES;
   }
 
+  if (newStyle.inlineMath.fontWeight != oldStyle.inlineMath.fontWeight) {
+    if (!newStyle.inlineMath.fontWeight.empty()) {
+      NSString *fontWeight = [[NSString alloc] initWithUTF8String:newStyle.inlineMath.fontWeight.c_str()];
+      [config setInlineMathFontWeight:fontWeight];
+      changed = YES;
+    }
+  }
+
+  if (newStyle.inlineMath.paddingVertical != oldStyle.inlineMath.paddingVertical) {
+    [config setInlineMathPaddingVertical:newStyle.inlineMath.paddingVertical];
+    changed = YES;
+  }
+
   // ── Spoiler ─────────────────────────────────────────────────────────────
 
   if (newStyle.spoiler.color != oldStyle.spoiler.color) {

package/ios/views/ENRMMathContainerView.m

@@ -1,6 +1,7 @@
 #import "ENRMMathContainerView.h"
 #import "ENRMAccessibilityLabels.h"
 #import "ENRMFeatureFlags.h"
+#import "ENRMMathFontWeight.h"
 #include <TargetConditionals.h>
 
 #if ENRICHED_MARKDOWN_MATH
@@ -94,7 +95,8 @@
   ENRMRaTeXRenderResult *result = [ENRMRaTeXBridge parse:latex
                                              displayMode:YES
                                                 fontSize:config.mathFontSize
-                                                   color:config.mathColor];
+                                                   color:config.mathColor
+                                                    bold:ENRMMathFontWeightIsBold(config.mathFontWeight)];
   _mathView.renderResult = result;
 
   CGFloat padding = config.mathPadding;

package/lib/module/EnrichedMarkdownNativeComponent.ts

@@ -141,10 +141,13 @@ interface MathStyleInternal {
   marginTop: CodegenTypes.Float;
   marginBottom: CodegenTypes.Float;
   textAlign: string;
+  fontWeight: string;
 }
 
 interface InlineMathStyleInternal {
   color: ColorValue;
+  paddingVertical: CodegenTypes.Float;
+  fontWeight: string;
 }
 
 interface SpoilerParticlesStyleInternal {