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

package/ios/renderer/RenderContext.h

@@ -0,0 +1,118 @@
+#import "ENRMUIKit.h"
+#import <Foundation/Foundation.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) RCTUIColor *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, strong) NSMutableArray<NSValue *> *headingRanges;
+@property (nonatomic, strong) NSMutableArray<NSNumber *> *headingLevels;
+@property (nonatomic, strong) NSMutableArray<NSValue *> *imageRanges;
+@property (nonatomic, strong) NSMutableArray<NSString *> *imageAltTexts;
+@property (nonatomic, strong) NSMutableArray<NSString *> *imageURLs;
+@property (nonatomic, strong) NSMutableArray<NSValue *> *listItemRanges;
+@property (nonatomic, strong) NSMutableArray<NSNumber *> *listItemPositions; // Position in parent list (1, 2, 3...)
+@property (nonatomic, strong) NSMutableArray<NSNumber *> *listItemDepths;  // Nesting depth (1 = top level, 2+ = nested)
+@property (nonatomic, strong) NSMutableArray<NSNumber *> *listItemOrdered; // YES = ordered, NO = unordered (bullet)
+@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;
+@property (nonatomic, assign) BOOL allowFontScaling;
+@property (nonatomic, assign) CGFloat maxFontSizeMultiplier;
+@property (nonatomic, assign) NSInteger taskItemCount;
+
+- (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)applyLinkAttributesToString:(NSMutableAttributedString *)attributedString;
+- (void)registerHeadingRange:(NSRange)range level:(NSInteger)level text:(NSString *)text;
+- (void)registerImageRange:(NSRange)range altText:(NSString *)altText url:(NSString *)url;
+- (void)registerListItemRange:(NSRange)range
+                     position:(NSInteger)position
+                        depth:(NSInteger)depth
+                    isOrdered:(BOOL)isOrdered;
+- (void)setBlockStyle:(BlockType)type
+             fontSize:(CGFloat)fontSize
+           fontFamily:(NSString *)fontFamily
+           fontWeight:(NSString *)fontWeight
+                color:(RCTUIColor *)color;
+- (void)setBlockStyle:(BlockType)type
+             fontSize:(CGFloat)fontSize
+           fontFamily:(NSString *)fontFamily
+           fontWeight:(NSString *)fontWeight
+                color:(RCTUIColor *)color
+         headingLevel:(NSInteger)headingLevel;
+- (void)setBlockStyle:(BlockType)type
+                 font:(UIFont *)font
+                color:(RCTUIColor *)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.
+ */
++ (RCTUIColor *)calculateStrongColor:(RCTUIColor *)configStrongColor blockColor:(RCTUIColor *)blockColor;
+
+/**
+ * Resolves highlight foreground color: uses block color when config matches paragraph default.
+ */
++ (RCTUIColor *)calculateHighlightColor:(RCTUIColor *)configHighlightColor
+                         paragraphColor:(RCTUIColor *)paragraphColor
+                             blockColor:(RCTUIColor *)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:(RCTUIColor *)color
+                 existingAttributes:(NSDictionary *)existingAttributes
+               shouldPreserveColors:(BOOL)shouldPreserveColors;
+@end

package/ios/renderer/RenderContext.m

