hunk.code_window:   // Package
     shell.sed('-i', `applicationId 'host.exp.exponent'`, `applicationId '${javaPackage}'`, `${shellPath}app/build.gradle`);
     await sedInPlaceAsync('-e', `s/android:name="host.exp.exponent"/android:name="${javaPackage}"/g`, `${shellPath}app/src/main/AndroidManifest.xml`);
     // Remove Exponent build script
     shell.sed('-i', `preBuild.dependsOn generateDynamicMacros`, ``, `${shellPath}app/build.gradle`);
     // change javaMaxHeapSize
     shell.sed('-i', `javaMaxHeapSize "8g"`, `javaMaxHeapSize "6g"`, `${shellPath}app/build.gradle`);
  
hunk.labels: keep keep keep keep add keep keep keep keep keep
hunk.after_edit:   // Versions
     let buildGradleFile = await fs.promise.readFile(`${shellPath}app/build.gradle`, 'utf8');
     let androidVersion = buildGradleFile.match(/versionName '(\S+)'/)[1];
     shell.sed('-i', 'VERSION_NAME = null', `VERSION_NAME = "${androidVersion}"`, `${shellPath}app/src/main/java/host/exp/exponent/Constants.java`);
     await sedInPlaceAsync('-e', `/BEGIN\ VERSIONS/,/END\ VERSIONS/d`, `${shellPath}app/build.gradle`);
     shell.sed('-i', '// ADD VERSIONS HERE', `versionCode ${versionCode}
       versionName '${version}'`, `${shellPath}app/build.gradle`);
  
