react-native-enriched-markdown 0.1.0 → 0.1.1

package/ios/renderer/LinkRenderer.m

@@ -0,0 +1,69 @@
+#import "LinkRenderer.h"
+#import "FontUtils.h"
+#import "RenderContext.h"
+#import "RendererFactory.h"
+#import "StyleConfig.h"
+
+@implementation LinkRenderer {
+  RendererFactory *_rendererFactory;
+  StyleConfig *_config;
+}
+
+- (instancetype)initWithRendererFactory:(id)rendererFactory config:(id)config
+{
+  self = [super init];
+  if (self) {
+    _rendererFactory = rendererFactory;
+    _config = (StyleConfig *)config;
+  }
+  return self;
+}
+
+#pragma mark - Rendering
+
+- (void)renderNode:(MarkdownASTNode *)node into:(NSMutableAttributedString *)output context:(RenderContext *)context
+{
+  NSUInteger start = output.length;
+
+  // 1. Render children first to establish base attributes
+  [_rendererFactory renderChildrenOfNode:node into:output context:context];
+
+  NSRange range = NSMakeRange(start, output.length - start);
+  if (range.length == 0)
+    return;
+
+  // 2. Extract configuration
+  NSString *url = node.attributes[@"url"] ?: @"";
+  UIColor *linkColor = [_config linkColor];
+  NSNumber *underlineStyle = @([_config linkUnderline] ? NSUnderlineStyleSingle : NSUnderlineStyleNone);
+
+  // 3. Apply core link functionality (non-destructive)
+  [output addAttribute:NSLinkAttributeName value:url range:range];
+
+  // 4. Optimize visual attributes via enumeration to avoid redundant updates
+  [output enumerateAttributesInRange:range
+                             options:NSAttributedStringEnumerationLongestEffectiveRangeNotRequired
+                          usingBlock:^(NSDictionary<NSAttributedStringKey, id> *attrs, NSRange subrange, BOOL *stop) {
+                            NSMutableDictionary *newAttributes = [NSMutableDictionary dictionary];
+
+                            // Only apply link color if the subrange isn't already colored by the link style
+                            if (linkColor && ![attrs[NSForegroundColorAttributeName] isEqual:linkColor]) {
+                              newAttributes[NSForegroundColorAttributeName] = linkColor;
+                              newAttributes[NSUnderlineColorAttributeName] = linkColor;
+                            }
+
+                            // Only update underline style if it differs from the config
+                            if (![attrs[NSUnderlineStyleAttributeName] isEqual:underlineStyle]) {
+                              newAttributes[NSUnderlineStyleAttributeName] = underlineStyle;
+                            }
+
+                            if (newAttributes.count > 0) {
+                              [output addAttributes:newAttributes range:subrange];
+                            }
+                          }];
+
+  // 5. Register for touch handling
+  [context registerLinkRange:range url:url];
+}
+
+@end

package/ios/renderer/ListItemRenderer.h

@@ -0,0 +1,16 @@
+#import "NodeRenderer.h"
+
+@class RendererFactory;
+@class StyleConfig;
+@class RenderContext;
+
+// Attribute names for list styling
+extern NSString *const ListDepthAttribute;
+extern NSString *const ListTypeAttribute;
+extern NSString *const ListItemNumberAttribute;
+
+@interface ListItemRenderer : NSObject <NodeRenderer>
+
+- (instancetype)initWithRendererFactory:(RendererFactory *)rendererFactory config:(StyleConfig *)config;
+
+@end

package/ios/renderer/ListItemRenderer.m

