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

package/ios/internals/ShadowMeasurementUtils.h

@@ -0,0 +1,135 @@
+#pragma once
+
+#include "MeasurementCache.h"
+#import <Foundation/Foundation.h>
+#import <React/RCTUtils.h>
+#include <algorithm>
+#include <cmath>
+#include <react/renderer/core/LayoutConstraints.h>
+#include <react/utils/ManagedObjectWrapper.h>
+
+namespace facebook::react {
+
+// measureContent runs on Yoga's background layout thread and uses
+// dispatch_sync to main for UIKit reads. Safe because RN never
+// synchronously joins the layout queue from main. A synchronous
+// layout flush from main would deadlock.
+
+static inline CGFloat ENRMFontScaleForMeasurement(bool allowFontScaling)
+{
+  if (!allowFontScaling) {
+    return 1.0;
+  }
+
+  __block CGFloat fontScale = 1.0;
+  void (^readFontScale)(void) = ^{ fontScale = RCTFontSizeMultiplier(); };
+
+  if ([NSThread isMainThread]) {
+    readFontScale();
+  } else {
+    dispatch_sync(dispatch_get_main_queue(), readFontScale);
+  }
+
+  return fontScale;
+}
+
+static inline Size ENRMClampMeasuredSize(CGSize size, const LayoutConstraints &layoutConstraints)
+{
+  Float clampedWidth = std::max((Float)size.width, layoutConstraints.minimumSize.width);
+  clampedWidth = std::min(clampedWidth, layoutConstraints.maximumSize.width);
+  Float clampedHeight = std::max((Float)size.height, layoutConstraints.minimumSize.height);
+  if (std::isfinite(layoutConstraints.maximumSize.height)) {
+    clampedHeight = std::min(clampedHeight, layoutConstraints.maximumSize.height);
+  }
+  return {clampedWidth, clampedHeight};
+}
+
+template <typename PropsT>
+static inline bool ENRMPropsNeedExactStreamingMeasurement(const PropsT &oldProps, const PropsT &newProps)
+{
+  return oldProps.streamingAnimation != newProps.streamingAnimation ||
+         oldProps.allowFontScaling != newProps.allowFontScaling ||
+         oldProps.maxFontSizeMultiplier != newProps.maxFontSizeMultiplier ||
+         oldProps.allowTrailingMargin != newProps.allowTrailingMargin ||
+         oldProps.md4cFlags.underline != newProps.md4cFlags.underline ||
+         oldProps.md4cFlags.superscript != newProps.md4cFlags.superscript ||
+         oldProps.md4cFlags.subscript != newProps.md4cFlags.subscript ||
+         oldProps.md4cFlags.latexMath != newProps.md4cFlags.latexMath ||
+         computeStyleFingerprint(oldProps.markdownStyle) != computeStyleFingerprint(newProps.markdownStyle);
+}
+
+template <typename PropsT, typename ViewT>
+static inline Size ENRMMeasureMarkdownContent(const PropsT &typedProps, const std::shared_ptr<void> &componentViewRef,
+                                              int receivedCounter, int &lastExactMeasurementCounter,
+                                              MarkdownFlavor flavor, const LayoutConstraints &layoutConstraints,
+                                              ViewT * (^createMockView)(CGFloat width))
+{
+  CGFloat maxWidth = layoutConstraints.maximumSize.width;
+
+  RCTInternalGenericWeakWrapper *weakWrapper = (RCTInternalGenericWeakWrapper *)unwrapManagedObject(componentViewRef);
+  ViewT *view = weakWrapper ? (ViewT *)weakWrapper.object : nil;
+
+  if (typedProps.streamingAnimation && view && receivedCounter <= lastExactMeasurementCounter) {
+    __block CGSize currentSize = CGSizeZero;
+    void (^readCurrentSize)(void) = ^{
+      if (view.bounds.size.width > 0 && view.bounds.size.height > 0) {
+        currentSize = view.bounds.size;
+      }
+    };
+
+    if ([NSThread isMainThread]) {
+      readCurrentSize();
+    } else {
+      dispatch_sync(dispatch_get_main_queue(), readCurrentSize);
+    }
+
+    if (currentSize.height > 0) {
+      return ENRMClampMeasuredSize(currentSize, layoutConstraints);
+    }
+  }
+
+  const bool shouldUseMeasurementCache = !typedProps.streamingAnimation;
+  CGFloat fontScale = shouldUseMeasurementCache ? ENRMFontScaleForMeasurement(typedProps.allowFontScaling) : 1.0;
+
+  if (shouldUseMeasurementCache && !typedProps.markdown.empty()) {
+    auto cacheKey = buildMeasurementCacheKey(typedProps, maxWidth, fontScale, flavor);
+    CachedSize cached;
+    if (MeasurementCache::shared().get(cacheKey, cached)) {
+      return ENRMClampMeasuredSize(CGSizeMake(cached.width, cached.height), layoutConstraints);
+    }
+  }
+
+  __block CGSize size;
+  NSString *currentMarkdown = typedProps.markdown.empty() ? nil : @(typedProps.markdown.c_str());
+  size_t styleFingerprint =
+      computeStyleFingerprint(typedProps.markdownStyle) ^ std::hash<bool>{}(typedProps.allowTrailingMargin);
+
+  void (^measureBlock)(void) = ^{
+    if (view && (typedProps.streamingAnimation || ([view hasRenderedMarkdown:currentMarkdown] &&
+                                                   [view hasRenderedWithStyleFingerprint:styleFingerprint]))) {
+      size = [view measureSize:maxWidth];
+    } else {
+      ViewT *mockView = createMockView(maxWidth);
+      size = [mockView measureSize:maxWidth];
+    }
+  };
+
+  if ([NSThread isMainThread]) {
+    measureBlock();
+  } else {
+    dispatch_sync(dispatch_get_main_queue(), measureBlock);
+  }
+
+  if (shouldUseMeasurementCache && !typedProps.markdown.empty()) {
+    auto cacheKey = buildMeasurementCacheKey(typedProps, maxWidth, fontScale, flavor);
+    MeasurementCache::shared().set(cacheKey, {size.width, size.height});
+  }
+
+  if (typedProps.streamingAnimation) {
+    lastExactMeasurementCounter = receivedCounter;
+  }
+
+  return ENRMClampMeasuredSize(size, layoutConstraints);
+}
+
+} // namespace facebook::react

