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

package/ios/input/ENRMEditPipeline.mm

@@ -0,0 +1,228 @@
+#import "ENRMEditPipeline.h"
+#import "ENRMBlockHandler.h"
+#import "ENRMBlockStore.h"
+#import "ENRMDetectorPipeline.h"
+#import "ENRMFormattingRange.h"
+#import "ENRMFormattingStore.h"
+#import "ENRMInputFormatter.h"
+#import "ENRMUIKit.h"
+
+@implementation ENRMEditContext
+
+- (instancetype)initWithEditLocation:(NSUInteger)editLocation
+                       deletedLength:(NSUInteger)deletedLength
+                      insertedLength:(NSUInteger)insertedLength
+              preEditReplacedNewline:(BOOL)preEditReplacedNewline
+                    preEditBlockType:(ENRMInputBlockType)preEditBlockType
+                   preEditBlockLevel:(NSInteger)preEditBlockLevel
+            preEditParagraphWasEmpty:(BOOL)preEditParagraphWasEmpty
+                       pendingStyles:(NSSet<NSNumber *> *)pendingStyles
+                pendingStyleRemovals:(NSSet<NSNumber *> *)pendingStyleRemovals
+{
+  if (self = [super init]) {
+    _editLocation = editLocation;
+    _deletedLength = deletedLength;
+    _insertedLength = insertedLength;
+    _preEditReplacedNewline = preEditReplacedNewline;
+    _preEditBlockType = preEditBlockType;
+    _preEditBlockLevel = preEditBlockLevel;
+    _preEditParagraphWasEmpty = preEditParagraphWasEmpty;
+    _pendingStyles = [pendingStyles copy];
+    _pendingStyleRemovals = [pendingStyleRemovals copy];
+  }
+  return self;
+}
+
+@end
+
+@implementation ENRMEditPipeline {
+  ENRMFormattingStore *_formattingStore;
+  ENRMBlockStore *_blockStore;
+  ENRMInputFormatter *_formatter;
+  ENRMDetectorPipeline *_detectorPipeline;
+  __weak id<ENRMEditPipelineHost> _host;
+}
+
+- (instancetype)initWithFormattingStore:(ENRMFormattingStore *)formattingStore
+                             blockStore:(ENRMBlockStore *)blockStore
+                              formatter:(ENRMInputFormatter *)formatter
+                       detectorPipeline:(ENRMDetectorPipeline *)detectorPipeline
+                                   host:(id<ENRMEditPipelineHost>)host
+{
+  if (self = [super init]) {
+    _formattingStore = formattingStore;
+    _blockStore = blockStore;
+    _formatter = formatter;
+    _detectorPipeline = detectorPipeline;
+    _host = host;
+  }
+  return self;
+}
+
+#pragma mark - Public API
+
+- (BOOL)processTextChangeWithContext:(ENRMEditContext *)context
+{
+  NSUInteger editLocation = context.editLocation;
+  NSUInteger insertedLength = context.insertedLength;
+
+  [self adjustStoresForEditAtLocation:editLocation deletedLength:context.deletedLength insertedLength:insertedLength];
+
+  NSString *plainText = [_host plainText];
+
+  if (insertedLength > 0) {
+    BOOL insertedHasGlyphContent = [self insertedHasGlyphContentAtLocation:editLocation
+                                                                    length:insertedLength
+                                                                      text:plainText];
+    [self applyPendingStylesWithContext:context plainText:plainText hasGlyphContent:insertedHasGlyphContent];
+
+    if (!insertedHasGlyphContent && insertedLength == 1) {
+      [self reconcileBlockContinuationAfterNewlineAt:editLocation
+                                previousItemWasEmpty:context.preEditParagraphWasEmpty
+                                    preEditBlockType:context.preEditBlockType
+                                   preEditBlockLevel:context.preEditBlockLevel];
+      // Continuation re-seeds fresh block ranges whose ordinal defaults to 1;
+      // normalize again so the list-metadata pass renumbers the adjacent run.
+      [_blockStore normalizeToLineBoundsInText:[_host plainText]];
+    }
+  }
+
+  // Determine whether the edit touched a newline (for full-vs-scoped formatting).
+  BOOL touchedNewline = context.preEditReplacedNewline;
+  if (!touchedNewline && insertedLength > 0) {
+    NSString *postEditText = [_host plainText];
+    NSUInteger insertedEnd = MIN(editLocation + insertedLength, postEditText.length);
+    if (editLocation < insertedEnd) {
+      NSRange insertedRun = NSMakeRange(editLocation, insertedEnd - editLocation);
+      touchedNewline = [postEditText rangeOfCharacterFromSet:[NSCharacterSet newlineCharacterSet]
+                                                     options:0
+                                                       range:insertedRun]
+                           .location != NSNotFound;
+    }
+  }
+
+  return touchedNewline;
+}
+
+- (NSString *)adjustStoresForEditAtLocation:(NSUInteger)editLocation
+                              deletedLength:(NSUInteger)deletedLength
+                             insertedLength:(NSUInteger)insertedLength
+{
+  [_formattingStore adjustForEditAtLocation:editLocation deletedLength:deletedLength insertedLength:insertedLength];
+  [_blockStore adjustForEditAtLocation:editLocation deletedLength:deletedLength insertedLength:insertedLength];
+  [self pruneOrphanedBlockAnchors];
+  NSString *plainText = [_host plainText];
+  [_blockStore normalizeToLineBoundsInText:plainText];
+  return plainText;
+}
+
+- (void)pruneOrphanedBlockAnchors
+{
+  NSString *text = [_host textStorage].string;
+  for (ENRMBlockRange *block in _blockStore.allRanges) {
+    if (!ENRMBlockTypePersistsWhenEmpty(block.type)) {
+      continue;
+    }
+    NSUInteger anchor = MIN(block.range.location, text.length);
+    BOOL atLineStart = [text paragraphRangeForRange:NSMakeRange(anchor, 0)].location == anchor;
+    if (!atLineStart) {
+      [_blockStore removeBlockInParagraphRange:NSMakeRange(anchor, 0) inText:text];
+    }
+  }
+}
+
+- (void)detectLinksAtLocation:(NSUInteger)editLocation insertedLength:(NSUInteger)insertedLength
+{
+  NSString *currentText = [_host plainText];
+  NSUInteger clampedEditLocation = MIN(editLocation, currentText.length);
+  NSUInteger clampedInsertedLength = MIN(insertedLength, currentText.length - clampedEditLocation);
+  [_detectorPipeline processTextChange:currentText
+                     modificationRange:NSMakeRange(clampedEditLocation, clampedInsertedLength)];
+}
+
+#pragma mark - Pending styles (private)
+
+- (void)applyPendingStylesWithContext:(ENRMEditContext *)context
+                            plainText:(NSString *)plainText
+                      hasGlyphContent:(BOOL)insertedHasGlyphContent
+{
+  NSRange insertedRange = NSMakeRange(context.editLocation, context.insertedLength);
+
+  if (insertedHasGlyphContent) {
+    for (NSNumber *styleNum in context.pendingStyles) {
+      ENRMFormattingRange *newRange = [ENRMFormattingRange rangeWithType:(ENRMInputStyleType)styleNum.integerValue
+                                                                   range:insertedRange];
+      [_formattingStore addRange:newRange];
+    }
+  }
+
+  // adjustForEditAtLocation may have expanded an existing range to cover
+  // the insertion — carve out the inserted portion for removed styles.
+  for (NSNumber *styleNum in context.pendingStyleRemovals) {
+    [_formattingStore removeType:(ENRMInputStyleType)styleNum.integerValue inRange:insertedRange];
+  }
+}
+
+- (BOOL)insertedHasGlyphContentAtLocation:(NSUInteger)location length:(NSUInteger)length text:(NSString *)text
+{
+  NSUInteger insertedEnd = location + length;
+  if (insertedEnd > text.length)
+    return NO;
+  NSCharacterSet *newlines = [NSCharacterSet newlineCharacterSet];
+  for (NSUInteger i = location; i < insertedEnd; i++) {
+    if (![newlines characterIsMember:[text characterAtIndex:i]]) {
+      return YES;
+    }
+  }
+  return NO;
+}
+
+#pragma mark - Block continuation (private)
+
+/// Reconciles blocks after Return: a non-empty item continues as a new item at
+/// the same depth, an empty item exits the list (both lines revert to plain
+/// paragraphs). Whether a type continues is the handler's continuesOnNewline.
+- (void)reconcileBlockContinuationAfterNewlineAt:(NSUInteger)newlineLocation
+                            previousItemWasEmpty:(BOOL)previousWasEmpty
+                                preEditBlockType:(ENRMInputBlockType)blockType
+                               preEditBlockLevel:(NSInteger)blockLevel
+{
+  id<ENRMBlockHandler> handler = [_formatter handlerForBlockType:blockType];
+  if (!handler || ![handler respondsToSelector:@selector(continuesOnNewline)] || !handler.continuesOnNewline) {
+    return;
+  }
+
+  NSString *text = [_host plainText];
+  NSUInteger newLineLocation = newlineLocation + 1;
+  if (newLineLocation > text.length) {
+    return;
+  }
+  NSRange originalParagraph = [text paragraphRangeForRange:NSMakeRange(newlineLocation, 0)];
+  NSRange newParagraph = [text paragraphRangeForRange:NSMakeRange(newLineLocation, 0)];
+
+  if (previousWasEmpty) {
+    // Exit: drop the block from both lines and strip their list paragraph style.
+    // Empty lines carry no stamped block-marker attribute for applyFormatting to
+    // key off, so the manual strip is the only thing that clears the leftover indent.
+    [_blockStore removeBlockInParagraphRange:originalParagraph inText:text];
+    [_blockStore removeBlockInParagraphRange:newParagraph inText:text];
+
+    NSTextStorage *storage = [_host textStorage];
+    [storage beginEditing];
+    NSRange clamped = NSIntersectionRange(originalParagraph, NSMakeRange(0, storage.length));
+    if (clamped.length > 0) {
+      [storage removeAttribute:NSParagraphStyleAttributeName range:clamped];
+    }
+    clamped = NSIntersectionRange(newParagraph, NSMakeRange(0, storage.length));
+    if (clamped.length > 0) {
+      [storage removeAttribute:NSParagraphStyleAttributeName range:clamped];
+    }
+    [storage endEditing];
+    return;
+  }
+
+  [_blockStore setBlockType:blockType level:blockLevel forParagraphRange:originalParagraph inText:text];
+  [_blockStore setBlockType:blockType level:blockLevel forParagraphRange:newParagraph inText:text];
+}
+
+@end

