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

package/ios/renderer/BaseRenderer.m

@@ -0,0 +1,16 @@
+#import "BaseRenderer.h"
+#import "RendererFactory.h"
+#import "StyleConfig.h"
+
+@implementation BaseRenderer
+
+- (instancetype)initWithRendererFactory:(id)rendererFactory config:(id)config
+{
+  if (self = [super init]) {
+    _rendererFactory = rendererFactory;
+    _config = (StyleConfig *)config;
+  }
+  return self;
+}
+
+@end

package/ios/renderer/BaselineShiftTextAttributes.h

@@ -0,0 +1,6 @@
+#pragma once
+#import "ENRMUIKit.h"
+#import <Foundation/Foundation.h>
+
+void ENRMApplyBaselineShift(NSMutableAttributedString *output, NSRange range, CGFloat fontScale,
+                            CGFloat baselineOffsetScale);

package/ios/renderer/BaselineShiftTextAttributes.m

@@ -0,0 +1,22 @@
+#import "BaselineShiftTextAttributes.h"
+
+void ENRMApplyBaselineShift(NSMutableAttributedString *output, NSRange range, CGFloat fontScale,
+                            CGFloat baselineOffsetScale)
+{
+  [output enumerateAttribute:NSFontAttributeName
+                     inRange:range
+                     options:NSAttributedStringEnumerationLongestEffectiveRangeNotRequired
+                  usingBlock:^(UIFont *font, NSRange fontRange, BOOL *stop) {
+                    (void)stop;
+                    if (![font isKindOfClass:UIFont.class]) {
+                      return;
+                    }
+
+                    UIFont *scaledFont = [UIFont fontWithDescriptor:font.fontDescriptor
+                                                               size:font.pointSize * fontScale];
+                    [output addAttribute:NSFontAttributeName value:scaledFont range:fontRange];
+                    [output addAttribute:NSBaselineOffsetAttributeName
+                                   value:@(font.pointSize * baselineOffsetScale)
+                                   range:fontRange];
+                  }];
+}

package/ios/renderer/BlockquoteRenderer.h

@@ -0,0 +1,6 @@
+#import "BaseRenderer.h"
+#import "MarkdownASTNode.h"
+#import "RenderContext.h"
+
+@interface BlockquoteRenderer : BaseRenderer <NodeRenderer>
+@end

package/ios/renderer/BlockquoteRenderer.m

