react-native-enriched-markdown-scaffold 1.0.2-scaffold.3 → 1.0.2-scaffold.5

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/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

package/ios/utils/ENRMLinkChip.m

@@ -0,0 +1,194 @@
+#import "ENRMLinkChip.h"
+#import "ENRMChipDrawing.h"
+#import <CoreText/CoreText.h>
+
+NSString *const ENRMLinkChipAttributeName = @"ENRMLinkChip";
+NSString *const ENRMLinkSpacerAttributeName = @"ENRMLinkSpacer";
+
+static const unichar kSpacerChar = 0x00A0;
+static const CGFloat kSpacerFontSize = 1.0;
+
+@implementation ENRMLinkChip
+
+- (BOOL)isVisible
+{
+  return self.backgroundColor != nil || (self.borderColor != nil && self.borderWidth > 0);
+}
+
+@end
+
+#pragma mark - Spacers
+
+static CGFloat spacerAdvance(UIFont *font)
+{
+  CTFontRef ctFont = (__bridge CTFontRef)font;
+  UniChar character = kSpacerChar;
+  CGGlyph glyph = 0;
+  if (!CTFontGetGlyphsForCharacters(ctFont, &character, &glyph, 1))
+    return 0;
+  CGSize advance = CGSizeZero;
+  CTFontGetAdvancesForGlyphs(ctFont, kCTFontOrientationHorizontal, &glyph, &advance, 1);
+  return advance.width;
+}
+
+NSAttributedString *ENRMLinkSpacerString(NSDictionary<NSAttributedStringKey, id> *baseAttributes, CGFloat width)
+{
+  static UIFont *spacerFont;
+  static CGFloat spacerFontAdvance;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    spacerFont = [UIFont systemFontOfSize:kSpacerFontSize];
+    spacerFontAdvance = spacerAdvance(spacerFont);
+  });
+
+  NSMutableDictionary *attributes = [baseAttributes mutableCopy] ?: [NSMutableDictionary dictionary];
+  attributes[NSFontAttributeName] = spacerFont;
+  attributes[NSKernAttributeName] = @(width - spacerFontAdvance);
+  attributes[ENRMLinkSpacerAttributeName] = @YES;
+  // Padding is not text: keep decorations and attachments off it.
+  [attributes removeObjectForKey:NSUnderlineStyleAttributeName];
+  [attributes removeObjectForKey:NSStrikethroughStyleAttributeName];
+  [attributes removeObjectForKey:NSAttachmentAttributeName];
+
+  NSString *spacer = [NSString stringWithCharacters:&kSpacerChar length:1];
+  return [[NSAttributedString alloc] initWithString:spacer attributes:attributes];
+}
+
+NSAttributedString *ENRMAttributedStringByRemovingLinkSpacers(NSAttributedString *string)
+{
+  __block NSMutableAttributedString *stripped = nil;
+  [string enumerateAttribute:ENRMLinkSpacerAttributeName
+                     inRange:NSMakeRange(0, string.length)
+                     options:NSAttributedStringEnumerationReverse
+                  usingBlock:^(id value, NSRange range, BOOL *stop) {
+                    if (!value)
+                      return;
+                    if (!stripped)
+                      stripped = [string mutableCopy];
+                    [stripped deleteCharactersInRange:range];
+                  }];
+  return stripped ?: string;
+}
+
+NSString *ENRMPlainTextByRemovingLinkSpacers(NSAttributedString *string, NSRange range)
+{
+  if (range.location == NSNotFound || NSMaxRange(range) > string.length)
+    return @"";
+  return ENRMAttributedStringByRemovingLinkSpacers([string attributedSubstringFromRange:range]).string;
+}
+
+void ENRMApplyLinkChipBackgroundsAsTextBackground(NSMutableAttributedString *string)
+{
+  [string enumerateAttribute:ENRMLinkChipAttributeName
+                     inRange:NSMakeRange(0, string.length)
+                     options:0
+                  usingBlock:^(ENRMLinkChip *chip, NSRange range, BOOL *stop) {
+                    if (chip.backgroundColor) {
+                      [string addAttribute:NSBackgroundColorAttributeName value:chip.backgroundColor range:range];
+                    }
+                  }];
+}
+
+#pragma mark - Geometry
+
+/// The font of the first non-spacer character of `charRange` — the spacer's
+/// 1pt font must not drive the chip's height.
+static UIFont *_Nullable chipFontInRange(NSTextStorage *storage, NSRange charRange)
+{
+  __block UIFont *font = nil;
+  [storage enumerateAttributesInRange:charRange
+                              options:0
+                           usingBlock:^(NSDictionary<NSAttributedStringKey, id> *attrs, NSRange range, BOOL *stop) {
+                             if (attrs[ENRMLinkSpacerAttributeName])
+                               return;
+                             font = attrs[NSFontAttributeName];
+                             *stop = font != nil;
+                           }];
+  return font;
+}
+
+void ENRMEnumerateLinkChipFragments(NSLayoutManager *layoutManager, NSTextContainer *textContainer, NSRange charRange,
+                                    ENRMLinkChip *chip, void (^block)(CGRect rect, BOOL isFirst, BOOL isLast))
+{
+  NSTextStorage *storage = layoutManager.textStorage;
+  if (charRange.length == 0 || NSMaxRange(charRange) > storage.length)
+    return;
+
+  NSRange glyphRange = [layoutManager glyphRangeForCharacterRange:charRange actualCharacterRange:NULL];
+  if (glyphRange.location == NSNotFound || glyphRange.length == 0)
+    return;
+
+  CGFloat paddingHorizontal = chip.paddingHorizontal;
+  CGFloat paddingVertical = chip.paddingVertical;
+
+  [layoutManager
+      enumerateLineFragmentsForGlyphRange:glyphRange
+                               usingBlock:^(CGRect lineRect, CGRect usedRect, NSTextContainer *tc, NSRange lineRange,
+                                            BOOL *stop) {
+                                 NSRange intersect = NSIntersectionRange(lineRange, glyphRange);
+                                 if (intersect.length == 0)
+                                   return;
+
+                                 BOOL isFirst = intersect.location == glyphRange.location;
+                                 BOOL isLast = NSMaxRange(intersect) == NSMaxRange(glyphRange);
+
+                                 CGRect textRect = [layoutManager boundingRectForGlyphRange:intersect
+                                                                            inTextContainer:textContainer];
+                                 CGFloat left = CGRectGetMinX(textRect);
+                                 CGFloat right = CGRectGetMaxX(textRect);
+
+                                 // The trailing spacer's kern is its advance; don't rely on the
+                                 // glyph bounds including it.
+                                 if (isLast && paddingHorizontal > 0) {
+                                   NSUInteger lastGlyph = NSMaxRange(intersect) - 1;
+                                   CGFloat spacerX =
+                                       lineRect.origin.x + [layoutManager locationForGlyphAtIndex:lastGlyph].x;
+                                   right = MAX(right, spacerX + paddingHorizontal);
+                                 }
+
+                                 NSRange fragmentChars = [layoutManager characterRangeForGlyphRange:intersect
+                                                                                   actualGlyphRange:NULL];
+                                 UIFont *font = chipFontInRange(storage, fragmentChars);
+                                 CGFloat top = CGRectGetMinY(textRect);
+                                 CGFloat bottom = CGRectGetMaxY(textRect);
+                                 if (font) {
+                                   // locationForGlyphAtIndex: y is the baseline within the line fragment.
+                                   CGFloat baseline =
+                                       lineRect.origin.y + [layoutManager locationForGlyphAtIndex:intersect.location].y;
+                                   top = baseline - font.ascender;
+                                   bottom = baseline - font.descender;
+                                 }
+                                 top -= paddingVertical;
+                                 bottom += paddingVertical;
+
+                                 block(CGRectMake(left, top, right - left, bottom - top), isFirst, isLast);
+                               }];
+}
+
+#pragma mark - Drawing
+
+void ENRMDrawLinkChipsForGlyphRange(NSLayoutManager *layoutManager, NSTextContainer *textContainer,
+                                    NSRange glyphsToShow, CGPoint origin)
+{
+  NSTextStorage *storage = layoutManager.textStorage;
+  NSRange charRange = [layoutManager characterRangeForGlyphRange:glyphsToShow actualGlyphRange:NULL];
+  if (charRange.location == NSNotFound || charRange.length == 0)
+    return;
+
+  // Enumerate the whole storage (like CodeBackground) so a chip that starts
+  // before the dirty range still gets its full rect.
+  [storage
+      enumerateAttribute:ENRMLinkChipAttributeName
+                 inRange:NSMakeRange(0, storage.length)
+                 options:0
+              usingBlock:^(ENRMLinkChip *chip, NSRange range, BOOL *stop) {
+                if (!chip.isVisible || NSIntersectionRange(range, charRange).length == 0)
+                  return;
+
+                ENRMEnumerateLinkChipFragments(
+                    layoutManager, textContainer, range, chip, ^(CGRect rect, BOOL isFirst, BOOL isLast) {
+                      ENRMDrawChipFragment(CGRectOffset(rect, origin.x, origin.y), chip.backgroundColor,
+                                           chip.borderColor, chip.borderWidth, chip.borderRadius, isFirst, isLast, YES);
+                    });
+              }];
+}