package/ios/input/ENRMEditSession.h

@@ -0,0 +1,36 @@
+#import "ENRMUIKit.h"
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+typedef NS_ENUM(NSInteger, ENRMEditPhase) {
+  ENRMEditPhaseIdle,
+  ENRMEditPhaseProcessing,
+  ENRMEditPhaseFormatting,
+  ENRMEditPhaseImporting,
+};
+
+/// Tracks the current editing phase and exposes computed suppression queries.
+/// Replaces the scattered boolean flags (`_isApplyingFormatting`, `_isTextChanging`,
+/// `blockEmitting`, `_lastTextChangeTime`) that previously guarded re-entrant
+/// code paths in the view.
+@interface ENRMEditSession : NSObject
+
+@property (nonatomic, readonly) ENRMEditPhase phase;
+
+- (instancetype)initWithTextView:(ENRMPlatformTextView *)textView;
+
+- (void)enterPhase:(ENRMEditPhase)newPhase;
+- (void)exitPhase;
+
+- (void)recordTextChange;
+
+@property (nonatomic, readonly) BOOL isComposing;
+@property (nonatomic, readonly) BOOL isPostEditGracePeriod;
+@property (nonatomic, readonly) BOOL shouldSuppressFormatting;
+@property (nonatomic, readonly) BOOL shouldSuppressEvents;
+@property (nonatomic, readonly) BOOL shouldSuppressSelectionSideEffects;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/input/ENRMEditSession.mm

