react-native-enriched-markdown-scaffold 0.7.4-scaffold.8 → 1.0.2-scaffold.1

package/ios/input/ENRMBlockStore.h

@@ -0,0 +1,56 @@
+#pragma once
+
+#import "ENRMBlockRange.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Stores the block-level (paragraph-scoped) ranges for the editor, mirroring
+/// ENRMFormattingStore. Unlike inline ranges, block ranges never overlap: at
+/// most one block covers any given paragraph, and ranges are kept normalized to
+/// whole-line boundaries.
+@interface ENRMBlockStore : NSObject
+
+@property (nonatomic, readonly) NSArray<ENRMBlockRange *> *allRanges;
+
+/// Returns the block whose paragraph starts exactly at `location`, or nil.
+/// Ranges are kept sorted by start, so this is an O(log n) binary search — the
+/// single lookup callers use instead of linearly scanning `allRanges`. Relies on
+/// the one-block-per-paragraph invariant (paragraph starts are unique).
+- (nullable ENRMBlockRange *)blockStartingAtLocation:(NSUInteger)location;
+
+- (void)setRanges:(NSArray<ENRMBlockRange *> *)ranges;
+- (void)clearAll;
+
+/// Sets/replaces the block on every paragraph the given range touches, expanding
+/// to whole-line boundaries within `text`. Removes any block previously covering
+/// those paragraphs.
+- (void)setBlockType:(ENRMInputBlockType)type
+                level:(NSInteger)level
+    forParagraphRange:(NSRange)range
+               inText:(NSString *)text;
+
+/// Clears any block on the paragraphs the given range touches (reverting them to
+/// the implicit paragraph default).
+- (void)removeBlockInParagraphRange:(NSRange)range inText:(NSString *)text;
+
+/// Shifts/clips block ranges to follow a text edit (shared
+/// ENRMRangeEditAdjustment classification), with heading persistence: a heading
+/// deleted exactly to its end collapses to a zero-length anchor at the edit
+/// location (its line survives), and existing anchors shift/keep/drop with
+/// their line.
+- (void)adjustForEditAtLocation:(NSUInteger)location
+                  deletedLength:(NSUInteger)deletedLength
+                 insertedLength:(NSUInteger)insertedLength;
+
+/// Snaps every stored range to the line bounds of its start position.
+/// Absorbs edge-typed chars, clips split ranges to first line, drops
+/// duplicates. On an empty line a heading persists as a zero-length anchor;
+/// any other collapsed range is dropped. List depths are clamped so an item
+/// nests at most one level under the previous adjacent item (CommonMark cannot
+/// represent orphan nesting). Call after adjustForEditAtLocation: once text is
+/// final. Idempotent.
+- (void)normalizeToLineBoundsInText:(NSString *)text;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/input/ENRMBlockStore.mm