@@ -0,0 +1,91 @@
+#import "ListItemRenderer.h"
+#import "MarkdownASTNode.h"
+#import "ParagraphStyleUtils.h"
+#import "RenderContext.h"
+#import "RendererFactory.h"
+#import "StyleConfig.h"
+
+NSString *const ListDepthAttribute = @"ListDepth";
+NSString *const ListTypeAttribute = @"ListType";
+NSString *const ListItemNumberAttribute = @"ListItemNumber";
+
+@implementation ListItemRenderer {
+  RendererFactory *_rendererFactory;
+  StyleConfig *_config;
+}
+
+- (instancetype)initWithRendererFactory:(RendererFactory *)factory config:(StyleConfig *)config
+{
+  if (self = [super init]) {
+    _rendererFactory = factory;
+    _config = config;
+  }
+  return self;
+}
+
+- (void)renderNode:(MarkdownASTNode *)node into:(NSMutableAttributedString *)output context:(RenderContext *)context
+{
+  if (!context)
+    return;
+
+  // 1. Maintain the ordered list counter
+  if (context.listType == ListTypeOrdered) {
+    context.listItemNumber++;
+  }
+
+  NSUInteger start = output.length;
+  [_rendererFactory renderChildrenOfNode:node into:output context:context];
+
+  // 2. Structural Fix: Ensure paragraph isolation to prevent merged lines
+  if (output.length > start && ![output.string hasSuffix:@"\n"]) {
+    [output appendAttributedString:kNewlineAttributedString];
+  }
+
+  NSRange itemRange = NSMakeRange(start, output.length - start);
+  if (itemRange.length == 0)
+    return;
+
+  // 3. Pre-calculate invariant metadata for this item
+  NSInteger currentDepth = context.listDepth - 1;
+  // Root items: just marker width + gap (flush to left edge)
+  // Nested items: add marginLeft for each nesting level
+  CGFloat minMarkerWidth = (context.listType == ListTypeOrdered) ? [_config effectiveListMarginLeftForNumber]
+                                                                 : [_config effectiveListMarginLeftForBullet];
+  CGFloat indent = minMarkerWidth + [_config effectiveListGapWidth] + (currentDepth * [_config listStyleMarginLeft]);
+  CGFloat configLineHeight = [_config listStyleLineHeight];
+
+  // Pre-wrap numbers to avoid repeated allocations in the block
+  NSNumber *depthVal = @(currentDepth);
+  NSNumber *typeVal = @(context.listType);
+  NSNumber *numVal = @(context.listItemNumber);
+
+  // 4. Protected Styling: Use enumerateAttribute to avoid flattening children
+  [output enumerateAttribute:ListDepthAttribute
+                     inRange:itemRange
+                     options:0
+                  usingBlock:^(id depth, NSRange range, BOOL *stop) {
+                    // Skip if this segment belongs to a deeper nested list
+                    if (depth && [depth integerValue] > currentDepth)
+                      return;
+
+                    NSMutableParagraphStyle *style = [[NSMutableParagraphStyle alloc] init];
+                    style.firstLineHeadIndent = indent;
+                    style.headIndent = indent;
+
+                    UIFont *font = [output attribute:NSFontAttributeName atIndex:range.location effectiveRange:NULL];
+                    if (configLineHeight > 0 && font) {
+                      style.lineHeightMultiple = configLineHeight / font.pointSize;
+                    }
+
+                    // Final attribute application
+                    [output addAttributes:@{
+                      NSParagraphStyleAttributeName : style,
+                      ListDepthAttribute : depthVal,
+                      ListTypeAttribute : typeVal,
+                      ListItemNumberAttribute : numVal
+                    }
+                                    range:range];
+                  }];
+}
+
+@end

package/ios/renderer/ListRenderer.h

@@ -0,0 +1,13 @@
+#import "NodeRenderer.h"
+
+@class RendererFactory;
+@class StyleConfig;
+@class RenderContext;
+
+@interface ListRenderer : NSObject <NodeRenderer>
+
+- (instancetype)initWithRendererFactory:(RendererFactory *)rendererFactory
+                                 config:(StyleConfig *)config
+                              isOrdered:(BOOL)isOrdered;
+
+@end

package/ios/renderer/ListRenderer.m

