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

package/ios/utils/ParagraphStyleUtils.m

@@ -0,0 +1,484 @@
+#import "ParagraphStyleUtils.h"
+#import "ENRMFeatureFlags.h"
+#import "ENRMImageAttachment.h"
+#import "ENRMLinkPillAttachment.h"
+#import "LastElementUtils.h"
+#import <React/RCTI18nUtil.h>
+
+#if ENRICHED_TIPTAP_MATH
+#import "ENRMMathInlineAttachment.h"
+#endif
+
+NSAttributedString *kNewlineAttributedString;
+static NSParagraphStyle *kBlockSpacerTemplate;
+
+NSLineBreakStrategy ENRMResolveLineBreakStrategy(NSString *strategy)
+{
+  if ([strategy isEqualToString:@"standard"]) {
+    return NSLineBreakStrategyStandard;
+  } else if ([strategy isEqualToString:@"hangul-word"]) {
+    return NSLineBreakStrategyHangulWordPriority;
+  } else if ([strategy isEqualToString:@"push-out"]) {
+    return NSLineBreakStrategyPushOut;
+  }
+  return NSLineBreakStrategyNone;
+}
+
+NSLineBreakMode ENRMResolveEllipsizeLineBreakMode(NSString *mode)
+{
+  if ([mode isEqualToString:@"head"]) {
+    return NSLineBreakByTruncatingHead;
+  } else if ([mode isEqualToString:@"middle"]) {
+    return NSLineBreakByTruncatingMiddle;
+  } else if ([mode isEqualToString:@"clip"]) {
+    return NSLineBreakByClipping;
+  }
+  return NSLineBreakByTruncatingTail;
+}
+
+__attribute__((constructor)) static void initParagraphStyleUtils(void)
+{
+  kNewlineAttributedString = [[NSAttributedString alloc] initWithString:@"\n"];
+
+  NSMutableParagraphStyle *template = [[NSMutableParagraphStyle alloc] init];
+  template.minimumLineHeight = 1;
+  template.maximumLineHeight = 1;
+  kBlockSpacerTemplate = [template copy];
+}
+
+ENRMWritingDirectionMode ENRMResolveWritingDirectionMode(NSString *value)
+{
+  if ([value isEqualToString:@"ltr"]) {
+    return ENRMWritingDirectionModeLTR;
+  }
+  if ([value isEqualToString:@"rtl"]) {
+    return ENRMWritingDirectionModeRTL;
+  }
+  if ([value isEqualToString:@"auto"]) {
+    return ENRMWritingDirectionModeAuto;
+  }
+  return ENRMWritingDirectionModeFirstStrong;
+}
+
+static BOOL ENRMIsStrongRTLChar(unichar c)
+{
+  return (c >= 0x0590 && c <= 0x08FF) || (c >= 0xFB1D && c <= 0xFDFF) || (c >= 0xFE70 && c <= 0xFEFF);
+}
+
+NSWritingDirection ENRMFirstStrongDirection(NSString *text)
+{
+  NSCharacterSet *letters = [NSCharacterSet letterCharacterSet];
+  NSUInteger length = text.length;
+  for (NSUInteger i = 0; i < length; i++) {
+    unichar c = [text characterAtIndex:i];
+    if (![letters characterIsMember:c]) {
+      continue;
+    }
+    return ENRMIsStrongRTLChar(c) ? NSWritingDirectionRightToLeft : NSWritingDirectionLeftToRight;
+  }
+  return NSWritingDirectionNatural;
+}
+
+BOOL ENRMParagraphIsRTL(NSParagraphStyle *style)
+{
+  if (style && style.baseWritingDirection != NSWritingDirectionNatural) {
+    return style.baseWritingDirection == NSWritingDirectionRightToLeft;
+  }
+  return [[RCTI18nUtil sharedInstance] isRTL];
+}
+
+void ENRMApplyWritingDirectionMode(NSMutableAttributedString *output, ENRMWritingDirectionMode mode,
+                                   NSWritingDirection layoutDirection)
+{
+  switch (mode) {
+    case ENRMWritingDirectionModeAuto:
+      ENRMApplyWritingDirectionToParagraphStyles(output, NSWritingDirectionNatural);
+      break;
+    case ENRMWritingDirectionModeLTR:
+      ENRMApplyWritingDirectionToParagraphStyles(output, NSWritingDirectionLeftToRight);
+      break;
+    case ENRMWritingDirectionModeRTL:
+      ENRMApplyWritingDirectionToParagraphStyles(output, NSWritingDirectionRightToLeft);
+      break;
+    case ENRMWritingDirectionModeFirstStrong:
+      ENRMApplyFirstStrongParagraphDirections(output, layoutDirection);
+      break;
+  }
+}
+
+void ENRMApplyFirstStrongParagraphDirections(NSMutableAttributedString *output, NSWritingDirection fallback)
+{
+  if (output.length == 0) {
+    return;
+  }
+  NSString *string = output.string;
+  NSUInteger length = string.length;
+  NSUInteger position = 0;
+  while (position < length) {
+    NSRange paragraphRange = [string paragraphRangeForRange:NSMakeRange(position, 0)];
+    if (NSMaxRange(paragraphRange) <= position) {
+      break;
+    }
+    position = NSMaxRange(paragraphRange);
+
+    NSNumber *isCodeBlock = [output attribute:CodeBlockAttributeName
+                                      atIndex:paragraphRange.location
+                               effectiveRange:nil];
+    if (isCodeBlock.boolValue) {
+      continue;
+    }
+
+    NSWritingDirection direction = ENRMFirstStrongDirection([string substringWithRange:paragraphRange]);
+    if (direction == NSWritingDirectionNatural) {
+      direction = fallback;
+    }
+    if (direction == NSWritingDirectionNatural) {
+      continue;
+    }
+
+    [output enumerateAttribute:NSParagraphStyleAttributeName
+                       inRange:paragraphRange
+                       options:0
+                    usingBlock:^(NSParagraphStyle *style, NSRange range, BOOL *stop) {
+                      if (style != nil && style.baseWritingDirection == direction) {
+                        return;
+                      }
+                      NSMutableParagraphStyle *updated =
+                          style ? [style mutableCopy] : [[NSMutableParagraphStyle alloc] init];
+                      updated.baseWritingDirection = direction;
+                      [output addAttribute:NSParagraphStyleAttributeName value:updated range:range];
+                    }];
+  }
+}
+
+void ENRMApplyWritingDirectionToParagraphStyles(NSMutableAttributedString *output, NSWritingDirection writingDirection)
+{
+  if (output.length == 0) {
+    return;
+  }
+  [output enumerateAttribute:NSParagraphStyleAttributeName
+                     inRange:NSMakeRange(0, output.length)
+                     options:0
+                  usingBlock:^(NSParagraphStyle *style, NSRange range, BOOL *stop) {
+                    if (!style) {
+                      return;
+                    }
+                    // Skip runs already in the target direction (issue #739),
+                    // mirroring ENRMApplyFirstStrongParagraphDirections.
+                    if (style.baseWritingDirection == writingDirection) {
+                      return;
+                    }
+                    NSNumber *isCodeBlock = [output attribute:CodeBlockAttributeName
+                                                      atIndex:range.location
+                                               effectiveRange:nil];
+                    if (isCodeBlock.boolValue) {
+                      return;
+                    }
+                    NSMutableParagraphStyle *mutable = [style mutableCopy];
+                    mutable.baseWritingDirection = writingDirection;
+                    [output addAttribute:NSParagraphStyleAttributeName value:mutable range:range];
+                  }];
+}
+
+NSMutableParagraphStyle *getOrCreateParagraphStyle(NSMutableAttributedString *output, NSUInteger index)
+{
+  NSParagraphStyle *existing = [output attribute:NSParagraphStyleAttributeName atIndex:index effectiveRange:NULL];
+  NSMutableParagraphStyle *style = existing ? [existing mutableCopy] : [[NSMutableParagraphStyle alloc] init];
+  return style;
+}
+
+void applyParagraphSpacingAfter(NSMutableAttributedString *output, NSUInteger start, CGFloat marginBottom)
+{
+  [output appendAttributedString:kNewlineAttributedString];
+
+  NSMutableParagraphStyle *style = getOrCreateParagraphStyle(output, start);
+  style.paragraphSpacing = marginBottom;
+
+  NSRange range = NSMakeRange(start, output.length - start);
+  [output addAttribute:NSParagraphStyleAttributeName value:style range:range];
+}
+
+NSUInteger applyParagraphSpacingBefore(NSMutableAttributedString *output, NSRange range, CGFloat marginTop)
+{
+  if (marginTop <= 0 || range.location == 0)
+    return 0;
+
+  NSUInteger prevIdx = range.location - 1;
+  if ([output.string characterAtIndex:prevIdx] != '\n')
+    return 0;
+
+  NSParagraphStyle *prevStyle = [output attribute:NSParagraphStyleAttributeName atIndex:prevIdx effectiveRange:NULL];
+
+  CGFloat prevMarginBottom = prevStyle.paragraphSpacing;
+  if (prevMarginBottom >= marginTop)
+    return 0;
+
+  CGFloat extraGap = marginTop - prevMarginBottom;
+
+  NSMutableParagraphStyle *spacerStyle = [kBlockSpacerTemplate mutableCopy];
+  spacerStyle.paragraphSpacing = MAX(0, extraGap - 1.0);
+
+  NSDictionary *attrs = @{NSParagraphStyleAttributeName : spacerStyle};
+  NSAttributedString *spacer = [[NSAttributedString alloc] initWithString:@"\n" attributes:attrs];
+
+  [output insertAttributedString:spacer atIndex:range.location];
+  return 1;
+}
+
+NSUInteger applyBlockSpacingBefore(NSMutableAttributedString *output, NSUInteger insertionPoint, CGFloat marginTop)
+{
+  if (marginTop <= 0) {
+    return 0;
+  }
+
+  CGFloat spacing = marginTop;
+
+  // At index 0 the spacer \n produces a 1pt line fragment (minimumLineHeight=1)
+  // on top of paragraphSpacing. Subtract it so the total equals the desired margin.
+  // For non-zero positions the 1pt is intentional inter-block spacing.
+  if (insertionPoint == 0) {
+    spacing = MAX(0, marginTop - 1.0);
+  }
+
+  NSMutableParagraphStyle *spacerStyle = [kBlockSpacerTemplate mutableCopy];
+  spacerStyle.paragraphSpacing = spacing;
+
+  NSAttributedString *spacer =
+      [[NSAttributedString alloc] initWithString:@"\n" attributes:@{NSParagraphStyleAttributeName : spacerStyle}];
+
+  [output insertAttributedString:spacer atIndex:insertionPoint];
+  return 1;
+}
+
+void applyBlockSpacingAfter(NSMutableAttributedString *output, CGFloat marginBottom)
+{
+  if (marginBottom <= 0) {
+    return;
+  }
+
+  NSUInteger spacerLocation = output.length;
+  [output appendAttributedString:kNewlineAttributedString];
+
+  NSMutableParagraphStyle *spacerStyle = [kBlockSpacerTemplate mutableCopy];
+  spacerStyle.paragraphSpacing = marginBottom;
+
+  [output addAttribute:NSParagraphStyleAttributeName value:spacerStyle range:NSMakeRange(spacerLocation, 1)];
+}
+
+CGFloat ENRMLineHeightWithLinkPills(NSAttributedString *text, NSRange range, CGFloat lineHeight)
+{
+#if !TARGET_OS_OSX
+  __block CGFloat fitting = lineHeight;
+  [text enumerateAttribute:NSAttachmentAttributeName
+                   inRange:range
+                   options:0
+                usingBlock:^(id value, __unused NSRange subrange, __unused BOOL *stop) {
+                  if ([value isKindOfClass:ENRMLinkPillAttachment.class])
+                    fitting = MAX(fitting, ((ENRMLinkPillAttachment *)value).lineHeight);
+                }];
+  return fitting;
+#else
+  return lineHeight;
+#endif
+}
+
+// UIKit's own key for the pre-substitution font. Not exported by any SDK header, so it is spelled out
+// here; it is the same string UIKit writes into a UITextView's storage when it substitutes a font.
+static NSString *const ENRMOriginalFontAttributeName = @"NSOriginalFont";
+
+void ENRMPinLineMetricsToStyledFonts(NSMutableAttributedString *output, NSRange range)
+{
+  if (range.length == 0 || NSMaxRange(range) > output.length) {
+    return;
+  }
+
+  [output enumerateAttribute:NSFontAttributeName
+                     inRange:range
+                     options:0
+                  usingBlock:^(UIFont *font, NSRange fontRange, __unused BOOL *stop) {
+                    if (font) {
+                      [output addAttribute:ENRMOriginalFontAttributeName value:font range:fontRange];
+                    }
+                  }];
+}
+
+// Floor, not clamp: minimumLineHeight keeps short lines at lineHeight, while maximumLineHeight = 0 lets
+// a line grow to fit a taller run (large inline code, math, images) instead of clipping it.
+// We can diverge from RN's clamp because we measure the real laid-out height, so grown lines are reserved.
+void ENRMApplyLineHeightToParagraphStyle(NSMutableParagraphStyle *style, CGFloat lineHeight)
+{
+  if (lineHeight <= 0) {
+    return;
+  }
+
+  style.minimumLineHeight = lineHeight;
+  style.maximumLineHeight = 0;
+}
+
+void applyLineHeight(NSMutableAttributedString *output, NSRange range, CGFloat lineHeight)
+{
+  lineHeight = ENRMLineHeightWithLinkPills(output, range, lineHeight);
+  if (lineHeight <= 0) {
+    return;
+  }
+
+  NSMutableParagraphStyle *style = getOrCreateParagraphStyle(output, range.location);
+  ENRMApplyLineHeightToParagraphStyle(style, lineHeight);
+
+  [output addAttribute:NSParagraphStyleAttributeName value:style range:range];
+}
+
+// Calculates the offset needed to center the text within the line height. Returns 0
+// when the range has no minimum line height or its content already fills the line.
+CGFloat calculateBaselineOffset(NSAttributedString *output, NSRange range)
+{
+  if (range.length == 0) {
+    return 0;
+  }
+
+  // applyLineHeight floors lines with minimumLineHeight (maximumLineHeight is 0 for grown lines,
+  // or equal to the minimum for re-clamped code blocks), so the target is the minimum line height.
+  __block CGFloat targetLineHeight = 0;
+  [output enumerateAttribute:NSParagraphStyleAttributeName
+                     inRange:range
+                     options:NSAttributedStringEnumerationLongestEffectiveRangeNotRequired
+                  usingBlock:^(NSParagraphStyle *paragraphStyle, __unused NSRange subrange, __unused BOOL *stop) {
+                    if (!paragraphStyle) {
+                      return;
+                    }
+                    targetLineHeight = MAX(paragraphStyle.minimumLineHeight, targetLineHeight);
+                  }];
+
+  if (targetLineHeight <= 0) {
+    return 0;
+  }
+
+  // Center on real text; on a math-only line center the math box instead of its font.
+  __block CGFloat textLineHeight = 0;
+#if ENRICHED_TIPTAP_MATH
+  __block BOOL hasMath = NO;
+#endif
+  [output enumerateAttributesInRange:range
+                             options:0
+                          usingBlock:^(NSDictionary<NSAttributedStringKey, id> *attrs, __unused NSRange subrange,
+                                       __unused BOOL *stop) {
+#if ENRICHED_TIPTAP_MATH
+                            if ([attrs[NSAttachmentAttributeName] isKindOfClass:[ENRMMathInlineAttachment class]]) {
+                              hasMath = YES;
+                              return;
+                            }
+#endif
+                            UIFont *font = attrs[NSFontAttributeName];
+                            if (font) {
+                              textLineHeight = MAX(UIFontLineHeight(font), textLineHeight);
+                            }
+                          }];
+
+  CGFloat contentLineHeight = textLineHeight;
+#if !TARGET_OS_OSX
+  __block CGFloat pillBoxHeight = 0;
+  [output enumerateAttribute:NSAttachmentAttributeName
+                     inRange:range
+                     options:0
+                  usingBlock:^(id value, NSRange subrange, BOOL *stop) {
+                    if ([value isKindOfClass:ENRMLinkPillAttachment.class])
+                      pillBoxHeight = MAX(pillBoxHeight, ((ENRMLinkPillAttachment *)value).boxHeight);
+                  }];
+  contentLineHeight = MAX(contentLineHeight, pillBoxHeight);
+#endif
+
+#if ENRICHED_TIPTAP_MATH
+  // Math only grows the content height, so measure it (parsing LaTeX) only when text
+  // alone wouldn't already fill the line.
+  if (hasMath && targetLineHeight > textLineHeight) {
+    __block CGFloat mathBoxHeight = 0;
+    [output enumerateAttribute:NSAttachmentAttributeName
+                       inRange:range
+                       options:0
+                    usingBlock:^(id value, __unused NSRange subrange, __unused BOOL *stop) {
+                      if ([value isKindOfClass:[ENRMMathInlineAttachment class]]) {
+                        mathBoxHeight = MAX(((ENRMMathInlineAttachment *)value).boxHeight, mathBoxHeight);
+                      }
+                    }];
+    contentLineHeight = MAX(contentLineHeight, mathBoxHeight);
+  }
+#endif
+
+  if (contentLineHeight <= 0 || targetLineHeight <= contentLineHeight) {
+    return 0;
+  }
+
+  return (targetLineHeight - contentLineHeight) / 2.0;
+}
+
+// Centers text within its line height (see calculateBaselineOffset). Called per block over its
+// own range so blocks can keep different line heights. Ranges that already carry a baseline offset
+// are left untouched, keeping nesting (e.g. a blockquote wrapping list items) idempotent.
+void applyBaselineOffset(NSMutableAttributedString *output, NSRange range)
+{
+  CGFloat baseLineOffset = calculateBaselineOffset(output, range);
+  if (baseLineOffset <= 0) {
+    return;
+  }
+
+  [output enumerateAttribute:NSBaselineOffsetAttributeName
+                     inRange:range
+                     options:0
+                  usingBlock:^(NSNumber *existingOffset, NSRange subrange, BOOL *stop) {
+                    if (existingOffset != nil) {
+                      return;
+                    }
+                    [output enumerateAttribute:NSAttachmentAttributeName
+                                       inRange:subrange
+                                       options:0
+                                    usingBlock:^(id attachment, NSRange attachmentRange, BOOL *innerStop) {
+                                      if ([attachment isKindOfClass:[ENRMImageAttachment class]] &&
+                                          !((ENRMImageAttachment *)attachment).isInline) {
+                                        return;
+                                      }
+                                      [output addAttribute:NSBaselineOffsetAttributeName
+                                                     value:@(baseLineOffset)
+                                                     range:attachmentRange];
+                                    }];
+                  }];
+}
+
+void applyTextAlignment(NSMutableAttributedString *output, NSRange range, NSTextAlignment textAlign)
+{
+  NSMutableParagraphStyle *style = getOrCreateParagraphStyle(output, range.location);
+  style.alignment = textAlign;
+  [output addAttribute:NSParagraphStyleAttributeName value:style range:range];
+}
+
+void ENRMApplyLineBreakStrategyToParagraphStyles(NSMutableAttributedString *output,
+                                                 NSLineBreakStrategy lineBreakStrategy)
+{
+  if (output.length == 0) {
+    return;
+  }
+  [output enumerateAttribute:NSParagraphStyleAttributeName
+                     inRange:NSMakeRange(0, output.length)
+                     options:0
+                  usingBlock:^(NSParagraphStyle *value, NSRange range, BOOL *stop) {
+                    if (!value) {
+                      return;
+                    }
+                    NSMutableParagraphStyle *mutable = [value mutableCopy];
+                    mutable.lineBreakStrategy = lineBreakStrategy;
+                    [output addAttribute:NSParagraphStyleAttributeName value:mutable range:range];
+                  }];
+}
+
+NSTextAlignment textAlignmentFromString(NSString *textAlign)
+{
+  if ([textAlign isEqualToString:@"left"]) {
+    return NSTextAlignmentLeft;
+  } else if ([textAlign isEqualToString:@"center"]) {
+    return NSTextAlignmentCenter;
+  } else if ([textAlign isEqualToString:@"right"]) {
+    return NSTextAlignmentRight;
+  } else if ([textAlign isEqualToString:@"justify"]) {
+    return NSTextAlignmentJustified;
+  }
+  return NSTextAlignmentNatural;
+}

