react-native-enriched-markdown-scaffold 0.7.4-scaffold.9 → 1.0.2-scaffold.2

package/ios/math/ENRMMathChipController.mm

@@ -0,0 +1,476 @@
+#import "ENRMMathChipController.h"
+
+#import "ENRMFeatureFlags.h"
+
+// The single gate for math chips in the editor. `ENRMMathInlineAttachment` does
+// not exist as a class in a math-disabled build (its whole @implementation is
+// compiled out), so this has to be a preprocessor split, not a runtime flag: an
+// unconditional reference here compiles clean and fails at link with
+// "Undefined symbols: _OBJC_CLASS_$_ENRMMathInlineAttachment".
+//
+// The inert twin at the bottom of the file is what lets the host call straight
+// through with no guards of its own — the iOS counterpart of Android returning a
+// null `MathChipController`.
+#if ENRICHED_MARKDOWN_MATH
+
+#import "ENRMMathFontWeight.h"
+#import "ENRMMathInlineAttachment.h"
+#import "ENRMTextHitTest.h"
+
+/// Fallback point sizes when `markdownStyle` carries none. Block math reads
+/// larger than inline math by convention.
+static const CGFloat kENRMDefaultInlineMathFontSize = 16.0;
+static const CGFloat kENRMDefaultBlockMathFontSize = 20.0;
+
+@implementation ENRMMathChipController {
+  __weak ENRMPlatformTextView *_textView;
+  ENRMInputFormatterStyle *_style;
+}
+
++ (BOOL)isAvailable
+{
+  return YES;
+}
+
+- (instancetype)initWithTextView:(ENRMPlatformTextView *)textView style:(ENRMInputFormatterStyle *)style
+{
+  if (self = [super init]) {
+    _textView = textView;
+    _style = style;
+  }
+  return self;
+}
+
+#pragma mark - Reading
+
+- (nullable NSTextStorage *)storage
+{
+  NSTextStorage *storage = _textView.textStorage;
+  return storage.length > 0 ? storage : nil;
+}
+
+/// The chip attachment at `position`, or nil. Checks the attribute rather than
+/// the character: a placeholder with no attachment is a chip that has not been
+/// stamped yet, and must not be mistaken for one that has.
+- (nullable ENRMMathInlineAttachment *)attachmentAtPosition:(NSUInteger)position inStorage:(NSTextStorage *)storage
+{
+  if (position >= storage.length) {
+    return nil;
+  }
+  id value = [storage attribute:NSAttachmentAttributeName atIndex:position effectiveRange:NULL];
+  return [value isKindOfClass:[ENRMMathInlineAttachment class]] ? value : nil;
+}
+
+- (ENRMMathAtom *)atomFromAttachment:(ENRMMathInlineAttachment *)attachment atPosition:(NSUInteger)position
+{
+  ENRMMathAtom *atom = [[ENRMMathAtom alloc] init];
+  atom.position = position;
+  atom.latex = attachment.latex ?: @"";
+  atom.displayMode = attachment.displayMode;
+  return atom;
+}
+
+- (NSArray<ENRMMathAtom *> *)allAtoms
+{
+  NSTextStorage *storage = [self storage];
+  if (storage == nil) {
+    return @[];
+  }
+
+  NSMutableArray<ENRMMathAtom *> *atoms = [NSMutableArray array];
+  [storage enumerateAttribute:NSAttachmentAttributeName
+                      inRange:NSMakeRange(0, storage.length)
+                      options:0
+                   usingBlock:^(id value, NSRange range, BOOL *stop) {
+                     if (![value isKindOfClass:[ENRMMathInlineAttachment class]]) {
+                       return;
+                     }
+                     [atoms addObject:[self atomFromAttachment:value atPosition:range.location]];
+                   }];
+  return atoms;
+}
+
+- (nullable ENRMMathAtom *)atomAtPosition:(NSUInteger)position
+{
+  NSTextStorage *storage = [self storage];
+  if (storage == nil) {
+    return nil;
+  }
+  ENRMMathInlineAttachment *attachment = [self attachmentAtPosition:position inStorage:storage];
+  return attachment != nil ? [self atomFromAttachment:attachment atPosition:position] : nil;
+}
+
+#pragma mark - Styling
+
+/// Pushes the current `markdownStyle` onto one attachment.
+///
+/// The two branches read *different* style keys and both compile against either
+/// set, so a wrong branch is silent: `inlineMath*` is `markdownStyle.inlineMath`
+/// and `math*` is `markdownStyle.math`, the block key. They swapped meanings in
+/// the rename, so the pairing below is the thing to check, not the spelling.
+- (void)applyStyleToAttachment:(ENRMMathInlineAttachment *)attachment
+{
+  if (attachment.displayMode) {
+    attachment.fontSize = _style.mathFontSize > 0 ? _style.mathFontSize : kENRMDefaultBlockMathFontSize;
+    attachment.mathTextColor = _style.mathColor ?: _style.baseTextColor;
+    attachment.containerBackgroundColor = _style.mathBackgroundColor;
+    attachment.containerBorderColor = _style.mathBorderColor;
+    attachment.containerBorderWidth = _style.mathBorderWidth;
+    attachment.containerBorderRadius = _style.mathBorderRadius;
+    attachment.containerPaddingHorizontal = _style.mathPaddingHorizontal;
+    attachment.containerPaddingVertical = _style.mathPaddingVertical;
+    attachment.blockMarginTop = _style.mathMarginTop;
+    attachment.blockMarginBottom = _style.mathMarginBottom;
+    attachment.blockAlignment = _style.mathTextAlign;
+    attachment.selectedBackgroundColor = _style.mathSelectedBackgroundColor;
+    attachment.selectedBorderColor = _style.mathSelectedBorderColor;
+    attachment.bold = ENRMMathFontWeightIsBold(_style.mathFontWeight);
+  } else {
+    attachment.fontSize = _style.inlineMathFontSize > 0 ? _style.inlineMathFontSize : kENRMDefaultInlineMathFontSize;
+    attachment.mathTextColor = _style.inlineMathColor ?: _style.baseTextColor;
+    attachment.containerBackgroundColor = _style.inlineMathBackgroundColor;
+    attachment.containerBorderColor = _style.inlineMathBorderColor;
+    attachment.containerBorderWidth = _style.inlineMathBorderWidth;
+    attachment.containerBorderRadius = _style.inlineMathBorderRadius;
+    attachment.containerPaddingHorizontal = _style.inlineMathPaddingHorizontal;
+    attachment.containerPaddingVertical = _style.inlineMathPaddingVertical;
+    // Inline math flows with the line: no block margins, no paragraph alignment.
+    attachment.blockMarginTop = 0;
+    attachment.blockMarginBottom = 0;
+    attachment.blockAlignment = NSTextAlignmentNatural;
+    attachment.selectedBackgroundColor = _style.inlineMathSelectedBackgroundColor;
+    attachment.selectedBorderColor = _style.inlineMathSelectedBorderColor;
+    attachment.bold = ENRMMathFontWeightIsBold(_style.inlineMathFontWeight);
+  }
+}
+
+- (ENRMMathInlineAttachment *)attachmentWithLatex:(NSString *)latex displayMode:(BOOL)displayMode
+{
+  ENRMMathInlineAttachment *attachment = [[ENRMMathInlineAttachment alloc] init];
+  attachment.latex = latex ?: @"";
+  attachment.displayMode = displayMode;
+  [self applyStyleToAttachment:attachment];
+#if TARGET_OS_OSX
+  [attachment renderForMacOS];
+#endif
+  return attachment;
+}
+
+/// A block chip claims the whole row, so its paragraph carries the configured
+/// alignment. Applied as a paragraph attribute on the chip character itself.
+- (nullable NSParagraphStyle *)paragraphStyleForAttachment:(ENRMMathInlineAttachment *)attachment
+{
+  if (!attachment.displayMode || attachment.blockAlignment == NSTextAlignmentNatural) {
+    return nil;
+  }
+  NSMutableParagraphStyle *paragraphStyle = [[NSMutableParagraphStyle alloc] init];
+  paragraphStyle.alignment = attachment.blockAlignment;
+  return paragraphStyle;
+}
+
+- (NSAttributedString *)attributedChipWithLatex:(NSString *)latex displayMode:(BOOL)displayMode
+{
+  ENRMMathInlineAttachment *attachment = [self attachmentWithLatex:latex displayMode:displayMode];
+  NSMutableAttributedString *chip = [[NSMutableAttributedString alloc]
+      initWithAttributedString:[NSAttributedString attributedStringWithAttachment:attachment]];
+  NSParagraphStyle *paragraphStyle = [self paragraphStyleForAttachment:attachment];
+  if (paragraphStyle != nil) {
+    [chip addAttribute:NSParagraphStyleAttributeName value:paragraphStyle range:NSMakeRange(0, chip.length)];
+  }
+  return chip;
+}
+
+#pragma mark - Mutation
+
+- (void)applyAtoms:(NSArray<ENRMMathAtom *> *)atoms offset:(NSUInteger)offset
+{
+  if (atoms.count == 0) {
+    return;
+  }
+  NSTextStorage *storage = [self storage];
+  if (storage == nil) {
+    return;
+  }
+
+  [storage beginEditing];
+  for (ENRMMathAtom *atom in atoms) {
+    NSUInteger position = atom.position + offset;
+    if (position >= storage.length) {
+      continue;
+    }
+    // The parser put a placeholder here; anything else means the buffer moved
+    // under the atom and stamping would overwrite live text.
+    if ([storage.string characterAtIndex:position] != kENRMObjectReplacement) {
+      continue;
+    }
+
+    ENRMMathInlineAttachment *attachment = [self attachmentWithLatex:atom.latex displayMode:atom.displayMode];
+    [storage addAttribute:NSAttachmentAttributeName value:attachment range:NSMakeRange(position, 1)];
+    NSParagraphStyle *paragraphStyle = [self paragraphStyleForAttachment:attachment];
+    if (paragraphStyle != nil) {
+      [storage addAttribute:NSParagraphStyleAttributeName value:paragraphStyle range:NSMakeRange(position, 1)];
+    }
+  }
+  [storage endEditing];
+
+  [self invalidateLayoutInRange:NSMakeRange(0, storage.length)];
+}
+
+- (BOOL)updateChipAtPosition:(NSUInteger)position latex:(NSString *)latex displayMode:(BOOL)displayMode
+{
+  NSTextStorage *storage = [self storage];
+  if (storage == nil) {
+    return NO;
+  }
+  ENRMMathInlineAttachment *attachment = [self attachmentAtPosition:position inStorage:storage];
+  if (attachment == nil) {
+    return NO;
+  }
+
+  BOOL modeChanged = (attachment.displayMode != displayMode);
+  attachment.latex = latex ?: @"";
+  attachment.displayMode = displayMode;
+  [self applyStyleToAttachment:attachment];
+  [attachment invalidateRender];
+#if TARGET_OS_OSX
+  [attachment renderForMacOS];
+#endif
+
+  NSRange chipRange = NSMakeRange(position, 1);
+  if (modeChanged) {
+    // Only a mode flip can add or drop the block paragraph style; leaving a stale
+    // one behind would centre the rest of the paragraph around a former block chip.
+    [storage beginEditing];
+    NSParagraphStyle *paragraphStyle = [self paragraphStyleForAttachment:attachment];
+    if (paragraphStyle != nil) {
+      [storage addAttribute:NSParagraphStyleAttributeName value:paragraphStyle range:chipRange];
+    } else {
+      [storage removeAttribute:NSParagraphStyleAttributeName range:chipRange];
+    }
+    [storage endEditing];
+  }
+
+  [self invalidateLayoutInRange:chipRange];
+  return YES;
+}
+
+- (BOOL)setSelected:(BOOL)selected atPosition:(NSUInteger)position
+{
+  NSTextStorage *storage = [self storage];
+  if (storage == nil) {
+    return NO;
+  }
+  ENRMMathInlineAttachment *attachment = [self attachmentAtPosition:position inStorage:storage];
+  if (attachment == nil || attachment.isSelected == selected) {
+    return NO;
+  }
+
+  attachment.isSelected = selected;
+  [attachment invalidateRender];
+  [self invalidateLayoutInRange:NSMakeRange(position, 1)];
+  return YES;
+}
+
+- (BOOL)clearSelectionsExceptPosition:(NSUInteger)keepPosition
+{
+  NSTextStorage *storage = [self storage];
+  if (storage == nil) {
+    return NO;
+  }
+
+  __block BOOL anyChanged = NO;
+  NSMutableArray<NSValue *> *changedRanges = [NSMutableArray array];
+  [storage enumerateAttribute:NSAttachmentAttributeName
+                      inRange:NSMakeRange(0, storage.length)
+                      options:0
+                   usingBlock:^(id value, NSRange range, BOOL *stop) {
+                     if (![value isKindOfClass:[ENRMMathInlineAttachment class]]) {
+                       return;
+                     }
+                     ENRMMathInlineAttachment *attachment = value;
+                     if (!attachment.isSelected || range.location == keepPosition) {
+                       return;
+                     }
+                     attachment.isSelected = NO;
+                     [attachment invalidateRender];
+                     [changedRanges addObject:[NSValue valueWithRange:range]];
+                     anyChanged = YES;
+                   }];
+
+  for (NSValue *rangeValue in changedRanges) {
+    [self invalidateLayoutInRange:rangeValue.rangeValue];
+  }
+  return anyChanged;
+}
+
+- (void)refreshAll
+{
+  NSTextStorage *storage = [self storage];
+  if (storage == nil) {
+    return;
+  }
+
+  __block BOOL anyChip = NO;
+  [storage beginEditing];
+  [storage enumerateAttribute:NSAttachmentAttributeName
+                      inRange:NSMakeRange(0, storage.length)
+                      options:0
+                   usingBlock:^(id value, NSRange range, BOOL *stop) {
+                     if (![value isKindOfClass:[ENRMMathInlineAttachment class]]) {
+                       return;
+                     }
+                     ENRMMathInlineAttachment *attachment = value;
+                     [self applyStyleToAttachment:attachment];
+                     [attachment invalidateRender];
+                     anyChip = YES;
+                     NSParagraphStyle *paragraphStyle = [self paragraphStyleForAttachment:attachment];
+                     if (paragraphStyle != nil) {
+                       [storage addAttribute:NSParagraphStyleAttributeName value:paragraphStyle range:range];
+                     }
+                   }];
+  [storage endEditing];
+
+  // With no chip in the buffer there is nothing to redraw and no reason to make
+  // the layout re-measure.
+  if (!anyChip) {
+    return;
+  }
+  [self invalidateLayoutInRange:NSMakeRange(0, storage.length)];
+}
+
+- (void)invalidateLayoutInRange:(NSRange)range
+{
+  ENRMPlatformTextView *textView = _textView;
+  NSLayoutManager *layoutManager = textView.textStorage.layoutManagers.firstObject;
+  if (layoutManager != nil) {
+    [layoutManager invalidateLayoutForCharacterRange:range actualCharacterRange:NULL];
+    [layoutManager ensureLayoutForCharacterRange:range];
+  }
+  ENRMSetNeedsDisplay(textView);
+}
+
+#pragma mark - Geometry
+
+- (CGRect)chipRectAtPosition:(NSUInteger)position
+{
+  ENRMPlatformTextView *textView = _textView;
+  NSTextStorage *storage = [self storage];
+  if (storage == nil || position >= storage.length) {
+    return CGRectNull;
+  }
+  NSLayoutManager *layoutManager = storage.layoutManagers.firstObject;
+  if (layoutManager == nil) {
+    return CGRectNull;
+  }
+
+  NSRange glyphRange = [layoutManager glyphRangeForCharacterRange:NSMakeRange(position, 1) actualCharacterRange:NULL];
+  CGRect rect = [layoutManager boundingRectForGlyphRange:glyphRange inTextContainer:textView.textContainer];
+  rect.origin.x += textView.textContainerInset.left;
+  rect.origin.y += textView.textContainerInset.top;
+  return rect;
+}
+
+- (NSUInteger)chipPositionAtPoint:(CGPoint)point
+{
+  ENRMPlatformTextView *textView = _textView;
+  NSTextStorage *storage = [self storage];
+  if (storage == nil) {
+    return NSNotFound;
+  }
+
+  NSUInteger index = ENRMCharacterIndexAtPoint(textView, point);
+  if (index == NSNotFound) {
+    return NSNotFound;
+  }
+
+  // The reported index can land just past the chip, so probe the character before
+  // it too. Requiring the touch inside the glyph rect is what stops a tap beside a
+  // chip — or in the padding past the last line — from reading as a tap on it.
+  NSUInteger candidates[2] = {index, index > 0 ? index - 1 : index};
+  NSUInteger candidateCount = index > 0 ? 2 : 1;
+  for (NSUInteger which = 0; which < candidateCount; which++) {
+    NSUInteger candidate = candidates[which];
+    if ([self attachmentAtPosition:candidate inStorage:storage] == nil) {
+      continue;
+    }
+    // An empty rect means the layout could not give the chip's extent; accept the
+    // candidate then, rather than making the chip untappable.
+    CGRect rect = [self chipRectAtPosition:candidate];
+    if (!CGRectIsNull(rect) && !CGRectIsEmpty(rect) && !CGRectContainsPoint(rect, point)) {
+      continue;
+    }
+    return candidate;
+  }
+  return NSNotFound;
+}
+
+@end
+
+#else // ENRICHED_MARKDOWN_MATH
+
+/// Math compiled out: the buffer can never hold a chip, so every query answers
+/// "no chip" and every mutation does nothing. Kept as a full implementation
+/// rather than `#if`s at the call sites so the host reads the same either way.
+@implementation ENRMMathChipController
+
++ (BOOL)isAvailable
+{
+  return NO;
+}
+
+- (instancetype)initWithTextView:(ENRMPlatformTextView *)textView style:(ENRMInputFormatterStyle *)style
+{
+  return [super init];
+}
+
+- (NSArray<ENRMMathAtom *> *)allAtoms
+{
+  return @[];
+}
+
+- (nullable ENRMMathAtom *)atomAtPosition:(NSUInteger)position
+{
+  return nil;
+}
+
+- (NSAttributedString *)attributedChipWithLatex:(NSString *)latex displayMode:(BOOL)displayMode
+{
+  return [[NSAttributedString alloc] initWithString:@""];
+}
+
+- (void)applyAtoms:(NSArray<ENRMMathAtom *> *)atoms offset:(NSUInteger)offset
+{
+}
+
+- (BOOL)updateChipAtPosition:(NSUInteger)position latex:(NSString *)latex displayMode:(BOOL)displayMode
+{
+  return NO;
+}
+
+- (BOOL)setSelected:(BOOL)selected atPosition:(NSUInteger)position
+{
+  return NO;
+}
+
+- (BOOL)clearSelectionsExceptPosition:(NSUInteger)keepPosition
+{
+  return NO;
+}
+
+- (void)refreshAll
+{
+}
+
+- (CGRect)chipRectAtPosition:(NSUInteger)position
+{
+  return CGRectNull;
+}
+
+- (NSUInteger)chipPositionAtPoint:(CGPoint)point
+{
+  return NSNotFound;
+}
+
+@end
+
+#endif // ENRICHED_MARKDOWN_MATH