package/ios/math/ENRMRaTeXBridge.swift

@@ -0,0 +1,58 @@
+import Foundation
+import CoreGraphics
+import CoreText
+import RaTeX
+
+#if canImport(UIKit)
+import UIKit
+#elseif canImport(AppKit)
+import AppKit
+private typealias UIColor = NSColor
+#endif
+
+@objc(ENRMRaTeXRenderResult)
+public final class ENRMRaTeXRenderResult: NSObject {
+  private let renderer: RaTeXRenderer
+
+  @objc public let width: CGFloat
+  @objc public let ascent: CGFloat
+  @objc public let descent: CGFloat
+  @objc public var totalHeight: CGFloat { ascent + descent }
+
+  init(renderer: RaTeXRenderer) {
+    self.renderer = renderer
+    self.width = renderer.width
+    self.ascent = renderer.height
+    self.descent = renderer.depth
+    super.init()
+  }
+
+  @objc public func draw(in context: CGContext) {
+    renderer.draw(in: context)
+  }
+}
+
+@objc(ENRMRaTeXBridge)
+public final class ENRMRaTeXBridge: NSObject {
+
+  @objc public static func ensureFontsLoaded() {
+    RaTeXFontLoader.ensureLoaded()
+  }
+
+  @objc public static func parse(
+    _ latex: String,
+    displayMode: Bool,
+    fontSize: CGFloat,
+    color: UIColor
+  ) -> ENRMRaTeXRenderResult? {
+    RaTeXFontLoader.ensureLoaded()
+    do {
+      let displayList = try RaTeXEngine.shared.parse(latex, displayMode: displayMode, color: color)
+      let renderer = RaTeXRenderer(displayList: displayList, fontSize: fontSize)
+      return ENRMRaTeXRenderResult(renderer: renderer)
+    } catch {
+      NSLog("[RaTeX] Failed to parse LaTeX: %@", error.localizedDescription)
+      return nil
+    }
+  }
+}

package/ios/parser/ENRMMarkdownParser.h

