react-native-enriched-markdown 0.1.0 → 0.2.0

package/ios/renderer/HeadingRenderer.m

@@ -0,0 +1,105 @@
+#import "HeadingRenderer.h"
+#import "FontUtils.h"
+#import "ParagraphStyleUtils.h"
+#import "RenderContext.h"
+#import "RendererFactory.h"
+#import "RuntimeKeys.h"
+#import "StyleConfig.h"
+
+// Lightweight struct to hold style data without object overhead
+typedef struct {
+  __unsafe_unretained UIFont *font;
+  __unsafe_unretained UIColor *color;
+  CGFloat marginTop;
+  CGFloat marginBottom;
+  CGFloat lineHeight;
+  NSTextAlignment textAlign;
+} HeadingStyle;
+
+static NSString *const kHeadingTypes[] = {nil,          @"heading-1", @"heading-2", @"heading-3",
+                                          @"heading-4", @"heading-5", @"heading-6"};
+
+@implementation HeadingRenderer {
+  RendererFactory *_rendererFactory;
+  StyleConfig *_config;
+}
+
+- (instancetype)initWithRendererFactory:(id)rendererFactory config:(id)config
+{
+  if (self = [super init]) {
+    _rendererFactory = rendererFactory;
+    _config = (StyleConfig *)config;
+  }
+  return self;
+}
+
+- (void)renderNode:(MarkdownASTNode *)node into:(NSMutableAttributedString *)output context:(RenderContext *)context
+{
+  NSInteger level = [node.attributes[@"level"] integerValue];
+  if (level < 1 || level > 6)
+    level = 1;
+
+  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 {
+    [context clearBlockStyle];
+  }
+
+  NSRange range = NSMakeRange(start, output.length - start);
+  if (range.length == 0)
+    return;
+
+  // 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);
+  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 - Style Mapping
+
+- (HeadingStyle)styleForLevel:(NSInteger)level
+{
+  StyleConfig *c = _config;
+  switch (level) {
+    case 1:
+      return (HeadingStyle){c.h1Font, c.h1Color, c.h1MarginTop, c.h1MarginBottom, c.h1LineHeight, c.h1TextAlign};
+    case 2:
+      return (HeadingStyle){c.h2Font, c.h2Color, c.h2MarginTop, c.h2MarginBottom, c.h2LineHeight, c.h2TextAlign};
+    case 3:
+      return (HeadingStyle){c.h3Font, c.h3Color, c.h3MarginTop, c.h3MarginBottom, c.h3LineHeight, c.h3TextAlign};
+    case 4:
+      return (HeadingStyle){c.h4Font, c.h4Color, c.h4MarginTop, c.h4MarginBottom, c.h4LineHeight, c.h4TextAlign};
+    case 5:
+      return (HeadingStyle){c.h5Font, c.h5Color, c.h5MarginTop, c.h5MarginBottom, c.h5LineHeight, c.h5TextAlign};
+    case 6:
+      return (HeadingStyle){c.h6Font, c.h6Color, c.h6MarginTop, c.h6MarginBottom, c.h6LineHeight, c.h6TextAlign};
+    default:
+      return [self styleForLevel:1];
+  }
+}
+
+@end

package/ios/renderer/ImageRenderer.h

@@ -0,0 +1,12 @@
+#pragma once
+#import "NodeRenderer.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface ImageRenderer : NSObject <NodeRenderer>
+
+- (instancetype)initWithRendererFactory:(id)rendererFactory config:(id)config;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/renderer/ImageRenderer.m

@@ -0,0 +1,83 @@
+#import "ImageRenderer.h"
+#import "EnrichedMarkdownImageAttachment.h"
+#import "MarkdownASTNode.h"
+#import "RenderContext.h"
+#import "RendererFactory.h"
+#import "StyleConfig.h"
+
+static const unichar kLineBreak = '\n';
+static const unichar kZeroWidthSpace = 0x200B;
+
+@implementation ImageRenderer {
+  RendererFactory *_rendererFactory;
+  StyleConfig *_config;
+}
+
+- (instancetype)initWithRendererFactory:(id)rendererFactory config:(id)config
+{
+  if (self = [super init]) {
+    _rendererFactory = rendererFactory;
+    _config = (StyleConfig *)config;
+  }
+  return self;
+}
+
+#pragma mark - Rendering
+
+- (void)renderNode:(MarkdownASTNode *)node into:(NSMutableAttributedString *)output context:(RenderContext *)context
+{
+  NSString *imageURL = node.attributes[@"url"];
+  if (!imageURL || imageURL.length == 0) {
+    return;
+  }
+
+  BOOL isInline = [self isInlineImageInOutput:output];
+  EnrichedMarkdownImageAttachment *attachment = [[EnrichedMarkdownImageAttachment alloc] initWithImageURL:imageURL
+                                                                                                   config:_config
+                                                                                                 isInline:isInline];
+
+  NSUInteger startIndex = output.length;
+
+  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;
+  }
+
+  unichar lastChar = [output.string characterAtIndex:output.length - 1];
+  return (lastChar != kLineBreak && lastChar != kZeroWidthSpace);
+}
+
+@end

package/ios/renderer/LinkRenderer.h

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

package/ios/renderer/LinkRenderer.m

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

package/ios/renderer/ListItemRenderer.h

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

package/ios/renderer/ListItemRenderer.m

