first commit

node_modules/react-native/Libraries/Text/BaseText/RCTBaseTextShadowView.h

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTShadowView.h>
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+#import "RCTTextAttributes.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+extern NSString *const RCTBaseTextShadowViewEmbeddedShadowViewAttributeName
+    __attribute__((deprecated("This API will be removed along with the legacy architecture.")));
+
+__attribute__((deprecated("This API will be removed along with the legacy architecture.")))
+@interface RCTBaseTextShadowView : RCTShadowView {
+ @protected
+  NSAttributedString *_Nullable cachedAttributedText;
+ @protected
+  RCTTextAttributes *_Nullable cachedTextAttributes;
+}
+
+@property (nonatomic, strong) RCTTextAttributes *textAttributes;
+
+- (NSAttributedString *)attributedTextWithBaseTextAttributes:(nullable RCTTextAttributes *)baseTextAttributes;
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif // RCT_REMOVE_LEGACY_ARCH

node_modules/react-native/Libraries/Text/BaseText/RCTBaseTextShadowView.mm

@@ -0,0 +1,162 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTBaseTextShadowView.h>
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+#import <React/RCTShadowView+Layout.h>
+
+#import <React/RCTRawTextShadowView.h>
+#import <React/RCTVirtualTextShadowView.h>
+
+NSString *const RCTBaseTextShadowViewEmbeddedShadowViewAttributeName =
+    @"RCTBaseTextShadowViewEmbeddedShadowViewAttributeName";
+
+static void RCTInlineViewYogaNodeDirtied(YGNodeConstRef node)
+{
+  // An inline view (a view nested inside of a text node) does not have a parent
+  // in the Yoga tree. Consequently, we have to manually propagate the inline
+  // view's dirty signal up through the text nodes. At some point, it'll reach
+  // the outermost text node which has a Yoga node and then Yoga will take over
+  // the dirty signal propagation.
+  RCTShadowView *inlineView = (__bridge RCTShadowView *)YGNodeGetContext(node);
+  RCTBaseTextShadowView *baseTextShadowView = (RCTBaseTextShadowView *)inlineView.reactSuperview;
+
+  [baseTextShadowView dirtyLayout];
+}
+
+@implementation RCTBaseTextShadowView
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _textAttributes = [RCTTextAttributes new];
+  }
+
+  return self;
+}
+
+- (void)setReactTag:(NSNumber *)reactTag
+{
+  [super setReactTag:reactTag];
+  _textAttributes.tag = reactTag;
+}
+
+#pragma mark - Life Cycle
+
+- (void)insertReactSubview:(RCTShadowView *)subview atIndex:(NSInteger)index
+{
+  [super insertReactSubview:subview atIndex:index];
+
+  [self dirtyLayout];
+
+  if (![subview isKindOfClass:[RCTVirtualTextShadowView class]]) {
+    YGNodeSetDirtiedFunc(subview.yogaNode, RCTInlineViewYogaNodeDirtied);
+  }
+}
+
+- (void)removeReactSubview:(RCTShadowView *)subview
+{
+  if (![subview isKindOfClass:[RCTVirtualTextShadowView class]]) {
+    YGNodeSetDirtiedFunc(subview.yogaNode, NULL);
+  }
+
+  [self dirtyLayout];
+
+  [super removeReactSubview:subview];
+}
+
+#pragma mark - attributedString
+
+- (NSAttributedString *)attributedTextWithBaseTextAttributes:(nullable RCTTextAttributes *)baseTextAttributes
+{
+  RCTTextAttributes *textAttributes;
+
+  if (baseTextAttributes) {
+    textAttributes = [baseTextAttributes copy];
+    [textAttributes applyTextAttributes:self.textAttributes];
+  } else {
+    textAttributes = [self.textAttributes copy];
+  }
+
+  if (cachedAttributedText && [cachedTextAttributes isEqual:textAttributes]) {
+    return cachedAttributedText;
+  }
+
+  NSMutableAttributedString *attributedText = [NSMutableAttributedString new];
+
+  [attributedText beginEditing];
+
+  for (RCTShadowView *shadowView in self.reactSubviews) {
+    // Special Case: RCTRawTextShadowView
+    if ([shadowView isKindOfClass:[RCTRawTextShadowView class]]) {
+      RCTRawTextShadowView *rawTextShadowView = (RCTRawTextShadowView *)shadowView;
+      NSString *text = rawTextShadowView.text;
+      if (text) {
+        NSAttributedString *rawTextAttributedString =
+            [[NSAttributedString alloc] initWithString:[textAttributes applyTextAttributesToText:text]
+                                            attributes:textAttributes.effectiveTextAttributes];
+        [attributedText appendAttributedString:rawTextAttributedString];
+      }
+      continue;
+    }
+
+    // Special Case: RCTBaseTextShadowView
+    if ([shadowView isKindOfClass:[RCTBaseTextShadowView class]]) {
+      RCTBaseTextShadowView *baseTextShadowView = (RCTBaseTextShadowView *)shadowView;
+      NSAttributedString *baseTextAttributedString =
+          [baseTextShadowView attributedTextWithBaseTextAttributes:textAttributes];
+      [attributedText appendAttributedString:baseTextAttributedString];
+      continue;
+    }
+
+    // Generic Case: Any RCTShadowView
+    NSTextAttachment *attachment = [NSTextAttachment new];
+    NSMutableAttributedString *embeddedShadowViewAttributedString = [NSMutableAttributedString new];
+    [embeddedShadowViewAttributedString beginEditing];
+    [embeddedShadowViewAttributedString
+        appendAttributedString:[NSAttributedString attributedStringWithAttachment:attachment]];
+    [embeddedShadowViewAttributedString addAttribute:RCTBaseTextShadowViewEmbeddedShadowViewAttributeName
+                                               value:shadowView
+                                               range:(NSRange){0, embeddedShadowViewAttributedString.length}];
+    [embeddedShadowViewAttributedString endEditing];
+    [attributedText appendAttributedString:embeddedShadowViewAttributedString];
+  }
+
+  [attributedText endEditing];
+
+  [self clearLayout];
+
+  cachedAttributedText = [attributedText copy];
+  cachedTextAttributes = textAttributes;
+
+  return cachedAttributedText;
+}
+
+- (void)dirtyLayout
+{
+  [super dirtyLayout];
+  cachedAttributedText = nil;
+  cachedTextAttributes = nil;
+}
+
+- (void)didUpdateReactSubviews
+{
+  [super didUpdateReactSubviews];
+  [self dirtyLayout];
+}
+
+- (void)didSetProps:(NSArray<NSString *> *)changedProps
+{
+  [super didSetProps:changedProps];
+  [self dirtyLayout];
+}
+
+@end
+
+#endif // RCT_REMOVE_LEGACY_ARCH

node_modules/react-native/Libraries/Text/BaseText/RCTBaseTextViewManager.h

@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTViewManager.h>
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+NS_ASSUME_NONNULL_BEGIN
+
+__attribute__((deprecated("This API will be removed along with the legacy architecture.")))
+@interface RCTBaseTextViewManager : RCTViewManager
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif // RCT_REMOVE_LEGACY_ARCH

node_modules/react-native/Libraries/Text/BaseText/RCTBaseTextViewManager.mm

@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTBaseTextViewManager.h>
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+@implementation RCTBaseTextViewManager
+
+RCT_EXPORT_MODULE(RCTBaseText)
+
+- (UIView *)view
+{
+  RCTAssert(NO, @"The `-[RCTBaseTextViewManager view]` property must be overridden in subclass.");
+  return nil;
+}
+
+- (RCTShadowView *)shadowView
+{
+  RCTAssert(NO, @"The `-[RCTBaseTextViewManager shadowView]` property must be overridden in subclass.");
+  return nil;
+}
+
+#pragma mark - Text Attributes
+
+// Color
+RCT_REMAP_SHADOW_PROPERTY(color, textAttributes.foregroundColor, UIColor)
+RCT_REMAP_SHADOW_PROPERTY(backgroundColor, textAttributes.backgroundColor, UIColor)
+RCT_REMAP_SHADOW_PROPERTY(opacity, textAttributes.opacity, CGFloat)
+// Font
+RCT_REMAP_SHADOW_PROPERTY(fontFamily, textAttributes.fontFamily, NSString)
+RCT_REMAP_SHADOW_PROPERTY(fontSize, textAttributes.fontSize, CGFloat)
+RCT_REMAP_SHADOW_PROPERTY(fontWeight, textAttributes.fontWeight, NSString)
+RCT_REMAP_SHADOW_PROPERTY(fontStyle, textAttributes.fontStyle, NSString)
+RCT_REMAP_SHADOW_PROPERTY(fontVariant, textAttributes.fontVariant, NSArray)
+RCT_REMAP_SHADOW_PROPERTY(allowFontScaling, textAttributes.allowFontScaling, BOOL)
+RCT_REMAP_SHADOW_PROPERTY(dynamicTypeRamp, textAttributes.dynamicTypeRamp, RCTDynamicTypeRamp)
+RCT_REMAP_SHADOW_PROPERTY(maxFontSizeMultiplier, textAttributes.maxFontSizeMultiplier, CGFloat)
+RCT_REMAP_SHADOW_PROPERTY(letterSpacing, textAttributes.letterSpacing, CGFloat)
+// Paragraph Styles
+RCT_REMAP_SHADOW_PROPERTY(lineHeight, textAttributes.lineHeight, CGFloat)
+RCT_REMAP_SHADOW_PROPERTY(textAlign, textAttributes.alignment, NSTextAlignment)
+RCT_REMAP_SHADOW_PROPERTY(writingDirection, textAttributes.baseWritingDirection, NSWritingDirection)
+RCT_REMAP_SHADOW_PROPERTY(lineBreakStrategyIOS, textAttributes.lineBreakStrategy, NSLineBreakStrategy)
+RCT_REMAP_SHADOW_PROPERTY(lineBreakModeIOS, textAttributes.lineBreakMode, NSLineBreakMode)
+// Decoration
+RCT_REMAP_SHADOW_PROPERTY(textDecorationColor, textAttributes.textDecorationColor, UIColor)
+RCT_REMAP_SHADOW_PROPERTY(textDecorationStyle, textAttributes.textDecorationStyle, NSUnderlineStyle)
+RCT_REMAP_SHADOW_PROPERTY(textDecorationLine, textAttributes.textDecorationLine, RCTTextDecorationLineType)
+// Shadow
+RCT_REMAP_SHADOW_PROPERTY(textShadowOffset, textAttributes.textShadowOffset, CGSize)
+RCT_REMAP_SHADOW_PROPERTY(textShadowRadius, textAttributes.textShadowRadius, CGFloat)
+RCT_REMAP_SHADOW_PROPERTY(textShadowColor, textAttributes.textShadowColor, UIColor)
+// Special
+RCT_REMAP_SHADOW_PROPERTY(isHighlighted, textAttributes.isHighlighted, BOOL)
+RCT_REMAP_SHADOW_PROPERTY(textTransform, textAttributes.textTransform, RCTTextTransform)
+
+@end
+
+#endif // RCT_REMOVE_LEGACY_ARCH

node_modules/react-native/Libraries/Text/RCTConvert+Text.h

@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTConvert.h>
+
+#import "RCTTextTransform.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RCTConvert (Text)
+
++ (UITextAutocorrectionType)UITextAutocorrectionType:(nullable id)json;
++ (UITextSpellCheckingType)UITextSpellCheckingType:(nullable id)json;
++ (RCTTextTransform)RCTTextTransform:(nullable id)json;
++ (UITextSmartInsertDeleteType)UITextSmartInsertDeleteType:(nullable id)json;
+
+@end
+
+NS_ASSUME_NONNULL_END

node_modules/react-native/Libraries/Text/RCTConvert+Text.mm

@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTConvert+Text.h>
+
+@implementation RCTConvert (Text)
+
++ (UITextAutocorrectionType)UITextAutocorrectionType:(id)json
+{
+  return json == nil           ? UITextAutocorrectionTypeDefault
+      : [RCTConvert BOOL:json] ? UITextAutocorrectionTypeYes
+                               : UITextAutocorrectionTypeNo;
+}
+
++ (UITextSpellCheckingType)UITextSpellCheckingType:(id)json
+{
+  return json == nil           ? UITextSpellCheckingTypeDefault
+      : [RCTConvert BOOL:json] ? UITextSpellCheckingTypeYes
+                               : UITextSpellCheckingTypeNo;
+}
+
+RCT_ENUM_CONVERTER(
+    RCTTextTransform,
+    (@{
+      @"none" : @(RCTTextTransformNone),
+      @"capitalize" : @(RCTTextTransformCapitalize),
+      @"uppercase" : @(RCTTextTransformUppercase),
+      @"lowercase" : @(RCTTextTransformLowercase),
+    }),
+    RCTTextTransformUndefined,
+    integerValue)
+
++ (UITextSmartInsertDeleteType)UITextSmartInsertDeleteType:(id)json
+{
+  return json == nil           ? UITextSmartInsertDeleteTypeDefault
+      : [RCTConvert BOOL:json] ? UITextSmartInsertDeleteTypeYes
+                               : UITextSmartInsertDeleteTypeNo;
+}
+
+@end

node_modules/react-native/Libraries/Text/RCTTextAttributes.h

@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <UIKit/UIKit.h>
+
+#import <React/RCTDynamicTypeRamp.h>
+#import <React/RCTTextDecorationLineType.h>
+#import <React/RCTTextTransform.h>
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+NS_ASSUME_NONNULL_BEGIN
+
+extern NSString *const RCTTextAttributesIsHighlightedAttributeName
+    __attribute__((deprecated("This API will be removed along with the legacy architecture.")));
+extern NSString *const RCTTextAttributesTagAttributeName
+    __attribute__((deprecated("This API will be removed along with the legacy architecture.")));
+
+/**
+ * Represents knowledge about all supported *text* attributes
+ * assigned to some text component such as <Text>, <VirtualText>,
+ * and <TextInput>.
+ */
+__attribute__((deprecated("This API will be removed along with the legacy architecture.")))
+@interface RCTTextAttributes : NSObject<NSCopying>
+
+// Color
+@property (nonatomic, strong, nullable) UIColor *foregroundColor;
+@property (nonatomic, strong, nullable) UIColor *backgroundColor;
+@property (nonatomic, assign) CGFloat opacity;
+// Font
+@property (nonatomic, copy, nullable) NSString *fontFamily;
+@property (nonatomic, assign) CGFloat fontSize;
+@property (nonatomic, assign) CGFloat fontSizeMultiplier;
+@property (nonatomic, assign) CGFloat maxFontSizeMultiplier;
+@property (nonatomic, copy, nullable) NSString *fontWeight;
+@property (nonatomic, copy, nullable) NSString *fontStyle;
+@property (nonatomic, copy, nullable) NSArray<NSString *> *fontVariant;
+@property (nonatomic, assign) BOOL allowFontScaling;
+@property (nonatomic, assign) RCTDynamicTypeRamp dynamicTypeRamp;
+@property (nonatomic, assign) CGFloat letterSpacing;
+// Paragraph Styles
+@property (nonatomic, assign) CGFloat lineHeight;
+@property (nonatomic, assign) NSTextAlignment alignment;
+@property (nonatomic, assign) NSWritingDirection baseWritingDirection;
+@property (nonatomic, assign) NSLineBreakStrategy lineBreakStrategy;
+@property (nonatomic, assign) NSLineBreakMode lineBreakMode;
+// Decoration
+@property (nonatomic, strong, nullable) UIColor *textDecorationColor;
+@property (nonatomic, assign) NSUnderlineStyle textDecorationStyle;
+@property (nonatomic, assign) RCTTextDecorationLineType textDecorationLine;
+// Shadow
+@property (nonatomic, assign) CGSize textShadowOffset;
+@property (nonatomic, assign) CGFloat textShadowRadius;
+@property (nonatomic, strong, nullable) UIColor *textShadowColor;
+// Special
+@property (nonatomic, assign) BOOL isHighlighted;
+@property (nonatomic, strong, nullable) NSNumber *tag;
+@property (nonatomic, assign) UIUserInterfaceLayoutDirection layoutDirection;
+@property (nonatomic, assign) RCTTextTransform textTransform;
+
+#pragma mark - Inheritance
+
+- (void)applyTextAttributes:(RCTTextAttributes *)textAttributes;
+
+#pragma mark - Adapters
+
+/**
+ * Text attributes in NSAttributedString terms.
+ */
+- (NSDictionary<NSAttributedStringKey, id> *)effectiveTextAttributes;
+
+/**
+ * Constructed paragraph style.
+ */
+- (NSParagraphStyle *_Nullable)effectiveParagraphStyle;
+
+/**
+ * Constructed font.
+ */
+- (UIFont *)effectiveFont;
+
+/**
+ * Font size multiplier reflects `allowFontScaling`, `fontSizeMultiplier`, and `maxFontSizeMultiplier`.
+ */
+- (CGFloat)effectiveFontSizeMultiplier;
+
+/**
+ * Foreground and background colors with opacity and right defaults.
+ */
+- (UIColor *)effectiveForegroundColor;
+- (UIColor *)effectiveBackgroundColor;
+
+/**
+ * Text transformed per 'none', 'uppercase', 'lowercase', 'capitalize'
+ */
+- (NSString *)applyTextAttributesToText:(NSString *)text;
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif // RCT_REMOVE_LEGACY_ARCH

node_modules/react-native/Libraries/Text/RCTTextAttributes.mm

@@ -0,0 +1,358 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTTextAttributes.h>
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+#import <React/RCTAssert.h>
+#import <React/RCTFont.h>
+#import <React/RCTLog.h>
+
+NSString *const RCTTextAttributesIsHighlightedAttributeName = @"RCTTextAttributesIsHighlightedAttributeName";
+NSString *const RCTTextAttributesTagAttributeName = @"RCTTextAttributesTagAttributeName";
+
+@implementation RCTTextAttributes
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _fontSize = NAN;
+    _letterSpacing = NAN;
+    _lineHeight = NAN;
+    _textDecorationStyle = NSUnderlineStyleSingle;
+    _fontSizeMultiplier = NAN;
+    _maxFontSizeMultiplier = NAN;
+    _alignment = NSTextAlignmentNatural;
+    _baseWritingDirection = NSWritingDirectionNatural;
+    _lineBreakStrategy = NSLineBreakStrategyNone;
+    _lineBreakMode = NSLineBreakByWordWrapping;
+    _textShadowRadius = NAN;
+    _opacity = NAN;
+    _textTransform = RCTTextTransformUndefined;
+  }
+
+  return self;
+}
+
+- (void)applyTextAttributes:(RCTTextAttributes *)textAttributes
+{
+  // Note: All lines marked with `*` does not use explicit/correct rules to compare old and new values because
+  // their types do not have special designated value representing undefined/unspecified/inherit meaning.
+  // We will address this in the future.
+
+  // Color
+  _foregroundColor = textAttributes->_foregroundColor ?: _foregroundColor;
+  _backgroundColor = textAttributes->_backgroundColor ?: _backgroundColor;
+  _opacity =
+      !isnan(textAttributes->_opacity) ? (isnan(_opacity) ? 1.0 : _opacity) * textAttributes->_opacity : _opacity;
+
+  // Font
+  _fontFamily = textAttributes->_fontFamily ?: _fontFamily;
+  _fontSize = !isnan(textAttributes->_fontSize) ? textAttributes->_fontSize : _fontSize;
+  _fontSizeMultiplier =
+      !isnan(textAttributes->_fontSizeMultiplier) ? textAttributes->_fontSizeMultiplier : _fontSizeMultiplier;
+  _maxFontSizeMultiplier =
+      !isnan(textAttributes->_maxFontSizeMultiplier) ? textAttributes->_maxFontSizeMultiplier : _maxFontSizeMultiplier;
+  _fontWeight = textAttributes->_fontWeight ?: _fontWeight;
+  _fontStyle = textAttributes->_fontStyle ?: _fontStyle;
+  _fontVariant = textAttributes->_fontVariant ?: _fontVariant;
+  _allowFontScaling = textAttributes->_allowFontScaling || _allowFontScaling; // *
+  _dynamicTypeRamp = textAttributes->_dynamicTypeRamp != RCTDynamicTypeRampUndefined ? textAttributes->_dynamicTypeRamp
+                                                                                     : _dynamicTypeRamp;
+  _letterSpacing = !isnan(textAttributes->_letterSpacing) ? textAttributes->_letterSpacing : _letterSpacing;
+
+  // Paragraph Styles
+  _lineHeight = !isnan(textAttributes->_lineHeight) ? textAttributes->_lineHeight : _lineHeight;
+  _alignment = textAttributes->_alignment != NSTextAlignmentNatural ? textAttributes->_alignment : _alignment; // *
+  _baseWritingDirection = textAttributes->_baseWritingDirection != NSWritingDirectionNatural
+      ? textAttributes->_baseWritingDirection
+      : _baseWritingDirection; // *
+  _lineBreakStrategy = textAttributes->_lineBreakStrategy ?: _lineBreakStrategy;
+  _lineBreakMode = textAttributes->_lineBreakMode ?: _lineBreakMode;
+
+  // Decoration
+  _textDecorationColor = textAttributes->_textDecorationColor ?: _textDecorationColor;
+  _textDecorationStyle = textAttributes->_textDecorationStyle != NSUnderlineStyleSingle
+      ? textAttributes->_textDecorationStyle
+      : _textDecorationStyle; // *
+  _textDecorationLine = textAttributes->_textDecorationLine != RCTTextDecorationLineTypeNone
+      ? textAttributes->_textDecorationLine
+      : _textDecorationLine; // *
+
+  // Shadow
+  _textShadowOffset = !CGSizeEqualToSize(textAttributes->_textShadowOffset, CGSizeZero)
+      ? textAttributes->_textShadowOffset
+      : _textShadowOffset; // *
+  _textShadowRadius = !isnan(textAttributes->_textShadowRadius) ? textAttributes->_textShadowRadius : _textShadowRadius;
+  _textShadowColor = textAttributes->_textShadowColor ?: _textShadowColor;
+
+  // Special
+  _isHighlighted = textAttributes->_isHighlighted || _isHighlighted; // *
+  _tag = textAttributes->_tag ?: _tag;
+  _layoutDirection = textAttributes->_layoutDirection != UIUserInterfaceLayoutDirectionLeftToRight
+      ? textAttributes->_layoutDirection
+      : _layoutDirection;
+  _textTransform =
+      textAttributes->_textTransform != RCTTextTransformUndefined ? textAttributes->_textTransform : _textTransform;
+}
+
+- (NSParagraphStyle *)effectiveParagraphStyle
+{
+  // Paragraph Style
+  NSMutableParagraphStyle *paragraphStyle = [NSMutableParagraphStyle new];
+  BOOL isParagraphStyleUsed = NO;
+  if (_alignment != NSTextAlignmentNatural) {
+    NSTextAlignment alignment = _alignment;
+    if (_layoutDirection == UIUserInterfaceLayoutDirectionRightToLeft) {
+      if (alignment == NSTextAlignmentRight) {
+        alignment = NSTextAlignmentLeft;
+      } else if (alignment == NSTextAlignmentLeft) {
+        alignment = NSTextAlignmentRight;
+      }
+    }
+
+    paragraphStyle.alignment = alignment;
+    isParagraphStyleUsed = YES;
+  }
+
+  if (_baseWritingDirection != NSWritingDirectionNatural) {
+    paragraphStyle.baseWritingDirection = _baseWritingDirection;
+    isParagraphStyleUsed = YES;
+  }
+
+  if (_lineBreakStrategy != NSLineBreakStrategyNone) {
+    if (@available(iOS 14.0, *)) {
+      paragraphStyle.lineBreakStrategy = _lineBreakStrategy;
+      isParagraphStyleUsed = YES;
+    }
+  }
+
+  if (_lineBreakMode != NSLineBreakByWordWrapping) {
+    paragraphStyle.lineBreakMode = _lineBreakMode;
+    isParagraphStyleUsed = YES;
+  }
+
+  if (!isnan(_lineHeight)) {
+    CGFloat lineHeight = _lineHeight * self.effectiveFontSizeMultiplier;
+    paragraphStyle.minimumLineHeight = lineHeight;
+    paragraphStyle.maximumLineHeight = lineHeight;
+    isParagraphStyleUsed = YES;
+  }
+
+  if (isParagraphStyleUsed) {
+    return [paragraphStyle copy];
+  }
+
+  return nil;
+}
+
+- (NSDictionary<NSAttributedStringKey, id> *)effectiveTextAttributes
+{
+  NSMutableDictionary<NSAttributedStringKey, id> *attributes = [NSMutableDictionary dictionaryWithCapacity:10];
+
+  // Font
+  UIFont *font = self.effectiveFont;
+  if (font) {
+    attributes[NSFontAttributeName] = font;
+  }
+
+  // Colors
+  UIColor *effectiveForegroundColor = self.effectiveForegroundColor;
+
+  if (_foregroundColor || !isnan(_opacity)) {
+    attributes[NSForegroundColorAttributeName] = effectiveForegroundColor;
+  }
+
+  if (_backgroundColor || !isnan(_opacity)) {
+    attributes[NSBackgroundColorAttributeName] = self.effectiveBackgroundColor;
+  }
+
+  // Kerning
+  if (!isnan(_letterSpacing)) {
+    attributes[NSKernAttributeName] = @(_letterSpacing);
+  }
+
+  // Paragraph Style
+  NSParagraphStyle *paragraphStyle = [self effectiveParagraphStyle];
+  if (paragraphStyle) {
+    attributes[NSParagraphStyleAttributeName] = paragraphStyle;
+  }
+
+  // Decoration
+  BOOL isTextDecorationEnabled = NO;
+  if (_textDecorationLine == RCTTextDecorationLineTypeUnderline ||
+      _textDecorationLine == RCTTextDecorationLineTypeUnderlineStrikethrough) {
+    isTextDecorationEnabled = YES;
+    attributes[NSUnderlineStyleAttributeName] = @(_textDecorationStyle);
+  }
+
+  if (_textDecorationLine == RCTTextDecorationLineTypeStrikethrough ||
+      _textDecorationLine == RCTTextDecorationLineTypeUnderlineStrikethrough) {
+    isTextDecorationEnabled = YES;
+    attributes[NSStrikethroughStyleAttributeName] = @(_textDecorationStyle);
+  }
+
+  if (_textDecorationColor || isTextDecorationEnabled) {
+    attributes[NSStrikethroughColorAttributeName] = _textDecorationColor ?: effectiveForegroundColor;
+    attributes[NSUnderlineColorAttributeName] = _textDecorationColor ?: effectiveForegroundColor;
+  }
+
+  // Shadow
+  if (!isnan(_textShadowRadius)) {
+    NSShadow *shadow = [NSShadow new];
+    shadow.shadowOffset = _textShadowOffset;
+    shadow.shadowBlurRadius = _textShadowRadius;
+    shadow.shadowColor = _textShadowColor;
+    attributes[NSShadowAttributeName] = shadow;
+  }
+
+  // Special
+  if (_isHighlighted) {
+    attributes[RCTTextAttributesIsHighlightedAttributeName] = @YES;
+  }
+
+  if (_tag) {
+    attributes[RCTTextAttributesTagAttributeName] = _tag;
+  }
+
+  return [attributes copy];
+}
+
+- (UIFont *)effectiveFont
+{
+  // FIXME: RCTFont has thread-safety issues and must be rewritten.
+  return [RCTFont updateFont:nil
+                  withFamily:_fontFamily
+                        size:@(isnan(_fontSize) ? 0 : _fontSize)
+                      weight:_fontWeight
+                       style:_fontStyle
+                     variant:_fontVariant
+             scaleMultiplier:self.effectiveFontSizeMultiplier];
+}
+
+- (CGFloat)effectiveFontSizeMultiplier
+{
+  bool fontScalingEnabled = !RCTHasFontHandlerSet() && _allowFontScaling;
+
+  if (fontScalingEnabled) {
+    CGFloat fontSizeMultiplier = !isnan(_fontSizeMultiplier) ? _fontSizeMultiplier : 1.0;
+    if (_dynamicTypeRamp != RCTDynamicTypeRampUndefined) {
+      UIFontMetrics *fontMetrics = RCTUIFontMetricsForDynamicTypeRamp(_dynamicTypeRamp);
+      // Using a specific font size reduces rounding errors from -scaledValueForValue:
+      CGFloat requestedSize = isnan(_fontSize) ? RCTBaseSizeForDynamicTypeRamp(_dynamicTypeRamp) : _fontSize;
+      fontSizeMultiplier = [fontMetrics scaledValueForValue:requestedSize] / requestedSize;
+    }
+    CGFloat maxFontSizeMultiplier = !isnan(_maxFontSizeMultiplier) ? _maxFontSizeMultiplier : 0.0;
+    return maxFontSizeMultiplier >= 1.0 ? fminf(maxFontSizeMultiplier, fontSizeMultiplier) : fontSizeMultiplier;
+  } else {
+    return 1.0;
+  }
+}
+
+- (UIColor *)effectiveForegroundColor
+{
+  UIColor *effectiveForegroundColor = _foregroundColor ?: [UIColor blackColor];
+
+  if (!isnan(_opacity)) {
+    effectiveForegroundColor =
+        [effectiveForegroundColor colorWithAlphaComponent:CGColorGetAlpha(effectiveForegroundColor.CGColor) * _opacity];
+  }
+
+  return effectiveForegroundColor;
+}
+
+- (UIColor *)effectiveBackgroundColor
+{
+  UIColor *effectiveBackgroundColor = _backgroundColor; // ?: [[UIColor whiteColor] colorWithAlphaComponent:0];
+
+  if (effectiveBackgroundColor && !isnan(_opacity)) {
+    effectiveBackgroundColor =
+        [effectiveBackgroundColor colorWithAlphaComponent:CGColorGetAlpha(effectiveBackgroundColor.CGColor) * _opacity];
+  }
+
+  return effectiveBackgroundColor ?: [UIColor clearColor];
+}
+
+static NSString *capitalizeText(NSString *text)
+{
+  NSMutableString *result = [[NSMutableString alloc] initWithString:text];
+  [result
+      enumerateSubstringsInRange:NSMakeRange(0, text.length)
+                         options:NSStringEnumerationByWords
+                      usingBlock:^(NSString *substring, NSRange substringRange, NSRange enclosingRange, BOOL *stop) {
+                        [result replaceCharactersInRange:NSMakeRange(substringRange.location, 1)
+                                              withString:[[substring substringToIndex:1] uppercaseString]];
+                      }];
+  return result;
+}
+
+- (NSString *)applyTextAttributesToText:(NSString *)text
+{
+  switch (_textTransform) {
+    case RCTTextTransformUndefined:
+    case RCTTextTransformNone:
+      return text;
+    case RCTTextTransformLowercase:
+      return [text lowercaseString];
+    case RCTTextTransformUppercase:
+      return [text uppercaseString];
+    case RCTTextTransformCapitalize:
+      return capitalizeText(text);
+  }
+}
+
+- (RCTTextAttributes *)copyWithZone:(NSZone *)zone
+{
+  RCTTextAttributes *textAttributes = [RCTTextAttributes new];
+  [textAttributes applyTextAttributes:self];
+  return textAttributes;
+}
+
+#pragma mark - NSObject
+
+- (BOOL)isEqual:(RCTTextAttributes *)textAttributes
+{
+  if (!textAttributes) {
+    return NO;
+  }
+  if (self == textAttributes) {
+    return YES;
+  }
+
+#define RCTTextAttributesCompareFloats(a) ((a == textAttributes->a) || (isnan(a) && isnan(textAttributes->a)))
+#define RCTTextAttributesCompareSize(a) CGSizeEqualToSize(a, textAttributes->a)
+#define RCTTextAttributesCompareObjects(a) ((a == textAttributes->a) || [a isEqual:textAttributes->a])
+#define RCTTextAttributesCompareStrings(a) ((a == textAttributes->a) || [a isEqualToString:textAttributes->a])
+#define RCTTextAttributesCompareOthers(a) (a == textAttributes->a)
+
+  return RCTTextAttributesCompareObjects(_foregroundColor) && RCTTextAttributesCompareObjects(_backgroundColor) &&
+      RCTTextAttributesCompareFloats(_opacity) &&
+      // Font
+      RCTTextAttributesCompareObjects(_fontFamily) && RCTTextAttributesCompareFloats(_fontSize) &&
+      RCTTextAttributesCompareFloats(_fontSizeMultiplier) && RCTTextAttributesCompareFloats(_maxFontSizeMultiplier) &&
+      RCTTextAttributesCompareStrings(_fontWeight) && RCTTextAttributesCompareObjects(_fontStyle) &&
+      RCTTextAttributesCompareObjects(_fontVariant) && RCTTextAttributesCompareOthers(_allowFontScaling) &&
+      RCTTextAttributesCompareOthers(_dynamicTypeRamp) && RCTTextAttributesCompareFloats(_letterSpacing) &&
+      // Paragraph Styles
+      RCTTextAttributesCompareFloats(_lineHeight) && RCTTextAttributesCompareFloats(_alignment) &&
+      RCTTextAttributesCompareOthers(_baseWritingDirection) && RCTTextAttributesCompareOthers(_lineBreakStrategy) &&
+      RCTTextAttributesCompareOthers(_lineBreakMode) &&
+      // Decoration
+      RCTTextAttributesCompareObjects(_textDecorationColor) && RCTTextAttributesCompareOthers(_textDecorationStyle) &&
+      RCTTextAttributesCompareOthers(_textDecorationLine) &&
+      // Shadow
+      RCTTextAttributesCompareSize(_textShadowOffset) && RCTTextAttributesCompareFloats(_textShadowRadius) &&
+      RCTTextAttributesCompareObjects(_textShadowColor) &&
+      // Special
+      RCTTextAttributesCompareOthers(_isHighlighted) && RCTTextAttributesCompareObjects(_tag) &&
+      RCTTextAttributesCompareOthers(_layoutDirection) && RCTTextAttributesCompareOthers(_textTransform);
+}
+
+@end
+
+#endif // RCT_REMOVE_LEGACY_ARCH