@@ -0,0 +1,67 @@
+#import "ListRenderer.h"
+#import "BlockquoteRenderer.h"
+#import "MarkdownASTNode.h"
+#import "ParagraphStyleUtils.h"
+#import "RenderContext.h"
+#import "RendererFactory.h"
+#import "StyleConfig.h"
+
+@implementation ListRenderer {
+  RendererFactory *_rendererFactory;
+  StyleConfig *_config;
+  BOOL _isOrdered;
+}
+
+- (instancetype)initWithRendererFactory:(RendererFactory *)factory config:(StyleConfig *)config isOrdered:(BOOL)ordered
+{
+  if (self = [super init]) {
+    _rendererFactory = factory;
+    _config = config;
+    _isOrdered = ordered;
+  }
+  return self;
+}
+
+- (void)renderNode:(MarkdownASTNode *)node into:(NSMutableAttributedString *)output context:(RenderContext *)context
+{
+  if (!context)
+    return;
+
+  // Snapshot parent state
+  NSInteger prevDepth = context.listDepth;
+  ListType prevType = context.listType;
+  NSInteger prevNum = context.listItemNumber;
+
+  // Configure depth and type
+  context.listDepth = prevDepth + 1;
+  context.listType = _isOrdered ? ListTypeOrdered : ListTypeUnordered;
+  context.listItemNumber = 0;
+
+  // Ensure isolation for nested lists
+  if (prevDepth > 0 && output.length > 0 && ![output.string hasSuffix:@"\n"]) {
+    [output appendAttributedString:kNewlineAttributedString];
+  }
+
+  [context setBlockStyle:_isOrdered ? BlockTypeOrderedList : BlockTypeUnorderedList
+                    font:[_config listStyleFont]
+                   color:[_config listStyleColor]
+            headingLevel:0];
+
+  @try {
+    [_rendererFactory renderChildrenOfNode:node into:output context:context];
+  } @finally {
+    // Restore parent state
+    context.listDepth = prevDepth;
+    context.listType = prevType;
+    context.listItemNumber = prevNum;
+    if (prevDepth == 0)
+      [context clearBlockStyle];
+  }
+
+  // Final spacing for root container
+  if (prevDepth == 0 && [_config listStyleMarginBottom] > 0) {
+    applyBlockSpacing(output, [_config listStyleMarginBottom]);
+  }
+}
+
+@end

package/ios/renderer/NodeRenderer.h

@@ -0,0 +1,8 @@
+#import <Foundation/Foundation.h>
+
+@class MarkdownASTNode;
+@class RenderContext;
+
+@protocol NodeRenderer <NSObject>
+- (void)renderNode:(MarkdownASTNode *)node into:(NSMutableAttributedString *)output context:(RenderContext *)context;
+@end

package/ios/renderer/ParagraphRenderer.h

@@ -0,0 +1,7 @@
+#import "MarkdownASTNode.h"
+#import "NodeRenderer.h"
+#import "RenderContext.h"
+
+@interface ParagraphRenderer : NSObject <NodeRenderer>
+- (instancetype)initWithRendererFactory:(id)rendererFactory config:(id)config;
+@end

package/ios/renderer/ParagraphRenderer.m

