react-native-enriched-markdown-scaffold 1.0.2-scaffold.2 → 1.0.2-scaffold.4

package/ios/renderer/LinkRenderer.m

@@ -1,4 +1,5 @@
 #import "LinkRenderer.h"
+#import "ENRMLinkChip.h"
 #import "FontUtils.h"
 #import "RenderContext.h"
 #import "RendererFactory.h"
@@ -13,31 +14,49 @@
                      into:(NSMutableAttributedString *)output
                   context:(RenderContext *)context
 {
-  NSUInteger start = output.length;
-
-  // 1. Render children first to establish base attributes
-  [_rendererFactory renderChildrenOfNode:node into:output context:context];
-
-  NSRange range = NSMakeRange(start, output.length - start);
-  if (range.length == 0)
-    return;
-
-  // 2. Extract configuration
+  // 1. Extract configuration
   NSString *url = node.attributes[@"url"] ?: @"";
   LinkVariantConfig *variant = [_config effectiveLinkVariantForURL:url];
 
   RCTUIColor *linkColor = variant.color ?: [_config linkColor];
   BOOL linkUnderline = variant ? variant.underline : [_config linkUnderline];
   NSString *linkFontFamily = [_config linkFontFamily];
-  RCTUIColor *backgroundColor = variant ? variant.backgroundColor : [_config linkBackgroundColor];
+  // Chip ("box") properties never fall back to the base link style.
+  ENRMLinkChip *chip = [[ENRMLinkChip alloc] init];
+  chip.backgroundColor = variant ? variant.backgroundColor : [_config linkBackgroundColor];
+  chip.borderColor = variant ? variant.borderColor : [_config linkBorderColor];
+  chip.borderWidth = variant ? variant.borderWidth : [_config linkBorderWidth];
+  chip.borderRadius = variant ? variant.borderRadius : [_config linkBorderRadius];
+  chip.paddingHorizontal = variant ? variant.paddingHorizontal : [_config linkPaddingHorizontal];
+  chip.paddingVertical = variant ? variant.paddingVertical : [_config linkPaddingVertical];
+  BOOL hasSpacers = chip.paddingHorizontal > 0;
 
   NSNumber *underlineStyle = @(linkUnderline ? NSUnderlineStyleSingle : NSUnderlineStyleNone);
 
+  // 2. Render children to establish base attributes. With horizontal padding, a
+  // leading spacer goes in first so ranges the children register stay valid;
+  // its attributes are fixed up once the first child glyph exists.
+  NSUInteger start = output.length;
+  if (hasSpacers) {
+    [output appendAttributedString:ENRMLinkSpacerString([context getTextAttributes], chip.paddingHorizontal)];
+  }
+  NSUInteger contentStart = output.length;
+
+  [_rendererFactory renderChildrenOfNode:node into:output context:context];
+
+  NSRange contentRange = NSMakeRange(contentStart, output.length - contentStart);
+  if (contentRange.length == 0) {
+    if (hasSpacers) {
+      [output deleteCharactersInRange:NSMakeRange(start, contentStart - start)];
+    }
+    return;
+  }
+
   // 3. Apply core link functionality (non-destructive)
-  [output addAttribute:NSLinkAttributeName value:url range:range];
+  [output addAttribute:NSLinkAttributeName value:url range:contentRange];
 
   // 4. Optimize visual attributes via enumeration to avoid redundant updates
-  [output enumerateAttributesInRange:range
+  [output enumerateAttributesInRange:contentRange
                              options:NSAttributedStringEnumerationLongestEffectiveRangeNotRequired
                           usingBlock:^(NSDictionary<NSAttributedStringKey, id> *attrs, NSRange subrange, BOOL *stop) {
                             NSMutableDictionary *newAttributes = [NSMutableDictionary dictionary];
@@ -74,10 +93,23 @@
                             }
                           }];
 
-  if (backgroundColor) {
-    [output addAttribute:NSBackgroundColorAttributeName value:backgroundColor range:range];
+  // 5. Reserve horizontal padding with a spacer at each outer edge (see
+  // ENRMLinkSpacerString). Spacers sit inside the link range, so tapping the
+  // padding hits the link.
+  NSRange range = contentRange;
+  if (hasSpacers) {
+    NSDictionary *firstAttrs = [output attributesAtIndex:contentRange.location effectiveRange:NULL];
+    NSDictionary *lastAttrs = [output attributesAtIndex:NSMaxRange(contentRange) - 1 effectiveRange:NULL];
+    NSAttributedString *leading = ENRMLinkSpacerString(firstAttrs, chip.paddingHorizontal);
+    [output setAttributes:[leading attributesAtIndex:0 effectiveRange:NULL] range:NSMakeRange(start, 1)];
+    [output appendAttributedString:ENRMLinkSpacerString(lastAttrs, chip.paddingHorizontal)];
+    range = NSMakeRange(start, output.length - start);
   }
 
+  // 6. Chip background/border is drawn by the layout manager (see ENRMLinkChip).
+  // Attached even when invisible so the chip's padding is known to link-layout reporting.
+  [output addAttribute:ENRMLinkChipAttributeName value:chip range:range];
+
   [context registerLinkRange:range url:url];
 }
 

package/ios/styles/StyleConfig.h

@@ -13,6 +13,12 @@ NS_ASSUME_NONNULL_BEGIN
 @property (nonatomic, strong) RCTUIColor *color;
 @property (nonatomic, assign) BOOL underline;
 @property (nonatomic, strong, nullable) RCTUIColor *backgroundColor;
+// Chip ("box") properties — never inherited from the base link style.
+@property (nonatomic, assign) CGFloat borderRadius;
+@property (nonatomic, assign) CGFloat paddingHorizontal;
+@property (nonatomic, assign) CGFloat paddingVertical;
+@property (nonatomic, strong, nullable) RCTUIColor *borderColor;
+@property (nonatomic, assign) CGFloat borderWidth;
 @end
 
 @interface StyleConfig : NSObject <NSCopying>
@@ -166,6 +172,16 @@ NS_ASSUME_NONNULL_BEGIN
 - (void)setLinkUnderline:(BOOL)newValue;
 - (nullable RCTUIColor *)linkBackgroundColor;
 - (void)setLinkBackgroundColor:(nullable RCTUIColor *)newValue;
+- (CGFloat)linkBorderRadius;
+- (void)setLinkBorderRadius:(CGFloat)newValue;
+- (CGFloat)linkPaddingHorizontal;
+- (void)setLinkPaddingHorizontal:(CGFloat)newValue;
+- (CGFloat)linkPaddingVertical;
+- (void)setLinkPaddingVertical:(CGFloat)newValue;
+- (nullable RCTUIColor *)linkBorderColor;
+- (void)setLinkBorderColor:(nullable RCTUIColor *)newValue;
+- (CGFloat)linkBorderWidth;
+- (void)setLinkBorderWidth:(CGFloat)newValue;
 - (NSArray<LinkVariantConfig *> *)linkVariants;
 - (void)setLinkVariants:(NSArray<LinkVariantConfig *> *)newValue;
 - (nullable LinkVariantConfig *)effectiveLinkVariantForURL:(NSString *)url;

package/ios/styles/StyleConfig.mm

@@ -113,6 +113,11 @@ static inline NSString *normalizedFontWeight(NSString *fontWeight)
   RCTUIColor *_linkColor;
   BOOL _linkUnderline;
   RCTUIColor *_linkBackgroundColor;
+  CGFloat _linkBorderRadius;
+  CGFloat _linkPaddingHorizontal;
+  CGFloat _linkPaddingVertical;
+  RCTUIColor *_linkBorderColor;
+  CGFloat _linkBorderWidth;
   NSArray<LinkVariantConfig *> *_linkVariants;
   NSArray<LinkVariantRegexEntry *> *_compiledVariantRegexes;
   // Strong properties
@@ -405,6 +410,11 @@ static inline NSString *normalizedFontWeight(NSString *fontWeight)
   copy->_linkColor = [_linkColor copy];
   copy->_linkUnderline = _linkUnderline;
   copy->_linkBackgroundColor = [_linkBackgroundColor copy];
+  copy->_linkBorderRadius = _linkBorderRadius;
+  copy->_linkPaddingHorizontal = _linkPaddingHorizontal;
+  copy->_linkPaddingVertical = _linkPaddingVertical;
+  copy->_linkBorderColor = [_linkBorderColor copy];
+  copy->_linkBorderWidth = _linkBorderWidth;
   copy->_linkVariants = [_linkVariants copy];
   copy->_compiledVariantRegexes = [_compiledVariantRegexes copy];
   copy->_strongFontFamily = [_strongFontFamily copy];
@@ -1334,6 +1344,56 @@ static inline NSString *normalizedFontWeight(NSString *fontWeight)
   _linkBackgroundColor = newValue;
 }
 
