react-native-enriched-markdown 0.1.1 → 0.2.0

package/ios/parser/MarkdownParser.mm

@@ -1,13 +1,42 @@
 #import "MarkdownParser.h"
 #import "MarkdownASTNode.h"
 
-extern MarkdownASTNode *parseMarkdownWithCppParser(NSString *markdown);
+extern MarkdownASTNode *parseMarkdownWithCppParser(NSString *markdown, Md4cFlags *flags);
+
+@implementation Md4cFlags
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _underline = NO;
+  }
+  return self;
+}
+
++ (instancetype)defaultFlags
+{
+  return [[Md4cFlags alloc] init];
+}
+
+- (id)copyWithZone:(NSZone *)zone
+{
+  Md4cFlags *copy = [[Md4cFlags allocWithZone:zone] init];
+  copy.underline = self.underline;
+  return copy;
+}
+
+@end
 
 @implementation MarkdownParser
 
 - (MarkdownASTNode *)parseMarkdown:(NSString *)markdown
 {
-  return parseMarkdownWithCppParser(markdown);
+  return [self parseMarkdown:markdown flags:[Md4cFlags defaultFlags]];
+}
+
+- (MarkdownASTNode *)parseMarkdown:(NSString *)markdown flags:(Md4cFlags *)flags
+{
+  return parseMarkdownWithCppParser(markdown, flags);
 }
 
 @end

package/ios/parser/MarkdownParserBridge.mm

@@ -1,6 +1,7 @@
 #include "MD4CParser.hpp"
 #import "MarkdownASTNode.h"
 #include "MarkdownASTNode.hpp"
+#import "MarkdownParser.h"
 
 // Convert C++ AST node to Objective-C AST node
 static MarkdownASTNode *convertCppASTToObjC(std::shared_ptr<Markdown::MarkdownASTNode> cppNode)
