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

package/ios/attachments/ENRMImageAttachment.m

@@ -5,7 +5,7 @@
 #import "StyleConfig.h"
 #import <objc/runtime.h>
 
-#define CACHE_KEY_PROCESSED(url, w, h, r) [NSString stringWithFormat:@"%@_w%.1f_h%.1f_r%.1f", url, w, h, r]
+#define CACHE_KEY_PROCESSED(url, w, h, r, m) [NSString stringWithFormat:@"%@_w%.1f_h%.1f_r%.1f_m%@", url, w, h, r, m]
 
 static inline NSUInteger ENRMImageByteCost(RCTUIImage *image)
 {
@@ -22,13 +22,19 @@ static NSMapTable<NSString *, ENRMImageAttachment *> *_attachmentRegistry;
 @interface ENRMImageAttachment ()
 
 @property (nonatomic, copy) NSString *imageURL;
+@property (nonatomic, copy, nullable) NSDictionary<NSString *, NSString *> *requestHeaders;
+@property (nonatomic, copy) NSString *cacheKey;
 @property (nonatomic, assign) BOOL isInline;
 @property (nonatomic, assign) CGFloat cachedHeight;
+@property (nonatomic, assign) CGFloat cachedMaxHeight;
+@property (nonatomic, assign) CGFloat cachedAspectRatio;
+@property (nonatomic, copy) NSString *cachedResizeMode;
 @property (nonatomic, assign) CGFloat cachedBorderRadius;
 @property (nonatomic, weak) NSTextContainer *textContainer;
 @property (nonatomic, weak) ENRMPlatformTextView *textView;
 @property (nonatomic, strong) RCTUIImage *originalImage;
 @property (nonatomic, strong) RCTUIImage *loadedImage;
+@property (nonatomic, strong) RCTUIImage *placeholderImage;
 @property (nonatomic, copy) NSString *lastProcessedKey;
 
 @end
@@ -66,7 +72,8 @@ static NSMapTable<NSString *, ENRMImageAttachment *> *_attachmentRegistry;
 
 + (instancetype)attachmentForURL:(NSString *)imageURL config:(StyleConfig *)config isInline:(BOOL)isInline
 {
-  NSString *key = [NSString stringWithFormat:@"%@_%d", imageURL, isInline];
+  NSString *key =
+      [NSString stringWithFormat:@"%@_%d", ENRMImageCacheKey(imageURL, [config imageRequestHeaders]), isInline];
   ENRMImageAttachment *existing = [[self attachmentRegistry] objectForKey:key];
   if (existing && existing.loadedImage) {
     return existing;
@@ -86,9 +93,14 @@ static NSMapTable<NSString *, ENRMImageAttachment *> *_attachmentRegistry;
   self = [super init];
   if (self) {
     _imageURL = imageURL;
+    _requestHeaders = [[config imageRequestHeaders] copy];
+    _cacheKey = ENRMImageCacheKey(imageURL, _requestHeaders);
     _isInline = isInline;
 
     _cachedHeight = isInline ? [config inlineImageSize] : [config imageHeight];
+    _cachedMaxHeight = [config imageMaxHeight];
+    _cachedAspectRatio = [config imageAspectRatio];
+    _cachedResizeMode = [config imageResizeMode];
     _cachedBorderRadius = [config imageBorderRadius];
 
     [self setupPlaceholder];
@@ -97,6 +109,33 @@ static NSMapTable<NSString *, ENRMImageAttachment *> *_attachmentRegistry;
   return self;
 }
 
+- (CGFloat)resolvedBoxHeightForWidth:(CGFloat)width
+{
+  if (self.cachedAspectRatio > 0 && width > 0) {
+    return width / self.cachedAspectRatio;
+  }
+
+  if (self.cachedMaxHeight > 0) {
+    RCTUIImage *source = self.originalImage;
+    if (source && width > 0 && source.size.width > 0 && source.size.height > 0) {
+      CGFloat fitted = width * source.size.height / source.size.width;
+      return MIN(self.cachedMaxHeight, fitted);
+    }
+    // Intrinsic size not known yet — fall back to the full max height; the box
+    // shrinks once the image loads and layout is invalidated.
+    return self.cachedMaxHeight;
+  }
+
+  return self.cachedHeight;
+}
+
+// True when resizeMode is unset ('') - legacy always implies a fixed height box.
+
+- (BOOL)isLegacyBlockSizing
+{
+  return !self.isInline && self.cachedResizeMode.length == 0;
+}
+
 - (CGRect)attachmentBoundsForTextContainer:(NSTextContainer *)textContainer
                       proposedLineFragment:(CGRect)lineFragment
                              glyphPosition:(CGPoint)position
@@ -105,26 +144,27 @@ static NSMapTable<NSString *, ENRMImageAttachment *> *_attachmentRegistry;
   CGFloat height = self.cachedHeight;
   CGFloat width = self.isInline ? height : (lineFragment.size.width > 0 ? lineFragment.size.width : height);
 
-  if (self.isInline) {
-    UIFont *appliedFont = nil;
-    NSLayoutManager *layoutManager = textContainer.layoutManager;
-    NSTextStorage *textStorage = layoutManager.textStorage;
+  if (!self.isInline) {
+    height = [self resolvedBoxHeightForWidth:width];
+    return CGRectMake(0, 0, width, height);
+  }
 
-    if (textStorage && characterIndex < textStorage.length) {
-      appliedFont = [textStorage attribute:NSFontAttributeName atIndex:characterIndex effectiveRange:NULL];
-    }
+  UIFont *appliedFont = nil;
+  NSLayoutManager *layoutManager = textContainer.layoutManager;
+  NSTextStorage *textStorage = layoutManager.textStorage;
 
-    CGFloat verticalOffset;
-    if (appliedFont) {
-      verticalOffset = (appliedFont.capHeight - height) / 2.0;
-    } else {
-      verticalOffset = (lineFragment.size.height - height) / 2.0;
-    }
+  if (textStorage && characterIndex < textStorage.length) {
+    appliedFont = [textStorage attribute:NSFontAttributeName atIndex:characterIndex effectiveRange:NULL];
+  }
 
-    return CGRectMake(0, verticalOffset, width, height);
+  CGFloat verticalOffset;
+  if (appliedFont) {
+    verticalOffset = (appliedFont.capHeight - height) / 2.0;
+  } else {
+    verticalOffset = (lineFragment.size.height - height) / 2.0;
   }
 
-  return CGRectMake(0, 0, width, height);
+  return CGRectMake(0, verticalOffset, width, height);
 }
 
 - (RCTUIImage *)imageForBounds:(CGRect)imageBounds
@@ -138,7 +178,7 @@ static NSMapTable<NSString *, ENRMImageAttachment *> *_attachmentRegistry;
     [self processAndApplyImage:self.originalImage withTargetWidth:imageBounds.size.width];
   }
 
-  return self.loadedImage ?: self.image;
+  return self.loadedImage ?: self.placeholderImage;
 }
 
 - (void)handleLoadedImage:(RCTUIImage *)image
@@ -146,7 +186,15 @@ static NSMapTable<NSString *, ENRMImageAttachment *> *_attachmentRegistry;
   if (!image)
     return;
 
+  // The downloader completes synchronously on cache hits, which can happen on the render queue
+  if (!NSThread.isMainThread) {
+    dispatch_async(dispatch_get_main_queue(), ^{ [self handleLoadedImage:image]; });
+    return;
+  }
+
   self.originalImage = image;
+  // UIKit reads the plain image property for save/drag/copy — it must hold the original
+  self.image = image;
   CGFloat targetWidth = self.isInline ? self.cachedHeight : self.bounds.size.width;
 
   // Defer processing if we don't have valid bounds yet (common for non-inline block images)
@@ -162,7 +210,10 @@ static NSMapTable<NSString *, ENRMImageAttachment *> *_attachmentRegistry;
   if (targetWidth <= 0)
     return;
 
-  NSString *processedKey = CACHE_KEY_PROCESSED(self.imageURL, targetWidth, self.cachedHeight, self.cachedBorderRadius);
+  CGFloat boxHeight = self.isInline ? self.cachedHeight : [self resolvedBoxHeightForWidth:targetWidth];
+
+  NSString *processedKey =
+      CACHE_KEY_PROCESSED(self.cacheKey, targetWidth, boxHeight, self.cachedBorderRadius, self.cachedResizeMode);
 
   if ([processedKey isEqualToString:self.lastProcessedKey])
     return;
@@ -172,8 +223,6 @@ static NSMapTable<NSString *, ENRMImageAttachment *> *_attachmentRegistry;
 
   if (cachedProcessed) {
     self.loadedImage = cachedProcessed;
-    if (self.isInline)
-      self.image = cachedProcessed;
     [self refreshDisplay];
     return;
   }
@@ -186,7 +235,7 @@ static NSMapTable<NSString *, ENRMImageAttachment *> *_attachmentRegistry;
 
     RCTUIImage *processedImage = [strongSelf createScaledImage:image
                                                        toWidth:targetWidth
-                                                        height:strongSelf.cachedHeight
+                                                        height:boxHeight
                                                   borderRadius:strongSelf.cachedBorderRadius];
 
     if (processedImage) {
@@ -198,10 +247,7 @@ static NSMapTable<NSString *, ENRMImageAttachment *> *_attachmentRegistry;
     dispatch_async(dispatch_get_main_queue(), ^{
       strongSelf.loadedImage = processedImage;
       if (strongSelf.isInline) {
-        strongSelf.image = processedImage;
         strongSelf.bounds = CGRectMake(0, 0, strongSelf.cachedHeight, strongSelf.cachedHeight);
-      } else {
-        strongSelf.image = image; // Keep original for layout references
       }
       [strongSelf refreshDisplay];
     });
@@ -218,32 +264,64 @@ static NSMapTable<NSString *, ENRMImageAttachment *> *_attachmentRegistry;
   if (sourceWidth <= 0 || sourceHeight <= 0)
     return nil;
 
-  CGFloat drawingWidth, drawingHeight;
+  CGSize source = CGSizeMake(sourceWidth, sourceHeight);
+  CGSize box = CGSizeMake(targetWidth, targetHeight);
+  BOOL legacy = [self isLegacyBlockSizing];
 
-  if (!self.isInline) {
-    CGFloat aspectRatioScale = targetWidth / sourceWidth;
-    drawingWidth = targetWidth;
-    drawingHeight = sourceHeight * aspectRatioScale;
+  CGRect drawingRect;
+  if (self.isInline || legacy) {
+    CGFloat drawingWidth, drawingHeight;
+    if (!self.isInline) {
+      CGFloat aspectRatioScale = targetWidth / sourceWidth;
+      drawingWidth = targetWidth;
+      drawingHeight = sourceHeight * aspectRatioScale;
+    } else {
+      drawingWidth = targetWidth;
+      drawingHeight = targetHeight;
+    }
+    drawingRect = CGRectMake((targetWidth - drawingWidth) / 2.0, (targetHeight - drawingHeight) / 2.0, drawingWidth,
+                             drawingHeight);
   } else {
-    drawingWidth = targetWidth;
-    drawingHeight = targetHeight;
+    drawingRect = [self drawingRectForResizeMode:self.cachedResizeMode source:source box:box];
   }
 
-  CGRect drawingRect =
-      CGRectMake((targetWidth - drawingWidth) / 2.0, (targetHeight - drawingHeight) / 2.0, drawingWidth, drawingHeight);
-
-  RCTUIGraphicsImageRenderer *renderer = ImageRendererForSize(CGSizeMake(targetWidth, targetHeight));
+  RCTUIGraphicsImageRenderer *renderer = ImageRendererForSize(box);
 
   return [renderer imageWithActions:^(RCTUIGraphicsImageRendererContext *context) {
     if (radius > 0) {
-      CGRect clippingRect = CGRectIntersection(CGRectMake(0, 0, targetWidth, targetHeight), drawingRect);
-      UIBezierPath *path = UIBezierPathWithRoundedRect(clippingRect, radius);
+      CGRect clipRect = CGRectIntersection(CGRectMake(0, 0, targetWidth, targetHeight), drawingRect);
+      UIBezierPath *path = UIBezierPathWithRoundedRect(clipRect, radius);
       [path addClip];
     }
     [image drawInRect:drawingRect];
   }];
 }
 
+- (CGRect)drawingRectForResizeMode:(NSString *)mode source:(CGSize)source box:(CGSize)box
+{
+  if ([mode isEqualToString:@"stretch"]) {
+    return CGRectMake(0, 0, box.width, box.height);
+  }
+
+  CGFloat widthScale = box.width / source.width;
+  CGFloat heightScale = box.height / source.height;
+
+  CGFloat scale;
+  if ([mode isEqualToString:@"contain"]) {
+    scale = MIN(widthScale, heightScale);
+  } else if ([mode isEqualToString:@"center"]) {
+    scale = MIN(1.0, MIN(widthScale, heightScale));
+  } else if ([mode isEqualToString:@"none"]) {
+    scale = 1.0;
+  } else { // cover (default)
+    scale = MAX(widthScale, heightScale);
+  }
+
+  CGFloat drawingWidth = source.width * scale;
+  CGFloat drawingHeight = source.height * scale;
+  return CGRectMake((box.width - drawingWidth) / 2.0, (box.height - drawingHeight) / 2.0, drawingWidth, drawingHeight);
+}
+
 - (void)startDownloadingImage
 {
   if (self.imageURL.length == 0)
@@ -251,6 +329,7 @@ static NSMapTable<NSString *, ENRMImageAttachment *> *_attachmentRegistry;
 
   __weak typeof(self) weakSelf = self;
   [[ENRMImageDownloader shared] downloadURL:self.imageURL
+                                    headers:self.requestHeaders
                                  completion:^(RCTUIImage *image) { [weakSelf handleLoadedImage:image]; }];
 }
 
@@ -265,10 +344,34 @@ static NSMapTable<NSString *, ENRMImageAttachment *> *_attachmentRegistry;
     [textView.layoutManager invalidateDisplayForCharacterRange:range];
     if (!self.isInline) {
       [textView.layoutManager invalidateLayoutForCharacterRange:range actualCharacterRange:NULL];
+      [self notifyImageLayoutObserver:textView];
     }
   }
 }
 