@@ -0,0 +1,148 @@
+#import "BlockquoteRenderer.h"
+#import "BlockquoteBorder.h"
+#import "FontUtils.h"
+#import "MarkdownASTNode.h"
+#import "ParagraphStyleUtils.h"
+#import "RendererFactory.h"
+#import "StyleConfig.h"
+
+static NSString *const kNestedInfoDepthKey = @"depth";
+static NSString *const kNestedInfoRangeKey = @"range";
+
+@implementation BlockquoteRenderer
+
+- (void)renderNode:(MarkdownASTNode *)node into:(NSMutableAttributedString *)output context:(RenderContext *)context
+{
+  NSInteger currentDepth = context.blockquoteDepth;
+  context.blockquoteDepth = currentDepth + 1;
+
+  [context setBlockStyle:BlockTypeBlockquote
+                    font:[_config blockquoteFont]
+                   color:[_config blockquoteColor]
+            headingLevel:0];
+
+  NSUInteger start = output.length;
+  @try {
+    [_rendererFactory renderChildrenOfNode:node into:output context:context];
+  } @finally {
+    [context clearBlockStyle];
+    context.blockquoteDepth = currentDepth;
+  }
+
+  NSUInteger end = output.length;
+  if (end <= start) {
+    return;
+  }
+
+  [self applyStylingAndSpacing:output start:start end:end currentDepth:currentDepth];
+}
+
+#pragma mark - Styling and Spacing
+
+- (void)applyStylingAndSpacing:(NSMutableAttributedString *)output
+                         start:(NSUInteger)start
+                           end:(NSUInteger)end
+                  currentDepth:(NSInteger)currentDepth
+{
+  NSUInteger contentStart = start;
+  if (currentDepth == 0) {
+    contentStart += applyBlockSpacingBefore(output, start, [_config blockquoteMarginTop]);
+  }
+
+  NSRange blockquoteRange = NSMakeRange(contentStart, end - start);
+  CGFloat levelSpacing = [_config blockquoteBorderWidth] + [_config blockquoteGapWidth];
+  NSArray<NSDictionary *> *nestedInfo = [self collectNestedBlockquotes:output range:blockquoteRange depth:currentDepth];
+
+  // Apply base styling (indentation, depth, background, line height)
+  [self applyBaseBlockquoteStyle:output
+                           range:blockquoteRange
+                           depth:currentDepth
+                    levelSpacing:levelSpacing
+                 backgroundColor:[_config blockquoteBackgroundColor]
+                      lineHeight:[_config blockquoteLineHeight]];
+
+  // Re-apply nested blockquote styles to restore their correct indentation
+  // (applyBaseBlockquoteStyle overwrites nested indents with the parent's indent)
+  [self reapplyNestedStyles:output nestedInfo:nestedInfo levelSpacing:levelSpacing];
+
+  if (currentDepth == 0) {
+    applyBlockSpacingAfter(output, [_config blockquoteMarginBottom]);
+  }
+}
+
+#pragma mark - Nested Blockquote Handling
+
+- (NSArray<NSDictionary *> *)collectNestedBlockquotes:(NSMutableAttributedString *)output
+                                                range:(NSRange)blockquoteRange
+                                                depth:(NSInteger)currentDepth
+{
+  NSMutableArray<NSDictionary *> *nestedInfo = [NSMutableArray array];
+
+  [output
+      enumerateAttribute:BlockquoteDepthAttributeName
+                 inRange:blockquoteRange
+                 options:NSAttributedStringEnumerationLongestEffectiveRangeNotRequired
+              usingBlock:^(id value, NSRange range, BOOL *stop) {
+                NSInteger depth = [value integerValue];
+                if (value && depth > currentDepth) {
+                  [nestedInfo
+                      addObject:@{kNestedInfoDepthKey : value, kNestedInfoRangeKey : [NSValue valueWithRange:range]}];
+                }
+              }];
+
+  return nestedInfo;
+}
+
+- (void)applyBaseBlockquoteStyle:(NSMutableAttributedString *)output
+                           range:(NSRange)blockquoteRange
+                           depth:(NSInteger)currentDepth
+                    levelSpacing:(CGFloat)levelSpacing
+                 backgroundColor:(RCTUIColor *)backgroundColor
+                      lineHeight:(CGFloat)lineHeight
+{
+  NSMutableParagraphStyle *paragraphStyle = getOrCreateParagraphStyle(output, blockquoteRange.location);
+  CGFloat totalIndent = [self calculateIndentForDepth:currentDepth levelSpacing:levelSpacing];
+  paragraphStyle.firstLineHeadIndent = totalIndent;
+  paragraphStyle.headIndent = totalIndent;
+
+  NSMutableDictionary *newAttributes =
+      [NSMutableDictionary dictionaryWithObjectsAndKeys:paragraphStyle, NSParagraphStyleAttributeName, @(currentDepth),
+                                                        BlockquoteDepthAttributeName, nil];
+  if (backgroundColor) {
+    newAttributes[BlockquoteBackgroundColorAttributeName] = backgroundColor;
+  }
+  [output addAttributes:newAttributes range:blockquoteRange];
+
+  applyLineHeight(output, blockquoteRange, lineHeight);
+}
+
+- (void)reapplyNestedStyles:(NSMutableAttributedString *)output
+                 nestedInfo:(NSArray<NSDictionary *> *)nestedInfo
+               levelSpacing:(CGFloat)levelSpacing
+{
+  // Re-apply indentation to nested blockquotes since applyBaseBlockquoteStyle
+  // overwrote them with the parent's indentation
+  for (NSDictionary *info in nestedInfo) {
+    NSRange nestedRange = [info[kNestedInfoRangeKey] rangeValue];
+    NSInteger nestedDepth = [info[kNestedInfoDepthKey] integerValue];
+    NSMutableParagraphStyle *style = getOrCreateParagraphStyle(output, nestedRange.location);
+
+    CGFloat indent = [self calculateIndentForDepth:nestedDepth levelSpacing:levelSpacing];
+    style.firstLineHeadIndent = indent;
+    style.headIndent = indent;
+    style.tailIndent = 0;
+
+    [output
+        addAttributes:@{NSParagraphStyleAttributeName : style, BlockquoteDepthAttributeName : info[kNestedInfoDepthKey]}
+                range:nestedRange];
+  }
+}
+
+#pragma mark - Helper Methods
+
+- (CGFloat)calculateIndentForDepth:(NSInteger)depth levelSpacing:(CGFloat)levelSpacing
+{
+  return (depth + 1) * levelSpacing;
+}
+
+@end