@@ -0,0 +1,21 @@
+#import "MarkdownASTNode.h"
+#import <Foundation/Foundation.h>
+
+@interface ENRMMd4cFlags : NSObject <NSCopying>
+
+@property (nonatomic, assign) BOOL underline;
+@property (nonatomic, assign) BOOL latexMath;
+@property (nonatomic, assign) BOOL superscript;
+@property (nonatomic, assign) BOOL subscript;
+@property (nonatomic, assign) BOOL highlight;
+
++ (instancetype)defaultFlags;
+
+@end
+
+@interface ENRMMarkdownParser : NSObject
+
+- (MarkdownASTNode *)parseMarkdown:(NSString *)markdown;
+- (MarkdownASTNode *)parseMarkdown:(NSString *)markdown flags:(ENRMMd4cFlags *)flags;
+
+@end

package/ios/parser/ENRMMarkdownParser.mm

@@ -0,0 +1,50 @@
+#import "ENRMMarkdownParser.h"
+#import "MarkdownASTNode.h"
+
+extern MarkdownASTNode *parseMarkdownWithCppParser(NSString *markdown, ENRMMd4cFlags *flags);
+
+@implementation ENRMMd4cFlags
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _underline = NO;
+    _latexMath = YES;
+    _superscript = NO;
+    _subscript = NO;
+    _highlight = NO;
+  }
+  return self;
+}
+
++ (instancetype)defaultFlags
+{
+  return [[ENRMMd4cFlags alloc] init];
+}
+
+- (id)copyWithZone:(NSZone *)zone
+{
+  ENRMMd4cFlags *copy = [[ENRMMd4cFlags allocWithZone:zone] init];
+  copy.underline = self.underline;
+  copy.latexMath = self.latexMath;
+  copy.superscript = self.superscript;
+  copy.subscript = self.subscript;
+  copy.highlight = self.highlight;
+  return copy;
+}
+
+@end
+
+@implementation ENRMMarkdownParser
+
+- (MarkdownASTNode *)parseMarkdown:(NSString *)markdown
+{
+  return [self parseMarkdown:markdown flags:[ENRMMd4cFlags defaultFlags]];
+}
+
+- (MarkdownASTNode *)parseMarkdown:(NSString *)markdown flags:(ENRMMd4cFlags *)flags
+{
+  return parseMarkdownWithCppParser(markdown, flags);
+}
+
+@end

package/ios/parser/MarkdownASTNode.h

@@ -0,0 +1,47 @@
+#import <Foundation/Foundation.h>
+
+typedef NS_ENUM(NSInteger, MarkdownNodeType) {
+  MarkdownNodeTypeDocument,
+  MarkdownNodeTypeParagraph,
+  MarkdownNodeTypeText,
+  MarkdownNodeTypeLink,
+  MarkdownNodeTypeHeading,
+  MarkdownNodeTypeLineBreak,
+  MarkdownNodeTypeStrong,
+  MarkdownNodeTypeEmphasis,
+  MarkdownNodeTypeStrikethrough,
+  MarkdownNodeTypeUnderline,
+  MarkdownNodeTypeCode,
+  MarkdownNodeTypeImage,
+  MarkdownNodeTypeBlockquote,
+  MarkdownNodeTypeUnorderedList,
+  MarkdownNodeTypeOrderedList,
+  MarkdownNodeTypeListItem,
+  MarkdownNodeTypeCodeBlock,
+  MarkdownNodeTypeThematicBreak,
+  MarkdownNodeTypeTable,
+  MarkdownNodeTypeTableHead,
+  MarkdownNodeTypeTableBody,
+  MarkdownNodeTypeTableRow,
+  MarkdownNodeTypeTableHeaderCell,
+  MarkdownNodeTypeTableCell,
+  MarkdownNodeTypeLatexMathInline,
+  MarkdownNodeTypeLatexMathDisplay,
+  MarkdownNodeTypeSpoiler,
+  MarkdownNodeTypeSuperscript,
+  MarkdownNodeTypeSubscript,
+  MarkdownNodeTypeHighlight
+};
+
+@interface MarkdownASTNode : NSObject
+
+@property (nonatomic, assign) MarkdownNodeType type;
+@property (nonatomic, strong) NSString *content;
+@property (nonatomic, strong) NSMutableDictionary *attributes;
+@property (nonatomic, strong) NSMutableArray<MarkdownASTNode *> *children;
+
+- (instancetype)initWithType:(MarkdownNodeType)type;
+- (void)addChild:(MarkdownASTNode *)child;
+- (void)setAttribute:(NSString *)key value:(NSString *)value;
+
+@end

