react-native-enriched-markdown-scaffold 0.7.4-scaffold.9 → 1.0.2-scaffold.2

package/ios/input/ENRMMarkdownSerializer.h

@@ -1,6 +1,8 @@
 #pragma once
 
+#import "ENRMBlockRange.h"
 #import "ENRMFormattingRange.h"
+#import "ENRMMathAtom.h"
 
 NS_ASSUME_NONNULL_BEGIN
 
@@ -8,11 +10,33 @@ NS_ASSUME_NONNULL_BEGIN
 
 + (NSString *)serializePlainText:(NSString *)text ranges:(NSArray<ENRMFormattingRange *> *)ranges;
 
-/// Serializes an attributed string, expanding any `ENRMMathInlineAttachment`
-/// at U+FFFC positions back into `$latex$` or `$$latex$$` markdown. The
-/// `ranges` are formatting ranges over `attr.string` positions; they are
-/// shifted internally to account for the expansion.
-+ (NSString *)serializeAttributedString:(NSAttributedString *)attr ranges:(NSArray<ENRMFormattingRange *> *)ranges;
+/// Block-aware serialization: serializes inline styles exactly as the inline-only
+/// overload, then prepends each line's block prefix. `prefixProvider` is asked,
+/// per block range, for the markdown line marker (e.g. @"# ", @"- "); returning
+/// @"" or nil leaves the line unprefixed. With empty `blockRanges` the output is
+/// identical to the inline-only overload.
++ (NSString *)serializePlainText:(NSString *)text
+                          ranges:(NSArray<ENRMFormattingRange *> *)ranges
+                     blockRanges:(NSArray<ENRMBlockRange *> *)blockRanges
+             blockPrefixProvider:(NSString *_Nullable (^_Nullable)(ENRMBlockRange *blockRange))prefixProvider;
+
+/// Math-aware serialization — the single output path for a buffer that may hold
+/// math chips. Each chip's `kENRMObjectReplacement` placeholder expands back to
+/// `$latex$` / `$$latex$$`, and **both** the inline ranges and the block ranges
+/// are translated through the same position map before the block-aware overload
+/// above runs. Translating only one of the two is the silent failure this
+/// exists to prevent: one placeholder character becomes n characters, so every
+/// block boundary after a chip would land a line off and `# `/`- `/`1. ` would
+/// prefix the wrong line.
+///
+/// Chips arrive as plain data (not an `NSAttributedString`), so this stays a pure
+/// function over `NSString` — which is what makes the round trip testable without
+/// a live editor. `ENRMMathAtom.position` is an offset into `text`.
++ (NSString *)serializePlainText:(NSString *)text
+                       mathAtoms:(NSArray<ENRMMathAtom *> *)mathAtoms
+                          ranges:(NSArray<ENRMFormattingRange *> *)ranges
+                     blockRanges:(NSArray<ENRMBlockRange *> *)blockRanges
+             blockPrefixProvider:(NSString *_Nullable (^_Nullable)(ENRMBlockRange *blockRange))prefixProvider;
 
 @end
 

package/ios/input/ENRMMarkdownSerializer.mm

@@ -1,9 +1,20 @@
 #import "ENRMMarkdownSerializer.h"
 