@@ -0,0 +1,69 @@
+#import "ParagraphRenderer.h"
+#import "FontUtils.h"
+#import "MarkdownASTNode.h"
+#import "ParagraphStyleUtils.h"
+#import "RendererFactory.h"
+#import "StyleConfig.h"
+
+@implementation ParagraphRenderer {
+  RendererFactory *_rendererFactory;
+  StyleConfig *_config;
+}
+
+- (instancetype)initWithRendererFactory:(id)rendererFactory config:(id)config
+{
+  self = [super init];
+  if (self) {
+    _rendererFactory = rendererFactory;
+    _config = (StyleConfig *)config;
+  }
+  return self;
+}
+
+#pragma mark - Rendering
+
+- (void)renderNode:(MarkdownASTNode *)node into:(NSMutableAttributedString *)output context:(RenderContext *)context
+{
+  // 1. Context-Aware Styling
+  // We only set the block style if no parent element (like a list or blockquote) has already established one.
+  BOOL isTopLevel = (context.currentBlockType == BlockTypeNone);
+
+  if (isTopLevel) {
+    [context setBlockStyle:BlockTypeParagraph font:_config.paragraphFont color:_config.paragraphColor headingLevel:0];
+  }
+
+  NSUInteger start = output.length;
+  @try {
+    [_rendererFactory renderChildrenOfNode:node into:output context:context];
+  } @finally {
+    // Only clear the style if this paragraph was the one that set it.
+    if (isTopLevel) {
+      [context clearBlockStyle];
+    }
+  }
+
+  // 2. Geometry and Spacing Logic
+  if (output.length <= start)
+    return;
+  NSRange range = NSMakeRange(start, output.length - start);
+
+  // Check if this paragraph is purely a wrapper for a block image.
+  // Images often require different spacing and should not have standard line height applied.
+  BOOL isBlockImage = (node.children.count == 1 && ((MarkdownASTNode *)node.children[0]).type == MarkdownNodeTypeImage);
+
+  // Apply line height only for text paragraphs to avoid unwanted gaps above/below images.
+  if (!isBlockImage) {
+    applyLineHeight(output, range, _config.paragraphLineHeight);
+  }
+
+  // 3. Margin Application
+  // Only top-level paragraphs apply bottom margins; nested paragraphs defer to their parents.
+  CGFloat marginBottom = 0;
+  if (isTopLevel) {
+    marginBottom = isBlockImage ? _config.imageMarginBottom : _config.paragraphMarginBottom;
+  }
+
+  applyParagraphSpacing(output, start, marginBottom);
+}
+
+@end

package/ios/renderer/RenderContext.h