node_modules/react-native/Libraries/Text/RCTTextTransform.h

@@ -0,0 +1,16 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <Foundation/Foundation.h>
+
+typedef NS_ENUM(NSInteger, RCTTextTransform) {
+  RCTTextTransformUndefined = 0,
+  RCTTextTransformNone,
+  RCTTextTransformCapitalize,
+  RCTTextTransformUppercase,
+  RCTTextTransformLowercase,
+};

node_modules/react-native/Libraries/Text/RawText/RCTRawTextShadowView.h

@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTShadowView.h>
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+NS_ASSUME_NONNULL_BEGIN
+
+__attribute__((deprecated("This API will be removed along with the legacy architecture.")))
+@interface RCTRawTextShadowView : RCTShadowView
+
+@property (nonatomic, copy, nullable) NSString *text;
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif // RCT_REMOVE_LEGACY_ARCH

node_modules/react-native/Libraries/Text/RawText/RCTRawTextShadowView.mm

@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTRawTextShadowView.h>
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+#import <React/RCTShadowView+Layout.h>
+
+@implementation RCTRawTextShadowView
+
+- (void)setText:(NSString *)text
+{
+  if (_text != text && ![_text isEqualToString:text]) {
+    _text = [text copy];
+    [self dirtyLayout];
+  }
+}
+
+- (void)dirtyLayout
+{
+  [self.superview dirtyLayout];
+}
+
+- (NSString *)description
+{
+  NSString *superDescription = super.description;
+  return [[superDescription substringToIndex:superDescription.length - 1]
+      stringByAppendingFormat:@"; text: %@>", self.text];
+}
+
+@end
+
+#endif // RCT_REMOVE_LEGACY_ARCH

node_modules/react-native/Libraries/Text/RawText/RCTRawTextViewManager.h

@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTViewManager.h>
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+NS_ASSUME_NONNULL_BEGIN
+
+__attribute__((deprecated("This API will be removed along with the legacy architecture.")))
+@interface RCTRawTextViewManager : RCTViewManager
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif // RCT_REMOVE_LEGACY_ARCH

node_modules/react-native/Libraries/Text/RawText/RCTRawTextViewManager.mm

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTRawTextViewManager.h>
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+#import <React/RCTRawTextShadowView.h>
+
+@implementation RCTRawTextViewManager
+
+RCT_EXPORT_MODULE(RCTRawText)
+
+- (UIView *)view
+{
+  return [UIView new];
+}
+
+- (RCTShadowView *)shadowView
+{
+  return [RCTRawTextShadowView new];
+}
+
+RCT_EXPORT_SHADOW_PROPERTY(text, NSString)
+
+@end
+
+#endif // RCT_REMOVE_LEGACY_ARCH

node_modules/react-native/Libraries/Text/React-RCTText.podspec

@@ -0,0 +1,37 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "..", "..", "package.json")))
+version = package['version']
+
+source = { :git => 'https://github.com/facebook/react-native.git' }
+if version == '1000.0.0'
+  # This is an unpublished version, use the latest commit hash of the react-native repo, which we’re presumably in.
+  source[:commit] = `git rev-parse HEAD`.strip if system("git rev-parse --git-dir > /dev/null 2>&1")
+else
+  source[:tag] = "v#{version}"
+end
+
+Pod::Spec.new do |s|
+  s.name                   = "React-RCTText"
+  s.version                = version
+  s.summary                = "A React component for displaying text."
+  s.homepage               = "https://reactnative.dev/"
+  s.documentation_url      = "https://reactnative.dev/docs/text"
+  s.license                = package["license"]
+  s.author                 = "Meta Platforms, Inc. and its affiliates"
+  s.platforms              = min_supported_versions
+  s.source                 = source
+  s.source_files           = podspec_sources("**/*.{h,m,mm}", "**/*.h")
+  s.preserve_paths         = "package.json", "LICENSE", "LICENSE-docs"
+  s.header_dir             = "RCTText"
+  s.framework              = ["MobileCoreServices"]
+  s.pod_target_xcconfig    = { "CLANG_CXX_LANGUAGE_STANDARD" => rct_cxx_language_standard() }
+
+  s.dependency "Yoga"
+  s.dependency "React-Core/RCTTextHeaders", version
+end

node_modules/react-native/Libraries/Text/Text.d.ts

@@ -0,0 +1,230 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ */
+
+import type * as React from 'react';
+import {Constructor} from '../../types/private/Utilities';
+import {AccessibilityProps} from '../Components/View/ViewAccessibility';
+import {HostInstance} from '../../types/public/ReactNativeTypes';
+import {ColorValue, StyleProp} from '../StyleSheet/StyleSheet';
+import {TextStyle, ViewStyle} from '../StyleSheet/StyleSheetTypes';
+import {
+  GestureResponderEvent,
+  LayoutChangeEvent,
+  TextLayoutEvent,
+} from '../Types/CoreEventTypes';
+
+export interface TextPropsIOS {
+  /**
+   * Specifies whether font should be scaled down automatically to fit given style constraints.
+   */
+  adjustsFontSizeToFit?: boolean | undefined;
+
+  /**
+   * The Dynamic Type scale ramp to apply to this element on iOS.
+   */
+  dynamicTypeRamp?:
+    | 'caption2'
+    | 'caption1'
+    | 'footnote'
+    | 'subheadline'
+    | 'callout'
+    | 'body'
+    | 'headline'
+    | 'title3'
+    | 'title2'
+    | 'title1'
+    | 'largeTitle'
+    | undefined;
+
+  /**
+   * When `true`, no visual change is made when text is pressed down. By
+   * default, a gray oval highlights the text on press down.
+   */
+  suppressHighlighting?: boolean | undefined;
+
+  /**
+   * Set line break strategy on iOS.
+   */
+  lineBreakStrategyIOS?:
+    | 'none'
+    | 'standard'
+    | 'hangul-word'
+    | 'push-out'
+    | undefined;
+}
+
+export interface TextPropsAndroid {
+  /**
+   * Specifies the disabled state of the text view for testing purposes.
+   */
+  disabled?: boolean | undefined;
+
+  /**
+   * Lets the user select text, to use the native copy and paste functionality.
+   */
+  selectable?: boolean | undefined;
+
+  /**
+   * The highlight color of the text.
+   */
+  selectionColor?: ColorValue | undefined;
+
+  /**
+   * Set text break strategy on Android API Level 23+
+   * default is `highQuality`.
+   */
+  textBreakStrategy?: 'simple' | 'highQuality' | 'balanced' | undefined;
+
+  /**
+   * Determines the types of data converted to clickable URLs in the text element.
+   * By default no data types are detected.
+   */
+  dataDetectorType?:
+    | null
+    | 'phoneNumber'
+    | 'link'
+    | 'email'
+    | 'none'
+    | 'all'
+    | undefined;
+
+  /**
+   * Hyphenation strategy
+   */
+  android_hyphenationFrequency?: 'normal' | 'none' | 'full' | undefined;
+}
+
+// https://reactnative.dev/docs/text#props
+export interface TextProps
+  extends TextPropsIOS,
+    TextPropsAndroid,
+    AccessibilityProps {
+  /**
+   * Specifies whether fonts should scale to respect Text Size accessibility settings.
+   * The default is `true`.
+   */
+  allowFontScaling?: boolean | undefined;
+
+  children?: React.ReactNode | undefined;
+
+  /**
+   * This can be one of the following values:
+   *
+   * - `head` - The line is displayed so that the end fits in the container and the missing text
+   * at the beginning of the line is indicated by an ellipsis glyph. e.g., "...wxyz"
+   * - `middle` - The line is displayed so that the beginning and end fit in the container and the
+   * missing text in the middle is indicated by an ellipsis glyph. "ab...yz"
+   * - `tail` - The line is displayed so that the beginning fits in the container and the
+   * missing text at the end of the line is indicated by an ellipsis glyph. e.g., "abcd..."
+   * - `clip` - Lines are not drawn past the edge of the text container.
+   *
+   * The default is `tail`.
+   *
+   * `numberOfLines` must be set in conjunction with this prop.
+   *
+   * > `clip` is working only for iOS
+   */
+  ellipsizeMode?: 'head' | 'middle' | 'tail' | 'clip' | undefined;
+
+  /**
+   * Used to reference react managed views from native code.
+   */
+  id?: string | undefined;
+
+  /**
+   * Line Break mode. Works only with numberOfLines.
+   * clip is working only for iOS
+   */
+  lineBreakMode?: 'head' | 'middle' | 'tail' | 'clip' | undefined;
+
+  /**
+   * Used to truncate the text with an ellipsis after computing the text
+   * layout, including line wrapping, such that the total number of lines
+   * does not exceed this number.
+   *
+   * This prop is commonly used with `ellipsizeMode`.
+   */
+  numberOfLines?: number | undefined;
+
+  /**
+   * Invoked on mount and layout changes with
+   *
+   * {nativeEvent: { layout: {x, y, width, height}}}.
+   */
+  onLayout?: ((event: LayoutChangeEvent) => void) | undefined;
+
+  /**
+   * Invoked on Text layout
+   */
+  onTextLayout?: ((event: TextLayoutEvent) => void) | undefined;
+
+  /**
+   * This function is called on press.
+   * Text intrinsically supports press handling with a default highlight state (which can be disabled with suppressHighlighting).
+   */
+  onPress?: ((event: GestureResponderEvent) => void) | undefined;
+
+  onPressIn?: ((event: GestureResponderEvent) => void) | undefined;
+  onPressOut?: ((event: GestureResponderEvent) => void) | undefined;
+
+  /**
+   * This function is called on long press.
+   * e.g., `onLongPress={this.increaseSize}>`
+   */
+  onLongPress?: ((event: GestureResponderEvent) => void) | undefined;
+
+  /**
+   * @see https://reactnative.dev/docs/text#style
+   */
+  style?: StyleProp<TextStyle> | undefined;
+
+  /**
+   * Used to locate this view in end-to-end tests.
+   */
+  testID?: string | undefined;
+
+  /**
+   * Used to reference react managed views from native code.
+   */
+  nativeID?: string | undefined;
+
+  /**
+   * Specifies largest possible scale a font can reach when allowFontScaling is enabled. Possible values:
+   * - null/undefined (default): inherit from the parent node or the global default (0)
+   * - 0: no max, ignore parent/global default
+   * - >= 1: sets the maxFontSizeMultiplier of this node to this value
+   */
+  maxFontSizeMultiplier?: number | null | undefined;
+
+  /**
+   * Specifies smallest possible scale a font can reach when adjustsFontSizeToFit is enabled. (values 0.01-1.0).
+   */
+  minimumFontScale?: number | undefined;
+
+  /**
+   * Controls how touch events are handled. Similar to `View`'s `pointerEvents`.
+   */
+  pointerEvents?: ViewStyle['pointerEvents'] | undefined;
+
+  /**
+   * Defines how far your touch may move off of the button, before deactivating the button.
+   */
+  pressRetentionOffset?:
+    | {top: number; left: number; bottom: number; right: number}
+    | undefined;
+}
+
+/**
+ * A React component for displaying text which supports nesting, styling, and touch handling.
+ */
+declare class TextComponent extends React.Component<TextProps> {}
+declare const TextBase: Constructor<HostInstance> & typeof TextComponent;
+export class Text extends TextBase {}
+
+export const unstable_TextAncestorContext: React.Context<boolean>;

node_modules/react-native/Libraries/Text/Text.js

@@ -0,0 +1,848 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+import type {TextStyleProp} from '../StyleSheet/StyleSheet';
+import type {____TextStyle_Internal as TextStyleInternal} from '../StyleSheet/StyleSheetTypes';
+import type {GestureResponderEvent} from '../Types/CoreEventTypes';
+import type {NativeTextProps} from './TextNativeComponent';
+import type {PressRetentionOffset, TextProps} from './TextProps';
+
+import * as ReactNativeFeatureFlags from '../../src/private/featureflags/ReactNativeFeatureFlags';
+import * as PressabilityDebug from '../Pressability/PressabilityDebug';
+import usePressability from '../Pressability/usePressability';
+import flattenStyle from '../StyleSheet/flattenStyle';
+import processColor from '../StyleSheet/processColor';
+import Platform from '../Utilities/Platform';
+import TextAncestorContext from './TextAncestorContext';
+import {NativeText, NativeVirtualText} from './TextNativeComponent';
+import * as React from 'react';
+import {useContext, useMemo, useState} from 'react';
+
+export type {TextProps} from './TextProps';
+
+type TextForwardRef = React.ElementRef<
+  typeof NativeText | typeof NativeVirtualText,
+>;
+
+/**
+ * Text is the fundamental component for displaying text.
+ *
+ * @see https://reactnative.dev/docs/text
+ */
+let _TextImpl;
+if (ReactNativeFeatureFlags.reduceDefaultPropsInText()) {
+  const TextImplNoDefaultProps: component(
+    ref?: React.RefSetter<TextForwardRef>,
+    ...props: TextProps
+  ) = ({
+    ref: forwardedRef,
+    accessible,
+    accessibilityLabel,
+    accessibilityState,
+    allowFontScaling,
+    'aria-busy': ariaBusy,
+    'aria-checked': ariaChecked,
+    'aria-disabled': ariaDisabled,
+    'aria-expanded': ariaExpanded,
+    'aria-hidden': ariaHidden,
+    'aria-label': ariaLabel,
+    'aria-selected': ariaSelected,
+    children,
+    ellipsizeMode,
+    disabled,
+    id,
+    nativeID,
+    numberOfLines,
+    onLongPress,
+    onPress,
+    onPressIn,
+    onPressOut,
+    onResponderGrant,
+    onResponderMove,
+    onResponderRelease,
+    onResponderTerminate,
+    onResponderTerminationRequest,
+    onStartShouldSetResponder,
+    pressRetentionOffset,
+    selectable,
+    selectionColor,
+    suppressHighlighting,
+    style,
+    ...restProps
+  }: {
+    ref?: React.RefSetter<TextForwardRef>,
+    ...TextProps,
+  }) => {
+    const processedProps = restProps as {
+      ...NativeTextProps,
+    };
+    const _accessibilityLabel = ariaLabel ?? accessibilityLabel;
+    let _accessibilityState: ?TextProps['accessibilityState'] =
+      accessibilityState;
+    if (
+      ariaBusy != null ||
+      ariaChecked != null ||
+      ariaDisabled != null ||
+      ariaExpanded != null ||
+      ariaSelected != null
+    ) {
+      if (_accessibilityState != null) {
+        _accessibilityState = {
+          busy: ariaBusy ?? _accessibilityState.busy,
+          checked: ariaChecked ?? _accessibilityState.checked,
+          disabled: ariaDisabled ?? _accessibilityState.disabled,
+          expanded: ariaExpanded ?? _accessibilityState.expanded,
+          selected: ariaSelected ?? _accessibilityState.selected,
+        };
+      } else {
+        _accessibilityState = {
+          busy: ariaBusy,
+          checked: ariaChecked,
+          disabled: ariaDisabled,
+          expanded: ariaExpanded,
+          selected: ariaSelected,
+        };
+      }
+    }
+
+    const _accessibilityStateDisabled = _accessibilityState?.disabled;
+    const _disabled = disabled ?? _accessibilityStateDisabled;
+
+    // If the disabled prop and accessibilityState.disabled are out of sync but not both in
+    // falsy states we need to update the accessibilityState object to use the disabled prop.
+    if (
+      _accessibilityState != null &&
+      _disabled !== _accessibilityStateDisabled &&
+      ((_disabled != null && _disabled !== false) ||
+        (_accessibilityStateDisabled != null &&
+          _accessibilityStateDisabled !== false))
+    ) {
+      _accessibilityState.disabled = _disabled;
+    }
+
+    if (ariaHidden !== undefined) {
+      processedProps.accessibilityElementsHidden = ariaHidden;
+      if (ariaHidden === true) {
+        processedProps.importantForAccessibility = 'no-hide-descendants';
+      }
+    }
+
+    const _accessible = Platform.select({
+      ios: accessible !== false,
+      android:
+        accessible == null
+          ? onPress != null || onLongPress != null
+          : accessible,
+      default: accessible,
+    });
+
+    const isPressable =
+      (onPress != null ||
+        onLongPress != null ||
+        onStartShouldSetResponder != null) &&
+      _disabled !== true;
+
+    // TODO: Move this processing to the view configuration.
+    const _selectionColor =
+      selectionColor != null ? processColor(selectionColor) : undefined;
+
+    let _style = style;
+    if (__DEV__) {
+      if (PressabilityDebug.isEnabled() && onPress != null) {
+        _style = [style, {color: 'magenta'}];
+      }
+    }
+
+    let _numberOfLines = numberOfLines;
+    if (_numberOfLines != null && !(_numberOfLines >= 0)) {
+      if (__DEV__) {
+        console.error(
+          `'numberOfLines' in <Text> must be a non-negative number, received: ${_numberOfLines}. The value will be set to 0.`,
+        );
+      }
+      _numberOfLines = 0;
+    }
+
+    let _selectable = selectable;
+
+    let processedStyle = flattenStyle<TextStyleProp>(_style);
+    if (processedStyle != null) {
+      let overrides: ?{...TextStyleInternal} = null;
+      if (typeof processedStyle.fontWeight === 'number') {
+        overrides = overrides || ({}: {...TextStyleInternal});
+        overrides.fontWeight =
+          // $FlowFixMe[incompatible-type]
+          (String(processedStyle.fontWeight): TextStyleInternal['fontWeight']);
+      }
+
+      if (processedStyle.userSelect != null) {
+        _selectable = userSelectToSelectableMap[processedStyle.userSelect];
+        overrides = overrides || ({}: {...TextStyleInternal});
+        overrides.userSelect = undefined;
+      }
+
+      if (processedStyle.verticalAlign != null) {
+        overrides = overrides || ({}: {...TextStyleInternal});
+        overrides.textAlignVertical =
+          verticalAlignToTextAlignVerticalMap[processedStyle.verticalAlign];
+        overrides.verticalAlign = undefined;
+      }
+
+      if (overrides != null) {
+        // $FlowFixMe[incompatible-type]
+        _style = [_style, overrides];
+      }
+    }
+
+    const _nativeID = id ?? nativeID;
+
+    if (_accessibilityLabel !== undefined) {
+      processedProps.accessibilityLabel = _accessibilityLabel;
+    }
+    if (_accessibilityState !== undefined) {
+      processedProps.accessibilityState = _accessibilityState;
+    }
+    if (_nativeID !== undefined) {
+      processedProps.nativeID = _nativeID;
+    }
+    if (_numberOfLines !== undefined) {
+      processedProps.numberOfLines = _numberOfLines;
+    }
+    if (_selectable !== undefined) {
+      processedProps.selectable = _selectable;
+    }
+    if (_style !== undefined) {
+      processedProps.style = _style;
+    }
+    if (_selectionColor !== undefined) {
+      processedProps.selectionColor = _selectionColor;
+    }
+
+    let textPressabilityProps: ?TextPressabilityProps;
+    if (isPressable) {
+      textPressabilityProps = {
+        onLongPress,
+        onPress,
+        onPressIn,
+        onPressOut,
+        onResponderGrant,
+        onResponderMove,
+        onResponderRelease,
+        onResponderTerminate,
+        onResponderTerminationRequest,
+        onStartShouldSetResponder,
+        pressRetentionOffset,
+        suppressHighlighting,
+      };
+    }
+
+    const hasTextAncestor = useContext(TextAncestorContext);
+    if (hasTextAncestor) {
+      processedProps.disabled = disabled;
+      processedProps.children = children;
+      if (isPressable) {
+        return (
+          <NativePressableVirtualText
+            ref={forwardedRef}
+            textProps={processedProps}
+            textPressabilityProps={textPressabilityProps ?? {}}
+          />
+        );
+      }
+      return <NativeVirtualText {...processedProps} ref={forwardedRef} />;
+    }
+
+    let nativeText = null;
+
+    processedProps.accessible = _accessible;
+    processedProps.allowFontScaling = allowFontScaling !== false;
+    processedProps.disabled = _disabled;
+    processedProps.ellipsizeMode = ellipsizeMode ?? 'tail';
+    processedProps.children = children;
+
+    if (isPressable) {
+      nativeText = (
+        <NativePressableText
+          ref={forwardedRef}
+          textProps={processedProps}
+          textPressabilityProps={textPressabilityProps ?? {}}
+        />
+      );
+    } else {
+      nativeText = <NativeText {...processedProps} ref={forwardedRef} />;
+    }
+
+    if (children == null) {
+      return nativeText;
+    }
+
+    // If the children do not contain a JSX element it would not be possible to have a
+    // nested `Text` component so we can skip adding the `TextAncestorContext` context wrapper
+    // which has a performance overhead. Since we do this for performance reasons we need
+    // to keep the check simple to avoid regressing overall perf. For this reason the
+    // `children.length` constant is set to `3`, this should be a reasonable tradeoff
+    // to capture the majority of `Text` uses but also not make this check too expensive.
+    if (Array.isArray(children) && children.length <= 3) {
+      let hasNonTextChild = false;
+      for (let child of children) {
+        if (child != null && typeof child === 'object') {
+          hasNonTextChild = true;
+          break;
+        }
+      }
+      if (!hasNonTextChild) {
+        return nativeText;
+      }
+    } else if (typeof children !== 'object') {
+      return nativeText;
+    }
+
+    return <TextAncestorContext value={true}>{nativeText}</TextAncestorContext>;
+  };
+  _TextImpl = TextImplNoDefaultProps;
+} else {
+  const TextImplLegacy: component(
+    ref?: React.RefSetter<TextForwardRef>,
+    ...props: TextProps
+  ) = ({
+    ref: forwardedRef,
+    accessible,
+    accessibilityElementsHidden,
+    importantForAccessibility,
+    accessibilityLabel,
+    accessibilityState,
+    allowFontScaling,
+    'aria-busy': ariaBusy,
+    'aria-checked': ariaChecked,
+    'aria-disabled': ariaDisabled,
+    'aria-expanded': ariaExpanded,
+    'aria-hidden': ariaHidden,
+    'aria-label': ariaLabel,
+    'aria-selected': ariaSelected,
+    children,
+    ellipsizeMode,
+    disabled,
+    id,
+    nativeID,
+    numberOfLines,
+    onLongPress,
+    onPress,
+    onPressIn,
+    onPressOut,
+    onResponderGrant,
+    onResponderMove,
+    onResponderRelease,
+    onResponderTerminate,
+    onResponderTerminationRequest,
+    onStartShouldSetResponder,
+    pressRetentionOffset,
+    selectable,
+    selectionColor,
+    suppressHighlighting,
+    style,
+    ...restProps
+  }: {
+    ref?: React.RefSetter<TextForwardRef>,
+    ...TextProps,
+  }) => {
+    const _accessibilityLabel = ariaLabel ?? accessibilityLabel;
+
+    let _accessibilityState: ?TextProps['accessibilityState'] =
+      accessibilityState;
+    if (
+      ariaBusy != null ||
+      ariaChecked != null ||
+      ariaDisabled != null ||
+      ariaExpanded != null ||
+      ariaSelected != null
+    ) {
+      if (_accessibilityState != null) {
+        _accessibilityState = {
+          busy: ariaBusy ?? _accessibilityState.busy,
+          checked: ariaChecked ?? _accessibilityState.checked,
+          disabled: ariaDisabled ?? _accessibilityState.disabled,
+          expanded: ariaExpanded ?? _accessibilityState.expanded,
+          selected: ariaSelected ?? _accessibilityState.selected,
+        };
+      } else {
+        _accessibilityState = {
+          busy: ariaBusy,
+          checked: ariaChecked,
+          disabled: ariaDisabled,
+          expanded: ariaExpanded,
+          selected: ariaSelected,
+        };
+      }
+    }
+
+    const _accessibilityStateDisabled = _accessibilityState?.disabled;
+    const _disabled = disabled ?? _accessibilityStateDisabled;
+
+    let _accessibilityElementsHidden =
+      ariaHidden ?? accessibilityElementsHidden;
+    let _importantForAccessibility = importantForAccessibility;
+    if (ariaHidden === true) {
+      _importantForAccessibility = 'no-hide-descendants';
+    }
+
+    const isPressable =
+      (onPress != null ||
+        onLongPress != null ||
+        onStartShouldSetResponder != null) &&
+      _disabled !== true;
+
+    // TODO: Move this processing to the view configuration.
+    const _selectionColor =
+      selectionColor != null ? processColor(selectionColor) : undefined;
+
+    let _style = style;
+    if (__DEV__) {
+      if (PressabilityDebug.isEnabled() && onPress != null) {
+        _style = [style, {color: 'magenta'}];
+      }
+    }
+
+    let _numberOfLines = numberOfLines;
+    if (_numberOfLines != null && !(_numberOfLines >= 0)) {
+      if (__DEV__) {
+        console.error(
+          `'numberOfLines' in <Text> must be a non-negative number, received: ${_numberOfLines}. The value will be set to 0.`,
+        );
+      }
+      _numberOfLines = 0;
+    }
+
+    let _selectable = selectable;
+
+    let processedStyle = flattenStyle<TextStyleProp>(_style);
+    if (processedStyle != null) {
+      let overrides: ?{...TextStyleInternal} = null;
+      if (typeof processedStyle.fontWeight === 'number') {
+        overrides = overrides || ({}: {...TextStyleInternal});
+        overrides.fontWeight =
+          // $FlowFixMe[incompatible-type]
+          (processedStyle.fontWeight.toString(): TextStyleInternal['fontWeight']);
+      }
+
+      if (processedStyle.userSelect != null) {
+        _selectable = userSelectToSelectableMap[processedStyle.userSelect];
+        overrides = overrides || ({}: {...TextStyleInternal});
+        overrides.userSelect = undefined;
+      }
+
+      if (processedStyle.verticalAlign != null) {
+        overrides = overrides || ({}: {...TextStyleInternal});
+        overrides.textAlignVertical =
+          verticalAlignToTextAlignVerticalMap[processedStyle.verticalAlign];
+        overrides.verticalAlign = undefined;
+      }
+
+      if (overrides != null) {
+        // $FlowFixMe[incompatible-type]
+        _style = [_style, overrides];
+      }
+    }
+
+    const _nativeID = id ?? nativeID;
+
+    const hasTextAncestor = useContext(TextAncestorContext);
+    if (hasTextAncestor) {
+      if (isPressable) {
+        return (
+          <NativePressableVirtualText
+            ref={forwardedRef}
+            textProps={{
+              ...restProps,
+              accessibilityElementsHidden: _accessibilityElementsHidden,
+              accessibilityLabel: _accessibilityLabel,
+              accessibilityState: _accessibilityState,
+              importantForAccessibility: _importantForAccessibility,
+              nativeID: _nativeID,
+              numberOfLines: _numberOfLines,
+              selectable: _selectable,
+              selectionColor: _selectionColor,
+              style: _style,
+              disabled: disabled,
+              children,
+            }}
+            textPressabilityProps={{
+              onLongPress,
+              onPress,
+              onPressIn,
+              onPressOut,
+              onResponderGrant,
+              onResponderMove,
+              onResponderRelease,
+              onResponderTerminate,
+              onResponderTerminationRequest,
+              onStartShouldSetResponder,
+              pressRetentionOffset,
+              suppressHighlighting,
+            }}
+          />
+        );
+      }
+
+      return (
+        <NativeVirtualText
+          {...restProps}
+          accessibilityElementsHidden={_accessibilityElementsHidden}
+          accessibilityLabel={_accessibilityLabel}
+          accessibilityState={_accessibilityState}
+          importantForAccessibility={_importantForAccessibility}
+          nativeID={_nativeID}
+          numberOfLines={_numberOfLines}
+          ref={forwardedRef}
+          selectable={_selectable}
+          selectionColor={_selectionColor}
+          style={_style}
+          disabled={disabled}>
+          {children}
+        </NativeVirtualText>
+      );
+    }
+
+    // If the disabled prop and accessibilityState.disabled are out of sync but not both in
+    // falsy states we need to update the accessibilityState object to use the disabled prop.
+    if (
+      _disabled !== _accessibilityStateDisabled &&
+      ((_disabled != null && _disabled !== false) ||
+        (_accessibilityStateDisabled != null &&
+          _accessibilityStateDisabled !== false))
+    ) {
+      _accessibilityState = {..._accessibilityState, disabled: _disabled};
+    }
+
+    const _accessible = Platform.select({
+      ios: accessible !== false,
+      android:
+        accessible == null
+          ? onPress != null || onLongPress != null
+          : accessible,
+      default: accessible,
+    });
+
+    let nativeText = null;
+    if (isPressable) {
+      nativeText = (
+        <NativePressableText
+          ref={forwardedRef}
+          textProps={{
+            ...restProps,
+            accessibilityElementsHidden: _accessibilityElementsHidden,
+            accessibilityLabel: _accessibilityLabel,
+            accessibilityState: _accessibilityState,
+            accessible: _accessible,
+            allowFontScaling: allowFontScaling !== false,
+            disabled: _disabled,
+            ellipsizeMode: ellipsizeMode ?? 'tail',
+            importantForAccessibility: _importantForAccessibility,
+            nativeID: _nativeID,
+            numberOfLines: _numberOfLines,
+            selectable: _selectable,
+            selectionColor: _selectionColor,
+            style: _style,
+            children,
+          }}
+          textPressabilityProps={{
+            onLongPress,
+            onPress,
+            onPressIn,
+            onPressOut,
+            onResponderGrant,
+            onResponderMove,
+            onResponderRelease,
+            onResponderTerminate,
+            onResponderTerminationRequest,
+            onStartShouldSetResponder,
+            pressRetentionOffset,
+            suppressHighlighting,
+          }}
+        />
+      );
+    } else {
+      nativeText = (
+        <NativeText
+          {...restProps}
+          accessibilityElementsHidden={_accessibilityElementsHidden}
+          accessibilityLabel={_accessibilityLabel}
+          accessibilityState={_accessibilityState}
+          accessible={_accessible}
+          allowFontScaling={allowFontScaling !== false}
+          disabled={_disabled}
+          ellipsizeMode={ellipsizeMode ?? 'tail'}
+          importantForAccessibility={_importantForAccessibility}
+          nativeID={_nativeID}
+          numberOfLines={_numberOfLines}
+          ref={forwardedRef}
+          selectable={_selectable}
+          selectionColor={_selectionColor}
+          style={_style}>
+          {children}
+        </NativeText>
+      );
+    }
+
+    if (children == null) {
+      return nativeText;
+    }
+
+    // If the children do not contain a JSX element it would not be possible to have a
+    // nested `Text` component so we can skip adding the `TextAncestorContext` context wrapper
+    // which has a performance overhead. Since we do this for performance reasons we need
+    // to keep the check simple to avoid regressing overall perf. For this reason the
+    // `children.length` constant is set to `3`, this should be a reasonable tradeoff
+    // to capture the majority of `Text` uses but also not make this check too expensive.
+    if (Array.isArray(children) && children.length <= 3) {
+      let hasNonTextChild = false;
+      for (let child of children) {
+        if (child != null && typeof child === 'object') {
+          hasNonTextChild = true;
+          break;
+        }
+      }
+      if (!hasNonTextChild) {
+        return nativeText;
+      }
+    } else if (typeof children !== 'object') {
+      return nativeText;
+    }
+
+    return <TextAncestorContext value={true}>{nativeText}</TextAncestorContext>;
+  };
+  _TextImpl = TextImplLegacy;
+}
+
+const TextImpl: component(
+  ref?: React.RefSetter<TextForwardRef>,
+  ...props: TextProps
+) = _TextImpl;
+
+TextImpl.displayName = 'Text';
+
+type TextPressabilityProps = $ReadOnly<{
+  onLongPress?: ?(event: GestureResponderEvent) => mixed,
+  onPress?: ?(event: GestureResponderEvent) => mixed,
+  onPressIn?: ?(event: GestureResponderEvent) => mixed,
+  onPressOut?: ?(event: GestureResponderEvent) => mixed,
+  onResponderGrant?: ?(event: GestureResponderEvent) => void,
+  onResponderMove?: ?(event: GestureResponderEvent) => void,
+  onResponderRelease?: ?(event: GestureResponderEvent) => void,
+  onResponderTerminate?: ?(event: GestureResponderEvent) => void,
+  onResponderTerminationRequest?: ?() => boolean,
+  onStartShouldSetResponder?: ?() => boolean,
+  pressRetentionOffset?: ?PressRetentionOffset,
+  suppressHighlighting?: ?boolean,
+}>;
+
+/**
+ * Hook that handles setting up Pressability of Text components.
+ *
+ * NOTE: This hook is relatively expensive so it should only be used absolutely necessary.
+ */
+function useTextPressability({
+  onLongPress,
+  onPress,
+  onPressIn,
+  onPressOut,
+  onResponderGrant,
+  onResponderMove,
+  onResponderRelease,
+  onResponderTerminate,
+  onResponderTerminationRequest,
+  onStartShouldSetResponder,
+  pressRetentionOffset,
+  suppressHighlighting,
+}: TextPressabilityProps) {
+  const [isHighlighted, setHighlighted] = useState(false);
+
+  // Setup pressability config and wrap callbacks needs to track the highlight state.
+  const config = useMemo(() => {
+    let _onPressIn = onPressIn;
+    let _onPressOut = onPressOut;
+
+    // Updating isHighlighted causes unnecessary re-renders for platforms that don't use it
+    // in the best case, and cause issues with text selection in the worst case. Forcing
+    // the isHighlighted prop to false on all platforms except iOS.
+    if (Platform.OS === 'ios') {
+      _onPressIn = (event: GestureResponderEvent) => {
+        setHighlighted(suppressHighlighting == null || !suppressHighlighting);
+        onPressIn?.(event);
+      };
+
+      _onPressOut = (event: GestureResponderEvent) => {
+        setHighlighted(false);
+        onPressOut?.(event);
+      };
+    }
+
+    return {
+      disabled: false,
+      pressRectOffset: pressRetentionOffset,
+      onLongPress,
+      onPress,
+      onPressIn: _onPressIn,
+      onPressOut: _onPressOut,
+    };
+  }, [
+    pressRetentionOffset,
+    onLongPress,
+    onPress,
+    onPressIn,
+    onPressOut,
+    suppressHighlighting,
+  ]);
+
+  // Init the pressability class
+  const eventHandlers = usePressability(config);
+
+  // Create NativeText event handlers which proxy events to pressability
+  const eventHandlersForText = useMemo(
+    () =>
+      eventHandlers == null
+        ? null
+        : {
+            onResponderGrant(event: GestureResponderEvent) {
+              eventHandlers.onResponderGrant(event);
+              if (onResponderGrant != null) {
+                onResponderGrant(event);
+              }
+            },
+            onResponderMove(event: GestureResponderEvent) {
+              eventHandlers.onResponderMove(event);
+              if (onResponderMove != null) {
+                onResponderMove(event);
+              }
+            },
+            onResponderRelease(event: GestureResponderEvent) {
+              eventHandlers.onResponderRelease(event);
+              if (onResponderRelease != null) {
+                onResponderRelease(event);
+              }
+            },
+            onResponderTerminate(event: GestureResponderEvent) {
+              eventHandlers.onResponderTerminate(event);
+              if (onResponderTerminate != null) {
+                onResponderTerminate(event);
+              }
+            },
+            onClick: eventHandlers.onClick,
+            onResponderTerminationRequest:
+              onResponderTerminationRequest != null
+                ? onResponderTerminationRequest
+                : eventHandlers.onResponderTerminationRequest,
+            onStartShouldSetResponder:
+              onStartShouldSetResponder != null
+                ? onStartShouldSetResponder
+                : eventHandlers.onStartShouldSetResponder,
+          },
+    [
+      eventHandlers,
+      onResponderGrant,
+      onResponderMove,
+      onResponderRelease,
+      onResponderTerminate,
+      onResponderTerminationRequest,
+      onStartShouldSetResponder,
+    ],
+  );
+
+  // Return the highlight state and NativeText event handlers
+  return useMemo(
+    () => [isHighlighted, eventHandlersForText],
+    [isHighlighted, eventHandlersForText],
+  );
+}
+
+type NativePressableTextProps = $ReadOnly<{
+  textProps: NativeTextProps,
+  textPressabilityProps: TextPressabilityProps,
+}>;
+
+/**
+ * Wrap the NativeVirtualText component and initialize pressability.
+ *
+ * This logic is split out from the main Text component to enable the more
+ * expensive pressability logic to be only initialized when needed.
+ */
+const NativePressableVirtualText: component(
+  ref: React.RefSetter<TextForwardRef>,
+  ...props: NativePressableTextProps
+) = ({
+  ref: forwardedRef,
+  textProps,
+  textPressabilityProps,
+}: {
+  ref?: React.RefSetter<TextForwardRef>,
+  ...NativePressableTextProps,
+}) => {
+  const [isHighlighted, eventHandlersForText] = useTextPressability(
+    textPressabilityProps,
+  );
+
+  return (
+    <NativeVirtualText
+      {...textProps}
+      {...eventHandlersForText}
+      isHighlighted={isHighlighted}
+      isPressable={true}
+      ref={forwardedRef}
+    />
+  );
+};
+
+/**
+ * Wrap the NativeText component and initialize pressability.
+ *
+ * This logic is split out from the main Text component to enable the more
+ * expensive pressability logic to be only initialized when needed.
+ */
+const NativePressableText: component(
+  ref: React.RefSetter<TextForwardRef>,
+  ...props: NativePressableTextProps
+) = ({
+  ref: forwardedRef,
+  textProps,
+  textPressabilityProps,
+}: {
+  ref?: React.RefSetter<TextForwardRef>,
+  ...NativePressableTextProps,
+}) => {
+  const [isHighlighted, eventHandlersForText] = useTextPressability(
+    textPressabilityProps,
+  );
+
+  return (
+    <NativeText
+      {...textProps}
+      {...eventHandlersForText}
+      isHighlighted={isHighlighted}
+      isPressable={true}
+      ref={forwardedRef}
+    />
+  );
+};
+
+const userSelectToSelectableMap = {
+  auto: true,
+  text: true,
+  none: false,
+  contain: true,
+  all: true,
+};
+
+const verticalAlignToTextAlignVerticalMap = {
+  auto: 'auto',
+  top: 'top',
+  bottom: 'bottom',
+  middle: 'center',
+} as const;
+
+export default TextImpl;

