initial commit taken from gitlab.lrz.de

node_modules/react-native/React/Modules/RCTAccessibilityManager.h

@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * 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/RCTBridge.h>
+#import <React/RCTBridgeModule.h>
+
+extern NSString *const RCTAccessibilityManagerDidUpdateMultiplierNotification; // posted when multiplier is changed
+
+@interface RCTAccessibilityManager : NSObject <RCTBridgeModule>
+
+@property (nonatomic, readonly) CGFloat multiplier;
+
+/// map from UIKit categories to multipliers
+@property (nonatomic, copy) NSDictionary<NSString *, NSNumber *> *multipliers;
+
+@property (nonatomic, assign) BOOL isVoiceOverEnabled;
+
+@end
+
+@interface RCTBridge (RCTAccessibilityManager)
+
+@property (nonatomic, readonly) RCTAccessibilityManager *accessibilityManager;
+
+@end

node_modules/react-native/React/Modules/RCTAccessibilityManager.m

@@ -0,0 +1,219 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTAccessibilityManager.h"
+
+#import "RCTUIManager.h"
+#import "RCTBridge.h"
+#import "RCTConvert.h"
+#import "RCTEventDispatcher.h"
+#import "RCTLog.h"
+
+NSString *const RCTAccessibilityManagerDidUpdateMultiplierNotification = @"RCTAccessibilityManagerDidUpdateMultiplierNotification";
+
+static NSString *UIKitCategoryFromJSCategory(NSString *JSCategory)
+{
+  static NSDictionary *map = nil;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    map = @{@"extraSmall": UIContentSizeCategoryExtraSmall,
+            @"small": UIContentSizeCategorySmall,
+            @"medium": UIContentSizeCategoryMedium,
+            @"large": UIContentSizeCategoryLarge,
+            @"extraLarge": UIContentSizeCategoryExtraLarge,
+            @"extraExtraLarge": UIContentSizeCategoryExtraExtraLarge,
+            @"extraExtraExtraLarge": UIContentSizeCategoryExtraExtraExtraLarge,
+            @"accessibilityMedium": UIContentSizeCategoryAccessibilityMedium,
+            @"accessibilityLarge": UIContentSizeCategoryAccessibilityLarge,
+            @"accessibilityExtraLarge": UIContentSizeCategoryAccessibilityExtraLarge,
+            @"accessibilityExtraExtraLarge": UIContentSizeCategoryAccessibilityExtraExtraLarge,
+            @"accessibilityExtraExtraExtraLarge": UIContentSizeCategoryAccessibilityExtraExtraExtraLarge};
+  });
+  return map[JSCategory];
+}
+
+@interface RCTAccessibilityManager ()
+
+@property (nonatomic, copy) NSString *contentSizeCategory;
+@property (nonatomic, assign) CGFloat multiplier;
+
+@end
+
+@implementation RCTAccessibilityManager
+
+@synthesize bridge = _bridge;
+@synthesize multipliers = _multipliers;
+
+RCT_EXPORT_MODULE()
+
++ (BOOL)requiresMainQueueSetup
+{
+  return YES;
+}
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _multiplier = 1.0;
+
+    // TODO: can this be moved out of the startup path?
+    [[NSNotificationCenter defaultCenter] addObserver:self
+                                             selector:@selector(didReceiveNewContentSizeCategory:)
+                                                 name:UIContentSizeCategoryDidChangeNotification
+                                               object:nil];
+
+    [[NSNotificationCenter defaultCenter] addObserver:self
+                                             selector:@selector(didReceiveNewVoiceOverStatus:)
+                                                 name:UIAccessibilityVoiceOverStatusChanged
+                                               object:nil];
+
+    [[NSNotificationCenter defaultCenter] addObserver:self
+                                             selector:@selector(accessibilityAnnouncementDidFinish:)
+                                                 name:UIAccessibilityAnnouncementDidFinishNotification
+                                               object:nil];
+
+    self.contentSizeCategory = RCTSharedApplication().preferredContentSizeCategory;
+    _isVoiceOverEnabled = UIAccessibilityIsVoiceOverRunning();
+  }
+  return self;
+}
+
+- (void)dealloc
+{
+  [[NSNotificationCenter defaultCenter] removeObserver:self];
+}
+
+- (void)didReceiveNewContentSizeCategory:(NSNotification *)note
+{
+  self.contentSizeCategory = note.userInfo[UIContentSizeCategoryNewValueKey];
+}
+
+- (void)didReceiveNewVoiceOverStatus:(__unused NSNotification *)notification
+{
+  BOOL newIsVoiceOverEnabled = UIAccessibilityIsVoiceOverRunning();
+  if (_isVoiceOverEnabled != newIsVoiceOverEnabled) {
+    _isVoiceOverEnabled = newIsVoiceOverEnabled;
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+    [_bridge.eventDispatcher sendDeviceEventWithName:@"voiceOverDidChange"
+                                                body:@(_isVoiceOverEnabled)];
+#pragma clang diagnostic pop
+  }
+}
+
+- (void)accessibilityAnnouncementDidFinish:(__unused NSNotification *)notification
+{
+  NSDictionary *userInfo = notification.userInfo;
+  // Response dictionary to populate the event with.
+  NSDictionary *response = @{@"announcement": userInfo[UIAccessibilityAnnouncementKeyStringValue],
+                              @"success": userInfo[UIAccessibilityAnnouncementKeyWasSuccessful]};
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+  [_bridge.eventDispatcher sendDeviceEventWithName:@"announcementDidFinish"
+                                              body:response];
+#pragma clang diagnostic pop
+}
+
+- (void)setContentSizeCategory:(NSString *)contentSizeCategory
+{
+  if (_contentSizeCategory != contentSizeCategory) {
+    _contentSizeCategory = [contentSizeCategory copy];
+    [self invalidateMultiplier];
+  }
+}
+
+- (void)invalidateMultiplier
+{
+  self.multiplier = [self multiplierForContentSizeCategory:_contentSizeCategory];
+  [[NSNotificationCenter defaultCenter] postNotificationName:RCTAccessibilityManagerDidUpdateMultiplierNotification object:self];
+}
+
+- (CGFloat)multiplierForContentSizeCategory:(NSString *)category
+{
+  NSNumber *m = self.multipliers[category];
+  if (m.doubleValue <= 0.0) {
+    RCTLogError(@"Can't determinte multiplier for category %@. Using 1.0.", category);
+    m = @1.0;
+  }
+  return m.doubleValue;
+}
+
+- (void)setMultipliers:(NSDictionary<NSString *, NSNumber *> *)multipliers
+{
+  if (_multipliers != multipliers) {
+    _multipliers = [multipliers copy];
+    [self invalidateMultiplier];
+  }
+}
+
+- (NSDictionary<NSString *, NSNumber *> *)multipliers
+{
+  if (_multipliers == nil) {
+    _multipliers = @{UIContentSizeCategoryExtraSmall: @0.823,
+                     UIContentSizeCategorySmall: @0.882,
+                     UIContentSizeCategoryMedium: @0.941,
+                     UIContentSizeCategoryLarge: @1.0,
+                     UIContentSizeCategoryExtraLarge: @1.118,
+                     UIContentSizeCategoryExtraExtraLarge: @1.235,
+                     UIContentSizeCategoryExtraExtraExtraLarge: @1.353,
+                     UIContentSizeCategoryAccessibilityMedium: @1.786,
+                     UIContentSizeCategoryAccessibilityLarge: @2.143,
+                     UIContentSizeCategoryAccessibilityExtraLarge: @2.643,
+                     UIContentSizeCategoryAccessibilityExtraExtraLarge: @3.143,
+                     UIContentSizeCategoryAccessibilityExtraExtraExtraLarge: @3.571};
+  }
+  return _multipliers;
+}
+
+RCT_EXPORT_METHOD(setAccessibilityContentSizeMultipliers:(NSDictionary *)JSMultipliers)
+{
+  NSMutableDictionary<NSString *, NSNumber *> *multipliers = [NSMutableDictionary new];
+  for (NSString *__nonnull JSCategory in JSMultipliers) {
+    NSNumber *m = [RCTConvert NSNumber:JSMultipliers[JSCategory]];
+    NSString *UIKitCategory = UIKitCategoryFromJSCategory(JSCategory);
+    multipliers[UIKitCategory] = m;
+  }
+  self.multipliers = multipliers;
+}
+
+RCT_EXPORT_METHOD(setAccessibilityFocus:(nonnull NSNumber *)reactTag)
+{
+  dispatch_async(dispatch_get_main_queue(), ^{
+    UIView *view = [self.bridge.uiManager viewForReactTag:reactTag];
+    UIAccessibilityPostNotification(UIAccessibilityLayoutChangedNotification, view);
+  });
+}
+
+RCT_EXPORT_METHOD(announceForAccessibility:(NSString *)announcement)
+{
+  UIAccessibilityPostNotification(UIAccessibilityAnnouncementNotification, announcement);
+}
+
+RCT_EXPORT_METHOD(getMultiplier:(RCTResponseSenderBlock)callback)
+{
+  if (callback) {
+    callback(@[ @(self.multiplier) ]);
+  }
+}
+
+RCT_EXPORT_METHOD(getCurrentVoiceOverState:(RCTResponseSenderBlock)callback
+                  error:(__unused RCTResponseSenderBlock)error)
+{
+  callback(@[@(_isVoiceOverEnabled)]);
+}
+
+@end
+
+@implementation RCTBridge (RCTAccessibilityManager)
+
+- (RCTAccessibilityManager *)accessibilityManager
+{
+  return [self moduleForClass:[RCTAccessibilityManager class]];
+}
+
+@end

node_modules/react-native/React/Modules/RCTAlertManager.h

@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * 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/RCTBridgeModule.h>
+#import <React/RCTInvalidating.h>
+
+typedef NS_ENUM(NSInteger, RCTAlertViewStyle) {
+  RCTAlertViewStyleDefault = 0,
+  RCTAlertViewStyleSecureTextInput,
+  RCTAlertViewStylePlainTextInput,
+  RCTAlertViewStyleLoginAndPasswordInput
+};
+
+
+@interface RCTAlertManager : NSObject <RCTBridgeModule, RCTInvalidating>
+
+@end

node_modules/react-native/React/Modules/RCTAlertManager.m

@@ -0,0 +1,183 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTAlertManager.h"
+
+#import "RCTAssert.h"
+#import "RCTConvert.h"
+#import "RCTLog.h"
+#import "RCTUtils.h"
+
+@implementation RCTConvert (UIAlertViewStyle)
+
+RCT_ENUM_CONVERTER(RCTAlertViewStyle, (@{
+  @"default": @(RCTAlertViewStyleDefault),
+  @"secure-text": @(RCTAlertViewStyleSecureTextInput),
+  @"plain-text": @(RCTAlertViewStylePlainTextInput),
+  @"login-password": @(RCTAlertViewStyleLoginAndPasswordInput),
+}), RCTAlertViewStyleDefault, integerValue)
+
+@end
+
+@interface RCTAlertManager()
+
+@end
+
+@implementation RCTAlertManager
+{
+  NSHashTable *_alertControllers;
+}
+
+RCT_EXPORT_MODULE()
+
+- (dispatch_queue_t)methodQueue
+{
+  return dispatch_get_main_queue();
+}
+
+- (void)invalidate
+{
+  for (UIAlertController *alertController in _alertControllers) {
+    [alertController.presentingViewController dismissViewControllerAnimated:YES completion:nil];
+  }
+}
+
+/**
+ * @param {NSDictionary} args Dictionary of the form
+ *
+ *   @{
+ *     @"message": @"<Alert message>",
+ *     @"buttons": @[
+ *       @{@"<key1>": @"<title1>"},
+ *       @{@"<key2>": @"<title2>"},
+ *     ],
+ *     @"cancelButtonKey": @"<key2>",
+ *   }
+ * The key from the `buttons` dictionary is passed back in the callback on click.
+ * Buttons are displayed in the order they are specified.
+ */
+RCT_EXPORT_METHOD(alertWithArgs:(NSDictionary *)args
+                  callback:(RCTResponseSenderBlock)callback)
+{
+  NSString *title = [RCTConvert NSString:args[@"title"]];
+  NSString *message = [RCTConvert NSString:args[@"message"]];
+  RCTAlertViewStyle type = [RCTConvert RCTAlertViewStyle:args[@"type"]];
+  NSArray<NSDictionary *> *buttons = [RCTConvert NSDictionaryArray:args[@"buttons"]];
+  NSString *defaultValue = [RCTConvert NSString:args[@"defaultValue"]];
+  NSString *cancelButtonKey = [RCTConvert NSString:args[@"cancelButtonKey"]];
+  NSString *destructiveButtonKey = [RCTConvert NSString:args[@"destructiveButtonKey"]];
+  UIKeyboardType keyboardType = [RCTConvert UIKeyboardType:args[@"keyboardType"]];
+
+  if (!title && !message) {
+    RCTLogError(@"Must specify either an alert title, or message, or both");
+    return;
+  }
+
+  if (buttons.count == 0) {
+    if (type == RCTAlertViewStyleDefault) {
+      buttons = @[@{@"0": RCTUIKitLocalizedString(@"OK")}];
+      cancelButtonKey = @"0";
+    } else {
+      buttons = @[
+        @{@"0": RCTUIKitLocalizedString(@"OK")},
+        @{@"1": RCTUIKitLocalizedString(@"Cancel")},
+      ];
+      cancelButtonKey = @"1";
+    }
+  }
+
+  UIViewController *presentingController = RCTPresentedViewController();
+  if (presentingController == nil) {
+    RCTLogError(@"Tried to display alert view but there is no application window. args: %@", args);
+    return;
+  }
+
+  UIAlertController *alertController = [UIAlertController
+                                        alertControllerWithTitle:title
+                                        message:nil
+                                        preferredStyle:UIAlertControllerStyleAlert];
+  switch (type) {
+    case RCTAlertViewStylePlainTextInput: {
+      [alertController addTextFieldWithConfigurationHandler:^(UITextField *textField) {
+        textField.secureTextEntry = NO;
+        textField.text = defaultValue;
+        textField.keyboardType = keyboardType;
+      }];
+      break;
+    }
+    case RCTAlertViewStyleSecureTextInput: {
+      [alertController addTextFieldWithConfigurationHandler:^(UITextField *textField) {
+        textField.placeholder = RCTUIKitLocalizedString(@"Password");
+        textField.secureTextEntry = YES;
+        textField.text = defaultValue;
+        textField.keyboardType = keyboardType;
+      }];
+      break;
+    }
+    case RCTAlertViewStyleLoginAndPasswordInput: {
+      [alertController addTextFieldWithConfigurationHandler:^(UITextField *textField) {
+        textField.placeholder = RCTUIKitLocalizedString(@"Login");
+        textField.text = defaultValue;
+        textField.keyboardType = keyboardType;
+      }];
+      [alertController addTextFieldWithConfigurationHandler:^(UITextField *textField) {
+        textField.placeholder = RCTUIKitLocalizedString(@"Password");
+        textField.secureTextEntry = YES;
+      }];
+      break;
+    }
+    case RCTAlertViewStyleDefault:
+      break;
+  }
+
+  alertController.message = message;
+
+  for (NSDictionary<NSString *, id> *button in buttons) {
+    if (button.count != 1) {
+      RCTLogError(@"Button definitions should have exactly one key.");
+    }
+    NSString *buttonKey = button.allKeys.firstObject;
+    NSString *buttonTitle = [RCTConvert NSString:button[buttonKey]];
+    UIAlertActionStyle buttonStyle = UIAlertActionStyleDefault;
+    if ([buttonKey isEqualToString:cancelButtonKey]) {
+      buttonStyle = UIAlertActionStyleCancel;
+    } else if ([buttonKey isEqualToString:destructiveButtonKey]) {
+      buttonStyle = UIAlertActionStyleDestructive;
+    }
+    __weak UIAlertController *weakAlertController = alertController;
+    [alertController addAction:[UIAlertAction actionWithTitle:buttonTitle
+                                                        style:buttonStyle
+                                                      handler:^(__unused UIAlertAction *action) {
+      switch (type) {
+        case RCTAlertViewStylePlainTextInput:
+        case RCTAlertViewStyleSecureTextInput:
+          callback(@[buttonKey, [weakAlertController.textFields.firstObject text]]);
+          break;
+        case RCTAlertViewStyleLoginAndPasswordInput: {
+          NSDictionary<NSString *, NSString *> *loginCredentials = @{
+            @"login": [weakAlertController.textFields.firstObject text],
+            @"password": [weakAlertController.textFields.lastObject text]
+          };
+          callback(@[buttonKey, loginCredentials]);
+          break;
+        }
+        case RCTAlertViewStyleDefault:
+          callback(@[buttonKey]);
+          break;
+      }
+    }]];
+  }
+
+  if (!_alertControllers) {
+    _alertControllers = [NSHashTable weakObjectsHashTable];
+  }
+  [_alertControllers addObject:alertController];
+
+  [presentingController presentViewController:alertController animated:YES completion:nil];
+}
+
+@end

node_modules/react-native/React/Modules/RCTAppState.h

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTEventEmitter.h>
+
+@interface RCTAppState : RCTEventEmitter
+
+@end

node_modules/react-native/React/Modules/RCTAppState.m

@@ -0,0 +1,124 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTAppState.h"
+
+#import "RCTAssert.h"
+#import "RCTBridge.h"
+#import "RCTEventDispatcher.h"
+#import "RCTUtils.h"
+
+static NSString *RCTCurrentAppBackgroundState()
+{
+  static NSDictionary *states;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    states = @{
+      @(UIApplicationStateActive): @"active",
+      @(UIApplicationStateBackground): @"background"
+    };
+  });
+
+  if (RCTRunningInAppExtension()) {
+    return @"extension";
+  }
+
+  return states[@(RCTSharedApplication().applicationState)] ?: @"unknown";
+}
+
+@implementation RCTAppState
+{
+  NSString *_lastKnownState;
+}
+
+RCT_EXPORT_MODULE()
+
++ (BOOL)requiresMainQueueSetup
+{
+  return YES;
+}
+
+- (dispatch_queue_t)methodQueue
+{
+  return dispatch_get_main_queue();
+}
+
+- (NSDictionary *)constantsToExport
+{
+  return @{@"initialAppState": RCTCurrentAppBackgroundState()};
+}
+
+#pragma mark - Lifecycle
+
+- (NSArray<NSString *> *)supportedEvents
+{
+  return @[@"appStateDidChange", @"memoryWarning"];
+}
+
+- (void)startObserving
+{
+  for (NSString *name in @[UIApplicationDidBecomeActiveNotification,
+                           UIApplicationDidEnterBackgroundNotification,
+                           UIApplicationDidFinishLaunchingNotification,
+                           UIApplicationWillResignActiveNotification,
+                           UIApplicationWillEnterForegroundNotification]) {
+
+    [[NSNotificationCenter defaultCenter] addObserver:self
+                                             selector:@selector(handleAppStateDidChange:)
+                                                 name:name
+                                               object:nil];
+  }
+
+  [[NSNotificationCenter defaultCenter] addObserver:self
+                                           selector:@selector(handleMemoryWarning)
+                                               name:UIApplicationDidReceiveMemoryWarningNotification
+                                             object:nil];
+}
+
+- (void)stopObserving
+{
+  [[NSNotificationCenter defaultCenter] removeObserver:self];
+}
+
+#pragma mark - App Notification Methods
+
+- (void)handleMemoryWarning
+{
+  [self sendEventWithName:@"memoryWarning" body:nil];
+}
+
+- (void)handleAppStateDidChange:(NSNotification *)notification
+{
+  NSString *newState;
+
+  if ([notification.name isEqualToString:UIApplicationWillResignActiveNotification]) {
+    newState = @"inactive";
+  } else if ([notification.name isEqualToString:UIApplicationWillEnterForegroundNotification]) {
+    newState = @"background";
+  } else {
+    newState = RCTCurrentAppBackgroundState();
+  }
+
+  if (![newState isEqualToString:_lastKnownState]) {
+    _lastKnownState = newState;
+    [self sendEventWithName:@"appStateDidChange"
+                       body:@{@"app_state": _lastKnownState}];
+  }
+}
+
+#pragma mark - Public API
+
+/**
+ * Get the current background/foreground state of the app
+ */
+RCT_EXPORT_METHOD(getCurrentAppState:(RCTResponseSenderBlock)callback
+                  error:(__unused RCTResponseSenderBlock)error)
+{
+  callback(@[@{@"app_state": RCTCurrentAppBackgroundState()}]);
+}
+
+@end

node_modules/react-native/React/Modules/RCTAsyncLocalStorage.h

@@ -0,0 +1,34 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTBridgeModule.h>
+#import <React/RCTInvalidating.h>
+
+/**
+ * A simple, asynchronous, persistent, key-value storage system designed as a
+ * backend to the AsyncStorage JS module, which is modeled after LocalStorage.
+ *
+ * Current implementation stores small values in serialized dictionary and
+ * larger values in separate files. Since we use a serial file queue
+ * `RKFileQueue`, reading/writing from multiple threads should be perceived as
+ * being atomic, unless someone bypasses the `RCTAsyncLocalStorage` API.
+ *
+ * Keys and values must always be strings or an error is returned.
+ */
+@interface RCTAsyncLocalStorage : NSObject <RCTBridgeModule,RCTInvalidating>
+
+@property (nonatomic, assign) BOOL clearOnInvalidate;
+
+@property (nonatomic, readonly, getter=isValid) BOOL valid;
+
+// Clear the RCTAsyncLocalStorage data from native code
+- (void)clearAllData;
+
+// For clearing data when the bridge may not exist, e.g. when logging out.
++ (void)clearAllData;
+
+@end

node_modules/react-native/React/Modules/RCTAsyncLocalStorage.m