package/ios/parser/MarkdownASTNode.m

@@ -0,0 +1,32 @@
+#import "MarkdownASTNode.h"
+
+@implementation MarkdownASTNode
+
+- (instancetype)initWithType:(MarkdownNodeType)type
+{
+  if (self = [super init]) {
+    _type = type;
+    _content = nil;
+    _attributes = [[NSMutableDictionary alloc] init];
+    _children = [[NSMutableArray alloc] init];
+  }
+  return self;
+}
+
+- (void)addChild:(MarkdownASTNode *)child
+{
+  [_children addObject:child];
+}
+
+- (void)setAttribute:(NSString *)key value:(NSString *)value
+{
+  _attributes[key] = value;
+}
+
+- (NSString *)description
+{
+  return [NSString stringWithFormat:@"MarkdownASTNode(type=%ld, content=%@, children=%lu)", (long)_type, _content,
+                                    (unsigned long)_children.count];
+}
+
+@end

package/ios/parser/MarkdownParserBridge.mm

@@ -0,0 +1,161 @@
+#import "ENRMMarkdownParser.h"
+#include "MD4CParser.hpp"
+#import "MarkdownASTNode.h"
+#include "MarkdownASTNode.hpp"
+#import <React/RCTLog.h>
+
+// Convert C++ AST node to Objective-C AST node
+static MarkdownASTNode *convertCppASTToObjC(std::shared_ptr<Markdown::MarkdownASTNode> cppNode)
+{
+  if (!cppNode) {
+    return [[MarkdownASTNode alloc] initWithType:MarkdownNodeTypeDocument];
+  }
+
+  // Convert C++ NodeType enum to Objective-C MarkdownNodeType
+  MarkdownNodeType objcType;
+  switch (cppNode->type) {
+    case Markdown::NodeType::Document:
+      objcType = MarkdownNodeTypeDocument;
+      break;
+    case Markdown::NodeType::Paragraph:
+      objcType = MarkdownNodeTypeParagraph;
+      break;
+    case Markdown::NodeType::Text:
+      objcType = MarkdownNodeTypeText;
+      break;
+    case Markdown::NodeType::Link:
+      objcType = MarkdownNodeTypeLink;
+      break;
+    case Markdown::NodeType::Heading:
+      objcType = MarkdownNodeTypeHeading;
+      break;
+    case Markdown::NodeType::LineBreak:
+      objcType = MarkdownNodeTypeLineBreak;
+      break;
+    case Markdown::NodeType::Strong:
+      objcType = MarkdownNodeTypeStrong;
+      break;
+    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;
+    case Markdown::NodeType::Image:
+      objcType = MarkdownNodeTypeImage;
+      break;
+    case Markdown::NodeType::Blockquote:
+      objcType = MarkdownNodeTypeBlockquote;
+      break;
+    case Markdown::NodeType::UnorderedList:
+      objcType = MarkdownNodeTypeUnorderedList;
+      break;
+    case Markdown::NodeType::OrderedList:
+      objcType = MarkdownNodeTypeOrderedList;
+      break;
+    case Markdown::NodeType::ListItem:
+      objcType = MarkdownNodeTypeListItem;
+      break;
+    case Markdown::NodeType::CodeBlock:
+      objcType = MarkdownNodeTypeCodeBlock;
+      break;
+    case Markdown::NodeType::ThematicBreak:
+      objcType = MarkdownNodeTypeThematicBreak;
+      break;
+    case Markdown::NodeType::Table:
+      objcType = MarkdownNodeTypeTable;
+      break;
+    case Markdown::NodeType::TableHead:
+      objcType = MarkdownNodeTypeTableHead;
+      break;
+    case Markdown::NodeType::TableBody:
+      objcType = MarkdownNodeTypeTableBody;
+      break;
+    case Markdown::NodeType::TableRow:
+      objcType = MarkdownNodeTypeTableRow;
+      break;
+    case Markdown::NodeType::TableHeaderCell:
+      objcType = MarkdownNodeTypeTableHeaderCell;
+      break;
+    case Markdown::NodeType::TableCell:
+      objcType = MarkdownNodeTypeTableCell;
+      break;
+    case Markdown::NodeType::LatexMathInline:
+      objcType = MarkdownNodeTypeLatexMathInline;
+      break;
+    case Markdown::NodeType::LatexMathDisplay:
+      objcType = MarkdownNodeTypeLatexMathDisplay;
+      break;
+    case Markdown::NodeType::Spoiler:
+      objcType = MarkdownNodeTypeSpoiler;
+      break;
+    case Markdown::NodeType::Superscript:
+      objcType = MarkdownNodeTypeSuperscript;
+      break;
+    case Markdown::NodeType::Subscript:
+      objcType = MarkdownNodeTypeSubscript;
+      break;
+    case Markdown::NodeType::Highlight:
+      objcType = MarkdownNodeTypeHighlight;
+      break;
+  }
+
+  MarkdownASTNode *objcNode = [[MarkdownASTNode alloc] initWithType:objcType];
+
+  // Convert content
+  if (!cppNode->content.empty()) {
+    objcNode.content = [NSString stringWithUTF8String:cppNode->content.c_str()];
+  }
+
+  // Convert attributes
+  for (const auto &[key, value] : cppNode->attributes) {
+    NSString *objcKey = [NSString stringWithUTF8String:key.c_str()];
+    NSString *objcValue = [NSString stringWithUTF8String:value.c_str()];
+    [objcNode setAttribute:objcKey value:objcValue];
+  }
+
+  // Convert children recursively
+  for (const auto &child : cppNode->children) {
+    MarkdownASTNode *objcChild = convertCppASTToObjC(child);
+    [objcNode addChild:objcChild];
+  }
+
+  return objcNode;
+}
+
+// Public function to parse markdown using C++ parser and convert to Objective-C AST
+MarkdownASTNode *parseMarkdownWithCppParser(NSString *markdown, ENRMMd4cFlags *flags)
+{
+  if (markdown.length == 0) {
+    return [[MarkdownASTNode alloc] initWithType:MarkdownNodeTypeDocument];
+  }
+
+  // Convert NSString to std::string
+  const char *utf8String = [markdown UTF8String];
+  if (!utf8String) {
+    RCTLogError(@"MarkdownParserBridge: Failed to convert markdown to UTF-8");
+    return [[MarkdownASTNode alloc] initWithType:MarkdownNodeTypeDocument];
+  }
+
+  std::string cppMarkdown(utf8String);
+
+  // Convert Objective-C flags to C++ flags
+  Markdown::Md4cFlags cppFlags;
+  cppFlags.underline = flags.underline;
+  cppFlags.latexMath = flags.latexMath;
+  cppFlags.superscript = flags.superscript;
+  cppFlags.subscript = flags.subscript;
+  cppFlags.highlight = flags.highlight;
+
+  Markdown::MD4CParser parser;
+  auto cppAST = parser.parse(cppMarkdown, cppFlags);
+
+  // Convert C++ AST to Objective-C AST
+  return convertCppASTToObjC(cppAST);
+}