package/ios/math/ENRMRaTeXBridge.swift

@@ -1,7 +1,10 @@
 import Foundation
 import CoreGraphics
 import CoreText
-import RaTeX
+// RaTeX's core Swift sources (RaTeXEngine/RaTeXRenderer/RaTeXFontLoader/DisplayList) are
+// vendored into this pod's own module (ios/vendor), so there is no external RaTeX module
+// to import; they resolve as same-module symbols. The vendored files import the RaTeXFFI
+// binary module from the XCFramework themselves.
 
 #if canImport(UIKit)
 import UIKit

package/ios/parser/ENRMMarkdownParser.h

@@ -8,17 +8,10 @@
 @property (nonatomic, assign) BOOL superscript;
 @property (nonatomic, assign) BOOL subscript;
 @property (nonatomic, assign) BOOL highlight;
+@property (nonatomic, assign) BOOL hardSoftBreaks;
 
 + (instancetype)defaultFlags;
 
-/// Flags matching the codegen `md4cFlags` Props defaults (every flag off).
-///
-/// Components mirror `md4cFlags` into an ivar with a per-field diff against the
-/// props baseline, so the ivar has to start from the same baseline the props do.
-/// `defaultFlags` enables `latexMath`, which is the right default for the
-/// standalone parser API but would make a `latexMath: false` prop a no-op.
-+ (instancetype)propsDefaultFlags;
-
 @end
 
 @interface ENRMMarkdownParser : NSObject