+// With maxHeight/aspectRatio sizing the box height can settle after the image
+// loads, while the component was measured (and its size cached) with the
+// pre-load fallback. Notify the hosting component so it can re-measure.
+// Dispatched async: refreshDisplay can run mid-layout (imageForBounds) and
+// re-measuring would re-enter the layout manager.
+- (void)notifyImageLayoutObserver:(UITextView *)textView
+{
+  // Only maxHeight/aspectRatio boxes can change height after load; a fixed
+  // height box (legacy or explicit resizeMode) never needs a re-measure.
+  if (self.cachedMaxHeight <= 0 && self.cachedAspectRatio <= 0)
+    return;
+
+  RCTUIView *candidate = textView;
+  while (candidate && ![candidate conformsToProtocol:@protocol(ENRMImageLayoutObserver)]) {
+    candidate = candidate.superview;
+  }
+  if (!candidate)
+    return;
+
+  id<ENRMImageLayoutObserver> observer = (id<ENRMImageLayoutObserver>)candidate;
+  dispatch_async(dispatch_get_main_queue(), ^{ [observer imageAttachmentDidResolveLayout]; });
+}
+
 - (ENRMPlatformTextView *)fetchAssociatedTextView
 {
   if (self.textView)
@@ -284,7 +387,7 @@ static NSMapTable<NSString *, ENRMImageAttachment *> *_attachmentRegistry;
   CGFloat size = self.cachedHeight;
   self.bounds = CGRectMake(0, 0, size, size);
   RCTUIGraphicsImageRenderer *renderer = [[RCTUIGraphicsImageRenderer alloc] initWithSize:CGSizeMake(1, 1)];
-  self.image = [renderer imageWithActions:^(RCTUIGraphicsImageRendererContext *ctx){}];
+  self.placeholderImage = [renderer imageWithActions:^(RCTUIGraphicsImageRendererContext *ctx){}];
 }
 
 - (NSRange)findAttachmentRangeInText:(NSAttributedString *)attributedString