package/ios/renderer/CodeBlockRenderer.h

@@ -0,0 +1,9 @@
+#pragma once
+#import "BaseRenderer.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface CodeBlockRenderer : BaseRenderer <NodeRenderer>
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/renderer/CodeBlockRenderer.m

@@ -0,0 +1,90 @@
+#import "CodeBlockRenderer.h"
+#import "CodeBlockBackground.h"
+#import "LastElementUtils.h"
+#import "MarkdownASTNode.h"
+#import "ParagraphStyleUtils.h"
+#import "RenderContext.h"
+#import "RendererFactory.h"
+#import "StyleConfig.h"
+
+@implementation CodeBlockRenderer
+
+- (void)renderNode:(MarkdownASTNode *)node into:(NSMutableAttributedString *)output context:(RenderContext *)context
+{
+  [context setBlockStyle:BlockTypeCodeBlock font:[_config codeBlockFont] color:[_config codeBlockColor] headingLevel:0];
+
+  CGFloat padding = [_config codeBlockPadding];
+  CGFloat lineHeight = [_config codeBlockLineHeight];
+  CGFloat marginTop = [_config codeBlockMarginTop];
+  CGFloat marginBottom = [_config codeBlockMarginBottom];
+
+  NSUInteger blockStart = output.length;
+  blockStart += applyBlockSpacingBefore(output, blockStart, marginTop);
+
+  // Top Padding: Inserted as a spacer character inside the background area
+  // apply only when positive
+  if (padding > 0) {
+    [output appendAttributedString:kNewlineAttributedString];
+    NSMutableParagraphStyle *topSpacerStyle = [context spacerStyleWithHeight:padding spacing:0];
+    topSpacerStyle.baseWritingDirection = NSWritingDirectionLeftToRight;
+    [output addAttribute:NSParagraphStyleAttributeName value:topSpacerStyle range:NSMakeRange(blockStart, 1)];
+  }
+
+  NSUInteger contentStart = output.length;
+  @try {
+    [_rendererFactory renderChildrenOfNode:node into:output context:context];
+  } @finally {
+    [context clearBlockStyle];
+  }
+
+  NSUInteger contentEnd = output.length;
+  if (contentEnd <= contentStart)
+    return;
+
+  NSRange contentRange = NSMakeRange(contentStart, contentEnd - contentStart);
+
+  UIFont *codeFont = [_config codeBlockFont];
+  RCTUIColor *codeColor = [_config codeBlockColor];
+  if (codeColor) {
+    [output addAttributes:@{NSFontAttributeName : codeFont, NSForegroundColorAttributeName : codeColor}
+                    range:contentRange];
+  } else {
+    [output addAttribute:NSFontAttributeName value:codeFont range:contentRange];
+  }
+
+  if (lineHeight > 0) {
+    applyLineHeight(output, contentRange, lineHeight);
+  }
+
+  // Code is always LTR regardless of app writing direction
+  NSMutableParagraphStyle *baseStyle = [getOrCreateParagraphStyle(output, contentStart) mutableCopy];
+  baseStyle.baseWritingDirection = NSWritingDirectionLeftToRight;
+  baseStyle.alignment = NSTextAlignmentLeft;
+  baseStyle.firstLineHeadIndent = padding;
+  baseStyle.headIndent = padding;
+  baseStyle.tailIndent = -padding;
+  [output addAttribute:NSParagraphStyleAttributeName value:baseStyle range:contentRange];
+
+  // Bottom Padding: Inserted as a spacer character inside the background area
+  // apply it only when positive
+  if (padding > 0) {
+    NSUInteger bottomPaddingStart = output.length;
+    [output appendAttributedString:kNewlineAttributedString];
+    NSMutableParagraphStyle *bottomPaddingStyle = [context spacerStyleWithHeight:padding spacing:0];
+    bottomPaddingStyle.baseWritingDirection = NSWritingDirectionLeftToRight;
+    [output addAttribute:NSParagraphStyleAttributeName
+                   value:bottomPaddingStyle
+                   range:NSMakeRange(bottomPaddingStart, 1)];
+  }
+
+  // Define the range for background rendering (includes padding, excludes margins)
+  NSRange backgroundRange = NSMakeRange(blockStart, output.length - blockStart);
+  [output addAttribute:CodeBlockAttributeName value:@YES range:backgroundRange];
+
+  // External Margin: Applied outside the background range
+  if (marginBottom > 0) {
+    applyBlockSpacingAfter(output, marginBottom);
+  }
+}
+
+@end