@@ -0,0 +1,275 @@
+#import "ENRMBlockStore.h"
+#import "ENRMRangeEditAdjustment.h"
+#import "ENRMRangeStoreUtils.h"
+
+/// Expands a selection to cover whole paragraphs (line-scoped block boundaries).
+/// Clamps unconditionally so out-of-bounds input can't reach
+/// paragraphRangeForRange: (which raises on an invalid range).
+static NSRange paragraphBoundsForRange(NSRange range, NSString *text)
+{
+  if (text.length == 0) {
+    return NSMakeRange(0, 0);
+  }
+  NSUInteger location = MIN(range.location, text.length);
+  NSUInteger length = MIN(range.length, text.length - location);
+  return [text paragraphRangeForRange:NSMakeRange(location, length)];
+}
+
+@implementation ENRMBlockStore {
+  NSMutableArray<ENRMBlockRange *> *_ranges;
+}
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _ranges = [NSMutableArray array];
+  }
+  return self;
+}
+
+- (NSArray<ENRMBlockRange *> *)allRanges
+{
+  return [_ranges copy];
+}
+
+- (nullable ENRMBlockRange *)blockStartingAtLocation:(NSUInteger)location
+{
+  NSInteger lo = 0;
+  NSInteger hi = (NSInteger)_ranges.count - 1;
+  while (lo <= hi) {
+    NSInteger mid = (lo + hi) / 2;
+    NSUInteger start = _ranges[(NSUInteger)mid].range.location;
+    if (start < location) {
+      lo = mid + 1;
+    } else if (start > location) {
+      hi = mid - 1;
+    } else {
+      return _ranges[(NSUInteger)mid];
+    }
+  }
+  return nil;
+}
+
+// Incoming ranges are trusted to be non-overlapping and line-scoped — the
+// parser owns that invariant (md4c block structure never overlaps at the same
+// nesting level, and nested containers are not yet mapped). Revisit enforcement
+// here if a container block type (list, blockquote) is added.
+- (void)setRanges:(NSArray<ENRMBlockRange *> *)ranges
+{
+  _ranges = [[ranges sortedArrayUsingComparator:^NSComparisonResult(ENRMBlockRange *first, ENRMBlockRange *second) {
+    if (first.range.location < second.range.location)
+      return NSOrderedAscending;
+    if (first.range.location > second.range.location)
+      return NSOrderedDescending;
+    return NSOrderedSame;
+  }] mutableCopy];
+  [self recomputeListMetadata];
+}
+
+- (void)clearAll
+{
+  [_ranges removeAllObjects];
+}
+
+/// Drops any stored block overlapping `paragraphRange` so a replacement can be
+/// inserted cleanly. Blocks are line-scoped and never partially overlap, so a
+/// touched block is removed wholesale.
+- (void)removeBlocksOverlappingRange:(NSRange)paragraphRange
+{
+  NSUInteger removeStart = paragraphRange.location;
+  NSUInteger removeEnd = NSMaxRange(paragraphRange);
+  NSMutableIndexSet *indexesToRemove = [NSMutableIndexSet indexSet];
+
+  for (NSUInteger idx = 0; idx < _ranges.count; idx++) {
+    ENRMBlockRange *existing = _ranges[idx];
+    NSUInteger existingStart = existing.range.location;
+    NSUInteger existingEnd = NSMaxRange(existing.range);
+
+    // A zero-length anchor occupies a point, so the half-open overlap test
+    // never matches it; drop one whose anchor lies within the removal bounds.
+    if (existing.range.length == 0) {
+      if (existingStart >= removeStart && existingStart <= removeEnd) {
+        [indexesToRemove addIndex:idx];
+      }
+      continue;
+    }
+
+    if (existingEnd <= removeStart || existingStart >= removeEnd) {
+      continue;
+    }
+    [indexesToRemove addIndex:idx];
+  }
+
+  ENRMRemoveIndexesInReverse(_ranges, indexesToRemove);
+}
+
+- (void)setBlockType:(ENRMInputBlockType)type
+                level:(NSInteger)level
+    forParagraphRange:(NSRange)range
+               inText:(NSString *)text
+{
+  NSRange paragraphRange = paragraphBoundsForRange(range, text);
+  [self removeBlocksOverlappingRange:paragraphRange];
+
+  paragraphRange = ENRMTrimLineTerminators(paragraphRange, text);
+
+  if (paragraphRange.length == 0 && !ENRMBlockTypePersistsWhenEmpty(type)) {
+    return;
+  }
+
+  ENRMBlockRange *blockRange = [ENRMBlockRange rangeWithType:type range:paragraphRange level:level];
+  NSUInteger insertAt = ENRMSortedInsertionIndex(
+      _ranges, blockRange.range.location, ^NSUInteger(id range) { return ((ENRMBlockRange *)range).range.location; });
+  [_ranges insertObject:blockRange atIndex:insertAt];
+}
+
+- (void)removeBlockInParagraphRange:(NSRange)range inText:(NSString *)text
+{
+  NSRange paragraphRange = paragraphBoundsForRange(range, text);
+  [self removeBlocksOverlappingRange:paragraphRange];
+}
+
+- (void)adjustForEditAtLocation:(NSUInteger)editLocation
+                  deletedLength:(NSUInteger)deletedLength
+                 insertedLength:(NSUInteger)insertedLength
+{
+  if (deletedLength == 0 && insertedLength == 0)
+    return;
+
+  NSUInteger deleteEnd = editLocation + deletedLength;
+  NSMutableIndexSet *indexesToRemove = [NSMutableIndexSet indexSet];
+
+  for (NSUInteger idx = 0; idx < _ranges.count; idx++) {
+    ENRMBlockRange *blockRange = _ranges[idx];
+    BOOL persists = ENRMBlockTypePersistsWhenEmpty(blockRange.type);
+
+    // Zero-length anchors don't follow the shared adjustment: one at the edit
+    // location stays put (normalize grows it over the typed text), one past
+    // the edit shifts with it, one inside the deletion is dropped.
+    if (blockRange.range.length == 0) {
+      if (!persists) {
+        [indexesToRemove addIndex:idx];
+      } else if (blockRange.range.location >= deleteEnd && blockRange.range.location > editLocation) {
+        blockRange.range = NSMakeRange(blockRange.range.location - deletedLength + insertedLength, 0);
+      } else if (blockRange.range.location > editLocation) {
+        [indexesToRemove addIndex:idx]; // anchor sat inside the deleted region
+      }
+      continue;
+    }
+
+    ENRMAdjustedRange adjusted = ENRMAdjustRangeForEdit(blockRange.range, editLocation, deletedLength, insertedLength,
+                                                        /* inheritsReplacementAtStart */ YES,
+                                                        /* growsAtStartOnInsert */ YES);
+    if (adjusted.shouldRemove) {
+      // A persisting block deleted exactly to its end collapses to a zero-length
+      // anchor (the line's newline survived, so the line stays the block); a
+      // deletion running past its end removed the line, so drop the block with it.
+      if (persists && NSMaxRange(blockRange.range) == deleteEnd && blockRange.range.location >= editLocation) {
+        blockRange.range = NSMakeRange(editLocation, 0);
+      } else {
+        [indexesToRemove addIndex:idx];
+      }
+      continue;
+    }
+    blockRange.range = adjusted.range;
+  }
+
+  ENRMRemoveIndexesInReverse(_ranges, indexesToRemove);
+
+  // Prune zero-length ranges, but keep zero-length persisting blocks: they anchor
+  // an emptied-but-still-present heading/bullet line (see the collapse rule above).
+  NSMutableIndexSet *emptyIndexes = [NSMutableIndexSet indexSet];
+  for (NSUInteger idx = 0; idx < _ranges.count; idx++) {
+    ENRMBlockRange *range = _ranges[idx];
+    if (range.range.length == 0 && !ENRMBlockTypePersistsWhenEmpty(range.type)) {
+      [emptyIndexes addIndex:idx];
+    }
+  }
+  if (emptyIndexes.count > 0) {
+    ENRMRemoveIndexesInReverse(_ranges, emptyIndexes);
+  }
+}
+
+- (void)normalizeToLineBoundsInText:(NSString *)text
+{
+  if (_ranges.count == 0) {
+    return;
+  }
+
+  NSMutableIndexSet *indexesToRemove = [NSMutableIndexSet indexSet];
+  NSInteger previousEnd = -1;
+
+  for (NSUInteger idx = 0; idx < _ranges.count; idx++) {
+    ENRMBlockRange *blockRange = _ranges[idx];
+    NSRange lineRange = paragraphBoundsForRange(NSMakeRange(blockRange.range.location, 0), text);
+
+    lineRange = ENRMTrimLineTerminators(lineRange, text);
+
+    BOOL emptyLine = lineRange.length == 0;
+    if ((emptyLine && !ENRMBlockTypePersistsWhenEmpty(blockRange.type)) ||
+        (NSInteger)lineRange.location <= previousEnd) {
+      // Dedup: drop a range that resolves to an already-claimed paragraph. This is a
+      // legitimate self-heal path (a heading anchor and the block it merges into can
+      // briefly share a start after a line-join), so it is deliberately silent — it
+      // cannot distinguish that benign case from genuine corruption, so it does not
+      // assert here.
+      [indexesToRemove addIndex:idx];
+      continue;
+    }
+
+    blockRange.range = lineRange;
+    previousEnd = (NSInteger)NSMaxRange(lineRange);
+  }
+
+  ENRMRemoveIndexesInReverse(_ranges, indexesToRemove);
+  [self recomputeListMetadata];
+}
+
+/// Clamps list depths to valid ancestry (an item nests at most one level under
+/// the previous adjacent list item — CommonMark cannot represent orphan nesting)
+/// and renumbers ordered items among their adjacent same-depth, same-type run.
+- (void)recomputeListMetadata
+{
+  NSInteger prevEnd = -2;
+  NSInteger prevDepth = -1;
+  NSInteger counters[kENRMMaxListDepth + 2];
+  ENRMInputBlockType counterTypes[kENRMMaxListDepth + 2];
+  memset(counters, 0, sizeof(counters));
+  memset(counterTypes, 0, sizeof(counterTypes));
+
+  for (ENRMBlockRange *blockRange in _ranges) {
+    if (!ENRMBlockTypeIsListItem(blockRange.type)) {
+      prevDepth = -1;
+      continue;
+    }
+    BOOL adjacent = prevDepth >= 0 && (NSInteger)blockRange.range.location == prevEnd + 1;
+    if (!adjacent) {
+      memset(counters, 0, sizeof(counters));
+      memset(counterTypes, 0, sizeof(counterTypes));
+    }
+    // Coerce into [0, kENRMMaxListDepth] before ancestry-clamping: parser and
+    // indent commands cap their depths, but this pass indexes the counter
+    // arrays by depth, so an out-of-bounds level must never survive it.
+    NSInteger maxDepth = MIN(adjacent ? prevDepth + 1 : 0, kENRMMaxListDepth);
+    if (blockRange.level > maxDepth) {
+      blockRange.level = maxDepth;
+    } else if (blockRange.level < 0) {
+      blockRange.level = 0;
+    }
+    NSInteger depth = blockRange.level;
+    for (NSInteger i = depth + 1; i <= kENRMMaxListDepth + 1; i++) {
+      counters[i] = 0;
+      counterTypes[i] = (ENRMInputBlockType)0;
+    }
+    if (counterTypes[depth] != blockRange.type) {
+      counters[depth] = 0;
+      counterTypes[depth] = blockRange.type;
+    }
+    counters[depth]++;
+    blockRange.ordinal = counters[depth];
+    prevEnd = (NSInteger)NSMaxRange(blockRange.range);
+    prevDepth = blockRange.level;
+  }
+}
+
+@end

