react-native-enriched-markdown 0.1.0 → 0.2.0

package/ios/utils/MarkdownExtractor.m

@@ -0,0 +1,308 @@
+#import "MarkdownExtractor.h"
+#import "BlockquoteBorder.h"
+#import "EnrichedMarkdownImageAttachment.h"
+#import "LastElementUtils.h"
+#import "RuntimeKeys.h"
+#import "ThematicBreakAttachment.h"
+
+#pragma mark - Extraction Context
+
+typedef struct {
+  NSInteger blockquoteDepth; // -1 = not in blockquote
+  NSInteger listDepth;       // -1 = not in list
+  BOOL needsBlankLine;
+} ExtractionState;
+
+#pragma mark - Helper Functions
+
+static void ensureBlankLine(NSMutableString *result)
+{
+  if (result.length == 0)
+    return;
+  if ([result hasSuffix:@"\n\n"])
+    return;
+
+  [result appendString:[result hasSuffix:@"\n"] ? @"\n" : @"\n\n"];
+}
+
+static BOOL isAtLineStart(NSMutableString *result)
+{
+  return result.length == 0 || [result hasSuffix:@"\n"];
+}
+
+/// Depth 0 = "> ", Depth 1 = "> > ", etc.
+static NSString *buildBlockquotePrefix(NSInteger depth)
+{
+  NSMutableString *prefix = [NSMutableString string];
+  for (NSInteger i = 0; i <= depth; i++) {
+    [prefix appendString:@"> "];
+  }
+  return prefix;
+}
+
+static NSString *buildListPrefix(NSInteger depth, BOOL isOrdered, NSInteger itemNumber)
+{
+  NSString *indent = [@"" stringByPaddingToLength:(depth * 2) withString:@" " startingAtIndex:0];
+  NSString *marker = isOrdered ? [NSString stringWithFormat:@"%ld.", (long)itemNumber] : @"-";
+  return [NSString stringWithFormat:@"%@%@ ", indent, marker];
+}
+
+static NSString *buildHeadingPrefix(NSInteger level)
+{
+  return [NSString stringWithFormat:@"%@ ", [@"" stringByPaddingToLength:level withString:@"#" startingAtIndex:0]];
+}
+
+static void extractFontTraits(NSDictionary *attrs, BOOL *isBold, BOOL *isItalic, BOOL *isMonospace)
+{
+  UIFont *font = attrs[NSFontAttributeName];
+  *isBold = NO;
+  *isItalic = NO;
+  *isMonospace = NO;
+
+  if (font) {
+    UIFontDescriptorSymbolicTraits traits = font.fontDescriptor.symbolicTraits;
+    *isBold = (traits & UIFontDescriptorTraitBold) != 0;
+    *isItalic = (traits & UIFontDescriptorTraitItalic) != 0;
+    *isMonospace = (traits & UIFontDescriptorTraitMonoSpace) != 0;
+  }
+}
+
+static NSString *applyInlineFormatting(NSString *text, BOOL isBold, BOOL isItalic, BOOL isMonospace,
+                                       BOOL isStrikethrough, BOOL isUnderline, NSString *linkURL)
+{
+  NSMutableString *result = [NSMutableString stringWithString:text];
+
+  // Innermost first
+  if (isMonospace && !linkURL) {
+    result = [NSMutableString stringWithFormat:@"`%@`", result];
+  }
+  if (isStrikethrough) {
+    result = [NSMutableString stringWithFormat:@"~~%@~~", result];
+  }
+  if (isUnderline && !linkURL) {
+    result = [NSMutableString stringWithFormat:@"<u>%@</u>", result];
+  }
+  if (isItalic) {
+    result = [NSMutableString stringWithFormat:@"*%@*", result];
+  }
+  if (isBold) {
+    result = [NSMutableString stringWithFormat:@"**%@**", result];
+  }
+  if (linkURL) {
+    result = [NSMutableString stringWithFormat:@"[%@](%@)", text, linkURL];
+  }
+
+  return result;
+}
+
+#pragma mark - Main Extraction Function
+
+NSString *_Nullable extractMarkdownFromAttributedString(NSAttributedString *attributedText, NSRange range)
+{
+  if (!attributedText || range.length == 0 || range.location >= attributedText.length) {
+    return nil;
+  }
+
+  range.length = MIN(range.length, attributedText.length - range.location);
+
+  NSMutableString *result = [NSMutableString string];
+
+  // Headings may span multiple attribute runs
+  __block NSString *currentHeadingType = nil;
+  __block NSMutableString *headingContent = nil;
+  __block ExtractionState state = {.blockquoteDepth = -1, .listDepth = -1, .needsBlankLine = NO};
+
+  void (^flushHeading)(void) = ^{
+    if (!currentHeadingType || headingContent.length == 0)
+      return;
+
+    ensureBlankLine(result);
+    NSInteger level = [[currentHeadingType substringFromIndex:8] integerValue];
+    [result appendFormat:@"%@%@\n", buildHeadingPrefix(level), headingContent];
+
+    currentHeadingType = nil;
+    headingContent = nil;
+    state.needsBlankLine = YES;
+  };
+
+  [attributedText
+      enumerateAttributesInRange:range
+                         options:0
+                      usingBlock:^(NSDictionary<NSAttributedStringKey, id> *attrs, NSRange attrRange, BOOL *stop) {
+                        NSString *text = [[attributedText attributedSubstringFromRange:attrRange] string];
+                        if (text.length == 0)
+                          return;
+
+                        // Images and Thematic Breaks
+                        NSTextAttachment *attachment = attrs[NSAttachmentAttributeName];
+                        if ([attachment isKindOfClass:[EnrichedMarkdownImageAttachment class]]) {
+                          EnrichedMarkdownImageAttachment *img = (EnrichedMarkdownImageAttachment *)attachment;
+                          if (!img.imageURL)
+                            return;
+
+                          if (img.isInline) {
+                            [result appendFormat:@"![image](%@)", img.imageURL];
+                          } else {
+                            ensureBlankLine(result);
+                            [result appendFormat:@"![image](%@)\n", img.imageURL];
+                            state.needsBlankLine = YES;
+                            state.blockquoteDepth = -1;
+                            state.listDepth = -1;
+                          }
+                          return;
+                        }
+
+                        if ([attachment isKindOfClass:[ThematicBreakAttachment class]]) {
+                          ensureBlankLine(result);
+                          [result appendString:@"---\n"];
+                          state.needsBlankLine = YES;
+                          state.blockquoteDepth = -1;
+                          state.listDepth = -1;
+                          return;
+                        }
+
+                        if ([text isEqualToString:@"\uFFFC"])
+                          return;
+
+                        // Newlines
+                        if ([text isEqualToString:@"\n"] || [text isEqualToString:@"\n\n"]) {
+                          NSNumber *bqDepth = attrs[BlockquoteDepthAttributeName];
+                          NSNumber *listDepth = attrs[@"ListDepth"];
+                          BOOL inBlockquote = (bqDepth != nil);
+                          BOOL inList = (listDepth != nil);
+
+                          if (!inBlockquote && state.blockquoteDepth >= 0) {
+                            ensureBlankLine(result);
+                            state.blockquoteDepth = -1;
+                            return;
+                          }
+
+                          if (!inList && state.listDepth >= 0) {
+                            ensureBlankLine(result);
+                            state.listDepth = -1;
+                            return;
+                          }
+
+                          if (inBlockquote || inList) {
+                            if (![result hasSuffix:@"\n"]) {
+                              [result appendString:@"\n"];
+                            }
+                            return;
+                          }
+
+                          ensureBlankLine(result);
+                          return;
+                        }
+
+                        // Headings
+                        NSString *markdownType = attrs[MarkdownTypeAttributeName];
+
+                        if (markdownType && [markdownType hasPrefix:@"heading-"]) {
+                          if (![markdownType isEqualToString:currentHeadingType]) {
+                            flushHeading();
+                            currentHeadingType = markdownType;
+                            headingContent = [NSMutableString string];
+                          }
+                          [headingContent
+                              appendString:[text stringByTrimmingCharactersInSet:[NSCharacterSet newlineCharacterSet]]];
+                          return;
+                        } else if (currentHeadingType) {
+                          flushHeading();
+                        }
+
+                        // Code blocks
+                        NSNumber *isCodeBlock = attrs[CodeBlockAttributeName];
+                        if ([isCodeBlock boolValue]) {
+                          if (state.needsBlankLine) {
+                            ensureBlankLine(result);
+                            state.needsBlankLine = NO;
+                          }
+
+                          BOOL needsFence = (result.length == 0) || [result hasSuffix:@"\n\n"];
+                          if (needsFence) {
+                            [result appendString:@"```\n"];
+                          }
+
+                          [result appendString:text];
+
+                          if ([text hasSuffix:@"\n"]) {
+                            [result appendString:@"```\n"];
+                            state.needsBlankLine = YES;
+                          }
+                          return;
+                        }
+
+                        // Blockquotes
+                        NSNumber *bqDepthNum = attrs[BlockquoteDepthAttributeName];
+                        NSInteger currentBqDepth = bqDepthNum ? [bqDepthNum integerValue] : -1;
+                        NSString *blockquotePrefix = nil;
+
+                        if (currentBqDepth >= 0) {
+                          blockquotePrefix = buildBlockquotePrefix(currentBqDepth);
+                          state.blockquoteDepth = currentBqDepth;
+                        } else if (state.blockquoteDepth >= 0) {
+                          ensureBlankLine(result);
+                          state.blockquoteDepth = -1;
+                        }
+
+                        // Lists
+                        NSNumber *listDepthNum = attrs[@"ListDepth"];
+                        NSNumber *listTypeNum = attrs[@"ListType"];
+                        NSNumber *listItemNum = attrs[@"ListItemNumber"];
+                        NSInteger currentListDepth = listDepthNum ? [listDepthNum integerValue] : -1;
+
+                        if (currentListDepth >= 0) {
+                          state.listDepth = currentListDepth;
+                        } else if (state.listDepth >= 0) {
+                          ensureBlankLine(result);
+                          state.listDepth = -1;
+                        }
+
+                        // Inline formatting
+                        BOOL isBold, isItalic, isMonospace;
+                        extractFontTraits(attrs, &isBold, &isItalic, &isMonospace);
+
+                        NSNumber *strikethroughStyle = attrs[NSStrikethroughStyleAttributeName];
+                        BOOL isStrikethrough = (strikethroughStyle != nil && [strikethroughStyle integerValue] != 0);
+                        NSNumber *underlineStyle = attrs[NSUnderlineStyleAttributeName];
+                        BOOL isUnderline = (underlineStyle != nil && [underlineStyle integerValue] != 0);
+
+                        NSString *linkURL = attrs[NSLinkAttributeName];
+                        NSString *segment = applyInlineFormatting(text, isBold, isItalic, isMonospace, isStrikethrough,
+                                                                  isUnderline, linkURL);
+
+                        // Add block prefixes at line start
+                        if (isAtLineStart(result)) {
+                          NSMutableString *prefixedSegment = [NSMutableString string];
+
+                          if (listDepthNum && ![text hasPrefix:@"\n"]) {
+                            BOOL isOrdered = ([listTypeNum integerValue] == 1);
+                            NSInteger itemNumber = listItemNum ? [listItemNum integerValue] : 1;
+                            [prefixedSegment appendString:buildListPrefix(currentListDepth, isOrdered, itemNumber)];
+                          }
+
+                          if (blockquotePrefix) {
+                            [prefixedSegment insertString:blockquotePrefix atIndex:0];
+                          }
+
+                          [prefixedSegment appendString:segment];
+                          segment = prefixedSegment;
+                        }
+
+                        if (state.needsBlankLine && result.length > 0) {
+                          ensureBlankLine(result);
+                          state.needsBlankLine = NO;
+                        }
+
+                        [result appendString:segment];
+                      }];
+
+  // Flush remaining heading
+  if (currentHeadingType && headingContent.length > 0) {
+    ensureBlankLine(result);
+    NSInteger level = [[currentHeadingType substringFromIndex:8] integerValue];
+    [result appendFormat:@"%@%@\n", buildHeadingPrefix(level), headingContent];
+  }
+
+  return result.length > 0 ? result : nil;
+}