@@ -0,0 +1,460 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTAsyncLocalStorage.h"
+
+#import <Foundation/Foundation.h>
+
+#import <CommonCrypto/CommonCryptor.h>
+#import <CommonCrypto/CommonDigest.h>
+
+#import "RCTConvert.h"
+#import "RCTLog.h"
+#import "RCTUtils.h"
+
+static NSString *const RCTStorageDirectory = @"RCTAsyncLocalStorage_V1";
+static NSString *const RCTManifestFileName = @"manifest.json";
+static const NSUInteger RCTInlineValueThreshold = 1024;
+
+#pragma mark - Static helper functions
+
+static NSDictionary *RCTErrorForKey(NSString *key)
+{
+  if (![key isKindOfClass:[NSString class]]) {
+    return RCTMakeAndLogError(@"Invalid key - must be a string.  Key: ", key, @{@"key": key});
+  } else if (key.length < 1) {
+    return RCTMakeAndLogError(@"Invalid key - must be at least one character.  Key: ", key, @{@"key": key});
+  } else {
+    return nil;
+  }
+}
+
+static void RCTAppendError(NSDictionary *error, NSMutableArray<NSDictionary *> **errors)
+{
+  if (error && errors) {
+    if (!*errors) {
+      *errors = [NSMutableArray new];
+    }
+    [*errors addObject:error];
+  }
+}
+
+static NSString *RCTReadFile(NSString *filePath, NSString *key, NSDictionary **errorOut)
+{
+  if ([[NSFileManager defaultManager] fileExistsAtPath:filePath]) {
+    NSError *error;
+    NSStringEncoding encoding;
+    NSString *entryString = [NSString stringWithContentsOfFile:filePath usedEncoding:&encoding error:&error];
+    NSDictionary *extraData = @{@"key": RCTNullIfNil(key)};
+
+    if (error) {
+      if (errorOut) *errorOut = RCTMakeError(@"Failed to read storage file.", error, extraData);
+      return nil;
+    }
+
+    if (encoding != NSUTF8StringEncoding) {
+      if (errorOut) *errorOut = RCTMakeError(@"Incorrect encoding of storage file: ", @(encoding), extraData);
+      return nil;
+    }
+    return entryString;
+  }
+
+  return nil;
+}
+
+static NSString *RCTGetStorageDirectory()
+{
+  static NSString *storageDirectory = nil;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+#if TARGET_OS_TV
+    storageDirectory = NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES).firstObject;
+#else
+    storageDirectory = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES).firstObject;
+#endif
+    storageDirectory = [storageDirectory stringByAppendingPathComponent:RCTStorageDirectory];
+  });
+  return storageDirectory;
+}
+
+static NSString *RCTGetManifestFilePath()
+{
+  static NSString *manifestFilePath = nil;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    manifestFilePath = [RCTGetStorageDirectory() stringByAppendingPathComponent:RCTManifestFileName];
+  });
+  return manifestFilePath;
+}
+
+// Only merges objects - all other types are just clobbered (including arrays)
+static BOOL RCTMergeRecursive(NSMutableDictionary *destination, NSDictionary *source)
+{
+  BOOL modified = NO;
+  for (NSString *key in source) {
+    id sourceValue = source[key];
+    id destinationValue = destination[key];
+    if ([sourceValue isKindOfClass:[NSDictionary class]]) {
+      if ([destinationValue isKindOfClass:[NSDictionary class]]) {
+        if ([destinationValue classForCoder] != [NSMutableDictionary class]) {
+          destinationValue = [destinationValue mutableCopy];
+        }
+        if (RCTMergeRecursive(destinationValue, sourceValue)) {
+          destination[key] = destinationValue;
+          modified = YES;
+        }
+      } else {
+        destination[key] = [sourceValue copy];
+        modified = YES;
+      }
+    } else if (![source isEqual:destinationValue]) {
+      destination[key] = [sourceValue copy];
+      modified = YES;
+    }
+  }
+  return modified;
+}
+
+static dispatch_queue_t RCTGetMethodQueue()
+{
+  // We want all instances to share the same queue since they will be reading/writing the same files.
+  static dispatch_queue_t queue;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    queue = dispatch_queue_create("com.facebook.react.AsyncLocalStorageQueue", DISPATCH_QUEUE_SERIAL);
+  });
+  return queue;
+}
+
+static NSCache *RCTGetCache()
+{
+  // We want all instances to share the same cache since they will be reading/writing the same files.
+  static NSCache *cache;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    cache = [NSCache new];
+    cache.totalCostLimit = 2 * 1024 * 1024; // 2MB
+
+    // Clear cache in the event of a memory warning
+    [[NSNotificationCenter defaultCenter] addObserverForName:UIApplicationDidReceiveMemoryWarningNotification object:nil queue:nil usingBlock:^(__unused NSNotification *note) {
+      [cache removeAllObjects];
+    }];
+  });
+  return cache;
+}
+
+static BOOL RCTHasCreatedStorageDirectory = NO;
+static NSDictionary *RCTDeleteStorageDirectory()
+{
+  NSError *error;
+  [[NSFileManager defaultManager] removeItemAtPath:RCTGetStorageDirectory() error:&error];
+  RCTHasCreatedStorageDirectory = NO;
+  return error ? RCTMakeError(@"Failed to delete storage directory.", error, nil) : nil;
+}
+
+#pragma mark - RCTAsyncLocalStorage
+
+@implementation RCTAsyncLocalStorage
+{
+  BOOL _haveSetup;
+  // The manifest is a dictionary of all keys with small values inlined.  Null values indicate values that are stored
+  // in separate files (as opposed to nil values which don't exist).  The manifest is read off disk at startup, and
+  // written to disk after all mutations.
+  NSMutableDictionary<NSString *, NSString *> *_manifest;
+}
+
+RCT_EXPORT_MODULE()
+
+- (dispatch_queue_t)methodQueue
+{
+  return RCTGetMethodQueue();
+}
+
+- (void)clearAllData
+{
+  dispatch_async(RCTGetMethodQueue(), ^{
+    [self->_manifest removeAllObjects];
+    [RCTGetCache() removeAllObjects];
+    RCTDeleteStorageDirectory();
+  });
+}
+
++ (void)clearAllData
+{
+  dispatch_async(RCTGetMethodQueue(), ^{
+    [RCTGetCache() removeAllObjects];
+    RCTDeleteStorageDirectory();
+  });
+}
+
+- (void)invalidate
+{
+  if (_clearOnInvalidate) {
+    [RCTGetCache() removeAllObjects];
+    RCTDeleteStorageDirectory();
+  }
+  _clearOnInvalidate = NO;
+  [_manifest removeAllObjects];
+  _haveSetup = NO;
+}
+
+- (BOOL)isValid
+{
+  return _haveSetup;
+}
+
+- (void)dealloc
+{
+  [self invalidate];
+}
+
+- (NSString *)_filePathForKey:(NSString *)key
+{
+  NSString *safeFileName = RCTMD5Hash(key);
+  return [RCTGetStorageDirectory() stringByAppendingPathComponent:safeFileName];
+}
+
+- (NSDictionary *)_ensureSetup
+{
+  RCTAssertThread(RCTGetMethodQueue(), @"Must be executed on storage thread");
+
+#if TARGET_OS_TV
+  RCTLogWarn(@"Persistent storage is not supported on tvOS, your data may be removed at any point.");
+#endif
+
+  NSError *error = nil;
+  if (!RCTHasCreatedStorageDirectory) {
+    [[NSFileManager defaultManager] createDirectoryAtPath:RCTGetStorageDirectory()
+                              withIntermediateDirectories:YES
+                                               attributes:nil
+                                                    error:&error];
+    if (error) {
+      return RCTMakeError(@"Failed to create storage directory.", error, nil);
+    }
+    RCTHasCreatedStorageDirectory = YES;
+  }
+  if (!_haveSetup) {
+    NSDictionary *errorOut;
+    NSString *serialized = RCTReadFile(RCTGetManifestFilePath(), RCTManifestFileName, &errorOut);
+    _manifest = serialized ? RCTJSONParseMutable(serialized, &error) : [NSMutableDictionary new];
+    if (error) {
+      RCTLogWarn(@"Failed to parse manifest - creating new one.\n\n%@", error);
+      _manifest = [NSMutableDictionary new];
+    }
+    _haveSetup = YES;
+  }
+  return nil;
+}
+
+- (NSDictionary *)_writeManifest:(NSMutableArray<NSDictionary *> **)errors
+{
+  NSError *error;
+  NSString *serialized = RCTJSONStringify(_manifest, &error);
+  [serialized writeToFile:RCTGetManifestFilePath() atomically:YES encoding:NSUTF8StringEncoding error:&error];
+  NSDictionary *errorOut;
+  if (error) {
+    errorOut = RCTMakeError(@"Failed to write manifest file.", error, nil);
+    RCTAppendError(errorOut, errors);
+  }
+  return errorOut;
+}
+
+- (NSDictionary *)_appendItemForKey:(NSString *)key
+                            toArray:(NSMutableArray<NSArray<NSString *> *> *)result
+{
+  NSDictionary *errorOut = RCTErrorForKey(key);
+  if (errorOut) {
+    return errorOut;
+  }
+  NSString *value = [self _getValueForKey:key errorOut:&errorOut];
+  [result addObject:@[key, RCTNullIfNil(value)]]; // Insert null if missing or failure.
+  return errorOut;
+}
+
+- (NSString *)_getValueForKey:(NSString *)key errorOut:(NSDictionary **)errorOut
+{
+  NSString *value = _manifest[key]; // nil means missing, null means there may be a data file, else: NSString
+  if (value == (id)kCFNull) {
+    value = [RCTGetCache() objectForKey:key];
+    if (!value) {
+      NSString *filePath = [self _filePathForKey:key];
+      value = RCTReadFile(filePath, key, errorOut);
+      if (value) {
+        [RCTGetCache() setObject:value forKey:key cost:value.length];
+      } else {
+        // file does not exist after all, so remove from manifest (no need to save
+        // manifest immediately though, as cost of checking again next time is negligible)
+        [_manifest removeObjectForKey:key];
+      }
+    }
+  }
+  return value;
+}
+
+- (NSDictionary *)_writeEntry:(NSArray<NSString *> *)entry changedManifest:(BOOL *)changedManifest
+{
+  if (entry.count != 2) {
+    return RCTMakeAndLogError(@"Entries must be arrays of the form [key: string, value: string], got: ", entry, nil);
+  }
+  NSString *key = entry[0];
+  NSDictionary *errorOut = RCTErrorForKey(key);
+  if (errorOut) {
+    return errorOut;
+  }
+  NSString *value = entry[1];
+  NSString *filePath = [self _filePathForKey:key];
+  NSError *error;
+  if (value.length <= RCTInlineValueThreshold) {
+    if (_manifest[key] == (id)kCFNull) {
+      // If the value already existed but wasn't inlined, remove the old file.
+      [[NSFileManager defaultManager] removeItemAtPath:filePath error:nil];
+      [RCTGetCache() removeObjectForKey:key];
+    }
+    *changedManifest = YES;
+    _manifest[key] = value;
+    return nil;
+  }
+  [value writeToFile:filePath atomically:YES encoding:NSUTF8StringEncoding error:&error];
+  [RCTGetCache() setObject:value forKey:key cost:value.length];
+  if (error) {
+    errorOut = RCTMakeError(@"Failed to write value.", error, @{@"key": key});
+  } else if (_manifest[key] != (id)kCFNull) {
+    *changedManifest = YES;
+    _manifest[key] = (id)kCFNull;
+  }
+  return errorOut;
+}
+
+#pragma mark - Exported JS Functions
+
+RCT_EXPORT_METHOD(multiGet:(NSArray<NSString *> *)keys
+                  callback:(RCTResponseSenderBlock)callback)
+{
+  NSDictionary *errorOut = [self _ensureSetup];
+  if (errorOut) {
+    callback(@[@[errorOut], (id)kCFNull]);
+    return;
+  }
+  NSMutableArray<NSDictionary *> *errors;
+  NSMutableArray<NSArray<NSString *> *> *result = [[NSMutableArray alloc] initWithCapacity:keys.count];
+  for (NSString *key in keys) {
+    id keyError;
+    id value = [self _getValueForKey:key errorOut:&keyError];
+    [result addObject:@[key, RCTNullIfNil(value)]];
+    RCTAppendError(keyError, &errors);
+  }
+  callback(@[RCTNullIfNil(errors), result]);
+}
+
+RCT_EXPORT_METHOD(multiSet:(NSArray<NSArray<NSString *> *> *)kvPairs
+                  callback:(RCTResponseSenderBlock)callback)
+{
+  NSDictionary *errorOut = [self _ensureSetup];
+  if (errorOut) {
+    callback(@[@[errorOut]]);
+    return;
+  }
+  BOOL changedManifest = NO;
+  NSMutableArray<NSDictionary *> *errors;
+  for (NSArray<NSString *> *entry in kvPairs) {
+    NSDictionary *keyError = [self _writeEntry:entry changedManifest:&changedManifest];
+    RCTAppendError(keyError, &errors);
+  }
+  if (changedManifest) {
+    [self _writeManifest:&errors];
+  }
+  callback(@[RCTNullIfNil(errors)]);
+}
+
+RCT_EXPORT_METHOD(multiMerge:(NSArray<NSArray<NSString *> *> *)kvPairs
+                    callback:(RCTResponseSenderBlock)callback)
+{
+  NSDictionary *errorOut = [self _ensureSetup];
+  if (errorOut) {
+    callback(@[@[errorOut]]);
+    return;
+  }
+  BOOL changedManifest = NO;
+  NSMutableArray<NSDictionary *> *errors;
+  for (__strong NSArray<NSString *> *entry in kvPairs) {
+    NSDictionary *keyError;
+    NSString *value = [self _getValueForKey:entry[0] errorOut:&keyError];
+    if (!keyError) {
+      if (value) {
+        NSError *jsonError;
+        NSMutableDictionary *mergedVal = RCTJSONParseMutable(value, &jsonError);
+        if (RCTMergeRecursive(mergedVal, RCTJSONParse(entry[1], &jsonError))) {
+          entry = @[entry[0], RCTNullIfNil(RCTJSONStringify(mergedVal, NULL))];
+        }
+        if (jsonError) {
+          keyError = RCTJSErrorFromNSError(jsonError);
+        }
+      }
+      if (!keyError) {
+        keyError = [self _writeEntry:entry changedManifest:&changedManifest];
+      }
+    }
+    RCTAppendError(keyError, &errors);
+  }
+  if (changedManifest) {
+    [self _writeManifest:&errors];
+  }
+  callback(@[RCTNullIfNil(errors)]);
+}
+
+RCT_EXPORT_METHOD(multiRemove:(NSArray<NSString *> *)keys
+                  callback:(RCTResponseSenderBlock)callback)
+{
+  NSDictionary *errorOut = [self _ensureSetup];
+  if (errorOut) {
+    callback(@[@[errorOut]]);
+    return;
+  }
+  NSMutableArray<NSDictionary *> *errors;
+  BOOL changedManifest = NO;
+  for (NSString *key in keys) {
+    NSDictionary *keyError = RCTErrorForKey(key);
+    if (!keyError) {
+      if (_manifest[key] == (id)kCFNull) {
+        NSString *filePath = [self _filePathForKey:key];
+        [[NSFileManager defaultManager] removeItemAtPath:filePath error:nil];
+        [RCTGetCache() removeObjectForKey:key];
+        // remove the key from manifest, but no need to mark as changed just for
+        // this, as the cost of checking again next time is negligible.
+        [_manifest removeObjectForKey:key];
+      } else if (_manifest[key]) {
+        changedManifest = YES;
+        [_manifest removeObjectForKey:key];
+      }
+    }
+    RCTAppendError(keyError, &errors);
+  }
+  if (changedManifest) {
+    [self _writeManifest:&errors];
+  }
+  callback(@[RCTNullIfNil(errors)]);
+}
+
+RCT_EXPORT_METHOD(clear:(RCTResponseSenderBlock)callback)
+{
+  [_manifest removeAllObjects];
+  [RCTGetCache() removeAllObjects];
+  NSDictionary *error = RCTDeleteStorageDirectory();
+  callback(@[RCTNullIfNil(error)]);
+}
+
+RCT_EXPORT_METHOD(getAllKeys:(RCTResponseSenderBlock)callback)
+{
+  NSDictionary *errorOut = [self _ensureSetup];
+  if (errorOut) {
+    callback(@[errorOut, (id)kCFNull]);
+  } else {
+    callback(@[(id)kCFNull, _manifest.allKeys]);
+  }
+}
+
+@end

node_modules/react-native/React/Modules/RCTClipboard.h

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTBridgeModule.h>
+
+@interface RCTClipboard : NSObject <RCTBridgeModule>
+
+@end

node_modules/react-native/React/Modules/RCTClipboard.m

@@ -0,0 +1,35 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTClipboard.h"
+
+#import <UIKit/UIKit.h>
+
+@implementation RCTClipboard
+
+RCT_EXPORT_MODULE()
+
+- (dispatch_queue_t)methodQueue
+{
+  return dispatch_get_main_queue();
+}
+
+
+RCT_EXPORT_METHOD(setString:(NSString *)content)
+{
+  UIPasteboard *clipboard = [UIPasteboard generalPasteboard];
+  clipboard.string = (content ? : @"");
+}
+
+RCT_EXPORT_METHOD(getString:(RCTPromiseResolveBlock)resolve
+                  rejecter:(__unused RCTPromiseRejectBlock)reject)
+{
+  UIPasteboard *clipboard = [UIPasteboard generalPasteboard];
+  resolve((clipboard.string ? : @""));
+}
+
+@end

node_modules/react-native/React/Modules/RCTDevSettings.h

@@ -0,0 +1,104 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTBridge.h>
+#import <React/RCTDefines.h>
+
+@protocol RCTPackagerClientMethod;
+
+/**
+ * An abstraction for a key-value store to manage RCTDevSettings behavior.
+ * The default implementation persists settings using NSUserDefaults.
+ */
+@protocol RCTDevSettingsDataSource <NSObject>
+
+/**
+ * Updates the setting with the given key to the given value.
+ * How the data source's state changes depends on the implementation.
+ */
+- (void)updateSettingWithValue:(id)value forKey:(NSString *)key;
+
+/**
+ * Returns the value for the setting with the given key.
+ */
+- (id)settingForKey:(NSString *)key;
+
+@end
+
+@interface RCTDevSettings : NSObject
+
+- (instancetype)initWithDataSource:(id<RCTDevSettingsDataSource>)dataSource;
+
+@property (nonatomic, readonly) BOOL isHotLoadingAvailable;
+@property (nonatomic, readonly) BOOL isLiveReloadAvailable;
+@property (nonatomic, readonly) BOOL isRemoteDebuggingAvailable;
+@property (nonatomic, readonly) BOOL isNuclideDebuggingAvailable;
+@property (nonatomic, readonly) BOOL isJSCSamplingProfilerAvailable;
+
+/**
+ * Whether the bridge is connected to a remote JS executor.
+ */
+@property (nonatomic, assign) BOOL isDebuggingRemotely;
+
+/*
+ * Whether shaking will show RCTDevMenu. The menu is enabled by default if RCT_DEV=1, but
+ * you may wish to disable it so that you can provide your own shake handler.
+ */
+@property (nonatomic, assign) BOOL isShakeToShowDevMenuEnabled;
+
+/**
+ * Whether performance profiling is enabled.
+ */
+@property (nonatomic, assign, setter=setProfilingEnabled:) BOOL isProfilingEnabled;
+
+/**
+ * Whether automatic polling for JS code changes is enabled. Only applicable when
+ * running the app from a server.
+ */
+@property (nonatomic, assign, setter=setLiveReloadEnabled:) BOOL isLiveReloadEnabled;
+
+/**
+ * Whether hot loading is enabled.
+ */
+@property (nonatomic, assign, setter=setHotLoadingEnabled:) BOOL isHotLoadingEnabled;
+
+/**
+ * Toggle the element inspector.
+ */
+- (void)toggleElementInspector;
+
+/**
+ * Toggle JSC's sampling profiler.
+ */
+- (void)toggleJSCSamplingProfiler;
+
+/**
+ * Enables starting of profiling sampler on launch
+ */
+@property (nonatomic, assign) BOOL startSamplingProfilerOnLaunch;
+
+/**
+ * Whether the element inspector is visible.
+ */
+@property (nonatomic, readonly) BOOL isElementInspectorShown;
+
+/**
+ * Whether the performance monitor is visible.
+ */
+@property (nonatomic, assign) BOOL isPerfMonitorShown;
+
+#if RCT_DEV
+- (void)addHandler:(id<RCTPackagerClientMethod>)handler forPackagerMethod:(NSString *)name __deprecated_msg("Use RCTPackagerConnection directly instead");
+#endif
+
+@end
+
+@interface RCTBridge (RCTDevSettings)
+
+@property (nonatomic, readonly) RCTDevSettings *devSettings;
+
+@end

node_modules/react-native/React/Modules/RCTDevSettings.mm