package/ios/input/ENRMBlockSyntaxSentinel.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Vertical tab. md4c treats it as ordinary whitespace, never as a line break.
+extern const unichar ENRMBlockSyntaxSentinelChar;
+
+/// Collapses `\r\n` / `\r` to `\n` and drops any `0x0B` already in the input.
+/// Dropping is deliberate: a pre-existing `0x0B` would come back out of
+/// `ENRMBlockSyntaxDecode` as a newline and silently corrupt the text.
+NSString *ENRMBlockSyntaxCanonicalize(NSString *markdown);
+
+/// Prepends one sentinel and replaces every `\n` with one. Grows the string by
+/// exactly one character and one UTF-8 byte, which is what keeps the parser's
+/// byte-to-UTF16 map valid and the offset correction a flat -1.
+NSString *ENRMBlockSyntaxEncode(NSString *canonical);
+
+/// Reverses `ENRMBlockSyntaxEncode`. Returns nil when the leading sentinel is
+/// missing, so the caller can fall back instead of shifting offsets that no
+/// longer hold.
+NSString *_Nullable ENRMBlockSyntaxDecode(NSString *plainText);
+
+NS_ASSUME_NONNULL_END

package/ios/input/ENRMBlockSyntaxSentinel.mm

@@ -0,0 +1,80 @@
+#import "ENRMBlockSyntaxSentinel.h"
+
+#import <vector>
+
+const unichar ENRMBlockSyntaxSentinelChar = 0x000B;
+
+NSString *ENRMBlockSyntaxCanonicalize(NSString *markdown)
+{
+  NSUInteger length = markdown.length;
+  if (length == 0) {
+    return @"";
+  }
+
+  std::vector<unichar> source(length);
+  [markdown getCharacters:source.data() range:NSMakeRange(0, length)];
+
+  std::vector<unichar> out;
+  out.reserve(length);
+
+  for (NSUInteger i = 0; i < length; i++) {
+    unichar c = source[i];
+    if (c == '\r') {
+      out.push_back('\n');
+      if (i + 1 < length && source[i + 1] == '\n') {
+        i++;
+      }
+    } else if (c != ENRMBlockSyntaxSentinelChar) {
+      out.push_back(c);
+    }
+  }
+
+  // `out.data()` on an empty vector may be null, which -stringWithCharacters: rejects.
+  if (out.empty()) {
+    return @"";
+  }
+
+  return [NSString stringWithCharacters:out.data() length:out.size()];
+}
+
+NSString *ENRMBlockSyntaxEncode(NSString *canonical)
+{
+  NSUInteger length = canonical.length;
+
+  std::vector<unichar> out;
+  out.reserve(length + 1);
+  out.push_back(ENRMBlockSyntaxSentinelChar);
+
+  if (length > 0) {
+    std::vector<unichar> source(length);
+    [canonical getCharacters:source.data() range:NSMakeRange(0, length)];
+    for (NSUInteger i = 0; i < length; i++) {
+      out.push_back(source[i] == '\n' ? ENRMBlockSyntaxSentinelChar : source[i]);
+    }
+  }
+
+  return [NSString stringWithCharacters:out.data() length:out.size()];
+}
+
+NSString *ENRMBlockSyntaxDecode(NSString *plainText)
+{
+  NSUInteger length = plainText.length;
+  if (length == 0 || [plainText characterAtIndex:0] != ENRMBlockSyntaxSentinelChar) {
+    return nil;
+  }
+
+  std::vector<unichar> source(length);
+  [plainText getCharacters:source.data() range:NSMakeRange(0, length)];
+
+  std::vector<unichar> out;
+  out.reserve(length - 1);
+  for (NSUInteger i = 1; i < length; i++) {
+    out.push_back(source[i] == ENRMBlockSyntaxSentinelChar ? '\n' : source[i]);
+  }
+
+  if (out.empty()) {
+    return @"";
+  }
+
+  return [NSString stringWithCharacters:out.data() length:out.size()];
+}

