react-native-enriched-markdown 0.1.0 → 0.1.1

package/ios/renderer/BlockquoteRenderer.m

@@ -0,0 +1,159 @@
+#import "BlockquoteRenderer.h"
+#import "BlockquoteBorder.h"
+#import "FontUtils.h"
+#import "MarkdownASTNode.h"
+#import "ParagraphStyleUtils.h"
+#import "RendererFactory.h"
+#import "StyleConfig.h"
+
+static NSString *const kNestedInfoDepthKey = @"depth";
+static NSString *const kNestedInfoRangeKey = @"range";
+
+@implementation BlockquoteRenderer {
+  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 currentDepth = context.blockquoteDepth;
+  context.blockquoteDepth = currentDepth + 1;
+
+  [context setBlockStyle:BlockTypeBlockquote
+                    font:[_config blockquoteFont]
+                   color:[_config blockquoteColor]
+            headingLevel:0];
+
+  NSUInteger start = output.length;
+  @try {
+    [_rendererFactory renderChildrenOfNode:node into:output context:context];
+  } @finally {
+    [context clearBlockStyle];
+    context.blockquoteDepth = currentDepth;
+  }
+
+  NSUInteger end = output.length;
+  if (end <= start) {
+    return;
+  }
+
+  [self applyStylingAndSpacing:output start:start end:end currentDepth:currentDepth];
+}
+
+#pragma mark - Styling and Spacing
+
+- (void)applyStylingAndSpacing:(NSMutableAttributedString *)output
+                         start:(NSUInteger)start
+                           end:(NSUInteger)end
+                  currentDepth:(NSInteger)currentDepth
+{
+  NSRange blockquoteRange = NSMakeRange(start, end - start);
+  CGFloat levelSpacing = [_config blockquoteBorderWidth] + [_config blockquoteGapWidth];
+  NSArray<NSDictionary *> *nestedInfo = [self collectNestedBlockquotes:output range:blockquoteRange depth:currentDepth];
+
+  // Apply base styling (indentation, depth, background, line height)
+  [self applyBaseBlockquoteStyle:output
+                           range:blockquoteRange
+                           depth:currentDepth
+                    levelSpacing:levelSpacing
+                 backgroundColor:[_config blockquoteBackgroundColor]
+                      lineHeight:[_config blockquoteLineHeight]];
+
+  // Re-apply nested blockquote styles to restore their correct indentation
+  // (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);
+    }
+  }
+}
+
+#pragma mark - Nested Blockquote Handling
+
+- (NSArray<NSDictionary *> *)collectNestedBlockquotes:(NSMutableAttributedString *)output
+                                                range:(NSRange)blockquoteRange
+                                                depth:(NSInteger)currentDepth
+{
+  NSMutableArray<NSDictionary *> *nestedInfo = [NSMutableArray array];
+
+  [output
+      enumerateAttribute:BlockquoteDepthAttributeName
+                 inRange:blockquoteRange
+                 options:NSAttributedStringEnumerationLongestEffectiveRangeNotRequired
+              usingBlock:^(id value, NSRange range, BOOL *stop) {
+                NSInteger depth = [value integerValue];
+                if (value && depth > currentDepth) {
+                  [nestedInfo
+                      addObject:@{kNestedInfoDepthKey : value, kNestedInfoRangeKey : [NSValue valueWithRange:range]}];
+                }
+              }];
+
+  return nestedInfo;
+}
+
+- (void)applyBaseBlockquoteStyle:(NSMutableAttributedString *)output
+                           range:(NSRange)blockquoteRange
+                           depth:(NSInteger)currentDepth
+                    levelSpacing:(CGFloat)levelSpacing
+                 backgroundColor:(UIColor *)backgroundColor
+                      lineHeight:(CGFloat)lineHeight
+{
+  NSMutableParagraphStyle *paragraphStyle = getOrCreateParagraphStyle(output, blockquoteRange.location);
+  CGFloat totalIndent = [self calculateIndentForDepth:currentDepth levelSpacing:levelSpacing];
+  paragraphStyle.firstLineHeadIndent = totalIndent;
+  paragraphStyle.headIndent = totalIndent;
+
+  NSMutableDictionary *newAttributes =
+      [NSMutableDictionary dictionaryWithObjectsAndKeys:paragraphStyle, NSParagraphStyleAttributeName, @(currentDepth),
+                                                        BlockquoteDepthAttributeName, nil];
+  if (backgroundColor) {
+    newAttributes[BlockquoteBackgroundColorAttributeName] = backgroundColor;
+  }
+  [output addAttributes:newAttributes range:blockquoteRange];
+
+  applyLineHeight(output, blockquoteRange, lineHeight);
+}
+
+- (void)reapplyNestedStyles:(NSMutableAttributedString *)output
+                 nestedInfo:(NSArray<NSDictionary *> *)nestedInfo
+               levelSpacing:(CGFloat)levelSpacing
+{
+  // Re-apply indentation to nested blockquotes since applyBaseBlockquoteStyle
+  // overwrote them with the parent's indentation
+  for (NSDictionary *info in nestedInfo) {
+    NSRange nestedRange = [info[kNestedInfoRangeKey] rangeValue];
+    NSInteger nestedDepth = [info[kNestedInfoDepthKey] integerValue];
+    NSMutableParagraphStyle *style = getOrCreateParagraphStyle(output, nestedRange.location);
+
+    CGFloat indent = [self calculateIndentForDepth:nestedDepth levelSpacing:levelSpacing];
+    style.firstLineHeadIndent = indent;
+    style.headIndent = indent;
+    style.tailIndent = 0;
+
+    [output
+        addAttributes:@{NSParagraphStyleAttributeName : style, BlockquoteDepthAttributeName : info[kNestedInfoDepthKey]}
+                range:nestedRange];
+  }
+}
+
+#pragma mark - Helper Methods
+
+- (CGFloat)calculateIndentForDepth:(NSInteger)depth levelSpacing:(CGFloat)levelSpacing
+{
+  return (depth + 1) * levelSpacing;
+}
+
+@end