package/ios/utils/ParagraphStyleUtils.h

@@ -0,0 +1,21 @@
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+__BEGIN_DECLS
+
+extern NSAttributedString *kNewlineAttributedString;
+
+NSMutableParagraphStyle *getOrCreateParagraphStyle(NSMutableAttributedString *output, NSUInteger index);
+void applyParagraphSpacingAfter(NSMutableAttributedString *output, NSUInteger start, CGFloat marginBottom);
+void applyParagraphSpacingBefore(NSMutableAttributedString *output, NSRange range, CGFloat marginTop);
+NSUInteger applyBlockSpacingBefore(NSMutableAttributedString *output, NSUInteger insertionPoint, CGFloat marginTop);
+void applyBlockSpacingAfter(NSMutableAttributedString *output, CGFloat marginBottom);
+void applyLineHeight(NSMutableAttributedString *output, NSRange range, CGFloat lineHeight);
+void applyTextAlignment(NSMutableAttributedString *output, NSRange range, NSTextAlignment textAlign);
+NSTextAlignment textAlignmentFromString(NSString *textAlign);
+
+__END_DECLS
+
+NS_ASSUME_NONNULL_END

package/ios/utils/ParagraphStyleUtils.m

@@ -0,0 +1,111 @@
+#import "ParagraphStyleUtils.h"
+
+NSAttributedString *kNewlineAttributedString;
+static NSParagraphStyle *kBlockSpacerTemplate;
+
+__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];
+}
+
+NSMutableParagraphStyle *getOrCreateParagraphStyle(NSMutableAttributedString *output, NSUInteger index)
+{
+  NSParagraphStyle *existing = [output attribute:NSParagraphStyleAttributeName atIndex:index effectiveRange:NULL];
+  return existing ? [existing mutableCopy] : [[NSMutableParagraphStyle alloc] init];
+}
+
+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];
+}
+
+void applyParagraphSpacingBefore(NSMutableAttributedString *output, NSRange range, CGFloat marginTop)
+{
+  if (marginTop <= 0) {
+    return;
+  }
+
+  // Note: paragraphSpacingBefore does not work at index 0 in TextKit.
+  // Leading spacing for the first element is handled by renderers via applyBlockSpacingBefore.
+  NSMutableParagraphStyle *style = getOrCreateParagraphStyle(output, range.location);
+  style.paragraphSpacingBefore = marginTop;
+  [output addAttribute:NSParagraphStyleAttributeName value:style range:range];
+}
+
+NSUInteger applyBlockSpacingBefore(NSMutableAttributedString *output, NSUInteger insertionPoint, CGFloat marginTop)
+{
+  if (marginTop <= 0) {
+    return 0;
+  }
+
+  NSMutableParagraphStyle *spacerStyle = [kBlockSpacerTemplate mutableCopy];
+  spacerStyle.paragraphSpacing = marginTop;
+
+  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)];
+}
+
+void applyLineHeight(NSMutableAttributedString *output, NSRange range, CGFloat lineHeight)
+{
+  if (lineHeight <= 0) {
+    return;
+  }
+
+  NSMutableParagraphStyle *style = getOrCreateParagraphStyle(output, range.location);
+
+  style.minimumLineHeight = lineHeight;
+  style.maximumLineHeight = lineHeight;
+
+  [output addAttribute:NSParagraphStyleAttributeName value:style range:range];
+}
+
+void applyTextAlignment(NSMutableAttributedString *output, NSRange range, NSTextAlignment textAlign)
+{
+  NSMutableParagraphStyle *style = getOrCreateParagraphStyle(output, range.location);
+  style.alignment = textAlign;
+  [output addAttribute:NSParagraphStyleAttributeName value:style range:range];
+}
+
+NSTextAlignment textAlignmentFromString(NSString *textAlign)
+{
+  if ([textAlign isEqualToString:@"center"]) {
+    return NSTextAlignmentCenter;
+  } else if ([textAlign isEqualToString:@"right"]) {
+    return NSTextAlignmentRight;
+  } else if ([textAlign isEqualToString:@"justify"]) {
+    return NSTextAlignmentJustified;
+  } else if ([textAlign isEqualToString:@"auto"]) {
+    return NSTextAlignmentNatural;
+  }
+  // Default to left for "left" or any unknown value
+  return NSTextAlignmentLeft;
+}