@@ -0,0 +1,63 @@
+#import "ENRMEditSession.h"
+
+static const CFTimeInterval kPostEditGracePeriod = 0.1;
+
+@implementation ENRMEditSession {
+  __weak ENRMPlatformTextView *_textView;
+  CFTimeInterval _lastTextChangeTime;
+}
+
+- (instancetype)initWithTextView:(ENRMPlatformTextView *)textView
+{
+  if (self = [super init]) {
+    _textView = textView;
+    _phase = ENRMEditPhaseIdle;
+    _lastTextChangeTime = 0;
+  }
+  return self;
+}
+
+- (void)enterPhase:(ENRMEditPhase)newPhase
+{
+  _phase = newPhase;
+}
+
+- (void)exitPhase
+{
+  _phase = ENRMEditPhaseIdle;
+}
+
+- (void)recordTextChange
+{
+  _lastTextChangeTime = CACurrentMediaTime();
+}
+
+- (BOOL)isComposing
+{
+  ENRMPlatformTextView *tv = _textView;
+  if (!tv)
+    return NO;
+  return ENRMHasMarkedText(tv);
+}
+
+- (BOOL)isPostEditGracePeriod
+{
+  return _lastTextChangeTime > 0 && (CACurrentMediaTime() - _lastTextChangeTime) < kPostEditGracePeriod;
+}
+
+- (BOOL)shouldSuppressFormatting
+{
+  return _phase == ENRMEditPhaseFormatting || _phase == ENRMEditPhaseImporting;
+}
+
+- (BOOL)shouldSuppressEvents
+{
+  return _phase == ENRMEditPhaseImporting;
+}
+
+- (BOOL)shouldSuppressSelectionSideEffects
+{
+  return _phase != ENRMEditPhaseIdle;
+}
+
+@end