@@ -0,0 +1,88 @@
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+
+typedef NS_ENUM(NSInteger, BlockType) {
+  BlockTypeNone,
+  BlockTypeParagraph,
+  BlockTypeHeading,
+  BlockTypeBlockquote,
+  BlockTypeUnorderedList,
+  BlockTypeOrderedList,
+  BlockTypeCodeBlock
+};
+
+typedef NS_ENUM(NSInteger, ListType) { ListTypeUnordered, ListTypeOrdered };
+
+@interface BlockStyle : NSObject
+@property (nonatomic, assign) CGFloat fontSize;
+@property (nonatomic, strong) NSString *fontFamily;
+@property (nonatomic, strong) NSString *fontWeight;
+@property (nonatomic, strong) UIColor *color;
+@property (nonatomic, strong) UIFont *cachedFont;
+@property (nonatomic, strong) NSDictionary *cachedTextAttributes;
+@end
+
+@interface RenderContext : NSObject
+@property (nonatomic, strong) NSMutableArray<NSValue *> *linkRanges;
+@property (nonatomic, strong) NSMutableArray<NSString *> *linkURLs;
+@property (nonatomic, assign) BlockType currentBlockType;
+@property (nonatomic, strong) BlockStyle *currentBlockStyle;
+@property (nonatomic, assign) NSInteger currentHeadingLevel;
+@property (nonatomic, assign) NSInteger blockquoteDepth;
+@property (nonatomic, assign) NSInteger listDepth;
+@property (nonatomic, assign) ListType listType;
+@property (nonatomic, assign) NSInteger listItemNumber;
+
+- (instancetype)init;
+- (void)reset;
+
+- (UIFont *)cachedFontForSize:(CGFloat)fontSize family:(NSString *)fontFamily weight:(NSString *)fontWeight;
+- (NSMutableParagraphStyle *)spacerStyleWithHeight:(CGFloat)height spacing:(CGFloat)spacing;
+- (NSMutableParagraphStyle *)blockSpacerStyleWithMargin:(CGFloat)margin;
+- (void)registerLinkRange:(NSRange)range url:(NSString *)url;
+- (void)setBlockStyle:(BlockType)type
+             fontSize:(CGFloat)fontSize
+           fontFamily:(NSString *)fontFamily
+           fontWeight:(NSString *)fontWeight
+                color:(UIColor *)color;
+- (void)setBlockStyle:(BlockType)type
+             fontSize:(CGFloat)fontSize
+           fontFamily:(NSString *)fontFamily
+           fontWeight:(NSString *)fontWeight
+                color:(UIColor *)color
+         headingLevel:(NSInteger)headingLevel;
+- (void)setBlockStyle:(BlockType)type font:(UIFont *)font color:(UIColor *)color headingLevel:(NSInteger)headingLevel;
+- (BlockStyle *)getBlockStyle;
+- (NSDictionary *)getTextAttributes;
+- (void)clearBlockStyle;
+
+/**
+ * Checks if colors should be preserved based on existing attributes.
+ * Returns YES if the text is inside a link or inline code, which means
+ * we should preserve their colors instead of applying new colors.
+ */
++ (BOOL)shouldPreserveColors:(NSDictionary *)existingAttributes;
+
+/**
+ * Calculates the color that strong would use based on the configured strong color and block style.
+ * Uses strongColor if explicitly set (different from block color), otherwise uses block color.
+ */
++ (UIColor *)calculateStrongColor:(UIColor *)configStrongColor blockColor:(UIColor *)blockColor;
+
+/**
+ * Calculates the range for content rendered between start and current output length.
+ * Returns a range with length 0 if no content was rendered.
+ */
++ (NSRange)rangeForRenderedContent:(NSMutableAttributedString *)output start:(NSUInteger)start;
+
+/**
+ * Applies font and color attributes conditionally, only updating if they've changed.
+ * Returns YES if any attributes were updated, NO otherwise.
+ */
++ (BOOL)applyFontAndColorAttributes:(NSMutableAttributedString *)output
+                              range:(NSRange)range
+                               font:(UIFont *)font
+                              color:(UIColor *)color
+                 existingAttributes:(NSDictionary *)existingAttributes
+               shouldPreserveColors:(BOOL)shouldPreserveColors;
+@end

package/ios/renderer/RenderContext.m