@@ -0,0 +1,572 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTDevSettings.h"
+
+#import <objc/runtime.h>
+
+#import <JavaScriptCore/JavaScriptCore.h>
+
+#import <jschelpers/JavaScriptCore.h>
+
+#import "RCTBridge+Private.h"
+#import "RCTBridgeModule.h"
+#import "RCTEventDispatcher.h"
+#import "RCTJSCSamplingProfiler.h"
+#import "RCTLog.h"
+#import "RCTPackagerClient.h"
+#import "RCTProfile.h"
+#import "RCTUtils.h"
+
+static NSString *const kRCTDevSettingProfilingEnabled = @"profilingEnabled";
+static NSString *const kRCTDevSettingHotLoadingEnabled = @"hotLoadingEnabled";
+static NSString *const kRCTDevSettingLiveReloadEnabled = @"liveReloadEnabled";
+static NSString *const kRCTDevSettingIsInspectorShown = @"showInspector";
+static NSString *const kRCTDevSettingIsDebuggingRemotely = @"isDebuggingRemotely";
+static NSString *const kRCTDevSettingExecutorOverrideClass = @"executor-override";
+static NSString *const kRCTDevSettingShakeToShowDevMenu = @"shakeToShow";
+static NSString *const kRCTDevSettingIsPerfMonitorShown = @"RCTPerfMonitorKey";
+static NSString *const kRCTDevSettingStartSamplingProfilerOnLaunch = @"startSamplingProfilerOnLaunch";
+
+static NSString *const kRCTDevSettingsUserDefaultsKey = @"RCTDevMenu";
+
+#if ENABLE_PACKAGER_CONNECTION
+#import "RCTPackagerConnection.h"
+#endif
+
+#if RCT_ENABLE_INSPECTOR
+#import "RCTInspectorDevServerHelper.h"
+#import <jschelpers/JSCWrapper.h>
+#endif
+
+#if RCT_DEV
+
+@interface RCTDevSettingsUserDefaultsDataSource : NSObject <RCTDevSettingsDataSource>
+
+@end
+
+@implementation RCTDevSettingsUserDefaultsDataSource {
+  NSMutableDictionary *_settings;
+  NSUserDefaults *_userDefaults;
+}
+
+- (instancetype)init
+{
+  return [self initWithDefaultValues:nil];
+}
+
+- (instancetype)initWithDefaultValues:(NSDictionary *)defaultValues
+{
+  if (self = [super init]) {
+    _userDefaults = [NSUserDefaults standardUserDefaults];
+    if (defaultValues) {
+      [self _reloadWithDefaults:defaultValues];
+    }
+  }
+  return self;
+}
+
+- (void)updateSettingWithValue:(id)value forKey:(NSString *)key
+{
+  RCTAssert((key != nil), @"%@", [NSString stringWithFormat:@"%@: Tried to update nil key", [self class]]);
+
+  id currentValue = [self settingForKey:key];
+  if (currentValue == value || [currentValue isEqual:value]) {
+    return;
+  }
+  if (value) {
+    _settings[key] = value;
+  } else {
+    [_settings removeObjectForKey:key];
+  }
+  [_userDefaults setObject:_settings forKey:kRCTDevSettingsUserDefaultsKey];
+}
+
+- (id)settingForKey:(NSString *)key
+{
+  return _settings[key];
+}
+
+- (void)_reloadWithDefaults:(NSDictionary *)defaultValues
+{
+  NSDictionary *existingSettings = [_userDefaults objectForKey:kRCTDevSettingsUserDefaultsKey];
+  _settings = existingSettings ? [existingSettings mutableCopy] : [NSMutableDictionary dictionary];
+  for (NSString *key in [defaultValues keyEnumerator]) {
+    if (!_settings[key]) {
+      _settings[key] = defaultValues[key];
+    }
+  }
+  [_userDefaults setObject:_settings forKey:kRCTDevSettingsUserDefaultsKey];
+}
+
+@end
+
+@interface RCTDevSettings () <RCTBridgeModule, RCTInvalidating>
+{
+  NSURLSessionDataTask *_liveReloadUpdateTask;
+  NSURL *_liveReloadURL;
+  BOOL _isJSLoaded;
+#if ENABLE_PACKAGER_CONNECTION
+  RCTHandlerToken _reloadToken;
+  RCTHandlerToken _pokeSamplingProfilerToken;
+#endif
+}
+
+@property (nonatomic, strong) Class executorClass;
+@property (nonatomic, readwrite, strong) id<RCTDevSettingsDataSource> dataSource;
+
+@end
+
+@implementation RCTDevSettings
+
+@synthesize bridge = _bridge;
+
+RCT_EXPORT_MODULE()
+
++ (BOOL)requiresMainQueueSetup
+{
+  return YES; // RCT_DEV-only
+}
+
+- (instancetype)init
+{
+  // default behavior is to use NSUserDefaults
+  NSDictionary *defaultValues = @{
+    kRCTDevSettingShakeToShowDevMenu: @YES,
+  };
+  RCTDevSettingsUserDefaultsDataSource *dataSource = [[RCTDevSettingsUserDefaultsDataSource alloc] initWithDefaultValues:defaultValues];
+  return [self initWithDataSource:dataSource];
+}
+
+- (instancetype)initWithDataSource:(id<RCTDevSettingsDataSource>)dataSource
+{
+  if (self = [super init]) {
+    _dataSource = dataSource;
+
+    [[NSNotificationCenter defaultCenter] addObserver:self
+                                             selector:@selector(jsLoaded:)
+                                                 name:RCTJavaScriptDidLoadNotification
+                                               object:nil];
+
+    // Delay setup until after Bridge init
+    dispatch_async(dispatch_get_main_queue(), ^{
+      [self _synchronizeAllSettings];
+    });
+  }
+  return self;
+}
+
+- (void)setBridge:(RCTBridge *)bridge
+{
+  RCTAssert(_bridge == nil, @"RCTDevSettings module should not be reused");
+  _bridge = bridge;
+
+#if ENABLE_PACKAGER_CONNECTION
+  RCTBridge *__weak weakBridge = bridge;
+  _reloadToken =
+  [[RCTPackagerConnection sharedPackagerConnection]
+   addNotificationHandler:^(id params) {
+     if (params != (id)kCFNull && [params[@"debug"] boolValue]) {
+       weakBridge.executorClass = objc_lookUpClass("RCTWebSocketExecutor");
+     }
+     [weakBridge reload];
+   }
+   queue:dispatch_get_main_queue()
+   forMethod:@"reload"];
+
+  _pokeSamplingProfilerToken =
+  [[RCTPackagerConnection sharedPackagerConnection]
+   addRequestHandler:^(NSDictionary<NSString *, id> *params, RCTPackagerClientResponder *responder) {
+     pokeSamplingProfiler(weakBridge, responder);
+   }
+   queue:dispatch_get_main_queue()
+   forMethod:@"pokeSamplingProfiler"];
+#endif
+
+#if RCT_ENABLE_INSPECTOR
+  // we need this dispatch back to the main thread because even though this
+  // is executed on the main thread, at this point the bridge is not yet
+  // finished with its initialisation. But it does finish by the time it
+  // relinquishes control of the main thread, so only queue on the JS thread
+  // after the current main thread operation is done.
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [bridge dispatchBlock:^{
+      [RCTInspectorDevServerHelper connectWithBundleURL:bridge.bundleURL];
+    } queue:RCTJSThread];
+  });
+#endif
+}
+
+static void pokeSamplingProfiler(RCTBridge *const bridge, RCTPackagerClientResponder *const responder)
+{
+  if (!bridge) {
+    [responder respondWithError:@"The bridge is nil. Try again."];
+    return;
+  }
+
+  JSGlobalContextRef globalContext = bridge.jsContextRef;
+  if (!JSC_JSSamplingProfilerEnabled(globalContext)) {
+    [responder respondWithError:@"The JSSamplingProfiler is disabled. See 'iOS specific setup' section here https://fburl.com/u4lw7xeq for some help"];
+    return;
+  }
+
+  // JSPokeSamplingProfiler() toggles the profiling process
+  JSValueRef jsResult = JSC_JSPokeSamplingProfiler(globalContext);
+  if (JSC_JSValueGetType(globalContext, jsResult) == kJSTypeNull) {
+    [responder respondWithResult:@"started"];
+  } else {
+    JSContext *context = [JSC_JSContext(globalContext) contextWithJSGlobalContextRef:globalContext];
+    NSString *results = [[JSC_JSValue(globalContext) valueWithJSValueRef:jsResult inContext:context] toObject];
+    [responder respondWithResult:results];
+  }
+}
+
+- (dispatch_queue_t)methodQueue
+{
+  return dispatch_get_main_queue();
+}
+
+- (void)invalidate
+{
+  [_liveReloadUpdateTask cancel];
+#if ENABLE_PACKAGER_CONNECTION
+  [[RCTPackagerConnection sharedPackagerConnection] removeHandler:_reloadToken];
+  [[RCTPackagerConnection sharedPackagerConnection] removeHandler:_pokeSamplingProfilerToken];
+#endif
+  [[NSNotificationCenter defaultCenter] removeObserver:self];
+}
+
+- (void)_updateSettingWithValue:(id)value forKey:(NSString *)key
+{
+  [_dataSource updateSettingWithValue:value forKey:key];
+}
+
+- (id)settingForKey:(NSString *)key
+{
+  return [_dataSource settingForKey:key];
+}
+
+- (BOOL)isNuclideDebuggingAvailable
+{
+#if RCT_ENABLE_INSPECTOR
+  return _bridge.isInspectable;
+#else
+  return false;
+#endif // RCT_ENABLE_INSPECTOR
+}
+
+- (BOOL)isRemoteDebuggingAvailable
+{
+  Class jsDebuggingExecutorClass = objc_lookUpClass("RCTWebSocketExecutor");
+  return (jsDebuggingExecutorClass != nil);
+}
+
+- (BOOL)isHotLoadingAvailable
+{
+  return _bridge.bundleURL && !_bridge.bundleURL.fileURL; // Only works when running from server
+}
+
+- (BOOL)isLiveReloadAvailable
+{
+  return (_liveReloadURL != nil);
+}
+
+- (BOOL)isJSCSamplingProfilerAvailable
+{
+  return JSC_JSSamplingProfilerEnabled(_bridge.jsContextRef);
+}
+
+RCT_EXPORT_METHOD(reload)
+{
+  [_bridge reload];
+}
+
+RCT_EXPORT_METHOD(setIsShakeToShowDevMenuEnabled:(BOOL)enabled)
+{
+  [self _updateSettingWithValue:@(enabled) forKey:kRCTDevSettingShakeToShowDevMenu];
+}
+
+- (BOOL)isShakeToShowDevMenuEnabled
+{
+  return [[self settingForKey:kRCTDevSettingShakeToShowDevMenu] boolValue];
+}
+
+RCT_EXPORT_METHOD(setIsDebuggingRemotely:(BOOL)enabled)
+{
+  [self _updateSettingWithValue:@(enabled) forKey:kRCTDevSettingIsDebuggingRemotely];
+  [self _remoteDebugSettingDidChange];
+}
+
+- (BOOL)isDebuggingRemotely
+{
+  return [[self settingForKey:kRCTDevSettingIsDebuggingRemotely] boolValue];
+}
+
+- (void)_remoteDebugSettingDidChange
+{
+  // This value is passed as a command-line argument, so fall back to reading from NSUserDefaults directly
+  NSString *executorOverride = [[NSUserDefaults standardUserDefaults] stringForKey:kRCTDevSettingExecutorOverrideClass];
+  Class executorOverrideClass = executorOverride ? NSClassFromString(executorOverride) : nil;
+  if (executorOverrideClass) {
+    self.executorClass = executorOverrideClass;
+  } else {
+    BOOL enabled = self.isRemoteDebuggingAvailable && self.isDebuggingRemotely;
+    self.executorClass = enabled ? objc_getClass("RCTWebSocketExecutor") : nil;
+  }
+}
+
+RCT_EXPORT_METHOD(setProfilingEnabled:(BOOL)enabled)
+{
+  [self _updateSettingWithValue:@(enabled) forKey:kRCTDevSettingProfilingEnabled];
+  [self _profilingSettingDidChange];
+}
+
+- (BOOL)isProfilingEnabled
+{
+  return [[self settingForKey:kRCTDevSettingProfilingEnabled] boolValue];
+}
+
+- (void)_profilingSettingDidChange
+{
+  BOOL enabled = self.isProfilingEnabled;
+  if (_liveReloadURL && enabled != RCTProfileIsProfiling()) {
+    if (enabled) {
+      [_bridge startProfiling];
+    } else {
+      [_bridge stopProfiling:^(NSData *logData) {
+        RCTProfileSendResult(self->_bridge, @"systrace", logData);
+      }];
+    }
+  }
+}
+
+RCT_EXPORT_METHOD(setLiveReloadEnabled:(BOOL)enabled)
+{
+  [self _updateSettingWithValue:@(enabled) forKey:kRCTDevSettingLiveReloadEnabled];
+  [self _liveReloadSettingDidChange];
+}
+
+- (BOOL)isLiveReloadEnabled
+{
+  return [[self settingForKey:kRCTDevSettingLiveReloadEnabled] boolValue];
+}
+
+- (void)_liveReloadSettingDidChange
+{
+  BOOL liveReloadEnabled = (self.isLiveReloadAvailable && self.isLiveReloadEnabled);
+  if (liveReloadEnabled) {
+    [self _pollForLiveReload];
+  } else {
+    [_liveReloadUpdateTask cancel];
+    _liveReloadUpdateTask = nil;
+  }
+}
+
+RCT_EXPORT_METHOD(setHotLoadingEnabled:(BOOL)enabled)
+{
+  if (self.isHotLoadingEnabled != enabled) {
+    [self _updateSettingWithValue:@(enabled) forKey:kRCTDevSettingHotLoadingEnabled];
+    [_bridge reload];
+  }
+}
+
+- (BOOL)isHotLoadingEnabled
+{
+  return [[self settingForKey:kRCTDevSettingHotLoadingEnabled] boolValue];
+}
+
+RCT_EXPORT_METHOD(toggleElementInspector)
+{
+  BOOL value = [[self settingForKey:kRCTDevSettingIsInspectorShown] boolValue];
+  [self _updateSettingWithValue:@(!value) forKey:kRCTDevSettingIsInspectorShown];
+
+  if (_isJSLoaded) {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+    [self.bridge.eventDispatcher sendDeviceEventWithName:@"toggleElementInspector" body:nil];
+#pragma clang diagnostic pop
+  }
+}
+
+- (void)toggleJSCSamplingProfiler
+{
+  JSGlobalContextRef globalContext = _bridge.jsContextRef;
+  // JSPokeSamplingProfiler() toggles the profiling process
+  JSValueRef jsResult = JSC_JSPokeSamplingProfiler(globalContext);
+
+  if (JSC_JSValueGetType(globalContext, jsResult) != kJSTypeNull) {
+    JSContext *context = [JSC_JSContext(globalContext) contextWithJSGlobalContextRef:globalContext];
+    NSString *results = [[JSC_JSValue(globalContext) valueWithJSValueRef:jsResult inContext:context] toObject];
+    RCTJSCSamplingProfiler *profilerModule = [_bridge moduleForClass:[RCTJSCSamplingProfiler class]];
+    [profilerModule operationCompletedWithResults:results];
+  }
+}
+
+- (BOOL)isElementInspectorShown
+{
+  return [[self settingForKey:kRCTDevSettingIsInspectorShown] boolValue];
+}
+
+- (void)setIsPerfMonitorShown:(BOOL)isPerfMonitorShown
+{
+  [self _updateSettingWithValue:@(isPerfMonitorShown) forKey:kRCTDevSettingIsPerfMonitorShown];
+}
+
+- (BOOL)isPerfMonitorShown
+{
+  return [[self settingForKey:kRCTDevSettingIsPerfMonitorShown] boolValue];
+}
+
+- (void)setStartSamplingProfilerOnLaunch:(BOOL)startSamplingProfilerOnLaunch
+{
+  [self _updateSettingWithValue:@(startSamplingProfilerOnLaunch) forKey:kRCTDevSettingStartSamplingProfilerOnLaunch];
+}
+
+- (BOOL)startSamplingProfilerOnLaunch
+{
+  return [[self settingForKey:kRCTDevSettingStartSamplingProfilerOnLaunch] boolValue];
+}
+
+- (void)setExecutorClass:(Class)executorClass
+{
+  _executorClass = executorClass;
+  if (_bridge.executorClass != executorClass) {
+
+    // TODO (6929129): we can remove this special case test once we have better
+    // support for custom executors in the dev menu. But right now this is
+    // needed to prevent overriding a custom executor with the default if a
+    // custom executor has been set directly on the bridge
+    if (executorClass == Nil &&
+        _bridge.executorClass != objc_lookUpClass("RCTWebSocketExecutor")) {
+      return;
+    }
+
+    _bridge.executorClass = executorClass;
+    [_bridge reload];
+  }
+}
+
+#if RCT_DEV
+
+- (void)addHandler:(id<RCTPackagerClientMethod>)handler forPackagerMethod:(NSString *)name
+{
+#if ENABLE_PACKAGER_CONNECTION
+  [[RCTPackagerConnection sharedPackagerConnection] addHandler:handler forMethod:name];
+#endif
+}
+
+#endif
+
+#pragma mark - Internal
+
+/**
+ *  Query the data source for all possible settings and make sure we're doing the right
+ *  thing for the state of each setting.
+ */
+- (void)_synchronizeAllSettings
+{
+  [self _liveReloadSettingDidChange];
+  [self _remoteDebugSettingDidChange];
+  [self _profilingSettingDidChange];
+}
+
+- (void)_pollForLiveReload
+{
+  if (!_isJSLoaded || ![[self settingForKey:kRCTDevSettingLiveReloadEnabled] boolValue] || !_liveReloadURL) {
+    return;
+  }
+
+  if (_liveReloadUpdateTask) {
+    return;
+  }
+
+  __weak RCTDevSettings *weakSelf = self;
+  _liveReloadUpdateTask = [[NSURLSession sharedSession] dataTaskWithURL:_liveReloadURL completionHandler:
+                           ^(__unused NSData *data, NSURLResponse *response, NSError *error) {
+
+                             dispatch_async(dispatch_get_main_queue(), ^{
+                               __strong RCTDevSettings *strongSelf = weakSelf;
+                               if (strongSelf && [[strongSelf settingForKey:kRCTDevSettingLiveReloadEnabled] boolValue]) {
+                                 NSHTTPURLResponse *HTTPResponse = (NSHTTPURLResponse *)response;
+                                 if (!error && HTTPResponse.statusCode == 205) {
+                                   [strongSelf reload];
+                                 } else {
+                                   if (error.code != NSURLErrorCancelled) {
+                                     strongSelf->_liveReloadUpdateTask = nil;
+                                     [strongSelf _pollForLiveReload];
+                                   }
+                                 }
+                               }
+                             });
+
+                           }];
+
+  [_liveReloadUpdateTask resume];
+}
+
+- (void)jsLoaded:(NSNotification *)notification
+{
+  if (notification.userInfo[@"bridge"] != _bridge) {
+    return;
+  }
+
+  _isJSLoaded = YES;
+
+  // Check if live reloading is available
+  NSURL *scriptURL = _bridge.bundleURL;
+  if (![scriptURL isFileURL]) {
+    // Live reloading is disabled when running from bundled JS file
+    _liveReloadURL = [[NSURL alloc] initWithString:@"/onchange" relativeToURL:scriptURL];
+  } else {
+    _liveReloadURL = nil;
+  }
+
+  dispatch_async(dispatch_get_main_queue(), ^{
+    // update state again after the bridge has finished loading
+    [self _synchronizeAllSettings];
+
+    // Inspector can only be shown after JS has loaded
+    if ([self isElementInspectorShown]) {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+      [self.bridge.eventDispatcher sendDeviceEventWithName:@"toggleElementInspector" body:nil];
+#pragma clang diagnostic pop
+    }
+  });
+}
+
+@end
+
+#else // #if RCT_DEV
+
+@implementation RCTDevSettings
+
+- (instancetype)initWithDataSource:(id<RCTDevSettingsDataSource>)dataSource { return [super init]; }
+- (BOOL)isHotLoadingAvailable { return NO; }
+- (BOOL)isLiveReloadAvailable { return NO; }
+- (BOOL)isRemoteDebuggingAvailable { return NO; }
+- (id)settingForKey:(NSString *)key { return nil; }
+- (void)reload {}
+- (void)toggleElementInspector {}
+- (void)toggleJSCSamplingProfiler {}
+
+@end
+
+#endif
+
+@implementation RCTBridge (RCTDevSettings)
+
+- (RCTDevSettings *)devSettings
+{
+#if RCT_DEV
+  return [self moduleForClass:[RCTDevSettings class]];
+#else
+  return nil;
+#endif
+}
+
+@end

node_modules/react-native/React/Modules/RCTDeviceInfo.h

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * 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/RCTBridge.h>
+#import <React/RCTBridgeModule.h>
+
+@interface RCTDeviceInfo : NSObject <RCTBridgeModule, RCTInvalidating>
+
+@end

node_modules/react-native/React/Modules/RCTDeviceInfo.m

@@ -0,0 +1,159 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTDeviceInfo.h"
+
+#import "RCTAccessibilityManager.h"
+#import "RCTAssert.h"
+#import "RCTEventDispatcher.h"
+#import "RCTUIUtils.h"
+#import "RCTUtils.h"
+
+@implementation RCTDeviceInfo {
+#if !TARGET_OS_TV
+  UIInterfaceOrientation _currentInterfaceOrientation;
+#endif
+}
+
+@synthesize bridge = _bridge;
+
+RCT_EXPORT_MODULE()
+
++ (BOOL)requiresMainQueueSetup
+{
+  return YES;
+}
+
+- (dispatch_queue_t)methodQueue
+{
+  return dispatch_get_main_queue();
+}
+
+- (void)setBridge:(RCTBridge *)bridge
+{
+  _bridge = bridge;
+
+  [[NSNotificationCenter defaultCenter] addObserver:self
+                                           selector:@selector(didReceiveNewContentSizeMultiplier)
+                                               name:RCTAccessibilityManagerDidUpdateMultiplierNotification
+                                             object:_bridge.accessibilityManager];
+#if !TARGET_OS_TV
+  _currentInterfaceOrientation = [RCTSharedApplication() statusBarOrientation];
+
+  [[NSNotificationCenter defaultCenter] addObserver:self
+                                           selector:@selector(interfaceOrientationDidChange)
+                                               name:UIApplicationDidChangeStatusBarOrientationNotification
+                                             object:nil];
+#endif
+}
+
+static BOOL RCTIsIPhoneX() {
+  static BOOL isIPhoneX = NO;
+  static dispatch_once_t onceToken;
+
+  dispatch_once(&onceToken, ^{
+    RCTAssertMainQueue();
+
+    isIPhoneX = CGSizeEqualToSize(
+      [UIScreen mainScreen].nativeBounds.size,
+      CGSizeMake(1125, 2436)
+    );
+  });
+
+  return isIPhoneX;
+}
+
+static NSDictionary *RCTExportedDimensions(RCTBridge *bridge)
+{
+  RCTAssertMainQueue();
+
+  RCTDimensions dimensions = RCTGetDimensions(bridge.accessibilityManager.multiplier);
+  typeof (dimensions.window) window = dimensions.window; // Window and Screen are considered equal for iOS.
+  NSDictionary<NSString *, NSNumber *> *dims = @{
+      @"width": @(window.width),
+      @"height": @(window.height),
+      @"scale": @(window.scale),
+      @"fontScale": @(window.fontScale)
+  };
+  return @{
+      @"window": dims,
+      @"screen": dims
+  };
+}
+
+- (void)dealloc
+{
+  [NSNotificationCenter.defaultCenter removeObserver:self];
+}
+
+- (void)invalidate
+{
+  RCTExecuteOnMainQueue(^{
+    self->_bridge = nil;
+    [[NSNotificationCenter defaultCenter] removeObserver:self];
+  });
+}
+
+- (NSDictionary<NSString *, id> *)constantsToExport
+{
+  return @{
+    @"Dimensions": RCTExportedDimensions(_bridge),
+    // Note:
+    // This prop is deprecated and will be removed right after June 01, 2018.
+    // Please use this only for a quick and temporary solution.
+    // Use <SafeAreaView> instead.
+    @"isIPhoneX_deprecated": @(RCTIsIPhoneX()),
+  };
+}
+
+- (void)didReceiveNewContentSizeMultiplier
+{
+  RCTBridge *bridge = _bridge;
+  RCTExecuteOnMainQueue(^{
+    // Report the event across the bridge.
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+    [bridge.eventDispatcher sendDeviceEventWithName:@"didUpdateDimensions"
+                                        body:RCTExportedDimensions(bridge)];
+#pragma clang diagnostic pop
+  });
+}
+
+#if !TARGET_OS_TV
+
+- (void)interfaceOrientationDidChange
+{
+  __weak typeof(self) weakSelf = self;
+  RCTExecuteOnMainQueue(^{
+    [weakSelf _interfaceOrientationDidChange];
+  });
+}
+
+
+- (void)_interfaceOrientationDidChange
+{
+  UIInterfaceOrientation nextOrientation = [RCTSharedApplication() statusBarOrientation];
+
+  // Update when we go from portrait to landscape, or landscape to portrait
+  if ((UIInterfaceOrientationIsPortrait(_currentInterfaceOrientation) &&
+       !UIInterfaceOrientationIsPortrait(nextOrientation)) ||
+      (UIInterfaceOrientationIsLandscape(_currentInterfaceOrientation) &&
+       !UIInterfaceOrientationIsLandscape(nextOrientation))) {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+        [_bridge.eventDispatcher sendDeviceEventWithName:@"didUpdateDimensions"
+                                                    body:RCTExportedDimensions(_bridge)];
+#pragma clang diagnostic pop
+      }
+
+  _currentInterfaceOrientation = nextOrientation;
+}
+
+#endif // TARGET_OS_TV
+
+
+@end