@@ -302,4 +405,4 @@ static NSMapTable<NSString *, ENRMImageAttachment *> *_attachmentRegistry;
   return foundRange;
 }
 
-@end
+@end

package/ios/attachments/ENRMMathInlineAttachment+macOS.m

@@ -29,7 +29,8 @@
                                              displayMode:NO
                                                 fontSize:self.fontSize
                                                    color:color
-                                                    bold:self.bold];
+                                                    bold:self.bold
+                                           glyphOverflow:self.glyphOverflow];
   if (!result)
     return;
 

package/ios/attachments/ENRMMathInlineAttachment.h

@@ -9,9 +9,14 @@ NS_ASSUME_NONNULL_BEGIN
 @property (nonatomic, assign) CGFloat fontSize;
 @property (nonatomic, strong, nullable) RCTUIColor *mathTextColor;
 
+@property (nonatomic, readonly) CGFloat boxHeight;
+
 /// Typeset the glyphs at bold weight (synthetic — see ENRMRaTeXBridge).
 @property (nonatomic, assign) BOOL bold;
 
+/// Ink headroom above and below the formula box (`inlineMath.glyphOverflow`, points).
+@property (nonatomic, assign) CGFloat glyphOverflow;
+
 /// YES if block math (`$$...$$`), NO for inline (`$...$`).
 @property (nonatomic, assign) BOOL displayMode;
 

