@mathers101/react-native-render-rich-text 0.0.0-stage → 0.1.10

package/ios/renderer/ListItemRenderer.m

@@ -0,0 +1,283 @@
+#import "ListItemRenderer.h"
+#import "BlockquoteBorder.h"
+#import "ENRMUIKit.h"
+#import "LastElementUtils.h"
+#import "TiptapASTNode.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";
+NSString *const ListItemMarkerStartAttribute = @"ListItemMarkerStart";
+NSString *const TaskItemAttribute = @"TaskItem";
+NSString *const TaskCheckedAttribute = @"TaskChecked";
+NSString *const TaskIndexAttribute = @"TaskIndex";
+
+@implementation ENRMListMarkerDescriptor
+@end
+
+// NSArray's -hash is its count, so plain one-marker arrays all collide in the
+// table that uniques attribute dictionaries, and each list item probes past
+// every earlier one. Hashing by the item's own marker keeps rendering linear.
+@interface ENRMListMarkerArray : NSArray
+@end
+
+@implementation ENRMListMarkerArray {
+  NSArray<ENRMListMarkerDescriptor *> *_markers;
+}
+
+- (instancetype)initWithMarkers:(NSArray<ENRMListMarkerDescriptor *> *)markers
+{
+  if (self = [super init]) {
+    _markers = [markers copy];
+  }
+  return self;
+}
+
+- (NSUInteger)count
+{
+  return _markers.count;
+}
+
+- (id)objectAtIndex:(NSUInteger)index
+{
+  return _markers[index];
+}
+
+- (NSUInteger)hash
+{
+  return _markers.lastObject.hash;
+}
+
+@end
+
+@interface ListItemRenderer ()
+- (void)applyCheckedDecorationsTo:(NSMutableAttributedString *)output
+                            range:(NSRange)range
+                     nestingLevel:(NSInteger)nestingLevel;
+@end
+
+@implementation ListItemRenderer
+
+- (void)renderNodeContent:(TiptapASTNode *)node
+                     into:(NSMutableAttributedString *)output
+                  context:(RenderContext *)context
+{
+  if (!context)
+    return;
+
+  context.listItemNumber++;
+  const NSInteger currentPosition = context.listItemNumber;
+  const NSInteger currentDepth = context.listDepth; // 1-based (1 = top level)
+
+  const BOOL isTask = [node.attributes[@"isTask"] isEqualToString:@"true"];
+  const BOOL isChecked = isTask && [node.attributes[@"taskChecked"] isEqualToString:@"true"];
+  NSInteger taskIndex = -1;
+  if (isTask) {
+    taskIndex = context.taskItemCount;
+    context.taskItemCount++;
+  }
+
+  // currentDepth - 1 handles the horizontal offset for nested lists
+  const NSInteger nestingLevel = currentDepth - 1;
+  // Bullets share the ordered-list `99.` column so both lists indent equally.
+  // A task in a widened ordered list moves with its numbered siblings.
+  const CGFloat baseMarkerWidth = isTask ? [_config effectiveListMarginLeftForTask] + context.listMarkerExtra
+                                         : context.listMarkerWidth;
+
+  const CGFloat blockquoteIndent =
+      blockquoteIndentForDepth(context.blockquoteDepth, [_config blockquoteBorderWidth] + [_config blockquoteGapWidth]);
+
+  const CGFloat totalIndent = blockquoteIndent + baseMarkerWidth + [_config effectiveListGapWidth] +
+                              (nestingLevel * [_config listStyleMarginLeft]) + context.ancestorMarkerOffset;
+
+  const NSUInteger startLocation = output.length;
+
+  // Manual save/restore — a scope snapshot would also roll back the listItemNumber increment
+  const CGFloat prevMarkerExtra = context.listItemMarkerExtra;
+  context.listItemMarkerExtra = context.listMarkerExtra;
+  const CGFloat prevIndent = context.accumulatedIndent;
+  context.accumulatedIndent = totalIndent;
+  @try {
+    [_rendererFactory renderChildrenOfNode:node into:output context:context];
+  } @finally {
+    context.accumulatedIndent = prevIndent;
+    context.listItemMarkerExtra = prevMarkerExtra;
+  }
+
+  // Ensure every list item ends with a newline to prevent paragraph merging
+  if (output.length > startLocation && ![output.string hasSuffix:@"\n"]) {
+    [output appendAttributedString:kNewlineAttributedString];
+  }
+
+  const NSRange itemRange = NSMakeRange(startLocation, output.length - startLocation);
+  if (itemRange.length == 0)
+    return;
+
+  // Informs TiptapAccessibilityElementBuilder about the specific boundaries of this list item
+  [context registerListItemRange:itemRange
+                        position:currentPosition
+                           depth:currentDepth
+                       isOrdered:(context.listType == ListTypeOrdered)];
+
+  const CGFloat lineHeightConfig = [_config listStyleLineHeight];
+
+  // Boxing metadata for attributed string storage
+  NSMutableDictionary *metadata = [@{
+    ListDepthAttribute : @(nestingLevel),
+    ListTypeAttribute : @(context.listType),
+    ListItemNumberAttribute : @(currentPosition)
+  } mutableCopy];
+
+  if (isTask) {
+    metadata[TaskItemAttribute] = @YES;
+    metadata[TaskCheckedAttribute] = @(isChecked);
+    metadata[TaskIndexAttribute] = @(taskIndex);
+  }
+
+  // Preserve styles of nested sub-lists and code blocks by applying the list
+  // paragraph style only to the surviving gaps between them.
+  NSMutableArray<NSValue *> *skipRanges = [NSMutableArray array];
+  [output enumerateAttribute:CodeBlockAttributeName
+                     inRange:itemRange
+                     options:0
+                  usingBlock:^(id value, NSRange range, BOOL *stop) {
+                    if ([value boolValue]) {
+                      [skipRanges addObject:[NSValue valueWithRange:range]];
+                    }
+                  }];
+  [output enumerateAttribute:ListDepthAttribute
+                     inRange:itemRange
+                     options:0
+                  usingBlock:^(id depthAttr, NSRange range, BOOL *stop) {
+                    if (depthAttr && [depthAttr integerValue] > nestingLevel) {
+                      [skipRanges addObject:[NSValue valueWithRange:range]];
+                    }
+                  }];
+  [skipRanges sortUsingComparator:^NSComparisonResult(NSValue *a, NSValue *b) {
+    NSUInteger la = [a rangeValue].location;
+    NSUInteger lb = [b rangeValue].location;
+    return la < lb ? NSOrderedAscending : (la > lb ? NSOrderedDescending : NSOrderedSame);
+  }];
+
+  void (^applyStyleToRange)(NSRange) = ^(NSRange range) {
+    if (range.length == 0)
+      return;
+    NSMutableParagraphStyle *style = [[NSMutableParagraphStyle alloc] init];
+    style.firstLineHeadIndent = totalIndent;
+    style.headIndent = totalIndent;
+    const CGFloat lineHeight = ENRMLineHeightWithLinkPills(output, range, lineHeightConfig);
+    if (lineHeight > 0) {
+      style.minimumLineHeight = lineHeight;
+    }
+    NSMutableDictionary *attributesToApply = [metadata mutableCopy];
+    attributesToApply[NSParagraphStyleAttributeName] = style;
+    [output addAttributes:attributesToApply range:range];
+    if (lineHeight > 0) {
+      applyBaselineOffset(output, range);
+    }
+  };
+
+  NSUInteger pos = itemRange.location;
+  const NSUInteger itemEnd = NSMaxRange(itemRange);
+  for (NSValue *val in skipRanges) {
+    NSRange skip = [val rangeValue];
+    if (pos < skip.location) {
+      applyStyleToRange(NSMakeRange(pos, skip.location - pos));
+    }
+    pos = MAX(pos, NSMaxRange(skip));
+  }
+  if (pos < itemEnd) {
+    applyStyleToRange(NSMakeRange(pos, itemEnd - pos));
+  }
+
+  ENRMListMarkerDescriptor *marker = [[ENRMListMarkerDescriptor alloc] init];
+  marker.isTask = isTask;
+  marker.isChecked = isChecked;
+  marker.taskIndex = taskIndex;
+  marker.listType = context.listType;
+  marker.number = currentPosition;
+  marker.depth = nestingLevel;
+  marker.indent = totalIndent;
+
+  // Anchor on the first content character so items that open with a code block
+  // or nested sublist still get their marker; fall back to startLocation for
+  // whitespace-only items.
+  NSUInteger anchorLocation = startLocation;
+  NSString *string = output.string;
+  for (NSUInteger i = startLocation; i < itemEnd; i++) {
+    if ([string characterAtIndex:i] != '\n') {
+      anchorLocation = i;
+      break;
+    }
+  }
+
+  // Cover the whole grapheme cluster: anchoring on a single UTF-16 code unit
+  // splits multi-unit graphemes (emoji surrogate pairs, ZWJ sequences) across
+  // two attribute runs, which drops the glyph and hides the marker for every
+  // item but the last.
+  const NSRange anchorRange = [string rangeOfComposedCharacterSequenceAtIndex:anchorLocation];
+
+  NSArray *existingMarkers = [output attribute:ListItemMarkerStartAttribute atIndex:anchorLocation effectiveRange:NULL];
+  NSArray *markers =
+      [existingMarkers isKindOfClass:[NSArray class]] ? [existingMarkers arrayByAddingObject:marker] : @[ marker ];
+  [output addAttribute:ListItemMarkerStartAttribute
+                 value:[[ENRMListMarkerArray alloc] initWithMarkers:markers]
+                 range:anchorRange];
+
+  if (isTask && isChecked) {
+    [self applyCheckedDecorationsTo:output range:itemRange nestingLevel:nestingLevel];
+  }
+}
+
+- (void)applyCheckedDecorationsTo:(NSMutableAttributedString *)output
+                            range:(NSRange)range
+                     nestingLevel:(NSInteger)nestingLevel
+{
+  RCTUIColor *checkedColor = [_config taskListCheckedTextColor];
+  BOOL shouldStrikethrough = [_config taskListCheckedStrikethrough];
+
+  if (!checkedColor && !shouldStrikethrough) {
+    return;
+  }
+
+  NSMutableDictionary *checkedAttrs = [NSMutableDictionary dictionary];
+
+  if (checkedColor) {
+    checkedAttrs[NSForegroundColorAttributeName] = checkedColor;
+  }
+
+  if (shouldStrikethrough) {
+    checkedAttrs[NSStrikethroughStyleAttributeName] = @(NSUnderlineStyleSingle);
+
+    RCTUIColor *lineColor = checkedColor ?: [_config listStyleColor];
+    if (lineColor) {
+      checkedAttrs[NSStrikethroughColorAttributeName] = lineColor;
+    }
+  }
+
+  [output enumerateAttribute:ListDepthAttribute
+                     inRange:range
+                     options:0
+                  usingBlock:^(NSNumber *depth, NSRange segmentRange, BOOL *stop) {
+                    BOOL isNestedSubItem = (depth && [depth integerValue] > nestingLevel);
+                    if (isNestedSubItem) {
+                      return;
+                    }
+
+                    // Skip code block ranges — preserve CodeBlockRenderer styles.
+                    NSNumber *isCodeBlock = [output attribute:CodeBlockAttributeName
+                                                      atIndex:segmentRange.location
+                                               effectiveRange:nil];
+                    if ([isCodeBlock boolValue]) {
+                      return;
+                    }
+
+                    [output addAttributes:checkedAttrs range:segmentRange];
+                  }];
+}
+
+@end