package/ios/utils/PasteboardUtils.h

@@ -0,0 +1,36 @@
+#pragma once
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+
+@class StyleConfig;
+
+NS_ASSUME_NONNULL_BEGIN
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Copies attributed string to pasteboard with multiple representations
+ * (plain text, Markdown, HTML, RTFD, RTF). Receiving apps pick the richest format they support.
+ */
+void copyAttributedStringToPasteboard(NSAttributedString *attributedString, NSString *_Nullable markdown,
+                                      StyleConfig *_Nullable styleConfig);
+
+/**
+ * Extracts markdown for the given range.
+ * Full selection returns cached markdown; partial selection reverse-engineers from attributes.
+ */
+NSString *_Nullable markdownForRange(NSAttributedString *attributedText, NSRange range,
+                                     NSString *_Nullable cachedMarkdown);
+
+/**
+ * Returns remote image URLs (http/https only) from EnrichedMarkdownImageAttachments 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,134 @@
+#import "PasteboardUtils.h"
+#import "EnrichedMarkdownImageAttachment.h"
+#import "HTMLGenerator.h"
+#import "MarkdownExtractor.h"
+#import "RTFExportUtils.h"
+#import "StyleConfig.h"
+#import <UIKit/UIPasteboard.h>
+
+static NSString *const kUTIPlainText = @"public.utf8-plain-text";
+static NSString *const kUTIMarkdown = @"net.daringfireball.markdown";
+static NSString *const kUTIHTML = @"public.html";
+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[kUTIRTFD] = 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 copyAttributedStringToPasteboard(NSAttributedString *attributedString, NSString *_Nullable markdown,
+                                      StyleConfig *_Nullable styleConfig)
+{
+  if (!attributedString || attributedString.length == 0)
+    return;
+
+  NSMutableDictionary *items = [NSMutableDictionary dictionary];
+
+  items[kUTIPlainText] = attributedString.string;
+
+  if (markdown.length > 0) {
+    items[kUTIMarkdown] = markdown;
+  }
+
+  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);
+
+  [[UIPasteboard generalPasteboard] setItems:@[ items ]];
+}
+
+#pragma mark - Content Extraction
+
+NSString *_Nullable markdownForRange(NSAttributedString *attributedText, NSRange range,
+                                     NSString *_Nullable cachedMarkdown)
+{
+  if (!cachedMarkdown || 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 markdown directly
+  BOOL isFullSelection = (range.location == 0 && range.length >= attributedText.length - 1);
+  if (isFullSelection) {
+    return cachedMarkdown;
+  }
+
+  // Partial selection: reverse-engineer from attributes
+  return extractMarkdownFromAttributedString(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:[EnrichedMarkdownImageAttachment class]])
+                              return;
+
+                            NSString *url = ((EnrichedMarkdownImageAttachment *)value).imageURL;
+                            if ([url hasPrefix:@"http://"] || [url hasPrefix:@"https://"]) {
+                              [urls addObject:url];
+                            }
+                          }];
+
+  return urls;
+}

package/ios/utils/RTFExportUtils.h

@@ -0,0 +1,24 @@
+#pragma once
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+
+@class StyleConfig;
+
+NS_ASSUME_NONNULL_BEGIN
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Prepares NSAttributedString for RTF/RTFD export by adding backgrounds,
+ * inserting text markers (>, •, 1.), and normalizing paragraph styles.
+ */
+NSAttributedString *prepareAttributedStringForRTFExport(NSAttributedString *attributedString,
+                                                        StyleConfig *_Nullable styleConfig);
+
+#ifdef __cplusplus
+}
+#endif
+
+NS_ASSUME_NONNULL_END