node_modules/react-native/Libraries/Text/Text/NSTextStorage+FontScaling.h

@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <UIKit/UIKit.h>
+
+@interface NSTextStorage (FontScaling)
+
+- (void)scaleFontSizeToFitSize:(CGSize)size
+               minimumFontSize:(CGFloat)minimumFontSize
+               maximumFontSize:(CGFloat)maximumFontSize;
+
+- (void)scaleFontSizeWithRatio:(CGFloat)ratio
+               minimumFontSize:(CGFloat)minimumFontSize
+               maximumFontSize:(CGFloat)maximumFontSize;
+
+@end

node_modules/react-native/Libraries/Text/Text/NSTextStorage+FontScaling.m

@@ -0,0 +1,131 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "NSTextStorage+FontScaling.h"
+
+typedef NS_OPTIONS(NSInteger, RCTTextSizeComparisonOptions) {
+  RCTTextSizeComparisonSmaller = 1 << 0,
+  RCTTextSizeComparisonLarger = 1 << 1,
+  RCTTextSizeComparisonWithinRange = 1 << 2,
+};
+
+@implementation NSTextStorage (FontScaling)
+
+- (void)scaleFontSizeToFitSize:(CGSize)size
+               minimumFontSize:(CGFloat)minimumFontSize
+               maximumFontSize:(CGFloat)maximumFontSize
+{
+  // Don't scale the font if it already fits
+  if ([self compareToSize:size thresholdRatio:0.01] & RCTTextSizeComparisonSmaller) {
+    return;
+  }
+
+  CGFloat bottomRatio = 1.0 / 128.0;
+  CGFloat topRatio = 128.0;
+  CGFloat ratio = 1.0;
+
+  NSAttributedString *originalAttributedString = [self copy];
+
+  CGFloat lastRatioWhichFits = 0.02;
+
+  while (true) {
+    [self scaleFontSizeWithRatio:ratio minimumFontSize:minimumFontSize maximumFontSize:maximumFontSize];
+
+    RCTTextSizeComparisonOptions comparison = [self compareToSize:size thresholdRatio:0.01];
+
+    if ((comparison & RCTTextSizeComparisonWithinRange) && (comparison & RCTTextSizeComparisonSmaller)) {
+      return;
+    } else if (comparison & RCTTextSizeComparisonSmaller) {
+      bottomRatio = ratio;
+      lastRatioWhichFits = ratio;
+    } else {
+      topRatio = ratio;
+    }
+
+    ratio = (topRatio + bottomRatio) / 2.0;
+
+    CGFloat kRatioThreshold = 0.005;
+    if (ABS(topRatio - bottomRatio) < kRatioThreshold || ABS(topRatio - ratio) < kRatioThreshold ||
+        ABS(bottomRatio - ratio) < kRatioThreshold) {
+      [self replaceCharactersInRange:(NSRange){0, self.length} withAttributedString:originalAttributedString];
+
+      [self scaleFontSizeWithRatio:lastRatioWhichFits minimumFontSize:minimumFontSize maximumFontSize:maximumFontSize];
+      return;
+    }
+
+    [self replaceCharactersInRange:(NSRange){0, self.length} withAttributedString:originalAttributedString];
+  }
+}
+
+- (RCTTextSizeComparisonOptions)compareToSize:(CGSize)size thresholdRatio:(CGFloat)thresholdRatio
+{
+  NSLayoutManager *layoutManager = self.layoutManagers.firstObject;
+  NSTextContainer *textContainer = layoutManager.textContainers.firstObject;
+
+  // A workaround for truncatedGlyphRangeInLineFragmentForGlyphAtIndex returning NSNotFound when text has only
+  // one character and it gets truncated
+  if ([self length] == 1) {
+    CGSize characterSize = [[self string] sizeWithAttributes:[self attributesAtIndex:0 effectiveRange:nil]];
+    if (characterSize.width > size.width) {
+      return RCTTextSizeComparisonLarger;
+    }
+  }
+
+  [layoutManager ensureLayoutForTextContainer:textContainer];
+
+  // Does it fit the text container?
+  NSRange glyphRange = [layoutManager glyphRangeForTextContainer:textContainer];
+  NSRange truncatedGlyphRange = [layoutManager truncatedGlyphRangeInLineFragmentForGlyphAtIndex:glyphRange.length - 1];
+
+  if (truncatedGlyphRange.location != NSNotFound) {
+    return RCTTextSizeComparisonLarger;
+  }
+
+  CGSize measuredSize = [layoutManager usedRectForTextContainer:textContainer].size;
+
+  // Does it fit the size?
+  BOOL fitsSize = size.width >= measuredSize.width && size.height >= measuredSize.height;
+
+  CGSize thresholdSize = (CGSize){
+      size.width * thresholdRatio,
+      size.height * thresholdRatio,
+  };
+
+  RCTTextSizeComparisonOptions result = 0;
+
+  result |= (fitsSize) ? RCTTextSizeComparisonSmaller : RCTTextSizeComparisonLarger;
+
+  if (ABS(measuredSize.width - size.width) < thresholdSize.width) {
+    result = result | RCTTextSizeComparisonWithinRange;
+  }
+
+  return result;
+}
+
+- (void)scaleFontSizeWithRatio:(CGFloat)ratio
+               minimumFontSize:(CGFloat)minimumFontSize
+               maximumFontSize:(CGFloat)maximumFontSize
+{
+  [self beginEditing];
+
+  [self enumerateAttribute:NSFontAttributeName
+                   inRange:(NSRange){0, self.length}
+                   options:NSAttributedStringEnumerationLongestEffectiveRangeNotRequired
+                usingBlock:^(UIFont *_Nullable font, NSRange range, BOOL *_Nonnull stop) {
+                  if (!font) {
+                    return;
+                  }
+
+                  CGFloat fontSize = MAX(MIN(font.pointSize * ratio, maximumFontSize), minimumFontSize);
+
+                  [self addAttribute:NSFontAttributeName value:[font fontWithSize:fontSize] range:range];
+                }];
+
+  [self endEditing];
+}
+
+@end

node_modules/react-native/Libraries/Text/Text/RCTDynamicTypeRamp.h

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <Foundation/Foundation.h>
+
+#import <React/RCTConvert.h>
+
+typedef NS_ENUM(NSInteger, RCTDynamicTypeRamp) {
+  RCTDynamicTypeRampUndefined,
+  RCTDynamicTypeRampCaption2,
+  RCTDynamicTypeRampCaption1,
+  RCTDynamicTypeRampFootnote,
+  RCTDynamicTypeRampSubheadline,
+  RCTDynamicTypeRampCallout,
+  RCTDynamicTypeRampBody,
+  RCTDynamicTypeRampHeadline,
+  RCTDynamicTypeRampTitle3,
+  RCTDynamicTypeRampTitle2,
+  RCTDynamicTypeRampTitle1,
+  RCTDynamicTypeRampLargeTitle
+};
+
+@interface RCTConvert (DynamicTypeRamp)
+
++ (RCTDynamicTypeRamp)RCTDynamicTypeRamp:(nullable id)json;
+
+@end
+
+/// Generates a `UIFontMetrics` instance representing a particular Dynamic Type ramp.
+UIFontMetrics *_Nonnull RCTUIFontMetricsForDynamicTypeRamp(RCTDynamicTypeRamp dynamicTypeRamp);
+/// The "reference" size for a particular font scale ramp, equal to a text element's size under default text size
+/// settings.
+CGFloat RCTBaseSizeForDynamicTypeRamp(RCTDynamicTypeRamp dynamicTypeRamp);

node_modules/react-native/Libraries/Text/Text/RCTDynamicTypeRamp.mm

@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTDynamicTypeRamp.h>
+
+@implementation RCTConvert (DynamicTypeRamp)
+
+RCT_ENUM_CONVERTER(
+    RCTDynamicTypeRamp,
+    (@{
+      @"caption2" : @(RCTDynamicTypeRampCaption2),
+      @"caption1" : @(RCTDynamicTypeRampCaption1),
+      @"footnote" : @(RCTDynamicTypeRampFootnote),
+      @"subheadline" : @(RCTDynamicTypeRampSubheadline),
+      @"callout" : @(RCTDynamicTypeRampCallout),
+      @"body" : @(RCTDynamicTypeRampBody),
+      @"headline" : @(RCTDynamicTypeRampHeadline),
+      @"title3" : @(RCTDynamicTypeRampTitle3),
+      @"title2" : @(RCTDynamicTypeRampTitle2),
+      @"title1" : @(RCTDynamicTypeRampTitle1),
+      @"largeTitle" : @(RCTDynamicTypeRampLargeTitle),
+    }),
+    RCTDynamicTypeRampUndefined,
+    integerValue)
+
+@end
+
+UIFontMetrics *RCTUIFontMetricsForDynamicTypeRamp(RCTDynamicTypeRamp dynamicTypeRamp)
+{
+  static NSDictionary<NSNumber *, UIFontTextStyle> *mapping;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    mapping = @{
+      @(RCTDynamicTypeRampCaption2) : UIFontTextStyleCaption2,
+      @(RCTDynamicTypeRampCaption1) : UIFontTextStyleCaption1,
+      @(RCTDynamicTypeRampFootnote) : UIFontTextStyleFootnote,
+      @(RCTDynamicTypeRampSubheadline) : UIFontTextStyleSubheadline,
+      @(RCTDynamicTypeRampCallout) : UIFontTextStyleCallout,
+      @(RCTDynamicTypeRampBody) : UIFontTextStyleBody,
+      @(RCTDynamicTypeRampHeadline) : UIFontTextStyleHeadline,
+      @(RCTDynamicTypeRampTitle3) : UIFontTextStyleTitle3,
+      @(RCTDynamicTypeRampTitle2) : UIFontTextStyleTitle2,
+      @(RCTDynamicTypeRampTitle1) : UIFontTextStyleTitle1,
+      @(RCTDynamicTypeRampLargeTitle) : UIFontTextStyleLargeTitle,
+    };
+  });
+
+  id textStyle =
+      mapping[@(dynamicTypeRamp)] ?: UIFontTextStyleBody; // Default to body if we don't recognize the specified ramp
+  return [UIFontMetrics metricsForTextStyle:textStyle];
+}
+
+CGFloat RCTBaseSizeForDynamicTypeRamp(RCTDynamicTypeRamp dynamicTypeRamp)
+{
+  static NSDictionary<NSNumber *, NSNumber *> *mapping;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    // Values taken from
+    // https://developer.apple.com/design/human-interface-guidelines/foundations/typography/#specifications
+    mapping = @{
+      @(RCTDynamicTypeRampCaption2) : @11,
+      @(RCTDynamicTypeRampCaption1) : @12,
+      @(RCTDynamicTypeRampFootnote) : @13,
+      @(RCTDynamicTypeRampSubheadline) : @15,
+      @(RCTDynamicTypeRampCallout) : @16,
+      @(RCTDynamicTypeRampBody) : @17,
+      @(RCTDynamicTypeRampHeadline) : @17,
+      @(RCTDynamicTypeRampTitle3) : @20,
+      @(RCTDynamicTypeRampTitle2) : @22,
+      @(RCTDynamicTypeRampTitle1) : @28,
+      @(RCTDynamicTypeRampLargeTitle) : @34,
+    };
+  });
+
+  NSNumber *baseSize =
+      mapping[@(dynamicTypeRamp)] ?: @17; // Default to body size if we don't recognize the specified ramp
+  return [baseSize doubleValue];
+}

node_modules/react-native/Libraries/Text/Text/RCTTextShadowView.h

@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTShadowView.h>
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+#import "RCTBaseTextShadowView.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+__attribute__((deprecated("This API will be removed along with the legacy architecture.")))
+@interface RCTTextShadowView : RCTBaseTextShadowView
+
+- (instancetype)initWithBridge:(RCTBridge *)bridge;
+
+@property (nonatomic, assign) NSInteger maximumNumberOfLines;
+@property (nonatomic, assign) NSLineBreakMode lineBreakMode;
+@property (nonatomic, assign) BOOL adjustsFontSizeToFit;
+@property (nonatomic, assign) CGFloat minimumFontScale;
+@property (nonatomic, copy) RCTDirectEventBlock onTextLayout;
+
+- (void)uiManagerWillPerformMounting;
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif // RCT_REMOVE_LEGACY_ARCH

node_modules/react-native/Libraries/Text/Text/RCTTextShadowView.mm

@@ -0,0 +1,469 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTTextShadowView.h>
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+#import <React/RCTBridge.h>
+#import <React/RCTShadowView+Layout.h>
+#import <React/RCTUIManager.h>
+#import <yoga/Yoga.h>
+
+#import <React/RCTTextView.h>
+#import "NSTextStorage+FontScaling.h"
+
+@implementation RCTTextShadowView {
+  __weak RCTBridge *_bridge;
+  BOOL _needsUpdateView;
+  NSMapTable<id, NSTextStorage *> *_cachedTextStorages;
+}
+
+- (instancetype)initWithBridge:(RCTBridge *)bridge
+{
+  if (self = [super init]) {
+    _bridge = bridge;
+    _cachedTextStorages = [NSMapTable strongToStrongObjectsMapTable];
+    _needsUpdateView = YES;
+    YGNodeSetMeasureFunc(self.yogaNode, RCTTextShadowViewMeasure);
+    YGNodeSetBaselineFunc(self.yogaNode, RCTTextShadowViewBaseline);
+  }
+
+  return self;
+}
+
+- (void)didSetProps:(NSArray<NSString *> *)changedProps
+{
+  [super didSetProps:changedProps];
+
+  // When applying a semi-transparent background color to Text component
+  // we must set the root text nodes text attribute background color to nil
+  // because the background color is drawn on the RCTTextView itself, as well
+  // as on the glphy background draw step. By setting this to nil, we allow
+  // the RCTTextView backgroundColor to be used, without affecting nested Text
+  // components.
+  self.textAttributes.backgroundColor = nil;
+  self.textAttributes.opacity = NAN;
+}
+
+- (BOOL)isYogaLeafNode
+{
+  return YES;
+}
+
+- (void)dirtyLayout
+{
+  [super dirtyLayout];
+  YGNodeMarkDirty(self.yogaNode);
+  [self invalidateCache];
+}
+
+- (void)invalidateCache
+{
+  [_cachedTextStorages removeAllObjects];
+  _needsUpdateView = YES;
+}
+
+#pragma mark - RCTUIManagerObserver
+
+- (void)uiManagerWillPerformMounting
+{
+  if (YGNodeIsDirty(self.yogaNode)) {
+    return;
+  }
+
+  if (!_needsUpdateView) {
+    return;
+  }
+  _needsUpdateView = NO;
+
+  CGRect contentFrame = self.contentFrame;
+  NSTextStorage *textStorage = [self textStorageAndLayoutManagerThatFitsSize:self.contentFrame.size
+                                                          exclusiveOwnership:YES];
+
+  NSNumber *tag = self.reactTag;
+  NSMutableArray<NSNumber *> *descendantViewTags = [NSMutableArray new];
+  [textStorage enumerateAttribute:RCTBaseTextShadowViewEmbeddedShadowViewAttributeName
+                          inRange:NSMakeRange(0, textStorage.length)
+                          options:0
+                       usingBlock:^(RCTShadowView *shadowView, NSRange range, __unused BOOL *stop) {
+                         if (!shadowView) {
+                           return;
+                         }
+
+                         [descendantViewTags addObject:shadowView.reactTag];
+                       }];
+
+  [_bridge.uiManager addUIBlock:^(RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+    RCTTextView *textView = (RCTTextView *)viewRegistry[tag];
+    if (!textView) {
+      return;
+    }
+
+    NSMutableArray<UIView *> *descendantViews = [NSMutableArray arrayWithCapacity:descendantViewTags.count];
+    [descendantViewTags
+        enumerateObjectsUsingBlock:^(NSNumber *_Nonnull descendantViewTag, NSUInteger index, BOOL *_Nonnull stop) {
+          UIView *descendantView = viewRegistry[descendantViewTag];
+          if (!descendantView) {
+            return;
+          }
+
+          [descendantViews addObject:descendantView];
+        }];
+
+    // Removing all references to Shadow Views to avoid unnecessary retaining.
+    [textStorage removeAttribute:RCTBaseTextShadowViewEmbeddedShadowViewAttributeName
+                           range:NSMakeRange(0, textStorage.length)];
+
+    [textView setTextStorage:textStorage contentFrame:contentFrame descendantViews:descendantViews];
+  }];
+}
+
+- (void)postprocessAttributedText:(NSMutableAttributedString *)attributedText
+{
+  __block CGFloat maximumLineHeight = 0;
+
+  [attributedText enumerateAttribute:NSParagraphStyleAttributeName
+                             inRange:NSMakeRange(0, attributedText.length)
+                             options:NSAttributedStringEnumerationLongestEffectiveRangeNotRequired
+                          usingBlock:^(NSParagraphStyle *paragraphStyle, __unused NSRange range, __unused BOOL *stop) {
+                            if (!paragraphStyle) {
+                              return;
+                            }
+
+                            maximumLineHeight = MAX(paragraphStyle.maximumLineHeight, maximumLineHeight);
+                          }];
+
+  if (maximumLineHeight == 0) {
+    // `lineHeight` was not specified, nothing to do.
+    return;
+  }
+
+  __block CGFloat maximumFontLineHeight = 0;
+
+  [attributedText enumerateAttribute:NSFontAttributeName
+                             inRange:NSMakeRange(0, attributedText.length)
+                             options:NSAttributedStringEnumerationLongestEffectiveRangeNotRequired
+                          usingBlock:^(UIFont *font, NSRange range, __unused BOOL *stop) {
+                            if (!font) {
+                              return;
+                            }
+
+                            if (maximumFontLineHeight <= font.lineHeight) {
+                              maximumFontLineHeight = font.lineHeight;
+                            }
+                          }];
+
+  if (maximumLineHeight < maximumFontLineHeight) {
+    return;
+  }
+
+  CGFloat baseLineOffset = maximumLineHeight / 2.0 - maximumFontLineHeight / 2.0;
+
+  [attributedText addAttribute:NSBaselineOffsetAttributeName
+                         value:@(baseLineOffset)
+                         range:NSMakeRange(0, attributedText.length)];
+}
+
+- (NSAttributedString *)attributedTextWithMeasuredAttachmentsThatFitSize:(CGSize)size
+{
+  static UIImage *placeholderImage;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    placeholderImage = [UIImage new];
+  });
+
+  NSMutableAttributedString *attributedText =
+      [[NSMutableAttributedString alloc] initWithAttributedString:[self attributedTextWithBaseTextAttributes:nil]];
+
+  [attributedText beginEditing];
+
+  [attributedText enumerateAttribute:RCTBaseTextShadowViewEmbeddedShadowViewAttributeName
+                             inRange:NSMakeRange(0, attributedText.length)
+                             options:0
+                          usingBlock:^(RCTShadowView *shadowView, NSRange range, __unused BOOL *stop) {
+                            if (!shadowView) {
+                              return;
+                            }
+
+                            CGSize fittingSize = [shadowView sizeThatFitsMinimumSize:CGSizeZero maximumSize:size];
+                            NSTextAttachment *attachment = [NSTextAttachment new];
+                            attachment.bounds = (CGRect){CGPointZero, fittingSize};
+                            attachment.image = placeholderImage;
+                            [attributedText addAttribute:NSAttachmentAttributeName value:attachment range:range];
+                          }];
+
+  [attributedText endEditing];
+
+  return [attributedText copy];
+}
+
+- (NSTextStorage *)textStorageAndLayoutManagerThatFitsSize:(CGSize)size exclusiveOwnership:(BOOL)exclusiveOwnership
+{
+  NSValue *key = [NSValue valueWithCGSize:size];
+  NSTextStorage *cachedTextStorage = [_cachedTextStorages objectForKey:key];
+
+  if (cachedTextStorage) {
+    if (exclusiveOwnership) {
+      [_cachedTextStorages removeObjectForKey:key];
+    }
+
+    return cachedTextStorage;
+  }
+
+  NSTextContainer *textContainer = [[NSTextContainer alloc] initWithSize:size];
+
+  textContainer.lineFragmentPadding = 0.0; // Note, the default value is 5.
+  textContainer.lineBreakMode = _maximumNumberOfLines > 0 ? _lineBreakMode : NSLineBreakByClipping;
+  textContainer.maximumNumberOfLines = _maximumNumberOfLines;
+
+  NSLayoutManager *layoutManager = [NSLayoutManager new];
+  layoutManager.usesFontLeading = NO;
+  [layoutManager addTextContainer:textContainer];
+
+  NSTextStorage *textStorage =
+      [[NSTextStorage alloc] initWithAttributedString:[self attributedTextWithMeasuredAttachmentsThatFitSize:size]];
+
+  [self postprocessAttributedText:textStorage];
+
+  [textStorage addLayoutManager:layoutManager];
+
+  if (_adjustsFontSizeToFit) {
+    CGFloat minimumFontSize = MAX(_minimumFontScale * (self.textAttributes.effectiveFont.pointSize), 4.0);
+    [textStorage scaleFontSizeToFitSize:size
+                        minimumFontSize:minimumFontSize
+                        maximumFontSize:self.textAttributes.effectiveFont.pointSize];
+  }
+
+  [self processTruncatedAttributedText:textStorage textContainer:textContainer layoutManager:layoutManager];
+
+  if (!exclusiveOwnership) {
+    [_cachedTextStorages setObject:textStorage forKey:key];
+  }
+
+  return textStorage;
+}
+
+- (void)processTruncatedAttributedText:(NSTextStorage *)textStorage
+                         textContainer:(NSTextContainer *)textContainer
+                         layoutManager:(NSLayoutManager *)layoutManager
+{
+  if (_maximumNumberOfLines > 0) {
+    [layoutManager ensureLayoutForTextContainer:textContainer];
+    NSRange glyphRange = [layoutManager glyphRangeForTextContainer:textContainer];
+    __block int line = 0;
+    [layoutManager
+        enumerateLineFragmentsForGlyphRange:glyphRange
+                                 usingBlock:^(
+                                     CGRect rect,
+                                     CGRect usedRect,
+                                     NSTextContainer *_Nonnull _,
+                                     NSRange lineGlyphRange,
+                                     BOOL *_Nonnull stop) {
+                                   if (line == textContainer.maximumNumberOfLines - 1) {
+                                     NSRange truncatedRange = [layoutManager
+                                         truncatedGlyphRangeInLineFragmentForGlyphAtIndex:lineGlyphRange.location];
+
+                                     if (truncatedRange.location != NSNotFound) {
+                                       NSRange characterRange =
+                                           [layoutManager characterRangeForGlyphRange:truncatedRange
+                                                                     actualGlyphRange:nil];
+                                       if (characterRange.location > 0 && characterRange.length > 0) {
+                                         // Remove color attributes for truncated range
+                                         for (NSAttributedStringKey key in
+                                              @[ NSForegroundColorAttributeName, NSBackgroundColorAttributeName ]) {
+                                           [textStorage removeAttribute:key range:characterRange];
+                                           id attribute = [textStorage attribute:key
+                                                                         atIndex:characterRange.location - 1
+                                                                  effectiveRange:nil];
+                                           if (attribute) {
+                                             [textStorage addAttribute:key value:attribute range:characterRange];
+                                           }
+                                         }
+                                       }
+                                     }
+                                   }
+                                   line++;
+                                 }];
+  }
+}
+
+- (void)layoutWithMetrics:(RCTLayoutMetrics)layoutMetrics layoutContext:(RCTLayoutContext)layoutContext
+{
+  // If the view got new `contentFrame`, we have to redraw it because
+  // and sizes of embedded views may change.
+  if (!CGRectEqualToRect(self.layoutMetrics.contentFrame, layoutMetrics.contentFrame)) {
+    _needsUpdateView = YES;
+  }
+
+  if (self.textAttributes.layoutDirection != layoutMetrics.layoutDirection) {
+    self.textAttributes.layoutDirection = layoutMetrics.layoutDirection;
+    [self invalidateCache];
+  }
+
+  [super layoutWithMetrics:layoutMetrics layoutContext:layoutContext];
+}
+
+- (void)layoutSubviewsWithContext:(RCTLayoutContext)layoutContext
+{
+  NSTextStorage *textStorage = [self textStorageAndLayoutManagerThatFitsSize:self.availableSize exclusiveOwnership:NO];
+  NSLayoutManager *layoutManager = textStorage.layoutManagers.firstObject;
+  NSTextContainer *textContainer = layoutManager.textContainers.firstObject;
+  NSRange glyphRange = [layoutManager glyphRangeForTextContainer:textContainer];
+  NSRange characterRange = [layoutManager characterRangeForGlyphRange:glyphRange actualGlyphRange:NULL];
+
+  [textStorage
+      enumerateAttribute:RCTBaseTextShadowViewEmbeddedShadowViewAttributeName
+                 inRange:characterRange
+                 options:0
+              usingBlock:^(RCTShadowView *shadowView, NSRange range, BOOL *stop) {
+                if (!shadowView) {
+                  return;
+                }
+
+                CGRect glyphRect = [layoutManager boundingRectForGlyphRange:range inTextContainer:textContainer];
+
+                NSTextAttachment *attachment = [textStorage attribute:NSAttachmentAttributeName
+                                                              atIndex:range.location
+                                                       effectiveRange:nil];
+
+                CGSize attachmentSize = attachment.bounds.size;
+
+                UIFont *font = [textStorage attribute:NSFontAttributeName atIndex:range.location effectiveRange:nil];
+
+                CGRect frame = {
+                    {RCTRoundPixelValue(glyphRect.origin.x),
+                     RCTRoundPixelValue(
+                         glyphRect.origin.y + glyphRect.size.height - attachmentSize.height + font.descender)},
+                    {RCTRoundPixelValue(attachmentSize.width), RCTRoundPixelValue(attachmentSize.height)}};
+
+                NSRange truncatedGlyphRange =
+                    [layoutManager truncatedGlyphRangeInLineFragmentForGlyphAtIndex:range.location];
+                BOOL viewIsTruncated = NSIntersectionRange(range, truncatedGlyphRange).length != 0;
+
+                RCTLayoutContext localLayoutContext = layoutContext;
+                localLayoutContext.absolutePosition.x += frame.origin.x;
+                localLayoutContext.absolutePosition.y += frame.origin.y;
+
+                [shadowView layoutWithMinimumSize:{shadowView.minWidth.value, shadowView.minHeight.value}
+                                      maximumSize:frame.size
+                                  layoutDirection:self.layoutMetrics.layoutDirection
+                                    layoutContext:localLayoutContext];
+
+                RCTLayoutMetrics localLayoutMetrics = shadowView.layoutMetrics;
+                localLayoutMetrics.frame.origin =
+                    frame.origin; // Reinforcing a proper frame origin for the Shadow View.
+                if (viewIsTruncated) {
+                  localLayoutMetrics.displayType = RCTDisplayTypeNone;
+                }
+                [shadowView layoutWithMetrics:localLayoutMetrics layoutContext:localLayoutContext];
+              }];
+
+  if (_onTextLayout) {
+    NSMutableArray *lineData = [NSMutableArray new];
+    [layoutManager enumerateLineFragmentsForGlyphRange:glyphRange
+                                            usingBlock:^(
+                                                CGRect overallRect,
+                                                CGRect usedRect,
+                                                NSTextContainer *_Nonnull usedTextContainer,
+                                                NSRange lineGlyphRange,
+                                                BOOL *_Nonnull stop) {
+                                              NSRange range = [layoutManager characterRangeForGlyphRange:lineGlyphRange
+                                                                                        actualGlyphRange:nil];
+                                              NSString *renderedString = [textStorage.string substringWithRange:range];
+                                              UIFont *font = [[textStorage attributedSubstringFromRange:range]
+                                                       attribute:NSFontAttributeName
+                                                         atIndex:0
+                                                  effectiveRange:nil];
+                                              [lineData addObject:@{
+                                                @"text" : renderedString,
+                                                @"x" : @(usedRect.origin.x),
+                                                @"y" : @(usedRect.origin.y),
+                                                @"width" : @(usedRect.size.width),
+                                                @"height" : @(usedRect.size.height),
+                                                @"descender" : @(-font.descender),
+                                                @"capHeight" : @(font.capHeight),
+                                                @"ascender" : @(font.ascender),
+                                                @"xHeight" : @(font.xHeight),
+                                              }];
+                                            }];
+    NSDictionary *payload = @{
+      @"lines" : lineData,
+    };
+    _onTextLayout(payload);
+  }
+}
+
+- (CGFloat)lastBaselineForSize:(CGSize)size
+{
+  NSAttributedString *attributedText = [self textStorageAndLayoutManagerThatFitsSize:size exclusiveOwnership:NO];
+
+  __block CGFloat maximumDescender = 0.0;
+
+  [attributedText enumerateAttribute:NSFontAttributeName
+                             inRange:NSMakeRange(0, attributedText.length)
+                             options:NSAttributedStringEnumerationLongestEffectiveRangeNotRequired
+                          usingBlock:^(UIFont *font, NSRange range, __unused BOOL *stop) {
+                            if (maximumDescender > font.descender) {
+                              maximumDescender = font.descender;
+                            }
+                          }];
+
+  return size.height + maximumDescender;
+}
+
+static YGSize RCTTextShadowViewMeasure(
+    YGNodeConstRef node,
+    float width,
+    YGMeasureMode widthMode,
+    float height,
+    YGMeasureMode heightMode)
+{
+  CGSize maximumSize = (CGSize){
+      widthMode == YGMeasureModeUndefined ? CGFLOAT_MAX : RCTCoreGraphicsFloatFromYogaFloat(width),
+      heightMode == YGMeasureModeUndefined ? CGFLOAT_MAX : RCTCoreGraphicsFloatFromYogaFloat(height),
+  };
+
+  RCTTextShadowView *shadowTextView = (__bridge RCTTextShadowView *)YGNodeGetContext(node);
+
+  NSTextStorage *textStorage = [shadowTextView textStorageAndLayoutManagerThatFitsSize:maximumSize
+                                                                    exclusiveOwnership:NO];
+
+  NSLayoutManager *layoutManager = textStorage.layoutManagers.firstObject;
+  NSTextContainer *textContainer = layoutManager.textContainers.firstObject;
+  [layoutManager ensureLayoutForTextContainer:textContainer];
+  CGSize size = [layoutManager usedRectForTextContainer:textContainer].size;
+
+  CGFloat letterSpacing = shadowTextView.textAttributes.letterSpacing;
+  if (!isnan(letterSpacing) && letterSpacing < 0) {
+    size.width -= letterSpacing;
+  }
+
+  size = (CGSize){MIN(RCTCeilPixelValue(size.width), maximumSize.width),
+                  MIN(RCTCeilPixelValue(size.height), maximumSize.height)};
+
+  // Adding epsilon value illuminates problems with converting values from
+  // `double` to `float`, and then rounding them to pixel grid in Yoga.
+  CGFloat epsilon = 0.001;
+  return (YGSize){RCTYogaFloatFromCoreGraphicsFloat(size.width + epsilon),
+                  RCTYogaFloatFromCoreGraphicsFloat(size.height + epsilon)};
+}
+
+static float RCTTextShadowViewBaseline(YGNodeConstRef node, const float width, const float height)
+{
+  RCTTextShadowView *shadowTextView = (__bridge RCTTextShadowView *)YGNodeGetContext(node);
+
+  CGSize size = (CGSize){RCTCoreGraphicsFloatFromYogaFloat(width), RCTCoreGraphicsFloatFromYogaFloat(height)};
+
+  CGFloat lastBaseline = [shadowTextView lastBaselineForSize:size];
+
+  return RCTYogaFloatFromCoreGraphicsFloat(lastBaseline);
+}
+
+@end
+
+#endif // RCT_REMOVE_LEGACY_ARCH