package/ios/renderer/CodeRenderer.h

@@ -0,0 +1,9 @@
+#pragma once
+#import "BaseRenderer.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface CodeRenderer : BaseRenderer <NodeRenderer>
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/renderer/CodeRenderer.m

@@ -0,0 +1,64 @@
+#import "CodeRenderer.h"
+#import "CodeBackground.h"
+#import "ENRMUIKit.h"
+#import "FontUtils.h"
+#import "MarkdownASTNode.h"
+#import "RenderContext.h"
+#import "RendererFactory.h"
+#import "StyleConfig.h"
+#import <React/RCTFont.h>
+
+@implementation CodeRenderer
+
+- (void)renderNode:(MarkdownASTNode *)node into:(NSMutableAttributedString *)output context:(RenderContext *)context
+{
+
+  BlockStyle *blockStyle = [context getBlockStyle];
+
+  RCTUIColor *codeColor = _config.codeColor;
+
+  UIFont *blockFont = cachedFontFromBlockStyle(blockStyle, context);
+
+  UIFontDescriptorSymbolicTraits traits = blockFont.fontDescriptor.symbolicTraits;
+  UIFontWeight weight = (traits & UIFontDescriptorTraitBold) ? UIFontWeightBold : UIFontWeightRegular;
+
+  CGFloat codeFontSize = _config.codeFontSize > 0 ? _config.codeFontSize : blockStyle.fontSize;
+
+  NSString *codeFontFamily = _config.codeFontFamily;
+  UIFont *codeFont;
+  if (codeFontFamily.length > 0) {
+    NSString *weightStr = (weight == UIFontWeightBold) ? @"bold" : nil;
+    codeFont = [RCTFont updateFont:nil
+                        withFamily:codeFontFamily
+                              size:@(codeFontSize)
+                            weight:weightStr
+                             style:nil
+                           variant:nil
+                   scaleMultiplier:1.0];
+  } else {
+    codeFont = [UIFont monospacedSystemFontOfSize:codeFontSize weight:weight];
+  }
+
+  NSUInteger start = output.length;
+
+  [_rendererFactory renderChildrenOfNode:node into:output context:context];
+
+  NSRange range = [RenderContext rangeForRenderedContent:output start:start];
+  if (range.length > 0) {
+    NSDictionary *existingAttributes = [output attributesAtIndex:start effectiveRange:NULL];
+    NSMutableDictionary *codeAttributes = [existingAttributes ?: @{} mutableCopy];
+
+    codeAttributes[NSFontAttributeName] = codeFont;
+    if (codeColor) {
+      codeAttributes[NSForegroundColorAttributeName] = codeColor;
+    }
+    codeAttributes[CodeAttributeName] = @YES;
+
+    // Store block line height directly for CodeBackground to use
+    codeAttributes[@"BlockLineHeight"] = @(UIFontLineHeight(blockFont));
+
+    [output setAttributes:codeAttributes range:range];
+  }
+}
+
+@end