package/ios/attachments/ENRMMathInlineAttachment.m

@@ -1,3 +1,4 @@
+#import "ENRMMathFallback.h"
 #import "ENRMMathInlineAttachmentShared.h"
 
 #if ENRICHED_MARKDOWN_MATH
@@ -10,21 +11,50 @@
 
 @implementation ENRMMathInlineAttachment
 
+- (CGFloat)boxHeight
+{
+#if !TARGET_OS_OSX
+  [self prepareIfNeeded];
+#endif
+  return _cachedSize.height + _containerPaddingVertical * 2;
+}
+
+/// Clears the cached glyph render so the next layout regenerates it
+/// (e.g. after style or latex changes).
+- (void)invalidateRender
+{
+  _renderResult = nil;
+  _fallbackSource = nil;
+  _cachedSize = CGSizeZero;
+  _mathAscent = 0;
+  _mathDescent = 0;
+}
+
 #if !TARGET_OS_OSX
 
 - (void)prepareIfNeeded
 {
-  if (_renderResult)
+  if (_renderResult || _fallbackSource)
     return;
 
   RCTUIColor *color = self.mathTextColor ?: [RCTUIColor blackColor];
   ENRMRaTeXRenderResult *result = [ENRMRaTeXBridge parse:self.latex
-                                             displayMode:self.displayMode
+                                             displayMode:NO
                                                 fontSize:self.fontSize
                                                    color:color
-                                                    bold:self.bold];
-  if (!result)
+                                                    bold:self.bold
+                                           glyphOverflow:self.glyphOverflow];
+  if (!result) {
+    _fallbackSource = ENRMMathFallbackString(self.latex, @"$", self.fontSize, color);
+    UIFont *font = [_fallbackSource attribute:NSFontAttributeName atIndex:0 effectiveRange:NULL];
+    CGRect bounds = [_fallbackSource boundingRectWithSize:CGSizeMake(CGFLOAT_MAX, CGFLOAT_MAX)
+                                                  options:NSStringDrawingUsesLineFragmentOrigin
+                                                  context:nil];
+    _mathAscent = font.ascender;
+    _mathDescent = -font.descender;
+    _cachedSize = CGSizeMake(ceil(bounds.size.width), ceil(_mathAscent + _mathDescent));
     return;
+  }
 
   _renderResult = result;
   _mathAscent = result.ascent;