node_modules/react-native/Libraries/Text/Text/RCTTextView.h

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTComponent.h>
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+__attribute__((deprecated("This API will be removed along with the legacy architecture.")))
+@interface RCTTextView : UIView
+
+@property (nonatomic, assign) BOOL selectable;
+
+- (void)setTextStorage:(NSTextStorage *)textStorage
+          contentFrame:(CGRect)contentFrame
+       descendantViews:(NSArray<UIView *> *)descendantViews;
+
+/**
+ * (Experimental and unused for Paper) Pointer event handlers.
+ */
+@property (nonatomic, assign) RCTBubblingEventBlock onClick;
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif // RCT_REMOVE_LEGACY_ARCH

node_modules/react-native/Libraries/Text/Text/RCTTextView.mm

@@ -0,0 +1,298 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTTextView.h>
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+#import <MobileCoreServices/UTCoreTypes.h>
+
+#import <React/RCTUtils.h>
+#import <React/UIView+React.h>
+
+#import <React/RCTTextShadowView.h>
+
+#import <QuartzCore/QuartzCore.h>
+
+@interface RCTTextView () <UIEditMenuInteractionDelegate>
+
+@property (nonatomic, nullable) UIEditMenuInteraction *editMenuInteraction API_AVAILABLE(ios(16.0));
+
+@end
+
+@implementation RCTTextView {
+  CAShapeLayer *_highlightLayer;
+  UILongPressGestureRecognizer *_longPressGestureRecognizer;
+
+  NSArray<UIView *> *_Nullable _descendantViews;
+  NSTextStorage *_Nullable _textStorage;
+  CGRect _contentFrame;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    self.isAccessibilityElement = YES;
+    self.accessibilityTraits |= UIAccessibilityTraitStaticText;
+    self.opaque = NO;
+    self.contentMode = UIViewContentModeRedraw;
+  }
+  return self;
+}
+
+- (NSString *)description
+{
+  NSString *stringToAppend = [NSString stringWithFormat:@" reactTag: %@; text: %@", self.reactTag, _textStorage.string];
+  return [[super description] stringByAppendingString:stringToAppend];
+}
+
+- (void)setSelectable:(BOOL)selectable
+{
+  if (_selectable == selectable) {
+    return;
+  }
+
+  _selectable = selectable;
+
+  if (_selectable) {
+    [self enableContextMenu];
+  } else {
+    [self disableContextMenu];
+  }
+}
+
+- (void)reactSetFrame:(CGRect)frame
+{
+  // Text looks super weird if its frame is animated.
+  // This disables the frame animation, without affecting opacity, etc.
+  [UIView performWithoutAnimation:^{
+    [super reactSetFrame:frame];
+  }];
+}
+
+- (void)didUpdateReactSubviews
+{
+  // Do nothing, as subviews are managed by `setTextStorage:` method
+}
+
+- (void)setTextStorage:(NSTextStorage *)textStorage
+          contentFrame:(CGRect)contentFrame
+       descendantViews:(NSArray<UIView *> *)descendantViews
+{
+  _textStorage = textStorage;
+  _contentFrame = contentFrame;
+
+  // FIXME: Optimize this.
+  for (UIView *view in _descendantViews) {
+    [view removeFromSuperview];
+  }
+
+  _descendantViews = descendantViews;
+
+  for (UIView *view in descendantViews) {
+    [self addSubview:view];
+  }
+
+  [self setNeedsDisplay];
+}
+
+- (void)drawRect:(CGRect)rect
+{
+  [super drawRect:rect];
+  if (!_textStorage) {
+    return;
+  }
+
+  NSLayoutManager *layoutManager = _textStorage.layoutManagers.firstObject;
+  NSTextContainer *textContainer = layoutManager.textContainers.firstObject;
+
+#if TARGET_OS_MACCATALYST
+  CGContextRef context = UIGraphicsGetCurrentContext();
+  CGContextSaveGState(context);
+  // NSLayoutManager tries to draw text with sub-pixel anti-aliasing by default on
+  // macOS, but rendering SPAA onto a transparent background produces poor results.
+  // CATextLayer disables font smoothing by default now on macOS; we follow suit.
+  CGContextSetShouldSmoothFonts(context, NO);
+#endif
+
+  NSRange glyphRange = [layoutManager glyphRangeForTextContainer:textContainer];
+  [layoutManager drawBackgroundForGlyphRange:glyphRange atPoint:_contentFrame.origin];
+  [layoutManager drawGlyphsForGlyphRange:glyphRange atPoint:_contentFrame.origin];
+
+  __block UIBezierPath *highlightPath = nil;
+  NSRange characterRange = [layoutManager characterRangeForGlyphRange:glyphRange actualGlyphRange:NULL];
+  [_textStorage
+      enumerateAttribute:RCTTextAttributesIsHighlightedAttributeName
+                 inRange:characterRange
+                 options:0
+              usingBlock:^(NSNumber *value, NSRange range, __unused BOOL *stop) {
+                if (!value.boolValue) {
+                  return;
+                }
+
+                [layoutManager
+                    enumerateEnclosingRectsForGlyphRange:range
+                                withinSelectedGlyphRange:range
+                                         inTextContainer:textContainer
+                                              usingBlock:^(CGRect enclosingRect, __unused BOOL *anotherStop) {
+                                                UIBezierPath *path = [UIBezierPath
+                                                    bezierPathWithRoundedRect:CGRectInset(enclosingRect, -2, -2)
+                                                                 cornerRadius:2];
+                                                if (highlightPath) {
+                                                  [highlightPath appendPath:path];
+                                                } else {
+                                                  highlightPath = path;
+                                                }
+                                              }];
+              }];
+
+  if (highlightPath) {
+    if (!_highlightLayer) {
+      _highlightLayer = [CAShapeLayer layer];
+      _highlightLayer.fillColor = [UIColor colorWithWhite:0 alpha:0.25].CGColor;
+      [self.layer addSublayer:_highlightLayer];
+    }
+    _highlightLayer.position = _contentFrame.origin;
+    _highlightLayer.path = highlightPath.CGPath;
+  } else {
+    [_highlightLayer removeFromSuperlayer];
+    _highlightLayer = nil;
+  }
+
+#if TARGET_OS_MACCATALYST
+  CGContextRestoreGState(context);
+#endif
+}
+
+- (NSNumber *)reactTagAtPoint:(CGPoint)point
+{
+  NSNumber *reactTag = self.reactTag;
+
+  CGFloat fraction;
+  NSLayoutManager *layoutManager = _textStorage.layoutManagers.firstObject;
+  NSTextContainer *textContainer = layoutManager.textContainers.firstObject;
+  NSUInteger characterIndex = [layoutManager characterIndexForPoint:point
+                                                    inTextContainer:textContainer
+                           fractionOfDistanceBetweenInsertionPoints:&fraction];
+
+  // If the point is not before (fraction == 0.0) the first character and not
+  // after (fraction == 1.0) the last character, then the attribute is valid.
+  if (_textStorage.length > 0 && (fraction > 0 || characterIndex > 0) &&
+      (fraction < 1 || characterIndex < _textStorage.length - 1)) {
+    reactTag = [_textStorage attribute:RCTTextAttributesTagAttributeName atIndex:characterIndex effectiveRange:NULL];
+  }
+
+  return reactTag;
+}
+
+- (void)didMoveToWindow
+{
+  [super didMoveToWindow];
+
+  if (!self.window) {
+    self.layer.contents = nil;
+    if (_highlightLayer) {
+      [_highlightLayer removeFromSuperlayer];
+      _highlightLayer = nil;
+    }
+  } else if (_textStorage) {
+    [self setNeedsDisplay];
+  }
+}
+
+#pragma mark - Accessibility
+
+- (NSString *)accessibilityLabel
+{
+  NSString *superAccessibilityLabel = [super accessibilityLabel];
+  if (superAccessibilityLabel) {
+    return superAccessibilityLabel;
+  }
+  return _textStorage.string;
+}
+
+#pragma mark - Context Menu
+
+- (void)enableContextMenu
+{
+  _longPressGestureRecognizer = [[UILongPressGestureRecognizer alloc] initWithTarget:self
+                                                                              action:@selector(handleLongPress:)];
+  if (@available(iOS 16.0, *)) {
+    _editMenuInteraction = [[UIEditMenuInteraction alloc] initWithDelegate:self];
+    [self addInteraction:_editMenuInteraction];
+  }
+
+  [self addGestureRecognizer:_longPressGestureRecognizer];
+}
+
+- (void)disableContextMenu
+{
+  [self removeGestureRecognizer:_longPressGestureRecognizer];
+
+  if (@available(iOS 16.0, *)) {
+    [self removeInteraction:_editMenuInteraction];
+    _editMenuInteraction = nil;
+  }
+  _longPressGestureRecognizer = nil;
+}
+
+- (void)handleLongPress:(UILongPressGestureRecognizer *)gesture
+{
+  if (@available(iOS 16.0, macCatalyst 16.0, *)) {
+    CGPoint location = [gesture locationInView:self];
+    UIEditMenuConfiguration *config = [UIEditMenuConfiguration configurationWithIdentifier:nil sourcePoint:location];
+    if (_editMenuInteraction) {
+      [_editMenuInteraction presentEditMenuWithConfiguration:config];
+    }
+  } else {
+    UIMenuController *menuController = [UIMenuController sharedMenuController];
+
+    if (menuController.isMenuVisible) {
+      return;
+    }
+
+    [menuController showMenuFromView:self rect:self.bounds];
+  }
+}
+
+- (BOOL)canBecomeFirstResponder
+{
+  return _selectable;
+}
+
+- (BOOL)canPerformAction:(SEL)action withSender:(id)sender
+{
+  if (_selectable && action == @selector(copy:)) {
+    return YES;
+  }
+
+  return [self.nextResponder canPerformAction:action withSender:sender];
+}
+
+- (void)copy:(id)sender
+{
+  NSAttributedString *attributedText = _textStorage;
+
+  NSMutableDictionary *item = [NSMutableDictionary new];
+
+  NSData *rtf = [attributedText dataFromRange:NSMakeRange(0, attributedText.length)
+                           documentAttributes:@{NSDocumentTypeDocumentAttribute : NSRTFDTextDocumentType}
+                                        error:nil];
+
+  if (rtf) {
+    [item setObject:rtf forKey:(id)kUTTypeFlatRTFD];
+  }
+
+  [item setObject:attributedText.string forKey:(id)kUTTypeUTF8PlainText];
+
+  UIPasteboard *pasteboard = [UIPasteboard generalPasteboard];
+  pasteboard.items = @[ item ];
+}
+
+@end
+
+#endif // RCT_REMOVE_LEGACY_ARCH

node_modules/react-native/Libraries/Text/Text/RCTTextViewManager.h

@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTViewManager.h>
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+#import "RCTBaseTextViewManager.h"
+
+__attribute__((deprecated("This API will be removed along with the legacy architecture.")))
+@interface RCTTextViewManager : RCTBaseTextViewManager
+
+@end
+
+#endif // RCT_REMOVE_LEGACY_ARCH

node_modules/react-native/Libraries/Text/Text/RCTTextViewManager.mm

@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTTextViewManager.h>
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+#import <React/RCTShadowView+Layout.h>
+#import <React/RCTShadowView.h>
+#import <React/RCTUIManager.h>
+#import <React/RCTUIManagerObserverCoordinator.h>
+#import <React/RCTUIManagerUtils.h>
+
+#import <React/RCTTextShadowView.h>
+#import <React/RCTTextView.h>
+
+@interface RCTTextViewManager () <RCTUIManagerObserver>
+
+@end
+
+@implementation RCTTextViewManager {
+  NSHashTable<RCTTextShadowView *> *_shadowViews;
+}
+
+RCT_EXPORT_MODULE(RCTText)
+
+RCT_REMAP_SHADOW_PROPERTY(numberOfLines, maximumNumberOfLines, NSInteger)
+RCT_REMAP_SHADOW_PROPERTY(ellipsizeMode, lineBreakMode, NSLineBreakMode)
+RCT_REMAP_SHADOW_PROPERTY(adjustsFontSizeToFit, adjustsFontSizeToFit, BOOL)
+RCT_REMAP_SHADOW_PROPERTY(minimumFontScale, minimumFontScale, CGFloat)
+
+RCT_EXPORT_SHADOW_PROPERTY(onTextLayout, RCTDirectEventBlock)
+
+RCT_EXPORT_VIEW_PROPERTY(selectable, BOOL)
+
+- (void)setBridge:(RCTBridge *)bridge
+{
+  [super setBridge:bridge];
+  _shadowViews = [NSHashTable weakObjectsHashTable];
+
+  [bridge.uiManager.observerCoordinator addObserver:self];
+
+  [[NSNotificationCenter defaultCenter] addObserver:self
+                                           selector:@selector(handleDidUpdateMultiplierNotification)
+                                               name:@"RCTAccessibilityManagerDidUpdateMultiplierNotification"
+                                             object:[bridge moduleForName:@"AccessibilityManager"
+                                                        lazilyLoadIfNecessary:YES]];
+}
+
+- (UIView *)view
+{
+  return [RCTTextView new];
+}
+
+- (RCTShadowView *)shadowView
+{
+  RCTTextShadowView *shadowView = [[RCTTextShadowView alloc] initWithBridge:self.bridge];
+  shadowView.textAttributes.fontSizeMultiplier =
+      [[[self.bridge moduleForName:@"AccessibilityManager"] valueForKey:@"multiplier"] floatValue];
+  [_shadowViews addObject:shadowView];
+  return shadowView;
+}
+
+#pragma mark - RCTUIManagerObserver
+
+- (void)uiManagerWillPerformMounting:(__unused RCTUIManager *)uiManager
+{
+  for (RCTTextShadowView *shadowView in _shadowViews) {
+    [shadowView uiManagerWillPerformMounting];
+  }
+}
+
+#pragma mark - Font Size Multiplier
+
+- (void)handleDidUpdateMultiplierNotification
+{
+  CGFloat fontSizeMultiplier =
+      [[[self.bridge moduleForName:@"AccessibilityManager"] valueForKey:@"multiplier"] floatValue];
+
+  NSHashTable<RCTTextShadowView *> *shadowViews = _shadowViews;
+  RCTExecuteOnUIManagerQueue(^{
+    for (RCTTextShadowView *shadowView in shadowViews) {
+      shadowView.textAttributes.fontSizeMultiplier = fontSizeMultiplier;
+      [shadowView dirtyLayout];
+    }
+
+    [self.bridge.uiManager setNeedsLayout];
+  });
+}
+
+@end
+
+#endif // RCT_REMOVE_LEGACY_ARCH

node_modules/react-native/Libraries/Text/TextAncestor.js

@@ -0,0 +1,16 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict
+ * @format
+ */
+
+// Compatibility module for ReactStrictDOMTextAncestorContext.native.js.flow (react-strict-dom)
+// TODO(huntie): Delete after we've fixed this cross-repo reference
+
+import TextAncestorContext from './TextAncestorContext';
+
+export default TextAncestorContext;

node_modules/react-native/Libraries/Text/TextAncestorContext.js

@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict
+ * @format
+ */
+
+'use strict';
+
+import * as React from 'react';
+import {createContext} from 'react';
+
+/**
+ * Whether the current element is the descendant of a <Text> element.
+ */
+const TextAncestorContext: React.Context<boolean> = createContext(false);
+if (__DEV__) {
+  TextAncestorContext.displayName = 'TextAncestorContext';
+}
+export default TextAncestorContext;

node_modules/react-native/Libraries/Text/TextInput/Multiline/RCTMultilineTextInputView.h

@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTBaseTextInputView.h"
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+NS_ASSUME_NONNULL_BEGIN
+
+__attribute__((deprecated("This API will be removed along with the legacy architecture.")))
+@interface RCTMultilineTextInputView : RCTBaseTextInputView
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif // RCT_REMOVE_LEGACY_ARCH

node_modules/react-native/Libraries/Text/TextInput/Multiline/RCTMultilineTextInputView.mm

@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTMultilineTextInputView.h>
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+#import <React/RCTUtils.h>
+
+#import <React/RCTUITextView.h>
+
+@implementation RCTMultilineTextInputView {
+  RCTUITextView *_backedTextInputView;
+}
+
+- (instancetype)initWithBridge:(RCTBridge *)bridge
+{
+  if (self = [super initWithBridge:bridge]) {
+    _backedTextInputView = [[RCTUITextView alloc] initWithFrame:self.bounds];
+    _backedTextInputView.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
+    _backedTextInputView.textInputDelegate = self;
+
+    [self addSubview:_backedTextInputView];
+  }
+
+  return self;
+}
+
+- (id<RCTBackedTextInputViewProtocol>)backedTextInputView
+{
+  return _backedTextInputView;
+}
+
+#pragma mark - UIScrollViewDelegate
+
+- (void)scrollViewDidScroll:(UIScrollView *)scrollView
+{
+  RCTDirectEventBlock onScroll = self.onScroll;
+
+  if (onScroll) {
+    CGPoint contentOffset = scrollView.contentOffset;
+    CGSize contentSize = scrollView.contentSize;
+    CGSize size = scrollView.bounds.size;
+    UIEdgeInsets contentInset = scrollView.contentInset;
+
+    onScroll(@{
+      @"contentOffset" : @{@"x" : @(contentOffset.x), @"y" : @(contentOffset.y)},
+      @"contentInset" : @{
+        @"top" : @(contentInset.top),
+        @"left" : @(contentInset.left),
+        @"bottom" : @(contentInset.bottom),
+        @"right" : @(contentInset.right)
+      },
+      @"contentSize" : @{@"width" : @(contentSize.width), @"height" : @(contentSize.height)},
+      @"layoutMeasurement" : @{@"width" : @(size.width), @"height" : @(size.height)},
+      @"zoomScale" : @(scrollView.zoomScale ?: 1),
+    });
+  }
+}
+
+@end
+
+#endif // RCT_REMOVE_LEGACY_ARCH

node_modules/react-native/Libraries/Text/TextInput/Multiline/RCTMultilineTextInputViewManager.h

@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTBaseTextInputViewManager.h"
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+NS_ASSUME_NONNULL_BEGIN
+
+__attribute__((deprecated("This API will be removed along with the legacy architecture.")))
+@interface RCTMultilineTextInputViewManager : RCTBaseTextInputViewManager
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif // RCT_REMOVE_LEGACY_ARCH

node_modules/react-native/Libraries/Text/TextInput/Multiline/RCTMultilineTextInputViewManager.mm

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTMultilineTextInputView.h>
+#import <React/RCTMultilineTextInputViewManager.h>
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+@implementation RCTMultilineTextInputViewManager
+
+RCT_EXPORT_MODULE()
+
+- (UIView *)view
+{
+  return [[RCTMultilineTextInputView alloc] initWithBridge:self.bridge];
+}
+
+#pragma mark - Multiline <TextInput> (aka TextView) specific properties
+
+RCT_REMAP_VIEW_PROPERTY(dataDetectorTypes, backedTextInputView.dataDetectorTypes, UIDataDetectorTypes)
+
+@end
+
+#endif // RCT_REMOVE_LEGACY_ARCH

node_modules/react-native/Libraries/Text/TextInput/Multiline/RCTUITextView.h

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <UIKit/UIKit.h>
+
+#import <React/RCTBackedTextInputDelegate.h>
+#import <React/RCTBackedTextInputViewProtocol.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/*
+ * Just regular UITextView... but much better!
+ */
+@interface RCTUITextView : UITextView <RCTBackedTextInputViewProtocol>
+
+- (instancetype)initWithFrame:(CGRect)frame textContainer:(nullable NSTextContainer *)textContainer NS_UNAVAILABLE;
+- (instancetype)initWithCoder:(NSCoder *)decoder NS_UNAVAILABLE;
+
+@property (nonatomic, weak) id<RCTBackedTextInputDelegate> textInputDelegate;
+
+@property (nonatomic, assign) BOOL contextMenuHidden;
+@property (nonatomic, assign, readonly) BOOL textWasPasted;
+@property (nonatomic, assign, readonly) BOOL dictationRecognizing;
+@property (nonatomic, copy, nullable) NSString *placeholder;
+@property (nonatomic, strong, nullable) UIColor *placeholderColor;
+
+@property (nonatomic, assign) CGFloat preferredMaxLayoutWidth;
+
+// The `clearButtonMode` property actually is not supported yet;
+// it's declared here only to conform to the interface.
+@property (nonatomic, assign) UITextFieldViewMode clearButtonMode;
+
+@property (nonatomic, assign) BOOL caretHidden;
+
+@property (nonatomic, strong, nullable) NSString *inputAccessoryViewID;
+@property (nonatomic, strong, nullable) NSString *inputAccessoryViewButtonLabel;
+
+@property (nonatomic, assign) BOOL disableKeyboardShortcuts;
+
+@end
+
+NS_ASSUME_NONNULL_END

node_modules/react-native/Libraries/Text/TextInput/Multiline/RCTUITextView.mm