@@ -0,0 +1,103 @@
+#import "ListItemRenderer.h"
+#import "MarkdownASTNode.h"
+#import "ParagraphStyleUtils.h"
+#import "RenderContext.h"
+#import "RendererFactory.h"
+#import "StyleConfig.h"
+
+NSString *const ListDepthAttribute = @"ListDepth";
+NSString *const ListTypeAttribute = @"ListType";
+NSString *const ListItemNumberAttribute = @"ListItemNumber";
+
+@implementation ListItemRenderer {
+  RendererFactory *_rendererFactory;
+  StyleConfig *_config;
+}
+
+- (instancetype)initWithRendererFactory:(RendererFactory *)factory config:(StyleConfig *)config
+{
+  if (self = [super init]) {
+    _rendererFactory = factory;
+    _config = config;
+  }
+  return self;
+}
+
+- (void)renderNode:(MarkdownASTNode *)node into:(NSMutableAttributedString *)output context:(RenderContext *)context
+{
+  if (!context)
+    return;
+
+  context.listItemNumber++;
+  const NSInteger currentPosition = context.listItemNumber;
+  const NSInteger currentDepth = context.listDepth; // 1-based (1 = top level)
+
+  const NSUInteger startLocation = output.length;
+
+  // Render the actual content of the list item (text, bolding, etc.)
+  [_rendererFactory renderChildrenOfNode:node into:output context:context];
+
+  // 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 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 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 = totalIndent;
+                    style.headIndent = totalIndent;
+
+                    // Apply line height if configured
+                    UIFont *currentFont = [output attribute:NSFontAttributeName
+                                                    atIndex:range.location
+                                             effectiveRange:NULL];
+                    if (lineHeightConfig > 0 && currentFont) {
+                      style.lineHeightMultiple = lineHeightConfig / currentFont.pointSize;
+                    }
+
+                    NSMutableDictionary *attributesToApply = [metadata mutableCopy];
+                    attributesToApply[NSParagraphStyleAttributeName] = style;
+
+                    [output addAttributes:attributesToApply range:range];
+                  }];
+}
+
+@end

package/ios/renderer/ListRenderer.h

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

package/ios/renderer/ListRenderer.m

@@ -0,0 +1,70 @@
+#import "ListRenderer.h"
+#import "BlockquoteRenderer.h"
+#import "MarkdownASTNode.h"
+#import "ParagraphStyleUtils.h"
+#import "RenderContext.h"
+#import "RendererFactory.h"
+#import "StyleConfig.h"
+
+@implementation ListRenderer {
+  RendererFactory *_rendererFactory;
+  StyleConfig *_config;
+  BOOL _isOrdered;
+}
+
+- (instancetype)initWithRendererFactory:(RendererFactory *)factory config:(StyleConfig *)config isOrdered:(BOOL)ordered
+{
+  if (self = [super init]) {
+    _rendererFactory = factory;
+    _config = config;
+    _isOrdered = ordered;
+  }
+  return self;
+}
+
+- (void)renderNode:(MarkdownASTNode *)node into:(NSMutableAttributedString *)output context:(RenderContext *)context
+{
+  if (!context)
+    return;
+
+  const NSInteger prevDepth = context.listDepth;
+  const ListType prevType = context.listType;
+  const NSInteger prevNum = context.listItemNumber;
+
+  const NSUInteger startLocation = output.length;
+  NSUInteger contentStart = startLocation;
+
+  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
+            headingLevel:0];
+
+  @try {
+    [_rendererFactory renderChildrenOfNode:node into:output context:context];
+  } @finally {
+    context.listDepth = prevDepth;
+    context.listType = prevType;
+    context.listItemNumber = prevNum;
+
+    if (prevDepth == 0) {
+      [context clearBlockStyle];
+
+      // Apply bottom margin for root-level list
+      applyBlockSpacingAfter(output, _config.listStyleMarginBottom);
+    }
+  }
+}
+
+@end

package/ios/renderer/NodeRenderer.h

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

package/ios/renderer/ParagraphRenderer.h

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

package/ios/renderer/ParagraphRenderer.m

@@ -0,0 +1,80 @@
+#import "ParagraphRenderer.h"
+#import "FontUtils.h"
+#import "MarkdownASTNode.h"
+#import "ParagraphStyleUtils.h"
+#import "RendererFactory.h"
+#import "StyleConfig.h"
+
+@implementation ParagraphRenderer {
+  RendererFactory *_rendererFactory;
+  StyleConfig *_config;
+}
+
+- (instancetype)initWithRendererFactory:(id)rendererFactory config:(id)config
+{
+  self = [super init];
+  if (self) {
+    _rendererFactory = rendererFactory;
+    _config = (StyleConfig *)config;
+  }
+  return self;
+}
+
+- (void)renderNode:(MarkdownASTNode *)node into:(NSMutableAttributedString *)output context:(RenderContext *)context
+{
+  // 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;
+  BOOL shouldApplyMargin =
+      (context.currentBlockType == BlockTypeNone || context.currentBlockType == BlockTypeParagraph);
+
+  // Detect if the paragraph is a wrapper for a standalone image to use image-specific spacing
+  BOOL isBlockImage = (node.children.count == 1 && ((MarkdownASTNode *)node.children[0]).type == MarkdownNodeTypeImage);
+  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;
+  }
+
+  @try {
+    [_rendererFactory renderChildrenOfNode:node into:output context:context];
+  } @finally {
+    if (isTopLevel) {
+      [context clearBlockStyle];
+    }
+  }
+
+  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);
+  }
+
+  applyTextAlignment(output, range, _config.paragraphTextAlign);
+
+  // Apply marginTop for non-index-0 elements using paragraphSpacingBefore
+  if (shouldApplyMargin && contentStart != 1) {
+    applyParagraphSpacingBefore(output, range, marginTop);
+  }
+
+  CGFloat marginBottom = 0;
+  if (shouldApplyMargin) {
+    marginBottom = isBlockImage ? _config.imageMarginBottom : _config.paragraphMarginBottom;
+  }
+  applyParagraphSpacingAfter(output, start, marginBottom);
+}
+
+@end

package/ios/renderer/RenderContext.h

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