-#import "ENRMFeatureFlags.h"
-#if ENRICHED_MARKDOWN_MATH
-#import "ENRMMathInlineAttachment.h"
-#endif
+#include <vector>
+
+/// Translates a range over the pre-expansion text into the expanded text. Both
+/// endpoints go through the same map, which is what keeps inline and block
+/// ranges consistent with each other after a chip expands.
+static NSRange mapRangeThroughPositionMap(NSRange range, const std::vector<NSUInteger> &positionMap,
+                                          NSUInteger textLength)
+{
+  NSUInteger start = MIN(range.location, textLength);
+  NSUInteger end = MIN(NSMaxRange(range), textLength);
+  if (end < start) {
+    end = start;
+  }
+  return NSMakeRange(positionMap[start], positionMap[end] - positionMap[start]);
+}
 
 static NSString *openingDelimiterForType(ENRMInputStyleType type)
 {
@@ -224,60 +235,171 @@ static NSArray<ENRMFormattingRange *> *splitRangesAtParagraphBreaks(NSArray<ENRM
   return markdown;
 }
 
-+ (NSString *)serializeAttributedString:(NSAttributedString *)attr ranges:(NSArray<ENRMFormattingRange *> *)ranges
++ (NSString *)serializePlainText:(NSString *)text
+                          ranges:(NSArray<ENRMFormattingRange *> *)ranges
+                     blockRanges:(NSArray<ENRMBlockRange *> *)blockRanges
+             blockPrefixProvider:(NSString *_Nullable (^_Nullable)(ENRMBlockRange *blockRange))prefixProvider
 {
-  if (attr.length == 0) {
-    return [self serializePlainText:@"" ranges:ranges];
+  NSString *inlineMarkdown = [self serializePlainText:text ranges:ranges];
+
+  if (blockRanges.count == 0 || prefixProvider == nil) {
+    return inlineMarkdown;
   }
 
-  NSString *plain = attr.string;
-  NSUInteger length = plain.length;
-
-  // Build expanded text where each math `` becomes its `$latex$` / `$$latex$$`
-  // markdown and build a position map from original indices to expanded indices.
-  NSMutableString *expanded = [NSMutableString stringWithCapacity:length];
-  NSMutableData *mapData = [NSMutableData dataWithLength:(length + 1) * sizeof(NSUInteger)];
-  NSUInteger *posMap = (NSUInteger *)mapData.mutableBytes;
-  NSUInteger expandedPos = 0;
-  for (NSUInteger i = 0; i < length; i++) {
-    posMap[i] = expandedPos;
-    unichar c = [plain characterAtIndex:i];
-    if (c == (unichar)0xFFFC) {
-#if ENRICHED_MARKDOWN_MATH
-      id value = [attr attribute:NSAttachmentAttributeName atIndex:i effectiveRange:NULL];
-      if ([value isKindOfClass:[ENRMMathInlineAttachment class]]) {
-        ENRMMathInlineAttachment *att = value;
-        NSString *delim = att.displayMode ? @"$$" : @"$";
-        [expanded appendString:delim];
-        if (att.latex.length > 0) {
-          [expanded appendString:att.latex];
+  // Block prefixes attach per line. Inline serialization only inserts inline
+  // delimiters (never newlines), so the serialized output has the same line
+  // count as the plain text — we map a block's plain-text range to line indices
+  // and prefix the corresponding serialized lines.
+  NSArray<NSString *> *plainLines = [text componentsSeparatedByString:@"\n"];
+  NSMutableArray<NSString *> *markdownLines = [[inlineMarkdown componentsSeparatedByString:@"\n"] mutableCopy];
+
+  // Inline delimiters never cross a newline, so the line partition is preserved.
+  // If this ever breaks, prefixes would land on the wrong lines. Contract on
+  // both platforms: assert in debug, log and fall back to inline-only output in
+  // release — a library must not crash the host app over lost block prefixes.
+  NSCAssert(plainLines.count == markdownLines.count,
+            @"Block serialization line-count invariant violated: plain=%lu markdown=%lu",
+            (unsigned long)plainLines.count, (unsigned long)markdownLines.count);
+  if (plainLines.count != markdownLines.count) {
+    NSLog(@"[EnrichedMarkdown] Block serialization line-count invariant violated: plain=%lu markdown=%lu",
+          (unsigned long)plainLines.count, (unsigned long)markdownLines.count);
+    return inlineMarkdown;
+  }
+
+  NSMutableArray<NSNumber *> *lineStartOffsets = [NSMutableArray arrayWithCapacity:plainLines.count];
+  NSUInteger runningOffset = 0;
+  for (NSString *line in plainLines) {
+    [lineStartOffsets addObject:@(runningOffset)];
+    runningOffset += line.length + 1; // +1 for the '\n' separator
+  }
+
+  for (ENRMBlockRange *blockRange in blockRanges) {
+    NSString *prefix = prefixProvider(blockRange);
+    if (prefix.length == 0) {
+      continue;
+    }
+
+    NSUInteger blockStart = blockRange.range.location;
+    NSUInteger blockEnd = NSMaxRange(blockRange.range);
+    BOOL isZeroLength = blockRange.range.length == 0;
+    BOOL isListItem = ENRMBlockTypeIsListItem(blockRange.type);
+
+    for (NSUInteger lineIndex = 0; lineIndex < plainLines.count; lineIndex++) {
+      NSUInteger lineStart = lineStartOffsets[lineIndex].unsignedIntegerValue;
+      NSUInteger lineEnd = lineStart + plainLines[lineIndex].length;
+      BOOL overlaps = isZeroLength ? (lineStart == blockStart) : (lineEnd >= blockStart && lineStart < blockEnd);
+      if (overlaps) {
+        // A marker-only list line ("- " with no content) re-parses as a setext
+        // underline for the previous line; emit an empty list line bare. An
+        // empty "# " heading is valid ATX and keeps its prefix.
+        if (isListItem && plainLines[lineIndex].length == 0) {
+          continue;
         }
-        [expanded appendString:delim];
-        expandedPos += delim.length * 2 + att.latex.length;
-        continue;
+        markdownLines[lineIndex] = [prefix stringByAppendingString:markdownLines[lineIndex]];
+      }
+    }
+  }
+
+  return [markdownLines componentsJoinedByString:@"\n"];
+}
+
+/// The chip's markdown form, delimiters included. Line breaks inside the LaTeX
+/// are collapsed to spaces: a chip is one line box in the editor, and emitting a
+/// real newline would change the serialized line count, which trips the
+/// line-count invariant above and silently drops every block prefix in the
+/// document. LaTeX is whitespace-insensitive here, so the formula is unaffected.
+/// A blank formula expands to nothing rather than to a bare `$$` that would
+/// re-parse as literal text.
+static NSString *mathDelimitedMarkdown(ENRMMathAtom *atom)
+{
+  NSMutableString *latex = [NSMutableString stringWithCapacity:atom.latex.length];
+  BOOL previousWasBreak = NO;
+  for (NSUInteger index = 0; index < atom.latex.length; index++) {
+    unichar character = [atom.latex characterAtIndex:index];
+    if (character == '\n' || character == '\r' || character == 0x2028 || character == 0x2029) {
+      if (!previousWasBreak) {
+        [latex appendString:@" "];
       }
-#endif
-      // Unknown attachment — skip the placeholder char so it doesn't leak.
+      previousWasBreak = YES;
       continue;
     }
-    [expanded appendFormat:@"%C", c];
-    expandedPos += 1;
+    [latex appendFormat:@"%C", character];
+    previousWasBreak = NO;
+  }
+
+  NSString *trimmed = [latex stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceCharacterSet]];
+  if (trimmed.length == 0) {
+    return @"";
   }
-  posMap[length] = expandedPos;
-
-  NSMutableArray<ENRMFormattingRange *> *shifted = [NSMutableArray arrayWithCapacity:ranges.count];
-  for (ENRMFormattingRange *fr in ranges) {
-    NSUInteger start = fr.range.location;
-    NSUInteger end = NSMaxRange(fr.range);
-    if (start > length)
-      start = length;
-    if (end > length)
-      end = length;
-    NSRange shiftedRange = NSMakeRange(posMap[start], posMap[end] - posMap[start]);
-    [shifted addObject:[ENRMFormattingRange rangeWithType:fr.type range:shiftedRange url:fr.url]];
+  NSString *delimiter = atom.displayMode ? @"$$" : @"$";
+  return [NSString stringWithFormat:@"%@%@%@", delimiter, trimmed, delimiter];
+}
+
++ (NSString *)serializePlainText:(NSString *)text
+                       mathAtoms:(NSArray<ENRMMathAtom *> *)mathAtoms
+                          ranges:(NSArray<ENRMFormattingRange *> *)ranges
+                     blockRanges:(NSArray<ENRMBlockRange *> *)blockRanges
+             blockPrefixProvider:(NSString *_Nullable (^_Nullable)(ENRMBlockRange *blockRange))prefixProvider
+{
+  if (mathAtoms.count == 0) {
+    return [self serializePlainText:text ranges:ranges blockRanges:blockRanges blockPrefixProvider:prefixProvider];
+  }
+
+  NSUInteger textLength = text.length;
+
+  // A chip whose recorded position no longer holds a placeholder is stale (the
+  // buffer moved under it); expanding it there would corrupt unrelated text.
+  NSMutableDictionary<NSNumber *, NSString *> *latexByPosition =
+      [NSMutableDictionary dictionaryWithCapacity:mathAtoms.count];
+  for (ENRMMathAtom *atom in mathAtoms) {
+    if (atom.position >= textLength) {
+      continue;
+    }
+    if ([text characterAtIndex:atom.position] != kENRMObjectReplacement) {
+      continue;
+    }
+    latexByPosition[@(atom.position)] = mathDelimitedMarkdown(atom);
+  }
+  if (latexByPosition.count == 0) {
+    return [self serializePlainText:text ranges:ranges blockRanges:blockRanges blockPrefixProvider:prefixProvider];
+  }
+
+  // positionMap[i] = offset in `expanded` of the character that was at text[i].
+  // Length + 1 so an exclusive end offset at textLength maps too.
+  NSMutableString *expanded = [NSMutableString stringWithCapacity:textLength];
+  std::vector<NSUInteger> positionMap(textLength + 1, 0);
+  for (NSUInteger index = 0; index < textLength; index++) {
+    positionMap[index] = expanded.length;
+    NSString *replacement = latexByPosition[@(index)];
+    if (replacement != nil) {
+      [expanded appendString:replacement];
+    } else {
+      [expanded appendFormat:@"%C", [text characterAtIndex:index]];
+    }
+  }
+  positionMap[textLength] = expanded.length;
+
+  NSMutableArray<ENRMFormattingRange *> *shiftedRanges = [NSMutableArray arrayWithCapacity:ranges.count];
+  for (ENRMFormattingRange *range in ranges) {
+    ENRMFormattingRange *shifted = [range copy];
+    shifted.range = mapRangeThroughPositionMap(range.range, positionMap, textLength);
+    [shiftedRanges addObject:shifted];
+  }
+
+  NSMutableArray<ENRMBlockRange *> *shiftedBlockRanges = [NSMutableArray arrayWithCapacity:blockRanges.count];
+  for (ENRMBlockRange *blockRange in blockRanges) {
+    // Copy rather than rebuild: `ordinal` carries an ordered item's number and is
+    // not part of any initializer, so a rebuilt range renumbers every "1." in the
+    // document — a silent failure the copy sidesteps entirely.
+    ENRMBlockRange *shifted = [blockRange copy];
+    shifted.range = mapRangeThroughPositionMap(blockRange.range, positionMap, textLength);
+    [shiftedBlockRanges addObject:shifted];
   }
 
-  return [self serializePlainText:expanded ranges:shifted];
+  return [self serializePlainText:expanded
+                           ranges:shiftedRanges
+                      blockRanges:shiftedBlockRanges
+              blockPrefixProvider:prefixProvider];
 }
 
 @end

package/ios/input/ENRMMathAtom.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// U+FFFC OBJECT REPLACEMENT CHARACTER — the single character a math chip
+/// occupies in the editor buffer. Declared once and shared by every stage of the
+/// round trip (parser writes it, serializer expands it, the view inserts it): a
+/// second copy of this literal is a round-trip bug waiting to happen.
+static const unichar kENRMObjectReplacement = 0xFFFC;
+
+/// `kENRMObjectReplacement` as a string, for insertion into text buffers.
+NSString *ENRMObjectReplacementString(void);
+
+/// One `$...$` / `$$...$$` formula found in the markdown. The parser has already
+/// put a single `kENRMObjectReplacement` at `position` in the plain text; the
+/// caller turns it into a chip. Pure data — no RaTeX dependency, so it exists in
+/// math-disabled builds too (md4c simply never emits any).
+@interface ENRMMathAtom : NSObject
+@property (nonatomic, assign) NSUInteger position;
+@property (nonatomic, copy) NSString *latex;
+@property (nonatomic, assign) BOOL displayMode;
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/input/ENRMMathAtom.mm

@@ -0,0 +1,12 @@
+#import "ENRMMathAtom.h"
+
+NSString *ENRMObjectReplacementString(void)
+{
+  static NSString *placeholder;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{ placeholder = [NSString stringWithCharacters:&kENRMObjectReplacement length:1]; });
+  return placeholder;
+}
+
+@implementation ENRMMathAtom
+@end

package/ios/input/ENRMMentionCoordinator.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#import "ENRMFormattingStore.h"
+#import "ENRMInputMentionCandidate.h"
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+typedef NS_ENUM(NSInteger, ENRMMentionEventType) {
+  ENRMMentionEventStart,
+  ENRMMentionEventChange,
+  ENRMMentionEventEnd,
+};
+
+@interface ENRMMentionEvent : NSObject
+@property (nonatomic, assign) ENRMMentionEventType type;
+@property (nonatomic, copy) NSString *indicator;
+@property (nonatomic, copy, nullable) NSString *text;
++ (instancetype)startWithIndicator:(NSString *)indicator;
++ (instancetype)changeWithIndicator:(NSString *)indicator text:(NSString *)text;
++ (instancetype)endWithIndicator:(NSString *)indicator;
+@end
+
+@interface ENRMMentionCoordinator : NSObject
+
+@property (nonatomic, readonly, nullable) NSString *activeIndicator;
+@property (nonatomic, readonly) NSRange activeRange;
+@property (nonatomic, readonly, copy) NSString *activeText;
+@property (nonatomic, readonly) BOOL isActive;
+
+- (instancetype)initWithFormattingStore:(ENRMFormattingStore *)formattingStore;
+
+- (BOOL)containsIndicator:(NSString *)indicator;
+- (NSArray<ENRMMentionEvent *> *)setIndicators:(NSArray<NSString *> *)indicators;
+
+/// Re-evaluates the active mention. Returns events for the view to dispatch.
+- (NSArray<ENRMMentionEvent *> *)updateWithText:(nullable NSString *)plainText selectedRange:(NSRange)selectedRange;
+
+- (NSArray<ENRMMentionEvent *> *)clearWithIndicatorOverride:(nullable NSString *)indicatorOverride;
+
+- (nullable ENRMInputMentionCandidate *)detectCandidateInText:(NSString *)plainText atCursor:(NSUInteger)cursor;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/input/ENRMMentionCoordinator.mm

@@ -0,0 +1,167 @@
+#import "ENRMMentionCoordinator.h"
+#import "ENRMWordsUtils.h"
+
+@implementation ENRMMentionEvent
+
++ (instancetype)startWithIndicator:(NSString *)indicator
+{
+  ENRMMentionEvent *e = [[ENRMMentionEvent alloc] init];
+  e.type = ENRMMentionEventStart;
+  e.indicator = indicator;
+  return e;
+}
+
++ (instancetype)changeWithIndicator:(NSString *)indicator text:(NSString *)text
+{
+  ENRMMentionEvent *e = [[ENRMMentionEvent alloc] init];
+  e.type = ENRMMentionEventChange;
+  e.indicator = indicator;
+  e.text = text;
+  return e;
+}
+
++ (instancetype)endWithIndicator:(NSString *)indicator
+{
+  ENRMMentionEvent *e = [[ENRMMentionEvent alloc] init];
+  e.type = ENRMMentionEventEnd;
+  e.indicator = indicator;
+  return e;
+}
+
+@end
+
+@implementation ENRMMentionCoordinator {
+  ENRMFormattingStore *_formattingStore;
+  NSArray<NSString *> *_indicators;
+  NSString *_activeIndicator;
+  NSRange _activeRange;
+  NSString *_activeText;
+}
+
+- (instancetype)initWithFormattingStore:(ENRMFormattingStore *)formattingStore
+{
+  if (self = [super init]) {
+    _formattingStore = formattingStore;
+    _indicators = @[];
+    _activeRange = NSMakeRange(NSNotFound, 0);
+    _activeText = @"";
+  }
+  return self;
+}
+
+- (NSString *)activeIndicator
+{
+  return _activeIndicator;
+}
+
+- (NSRange)activeRange
+{
+  return _activeRange;
+}
+
+- (NSString *)activeText
+{
+  return _activeText;
+}
+
+- (BOOL)isActive
+{
+  return _activeIndicator != nil;
+}
+
+- (BOOL)containsIndicator:(NSString *)indicator
+{
+  return [_indicators containsObject:indicator];
+}
+
+- (NSArray<ENRMMentionEvent *> *)setIndicators:(NSArray<NSString *> *)indicators
+{
+  if ([indicators isEqualToArray:_indicators]) {
+    return @[];
+  }
+  _indicators = [indicators copy];
+  NSMutableArray<ENRMMentionEvent *> *events = [NSMutableArray array];
+  if (_activeIndicator != nil && ![_indicators containsObject:_activeIndicator]) {
+    [events addObjectsFromArray:[self clearWithIndicatorOverride:_activeIndicator]];
+  }
+  return events;
+}
+
+- (NSArray<ENRMMentionEvent *> *)updateWithText:(nullable NSString *)plainText selectedRange:(NSRange)selectedRange
+{
+  if (plainText == nil || selectedRange.length != 0) {
+    return [self clearWithIndicatorOverride:nil];
+  }
+  NSUInteger cursor = selectedRange.location;
+  if (cursor > plainText.length) {
+    return [self clearWithIndicatorOverride:nil];
+  }
+
+  ENRMInputMentionCandidate *candidate = [self detectCandidateInText:plainText atCursor:cursor];
+  if (candidate == nil) {
+    return [self clearWithIndicatorOverride:nil];
+  }
+
+  NSMutableArray<ENRMMentionEvent *> *events = [NSMutableArray array];
+
+  if (_activeIndicator == nil || ![_activeIndicator isEqualToString:candidate.indicator] ||
+      _activeRange.location != candidate.start) {
+    if (_activeIndicator != nil) {
+      [events addObject:[ENRMMentionEvent endWithIndicator:_activeIndicator]];
+    }
+    _activeIndicator = candidate.indicator;
+    [events addObject:[ENRMMentionEvent startWithIndicator:candidate.indicator]];
+  }
+
+  _activeRange = NSMakeRange(candidate.start, candidate.end - candidate.start);
+
+  if (![_activeText isEqualToString:candidate.text]) {
+    _activeText = candidate.text;
+    [events addObject:[ENRMMentionEvent changeWithIndicator:candidate.indicator text:candidate.text]];
+  }
+
+  return events;
+}
+
+- (NSArray<ENRMMentionEvent *> *)clearWithIndicatorOverride:(nullable NSString *)indicatorOverride
+{
+  NSString *indicator = indicatorOverride ?: _activeIndicator;
+  _activeIndicator = nil;
+  _activeRange = NSMakeRange(NSNotFound, 0);
+  _activeText = @"";
+  if (indicator.length > 0) {
+    return @[ [ENRMMentionEvent endWithIndicator:indicator] ];
+  }
+  return @[];
+}
+
+- (nullable ENRMInputMentionCandidate *)detectCandidateInText:(NSString *)plainText atCursor:(NSUInteger)cursor
+{
+  if (_indicators.count == 0) {
+    return nil;
+  }
+
+  NSUInteger start = [ENRMWordsUtils tokenStartInText:plainText beforePosition:cursor];
+  NSString *token = [plainText substringWithRange:NSMakeRange(start, cursor - start)];
+  NSString *matchedIndicator = nil;
+  for (NSString *indicator in _indicators) {
+    if ([token hasPrefix:indicator]) {
+      matchedIndicator = indicator;
+      break;
+    }
+  }
+  if (matchedIndicator == nil) {
+    return nil;
+  }
+
+  if ([_formattingStore rangeOfType:ENRMInputStyleTypeLink containingPosition:start] != nil) {
+    return nil;
+  }
+
+  return [ENRMInputMentionCandidate candidateWithIndicator:matchedIndicator
+                                                     start:start
+                                                       end:cursor
+                                                      text:[token substringFromIndex:matchedIndicator.length]];
+}
+
+@end

package/ios/input/ENRMRangeEditAdjustment.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+typedef struct {
+  NSRange range;
+  BOOL shouldRemove;
+} ENRMAdjustedRange;
+
+/// Shared shift/clip logic applied to a stored range after a text edit that
+/// replaced `deletedLength` characters at `editLocation` with `insertedLength`
+/// characters. Both ENRMFormattingStore and ENRMBlockStore delegate here so the
+/// overlap classification lives in exactly one place. `shouldRemove` is set
+/// when the range was deleted outright or clipped to zero length.
+///
+/// Insert-only edits at exactly the range end do NOT grow the range — the typed
+/// characters stay outside it. An insert at exactly the range start grows the
+/// range only when `growsAtStartOnInsert` is YES; otherwise the range shifts and
+/// the typed characters stay outside it. Whether boundary text joins the range is
+/// otherwise decided elsewhere: pending styles for inline ranges, line
+/// re-normalization for block ranges.
+///
+/// `inheritsReplacementAtStart`: when YES, a replacement whose deletion starts
+/// at the range start lets the inserted text join the range (UIKit attribute
+/// inheritance); when NO, the old clip/remove behavior applies.
+///
+/// `growsAtStartOnInsert`: when YES, a pure insert at the range start grows the
+/// range to cover the inserted text instead of shifting the range past it. Block
+/// ranges own their whole line, so a character typed at the line start must keep
+/// the line's block; inline styles must NOT set this (a character typed before a
+/// bold run must not become bold).
+ENRMAdjustedRange ENRMAdjustRangeForEdit(NSRange range, NSUInteger editLocation, NSUInteger deletedLength,
+                                         NSUInteger insertedLength, BOOL inheritsReplacementAtStart,
+                                         BOOL growsAtStartOnInsert);
+
+NS_ASSUME_NONNULL_END

package/ios/input/ENRMRangeEditAdjustment.mm

@@ -0,0 +1,91 @@
+#import "ENRMRangeEditAdjustment.h"
+
+typedef NS_ENUM(NSInteger, EditOverlap) {
+  EditOverlapBeforeEdit,
+  EditOverlapAfterEdit,
+  EditOverlapFullyDeleted,
+  EditOverlapDeletedInside,
+  EditOverlapClippedEnd,
+  EditOverlapClippedStart,
+};
+
+static EditOverlap classifyOverlap(NSUInteger rangeStart, NSUInteger rangeEnd, NSUInteger editLocation,
+                                   NSUInteger deleteEnd)
+{
+  if (rangeEnd <= editLocation)
+    return EditOverlapBeforeEdit;
+  if (rangeStart >= deleteEnd)
+    return EditOverlapAfterEdit;
+  if (rangeStart >= editLocation && rangeEnd <= deleteEnd)
+    return EditOverlapFullyDeleted;
+  if (rangeStart < editLocation && rangeEnd > deleteEnd)
+    return EditOverlapDeletedInside;
+  if (rangeStart < editLocation && rangeEnd <= deleteEnd)
+    return EditOverlapClippedEnd;
+  return EditOverlapClippedStart;
+}
+
+ENRMAdjustedRange ENRMAdjustRangeForEdit(NSRange range, NSUInteger editLocation, NSUInteger deletedLength,
+                                         NSUInteger insertedLength, BOOL inheritsReplacementAtStart,
+                                         BOOL growsAtStartOnInsert)
+{
+  ENRMAdjustedRange result = {range, NO};
+  NSUInteger rangeStart = range.location;
+  NSUInteger rangeEnd = NSMaxRange(range);
+
+  if (deletedLength > 0) {
+    NSUInteger deleteEnd = editLocation + deletedLength;
+    BOOL inheritsReplacement = inheritsReplacementAtStart && insertedLength > 0 && rangeStart == editLocation;
+
+    switch (classifyOverlap(rangeStart, rangeEnd, editLocation, deleteEnd)) {
+      case EditOverlapBeforeEdit:
+        break;
+
+      case EditOverlapAfterEdit:
+        result.range = NSMakeRange(rangeStart - deletedLength + insertedLength, range.length);
+        break;
+
+      case EditOverlapFullyDeleted:
+        if (inheritsReplacement) {
+          result.range = NSMakeRange(editLocation, insertedLength);
+        } else {
+          result.shouldRemove = YES;
+        }
+        break;
+
+      case EditOverlapDeletedInside:
+        result.range = NSMakeRange(rangeStart, range.length - deletedLength + insertedLength);
+        break;
+
+      case EditOverlapClippedEnd: {
+        NSUInteger newEnd = editLocation + insertedLength;
+        NSUInteger newLength = newEnd > rangeStart ? newEnd - rangeStart : 0;
+        result.range = NSMakeRange(rangeStart, newLength);
+        result.shouldRemove = (newLength == 0);
+        break;
+      }
+
+      case EditOverlapClippedStart: {
+        NSUInteger charsClipped = deleteEnd - rangeStart;
+        NSUInteger survivingLength = range.length - charsClipped;
+        if (inheritsReplacement) {
+          result.range = NSMakeRange(editLocation, insertedLength + survivingLength);
+        } else {
+          result.range = NSMakeRange(editLocation + insertedLength, survivingLength);
+          result.shouldRemove = (survivingLength == 0);
+        }
+        break;
+      }
+    }
+  } else if (insertedLength > 0) {
+    if (rangeStart == editLocation && growsAtStartOnInsert) {
+      result.range = NSMakeRange(rangeStart, range.length + insertedLength);
+    } else if (rangeStart >= editLocation) {
+      result.range = NSMakeRange(rangeStart + insertedLength, range.length);
+    } else if (editLocation < rangeEnd) {
+      result.range = NSMakeRange(rangeStart, range.length + insertedLength);
+    }
+  }
+
+  return result;
+}