@@ -0,0 +1,375 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTUITextView.h>
+
+#import <React/RCTUtils.h>
+#import <React/UIView+React.h>
+
+#import <React/RCTBackedTextInputDelegateAdapter.h>
+#import <React/RCTTextAttributes.h>
+
+@implementation RCTUITextView {
+  UILabel *_placeholderView;
+  UITextView *_detachedTextView;
+  RCTBackedTextViewDelegateAdapter *_textInputDelegateAdapter;
+  NSDictionary<NSAttributedStringKey, id> *_defaultTextAttributes;
+  NSArray<UIBarButtonItemGroup *> *_initialValueLeadingBarButtonGroups;
+  NSArray<UIBarButtonItemGroup *> *_initialValueTrailingBarButtonGroups;
+  NSArray<NSString *> *_acceptDragAndDropTypes;
+}
+
+static UIFont *defaultPlaceholderFont(void)
+{
+  return [UIFont preferredFontForTextStyle:UIFontTextStyleBody];
+}
+
+static UIColor *defaultPlaceholderColor(void)
+{
+  // Default placeholder color from UITextField.
+  return [UIColor placeholderTextColor];
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    [[NSNotificationCenter defaultCenter] addObserver:self
+                                             selector:@selector(textDidChange)
+                                                 name:UITextViewTextDidChangeNotification
+                                               object:self];
+
+    _placeholderView = [[UILabel alloc] initWithFrame:self.bounds];
+    _placeholderView.isAccessibilityElement = NO;
+    _placeholderView.numberOfLines = 0;
+    [self addSubview:_placeholderView];
+
+    _textInputDelegateAdapter = [[RCTBackedTextViewDelegateAdapter alloc] initWithTextView:self];
+
+    self.backgroundColor = [UIColor clearColor];
+    self.textColor = [UIColor blackColor];
+    // This line actually removes 5pt (default value) left and right padding in UITextView.
+    self.textContainer.lineFragmentPadding = 0;
+    self.scrollsToTop = NO;
+    self.scrollEnabled = YES;
+    _initialValueLeadingBarButtonGroups = nil;
+    _initialValueTrailingBarButtonGroups = nil;
+  }
+
+  return self;
+}
+
+- (void)setDelegate:(id<UITextViewDelegate>)delegate
+{
+  // Delegate is set inside `[RCTBackedTextViewDelegateAdapter initWithTextView]` and
+  // it cannot be changed from outside.
+  if (super.delegate) {
+    return;
+  }
+  [super setDelegate:delegate];
+}
+
+#pragma mark - Accessibility
+
+- (void)setIsAccessibilityElement:(BOOL)isAccessibilityElement
+{
+  // UITextView is accessible by default (some nested views are) and disabling that is not supported.
+  // On iOS accessible elements cannot be nested, therefore enabling accessibility for some container view
+  // (even in a case where this view is a part of public API of TextInput on iOS) shadows some features implemented
+  // inside the component.
+}
+
+- (NSString *)accessibilityLabel
+{
+  NSMutableString *accessibilityLabel = [NSMutableString new];
+
+  NSString *superAccessibilityLabel = [super accessibilityLabel];
+  if (superAccessibilityLabel.length > 0) {
+    [accessibilityLabel appendString:superAccessibilityLabel];
+  }
+
+  if (self.placeholder.length > 0 && self.attributedText.string.length == 0) {
+    if (accessibilityLabel.length > 0) {
+      [accessibilityLabel appendString:@" "];
+    }
+    [accessibilityLabel appendString:self.placeholder];
+  }
+
+  return accessibilityLabel;
+}
+
+#pragma mark - Properties
+
+- (void)setAcceptDragAndDropTypes:(NSArray<NSString *> *)acceptDragAndDropTypes
+{
+  _acceptDragAndDropTypes = acceptDragAndDropTypes;
+}
+
+- (nullable NSArray<NSString *> *)acceptDragAndDropTypes
+{
+  return _acceptDragAndDropTypes;
+}
+
+- (void)setPlaceholder:(NSString *)placeholder
+{
+  _placeholder = placeholder;
+  [self _updatePlaceholder];
+}
+
+- (void)setPlaceholderColor:(UIColor *)placeholderColor
+{
+  _placeholderColor = placeholderColor;
+  [self _updatePlaceholder];
+}
+
+- (void)setDefaultTextAttributes:(NSDictionary<NSAttributedStringKey, id> *)defaultTextAttributes
+{
+  if ([_defaultTextAttributes isEqualToDictionary:defaultTextAttributes]) {
+    return;
+  }
+
+  _defaultTextAttributes = defaultTextAttributes;
+  self.typingAttributes = defaultTextAttributes;
+  [self _updatePlaceholder];
+}
+
+- (NSDictionary<NSAttributedStringKey, id> *)defaultTextAttributes
+{
+  return _defaultTextAttributes;
+}
+
+- (void)textDidChange
+{
+  _textWasPasted = NO;
+  [self _invalidatePlaceholderVisibility];
+}
+
+- (void)setDisableKeyboardShortcuts:(BOOL)disableKeyboardShortcuts
+{
+#if TARGET_OS_IOS
+  // Initialize the initial values only once
+  if (_initialValueLeadingBarButtonGroups == nil) {
+    // Capture initial values of leading and trailing button groups
+    _initialValueLeadingBarButtonGroups = self.inputAssistantItem.leadingBarButtonGroups;
+    _initialValueTrailingBarButtonGroups = self.inputAssistantItem.trailingBarButtonGroups;
+  }
+
+  if (disableKeyboardShortcuts) {
+    self.inputAssistantItem.leadingBarButtonGroups = @[];
+    self.inputAssistantItem.trailingBarButtonGroups = @[];
+  } else {
+    // Restore the initial values
+    self.inputAssistantItem.leadingBarButtonGroups = _initialValueLeadingBarButtonGroups;
+    self.inputAssistantItem.trailingBarButtonGroups = _initialValueTrailingBarButtonGroups;
+  }
+  _disableKeyboardShortcuts = disableKeyboardShortcuts;
+#endif
+}
+
+#pragma mark - Overrides
+
+- (void)setFont:(UIFont *)font
+{
+  [super setFont:font];
+  [self _updatePlaceholder];
+}
+
+- (void)setTextAlignment:(NSTextAlignment)textAlignment
+{
+  [super setTextAlignment:textAlignment];
+  _placeholderView.textAlignment = textAlignment;
+}
+
+- (void)setAttributedText:(NSAttributedString *)attributedText
+{
+  [super setAttributedText:attributedText];
+  [self textDidChange];
+}
+
+- (void)setSelectedTextRange:(UITextRange *)selectedTextRange notifyDelegate:(BOOL)notifyDelegate
+{
+  if (!notifyDelegate) {
+    // We have to notify an adapter that following selection change was initiated programmatically,
+    // so the adapter must not generate a notification for it.
+    [_textInputDelegateAdapter skipNextTextInputDidChangeSelectionEventWithTextRange:selectedTextRange];
+  }
+
+  [super setSelectedTextRange:selectedTextRange];
+}
+
+// After restoring the previous cursor position, we manually trigger the scroll to the new cursor position (PR 38679).
+- (void)scrollRangeToVisible:(NSRange)range
+{
+  [super scrollRangeToVisible:range];
+}
+
+- (void)paste:(id)sender
+{
+  _textWasPasted = YES;
+  [super paste:sender];
+}
+
+// Turn off scroll animation to fix flaky scrolling.
+// This is only necessary for iOS < 14.
+#if defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && __IPHONE_OS_VERSION_MAX_ALLOWED < 140000
+- (void)setContentOffset:(CGPoint)contentOffset animated:(__unused BOOL)animated
+{
+  [super setContentOffset:contentOffset animated:NO];
+}
+#endif
+
+- (void)selectAll:(id)sender
+{
+  [super selectAll:sender];
+
+  // `selectAll:` does not work for UITextView when it's being called inside UITextView's delegate methods.
+  dispatch_async(dispatch_get_main_queue(), ^{
+    UITextRange *selectionRange = [self textRangeFromPosition:self.beginningOfDocument toPosition:self.endOfDocument];
+    [self setSelectedTextRange:selectionRange notifyDelegate:NO];
+  });
+}
+
+#pragma mark - Layout
+
+- (CGFloat)preferredMaxLayoutWidth
+{
+  // Returning size DOES contain `textContainerInset` (aka `padding`).
+  return _preferredMaxLayoutWidth ?: self.placeholderSize.width;
+}
+
+- (CGSize)placeholderSize
+{
+  UIEdgeInsets textContainerInset = self.textContainerInset;
+  NSString *placeholder = self.placeholder ?: @"";
+  CGSize maxPlaceholderSize =
+      CGSizeMake(UIEdgeInsetsInsetRect(self.bounds, textContainerInset).size.width, CGFLOAT_MAX);
+  CGSize placeholderSize = [placeholder boundingRectWithSize:maxPlaceholderSize
+                                                     options:NSStringDrawingUsesLineFragmentOrigin
+                                                  attributes:[self _placeholderTextAttributes]
+                                                     context:nil]
+                               .size;
+  placeholderSize = CGSizeMake(RCTCeilPixelValue(placeholderSize.width), RCTCeilPixelValue(placeholderSize.height));
+  placeholderSize.width += textContainerInset.left + textContainerInset.right;
+  placeholderSize.height += textContainerInset.top + textContainerInset.bottom;
+  // Returning size DOES contain `textContainerInset` (aka `padding`; as `sizeThatFits:` does).
+  return placeholderSize;
+}
+
+- (CGSize)contentSize
+{
+  CGSize contentSize = super.contentSize;
+  CGSize placeholderSize = _placeholderView.isHidden ? CGSizeZero : self.placeholderSize;
+  // When a text input is empty, it actually displays a placeholder.
+  // So, we have to consider `placeholderSize` as a minimum `contentSize`.
+  // Returning size DOES contain `textContainerInset` (aka `padding`).
+  return CGSizeMake(MAX(contentSize.width, placeholderSize.width), MAX(contentSize.height, placeholderSize.height));
+}
+
+- (void)layoutSubviews
+{
+  [super layoutSubviews];
+
+  CGRect textFrame = UIEdgeInsetsInsetRect(self.bounds, self.textContainerInset);
+  CGFloat placeholderHeight = [_placeholderView sizeThatFits:textFrame.size].height;
+  textFrame.size.height = MIN(placeholderHeight, textFrame.size.height);
+  _placeholderView.frame = textFrame;
+}
+
+- (CGSize)intrinsicContentSize
+{
+  // Returning size DOES contain `textContainerInset` (aka `padding`).
+  return [self sizeThatFits:CGSizeMake(self.preferredMaxLayoutWidth, CGFLOAT_MAX)];
+}
+
+- (CGSize)sizeThatFits:(CGSize)size
+{
+  // Returned fitting size depends on text size and placeholder size.
+  CGSize textSize = [super sizeThatFits:size];
+  CGSize placeholderSize = self.placeholderSize;
+  // Returning size DOES contain `textContainerInset` (aka `padding`).
+  return CGSizeMake(MAX(textSize.width, placeholderSize.width), MAX(textSize.height, placeholderSize.height));
+}
+
+#pragma mark - Context Menu
+
+- (BOOL)canPerformAction:(SEL)action withSender:(id)sender
+{
+  if (_contextMenuHidden) {
+    return NO;
+  }
+
+  return [super canPerformAction:action withSender:sender];
+}
+
+- (void)buildMenuWithBuilder:(id<UIMenuBuilder>)builder
+{
+#if defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && __IPHONE_OS_VERSION_MAX_ALLOWED >= 170000
+  if (@available(iOS 17.0, *)) {
+    if (_contextMenuHidden) {
+      [builder removeMenuForIdentifier:UIMenuAutoFill];
+    }
+  }
+#endif
+
+  [super buildMenuWithBuilder:builder];
+}
+
+#pragma mark - Dictation
+
+- (void)dictationRecordingDidEnd
+{
+  _dictationRecognizing = YES;
+}
+
+- (void)removeDictationResultPlaceholder:(id)placeholder willInsertResult:(BOOL)willInsertResult
+{
+  [super removeDictationResultPlaceholder:placeholder willInsertResult:willInsertResult];
+  _dictationRecognizing = NO;
+}
+
+#pragma mark - Placeholder
+
+- (void)_invalidatePlaceholderVisibility
+{
+  BOOL isVisible = _placeholder.length != 0 && self.attributedText.length == 0;
+  _placeholderView.hidden = !isVisible;
+}
+
+- (void)_updatePlaceholder
+{
+  _placeholderView.attributedText = [[NSAttributedString alloc] initWithString:_placeholder ?: @""
+                                                                    attributes:[self _placeholderTextAttributes]];
+  [self _invalidatePlaceholderVisibility];
+}
+
+- (NSDictionary<NSAttributedStringKey, id> *)_placeholderTextAttributes
+{
+  NSMutableDictionary<NSAttributedStringKey, id> *textAttributes =
+      [_defaultTextAttributes mutableCopy] ?: [NSMutableDictionary new];
+
+  [textAttributes setValue:self.placeholderColor ?: defaultPlaceholderColor() forKey:NSForegroundColorAttributeName];
+
+  if (![textAttributes objectForKey:NSFontAttributeName]) {
+    [textAttributes setValue:defaultPlaceholderFont() forKey:NSFontAttributeName];
+  }
+
+  return textAttributes;
+}
+
+#pragma mark - Caret Manipulation
+
+- (CGRect)caretRectForPosition:(UITextPosition *)position
+{
+  if (_caretHidden) {
+    return CGRectZero;
+  }
+
+  return [super caretRectForPosition:position];
+}
+
+#pragma mark - Utility Methods
+
+@end

node_modules/react-native/Libraries/Text/TextInput/RCTBackedTextInputDelegate.h

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <UIKit/UIKit.h>
+
+@protocol RCTBackedTextInputViewProtocol;
+
+NS_ASSUME_NONNULL_BEGIN
+
+@protocol RCTBackedTextInputDelegate <NSObject>
+
+- (BOOL)textInputShouldBeginEditing; // Return `NO` to disallow editing.
+- (void)textInputDidBeginEditing;
+
+- (BOOL)textInputShouldEndEditing; // Return `YES` to allow editing to stop and to resign first responder status. `NO`
+                                   // to disallow the editing session to end.
+- (void)textInputDidEndEditing; // May be called if forced even if `textInputShouldEndEditing` returns `NO` (e.g. view
+                                // removed from window) or `[textInput endEditing:YES]` called.
+
+- (BOOL)textInputShouldReturn; // May be called right before `textInputShouldEndEditing` if "Return" button was pressed.
+                               // Dismisses keyboard if true
+- (void)textInputDidReturn;
+
+- (BOOL)textInputShouldSubmitOnReturn; // Checks whether to submit when return is pressed and emits an event if true.
+
+/*
+ * Called before any change in the TextInput. The delegate has the opportunity to change the replacement string or
+ * reject the change completely. To change the replacement, return the changed version of the `text`. To accept the
+ * change, return `text` argument as-is. To reject the change, return `nil`.
+ */
+- (NSString *)textInputShouldChangeText:(NSString *)text inRange:(NSRange)range;
+- (void)textInputDidChange;
+
+- (void)textInputDidChangeSelection;
+
+@optional
+
+- (void)scrollViewDidScroll:(UIScrollView *)scrollView;
+
+@end
+
+NS_ASSUME_NONNULL_END

node_modules/react-native/Libraries/Text/TextInput/RCTBackedTextInputDelegateAdapter.h

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <UIKit/UIKit.h>
+
+#import "RCTBackedTextInputDelegate.h"
+#import "RCTBackedTextInputViewProtocol.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+#pragma mark - RCTBackedTextFieldDelegateAdapter (for UITextField)
+
+@interface RCTBackedTextFieldDelegateAdapter : NSObject
+
+- (instancetype)initWithTextField:(UITextField<RCTBackedTextInputViewProtocol> *)backedTextInputView;
+
+- (void)skipNextTextInputDidChangeSelectionEventWithTextRange:(UITextRange *)textRange;
+- (void)selectedTextRangeWasSet;
+
+@end
+
+#pragma mark - RCTBackedTextViewDelegateAdapter (for UITextView)
+
+@interface RCTBackedTextViewDelegateAdapter : NSObject
+
+- (instancetype)initWithTextView:(UITextView<RCTBackedTextInputViewProtocol> *)backedTextInputView;
+
+- (void)skipNextTextInputDidChangeSelectionEventWithTextRange:(UITextRange *)textRange;
+
+@end
+
+NS_ASSUME_NONNULL_END

node_modules/react-native/Libraries/Text/TextInput/RCTBackedTextInputDelegateAdapter.mm

@@ -0,0 +1,381 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTBackedTextInputDelegateAdapter.h>
+
+#pragma mark - RCTBackedTextFieldDelegateAdapter (for UITextField)
+
+static void *TextFieldSelectionObservingContext = &TextFieldSelectionObservingContext;
+
+@interface RCTBackedTextFieldDelegateAdapter () <UITextFieldDelegate, UITextDropDelegate>
+@end
+
+@implementation RCTBackedTextFieldDelegateAdapter {
+  __weak UITextField<RCTBackedTextInputViewProtocol> *_backedTextInputView;
+  BOOL _textDidChangeIsComing;
+  UITextRange *_previousSelectedTextRange;
+}
+
+- (instancetype)initWithTextField:(UITextField<RCTBackedTextInputViewProtocol> *)backedTextInputView
+{
+  if (self = [super init]) {
+    _backedTextInputView = backedTextInputView;
+    backedTextInputView.delegate = self;
+    backedTextInputView.textDropDelegate = self;
+
+    [_backedTextInputView addTarget:self
+                             action:@selector(textFieldDidChange)
+                   forControlEvents:UIControlEventEditingChanged];
+    [_backedTextInputView addTarget:self
+                             action:@selector(textFieldDidEndEditingOnExit)
+                   forControlEvents:UIControlEventEditingDidEndOnExit];
+  }
+
+  return self;
+}
+
+- (void)dealloc
+{
+  [_backedTextInputView removeTarget:self action:nil forControlEvents:UIControlEventEditingChanged];
+  [_backedTextInputView removeTarget:self action:nil forControlEvents:UIControlEventEditingDidEndOnExit];
+}
+
+#pragma mark - UITextFieldDelegate
+
+- (BOOL)textFieldShouldBeginEditing:(__unused UITextField *)textField
+{
+  return [_backedTextInputView.textInputDelegate textInputShouldBeginEditing];
+}
+
+- (void)textFieldDidBeginEditing:(__unused UITextField *)textField
+{
+  [_backedTextInputView.textInputDelegate textInputDidBeginEditing];
+}
+
+- (BOOL)textFieldShouldEndEditing:(__unused UITextField *)textField
+{
+  return [_backedTextInputView.textInputDelegate textInputShouldEndEditing];
+}
+
+- (void)textFieldDidEndEditing:(__unused UITextField *)textField
+{
+  if (_textDidChangeIsComing) {
+    // iOS does't call `textViewDidChange:` delegate method if the change was happened because of autocorrection
+    // which was triggered by losing focus. So, we call it manually.
+    _textDidChangeIsComing = NO;
+    [_backedTextInputView.textInputDelegate textInputDidChange];
+  }
+
+  [_backedTextInputView.textInputDelegate textInputDidEndEditing];
+}
+
+- (BOOL)textField:(__unused UITextField *)textField
+    shouldChangeCharactersInRange:(NSRange)range
+                replacementString:(NSString *)string
+{
+  NSString *newText = [_backedTextInputView.textInputDelegate textInputShouldChangeText:string inRange:range];
+
+  if (newText == nil) {
+    return NO;
+  }
+
+  if ([newText isEqualToString:string]) {
+    _textDidChangeIsComing = YES;
+    return YES;
+  }
+
+  NSMutableAttributedString *attributedString = [_backedTextInputView.attributedText mutableCopy];
+  [attributedString replaceCharactersInRange:range withString:newText];
+  [_backedTextInputView setAttributedText:[attributedString copy]];
+
+  // Setting selection to the end of the replaced text.
+  UITextPosition *position = [_backedTextInputView positionFromPosition:_backedTextInputView.beginningOfDocument
+                                                                 offset:(range.location + newText.length)];
+  [_backedTextInputView setSelectedTextRange:[_backedTextInputView textRangeFromPosition:position toPosition:position]
+                              notifyDelegate:YES];
+
+  [self textFieldDidChange];
+
+  return NO;
+}
+
+- (BOOL)textFieldShouldReturn:(__unused UITextField *)textField
+{
+  // Ignore the value of whether we submitted; just make sure the submit event is called if necessary.
+  [_backedTextInputView.textInputDelegate textInputShouldSubmitOnReturn];
+  return [_backedTextInputView.textInputDelegate textInputShouldReturn];
+}
+
+#pragma mark - UIControlEventEditing* Family Events
+
+- (void)textFieldDidChange
+{
+  _textDidChangeIsComing = NO;
+  [_backedTextInputView.textInputDelegate textInputDidChange];
+
+  // `selectedTextRangeWasSet` isn't triggered during typing.
+  [self textFieldProbablyDidChangeSelection];
+}
+
+- (void)textFieldDidEndEditingOnExit
+{
+  [_backedTextInputView.textInputDelegate textInputDidReturn];
+}
+
+#pragma mark - UIKeyboardInput (private UIKit protocol)
+
+// This method allows us to detect a [Backspace] `keyPress`
+// even when there is no more text in the `UITextField`.
+- (BOOL)keyboardInputShouldDelete:(__unused UITextField *)textField
+{
+  [_backedTextInputView.textInputDelegate textInputShouldChangeText:@"" inRange:NSMakeRange(0, 0)];
+  return YES;
+}
+
+#pragma mark - Public Interface
+
+- (void)skipNextTextInputDidChangeSelectionEventWithTextRange:(UITextRange *)textRange
+{
+  _previousSelectedTextRange = textRange;
+}
+
+- (void)selectedTextRangeWasSet
+{
+  [self textFieldProbablyDidChangeSelection];
+}
+
+#pragma mark - Generalization
+
+- (void)textFieldProbablyDidChangeSelection
+{
+  if ([_backedTextInputView.selectedTextRange isEqual:_previousSelectedTextRange]) {
+    return;
+  }
+
+  _previousSelectedTextRange = _backedTextInputView.selectedTextRange;
+  [_backedTextInputView.textInputDelegate textInputDidChangeSelection];
+}
+
+#pragma mark - UITextDropDelegate
+
+- (UITextDropEditability)textDroppableView:(UIView<UITextDroppable> *)textDroppableView
+                 willBecomeEditableForDrop:(id<UITextDropRequest>)drop
+{
+  if (!_backedTextInputView.enabled) {
+    return UITextDropEditabilityNo;
+  }
+  if ([self _shouldAcceptDrop:drop]) {
+    return UITextDropEditabilityYes;
+  } else {
+    return UITextDropEditabilityNo;
+  }
+}
+
+- (UITextDropProposal *)textDroppableView:(UIView<UITextDroppable> *)textDroppableView
+                          proposalForDrop:(id<UITextDropRequest>)drop
+{
+  if ([self _shouldAcceptDrop:drop]) {
+    return drop.suggestedProposal;
+  } else {
+    return [[UITextDropProposal alloc] initWithDropOperation:UIDropOperationCancel];
+  }
+}
+
+- (bool)_shouldAcceptDrop:(id<UITextDropRequest>)drop
+{
+  if (_backedTextInputView.acceptDragAndDropTypes) {
+    // If we have accepted types, we should only accept drops that match one of them
+    return [drop.dropSession hasItemsConformingToTypeIdentifiers:_backedTextInputView.acceptDragAndDropTypes];
+  } else {
+    // If we don't have any accepted types, we should accept any drop
+    return true;
+  }
+}
+
+@end
+
+#pragma mark - RCTBackedTextViewDelegateAdapter (for UITextView)
+
+@interface RCTBackedTextViewDelegateAdapter () <UITextViewDelegate, UITextDropDelegate>
+@end
+
+@implementation RCTBackedTextViewDelegateAdapter {
+  __weak UITextView<RCTBackedTextInputViewProtocol> *_backedTextInputView;
+  NSAttributedString *_lastStringStateWasUpdatedWith;
+  BOOL _ignoreNextTextInputCall;
+  BOOL _textDidChangeIsComing;
+  UITextRange *_previousSelectedTextRange;
+}
+
+- (instancetype)initWithTextView:(UITextView<RCTBackedTextInputViewProtocol> *)backedTextInputView
+{
+  if (self = [super init]) {
+    _backedTextInputView = backedTextInputView;
+    backedTextInputView.delegate = self;
+    backedTextInputView.textDropDelegate = self;
+  }
+
+  return self;
+}
+
+#pragma mark - UITextViewDelegate
+
+- (BOOL)textViewShouldBeginEditing:(__unused UITextView *)textView
+{
+  return [_backedTextInputView.textInputDelegate textInputShouldBeginEditing];
+}
+
+- (void)textViewDidBeginEditing:(__unused UITextView *)textView
+{
+  [_backedTextInputView.textInputDelegate textInputDidBeginEditing];
+}
+
+- (BOOL)textViewShouldEndEditing:(__unused UITextView *)textView
+{
+  return [_backedTextInputView.textInputDelegate textInputShouldEndEditing];
+}
+
+- (void)textViewDidEndEditing:(__unused UITextView *)textView
+{
+  if (_textDidChangeIsComing) {
+    // iOS does't call `textViewDidChange:` delegate method if the change was happened because of autocorrection
+    // which was triggered by losing focus. So, we call it manually.
+    _textDidChangeIsComing = NO;
+    [_backedTextInputView.textInputDelegate textInputDidChange];
+  }
+
+  [_backedTextInputView.textInputDelegate textInputDidEndEditing];
+}
+
+- (BOOL)textView:(__unused UITextView *)textView shouldChangeTextInRange:(NSRange)range replacementText:(NSString *)text
+{
+  // Custom implementation of `textInputShouldReturn` and `textInputDidReturn` pair for `UITextView`.
+  if (!_backedTextInputView.textWasPasted && [text isEqualToString:@"\n"]) {
+    const BOOL shouldSubmit = [_backedTextInputView.textInputDelegate textInputShouldSubmitOnReturn];
+    const BOOL shouldReturn = [_backedTextInputView.textInputDelegate textInputShouldReturn];
+    if (shouldReturn) {
+      [_backedTextInputView.textInputDelegate textInputDidReturn];
+      [_backedTextInputView endEditing:NO];
+      return NO;
+    } else if (shouldSubmit) {
+      return NO;
+    }
+  }
+
+  NSString *newText = [_backedTextInputView.textInputDelegate textInputShouldChangeText:text inRange:range];
+
+  if (newText == nil) {
+    return NO;
+  }
+
+  if (range.location + range.length > _backedTextInputView.text.length) {
+    range = NSMakeRange(range.location, _backedTextInputView.text.length - range.location);
+  } else if ([newText isEqualToString:text]) {
+    _textDidChangeIsComing = YES;
+    return YES;
+  }
+
+  NSMutableAttributedString *attributedString = [_backedTextInputView.attributedText mutableCopy];
+  [attributedString replaceCharactersInRange:range withString:newText];
+  [_backedTextInputView setAttributedText:[attributedString copy]];
+
+  // Setting selection to the end of the replaced text.
+  UITextPosition *position = [_backedTextInputView positionFromPosition:_backedTextInputView.beginningOfDocument
+                                                                 offset:(range.location + newText.length)];
+  [_backedTextInputView setSelectedTextRange:[_backedTextInputView textRangeFromPosition:position toPosition:position]
+                              notifyDelegate:YES];
+
+  [self textViewDidChange:_backedTextInputView];
+
+  return NO;
+}
+
+- (void)textViewDidChange:(__unused UITextView *)textView
+{
+  if (_ignoreNextTextInputCall && [_lastStringStateWasUpdatedWith isEqual:_backedTextInputView.attributedText]) {
+    _ignoreNextTextInputCall = NO;
+    return;
+  }
+  _textDidChangeIsComing = NO;
+  [_backedTextInputView.textInputDelegate textInputDidChange];
+}
+
+- (void)textViewDidChangeSelection:(__unused UITextView *)textView
+{
+  if (_lastStringStateWasUpdatedWith && ![_lastStringStateWasUpdatedWith isEqual:_backedTextInputView.attributedText]) {
+    [self textViewDidChange:_backedTextInputView];
+    _ignoreNextTextInputCall = YES;
+  }
+  _lastStringStateWasUpdatedWith = _backedTextInputView.attributedText;
+  [self textViewProbablyDidChangeSelection];
+}
+
+#pragma mark - UIScrollViewDelegate
+
+- (void)scrollViewDidScroll:(UIScrollView *)scrollView
+{
+  if ([_backedTextInputView.textInputDelegate respondsToSelector:@selector(scrollViewDidScroll:)]) {
+    [_backedTextInputView.textInputDelegate scrollViewDidScroll:scrollView];
+  }
+}
+
+#pragma mark - Public Interface
+
+- (void)skipNextTextInputDidChangeSelectionEventWithTextRange:(UITextRange *)textRange
+{
+  _previousSelectedTextRange = textRange;
+}
+
+#pragma mark - Generalization
+
+- (void)textViewProbablyDidChangeSelection
+{
+  if ([_backedTextInputView.selectedTextRange isEqual:_previousSelectedTextRange]) {
+    return;
+  }
+
+  _previousSelectedTextRange = _backedTextInputView.selectedTextRange;
+  [_backedTextInputView.textInputDelegate textInputDidChangeSelection];
+}
+
+#pragma mark - UITextDropDelegate
+
+- (UITextDropEditability)textDroppableView:(UIView<UITextDroppable> *)textDroppableView
+                 willBecomeEditableForDrop:(id<UITextDropRequest>)drop
+{
+  if (!_backedTextInputView.isEditable) {
+    return UITextDropEditabilityNo;
+  }
+  if ([self _shouldAcceptDrop:drop]) {
+    return UITextDropEditabilityYes;
+  } else {
+    return UITextDropEditabilityNo;
+  }
+}
+
+- (UITextDropProposal *)textDroppableView:(UIView<UITextDroppable> *)textDroppableView
+                          proposalForDrop:(id<UITextDropRequest>)drop
+{
+  if ([self _shouldAcceptDrop:drop]) {
+    return drop.suggestedProposal;
+  } else {
+    return [[UITextDropProposal alloc] initWithDropOperation:UIDropOperationCancel];
+  }
+}
+
+- (bool)_shouldAcceptDrop:(id<UITextDropRequest>)drop
+{
+  if (_backedTextInputView.acceptDragAndDropTypes) {
+    // If we have accepted types, we should only accept drops that match one of them
+    return [drop.dropSession hasItemsConformingToTypeIdentifiers:(_backedTextInputView.acceptDragAndDropTypes)];
+  } else {
+    // If we don't have any accepted types, we should accept any drop
+    return true;
+  }
+}
+
+@end

node_modules/react-native/Libraries/Text/TextInput/RCTBackedTextInputViewProtocol.h

@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <UIKit/UIKit.h>
+
+@protocol RCTBackedTextInputDelegate;
+@class RCTTextAttributes;
+
+NS_ASSUME_NONNULL_BEGIN
+
+@protocol RCTBackedTextInputViewProtocol <UITextInput>
+
+@property (nonatomic, copy, nullable) NSAttributedString *attributedText;
+@property (nonatomic, copy, nullable) NSString *placeholder;
+@property (nonatomic, strong, nullable) UIColor *placeholderColor;
+@property (nonatomic, assign, readonly) BOOL textWasPasted;
+@property (nonatomic, assign, readonly) BOOL dictationRecognizing;
+@property (nonatomic, assign) UIEdgeInsets textContainerInset;
+@property (nonatomic, strong, nullable) UIView *inputAccessoryView;
+@property (nonatomic, strong, nullable) UIView *inputView;
+@property (nonatomic, weak, nullable) id<RCTBackedTextInputDelegate> textInputDelegate;
+@property (nonatomic, readonly) CGSize contentSize;
+@property (nonatomic, strong, nullable) NSDictionary<NSAttributedStringKey, id> *defaultTextAttributes;
+@property (nonatomic, assign) BOOL contextMenuHidden;
+@property (nonatomic, assign, getter=isEditable) BOOL editable;
+@property (nonatomic, assign) BOOL caretHidden;
+@property (nonatomic, assign) BOOL enablesReturnKeyAutomatically;
+@property (nonatomic, assign) UITextFieldViewMode clearButtonMode;
+@property (nonatomic, assign) UIDataDetectorTypes dataDetectorTypes;
+@property (nonatomic, getter=isScrollEnabled) BOOL scrollEnabled;
+@property (nonatomic, strong, nullable) NSString *inputAccessoryViewID;
+@property (nonatomic, strong, nullable) NSString *inputAccessoryViewButtonLabel;
+@property (nonatomic, assign, readonly) CGFloat zoomScale;
+@property (nonatomic, assign, readonly) CGPoint contentOffset;
+@property (nonatomic, assign, readonly) UIEdgeInsets contentInset;
+@property (nullable, nonatomic, copy) NSDictionary<NSAttributedStringKey, id> *typingAttributes;
+@property (nonatomic, strong, nullable) NSArray<NSString *> *acceptDragAndDropTypes;
+
+// This protocol disallows direct access to `selectedTextRange` property because
+// unwise usage of it can break the `delegate` behavior. So, we always have to
+// explicitly specify should `delegate` be notified about the change or not.
+// If the change was initiated programmatically, we must NOT notify the delegate.
+// If the change was a result of user actions (like typing or touches), we MUST notify the delegate.
+- (void)setSelectedTextRange:(nullable UITextRange *)selectedTextRange NS_UNAVAILABLE;
+- (void)setSelectedTextRange:(nullable UITextRange *)selectedTextRange notifyDelegate:(BOOL)notifyDelegate;
+- (void)scrollRangeToVisible:(NSRange)selectedTextRange;
+
+// This protocol disallows direct access to `text` property because
+// unwise usage of it can break the `attributeText` behavior.
+// Use `attributedText.string` instead.
+@property (nonatomic, copy, nullable) NSString *text NS_UNAVAILABLE;
+
+@property (nonatomic, assign) BOOL disableKeyboardShortcuts;
+
+@end
+
+NS_ASSUME_NONNULL_END

node_modules/react-native/Libraries/Text/TextInput/RCTBaseTextInputShadowView.h

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTBaseTextShadowView.h"
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+NS_ASSUME_NONNULL_BEGIN
+
+__attribute__((deprecated("This API will be removed along with the legacy architecture.")))
+@interface RCTBaseTextInputShadowView : RCTBaseTextShadowView
+
+- (instancetype)initWithBridge:(RCTBridge *)bridge;
+
+@property (nonatomic, copy, nullable) NSString *text;
+@property (nonatomic, copy, nullable) NSString *placeholder;
+@property (nonatomic, assign) NSInteger maximumNumberOfLines;
+@property (nonatomic, copy, nullable) RCTDirectEventBlock onContentSizeChange;
+
+- (void)uiManagerWillPerformMounting;
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif // RCT_REMOVE_LEGACY_ARCH

node_modules/react-native/Libraries/Text/TextInput/RCTBaseTextInputShadowView.mm