package/ios/renderer/CodeBlockRenderer.h

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

package/ios/renderer/CodeBlockRenderer.m

@@ -0,0 +1,89 @@
+#import "CodeBlockRenderer.h"
+#import "CodeBlockBackground.h"
+#import "LastElementUtils.h"
+#import "MarkdownASTNode.h"
+#import "ParagraphStyleUtils.h"
+#import "RenderContext.h"
+#import "RendererFactory.h"
+#import "StyleConfig.h"
+
+@implementation CodeBlockRenderer {
+  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
+{
+  [context setBlockStyle:BlockTypeCodeBlock font:[_config codeBlockFont] color:[_config codeBlockColor] headingLevel:0];
+
+  CGFloat padding = [_config codeBlockPadding];
+  CGFloat lineHeight = [_config codeBlockLineHeight];
+  CGFloat marginBottom = [_config codeBlockMarginBottom];
+  NSUInteger blockStart = output.length;
+
+  // 1. TOP PADDING: Inside the background
+  [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];
+  } @finally {
+    [context clearBlockStyle];
+  }
+
+  NSUInteger contentEnd = output.length;
+  if (contentEnd <= contentStart)
+    return;
+
+  NSRange contentRange = NSMakeRange(contentStart, contentEnd - contentStart);
+
+  // 3. CONTENT STYLING
+  UIFont *codeFont = [_config codeBlockFont];
+  UIColor *codeColor = [_config codeBlockColor];
+  if (codeColor) {
+    [output addAttributes:@{NSFontAttributeName : codeFont, NSForegroundColorAttributeName : codeColor}
+                    range:contentRange];
+  } else {
+    [output addAttribute:NSFontAttributeName value:codeFont range:contentRange];
+  }
+
+  if (lineHeight > 0) {
+    applyLineHeight(output, contentRange, lineHeight);
+  }
+
+  // HORIZONTAL INDENTS
+  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
+  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
+  NSRange backgroundRange = NSMakeRange(blockStart, output.length - blockStart);
+  [output addAttribute:CodeBlockAttributeName value:@YES range:backgroundRange];
+
+  // 5. EXTERNAL MARGIN: Outside the background
+  if (marginBottom > 0) {
+    applyBlockSpacing(output, marginBottom);
+  }
+}
+
+@end