package/ios/input/ENRMFormattingStore.h

@@ -21,6 +21,23 @@ NS_ASSUME_NONNULL_BEGIN
 /// the whole link, a caret inside a link moves to its end (unchanged when no adjustment is needed).
 - (NSRange)selectionAdjustedForAtomicLinks:(NSRange)selection;
 
+/// YES when the entire `range` is covered by adjacent/overlapping ranges of `type`.
+- (BOOL)isStyleFullyActive:(ENRMInputStyleType)type inRange:(NSRange)range;
+
+/// Toggles `type` on `range`. For a selection (length > 0), removes the style
+/// when fully active, otherwise strips `conflictingStyles` and adds it.
+/// For a caret (length == 0), reports the current state without mutating.
+/// Returns YES when the style was active (removed / pending removal).
+- (BOOL)toggleStyle:(ENRMInputStyleType)type
+              inRange:(NSRange)range
+    conflictingStyles:(NSSet<NSNumber *> *)conflictingStyles;
+
+/// YES when toggling `type` ON at `position` should be refused because one of
+/// the `blockingStyles` is active there. Toggling OFF is never blocked.
+- (BOOL)isToggleBlocked:(ENRMInputStyleType)type
+             atPosition:(NSUInteger)position
+         blockingStyles:(NSSet<NSNumber *> *)blockingStyles;
+
 - (void)addRange:(ENRMFormattingRange *)range;
 - (void)removeType:(ENRMInputStyleType)type inRange:(NSRange)range;
 - (void)removeRange:(ENRMFormattingRange *)range;

package/ios/input/ENRMFormattingStore.mm

@@ -1,46 +1,6 @@
 #import "ENRMFormattingStore.h"
-
-static NSUInteger sortedInsertionIndex(NSArray<ENRMFormattingRange *> *ranges, NSUInteger location)
-{
-  NSUInteger index = 0;
-  for (ENRMFormattingRange *existing in ranges) {
-    if (existing.range.location > location)
-      break;
-    index++;
-  }
-  return index;
-}
-
-static void removeIndexesInReverse(NSMutableArray *array, NSMutableIndexSet *indexes)
-{
-  [indexes enumerateIndexesWithOptions:NSEnumerationReverse
-                            usingBlock:^(NSUInteger idx, BOOL *stop) { [array removeObjectAtIndex:idx]; }];
-}
-
-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;
-}
+#import "ENRMRangeEditAdjustment.h"
+#import "ENRMRangeStoreUtils.h"
 
 @implementation ENRMFormattingStore {
   NSMutableArray<ENRMFormattingRange *> *_ranges;
@@ -148,6 +108,59 @@ static EditOverlap classifyOverlap(NSUInteger rangeStart, NSUInteger rangeEnd, N
                                                                            containingPosition:position - 1] != nil;
 }
 