+- (CGFloat)linkBorderRadius
+{
+  return _linkBorderRadius;
+}
+
+- (void)setLinkBorderRadius:(CGFloat)newValue
+{
+  _linkBorderRadius = newValue;
+}
+
+- (CGFloat)linkPaddingHorizontal
+{
+  return _linkPaddingHorizontal;
+}
+
+- (void)setLinkPaddingHorizontal:(CGFloat)newValue
+{
+  _linkPaddingHorizontal = newValue;
+}
+
+- (CGFloat)linkPaddingVertical
+{
+  return _linkPaddingVertical;
+}
+
+- (void)setLinkPaddingVertical:(CGFloat)newValue
+{
+  _linkPaddingVertical = newValue;
+}
+
+- (RCTUIColor *)linkBorderColor
+{
+  return _linkBorderColor;
+}
+
+- (void)setLinkBorderColor:(RCTUIColor *)newValue
+{
+  _linkBorderColor = newValue;
+}
+
+- (CGFloat)linkBorderWidth
+{
+  return _linkBorderWidth;
+}
+
+- (void)setLinkBorderWidth:(CGFloat)newValue
+{
+  _linkBorderWidth = newValue;
+}
+
 - (NSArray<LinkVariantConfig *> *)linkVariants
 {
   return _linkVariants;

package/ios/utils/CodeBackground.m

@@ -1,4 +1,5 @@
 #import "CodeBackground.h"
+#import "ENRMChipDrawing.h"
 #import "ENRMUIKit.h"
 #import "RenderContext.h"
 
@@ -116,71 +117,8 @@ static const CGFloat kCodeBackgroundBorderWidth = 0.5;
                          isFirst:(BOOL)isFirst
                           isLast:(BOOL)isLast
 {
-  UIBezierPath *path = [self pathForRect:rect isFirst:isFirst isLast:isLast];
-  [backgroundColor setFill];
-  [path fill];
-
-  if (borderColor) {
-    [borderColor setStroke];
-    UIBezierPath *strokePath =
-        (isFirst && isLast) ? path : [self openBorderPathForRect:rect isFirst:isFirst isLast:isLast];
-    strokePath.lineWidth = kCodeBackgroundBorderWidth;
-    BezierPathSetRoundStyle(strokePath);
-    [strokePath stroke];
-  }
-}
-
-- (UIBezierPath *)pathForRect:(CGRect)rect isFirst:(BOOL)isFirst isLast:(BOOL)isLast
-{
-#if !TARGET_OS_OSX
-  UIRectCorner corners = 0;
-  if (isFirst)
-    corners |= (UIRectCornerTopLeft | UIRectCornerBottomLeft);
-  if (isLast)
-    corners |= (UIRectCornerTopRight | UIRectCornerBottomRight);
-
-  return [UIBezierPath bezierPathWithRoundedRect:rect
-                               byRoundingCorners:corners
-                                     cornerRadii:CGSizeMake(kCodeBackgroundCornerRadius, kCodeBackgroundCornerRadius)];
-#else
-  // NSBezierPath doesn't support per-corner rounding — use uniform corner radius
-  CGFloat cornerRadius = (isFirst || isLast) ? kCodeBackgroundCornerRadius : 0;
-  return UIBezierPathWithRoundedRect(rect, cornerRadius);
-#endif
-}
-
-- (UIBezierPath *)openBorderPathForRect:(CGRect)rect isFirst:(BOOL)isFirst isLast:(BOOL)isLast
-{
-  UIBezierPath *path = [UIBezierPath bezierPath];
-  CGFloat r = kCodeBackgroundCornerRadius;
-  CGFloat inset = kCodeBackgroundBorderWidth / 2.0;
-  CGRect insetRect = CGRectInset(rect, inset, inset);
-
-  if (isFirst) {
-    [path moveToPoint:CGPointMake(CGRectGetMaxX(rect), insetRect.origin.y)];
-    BezierPathAddLine(path, CGPointMake(insetRect.origin.x + r, insetRect.origin.y));
-    BezierPathAddQuadCurve(path, CGPointMake(insetRect.origin.x, insetRect.origin.y + r),
-                           CGPointMake(insetRect.origin.x, insetRect.origin.y));
-    BezierPathAddLine(path, CGPointMake(insetRect.origin.x, CGRectGetMaxY(insetRect) - r));
-    BezierPathAddQuadCurve(path, CGPointMake(insetRect.origin.x + r, CGRectGetMaxY(insetRect)),
-                           CGPointMake(insetRect.origin.x, CGRectGetMaxY(insetRect)));
-    BezierPathAddLine(path, CGPointMake(CGRectGetMaxX(rect), CGRectGetMaxY(insetRect)));
-  } else if (isLast) {
-    [path moveToPoint:CGPointMake(rect.origin.x, insetRect.origin.y)];
-    BezierPathAddLine(path, CGPointMake(CGRectGetMaxX(insetRect) - r, insetRect.origin.y));
-    BezierPathAddQuadCurve(path, CGPointMake(CGRectGetMaxX(insetRect), insetRect.origin.y + r),
-                           CGPointMake(CGRectGetMaxX(insetRect), insetRect.origin.y));
-    BezierPathAddLine(path, CGPointMake(CGRectGetMaxX(insetRect), CGRectGetMaxY(insetRect) - r));
-    BezierPathAddQuadCurve(path, CGPointMake(CGRectGetMaxX(insetRect) - r, CGRectGetMaxY(insetRect)),
-                           CGPointMake(CGRectGetMaxX(insetRect), CGRectGetMaxY(insetRect)));
-    BezierPathAddLine(path, CGPointMake(rect.origin.x, CGRectGetMaxY(insetRect)));
-  } else {
-    [path moveToPoint:CGPointMake(rect.origin.x, insetRect.origin.y)];
-    BezierPathAddLine(path, CGPointMake(CGRectGetMaxX(rect), insetRect.origin.y));
-    [path moveToPoint:CGPointMake(rect.origin.x, CGRectGetMaxY(insetRect))];
-    BezierPathAddLine(path, CGPointMake(CGRectGetMaxX(rect), CGRectGetMaxY(insetRect)));
-  }
-  return path;
+  ENRMDrawChipFragment(rect, backgroundColor, borderColor, kCodeBackgroundBorderWidth, kCodeBackgroundCornerRadius,
+                       isFirst, isLast, NO);
 }
 
 #pragma mark - Helpers

package/ios/utils/ENRMBlockMenu.h

@@ -18,20 +18,29 @@ typedef struct {
   BOOL copyAsMarkdownHidden;
   // `selectionMenuConfig.codeBlockCopyButton.enabled == false`.
   BOOL copyButtonHidden;
+  // JS `onCopy` is set: the Copy item hands the block's content to the view's
+  // `onCopyRequest` instead of writing the pasteboard.
+  BOOL interceptCopy;
 } ENRMBlockMenuOptions;
 
+/// Receives an intercepted block Copy: the block's Markdown and its raw content.
+typedef void (^ENRMBlockCopyRequestBlock)(NSString *markdown, NSString *text);
+
 #if !TARGET_OS_OSX
 /// Builds the long-press menu shared by the table, math and code block views.
 /// Returns nil when no item is left — nil is how UIKit suppresses a context
-/// menu, whereas an empty menu would still lift the view.
+/// menu, whereas an empty menu would still lift the view. `requestCopy` replaces
+/// the Copy item's handler when `options.interceptCopy` is set.
 static inline UIContextMenuConfiguration *_Nullable ENRMBlockContextMenuConfiguration(
     ENRMBlockMenuOptions options, NSString *_Nullable copyLabel, NSString *_Nullable copyAsMarkdownLabel,
-    void (^copyRaw)(void), void (^copyMarkdown)(void))
+    void (^copyRaw)(void), void (^copyMarkdown)(void), void (^_Nullable requestCopy)(void))
 {
   if (options.copyHidden && options.copyAsMarkdownHidden) {
     return nil;
   }
-  void (^copyHandler)(void) = options.copyWritesMarkdown ? copyMarkdown : copyRaw;
+  void (^copyHandler)(void) = (options.interceptCopy && requestCopy) ? requestCopy
+                              : options.copyWritesMarkdown           ? copyMarkdown
+                                                                     : copyRaw;
   return [UIContextMenuConfiguration
       configurationWithIdentifier:nil
                   previewProvider:nil

package/ios/utils/ENRMChipDrawing.h

@@ -0,0 +1,24 @@
+#pragma once
+#import "ENRMUIKit.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// Fills (and optionally strokes) one line fragment of an inline "chip" — the
+/// rounded background shared by inline code and link chips. For a chip that
+/// wraps, only the outer ends are rounded (`isFirst` / `isLast`) and the border
+/// stays open where the fragment is cut.
+///
+/// `strokeInset` keeps a closed border inside `rect` (link chips); otherwise it
+/// is centered on the edge (inline code, kept for pixel parity).
+void ENRMDrawChipFragment(CGRect rect, RCTUIColor *_Nullable backgroundColor, RCTUIColor *_Nullable borderColor,
+                          CGFloat borderWidth, CGFloat cornerRadius, BOOL isFirst, BOOL isLast, BOOL strokeInset);
+
+#ifdef __cplusplus
+}
+#endif
+
+NS_ASSUME_NONNULL_END

package/ios/utils/ENRMChipDrawing.m

@@ -0,0 +1,83 @@
+#import "ENRMChipDrawing.h"
+
+static UIBezierPath *chipFillPath(CGRect rect, CGFloat r, BOOL isFirst, BOOL isLast)
+{
+#if !TARGET_OS_OSX
+  UIRectCorner corners = 0;
+  if (isFirst)
+    corners |= (UIRectCornerTopLeft | UIRectCornerBottomLeft);
+  if (isLast)
+    corners |= (UIRectCornerTopRight | UIRectCornerBottomRight);
+
+  return [UIBezierPath bezierPathWithRoundedRect:rect byRoundingCorners:corners cornerRadii:CGSizeMake(r, r)];
+#else
+  // NSBezierPath doesn't support per-corner rounding — use uniform corner radius
+  return UIBezierPathWithRoundedRect(rect, (isFirst || isLast) ? r : 0);
+#endif
+}
+
+static UIBezierPath *chipOpenBorderPath(CGRect rect, CGFloat r, CGFloat borderWidth, BOOL isFirst, BOOL isLast)
+{
+  UIBezierPath *path = [UIBezierPath bezierPath];
+  CGFloat inset = borderWidth / 2.0;
+  CGRect insetRect = CGRectInset(rect, inset, inset);
+
+  if (isFirst) {
+    [path moveToPoint:CGPointMake(CGRectGetMaxX(rect), insetRect.origin.y)];
+    BezierPathAddLine(path, CGPointMake(insetRect.origin.x + r, insetRect.origin.y));
+    BezierPathAddQuadCurve(path, CGPointMake(insetRect.origin.x, insetRect.origin.y + r),
+                           CGPointMake(insetRect.origin.x, insetRect.origin.y));
+    BezierPathAddLine(path, CGPointMake(insetRect.origin.x, CGRectGetMaxY(insetRect) - r));
+    BezierPathAddQuadCurve(path, CGPointMake(insetRect.origin.x + r, CGRectGetMaxY(insetRect)),
+                           CGPointMake(insetRect.origin.x, CGRectGetMaxY(insetRect)));
+    BezierPathAddLine(path, CGPointMake(CGRectGetMaxX(rect), CGRectGetMaxY(insetRect)));
+  } else if (isLast) {
+    [path moveToPoint:CGPointMake(rect.origin.x, insetRect.origin.y)];
+    BezierPathAddLine(path, CGPointMake(CGRectGetMaxX(insetRect) - r, insetRect.origin.y));
+    BezierPathAddQuadCurve(path, CGPointMake(CGRectGetMaxX(insetRect), insetRect.origin.y + r),
+                           CGPointMake(CGRectGetMaxX(insetRect), insetRect.origin.y));
+    BezierPathAddLine(path, CGPointMake(CGRectGetMaxX(insetRect), CGRectGetMaxY(insetRect) - r));
+    BezierPathAddQuadCurve(path, CGPointMake(CGRectGetMaxX(insetRect) - r, CGRectGetMaxY(insetRect)),
+                           CGPointMake(CGRectGetMaxX(insetRect), CGRectGetMaxY(insetRect)));
+    BezierPathAddLine(path, CGPointMake(rect.origin.x, CGRectGetMaxY(insetRect)));
+  } else {
+    [path moveToPoint:CGPointMake(rect.origin.x, insetRect.origin.y)];
+    BezierPathAddLine(path, CGPointMake(CGRectGetMaxX(rect), insetRect.origin.y));
+    [path moveToPoint:CGPointMake(rect.origin.x, CGRectGetMaxY(insetRect))];
+    BezierPathAddLine(path, CGPointMake(CGRectGetMaxX(rect), CGRectGetMaxY(insetRect)));
+  }
+  return path;
+}
+
+void ENRMDrawChipFragment(CGRect rect, RCTUIColor *backgroundColor, RCTUIColor *borderColor, CGFloat borderWidth,
+                          CGFloat cornerRadius, BOOL isFirst, BOOL isLast, BOOL strokeInset)
+{
+  if (CGRectIsEmpty(rect))
+    return;
+
+  CGFloat r = MIN(MAX(cornerRadius, 0), MIN(rect.size.width, rect.size.height) / 2.0);
+
+  if (backgroundColor) {
+    [backgroundColor setFill];
+    [chipFillPath(rect, r, isFirst, isLast) fill];
+  }
+
+  if (!borderColor || borderWidth <= 0)
+    return;
+
+  [borderColor setStroke];
+  UIBezierPath *strokePath;
+  if (isFirst && isLast) {
+    if (strokeInset) {
+      CGFloat inset = borderWidth / 2.0;
+      strokePath = chipFillPath(CGRectInset(rect, inset, inset), MAX(r - inset, 0), YES, YES);
+    } else {
+      strokePath = chipFillPath(rect, r, YES, YES);
+    }
+  } else {
+    strokePath = chipOpenBorderPath(rect, r, borderWidth, isFirst, isLast);
+  }
+  strokePath.lineWidth = borderWidth;
+  BezierPathSetRoundStyle(strokePath);
+  [strokePath stroke];
+}

package/ios/utils/ENRMLinkChip.h

@@ -0,0 +1,70 @@
+#pragma once
+#import "ENRMUIKit.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Marks a link range that carries chip styling. The value is one
+/// `ENRMLinkChip` instance per link: instances compare by identity, so two
+/// adjacent links never coalesce into one attribute run (one chip).
+extern NSString *const ENRMLinkChipAttributeName;
+
+/// Marks the spacer characters `LinkRenderer` inserts at both outer edges of a
+/// link to reserve `paddingHorizontal` in the line. Spacers are layout-only:
+/// every text exit point (copy, markdown/HTML export, decoration text) strips
+/// them by this attribute — never by character, since U+00A0 can be content.
+extern NSString *const ENRMLinkSpacerAttributeName;
+
+@interface ENRMLinkChip : NSObject
+@property (nonatomic, strong, nullable) RCTUIColor *backgroundColor;
+@property (nonatomic, strong, nullable) RCTUIColor *borderColor;
+@property (nonatomic, assign) CGFloat borderWidth;
+@property (nonatomic, assign) CGFloat borderRadius;
+@property (nonatomic, assign) CGFloat paddingHorizontal;
+@property (nonatomic, assign) CGFloat paddingVertical;
+/// YES when the chip paints something (a background or a visible border).
+@property (nonatomic, readonly) BOOL isVisible;
+@end
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// A spacer character (U+00A0) whose advance is exactly `width`.
+///
+/// U+00A0 is line-break class GL: a break is allowed before it after a space
+/// but never after it, and never before it after a non-space — so a leading
+/// spacer always travels with the link's first glyph and a trailing one with
+/// its last glyph (no orphaned padding at a wrap). It uses a 1pt system font
+/// so its own advance and line-height contribution are negligible whatever
+/// the link font (a custom font may lack U+00A0), and NSKern makes up the rest.
+NSAttributedString *ENRMLinkSpacerString(NSDictionary<NSAttributedStringKey, id> *baseAttributes, CGFloat width);
+
+/// `string` without link spacers (returns `string` itself when it has none).
+NSAttributedString *ENRMAttributedStringByRemovingLinkSpacers(NSAttributedString *string);
+
+/// Plain text of `range` without link spacers.
+NSString *ENRMPlainTextByRemovingLinkSpacers(NSAttributedString *string, NSRange range);
+
+/// Falls back to a plain `NSBackgroundColorAttributeName` for every chip
+/// background, for text drawn without `TextViewLayoutManager` (table cells,
+/// RTF export). Radius, border and vertical padding are not represented.
+void ENRMApplyLinkChipBackgroundsAsTextBackground(NSMutableAttributedString *string);
+
+/// Enumerates the chip rect of every laid-out line fragment of the link at
+/// `charRange`, in text-container coordinates. The rect spans the glyphs
+/// (spacers included, so it already covers `paddingHorizontal`) horizontally
+/// and the link font's ascender..descender ± `paddingVertical` vertically.
+void ENRMEnumerateLinkChipFragments(NSLayoutManager *layoutManager, NSTextContainer *textContainer, NSRange charRange,
+                                    ENRMLinkChip *_Nullable chip,
+                                    void (^block)(CGRect rect, BOOL isFirst, BOOL isLast));
+
+/// Draws the visible link chips intersecting `glyphsToShow`. Called from the
+/// layout manager's background pass, before glyphs are drawn.
+void ENRMDrawLinkChipsForGlyphRange(NSLayoutManager *layoutManager, NSTextContainer *textContainer,
+                                    NSRange glyphsToShow, CGPoint origin);
+
+#ifdef __cplusplus
+}
+#endif
+
+NS_ASSUME_NONNULL_END