@@ -0,0 +1,337 @@
+#import "RenderContext.h"
+#import "CodeBackground.h"
+#import "FontUtils.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];
+    _headingRanges = [NSMutableArray array];
+    _headingLevels = [NSMutableArray array];
+    _imageRanges = [NSMutableArray array];
+    _imageAltTexts = [NSMutableArray array];
+    _imageURLs = [NSMutableArray array];
+    _listItemRanges = [NSMutableArray array];
+    _listItemPositions = [NSMutableArray array];
+    _listItemDepths = [NSMutableArray array];
+    _listItemOrdered = [NSMutableArray array];
+    _fontCache = [NSMutableDictionary dictionary];
+    _currentBlockStyle = [[BlockStyle alloc] init];
+    _allowFontScaling = YES;
+    _maxFontSizeMultiplier = 0;
+
+    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
+{
+  CGFloat effectiveMultiplier = _allowFontScaling ? RCTFontSizeMultiplierWithMax(_maxFontSizeMultiplier) : 1.0;
+
+  NSString *weightKey = (fontWeight.length > 0) ? fontWeight : @"";
+  NSString *key =
+      [NSString stringWithFormat:@"%.1f|%@|%@|%.2f", fontSize, fontFamily ?: @"", weightKey, effectiveMultiplier];
+
+  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:effectiveMultiplier];
+
+  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 ?: @""];
+}
+
+- (void)applyLinkAttributesToString:(NSMutableAttributedString *)attributedString
+{
+  NSUInteger length = attributedString.length;
+  for (NSUInteger i = 0; i < self.linkRanges.count; i++) {
+    NSRange range = [self.linkRanges[i] rangeValue];
+    if (NSMaxRange(range) > length)
+      continue;
+    [attributedString addAttribute:@"linkURL" value:self.linkURLs[i] range:range];
+  }
+}
+
+- (void)registerHeadingRange:(NSRange)range level:(NSInteger)level text:(NSString *)text
+{
+  if (range.length == 0)
+    return;
+  [self.headingRanges addObject:[NSValue valueWithRange:range]];
+  [self.headingLevels addObject:@(level)];
+}
+
+- (void)registerImageRange:(NSRange)range altText:(NSString *)altText url:(NSString *)url
+{
+  if (range.length == 0)
+    return;
+  [self.imageRanges addObject:[NSValue valueWithRange:range]];
+  [self.imageAltTexts addObject:altText ?: @""];
+  [self.imageURLs addObject:url ?: @""];
+}
+
+#pragma mark - Registration Helpers
+
+- (void)registerListItemRange:(NSRange)range
+                     position:(NSInteger)position
+                        depth:(NSInteger)depth
+                    isOrdered:(BOOL)isOrdered
+{
+  if (![self isValidRange:range])
+    return;
+
+  [self.listItemRanges addObject:[NSValue valueWithRange:range]];
+  [self.listItemPositions addObject:@(position)];
+  [self.listItemDepths addObject:@(depth)];
+  [self.listItemOrdered addObject:@(isOrdered)];
+}
+
+#pragma mark - Private
+
+- (BOOL)isValidRange:(NSRange)range
+{
+  return range.length > 0 && range.location != NSNotFound;
+}
+
+#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:(RCTUIColor *)color
+         headingLevel:(NSInteger)headingLevel
+{
+  _currentBlockType = type;
+  _currentHeadingLevel = headingLevel;
+
+  _currentBlockStyle.fontSize = fontSize;
+  _currentBlockStyle.fontFamily = fontFamily ?: @"";
+  _currentBlockStyle.fontWeight = fontWeight ?: @"normal";
+  _currentBlockStyle.color = color ?: [RCTUIColor blackColor];
+}
+
+- (void)setBlockStyle:(BlockType)type
+             fontSize:(CGFloat)fontSize
+           fontFamily:(NSString *)fontFamily
+           fontWeight:(NSString *)fontWeight
+                color:(RCTUIColor *)color
+{
+  [self setBlockStyle:type fontSize:fontSize fontFamily:fontFamily fontWeight:fontWeight color:color headingLevel:0];
+}
+
+- (void)setBlockStyle:(BlockType)type font:(UIFont *)font color:(RCTUIColor *)color headingLevel:(NSInteger)headingLevel
+{
+  _currentBlockType = type;
+  _currentHeadingLevel = headingLevel;
+
+  RCTUIColor *finalColor = color ?: [RCTUIColor 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];
+  }
+  RCTUIColor *color = style.color ?: [RCTUIColor 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];
+  [_headingRanges removeAllObjects];
+  [_headingLevels removeAllObjects];
+  [_imageRanges removeAllObjects];
+  [_imageAltTexts removeAllObjects];
+  [_imageURLs removeAllObjects];
+  [_listItemRanges removeAllObjects];
+  [_listItemPositions removeAllObjects];
+  [_listItemDepths removeAllObjects];
+  [_listItemOrdered removeAllObjects];
+  [self clearBlockStyle];
+
+  _blockquoteDepth = 0;
+  _listDepth = 0;
+  _listType = ListTypeUnordered;
+  _listItemNumber = 0;
+  _taskItemCount = 0;
+
+  // Revert shared style object to baseline defaults
+  _currentBlockStyle.fontSize = 0;
+  _currentBlockStyle.fontFamily = @"";
+  _currentBlockStyle.fontWeight = @"";
+  _currentBlockStyle.color = [RCTUIColor 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);
+}
+
+// TODO: Unify calculateStrongColor and calculateHighlightColor into a single helper that
+// resolves inline foreground color from (configColor, inheritanceBaseline, blockColor).
+
+/**
+ * Calculates whether a strong color should override the block color.
+ */
++ (RCTUIColor *)calculateStrongColor:(RCTUIColor *)configStrongColor blockColor:(RCTUIColor *)blockColor
+{
+  if (!configStrongColor || [configStrongColor isEqual:blockColor]) {
+    return blockColor;
+  }
+  return configStrongColor;
+}
+
++ (RCTUIColor *)calculateHighlightColor:(RCTUIColor *)configHighlightColor
+                         paragraphColor:(RCTUIColor *)paragraphColor
+                             blockColor:(RCTUIColor *)blockColor
+{
+  if ([configHighlightColor isEqual:paragraphColor]) {
+    return blockColor;
+  }
+  return configHighlightColor;
+}
+
+/**
+ * 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:(RCTUIColor *)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

package/ios/renderer/RendererFactory.m

@@ -0,0 +1,147 @@
+#import "RendererFactory.h"
+#import "BlockquoteRenderer.h"
+#import "CodeBlockRenderer.h"
+#import "CodeRenderer.h"
+#import "ENRMImageRenderer.h"
+#import "EmphasisRenderer.h"
+
+#import "ENRMFeatureFlags.h"
+
+#if ENRICHED_MARKDOWN_MATH
+#import "ENRMMathInlineRenderer.h"
+#endif
+#import "ENRMSpoilerRenderer.h"
+#import "HeadingRenderer.h"
+#import "HighlightRenderer.h"
+#import "LinkRenderer.h"
+#import "ListItemRenderer.h"
+#import "ListRenderer.h"
+#import "MarkdownASTNode.h"
+#import "ParagraphRenderer.h"
+#import "RenderContext.h"
+#import "StrikethroughRenderer.h"
+#import "StrongRenderer.h"
+#import "StyleConfig.h"
+#import "SubscriptRenderer.h"
+#import "SuperscriptRenderer.h"
+#import "TextRenderer.h"
+#import "ThematicBreakRenderer.h"
+#import "UnderlineRenderer.h"
+
+@implementation RendererFactory {
+  StyleConfig *_config;
+  NSMutableDictionary<NSNumber *, id<NodeRenderer>> *_cache;
+}
+
+/**
+ * Initializes the factory with a shared style configuration.
+ * Uses a mutable dictionary to cache renderer instances as they are needed.
+ */
+- (instancetype)initWithConfig:(StyleConfig *)config
+{
+  self = [super init];
+  if (self) {
+    _config = config;
+    _cache = [NSMutableDictionary new];
+  }
+  return self;
+}
+
+/**
+ * Returns a shared renderer instance for a specific node type.
+ * Implements lazy initialization to avoid allocating unused renderers.
+ */
+- (id<NodeRenderer>)rendererForNodeType:(MarkdownNodeType)type
+{
+  id<NodeRenderer> cached = _cache[@(type)];
+  if (cached) {
+    return cached;
+  }
+
+  id<NodeRenderer> renderer = [self createRendererForType:type];
+  if (renderer) {
+    _cache[@(type)] = renderer;
+  }
+  return renderer;
+}
+
+/**
+ * Internal factory method to instantiate specialized renderers.
+ */
+- (id<NodeRenderer>)createRendererForType:(MarkdownNodeType)type
+{
+  switch (type) {
+    case MarkdownNodeTypeText:
+      return [TextRenderer new];
+    case MarkdownNodeTypeStrong:
+      return [[StrongRenderer alloc] initWithRendererFactory:self config:_config];
+    case MarkdownNodeTypeEmphasis:
+      return [[EmphasisRenderer alloc] initWithRendererFactory:self config:_config];
+    case MarkdownNodeTypeStrikethrough:
+      return [[StrikethroughRenderer alloc] initWithRendererFactory:self config:_config];
+    case MarkdownNodeTypeUnderline:
+      return [[UnderlineRenderer alloc] initWithRendererFactory:self config:_config];
+    case MarkdownNodeTypeSuperscript:
+      return [[SuperscriptRenderer alloc] initWithRendererFactory:self config:_config];
+    case MarkdownNodeTypeSubscript:
+      return [[SubscriptRenderer alloc] initWithRendererFactory:self config:_config];
+    case MarkdownNodeTypeHighlight:
+      return [[HighlightRenderer alloc] initWithRendererFactory:self config:_config];
+    case MarkdownNodeTypeParagraph:
+      return [[ParagraphRenderer alloc] initWithRendererFactory:self config:_config];
+    case MarkdownNodeTypeLink:
+      return [[LinkRenderer alloc] initWithRendererFactory:self config:_config];
+    case MarkdownNodeTypeHeading:
+      return [[HeadingRenderer alloc] initWithRendererFactory:self config:_config];
+    case MarkdownNodeTypeCode:
+      return [[CodeRenderer alloc] initWithRendererFactory:self config:_config];
+    case MarkdownNodeTypeImage:
+      return [[ENRMImageRenderer alloc] initWithRendererFactory:self config:_config];
+    case MarkdownNodeTypeBlockquote:
+      return [[BlockquoteRenderer alloc] initWithRendererFactory:self config:_config];
+    case MarkdownNodeTypeListItem:
+      return [[ListItemRenderer alloc] initWithRendererFactory:self config:_config];
+    case MarkdownNodeTypeUnorderedList:
+      return [[ListRenderer alloc] initWithRendererFactory:self config:_config isOrdered:NO];
+    case MarkdownNodeTypeOrderedList:
+      return [[ListRenderer alloc] initWithRendererFactory:self config:_config isOrdered:YES];
+    case MarkdownNodeTypeCodeBlock:
+      return [[CodeBlockRenderer alloc] initWithRendererFactory:self config:_config];
+    case MarkdownNodeTypeThematicBreak:
+      return [[ThematicBreakRenderer alloc] initWithRendererFactory:self config:_config];
+#if ENRICHED_MARKDOWN_MATH
+    case MarkdownNodeTypeLatexMathInline:
+      return [[ENRMMathInlineRenderer alloc] initWithRendererFactory:self config:_config];
+#endif
+    case MarkdownNodeTypeSpoiler:
+      return [[ENRMSpoilerRenderer alloc] initWithRendererFactory:self config:_config];
+    default:
+      return nil;
+  }
+}
+
+/**
+ * Helper method for container renderers to process their children.
+ * Leverages the factory to find the appropriate renderer for each child node.
+ */
+- (void)renderChildrenOfNode:(MarkdownASTNode *)node
+                        into:(NSMutableAttributedString *)output
+                     context:(RenderContext *)context
+{
+  for (MarkdownASTNode *child in node.children) {
+    if (child.type == MarkdownNodeTypeLineBreak) {
+      NSAttributedString *lineBreak = [[NSAttributedString alloc] initWithString:@"\u2028"
+                                                                      attributes:[context getTextAttributes]];
+      [output appendAttributedString:lineBreak];
+      continue;
+    }
+    id<NodeRenderer> renderer = [self rendererForNodeType:child.type];
+    if (renderer) {
+      [renderer renderNode:child into:output context:context];
+    } else if (child.children.count > 0) {
+      [self renderChildrenOfNode:child into:output context:context];
+    }
+  }
+}
+
+@end

package/ios/renderer/StrikethroughRenderer.h

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

package/ios/renderer/StrikethroughRenderer.m

@@ -0,0 +1,28 @@
+#import "StrikethroughRenderer.h"
+#import "MarkdownASTNode.h"
+#import "RenderContext.h"
+#import "RendererFactory.h"
+#import "StyleConfig.h"
+
+@implementation StrikethroughRenderer
+
+#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;
+
+  // Apply strikethrough style
+  [output addAttribute:NSStrikethroughStyleAttributeName value:@(NSUnderlineStyleSingle) range:range];
+
+  // Apply strikethrough line color (not text color)
+  RCTUIColor *strikethroughColor = [_config strikethroughColor];
+  [output addAttribute:NSStrikethroughColorAttributeName value:strikethroughColor range:range];
+}
+
+@end

package/ios/renderer/StrongRenderer.h

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