package/ios/renderer/ListRenderer.h

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

package/ios/renderer/ListRenderer.m

@@ -0,0 +1,126 @@
+#import "ListRenderer.h"
+#import "BlockquoteRenderer.h"
+#import "TiptapASTNode.h"
+#import "ParagraphStyleUtils.h"
+#import "RenderContext.h"
+#import "RendererFactory.h"
+#import "StyleConfig.h"
+
+// Inserts the configured vertical gap between consecutive list items (including
+// nested ones) by raising paragraphSpacing on the paragraph preceding each item
+// start. The first item of the root list gets no spacing above it.
+static void applyListItemSpacing(NSMutableAttributedString *output, RenderContext *context, NSUInteger listStart,
+                                 CGFloat itemSpacing)
+{
+  if (itemSpacing <= 0)
+    return;
+
+  NSMutableIndexSet *itemStarts = [NSMutableIndexSet indexSet];
+  for (NSValue *value in context.listItemRanges) {
+    NSUInteger location = [value rangeValue].location;
+    if (location >= listStart && location < output.length) {
+      [itemStarts addIndex:location];
+    }
+  }
+  if (itemStarts.count < 2)
+    return;
+
+  NSString *string = output.string;
+  const NSUInteger firstStart = itemStarts.firstIndex;
+  [itemStarts enumerateIndexesUsingBlock:^(NSUInteger itemStart, BOOL *stop) {
+    if (itemStart == firstStart)
+      return;
+    NSRange prevParagraph = [string paragraphRangeForRange:NSMakeRange(itemStart - 1, 0)];
+    [output enumerateAttribute:NSParagraphStyleAttributeName
+                       inRange:prevParagraph
+                       options:0
+                    usingBlock:^(NSParagraphStyle *style, NSRange range, BOOL *innerStop) {
+                      if (style.paragraphSpacing >= itemSpacing)
+                        return;
+                      NSMutableParagraphStyle *updated =
+                          style ? [style mutableCopy] : [[NSMutableParagraphStyle alloc] init];
+                      updated.paragraphSpacing = itemSpacing;
+                      [output addAttribute:NSParagraphStyleAttributeName value:updated range:range];
+                    }];
+  }];
+}
+
+@implementation ListRenderer {
+  BOOL _isOrdered;
+}
+
+- (instancetype)initWithRendererFactory:(RendererFactory *)factory config:(StyleConfig *)config isOrdered:(BOOL)ordered
+{
+  if (self = [super initWithRendererFactory:factory config:config]) {
+    _isOrdered = ordered;
+  }
+  return self;
+}
+
+- (id)takeContextSnapshot:(RenderContext *)context
+{
+  return [context snapshotScope];
+}
+
+- (void)renderNodeContent:(TiptapASTNode *)node
+                     into:(NSMutableAttributedString *)output
+                  context:(RenderContext *)context
+{
+  if (!context)
+    return;
+
+  const NSInteger prevDepth = context.listDepth;
+  const NSUInteger startLocation = output.length;
+
+  if (prevDepth == 0) {
+    // Apply top margin for root-level list
+    applyBlockSpacingBefore(output, startLocation, _config.listStyleMarginTop);
+  } else if (output.length > 0 && ![output.string hasSuffix:@"\n"]) {
+    // Ensure nested lists start on a new line
+    [output appendAttributedString:kNewlineAttributedString];
+  }
+
+  context.listDepth = prevDepth + 1;
+  context.listType = _isOrdered ? ListTypeOrdered : ListTypeUnordered;
+  NSInteger startNumber = 1;
+  NSString *startAttr = node.attributes[@"start"];
+  if (_isOrdered && startAttr != nil) {
+    startNumber = MAX((NSInteger)0, (NSInteger)startAttr.integerValue);
+  }
+  // ListItemRenderer pre-increments, so the counter starts one below the
+  // first rendered number.
+  context.listItemNumber = startNumber - 1;
+  const CGFloat defaultMarkerWidth = [_config effectiveListMarginLeftForNumber:99];
+  if (prevDepth > 0) {
+    context.ancestorMarkerOffset += context.listItemMarkerExtra;
+  }
+  context.listMarkerWidth = defaultMarkerWidth;
+  if (_isOrdered) {
+    NSInteger number = startNumber;
+    for (TiptapASTNode *item in node.children) {
+      if (item.type != TiptapNodeTypeListItem)
+        continue;
+      // Keep the existing gutter for one- and two-digit markers.
+      if (number >= 100 && ![item.attributes[@"isTask"] isEqualToString:@"true"]) {
+        context.listMarkerWidth = MAX(context.listMarkerWidth, [_config effectiveListMarginLeftForNumber:number]);
+      }
+      number++;
+    }
+  }
+  context.listMarkerExtra = context.listMarkerWidth - defaultMarkerWidth;
+
+  [context setBlockStyle:_isOrdered ? BlockTypeOrderedList : BlockTypeUnorderedList
+                    font:_config.listStyleFont
+                   color:_config.listStyleColor
+            headingLevel:0];
+
+  [_rendererFactory renderChildrenOfNode:node into:output context:context];
+
+  if (prevDepth == 0) {
+    applyListItemSpacing(output, context, startLocation, [_config listStyleItemSpacing]);
+    // Apply bottom margin for root-level list
+    applyBlockSpacingAfter(output, _config.listStyleMarginBottom);
+  }
+}
+
+@end