node_modules/react-native/React/Modules/RCTEventEmitter.h

@@ -0,0 +1,42 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTBridge.h>
+
+/**
+ * RCTEventEmitter is an abstract base class to be used for modules that emit
+ * events to be observed by JS.
+ */
+@interface RCTEventEmitter : NSObject <RCTBridgeModule>
+
+@property (nonatomic, weak) RCTBridge *bridge;
+
+/**
+ * Override this method to return an array of supported event names. Attempting
+ * to observe or send an event that isn't included in this list will result in
+ * an error.
+ */
+- (NSArray<NSString *> *)supportedEvents;
+
+/**
+ * Send an event that does not relate to a specific view, e.g. a navigation
+ * or data update notification.
+ */
+- (void)sendEventWithName:(NSString *)name body:(id)body;
+
+/**
+ * These methods will be called when the first observer is added and when the
+ * last observer is removed (or when dealloc is called), respectively. These
+ * should be overridden in your subclass in order to start/stop sending events.
+ */
+- (void)startObserving;
+- (void)stopObserving;
+
+- (void)addListener:(NSString *)eventName;
+- (void)removeListeners:(double)count;
+
+@end

node_modules/react-native/React/Modules/RCTEventEmitter.m

@@ -0,0 +1,98 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTEventEmitter.h"
+#import "RCTAssert.h"
+#import "RCTUtils.h"
+#import "RCTLog.h"
+
+@implementation RCTEventEmitter
+{
+  NSInteger _listenerCount;
+}
+
++ (NSString *)moduleName
+{
+  return @"";
+}
+
++ (void)initialize
+{
+  if (self != [RCTEventEmitter class]) {
+    RCTAssert(RCTClassOverridesInstanceMethod(self, @selector(supportedEvents)),
+              @"You must override the `supportedEvents` method of %@", self);
+  }
+}
+
+- (NSArray<NSString *> *)supportedEvents
+{
+  return nil;
+}
+
+- (void)sendEventWithName:(NSString *)eventName body:(id)body
+{
+  RCTAssert(_bridge != nil, @"Error when sending event: %@ with body: %@. "
+            "Bridge is not set. This is probably because you've "
+            "explicitly synthesized the bridge in %@, even though it's inherited "
+            "from RCTEventEmitter.", eventName, body, [self class]);
+
+  if (RCT_DEBUG && ![[self supportedEvents] containsObject:eventName]) {
+    RCTLogError(@"`%@` is not a supported event type for %@. Supported events are: `%@`",
+                eventName, [self class], [[self supportedEvents] componentsJoinedByString:@"`, `"]);
+  }
+  if (_listenerCount > 0) {
+    [_bridge enqueueJSCall:@"RCTDeviceEventEmitter"
+                    method:@"emit"
+                      args:body ? @[eventName, body] : @[eventName]
+                completion:NULL];
+  } else {
+    RCTLogWarn(@"Sending `%@` with no listeners registered.", eventName);
+  }
+}
+
+- (void)startObserving
+{
+  // Does nothing
+}
+
+- (void)stopObserving
+{
+  // Does nothing
+}
+
+- (void)dealloc
+{
+  if (_listenerCount > 0) {
+    [self stopObserving];
+  }
+}
+
+RCT_EXPORT_METHOD(addListener:(NSString *)eventName)
+{
+  if (RCT_DEBUG && ![[self supportedEvents] containsObject:eventName]) {
+    RCTLogError(@"`%@` is not a supported event type for %@. Supported events are: `%@`",
+                eventName, [self class], [[self supportedEvents] componentsJoinedByString:@"`, `"]);
+  }
+  _listenerCount++;
+  if (_listenerCount == 1) {
+    [self startObserving];
+  }
+}
+
+RCT_EXPORT_METHOD(removeListeners:(double)count)
+{
+  int currentCount = (int)count;
+  if (RCT_DEBUG && currentCount > _listenerCount) {
+    RCTLogError(@"Attempted to remove more %@ listeners than added", [self class]);
+  }
+  _listenerCount = MAX(_listenerCount - currentCount, 0);
+  if (_listenerCount == 0) {
+    [self stopObserving];
+  }
+}
+
+@end

node_modules/react-native/React/Modules/RCTExceptionsManager.h

@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * 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/RCTBridgeModule.h>
+
+@protocol RCTExceptionsManagerDelegate <NSObject>
+
+- (void)handleSoftJSExceptionWithMessage:(NSString *)message stack:(NSArray *)stack exceptionId:(NSNumber *)exceptionId;
+- (void)handleFatalJSExceptionWithMessage:(NSString *)message stack:(NSArray *)stack exceptionId:(NSNumber *)exceptionId;
+
+@optional
+- (void)updateJSExceptionWithMessage:(NSString *)message stack:(NSArray *)stack exceptionId:(NSNumber *)exceptionId;
+
+@end
+
+@interface RCTExceptionsManager : NSObject <RCTBridgeModule>
+
+- (instancetype)initWithDelegate:(id<RCTExceptionsManagerDelegate>)delegate;
+
+@property (nonatomic, weak) id<RCTExceptionsManagerDelegate> delegate;
+
+@property (nonatomic, assign) NSUInteger maxReloadAttempts;
+
+@end

node_modules/react-native/React/Modules/RCTExceptionsManager.m

@@ -0,0 +1,80 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTExceptionsManager.h"
+
+#import "RCTConvert.h"
+#import "RCTDefines.h"
+#import "RCTLog.h"
+#import "RCTRedBox.h"
+#import "RCTRootView.h"
+
+@implementation RCTExceptionsManager
+
+@synthesize bridge = _bridge;
+
+RCT_EXPORT_MODULE()
+
+- (instancetype)initWithDelegate:(id<RCTExceptionsManagerDelegate>)delegate
+{
+  if ((self = [self init])) {
+    _delegate = delegate;
+  }
+  return self;
+}
+
+RCT_EXPORT_METHOD(reportSoftException:(NSString *)message
+                  stack:(NSArray<NSDictionary *> *)stack
+                  exceptionId:(nonnull NSNumber *)exceptionId)
+{
+  [_bridge.redBox showErrorMessage:message withStack:stack];
+
+  if (_delegate) {
+    [_delegate handleSoftJSExceptionWithMessage:message stack:stack exceptionId:exceptionId];
+  }
+}
+
+RCT_EXPORT_METHOD(reportFatalException:(NSString *)message
+                  stack:(NSArray<NSDictionary *> *)stack
+                  exceptionId:(nonnull NSNumber *)exceptionId)
+{
+  [_bridge.redBox showErrorMessage:message withStack:stack];
+
+  if (_delegate) {
+    [_delegate handleFatalJSExceptionWithMessage:message stack:stack exceptionId:exceptionId];
+  }
+
+  static NSUInteger reloadRetries = 0;
+  if (!RCT_DEBUG && reloadRetries < _maxReloadAttempts) {
+    reloadRetries++;
+    [_bridge reload];
+  } else {
+    NSString *description = [@"Unhandled JS Exception: " stringByAppendingString:message];
+    NSDictionary *errorInfo = @{ NSLocalizedDescriptionKey: description, RCTJSStackTraceKey: stack };
+    RCTFatal([NSError errorWithDomain:RCTErrorDomain code:0 userInfo:errorInfo]);
+  }
+}
+
+RCT_EXPORT_METHOD(updateExceptionMessage:(NSString *)message
+                  stack:(NSArray<NSDictionary *> *)stack
+                  exceptionId:(nonnull NSNumber *)exceptionId)
+{
+  [_bridge.redBox updateErrorMessage:message withStack:stack];
+
+  if (_delegate && [_delegate respondsToSelector:@selector(updateJSExceptionWithMessage:stack:exceptionId:)]) {
+    [_delegate updateJSExceptionWithMessage:message stack:stack exceptionId:exceptionId];
+  }
+}
+
+// Deprecated.  Use reportFatalException directly instead.
+RCT_EXPORT_METHOD(reportUnhandledException:(NSString *)message
+                  stack:(NSArray<NSDictionary *> *)stack)
+{
+  [self reportFatalException:message stack:stack exceptionId:@-1];
+}
+
+@end

node_modules/react-native/React/Modules/RCTI18nManager.h

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTBridgeModule.h>
+
+/**
+ * @experimental
+ * This is a experimental module for RTL support
+ * This module bridges the i18n utility from RCTI18nUtil
+ */
+@interface RCTI18nManager : NSObject <RCTBridgeModule>
+
+@end

node_modules/react-native/React/Modules/RCTI18nManager.m

@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTI18nManager.h"
+#import "RCTI18nUtil.h"
+
+@implementation RCTI18nManager
+
+RCT_EXPORT_MODULE()
+
++ (BOOL)requiresMainQueueSetup
+{
+  return NO;
+}
+
+RCT_EXPORT_METHOD(allowRTL:(BOOL)value)
+{
+  [[RCTI18nUtil sharedInstance] allowRTL:value];
+}
+
+RCT_EXPORT_METHOD(forceRTL:(BOOL)value)
+{
+  [[RCTI18nUtil sharedInstance] forceRTL:value];
+}
+
+RCT_EXPORT_METHOD(swapLeftAndRightInRTL:(BOOL)value)
+{
+  [[RCTI18nUtil sharedInstance] swapLeftAndRightInRTL:value];
+}
+
+- (NSDictionary *)constantsToExport
+{
+  return @{
+    @"isRTL": @([[RCTI18nUtil sharedInstance] isRTL]),
+    @"doLeftAndRightSwapInRTL": @([[RCTI18nUtil sharedInstance] doLeftAndRightSwapInRTL])
+  };
+}
+
+@end

node_modules/react-native/React/Modules/RCTI18nUtil.h

@@ -0,0 +1,28 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * 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>
+
+/**
+ * @experimental
+ * This is a experimental module for to expose constance IsRTL to js about the RTL status.
+ * And it allows js to force RLT status for development propose.
+ * This will also provide other i18n related utilities in the future.
+ */
+@interface RCTI18nUtil : NSObject
+
++ (instancetype)sharedInstance;
+
+- (BOOL)isRTL;
+- (BOOL)isRTLAllowed;
+- (void)allowRTL:(BOOL)value;
+- (BOOL)isRTLForced;
+- (void)forceRTL:(BOOL)value;
+- (BOOL)doLeftAndRightSwapInRTL;
+- (void)swapLeftAndRightInRTL:(BOOL)value;
+
+@end

node_modules/react-native/React/Modules/RCTI18nUtil.m

@@ -0,0 +1,105 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTI18nUtil.h"
+
+#import <UIKit/UIKit.h>
+
+@implementation RCTI18nUtil
+
++ (instancetype)sharedInstance
+{
+  static RCTI18nUtil *sharedInstance;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    sharedInstance = [self new];
+    [sharedInstance swapLeftAndRightInRTL: true];
+  });
+  
+  return sharedInstance;
+}
+
+/**
+ * Check if the app is currently running on an RTL locale.
+ * This only happens when the app:
+ * - is forcing RTL layout, regardless of the active language (for development purpose)
+ * - allows RTL layout when using RTL locale
+ */
+- (BOOL)isRTL
+{
+  if ([self isRTLForced]) {
+    return YES;
+  }
+  if ([self isRTLAllowed] && [self isApplicationPreferredLanguageRTL]) {
+    return YES;
+  }
+  return NO;
+}
+
+/**
+ * Should be used very early during app start up
+ * Before the bridge is initialized
+ * @return whether the app allows RTL layout, default is true
+ */
+- (BOOL)isRTLAllowed
+{
+  NSNumber *value = [[NSUserDefaults standardUserDefaults] objectForKey:@"RCTI18nUtil_allowRTL"];
+  if (value == nil) {
+    return YES;
+  }
+  return [value boolValue];
+}
+
+- (void)allowRTL:(BOOL)rtlStatus
+{
+  [[NSUserDefaults standardUserDefaults] setBool:rtlStatus forKey:@"RCTI18nUtil_allowRTL"];
+  [[NSUserDefaults standardUserDefaults] synchronize];
+}
+
+/**
+ * Could be used to test RTL layout with English
+ * Used for development and testing purpose
+ */
+- (BOOL)isRTLForced
+{
+  BOOL rtlStatus = [[NSUserDefaults standardUserDefaults]
+                            boolForKey:@"RCTI18nUtil_forceRTL"];
+  return rtlStatus;
+}
+
+- (void)forceRTL:(BOOL)rtlStatus
+{
+  [[NSUserDefaults standardUserDefaults] setBool:rtlStatus forKey:@"RCTI18nUtil_forceRTL"];
+  [[NSUserDefaults standardUserDefaults] synchronize];
+}
+
+- (BOOL)doLeftAndRightSwapInRTL
+{
+  return [[NSUserDefaults standardUserDefaults] boolForKey:@"RCTI18nUtil_makeRTLFlipLeftAndRightStyles"];
+}
+
+- (void)swapLeftAndRightInRTL:(BOOL)value
+{
+  [[NSUserDefaults standardUserDefaults] setBool:value forKey:@"RCTI18nUtil_makeRTLFlipLeftAndRightStyles"];
+  [[NSUserDefaults standardUserDefaults] synchronize];
+}
+
+// Check if the current device language is RTL
+- (BOOL)isDevicePreferredLanguageRTL
+{
+  NSLocaleLanguageDirection direction = [NSLocale characterDirectionForLanguage:[[NSLocale preferredLanguages] objectAtIndex:0]];
+  return direction == NSLocaleLanguageDirectionRightToLeft;
+}
+
+// Check if the current application language is RTL
+- (BOOL)isApplicationPreferredLanguageRTL
+{
+  NSWritingDirection direction = [NSParagraphStyle defaultWritingDirectionForLanguage:nil];
+  return direction == NSWritingDirectionRightToLeft;
+}
+
+@end

node_modules/react-native/React/Modules/RCTJSCSamplingProfiler.h

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * 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/RCTBridgeModule.h>
+
+@interface RCTJSCSamplingProfiler : NSObject <RCTBridgeModule>
+
+/**
+ * Receives a JSON string containing the result of a JSC CPU Profiling run,
+ *  and sends them to the packager to be symbolicated and saved to disk.
+ * It is safe to call this method from any thread.
+ */
+- (void)operationCompletedWithResults:(NSString *)results;
+
+@end

node_modules/react-native/React/Modules/RCTJSCSamplingProfiler.m

@@ -0,0 +1,59 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTJSCSamplingProfiler.h"
+
+#import "RCTBridge.h"
+#import "RCTLog.h"
+
+@implementation RCTJSCSamplingProfiler
+
+@synthesize methodQueue = _methodQueue;
+@synthesize bridge = _bridge;
+
+RCT_EXPORT_MODULE(RCTJSCSamplingProfiler);
+
+#ifdef RCT_PROFILE
+RCT_EXPORT_METHOD(operationComplete:(__unused int)token result:(id)profileData error:(id)error)
+{
+  if (error) {
+    RCTLogError(@"JSC Sampling profiler ended with error: %@", error);
+    return;
+  }
+
+  // Create a POST request with all of the datas
+  NSURL *url = [NSURL URLWithString:@"/jsc-profile" relativeToURL:self.bridge.bundleURL];
+  NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url
+                                                         cachePolicy:NSURLRequestReloadIgnoringLocalAndRemoteCacheData
+                                                     timeoutInterval:60];
+  [request setHTTPMethod:@"POST"];
+  [request setHTTPBody:[profileData dataUsingEncoding:NSUTF8StringEncoding]];
+
+  // Send the request
+  NSURLSession *session = [NSURLSession sessionWithConfiguration:[NSURLSessionConfiguration defaultSessionConfiguration]];
+  NSURLSessionDataTask *sessionDataTask = [session dataTaskWithRequest:request completionHandler:^(__unused NSData *data, __unused NSURLResponse *response, NSError *sessionError) {
+    if (sessionError) {
+      RCTLogWarn(@"JS CPU Profile data failed to send. Is the packager server running locally?\nDetails: %@", error);
+    } else {
+      RCTLogInfo(@"JS CPU Profile data sent successfully.");
+    }
+  }];
+
+  [sessionDataTask resume];
+}
+
+- (void)operationCompletedWithResults:(NSString *)results
+{
+  // Send the results to the packager, using the module's queue.
+  dispatch_async(self.methodQueue, ^{
+    [self operationComplete:0 result:results error:nil];
+  });
+}
+
+#endif
+
+@end

node_modules/react-native/React/Modules/RCTKeyboardObserver.h

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTEventEmitter.h>
+
+@interface RCTKeyboardObserver : RCTEventEmitter
+
+@end

node_modules/react-native/React/Modules/RCTKeyboardObserver.m

@@ -0,0 +1,121 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTKeyboardObserver.h"
+
+#import "RCTEventDispatcher.h"
+
+static NSDictionary *RCTParseKeyboardNotification(NSNotification *notification);
+
+@implementation RCTKeyboardObserver
+
+RCT_EXPORT_MODULE()
+
+- (void)startObserving
+{
+#if !TARGET_OS_TV
+
+  NSNotificationCenter *nc = [NSNotificationCenter defaultCenter];
+
+#define ADD_KEYBOARD_HANDLER(NAME, SELECTOR) \
+  [nc addObserver:self selector:@selector(SELECTOR:) name:NAME object:nil]
+
+  ADD_KEYBOARD_HANDLER(UIKeyboardWillShowNotification, keyboardWillShow);
+  ADD_KEYBOARD_HANDLER(UIKeyboardDidShowNotification, keyboardDidShow);
+  ADD_KEYBOARD_HANDLER(UIKeyboardWillHideNotification, keyboardWillHide);
+  ADD_KEYBOARD_HANDLER(UIKeyboardDidHideNotification, keyboardDidHide);
+  ADD_KEYBOARD_HANDLER(UIKeyboardWillChangeFrameNotification, keyboardWillChangeFrame);
+  ADD_KEYBOARD_HANDLER(UIKeyboardDidChangeFrameNotification, keyboardDidChangeFrame);
+
+#undef ADD_KEYBOARD_HANDLER
+
+#endif
+
+}
+
+- (NSArray<NSString *> *)supportedEvents
+{
+  return @[@"keyboardWillShow",
+           @"keyboardDidShow",
+           @"keyboardWillHide",
+           @"keyboardDidHide",
+           @"keyboardWillChangeFrame",
+           @"keyboardDidChangeFrame"];
+}
+
+- (void)stopObserving
+{
+  [[NSNotificationCenter defaultCenter] removeObserver:self];
+}
+
+// Bridge might be already invalidated by the time the keyboard is about to be dismissed.
+// This might happen, for example, when reload from the packager is performed.
+// Thus we need to check against nil here.
+#define IMPLEMENT_KEYBOARD_HANDLER(EVENT) \
+- (void)EVENT:(NSNotification *)notification \
+{ \
+  if (!self.bridge) { \
+    return; \
+  } \
+  [self sendEventWithName:@#EVENT \
+    body:RCTParseKeyboardNotification(notification)]; \
+}
+
+IMPLEMENT_KEYBOARD_HANDLER(keyboardWillShow)
+IMPLEMENT_KEYBOARD_HANDLER(keyboardDidShow)
+IMPLEMENT_KEYBOARD_HANDLER(keyboardWillHide)
+IMPLEMENT_KEYBOARD_HANDLER(keyboardDidHide)
+IMPLEMENT_KEYBOARD_HANDLER(keyboardWillChangeFrame)
+IMPLEMENT_KEYBOARD_HANDLER(keyboardDidChangeFrame)
+
+@end
+
+NS_INLINE NSDictionary *RCTRectDictionaryValue(CGRect rect)
+{
+  return @{
+    @"screenX": @(rect.origin.x),
+    @"screenY": @(rect.origin.y),
+    @"width": @(rect.size.width),
+    @"height": @(rect.size.height),
+  };
+}
+
+static NSString *RCTAnimationNameForCurve(UIViewAnimationCurve curve)
+{
+  switch (curve) {
+    case UIViewAnimationCurveEaseIn:
+      return @"easeIn";
+    case UIViewAnimationCurveEaseInOut:
+      return @"easeInEaseOut";
+    case UIViewAnimationCurveEaseOut:
+      return @"easeOut";
+    case UIViewAnimationCurveLinear:
+      return @"linear";
+    default:
+      return @"keyboard";
+  }
+}
+
+static NSDictionary *RCTParseKeyboardNotification(NSNotification *notification)
+{
+#if TARGET_OS_TV
+  return @{};
+#else
+  NSDictionary *userInfo = notification.userInfo;
+  CGRect beginFrame = [userInfo[UIKeyboardFrameBeginUserInfoKey] CGRectValue];
+  CGRect endFrame = [userInfo[UIKeyboardFrameEndUserInfoKey] CGRectValue];
+  NSTimeInterval duration = [userInfo[UIKeyboardAnimationDurationUserInfoKey] doubleValue];
+  UIViewAnimationCurve curve = [userInfo[UIKeyboardAnimationCurveUserInfoKey] integerValue];
+
+  return @{
+    @"startCoordinates": RCTRectDictionaryValue(beginFrame),
+    @"endCoordinates": RCTRectDictionaryValue(endFrame),
+    @"duration": @(duration * 1000.0), // ms
+    @"easing": RCTAnimationNameForCurve(curve),
+  };
+#endif
+}