package/ios/input/ENRMClipboardCoordinator.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#import "ENRMBlockRange.h"
+#import "ENRMFormattingRange.h"
+#import "ENRMMathAtom.h"
+#import <Foundation/Foundation.h>
+
+@class ENRMFormattingStore;
+@class ENRMBlockStore;
+@class ENRMInputFormatter;
+@protocol ENRMDetectorPipelineTransientRanges;
+
+NS_ASSUME_NONNULL_BEGIN
+
+@protocol ENRMTransientRangeProvider <NSObject>
+- (NSArray<ENRMFormattingRange *> *)allTransientFormattingRanges;
+@end
+
+@interface ENRMClipboardCoordinator : NSObject
+
+- (instancetype)initWithFormattingStore:(ENRMFormattingStore *)formattingStore
+                             blockStore:(ENRMBlockStore *)blockStore
+                 transientRangeProvider:(id<ENRMTransientRangeProvider>)transientRangeProvider
+                              formatter:(ENRMInputFormatter *)formatter;
+
+- (NSArray<ENRMFormattingRange *> *)allRangesIncludingTransient;
+
+/// `mathAtoms` positions are offsets into `text`. Pass `@[]` only for text that
+/// genuinely holds no chip — every path that serializes the live buffer must
+/// carry its chips, or each formula leaves the editor as a bare placeholder
+/// character instead of `$latex$`.
+- (NSString *)serializeText:(NSString *)text
+                  mathAtoms:(NSArray<ENRMMathAtom *> *)mathAtoms
+                     ranges:(NSArray<ENRMFormattingRange *> *)ranges
+                blockRanges:(NSArray<ENRMBlockRange *> *)blockRanges;
+
+- (NSString *)serializeFullDocument:(NSString *)plainText mathAtoms:(NSArray<ENRMMathAtom *> *)mathAtoms;
+
+- (nullable NSString *)serializeSelectedRange:(NSRange)selection
+                                       inText:(NSString *)fullText
+                                    mathAtoms:(NSArray<ENRMMathAtom *> *)mathAtoms;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/input/ENRMClipboardCoordinator.mm