package/ios/utils/PasteboardUtils.h

@@ -0,0 +1,48 @@
+#pragma once
+#import "ENRMUIKit.h"
+#import <Foundation/Foundation.h>
+
+@class StyleConfig;
+
+static NSString *const kUTIPlainText = @"public.utf8-plain-text";
+static NSString *const kUTIHTML = @"public.html";
+static NSString *const kUTITiptap = @"net.daringfireball.tiptap";
+
+NS_ASSUME_NONNULL_BEGIN
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Copies a plain string to the platform pasteboard.
+ */
+void copyStringToPasteboard(NSString *string);
+
+/// Copies a { UTI → NSString | NSData } dictionary to the platform pasteboard.
+void copyItemsToPasteboard(NSDictionary<NSString *, id> *items);
+
+/**
+ * Copies attributed string to pasteboard with multiple representations
+ * (plain text, Tiptap, HTML, RTFD, RTF). Receiving apps pick the richest format they support.
+ */
+void copyAttributedStringToPasteboard(NSAttributedString *attributedString, NSString *_Nullable tiptap,
+                                      StyleConfig *_Nullable styleConfig);
+
+/**
+ * Extracts tiptap for the given range.
+ * Full selection returns cached tiptap; partial selection reverse-engineers from attributes.
+ */
+NSString *_Nullable tiptapForRange(NSAttributedString *attributedText, NSRange range,
+                                     NSString *_Nullable cachedTiptap);
+
+/**
+ * Returns remote image URLs (http/https only) from ENRMImageAttachments in the given range.
+ */
+NSArray<NSString *> *imageURLsInRange(NSAttributedString *attributedText, NSRange range);
+
+#ifdef __cplusplus
+}
+#endif
+
+NS_ASSUME_NONNULL_END