package/ios/parser/ENRMMarkdownParser.mm

@@ -13,6 +13,7 @@ extern MarkdownASTNode *parseMarkdownWithCppParser(NSString *markdown, ENRMMd4cF
     _superscript = NO;
     _subscript = NO;
     _highlight = NO;
+    _hardSoftBreaks = NO;
   }
   return self;
 }
@@ -22,17 +23,6 @@ extern MarkdownASTNode *parseMarkdownWithCppParser(NSString *markdown, ENRMMd4cF
   return [[ENRMMd4cFlags alloc] init];
 }
 
-+ (instancetype)propsDefaultFlags
-{
-  ENRMMd4cFlags *flags = [[ENRMMd4cFlags alloc] init];
-  flags.underline = NO;
-  flags.latexMath = NO;
-  flags.superscript = NO;
-  flags.subscript = NO;
-  flags.highlight = NO;
-  return flags;
-}
-
 - (id)copyWithZone:(NSZone *)zone
 {
   ENRMMd4cFlags *copy = [[ENRMMd4cFlags allocWithZone:zone] init];
@@ -41,6 +31,7 @@ extern MarkdownASTNode *parseMarkdownWithCppParser(NSString *markdown, ENRMMd4cF
   copy.superscript = self.superscript;
   copy.subscript = self.subscript;
   copy.highlight = self.highlight;
+  copy.hardSoftBreaks = self.hardSoftBreaks;
   return copy;
 }
 

package/ios/parser/MarkdownASTNode.h

@@ -30,7 +30,8 @@ typedef NS_ENUM(NSInteger, MarkdownNodeType) {
   MarkdownNodeTypeSpoiler,
   MarkdownNodeTypeSuperscript,
   MarkdownNodeTypeSubscript,
-  MarkdownNodeTypeHighlight
+  MarkdownNodeTypeHighlight,
+  MarkdownNodeTypeSoftBreak
 };
 
 @interface MarkdownASTNode : NSObject

package/ios/parser/MarkdownParserBridge.mm

@@ -104,6 +104,9 @@ static MarkdownASTNode *convertCppASTToObjC(std::shared_ptr<Markdown::MarkdownAS
     case Markdown::NodeType::Highlight:
       objcType = MarkdownNodeTypeHighlight;
       break;
+    case Markdown::NodeType::SoftBreak:
+      objcType = MarkdownNodeTypeSoftBreak;
+      break;
   }
 
   MarkdownASTNode *objcNode = [[MarkdownASTNode alloc] initWithType:objcType];
@@ -152,6 +155,7 @@ MarkdownASTNode *parseMarkdownWithCppParser(NSString *markdown, ENRMMd4cFlags *f
   cppFlags.superscript = flags.superscript;
   cppFlags.subscript = flags.subscript;
   cppFlags.highlight = flags.highlight;
+  cppFlags.hardSoftBreaks = flags.hardSoftBreaks;
 
   Markdown::MD4CParser parser;
   auto cppAST = parser.parse(cppMarkdown, cppFlags);

package/ios/renderer/AttributedRenderer.m

@@ -1,4 +1,5 @@
 #import "AttributedRenderer.h"
+#import "BlockquoteBorder.h"
 #import "CodeBlockBackground.h"
 #import "LastElementUtils.h"
 #import "MarkdownASTNode.h"
@@ -110,6 +111,10 @@
   // 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
@@ -121,15 +126,28 @@
       [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) {
-    NSUInteger tailIdx = NSMaxRange(codeRange);
+  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;

package/ios/renderer/BaseRenderer.h

@@ -3,11 +3,16 @@
 
 @class RendererFactory;
 @class StyleConfig;
+@class RenderContext;
+@class MarkdownASTNode;
 
 /// 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 {
+/// `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;
@@ -15,4 +20,14 @@
 
 - (instancetype)initWithRendererFactory:(id)rendererFactory config:(id)config;
 
+- (void)renderNodeContent:(MarkdownASTNode *)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

@@ -1,4 +1,5 @@
 #import "BaseRenderer.h"
+#import "RenderContext.h"
 #import "RendererFactory.h"
 #import "StyleConfig.h"
 
@@ -13,4 +14,33 @@
   return self;
 }
 
+- (void)renderNode:(MarkdownASTNode *)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:(MarkdownASTNode *)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