package/ios/renderer/MentionRenderer.h

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

package/ios/renderer/MentionRenderer.m

@@ -0,0 +1,96 @@
+#import "MentionRenderer.h"
+#import "FontUtils.h"
+#import "MentionBackground.h"
+#import "RenderContext.h"
+#import "RendererFactory.h"
+#import "StyleConfig.h"
+#import "TiptapASTNode.h"
+
+static RCTUIColor *ENRMMentionColor(RCTUIColor *styleColor, unsigned int rgb)
+{
+  if (styleColor)
+    return styleColor;
+  return [RCTUIColor colorWithRed:((rgb >> 16) & 0xFF) / 255.0
+                           green:((rgb >> 8) & 0xFF) / 255.0
+                            blue:(rgb & 0xFF) / 255.0
+                           alpha:1.0];
+}
+
+/// Semibold is the iOS weight for a name sitting in body text. Android uses medium.
+static UIFont *ENRMSemiboldFont(UIFont *font)
+{
+  if (!font)
+    return [UIFont systemFontOfSize:17 weight:UIFontWeightSemibold];
+
+  UIFontDescriptor *descriptor = [font.fontDescriptor fontDescriptorByAddingAttributes:@{
+    UIFontDescriptorTraitsAttribute : @{UIFontWeightTrait : @(UIFontWeightSemibold)}
+  }];
+  UIFont *resolved = [UIFont fontWithDescriptor:descriptor size:font.pointSize];
+  return resolved ?: font;
+}
+
+static NSString *ENRMMentionText(NSString *mentionId, NSString *label)
+{
+  NSCharacterSet *spaces = [NSCharacterSet whitespaceAndNewlineCharacterSet];
+  NSString *name = label;
+  if (name.length == 0 || [[name stringByTrimmingCharactersInSet:spaces] length] == 0)
+    name = mentionId ?: @"";
+  if (name.length == 0 || [[name stringByTrimmingCharactersInSet:spaces] length] == 0)
+    name = @"";
+  return [@"@" stringByAppendingString:name];
+}
+
+static void ENRMAddKern(NSMutableAttributedString *output, NSUInteger index, CGFloat extra)
+{
+  if (index >= output.length)
+    return;
+  NSNumber *existing = [output attribute:NSKernAttributeName atIndex:index effectiveRange:NULL];
+  [output addAttribute:NSKernAttributeName
+                 value:@(existing.doubleValue + extra)
+                 range:NSMakeRange(index, 1)];
+}
+
+@implementation MentionRenderer
+
+- (void)renderNodeContent:(TiptapASTNode *)node
+                     into:(NSMutableAttributedString *)output
+                  context:(RenderContext *)context
+{
+  NSString *mentionId = node.attributes[@"id"] ?: @"";
+  NSString *label = node.attributes[@"label"] ?: @"";
+  NSString *text = ENRMMentionText(mentionId, label);
+
+  BlockStyle *block = [context getBlockStyle];
+  UIFont *font = block.cachedFont;
+  if (!font && block)
+    font = [context cachedFontForSize:block.fontSize family:block.fontFamily weight:block.fontWeight];
+
+  // Same defaults JS applies when textStyle.mention omits a color.
+  RCTUIColor *textColor = ENRMMentionColor(_config.mentionColor, 0x1D4ED8);
+  RCTUIColor *backgroundColor = ENRMMentionColor(_config.mentionBackgroundColor, 0xDBEAFE);
+
+  NSDictionary *baseAttrs = block ? [context getTextAttributes] : @{};
+  NSMutableDictionary *attrs = [baseAttrs mutableCopy] ?: [NSMutableDictionary dictionary];
+  attrs[NSFontAttributeName] = ENRMSemiboldFont(font);
+  attrs[NSForegroundColorAttributeName] = textColor;
+  attrs[MentionAttributeName] = @YES;
+  attrs[MentionIdAttributeName] = mentionId;
+  attrs[MentionLabelAttributeName] = label;
+  attrs[MentionBackgroundColorAttributeName] = backgroundColor;
+
+  NSUInteger start = output.length;
+  [output appendAttributedString:[[NSAttributedString alloc] initWithString:text attributes:attrs]];
+  if (text.length == 0)
+    return;
+
+  // The fill is wider than the glyphs. Kern reserves that room so it sits in
+  // the gap instead of painting over the words on either side.
+  if (start > 0) {
+    unichar previous = [output.string characterAtIndex:start - 1];
+    if (previous != '\n' && previous != 0x2028 && previous != 0x2029)
+      ENRMAddKern(output, start - 1, ENRMMentionPaddingX);
+  }
+  ENRMAddKern(output, start + text.length - 1, ENRMMentionPaddingX);
+}
+
+@end