@@ -0,0 +1,120 @@
+#import "ENRMClipboardCoordinator.h"
+#import "ENRMBlockStore.h"
+#import "ENRMFormattingStore.h"
+#import "ENRMInputFormatter.h"
+#import "ENRMMarkdownSerializer.h"
+#import "styles/ENRMBlockHandler.h"
+
+@implementation ENRMClipboardCoordinator {
+  ENRMFormattingStore *_formattingStore;
+  ENRMBlockStore *_blockStore;
+  id<ENRMTransientRangeProvider> _transientRangeProvider;
+  ENRMInputFormatter *_formatter;
+}
+
+- (instancetype)initWithFormattingStore:(ENRMFormattingStore *)formattingStore
+                             blockStore:(ENRMBlockStore *)blockStore
+                 transientRangeProvider:(id<ENRMTransientRangeProvider>)transientRangeProvider
+                              formatter:(ENRMInputFormatter *)formatter
+{
+  if (self = [super init]) {
+    _formattingStore = formattingStore;
+    _blockStore = blockStore;
+    _transientRangeProvider = transientRangeProvider;
+    _formatter = formatter;
+  }
+  return self;
+}
+
+- (NSArray<ENRMFormattingRange *> *)allRangesIncludingTransient
+{
+  NSArray<ENRMFormattingRange *> *transient = [_transientRangeProvider allTransientFormattingRanges];
+  if (transient.count == 0) {
+    return _formattingStore.allRanges;
+  }
+  NSMutableArray<ENRMFormattingRange *> *merged = [_formattingStore.allRanges mutableCopy];
+  [merged addObjectsFromArray:transient];
+  return merged;
+}
+
+- (NSString *)serializeText:(NSString *)text
+                  mathAtoms:(NSArray<ENRMMathAtom *> *)mathAtoms
+                     ranges:(NSArray<ENRMFormattingRange *> *)ranges
+                blockRanges:(NSArray<ENRMBlockRange *> *)blockRanges
+{
+  ENRMInputFormatter *formatter = _formatter;
+  return [ENRMMarkdownSerializer serializePlainText:text
+                                          mathAtoms:mathAtoms
+                                             ranges:ranges
+                                        blockRanges:blockRanges
+                                blockPrefixProvider:^NSString *(ENRMBlockRange *blockRange) {
+                                  id<ENRMBlockHandler> handler = [formatter handlerForBlockType:blockRange.type];
+                                  return [handler markdownLinePrefixForBlockRange:blockRange];
+                                }];
+}
+
+- (NSString *)serializeFullDocument:(NSString *)plainText mathAtoms:(NSArray<ENRMMathAtom *> *)mathAtoms
+{
+  return [self serializeText:plainText
+                   mathAtoms:mathAtoms
+                      ranges:[self allRangesIncludingTransient]
+                 blockRanges:_blockStore.allRanges];
+}
+
+- (nullable NSString *)serializeSelectedRange:(NSRange)selection
+                                       inText:(NSString *)fullText
+                                    mathAtoms:(NSArray<ENRMMathAtom *> *)mathAtoms
+{
+  if (selection.length == 0) {
+    return nil;
+  }
+
+  NSString *selectedText = [fullText substringWithRange:selection];
+  NSUInteger selEnd = NSMaxRange(selection);
+
+  NSMutableArray<ENRMFormattingRange *> *clippedRanges = [NSMutableArray array];
+  for (ENRMFormattingRange *range in [self allRangesIncludingTransient]) {
+    NSUInteger rangeStart = range.range.location;
+    NSUInteger rangeEnd = NSMaxRange(range.range);
+    if (rangeEnd <= selection.location || rangeStart >= selEnd) {
+      continue;
+    }
+    NSUInteger clippedStart = MAX(rangeStart, selection.location);
+    NSUInteger clippedEnd = MIN(rangeEnd, selEnd);
+    NSRange shifted = NSMakeRange(clippedStart - selection.location, clippedEnd - clippedStart);
+    [clippedRanges addObject:[ENRMFormattingRange rangeWithType:range.type range:shifted url:range.url]];
+  }
+
+  NSMutableArray<ENRMBlockRange *> *clippedBlockRanges = [NSMutableArray array];
+  for (ENRMBlockRange *blockRange in _blockStore.allRanges) {
+    NSUInteger rangeStart = blockRange.range.location;
+    NSUInteger rangeEnd = NSMaxRange(blockRange.range);
+    if (rangeEnd <= selection.location || rangeStart >= selEnd) {
+      continue;
+    }
+    NSUInteger clippedStart = MAX(rangeStart, selection.location);
+    NSUInteger clippedEnd = MIN(rangeEnd, selEnd);
+    NSRange shifted = NSMakeRange(clippedStart - selection.location, clippedEnd - clippedStart);
+    [clippedBlockRanges addObject:[ENRMBlockRange rangeWithType:blockRange.type range:shifted level:blockRange.level]];
+  }
+
+  // A chip is a single character, so it is cleanly inside or outside the
+  // selection; rebase the survivors onto the substring like the ranges above.
+  // Copying part of a document must serialize its formulas, not the bare
+  // placeholder character.
+  NSMutableArray<ENRMMathAtom *> *clippedAtoms = [NSMutableArray array];
+  for (ENRMMathAtom *atom in mathAtoms) {
+    if (atom.position < selection.location || atom.position >= selEnd) {
+      continue;
+    }
+    ENRMMathAtom *clipped = [[ENRMMathAtom alloc] init];
+    clipped.position = atom.position - selection.location;
+    clipped.latex = atom.latex;
+    clipped.displayMode = atom.displayMode;
+    [clippedAtoms addObject:clipped];
+  }
+
+  return [self serializeText:selectedText mathAtoms:clippedAtoms ranges:clippedRanges blockRanges:clippedBlockRanges];
+}
+
+@end

package/ios/input/ENRMDetectorPipeline.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#import "ENRMClipboardCoordinator.h"
 #import "ENRMFormattingRange.h"
 #import "ENRMTextDetector.h"
 #import <Foundation/Foundation.h>
@@ -8,7 +9,7 @@ NS_ASSUME_NONNULL_BEGIN
 
 /// Coordinates a set of ENRMTextDetector instances. The input view calls
 /// this pipeline instead of individual detectors.
-@interface ENRMDetectorPipeline : NSObject
+@interface ENRMDetectorPipeline : NSObject <ENRMTransientRangeProvider>
 
 - (void)addDetector:(id<ENRMTextDetector>)detector;