@@ -0,0 +1,367 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTBaseTextInputShadowView.h>
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+#import <React/RCTBridge.h>
+#import <React/RCTShadowView+Layout.h>
+#import <React/RCTUIManager.h>
+#import <yoga/Yoga.h>
+
+#import <React/RCTBaseTextInputView.h>
+#import "NSTextStorage+FontScaling.h"
+
+@implementation RCTBaseTextInputShadowView {
+  __weak RCTBridge *_bridge;
+  NSAttributedString *_Nullable _previousAttributedText;
+  BOOL _needsUpdateView;
+  NSAttributedString *_Nullable _localAttributedText;
+  CGSize _previousContentSize;
+
+  NSString *_text;
+  NSTextStorage *_textStorage;
+  NSTextContainer *_textContainer;
+  NSLayoutManager *_layoutManager;
+}
+
+- (instancetype)initWithBridge:(RCTBridge *)bridge
+{
+  if (self = [super init]) {
+    _bridge = bridge;
+    _needsUpdateView = YES;
+
+    YGNodeSetMeasureFunc(self.yogaNode, RCTBaseTextInputShadowViewMeasure);
+    YGNodeSetBaselineFunc(self.yogaNode, RCTTextInputShadowViewBaseline);
+  }
+
+  return self;
+}
+
+- (BOOL)isYogaLeafNode
+{
+  return YES;
+}
+
+- (void)didSetProps:(NSArray<NSString *> *)changedProps
+{
+  [super didSetProps:changedProps];
+
+  // `backgroundColor` and `opacity` are being applied directly to a UIView,
+  // therefore we need to exclude them from base `textAttributes`.
+  self.textAttributes.backgroundColor = nil;
+  self.textAttributes.opacity = NAN;
+}
+
+- (void)layoutSubviewsWithContext:(RCTLayoutContext)layoutContext
+{
+  // Do nothing.
+}
+
+- (void)setLocalData:(NSObject *)localData
+{
+  NSAttributedString *attributedText = (NSAttributedString *)localData;
+
+  if ([attributedText isEqualToAttributedString:_localAttributedText]) {
+    return;
+  }
+
+  _localAttributedText = attributedText;
+  [self dirtyLayout];
+}
+
+- (void)dirtyLayout
+{
+  [super dirtyLayout];
+  _needsUpdateView = YES;
+  YGNodeMarkDirty(self.yogaNode);
+  [self invalidateContentSize];
+}
+
+- (void)invalidateContentSize
+{
+  if (!_onContentSizeChange) {
+    return;
+  }
+
+  CGSize maximumSize = self.layoutMetrics.contentFrame.size;
+
+  if (_maximumNumberOfLines == 1) {
+    maximumSize.width = CGFLOAT_MAX;
+  } else {
+    maximumSize.height = CGFLOAT_MAX;
+  }
+
+  CGSize contentSize = [self sizeThatFitsMinimumSize:(CGSize)CGSizeZero maximumSize:maximumSize];
+
+  if (CGSizeEqualToSize(_previousContentSize, contentSize)) {
+    return;
+  }
+  _previousContentSize = contentSize;
+
+  _onContentSizeChange(@{
+    @"contentSize" : @{
+      @"height" : @(contentSize.height),
+      @"width" : @(contentSize.width),
+    },
+    @"target" : self.reactTag,
+  });
+}
+
+- (NSString *)text
+{
+  return _text;
+}
+
+- (void)setText:(NSString *)text
+{
+  _text = text;
+  // Clear `_previousAttributedText` to notify the view about the change
+  // when `text` native prop is set.
+  _previousAttributedText = nil;
+  [self dirtyLayout];
+}
+
+#pragma mark - RCTUIManagerObserver
+
+- (void)uiManagerWillPerformMounting
+{
+  if (YGNodeIsDirty(self.yogaNode)) {
+    return;
+  }
+
+  if (!_needsUpdateView) {
+    return;
+  }
+  _needsUpdateView = NO;
+
+  UIEdgeInsets borderInsets = self.borderAsInsets;
+  UIEdgeInsets paddingInsets = self.paddingAsInsets;
+
+  RCTTextAttributes *textAttributes = [self.textAttributes copy];
+
+  NSMutableAttributedString *attributedText = [[self attributedTextWithBaseTextAttributes:nil] mutableCopy];
+
+  // Removing all references to Shadow Views and tags to avoid unnecessary retaining
+  // and problems with comparing the strings.
+  [attributedText removeAttribute:RCTBaseTextShadowViewEmbeddedShadowViewAttributeName
+                            range:NSMakeRange(0, attributedText.length)];
+
+  [attributedText removeAttribute:RCTTextAttributesTagAttributeName range:NSMakeRange(0, attributedText.length)];
+
+  if (self.text.length) {
+    NSAttributedString *propertyAttributedText =
+        [[NSAttributedString alloc] initWithString:self.text attributes:self.textAttributes.effectiveTextAttributes];
+    [attributedText insertAttributedString:propertyAttributedText atIndex:0];
+  }
+
+  [self postprocessAttributedText:attributedText];
+
+  NSAttributedString *newAttributedText;
+  if (![_previousAttributedText isEqualToAttributedString:attributedText]) {
+    // We have to follow `set prop` pattern:
+    // If the value has not changed, we must not notify the view about the change,
+    // otherwise we may break local (temporary) state of the text input.
+    newAttributedText = [attributedText copy];
+    _previousAttributedText = newAttributedText;
+  }
+
+  NSNumber *tag = self.reactTag;
+
+  [_bridge.uiManager addUIBlock:^(RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+    RCTBaseTextInputView *baseTextInputView = (RCTBaseTextInputView *)viewRegistry[tag];
+    if (!baseTextInputView) {
+      return;
+    }
+
+    baseTextInputView.textAttributes = textAttributes;
+    baseTextInputView.reactBorderInsets = borderInsets;
+    baseTextInputView.reactPaddingInsets = paddingInsets;
+
+    if (newAttributedText) {
+      // Don't set `attributedText` if length equal to zero, otherwise it would shrink when attributes contain like
+      // `lineHeight`.
+      if (newAttributedText.length != 0) {
+        baseTextInputView.attributedText = newAttributedText;
+      } else {
+        baseTextInputView.attributedText = nil;
+      }
+    }
+  }];
+}
+
+- (void)postprocessAttributedText:(NSMutableAttributedString *)attributedText
+{
+  __block CGFloat maximumLineHeight = 0;
+
+  [attributedText enumerateAttribute:NSParagraphStyleAttributeName
+                             inRange:NSMakeRange(0, attributedText.length)
+                             options:NSAttributedStringEnumerationLongestEffectiveRangeNotRequired
+                          usingBlock:^(NSParagraphStyle *paragraphStyle, __unused NSRange range, __unused BOOL *stop) {
+                            if (!paragraphStyle) {
+                              return;
+                            }
+
+                            maximumLineHeight = MAX(paragraphStyle.maximumLineHeight, maximumLineHeight);
+                          }];
+
+  if (maximumLineHeight == 0) {
+    // `lineHeight` was not specified, nothing to do.
+    return;
+  }
+
+  __block CGFloat maximumFontLineHeight = 0;
+
+  [attributedText enumerateAttribute:NSFontAttributeName
+                             inRange:NSMakeRange(0, attributedText.length)
+                             options:NSAttributedStringEnumerationLongestEffectiveRangeNotRequired
+                          usingBlock:^(UIFont *font, NSRange range, __unused BOOL *stop) {
+                            if (!font) {
+                              return;
+                            }
+
+                            if (maximumFontLineHeight <= font.lineHeight) {
+                              maximumFontLineHeight = font.lineHeight;
+                            }
+                          }];
+
+  if (maximumLineHeight < maximumFontLineHeight) {
+    return;
+  }
+
+  CGFloat baseLineOffset = maximumLineHeight / 2.0 - maximumFontLineHeight / 2.0;
+
+  [attributedText addAttribute:NSBaselineOffsetAttributeName
+                         value:@(baseLineOffset)
+                         range:NSMakeRange(0, attributedText.length)];
+}
+
+#pragma mark -
+
+- (NSAttributedString *)measurableAttributedText
+{
+  // Only for the very first render when we don't have `_localAttributedText`,
+  // we use value directly from the property and/or nested content.
+  NSAttributedString *attributedText = _localAttributedText ?: [self attributedTextWithBaseTextAttributes:nil];
+
+  if (attributedText.length == 0) {
+    // It's impossible to measure empty attributed string because all attributes are
+    // associated with some characters, so no characters means no data.
+
+    // Placeholder also can represent the intrinsic size when it is visible.
+    NSString *text = self.placeholder;
+    if (!text.length) {
+      // Note: `zero-width space` is insufficient in some cases.
+      text = @"I";
+    }
+    attributedText = [[NSAttributedString alloc] initWithString:text
+                                                     attributes:self.textAttributes.effectiveTextAttributes];
+  }
+
+  return attributedText;
+}
+
+- (CGSize)sizeThatFitsMinimumSize:(CGSize)minimumSize maximumSize:(CGSize)maximumSize
+{
+  NSAttributedString *attributedText = [self measurableAttributedText];
+
+  if (!_textStorage) {
+    _textContainer = [NSTextContainer new];
+    _textContainer.lineFragmentPadding = 0.0; // Note, the default value is 5.
+    _layoutManager = [NSLayoutManager new];
+    [_layoutManager addTextContainer:_textContainer];
+    _textStorage = [NSTextStorage new];
+    [_textStorage addLayoutManager:_layoutManager];
+  }
+
+  _textContainer.size = maximumSize;
+  _textContainer.maximumNumberOfLines = _maximumNumberOfLines;
+  [_textStorage replaceCharactersInRange:(NSRange){0, _textStorage.length} withAttributedString:attributedText];
+  [_layoutManager ensureLayoutForTextContainer:_textContainer];
+  CGSize size = [_layoutManager usedRectForTextContainer:_textContainer].size;
+
+  return (CGSize){MAX(minimumSize.width, MIN(RCTCeilPixelValue(size.width), maximumSize.width)),
+                  MAX(minimumSize.height, MIN(RCTCeilPixelValue(size.height), maximumSize.height))};
+}
+
+- (CGFloat)lastBaselineForSize:(CGSize)size
+{
+  NSAttributedString *attributedText = [self measurableAttributedText];
+
+  __block CGFloat maximumDescender = 0.0;
+
+  [attributedText enumerateAttribute:NSFontAttributeName
+                             inRange:NSMakeRange(0, attributedText.length)
+                             options:NSAttributedStringEnumerationLongestEffectiveRangeNotRequired
+                          usingBlock:^(UIFont *font, NSRange range, __unused BOOL *stop) {
+                            if (maximumDescender > font.descender) {
+                              maximumDescender = font.descender;
+                            }
+                          }];
+
+  return size.height + maximumDescender;
+}
+
+static YGSize RCTBaseTextInputShadowViewMeasure(
+    YGNodeConstRef node,
+    float width,
+    YGMeasureMode widthMode,
+    float height,
+    YGMeasureMode heightMode)
+{
+  RCTShadowView *shadowView = (__bridge RCTShadowView *)YGNodeGetContext(node);
+
+  CGSize minimumSize = CGSizeMake(0, 0);
+  CGSize maximumSize = CGSizeMake(CGFLOAT_MAX, CGFLOAT_MAX);
+
+  CGSize size = {RCTCoreGraphicsFloatFromYogaFloat(width), RCTCoreGraphicsFloatFromYogaFloat(height)};
+
+  switch (widthMode) {
+    case YGMeasureModeUndefined:
+      break;
+    case YGMeasureModeExactly:
+      minimumSize.width = size.width;
+      maximumSize.width = size.width;
+      break;
+    case YGMeasureModeAtMost:
+      maximumSize.width = size.width;
+      break;
+  }
+
+  switch (heightMode) {
+    case YGMeasureModeUndefined:
+      break;
+    case YGMeasureModeExactly:
+      minimumSize.height = size.height;
+      maximumSize.height = size.height;
+      break;
+    case YGMeasureModeAtMost:
+      maximumSize.height = size.height;
+      break;
+  }
+
+  CGSize measuredSize = [shadowView sizeThatFitsMinimumSize:minimumSize maximumSize:maximumSize];
+
+  return (YGSize){RCTYogaFloatFromCoreGraphicsFloat(measuredSize.width),
+                  RCTYogaFloatFromCoreGraphicsFloat(measuredSize.height)};
+}
+
+static float RCTTextInputShadowViewBaseline(YGNodeConstRef node, const float width, const float height)
+{
+  RCTBaseTextInputShadowView *shadowTextView = (__bridge RCTBaseTextInputShadowView *)YGNodeGetContext(node);
+
+  CGSize size = (CGSize){RCTCoreGraphicsFloatFromYogaFloat(width), RCTCoreGraphicsFloatFromYogaFloat(height)};
+
+  CGFloat lastBaseline = [shadowTextView lastBaselineForSize:size];
+
+  return RCTYogaFloatFromCoreGraphicsFloat(lastBaseline);
+}
+
+@end
+
+#endif // RCT_REMOVE_LEGACY_ARCH

node_modules/react-native/Libraries/Text/TextInput/RCTBaseTextInputView.h

@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <UIKit/UIKit.h>
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+#import <React/RCTView.h>
+
+#import "RCTBackedTextInputDelegate.h"
+#import "RCTBackedTextInputViewProtocol.h"
+
+@class RCTBridge;
+@class RCTTextAttributes;
+@class RCTTextSelection;
+
+NS_ASSUME_NONNULL_BEGIN
+
+__attribute__((deprecated("This API will be removed along with the legacy architecture.")))
+@interface RCTBaseTextInputView : RCTView<RCTBackedTextInputDelegate>
+
+- (instancetype)initWithBridge:(RCTBridge *)bridge NS_DESIGNATED_INITIALIZER;
+
+- (instancetype)init NS_UNAVAILABLE;
+- (instancetype)initWithCoder:(NSCoder *)decoder NS_UNAVAILABLE;
+- (instancetype)initWithFrame:(CGRect)frame NS_UNAVAILABLE;
+
+@property (nonatomic, readonly) UIView<RCTBackedTextInputViewProtocol> *backedTextInputView;
+
+@property (nonatomic, strong, nullable) RCTTextAttributes *textAttributes;
+@property (nonatomic, assign) UIEdgeInsets reactPaddingInsets;
+@property (nonatomic, assign) UIEdgeInsets reactBorderInsets;
+
+@property (nonatomic, copy, nullable) RCTDirectEventBlock onContentSizeChange;
+@property (nonatomic, copy, nullable) RCTDirectEventBlock onSelectionChange;
+@property (nonatomic, copy, nullable) RCTDirectEventBlock onChange;
+@property (nonatomic, copy, nullable) RCTDirectEventBlock onChangeSync;
+@property (nonatomic, copy, nullable) RCTDirectEventBlock onScroll;
+
+@property (nonatomic, assign) NSInteger mostRecentEventCount;
+@property (nonatomic, assign, readonly) NSInteger nativeEventCount;
+@property (nonatomic, assign) BOOL autoFocus;
+@property (nonatomic, copy) NSString *submitBehavior;
+@property (nonatomic, assign) BOOL selectTextOnFocus;
+@property (nonatomic, assign) BOOL clearTextOnFocus;
+@property (nonatomic, assign) BOOL secureTextEntry;
+@property (nonatomic, copy) RCTTextSelection *selection;
+@property (nonatomic, strong, nullable) NSNumber *maxLength;
+@property (nonatomic, copy, nullable) NSAttributedString *attributedText;
+@property (nonatomic, copy) NSString *inputAccessoryViewID;
+@property (nonatomic, strong) NSString *inputAccessoryViewButtonLabel;
+@property (nonatomic, assign) UIKeyboardType keyboardType;
+@property (nonatomic, assign) BOOL showSoftInputOnFocus;
+
+/**
+ Sets selection intext input if both start and end are within range of the text input.
+ **/
+- (void)setSelectionStart:(NSInteger)start selectionEnd:(NSInteger)end;
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif // RCT_REMOVE_LEGACY_ARCH

node_modules/react-native/Libraries/Text/TextInput/RCTBaseTextInputView.mm

@@ -0,0 +1,846 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTBaseTextInputView.h>
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+#import <React/RCTBridge.h>
+#import <React/RCTConvert.h>
+#import <React/RCTEventDispatcherProtocol.h>
+#import <React/RCTScrollView.h>
+#import <React/RCTUIManager.h>
+#import <React/RCTUtils.h>
+#import <React/UIView+React.h>
+
+#import <React/RCTInputAccessoryView.h>
+#import <React/RCTInputAccessoryViewContent.h>
+#import <React/RCTTextAttributes.h>
+#import <React/RCTTextSelection.h>
+
+/** Native iOS text field bottom keyboard offset amount */
+static const CGFloat kSingleLineKeyboardBottomOffset = 15.0;
+static NSSet<NSNumber *> *returnKeyTypesSet;
+
+@implementation RCTBaseTextInputView {
+  __weak RCTBridge *_bridge;
+  __weak id<RCTEventDispatcherProtocol> _eventDispatcher;
+  BOOL _hasInputAccessoryView;
+  NSString *_Nullable _predictedText;
+  BOOL _didMoveToWindow;
+  NSArray<UIBarButtonItemGroup *> *_initialValueLeadingBarButtonGroups;
+  NSArray<UIBarButtonItemGroup *> *_initialValueTrailingBarButtonGroups;
+}
+
+- (void)reactUpdateResponderOffsetForScrollView:(RCTScrollView *)scrollView
+{
+  if (![self isDescendantOfView:scrollView]) {
+    // View is outside scroll view
+    scrollView.firstResponderViewOutsideScrollView = self.backedTextInputView;
+    return;
+  }
+
+  UITextRange *selectedTextRange = self.backedTextInputView.selectedTextRange;
+  UITextSelectionRect *selection = [self.backedTextInputView selectionRectsForRange:selectedTextRange].firstObject;
+  CGRect focusRect;
+  if (selection == nil) {
+    // No active selection or caret - fallback to entire input frame
+    focusRect = self.bounds;
+  } else {
+    // Focus on text selection frame
+    focusRect = selection.rect;
+    BOOL isMultiline = [self.backedTextInputView isKindOfClass:[UITextView class]];
+    if (!isMultiline) {
+      focusRect.size.height += kSingleLineKeyboardBottomOffset;
+    }
+  }
+  scrollView.firstResponderFocus = [self convertRect:focusRect toView:nil];
+}
+
+- (instancetype)initWithBridge:(RCTBridge *)bridge
+{
+  RCTAssertParam(bridge);
+
+  if (self = [super initWithFrame:CGRectZero]) {
+    _bridge = bridge;
+    _eventDispatcher = bridge.eventDispatcher;
+    [self initializeReturnKeyType];
+    _initialValueLeadingBarButtonGroups = nil;
+    _initialValueTrailingBarButtonGroups = nil;
+  }
+
+  return self;
+}
+
+RCT_NOT_IMPLEMENTED(-(instancetype)init)
+RCT_NOT_IMPLEMENTED(-(instancetype)initWithCoder : (NSCoder *)decoder)
+RCT_NOT_IMPLEMENTED(-(instancetype)initWithFrame : (CGRect)frame)
+
+- (UIView<RCTBackedTextInputViewProtocol> *)backedTextInputView
+{
+  RCTAssert(NO, @"-[RCTBaseTextInputView backedTextInputView] must be implemented in subclass.");
+  return nil;
+}
+
+#pragma mark - RCTComponent
+
+- (void)didUpdateReactSubviews
+{
+  // Do nothing.
+}
+
+#pragma mark - Properties
+
+- (void)setTextAttributes:(RCTTextAttributes *)textAttributes
+{
+  _textAttributes = textAttributes;
+  [self enforceTextAttributesIfNeeded];
+}
+
+- (void)enforceTextAttributesIfNeeded
+{
+  id<RCTBackedTextInputViewProtocol> backedTextInputView = self.backedTextInputView;
+
+  NSDictionary<NSAttributedStringKey, id> *textAttributes = [[_textAttributes effectiveTextAttributes] mutableCopy];
+  if ([textAttributes valueForKey:NSForegroundColorAttributeName] == nil) {
+    [textAttributes setValue:[UIColor blackColor] forKey:NSForegroundColorAttributeName];
+  }
+
+  backedTextInputView.defaultTextAttributes = textAttributes;
+}
+
+- (void)setReactPaddingInsets:(UIEdgeInsets)reactPaddingInsets
+{
+  _reactPaddingInsets = reactPaddingInsets;
+  // We apply `paddingInsets` as `backedTextInputView`'s `textContainerInset`.
+  self.backedTextInputView.textContainerInset = reactPaddingInsets;
+  [self setNeedsLayout];
+}
+
+- (void)setReactBorderInsets:(UIEdgeInsets)reactBorderInsets
+{
+  _reactBorderInsets = reactBorderInsets;
+  // We apply `borderInsets` as `backedTextInputView` layout offset.
+  self.backedTextInputView.frame = UIEdgeInsetsInsetRect(self.bounds, reactBorderInsets);
+  [self setNeedsLayout];
+}
+
+- (NSAttributedString *)attributedText
+{
+  return self.backedTextInputView.attributedText;
+}
+
+- (BOOL)textOf:(NSAttributedString *)newText equals:(NSAttributedString *)oldText
+{
+  // When the dictation is running we can't update the attributed text on the backed up text view
+  // because setting the attributed string will kill the dictation. This means that we can't impose
+  // the settings on a dictation.
+  // Similarly, when the user is in the middle of inputting some text in Japanese/Chinese, there will be styling on the
+  // text that we should disregard. See
+  // https://developer.apple.com/documentation/uikit/uitextinput/1614489-markedtextrange?language=objc for more info.
+  // Also, updating the attributed text while inputting Korean language will break input mechanism.
+  // If the user added an emoji, the system adds a font attribute for the emoji and stores the original font in
+  // NSOriginalFont. Lastly, when entering a password, etc., there will be additional styling on the field as the native
+  // text view handles showing the last character for a split second.
+  __block BOOL fontHasBeenUpdatedBySystem = false;
+  [oldText enumerateAttribute:@"NSOriginalFont"
+                      inRange:NSMakeRange(0, oldText.length)
+                      options:0
+                   usingBlock:^(id value, NSRange range, BOOL *stop) {
+                     if (value) {
+                       fontHasBeenUpdatedBySystem = true;
+                     }
+                   }];
+
+  BOOL shouldFallbackDictation = [self.backedTextInputView.textInputMode.primaryLanguage isEqualToString:@"dictation"];
+  if (@available(iOS 16.0, *)) {
+    shouldFallbackDictation = self.backedTextInputView.dictationRecognizing;
+  }
+
+  BOOL shouldFallbackToBareTextComparison = shouldFallbackDictation ||
+      [self.backedTextInputView.textInputMode.primaryLanguage isEqualToString:@"ko-KR"] ||
+      self.backedTextInputView.markedTextRange || self.backedTextInputView.isSecureTextEntry ||
+      fontHasBeenUpdatedBySystem;
+
+  if (shouldFallbackToBareTextComparison) {
+    return ([newText.string isEqualToString:oldText.string]);
+  } else {
+    return ([newText isEqualToAttributedString:oldText]);
+  }
+}
+
+- (void)setAttributedText:(NSAttributedString *)attributedText
+{
+  NSInteger eventLag = _nativeEventCount - _mostRecentEventCount;
+  BOOL textNeedsUpdate = NO;
+  // Remove tag attribute to ensure correct attributed string comparison.
+  NSMutableAttributedString *const backedTextInputViewTextCopy = [self.backedTextInputView.attributedText mutableCopy];
+  NSMutableAttributedString *const attributedTextCopy = [attributedText mutableCopy];
+
+  [backedTextInputViewTextCopy removeAttribute:RCTTextAttributesTagAttributeName
+                                         range:NSMakeRange(0, backedTextInputViewTextCopy.length)];
+
+  [attributedTextCopy removeAttribute:RCTTextAttributesTagAttributeName
+                                range:NSMakeRange(0, attributedTextCopy.length)];
+
+  textNeedsUpdate = ([self textOf:attributedTextCopy equals:backedTextInputViewTextCopy] == NO);
+
+  if (eventLag == 0 && textNeedsUpdate) {
+    UITextRange *selection = self.backedTextInputView.selectedTextRange;
+    NSInteger oldTextLength = self.backedTextInputView.attributedText.string.length;
+
+    self.backedTextInputView.attributedText = attributedText;
+
+    if (selection.empty) {
+      // Maintaining a cursor position relative to the end of the old text.
+      NSInteger offsetStart = [self.backedTextInputView offsetFromPosition:self.backedTextInputView.beginningOfDocument
+                                                                toPosition:selection.start];
+      NSInteger offsetFromEnd = oldTextLength - offsetStart;
+      NSInteger newOffset = attributedText.string.length - offsetFromEnd;
+      UITextPosition *position =
+          [self.backedTextInputView positionFromPosition:self.backedTextInputView.beginningOfDocument offset:newOffset];
+      [self.backedTextInputView setSelectedTextRange:[self.backedTextInputView textRangeFromPosition:position
+                                                                                          toPosition:position]
+                                      notifyDelegate:YES];
+    }
+
+    [self updateLocalData];
+  } else if (eventLag > RCTTextUpdateLagWarningThreshold) {
+    RCTLog(
+        @"Native TextInput(%@) is %lld events ahead of JS - try to make your JS faster.",
+        self.backedTextInputView.attributedText.string,
+        (long long)eventLag);
+  }
+}
+
+- (RCTTextSelection *)selection
+{
+  id<RCTBackedTextInputViewProtocol> backedTextInputView = self.backedTextInputView;
+  UITextRange *selectedTextRange = backedTextInputView.selectedTextRange;
+  return [[RCTTextSelection new]
+      initWithStart:[backedTextInputView offsetFromPosition:backedTextInputView.beginningOfDocument
+                                                 toPosition:selectedTextRange.start]
+                end:[backedTextInputView offsetFromPosition:backedTextInputView.beginningOfDocument
+                                                 toPosition:selectedTextRange.end]];
+}
+
+- (void)setSelection:(RCTTextSelection *)selection
+{
+  if (!selection) {
+    return;
+  }
+
+  id<RCTBackedTextInputViewProtocol> backedTextInputView = self.backedTextInputView;
+
+  UITextRange *previousSelectedTextRange = backedTextInputView.selectedTextRange;
+  UITextPosition *start = [backedTextInputView positionFromPosition:backedTextInputView.beginningOfDocument
+                                                             offset:selection.start];
+  UITextPosition *end = [backedTextInputView positionFromPosition:backedTextInputView.beginningOfDocument
+                                                           offset:selection.end];
+  UITextRange *selectedTextRange = [backedTextInputView textRangeFromPosition:start toPosition:end];
+
+  NSInteger eventLag = _nativeEventCount - _mostRecentEventCount;
+  if (eventLag == 0 && ![previousSelectedTextRange isEqual:selectedTextRange]) {
+    [backedTextInputView setSelectedTextRange:selectedTextRange notifyDelegate:NO];
+  } else if (eventLag > RCTTextUpdateLagWarningThreshold) {
+    RCTLog(
+        @"Native TextInput(%@) is %lld events ahead of JS - try to make your JS faster.",
+        backedTextInputView.attributedText.string,
+        (long long)eventLag);
+  }
+}
+
+- (void)setSelectionStart:(NSInteger)start selectionEnd:(NSInteger)end
+{
+  UITextPosition *startPosition =
+      [self.backedTextInputView positionFromPosition:self.backedTextInputView.beginningOfDocument offset:start];
+  UITextPosition *endPosition =
+      [self.backedTextInputView positionFromPosition:self.backedTextInputView.beginningOfDocument offset:end];
+  if (startPosition && endPosition) {
+    UITextRange *range = [self.backedTextInputView textRangeFromPosition:startPosition toPosition:endPosition];
+    [self.backedTextInputView setSelectedTextRange:range notifyDelegate:NO];
+  }
+}
+
+- (void)setTextContentType:(NSString *)type
+{
+  static dispatch_once_t onceToken;
+  static NSDictionary<NSString *, NSString *> *contentTypeMap;
+
+  dispatch_once(&onceToken, ^{
+    NSMutableDictionary<NSString *, NSString *> *mutableContentTypeMap = [NSMutableDictionary new];
+    [mutableContentTypeMap addEntriesFromDictionary:@{
+      @"none" : @"",
+      @"URL" : UITextContentTypeURL,
+      @"addressCity" : UITextContentTypeAddressCity,
+      @"addressCityAndState" : UITextContentTypeAddressCityAndState,
+      @"addressState" : UITextContentTypeAddressState,
+      @"countryName" : UITextContentTypeCountryName,
+      @"creditCardNumber" : UITextContentTypeCreditCardNumber,
+      @"emailAddress" : UITextContentTypeEmailAddress,
+      @"familyName" : UITextContentTypeFamilyName,
+      @"fullStreetAddress" : UITextContentTypeFullStreetAddress,
+      @"givenName" : UITextContentTypeGivenName,
+      @"jobTitle" : UITextContentTypeJobTitle,
+      @"location" : UITextContentTypeLocation,
+      @"middleName" : UITextContentTypeMiddleName,
+      @"name" : UITextContentTypeName,
+      @"namePrefix" : UITextContentTypeNamePrefix,
+      @"nameSuffix" : UITextContentTypeNameSuffix,
+      @"nickname" : UITextContentTypeNickname,
+      @"organizationName" : UITextContentTypeOrganizationName,
+      @"postalCode" : UITextContentTypePostalCode,
+      @"streetAddressLine1" : UITextContentTypeStreetAddressLine1,
+      @"streetAddressLine2" : UITextContentTypeStreetAddressLine2,
+      @"sublocality" : UITextContentTypeSublocality,
+      @"telephoneNumber" : UITextContentTypeTelephoneNumber,
+      @"username" : UITextContentTypeUsername,
+      @"password" : UITextContentTypePassword,
+      @"newPassword" : UITextContentTypeNewPassword,
+      @"oneTimeCode" : UITextContentTypeOneTimeCode,
+    }];
+
+    if (@available(iOS 15.0, *)) {
+      [mutableContentTypeMap addEntriesFromDictionary:@{
+        @"dateTime" : UITextContentTypeDateTime,
+        @"flightNumber" : UITextContentTypeFlightNumber,
+        @"shipmentTrackingNumber" : UITextContentTypeShipmentTrackingNumber,
+      }];
+    }
+
+#if defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && __IPHONE_OS_VERSION_MAX_ALLOWED >= 170000 /* __IPHONE_17_0 */
+    if (@available(iOS 17.0, *)) {
+      [mutableContentTypeMap addEntriesFromDictionary:@{
+        @"creditCardExpiration" : UITextContentTypeCreditCardExpiration,
+        @"creditCardExpirationMonth" : UITextContentTypeCreditCardExpirationMonth,
+        @"creditCardExpirationYear" : UITextContentTypeCreditCardExpirationYear,
+        @"creditCardSecurityCode" : UITextContentTypeCreditCardSecurityCode,
+        @"creditCardType" : UITextContentTypeCreditCardType,
+        @"creditCardName" : UITextContentTypeCreditCardName,
+        @"creditCardGivenName" : UITextContentTypeCreditCardGivenName,
+        @"creditCardMiddleName" : UITextContentTypeCreditCardMiddleName,
+        @"creditCardFamilyName" : UITextContentTypeCreditCardFamilyName,
+        @"birthdate" : UITextContentTypeBirthdate,
+        @"birthdateDay" : UITextContentTypeBirthdateDay,
+        @"birthdateMonth" : UITextContentTypeBirthdateMonth,
+        @"birthdateYear" : UITextContentTypeBirthdateYear,
+      }];
+    }
+
+#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 170400 /* __IPHONE_17_4 */
+    if (@available(iOS 17.4, *)) {
+      [mutableContentTypeMap addEntriesFromDictionary:@{
+        @"cellularEID" : UITextContentTypeCellularEID,
+        @"cellularIMEI" : UITextContentTypeCellularIMEI,
+      }];
+    }
+#endif
+#endif
+
+    contentTypeMap = mutableContentTypeMap;
+  });
+
+  // Setting textContentType to an empty string will disable any
+  // default behaviour, like the autofill bar for password inputs
+  self.backedTextInputView.textContentType = contentTypeMap[type] ?: type;
+}
+
+- (void)setPasswordRules:(NSString *)descriptor
+{
+  self.backedTextInputView.passwordRules = [UITextInputPasswordRules passwordRulesWithDescriptor:descriptor];
+}
+
+- (UIKeyboardType)keyboardType
+{
+  return self.backedTextInputView.keyboardType;
+}
+
+- (void)setKeyboardType:(UIKeyboardType)keyboardType
+{
+  UIView<RCTBackedTextInputViewProtocol> *textInputView = self.backedTextInputView;
+  if (textInputView.keyboardType != keyboardType) {
+    textInputView.keyboardType = keyboardType;
+    // Without the call to reloadInputViews, the keyboard will not change until the textview field (the first responder)
+    // loses and regains focus.
+    if (textInputView.isFirstResponder) {
+      [textInputView reloadInputViews];
+    }
+  }
+}
+
+- (void)setShowSoftInputOnFocus:(BOOL)showSoftInputOnFocus
+{
+  (void)_showSoftInputOnFocus;
+  if (showSoftInputOnFocus) {
+    // Resets to default keyboard.
+    self.backedTextInputView.inputView = nil;
+
+    // Without the call to reloadInputViews, the keyboard will not change until the textInput field (the first
+    // responder) loses and regains focus.
+    if (self.backedTextInputView.isFirstResponder) {
+      [self.backedTextInputView reloadInputViews];
+    }
+  } else {
+    // Hides keyboard, but keeps blinking cursor.
+    self.backedTextInputView.inputView = [UIView new];
+  }
+}
+
+- (NSString *)inputAccessoryViewButtonLabel
+{
+  return self.backedTextInputView.inputAccessoryViewButtonLabel;
+}
+
+- (void)setInputAccessoryViewButtonLabel:(NSString *)inputAccessoryViewButtonLabel
+{
+  self.backedTextInputView.inputAccessoryViewButtonLabel = inputAccessoryViewButtonLabel;
+}
+
+- (void)setDisableKeyboardShortcuts:(BOOL)disableKeyboardShortcuts
+{
+#if TARGET_OS_IOS
+  // Initialize the initial values only once
+  if (_initialValueLeadingBarButtonGroups == nil) {
+    // Capture initial values of leading and trailing button groups
+    _initialValueLeadingBarButtonGroups = self.backedTextInputView.inputAssistantItem.leadingBarButtonGroups;
+    _initialValueTrailingBarButtonGroups = self.backedTextInputView.inputAssistantItem.trailingBarButtonGroups;
+  }
+
+  if (disableKeyboardShortcuts) {
+    self.backedTextInputView.inputAssistantItem.leadingBarButtonGroups = @[];
+    self.backedTextInputView.inputAssistantItem.trailingBarButtonGroups = @[];
+  } else {
+    // Restore the initial values
+    self.backedTextInputView.inputAssistantItem.leadingBarButtonGroups = _initialValueLeadingBarButtonGroups;
+    self.backedTextInputView.inputAssistantItem.trailingBarButtonGroups = _initialValueTrailingBarButtonGroups;
+  }
+#endif
+}
+
+#pragma mark - RCTBackedTextInputDelegate
+
+- (BOOL)textInputShouldBeginEditing
+{
+  return YES;
+}
+
+- (void)textInputDidBeginEditing
+{
+  [_eventDispatcher sendTextEventWithType:RCTTextEventTypeFocus
+                                 reactTag:self.reactTag
+                                     text:[self.backedTextInputView.attributedText.string copy]
+                                      key:nil
+                               eventCount:_nativeEventCount];
+}
+
+- (BOOL)textInputShouldEndEditing
+{
+  return YES;
+}
+
+- (void)textInputDidEndEditing
+{
+  [_eventDispatcher sendTextEventWithType:RCTTextEventTypeEnd
+                                 reactTag:self.reactTag
+                                     text:[self.backedTextInputView.attributedText.string copy]
+                                      key:nil
+                               eventCount:_nativeEventCount];
+
+  [_eventDispatcher sendTextEventWithType:RCTTextEventTypeBlur
+                                 reactTag:self.reactTag
+                                     text:[self.backedTextInputView.attributedText.string copy]
+                                      key:nil
+                               eventCount:_nativeEventCount];
+}
+
+- (BOOL)textInputShouldSubmitOnReturn
+{
+  const BOOL shouldSubmit =
+      [_submitBehavior isEqualToString:@"blurAndSubmit"] || [_submitBehavior isEqualToString:@"submit"];
+  if (shouldSubmit) {
+    // We send `submit` event here, in `textInputShouldSubmit`
+    // (not in `textInputDidReturn)`, because of semantic of the event:
+    // `onSubmitEditing` is called when "Submit" button
+    // (the blue key on onscreen keyboard) did pressed
+    // (no connection to any specific "submitting" process).
+    [_eventDispatcher sendTextEventWithType:RCTTextEventTypeSubmit
+                                   reactTag:self.reactTag
+                                       text:[self.backedTextInputView.attributedText.string copy]
+                                        key:nil
+                                 eventCount:_nativeEventCount];
+  }
+  return shouldSubmit;
+}
+
+- (BOOL)textInputShouldReturn
+{
+  return [_submitBehavior isEqualToString:@"blurAndSubmit"];
+}
+
+- (void)textInputDidReturn
+{
+  // Does nothing.
+}
+
+- (NSString *)textInputShouldChangeText:(NSString *)text inRange:(NSRange)range
+{
+  id<RCTBackedTextInputViewProtocol> backedTextInputView = self.backedTextInputView;
+
+  if (!backedTextInputView.textWasPasted) {
+    [_eventDispatcher sendTextEventWithType:RCTTextEventTypeKeyPress
+                                   reactTag:self.reactTag
+                                       text:nil
+                                        key:text
+                                 eventCount:_nativeEventCount];
+  }
+
+  if (_maxLength) {
+    NSInteger allowedLength = MAX(
+        _maxLength.integerValue - (NSInteger)backedTextInputView.attributedText.string.length + (NSInteger)range.length,
+        0);
+
+    if (text.length > allowedLength) {
+      // If we typed/pasted more than one character, limit the text inputted.
+      if (text.length > 1) {
+        if (allowedLength > 0) {
+          // make sure unicode characters that are longer than 16 bits (such as emojis) are not cut off
+          NSRange cutOffCharacterRange = [text rangeOfComposedCharacterSequenceAtIndex:allowedLength - 1];
+          if (cutOffCharacterRange.location + cutOffCharacterRange.length > allowedLength) {
+            // the character at the length limit takes more than 16bits, truncation should end at the character before
+            allowedLength = cutOffCharacterRange.location;
+          }
+        }
+        if (allowedLength <= 0) {
+          return nil;
+        }
+        // Truncate the input string so the result is exactly maxLength
+        NSString *limitedString = [text substringToIndex:allowedLength];
+        NSMutableAttributedString *newAttributedText = [backedTextInputView.attributedText mutableCopy];
+        // Apply text attributes if original input view doesn't have text.
+        if (backedTextInputView.attributedText.length == 0) {
+          newAttributedText = [[NSMutableAttributedString alloc]
+              initWithString:[self.textAttributes applyTextAttributesToText:limitedString]
+                  attributes:self.textAttributes.effectiveTextAttributes];
+        } else {
+          [newAttributedText replaceCharactersInRange:range withString:limitedString];
+        }
+        backedTextInputView.attributedText = newAttributedText;
+        _predictedText = newAttributedText.string;
+
+        // Collapse selection at end of insert to match normal paste behavior.
+        UITextPosition *insertEnd = [backedTextInputView positionFromPosition:backedTextInputView.beginningOfDocument
+                                                                       offset:(range.location + allowedLength)];
+        [backedTextInputView setSelectedTextRange:[backedTextInputView textRangeFromPosition:insertEnd
+                                                                                  toPosition:insertEnd]
+                                   notifyDelegate:YES];
+
+        [self textInputDidChange];
+      }
+
+      return nil; // Rejecting the change.
+    }
+  }
+
+  if (range.location + range.length > backedTextInputView.attributedText.string.length) {
+    _predictedText = backedTextInputView.attributedText.string;
+  } else if (text != nil) {
+    _predictedText = [backedTextInputView.attributedText.string stringByReplacingCharactersInRange:range
+                                                                                        withString:text];
+  }
+
+  return text; // Accepting the change.
+}
+
+- (void)textInputDidChange
+{
+  [self updateLocalData];
+
+  id<RCTBackedTextInputViewProtocol> backedTextInputView = self.backedTextInputView;
+
+  // Detect when `backedTextInputView` updates happened that didn't invoke `shouldChangeTextInRange`
+  // (e.g. typing simplified Chinese in pinyin will insert and remove spaces without
+  // calling shouldChangeTextInRange).  This will cause JS to get out of sync so we
+  // update the mismatched range.
+  NSRange currentRange;
+  NSRange predictionRange;
+  if (findMismatch(backedTextInputView.attributedText.string, _predictedText, &currentRange, &predictionRange)) {
+    NSString *replacement = [backedTextInputView.attributedText.string substringWithRange:currentRange];
+    [self textInputShouldChangeText:replacement inRange:predictionRange];
+    // JS will assume the selection changed based on the location of our shouldChangeTextInRange, so reset it.
+    [self textInputDidChangeSelection];
+  }
+
+  _nativeEventCount++;
+
+  if (_onChange) {
+    _onChange(@{
+      @"text" : [self.attributedText.string copy],
+      @"target" : self.reactTag,
+      @"eventCount" : @(_nativeEventCount),
+    });
+  }
+}
+
+- (void)textInputDidChangeSelection
+{
+  if (!_onSelectionChange) {
+    return;
+  }
+
+  RCTTextSelection *selection = self.selection;
+
+  _onSelectionChange(@{
+    @"selection" : @{
+      @"start" : @(selection.start),
+      @"end" : @(selection.end),
+    },
+  });
+}
+
+- (void)updateLocalData
+{
+  [self enforceTextAttributesIfNeeded];
+
+  [_bridge.uiManager setLocalData:[self.backedTextInputView.attributedText copy] forView:self];
+}
+
+#pragma mark - Layout (in UIKit terms, with all insets)
+
+- (CGSize)intrinsicContentSize
+{
+  CGSize size = self.backedTextInputView.intrinsicContentSize;
+  size.width += _reactBorderInsets.left + _reactBorderInsets.right;
+  size.height += _reactBorderInsets.top + _reactBorderInsets.bottom;
+  // Returning value DOES include border and padding insets.
+  return size;
+}
+
+- (CGSize)sizeThatFits:(CGSize)size
+{
+  CGFloat compoundHorizontalBorderInset = _reactBorderInsets.left + _reactBorderInsets.right;
+  CGFloat compoundVerticalBorderInset = _reactBorderInsets.top + _reactBorderInsets.bottom;
+
+  size.width -= compoundHorizontalBorderInset;
+  size.height -= compoundVerticalBorderInset;
+
+  // Note: `paddingInsets` was already included in `backedTextInputView` size
+  // because it was applied as `textContainerInset`.
+  CGSize fittingSize = [self.backedTextInputView sizeThatFits:size];
+
+  fittingSize.width += compoundHorizontalBorderInset;
+  fittingSize.height += compoundVerticalBorderInset;
+
+  // Returning value DOES include border and padding insets.
+  return fittingSize;
+}
+
+#pragma mark - Accessibility
+
+- (UIView *)reactAccessibilityElement
+{
+  return self.backedTextInputView;
+}
+
+#pragma mark - Focus Control
+
+- (void)reactFocus
+{
+  [self.backedTextInputView reactFocus];
+
+  if (_clearTextOnFocus) {
+    self.backedTextInputView.attributedText = [NSAttributedString new];
+  }
+
+  if (_selectTextOnFocus) {
+    [self.backedTextInputView selectAll:nil];
+  }
+}
+
+- (void)reactBlur
+{
+  [self.backedTextInputView reactBlur];
+}
+
+- (void)didMoveToWindow
+{
+  if (self.autoFocus && !_didMoveToWindow) {
+    [self.backedTextInputView reactFocus];
+    [self initializeReturnKeyType];
+  } else {
+    [self.backedTextInputView reactFocusIfNeeded];
+  }
+
+  _didMoveToWindow = YES;
+}
+
+#pragma mark - Custom Input Accessory View
+
+- (void)didSetProps:(NSArray<NSString *> *)changedProps
+{
+  if ([changedProps containsObject:@"inputAccessoryViewID"] && self.inputAccessoryViewID) {
+    [self setCustomInputAccessoryViewWithNativeID:self.inputAccessoryViewID];
+  } else if (!self.inputAccessoryViewID) {
+    [self setDefaultInputAccessoryView];
+  }
+}
+
+- (void)setCustomInputAccessoryViewWithNativeID:(NSString *)nativeID
+{
+  __weak RCTBaseTextInputView *weakSelf = self;
+  [_bridge.uiManager rootViewForReactTag:self.reactTag
+                          withCompletion:^(UIView *rootView) {
+                            RCTBaseTextInputView *strongSelf = weakSelf;
+                            if (rootView) {
+                              UIView *accessoryView = [strongSelf->_bridge.uiManager viewForNativeID:nativeID
+                                                                                         withRootTag:rootView.reactTag];
+                              if (accessoryView && [accessoryView isKindOfClass:[RCTInputAccessoryView class]]) {
+                                strongSelf.backedTextInputView.inputAccessoryView =
+                                    ((RCTInputAccessoryView *)accessoryView).inputAccessoryView;
+                                [strongSelf reloadInputViewsIfNecessary];
+                              }
+                            }
+                          }];
+}
+
+- (NSString *)returnKeyTypeToString:(UIReturnKeyType)returnKeyType
+{
+  switch (returnKeyType) {
+    case UIReturnKeyGo:
+      return @"Go";
+    case UIReturnKeyNext:
+      return @"Next";
+    case UIReturnKeySearch:
+      return @"Search";
+    case UIReturnKeySend:
+      return @"Send";
+    case UIReturnKeyYahoo:
+      return @"Yahoo";
+    case UIReturnKeyGoogle:
+      return @"Google";
+    case UIReturnKeyRoute:
+      return @"Route";
+    case UIReturnKeyJoin:
+      return @"Join";
+    case UIReturnKeyEmergencyCall:
+      return @"Emergency Call";
+    default:
+      return @"Done";
+  }
+}
+
+- (void)initializeReturnKeyType
+{
+  returnKeyTypesSet = [NSSet setWithObjects:@(UIReturnKeyDone),
+                                            @(UIReturnKeyGo),
+                                            @(UIReturnKeyNext),
+                                            @(UIReturnKeySearch),
+                                            @(UIReturnKeySend),
+                                            @(UIReturnKeyYahoo),
+                                            @(UIReturnKeyGoogle),
+                                            @(UIReturnKeyRoute),
+                                            @(UIReturnKeyJoin),
+                                            @(UIReturnKeyRoute),
+                                            @(UIReturnKeyEmergencyCall),
+                                            nil];
+}
+
+- (void)setDefaultInputAccessoryView
+{
+  UIView<RCTBackedTextInputViewProtocol> *textInputView = self.backedTextInputView;
+  UIKeyboardType keyboardType = textInputView.keyboardType;
+  NSString *inputAccessoryViewButtonLabel = textInputView.inputAccessoryViewButtonLabel;
+
+  // These keyboard types (all are number pads) don't have a Return Key button by default,
+  // so we create an `inputAccessoryView` with this button for them.
+
+  UIReturnKeyType returnKeyType = textInputView.returnKeyType;
+
+  BOOL containsKeyType = [returnKeyTypesSet containsObject:@(returnKeyType)];
+  BOOL containsInputAccessoryViewButtonLabel = inputAccessoryViewButtonLabel != nil;
+
+  BOOL shouldHaveInputAccessoryView =
+      (keyboardType == UIKeyboardTypeNumberPad || keyboardType == UIKeyboardTypePhonePad ||
+       keyboardType == UIKeyboardTypeDecimalPad || keyboardType == UIKeyboardTypeASCIICapableNumberPad) &&
+      (containsKeyType || containsInputAccessoryViewButtonLabel);
+
+  if (_hasInputAccessoryView == shouldHaveInputAccessoryView) {
+    return;
+  }
+
+  _hasInputAccessoryView = shouldHaveInputAccessoryView;
+
+  if (shouldHaveInputAccessoryView) {
+    NSString *buttonLabel = inputAccessoryViewButtonLabel != nil ? inputAccessoryViewButtonLabel
+                                                                 : [self returnKeyTypeToString:returnKeyType];
+
+    UIToolbar *toolbarView = [UIToolbar new];
+    [toolbarView sizeToFit];
+    UIBarButtonItem *flexibleSpace =
+        [[UIBarButtonItem alloc] initWithBarButtonSystemItem:UIBarButtonSystemItemFlexibleSpace target:nil action:nil];
+    UIBarButtonItem *doneButton = [[UIBarButtonItem alloc] initWithTitle:buttonLabel
+                                                                   style:UIBarButtonItemStylePlain
+                                                                  target:self
+                                                                  action:@selector(handleInputAccessoryDoneButton)];
+    toolbarView.items = @[ flexibleSpace, doneButton ];
+    textInputView.inputAccessoryView = toolbarView;
+  } else {
+    textInputView.inputAccessoryView = nil;
+  }
+  [self reloadInputViewsIfNecessary];
+}
+
+- (void)reloadInputViewsIfNecessary
+{
+  // We have to call `reloadInputViews` for focused text inputs to update an accessory view.
+  if (self.backedTextInputView.isFirstResponder) {
+    [self.backedTextInputView reloadInputViews];
+  }
+}
+
+- (void)handleInputAccessoryDoneButton
+{
+  // Ignore the value of whether we submitted; just make sure the submit event is called if necessary.
+  [self textInputShouldSubmitOnReturn];
+  if ([self textInputShouldReturn]) {
+    [self.backedTextInputView endEditing:YES];
+  }
+}
+
+#pragma mark - Helpers
+
+static BOOL findMismatch(NSString *first, NSString *second, NSRange *firstRange, NSRange *secondRange)
+{
+  NSInteger firstMismatch = -1;
+  for (NSUInteger ii = 0; ii < MAX(first.length, second.length); ii++) {
+    if (ii >= first.length || ii >= second.length || [first characterAtIndex:ii] != [second characterAtIndex:ii]) {
+      firstMismatch = ii;
+      break;
+    }
+  }
+
+  if (firstMismatch == -1) {
+    return NO;
+  }
+
+  NSUInteger ii = second.length;
+  NSUInteger lastMismatch = first.length;
+  while (ii > firstMismatch && lastMismatch > firstMismatch) {
+    if ([first characterAtIndex:(lastMismatch - 1)] != [second characterAtIndex:(ii - 1)]) {
+      break;
+    }
+    ii--;
+    lastMismatch--;
+  }
+
+  *firstRange = NSMakeRange(firstMismatch, lastMismatch - firstMismatch);
+  *secondRange = NSMakeRange(firstMismatch, ii - firstMismatch);
+  return YES;
+}
+
+@end
+
+#endif // RCT_REMOVE_LEGACY_ARCH

