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

package/ios/parser/TiptapParserBridge.mm

@@ -0,0 +1,179 @@
+#import "ENRMTiptapParser.h"
+#include "TiptapParser.hpp"
+#import "TiptapASTNode.h"
+#include "TiptapASTNode.hpp"
+#import <React/RCTLog.h>
+
+// Convert C++ AST node to Objective-C AST node
+static TiptapASTNode *convertCppASTToObjC(std::shared_ptr<Tiptap::TiptapASTNode> cppNode)
+{
+  if (!cppNode) {
+    return [[TiptapASTNode alloc] initWithType:TiptapNodeTypeDocument];
+  }
+
+  // Convert C++ NodeType enum to Objective-C TiptapNodeType
+  TiptapNodeType objcType;
+  switch (cppNode->type) {
+    case Tiptap::NodeType::Document:
+      objcType = TiptapNodeTypeDocument;
+      break;
+    case Tiptap::NodeType::Paragraph:
+      objcType = TiptapNodeTypeParagraph;
+      break;
+    case Tiptap::NodeType::Text:
+      objcType = TiptapNodeTypeText;
+      break;
+    case Tiptap::NodeType::Link:
+      objcType = TiptapNodeTypeLink;
+      break;
+    case Tiptap::NodeType::Heading:
+      objcType = TiptapNodeTypeHeading;
+      break;
+    case Tiptap::NodeType::LineBreak:
+      objcType = TiptapNodeTypeLineBreak;
+      break;
+    case Tiptap::NodeType::Strong:
+      objcType = TiptapNodeTypeStrong;
+      break;
+    case Tiptap::NodeType::Emphasis:
+      objcType = TiptapNodeTypeEmphasis;
+      break;
+    case Tiptap::NodeType::Strikethrough:
+      objcType = TiptapNodeTypeStrikethrough;
+      break;
+    case Tiptap::NodeType::Underline:
+      objcType = TiptapNodeTypeUnderline;
+      break;
+    case Tiptap::NodeType::Code:
+      objcType = TiptapNodeTypeCode;
+      break;
+    case Tiptap::NodeType::Image:
+      objcType = TiptapNodeTypeImage;
+      break;
+    case Tiptap::NodeType::Blockquote:
+      objcType = TiptapNodeTypeBlockquote;
+      break;
+    case Tiptap::NodeType::UnorderedList:
+      objcType = TiptapNodeTypeUnorderedList;
+      break;
+    case Tiptap::NodeType::OrderedList:
+      objcType = TiptapNodeTypeOrderedList;
+      break;
+    case Tiptap::NodeType::ListItem:
+      objcType = TiptapNodeTypeListItem;
+      break;
+    case Tiptap::NodeType::CodeBlock:
+      objcType = TiptapNodeTypeCodeBlock;
+      break;
+    case Tiptap::NodeType::ThematicBreak:
+      objcType = TiptapNodeTypeThematicBreak;
+      break;
+    case Tiptap::NodeType::Table:
+      objcType = TiptapNodeTypeTable;
+      break;
+    case Tiptap::NodeType::TableHead:
+      objcType = TiptapNodeTypeTableHead;
+      break;
+    case Tiptap::NodeType::TableBody:
+      objcType = TiptapNodeTypeTableBody;
+      break;
+    case Tiptap::NodeType::TableRow:
+      objcType = TiptapNodeTypeTableRow;
+      break;
+    case Tiptap::NodeType::TableHeaderCell:
+      objcType = TiptapNodeTypeTableHeaderCell;
+      break;
+    case Tiptap::NodeType::TableCell:
+      objcType = TiptapNodeTypeTableCell;
+      break;
+    case Tiptap::NodeType::LatexMathInline:
+      objcType = TiptapNodeTypeLatexMathInline;
+      break;
+    case Tiptap::NodeType::LatexMathDisplay:
+      objcType = TiptapNodeTypeLatexMathDisplay;
+      break;
+    case Tiptap::NodeType::Spoiler:
+      objcType = TiptapNodeTypeSpoiler;
+      break;
+    case Tiptap::NodeType::Superscript:
+      objcType = TiptapNodeTypeSuperscript;
+      break;
+    case Tiptap::NodeType::Subscript:
+      objcType = TiptapNodeTypeSubscript;
+      break;
+    case Tiptap::NodeType::Highlight:
+      objcType = TiptapNodeTypeHighlight;
+      break;
+    case Tiptap::NodeType::SoftBreak:
+      objcType = TiptapNodeTypeSoftBreak;
+      break;
+    case Tiptap::NodeType::BlankLine:
+      objcType = TiptapNodeTypeBlankLine;
+      break;
+    case Tiptap::NodeType::Admonition:
+      objcType = TiptapNodeTypeAdmonition;
+      break;
+    case Tiptap::NodeType::Video:
+      objcType = TiptapNodeTypeVideo;
+      break;
+    case Tiptap::NodeType::Factoid:
+      objcType = TiptapNodeTypeFactoid;
+      break;
+    case Tiptap::NodeType::Mention:
+      objcType = TiptapNodeTypeMention;
+      break;
+  }
+
+  TiptapASTNode *objcNode = [[TiptapASTNode 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) {
+    TiptapASTNode *objcChild = convertCppASTToObjC(child);
+    [objcNode addChild:objcChild];
+  }
+
+  return objcNode;
+}
+
+TiptapASTNode *parseTiptapWithCppParser(NSString *document, ENRMMd4cFlags *flags, BOOL isGFM,
+                                            ENRMLinkRegexConfig *textRegex, ENRMLinkRegexConfig *codeRegex);
+
+TiptapASTNode *parseTiptapWithCppParser(NSString *document, ENRMMd4cFlags *flags, BOOL isGFM)
+{
+  return parseTiptapWithCppParser(document, flags, isGFM, nil, nil);
+}
+
+// Flags and link-regex arguments are ignored. The string is a Tiptap document.
+TiptapASTNode *parseTiptapWithCppParser(NSString *document, ENRMMd4cFlags *flags, BOOL isGFM,
+                                            ENRMLinkRegexConfig *textRegex, ENRMLinkRegexConfig *codeRegex)
+{
+  (void)flags;
+  (void)isGFM;
+  (void)textRegex;
+  (void)codeRegex;
+
+  if (document.length == 0) {
+    return [[TiptapASTNode alloc] initWithType:TiptapNodeTypeDocument];
+  }
+
+  const char *utf8String = [document UTF8String];
+  if (!utf8String) {
+    RCTLogError(@"TiptapParserBridge: Failed to convert document to UTF-8");
+    return [[TiptapASTNode alloc] initWithType:TiptapNodeTypeDocument];
+  }
+
+  auto cppAST = Tiptap::parseTiptapDocument(std::string(utf8String));
+  return convertCppASTToObjC(cppAST);
+}

package/ios/renderer/AttributedRenderer.h

@@ -0,0 +1,23 @@
+#import <Foundation/Foundation.h>
+
+@class ENRMBlockquoteTextRenderer;
+@class TiptapASTNode;
+@class RenderContext;
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface AttributedRenderer : NSObject
+- (instancetype)initWithConfig:(id)config;
+// Renders a flat list of sibling nodes into an attributed string: sets the baseline block style,
+// walks each node, and trims the trailing block margin. Pass a non-nil block to render the nodes as
+// a blockquote's own content (blockquote baseline + the quote's line height applied over the run);
+// it draws no box - the ENRMBlockquoteContainerView draws the border/background/padding. See
+// ENRMBlockquoteTextRenderer.
+- (NSMutableAttributedString *)renderNodes:(NSArray<TiptapASTNode *> *)nodes
+                                   context:(RenderContext *)context
+                                     block:(nullable ENRMBlockquoteTextRenderer *)block;
+- (CGFloat)getLastElementMarginBottom;
+- (void)setAllowTrailingMargin:(BOOL)allow;
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/renderer/AttributedRenderer.m

@@ -0,0 +1,229 @@
+#import "AttributedRenderer.h"
+#import "BlockquoteBorder.h"
+#import "CodeBlockBackground.h"
+#import "ENRMBlockquoteTextRenderer.h"
+#import "ENRMLinkPillText.h"
+#import "LastElementUtils.h"
+#import "TiptapASTNode.h"
+#import "NodeRenderer.h"
+#import "ParagraphStyleUtils.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 flat list of sibling nodes (e.g. a document's or a block segment's
+ * children). Sets the baseline block style, runs the recursive traversal, and trims the trailing
+ * block margin. An optional [block] decorates the pass - it enters a block baseline before the nodes
+ * render and post-processes the finished string - letting a caller render content as e.g. blockquote
+ * text without this class knowing anything block-specific. See ENRMBlockquoteTextRenderer.
+ */
+- (NSMutableAttributedString *)renderNodes:(NSArray<TiptapASTNode *> *)nodes
+                                   context:(RenderContext *)context
+                                     block:(ENRMBlockquoteTextRenderer *)block
+{
+  // 1. Establish the baseline block style. This ensures leaf nodes (like Text) have valid
+  // attributes if they appear at the top level. A decorator overrides the default paragraph
+  // baseline (e.g. the blockquote baseline so paragraphs render tight and pick up the quote's
+  // font/color).
+  if (block) {
+    [block pushOnContext:context];
+  } else {
+    [context setBlockStyle:BlockTypeParagraph font:_config.paragraphFont color:_config.paragraphColor headingLevel:0];
+  }
+
+  NSMutableAttributedString *output = [[NSMutableAttributedString alloc] init];
+
+  // 2. Iterate through the sibling nodes.
+  for (TiptapASTNode *node in nodes) {
+    [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. Let the decorator post-process the finished string (e.g. stamp the quote's line height).
+  [block postProcess:output];
+  ENRMLinkPillsAdoptPlaceholderFonts(output);
+
+  // 5. Cleanup global state to prevent side effects in subsequent renders.
+  [context clearBlockStyle];
+
+  return output;
+}
+
+/**
+ * Trims trailing newlines after the last rendered block, with special handling for code blocks.
+ *
+ * For non-code-block tail elements: deletes all trailing newlines after the last non-newline
+ * character and zeroes the last element's paragraph spacing so it doesn't render a margin past
+ * the content.
+ *
+ * For code blocks (`isLastBlockACodeBlock` == YES): keeps the bottom padding spacer in place
+ * AND preserves a single trailing newline immediately after it (typically the
+ * codeBlockMarginBottom spacer that CodeBlockRenderer already appended; if none exists, one is
+ * synthesized here). That extra newline matters because of an iOS layout quirk:
+ *
+ *   - iOS treats the trailing `\n` of the storage as a paragraph terminator and reports the
+ *     line fragment for the paragraph after it via `extraLineFragmentRect`.
+ *   - `boundingRectForGlyphRange:` excludes that extra line, and the graphics-context clip
+ *     passed to `drawBackgroundForGlyphRange:` is tiled to the laid-out content area (rounded
+ *     up to 128pt boundaries) which also excludes it.
+ *   - If the bottom padding spacer were the trailing `\n`, its 16/19pt line fragment would
+ *     fall into that excluded zone — the background rect would have to be manually extended
+ *     past the clip and the bottom rounded corner would get sliced off at the tile boundary
+ *     (the original visual bug in #354).
+ *
+ * By keeping a 1pt-tall tail newline beyond the bottom padding spacer, iOS lays the spacer
+ * out as a normal interior line fragment included in usedRect/boundingRect and inside the
+ * drawing tiles, so the corner renders intact and no rect extension is needed.
+ */
+- (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 = isLastBlockACodeBlock(output);
+  BOOL isPaddedBlockquote = !isCodeBlock && [_config blockquotePadding] > 0 &&
+                            [output attribute:BlockquoteDepthAttributeName
+                                       atIndex:lastContent.location
+                                effectiveRange:NULL] != nil;
+  NSRange codeRange = NSMakeRange(0, 0);
+  if (isCodeBlock) {
+    [output attribute:CodeBlockAttributeName
+                      atIndex:lastContent.location
+        longestEffectiveRange:&codeRange
+                      inRange:NSMakeRange(0, output.length)];
+    NSUInteger codeEnd = NSMaxRange(codeRange);
+    if (codeEnd >= output.length) {
+      [output appendAttributedString:kNewlineAttributedString];
+    }
+    logicalEnd = codeEnd + 1;
+  } else if (isPaddedBlockquote) {
+    NSUInteger blockquoteEnd = NSMaxRange(lastContent);
+    while (blockquoteEnd < output.length && [output attribute:BlockquoteDepthAttributeName
+                                                       atIndex:blockquoteEnd
+                                                effectiveRange:NULL] != nil) {
+      blockquoteEnd++;
+    }
+    if (blockquoteEnd >= output.length) {
+      [output appendAttributedString:kNewlineAttributedString];
+    }
+    logicalEnd = blockquoteEnd + 1;
+  }
+
+  if (logicalEnd < output.length) {
+    [output deleteCharactersInRange:NSMakeRange(logicalEnd, output.length - logicalEnd)];
+  }
+
+  if ((isCodeBlock && NSMaxRange(codeRange) < output.length) || isPaddedBlockquote) {
+    NSUInteger tailIdx = isCodeBlock ? NSMaxRange(codeRange) : logicalEnd - 1;
+    [output removeAttribute:CodeBlockAttributeName range:NSMakeRange(tailIdx, 1)];
+    [output removeAttribute:BlockquoteDepthAttributeName range:NSMakeRange(tailIdx, 1)];
+    [output removeAttribute:BlockquoteBackgroundColorAttributeName range:NSMakeRange(tailIdx, 1)];
+    NSParagraphStyle *style = [output attribute:NSParagraphStyleAttributeName atIndex:tailIdx effectiveRange:NULL];
+    NSMutableParagraphStyle *mutableStyle = style ? [style mutableCopy] : [[NSMutableParagraphStyle alloc] init];
+    mutableStyle.paragraphSpacing = 0;
+    mutableStyle.paragraphSpacingBefore = 0;
+    mutableStyle.minimumLineHeight = 1;
+    mutableStyle.maximumLineHeight = 1;
+    [output addAttribute:NSParagraphStyleAttributeName value:mutableStyle range:NSMakeRange(tailIdx, 1)];
+  }
+
+  // 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:(TiptapASTNode *)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 (TiptapASTNode *child in node.children) {
+      [self renderNodeRecursive:child into:out context:context];
+    }
+  }
+}
+
+@end

package/ios/renderer/BaseRenderer.h

@@ -0,0 +1,33 @@
+#pragma once
+#import "NodeRenderer.h"
+
+@class RendererFactory;
+@class StyleConfig;
+@class RenderContext;
+@class TiptapASTNode;
+
+/// Shared base for all node renderers — provides `_rendererFactory` and `_config`
+/// as protected ivars and the common designated initializer.
+/// `renderNode:into:context:` is a template method: take context snapshot ->
+/// `renderNodeContent:into:context:` -> restore snapshot. Subclasses implement
+/// `renderNodeContent:into:context:` and, when they mutate scoped context state,
+/// override `takeContextSnapshot:` to return `[context snapshotScope]`.
+@interface BaseRenderer : NSObject <NodeRenderer> {
+@protected
+  __weak RendererFactory *_rendererFactory;
+  StyleConfig *_config;
+}
+
+- (instancetype)initWithRendererFactory:(id)rendererFactory config:(id)config;
+
+- (void)renderNodeContent:(TiptapASTNode *)node
+                     into:(NSMutableAttributedString *)output
+                  context:(RenderContext *)context;
+
+/// Default returns nil.
+- (nullable id)takeContextSnapshot:(RenderContext *)context;
+
+/// Default restores a scope frame when snapshot is non-nil, no-op otherwise.
+- (void)restoreContextSnapshot:(nullable id)snapshot context:(RenderContext *)context;
+
+@end

package/ios/renderer/BaseRenderer.m

@@ -0,0 +1,46 @@
+#import "BaseRenderer.h"
+#import "RenderContext.h"
+#import "RendererFactory.h"
+#import "StyleConfig.h"
+
+@implementation BaseRenderer
+
+- (instancetype)initWithRendererFactory:(id)rendererFactory config:(id)config
+{
+  if (self = [super init]) {
+    _rendererFactory = rendererFactory;
+    _config = (StyleConfig *)config;
+  }
+  return self;
+}
+
+- (void)renderNode:(TiptapASTNode *)node into:(NSMutableAttributedString *)output context:(RenderContext *)context
+{
+  id snapshot = [self takeContextSnapshot:context];
+  @try {
+    [self renderNodeContent:node into:output context:context];
+  } @finally {
+    [self restoreContextSnapshot:snapshot context:context];
+  }
+}
+
+- (void)renderNodeContent:(TiptapASTNode *)node
+                     into:(NSMutableAttributedString *)output
+                  context:(RenderContext *)context
+{
+  [self doesNotRecognizeSelector:_cmd];
+}
+
+- (id)takeContextSnapshot:(RenderContext *)context
+{
+  return nil;
+}
+
+- (void)restoreContextSnapshot:(id)snapshot context:(RenderContext *)context
+{
+  if (snapshot) {
+    [context restoreScope:snapshot];
+  }
+}
+
+@end

package/ios/renderer/BaselineShiftTextAttributes.h

@@ -0,0 +1,10 @@
+#pragma once
+#import "ENRMUIKit.h"
+#import <Foundation/Foundation.h>
+
+extern NSString *const ENRMScriptAttributeName;
+extern NSString *const ENRMScriptValueSuperscript;
+extern NSString *const ENRMScriptValueSubscript;
+
+void ENRMApplyBaselineShift(NSMutableAttributedString *output, NSRange range, CGFloat fontScale,
+                            CGFloat baselineOffsetScale);

package/ios/renderer/BaselineShiftTextAttributes.m

@@ -0,0 +1,26 @@
+#import "BaselineShiftTextAttributes.h"
+
+NSString *const ENRMScriptAttributeName = @"ENRMScript";
+NSString *const ENRMScriptValueSuperscript = @"superscript";
+NSString *const ENRMScriptValueSubscript = @"subscript";
+
+void ENRMApplyBaselineShift(NSMutableAttributedString *output, NSRange range, CGFloat fontScale,
+                            CGFloat baselineOffsetScale)
+{
+  [output enumerateAttribute:NSFontAttributeName
+                     inRange:range
+                     options:NSAttributedStringEnumerationLongestEffectiveRangeNotRequired
+                  usingBlock:^(UIFont *font, NSRange fontRange, BOOL *stop) {
+                    (void)stop;
+                    if (![font isKindOfClass:UIFont.class]) {
+                      return;
+                    }
+
+                    UIFont *scaledFont = [UIFont fontWithDescriptor:font.fontDescriptor
+                                                               size:font.pointSize * fontScale];
+                    [output addAttribute:NSFontAttributeName value:scaledFont range:fontRange];
+                    [output addAttribute:NSBaselineOffsetAttributeName
+                                   value:@(font.pointSize * baselineOffsetScale)
+                                   range:fontRange];
+                  }];
+}

package/ios/renderer/BlankLineRenderer.h

@@ -0,0 +1,4 @@
+#import "BaseRenderer.h"
+
+@interface BlankLineRenderer : BaseRenderer
+@end

package/ios/renderer/BlankLineRenderer.m

@@ -0,0 +1,51 @@
+#import "BlankLineRenderer.h"
+#import "TiptapASTNode.h"
+#import "ParagraphStyleUtils.h"
+#import "StyleConfig.h"
+
+#pragma mark - Renderer Implementation
+
+// Renders a run of consecutive blank lines emitted by the parser when the
+// preserveBlankLines flag is enabled. Each blank line in the source is drawn as
+// one empty line, so the rendered text keeps the exact line count that was typed
+// (e.g. in EnrichedTiptapTextInput). The empty lines use the paragraph font
+// and line height so their vertical rhythm matches the surrounding paragraphs;
+// any extra block spacing is left to the caller to configure via tiptapStyle.
+@implementation BlankLineRenderer
+
+- (void)renderNodeContent:(TiptapASTNode *)node
+                     into:(NSMutableAttributedString *)output
+                  context:(RenderContext *)context
+{
+  NSInteger count = [node.attributes[@"count"] integerValue];
+  if (count <= 0) {
+    return;
+  }
+
+  [self ensureStartingNewline:output];
+
+  NSDictionary *attributes = @{NSFontAttributeName : _config.paragraphFont};
+
+  NSMutableString *blanks = [NSMutableString stringWithCapacity:(NSUInteger)count];
+  for (NSInteger i = 0; i < count; i++) {
+    [blanks appendString:@"\n"];
+  }
+
+  NSUInteger start = output.length;
+  [output appendAttributedString:[[NSAttributedString alloc] initWithString:blanks attributes:attributes]];
+
+  NSRange range = NSMakeRange(start, output.length - start);
+  applyLineHeight(output, range, _config.paragraphLineHeight);
+  applyTextAlignment(output, range, _config.paragraphTextAlign);
+}
+
+#pragma mark - Private Utilities
+
+- (void)ensureStartingNewline:(NSMutableAttributedString *)output
+{
+  if (output.length > 0 && ![output.string hasSuffix:@"\n"]) {
+    [output appendAttributedString:[[NSAttributedString alloc] initWithString:@"\n"]];
+  }
+}
+
+@end

package/ios/renderer/BlockquoteRenderer.h

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