package/ios/renderer/ENRMImageRenderer.h

@@ -0,0 +1,9 @@
+#pragma once
+#import "BaseRenderer.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface ENRMImageRenderer : BaseRenderer <NodeRenderer>
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/renderer/ENRMImageRenderer.m

@@ -0,0 +1,65 @@
+#import "ENRMImageRenderer.h"
+#import "ENRMImageAttachment.h"
+#import "MarkdownASTNode.h"
+#import "RenderContext.h"
+#import "RendererFactory.h"
+#import "StyleConfig.h"
+
+static const unichar kLineBreak = '\n';
+static const unichar kZeroWidthSpace = 0x200B;
+
+@implementation ENRMImageRenderer
+
+- (void)renderNode:(MarkdownASTNode *)node into:(NSMutableAttributedString *)output context:(RenderContext *)context
+{
+  NSString *imageURL = node.attributes[@"url"];
+  if (!imageURL || imageURL.length == 0) {
+    return;
+  }
+
+  BOOL isInline = [self isInlineImageInOutput:output];
+  ENRMImageAttachment *attachment = [ENRMImageAttachment attachmentForURL:imageURL config:_config isInline:isInline];
+
+  NSUInteger startIndex = output.length;
+
+  NSAttributedString *imageString = [NSAttributedString attributedStringWithAttachment:attachment];
+  [output appendAttributedString:imageString];
+
+  // Extract alt text from children (![alt text](url) - "alt text" is in children)
+  NSString *altText = [self extractTextFromNode:node];
+  NSRange imageRange = NSMakeRange(startIndex, output.length - startIndex);
+  [context registerImageRange:imageRange altText:altText url:imageURL];
+}
+
+- (NSString *)extractTextFromNode:(MarkdownASTNode *)node
+{
+  if (!node)
+    return @"";
+
+  NSMutableString *buffer = [NSMutableString string];
+  [self _appendChildTextFromNode:node toBuffer:buffer];
+  return [buffer copy];
+}
+
+- (void)_appendChildTextFromNode:(MarkdownASTNode *)node toBuffer:(NSMutableString *)buffer
+{
+  if (node.content.length > 0) {
+    [buffer appendString:node.content];
+  }
+
+  for (MarkdownASTNode *child in node.children) {
+    [self _appendChildTextFromNode:child toBuffer:buffer];
+  }
+}
+
+- (BOOL)isInlineImageInOutput:(NSAttributedString *)output
+{
+  if (output.length == 0) {
+    return NO;
+  }
+
+  unichar lastChar = [output.string characterAtIndex:output.length - 1];
+  return (lastChar != kLineBreak && lastChar != kZeroWidthSpace);
+}
+
+@end

package/ios/renderer/ENRMMathInlineRenderer.h

@@ -0,0 +1,9 @@
+#pragma once
+#import "BaseRenderer.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface ENRMMathInlineRenderer : BaseRenderer <NodeRenderer>
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/renderer/ENRMMathInlineRenderer.m