node_modules/react-native/React/Modules/RCTLayoutAnimation.h

@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * 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/RCTAnimationType.h>
+
+@interface RCTLayoutAnimation : NSObject
+
+@property (nonatomic, readonly) NSTimeInterval duration;
+@property (nonatomic, readonly) NSTimeInterval delay;
+@property (nonatomic, readonly, copy) NSString *property;
+@property (nonatomic, readonly) CGFloat springDamping;
+@property (nonatomic, readonly) CGFloat initialVelocity;
+@property (nonatomic, readonly) RCTAnimationType animationType;
+
++ (void)initializeStatics;
+
+- (instancetype)initWithDuration:(NSTimeInterval)duration
+                           delay:(NSTimeInterval)delay
+                        property:(NSString *)property
+                   springDamping:(CGFloat)springDamping
+                 initialVelocity:(CGFloat)initialVelocity
+                   animationType:(RCTAnimationType)animationType;
+
+- (instancetype)initWithDuration:(NSTimeInterval)duration
+                          config:(NSDictionary *)config;
+
+- (void)performAnimations:(void (^)(void))animations
+      withCompletionBlock:(void (^)(BOOL completed))completionBlock;
+
+@end

node_modules/react-native/React/Modules/RCTLayoutAnimation.m

@@ -0,0 +1,153 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTLayoutAnimation.h"
+
+#import "RCTConvert.h"
+
+@implementation RCTLayoutAnimation
+
+static UIViewAnimationCurve _currentKeyboardAnimationCurve;
+
+static UIViewAnimationOptions UIViewAnimationOptionsFromRCTAnimationType(RCTAnimationType type)
+{
+  switch (type) {
+    case RCTAnimationTypeLinear:
+      return UIViewAnimationOptionCurveLinear;
+    case RCTAnimationTypeEaseIn:
+      return UIViewAnimationOptionCurveEaseIn;
+    case RCTAnimationTypeEaseOut:
+      return UIViewAnimationOptionCurveEaseOut;
+    case RCTAnimationTypeEaseInEaseOut:
+      return UIViewAnimationOptionCurveEaseInOut;
+    case RCTAnimationTypeKeyboard:
+      // http://stackoverflow.com/questions/18870447/how-to-use-the-default-ios7-uianimation-curve
+      return (UIViewAnimationOptions)(_currentKeyboardAnimationCurve << 16);
+    default:
+      RCTLogError(@"Unsupported animation type %lld", (long long)type);
+      return UIViewAnimationOptionCurveEaseInOut;
+  }
+}
+
+// Use a custom initialization function rather than implementing `+initialize` so that we can control
+// when the initialization code runs. `+initialize` runs immediately before the first message is sent
+// to the class which may be too late for us. By this time, we may have missed some
+// `UIKeyboardWillChangeFrameNotification`s.
++ (void)initializeStatics
+{
+#if !TARGET_OS_TV
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    [[NSNotificationCenter defaultCenter] addObserver:self
+                                             selector:@selector(keyboardWillChangeFrame:)
+                                                 name:UIKeyboardWillChangeFrameNotification
+                                               object:nil];
+  });
+#endif
+}
+
++ (void)keyboardWillChangeFrame:(NSNotification *)notification
+{
+#if !TARGET_OS_TV
+  NSDictionary *userInfo = notification.userInfo;
+  _currentKeyboardAnimationCurve = [userInfo[UIKeyboardAnimationCurveUserInfoKey] integerValue];
+#endif
+}
+
+- (instancetype)initWithDuration:(NSTimeInterval)duration
+                           delay:(NSTimeInterval)delay
+                        property:(NSString *)property
+                   springDamping:(CGFloat)springDamping
+                 initialVelocity:(CGFloat)initialVelocity
+                   animationType:(RCTAnimationType)animationType
+{
+  if (self = [super init]) {
+    _duration = duration;
+    _delay = delay;
+    _property = property;
+    _springDamping = springDamping;
+    _initialVelocity = initialVelocity;
+    _animationType = animationType;
+  }
+
+  return self;
+}
+
+- (instancetype)initWithDuration:(NSTimeInterval)duration
+                          config:(NSDictionary *)config
+{
+  if (!config) {
+    return nil;
+  }
+
+  if (self = [super init]) {
+    _property = [RCTConvert NSString:config[@"property"]];
+
+    _duration = [RCTConvert NSTimeInterval:config[@"duration"]] ?: duration;
+    if (_duration > 0.0 && _duration < 0.01) {
+      RCTLogError(@"RCTLayoutAnimationGroup expects timings to be in ms, not seconds.");
+      _duration = _duration * 1000.0;
+    }
+
+    _delay = [RCTConvert NSTimeInterval:config[@"delay"]];
+    if (_delay > 0.0 && _delay < 0.01) {
+      RCTLogError(@"RCTLayoutAnimationGroup expects timings to be in ms, not seconds.");
+      _delay = _delay * 1000.0;
+    }
+
+    _animationType = [RCTConvert RCTAnimationType:config[@"type"]];
+    if (_animationType == RCTAnimationTypeSpring) {
+      _springDamping = [RCTConvert CGFloat:config[@"springDamping"]];
+      _initialVelocity = [RCTConvert CGFloat:config[@"initialVelocity"]];
+    }
+  }
+
+  return self;
+}
+
+- (void)performAnimations:(void (^)(void))animations
+      withCompletionBlock:(void (^)(BOOL completed))completionBlock
+{
+  if (_animationType == RCTAnimationTypeSpring) {
+    [UIView animateWithDuration:_duration
+                          delay:_delay
+         usingSpringWithDamping:_springDamping
+          initialSpringVelocity:_initialVelocity
+                        options:UIViewAnimationOptionBeginFromCurrentState
+                     animations:animations
+                     completion:completionBlock];
+  } else {
+    UIViewAnimationOptions options =
+      UIViewAnimationOptionBeginFromCurrentState |
+      UIViewAnimationOptionsFromRCTAnimationType(_animationType);
+
+    [UIView animateWithDuration:_duration
+                          delay:_delay
+                        options:options
+                     animations:animations
+                     completion:completionBlock];
+  }
+}
+
+- (BOOL)isEqual:(RCTLayoutAnimation *)animation
+{
+  return
+    _duration == animation.duration &&
+    _delay == animation.delay &&
+    (_property == animation.property || [_property isEqualToString:animation.property]) &&
+    _springDamping == animation.springDamping &&
+    _initialVelocity == animation.initialVelocity &&
+    _animationType == animation.animationType;
+}
+
+- (NSString *)description
+{
+  return [NSString stringWithFormat:@"<%@: %p; duration: %f; delay: %f; property: %@; springDamping: %f; initialVelocity: %f; animationType: %li;>",
+          NSStringFromClass([self class]), self, _duration, _delay, _property, _springDamping, _initialVelocity, (long)_animationType];
+}
+
+@end

node_modules/react-native/React/Modules/RCTLayoutAnimationGroup.h

@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * 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/RCTBridgeModule.h>
+
+@class RCTLayoutAnimation;
+
+@interface RCTLayoutAnimationGroup : NSObject
+
+@property (nonatomic, readonly) RCTLayoutAnimation *creatingLayoutAnimation;
+@property (nonatomic, readonly) RCTLayoutAnimation *updatingLayoutAnimation;
+@property (nonatomic, readonly) RCTLayoutAnimation *deletingLayoutAnimation;
+
+@property (nonatomic, copy) RCTResponseSenderBlock callback;
+
+- (instancetype)initWithCreatingLayoutAnimation:(RCTLayoutAnimation *)creatingLayoutAnimation
+                        updatingLayoutAnimation:(RCTLayoutAnimation *)updatingLayoutAnimation
+                        deletingLayoutAnimation:(RCTLayoutAnimation *)deletingLayoutAnimation
+                                       callback:(RCTResponseSenderBlock)callback;
+
+- (instancetype)initWithConfig:(NSDictionary *)config
+                      callback:(RCTResponseSenderBlock)callback;
+
+@end

node_modules/react-native/React/Modules/RCTLayoutAnimationGroup.m

@@ -0,0 +1,72 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTLayoutAnimationGroup.h"
+
+#import "RCTLayoutAnimation.h"
+#import "RCTConvert.h"
+
+@implementation RCTLayoutAnimationGroup
+
+- (instancetype)initWithCreatingLayoutAnimation:(RCTLayoutAnimation *)creatingLayoutAnimation
+                        updatingLayoutAnimation:(RCTLayoutAnimation *)updatingLayoutAnimation
+                        deletingLayoutAnimation:(RCTLayoutAnimation *)deletingLayoutAnimation
+                                       callback:(RCTResponseSenderBlock)callback
+{
+  if (self = [super init]) {
+    _creatingLayoutAnimation = creatingLayoutAnimation;
+    _updatingLayoutAnimation = updatingLayoutAnimation;
+    _deletingLayoutAnimation = deletingLayoutAnimation;
+    _callback = callback;
+  }
+
+  return self;
+}
+
+- (instancetype)initWithConfig:(NSDictionary *)config
+                      callback:(RCTResponseSenderBlock)callback
+{
+  if (!config) {
+    return nil;
+  }
+
+  if (self = [super init]) {
+    NSTimeInterval duration = [RCTConvert NSTimeInterval:config[@"duration"]];
+
+    if (duration > 0.0 && duration < 0.01) {
+      RCTLogError(@"RCTLayoutAnimationGroup expects timings to be in ms, not seconds.");
+      duration = duration * 1000.0;
+    }
+
+    _creatingLayoutAnimation = [[RCTLayoutAnimation alloc] initWithDuration:duration config:config[@"create"]];
+    _updatingLayoutAnimation = [[RCTLayoutAnimation alloc] initWithDuration:duration config:config[@"update"]];
+    _deletingLayoutAnimation = [[RCTLayoutAnimation alloc] initWithDuration:duration config:config[@"delete"]];
+    _callback = callback;
+  }
+
+  return self;
+}
+
+- (BOOL)isEqual:(RCTLayoutAnimationGroup *)layoutAnimation
+{
+  RCTLayoutAnimation *creatingLayoutAnimation = layoutAnimation.creatingLayoutAnimation;
+  RCTLayoutAnimation *updatingLayoutAnimation = layoutAnimation.updatingLayoutAnimation;
+  RCTLayoutAnimation *deletingLayoutAnimation = layoutAnimation.deletingLayoutAnimation;
+
+  return
+    (_creatingLayoutAnimation == creatingLayoutAnimation || [_creatingLayoutAnimation isEqual:creatingLayoutAnimation]) &&
+    (_updatingLayoutAnimation == updatingLayoutAnimation || [_updatingLayoutAnimation isEqual:updatingLayoutAnimation]) &&
+    (_deletingLayoutAnimation == deletingLayoutAnimation || [_deletingLayoutAnimation isEqual:deletingLayoutAnimation]);
+}
+
+- (NSString *)description
+{
+  return [NSString stringWithFormat:@"<%@: %p; creatingLayoutAnimation: %@; updatingLayoutAnimation: %@; deletingLayoutAnimation: %@>",
+          NSStringFromClass([self class]), self, [_creatingLayoutAnimation description], [_updatingLayoutAnimation description], [_deletingLayoutAnimation description]];
+}
+
+@end

node_modules/react-native/React/Modules/RCTRedBox.h

@@ -0,0 +1,46 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * 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/RCTBridge.h>
+#import <React/RCTBridgeModule.h>
+#import <React/RCTErrorCustomizer.h>
+
+@class RCTJSStackFrame;
+
+@interface RCTRedBox : NSObject <RCTBridgeModule>
+
+- (void)registerErrorCustomizer:(id<RCTErrorCustomizer>)errorCustomizer;
+- (void)showError:(NSError *)error;
+- (void)showErrorMessage:(NSString *)message;
+- (void)showErrorMessage:(NSString *)message withDetails:(NSString *)details;
+- (void)showErrorMessage:(NSString *)message withRawStack:(NSString *)rawStack;
+- (void)showErrorMessage:(NSString *)message withStack:(NSArray<NSDictionary *> *)stack;
+- (void)updateErrorMessage:(NSString *)message withStack:(NSArray<NSDictionary *> *)stack;
+- (void)showErrorMessage:(NSString *)message withParsedStack:(NSArray<RCTJSStackFrame *> *)stack;
+- (void)updateErrorMessage:(NSString *)message withParsedStack:(NSArray<RCTJSStackFrame *> *)stack;
+
+- (void)dismiss;
+
+/** Overrides bridge.bundleURL. Modify on main thread only. You shouldn't need to use this. */
+@property (nonatomic, strong) NSURL *overrideBundleURL;
+
+/** Overrides the default behavior of calling [bridge reload] on reload. You shouldn't need to use this. */
+@property (nonatomic, strong) dispatch_block_t overrideReloadAction;
+
+@end
+
+/**
+ * This category makes the red box instance available via the RCTBridge, which
+ * is useful for any class that needs to access the red box or error log.
+ */
+@interface RCTBridge (RCTRedBox)
+
+@property (nonatomic, readonly) RCTRedBox *redBox;
+
+@end

node_modules/react-native/React/Modules/RCTRedBox.m