@@ -36,6 +37,12 @@ static MarkdownASTNode *convertCppASTToObjC(std::shared_ptr<Markdown::MarkdownAS
     case Markdown::NodeType::Emphasis:
       objcType = MarkdownNodeTypeEmphasis;
       break;
+    case Markdown::NodeType::Strikethrough:
+      objcType = MarkdownNodeTypeStrikethrough;
+      break;
+    case Markdown::NodeType::Underline:
+      objcType = MarkdownNodeTypeUnderline;
+      break;
     case Markdown::NodeType::Code:
       objcType = MarkdownNodeTypeCode;
       break;
@@ -86,7 +93,7 @@ static MarkdownASTNode *convertCppASTToObjC(std::shared_ptr<Markdown::MarkdownAS
 }
 
 // Public function to parse markdown using C++ parser and convert to Objective-C AST
-MarkdownASTNode *parseMarkdownWithCppParser(NSString *markdown)
+MarkdownASTNode *parseMarkdownWithCppParser(NSString *markdown, Md4cFlags *flags)
 {
   if (markdown.length == 0) {
     return [[MarkdownASTNode alloc] initWithType:MarkdownNodeTypeDocument];
@@ -101,9 +108,12 @@ MarkdownASTNode *parseMarkdownWithCppParser(NSString *markdown)
 
   std::string cppMarkdown(utf8String);
 
-  // Parse using C++ parser
+  // Convert Objective-C flags to C++ flags
+  Markdown::Md4cFlags cppFlags;
+  cppFlags.underline = flags.underline;
+
   Markdown::MD4CParser parser;
-  auto cppAST = parser.parse(cppMarkdown);
+  auto cppAST = parser.parse(cppMarkdown, cppFlags);
 
   // Convert C++ AST to Objective-C AST
   return convertCppASTToObjC(cppAST);

package/ios/renderer/AttributedRenderer.h

@@ -6,4 +6,6 @@
 @interface AttributedRenderer : NSObject
 - (instancetype)initWithConfig:(id)config;
 - (NSMutableAttributedString *)renderRoot:(MarkdownASTNode *)root context:(RenderContext *)context;
+- (CGFloat)getLastElementMarginBottom;
+- (void)setAllowTrailingMargin:(BOOL)allow;
 @end

package/ios/renderer/AttributedRenderer.m

@@ -10,6 +10,8 @@
 @implementation AttributedRenderer {
   StyleConfig *_config;
   RendererFactory *_rendererFactory;
+  CGFloat _lastElementMarginBottom;
+  BOOL _allowTrailingMargin;
 }
 
 - (instancetype)initWithConfig:(StyleConfig *)config
@@ -18,6 +20,8 @@
   if (self) {
     _config = config;
     _rendererFactory = [[RendererFactory alloc] initWithConfig:config];
+    _lastElementMarginBottom = 0.0;
+    _allowTrailingMargin = NO;
   }
   return self;
 }
@@ -44,6 +48,8 @@
   }
 
   // 3. Remove trailing paragraph spacing from last block element
+  // Reset lastElementMarginBottom before processing
+  _lastElementMarginBottom = 0.0;
   [self removeTrailingSpacing:output];
 
   // 4. Cleanup global state to prevent side effects in subsequent renders.
@@ -58,40 +64,67 @@
   if (output.length == 0)
     return;
 
-  NSRange lastContent = [output.string rangeOfCharacterFromSet:[[NSCharacterSet newlineCharacterSet] invertedSet]
+  // Find the last non-newline character
+  NSRange lastContent = [output.string rangeOfCharacterFromSet:[NSCharacterSet.newlineCharacterSet invertedSet]
                                                        options:NSBackwardsSearch];
   if (lastContent.location == NSNotFound)
     return;
 
-  if (isLastElementCodeBlock(output)) {
-    // Code block: preserve bottom padding, only trim external margin
-    NSRange codeBlockRange;
-    [output attribute:CodeBlockAttributeName atIndex:lastContent.location effectiveRange:&codeBlockRange];
-    NSUInteger codeBlockEnd = NSMaxRange(codeBlockRange);
-    if (codeBlockEnd < output.length) {
-      [output deleteCharactersInRange:NSMakeRange(codeBlockEnd, output.length - codeBlockEnd)];
+  // 1. Capture the Margin Bottom (Scanning from last content to end)
+  _lastElementMarginBottom = 0.0;
+  for (NSUInteger i = lastContent.location; i < output.length;) {
+    NSRange attrRange;
+    NSParagraphStyle *style = [output attribute:NSParagraphStyleAttributeName atIndex:i effectiveRange:&attrRange];
+    if (style) {
+      _lastElementMarginBottom = MAX(_lastElementMarginBottom, style.paragraphSpacing);
     }
-  } else {
-    // Other elements: trim trailing newlines and zero all spacing
-    [output deleteCharactersInRange:NSMakeRange(NSMaxRange(lastContent), output.length - NSMaxRange(lastContent))];
+    i = NSMaxRange(attrRange);
+  }
+
+  // 2. Trim trailing characters
+  NSUInteger logicalEnd = NSMaxRange(lastContent);
+  if (isLastElementCodeBlock(output)) {
+    NSRange codeRange;
+    [output attribute:CodeBlockAttributeName atIndex:lastContent.location effectiveRange:&codeRange];
+    logicalEnd = NSMaxRange(codeRange);
+  }
+
+  if (logicalEnd < output.length) {
+    [output deleteCharactersInRange:NSMakeRange(logicalEnd, output.length - logicalEnd)];
+  }
 
-    NSRange range;
+  // 3. Zero out internal spacing for the last element (if not a code block)
+  if (!isLastElementCodeBlock(output)) {
+    NSRange styleRange;
     NSParagraphStyle *style = [output attribute:NSParagraphStyleAttributeName
                                         atIndex:lastContent.location
-                                 effectiveRange:&range];
+                                 effectiveRange:&styleRange];
+
     if (style) {
-      NSMutableParagraphStyle *fixed = [style mutableCopy];
-      fixed.paragraphSpacing = 0;
-      fixed.paragraphSpacingBefore = 0;
-      // For images: zero line spacing to eliminate baseline gaps
+      NSMutableParagraphStyle *mutableStyle = [style mutableCopy];
+      mutableStyle.paragraphSpacing = 0;
+      mutableStyle.paragraphSpacingBefore = 0;
+
       if (isLastElementImage(output)) {
-        fixed.lineSpacing = 0;
+        mutableStyle.lineSpacing = 0;
       }
-      [output addAttribute:NSParagraphStyleAttributeName value:fixed range:range];
+
+      NSRange safeRange = NSIntersectionRange(styleRange, NSMakeRange(0, output.length));
+      [output addAttribute:NSParagraphStyleAttributeName value:mutableStyle range:safeRange];
     }
   }
 }
 
+- (void)setAllowTrailingMargin:(BOOL)allow
+{
+  _allowTrailingMargin = allow;
+}
+
+- (CGFloat)getLastElementMarginBottom
+{
+  return _lastElementMarginBottom;
+}
+
 /**
  * Orchestrates the recursive traversal of the AST.
  * If a specialized renderer exists for a node type, it takes full control.

package/ios/renderer/BlockquoteRenderer.m

@@ -56,7 +56,12 @@ static NSString *const kNestedInfoRangeKey = @"range";
                            end:(NSUInteger)end
                   currentDepth:(NSInteger)currentDepth
 {
-  NSRange blockquoteRange = NSMakeRange(start, end - start);
+  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];
 
@@ -72,12 +77,8 @@ static NSString *const kNestedInfoRangeKey = @"range";
   // (applyBaseBlockquoteStyle overwrites nested indents with the parent's indent)
   [self reapplyNestedStyles:output nestedInfo:nestedInfo levelSpacing:levelSpacing];
 
-  // Apply bottom margin for top-level blockquotes only
   if (currentDepth == 0) {
-    CGFloat marginBottom = [_config blockquoteMarginBottom];
-    if (marginBottom > 0) {
-      applyBlockSpacing(output, marginBottom);
-    }
+    applyBlockSpacingAfter(output, [_config blockquoteMarginBottom]);
   }
 }
 

package/ios/renderer/CodeBlockRenderer.m

@@ -27,15 +27,17 @@
 
   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);
 
-  // 1. TOP PADDING: Inside the background
+  // Top Padding: Inserted as a spacer character inside the background area
   [output appendAttributedString:kNewlineAttributedString];
   NSMutableParagraphStyle *topSpacerStyle = [context spacerStyleWithHeight:padding spacing:0];
   [output addAttribute:NSParagraphStyleAttributeName value:topSpacerStyle range:NSMakeRange(blockStart, 1)];
 
-  // 2. RENDER CONTENT
   NSUInteger contentStart = output.length;
   @try {
     [_rendererFactory renderChildrenOfNode:node into:output context:context];
@@ -49,7 +51,6 @@
 
   NSRange contentRange = NSMakeRange(contentStart, contentEnd - contentStart);
 
-  // 3. CONTENT STYLING
   UIFont *codeFont = [_config codeBlockFont];
   UIColor *codeColor = [_config codeBlockColor];
   if (codeColor) {
@@ -63,26 +64,26 @@
     applyLineHeight(output, contentRange, lineHeight);
   }
 
-  // HORIZONTAL INDENTS
+  // Apply horizontal indents to the content
   NSMutableParagraphStyle *baseStyle = [getOrCreateParagraphStyle(output, contentStart) mutableCopy];
   baseStyle.firstLineHeadIndent = padding;
   baseStyle.headIndent = padding;
   baseStyle.tailIndent = -padding;
   [output addAttribute:NSParagraphStyleAttributeName value:baseStyle range:contentRange];
 
-  // 4. BOTTOM PADDING: Inside the background
+  // Bottom Padding: Inserted as a spacer character inside the background area
   NSUInteger bottomPaddingStart = output.length;
   [output appendAttributedString:kNewlineAttributedString];
   NSMutableParagraphStyle *bottomPaddingStyle = [context spacerStyleWithHeight:padding spacing:0];
   [output addAttribute:NSParagraphStyleAttributeName value:bottomPaddingStyle range:NSMakeRange(bottomPaddingStart, 1)];
 
-  // MARK BACKGROUND: Ends here to exclude the margin
+  // Define the range for background rendering (includes padding, excludes margins)
   NSRange backgroundRange = NSMakeRange(blockStart, output.length - blockStart);
   [output addAttribute:CodeBlockAttributeName value:@YES range:backgroundRange];
 
-  // 5. EXTERNAL MARGIN: Outside the background
+  // External Margin: Applied outside the background range
   if (marginBottom > 0) {
-    applyBlockSpacing(output, marginBottom);
+    applyBlockSpacingAfter(output, marginBottom);
   }
 }
 

package/ios/renderer/HeadingRenderer.m

@@ -10,11 +10,12 @@
 typedef struct {
   __unsafe_unretained UIFont *font;
   __unsafe_unretained UIColor *color;
+  CGFloat marginTop;
   CGFloat marginBottom;
   CGFloat lineHeight;
+  NSTextAlignment textAlign;
 } HeadingStyle;
 
-// Static heading type strings (index 0 unused, 1-6 for h1-h6)
 static NSString *const kHeadingTypes[] = {nil,          @"heading-1", @"heading-2", @"heading-3",
                                           @"heading-4", @"heading-5", @"heading-6"};
 
@@ -32,20 +33,25 @@ static NSString *const kHeadingTypes[] = {nil,          @"heading-1", @"heading-
   return self;
 }
 
-#pragma mark - Rendering
-
 - (void)renderNode:(MarkdownASTNode *)node into:(NSMutableAttributedString *)output context:(RenderContext *)context
 {
   NSInteger level = [node.attributes[@"level"] integerValue];
   if (level < 1 || level > 6)
     level = 1;
 
-  // Fetch style struct with pre-cached font from StyleConfig
   HeadingStyle style = [self styleForLevel:level];
-
   [context setBlockStyle:BlockTypeHeading font:style.font color:style.color headingLevel:level];
 
   NSUInteger start = output.length;
+  NSUInteger contentStart = start;
+
+  // Spacing at the very start of the document requires a spacer character (index 0 check)
+  if (start == 0) {
+    NSUInteger offset = applyBlockSpacingBefore(output, 0, style.marginTop);
+    contentStart += offset;
+    start += offset;
+  }
+
   @try {
     [_rendererFactory renderChildrenOfNode:node into:output context:context];
   } @finally {
@@ -56,43 +62,44 @@ static NSString *const kHeadingTypes[] = {nil,          @"heading-1", @"heading-
   if (range.length == 0)
     return;
 
-  // Mark as heading for HTML generation and Copy as Markdown
+  // Register heading for accessibility
+  NSString *headingText = [[output attributedSubstringFromRange:range] string];
+  [context registerHeadingRange:range level:level text:headingText];
+
+  // Metadata attribute used for post-processing (e.g., Export to Markdown/HTML)
   [output addAttribute:MarkdownTypeAttributeName value:kHeadingTypes[level] range:range];
 
   applyLineHeight(output, range, style.lineHeight);
-  applyParagraphSpacing(output, start, style.marginBottom);
+  applyTextAlignment(output, range, style.textAlign);
+
+  // Use paragraphSpacingBefore for internal elements; applyBlockSpacingBefore handles index 0
+  if (contentStart != 1) {
+    applyParagraphSpacingBefore(output, range, style.marginTop);
+  }
+  applyParagraphSpacingAfter(output, start, style.marginBottom);
 }
 
-#pragma mark - Optimized Style Provider
+#pragma mark - Style Mapping
 
 - (HeadingStyle)styleForLevel:(NSInteger)level
 {
   StyleConfig *c = _config;
-  HeadingStyle s;
-
   switch (level) {
     case 1:
-      s = (HeadingStyle){c.h1Font, c.h1Color, c.h1MarginBottom, c.h1LineHeight};
-      break;
+      return (HeadingStyle){c.h1Font, c.h1Color, c.h1MarginTop, c.h1MarginBottom, c.h1LineHeight, c.h1TextAlign};
     case 2:
-      s = (HeadingStyle){c.h2Font, c.h2Color, c.h2MarginBottom, c.h2LineHeight};
-      break;
+      return (HeadingStyle){c.h2Font, c.h2Color, c.h2MarginTop, c.h2MarginBottom, c.h2LineHeight, c.h2TextAlign};
     case 3:
-      s = (HeadingStyle){c.h3Font, c.h3Color, c.h3MarginBottom, c.h3LineHeight};
-      break;
+      return (HeadingStyle){c.h3Font, c.h3Color, c.h3MarginTop, c.h3MarginBottom, c.h3LineHeight, c.h3TextAlign};
     case 4:
-      s = (HeadingStyle){c.h4Font, c.h4Color, c.h4MarginBottom, c.h4LineHeight};
-      break;
+      return (HeadingStyle){c.h4Font, c.h4Color, c.h4MarginTop, c.h4MarginBottom, c.h4LineHeight, c.h4TextAlign};
     case 5:
-      s = (HeadingStyle){c.h5Font, c.h5Color, c.h5MarginBottom, c.h5LineHeight};
-      break;
+      return (HeadingStyle){c.h5Font, c.h5Color, c.h5MarginTop, c.h5MarginBottom, c.h5LineHeight, c.h5TextAlign};
     case 6:
-      s = (HeadingStyle){c.h6Font, c.h6Color, c.h6MarginBottom, c.h6LineHeight};
-      break;
+      return (HeadingStyle){c.h6Font, c.h6Color, c.h6MarginTop, c.h6MarginBottom, c.h6LineHeight, c.h6TextAlign};
     default:
       return [self styleForLevel:1];
   }
-  return s;
 }
 
-@end
+@end

package/ios/renderer/ImageRenderer.m

@@ -1,5 +1,5 @@
 #import "ImageRenderer.h"
-#import "ImageAttachment.h"
+#import "EnrichedMarkdownImageAttachment.h"
 #import "MarkdownASTNode.h"
 #import "RenderContext.h"
 #import "RendererFactory.h"
@@ -27,35 +27,56 @@ static const unichar kZeroWidthSpace = 0x200B;
 - (void)renderNode:(MarkdownASTNode *)node into:(NSMutableAttributedString *)output context:(RenderContext *)context
 {
   NSString *imageURL = node.attributes[@"url"];
-  // Safety check for URL presence and length
   if (!imageURL || imageURL.length == 0) {
     return;
   }
 
-  // Determine if this image is being placed inside an existing line of text
   BOOL isInline = [self isInlineImageInOutput:output];
+  EnrichedMarkdownImageAttachment *attachment = [[EnrichedMarkdownImageAttachment alloc] initWithImageURL:imageURL
+                                                                                                   config:_config
+                                                                                                 isInline:isInline];
 
-  // Create the attachment using the shared config
-  ImageAttachment *attachment = [[ImageAttachment alloc] initWithImageURL:imageURL config:_config isInline:isInline];
+  NSUInteger startIndex = output.length;
 
-  // Append the attachment character to the output
   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];
 }
 
 #pragma mark - Private Helpers
 
+- (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;
   }
 
-  // Check the last character to see if we are currently mid-paragraph
   unichar lastChar = [output.string characterAtIndex:output.length - 1];
-
-  // If the last character is a newline or a zero-width space (often used as block separators),
-  // we consider the next image to be a "block" image.
   return (lastChar != kLineBreak && lastChar != kZeroWidthSpace);
 }
 

package/ios/renderer/ListItemRenderer.m

@@ -28,63 +28,75 @@ NSString *const ListItemNumberAttribute = @"ListItemNumber";
   if (!context)
     return;
 
-  // 1. Maintain the ordered list counter
-  if (context.listType == ListTypeOrdered) {
-    context.listItemNumber++;
-  }
+  context.listItemNumber++;
+  const NSInteger currentPosition = context.listItemNumber;
+  const NSInteger currentDepth = context.listDepth; // 1-based (1 = top level)
+
+  const NSUInteger startLocation = output.length;
 
-  NSUInteger start = output.length;
+  // Render the actual content of the list item (text, bolding, etc.)
   [_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"]) {
+  // Ensure every list item ends with a newline to prevent paragraph merging
+  if (output.length > startLocation && ![output.string hasSuffix:@"\n"]) {
     [output appendAttributedString:kNewlineAttributedString];
   }
 
-  NSRange itemRange = NSMakeRange(start, output.length - start);
+  const NSRange itemRange = NSMakeRange(startLocation, output.length - startLocation);
   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
+  // Informs MarkdownAccessibilityElementBuilder about the specific boundaries of this list item
+  [context registerListItemRange:itemRange
+                        position:currentPosition
+                           depth:currentDepth
+                       isOrdered:(context.listType == ListTypeOrdered)];
+
+  // currentDepth - 1 handles the horizontal offset for nested lists
+  const NSInteger nestingLevel = currentDepth - 1;
+  const CGFloat baseMarkerWidth = (context.listType == ListTypeOrdered) ? [_config effectiveListMarginLeftForNumber]
+                                                                        : [_config effectiveListMarginLeftForBullet];
+
+  const CGFloat totalIndent =
+      baseMarkerWidth + [_config effectiveListGapWidth] + (nestingLevel * [_config listStyleMarginLeft]);
+
+  const CGFloat lineHeightConfig = [_config listStyleLineHeight];
+
+  // Boxing metadata for attributed string storage
+  NSDictionary *metadata = @{
+    ListDepthAttribute : @(nestingLevel),
+    ListTypeAttribute : @(context.listType),
+    ListItemNumberAttribute : @(currentPosition)
+  };
+
+  // We enumerate to ensure we don't overwrite styles of nested sub-lists
+  // that may have already been rendered inside this item.
   [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)
+                  usingBlock:^(id depthAttr, NSRange range, BOOL *stop) {
+                    // If a segment already has a Depth attribute higher than our current level,
+                    // it belongs to a nested list and we should skip it to preserve its styling.
+                    if (depthAttr && [depthAttr integerValue] > nestingLevel) {
                       return;
+                    }
 
                     NSMutableParagraphStyle *style = [[NSMutableParagraphStyle alloc] init];
-                    style.firstLineHeadIndent = indent;
-                    style.headIndent = indent;
+                    style.firstLineHeadIndent = totalIndent;
+                    style.headIndent = totalIndent;
 
-                    UIFont *font = [output attribute:NSFontAttributeName atIndex:range.location effectiveRange:NULL];
-                    if (configLineHeight > 0 && font) {
-                      style.lineHeightMultiple = configLineHeight / font.pointSize;
+                    // Apply line height if configured
+                    UIFont *currentFont = [output attribute:NSFontAttributeName
+                                                    atIndex:range.location
+                                             effectiveRange:NULL];
+                    if (lineHeightConfig > 0 && currentFont) {
+                      style.lineHeightMultiple = lineHeightConfig / currentFont.pointSize;
                     }
 
-                    // Final attribute application
-                    [output addAttributes:@{
-                      NSParagraphStyleAttributeName : style,
-                      ListDepthAttribute : depthVal,
-                      ListTypeAttribute : typeVal,
-                      ListItemNumberAttribute : numVal
-                    }
-                                    range:range];
+                    NSMutableDictionary *attributesToApply = [metadata mutableCopy];
+                    attributesToApply[NSParagraphStyleAttributeName] = style;
+
+                    [output addAttributes:attributesToApply range:range];
                   }];
 }
 

package/ios/renderer/ListRenderer.m

@@ -27,40 +27,43 @@
   if (!context)
     return;
 
-  // Snapshot parent state
-  NSInteger prevDepth = context.listDepth;
-  ListType prevType = context.listType;
-  NSInteger prevNum = context.listItemNumber;
+  const NSInteger prevDepth = context.listDepth;
+  const ListType prevType = context.listType;
+  const NSInteger prevNum = context.listItemNumber;
 
-  // Configure depth and type
-  context.listDepth = prevDepth + 1;
-  context.listType = _isOrdered ? ListTypeOrdered : ListTypeUnordered;
-  context.listItemNumber = 0;
+  const NSUInteger startLocation = output.length;
+  NSUInteger contentStart = startLocation;
 
-  // Ensure isolation for nested lists
-  if (prevDepth > 0 && output.length > 0 && ![output.string hasSuffix:@"\n"]) {
+  if (prevDepth == 0) {
+    // Apply top margin for root-level list
+    contentStart += 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;
+  context.listItemNumber = 0; // Reset counter for this specific list level
+
   [context setBlockStyle:_isOrdered ? BlockTypeOrderedList : BlockTypeUnorderedList
-                    font:[_config listStyleFont]
-                   color:[_config listStyleColor]
+                    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)
+
+    if (prevDepth == 0) {
       [context clearBlockStyle];
-  }
 
-  // Final spacing for root container
-  if (prevDepth == 0 && [_config listStyleMarginBottom] > 0) {
-    applyBlockSpacing(output, [_config listStyleMarginBottom]);
+      // Apply bottom margin for root-level list
+      applyBlockSpacingAfter(output, _config.listStyleMarginBottom);
+    }
   }
 }