@@ -0,0 +1,248 @@
+#import "RenderContext.h"
+#import "CodeBackground.h"
+#import <React/RCTFont.h>
+
+@implementation BlockStyle
+@end
+
+@implementation RenderContext {
+  NSMutableDictionary<NSString *, UIFont *> *_fontCache;
+  NSParagraphStyle *_baseSpacerTemplate;
+  NSParagraphStyle *_baseBlockSpacerTemplate;
+}
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _linkRanges = [NSMutableArray array];
+    _linkURLs = [NSMutableArray array];
+    _fontCache = [NSMutableDictionary dictionary];
+    _currentBlockStyle = [[BlockStyle alloc] init];
+
+    NSMutableParagraphStyle *spacerTemplate = [[NSMutableParagraphStyle alloc] init];
+    _baseSpacerTemplate = [spacerTemplate copy];
+
+    NSMutableParagraphStyle *blockSpacerTemplate = [[NSMutableParagraphStyle alloc] init];
+    blockSpacerTemplate.minimumLineHeight = 1;
+    blockSpacerTemplate.maximumLineHeight = 1;
+    _baseBlockSpacerTemplate = [blockSpacerTemplate copy];
+
+    [self reset];
+  }
+  return self;
+}
+
+#pragma mark - Font Cache
+
+- (UIFont *)cachedFontForSize:(CGFloat)fontSize family:(NSString *)fontFamily weight:(NSString *)fontWeight
+{
+  NSString *weightKey = (fontWeight.length > 0) ? fontWeight : @"";
+  NSString *key = [NSString stringWithFormat:@"%.1f|%@|%@", fontSize, fontFamily ?: @"", weightKey];
+
+  UIFont *cached = _fontCache[key];
+  if (cached) {
+    return cached;
+  }
+
+  NSString *effectiveWeight = (fontWeight.length > 0) ? fontWeight : nil;
+
+  UIFont *font = [RCTFont updateFont:nil
+                          withFamily:fontFamily
+                                size:@(fontSize)
+                              weight:effectiveWeight
+                               style:nil
+                             variant:nil
+                     scaleMultiplier:1];
+
+  if (font) {
+    _fontCache[key] = font;
+  }
+  return font;
+}
+
+#pragma mark - Paragraph Style Factory
+
+- (NSMutableParagraphStyle *)spacerStyleWithHeight:(CGFloat)height spacing:(CGFloat)spacing
+{
+  NSMutableParagraphStyle *style = [_baseSpacerTemplate mutableCopy];
+  style.minimumLineHeight = height;
+  style.maximumLineHeight = height;
+  style.paragraphSpacing = spacing;
+  return style;
+}
+
+- (NSMutableParagraphStyle *)blockSpacerStyleWithMargin:(CGFloat)margin
+{
+  NSMutableParagraphStyle *style = [_baseBlockSpacerTemplate mutableCopy];
+  style.paragraphSpacing = margin;
+  return style;
+}
+
+#pragma mark - Link Registry
+
+- (void)registerLinkRange:(NSRange)range url:(NSString *)url
+{
+  if (range.length == 0)
+    return;
+  [self.linkRanges addObject:[NSValue valueWithRange:range]];
+  [self.linkURLs addObject:url ?: @""];
+}
+
+#pragma mark - Block Style Management
+
+/**
+ * Updates the shared BlockStyle object with new traits.
+ * This avoids allocating a new object for every block node in the AST.
+ */
+- (void)setBlockStyle:(BlockType)type
+             fontSize:(CGFloat)fontSize
+           fontFamily:(NSString *)fontFamily
+           fontWeight:(NSString *)fontWeight
+                color:(UIColor *)color
+         headingLevel:(NSInteger)headingLevel
+{
+  _currentBlockType = type;
+  _currentHeadingLevel = headingLevel;
+
+  _currentBlockStyle.fontSize = fontSize;
+  _currentBlockStyle.fontFamily = fontFamily ?: @"";
+  _currentBlockStyle.fontWeight = fontWeight ?: @"normal";
+  _currentBlockStyle.color = color ?: [UIColor blackColor];
+}
+
+- (void)setBlockStyle:(BlockType)type
+             fontSize:(CGFloat)fontSize
+           fontFamily:(NSString *)fontFamily
+           fontWeight:(NSString *)fontWeight
+                color:(UIColor *)color
+{
+  [self setBlockStyle:type fontSize:fontSize fontFamily:fontFamily fontWeight:fontWeight color:color headingLevel:0];
+}
+
+- (void)setBlockStyle:(BlockType)type font:(UIFont *)font color:(UIColor *)color headingLevel:(NSInteger)headingLevel
+{
+  _currentBlockType = type;
+  _currentHeadingLevel = headingLevel;
+
+  UIColor *finalColor = color ?: [UIColor blackColor];
+  _currentBlockStyle.cachedFont = font;
+  _currentBlockStyle.color = finalColor;
+
+  // Pre-create text attributes dictionary if we have both font and color
+  if (font) {
+    _currentBlockStyle.cachedTextAttributes =
+        @{NSFontAttributeName : font, NSForegroundColorAttributeName : finalColor};
+  }
+}
+
+- (BlockStyle *)getBlockStyle
+{
+  return _currentBlockStyle;
+}
+
+- (NSDictionary *)getTextAttributes
+{
+  BlockStyle *style = _currentBlockStyle;
+
+  // Return pre-cached attributes if available
+  if (style.cachedTextAttributes) {
+    return style.cachedTextAttributes;
+  }
+
+  // Fall back to creating attributes from font cache
+  UIFont *font = style.cachedFont;
+  if (!font) {
+    font = [self cachedFontForSize:style.fontSize family:style.fontFamily weight:style.fontWeight];
+  }
+  UIColor *color = style.color ?: [UIColor blackColor];
+
+  // Cache for future calls within same block
+  style.cachedTextAttributes = @{NSFontAttributeName : font, NSForegroundColorAttributeName : color};
+  return style.cachedTextAttributes;
+}
+
+- (void)clearBlockStyle
+{
+  _currentBlockType = BlockTypeNone;
+  _currentHeadingLevel = 0;
+  _currentBlockStyle.cachedFont = nil;
+  _currentBlockStyle.cachedTextAttributes = nil;
+}
+
+#pragma mark - Reset
+
+- (void)reset
+{
+  [_linkRanges removeAllObjects];
+  [_linkURLs removeAllObjects];
+  [self clearBlockStyle];
+
+  _blockquoteDepth = 0;
+  _listDepth = 0;
+  _listType = ListTypeUnordered;
+  _listItemNumber = 0;
+
+  // Revert shared style object to baseline defaults
+  _currentBlockStyle.fontSize = 0;
+  _currentBlockStyle.fontFamily = @"";
+  _currentBlockStyle.fontWeight = @"";
+  _currentBlockStyle.color = [UIColor blackColor];
+}
+
+#pragma mark - Static Utilities
+
+/**
+ * Determines if specific inline attributes should protect the current color.
+ */
++ (BOOL)shouldPreserveColors:(NSDictionary *)attrs
+{
+  return (attrs[NSLinkAttributeName] != nil || attrs[CodeAttributeName] != nil);
+}
+
+/**
+ * Calculates whether a strong color should override the block color.
+ */
++ (UIColor *)calculateStrongColor:(UIColor *)configStrongColor blockColor:(UIColor *)blockColor
+{
+  if (!configStrongColor || [configStrongColor isEqual:blockColor]) {
+    return blockColor;
+  }
+  return configStrongColor;
+}
+
+/**
+ * Safely calculates a range based on a start point and the current output length.
+ */
++ (NSRange)rangeForRenderedContent:(NSMutableAttributedString *)output start:(NSUInteger)start
+{
+  if (output.length < start)
+    return NSMakeRange(start, 0);
+  return NSMakeRange(start, output.length - start);
+}
+
+/**
+ * Surgically applies attributes only if they differ from current values.
+ * This minimizes "dirtying" the AttributedString, which improves layout performance.
+ */
++ (void)applyFontAndColorAttributes:(NSMutableAttributedString *)output
+                              range:(NSRange)range
+                               font:(UIFont *)font
+                              color:(UIColor *)color
+                 existingAttributes:(NSDictionary *)attrs
+               shouldPreserveColors:(BOOL)shouldPreserve
+{
+  if (range.length == 0)
+    return;
+
+  // Font Update: Only if it exists and is different
+  if (font && ![font isEqual:attrs[NSFontAttributeName]]) {
+    [output addAttribute:NSFontAttributeName value:font range:range];
+  }
+
+  // Color Update: Only if not a link/code and different from existing
+  if (color && !shouldPreserve && ![color isEqual:attrs[NSForegroundColorAttributeName]]) {
+    [output addAttribute:NSForegroundColorAttributeName value:color range:range];
+  }
+}
+
+@end

package/ios/renderer/RendererFactory.h

@@ -0,0 +1,12 @@
+#import "MarkdownASTNode.h"
+#import "NodeRenderer.h"
+
+@class RenderContext;
+
+@interface RendererFactory : NSObject
+- (instancetype)initWithConfig:(id)config;
+- (id<NodeRenderer>)rendererForNodeType:(MarkdownNodeType)type;
+- (void)renderChildrenOfNode:(MarkdownASTNode *)node
+                        into:(NSMutableAttributedString *)output
+                     context:(RenderContext *)context;
+@end