@@ -0,0 +1,568 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTRedBox.h"
+
+#import "RCTBridge.h"
+#import "RCTConvert.h"
+#import "RCTDefines.h"
+#import "RCTErrorInfo.h"
+#import "RCTEventDispatcher.h"
+#import "RCTJSStackFrame.h"
+#import "RCTRedBoxExtraDataViewController.h"
+#import "RCTUtils.h"
+
+#if RCT_DEBUG
+
+@class RCTRedBoxWindow;
+
+@protocol RCTRedBoxWindowActionDelegate <NSObject>
+
+- (void)redBoxWindow:(RCTRedBoxWindow *)redBoxWindow openStackFrameInEditor:(RCTJSStackFrame *)stackFrame;
+- (void)reloadFromRedBoxWindow:(RCTRedBoxWindow *)redBoxWindow;
+- (void)loadExtraDataViewController;
+
+@end
+
+@interface RCTRedBoxWindow : UIWindow <UITableViewDelegate, UITableViewDataSource>
+@property (nonatomic, weak) id<RCTRedBoxWindowActionDelegate> actionDelegate;
+@end
+
+@implementation RCTRedBoxWindow
+{
+    UITableView *_stackTraceTableView;
+    NSString *_lastErrorMessage;
+    NSArray<RCTJSStackFrame *> *_lastStackTrace;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+    if ((self = [super initWithFrame:frame])) {
+#if TARGET_OS_TV
+        self.windowLevel = UIWindowLevelAlert + 1000;
+#else
+        self.windowLevel = UIWindowLevelStatusBar - 1;
+#endif
+        self.backgroundColor = [UIColor colorWithRed:0.8 green:0 blue:0 alpha:1];
+        self.hidden = YES;
+
+        UIViewController *rootController = [UIViewController new];
+        self.rootViewController = rootController;
+        UIView *rootView = rootController.view;
+        rootView.backgroundColor = [UIColor clearColor];
+
+        const CGFloat buttonHeight = 60;
+
+        CGRect detailsFrame = rootView.bounds;
+        detailsFrame.size.height -= buttonHeight;
+
+        _stackTraceTableView = [[UITableView alloc] initWithFrame:detailsFrame style:UITableViewStylePlain];
+        _stackTraceTableView.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
+        _stackTraceTableView.delegate = self;
+        _stackTraceTableView.dataSource = self;
+        _stackTraceTableView.backgroundColor = [UIColor clearColor];
+#if !TARGET_OS_TV
+        _stackTraceTableView.separatorColor = [UIColor colorWithWhite:1 alpha:0.3];
+        _stackTraceTableView.separatorStyle = UITableViewCellSeparatorStyleNone;
+#endif
+        _stackTraceTableView.indicatorStyle = UIScrollViewIndicatorStyleWhite;
+        [rootView addSubview:_stackTraceTableView];
+
+#if TARGET_OS_SIMULATOR
+        NSString *reloadText = @"Reload JS (\u2318R)";
+        NSString *dismissText = @"Dismiss (ESC)";
+        NSString *copyText = @"Copy (\u2325\u2318C)";
+        NSString *extraText = @"Extra Info (\u2318E)";
+#else
+        NSString *reloadText = @"Reload JS";
+        NSString *dismissText = @"Dismiss";
+        NSString *copyText = @"Copy";
+        NSString *extraText = @"Extra Info";
+#endif
+
+        UIButton *dismissButton = [UIButton buttonWithType:UIButtonTypeCustom];
+        dismissButton.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleTopMargin | UIViewAutoresizingFlexibleRightMargin;
+        dismissButton.accessibilityIdentifier = @"redbox-dismiss";
+        dismissButton.titleLabel.font = [UIFont systemFontOfSize:13];
+        [dismissButton setTitle:dismissText forState:UIControlStateNormal];
+        [dismissButton setTitleColor:[UIColor colorWithWhite:1 alpha:0.5] forState:UIControlStateNormal];
+        [dismissButton setTitleColor:[UIColor whiteColor] forState:UIControlStateHighlighted];
+        [dismissButton addTarget:self action:@selector(dismiss) forControlEvents:UIControlEventTouchUpInside];
+
+        UIButton *reloadButton = [UIButton buttonWithType:UIButtonTypeCustom];
+        reloadButton.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleTopMargin | UIViewAutoresizingFlexibleLeftMargin;
+        reloadButton.accessibilityIdentifier = @"redbox-reload";
+        reloadButton.titleLabel.font = [UIFont systemFontOfSize:13];
+
+        [reloadButton setTitle:reloadText forState:UIControlStateNormal];
+        [reloadButton setTitleColor:[UIColor colorWithWhite:1 alpha:0.5] forState:UIControlStateNormal];
+        [reloadButton setTitleColor:[UIColor whiteColor] forState:UIControlStateHighlighted];
+        [reloadButton addTarget:self action:@selector(reload) forControlEvents:UIControlEventTouchUpInside];
+
+        UIButton *copyButton = [UIButton buttonWithType:UIButtonTypeCustom];
+        copyButton.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleTopMargin | UIViewAutoresizingFlexibleLeftMargin;
+        copyButton.accessibilityIdentifier = @"redbox-copy";
+        copyButton.titleLabel.font = [UIFont systemFontOfSize:13];
+        [copyButton setTitle:copyText forState:UIControlStateNormal];
+        [copyButton setTitleColor:[UIColor colorWithWhite:1 alpha:0.5] forState:UIControlStateNormal];
+        [copyButton setTitleColor:[UIColor whiteColor] forState:UIControlStateHighlighted];
+        [copyButton addTarget:self action:@selector(copyStack) forControlEvents:UIControlEventTouchUpInside];
+
+        UIButton *extraButton = [UIButton buttonWithType:UIButtonTypeCustom];
+        extraButton.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleTopMargin | UIViewAutoresizingFlexibleLeftMargin;
+        extraButton.accessibilityIdentifier = @"redbox-extra";
+        extraButton.titleLabel.font = [UIFont systemFontOfSize:13];
+        [extraButton setTitle:extraText forState:UIControlStateNormal];
+        [extraButton setTitleColor:[UIColor colorWithWhite:1 alpha:0.5] forState:UIControlStateNormal];
+        [extraButton setTitleColor:[UIColor whiteColor] forState:UIControlStateHighlighted];
+        [extraButton addTarget:self action:@selector(showExtraDataViewController) forControlEvents:UIControlEventTouchUpInside];
+
+        CGFloat buttonWidth = self.bounds.size.width / 4;
+        dismissButton.frame = CGRectMake(0, self.bounds.size.height - buttonHeight, buttonWidth, buttonHeight);
+        reloadButton.frame = CGRectMake(buttonWidth, self.bounds.size.height - buttonHeight, buttonWidth, buttonHeight);
+        copyButton.frame = CGRectMake(buttonWidth * 2, self.bounds.size.height - buttonHeight, buttonWidth, buttonHeight);
+        extraButton.frame = CGRectMake(buttonWidth * 3, self.bounds.size.height - buttonHeight, buttonWidth, buttonHeight);
+
+        [rootView addSubview:dismissButton];
+        [rootView addSubview:reloadButton];
+        [rootView addSubview:copyButton];
+        [rootView addSubview:extraButton];
+    }
+    return self;
+}
+
+RCT_NOT_IMPLEMENTED(- (instancetype)initWithCoder:(NSCoder *)aDecoder)
+
+- (void)dealloc
+{
+    _stackTraceTableView.dataSource = nil;
+    _stackTraceTableView.delegate = nil;
+    [[NSNotificationCenter defaultCenter] removeObserver:self];
+}
+
+- (void)showErrorMessage:(NSString *)message withStack:(NSArray<RCTJSStackFrame *> *)stack isUpdate:(BOOL)isUpdate
+{
+    // Show if this is a new message, or if we're updating the previous message
+    if ((self.hidden && !isUpdate) || (!self.hidden && isUpdate && [_lastErrorMessage isEqualToString:message])) {
+        _lastStackTrace = stack;
+        // message is displayed using UILabel, which is unable to render text of
+        // unlimited length, so we truncate it
+        _lastErrorMessage = [message substringToIndex:MIN((NSUInteger)10000, message.length)];
+
+        [_stackTraceTableView reloadData];
+
+        if (self.hidden) {
+            [_stackTraceTableView scrollToRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]
+                                        atScrollPosition:UITableViewScrollPositionTop
+                                                animated:NO];
+        }
+
+        [self makeKeyAndVisible];
+        [self becomeFirstResponder];
+    }
+}
+
+- (void)dismiss
+{
+    self.hidden = YES;
+    [self resignFirstResponder];
+    [RCTSharedApplication().delegate.window makeKeyWindow];
+}
+
+- (void)reload
+{
+    [_actionDelegate reloadFromRedBoxWindow:self];
+}
+
+- (void)showExtraDataViewController
+{
+    [_actionDelegate loadExtraDataViewController];
+}
+
+- (void)copyStack
+{
+    NSMutableString *fullStackTrace;
+
+    if (_lastErrorMessage != nil) {
+        fullStackTrace = [_lastErrorMessage mutableCopy];
+        [fullStackTrace appendString:@"\n\n"];
+    }
+    else {
+        fullStackTrace = [NSMutableString string];
+    }
+
+    for (RCTJSStackFrame *stackFrame in _lastStackTrace) {
+        [fullStackTrace appendString:[NSString stringWithFormat:@"%@\n", stackFrame.methodName]];
+        if (stackFrame.file) {
+            [fullStackTrace appendFormat:@"    %@\n", [self formatFrameSource:stackFrame]];
+        }
+    }
+#if !TARGET_OS_TV
+    UIPasteboard *pb = [UIPasteboard generalPasteboard];
+    [pb setString:fullStackTrace];
+#endif
+}
+
+- (NSString *)formatFrameSource:(RCTJSStackFrame *)stackFrame
+{
+    NSString *fileName = RCTNilIfNull(stackFrame.file) ? [stackFrame.file lastPathComponent] : @"<unknown file>";
+    NSString *lineInfo = [NSString stringWithFormat:@"%@:%lld",
+                          fileName,
+                          (long long)stackFrame.lineNumber];
+
+    if (stackFrame.column != 0) {
+        lineInfo = [lineInfo stringByAppendingFormat:@":%lld", (long long)stackFrame.column];
+    }
+    return lineInfo;
+}
+
+#pragma mark - TableView
+
+- (NSInteger)numberOfSectionsInTableView:(__unused UITableView *)tableView
+{
+    return 2;
+}
+
+- (NSInteger)tableView:(__unused UITableView *)tableView numberOfRowsInSection:(NSInteger)section
+{
+    return section == 0 ? 1 : _lastStackTrace.count;
+}
+
+- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
+{
+    if (indexPath.section == 0) {
+        UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:@"msg-cell"];
+        return [self reuseCell:cell forErrorMessage:_lastErrorMessage];
+    }
+    UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:@"cell"];
+    NSUInteger index = indexPath.row;
+    RCTJSStackFrame *stackFrame = _lastStackTrace[index];
+    return [self reuseCell:cell forStackFrame:stackFrame];
+}
+
+- (UITableViewCell *)reuseCell:(UITableViewCell *)cell forErrorMessage:(NSString *)message
+{
+    if (!cell) {
+        cell = [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleSubtitle reuseIdentifier:@"msg-cell"];
+        cell.textLabel.accessibilityIdentifier = @"redbox-error";
+        cell.textLabel.textColor = [UIColor whiteColor];
+        cell.textLabel.font = [UIFont boldSystemFontOfSize:16];
+        cell.textLabel.lineBreakMode = NSLineBreakByWordWrapping;
+        cell.textLabel.numberOfLines = 0;
+        cell.detailTextLabel.textColor = [UIColor whiteColor];
+        cell.backgroundColor = [UIColor clearColor];
+        cell.selectionStyle = UITableViewCellSelectionStyleNone;
+    }
+
+    cell.textLabel.text = message;
+
+    return cell;
+}
+
+- (UITableViewCell *)reuseCell:(UITableViewCell *)cell forStackFrame:(RCTJSStackFrame *)stackFrame
+{
+    if (!cell) {
+        cell = [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleSubtitle reuseIdentifier:@"cell"];
+        cell.textLabel.textColor = [UIColor colorWithWhite:1 alpha:0.9];
+        cell.textLabel.font = [UIFont fontWithName:@"Menlo-Regular" size:14];
+        cell.textLabel.lineBreakMode = NSLineBreakByCharWrapping;
+        cell.textLabel.numberOfLines = 2;
+        cell.detailTextLabel.textColor = [UIColor colorWithWhite:1 alpha:0.7];
+        cell.detailTextLabel.font = [UIFont fontWithName:@"Menlo-Regular" size:11];
+        cell.detailTextLabel.lineBreakMode = NSLineBreakByTruncatingMiddle;
+        cell.backgroundColor = [UIColor clearColor];
+        cell.selectedBackgroundView = [UIView new];
+        cell.selectedBackgroundView.backgroundColor = [UIColor colorWithWhite:0 alpha:0.2];
+    }
+
+    cell.textLabel.text = stackFrame.methodName ?: @"(unnamed method)";
+    if (stackFrame.file) {
+        cell.detailTextLabel.text = [self formatFrameSource:stackFrame];
+    } else {
+        cell.detailTextLabel.text = @"";
+    }
+    return cell;
+}
+
+- (CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath
+{
+    if (indexPath.section == 0) {
+        NSMutableParagraphStyle *paragraphStyle = [[NSParagraphStyle defaultParagraphStyle] mutableCopy];
+        paragraphStyle.lineBreakMode = NSLineBreakByWordWrapping;
+
+        NSDictionary *attributes = @{NSFontAttributeName: [UIFont boldSystemFontOfSize:16],
+                                     NSParagraphStyleAttributeName: paragraphStyle};
+        CGRect boundingRect = [_lastErrorMessage boundingRectWithSize:CGSizeMake(tableView.frame.size.width - 30, CGFLOAT_MAX) options:NSStringDrawingUsesLineFragmentOrigin attributes:attributes context:nil];
+        return ceil(boundingRect.size.height) + 40;
+    } else {
+        return 50;
+    }
+}
+
+- (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath
+{
+    if (indexPath.section == 1) {
+        NSUInteger row = indexPath.row;
+        RCTJSStackFrame *stackFrame = _lastStackTrace[row];
+        [_actionDelegate redBoxWindow:self openStackFrameInEditor:stackFrame];
+    }
+    [tableView deselectRowAtIndexPath:indexPath animated:YES];
+}
+
+#pragma mark - Key commands
+
+- (NSArray<UIKeyCommand *> *)keyCommands
+{
+    // NOTE: We could use RCTKeyCommands for this, but since
+    // we control this window, we can use the standard, non-hacky
+    // mechanism instead
+
+    return @[
+             // Dismiss red box
+             [UIKeyCommand keyCommandWithInput:UIKeyInputEscape
+                                 modifierFlags:0
+                                        action:@selector(dismiss)],
+
+             // Reload
+             [UIKeyCommand keyCommandWithInput:@"r"
+                                 modifierFlags:UIKeyModifierCommand
+                                        action:@selector(reload)],
+
+             // Copy = Cmd-Option C since Cmd-C in the simulator copies the pasteboard from
+             // the simulator to the desktop pasteboard.
+             [UIKeyCommand keyCommandWithInput:@"c"
+                                 modifierFlags:UIKeyModifierCommand | UIKeyModifierAlternate
+                                        action:@selector(copyStack)],
+
+             // Extra data
+             [UIKeyCommand keyCommandWithInput:@"e"
+                                 modifierFlags:UIKeyModifierCommand
+                                        action:@selector(showExtraDataViewController)]
+             ];
+}
+
+- (BOOL)canBecomeFirstResponder
+{
+    return YES;
+}
+
+@end
+
+@interface RCTRedBox () <RCTInvalidating, RCTRedBoxWindowActionDelegate, RCTRedBoxExtraDataActionDelegate>
+@end
+
+@implementation RCTRedBox
+{
+    RCTRedBoxWindow *_window;
+    NSMutableArray<id<RCTErrorCustomizer>> *_errorCustomizers;
+    RCTRedBoxExtraDataViewController *_extraDataViewController;
+}
+
+@synthesize bridge = _bridge;
+
+RCT_EXPORT_MODULE()
+
+- (void)registerErrorCustomizer:(id<RCTErrorCustomizer>)errorCustomizer
+{
+    dispatch_async(dispatch_get_main_queue(), ^{
+        if (!self->_errorCustomizers) {
+            self->_errorCustomizers = [NSMutableArray array];
+        }
+        if (![self->_errorCustomizers containsObject:errorCustomizer]) {
+            [self->_errorCustomizers addObject:errorCustomizer];
+        }
+    });
+}
+
+// WARNING: Should only be called from the main thread/dispatch queue.
+- (RCTErrorInfo *)_customizeError:(RCTErrorInfo *)error
+{
+    RCTAssertMainQueue();
+    if (!self->_errorCustomizers) {
+        return error;
+    }
+    for (id<RCTErrorCustomizer> customizer in self->_errorCustomizers) {
+        RCTErrorInfo *newInfo = [customizer customizeErrorInfo:error];
+        if (newInfo) {
+            error = newInfo;
+        }
+    }
+    return error;
+}
+
+- (void)showError:(NSError *)error
+{
+    [self showErrorMessage:error.localizedDescription
+               withDetails:error.localizedFailureReason
+                     stack:error.userInfo[RCTJSStackTraceKey]];
+}
+
+- (void)showErrorMessage:(NSString *)message
+{
+    [self showErrorMessage:message withParsedStack:nil isUpdate:NO];
+}
+
+- (void)showErrorMessage:(NSString *)message withDetails:(NSString *)details
+{
+    [self showErrorMessage:message withDetails:details stack:nil];
+}
+
+- (void)showErrorMessage:(NSString *)message withDetails:(NSString *)details stack:(NSArray<RCTJSStackFrame *> *)stack {
+    NSString *combinedMessage = message;
+    if (details) {
+        combinedMessage = [NSString stringWithFormat:@"%@\n\n%@", message, details];
+    }
+    [self showErrorMessage:combinedMessage withParsedStack:stack isUpdate:NO];
+}
+
+- (void)showErrorMessage:(NSString *)message withRawStack:(NSString *)rawStack
+{
+    NSArray<RCTJSStackFrame *> *stack = [RCTJSStackFrame stackFramesWithLines:rawStack];
+    [self showErrorMessage:message withParsedStack:stack isUpdate:NO];
+}
+
+- (void)showErrorMessage:(NSString *)message withStack:(NSArray<NSDictionary *> *)stack
+{
+    [self showErrorMessage:message withParsedStack:[RCTJSStackFrame stackFramesWithDictionaries:stack] isUpdate:NO];
+}
+
+- (void)updateErrorMessage:(NSString *)message withStack:(NSArray<NSDictionary *> *)stack
+{
+    [self showErrorMessage:message withParsedStack:[RCTJSStackFrame stackFramesWithDictionaries:stack] isUpdate:YES];
+}
+
+- (void)showErrorMessage:(NSString *)message withParsedStack:(NSArray<RCTJSStackFrame *> *)stack
+{
+    [self showErrorMessage:message withParsedStack:stack isUpdate:NO];
+}
+
+- (void)updateErrorMessage:(NSString *)message withParsedStack:(NSArray<RCTJSStackFrame *> *)stack
+{
+    [self showErrorMessage:message withParsedStack:stack isUpdate:YES];
+}
+
+- (void)showErrorMessage:(NSString *)message withParsedStack:(NSArray<RCTJSStackFrame *> *)stack isUpdate:(BOOL)isUpdate
+{
+    dispatch_async(dispatch_get_main_queue(), ^{
+        if (self->_extraDataViewController == nil) {
+            self->_extraDataViewController = [RCTRedBoxExtraDataViewController new];
+            self->_extraDataViewController.actionDelegate = self;
+        }
+        [self->_bridge.eventDispatcher sendDeviceEventWithName:@"collectRedBoxExtraData" body:nil];
+
+        if (!self->_window) {
+            self->_window = [[RCTRedBoxWindow alloc] initWithFrame:[UIScreen mainScreen].bounds];
+            self->_window.actionDelegate = self;
+        }
+
+        RCTErrorInfo *errorInfo = [[RCTErrorInfo alloc] initWithErrorMessage:message
+                                                                       stack:stack];
+        errorInfo = [self _customizeError:errorInfo];
+        [self->_window showErrorMessage:errorInfo.errorMessage
+                              withStack:errorInfo.stack
+                               isUpdate:isUpdate];
+    });
+}
+
+- (void)loadExtraDataViewController {
+    dispatch_async(dispatch_get_main_queue(), ^{
+        // Make sure the CMD+E shortcut doesn't call this twice
+        if (self->_extraDataViewController != nil && ![self->_window.rootViewController presentedViewController]) {
+            [self->_window.rootViewController presentViewController:self->_extraDataViewController animated:YES completion:nil];
+        }
+    });
+}
+
+RCT_EXPORT_METHOD(setExtraData:(NSDictionary *)extraData forIdentifier:(NSString *)identifier) {
+    [_extraDataViewController addExtraData:extraData forIdentifier:identifier];
+}
+
+RCT_EXPORT_METHOD(dismiss)
+{
+    dispatch_async(dispatch_get_main_queue(), ^{
+        [self->_window dismiss];
+    });
+}
+
+- (void)invalidate
+{
+    [self dismiss];
+}
+
+- (void)redBoxWindow:(__unused RCTRedBoxWindow *)redBoxWindow openStackFrameInEditor:(RCTJSStackFrame *)stackFrame
+{
+    NSURL *const bundleURL = _overrideBundleURL ?: _bridge.bundleURL;
+    if (![bundleURL.scheme hasPrefix:@"http"]) {
+        RCTLogWarn(@"Cannot open stack frame in editor because you're not connected to the packager.");
+        return;
+    }
+
+    NSData *stackFrameJSON = [RCTJSONStringify([stackFrame toDictionary], NULL) dataUsingEncoding:NSUTF8StringEncoding];
+    NSString *postLength = [NSString stringWithFormat:@"%tu", stackFrameJSON.length];
+    NSMutableURLRequest *request = [NSMutableURLRequest new];
+    request.URL = [NSURL URLWithString:@"/open-stack-frame" relativeToURL:bundleURL];
+    request.HTTPMethod = @"POST";
+    request.HTTPBody = stackFrameJSON;
+    [request setValue:postLength forHTTPHeaderField:@"Content-Length"];
+    [request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
+
+    [[[NSURLSession sharedSession] dataTaskWithRequest:request] resume];
+}
+
+- (void)reload
+{
+    // Window is not used and can be nil
+    [self reloadFromRedBoxWindow:nil];
+}
+
+- (void)reloadFromRedBoxWindow:(__unused RCTRedBoxWindow *)redBoxWindow
+{
+    if (_overrideReloadAction) {
+        _overrideReloadAction();
+    } else {
+        [_bridge reload];
+    }
+    [self dismiss];
+}
+
+@end
+
+@implementation RCTBridge (RCTRedBox)
+
+- (RCTRedBox *)redBox
+{
+    return [self moduleForClass:[RCTRedBox class]];
+}
+
+@end
+
+#else // Disabled
+
+@implementation RCTRedBox
+
++ (NSString *)moduleName { return nil; }
+- (void)registerErrorCustomizer:(id<RCTErrorCustomizer>)errorCustomizer {}
+- (void)showError:(NSError *)message {}
+- (void)showErrorMessage:(NSString *)message {}
+- (void)showErrorMessage:(NSString *)message withDetails:(NSString *)details {}
+- (void)showErrorMessage:(NSString *)message withRawStack:(NSString *)rawStack {}
+- (void)showErrorMessage:(NSString *)message withStack:(NSArray<NSDictionary *> *)stack {}
+- (void)updateErrorMessage:(NSString *)message withStack:(NSArray<NSDictionary *> *)stack {}
+- (void)showErrorMessage:(NSString *)message withParsedStack:(NSArray<RCTJSStackFrame *> *)stack {}
+- (void)updateErrorMessage:(NSString *)message withParsedStack:(NSArray<RCTJSStackFrame *> *)stack {}
+- (void)showErrorMessage:(NSString *)message withStack:(NSArray<NSDictionary *> *)stack isUpdate:(BOOL)isUpdate {}
+- (void)dismiss {}
+
+@end
+
+@implementation RCTBridge (RCTRedBox)
+
+- (RCTRedBox *)redBox { return nil; }
+
+@end
+
+#endif

node_modules/react-native/React/Modules/RCTRedBoxExtraDataViewController.h

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * 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 RCTRedBoxExtraDataActionDelegate <NSObject>
+- (void)reload;
+@end
+
+@interface RCTRedBoxExtraDataViewController : UIViewController <UITableViewDelegate, UITableViewDataSource>
+
+@property (nonatomic, weak) id<RCTRedBoxExtraDataActionDelegate> actionDelegate;
+
+- (void)addExtraData:(NSDictionary *)data forIdentifier:(NSString *)identifier;
+
+@end

node_modules/react-native/React/Modules/RCTRedBoxExtraDataViewController.m

@@ -0,0 +1,292 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTRedBoxExtraDataViewController.h"
+
+@interface RCTRedBoxExtraDataCell : UITableViewCell
+
+@property (nonatomic, strong) UILabel *keyLabel;
+@property (nonatomic, strong) UILabel *valueLabel;
+
+@end
+
+@implementation RCTRedBoxExtraDataCell
+
+- (instancetype)initWithStyle:(UITableViewCellStyle)style
+              reuseIdentifier:(NSString *)reuseIdentifier
+{
+    if (self = [super initWithStyle:style reuseIdentifier:reuseIdentifier]) {
+        self.backgroundColor = [UIColor colorWithRed:0.8
+                                               green:0 blue:0
+                                               alpha:1];
+        UILayoutGuide *contentLayout =  self.contentView.layoutMarginsGuide;
+
+        self.keyLabel = [UILabel new];
+        [self.contentView addSubview:self.keyLabel];
+
+        self.keyLabel.translatesAutoresizingMaskIntoConstraints = NO;
+        [self.keyLabel.leadingAnchor
+            constraintEqualToAnchor:contentLayout.leadingAnchor].active = YES;
+        [self.keyLabel.topAnchor
+            constraintEqualToAnchor:contentLayout.topAnchor].active = YES;
+        [self.keyLabel.bottomAnchor
+            constraintEqualToAnchor:contentLayout.bottomAnchor].active = YES;
+        [self.keyLabel.widthAnchor
+            constraintEqualToAnchor:contentLayout.widthAnchor
+            multiplier:0.3].active = YES;
+
+
+        self.keyLabel.textColor = [UIColor whiteColor];
+        self.keyLabel.numberOfLines = 0;
+#if !TARGET_OS_TV
+        self.keyLabel.lineBreakMode = UILineBreakModeWordWrap;
+        self.keyLabel.font = [UIFont fontWithName:@"Menlo-Regular" size:12.0f];
+#endif
+        self.valueLabel = [UILabel new];
+        [self.contentView addSubview:self.valueLabel];
+
+        self.valueLabel.translatesAutoresizingMaskIntoConstraints = NO;
+        [self.valueLabel.leadingAnchor
+            constraintEqualToAnchor:self.keyLabel.trailingAnchor
+            constant:10.f].active = YES;
+        [self.valueLabel.trailingAnchor
+            constraintEqualToAnchor:contentLayout.trailingAnchor].active = YES;
+        [self.valueLabel.topAnchor
+            constraintEqualToAnchor:contentLayout.topAnchor].active = YES;
+        [self.valueLabel.bottomAnchor
+            constraintEqualToAnchor:contentLayout.bottomAnchor].active = YES;
+
+        self.valueLabel.textColor = [UIColor whiteColor];
+        self.valueLabel.numberOfLines = 0;
+#if !TARGET_OS_TV
+        self.valueLabel.lineBreakMode = UILineBreakModeWordWrap;
+        self.valueLabel.font = [UIFont fontWithName:@"Menlo-Regular" size:12.0f];
+#endif
+    }
+    return self;
+}
+
+@end
+
+@interface RCTRedBoxExtraDataViewController ()
+
+@end
+
+@implementation RCTRedBoxExtraDataViewController
+{
+    UITableView *_tableView;
+    NSMutableArray *_extraDataTitle;
+    NSMutableArray *_extraData;
+}
+
+@synthesize actionDelegate = _actionDelegate;
+
+- (instancetype)init
+{
+    if (self = [super init]) {
+        _extraData = [NSMutableArray new];
+        _extraDataTitle = [NSMutableArray new];
+        self.view.backgroundColor = [UIColor colorWithRed:0.8
+                                                    green:0
+                                                     blue:0
+                                                    alpha:1];
+
+        _tableView = [UITableView new];
+        _tableView.delegate = self;
+        _tableView.dataSource = self;
+        _tableView.backgroundColor = [UIColor clearColor];
+        _tableView.estimatedRowHeight = 200;
+#if !TARGET_OS_TV
+        _tableView.separatorStyle = UITableViewCellSeparatorStyleNone;
+#endif
+        _tableView.rowHeight = UITableViewAutomaticDimension;
+        _tableView.allowsSelection = NO;
+
+#if TARGET_OS_SIMULATOR
+        NSString *reloadText = @"Reload JS (\u2318R)";
+        NSString *dismissText = @"Dismiss (ESC)";
+#else
+        NSString *reloadText = @"Reload JS";
+        NSString *dismissText = @"Dismiss";
+#endif
+
+        UIButton *dismissButton = [UIButton buttonWithType:UIButtonTypeCustom];
+        dismissButton.translatesAutoresizingMaskIntoConstraints = NO;
+        dismissButton.accessibilityIdentifier = @"redbox-extra-data-dismiss";
+        dismissButton.titleLabel.font = [UIFont systemFontOfSize:13];
+        [dismissButton setTitle:dismissText forState:UIControlStateNormal];
+        [dismissButton setTitleColor:[UIColor colorWithWhite:1 alpha:0.5]
+                            forState:UIControlStateNormal];
+        [dismissButton setTitleColor:[UIColor whiteColor]
+                            forState:UIControlStateHighlighted];
+        [dismissButton addTarget:self
+                          action:@selector(dismiss)
+                forControlEvents:UIControlEventTouchUpInside];
+
+        UIButton *reloadButton = [UIButton buttonWithType:UIButtonTypeCustom];
+        reloadButton.accessibilityIdentifier = @"redbox-reload";
+        reloadButton.titleLabel.font = [UIFont systemFontOfSize:13];
+        [reloadButton setTitle:reloadText forState:UIControlStateNormal];
+        [reloadButton setTitleColor:[UIColor colorWithWhite:1 alpha:0.5]
+                           forState:UIControlStateNormal];
+        [reloadButton setTitleColor:[UIColor whiteColor]
+                            forState:UIControlStateHighlighted];
+        [reloadButton addTarget:self
+                          action:@selector(reload)
+                forControlEvents:UIControlEventTouchUpInside];
+
+        UIStackView *buttonStackView = [UIStackView new];
+        buttonStackView.axis = UILayoutConstraintAxisHorizontal;
+        buttonStackView.distribution = UIStackViewDistributionEqualSpacing;
+        buttonStackView.alignment = UIStackViewAlignmentFill;
+        buttonStackView.spacing = 20;
+
+        [buttonStackView addArrangedSubview:dismissButton];
+        [buttonStackView addArrangedSubview:reloadButton];
+        buttonStackView.translatesAutoresizingMaskIntoConstraints = NO;
+
+        UIStackView *mainStackView = [UIStackView new];
+        mainStackView.axis = UILayoutConstraintAxisVertical;
+        mainStackView.backgroundColor = [UIColor colorWithRed:0.8
+                                                        green:0 blue:0
+                                                        alpha:1];
+        [mainStackView addArrangedSubview:_tableView];
+        [mainStackView addArrangedSubview:buttonStackView];
+        mainStackView.translatesAutoresizingMaskIntoConstraints = NO;
+
+        [self.view addSubview:mainStackView];
+
+        CGFloat tableHeight = self.view.bounds.size.height - 60.f;
+        [_tableView.heightAnchor constraintEqualToConstant:tableHeight].active = YES;
+        [_tableView.widthAnchor constraintEqualToAnchor:self.view.widthAnchor].active = YES;
+
+        CGFloat buttonWidth = self.view.bounds.size.width / 4;
+        [dismissButton.heightAnchor constraintEqualToConstant:60].active = YES;
+        [dismissButton.widthAnchor
+            constraintEqualToConstant:buttonWidth].active = YES;
+        [reloadButton.heightAnchor constraintEqualToConstant:60].active = YES;
+        [reloadButton.widthAnchor
+            constraintEqualToConstant:buttonWidth].active = YES;
+    }
+    return self;
+}
+
+- (void)viewDidAppear:(BOOL)animated
+{
+    [super viewDidAppear:animated];
+    [_tableView reloadData];
+}
+
+- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section
+{
+    return [[_extraData objectAtIndex:section] count];
+}
+
+- (CGFloat)tableView:(UITableView *)tableView heightForHeaderInSection:(NSInteger)section
+{
+    return 40;
+}
+
+- (UIView *)tableView:(UITableView *)tableView viewForHeaderInSection:(NSInteger)section
+{
+    UIView *view = [UIView new];
+    view.backgroundColor = [UIColor colorWithRed:1 green:0 blue:0 alpha:1];
+
+    UILabel *header = [UILabel new];
+    [view addSubview:header];
+
+    header.translatesAutoresizingMaskIntoConstraints = NO;
+    [header.leadingAnchor
+        constraintEqualToAnchor:view.leadingAnchor constant:5].active = YES;
+    [header.trailingAnchor
+        constraintEqualToAnchor:view.trailingAnchor].active = YES;
+    [header.topAnchor
+        constraintEqualToAnchor:view.topAnchor].active = YES;
+    [header.bottomAnchor
+        constraintEqualToAnchor:view.bottomAnchor].active = YES;
+
+    header.textColor = [UIColor whiteColor];
+    header.font = [UIFont fontWithName:@"Menlo-Bold" size:14.0f];
+    header.text = [_extraDataTitle[section] uppercaseString];
+
+    return view;
+}
+
+- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
+{
+    static NSString *reuseIdentifier = @"RedBoxExtraData";
+
+    RCTRedBoxExtraDataCell *cell =
+            (RCTRedBoxExtraDataCell *)[tableView
+            dequeueReusableCellWithIdentifier:reuseIdentifier];
+
+    if (cell == nil) {
+        cell = [[RCTRedBoxExtraDataCell alloc]
+                initWithStyle:UITableViewCellStyleDefault
+                reuseIdentifier:reuseIdentifier];
+    }
+
+    NSArray *dataKVPair = _extraData[indexPath.section][indexPath.row];
+    cell.keyLabel.text = dataKVPair[0];
+    cell.valueLabel.text = dataKVPair[1];
+
+    return cell;
+}
+
+- (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView
+{
+    return _extraDataTitle.count;
+}
+
+- (void)addExtraData:(NSDictionary *)data forIdentifier:(NSString *)identifier
+{
+    dispatch_async(dispatch_get_main_queue(), ^{
+        NSMutableArray *newData = [NSMutableArray new];
+        for (id key in data) {
+            [newData addObject:@[[NSString stringWithFormat:@"%@", key],
+                [NSString stringWithFormat:@"%@", [data objectForKey:key]]]];
+        }
+
+        NSInteger idx = [self->_extraDataTitle indexOfObject:identifier];
+        if (idx == NSNotFound) {
+            [self->_extraDataTitle addObject:identifier];
+            [self->_extraData addObject:newData];
+        } else {
+            [self->_extraData replaceObjectAtIndex:idx withObject:newData];
+        }
+
+        [self->_tableView reloadData];
+    });
+}
+
+- (void)dismiss
+{
+    [self dismissViewControllerAnimated:YES completion:nil];
+}
+
+- (void)reload
+{
+    [_actionDelegate reload];
+}
+
+#pragma mark - Key commands
+
+- (NSArray<UIKeyCommand *> *)keyCommands
+{
+    return @[
+             // Dismiss
+             [UIKeyCommand keyCommandWithInput:UIKeyInputEscape
+                                 modifierFlags:0
+                                        action:@selector(dismiss)],
+             // Reload
+             [UIKeyCommand keyCommandWithInput:@"r"
+                                 modifierFlags:UIKeyModifierCommand
+                                        action:@selector(reload)]
+    ];
+}
+
+@end

node_modules/react-native/React/Modules/RCTSourceCode.h

@@ -0,0 +1,14 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * 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/RCTBridgeModule.h>
+
+@interface RCTSourceCode : NSObject <RCTBridgeModule>
+
+@end

node_modules/react-native/React/Modules/RCTSourceCode.m

@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTSourceCode.h"
+
+#import "RCTBridge.h"
+
+@implementation RCTSourceCode
+
+RCT_EXPORT_MODULE()
+
+@synthesize bridge = _bridge;
+
++ (BOOL)requiresMainQueueSetup
+{
+  return NO;
+}
+
+- (NSDictionary<NSString *, id> *)constantsToExport
+{
+  return @{
+    @"scriptURL": self.bridge.bundleURL.absoluteString ?: @"",
+  };
+}
+
+@end

node_modules/react-native/React/Modules/RCTStatusBarManager.h

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * 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/RCTConvert.h>
+#import <React/RCTEventEmitter.h>
+
+@interface RCTConvert (UIStatusBar)
+
+#if !TARGET_OS_TV
++ (UIStatusBarStyle)UIStatusBarStyle:(id)json;
++ (UIStatusBarAnimation)UIStatusBarAnimation:(id)json;
+#endif
+
+@end
+
+@interface RCTStatusBarManager : RCTEventEmitter
+
+@end

node_modules/react-native/React/Modules/RCTStatusBarManager.m

@@ -0,0 +1,135 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTStatusBarManager.h"
+
+#import "RCTEventDispatcher.h"
+#import "RCTLog.h"
+#import "RCTUtils.h"
+
+#if !TARGET_OS_TV
+@implementation RCTConvert (UIStatusBar)
+
+RCT_ENUM_CONVERTER(UIStatusBarStyle, (@{
+  @"default": @(UIStatusBarStyleDefault),
+  @"light-content": @(UIStatusBarStyleLightContent),
+  @"dark-content": @(UIStatusBarStyleDefault),
+}), UIStatusBarStyleDefault, integerValue);
+
+RCT_ENUM_CONVERTER(UIStatusBarAnimation, (@{
+  @"none": @(UIStatusBarAnimationNone),
+  @"fade": @(UIStatusBarAnimationFade),
+  @"slide": @(UIStatusBarAnimationSlide),
+}), UIStatusBarAnimationNone, integerValue);
+
+@end
+#endif
+
+@implementation RCTStatusBarManager
+
+static BOOL RCTViewControllerBasedStatusBarAppearance()
+{
+  static BOOL value;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    value = [[[NSBundle mainBundle] objectForInfoDictionaryKey:
+              @"UIViewControllerBasedStatusBarAppearance"] ?: @YES boolValue];
+  });
+
+  return value;
+}
+
+RCT_EXPORT_MODULE()
+
+- (NSArray<NSString *> *)supportedEvents
+{
+  return @[@"statusBarFrameDidChange",
+           @"statusBarFrameWillChange"];
+}
+
+#if !TARGET_OS_TV
+
+- (void)startObserving
+{
+  NSNotificationCenter *nc = [NSNotificationCenter defaultCenter];
+  [nc addObserver:self selector:@selector(applicationDidChangeStatusBarFrame:) name:UIApplicationDidChangeStatusBarFrameNotification object:nil];
+  [nc addObserver:self selector:@selector(applicationWillChangeStatusBarFrame:) name:UIApplicationWillChangeStatusBarFrameNotification object:nil];
+}
+
+- (void)stopObserving
+{
+  [[NSNotificationCenter defaultCenter] removeObserver:self];
+}
+
+- (dispatch_queue_t)methodQueue
+{
+  return dispatch_get_main_queue();
+}
+
+- (void)emitEvent:(NSString *)eventName forNotification:(NSNotification *)notification
+{
+  CGRect frame = [notification.userInfo[UIApplicationStatusBarFrameUserInfoKey] CGRectValue];
+  NSDictionary *event = @{
+    @"frame": @{
+      @"x": @(frame.origin.x),
+      @"y": @(frame.origin.y),
+      @"width": @(frame.size.width),
+      @"height": @(frame.size.height),
+    },
+  };
+  [self sendEventWithName:eventName body:event];
+}
+
+- (void)applicationDidChangeStatusBarFrame:(NSNotification *)notification
+{
+  [self emitEvent:@"statusBarFrameDidChange" forNotification:notification];
+}
+
+- (void)applicationWillChangeStatusBarFrame:(NSNotification *)notification
+{
+  [self emitEvent:@"statusBarFrameWillChange" forNotification:notification];
+}
+
+RCT_EXPORT_METHOD(getHeight:(RCTResponseSenderBlock)callback)
+{
+  callback(@[@{
+    @"height": @(RCTSharedApplication().statusBarFrame.size.height),
+  }]);
+}
+
+RCT_EXPORT_METHOD(setStyle:(UIStatusBarStyle)statusBarStyle
+                  animated:(BOOL)animated)
+{
+  if (RCTViewControllerBasedStatusBarAppearance()) {
+    RCTLogError(@"RCTStatusBarManager module requires that the \
+                UIViewControllerBasedStatusBarAppearance key in the Info.plist is set to NO");
+  } else {
+    [RCTSharedApplication() setStatusBarStyle:statusBarStyle
+                                     animated:animated];
+  }
+}
+
+RCT_EXPORT_METHOD(setHidden:(BOOL)hidden
+                  withAnimation:(UIStatusBarAnimation)animation)
+{
+  if (RCTViewControllerBasedStatusBarAppearance()) {
+    RCTLogError(@"RCTStatusBarManager module requires that the \
+                UIViewControllerBasedStatusBarAppearance key in the Info.plist is set to NO");
+  } else {
+    [RCTSharedApplication() setStatusBarHidden:hidden
+                                 withAnimation:animation];
+  }
+}
+
+RCT_EXPORT_METHOD(setNetworkActivityIndicatorVisible:(BOOL)visible)
+{
+  RCTSharedApplication().networkActivityIndicatorVisible = visible;
+}
+
+#endif //TARGET_OS_TV
+
+@end

node_modules/react-native/React/Modules/RCTTVNavigationEventEmitter.h

@@ -0,0 +1,14 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTEventEmitter.h"
+
+RCT_EXTERN NSString *const RCTTVNavigationEventNotification;
+
+@interface RCTTVNavigationEventEmitter : RCTEventEmitter
+
+@end

node_modules/react-native/React/Modules/RCTTVNavigationEventEmitter.m

@@ -0,0 +1,52 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTTVNavigationEventEmitter.h"
+
+NSString *const RCTTVNavigationEventNotification = @"RCTTVNavigationEventNotification";
+
+static NSString *const TVNavigationEventName = @"onHWKeyEvent";
+
+@implementation RCTTVNavigationEventEmitter
+
+RCT_EXPORT_MODULE()
+
++ (BOOL)requiresMainQueueSetup
+{
+  return NO;
+}
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    [[NSNotificationCenter defaultCenter] addObserver:self
+                                             selector:@selector(handleTVNavigationEventNotification:)
+                                                 name:RCTTVNavigationEventNotification
+                                               object:nil];
+
+  }
+  return self;
+}
+
+- (void)dealloc
+{
+  [[NSNotificationCenter defaultCenter] removeObserver:self];
+}
+
+- (NSArray<NSString *> *)supportedEvents
+{
+  return @[TVNavigationEventName];
+}
+
+- (void)handleTVNavigationEventNotification:(NSNotification *)notif
+{
+  if (self.bridge) {
+    [self sendEventWithName:TVNavigationEventName body:notif.object];
+  }
+}
+
+@end