@@ -0,0 +1,56 @@
+#import "ENRMMathInlineRenderer.h"
+#import "ENRMMathInlineAttachment.h"
+#import "MarkdownASTNode.h"
+#import "RenderContext.h"
+#import "RendererFactory.h"
+#import "StyleConfig.h"
+
+#import "ENRMFeatureFlags.h"
+
+#if ENRICHED_MARKDOWN_MATH
+
+@implementation ENRMMathInlineRenderer
+
+- (void)renderNode:(MarkdownASTNode *)node into:(NSMutableAttributedString *)output context:(RenderContext *)context
+{
+  NSString *latex = [self extractLatexFromNode:node];
+  if (latex.length == 0) {
+    return;
+  }
+
+  NSDictionary *textAttrs = [context getTextAttributes];
+  UIFont *currentFont = textAttrs[NSFontAttributeName];
+
+  ENRMMathInlineAttachment *attachment = [[ENRMMathInlineAttachment alloc] init];
+  attachment.latex = latex;
+  attachment.fontSize = currentFont ? currentFont.pointSize : [_config paragraphFontSize];
+  attachment.mathTextColor = [_config inlineMathColor];
+
+#if TARGET_OS_OSX
+  // On macOS, NSLayoutManager uses self.image/self.bounds rather than calling
+  // imageForBounds:textContainer:characterIndex:, so we pre-render eagerly.
+  [attachment renderForMacOS];
+#endif
+
+  NSAttributedString *attachmentString = [NSAttributedString attributedStringWithAttachment:attachment];
+  [output appendAttributedString:attachmentString];
+}
+
+- (NSString *)extractLatexFromNode:(MarkdownASTNode *)node
+{
+  if (node.content.length > 0) {
+    return node.content;
+  }
+
+  NSMutableString *buffer = [NSMutableString string];
+  for (MarkdownASTNode *child in node.children) {
+    if (child.content.length > 0) {
+      [buffer appendString:child.content];
+    }
+  }
+  return buffer;
+}
+
+@end
+
+#endif

package/ios/renderer/ENRMSpoilerRenderer.h

@@ -0,0 +1,5 @@
+#pragma once
+#import "BaseRenderer.h"
+
+@interface ENRMSpoilerRenderer : BaseRenderer <NodeRenderer>
+@end

package/ios/renderer/ENRMSpoilerRenderer.m

@@ -0,0 +1,32 @@
+#import "ENRMSpoilerRenderer.h"
+#import "ENRMSpoilerTapUtils.h"
+#import "MarkdownASTNode.h"
+#import "RenderContext.h"
+#import "RendererFactory.h"
+
+@implementation ENRMSpoilerRenderer
+
+- (void)renderNode:(MarkdownASTNode *)node into:(NSMutableAttributedString *)output context:(RenderContext *)context
+{
+  NSUInteger start = output.length;
+  [_rendererFactory renderChildrenOfNode:node into:output context:context];
+
+  NSRange range = NSMakeRange(start, output.length - start);
+  if (range.length == 0)
+    return;
+
+  [output addAttribute:SpoilerAttributeName value:@YES range:range];
+
+  [output enumerateAttribute:NSForegroundColorAttributeName
+                     inRange:range
+                     options:0
+                  usingBlock:^(id value, NSRange subRange, BOOL *stop) {
+                    if (value) {
+                      [output addAttribute:SpoilerOriginalColorAttributeName value:value range:subRange];
+                    }
+                  }];
+
+  [output addAttribute:NSForegroundColorAttributeName value:[RCTUIColor colorWithWhite:0 alpha:0] range:range];
+}
+
+@end

package/ios/renderer/EmphasisRenderer.h

@@ -0,0 +1,5 @@
+#pragma once
+#import "BaseRenderer.h"
+
+@interface EmphasisRenderer : BaseRenderer <NodeRenderer>
+@end

package/ios/renderer/EmphasisRenderer.m