node_modules/react-native/Libraries/Text/TextInput/RCTBaseTextInputViewManager.h

@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTBaseTextViewManager.h"
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+__attribute__((deprecated("This API will be removed along with the legacy architecture.")))
+@interface RCTBaseTextInputViewManager : RCTBaseTextViewManager
+
+@end
+
+#endif // RCT_REMOVE_LEGACY_ARCH

node_modules/react-native/Libraries/Text/TextInput/RCTBaseTextInputViewManager.mm

@@ -0,0 +1,181 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTBaseTextInputViewManager.h>
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+#import <React/RCTBridge.h>
+#import <React/RCTConvert.h>
+#import <React/RCTFont.h>
+#import <React/RCTShadowView+Layout.h>
+#import <React/RCTShadowView.h>
+#import <React/RCTUIManager.h>
+#import <React/RCTUIManagerObserverCoordinator.h>
+#import <React/RCTUIManagerUtils.h>
+
+#import <React/RCTBaseTextInputShadowView.h>
+#import <React/RCTBaseTextInputView.h>
+#import <React/RCTConvert+Text.h>
+
+@interface RCTBaseTextInputViewManager () <RCTUIManagerObserver>
+
+@end
+
+@implementation RCTBaseTextInputViewManager {
+  NSHashTable<RCTBaseTextInputShadowView *> *_shadowViews;
+}
+
+RCT_EXPORT_MODULE()
+
+#pragma mark - Unified <TextInput> properties
+
+RCT_REMAP_VIEW_PROPERTY(autoCapitalize, backedTextInputView.autocapitalizationType, UITextAutocapitalizationType)
+RCT_REMAP_VIEW_PROPERTY(autoCorrect, backedTextInputView.autocorrectionType, UITextAutocorrectionType)
+RCT_REMAP_VIEW_PROPERTY(contextMenuHidden, backedTextInputView.contextMenuHidden, BOOL)
+RCT_REMAP_VIEW_PROPERTY(editable, backedTextInputView.editable, BOOL)
+RCT_REMAP_VIEW_PROPERTY(enablesReturnKeyAutomatically, backedTextInputView.enablesReturnKeyAutomatically, BOOL)
+RCT_REMAP_VIEW_PROPERTY(keyboardAppearance, backedTextInputView.keyboardAppearance, UIKeyboardAppearance)
+RCT_REMAP_VIEW_PROPERTY(placeholder, backedTextInputView.placeholder, NSString)
+RCT_REMAP_VIEW_PROPERTY(placeholderTextColor, backedTextInputView.placeholderColor, UIColor)
+RCT_REMAP_VIEW_PROPERTY(returnKeyType, backedTextInputView.returnKeyType, UIReturnKeyType)
+RCT_REMAP_VIEW_PROPERTY(selectionColor, backedTextInputView.tintColor, UIColor)
+RCT_REMAP_VIEW_PROPERTY(spellCheck, backedTextInputView.spellCheckingType, UITextSpellCheckingType)
+RCT_REMAP_VIEW_PROPERTY(caretHidden, backedTextInputView.caretHidden, BOOL)
+RCT_REMAP_VIEW_PROPERTY(clearButtonMode, backedTextInputView.clearButtonMode, UITextFieldViewMode)
+RCT_REMAP_VIEW_PROPERTY(scrollEnabled, backedTextInputView.scrollEnabled, BOOL)
+RCT_REMAP_VIEW_PROPERTY(secureTextEntry, backedTextInputView.secureTextEntry, BOOL)
+RCT_REMAP_VIEW_PROPERTY(smartInsertDelete, backedTextInputView.smartInsertDeleteType, UITextSmartInsertDeleteType)
+
+RCT_EXPORT_VIEW_PROPERTY(autoFocus, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(submitBehavior, NSString)
+RCT_EXPORT_VIEW_PROPERTY(clearTextOnFocus, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(keyboardType, UIKeyboardType)
+RCT_EXPORT_VIEW_PROPERTY(showSoftInputOnFocus, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(maxLength, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(selectTextOnFocus, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(selection, RCTTextSelection)
+RCT_EXPORT_VIEW_PROPERTY(inputAccessoryViewID, NSString)
+RCT_EXPORT_VIEW_PROPERTY(inputAccessoryViewButtonLabel, NSString)
+RCT_EXPORT_VIEW_PROPERTY(textContentType, NSString)
+RCT_EXPORT_VIEW_PROPERTY(passwordRules, NSString)
+RCT_EXPORT_VIEW_PROPERTY(mostRecentEventCount, NSInteger)
+RCT_EXPORT_VIEW_PROPERTY(disableKeyboardShortcuts, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(acceptDragAndDropTypes, NSArray<NSString *>)
+
+RCT_EXPORT_VIEW_PROPERTY(onChange, RCTBubblingEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onKeyPressSync, RCTDirectEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onChangeSync, RCTDirectEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onSelectionChange, RCTDirectEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onScroll, RCTDirectEventBlock)
+
+RCT_EXPORT_SHADOW_PROPERTY(text, NSString)
+RCT_EXPORT_SHADOW_PROPERTY(placeholder, NSString)
+RCT_EXPORT_SHADOW_PROPERTY(onContentSizeChange, RCTDirectEventBlock)
+
+RCT_CUSTOM_VIEW_PROPERTY(multiline, BOOL, UIView)
+{
+  // No op.
+  // This View Manager doesn't use this prop but it must be exposed here via ViewConfig to enable Fabric component use
+  // it.
+}
+
+- (RCTShadowView *)shadowView
+{
+  RCTBaseTextInputShadowView *shadowView = [[RCTBaseTextInputShadowView alloc] initWithBridge:self.bridge];
+  shadowView.textAttributes.fontSizeMultiplier =
+      [[[self.bridge moduleForName:@"AccessibilityManager"
+             lazilyLoadIfNecessary:YES] valueForKey:@"multiplier"] floatValue];
+  [_shadowViews addObject:shadowView];
+  return shadowView;
+}
+
+- (void)setBridge:(RCTBridge *)bridge
+{
+  [super setBridge:bridge];
+
+  _shadowViews = [NSHashTable weakObjectsHashTable];
+
+  [bridge.uiManager.observerCoordinator addObserver:self];
+
+  [[NSNotificationCenter defaultCenter] addObserver:self
+                                           selector:@selector(handleDidUpdateMultiplierNotification)
+                                               name:@"RCTAccessibilityManagerDidUpdateMultiplierNotification"
+                                             object:[bridge moduleForName:@"AccessibilityManager"
+                                                        lazilyLoadIfNecessary:YES]];
+}
+
+RCT_EXPORT_METHOD(focus : (nonnull NSNumber *)viewTag)
+{
+  [self.bridge.uiManager addUIBlock:^(RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+    UIView *view = viewRegistry[viewTag];
+    [view reactFocus];
+  }];
+}
+
+RCT_EXPORT_METHOD(blur : (nonnull NSNumber *)viewTag)
+{
+  [self.bridge.uiManager addUIBlock:^(RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+    UIView *view = viewRegistry[viewTag];
+    [view reactBlur];
+  }];
+}
+
+RCT_EXPORT_METHOD(
+    setTextAndSelection : (nonnull NSNumber *)viewTag mostRecentEventCount : (NSInteger)
+        mostRecentEventCount value : (NSString *)value start : (NSInteger)start end : (NSInteger)end)
+{
+  [self.bridge.uiManager addUIBlock:^(RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+    RCTBaseTextInputView *view = (RCTBaseTextInputView *)viewRegistry[viewTag];
+    NSInteger eventLag = view.nativeEventCount - mostRecentEventCount;
+    if (eventLag != 0) {
+      return;
+    }
+    RCTExecuteOnUIManagerQueue(^{
+      RCTBaseTextInputShadowView *shadowView =
+          (RCTBaseTextInputShadowView *)[self.bridge.uiManager shadowViewForReactTag:viewTag];
+      if (value != nullptr) {
+        [shadowView setText:value];
+      }
+      [self.bridge.uiManager setNeedsLayout];
+      RCTExecuteOnMainQueue(^{
+        [view setSelectionStart:start selectionEnd:end];
+      });
+    });
+  }];
+}
+
+#pragma mark - RCTUIManagerObserver
+
+- (void)uiManagerWillPerformMounting:(__unused RCTUIManager *)uiManager
+{
+  for (RCTBaseTextInputShadowView *shadowView in _shadowViews) {
+    [shadowView uiManagerWillPerformMounting];
+  }
+}
+
+#pragma mark - Font Size Multiplier
+
+- (void)handleDidUpdateMultiplierNotification
+{
+  CGFloat fontSizeMultiplier =
+      [[[self.bridge moduleForName:@"AccessibilityManager"] valueForKey:@"multiplier"] floatValue];
+
+  NSHashTable<RCTBaseTextInputShadowView *> *shadowViews = _shadowViews;
+  RCTExecuteOnUIManagerQueue(^{
+    for (RCTBaseTextInputShadowView *shadowView in shadowViews) {
+      shadowView.textAttributes.fontSizeMultiplier = fontSizeMultiplier;
+      [shadowView dirtyLayout];
+    }
+
+    [self.bridge.uiManager setNeedsLayout];
+  });
+}
+
+@end
+
+#endif // RCT_REMOVE_LEGACY_ARCH

node_modules/react-native/Libraries/Text/TextInput/RCTInputAccessoryShadowView.h

@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTShadowView.h>
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+__attribute__((deprecated("This API will be removed along with the legacy architecture.")))
+@interface RCTInputAccessoryShadowView : RCTShadowView
+
+@end
+
+#endif // RCT_REMOVE_LEGACY_ARCH

node_modules/react-native/Libraries/Text/TextInput/RCTInputAccessoryShadowView.mm

@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTInputAccessoryShadowView.h>
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+#import <React/RCTUtils.h>
+
+@implementation RCTInputAccessoryShadowView
+
+- (void)insertReactSubview:(RCTShadowView *)subview atIndex:(NSInteger)atIndex
+{
+  [super insertReactSubview:subview atIndex:atIndex];
+  subview.width = (YGValue){static_cast<float>(RCTScreenSize().width), YGUnitPoint};
+}
+
+@end
+
+#endif // RCT_REMOVE_LEGACY_ARCH

node_modules/react-native/Libraries/Text/TextInput/RCTInputAccessoryView.h

@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <UIKit/UIKit.h>
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+@class RCTBridge;
+@class RCTInputAccessoryViewContent;
+
+__attribute__((deprecated("This API will be removed along with the legacy architecture.")))
+@interface RCTInputAccessoryView : UIView
+
+- (instancetype)initWithBridge:(RCTBridge *)bridge;
+
+@end
+
+#endif // RCT_REMOVE_LEGACY_ARCH

node_modules/react-native/Libraries/Text/TextInput/RCTInputAccessoryView.mm

@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTInputAccessoryView.h>
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+#import <React/RCTBridge.h>
+#import <React/RCTTouchHandler.h>
+#import <React/UIView+React.h>
+
+#import <React/RCTInputAccessoryViewContent.h>
+
+@interface RCTInputAccessoryView ()
+
+// Overriding `inputAccessoryView` to `readwrite`.
+@property (nonatomic, readwrite, retain) UIView *inputAccessoryView;
+
+@end
+
+@implementation RCTInputAccessoryView {
+  BOOL _shouldBecomeFirstResponder;
+}
+
+- (instancetype)initWithBridge:(RCTBridge *)bridge
+{
+  if (self = [super init]) {
+    _inputAccessoryView = [RCTInputAccessoryViewContent new];
+    RCTTouchHandler *const touchHandler = [[RCTTouchHandler alloc] initWithBridge:bridge];
+    [touchHandler attachToView:_inputAccessoryView];
+  }
+  return self;
+}
+
+- (BOOL)canBecomeFirstResponder
+{
+  return true;
+}
+
+- (void)reactSetFrame:(CGRect)frame
+{
+  [_inputAccessoryView reactSetFrame:frame];
+
+  if (_shouldBecomeFirstResponder) {
+    _shouldBecomeFirstResponder = NO;
+    [self becomeFirstResponder];
+  }
+}
+
+- (void)insertReactSubview:(UIView *)subview atIndex:(NSInteger)index
+{
+  [super insertReactSubview:subview atIndex:index];
+  [_inputAccessoryView insertReactSubview:subview atIndex:index];
+}
+
+- (void)removeReactSubview:(UIView *)subview
+{
+  [super removeReactSubview:subview];
+  [_inputAccessoryView removeReactSubview:subview];
+}
+
+- (void)didUpdateReactSubviews
+{
+  // Do nothing, as subviews are managed by `insertReactSubview:atIndex:`.
+}
+
+- (void)didSetProps:(NSArray<NSString *> *)changedProps
+{
+  // If the accessory view is not linked to a text input via nativeID, assume it is
+  // a standalone component that should get focus whenever it is rendered.
+  if (![changedProps containsObject:@"nativeID"] && !self.nativeID) {
+    _shouldBecomeFirstResponder = YES;
+  }
+}
+
+@end
+
+#endif // RCT_REMOVE_LEGACY_ARCH

node_modules/react-native/Libraries/Text/TextInput/RCTInputAccessoryViewContent.h

@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <UIKit/UIKit.h>
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+__attribute__((deprecated("This API will be removed along with the legacy architecture.")))
+@interface RCTInputAccessoryViewContent : UIView
+
+@end
+
+#endif // RCT_REMOVE_LEGACY_ARCH

node_modules/react-native/Libraries/Text/TextInput/RCTInputAccessoryViewContent.mm

@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTInputAccessoryViewContent.h>
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+#import <React/UIView+React.h>
+
+@implementation RCTInputAccessoryViewContent {
+  UIView *_safeAreaContainer;
+  NSLayoutConstraint *_heightConstraint;
+}
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _safeAreaContainer = [UIView new];
+    [self addSubview:_safeAreaContainer];
+
+    // Use autolayout to position the view properly and take into account
+    // safe area insets on iPhone X.
+    // TODO: Support rotation, anchor to left and right without breaking frame x coordinate (T27974328).
+    self.autoresizingMask = UIViewAutoresizingFlexibleHeight;
+    _safeAreaContainer.translatesAutoresizingMaskIntoConstraints = NO;
+
+    _heightConstraint = [_safeAreaContainer.heightAnchor constraintEqualToConstant:0];
+    _heightConstraint.active = YES;
+
+    [_safeAreaContainer.bottomAnchor constraintEqualToAnchor:self.safeAreaLayoutGuide.bottomAnchor].active = YES;
+    [_safeAreaContainer.topAnchor constraintEqualToAnchor:self.safeAreaLayoutGuide.topAnchor].active = YES;
+    [_safeAreaContainer.leadingAnchor constraintEqualToAnchor:self.leadingAnchor].active = YES;
+    [_safeAreaContainer.trailingAnchor constraintEqualToAnchor:self.trailingAnchor].active = YES;
+  }
+  return self;
+}
+
+- (CGSize)intrinsicContentSize
+{
+  // This is needed so the view size is based on autolayout constraints.
+  return CGSizeZero;
+}
+
+- (void)reactSetFrame:(CGRect)frame
+{
+  // We still need to set the frame here, otherwise it won't be
+  // measured until moved to the window during the keyboard opening
+  // animation. If this happens, the height will be animated from 0 to
+  // its actual size and we don't want that.
+  [self setFrame:frame];
+  [_safeAreaContainer setFrame:frame];
+
+  _heightConstraint.constant = frame.size.height;
+  [self layoutIfNeeded];
+}
+
+- (void)insertReactSubview:(UIView *)subview atIndex:(NSInteger)index
+{
+  [super insertReactSubview:subview atIndex:index];
+  [_safeAreaContainer insertSubview:subview atIndex:index];
+}
+
+- (void)removeReactSubview:(UIView *)subview
+{
+  [super removeReactSubview:subview];
+  [subview removeFromSuperview];
+  if ([[_safeAreaContainer subviews] count] == 0 && [self isFirstResponder]) {
+    [self resignFirstResponder];
+  }
+}
+
+@end
+
+#endif // RCT_REMOVE_LEGACY_ARCH

node_modules/react-native/Libraries/Text/TextInput/RCTInputAccessoryViewManager.h

@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTViewManager.h>
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+__attribute__((deprecated("This API will be removed along with the legacy architecture.")))
+@interface RCTInputAccessoryViewManager : RCTViewManager
+
+@end
+
+#endif // RCT_REMOVE_LEGACY_ARCH

node_modules/react-native/Libraries/Text/TextInput/RCTInputAccessoryViewManager.mm

@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTInputAccessoryViewManager.h>
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+#import <React/RCTInputAccessoryShadowView.h>
+#import <React/RCTInputAccessoryView.h>
+
+@implementation RCTInputAccessoryViewManager
+
+RCT_EXPORT_MODULE()
+
+- (UIView *)view
+{
+  return [[RCTInputAccessoryView alloc] initWithBridge:self.bridge];
+}
+
+- (RCTShadowView *)shadowView
+{
+  return [RCTInputAccessoryShadowView new];
+}
+
+RCT_REMAP_VIEW_PROPERTY(backgroundColor, inputAccessoryView.backgroundColor, UIColor)
+
+@end
+
+#endif // RCT_REMOVE_LEGACY_ARCH

node_modules/react-native/Libraries/Text/TextInput/RCTTextSelection.h

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTConvert.h>
+
+/**
+ * Object containing information about a TextInput's selection.
+ */
+@interface RCTTextSelection : NSObject
+
+@property (nonatomic, assign, readonly) NSInteger start;
+@property (nonatomic, assign, readonly) NSInteger end;
+
+- (instancetype)initWithStart:(NSInteger)start end:(NSInteger)end;
+
+@end
+
+@interface RCTConvert (RCTTextSelection)
+
++ (RCTTextSelection *)RCTTextSelection:(id)json;
+
+@end

node_modules/react-native/Libraries/Text/TextInput/RCTTextSelection.mm

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTTextSelection.h>
+
+@implementation RCTTextSelection
+
+- (instancetype)initWithStart:(NSInteger)start end:(NSInteger)end
+{
+  if (self = [super init]) {
+    _start = start;
+    _end = end;
+  }
+  return self;
+}
+
+@end
+
+@implementation RCTConvert (RCTTextSelection)
+
++ (RCTTextSelection *)RCTTextSelection:(id)json
+{
+  if ([json isKindOfClass:[NSDictionary class]]) {
+    NSInteger start = [self NSInteger:json[@"start"]];
+    NSInteger end = [self NSInteger:json[@"end"]];
+    return [[RCTTextSelection alloc] initWithStart:start end:end];
+  }
+
+  return nil;
+}
+
+@end

node_modules/react-native/Libraries/Text/TextInput/Singleline/RCTSinglelineTextInputView.h

@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTBaseTextInputView.h"
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+NS_ASSUME_NONNULL_BEGIN
+
+__attribute__((deprecated("This API will be removed along with the legacy architecture.")))
+@interface RCTSinglelineTextInputView : RCTBaseTextInputView
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif // RCT_REMOVE_LEGACY_ARCH

node_modules/react-native/Libraries/Text/TextInput/Singleline/RCTSinglelineTextInputView.mm

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTSinglelineTextInputView.h>
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+#import <React/RCTBridge.h>
+
+#import <React/RCTUITextField.h>
+
+@implementation RCTSinglelineTextInputView {
+  RCTUITextField *_backedTextInputView;
+}
+
+- (instancetype)initWithBridge:(RCTBridge *)bridge
+{
+  if (self = [super initWithBridge:bridge]) {
+    // `submitBehavior` defaults to `"blurAndSubmit"` for <TextInput multiline={false}> by design.
+    self.submitBehavior = @"blurAndSubmit";
+
+    _backedTextInputView = [[RCTUITextField alloc] initWithFrame:self.bounds];
+    _backedTextInputView.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
+    _backedTextInputView.textInputDelegate = self;
+
+    [self addSubview:_backedTextInputView];
+  }
+
+  return self;
+}
+
+- (id<RCTBackedTextInputViewProtocol>)backedTextInputView
+{
+  return _backedTextInputView;
+}
+
+@end
+
+#endif // RCT_REMOVE_LEGACY_ARCH

node_modules/react-native/Libraries/Text/TextInput/Singleline/RCTSinglelineTextInputViewManager.h

@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTBaseTextInputViewManager.h"
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+NS_ASSUME_NONNULL_BEGIN
+
+__attribute__((deprecated("This API will be removed along with the legacy architecture.")))
+@interface RCTSinglelineTextInputViewManager : RCTBaseTextInputViewManager
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif // RCT_REMOVE_LEGACY_ARCH

node_modules/react-native/Libraries/Text/TextInput/Singleline/RCTSinglelineTextInputViewManager.mm

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTSinglelineTextInputViewManager.h>
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+#import <React/RCTBaseTextInputShadowView.h>
+#import <React/RCTSinglelineTextInputView.h>
+
+@implementation RCTSinglelineTextInputViewManager
+
+RCT_EXPORT_MODULE()
+
+- (RCTShadowView *)shadowView
+{
+  RCTBaseTextInputShadowView *shadowView = (RCTBaseTextInputShadowView *)[super shadowView];
+
+  shadowView.maximumNumberOfLines = 1;
+
+  return shadowView;
+}
+
+- (UIView *)view
+{
+  return [[RCTSinglelineTextInputView alloc] initWithBridge:self.bridge];
+}
+
+@end
+
+#endif // RCT_REMOVE_LEGACY_ARCH

node_modules/react-native/Libraries/Text/TextInput/Singleline/RCTUITextField.h

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <UIKit/UIKit.h>
+
+#import <React/RCTBackedTextInputDelegate.h>
+#import <React/RCTBackedTextInputViewProtocol.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/*
+ * Just regular UITextField... but much better!
+ */
+@interface RCTUITextField : UITextField <RCTBackedTextInputViewProtocol>
+
+- (instancetype)initWithCoder:(NSCoder *)decoder NS_UNAVAILABLE;
+
+@property (nonatomic, weak) id<RCTBackedTextInputDelegate> textInputDelegate;
+
+@property (nonatomic, assign) BOOL caretHidden;
+@property (nonatomic, assign) BOOL contextMenuHidden;
+@property (nonatomic, assign, readonly) BOOL textWasPasted;
+@property (nonatomic, assign, readonly) BOOL dictationRecognizing;
+@property (nonatomic, strong, nullable) UIColor *placeholderColor;
+@property (nonatomic, assign) UIEdgeInsets textContainerInset;
+@property (nonatomic, assign, getter=isEditable) BOOL editable;
+@property (nonatomic, getter=isScrollEnabled) BOOL scrollEnabled;
+@property (nonatomic, strong, nullable) NSString *inputAccessoryViewID;
+@property (nonatomic, strong, nullable) NSString *inputAccessoryViewButtonLabel;
+@property (nonatomic, assign, readonly) CGFloat zoomScale;
+@property (nonatomic, assign, readonly) CGPoint contentOffset;
+@property (nonatomic, assign, readonly) UIEdgeInsets contentInset;
+@property (nonatomic, assign) BOOL disableKeyboardShortcuts;
+
+@end
+
+NS_ASSUME_NONNULL_END

node_modules/react-native/Libraries/Text/TextInput/Singleline/RCTUITextField.mm

@@ -0,0 +1,296 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTUITextField.h>
+
+#import <React/RCTBackedTextInputDelegateAdapter.h>
+#import <React/RCTTextAttributes.h>
+#import <React/RCTUtils.h>
+#import <React/UIView+React.h>
+
+@implementation RCTUITextField {
+  RCTBackedTextFieldDelegateAdapter *_textInputDelegateAdapter;
+  NSDictionary<NSAttributedStringKey, id> *_defaultTextAttributes;
+  NSArray<UIBarButtonItemGroup *> *_initialValueLeadingBarButtonGroups;
+  NSArray<UIBarButtonItemGroup *> *_initialValueTrailingBarButtonGroups;
+  NSArray<NSString *> *_acceptDragAndDropTypes;
+}
+
+// This should not be needed but internal build were failing without it.
+// This variable is unused.
+@synthesize dataDetectorTypes;
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    [[NSNotificationCenter defaultCenter] addObserver:self
+                                             selector:@selector(_textDidChange)
+                                                 name:UITextFieldTextDidChangeNotification
+                                               object:self];
+
+    _textInputDelegateAdapter = [[RCTBackedTextFieldDelegateAdapter alloc] initWithTextField:self];
+    _scrollEnabled = YES;
+    _initialValueLeadingBarButtonGroups = nil;
+    _initialValueTrailingBarButtonGroups = nil;
+  }
+
+  return self;
+}
+
+- (void)_textDidChange
+{
+  _textWasPasted = NO;
+}
+
+#pragma mark - Accessibility
+
+- (void)setIsAccessibilityElement:(BOOL)isAccessibilityElement
+{
+  // UITextField is accessible by default (some nested views are) and disabling that is not supported.
+  // On iOS accessible elements cannot be nested, therefore enabling accessibility for some container view
+  // (even in a case where this view is a part of public API of TextInput on iOS) shadows some features implemented
+  // inside the component.
+}
+
+#pragma mark - Properties
+
+- (void)setAcceptDragAndDropTypes:(NSArray<NSString *> *)acceptDragAndDropTypes
+{
+  _acceptDragAndDropTypes = acceptDragAndDropTypes;
+}
+
+- (nullable NSArray<NSString *> *)acceptDragAndDropTypes
+{
+  return _acceptDragAndDropTypes;
+}
+
+- (void)setTextContainerInset:(UIEdgeInsets)textContainerInset
+{
+  _textContainerInset = textContainerInset;
+  [self setNeedsLayout];
+}
+
+- (void)setPlaceholder:(NSString *)placeholder
+{
+  [super setPlaceholder:placeholder];
+  [self _updatePlaceholder];
+}
+
+- (void)setPlaceholderColor:(UIColor *)placeholderColor
+{
+  _placeholderColor = placeholderColor;
+  [self _updatePlaceholder];
+}
+
+- (void)setDefaultTextAttributes:(NSDictionary<NSAttributedStringKey, id> *)defaultTextAttributes
+{
+  if ([_defaultTextAttributes isEqualToDictionary:defaultTextAttributes]) {
+    return;
+  }
+
+  _defaultTextAttributes = defaultTextAttributes;
+  [super setDefaultTextAttributes:defaultTextAttributes];
+  [self _updatePlaceholder];
+}
+
+- (NSDictionary<NSAttributedStringKey, id> *)defaultTextAttributes
+{
+  return _defaultTextAttributes;
+}
+
+- (void)_updatePlaceholder
+{
+  self.attributedPlaceholder = [[NSAttributedString alloc] initWithString:self.placeholder ?: @""
+                                                               attributes:[self _placeholderTextAttributes]];
+}
+
+- (BOOL)isEditable
+{
+  return self.isEnabled;
+}
+
+- (void)setEditable:(BOOL)editable
+{
+  self.enabled = editable;
+}
+
+- (void)setSecureTextEntry:(BOOL)secureTextEntry
+{
+  if (self.secureTextEntry == secureTextEntry) {
+    return;
+  }
+
+  [super setSecureTextEntry:secureTextEntry];
+
+  // Fix for trailing whitespate issue
+  // Read more:
+  // https://stackoverflow.com/questions/14220187/uitextfield-has-trailing-whitespace-after-securetextentry-toggle/22537788#22537788
+  NSAttributedString *originalText = [self.attributedText copy];
+  self.attributedText = [NSAttributedString new];
+  self.attributedText = originalText;
+}
+
+- (void)setDisableKeyboardShortcuts:(BOOL)disableKeyboardShortcuts
+{
+#if TARGET_OS_IOS
+  // Initialize the initial values only once
+  if (_initialValueLeadingBarButtonGroups == nil) {
+    // Capture initial values of leading and trailing button groups
+    _initialValueLeadingBarButtonGroups = self.inputAssistantItem.leadingBarButtonGroups;
+    _initialValueTrailingBarButtonGroups = self.inputAssistantItem.trailingBarButtonGroups;
+  }
+
+  if (disableKeyboardShortcuts) {
+    self.inputAssistantItem.leadingBarButtonGroups = @[];
+    self.inputAssistantItem.trailingBarButtonGroups = @[];
+  } else {
+    // Restore the initial values
+    self.inputAssistantItem.leadingBarButtonGroups = _initialValueLeadingBarButtonGroups;
+    self.inputAssistantItem.trailingBarButtonGroups = _initialValueTrailingBarButtonGroups;
+  }
+  _disableKeyboardShortcuts = disableKeyboardShortcuts;
+#endif
+}
+
+#pragma mark - Placeholder
+
+- (NSDictionary<NSAttributedStringKey, id> *)_placeholderTextAttributes
+{
+  NSMutableDictionary<NSAttributedStringKey, id> *textAttributes =
+      [_defaultTextAttributes mutableCopy] ?: [NSMutableDictionary new];
+
+  if (self.placeholderColor) {
+    [textAttributes setValue:self.placeholderColor forKey:NSForegroundColorAttributeName];
+  } else {
+    [textAttributes removeObjectForKey:NSForegroundColorAttributeName];
+  }
+
+  return textAttributes;
+}
+
+#pragma mark - Context Menu
+
+- (BOOL)canPerformAction:(SEL)action withSender:(id)sender
+{
+  if (_contextMenuHidden) {
+    return NO;
+  }
+
+  return [super canPerformAction:action withSender:sender];
+}
+
+- (void)buildMenuWithBuilder:(id<UIMenuBuilder>)builder
+{
+#if defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && __IPHONE_OS_VERSION_MAX_ALLOWED >= 170000
+  if (@available(iOS 17.0, *)) {
+    if (_contextMenuHidden) {
+      [builder removeMenuForIdentifier:UIMenuAutoFill];
+    }
+  }
+#endif
+
+  [super buildMenuWithBuilder:builder];
+}
+
+#pragma mark - Dictation
+
+- (void)dictationRecordingDidEnd
+{
+  _dictationRecognizing = YES;
+}
+
+- (void)removeDictationResultPlaceholder:(id)placeholder willInsertResult:(BOOL)willInsertResult
+{
+  [super removeDictationResultPlaceholder:placeholder willInsertResult:willInsertResult];
+  _dictationRecognizing = NO;
+}
+
+#pragma mark - Caret Manipulation
+
+- (CGRect)caretRectForPosition:(UITextPosition *)position
+{
+  if (_caretHidden) {
+    return CGRectZero;
+  }
+
+  return [super caretRectForPosition:position];
+}
+
+#pragma mark - Positioning Overrides
+
+- (CGRect)textRectForBounds:(CGRect)bounds
+{
+  return UIEdgeInsetsInsetRect([super textRectForBounds:bounds], _textContainerInset);
+}
+
+- (CGRect)editingRectForBounds:(CGRect)bounds
+{
+  return [self textRectForBounds:bounds];
+}
+
+#pragma mark - Overrides
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-implementations"
+// Overrides selectedTextRange setter to get notify when selectedTextRange changed.
+- (void)setSelectedTextRange:(UITextRange *)selectedTextRange
+{
+  [super setSelectedTextRange:selectedTextRange];
+  [_textInputDelegateAdapter selectedTextRangeWasSet];
+}
+#pragma clang diagnostic pop
+
+- (void)setSelectedTextRange:(UITextRange *)selectedTextRange notifyDelegate:(BOOL)notifyDelegate
+{
+  if (!notifyDelegate) {
+    // We have to notify an adapter that following selection change was initiated programmatically,
+    // so the adapter must not generate a notification for it.
+    [_textInputDelegateAdapter skipNextTextInputDidChangeSelectionEventWithTextRange:selectedTextRange];
+  }
+
+  [super setSelectedTextRange:selectedTextRange];
+}
+
+- (void)scrollRangeToVisible:(NSRange)range
+{
+  // Singleline TextInput does not require scrolling after calling setSelectedTextRange (PR 38679).
+}
+
+- (void)paste:(id)sender
+{
+  _textWasPasted = YES;
+  [super paste:sender];
+}
+
+#pragma mark - Layout
+
+- (CGSize)contentSize
+{
+  // Returning size DOES contain `textContainerInset` (aka `padding`).
+  return self.intrinsicContentSize;
+}
+
+- (CGSize)intrinsicContentSize
+{
+  // Note: `placeholder` defines intrinsic size for `<TextInput>`.
+  NSString *text = self.placeholder ?: @"";
+  CGSize size = [text sizeWithAttributes:[self _placeholderTextAttributes]];
+  size = CGSizeMake(RCTCeilPixelValue(size.width), RCTCeilPixelValue(size.height));
+  size.width += _textContainerInset.left + _textContainerInset.right;
+  size.height += _textContainerInset.top + _textContainerInset.bottom;
+  // Returning size DOES contain `textContainerInset` (aka `padding`).
+  return size;
+}
+
+- (CGSize)sizeThatFits:(CGSize)size
+{
+  // All size values here contain `textContainerInset` (aka `padding`).
+  CGSize intrinsicSize = self.intrinsicContentSize;
+  return CGSizeMake(MIN(size.width, intrinsicSize.width), MIN(size.height, intrinsicSize.height));
+}
+
+@end

node_modules/react-native/Libraries/Text/TextNativeComponent.js

@@ -0,0 +1,92 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ * @format
+ */
+
+import type {HostComponent} from '../../src/private/types/HostComponent';
+import type {ProcessedColorValue} from '../StyleSheet/processColor';
+import type {GestureResponderEvent} from '../Types/CoreEventTypes';
+import type {TextProps} from './TextProps';
+
+import {createViewConfig} from '../NativeComponent/ViewConfig';
+import UIManager from '../ReactNative/UIManager';
+import createReactNativeComponentClass from '../Renderer/shims/createReactNativeComponentClass';
+
+export type NativeTextProps = $ReadOnly<{
+  ...TextProps,
+  isHighlighted?: ?boolean,
+  selectionColor?: ?ProcessedColorValue,
+  onClick?: ?(event: GestureResponderEvent) => mixed,
+  // This is only needed for platforms that optimize text hit testing, e.g.,
+  // react-native-windows. It can be used to only hit test virtual text spans
+  // that have pressable events attached to them.
+  isPressable?: ?boolean,
+}>;
+
+const textViewConfig = {
+  validAttributes: {
+    isHighlighted: true,
+    isPressable: true,
+    numberOfLines: true,
+    ellipsizeMode: true,
+    allowFontScaling: true,
+    dynamicTypeRamp: true,
+    maxFontSizeMultiplier: true,
+    disabled: true,
+    selectable: true,
+    selectionColor: true,
+    adjustsFontSizeToFit: true,
+    minimumFontScale: true,
+    textBreakStrategy: true,
+    onTextLayout: true,
+    dataDetectorType: true,
+    android_hyphenationFrequency: true,
+    lineBreakStrategyIOS: true,
+  },
+  directEventTypes: {
+    topTextLayout: {
+      registrationName: 'onTextLayout',
+    },
+  },
+  uiViewClassName: 'RCTText',
+};
+
+const virtualTextViewConfig = {
+  validAttributes: {
+    isHighlighted: true,
+    isPressable: true,
+    maxFontSizeMultiplier: true,
+  },
+  uiViewClassName: 'RCTVirtualText',
+};
+
+/**
+ * `NativeText` is an internal React Native host component, and is exported to
+ * provide lower-level access for libraries.
+ *
+ * @warning `<unstable_NativeText>` provides no semver guarantees and is not
+ *   intended to be used in app code. Please use
+ *   [`<Text>`](https://reactnative.dev/docs/text) instead.
+ */
+// Additional note: Our long term plan is to reduce the overhead of the <Text>
+// and <View> wrappers so that we no longer have any reason to export these APIs.
+export const NativeText: HostComponent<NativeTextProps> =
+  (createReactNativeComponentClass('RCTText', () =>
+    /* $FlowFixMe[incompatible-type] Natural Inference rollout. See
+     * https://fburl.com/workplace/6291gfvu */
+    createViewConfig(textViewConfig),
+  ): any);
+
+export const NativeVirtualText: HostComponent<NativeTextProps> =
+  !global.RN$Bridgeless && !UIManager.hasViewManagerConfig('RCTVirtualText')
+    ? NativeText
+    : (createReactNativeComponentClass('RCTVirtualText', () =>
+        /* $FlowFixMe[incompatible-type] Natural Inference rollout. See
+         * https://fburl.com/workplace/6291gfvu */
+        createViewConfig(virtualTextViewConfig),
+      ): any);

node_modules/react-native/Libraries/Text/TextProps.js

@@ -0,0 +1,277 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+import type {
+  AccessibilityActionEvent,
+  AccessibilityProps,
+  Role,
+} from '../Components/View/ViewAccessibility';
+import type {ColorValue, TextStyleProp} from '../StyleSheet/StyleSheet';
+import type {
+  GestureResponderEvent,
+  LayoutChangeEvent,
+  PointerEvent,
+  TextLayoutEvent,
+} from '../Types/CoreEventTypes';
+
+import * as React from 'react';
+
+export type PressRetentionOffset = $ReadOnly<{
+  top: number,
+  left: number,
+  bottom: number,
+  right: number,
+}>;
+
+type TextPointerEventProps = $ReadOnly<{
+  onPointerEnter?: (event: PointerEvent) => void,
+  onPointerLeave?: (event: PointerEvent) => void,
+  onPointerMove?: (event: PointerEvent) => void,
+}>;
+
+export type TextPropsIOS = {
+  /**
+   * Specifies whether font should be scaled down automatically to fit given style constraints.
+   *
+   * See https://reactnative.dev/docs/text#adjustsfontsizetofit
+   */
+  adjustsFontSizeToFit?: ?boolean,
+
+  /**
+   * The Dynamic Type scale ramp to apply to this element on iOS.
+   */
+  dynamicTypeRamp?: ?(
+    | 'caption2'
+    | 'caption1'
+    | 'footnote'
+    | 'subheadline'
+    | 'callout'
+    | 'body'
+    | 'headline'
+    | 'title3'
+    | 'title2'
+    | 'title1'
+    | 'largeTitle'
+  ),
+
+  /**
+   * When `true`, no visual change is made when text is pressed down. By
+   * default, a gray oval highlights the text on press down.
+   *
+   * See https://reactnative.dev/docs/text#supperhighlighting
+   */
+  suppressHighlighting?: ?boolean,
+
+  /**
+   * Set line break strategy on iOS.
+   *
+   * See https://reactnative.dev/docs/text.html#linebreakstrategyios
+   */
+  lineBreakStrategyIOS?: ?('none' | 'standard' | 'hangul-word' | 'push-out'),
+};
+
+export type TextPropsAndroid = {
+  /**
+   * Specifies the disabled state of the text view for testing purposes.
+   *
+   * See https://reactnative.dev/docs/text#disabled
+   */
+  disabled?: ?boolean,
+
+  /**
+   * The highlight color of the text.
+   *
+   * See https://reactnative.dev/docs/text#selectioncolor
+   */
+  selectionColor?: ?ColorValue,
+
+  /**
+   * Determines the types of data converted to clickable URLs in the text element.
+   * By default no data types are detected.
+   */
+  dataDetectorType?: ?('phoneNumber' | 'link' | 'email' | 'none' | 'all'),
+
+  /**
+   * Set text break strategy on Android API Level 23+
+   * default is `highQuality`.
+   *
+   * See https://reactnative.dev/docs/text#textbreakstrategy
+   */
+  textBreakStrategy?: ?('balanced' | 'highQuality' | 'simple'),
+
+  /**
+   * iOS Only
+   */
+  adjustsFontSizeToFit?: ?boolean,
+
+  /**
+   * Specifies smallest possible scale a font can reach when adjustsFontSizeToFit is enabled. (values 0.01-1.0).
+   *
+   * See https://reactnative.dev/docs/text#minimumfontscale
+   */
+  minimumFontScale?: ?number,
+};
+
+type TextBaseProps = $ReadOnly<{
+  onAccessibilityAction?: ?(event: AccessibilityActionEvent) => mixed,
+
+  /**
+   * Whether fonts should scale to respect Text Size accessibility settings.
+   * The default is `true`.
+   *
+   * See https://reactnative.dev/docs/text#allowfontscaling
+   */
+  allowFontScaling?: ?boolean,
+
+  /**
+   * Set hyphenation strategy on Android.
+   *
+   */
+  android_hyphenationFrequency?: ?('normal' | 'none' | 'full'),
+  children?: ?React.Node,
+
+  /**
+   * When `numberOfLines` is set, this prop defines how text will be
+   * truncated.
+   *
+   * This can be one of the following values:
+   *
+   * - `head` - The line is displayed so that the end fits in the container and the missing text
+   * at the beginning of the line is indicated by an ellipsis glyph. e.g., "...wxyz"
+   * - `middle` - The line is displayed so that the beginning and end fit in the container and the
+   * missing text in the middle is indicated by an ellipsis glyph. "ab...yz"
+   * - `tail` - The line is displayed so that the beginning fits in the container and the
+   * missing text at the end of the line is indicated by an ellipsis glyph. e.g., "abcd..."
+   * - `clip` - Lines are not drawn past the edge of the text container.
+   *
+   * The default is `tail`.
+   *
+   * `numberOfLines` must be set in conjunction with this prop.
+   *
+   * > `clip` is working only for iOS
+   *
+   * See https://reactnative.dev/docs/text#ellipsizemode
+   */
+  ellipsizeMode?: ?('clip' | 'head' | 'middle' | 'tail'),
+
+  /**
+   * Used to reference react managed views from native code.
+   *
+   * See https://reactnative.dev/docs/text#nativeid
+   */
+  id?: string,
+
+  /**
+   * Specifies largest possible scale a font can reach when `allowFontScaling` is enabled.
+   * Possible values:
+   * `null/undefined` (default): inherit from the parent node or the global default (0)
+   * `0`: no max, ignore parent/global default
+   * `>= 1`: sets the maxFontSizeMultiplier of this node to this value
+   */
+  maxFontSizeMultiplier?: ?number,
+
+  /**
+   * Used to locate this view from native code.
+   *
+   * See https://reactnative.dev/docs/text#nativeid
+   */
+  nativeID?: ?string,
+
+  /**
+   * Used to truncate the text with an ellipsis after computing the text
+   * layout, including line wrapping, such that the total number of lines
+   * does not exceed this number.
+   *
+   * This prop is commonly used with `ellipsizeMode`.
+   *
+   * See https://reactnative.dev/docs/text#numberoflines
+   */
+  numberOfLines?: ?number,
+
+  /**
+   * Invoked on mount and layout changes.
+   *
+   * {nativeEvent: { layout: {x, y, width, height}}}.
+   *
+   * See https://reactnative.dev/docs/text#onlayout
+   */
+  onLayout?: ?(event: LayoutChangeEvent) => mixed,
+
+  /**
+   * This function is called on long press.
+   * e.g., `onLongPress={this.increaseSize}>`
+   *
+   * See https://reactnative.dev/docs/text#onlongpress
+   */
+  onLongPress?: ?(event: GestureResponderEvent) => mixed,
+
+  /**
+   * This function is called on press.
+   * Text intrinsically supports press handling with a default highlight state (which can be disabled with suppressHighlighting).
+   *
+   * See https://reactnative.dev/docs/text#onpress
+   */
+  onPress?: ?(event: GestureResponderEvent) => mixed,
+  onPressIn?: ?(event: GestureResponderEvent) => mixed,
+  onPressOut?: ?(event: GestureResponderEvent) => mixed,
+  onResponderGrant?: ?(event: GestureResponderEvent) => void,
+  onResponderMove?: ?(event: GestureResponderEvent) => void,
+  onResponderRelease?: ?(event: GestureResponderEvent) => void,
+  onResponderTerminate?: ?(event: GestureResponderEvent) => void,
+  onResponderTerminationRequest?: ?() => boolean,
+  onStartShouldSetResponder?: ?() => boolean,
+  onMoveShouldSetResponder?: ?() => boolean,
+  onTextLayout?: ?(event: TextLayoutEvent) => mixed,
+
+  /**
+   * Defines how far your touch may move off of the button, before
+   * deactivating the button.
+   *
+   * See https://reactnative.dev/docs/text#pressretentionoffset
+   */
+  pressRetentionOffset?: ?PressRetentionOffset,
+
+  /**
+   * Indicates to accessibility services to treat UI component like a specific role.
+   */
+  role?: ?Role,
+
+  /**
+   * Lets the user select text.
+   *
+   * See https://reactnative.dev/docs/text#selectable
+   */
+  selectable?: ?boolean,
+
+  /**
+   * @see https://reactnative.dev/docs/text#style
+   */
+  style?: ?TextStyleProp,
+
+  /**
+   * Used to locate this view in end-to-end tests.
+   *
+   * See https://reactnative.dev/docs/text#testid
+   */
+  testID?: ?string,
+}>;
+
+/**
+ * @see https://reactnative.dev/docs/text#reference
+ */
+export type TextProps = $ReadOnly<{
+  ...TextPointerEventProps,
+  ...TextPropsIOS,
+  ...TextPropsAndroid,
+  ...TextBaseProps,
+  ...AccessibilityProps,
+}>;

node_modules/react-native/Libraries/Text/VirtualText/RCTVirtualTextShadowView.h

@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTBaseTextShadowView.h"
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+__attribute__((deprecated("This API will be removed along with the legacy architecture.")))
+@interface RCTVirtualTextShadowView : RCTBaseTextShadowView
+
+@end
+
+#endif // RCT_REMOVE_LEGACY_ARCH

node_modules/react-native/Libraries/Text/VirtualText/RCTVirtualTextShadowView.mm

@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTVirtualTextShadowView.h>
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+#import <React/RCTShadowView+Layout.h>
+#import <yoga/Yoga.h>
+
+#import <React/RCTRawTextShadowView.h>
+
+@implementation RCTVirtualTextShadowView {
+  BOOL _isLayoutDirty;
+}
+
+#pragma mark - Layout
+
+- (void)dirtyLayout
+{
+  [super dirtyLayout];
+
+  if (_isLayoutDirty) {
+    return;
+  }
+  _isLayoutDirty = YES;
+
+  [self.superview dirtyLayout];
+}
+
+- (void)clearLayout
+{
+  _isLayoutDirty = NO;
+}
+
+@end
+
+#endif // RCT_REMOVE_LEGACY_ARCH

node_modules/react-native/Libraries/Text/VirtualText/RCTVirtualTextView.h

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTComponent.h>
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+__attribute__((deprecated("This API will be removed along with the legacy architecture.")))
+@interface RCTVirtualTextView : UIView
+
+/**
+ * (Experimental and unused for Paper) Pointer event handlers.
+ */
+@property (nonatomic, assign) RCTBubblingEventBlock onClick;
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif // RCT_REMOVE_LEGACY_ARCH

node_modules/react-native/Libraries/Text/VirtualText/RCTVirtualTextView.mm

@@ -0,0 +1,16 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTVirtualTextView.h>
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+@implementation RCTVirtualTextView
+
+@end
+
+#endif // RCT_REMOVE_LEGACY_ARCH

node_modules/react-native/Libraries/Text/VirtualText/RCTVirtualTextViewManager.h

@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTBaseTextViewManager.h"
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+__attribute__((deprecated("This API will be removed along with the legacy architecture.")))
+@interface RCTVirtualTextViewManager : RCTBaseTextViewManager
+
+@end
+
+#endif // RCT_REMOVE_LEGACY_ARCH

node_modules/react-native/Libraries/Text/VirtualText/RCTVirtualTextViewManager.mm

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTVirtualTextShadowView.h>
+#import <React/RCTVirtualTextView.h>
+#import <React/RCTVirtualTextViewManager.h>
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+@implementation RCTVirtualTextViewManager
+
+RCT_EXPORT_MODULE(RCTVirtualText)
+
+- (UIView *)view
+{
+  return [RCTVirtualTextView new];
+}
+
+- (RCTShadowView *)shadowView
+{
+  return [RCTVirtualTextShadowView new];
+}
+
+@end
+
+#endif // RCT_REMOVE_LEGACY_ARCH