package/ios/renderer/NodeRenderer.h

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

package/ios/renderer/ParagraphRenderer.h

@@ -0,0 +1,6 @@
+#import "BaseRenderer.h"
+#import "TiptapASTNode.h"
+#import "RenderContext.h"
+
+@interface ParagraphRenderer : BaseRenderer
+@end

package/ios/renderer/ParagraphRenderer.m

@@ -0,0 +1,85 @@
+#import "ParagraphRenderer.h"
+#import "FontUtils.h"
+#import "TiptapASTNode.h"
+#import "ParagraphStyleUtils.h"
+#import "RendererFactory.h"
+#import "StyleConfig.h"
+
+@implementation ParagraphRenderer
+
+- (id)takeContextSnapshot:(RenderContext *)context
+{
+  return [context snapshotScope];
+}
+
+- (void)renderNodeContent:(TiptapASTNode *)node
+                     into:(NSMutableAttributedString *)output
+                  context:(RenderContext *)context
+{
+  // Synthetic wrapper around tight list item inlines (see wrapListItemInlineRuns
+  // in MD4CParser) — render transparently, the list owns spacing and layout.
+  if ([node.attributes[@"tight"] boolValue]) {
+    [_rendererFactory renderChildrenOfNode:node into:output context:context];
+    return;
+  }
+
+  // Only set block style if a parent element (e.g. List, Blockquote) hasn't 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;
+  // Paragraphs directly inside a blockquote keep their block margins so spacing
+  // between blocks matches the top-level document (a heading defaults to
+  // marginTop 0, so the gap before it comes from the preceding paragraph's
+  // marginBottom). List content stays tight - lists own their item spacing.
+  BOOL shouldApplyMargin =
+      (context.currentBlockType == BlockTypeNone || context.currentBlockType == BlockTypeParagraph ||
+       context.currentBlockType == BlockTypeBlockquote);
+
+  // Detect if the paragraph is a wrapper for a standalone image to use image-specific spacing
+  BOOL isBlockImage = (node.children.count == 1 && ((TiptapASTNode *)node.children[0]).type == TiptapNodeTypeImage);
+  CGFloat marginTop = isBlockImage ? _config.imageMarginTop : _config.paragraphMarginTop;
+
+  NSUInteger contentStart = start;
+
+  // Handle leading margin for the first element in the document (Index 0 check)
+  if (shouldApplyMargin && start == 0) {
+    NSUInteger offset = applyBlockSpacingBefore(output, 0, marginTop);
+    contentStart += offset;
+    start += offset;
+  }
+
+  [_rendererFactory renderChildrenOfNode:node into:output context:context];
+
+  if (output.length <= start)
+    return;
+  NSRange range = NSMakeRange(start, output.length - start);
+
+  // Avoid standard line height on block images to prevent vertical alignment issues
+  if (!isBlockImage) {
+    applyLineHeight(output, range, _config.paragraphLineHeight);
+    if (!ENRMBlockTypeReappliesBaselineOffset(context.currentBlockType)) {
+      applyBaselineOffset(output, range);
+    }
+  }
+
+  applyTextAlignment(output, range, _config.paragraphTextAlign);
+
+  // Skip marginTop for the first block — already handled by applyBlockSpacingBefore above
+  if (shouldApplyMargin && contentStart != 1) {
+    NSUInteger inserted = applyParagraphSpacingBefore(output, range, marginTop);
+    start += inserted;
+  }
+
+  CGFloat marginBottom = 0;
+  if (shouldApplyMargin) {
+    marginBottom = isBlockImage ? _config.imageMarginBottom : _config.paragraphMarginBottom;
+  }
+
+  applyParagraphSpacingAfter(output, start, marginBottom);
+}
+
+@end