node_modules/react-native/React/Modules/RCTTiming.h

@@ -0,0 +1,16 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * 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/RCTBridgeModule.h>
+#import <React/RCTFrameUpdate.h>
+#import <React/RCTInvalidating.h>
+
+@interface RCTTiming : NSObject <RCTBridgeModule, RCTInvalidating, RCTFrameUpdateObserver>
+
+@end

node_modules/react-native/React/Modules/RCTTiming.m

@@ -0,0 +1,325 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTTiming.h"
+
+#import "RCTAssert.h"
+#import "RCTBridge+Private.h"
+#import "RCTBridge.h"
+#import "RCTLog.h"
+#import "RCTUtils.h"
+
+static const NSTimeInterval kMinimumSleepInterval = 1;
+
+// These timing contants should be kept in sync with the ones in `JSTimers.js`.
+// The duration of a frame. This assumes that we want to run at 60 fps.
+static const NSTimeInterval kFrameDuration = 1.0 / 60.0;
+// The minimum time left in a frame to trigger the idle callback.
+static const NSTimeInterval kIdleCallbackFrameDeadline = 0.001;
+
+@interface _RCTTimer : NSObject
+
+@property (nonatomic, strong, readonly) NSDate *target;
+@property (nonatomic, assign, readonly) BOOL repeats;
+@property (nonatomic, copy, readonly) NSNumber *callbackID;
+@property (nonatomic, assign, readonly) NSTimeInterval interval;
+
+@end
+
+@implementation _RCTTimer
+
+- (instancetype)initWithCallbackID:(NSNumber *)callbackID
+                          interval:(NSTimeInterval)interval
+                        targetTime:(NSTimeInterval)targetTime
+                           repeats:(BOOL)repeats
+{
+  if ((self = [super init])) {
+    _interval = interval;
+    _repeats = repeats;
+    _callbackID = callbackID;
+    _target = [NSDate dateWithTimeIntervalSinceNow:targetTime];
+  }
+  return self;
+}
+
+/**
+ * Returns `YES` if we should invoke the JS callback.
+ */
+- (BOOL)shouldFire:(NSDate *)now
+{
+  if (_target && [_target timeIntervalSinceDate:now] <= 0) {
+    return YES;
+  }
+  return NO;
+}
+
+- (void)reschedule
+{
+  // The JS Timers will do fine grained calculating of expired timeouts.
+  _target = [NSDate dateWithTimeIntervalSinceNow:_interval];
+}
+
+@end
+
+@interface _RCTTimingProxy : NSObject
+
+@end
+
+// NSTimer retains its target, insert this class to break potential retain cycles
+@implementation _RCTTimingProxy
+{
+  __weak id _target;
+}
+
++ (instancetype)proxyWithTarget:(id)target
+{
+  _RCTTimingProxy *proxy = [self new];
+  if (proxy) {
+    proxy->_target = target;
+  }
+  return proxy;
+}
+
+- (void)timerDidFire
+{
+  [_target timerDidFire];
+}
+
+@end
+
+@implementation RCTTiming
+{
+  NSMutableDictionary<NSNumber *, _RCTTimer *> *_timers;
+  NSTimer *_sleepTimer;
+  BOOL _sendIdleEvents;
+}
+
+@synthesize bridge = _bridge;
+@synthesize paused = _paused;
+@synthesize pauseCallback = _pauseCallback;
+
+RCT_EXPORT_MODULE()
+
+- (void)setBridge:(RCTBridge *)bridge
+{
+  RCTAssert(!_bridge, @"Should never be initialized twice!");
+
+  _paused = YES;
+  _timers = [NSMutableDictionary new];
+
+  for (NSString *name in @[UIApplicationWillResignActiveNotification,
+                           UIApplicationDidEnterBackgroundNotification,
+                           UIApplicationWillTerminateNotification]) {
+    [[NSNotificationCenter defaultCenter] addObserver:self
+                                             selector:@selector(stopTimers)
+                                                 name:name
+                                               object:nil];
+  }
+
+  for (NSString *name in @[UIApplicationDidBecomeActiveNotification,
+                           UIApplicationWillEnterForegroundNotification]) {
+    [[NSNotificationCenter defaultCenter] addObserver:self
+                                             selector:@selector(startTimers)
+                                                 name:name
+                                               object:nil];
+  }
+
+  _bridge = bridge;
+}
+
+- (void)dealloc
+{
+  [_sleepTimer invalidate];
+  [[NSNotificationCenter defaultCenter] removeObserver:self];
+}
+
+- (dispatch_queue_t)methodQueue
+{
+  return RCTJSThread;
+}
+
+- (void)invalidate
+{
+  [self stopTimers];
+  _bridge = nil;
+}
+
+- (void)stopTimers
+{
+  if (!_paused) {
+    _paused = YES;
+    if (_pauseCallback) {
+      _pauseCallback();
+    }
+  }
+}
+
+- (void)startTimers
+{
+  if (!_bridge || ![self hasPendingTimers]) {
+    return;
+  }
+
+  if (_paused) {
+    _paused = NO;
+    if (_pauseCallback) {
+      _pauseCallback();
+    }
+  }
+}
+
+- (BOOL)hasPendingTimers
+{
+  return _sendIdleEvents || _timers.count > 0;
+}
+
+- (void)didUpdateFrame:(RCTFrameUpdate *)update
+{
+  NSDate *nextScheduledTarget = [NSDate distantFuture];
+  NSMutableArray<_RCTTimer *> *timersToCall = [NSMutableArray new];
+  NSDate *now = [NSDate date]; // compare all the timers to the same base time
+  for (_RCTTimer *timer in _timers.allValues) {
+    if ([timer shouldFire:now]) {
+      [timersToCall addObject:timer];
+    } else {
+      nextScheduledTarget = [nextScheduledTarget earlierDate:timer.target];
+    }
+  }
+
+  // Call timers that need to be called
+  if (timersToCall.count > 0) {
+    NSArray<NSNumber *> *sortedTimers = [[timersToCall sortedArrayUsingComparator:^(_RCTTimer *a, _RCTTimer *b) {
+      return [a.target compare:b.target];
+    }] valueForKey:@"callbackID"];
+    [_bridge enqueueJSCall:@"JSTimers"
+                    method:@"callTimers"
+                      args:@[sortedTimers]
+                completion:NULL];
+  }
+
+  for (_RCTTimer *timer in timersToCall) {
+    if (timer.repeats) {
+      [timer reschedule];
+      nextScheduledTarget = [nextScheduledTarget earlierDate:timer.target];
+    } else {
+      [_timers removeObjectForKey:timer.callbackID];
+    }
+  }
+
+  if (_sendIdleEvents) {
+    NSTimeInterval frameElapsed = (CACurrentMediaTime() - update.timestamp);
+    if (kFrameDuration - frameElapsed >= kIdleCallbackFrameDeadline) {
+      NSTimeInterval currentTimestamp = [[NSDate date] timeIntervalSince1970];
+      NSNumber *absoluteFrameStartMS = @((currentTimestamp - frameElapsed) * 1000);
+      [_bridge enqueueJSCall:@"JSTimers"
+                      method:@"callIdleCallbacks"
+                        args:@[absoluteFrameStartMS]
+                  completion:NULL];
+    }
+  }
+
+  // Switch to a paused state only if we didn't call any timer this frame, so if
+  // in response to this timer another timer is scheduled, we don't pause and unpause
+  // the displaylink frivolously.
+  if (!_sendIdleEvents && timersToCall.count == 0) {
+    // No need to call the pauseCallback as RCTDisplayLink will ask us about our paused
+    // status immediately after completing this call
+    if (_timers.count == 0) {
+      _paused = YES;
+    }
+    // If the next timer is more than 1 second out, pause and schedule an NSTimer;
+    else if ([nextScheduledTarget timeIntervalSinceNow] > kMinimumSleepInterval) {
+      [self scheduleSleepTimer:nextScheduledTarget];
+      _paused = YES;
+    }
+  }
+}
+
+- (void)scheduleSleepTimer:(NSDate *)sleepTarget
+{
+  if (!_sleepTimer || !_sleepTimer.valid) {
+    _sleepTimer = [[NSTimer alloc] initWithFireDate:sleepTarget
+                                           interval:0
+                                             target:[_RCTTimingProxy proxyWithTarget:self]
+                                           selector:@selector(timerDidFire)
+                                           userInfo:nil
+                                            repeats:NO];
+    [[NSRunLoop currentRunLoop] addTimer:_sleepTimer forMode:NSDefaultRunLoopMode];
+  } else {
+    _sleepTimer.fireDate = [_sleepTimer.fireDate earlierDate:sleepTarget];
+  }
+}
+
+- (void)timerDidFire
+{
+  _sleepTimer = nil;
+  if (_paused) {
+    [self startTimers];
+
+    // Immediately dispatch frame, so we don't have to wait on the displaylink.
+    [self didUpdateFrame:nil];
+  }
+}
+
+/**
+ * There's a small difference between the time when we call
+ * setTimeout/setInterval/requestAnimation frame and the time it actually makes
+ * it here. This is important and needs to be taken into account when
+ * calculating the timer's target time. We calculate this by passing in
+ * Date.now() from JS and then subtracting that from the current time here.
+ */
+RCT_EXPORT_METHOD(createTimer:(nonnull NSNumber *)callbackID
+                  duration:(NSTimeInterval)jsDuration
+                  jsSchedulingTime:(NSDate *)jsSchedulingTime
+                  repeats:(BOOL)repeats)
+{
+  if (jsDuration == 0 && repeats == NO) {
+    // For super fast, one-off timers, just enqueue them immediately rather than waiting a frame.
+    [_bridge _immediatelyCallTimer:callbackID];
+    return;
+  }
+
+  NSTimeInterval jsSchedulingOverhead = MAX(-jsSchedulingTime.timeIntervalSinceNow, 0);
+
+  NSTimeInterval targetTime = jsDuration - jsSchedulingOverhead;
+  if (jsDuration < 0.018) { // Make sure short intervals run each frame
+    jsDuration = 0;
+  }
+
+  _RCTTimer *timer = [[_RCTTimer alloc] initWithCallbackID:callbackID
+                                                  interval:jsDuration
+                                                targetTime:targetTime
+                                                   repeats:repeats];
+  _timers[callbackID] = timer;
+  if (_paused) {
+    if ([timer.target timeIntervalSinceNow] > kMinimumSleepInterval) {
+      [self scheduleSleepTimer:timer.target];
+    } else {
+      [self startTimers];
+    }
+  }
+}
+
+RCT_EXPORT_METHOD(deleteTimer:(nonnull NSNumber *)timerID)
+{
+  [_timers removeObjectForKey:timerID];
+  if (![self hasPendingTimers]) {
+    [self stopTimers];
+  }
+}
+
+RCT_EXPORT_METHOD(setSendIdleEvents:(BOOL)sendIdleEvents)
+{
+  _sendIdleEvents = sendIdleEvents;
+  if (sendIdleEvents) {
+    [self startTimers];
+  } else if (![self hasPendingTimers]) {
+    [self stopTimers];
+  }
+}
+
+@end