@@ -0,0 +1,98 @@
+#import "EmphasisRenderer.h"
+#import "FontUtils.h"
+#import "MarkdownASTNode.h"
+#import "RenderContext.h"
+#import "RendererFactory.h"
+#import "StyleConfig.h"
+#import <React/RCTFont.h>
+
+@implementation EmphasisRenderer
+
+#pragma mark - Rendering
+
+- (void)renderNode:(MarkdownASTNode *)node into:(NSMutableAttributedString *)output context:(RenderContext *)context
+{
+  NSUInteger start = output.length;
+  [_rendererFactory renderChildrenOfNode:node into:output context:context];
+
+  NSRange range = NSMakeRange(start, output.length - start);
+  if (range.length == 0)
+    return;
+
+  BlockStyle *blockStyle = [context getBlockStyle];
+  RCTUIColor *configEmphasisColor = [_config emphasisColor];
+  NSString *emphasisFontFamily = [_config emphasisFontFamily];
+  NSString *emphasisFontStyle = [_config emphasisFontStyle];
+  BOOL useNormalStyle = [emphasisFontStyle isEqualToString:@"normal"];
+
+  // Cache the Strong color calculation to efficiently detect nested Strong nodes
+  RCTUIColor *strongColorToPreserve = [_config strongColor] ? [RenderContext calculateStrongColor:[_config strongColor]
+                                                                                       blockColor:blockStyle.color]
+                                                            : nil;
+
+  [output enumerateAttributesInRange:range
+                             options:NSAttributedStringEnumerationLongestEffectiveRangeNotRequired
+                          usingBlock:^(NSDictionary<NSAttributedStringKey, id> *attrs, NSRange subrange, BOOL *stop) {
+                            UIFont *currentFont =
+                                attrs[NSFontAttributeName] ?: cachedFontFromBlockStyle(blockStyle, context);
+                            UIFont *resolvedFont = nil;
+
+                            if (emphasisFontFamily.length > 0) {
+                              resolvedFont = [RCTFont updateFont:currentFont
+                                                      withFamily:emphasisFontFamily
+                                                            size:nil
+                                                          weight:nil
+                                                           style:useNormalStyle ? nil : @"italic"
+                                                         variant:nil
+                                                 scaleMultiplier:1.0];
+                            } else if (currentFont &&
+                                       !(currentFont.fontDescriptor.symbolicTraits & UIFontDescriptorTraitItalic)) {
+                              resolvedFont = [self ensureFontIsItalic:currentFont];
+                            }
+
+                            if (resolvedFont && ![resolvedFont isEqual:currentFont]) {
+                              [output addAttribute:NSFontAttributeName value:resolvedFont range:subrange];
+                            }
+
+                            // 2. Color Optimization: Handle nesting and avoid redundant updates
+                            if (configEmphasisColor) {
+                              RCTUIColor *currentColor = attrs[NSForegroundColorAttributeName];
+                              BOOL isLink = attrs[NSLinkAttributeName] != nil;
+
+                              // Verify if the current color belongs to a Strong parent
+                              BOOL isStrongColor =
+                                  strongColorToPreserve && [currentColor isEqual:strongColorToPreserve];
+
+                              // Preserving colors for higher-priority elements (links, strong nodes, etc.)
+                              if (!isLink && !isStrongColor && ![RenderContext shouldPreserveColors:attrs]) {
+                                // Only modify the string if the color is actually different
+                                if (![currentColor isEqual:configEmphasisColor]) {
+                                  [output addAttribute:NSForegroundColorAttributeName
+                                                 value:configEmphasisColor
+                                                 range:subrange];
+                                }
+                              }
+                            }
+                          }];
+}
+
+#pragma mark - Helper Methods
+
+- (UIFont *)ensureFontIsItalic:(UIFont *)font
+{
+  if (!font)
+    return nil;
+
+  UIFontDescriptorSymbolicTraits traits = font.fontDescriptor.symbolicTraits;
+  if (traits & UIFontDescriptorTraitItalic)
+    return font;
+
+  // Combine italic with existing traits (e.g., preserving Bold if present)
+  UIFontDescriptorSymbolicTraits combinedTraits = traits | UIFontDescriptorTraitItalic;
+  UIFontDescriptor *italicDescriptor = [font.fontDescriptor fontDescriptorWithSymbolicTraits:combinedTraits];
+
+  // Size 0 in fontWithDescriptor:size: maintains the current point size
+  return [UIFont fontWithDescriptor:italicDescriptor size:0] ?: font;
+}
+
+@end

package/ios/renderer/HeadingRenderer.h

@@ -0,0 +1,6 @@
+#import "BaseRenderer.h"
+#import "MarkdownASTNode.h"
+#import "RenderContext.h"
+
+@interface HeadingRenderer : BaseRenderer <NodeRenderer>
+@end