hunk.file_path: tools-public/android-shell-app.js
hunk.type: add
file: /**
   * Copyright (c) 2015-present, Facebook, Inc.
   * All rights reserved.
   *
   * This source code is licensed under the BSD-style license found in the
   * LICENSE file in the root directory of this source tree. An additional grant
   * of patent rights can be found in the PATENTS file in the same directory.
   */
  
  #import "ABI7_0_0RCTShadowText.h"
  
  #import "ABI7_0_0RCTAccessibilityManager.h"
  #import "ABI7_0_0RCTUIManager.h"
  #import "ABI7_0_0RCTBridge.h"
  #import "ABI7_0_0RCTConvert.h"
  #import "ABI7_0_0RCTLog.h"
  #import "ABI7_0_0RCTShadowRawText.h"
  #import "ABI7_0_0RCTText.h"
  #import "ABI7_0_0RCTUtils.h"
  
  NSString *const ABI7_0_0RCTShadowViewAttributeName = @"ABI7_0_0RCTShadowViewAttributeName";
  NSString *const ABI7_0_0RCTIsHighlightedAttributeName = @"IsHighlightedAttributeName";
  NSString *const ABI7_0_0RCTReactABI7_0_0TagAttributeName = @"ReactABI7_0_0TagAttributeName";
  
  @implementation ABI7_0_0RCTShadowText
  {
    NSTextStorage *_cachedTextStorage;
    CGFloat _cachedTextStorageWidth;
    CGFloat _cachedTextStorageWidthMode;
    NSAttributedString *_cachedAttributedString;
    CGFloat _effectiveLetterSpacing;
  }
  
  static css_dim_t ABI7_0_0RCTMeasure(void *context, float width, css_measure_mode_t widthMode, float height, css_measure_mode_t heightMode)
  {
    ABI7_0_0RCTShadowText *shadowText = (__bridge ABI7_0_0RCTShadowText *)context;
    NSTextStorage *textStorage = [shadowText buildTextStorageForWidth:width widthMode:widthMode];
    NSLayoutManager *layoutManager = textStorage.layoutManagers.firstObject;
    NSTextContainer *textContainer = layoutManager.textContainers.firstObject;
    CGSize computedSize = [layoutManager usedRectForTextContainer:textContainer].size;
  
    css_dim_t result;
    result.dimensions[CSS_WIDTH] = ABI7_0_0RCTCeilPixelValue(computedSize.width);
    if (shadowText->_effectiveLetterSpacing < 0) {
      result.dimensions[CSS_WIDTH] -= shadowText->_effectiveLetterSpacing;
    }
    result.dimensions[CSS_HEIGHT] = ABI7_0_0RCTCeilPixelValue(computedSize.height);
    return result;
  }
  
  - (instancetype)init
  {
    if ((self = [super init])) {
      _fontSize = NAN;
      _letterSpacing = NAN;
      _isHighlighted = NO;
      _textDecorationStyle = NSUnderlineStyleSingle;
      _opacity = 1.0;
      _cachedTextStorageWidth = -1;
      _cachedTextStorageWidthMode = -1;
      _fontSizeMultiplier = 1.0;
      [[NSNotificationCenter defaultCenter] addObserver:self
                                               selector:@selector(contentSizeMultiplierDidChange:)
                                                   name:ABI7_0_0RCTUIManagerWillUpdateViewsDueToContentSizeMultiplierChangeNotification
                                                 object:nil];
    }
    return self;
  }
  
  - (void)dealloc
  {
    [[NSNotificationCenter defaultCenter] removeObserver:self];
  }
  
  - (NSString *)description
  {
    NSString *superDescription = super.description;
    return [[superDescription substringToIndex:superDescription.length - 1] stringByAppendingFormat:@"; text: %@>", [self attributedString].string];
  }
  
  - (void)contentSizeMultiplierDidChange:(NSNotification *)note
  {
    [self dirtyLayout];
    [self dirtyText];
  }
  
  - (NSDictionary<NSString *, id> *)processUpdatedProperties:(NSMutableSet<ABI7_0_0RCTApplierBlock> *)applierBlocks
                                            parentProperties:(NSDictionary<NSString *, id> *)parentProperties
  {
    if ([[self ReactABI7_0_0Superview] isKindOfClass:[ABI7_0_0RCTShadowText class]]) {
      return parentProperties;
    }
  
    parentProperties = [super processUpdatedProperties:applierBlocks
                                      parentProperties:parentProperties];
  
    UIEdgeInsets padding = self.paddingAsInsets;
    CGFloat width = self.frame.size.width - (padding.left + padding.right);
  
    NSTextStorage *textStorage = [self buildTextStorageForWidth:width widthMode:CSS_MEASURE_MODE_EXACTLY];
    [applierBlocks addObject:^(NSDictionary<NSNumber *, ABI7_0_0RCTText *> *viewRegistry) {
      ABI7_0_0RCTText *view = viewRegistry[self.ReactABI7_0_0Tag];
      view.textStorage = textStorage;
    }];
  
    return parentProperties;
  }
  
  - (void)applyLayoutNode:(css_node_t *)node
        viewsWithNewFrame:(NSMutableSet<ABI7_0_0RCTShadowView *> *)viewsWithNewFrame
         absolutePosition:(CGPoint)absolutePosition
  {
    [super applyLayoutNode:node viewsWithNewFrame:viewsWithNewFrame absolutePosition:absolutePosition];
    [self dirtyPropagation];
  }
  
  - (void)applyLayoutToChildren:(css_node_t *)node
              viewsWithNewFrame:(NSMutableSet<ABI7_0_0RCTShadowView *> *)viewsWithNewFrame
               absolutePosition:(CGPoint)absolutePosition
  {
    // Run layout on subviews.
    NSTextStorage *textStorage = [self buildTextStorageForWidth:self.frame.size.width widthMode:CSS_MEASURE_MODE_EXACTLY];
    NSLayoutManager *layoutManager = textStorage.layoutManagers.firstObject;
    NSTextContainer *textContainer = layoutManager.textContainers.firstObject;
    NSRange glyphRange = [layoutManager glyphRangeForTextContainer:textContainer];
    NSRange characterRange = [layoutManager characterRangeForGlyphRange:glyphRange actualGlyphRange:NULL];
    [layoutManager.textStorage enumerateAttribute:ABI7_0_0RCTShadowViewAttributeName inRange:characterRange options:0 usingBlock:^(ABI7_0_0RCTShadowView *child, NSRange range, BOOL *_) {
      if (child != nil) {
        css_node_t *childNode = child.cssNode;
        float width = childNode->style.dimensions[CSS_WIDTH];
        float height = childNode->style.dimensions[CSS_HEIGHT];
        if (isUndefined(width) || isUndefined(height)) {
          ABI7_0_0RCTLogError(@"Views nested within a <Text> must have a width and height");
        }
        UIFont *font = [textStorage attribute:NSFontAttributeName atIndex:range.location effectiveRange:nil];
        CGRect glyphRect = [layoutManager boundingRectForGlyphRange:range inTextContainer:textContainer];
        CGRect childFrame = {{
          ABI7_0_0RCTRoundPixelValue(glyphRect.origin.x),
          ABI7_0_0RCTRoundPixelValue(glyphRect.origin.y + glyphRect.size.height - height + font.descender)
        }, {
          ABI7_0_0RCTRoundPixelValue(width),
          ABI7_0_0RCTRoundPixelValue(height)
        }};
  
        NSRange truncatedGlyphRange = [layoutManager truncatedGlyphRangeInLineFragmentForGlyphAtIndex:range.location];
        BOOL childIsTruncated = NSIntersectionRange(range, truncatedGlyphRange).length != 0;
  
        [child collectUpdatedFrames:viewsWithNewFrame
                          withFrame:childFrame
                             hidden:childIsTruncated
                   absolutePosition:absolutePosition];
      }
    }];
  }
  
  - (NSTextStorage *)buildTextStorageForWidth:(CGFloat)width widthMode:(css_measure_mode_t)widthMode
  {
    if (_cachedTextStorage && width == _cachedTextStorageWidth && widthMode == _cachedTextStorageWidthMode) {
      return _cachedTextStorage;
    }
  
    NSLayoutManager *layoutManager = [NSLayoutManager new];
  
    NSTextStorage *textStorage = [[NSTextStorage alloc] initWithAttributedString:self.attributedString];
    [textStorage addLayoutManager:layoutManager];
  
    NSTextContainer *textContainer = [NSTextContainer new];
    textContainer.lineFragmentPadding = 0.0;
    textContainer.lineBreakMode = _numberOfLines > 0 ? NSLineBreakByTruncatingTail : NSLineBreakByClipping;
    textContainer.maximumNumberOfLines = _numberOfLines;
    textContainer.size = (CGSize){widthMode == CSS_MEASURE_MODE_UNDEFINED ? CGFLOAT_MAX : width, CGFLOAT_MAX};
  
    [layoutManager addTextContainer:textContainer];
    [layoutManager ensureLayoutForTextContainer:textContainer];
  
    _cachedTextStorageWidth = width;
    _cachedTextStorageWidthMode = widthMode;
    _cachedTextStorage = textStorage;
  
    return textStorage;
  }
  
  - (void)dirtyText
  {
    [super dirtyText];
    _cachedTextStorage = nil;
  }
  
  - (void)recomputeText
  {
    [self attributedString];
    [self setTextComputed];
    [self dirtyPropagation];
  }
  
  - (NSAttributedString *)attributedString
  {
    return [self _attributedStringWithFontFamily:nil
                                        fontSize:nil
                                      fontWeight:nil
                                       fontStyle:nil
                                   letterSpacing:nil
                              useBackgroundColor:NO
                                 foregroundColor:self.color ?: [UIColor blackColor]
                                 backgroundColor:self.backgroundColor
                                         opacity:self.opacity];
  }
  
  - (NSAttributedString *)_attributedStringWithFontFamily:(NSString *)fontFamily
                                                 fontSize:(NSNumber *)fontSize
                                               fontWeight:(NSString *)fontWeight
                                                fontStyle:(NSString *)fontStyle
                                            letterSpacing:(NSNumber *)letterSpacing
                                       useBackgroundColor:(BOOL)useBackgroundColor
                                          foregroundColor:(UIColor *)foregroundColor
                                          backgroundColor:(UIColor *)backgroundColor
                                                  opacity:(CGFloat)opacity
  {
    if (![self isTextDirty] && _cachedAttributedString) {
      return _cachedAttributedString;
    }
  
    if (_fontSize && !isnan(_fontSize)) {
      fontSize = @(_fontSize);
    }
    if (_fontWeight) {
      fontWeight = _fontWeight;
    }
    if (_fontStyle) {
      fontStyle = _fontStyle;
    }
    if (_fontFamily) {
      fontFamily = _fontFamily;
    }
    if (!isnan(_letterSpacing)) {
      letterSpacing = @(_letterSpacing);
    }
  
    _effectiveLetterSpacing = letterSpacing.doubleValue;
  
    UIFont *font = [ABI7_0_0RCTConvert UIFont:nil withFamily:fontFamily
                                 size:fontSize weight:fontWeight style:fontStyle
                      scaleMultiplier:_allowFontScaling ? _fontSizeMultiplier : 1.0];
  
    CGFloat heightOfTallestSubview = 0.0;
    NSMutableAttributedString *attributedString = [NSMutableAttributedString new];
    for (ABI7_0_0RCTShadowView *child in [self ReactABI7_0_0Subviews]) {
      if ([child isKindOfClass:[ABI7_0_0RCTShadowText class]]) {
        ABI7_0_0RCTShadowText *shadowText = (ABI7_0_0RCTShadowText *)child;
        [attributedString appendAttributedString:
         [shadowText _attributedStringWithFontFamily:fontFamily
                                            fontSize:fontSize
                                          fontWeight:fontWeight
                                           fontStyle:fontStyle
                                       letterSpacing:letterSpacing
                                  useBackgroundColor:YES
                                     foregroundColor:shadowText.color ?: foregroundColor
                                     backgroundColor:shadowText.backgroundColor ?: backgroundColor
                                             opacity:opacity * shadowText.opacity]];
        [child setTextComputed];
      } else if ([child isKindOfClass:[ABI7_0_0RCTShadowRawText class]]) {
        ABI7_0_0RCTShadowRawText *shadowRawText = (ABI7_0_0RCTShadowRawText *)child;
        [attributedString appendAttributedString:[[NSAttributedString alloc] initWithString:shadowRawText.text ?: @""]];
        [child setTextComputed];
      } else {
        float width = child.cssNode->style.dimensions[CSS_WIDTH];
        float height = child.cssNode->style.dimensions[CSS_HEIGHT];
        if (isUndefined(width) || isUndefined(height)) {
          ABI7_0_0RCTLogError(@"Views nested within a <Text> must have a width and height");
        }
        NSTextAttachment *attachment = [NSTextAttachment new];
        attachment.bounds = (CGRect){CGPointZero, {width, height}};
        NSMutableAttributedString *attachmentString = [NSMutableAttributedString new];
        [attachmentString appendAttributedString:[NSAttributedString attributedStringWithAttachment:attachment]];
        [attachmentString addAttribute:ABI7_0_0RCTShadowViewAttributeName value:child range:(NSRange){0, attachmentString.length}];
        [attributedString appendAttributedString:attachmentString];
        if (height > heightOfTallestSubview) {
          heightOfTallestSubview = height;
        }
        // Don't call setTextComputed on this child. ABI7_0_0RCTTextManager takes care of
        // processing inline UIViews.
      }
    }
  
    [self _addAttribute:NSForegroundColorAttributeName
              withValue:[foregroundColor colorWithAlphaComponent:CGColorGetAlpha(foregroundColor.CGColor) * opacity]
     toAttributedString:attributedString];
  
    if (_isHighlighted) {
      [self _addAttribute:ABI7_0_0RCTIsHighlightedAttributeName withValue:@YES toAttributedString:attributedString];
    }
    if (useBackgroundColor && backgroundColor) {
      [self _addAttribute:NSBackgroundColorAttributeName
                withValue:[backgroundColor colorWithAlphaComponent:CGColorGetAlpha(backgroundColor.CGColor) * opacity]
       toAttributedString:attributedString];
    }
  
    [self _addAttribute:NSFontAttributeName withValue:font toAttributedString:attributedString];
    [self _addAttribute:NSKernAttributeName withValue:letterSpacing toAttributedString:attributedString];
    [self _addAttribute:ABI7_0_0RCTReactABI7_0_0TagAttributeName withValue:self.ReactABI7_0_0Tag toAttributedString:attributedString];
    [self _setParagraphStyleOnAttributedString:attributedString heightOfTallestSubview:heightOfTallestSubview];
  
    // create a non-mutable attributedString for use by the Text system which avoids copies down the line
    _cachedAttributedString = [[NSAttributedString alloc] initWithAttributedString:attributedString];
    [self dirtyLayout];
  
    return _cachedAttributedString;
  }
  
  - (void)_addAttribute:(NSString *)attribute withValue:(id)attributeValue toAttributedString:(NSMutableAttributedString *)attributedString
  {
    [attributedString enumerateAttribute:attribute inRange:NSMakeRange(0, attributedString.length) options:0 usingBlock:^(id value, NSRange range, BOOL *stop) {
      if (!value && attributeValue) {
        [attributedString addAttribute:attribute value:attributeValue range:range];
      }
    }];
  }
  
  /*
   * LineHeight works the same way line-height works in the web: if children and self have
   * varying lineHeights, we simply take the max.
   */
  - (void)_setParagraphStyleOnAttributedString:(NSMutableAttributedString *)attributedString
                        heightOfTallestSubview:(CGFloat)heightOfTallestSubview
  {
    // check if we have lineHeight set on self
    __block BOOL hasParagraphStyle = NO;
    if (_lineHeight || _textAlign) {
      hasParagraphStyle = YES;
    }
  
    __block float newLineHeight = _lineHeight ?: 0.0;
  
    CGFloat fontSizeMultiplier = _allowFontScaling ? _fontSizeMultiplier : 1.0;
  
    // check for lineHeight on each of our children, update the max as we go (in self.lineHeight)
    [attributedString enumerateAttribute:NSParagraphStyleAttributeName inRange:(NSRange){0, attributedString.length} options:0 usingBlock:^(id value, NSRange range, BOOL *stop) {
      if (value) {
        NSParagraphStyle *paragraphStyle = (NSParagraphStyle *)value;
        CGFloat maximumLineHeight = round(paragraphStyle.maximumLineHeight / fontSizeMultiplier);
        if (maximumLineHeight > newLineHeight) {
          newLineHeight = maximumLineHeight;
        }
        hasParagraphStyle = YES;
      }
    }];
  
    if (self.lineHeight != newLineHeight) {
      self.lineHeight = newLineHeight;
    }
  
    NSTextAlignment newTextAlign = _textAlign ?: NSTextAlignmentNatural;
    if (self.textAlign != newTextAlign) {
      self.textAlign = newTextAlign;
    }
    NSWritingDirection newWritingDirection = _writingDirection ?: NSWritingDirectionNatural;
    if (self.writingDirection != newWritingDirection) {
      self.writingDirection = newWritingDirection;
    }
  
    // if we found anything, set it :D
    if (hasParagraphStyle) {
      NSMutableParagraphStyle *paragraphStyle = [NSMutableParagraphStyle new];
      paragraphStyle.alignment = _textAlign;
      paragraphStyle.baseWritingDirection = _writingDirection;
      CGFloat lineHeight = round(_lineHeight * fontSizeMultiplier);
      if (heightOfTallestSubview > lineHeight) {
        lineHeight = ceilf(heightOfTallestSubview);
      }
      paragraphStyle.minimumLineHeight = lineHeight;
      paragraphStyle.maximumLineHeight = lineHeight;
      [attributedString addAttribute:NSParagraphStyleAttributeName
                               value:paragraphStyle
                               range:(NSRange){0, attributedString.length}];
    }
  
    // Text decoration
    if (_textDecorationLine == ABI7_0_0RCTTextDecorationLineTypeUnderline ||
        _textDecorationLine == ABI7_0_0RCTTextDecorationLineTypeUnderlineStrikethrough) {
      [self _addAttribute:NSUnderlineStyleAttributeName withValue:@(_textDecorationStyle)
       toAttributedString:attributedString];
    }
    if (_textDecorationLine == ABI7_0_0RCTTextDecorationLineTypeStrikethrough ||
        _textDecorationLine == ABI7_0_0RCTTextDecorationLineTypeUnderlineStrikethrough){
      [self _addAttribute:NSStrikethroughStyleAttributeName withValue:@(_textDecorationStyle)
       toAttributedString:attributedString];
    }
    if (_textDecorationColor) {
      [self _addAttribute:NSStrikethroughColorAttributeName withValue:_textDecorationColor
       toAttributedString:attributedString];
      [self _addAttribute:NSUnderlineColorAttributeName withValue:_textDecorationColor
       toAttributedString:attributedString];
    }
  
    // Text shadow
    if (!CGSizeEqualToSize(_textShadowOffset, CGSizeZero)) {
      NSShadow *shadow = [NSShadow new];
      shadow.shadowOffset = _textShadowOffset;
      shadow.shadowBlurRadius = _textShadowRadius;
      shadow.shadowColor = _textShadowColor;
      [self _addAttribute:NSShadowAttributeName withValue:shadow toAttributedString:attributedString];
    }
  }
  
  - (void)fillCSSNode:(css_node_t *)node
  {
    [super fillCSSNode:node];
    node->measure = ABI7_0_0RCTMeasure;
    node->children_count = 0;
  }
  
  - (void)insertReactABI7_0_0Subview:(ABI7_0_0RCTShadowView *)subview atIndex:(NSInteger)atIndex
  {
    [super insertReactABI7_0_0Subview:subview atIndex:atIndex];
    self.cssNode->children_count = 0;
  }
  
  - (void)removeReactABI7_0_0Subview:(ABI7_0_0RCTShadowView *)subview
  {
    [super removeReactABI7_0_0Subview:subview];
    self.cssNode->children_count = 0;
  }
  
  - (void)setBackgroundColor:(UIColor *)backgroundColor
  {
    super.backgroundColor = backgroundColor;
    [self dirtyText];
  }
  
  #define ABI7_0_0RCT_TEXT_PROPERTY(setProp, ivar, type) \
  - (void)set##setProp:(type)value;              \
  {                                              \
    ivar = value;                                \
    [self dirtyText];                            \
  }
  
  ABI7_0_0RCT_TEXT_PROPERTY(Color, _color, UIColor *)
  ABI7_0_0RCT_TEXT_PROPERTY(FontFamily, _fontFamily, NSString *)
  ABI7_0_0RCT_TEXT_PROPERTY(FontSize, _fontSize, CGFloat)
  ABI7_0_0RCT_TEXT_PROPERTY(FontWeight, _fontWeight, NSString *)
  ABI7_0_0RCT_TEXT_PROPERTY(FontStyle, _fontStyle, NSString *)
  ABI7_0_0RCT_TEXT_PROPERTY(IsHighlighted, _isHighlighted, BOOL)
  ABI7_0_0RCT_TEXT_PROPERTY(LetterSpacing, _letterSpacing, CGFloat)
  ABI7_0_0RCT_TEXT_PROPERTY(LineHeight, _lineHeight, CGFloat)
  ABI7_0_0RCT_TEXT_PROPERTY(NumberOfLines, _numberOfLines, NSUInteger)
  ABI7_0_0RCT_TEXT_PROPERTY(TextAlign, _textAlign, NSTextAlignment)
  ABI7_0_0RCT_TEXT_PROPERTY(TextDecorationColor, _textDecorationColor, UIColor *);
  ABI7_0_0RCT_TEXT_PROPERTY(TextDecorationLine, _textDecorationLine, ABI7_0_0RCTTextDecorationLineType);
  ABI7_0_0RCT_TEXT_PROPERTY(TextDecorationStyle, _textDecorationStyle, NSUnderlineStyle);
  ABI7_0_0RCT_TEXT_PROPERTY(WritingDirection, _writingDirection, NSWritingDirection)
  ABI7_0_0RCT_TEXT_PROPERTY(Opacity, _opacity, CGFloat)
  ABI7_0_0RCT_TEXT_PROPERTY(TextShadowOffset, _textShadowOffset, CGSize);
  ABI7_0_0RCT_TEXT_PROPERTY(TextShadowRadius, _textShadowRadius, CGFloat);
  ABI7_0_0RCT_TEXT_PROPERTY(TextShadowColor, _textShadowColor, UIColor *);
  
  - (void)setAllowFontScaling:(BOOL)allowFontScaling
  {
    _allowFontScaling = allowFontScaling;
    for (ABI7_0_0RCTShadowView *child in [self ReactABI7_0_0Subviews]) {
      if ([child isKindOfClass:[ABI7_0_0RCTShadowText class]]) {
        ((ABI7_0_0RCTShadowText *)child).allowFontScaling = allowFontScaling;
      }
    }
    [self dirtyText];
  }
  
  - (void)setFontSizeMultiplier:(CGFloat)fontSizeMultiplier
  {
    _fontSizeMultiplier = fontSizeMultiplier;
    if (_fontSizeMultiplier == 0) {
      ABI7_0_0RCTLogError(@"fontSizeMultiplier value must be > zero.");
      _fontSizeMultiplier = 1.0;
    }
    for (ABI7_0_0RCTShadowView *child in [self ReactABI7_0_0Subviews]) {
      if ([child isKindOfClass:[ABI7_0_0RCTShadowText class]]) {
        ((ABI7_0_0RCTShadowText *)child).fontSizeMultiplier = fontSizeMultiplier;
      }
    }
    [self dirtyText];
  }
  
  @end
  