+- (BOOL)isStyleFullyActive:(ENRMInputStyleType)type inRange:(NSRange)range
+{
+  NSUInteger pos = range.location;
+  NSUInteger end = NSMaxRange(range);
+  while (pos < end) {
+    ENRMFormattingRange *match = [self rangeOfType:type containingPosition:pos];
+    if (match == nil) {
+      return NO;
+    }
+    pos = NSMaxRange(match.range);
+  }
+  return YES;
+}
+
+- (BOOL)toggleStyle:(ENRMInputStyleType)type
+              inRange:(NSRange)range
+    conflictingStyles:(NSSet<NSNumber *> *)conflictingStyles
+{
+  BOOL wasActive;
+  if (range.length > 0) {
+    wasActive = [self isStyleFullyActive:type inRange:range];
+    if (wasActive) {
+      [self removeType:type inRange:range];
+    } else {
+      for (NSNumber *conflict in conflictingStyles) {
+        [self removeType:(ENRMInputStyleType)conflict.integerValue inRange:range];
+      }
+      [self addRange:[ENRMFormattingRange rangeWithType:type range:range]];
+    }
+  } else {
+    wasActive = [self isStyleActive:type atPosition:range.location];
+  }
+  return wasActive;
+}
+
+- (BOOL)isToggleBlocked:(ENRMInputStyleType)type
+             atPosition:(NSUInteger)position
+         blockingStyles:(NSSet<NSNumber *> *)blockingStyles
+{
+  if (blockingStyles.count == 0) {
+    return NO;
+  }
+  if ([self isStyleActive:type atPosition:position]) {
+    return NO;
+  }
+  for (NSNumber *blocker in blockingStyles) {
+    if ([self isStyleActive:(ENRMInputStyleType)blocker.integerValue atPosition:position]) {
+      return YES;
+    }
+  }
+  return NO;
+}
+
 - (void)addRange:(ENRMFormattingRange *)newRange
 {
   NSMutableIndexSet *mergeIndexes = [NSMutableIndexSet indexSet];
@@ -167,13 +180,14 @@ static EditOverlap classifyOverlap(NSUInteger rangeStart, NSUInteger rangeEnd, N
     }
   }
 
-  removeIndexesInReverse(_ranges, mergeIndexes);
+  ENRMRemoveIndexesInReverse(_ranges, mergeIndexes);
 
   ENRMFormattingRange *merged = [ENRMFormattingRange rangeWithType:newRange.type
                                                              range:NSMakeRange(mergedStart, mergedEnd - mergedStart)
                                                                url:newRange.url];
 
-  NSUInteger insertAt = sortedInsertionIndex(_ranges, merged.range.location);
+  NSUInteger insertAt = ENRMSortedInsertionIndex(
+      _ranges, merged.range.location, ^NSUInteger(id range) { return ((ENRMFormattingRange *)range).range.location; });
   [_ranges insertObject:merged atIndex:insertAt];
 }
 
@@ -211,11 +225,13 @@ static EditOverlap classifyOverlap(NSUInteger rangeStart, NSUInteger rangeEnd, N
     }
   }
 
-  removeIndexesInReverse(_ranges, indexesToRemove);
+  ENRMRemoveIndexesInReverse(_ranges, indexesToRemove);
 
   // Remainders are fragments of a just-removed range and cannot overlap others.
   for (ENRMFormattingRange *remainder in remainders) {
-    NSUInteger insertAt = sortedInsertionIndex(_ranges, remainder.range.location);
+    NSUInteger insertAt = ENRMSortedInsertionIndex(_ranges, remainder.range.location, ^NSUInteger(id range) {
+      return ((ENRMFormattingRange *)range).range.location;
+    });
     [_ranges insertObject:remainder atIndex:insertAt];
   }
 }