package/ios/renderer/AttributedRenderer.h

@@ -0,0 +1,11 @@
+#import <Foundation/Foundation.h>
+
+@class MarkdownASTNode;
+@class RenderContext;
+
+@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

@@ -0,0 +1,153 @@
+#import "AttributedRenderer.h"
+#import "CodeBlockBackground.h"
+#import "LastElementUtils.h"
+#import "MarkdownASTNode.h"
+#import "NodeRenderer.h"
+#import "RenderContext.h"
+#import "RendererFactory.h"
+#import "StyleConfig.h"
+
+@implementation AttributedRenderer {
+  StyleConfig *_config;
+  RendererFactory *_rendererFactory;
+  CGFloat _lastElementMarginBottom;
+  BOOL _allowTrailingMargin;
+}
+
+- (instancetype)initWithConfig:(StyleConfig *)config
+{
+  self = [super init];
+  if (self) {
+    _config = config;
+    _rendererFactory = [[RendererFactory alloc] initWithConfig:config];
+    _lastElementMarginBottom = 0.0;
+    _allowTrailingMargin = NO;
+  }
+  return self;
+}
+
+/**
+ * Entry point for rendering a Markdown AST.
+ * Sets the baseline global style and initiates the recursive traversal.
+ */
+- (NSMutableAttributedString *)renderRoot:(MarkdownASTNode *)root context:(RenderContext *)context
+{
+  if (!root)
+    return [[NSMutableAttributedString alloc] init];
+
+  // 1. Establish the global baseline style.
+  // This ensures that leaf nodes (like Text) have valid attributes if they appear at the root.
+  [context setBlockStyle:BlockTypeParagraph font:_config.paragraphFont color:_config.paragraphColor headingLevel:0];
+
+  NSMutableAttributedString *output = [[NSMutableAttributedString alloc] init];
+
+  // 2. Iterate through root children.
+  // We skip the 'Root' node itself as it is a container, not a renderable element.
+  for (MarkdownASTNode *node in root.children) {
+    [self renderNodeRecursive:node into:output context:context];
+  }
+
+  // 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.
+  [context clearBlockStyle];
+
+  return output;
+}
+
+/// Removes trailing margin spacing while preserving code block padding
+- (void)removeTrailingSpacing:(NSMutableAttributedString *)output
+{
+  if (output.length == 0)
+    return;
+
+  // Find the last non-newline character
+  NSRange lastContent = [output.string rangeOfCharacterFromSet:[NSCharacterSet.newlineCharacterSet invertedSet]
+                                                       options:NSBackwardsSearch];
+  if (lastContent.location == NSNotFound)
+    return;
+
+  // 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);
+    }
+    i = NSMaxRange(attrRange);
+  }
+
+  // 2. Trim trailing characters
+  NSUInteger logicalEnd = NSMaxRange(lastContent);
+  BOOL isCodeBlock = isLastElementCodeBlock(output);
+  if (isCodeBlock) {
+    NSRange codeRange;
+    [output attribute:CodeBlockAttributeName atIndex:lastContent.location effectiveRange:&codeRange];
+    logicalEnd = NSMaxRange(codeRange);
+  }
+
+  if (logicalEnd < output.length) {
+    [output deleteCharactersInRange:NSMakeRange(logicalEnd, output.length - logicalEnd)];
+  }
+
+  // 3. Zero out internal spacing for the last element (if not a code block)
+  if (!isCodeBlock) {
+    NSRange styleRange;
+    NSParagraphStyle *style = [output attribute:NSParagraphStyleAttributeName
+                                        atIndex:lastContent.location
+                                 effectiveRange:&styleRange];
+
+    if (style) {
+      NSMutableParagraphStyle *mutableStyle = [style mutableCopy];
+      mutableStyle.paragraphSpacing = 0;
+      mutableStyle.paragraphSpacingBefore = 0;
+
+      if (isLastElementImage(output)) {
+        mutableStyle.lineSpacing = 0;
+      }
+
+      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.
+ */
+- (void)renderNodeRecursive:(MarkdownASTNode *)node
+                       into:(NSMutableAttributedString *)out
+                    context:(RenderContext *)context
+{
+  if (!node)
+    return;
+
+  id<NodeRenderer> renderer = [_rendererFactory rendererForNodeType:node.type];
+
+  if (renderer) {
+    // Specialized renderers (e.g., Strong, Link, Heading) handle their own sub-trees.
+    [renderer renderNode:node into:out context:context];
+  } else {
+    // Fallback: Default to deep-first traversal for unhandled container nodes.
+    for (MarkdownASTNode *child in node.children) {
+      [self renderNodeRecursive:child into:out context:context];
+    }
+  }
+}
+
+@end

package/ios/renderer/BaseRenderer.h

@@ -0,0 +1,18 @@
+#pragma once
+#import "NodeRenderer.h"
+
+@class RendererFactory;
+@class StyleConfig;
+
+/// Shared base for all node renderers — provides `_rendererFactory` and `_config`
+/// as protected ivars and the common designated initializer.
+/// Concrete subclasses must implement `renderNode:into:context:`.
+@interface BaseRenderer : NSObject {
+@protected
+  __weak RendererFactory *_rendererFactory;
+  StyleConfig *_config;
+}
+
+- (instancetype)initWithRendererFactory:(id)rendererFactory config:(id)config;
+
+@end