package/ios/utils/PasteboardUtils.m

@@ -0,0 +1,166 @@
+#import "PasteboardUtils.h"
+#import "ENRMImageAttachment.h"
+#import "ENRMLinkPillText.h"
+#import "HTMLGenerator.h"
+#import "TiptapExtractor.h"
+#import "RTFExportUtils.h"
+#import "StyleConfig.h"
+#include <TargetConditionals.h>
+#if !TARGET_OS_OSX
+#import <UIKit/UIPasteboard.h>
+#endif
+
+static NSString *const kUTIRTFD = @"com.apple.rtfd";
+static NSString *const kUTIFlatRTFD = @"com.apple.flat-rtfd";
+static NSString *const kUTIRTF = @"public.rtf";
+
+#pragma mark - Private Helpers
+
+static void addRTFData(NSMutableDictionary *items, NSAttributedString *attributedString, NSRange range,
+                       NSString *documentType, NSString *uti)
+{
+  NSError *error = nil;
+  NSData *data = [attributedString dataFromRange:range
+                              documentAttributes:@{NSDocumentTypeDocumentAttribute : documentType}
+                                           error:&error];
+  if (data && !error) {
+    items[uti] = data;
+  }
+}
+
+static void addRTFDData(NSMutableDictionary *items, NSAttributedString *attributedString, NSRange range)
+{
+  NSError *error = nil;
+  NSFileWrapper *wrapper =
+      [attributedString fileWrapperFromRange:range
+                          documentAttributes:@{NSDocumentTypeDocumentAttribute : NSRTFDTextDocumentType}
+                                       error:&error];
+  if (wrapper && !error) {
+    NSData *data = [wrapper serializedRepresentation];
+    if (data) {
+      items[kUTIFlatRTFD] = data;
+    }
+  }
+}
+
+static void addHTMLData(NSMutableDictionary *items, NSAttributedString *attributedString, StyleConfig *styleConfig)
+{
+  NSString *html = generateHTML(attributedString, styleConfig);
+  if (html) {
+    NSData *data = [html dataUsingEncoding:NSUTF8StringEncoding];
+    if (data) {
+      items[kUTIHTML] = data;
+    }
+  }
+}
+
+#pragma mark - Public API
+
+void copyStringToPasteboard(NSString *string)
+{
+#if !TARGET_OS_OSX
+  [[UIPasteboard generalPasteboard] setString:string];
+#else
+  NSPasteboard *pasteboard = [NSPasteboard generalPasteboard];
+  [pasteboard clearContents];
+  [pasteboard setString:string forType:kUTIPlainText];
+#endif
+}
+
+void copyItemsToPasteboard(NSDictionary<NSString *, id> *items)
+{
+#if !TARGET_OS_OSX
+  [[UIPasteboard generalPasteboard] setItems:@[ items ]];
+#else
+  NSPasteboard *pasteboard = [NSPasteboard generalPasteboard];
+  [pasteboard clearContents];
+  for (NSString *type in items) {
+    id value = items[type];
+    if ([value isKindOfClass:[NSString class]]) {
+      [pasteboard setString:value forType:type];
+    } else if ([value isKindOfClass:[NSData class]]) {
+      [pasteboard setData:value forType:type];
+    }
+  }
+#endif
+}
+
+void copyAttributedStringToPasteboard(NSAttributedString *attributedString, NSString *_Nullable tiptap,
+                                      StyleConfig *_Nullable styleConfig)
+{
+  if (!attributedString || attributedString.length == 0)
+    return;
+
+  // Expanded once here for the plain-text flavor; the exporters below then have nothing left to expand.
+  attributedString = ENRMAttributedStringByExpandingLinkPills(attributedString, NULL);
+
+  NSMutableDictionary *items = [NSMutableDictionary dictionary];
+
+  items[kUTIPlainText] = attributedString.string;
+
+  if (tiptap.length > 0) {
+    items[kUTITiptap] = tiptap;
+  }
+
+  if (styleConfig) {
+    addHTMLData(items, attributedString, styleConfig);
+  }
+
+  // RTF export requires preprocessing (backgrounds, markers, normalized spacing)
+  NSAttributedString *rtfPrepared = prepareAttributedStringForRTFExport(attributedString, styleConfig);
+  NSRange rtfRange = NSMakeRange(0, rtfPrepared.length);
+
+  addRTFDData(items, rtfPrepared, rtfRange);
+  addRTFData(items, rtfPrepared, rtfRange, NSRTFTextDocumentType, kUTIRTF);
+
+  copyItemsToPasteboard(items);
+}
+
+#pragma mark - Content Extraction
+
+NSString *_Nullable tiptapForRange(NSAttributedString *attributedText, NSRange range,
+                                     NSString *_Nullable cachedTiptap)
+{
+  if (!cachedTiptap || range.length == 0)
+    return nil;
+
+  if (!attributedText || range.location >= attributedText.length)
+    return nil;
+
+  range.length = MIN(range.length, attributedText.length - range.location);
+
+  // Full selection: use cached tiptap directly
+  BOOL isFullSelection = (range.location == 0 && range.length >= attributedText.length - 1);
+  if (isFullSelection) {
+    return cachedTiptap;
+  }
+
+  // Partial selection: reverse-engineer from attributes
+  return extractTiptapFromAttributedString(attributedText, range);
+}
+
+NSArray<NSString *> *imageURLsInRange(NSAttributedString *attributedText, NSRange range)
+{
+  if (!attributedText || range.location == NSNotFound || range.length == 0 || range.location >= attributedText.length) {
+    return @[];
+  }
+
+  range.length = MIN(range.length, attributedText.length - range.location);
+
+  NSMutableArray<NSString *> *urls = [NSMutableArray array];
+
+  [attributedText enumerateAttribute:NSAttachmentAttributeName
+                             inRange:range
+                             options:0
+                          usingBlock:^(id value, NSRange r, BOOL *stop) {
+                            if (![value isKindOfClass:[ENRMImageAttachment class]])
+                              return;
+
+                            NSString *url = ((ENRMImageAttachment *)value).imageURL;
+                            if ([url hasPrefix:@"http://"] || [url hasPrefix:@"https://"]) {
+                              [urls addObject:url];
+                            }
+                          }];
+
+  return urls;
+}