react-native-enriched-markdown-scaffold 0.6.0-scaffold.4

package/ios/input/ENRMInputParser.mm

@@ -0,0 +1,556 @@
+#import "ENRMInputParser.h"
+#import "ENRMFormattingRange.h"
+#import "ENRMInputRemend.h"
+#include "md4c.h"
+#include <string>
+#include <vector>
+
+@interface ENRMParseResult ()
+@property (nonatomic, strong, readwrite) NSString *plainText;
+@property (nonatomic, strong, readwrite) NSArray<ENRMFormattingRange *> *formattingRanges;
+@property (nonatomic, strong, readwrite) NSArray<ENRMMathAtom *> *mathAtoms;
+@end
+
+@implementation ENRMParseResult
+@end
+
+@implementation ENRMMathAtom
+@end
+
+namespace {
+
+static const size_t kByteOffsetUnset = SIZE_MAX;
+
+struct SpanTypeMapping {
+  MD_SPANTYPE md4cType;
+  ENRMInputStyleType styleType;
+};
+
+static const SpanTypeMapping kSupportedSpans[] = {
+    {MD_SPAN_STRONG, ENRMInputStyleTypeStrong}, {MD_SPAN_EM, ENRMInputStyleTypeEmphasis},
+    {MD_SPAN_U, ENRMInputStyleTypeUnderline},   {MD_SPAN_DEL, ENRMInputStyleTypeStrikethrough},
+    {MD_SPAN_A, ENRMInputStyleTypeLink},        {MD_SPAN_SPOILER, ENRMInputStyleTypeSpoiler},
+};
+static const size_t kSupportedSpanCount = sizeof(kSupportedSpans) / sizeof(kSupportedSpans[0]);
+
+static bool isSupportedSpan(MD_SPANTYPE md4cType, ENRMInputStyleType &outStyleType)
+{
+  for (size_t index = 0; index < kSupportedSpanCount; index++) {
+    if (kSupportedSpans[index].md4cType == md4cType) {
+      outStyleType = kSupportedSpans[index].styleType;
+      return true;
+    }
+  }
+  return false;
+}
+
+struct InlineSpanInfo {
+  ENRMInputStyleType type;
+  size_t openingDelimiterByteOffset;
+  size_t contentStartByteOffset = kByteOffsetUnset;
+  size_t contentEndByteOffset = kByteOffsetUnset;
+  std::string linkURL;
+};
+
+struct MathSpanInfo {
+  bool displayMode;
+  size_t openingDelimiterByteOffset;
+  size_t contentEndByteOffset = kByteOffsetUnset;
+  std::string latex;
+};
+
+struct ParseContext {
+  const char *buffer;
+  size_t bufferLength;
+  size_t originalLength;
+  std::vector<InlineSpanInfo> openStack;
+  std::vector<InlineSpanInfo> resolved;
+  std::vector<MathSpanInfo> openMathStack;
+  std::vector<MathSpanInfo> resolvedMath;
+  size_t lastTextEnd = 0;
+};
+
+static std::vector<NSUInteger> buildByteToUTF16Map(const char *utf8, size_t byteLength)
+{
+  std::vector<NSUInteger> map(byteLength + 1, 0);
+  NSUInteger utf16Index = 0;
+  size_t byteIndex = 0;
+
+  while (byteIndex < byteLength) {
+    unsigned char leadByte = (unsigned char)utf8[byteIndex];
+    size_t sequenceLength;
+
+    if (leadByte < 0x80) {
+      sequenceLength = 1;
+    } else if ((leadByte & 0xE0) == 0xC0) {
+      sequenceLength = 2;
+    } else if ((leadByte & 0xF0) == 0xE0) {
+      sequenceLength = 3;
+    } else {
+      sequenceLength = 4;
+    }
+
+    for (size_t offset = 0; offset < sequenceLength && (byteIndex + offset) <= byteLength; offset++) {
+      map[byteIndex + offset] = utf16Index;
+    }
+
+    // 4-byte UTF-8 sequences encode codepoints above U+FFFF, which need a surrogate pair in UTF-16
+    utf16Index += (sequenceLength == 4) ? 2 : 1;
+    byteIndex += sequenceLength;
+  }
+
+  map[byteLength] = utf16Index;
+  return map;
+}
+
+static inline NSUInteger mapByteOffset(const std::vector<NSUInteger> &map, size_t offset, size_t maxOffset)
+{
+  return map[std::min(offset, maxOffset)];
+}
+
+static const size_t kClosingDelimiterByteLength[] = {
+    [ENRMInputStyleTypeStrong] = 2,        [ENRMInputStyleTypeEmphasis] = 1, [ENRMInputStyleTypeUnderline] = 1,
+    [ENRMInputStyleTypeStrikethrough] = 2, [ENRMInputStyleTypeSpoiler] = 2,
+};
+
+static size_t closingDelimiterEndByte(const InlineSpanInfo &span, const char *utf8, size_t bufferLength)
+{
+  size_t position = span.contentEndByteOffset;
+
+  if (span.type == ENRMInputStyleTypeLink) {
+    while (position < bufferLength && utf8[position] != ')') {
+      position++;
+    }
+    return (position < bufferLength) ? position + 1 : position;
+  }
+
+  return position + kClosingDelimiterByteLength[span.type];
+}
+
+// TODO: onEnterBlock/onLeaveBlock are no-ops, so lastTextEnd never advances
+// past inter-block whitespace. This causes onEnterSpan to set
+// openingDelimiterByteOffset to a position that includes \n\n (or other
+// block-separator characters) in the syntax range. The newline-stripping
+// workaround in parseToPlainTextAndRanges only handles \n/\r — it won't
+// catch block-level syntax like list markers, blockquote '>', or heading '#'
+// if those elements are added in the future.
+//
+// A proper fix would advance lastTextEnd here (or retroactively adjust
+// openingDelimiterByteOffset for spans opened since the last block
+// transition). md4c's enter_block doesn't provide a byte offset, so this
+// likely requires tracking a "new block" flag and correcting span offsets
+// in onText when the first text inside a new block arrives.
+static int onEnterBlock(MD_BLOCKTYPE, void *, void *)
+{
+  return 0;
+}
+static int onLeaveBlock(MD_BLOCKTYPE, void *, void *)
+{
+  return 0;
+}
+
+static int onEnterSpan(MD_SPANTYPE spanType, void *detail, void *userdata)
+{
+  auto *context = static_cast<ParseContext *>(userdata);
+
+  if (spanType == MD_SPAN_LATEXMATH || spanType == MD_SPAN_LATEXMATH_DISPLAY) {
+    MathSpanInfo mathInfo;
+    mathInfo.displayMode = (spanType == MD_SPAN_LATEXMATH_DISPLAY);
+    mathInfo.openingDelimiterByteOffset = context->lastTextEnd;
+    context->openMathStack.push_back(mathInfo);
+    return 0;
+  }
+
+  ENRMInputStyleType styleType;
+  if (!isSupportedSpan(spanType, styleType)) {
+    return 0;
+  }
+
+  InlineSpanInfo spanInfo;
+  spanInfo.type = styleType;
+  spanInfo.openingDelimiterByteOffset = context->lastTextEnd;
+
+  if (spanType == MD_SPAN_A && detail) {
+    auto *linkDetail = static_cast<MD_SPAN_A_DETAIL *>(detail);
+    if (linkDetail->href.text && linkDetail->href.size > 0) {
+      spanInfo.linkURL = std::string(linkDetail->href.text, linkDetail->href.size);
+    }
+  }
+
+  context->openStack.push_back(spanInfo);
+  return 0;
+}
+
+static int onLeaveSpan(MD_SPANTYPE spanType, void *, void *userdata)
+{
+  auto *context = static_cast<ParseContext *>(userdata);
+
+  if (spanType == MD_SPAN_LATEXMATH || spanType == MD_SPAN_LATEXMATH_DISPLAY) {
+    if (context->openMathStack.empty()) {
+      return 0;
+    }
+    context->resolvedMath.push_back(context->openMathStack.back());
+    context->openMathStack.pop_back();
+    return 0;
+  }
+
+  ENRMInputStyleType styleType;
+  if (!isSupportedSpan(spanType, styleType)) {
+    return 0;
+  }
+
+  if (context->openStack.empty()) {
+    return 0;
+  }
+
+  context->resolved.push_back(context->openStack.back());
+  context->openStack.pop_back();
+  return 0;
+}
+
+static int onText(MD_TEXTTYPE textType, const MD_CHAR *text, MD_SIZE size, void *userdata)
+{
+  if (!text || size == 0) {
+    return 0;
+  }
+  auto *context = static_cast<ParseContext *>(userdata);
+
+  // Inside a math span, md4c emits the latex source (typically MD_TEXT_LATEXMATH).
+  // Accumulate it into the open math info and do not propagate to regular spans.
+  if (!context->openMathStack.empty()) {
+    (void)textType;
+    MathSpanInfo &top = context->openMathStack.back();
+    top.latex.append(text, size);
+    bool insideBuffer = (text >= context->buffer && text < context->buffer + context->bufferLength);
+    if (insideBuffer) {
+      size_t textStart = text - context->buffer;
+      top.contentEndByteOffset = textStart + size;
+      context->lastTextEnd = textStart + size;
+    }
+    return 0;
+  }
+
+  // md4c passes pointers outside the input buffer for synthetic tokens
+  // (e.g. MD_TEXT_SOFTBR, MD_TEXT_BR use a string literal "\n").
+  // Pointer arithmetic against context->buffer would underflow, corrupting offsets.
+  //
+  // TODO: Skipping out-of-buffer tokens means lastTextEnd doesn't advance past
+  // newlines. Fine for inline spans, but if block-level input formatting is
+  // added later, openingDelimiterByteOffset will include newline chars in the
+  // syntax range. See the related TODO above onEnterBlock.
+  bool insideBuffer = (text >= context->buffer && text < context->buffer + context->bufferLength);
+  if (!insideBuffer) {
+    return 0;
+  }
+
+  size_t textStart = text - context->buffer;
+  size_t textEnd = textStart + size;
+
+  for (auto &openSpan : context->openStack) {
+    if (openSpan.contentStartByteOffset == kByteOffsetUnset) {
+      openSpan.contentStartByteOffset = textStart;
+    }
+    openSpan.contentEndByteOffset = textEnd;
+  }
+  context->lastTextEnd = textEnd;
+  return 0;
+}
+
+static bool runMd4cParse(NSString *markdown, ParseContext &context)
+{
+  NSString *completed = ENRMInputRemendComplete(markdown);
+  const char *completedUTF8 = [completed UTF8String];
+  size_t completedLength = strlen(completedUTF8);
+  size_t originalLength = [markdown lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
+
+  context.buffer = completedUTF8;
+  context.bufferLength = completedLength;
+  context.originalLength = originalLength;
+
+  MD_PARSER parser = {
+      .abi_version = 0,
+      .flags = MD_FLAG_NOHTML | MD_FLAG_UNDERLINE | MD_FLAG_STRIKETHROUGH | MD_FLAG_SPOILERS | MD_FLAG_LATEXMATHSPANS,
+      .enter_block = onEnterBlock,
+      .leave_block = onLeaveBlock,
+      .enter_span = onEnterSpan,
+      .leave_span = onLeaveSpan,
+      .text = onText,
+      .debug_log = nullptr,
+      .syntax = nullptr,
+  };
+
+  return md_parse(completedUTF8, (MD_SIZE)completedLength, &parser, &context) == 0;
+}
+
+struct ParsedSpans {
+  std::vector<MathSpanInfo> mathSpans;
+};
+
+static NSArray<ENRMInputStyledRange *> *runParseInternal(NSString *markdown, ParsedSpans &out)
+{
+  if (markdown.length == 0) {
+    return @[];
+  }
+
+  ParseContext context;
+  if (!runMd4cParse(markdown, context)) {
+    return @[];
+  }
+
+  out.mathSpans = context.resolvedMath;
+
+  auto byteMap = buildByteToUTF16Map(context.buffer, context.bufferLength);
+
+  NSMutableArray<ENRMInputStyledRange *> *results = [NSMutableArray arrayWithCapacity:context.resolved.size()];
+
+  for (const auto &spanInfo : context.resolved) {
+    if (spanInfo.contentStartByteOffset == kByteOffsetUnset || spanInfo.contentEndByteOffset == kByteOffsetUnset ||
+        spanInfo.contentStartByteOffset > context.originalLength) {
+      continue;
+    }
+
+    ENRMInputStyledRange *styledRange = [[ENRMInputStyledRange alloc] init];
+    styledRange.type = spanInfo.type;
+
+    if (spanInfo.type == ENRMInputStyleTypeLink && !spanInfo.linkURL.empty()) {
+      styledRange.url = [NSString stringWithUTF8String:spanInfo.linkURL.c_str()];
+    }
+
+    NSUInteger contentStart = mapByteOffset(byteMap, spanInfo.contentStartByteOffset, context.bufferLength);
+    NSUInteger contentEnd = mapByteOffset(byteMap, spanInfo.contentEndByteOffset, context.bufferLength);
+    styledRange.contentRange = NSMakeRange(contentStart, contentEnd - contentStart);
+
+    NSUInteger openStart = mapByteOffset(byteMap, spanInfo.openingDelimiterByteOffset, context.bufferLength);
+    NSRange openingRange = NSMakeRange(openStart, contentStart - openStart);
+
+    size_t closingEndByte =
+        std::min(closingDelimiterEndByte(spanInfo, context.buffer, context.bufferLength), context.bufferLength);
+    NSUInteger closingStart = mapByteOffset(byteMap, spanInfo.contentEndByteOffset, context.bufferLength);
+    NSUInteger closingEnd = mapByteOffset(byteMap, closingEndByte, context.bufferLength);
+    NSRange closingRange = NSMakeRange(closingStart, closingEnd - closingStart);
+
+    styledRange.syntaxRanges = @[ [NSValue valueWithRange:openingRange], [NSValue valueWithRange:closingRange] ];
+
+    NSUInteger fullStart = openingRange.location;
+    NSUInteger fullEnd = NSMaxRange(closingRange);
+    styledRange.fullRange = NSMakeRange(fullStart, fullEnd - fullStart);
+
+    styledRange.isComplete = (closingEndByte <= context.originalLength);
+
+    [results addObject:styledRange];
+  }
+
+  [results sortUsingComparator:^NSComparisonResult(ENRMInputStyledRange *first, ENRMInputStyledRange *second) {
+    NSUInteger a = first.fullRange.location, b = second.fullRange.location;
+    return (a < b) ? NSOrderedAscending : (a > b) ? NSOrderedDescending : NSOrderedSame;
+  }];
+
+  return results;
+}
+
+} // namespace
+
+@implementation ENRMInputParser
+
+- (NSArray<ENRMInputStyledRange *> *)parse:(NSString *)markdown
+{
+  ParsedSpans spans;
+  return runParseInternal(markdown, spans);
+}
+
+- (ENRMParseResult *)parseToPlainTextAndRanges:(NSString *)markdown
+{
+  ENRMParseResult *parseResult = [[ENRMParseResult alloc] init];
+
+  if (markdown.length == 0) {
+    parseResult.plainText = @"";
+    parseResult.formattingRanges = @[];
+    parseResult.mathAtoms = @[];
+    return parseResult;
+  }
+
+  ParsedSpans parsedSpans;
+  NSArray<ENRMInputStyledRange *> *styledRanges = runParseInternal(markdown, parsedSpans);
+
+  // Compute byte map + raw byte ranges for math spans so we can strip the
+  // entire `$...$` (or `$$...$$`) syntax and inject a single `` at each.
+  size_t rawByteLength = [markdown lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
+  const char *rawUTF8 = [markdown UTF8String];
+  std::vector<NSUInteger> rawByteMap = buildByteToUTF16Map(rawUTF8, rawByteLength);
+
+  struct MathChip {
+    NSRange rawSyntaxRange; // UTF-16 range in the original markdown to strip
+    NSString *latex;
+    BOOL displayMode;
+  };
+  std::vector<MathChip> mathChips;
+  mathChips.reserve(parsedSpans.mathSpans.size());
+  for (const auto &mathInfo : parsedSpans.mathSpans) {
+    if (mathInfo.contentEndByteOffset == kByteOffsetUnset)
+      continue;
+    size_t closingByteEnd = mathInfo.contentEndByteOffset + (mathInfo.displayMode ? 2 : 1);
+    if (closingByteEnd > rawByteLength)
+      closingByteEnd = rawByteLength;
+    if (mathInfo.openingDelimiterByteOffset > rawByteLength)
+      continue;
+    if (closingByteEnd > rawByteLength)
+      continue;
+
+    NSUInteger rawStart = rawByteMap[mathInfo.openingDelimiterByteOffset];
+    NSUInteger rawEnd = rawByteMap[closingByteEnd];
+    if (rawEnd <= rawStart)
+      continue;
+
+    MathChip chip;
+    chip.rawSyntaxRange = NSMakeRange(rawStart, rawEnd - rawStart);
+    chip.latex = [[NSString alloc] initWithBytes:mathInfo.latex.data()
+                                          length:mathInfo.latex.size()
+                                        encoding:NSUTF8StringEncoding]
+                     ?: @"";
+    chip.displayMode = mathInfo.displayMode ? YES : NO;
+    mathChips.push_back(chip);
+  }
+
+  // Sort math chips by raw position so we process left-to-right.
+  std::sort(mathChips.begin(), mathChips.end(),
+            [](const MathChip &a, const MathChip &b) { return a.rawSyntaxRange.location < b.rawSyntaxRange.location; });
+
+  NSUInteger rawLength = markdown.length;
+
+  NSMutableIndexSet *syntaxIndexes = [NSMutableIndexSet indexSet];
+  for (ENRMInputStyledRange *styledRange in styledRanges) {
+    if (!styledRange.isComplete)
+      continue;
+    for (NSValue *syntaxValue in styledRange.syntaxRanges) {
+      NSRange syntaxRange = [syntaxValue rangeValue];
+      if (NSMaxRange(syntaxRange) > rawLength) {
+        syntaxRange.length = (syntaxRange.location < rawLength) ? rawLength - syntaxRange.location : 0;
+      }
+      if (syntaxRange.length > 0) {
+        [syntaxIndexes addIndexesInRange:syntaxRange];
+      }
+    }
+  }
+
+  // Add math full ranges (delimiters + latex) to the strip set.
+  for (const auto &chip : mathChips) {
+    NSRange r = chip.rawSyntaxRange;
+    if (NSMaxRange(r) > rawLength) {
+      r.length = (r.location < rawLength) ? rawLength - r.location : 0;
+    }
+    if (r.length > 0) {
+      [syntaxIndexes addIndexesInRange:r];
+    }
+  }
+
+  // Strip \n/\r from syntax ranges — newlines are structural content, not
+  // markdown syntax (included due to no-op onEnterBlock/onLeaveBlock).
+  NSMutableIndexSet *newlineIndexes = [NSMutableIndexSet indexSet];
+  [syntaxIndexes enumerateIndexesUsingBlock:^(NSUInteger index, BOOL *stop) {
+    if (index < rawLength) {
+      unichar character = [markdown characterAtIndex:index];
+      if (character == '\n' || character == '\r') {
+        [newlineIndexes addIndex:index];
+      }
+    }
+  }];
+  [syntaxIndexes removeIndexes:newlineIndexes];
+
+  NSMutableString *plainText = [NSMutableString stringWithCapacity:rawLength];
+  __block std::vector<NSUInteger> rawToPlainMap(rawLength + 1, 0);
+
+  __block NSUInteger plainPosition = 0;
+  __block NSUInteger previousEnd = 0;
+
+  [syntaxIndexes enumerateRangesUsingBlock:^(NSRange syntaxRange, BOOL *stop) {
+    if (syntaxRange.location > previousEnd) {
+      NSRange visibleRange = NSMakeRange(previousEnd, syntaxRange.location - previousEnd);
+      [plainText appendString:[markdown substringWithRange:visibleRange]];
+      for (NSUInteger rawIndex = previousEnd; rawIndex < syntaxRange.location; rawIndex++) {
+        rawToPlainMap[rawIndex] = plainPosition++;
+      }
+    }
+    for (NSUInteger rawIndex = syntaxRange.location; rawIndex < NSMaxRange(syntaxRange); rawIndex++) {
+      rawToPlainMap[rawIndex] = plainPosition;
+    }
+    previousEnd = NSMaxRange(syntaxRange);
+  }];
+
+  if (previousEnd < rawLength) {
+    [plainText appendString:[markdown substringFromIndex:previousEnd]];
+    for (NSUInteger rawIndex = previousEnd; rawIndex < rawLength; rawIndex++) {
+      rawToPlainMap[rawIndex] = plainPosition++;
+    }
+  }
+  rawToPlainMap[rawLength] = plainPosition;
+
+  NSMutableArray<ENRMFormattingRange *> *formattingRanges = [NSMutableArray arrayWithCapacity:styledRanges.count];
+
+  for (ENRMInputStyledRange *styledRange in styledRanges) {
+    if (!styledRange.isComplete)
+      continue;
+
+    NSUInteger contentStart = styledRange.contentRange.location;
+    NSUInteger contentEnd = NSMaxRange(styledRange.contentRange);
+
+    if (contentStart > rawLength || contentEnd > rawLength)
+      continue;
+
+    NSUInteger plainStart = rawToPlainMap[contentStart];
+    NSUInteger plainEnd = rawToPlainMap[contentEnd];
+
+    if (plainEnd <= plainStart)
+      continue;
+
+    ENRMFormattingRange *formattingRange =
+        [ENRMFormattingRange rangeWithType:styledRange.type
+                                     range:NSMakeRange(plainStart, plainEnd - plainStart)
+                                       url:styledRange.url];
+    [formattingRanges addObject:formattingRange];
+  }
+
+  // Inject `` (U+FFFC, NSAttachmentCharacter) at each math chip's plain
+  // position and emit ENRMMathAtom records pointing at the inserted character.
+  NSMutableArray<ENRMMathAtom *> *mathAtoms = [NSMutableArray arrayWithCapacity:mathChips.size()];
+  static unichar attachmentChar = (unichar)0xFFFC;
+  NSString *attachmentString = [NSString stringWithCharacters:&attachmentChar length:1];
+  NSUInteger insertionsSoFar = 0;
+  for (const auto &chip : mathChips) {
+    NSUInteger rawStart = chip.rawSyntaxRange.location;
+    if (rawStart > rawLength)
+      continue;
+    NSUInteger basePlain = rawToPlainMap[rawStart];
+    NSUInteger insertAt = basePlain + insertionsSoFar;
+    if (insertAt > plainText.length)
+      insertAt = plainText.length;
+    [plainText insertString:attachmentString atIndex:insertAt];
+
+    ENRMMathAtom *atom = [[ENRMMathAtom alloc] init];
+    atom.position = insertAt;
+    atom.latex = chip.latex ?: @"";
+    atom.displayMode = chip.displayMode;
+    [mathAtoms addObject:atom];
+
+    // Shift existing formatting ranges that start at or after this insertion.
+    for (NSUInteger idx = 0; idx < formattingRanges.count; idx++) {
+      ENRMFormattingRange *fr = formattingRanges[idx];
+      NSRange r = fr.range;
+      if (r.location >= insertAt) {
+        r.location += 1;
+        formattingRanges[idx] = [ENRMFormattingRange rangeWithType:fr.type range:r url:fr.url];
+      } else if (NSMaxRange(r) > insertAt) {
+        r.length += 1;
+        formattingRanges[idx] = [ENRMFormattingRange rangeWithType:fr.type range:r url:fr.url];
+      }
+    }
+
+    insertionsSoFar++;
+  }
+
+  parseResult.plainText = plainText;
+  parseResult.formattingRanges = formattingRanges;
+  parseResult.mathAtoms = mathAtoms;
+  return parseResult;
+}
+
+@end

package/ios/input/ENRMInputRemend.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+NSString *ENRMInputRemendComplete(NSString *markdown);
+
+NS_ASSUME_NONNULL_END

package/ios/input/ENRMInputRemend.mm

@@ -0,0 +1,136 @@
+#import "ENRMInputRemend.h"
+
+typedef struct {
+  NSString *__unsafe_unretained open;
+  NSString *__unsafe_unretained close;
+  BOOL symmetric;
+} ENRMDelimiterPair;
+
+static const ENRMDelimiterPair kDelimiterPairs[] = {
+    {@"**", @"**", YES}, {@"*", @"*", YES}, {@"_", @"_", YES}, {@"~~", @"~~", YES},
+    {@"||", @"||", YES}, {@"`", @"`", YES}, {@"[", @"]", NO},
+};
+static const NSUInteger kDelimiterPairCount = sizeof(kDelimiterPairs) / sizeof(kDelimiterPairs[0]);
+
+static NSString *closingForStackEntry(NSString *entry)
+{
+  for (NSUInteger i = 0; i < kDelimiterPairCount; i++) {
+    if ([entry isEqualToString:kDelimiterPairs[i].open]) {
+      return kDelimiterPairs[i].close;
+    }
+  }
+  return entry;
+}
+
+NSString *ENRMInputRemendComplete(NSString *markdown)
+{
+  if (markdown.length == 0) {
+    return markdown;
+  }
+
+  NSMutableArray<NSString *> *stack = [[NSMutableArray alloc] init];
+  BOOL inLinkParen = NO;
+  NSUInteger length = markdown.length;
+  NSUInteger i = 0;
+
+  while (i < length) {
+    unichar c = [markdown characterAtIndex:i];
+
+    if (c == '\\' && i + 1 < length) {
+      i += 2;
+      continue;
+    }
+
+    // Link URL parentheses are a special two-character transition from "]("
+    if (c == ']' && !inLinkParen && i + 1 < length && [markdown characterAtIndex:i + 1] == '(') {
+      NSUInteger bracketIndex = NSNotFound;
+      for (NSUInteger idx = stack.count; idx > 0; idx--) {
+        if ([stack[idx - 1] isEqualToString:@"["]) {
+          bracketIndex = idx - 1;
+          break;
+        }
+      }
+      if (bracketIndex != NSNotFound) {
+        [stack removeObjectsInRange:NSMakeRange(bracketIndex, stack.count - bracketIndex)];
+      }
+      inLinkParen = YES;
+      i += 2;
+      continue;
+    }
+
+    if (inLinkParen && c == ')') {
+      inLinkParen = NO;
+      i++;
+      continue;
+    }
+
+    if (inLinkParen) {
+      i++;
+      continue;
+    }
+
+    BOOL matched = NO;
+    for (NSUInteger p = 0; p < kDelimiterPairCount; p++) {
+      ENRMDelimiterPair pair = kDelimiterPairs[p];
+      NSUInteger openLen = pair.open.length;
+
+      if (i + openLen > length) {
+        continue;
+      }
+
+      NSString *substring = [markdown substringWithRange:NSMakeRange(i, openLen)];
+
+      if (pair.symmetric) {
+        if ([substring isEqualToString:pair.open]) {
+          if (stack.count > 0 && [stack.lastObject isEqualToString:pair.open]) {
+            [stack removeLastObject];
+          } else {
+            [stack addObject:pair.open];
+          }
+          i += openLen;
+          matched = YES;
+          break;
+        }
+      } else {
+        if ([substring isEqualToString:pair.open]) {
+          [stack addObject:pair.open];
+          i += openLen;
+          matched = YES;
+          break;
+        }
+        NSUInteger closeLen = pair.close.length;
+        if (i + closeLen <= length) {
+          NSString *closeSub = [markdown substringWithRange:NSMakeRange(i, closeLen)];
+          if ([closeSub isEqualToString:pair.close]) {
+            if (stack.count > 0 && [stack.lastObject isEqualToString:pair.open]) {
+              [stack removeLastObject];
+            }
+            i += closeLen;
+            matched = YES;
+            break;
+          }
+        }
+      }
+    }
+
+    if (!matched) {
+      i++;
+    }
+  }
+
+  NSMutableString *closingSuffix = [NSMutableString string];
+
+  if (inLinkParen) {
+    [closingSuffix appendString:@")"];
+  }
+
+  for (NSString *entry in [stack reverseObjectEnumerator]) {
+    [closingSuffix appendString:closingForStackEntry(entry)];
+  }
+
+  if (closingSuffix.length == 0) {
+    return markdown;
+  }
+
+  return [markdown stringByAppendingString:closingSuffix];
+}