node_modules/react-native/React/Modules/RCTUIManager.h

@@ -0,0 +1,166 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * 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/RCTBridge.h>
+#import <React/RCTBridgeModule.h>
+#import <React/RCTInvalidating.h>
+#import <React/RCTRootView.h>
+#import <React/RCTViewManager.h>
+
+/**
+ * Posted right before re-render happens. This is a chance for views to invalidate their state so
+ * next render cycle will pick up updated views and layout appropriately.
+ */
+RCT_EXTERN NSString *const RCTUIManagerWillUpdateViewsDueToContentSizeMultiplierChangeNotification;
+
+@class RCTLayoutAnimationGroup;
+@class RCTUIManagerObserverCoordinator;
+
+/**
+ * The RCTUIManager is the module responsible for updating the view hierarchy.
+ */
+@interface RCTUIManager : NSObject <RCTBridgeModule, RCTInvalidating>
+
+/**
+ * Register a root view tag and creates corresponding `rootView` and
+ * `rootShadowView`.
+ */
+- (void)registerRootViewTag:(NSNumber *)rootTag;
+
+/**
+ * Register a root view with the RCTUIManager.
+ */
+- (void)registerRootView:(UIView *)rootView;
+
+/**
+ * Gets the view name associated with a reactTag.
+ */
+- (NSString *)viewNameForReactTag:(NSNumber *)reactTag;
+
+/**
+ * Gets the view associated with a reactTag.
+ */
+- (UIView *)viewForReactTag:(NSNumber *)reactTag;
+
+/**
+ * Gets the shadow view associated with a reactTag.
+ */
+- (RCTShadowView *)shadowViewForReactTag:(NSNumber *)reactTag;
+
+/**
+ * Set the available size (`availableSize` property) for a root view.
+ * This might be used in response to changes in external layout constraints.
+ * This value will be directly trasmitted to layout engine and defines how big viewport is;
+ * this value does not affect root node size style properties.
+ * Can be considered as something similar to `setSize:forView:` but applicable only for root view.
+ */
+- (void)setAvailableSize:(CGSize)availableSize forRootView:(UIView *)rootView;
+
+/**
+ * Sets local data for a shadow view corresponded with given view.
+ * In some cases we need a way to specify some environmental data to shadow view
+ * to improve layout (or do something similar), so `localData` serves these needs.
+ * For example, any stateful embedded native views may benefit from this.
+ * Have in mind that this data is not supposed to interfere with the state of
+ * the shadow view.
+ * Please respect one-directional data flow of React.
+ */
+- (void)setLocalData:(NSObject *)localData forView:(UIView *)view;
+
+/**
+ * Set the size of a view. This might be in response to a screen rotation
+ * or some other layout event outside of the React-managed view hierarchy.
+ */
+- (void)setSize:(CGSize)size forView:(UIView *)view;
+
+/**
+ * Set the natural size of a view, which is used when no explicit size is set.
+ * Use `UIViewNoIntrinsicMetric` to ignore a dimension.
+ * The `size` must NOT include padding and border.
+ */
+- (void)setIntrinsicContentSize:(CGSize)intrinsicContentSize forView:(UIView *)view;
+
+/**
+ * Sets up layout animation which will perform on next layout pass.
+ * The animation will affect only one next layout pass.
+ * Must be called on the main queue.
+ */
+- (void)setNextLayoutAnimationGroup:(RCTLayoutAnimationGroup *)layoutAnimationGroup;
+
+/**
+ * Schedule a block to be executed on the UI thread. Useful if you need to execute
+ * view logic after all currently queued view updates have completed.
+ */
+- (void)addUIBlock:(RCTViewManagerUIBlock)block;
+
+/**
+ * Schedule a block to be executed on the UI thread. Useful if you need to execute
+ * view logic before all currently queued view updates have completed.
+ */
+- (void)prependUIBlock:(RCTViewManagerUIBlock)block;
+
+/**
+ * Used by native animated module to bypass the process of updating the values through the shadow
+ * view hierarchy. This method will directly update native views, which means that updates for
+ * layout-related propertied won't be handled properly.
+ * Make sure you know what you're doing before calling this method :)
+ */
+- (void)synchronouslyUpdateViewOnUIThread:(NSNumber *)reactTag
+                                 viewName:(NSString *)viewName
+                                    props:(NSDictionary *)props;
+
+/**
+ * Given a reactTag from a component, find its root view, if possible.
+ * Otherwise, this will give back nil.
+ *
+ * @param reactTag the component tag
+ * @param completion the completion block that will hand over the rootView, if any.
+ *
+ */
+- (void)rootViewForReactTag:(NSNumber *)reactTag withCompletion:(void (^)(UIView *view))completion;
+
+/**
+ * Finds a view that is tagged with nativeID as its nativeID prop
+ * with the associated rootTag root tag view hierarchy. Returns the
+ * view if found, nil otherwise.
+ *
+ * @param nativeID the id reference to native component relative to root view.
+ * @param rootTag the react tag of root view hierarchy from which to find the view.
+ */
+- (UIView *)viewForNativeID:(NSString *)nativeID withRootTag:(NSNumber *)rootTag;
+
+/**
+ * The view that is currently first responder, according to the JS context.
+ */
++ (UIView *)JSResponder;
+
+/**
+ * In some cases we might want to trigger layout from native side.
+ * React won't be aware of this, so we need to make sure it happens.
+ */
+- (void)setNeedsLayout;
+
+/**
+ * Dedicated object for subscribing for UIManager events.
+ * See `RCTUIManagerObserver` protocol for more details.
+ */
+@property (atomic, retain, readonly) RCTUIManagerObserverCoordinator *observerCoordinator;
+
+@end
+
+/**
+ * This category makes the current RCTUIManager instance available via the
+ * RCTBridge, which is useful for RCTBridgeModules or RCTViewManagers that
+ * need to access the RCTUIManager.
+ */
+@interface RCTBridge (RCTUIManager)
+
+@property (nonatomic, readonly) RCTUIManager *uiManager;
+
+@end

node_modules/react-native/React/Modules/RCTUIManagerObserverCoordinator.h

@@ -0,0 +1,81 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * 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/RCTViewManager.h>
+
+typedef dispatch_block_t RCTUIManagerMountingBlock;
+
+/**
+ * Allows hooking into UIManager internals. This can be used to execute code at
+ * specific points during the view updating process.
+ * New observers must not be added inside observer handlers.
+ * The particular order of handler invocation is not guaranteed.
+ * All observer handlers are called on UIManager queue.
+ */
+@protocol RCTUIManagerObserver <NSObject>
+
+@optional
+
+/**
+ * Called just before the UIManager layout views.
+ * It allows performing some operation for components which contain custom
+ * layout logic right before regular Yoga based layout. So, for instance,
+ * some components which have own React-independent state can compute and cache
+ * own intrinsic content size (which will be used by Yoga) at this point.
+ */
+- (void)uiManagerWillPerformLayout:(RCTUIManager *)manager;
+
+/**
+ * Called just after the UIManager layout views.
+ * It allows performing custom layout logic right after regular Yoga based layout.
+ * So, for instance, this can be used for computing final layout for a component,
+ * since it has its final frame set by Yoga at this point.
+ */
+- (void)uiManagerDidPerformLayout:(RCTUIManager *)manager;
+
+/**
+ * Called before flushing UI blocks at the end of a batch.
+ * This is called from the UIManager queue. Can be used to add UI operations in that batch.
+ */
+- (void)uiManagerWillPerformMounting:(RCTUIManager *)manager;
+
+/**
+ * Called right before flushing UI blocks and allows to intercept the mounting process.
+ * Return `YES` to cancel default execution of the `block` (and perform the
+ * execution later).
+ */
+- (BOOL)uiManager:(RCTUIManager *)manager performMountingWithBlock:(RCTUIManagerMountingBlock)block;
+
+/**
+ * Called just after flushing UI blocks.
+ * This is called from the UIManager queue.
+ */
+- (void)uiManagerDidPerformMounting:(RCTUIManager *)manager;
+
+@end
+
+/**
+ * Simple helper which take care of RCTUIManager's observers.
+ */
+@interface RCTUIManagerObserverCoordinator : NSObject <RCTUIManagerObserver>
+
+/**
+ * Add a UIManagerObserver. See the `RCTUIManagerObserver` protocol for more info.
+ * References to observers are held weakly.
+ * This method can be called safely from any queue.
+ */
+- (void)addObserver:(id<RCTUIManagerObserver>)observer;
+
+/**
+ * Remove a `UIManagerObserver`.
+ * This method can be called safely from any queue.
+ */
+- (void)removeObserver:(id<RCTUIManagerObserver>)observer;
+
+@end

node_modules/react-native/React/Modules/RCTUIManagerObserverCoordinator.mm

@@ -0,0 +1,101 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTUIManagerObserverCoordinator.h"
+
+#import <mutex>
+
+#import "RCTUIManager.h"
+
+@implementation RCTUIManagerObserverCoordinator {
+  NSHashTable<id<RCTUIManagerObserver>> *_observers;
+  std::mutex _mutex;
+}
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _observers = [[NSHashTable alloc] initWithOptions:NSHashTableWeakMemory capacity:0];
+  }
+
+  return self;
+}
+
+- (void)addObserver:(id<RCTUIManagerObserver>)observer
+{
+  std::lock_guard<std::mutex> lock(_mutex);
+  [self->_observers addObject:observer];
+}
+
+- (void)removeObserver:(id<RCTUIManagerObserver>)observer
+{
+  std::lock_guard<std::mutex> lock(_mutex);
+  [self->_observers removeObject:observer];
+}
+
+#pragma mark - RCTUIManagerObserver
+
+- (void)uiManagerWillPerformLayout:(RCTUIManager *)manager
+{
+  std::lock_guard<std::mutex> lock(_mutex);
+
+  for (id<RCTUIManagerObserver> observer in _observers) {
+    if ([observer respondsToSelector:@selector(uiManagerWillPerformLayout:)]) {
+      [observer uiManagerWillPerformLayout:manager];
+    }
+  }
+}
+
+- (void)uiManagerDidPerformLayout:(RCTUIManager *)manager
+{
+  std::lock_guard<std::mutex> lock(_mutex);
+
+  for (id<RCTUIManagerObserver> observer in _observers) {
+    if ([observer respondsToSelector:@selector(uiManagerDidPerformLayout:)]) {
+      [observer uiManagerDidPerformLayout:manager];
+    }
+  }
+}
+
+- (void)uiManagerWillPerformMounting:(RCTUIManager *)manager
+{
+  std::lock_guard<std::mutex> lock(_mutex);
+
+  for (id<RCTUIManagerObserver> observer in _observers) {
+    if ([observer respondsToSelector:@selector(uiManagerWillPerformMounting:)]) {
+      [observer uiManagerWillPerformMounting:manager];
+    }
+  }
+}
+
+- (BOOL)uiManager:(RCTUIManager *)manager performMountingWithBlock:(RCTUIManagerMountingBlock)block
+{
+  std::lock_guard<std::mutex> lock(_mutex);
+
+  for (id<RCTUIManagerObserver> observer in _observers) {
+    if ([observer respondsToSelector:@selector(uiManager:performMountingWithBlock:)]) {
+      if ([observer uiManager:manager performMountingWithBlock:block]) {
+        return YES;
+      }
+    }
+  }
+  return NO;
+}
+
+- (void)uiManagerDidPerformMounting:(RCTUIManager *)manager
+{
+  std::lock_guard<std::mutex> lock(_mutex);
+
+  for (id<RCTUIManagerObserver> observer in _observers) {
+    if ([observer respondsToSelector:@selector(uiManagerDidPerformMounting:)]) {
+      [observer uiManagerDidPerformMounting:manager];
+    }
+  }
+}
+
+
+@end

node_modules/react-native/React/Modules/RCTUIManagerUtils.h

@@ -0,0 +1,104 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * 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/RCTAssert.h>
+#import <React/RCTDefines.h>
+
+/**
+ * Queues Problem Intro:
+ * UIManager queue is a special queue because it has a special relationship with
+ * the Main queue.
+ *
+ * This particular relationship comes from two key factors:
+ *  1. UIManager initiates execution of many blocks on the Main queue;
+ *  2. In some cases, we want to initiate (and wait for) some UIManager's work *synchronously* from
+ *     the Main queue.
+ *
+ * So, how can we meet these criteria?
+ * "Pseudo UIManager queue" comes to rescue!
+ *
+ * "Pseudo UIManager queue" means the safe execution of typical UIManager's work
+ * on the Main queue while the UIManager queue is explicitly blocked for preventing
+ * simultaneous/concurrent memory access.
+ *
+ * So, how can we technically do this?
+ *  1. `RCTAssertUIManagerQueue` is okay with execution on both actual UIManager and
+ *     Pseudo UIManager queues.
+ *  2. Both `RCTExecuteOnUIManagerQueue` and `RCTUnsafeExecuteOnUIManagerQueueSync`
+ *     execute given block *synchronously* if they were called on actual UIManager
+ *     or Pseudo UIManager queues.
+ *  3. `RCTExecuteOnMainQueue` executes given block *synchronously* if we already on
+ *     the Main queue.
+ *  4. `RCTUnsafeExecuteOnUIManagerQueueSync` is smart enough to do the trick:
+ *     It detects calling on the Main queue and in this case, instead of doing
+ *     trivial *synchronous* dispatch, it does:
+ *       - Block the Main queue;
+ *       - Dispatch the special block on UIManager queue to block the queue and
+ *         concurrent memory access;
+ *       - Execute the given block on the Main queue;
+ *       - Unblock the UIManager queue.
+ *
+ * Imagine the analogy: We have two queues: the Main one and UIManager one.
+ * And these queues are two lanes of railway that go in parallel. Then,
+ * at some point, we merge UIManager lane with the Main lane, and all cars use
+ * the unified the Main lane.
+ * And then we split lanes again.
+ *
+ * This solution assumes that the code running on UIManager queue will never
+ * *explicitly* block the Main queue via calling `RCTUnsafeExecuteOnMainQueueSync`.
+ * Otherwise, it can cause a deadlock.
+ */
+
+/**
+ * Returns UIManager queue.
+ */
+RCT_EXTERN dispatch_queue_t RCTGetUIManagerQueue(void);
+
+/**
+ * Default name for the UIManager queue.
+ */
+RCT_EXTERN char *const RCTUIManagerQueueName;
+
+/**
+ * Check if we are currently on UIManager queue.
+ * Please do not use this unless you really know what you're doing.
+ */
+RCT_EXTERN BOOL RCTIsUIManagerQueue(void);
+
+/**
+ * Check if we are currently on Pseudo UIManager queue.
+ * Please do not use this unless you really know what you're doing.
+ */
+RCT_EXTERN BOOL RCTIsPseudoUIManagerQueue(void);
+
+/**
+ * *Asynchronously* executes the specified block on the UIManager queue.
+ * Unlike `dispatch_async()` this will execute the block immediately
+ * if we're already on the UIManager queue.
+ */
+RCT_EXTERN void RCTExecuteOnUIManagerQueue(dispatch_block_t block);
+
+/**
+ * *Synchorously* executes the specified block on the UIManager queue.
+ * Unlike `dispatch_sync()` this will execute the block immediately
+ * if we're already on the UIManager queue.
+ * Please do not use this unless you really know what you're doing.
+ */
+RCT_EXTERN void RCTUnsafeExecuteOnUIManagerQueueSync(dispatch_block_t block);
+
+/**
+ * Convenience macro for asserting that we're running on UIManager queue.
+ */
+#define RCTAssertUIManagerQueue() RCTAssert(RCTIsUIManagerQueue() || RCTIsPseudoUIManagerQueue(), \
+@"This function must be called on the UIManager queue")
+
+/**
+ * Returns new unique root view tag.
+ */
+RCT_EXTERN NSNumber *RCTAllocateRootViewTag(void);

node_modules/react-native/React/Modules/RCTUIManagerUtils.m

@@ -0,0 +1,102 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTUIManagerUtils.h"
+
+#import <libkern/OSAtomic.h>
+
+#import "RCTAssert.h"
+
+char *const RCTUIManagerQueueName = "com.facebook.react.ShadowQueue";
+
+static BOOL pseudoUIManagerQueueFlag = NO;
+
+dispatch_queue_t RCTGetUIManagerQueue(void)
+{
+  static dispatch_queue_t shadowQueue;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    if ([NSOperation instancesRespondToSelector:@selector(qualityOfService)]) {
+      dispatch_queue_attr_t attr = dispatch_queue_attr_make_with_qos_class(DISPATCH_QUEUE_SERIAL, QOS_CLASS_USER_INTERACTIVE, 0);
+      shadowQueue = dispatch_queue_create(RCTUIManagerQueueName, attr);
+    } else {
+      shadowQueue = dispatch_queue_create(RCTUIManagerQueueName, DISPATCH_QUEUE_SERIAL);
+      dispatch_set_target_queue(shadowQueue, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0));
+    }
+  });
+  return shadowQueue;
+}
+
+BOOL RCTIsUIManagerQueue()
+{
+  static void *queueKey = &queueKey;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    dispatch_queue_set_specific(RCTGetUIManagerQueue(), queueKey, queueKey, NULL);
+  });
+  return dispatch_get_specific(queueKey) == queueKey;
+}
+
+BOOL RCTIsPseudoUIManagerQueue()
+{
+  if (RCTIsMainQueue()) {
+    return pseudoUIManagerQueueFlag;
+  }
+
+  return NO;
+}
+
+void RCTExecuteOnUIManagerQueue(dispatch_block_t block)
+{
+  if (RCTIsUIManagerQueue() || RCTIsPseudoUIManagerQueue()) {
+    block();
+  } else {
+    dispatch_async(RCTGetUIManagerQueue(), ^{
+      block();
+    });
+  }
+}
+
+void RCTUnsafeExecuteOnUIManagerQueueSync(dispatch_block_t block)
+{
+  if (RCTIsUIManagerQueue() || RCTIsPseudoUIManagerQueue()) {
+    block();
+  } else {
+    if (RCTIsMainQueue()) {
+      dispatch_semaphore_t mainQueueBlockingSemaphore = dispatch_semaphore_create(0);
+      dispatch_semaphore_t uiManagerQueueBlockingSemaphore = dispatch_semaphore_create(0);
+
+      // Dispatching block which blocks UI Manager queue.
+      dispatch_async(RCTGetUIManagerQueue(), ^{
+        // Initiating `block` execution on main queue.
+        dispatch_semaphore_signal(mainQueueBlockingSemaphore);
+        // Waiting for finishing `block`.
+        dispatch_semaphore_wait(uiManagerQueueBlockingSemaphore, DISPATCH_TIME_FOREVER);
+      });
+
+      // Waiting for block on UIManager queue.
+      dispatch_semaphore_wait(mainQueueBlockingSemaphore, DISPATCH_TIME_FOREVER);
+      pseudoUIManagerQueueFlag = YES;
+      // `block` execution while UIManager queue is blocked by semaphore.
+      block();
+      pseudoUIManagerQueueFlag = NO;
+      // Signalling UIManager block.
+      dispatch_semaphore_signal(uiManagerQueueBlockingSemaphore);
+    } else {
+      dispatch_sync(RCTGetUIManagerQueue(), ^{
+        block();
+      });
+    }
+  }
+}
+
+NSNumber *RCTAllocateRootViewTag()
+{
+  // Numbering of these tags goes from 1, 11, 21, 31, ..., 100501, ...
+  static int64_t rootViewTagCounter = -1;
+  return @(OSAtomicIncrement64(&rootViewTagCounter) * 10 + 1);
+}