@@ -32,33 +62,16 @@
   _cachedSize = CGSizeMake(ceil(result.width), ceil(result.totalHeight));
 }
 
-- (void)invalidateRender
-{
-  _renderResult = nil;
-  _cachedSize = CGSizeZero;
-  _mathAscent = 0;
-  _mathDescent = 0;
-}
-
 - (CGRect)attachmentBoundsForTextContainer:(NSTextContainer *)textContainer
                       proposedLineFragment:(CGRect)lineFragment
                              glyphPosition:(CGPoint)position
                             characterIndex:(NSUInteger)characterIndex
 {
   [self prepareIfNeeded];
-
-  CGFloat intrinsicW = _cachedSize.width + _containerPaddingHorizontal * 2;
-  CGFloat totalH = _cachedSize.height + _containerPaddingVertical * 2;
-
-  if (_displayMode) {
-    totalH += _blockMarginTop + _blockMarginBottom;
-    // Block chip claims the full line fragment so text can't share the row.
-    // Fall back to intrinsic width when the proposed fragment is degenerate
-    // (e.g. during initial layout before the text container has a size).
-    CGFloat fullW = MAX(lineFragment.size.width, intrinsicW);
-    return CGRectMake(0, -(_mathDescent + _containerPaddingVertical + _blockMarginBottom), fullW, totalH);
-  }
-  return CGRectMake(0, -(_mathDescent + _containerPaddingVertical), intrinsicW, totalH);
+  // inlineMath.paddingVertical grows the glyph box symmetrically so a tall formula
+  // (\frac, \sum) stops sitting flush against the neighbouring line.
+  return CGRectMake(0, -(_mathDescent + _containerPaddingVertical), _cachedSize.width,
+                    _cachedSize.height + _containerPaddingVertical * 2);
 }
 
 - (UIImage *)imageForBounds:(CGRect)imageBounds