@@ -232,71 +248,20 @@ static EditOverlap classifyOverlap(NSUInteger rangeStart, NSUInteger rangeEnd, N
   if (deletedLength == 0 && insertedLength == 0)
     return;
 
-  NSUInteger deleteEnd = editLocation + deletedLength;
   NSMutableIndexSet *indexesToRemove = [NSMutableIndexSet indexSet];
 
   for (NSUInteger idx = 0; idx < _ranges.count; idx++) {
     ENRMFormattingRange *formattingRange = _ranges[idx];
-    NSUInteger rangeStart = formattingRange.range.location;
-    NSUInteger rangeEnd = NSMaxRange(formattingRange.range);
-
-    if (deletedLength > 0) {
-      EditOverlap overlap = classifyOverlap(rangeStart, rangeEnd, editLocation, deleteEnd);
-
-      switch (overlap) {
-        case EditOverlapBeforeEdit:
-          break;
-
-        case EditOverlapAfterEdit:
-          formattingRange.range =
-              NSMakeRange(rangeStart - deletedLength + insertedLength, formattingRange.range.length);
-          break;
-
-        case EditOverlapFullyDeleted:
-          [indexesToRemove addIndex:idx];
-          break;
-
-        case EditOverlapDeletedInside: {
-          NSUInteger newLength = formattingRange.range.length - deletedLength + insertedLength;
-          formattingRange.range = NSMakeRange(rangeStart, newLength);
-          break;
-        }
-
-        case EditOverlapClippedEnd: {
-          NSUInteger newEnd = editLocation + insertedLength;
-          NSUInteger newLength = newEnd > rangeStart ? newEnd - rangeStart : 0;
-          formattingRange.range = NSMakeRange(rangeStart, newLength);
-          if (newLength == 0) {
-            [indexesToRemove addIndex:idx];
-          }
-          break;
-        }
-
-        case EditOverlapClippedStart: {
-          NSUInteger charsClipped = deleteEnd - rangeStart;
-          NSUInteger newStart = editLocation + insertedLength;
-          NSUInteger newLength = formattingRange.range.length - charsClipped;
-          formattingRange.range = NSMakeRange(newStart, newLength);
-          if (newLength == 0) {
-            [indexesToRemove addIndex:idx];
-          }
-          break;
-        }
-      }
-    } else {
-      if (rangeStart >= editLocation) {
-        // Insertion at or before the range start: shift right.
-        // _pendingStyles handles whether the inserted text inherits the style.
-        formattingRange.range = NSMakeRange(rangeStart + insertedLength, formattingRange.range.length);
-      } else if (editLocation < rangeEnd) {
-        formattingRange.range = NSMakeRange(rangeStart, formattingRange.range.length + insertedLength);
-      }
-      // Typing at rangeEnd does not expand — pending styles control
-      // whether new text at the boundary inherits the style.
+    BOOL inheritsReplacement = formattingRange.type != ENRMInputStyleTypeLink;
+    ENRMAdjustedRange adjusted = ENRMAdjustRangeForEdit(formattingRange.range, editLocation, deletedLength,
+                                                        insertedLength, inheritsReplacement, NO);
+    formattingRange.range = adjusted.range;
+    if (adjusted.shouldRemove) {
+      [indexesToRemove addIndex:idx];
     }
   }
 
-  removeIndexesInReverse(_ranges, indexesToRemove);
+  ENRMRemoveIndexesInReverse(_ranges, indexesToRemove);
 
   NSMutableIndexSet *emptyIndexes = [NSMutableIndexSet indexSet];
   for (NSUInteger idx = 0; idx < _ranges.count; idx++) {
@@ -305,7 +270,32 @@ static EditOverlap classifyOverlap(NSUInteger rangeStart, NSUInteger rangeEnd, N
     }
   }
   if (emptyIndexes.count > 0) {
-    removeIndexesInReverse(_ranges, emptyIndexes);
+    ENRMRemoveIndexesInReverse(_ranges, emptyIndexes);
+  }
+
+  [self coalesceAdjacentSameTypeRanges];
+}
+
+/// Merge same-type (and same-url) ranges left adjacent or overlapping by an
+/// edit — e.g. deleting the space in "**foo** **bar**" leaves two touching
+/// bold ranges that would serialize as "**foo****bar**". `addRange:` keeps
+/// this invariant on insert; the edit path must too.
+- (void)coalesceAdjacentSameTypeRanges
+{
+  for (NSUInteger idx = 0; idx < _ranges.count; idx++) {
+    ENRMFormattingRange *current = _ranges[idx];
+    NSUInteger next = idx + 1;
+    while (next < _ranges.count && _ranges[next].range.location <= NSMaxRange(current.range)) {
+      ENRMFormattingRange *candidate = _ranges[next];
+      BOOL sameUrl = (current.url == candidate.url) || [current.url isEqualToString:candidate.url];
+      if (candidate.type == current.type && sameUrl) {
+        NSUInteger mergedEnd = MAX(NSMaxRange(current.range), NSMaxRange(candidate.range));
+        current.range = NSMakeRange(current.range.location, mergedEnd - current.range.location);
+        [_ranges removeObjectAtIndex:next];
+      } else {
+        next++;
+      }
+    }
   }
 }