package/ios/renderer/CodeRenderer.h

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

package/ios/renderer/CodeRenderer.m

@@ -0,0 +1,60 @@
+#import "CodeRenderer.h"
+#import "CodeBackground.h"
+#import "FontUtils.h"
+#import "MarkdownASTNode.h"
+#import "RenderContext.h"
+#import "RendererFactory.h"
+#import "StyleConfig.h"
+
+@implementation CodeRenderer {
+  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
+{
+
+  BlockStyle *blockStyle = [context getBlockStyle];
+
+  UIColor *codeColor = _config.codeColor;
+
+  UIFont *blockFont = cachedFontFromBlockStyle(blockStyle, context);
+
+  UIFontDescriptorSymbolicTraits traits = blockFont.fontDescriptor.symbolicTraits;
+  UIFontWeight weight = (traits & UIFontDescriptorTraitBold) ? UIFontWeightBold : UIFontWeightRegular;
+
+  UIFont *monospacedFont = [UIFont monospacedSystemFontOfSize:blockStyle.fontSize weight:weight];
+
+  NSUInteger start = output.length;
+
+  [_rendererFactory renderChildrenOfNode:node into:output context:context];
+
+  NSRange range = [RenderContext rangeForRenderedContent:output start:start];
+  if (range.length > 0) {
+    NSDictionary *existingAttributes = [output attributesAtIndex:start effectiveRange:NULL];
+    NSMutableDictionary *codeAttributes = [existingAttributes ?: @{} mutableCopy];
+
+    codeAttributes[NSFontAttributeName] = monospacedFont;
+    if (codeColor) {
+      codeAttributes[NSForegroundColorAttributeName] = codeColor;
+    }
+    codeAttributes[CodeAttributeName] = @YES;
+
+    // Store block line height directly for CodeBackground to use
+    codeAttributes[@"BlockLineHeight"] = @(blockFont.lineHeight);
+
+    [output setAttributes:codeAttributes range:range];
+  }
+}
+
+@end

package/ios/renderer/EmphasisRenderer.h

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

package/ios/renderer/EmphasisRenderer.m

@@ -0,0 +1,96 @@
+#import "EmphasisRenderer.h"
+#import "FontUtils.h"
+#import "MarkdownASTNode.h"
+#import "RenderContext.h"
+#import "RendererFactory.h"
+#import "StyleConfig.h"
+
+@implementation EmphasisRenderer {
+  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;
+  [_rendererFactory renderChildrenOfNode:node into:output context:context];
+
+  NSRange range = NSMakeRange(start, output.length - start);
+  if (range.length == 0)
+    return;
+
+  BlockStyle *blockStyle = [context getBlockStyle];
+  UIColor *configEmphasisColor = [_config emphasisColor];
+
+  // Cache the Strong color calculation to efficiently detect nested Strong nodes
+  UIColor *strongColorToPreserve = [_config strongColor] ? [RenderContext calculateStrongColor:[_config strongColor]
+                                                                                    blockColor:blockStyle.color]
+                                                         : nil;
+
+  [output
+      enumerateAttributesInRange:range
+                         options:NSAttributedStringEnumerationLongestEffectiveRangeNotRequired
+                      usingBlock:^(NSDictionary<NSAttributedStringKey, id> *attrs, NSRange subrange, BOOL *stop) {
+                        // 1. Font Optimization: Only apply italic trait if not already present
+                        UIFont *currentFont =
+                            attrs[NSFontAttributeName] ?: cachedFontFromBlockStyle(blockStyle, context);
+                        if (currentFont && !(currentFont.fontDescriptor.symbolicTraits & UIFontDescriptorTraitItalic)) {
+                          UIFont *italicFont = [self ensureFontIsItalic:currentFont];
+                          if (italicFont) {
+                            [output addAttribute:NSFontAttributeName value:italicFont range:subrange];
+                          }
+                        }
+
+                        // 2. Color Optimization: Handle nesting and avoid redundant updates
+                        if (configEmphasisColor) {
+                          UIColor *currentColor = attrs[NSForegroundColorAttributeName];
+                          BOOL isLink = attrs[NSLinkAttributeName] != nil;
+
+                          // Verify if the current color belongs to a Strong parent
+                          BOOL isStrongColor = strongColorToPreserve && [currentColor isEqual:strongColorToPreserve];
+
+                          // Preserving colors for higher-priority elements (links, strong nodes, etc.)
+                          if (!isLink && !isStrongColor && ![RenderContext shouldPreserveColors:attrs]) {
+                            // Only modify the string if the color is actually different
+                            if (![currentColor isEqual:configEmphasisColor]) {
+                              [output addAttribute:NSForegroundColorAttributeName
+                                             value:configEmphasisColor
+                                             range:subrange];
+                            }
+                          }
+                        }
+                      }];
+}
+
+#pragma mark - Helper Methods
+
+- (UIFont *)ensureFontIsItalic:(UIFont *)font
+{
+  if (!font)
+    return nil;
+
+  UIFontDescriptorSymbolicTraits traits = font.fontDescriptor.symbolicTraits;
+  if (traits & UIFontDescriptorTraitItalic)
+    return font;
+
+  // Combine italic with existing traits (e.g., preserving Bold if present)
+  UIFontDescriptorSymbolicTraits combinedTraits = traits | UIFontDescriptorTraitItalic;
+  UIFontDescriptor *italicDescriptor = [font.fontDescriptor fontDescriptorWithSymbolicTraits:combinedTraits];
+
+  // Size 0 in fontWithDescriptor:size: maintains the current point size
+  return [UIFont fontWithDescriptor:italicDescriptor size:0] ?: font;
+}
+
+@end

package/ios/renderer/HeadingRenderer.h

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

package/ios/renderer/HeadingRenderer.m

@@ -0,0 +1,98 @@
+#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 marginBottom;
+  CGFloat lineHeight;
+} 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"};
+
+@implementation HeadingRenderer {
+  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
+{
+  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;
+  @try {
+    [_rendererFactory renderChildrenOfNode:node into:output context:context];
+  } @finally {
+    [context clearBlockStyle];
+  }
+
+  NSRange range = NSMakeRange(start, output.length - start);
+  if (range.length == 0)
+    return;
+
+  // Mark as heading for HTML generation and Copy as Markdown
+  [output addAttribute:MarkdownTypeAttributeName value:kHeadingTypes[level] range:range];
+
+  applyLineHeight(output, range, style.lineHeight);
+  applyParagraphSpacing(output, start, style.marginBottom);
+}
+
+#pragma mark - Optimized Style Provider
+
+- (HeadingStyle)styleForLevel:(NSInteger)level
+{
+  StyleConfig *c = _config;
+  HeadingStyle s;
+
+  switch (level) {
+    case 1:
+      s = (HeadingStyle){c.h1Font, c.h1Color, c.h1MarginBottom, c.h1LineHeight};
+      break;
+    case 2:
+      s = (HeadingStyle){c.h2Font, c.h2Color, c.h2MarginBottom, c.h2LineHeight};
+      break;
+    case 3:
+      s = (HeadingStyle){c.h3Font, c.h3Color, c.h3MarginBottom, c.h3LineHeight};
+      break;
+    case 4:
+      s = (HeadingStyle){c.h4Font, c.h4Color, c.h4MarginBottom, c.h4LineHeight};
+      break;
+    case 5:
+      s = (HeadingStyle){c.h5Font, c.h5Color, c.h5MarginBottom, c.h5LineHeight};
+      break;
+    case 6:
+      s = (HeadingStyle){c.h6Font, c.h6Color, c.h6MarginBottom, c.h6LineHeight};
+      break;
+    default:
+      return [self styleForLevel:1];
+  }
+  return s;
+}
+
+@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,62 @@
+#import "ImageRenderer.h"
+#import "ImageAttachment.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"];
+  // 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];
+
+  // Create the attachment using the shared config
+  ImageAttachment *attachment = [[ImageAttachment alloc] initWithImageURL:imageURL config:_config isInline:isInline];
+
+  // Append the attachment character to the output
+  NSAttributedString *imageString = [NSAttributedString attributedStringWithAttachment:attachment];
+  [output appendAttributedString:imageString];
+}
+
+#pragma mark - Private Helpers
+
+- (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);
+}
+
+@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