@@ -66,72 +79,27 @@
              characterIndex:(NSUInteger)characterIndex
 {
   [self prepareIfNeeded];
-  if (!_renderResult)
+  if (!_renderResult && !_fallbackSource)
     return nil;
 
-  // Block chips claim the full line fragment (set in attachmentBounds…), so
-  // the canvas is `imageBounds.width` wide and the formula floats inside it
-  // according to `blockAlignment`. Inline chips fall back to intrinsic width.
-  CGFloat intrinsicW = _cachedSize.width + _containerPaddingHorizontal * 2;
-  CGFloat totalW = (_displayMode && imageBounds.size.width > intrinsicW) ? imageBounds.size.width : intrinsicW;
-  CGFloat totalH = _cachedSize.height + _containerPaddingVertical * 2;
-  CGSize totalSize = CGSizeMake(totalW, totalH);
-
-  RCTUIColor *bg = _isSelected ? (_selectedBackgroundColor ?: _containerBackgroundColor) : _containerBackgroundColor;
-  RCTUIColor *border = _isSelected ? (_selectedBorderColor ?: _containerBorderColor) : _containerBorderColor;
-  CGFloat borderWidth = _containerBorderWidth;
-  CGFloat borderRadius = _containerBorderRadius;
-  CGFloat padH = _containerPaddingHorizontal;
-  CGFloat padV = _containerPaddingVertical;
-  ENRMRaTeXRenderResult *render = _renderResult;
-  CGFloat formulaW = _cachedSize.width;
-  NSTextAlignment alignment = _blockAlignment;
-  BOOL displayMode = _displayMode;
-
   UIGraphicsImageRendererFormat *format = [UIGraphicsImageRendererFormat preferredFormat];
   format.opaque = NO;
 
-  UIGraphicsImageRenderer *renderer = [[UIGraphicsImageRenderer alloc] initWithSize:totalSize format:format];
+  CGFloat padV = _containerPaddingVertical;
+  CGSize boxSize = CGSizeMake(_cachedSize.width, _cachedSize.height + padV * 2);
+  UIGraphicsImageRenderer *renderer = [[UIGraphicsImageRenderer alloc] initWithSize:boxSize format:format];
 
   return [renderer imageWithActions:^(UIGraphicsImageRendererContext *rendererContext) {
     CGContextRef ctx = rendererContext.CGContext;
-
-    if (bg) {
-      CGFloat inset = borderWidth / 2.0;
-      CGRect rect = CGRectMake(inset, inset, totalW - borderWidth, totalH - borderWidth);
-      UIBezierPath *path = [UIBezierPath bezierPathWithRoundedRect:rect cornerRadius:borderRadius];
-      [bg setFill];
-      [path fill];
-    }
-
-    if (border && borderWidth > 0) {
-      CGFloat inset = borderWidth / 2.0;
-      CGRect rect = CGRectMake(inset, inset, totalW - borderWidth, totalH - borderWidth);
-      UIBezierPath *path = [UIBezierPath bezierPathWithRoundedRect:rect cornerRadius:borderRadius];
-      [border setStroke];
-      path.lineWidth = borderWidth;
-      [path stroke];
-    }
-
-    CGFloat glyphOffset = padH;
-    if (displayMode && totalW > intrinsicW) {
-      CGFloat slack = totalW - formulaW - padH * 2;
-      switch (alignment) {
-        case NSTextAlignmentCenter:
-          glyphOffset = padH + slack / 2.0;
-          break;
-        case NSTextAlignmentRight:
-          glyphOffset = padH + slack;
-          break;
-        default:
-          glyphOffset = padH;
-          break;
-      }
-    }
-
     CGContextSaveGState(ctx);
-    CGContextTranslateCTM(ctx, glyphOffset, padV);
-    [render drawIn:ctx];
+    CGContextTranslateCTM(ctx, 0, padV);
+    if (_renderResult) {
+      [_renderResult drawIn:ctx];
+    } else {
+      [_fallbackSource drawWithRect:CGRectMake(0, 0, _cachedSize.width, _cachedSize.height)
+                            options:NSStringDrawingUsesLineFragmentOrigin
+                            context:nil];
+    }
     CGContextRestoreGState(ctx);
   }];
 }

package/ios/attachments/ENRMMathInlineAttachmentShared.h

@@ -11,6 +11,8 @@
   CGFloat _mathAscent;
   CGFloat _mathDescent;
   ENRMRaTeXRenderResult *_renderResult;
+  // Visible-source fallback when RaTeX cannot parse the span; see ENRMMathFallback.h.
+  NSAttributedString *_fallbackSource;
 }
 @end