initial commit taken from gitlab.lrz.de

node_modules/react-native/React/Base/RCTAssert.h

@@ -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 <Foundation/Foundation.h>
+
+#import <React/RCTDefines.h>
+
+/*
+ * Defined in RCTUtils.m
+ */
+RCT_EXTERN BOOL RCTIsMainQueue(void);
+
+/**
+ * This is the main assert macro that you should use. Asserts should be compiled out
+ * in production builds. You can customize the assert behaviour by setting a custom
+ * assert handler through `RCTSetAssertFunction`.
+ */
+#ifndef NS_BLOCK_ASSERTIONS
+#define RCTAssert(condition, ...) do { \
+  if ((condition) == 0) { \
+    _RCTAssertFormat(#condition, __FILE__, __LINE__, __func__, __VA_ARGS__); \
+    if (RCT_NSASSERT) { \
+      [[NSAssertionHandler currentHandler] handleFailureInFunction:@(__func__) \
+        file:@(__FILE__) lineNumber:__LINE__ description:__VA_ARGS__]; \
+    } \
+  } \
+} while (false)
+#else
+#define RCTAssert(condition, ...) do {} while (false)
+#endif
+RCT_EXTERN void _RCTAssertFormat(
+  const char *, const char *, int, const char *, NSString *, ...
+) NS_FORMAT_FUNCTION(5,6);
+
+/**
+ * Report a fatal condition when executing. These calls will _NOT_ be compiled out
+ * in production, and crash the app by default. You can customize the fatal behaviour
+ * by setting a custom fatal handler through `RCTSetFatalHandler`.
+ */
+RCT_EXTERN void RCTFatal(NSError *error);
+
+/**
+ * The default error domain to be used for React errors.
+ */
+RCT_EXTERN NSString *const RCTErrorDomain;
+
+/**
+ * JS Stack trace provided as part of an NSError's userInfo
+ */
+RCT_EXTERN NSString *const RCTJSStackTraceKey;
+
+/**
+ * Raw JS Stack trace string provided as part of an NSError's userInfo
+ */
+RCT_EXTERN NSString *const RCTJSRawStackTraceKey;
+
+/**
+ * Name of fatal exceptions generated by RCTFatal
+ */
+RCT_EXTERN NSString *const RCTFatalExceptionName;
+
+/**
+ * A block signature to be used for custom assertion handling.
+ */
+typedef void (^RCTAssertFunction)(NSString *condition,
+                                  NSString *fileName,
+                                  NSNumber *lineNumber,
+                                  NSString *function,
+                                  NSString *message);
+
+typedef void (^RCTFatalHandler)(NSError *error);
+
+/**
+ * Convenience macro for asserting that a parameter is non-nil/non-zero.
+ */
+#define RCTAssertParam(name) RCTAssert(name, @"'%s' is a required parameter", #name)
+
+/**
+ * Convenience macro for asserting that we're running on main queue.
+ */
+#define RCTAssertMainQueue() RCTAssert(RCTIsMainQueue(), \
+  @"This function must be called on the main queue")
+
+/**
+ * Convenience macro for asserting that we're running off the main queue.
+ */
+#define RCTAssertNotMainQueue() RCTAssert(!RCTIsMainQueue(), \
+@"This function must not be called on the main queue")
+
+/**
+ * These methods get and set the current assert function called by the RCTAssert
+ * macros. You can use these to replace the standard behavior with custom assert
+ * functionality.
+ */
+RCT_EXTERN void RCTSetAssertFunction(RCTAssertFunction assertFunction);
+RCT_EXTERN RCTAssertFunction RCTGetAssertFunction(void);
+
+/**
+ * This appends additional code to the existing assert function, without
+ * replacing the existing functionality. Useful if you just want to forward
+ * assert info to an extra service without changing the default behavior.
+ */
+RCT_EXTERN void RCTAddAssertFunction(RCTAssertFunction assertFunction);
+
+/**
+ * This method temporarily overrides the assert function while performing the
+ * specified block. This is useful for testing purposes (to detect if a given
+ * function asserts something) or to suppress or override assertions temporarily.
+ */
+RCT_EXTERN void RCTPerformBlockWithAssertFunction(void (^block)(void), RCTAssertFunction assertFunction);
+
+/**
+ These methods get and set the current fatal handler called by the RCTFatal method.
+ */
+RCT_EXTERN void RCTSetFatalHandler(RCTFatalHandler fatalHandler);
+RCT_EXTERN RCTFatalHandler RCTGetFatalHandler(void);
+
+/**
+ * Get the current thread's name (or the current queue, if in debug mode)
+ */
+RCT_EXTERN NSString *RCTCurrentThreadName(void);
+
+/**
+ * Helper to get generate exception message from NSError
+ */
+RCT_EXTERN NSString *RCTFormatError(NSString *message, NSArray<NSDictionary<NSString *, id> *> *stacktrace, NSUInteger maxMessageLength);
+
+/**
+ * Convenience macro to assert which thread is currently running (DEBUG mode only)
+ */
+#if DEBUG
+
+#define RCTAssertThread(thread, format...) \
+_Pragma("clang diagnostic push") \
+_Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"") \
+RCTAssert( \
+  [(id)thread isKindOfClass:[NSString class]] ? \
+    [RCTCurrentThreadName() isEqualToString:(NSString *)thread] : \
+    [(id)thread isKindOfClass:[NSThread class]] ? \
+      [NSThread currentThread] ==  (NSThread *)thread : \
+      dispatch_get_current_queue() == (dispatch_queue_t)thread, \
+  format); \
+_Pragma("clang diagnostic pop")
+
+#else
+
+#define RCTAssertThread(thread, format...) do { } while (0)
+
+#endif

node_modules/react-native/React/Base/RCTAssert.m

@@ -0,0 +1,175 @@
+/**
+ * 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 "RCTAssert.h"
+#import "RCTLog.h"
+
+NSString *const RCTErrorDomain = @"RCTErrorDomain";
+NSString *const RCTJSStackTraceKey = @"RCTJSStackTraceKey";
+NSString *const RCTJSRawStackTraceKey = @"RCTJSRawStackTraceKey";
+NSString *const RCTFatalExceptionName = @"RCTFatalException";
+
+static NSString *const RCTAssertFunctionStack = @"RCTAssertFunctionStack";
+
+RCTAssertFunction RCTCurrentAssertFunction = nil;
+RCTFatalHandler RCTCurrentFatalHandler = nil;
+
+NSException *_RCTNotImplementedException(SEL, Class);
+NSException *_RCTNotImplementedException(SEL cmd, Class cls)
+{
+  NSString *msg = [NSString stringWithFormat:@"%s is not implemented "
+                   "for the class %@", sel_getName(cmd), cls];
+  return [NSException exceptionWithName:@"RCTNotDesignatedInitializerException"
+                                 reason:msg userInfo:nil];
+}
+
+void RCTSetAssertFunction(RCTAssertFunction assertFunction)
+{
+  RCTCurrentAssertFunction = assertFunction;
+}
+
+RCTAssertFunction RCTGetAssertFunction(void)
+{
+  return RCTCurrentAssertFunction;
+}
+
+void RCTAddAssertFunction(RCTAssertFunction assertFunction)
+{
+  RCTAssertFunction existing = RCTCurrentAssertFunction;
+  if (existing) {
+    RCTCurrentAssertFunction = ^(NSString *condition,
+                                 NSString *fileName,
+                                 NSNumber *lineNumber,
+                                 NSString *function,
+                                 NSString *message) {
+
+      existing(condition, fileName, lineNumber, function, message);
+      assertFunction(condition, fileName, lineNumber, function, message);
+    };
+  } else {
+    RCTCurrentAssertFunction = assertFunction;
+  }
+}
+
+/**
+ * returns the topmost stacked assert function for the current thread, which
+ * may not be the same as the current value of RCTCurrentAssertFunction.
+ */
+static RCTAssertFunction RCTGetLocalAssertFunction()
+{
+  NSMutableDictionary *threadDictionary = [NSThread currentThread].threadDictionary;
+  NSArray<RCTAssertFunction> *functionStack = threadDictionary[RCTAssertFunctionStack];
+  RCTAssertFunction assertFunction = functionStack.lastObject;
+  if (assertFunction) {
+    return assertFunction;
+  }
+  return RCTCurrentAssertFunction;
+}
+
+void RCTPerformBlockWithAssertFunction(void (^block)(void), RCTAssertFunction assertFunction)
+{
+  NSMutableDictionary *threadDictionary = [NSThread currentThread].threadDictionary;
+  NSMutableArray<RCTAssertFunction> *functionStack = threadDictionary[RCTAssertFunctionStack];
+  if (!functionStack) {
+    functionStack = [NSMutableArray new];
+    threadDictionary[RCTAssertFunctionStack] = functionStack;
+  }
+  [functionStack addObject:assertFunction];
+  block();
+  [functionStack removeLastObject];
+}
+
+NSString *RCTCurrentThreadName(void)
+{
+  NSThread *thread = [NSThread currentThread];
+  NSString *threadName = RCTIsMainQueue() || thread.isMainThread ? @"main" : thread.name;
+  if (threadName.length == 0) {
+    const char *label = dispatch_queue_get_label(DISPATCH_CURRENT_QUEUE_LABEL);
+    if (label && strlen(label) > 0) {
+      threadName = @(label);
+    } else {
+      threadName = [NSString stringWithFormat:@"%p", thread];
+    }
+  }
+  return threadName;
+}
+
+void _RCTAssertFormat(
+  const char *condition,
+  const char *fileName,
+  int lineNumber,
+  const char *function,
+  NSString *format, ...)
+{
+  RCTAssertFunction assertFunction = RCTGetLocalAssertFunction();
+  if (assertFunction) {
+    va_list args;
+    va_start(args, format);
+    NSString *message = [[NSString alloc] initWithFormat:format arguments:args];
+    va_end(args);
+
+    assertFunction(@(condition), @(fileName), @(lineNumber), @(function), message);
+  }
+}
+
+void RCTFatal(NSError *error)
+{
+  _RCTLogNativeInternal(RCTLogLevelFatal, NULL, 0, @"%@", error.localizedDescription);
+
+  RCTFatalHandler fatalHandler = RCTGetFatalHandler();
+  if (fatalHandler) {
+    fatalHandler(error);
+  } else {
+#if DEBUG
+    @try {
+#endif
+      NSString *name = [NSString stringWithFormat:@"%@: %@", RCTFatalExceptionName, error.localizedDescription];
+      NSString *message = RCTFormatError(error.localizedDescription, error.userInfo[RCTJSStackTraceKey], 75);
+      @throw [[NSException alloc]  initWithName:name reason:message userInfo:nil];
+#if DEBUG
+    } @catch (NSException *e) {}
+#endif
+  }
+}
+
+void RCTSetFatalHandler(RCTFatalHandler fatalhandler)
+{
+  RCTCurrentFatalHandler = fatalhandler;
+}
+
+RCTFatalHandler RCTGetFatalHandler(void)
+{
+  return RCTCurrentFatalHandler;
+}
+
+NSString *RCTFormatError(NSString *message, NSArray<NSDictionary<NSString *, id> *> *stackTrace, NSUInteger maxMessageLength)
+{
+  if (maxMessageLength > 0 && message.length > maxMessageLength) {
+    message = [[message substringToIndex:maxMessageLength] stringByAppendingString:@"..."];
+  }
+
+  NSMutableString *prettyStack = [NSMutableString string];
+  if (stackTrace) {
+    [prettyStack appendString:@", stack:\n"];
+
+    NSRegularExpression *regex = [NSRegularExpression regularExpressionWithPattern:@"^(\\d+\\.js)$"
+                                                                           options:NSRegularExpressionCaseInsensitive
+                                                                             error:NULL];
+    for (NSDictionary<NSString *, id> *frame in stackTrace) {
+      NSString *fileName = [frame[@"file"] lastPathComponent];
+      if (fileName && [regex numberOfMatchesInString:fileName options:0 range:NSMakeRange(0, [fileName length])]) {
+        fileName = [fileName stringByAppendingString:@":"];
+      } else {
+        fileName = @"";
+      }
+
+      [prettyStack appendFormat:@"%@@%@%@:%@\n", frame[@"methodName"], fileName, frame[@"lineNumber"], frame[@"column"]];
+    }
+  }
+
+  return [NSString stringWithFormat:@"%@%@", message, prettyStack];
+}

node_modules/react-native/React/Base/RCTBridge+Private.h

@@ -0,0 +1,161 @@
+/**
+ * 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 <JavaScriptCore/JavaScriptCore.h>
+#import <JavaScriptCore/JSBase.h>
+
+#import <React/RCTBridge.h>
+
+@class RCTModuleData;
+@protocol RCTJavaScriptExecutor;
+
+RCT_EXTERN NSArray<Class> *RCTGetModuleClasses(void);
+
+RCT_EXTERN __attribute__((weak)) void RCTFBQuickPerformanceLoggerConfigureHooks(JSGlobalContextRef ctx);
+
+#if RCT_DEBUG
+RCT_EXTERN void RCTVerifyAllModulesExported(NSArray *extraModules);
+#endif
+
+@interface RCTBridge ()
+
+// Private designated initializer
+- (instancetype)initWithDelegate:(id<RCTBridgeDelegate>)delegate
+                       bundleURL:(NSURL *)bundleURL
+                  moduleProvider:(RCTBridgeModuleListProvider)block
+                   launchOptions:(NSDictionary *)launchOptions NS_DESIGNATED_INITIALIZER;
+
+// Used for the profiler flow events between JS and native
+@property (nonatomic, assign) int64_t flowID;
+@property (nonatomic, assign) CFMutableDictionaryRef flowIDMap;
+@property (nonatomic, strong) NSLock *flowIDMapLock;
+
+// Used by RCTDevMenu
+@property (nonatomic, copy) NSString *bridgeDescription;
+
++ (instancetype)currentBridge;
++ (void)setCurrentBridge:(RCTBridge *)bridge;
+
+/**
+ * Bridge setup code - creates an instance of RCTBachedBridge. Exposed for
+ * test only
+ */
+- (void)setUp;
+
+/**
+ * This method is used to invoke a callback that was registered in the
+ * JavaScript application context. Safe to call from any thread.
+ */
+- (void)enqueueCallback:(NSNumber *)cbID args:(NSArray *)args;
+
+/**
+ * This property is mostly used on the main thread, but may be touched from
+ * a background thread if the RCTBridge happens to deallocate on a background
+ * thread. Therefore, we want all writes to it to be seen atomically.
+ */
+@property (atomic, strong) RCTBridge *batchedBridge;
+
+/**
+ * The block that creates the modules' instances to be added to the bridge.
+ * Exposed for RCTCxxBridge
+ */
+@property (nonatomic, copy, readonly) RCTBridgeModuleListProvider moduleProvider;
+
+/**
+ * Used by RCTDevMenu to override the `hot` param of the current bundleURL.
+ */
+@property (nonatomic, strong, readwrite) NSURL *bundleURL;
+
+@end
+
+@interface RCTBridge (RCTCxxBridge)
+
+/**
+ * Used by RCTModuleData
+ */
+
+@property (nonatomic, weak, readonly) RCTBridge *parentBridge;
+
+/**
+ * Used by RCTModuleData
+ */
+@property (nonatomic, assign, readonly) BOOL moduleSetupComplete;
+
+/**
+ * Called on the child bridge to run the executor and start loading.
+ */
+- (void)start;
+
+/**
+ * Used by RCTModuleData to register the module for frame updates after it is
+ * lazily initialized.
+ */
+- (void)registerModuleForFrameUpdates:(id<RCTBridgeModule>)module
+                       withModuleData:(RCTModuleData *)moduleData;
+
+/**
+ * Dispatch work to a module's queue - this is also suports the fake RCTJSThread
+ * queue. Exposed for the RCTProfiler
+ */
+- (void)dispatchBlock:(dispatch_block_t)block queue:(dispatch_queue_t)queue;
+
+/**
+ * Get the module data for a given module name. Used by UIManager to implement
+ * the `dispatchViewManagerCommand` method.
+ */
+- (RCTModuleData *)moduleDataForName:(NSString *)moduleName;
+
+/**
+* Registers additional classes with the ModuleRegistry.
+*/
+- (void)registerAdditionalModuleClasses:(NSArray<Class> *)newModules;
+
+/**
+ * Systrace profiler toggling methods exposed for the RCTDevMenu
+ */
+- (void)startProfiling;
+- (void)stopProfiling:(void (^)(NSData *))callback;
+
+/**
+ * Synchronously call a specific native module's method and return the result
+ */
+- (id)callNativeModule:(NSUInteger)moduleID
+                method:(NSUInteger)methodID
+                params:(NSArray *)params;
+
+/**
+ * Hook exposed for RCTLog to send logs to JavaScript when not running in JSC
+ */
+- (void)logMessage:(NSString *)message level:(NSString *)level;
+
+/**
+ * Allow super fast, one time, timers to skip the queue and be directly executed
+ */
+- (void)_immediatelyCallTimer:(NSNumber *)timer;
+
+@end
+
+@interface RCTBridge (JavaScriptCore)
+
+/**
+ * The raw JSGlobalContextRef used by the bridge.
+ */
+@property (nonatomic, readonly, assign) JSGlobalContextRef jsContextRef;
+
+@end
+
+@interface RCTBridge (Inspector)
+
+@property (nonatomic, readonly, getter=isInspectable) BOOL inspectable;
+
+@end
+
+@interface RCTCxxBridge : RCTBridge
+
+- (instancetype)initWithParentBridge:(RCTBridge *)bridge NS_DESIGNATED_INITIALIZER;
+
+@end

node_modules/react-native/React/Base/RCTBridge.h

@@ -0,0 +1,220 @@
+/**
+ * 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/RCTBridgeDelegate.h>
+#import <React/RCTBridgeModule.h>
+#import <React/RCTDefines.h>
+#import <React/RCTFrameUpdate.h>
+#import <React/RCTInvalidating.h>
+
+@class JSValue;
+@class RCTBridge;
+@class RCTEventDispatcher;
+@class RCTPerformanceLogger;
+
+/**
+ * This notification fires when the bridge initializes.
+ */
+RCT_EXTERN NSString *const RCTJavaScriptWillStartLoadingNotification;
+
+
+/**
+ * This notification fires when the bridge starts executing the JS bundle.
+ */
+RCT_EXTERN NSString *const RCTJavaScriptWillStartExecutingNotification;
+
+/**
+ * This notification fires when the bridge has finished loading the JS bundle.
+ */
+RCT_EXTERN NSString *const RCTJavaScriptDidLoadNotification;
+
+/**
+ * This notification fires when the bridge failed to load the JS bundle. The
+ * `error` key can be used to determine the error that occurred.
+ */
+RCT_EXTERN NSString *const RCTJavaScriptDidFailToLoadNotification;
+
+/**
+ * This notification fires each time a native module is instantiated. The
+ * `module` key will contain a reference to the newly-created module instance.
+ * Note that this notification may be fired before the module is available via
+ * the `[bridge moduleForClass:]` method.
+ */
+RCT_EXTERN NSString *const RCTDidInitializeModuleNotification;
+
+/**
+ * This notification fires just before the bridge starts processing a request to
+ * reload.
+ */
+RCT_EXTERN NSString *const RCTBridgeWillReloadNotification;
+
+/**
+ * This notification fires just before the bridge begins downloading a script
+ * from the packager.
+ */
+RCT_EXTERN NSString *const RCTBridgeWillDownloadScriptNotification;
+
+/**
+ * This notification fires just after the bridge finishes downloading a script
+ * from the packager.
+ */
+RCT_EXTERN NSString *const RCTBridgeDidDownloadScriptNotification;
+
+/**
+ * Key for the RCTSource object in the RCTBridgeDidDownloadScriptNotification
+ * userInfo dictionary.
+ */
+RCT_EXTERN NSString *const RCTBridgeDidDownloadScriptNotificationSourceKey;
+
+/**
+ * This block can be used to instantiate modules that require additional
+ * init parameters, or additional configuration prior to being used.
+ * The bridge will call this block to instatiate the modules, and will
+ * be responsible for invalidating/releasing them when the bridge is destroyed.
+ * For this reason, the block should always return new module instances, and
+ * module instances should not be shared between bridges.
+ */
+typedef NSArray<id<RCTBridgeModule>> *(^RCTBridgeModuleListProvider)(void);
+
+/**
+ * This function returns the module name for a given class.
+ */
+RCT_EXTERN NSString *RCTBridgeModuleNameForClass(Class bridgeModuleClass);
+
+/**
+ * Async batched bridge used to communicate with the JavaScript application.
+ */
+@interface RCTBridge : NSObject <RCTInvalidating>
+
+/**
+ * Creates a new bridge with a custom RCTBridgeDelegate.
+ *
+ * All the interaction with the JavaScript context should be done using the bridge
+ * instance of the RCTBridgeModules. Modules will be automatically instantiated
+ * using the default contructor, but you can optionally pass in an array of
+ * pre-initialized module instances if they require additional init parameters
+ * or configuration.
+ */
+- (instancetype)initWithDelegate:(id<RCTBridgeDelegate>)delegate
+                   launchOptions:(NSDictionary *)launchOptions;
+
+/**
+ * DEPRECATED: Use initWithDelegate:launchOptions: instead
+ *
+ * The designated initializer. This creates a new bridge on top of the specified
+ * executor. The bridge should then be used for all subsequent communication
+ * with the JavaScript code running in the executor. Modules will be automatically
+ * instantiated using the default contructor, but you can optionally pass in an
+ * array of pre-initialized module instances if they require additional init
+ * parameters or configuration.
+ */
+- (instancetype)initWithBundleURL:(NSURL *)bundleURL
+                   moduleProvider:(RCTBridgeModuleListProvider)block
+                    launchOptions:(NSDictionary *)launchOptions;
+
+/**
+ * This method is used to call functions in the JavaScript application context.
+ * It is primarily intended for use by modules that require two-way communication
+ * with the JavaScript code. Safe to call from any thread.
+ */
+- (void)enqueueJSCall:(NSString *)moduleDotMethod args:(NSArray *)args;
+- (void)enqueueJSCall:(NSString *)module method:(NSString *)method args:(NSArray *)args completion:(dispatch_block_t)completion;
+
+/**
+ * This method registers the file path of an additional JS segment by its ID.
+ *
+ * @experimental
+ */
+- (void)registerSegmentWithId:(NSUInteger)segmentId path:(NSString *)path;
+
+/**
+ * Retrieve a bridge module instance by name or class. Note that modules are
+ * lazily instantiated, so calling these methods for the first time with a given
+ * module name/class may cause the class to be sychronously instantiated,
+ * potentially blocking both the calling thread and main thread for a short time.
+ */
+- (id)moduleForName:(NSString *)moduleName;
+- (id)moduleForClass:(Class)moduleClass;
+
+/**
+ * Convenience method for retrieving all modules conforming to a given protocol.
+ * Modules will be sychronously instantiated if they haven't already been,
+ * potentially blocking both the calling thread and main thread for a short time.
+ */
+- (NSArray *)modulesConformingToProtocol:(Protocol *)protocol;
+
+/**
+ * Test if a module has been initialized. Use this prior to calling
+ * `moduleForClass:` or `moduleForName:` if you do not want to cause the module
+ * to be instantiated if it hasn't been already.
+ */
+- (BOOL)moduleIsInitialized:(Class)moduleClass;
+
+/**
+ * Retrieve an extra module that gets bound to the JS context, if any.
+ */
+- (id)jsBoundExtraModuleForClass:(Class)moduleClass;
+
+/**
+ * All registered bridge module classes.
+ */
+@property (nonatomic, copy, readonly) NSArray<Class> *moduleClasses;
+
+/**
+ * URL of the script that was loaded into the bridge.
+ */
+@property (nonatomic, strong, readonly) NSURL *bundleURL;
+
+/**
+ * The class of the executor currently being used. Changes to this value will
+ * take effect after the bridge is reloaded.
+ */
+@property (nonatomic, strong) Class executorClass;
+
+/**
+ * The delegate provided during the bridge initialization
+ */
+@property (nonatomic, weak, readonly) id<RCTBridgeDelegate> delegate;
+
+/**
+ * The launch options that were used to initialize the bridge.
+ */
+@property (nonatomic, copy, readonly) NSDictionary *launchOptions;
+
+/**
+ * Use this to check if the bridge is currently loading.
+ */
+@property (nonatomic, readonly, getter=isLoading) BOOL loading;
+
+/**
+ * Use this to check if the bridge has been invalidated.
+ */
+@property (nonatomic, readonly, getter=isValid) BOOL valid;
+
+/**
+ * Link to the Performance Logger that logs React Native perf events.
+ */
+@property (nonatomic, readonly, strong) RCTPerformanceLogger *performanceLogger;
+
+/**
+ * Reload the bundle and reset executor & modules. Safe to call from any thread.
+ */
+- (void)reload;
+
+/**
+ * Inform the bridge, and anything subscribing to it, that it should reload.
+ */
+- (void)requestReload __deprecated_msg("Call reload instead");
+
+/**
+ * Says whether bridge has started receiving calls from javascript.
+ */
+- (BOOL)isBatchActive;
+
+@end

node_modules/react-native/React/Base/RCTBridge.m

@@ -0,0 +1,378 @@
+/**
+ * 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 "RCTBridge.h"
+#import "RCTBridge+Private.h"
+
+#import <objc/runtime.h>
+
+#import "RCTConvert.h"
+#import "RCTEventDispatcher.h"
+#if RCT_ENABLE_INSPECTOR
+#import "RCTInspectorDevServerHelper.h"
+#endif
+#import "RCTLog.h"
+#import "RCTModuleData.h"
+#import "RCTPerformanceLogger.h"
+#import "RCTProfile.h"
+#import "RCTReloadCommand.h"
+#import "RCTUtils.h"
+
+NSString *const RCTJavaScriptWillStartLoadingNotification = @"RCTJavaScriptWillStartLoadingNotification";
+NSString *const RCTJavaScriptWillStartExecutingNotification = @"RCTJavaScriptWillStartExecutingNotification";
+NSString *const RCTJavaScriptDidLoadNotification = @"RCTJavaScriptDidLoadNotification";
+NSString *const RCTJavaScriptDidFailToLoadNotification = @"RCTJavaScriptDidFailToLoadNotification";
+NSString *const RCTDidInitializeModuleNotification = @"RCTDidInitializeModuleNotification";
+NSString *const RCTBridgeWillReloadNotification = @"RCTBridgeWillReloadNotification";
+NSString *const RCTBridgeWillDownloadScriptNotification = @"RCTBridgeWillDownloadScriptNotification";
+NSString *const RCTBridgeDidDownloadScriptNotification = @"RCTBridgeDidDownloadScriptNotification";
+NSString *const RCTBridgeDidDownloadScriptNotificationSourceKey = @"source";
+
+static NSMutableArray<Class> *RCTModuleClasses;
+NSArray<Class> *RCTGetModuleClasses(void)
+{
+  return RCTModuleClasses;
+}
+
+void RCTFBQuickPerformanceLoggerConfigureHooks(__unused JSGlobalContextRef ctx) { }
+
+/**
+ * Register the given class as a bridge module. All modules must be registered
+ * prior to the first bridge initialization.
+ */
+void RCTRegisterModule(Class);
+void RCTRegisterModule(Class moduleClass)
+{
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    RCTModuleClasses = [NSMutableArray new];
+  });
+
+  RCTAssert([moduleClass conformsToProtocol:@protocol(RCTBridgeModule)],
+            @"%@ does not conform to the RCTBridgeModule protocol",
+            moduleClass);
+
+  // Register module
+  [RCTModuleClasses addObject:moduleClass];
+}
+
+/**
+ * This function returns the module name for a given class.
+ */
+NSString *RCTBridgeModuleNameForClass(Class cls)
+{
+#if RCT_DEBUG
+  RCTAssert([cls conformsToProtocol:@protocol(RCTBridgeModule)],
+            @"Bridge module `%@` does not conform to RCTBridgeModule", cls);
+#endif
+
+  NSString *name = [cls moduleName];
+  if (name.length == 0) {
+    name = NSStringFromClass(cls);
+  }
+
+  if ([name hasPrefix:@"RK"]) {
+    name = [name substringFromIndex:2];
+  } else if ([name hasPrefix:@"RCT"]) {
+    name = [name substringFromIndex:3];
+  }
+
+  return name;
+}
+
+#if RCT_DEBUG
+void RCTVerifyAllModulesExported(NSArray *extraModules)
+{
+  // Check for unexported modules
+  unsigned int classCount;
+  Class *classes = objc_copyClassList(&classCount);
+
+  NSMutableSet *moduleClasses = [NSMutableSet new];
+  [moduleClasses addObjectsFromArray:RCTGetModuleClasses()];
+  [moduleClasses addObjectsFromArray:[extraModules valueForKeyPath:@"class"]];
+
+  for (unsigned int i = 0; i < classCount; i++) {
+    Class cls = classes[i];
+    Class superclass = cls;
+    while (superclass) {
+      if (class_conformsToProtocol(superclass, @protocol(RCTBridgeModule))) {
+        if ([moduleClasses containsObject:cls]) {
+          break;
+        }
+
+        // Verify it's not a super-class of one of our moduleClasses
+        BOOL isModuleSuperClass = NO;
+        for (Class moduleClass in moduleClasses) {
+          if ([moduleClass isSubclassOfClass:cls]) {
+            isModuleSuperClass = YES;
+            break;
+          }
+        }
+        if (isModuleSuperClass) {
+          break;
+        }
+
+        RCTLogWarn(@"Class %@ was not exported. Did you forget to use RCT_EXPORT_MODULE()?", cls);
+        break;
+      }
+      superclass = class_getSuperclass(superclass);
+    }
+  }
+
+  free(classes);
+}
+#endif
+
+@interface RCTBridge () <RCTReloadListener>
+@end
+
+@implementation RCTBridge
+{
+  NSURL *_delegateBundleURL;
+}
+
+dispatch_queue_t RCTJSThread;
+
++ (void)initialize
+{
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+
+    // Set up JS thread
+    RCTJSThread = (id)kCFNull;
+  });
+}
+
+static RCTBridge *RCTCurrentBridgeInstance = nil;
+
+/**
+ * The last current active bridge instance. This is set automatically whenever
+ * the bridge is accessed. It can be useful for static functions or singletons
+ * that need to access the bridge for purposes such as logging, but should not
+ * be relied upon to return any particular instance, due to race conditions.
+ */
++ (instancetype)currentBridge
+{
+  return RCTCurrentBridgeInstance;
+}
+
++ (void)setCurrentBridge:(RCTBridge *)currentBridge
+{
+  RCTCurrentBridgeInstance = currentBridge;
+}
+
+- (instancetype)initWithDelegate:(id<RCTBridgeDelegate>)delegate
+                   launchOptions:(NSDictionary *)launchOptions
+{
+  return [self initWithDelegate:delegate
+                      bundleURL:nil
+                 moduleProvider:nil
+                  launchOptions:launchOptions];
+}
+
+- (instancetype)initWithBundleURL:(NSURL *)bundleURL
+                   moduleProvider:(RCTBridgeModuleListProvider)block
+                    launchOptions:(NSDictionary *)launchOptions
+{
+  return [self initWithDelegate:nil
+                      bundleURL:bundleURL
+                 moduleProvider:block
+                  launchOptions:launchOptions];
+}
+
+- (instancetype)initWithDelegate:(id<RCTBridgeDelegate>)delegate
+                       bundleURL:(NSURL *)bundleURL
+                  moduleProvider:(RCTBridgeModuleListProvider)block
+                   launchOptions:(NSDictionary *)launchOptions
+{
+  if (self = [super init]) {
+    _delegate = delegate;
+    _bundleURL = bundleURL;
+    _moduleProvider = block;
+    _launchOptions = [launchOptions copy];
+
+    [self setUp];
+  }
+  return self;
+}
+
+RCT_NOT_IMPLEMENTED(- (instancetype)init)
+
+- (void)dealloc
+{
+  /**
+   * This runs only on the main thread, but crashes the subclass
+   * RCTAssertMainQueue();
+   */
+  [self invalidate];
+}
+
+- (void)didReceiveReloadCommand
+{
+  [self reload];
+}
+
+- (NSArray<Class> *)moduleClasses
+{
+  return self.batchedBridge.moduleClasses;
+}
+
+- (id)moduleForName:(NSString *)moduleName
+{
+  return [self.batchedBridge moduleForName:moduleName];
+}
+
+- (id)moduleForClass:(Class)moduleClass
+{
+  return [self moduleForName:RCTBridgeModuleNameForClass(moduleClass)];
+}
+
+- (NSArray *)modulesConformingToProtocol:(Protocol *)protocol
+{
+  NSMutableArray *modules = [NSMutableArray new];
+  for (Class moduleClass in self.moduleClasses) {
+    if ([moduleClass conformsToProtocol:protocol]) {
+      id module = [self moduleForClass:moduleClass];
+      if (module) {
+        [modules addObject:module];
+      }
+    }
+  }
+  return [modules copy];
+}
+
+- (BOOL)moduleIsInitialized:(Class)moduleClass
+{
+  return [self.batchedBridge moduleIsInitialized:moduleClass];
+}
+
+- (id)jsBoundExtraModuleForClass:(Class)moduleClass
+{
+  return [self.batchedBridge jsBoundExtraModuleForClass:moduleClass];
+}
+
+- (void)reload
+{
+  #if RCT_ENABLE_INSPECTOR
+  // Disable debugger to resume the JsVM & avoid thread locks while reloading
+  [RCTInspectorDevServerHelper disableDebugger];
+  #endif
+
+  [[NSNotificationCenter defaultCenter] postNotificationName:RCTBridgeWillReloadNotification object:self];
+
+  /**
+   * Any thread
+   */
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [self invalidate];
+    [self setUp];
+  });
+}
+
+- (void)requestReload
+{
+  [self reload];
+}
+
+- (Class)bridgeClass
+{
+  return [RCTCxxBridge class];
+}
+
+- (void)setUp
+{
+  RCT_PROFILE_BEGIN_EVENT(0, @"-[RCTBridge setUp]", nil);
+
+  _performanceLogger = [RCTPerformanceLogger new];
+  [_performanceLogger markStartForTag:RCTPLBridgeStartup];
+  [_performanceLogger markStartForTag:RCTPLTTI];
+
+  Class bridgeClass = self.bridgeClass;
+
+  #if RCT_DEV
+  RCTExecuteOnMainQueue(^{
+    RCTRegisterReloadCommandListener(self);
+  });
+  #endif
+
+  // Only update bundleURL from delegate if delegate bundleURL has changed
+  NSURL *previousDelegateURL = _delegateBundleURL;
+  _delegateBundleURL = [self.delegate sourceURLForBridge:self];
+  if (_delegateBundleURL && ![_delegateBundleURL isEqual:previousDelegateURL]) {
+    _bundleURL = _delegateBundleURL;
+  }
+
+  // Sanitize the bundle URL
+  _bundleURL = [RCTConvert NSURL:_bundleURL.absoluteString];
+
+  self.batchedBridge = [[bridgeClass alloc] initWithParentBridge:self];
+  [self.batchedBridge start];
+
+  RCT_PROFILE_END_EVENT(RCTProfileTagAlways, @"");
+}
+
+- (BOOL)isLoading
+{
+  return self.batchedBridge.loading;
+}
+
+- (BOOL)isValid
+{
+  return self.batchedBridge.valid;
+}
+
+- (BOOL)isBatchActive
+{
+  return [_batchedBridge isBatchActive];
+}
+
+- (void)invalidate
+{
+  RCTBridge *batchedBridge = self.batchedBridge;
+  self.batchedBridge = nil;
+
+  if (batchedBridge) {
+    RCTExecuteOnMainQueue(^{
+      [batchedBridge invalidate];
+    });
+  }
+}
+
+- (void)registerAdditionalModuleClasses:(NSArray<Class> *)modules
+{
+  [self.batchedBridge registerAdditionalModuleClasses:modules];
+}
+
+- (void)enqueueJSCall:(NSString *)moduleDotMethod args:(NSArray *)args
+{
+  NSArray<NSString *> *ids = [moduleDotMethod componentsSeparatedByString:@"."];
+  NSString *module = ids[0];
+  NSString *method = ids[1];
+  [self enqueueJSCall:module method:method args:args completion:NULL];
+}
+
+- (void)enqueueJSCall:(NSString *)module method:(NSString *)method args:(NSArray *)args completion:(dispatch_block_t)completion
+{
+  [self.batchedBridge enqueueJSCall:module method:method args:args completion:completion];
+}
+
+- (void)enqueueCallback:(NSNumber *)cbID args:(NSArray *)args
+{
+  [self.batchedBridge enqueueCallback:cbID args:args];
+}
+
+- (void)registerSegmentWithId:(NSUInteger)segmentId path:(NSString *)path
+{
+  [self.batchedBridge registerSegmentWithId:segmentId path:path];
+}
+
+- (JSGlobalContextRef)jsContextRef
+{
+  return [self.batchedBridge jsContextRef];
+}
+
+@end

node_modules/react-native/React/Base/RCTBridgeDelegate.h

@@ -0,0 +1,75 @@
+/**
+ * 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/RCTJavaScriptLoader.h>
+
+@class RCTBridge;
+@protocol RCTBridgeModule;
+
+@protocol RCTBridgeDelegate <NSObject>
+
+/**
+ * The location of the JavaScript source file. When running from the packager
+ * this should be an absolute URL, e.g. `http://localhost:8081/index.ios.bundle`.
+ * When running from a locally bundled JS file, this should be a `file://` url
+ * pointing to a path inside the app resources, e.g. `file://.../main.jsbundle`.
+ */
+- (NSURL *)sourceURLForBridge:(RCTBridge *)bridge;
+
+@optional
+
+/**
+ * The bridge initializes any registered RCTBridgeModules automatically, however
+ * if you wish to instantiate your own module instances, you can return them
+ * from this method.
+ *
+ * Note: You should always return a new instance for each call, rather than
+ * returning the same instance each time the bridge is reloaded. Module instances
+ * should not be shared between bridges, and this may cause unexpected behavior.
+ *
+ * It is also possible to override standard modules with your own implementations
+ * by returning a class with the same `moduleName` from this method, but this is
+ * not recommended in most cases - if the module methods and behavior do not
+ * match exactly, it may lead to bugs or crashes.
+ */
+- (NSArray<id<RCTBridgeModule>> *)extraModulesForBridge:(RCTBridge *)bridge;
+
+/**
+ * Configure whether the JSCExecutor created should use the system JSC API or
+ * alternative hooks provided. When returning YES from this method, you must have
+ * previously called facebook::react::setCustomJSCWrapper.
+ *
+ * @experimental
+ */
+- (BOOL)shouldBridgeUseCustomJSC:(RCTBridge *)bridge;
+
+/**
+* The bridge will call this method when a module been called from JS
+* cannot be found among registered modules.
+* It should return YES if the module with name 'moduleName' was registered
+* in the implementation, and the system must attempt to look for it again among registered.
+* If the module was not registered, return NO to prevent further searches.
+*/
+- (BOOL)bridge:(RCTBridge *)bridge didNotFindModule:(NSString *)moduleName;
+
+/**
+ * The bridge will automatically attempt to load the JS source code from the
+ * location specified by the `sourceURLForBridge:` method, however, if you want
+ * to handle loading the JS yourself, you can do so by implementing this method.
+ */
+- (void)loadSourceForBridge:(RCTBridge *)bridge
+                 onProgress:(RCTSourceLoadProgressBlock)onProgress
+                 onComplete:(RCTSourceLoadBlock)loadCallback;
+
+/**
+ * Similar to loadSourceForBridge:onProgress:onComplete: but without progress
+ * reporting.
+ */
+- (void)loadSourceForBridge:(RCTBridge *)bridge
+                  withBlock:(RCTSourceLoadBlock)loadCallback;
+
+@end

node_modules/react-native/React/Base/RCTBridgeMethod.h

@@ -0,0 +1,38 @@
+/**
+ * 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>
+
+@class RCTBridge;
+
+typedef NS_ENUM(NSUInteger, RCTFunctionType) {
+  RCTFunctionTypeNormal,
+  RCTFunctionTypePromise,
+  RCTFunctionTypeSync,
+};
+
+static inline const char *RCTFunctionDescriptorFromType(RCTFunctionType type) {
+  switch (type) {
+    case RCTFunctionTypeNormal:
+      return "async";
+    case RCTFunctionTypePromise:
+      return "promise";
+    case RCTFunctionTypeSync:
+      return "sync";
+  }
+};
+
+@protocol RCTBridgeMethod <NSObject>
+
+@property (nonatomic, readonly) const char *JSMethodName;
+@property (nonatomic, readonly) RCTFunctionType functionType;
+
+- (id)invokeWithBridge:(RCTBridge *)bridge
+                module:(id)module
+             arguments:(NSArray *)arguments;
+
+@end

node_modules/react-native/React/Base/RCTBridgeModule.h

@@ -0,0 +1,312 @@
+/**
+ * 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/RCTDefines.h>
+
+@class RCTBridge;
+@protocol RCTBridgeMethod;
+
+/**
+ * The type of a block that is capable of sending a response to a bridged
+ * operation. Use this for returning callback methods to JS.
+ */
+typedef void (^RCTResponseSenderBlock)(NSArray *response);
+
+/**
+ * The type of a block that is capable of sending an error response to a
+ * bridged operation. Use this for returning error information to JS.
+ */
+typedef void (^RCTResponseErrorBlock)(NSError *error);
+
+/**
+ * Block that bridge modules use to resolve the JS promise waiting for a result.
+ * Nil results are supported and are converted to JS's undefined value.
+ */
+typedef void (^RCTPromiseResolveBlock)(id result);
+
+/**
+ * Block that bridge modules use to reject the JS promise waiting for a result.
+ * The error may be nil but it is preferable to pass an NSError object for more
+ * precise error messages.
+ */
+typedef void (^RCTPromiseRejectBlock)(NSString *code, NSString *message, NSError *error);
+
+/**
+ * This constant can be returned from +methodQueue to force module
+ * methods to be called on the JavaScript thread. This can have serious
+ * implications for performance, so only use this if you're sure it's what
+ * you need.
+ *
+ * NOTE: RCTJSThread is not a real libdispatch queue
+ */
+RCT_EXTERN dispatch_queue_t RCTJSThread;
+
+RCT_EXTERN_C_BEGIN
+
+typedef struct RCTMethodInfo {
+  const char *const jsName;
+  const char *const objcName;
+  const BOOL isSync;
+} RCTMethodInfo;
+
+RCT_EXTERN_C_END
+
+/**
+ * Provides the interface needed to register a bridge module.
+ */
+@protocol RCTBridgeModule <NSObject>
+
+/**
+ * Place this macro in your class implementation to automatically register
+ * your module with the bridge when it loads. The optional js_name argument
+ * will be used as the JS module name. If omitted, the JS module name will
+ * match the Objective-C class name.
+ */
+#define RCT_EXPORT_MODULE(js_name) \
+RCT_EXTERN void RCTRegisterModule(Class); \
++ (NSString *)moduleName { return @#js_name; } \
++ (void)load { RCTRegisterModule(self); }
+
+// Implemented by RCT_EXPORT_MODULE
++ (NSString *)moduleName;
+
+@optional
+
+/**
+ * A reference to the RCTBridge. Useful for modules that require access
+ * to bridge features, such as sending events or making JS calls. This
+ * will be set automatically by the bridge when it initializes the module.
+ * To implement this in your module, just add `@synthesize bridge = _bridge;`
+ */
+@property (nonatomic, weak, readonly) RCTBridge *bridge;
+
+/**
+ * The queue that will be used to call all exported methods. If omitted, this
+ * will call on a default background queue, which is avoids blocking the main
+ * thread.
+ *
+ * If the methods in your module need to interact with UIKit methods, they will
+ * probably need to call those on the main thread, as most of UIKit is main-
+ * thread-only. You can tell React Native to call your module methods on the
+ * main thread by returning a reference to the main queue, like this:
+ *
+ * - (dispatch_queue_t)methodQueue
+ * {
+ *   return dispatch_get_main_queue();
+ * }
+ *
+ * If you don't want to specify the queue yourself, but you need to use it
+ * inside your class (e.g. if you have internal methods that need to dispatch
+ * onto that queue), you can just add `@synthesize methodQueue = _methodQueue;`
+ * and the bridge will populate the methodQueue property for you automatically
+ * when it initializes the module.
+ */
+@property (nonatomic, strong, readonly) dispatch_queue_t methodQueue;
+
+/**
+ * Wrap the parameter line of your method implementation with this macro to
+ * expose it to JS. By default the exposed method will match the first part of
+ * the Objective-C method selector name (up to the first colon). Use
+ * RCT_REMAP_METHOD to specify the JS name of the method.
+ *
+ * For example, in ModuleName.m:
+ *
+ * - (void)doSomething:(NSString *)aString withA:(NSInteger)a andB:(NSInteger)b
+ * { ... }
+ *
+ * becomes
+ *
+ * RCT_EXPORT_METHOD(doSomething:(NSString *)aString
+ *                   withA:(NSInteger)a
+ *                   andB:(NSInteger)b)
+ * { ... }
+ *
+ * and is exposed to JavaScript as `NativeModules.ModuleName.doSomething`.
+ *
+ * ## Promises
+ *
+ * Bridge modules can also define methods that are exported to JavaScript as
+ * methods that return a Promise, and are compatible with JS async functions.
+ *
+ * Declare the last two parameters of your native method to be a resolver block
+ * and a rejecter block. The resolver block must precede the rejecter block.
+ *
+ * For example:
+ *
+ * RCT_EXPORT_METHOD(doSomethingAsync:(NSString *)aString
+ *                           resolver:(RCTPromiseResolveBlock)resolve
+ *                           rejecter:(RCTPromiseRejectBlock)reject
+ * { ... }
+ *
+ * Calling `NativeModules.ModuleName.doSomethingAsync(aString)` from
+ * JavaScript will return a promise that is resolved or rejected when your
+ * native method implementation calls the respective block.
+ *
+ */
+#define RCT_EXPORT_METHOD(method) \
+  RCT_REMAP_METHOD(, method)
+
+/**
+ * Same as RCT_EXPORT_METHOD but the method is called from JS
+ * synchronously **on the JS thread**, possibly returning a result.
+ *
+ * WARNING: in the vast majority of cases, you should use RCT_EXPORT_METHOD which
+ * allows your native module methods to be called asynchronously: calling
+ * methods synchronously can have strong performance penalties and introduce
+ * threading-related bugs to your native modules.
+ *
+ * The return type must be of object type (id) and should be serializable
+ * to JSON. This means that the hook can only return nil or JSON values
+ * (e.g. NSNumber, NSString, NSArray, NSDictionary).
+ *
+ * Calling these methods when running under the websocket executor
+ * is currently not supported.
+ */
+#define RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(method) \
+  RCT_EXPORT_SYNCHRONOUS_TYPED_METHOD(id, method)
+
+#define RCT_EXPORT_SYNCHRONOUS_TYPED_METHOD(returnType, method) \
+  RCT_REMAP_BLOCKING_SYNCHRONOUS_METHOD(, returnType, method)
+
+
+/**
+ * Similar to RCT_EXPORT_METHOD but lets you set the JS name of the exported
+ * method. Example usage:
+ *
+ * RCT_REMAP_METHOD(executeQueryWithParameters,
+ *   executeQuery:(NSString *)query parameters:(NSDictionary *)parameters)
+ * { ... }
+ */
+#define RCT_REMAP_METHOD(js_name, method) \
+  _RCT_EXTERN_REMAP_METHOD(js_name, method, NO) \
+  - (void)method RCT_DYNAMIC;
+
+/**
+ * Similar to RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD but lets you set
+ * the JS name of the exported method. Example usage:
+ *
+ * RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(executeQueryWithParameters,
+ *   executeQuery:(NSString *)query parameters:(NSDictionary *)parameters)
+ * { ... }
+ */
+#define RCT_REMAP_BLOCKING_SYNCHRONOUS_METHOD(js_name, returnType, method) \
+  _RCT_EXTERN_REMAP_METHOD(js_name, method, YES) \
+  - (returnType)method RCT_DYNAMIC;
+
+/**
+ * Use this macro in a private Objective-C implementation file to automatically
+ * register an external module with the bridge when it loads. This allows you to
+ * register Swift or private Objective-C classes with the bridge.
+ *
+ * For example if one wanted to export a Swift class to the bridge:
+ *
+ * MyModule.swift:
+ *
+ *   @objc(MyModule) class MyModule: NSObject {
+ *
+ *     @objc func doSomething(string: String! withFoo a: Int, bar b: Int) { ... }
+ *
+ *   }
+ *
+ * MyModuleExport.m:
+ *
+ *   #import <React/RCTBridgeModule.h>
+ *
+ *   @interface RCT_EXTERN_MODULE(MyModule, NSObject)
+ *
+ *   RCT_EXTERN_METHOD(doSomething:(NSString *)string withFoo:(NSInteger)a bar:(NSInteger)b)
+ *
+ *   @end
+ *
+ * This will now expose MyModule and the method to JavaScript via
+ * `NativeModules.MyModule.doSomething`
+ */
+#define RCT_EXTERN_MODULE(objc_name, objc_supername) \
+  RCT_EXTERN_REMAP_MODULE(, objc_name, objc_supername)
+
+/**
+ * Like RCT_EXTERN_MODULE, but allows setting a custom JavaScript name.
+ */
+#define RCT_EXTERN_REMAP_MODULE(js_name, objc_name, objc_supername) \
+  objc_name : objc_supername \
+  @end \
+  @interface objc_name (RCTExternModule) <RCTBridgeModule> \
+  @end \
+  @implementation objc_name (RCTExternModule) \
+  RCT_EXPORT_MODULE(js_name)
+
+/**
+ * Use this macro in accordance with RCT_EXTERN_MODULE to export methods
+ * of an external module.
+ */
+#define RCT_EXTERN_METHOD(method) \
+  _RCT_EXTERN_REMAP_METHOD(, method, NO)
+
+/**
+ * Use this macro in accordance with RCT_EXTERN_MODULE to export methods
+ * of an external module that should be invoked synchronously.
+ */
+#define RCT_EXTERN__BLOCKING_SYNCHRONOUS_METHOD(method) \
+  _RCT_EXTERN_REMAP_METHOD(, method, YES)
+
+/**
+ * Like RCT_EXTERN_REMAP_METHOD, but allows setting a custom JavaScript name
+ * and also whether this method is synchronous.
+ */
+#define _RCT_EXTERN_REMAP_METHOD(js_name, method, is_blocking_synchronous_method) \
+  + (const RCTMethodInfo *)RCT_CONCAT(__rct_export__, RCT_CONCAT(js_name, RCT_CONCAT(__LINE__, __COUNTER__))) { \
+    static RCTMethodInfo config = {#js_name, #method, is_blocking_synchronous_method}; \
+    return &config; \
+  }
+
+/**
+ * Most modules can be used from any thread. All of the modules exported non-sync method will be called on its
+ * methodQueue, and the module will be constructed lazily when its first invoked. Some modules have main need to access
+ * information that's main queue only (e.g. most UIKit classes). Since we don't want to dispatch synchronously to the
+ * main thread to this safely, we construct these moduels and export their constants ahead-of-time.
+ *
+ * Note that when set to false, the module constructor will be called from any thread.
+ *
+ * This requirement is currently inferred by checking if the module has a custom initializer or if there's exported
+ * constants. In the future, we'll stop automatically inferring this and instead only rely on this method.
+ */
++ (BOOL)requiresMainQueueSetup;
+
+/**
+ * Injects methods into JS.  Entries in this array are used in addition to any
+ * methods defined using the macros above.  This method is called only once,
+ * before registration.
+ */
+- (NSArray<id<RCTBridgeMethod>> *)methodsToExport;
+
+/**
+ * Injects constants into JS. These constants are made accessible via NativeModules.ModuleName.X. It is only called once
+ * for the lifetime of the bridge, so it is not suitable for returning dynamic values, but may be used for long-lived
+ * values such as session keys, that are regenerated only as part of a reload of the entire React application.
+ *
+ * If you implement this method and do not implement `requiresMainThreadSetup`, you will trigger deprecated logic
+ * that eagerly initializes your module on bridge startup. In the future, this behaviour will be changed to default
+ * to initializing lazily, and even modules with constants will be initialized lazily.
+ */
+- (NSDictionary *)constantsToExport;
+
+/**
+ * Notifies the module that a batch of JS method invocations has just completed.
+ */
+- (void)batchDidComplete;
+
+/**
+ * Notifies the module that the active batch of JS method invocations has been
+ * partially flushed.
+ *
+ * This occurs before -batchDidComplete, and more frequently.
+ */
+- (void)partialBatchDidFlush;
+
+@end

node_modules/react-native/React/Base/RCTBundleURLProvider.h

@@ -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 <Foundation/Foundation.h>
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+extern NSString *const RCTBundleURLProviderUpdatedNotification;
+
+extern const NSUInteger kRCTBundleURLProviderDefaultPort;
+
+#if defined(__cplusplus)
+}
+#endif
+
+@interface RCTBundleURLProvider : NSObject
+
+/**
+ * Set default settings on NSUserDefaults.
+ */
+- (void)setDefaults;
+
+/**
+ * Reset every settings to default.
+ */
+- (void)resetToDefaults;
+
+/**
+ * Returns the jsBundleURL for a given bundle entrypoint and
+ * the fallback offline JS bundle if the packager is not running.
+ * if resourceName or extension are nil, "main" and "jsbundle" will be
+ * used, respectively.
+ */
+- (NSURL *)jsBundleURLForBundleRoot:(NSString *)bundleRoot
+                   fallbackResource:(NSString *)resourceName
+                  fallbackExtension:(NSString *)extension;
+
+/**
+ * Returns the jsBundleURL for a given bundle entrypoint and
+ * the fallback offline JS bundle if the packager is not running.
+ */
+- (NSURL *)jsBundleURLForBundleRoot:(NSString *)bundleRoot
+                   fallbackResource:(NSString *)resourceName;
+
+/**
+ * Returns the jsBundleURL for a given bundle entrypoint and
+ * the fallback offline JS bundle. If resourceName or extension
+ * are nil, "main" and "jsbundle" will be used, respectively.
+ */
+- (NSURL *)jsBundleURLForFallbackResource:(NSString *)resourceName
+                        fallbackExtension:(NSString *)extension;
+
+/**
+ * Returns the resourceURL for a given bundle entrypoint and
+ * the fallback offline resource file if the packager is not running.
+ */
+- (NSURL *)resourceURLForResourceRoot:(NSString *)root
+                         resourceName:(NSString *)name
+                    resourceExtension:(NSString *)extension
+                        offlineBundle:(NSBundle *)offlineBundle;
+
+/**
+ * The IP address or hostname of the packager.
+ */
+@property (nonatomic, copy) NSString *jsLocation;
+
+@property (nonatomic, assign) BOOL enableLiveReload;
+@property (nonatomic, assign) BOOL enableMinification;
+@property (nonatomic, assign) BOOL enableDev;
+
++ (instancetype)sharedSettings;
+
+/**
+ Given a hostname for the packager and a bundle root, returns the URL to the js bundle. Generally you should use the
+ instance method -jsBundleURLForBundleRoot:fallbackResource: which includes logic to guess if the packager is running
+ and fall back to a pre-packaged bundle if it is not.
+ */
++ (NSURL *)jsBundleURLForBundleRoot:(NSString *)bundleRoot
+                       packagerHost:(NSString *)packagerHost
+                          enableDev:(BOOL)enableDev
+                 enableMinification:(BOOL)enableMinification;
+
+/**
+ * Given a hostname for the packager and a resource path (including "/"), return the URL to the resource.
+ * In general, please use the instance method to decide if the packager is running and fallback to the pre-packaged
+ * resource if it is not: -resourceURLForResourceRoot:resourceName:resourceExtension:offlineBundle:
+ */
++ (NSURL *)resourceURLForResourcePath:(NSString *)path
+                         packagerHost:(NSString *)packagerHost
+                                query:(NSString *)query;
+
+@end

node_modules/react-native/React/Base/RCTBundleURLProvider.m

@@ -0,0 +1,235 @@
+/**
+ * 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 "RCTBundleURLProvider.h"
+
+#import "RCTConvert.h"
+#import "RCTDefines.h"
+
+NSString *const RCTBundleURLProviderUpdatedNotification = @"RCTBundleURLProviderUpdatedNotification";
+
+const NSUInteger kRCTBundleURLProviderDefaultPort = RCT_METRO_PORT;
+
+static NSString *const kRCTJsLocationKey = @"RCT_jsLocation";
+static NSString *const kRCTEnableLiveReloadKey = @"RCT_enableLiveReload";
+static NSString *const kRCTEnableDevKey = @"RCT_enableDev";
+static NSString *const kRCTEnableMinificationKey = @"RCT_enableMinification";
+
+@implementation RCTBundleURLProvider
+
+- (instancetype)init
+{
+  self = [super init];
+  if (self) {
+    [self setDefaults];
+  }
+  return self;
+}
+
+- (NSDictionary *)defaults
+{
+  return @{
+    kRCTEnableLiveReloadKey: @NO,
+    kRCTEnableDevKey: @YES,
+    kRCTEnableMinificationKey: @NO,
+  };
+}
+
+- (void)settingsUpdated
+{
+  [[NSNotificationCenter defaultCenter] postNotificationName:RCTBundleURLProviderUpdatedNotification object:self];
+}
+
+- (void)setDefaults
+{
+  [[NSUserDefaults standardUserDefaults] registerDefaults:[self defaults]];
+}
+
+- (void)resetToDefaults
+{
+  for (NSString *key in [[self defaults] allKeys]) {
+    [[NSUserDefaults standardUserDefaults] removeObjectForKey:key];
+  }
+  [self setDefaults];
+  [self settingsUpdated];
+}
+
+static NSURL *serverRootWithHost(NSString *host)
+{
+  return [NSURL URLWithString:
+          [NSString stringWithFormat:@"http://%@:%lu/",
+           host, (unsigned long)kRCTBundleURLProviderDefaultPort]];
+}
+
+#if RCT_DEV
+- (BOOL)isPackagerRunning:(NSString *)host
+{
+  NSURL *url = [serverRootWithHost(host) URLByAppendingPathComponent:@"status"];
+  NSURLRequest *request = [NSURLRequest requestWithURL:url];
+  NSURLResponse *response;
+  NSData *data = [NSURLConnection sendSynchronousRequest:request returningResponse:&response error:NULL];
+  NSString *status = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
+  return [status isEqualToString:@"packager-status:running"];
+}
+
+- (NSString *)guessPackagerHost
+{
+  static NSString *ipGuess;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    NSString *ipPath = [[NSBundle mainBundle] pathForResource:@"ip" ofType:@"txt"];
+    ipGuess = [[NSString stringWithContentsOfFile:ipPath encoding:NSUTF8StringEncoding error:nil]
+               stringByTrimmingCharactersInSet:[NSCharacterSet newlineCharacterSet]];
+  });
+
+  NSString *host = ipGuess ?: @"localhost";
+  if ([self isPackagerRunning:host]) {
+    return host;
+  }
+  return nil;
+}
+#endif
+
+- (NSString *)packagerServerHost
+{
+  NSString *location = [self jsLocation];
+  if (location != nil) {
+    return location;
+  }
+#if RCT_DEV
+  NSString *host = [self guessPackagerHost];
+  if (host) {
+    return host;
+  }
+#endif
+  return nil;
+}
+
+- (NSURL *)jsBundleURLForBundleRoot:(NSString *)bundleRoot fallbackResource:(NSString *)resourceName fallbackExtension:(NSString *)extension
+{
+  NSString *packagerServerHost = [self packagerServerHost];
+  if (!packagerServerHost) {
+    return [self jsBundleURLForFallbackResource:resourceName fallbackExtension:extension];
+  } else {
+    return [RCTBundleURLProvider jsBundleURLForBundleRoot:bundleRoot
+                                             packagerHost:packagerServerHost
+                                                enableDev:[self enableDev]
+                                       enableMinification:[self enableMinification]];
+  }
+}
+
+- (NSURL *)jsBundleURLForBundleRoot:(NSString *)bundleRoot fallbackResource:(NSString *)resourceName
+{
+  return [self jsBundleURLForBundleRoot:bundleRoot fallbackResource:resourceName fallbackExtension:nil];
+}
+
+- (NSURL *)jsBundleURLForFallbackResource:(NSString *)resourceName
+                        fallbackExtension:(NSString *)extension
+{
+  resourceName = resourceName ?: @"main";
+  extension = extension ?: @"jsbundle";
+  return [[NSBundle mainBundle] URLForResource:resourceName withExtension:extension];
+}
+
+- (NSURL *)resourceURLForResourceRoot:(NSString *)root
+                         resourceName:(NSString *)name
+                    resourceExtension:(NSString *)extension
+                        offlineBundle:(NSBundle *)offlineBundle
+{
+  NSString *packagerServerHost = [self packagerServerHost];
+  if (!packagerServerHost) {
+    // Serve offline bundle (local file)
+    NSBundle *bundle = offlineBundle ?: [NSBundle mainBundle];
+    return [bundle URLForResource:name withExtension:extension];
+  }
+  NSString *path = [NSString stringWithFormat:@"/%@/%@.%@", root, name, extension];
+  return [[self class] resourceURLForResourcePath:path packagerHost:packagerServerHost query:nil];
+}
+
++ (NSURL *)jsBundleURLForBundleRoot:(NSString *)bundleRoot
+                       packagerHost:(NSString *)packagerHost
+                          enableDev:(BOOL)enableDev
+                 enableMinification:(BOOL)enableMinification
+{
+  NSString *path = [NSString stringWithFormat:@"/%@.bundle", bundleRoot];
+  // When we support only iOS 8 and above, use queryItems for a better API.
+  NSString *query = [NSString stringWithFormat:@"platform=ios&dev=%@&minify=%@",
+                      enableDev ? @"true" : @"false",
+                      enableMinification ? @"true": @"false"];
+  return [[self class] resourceURLForResourcePath:path packagerHost:packagerHost query:query];
+}
+
++ (NSURL *)resourceURLForResourcePath:(NSString *)path
+                         packagerHost:(NSString *)packagerHost
+                                query:(NSString *)query
+{
+  NSURLComponents *components = [NSURLComponents componentsWithURL:serverRootWithHost(packagerHost) resolvingAgainstBaseURL:NO];
+  components.path = path;
+  if (query != nil) {
+    components.query = query;
+  }
+  return components.URL;
+}
+
+- (void)updateValue:(id)object forKey:(NSString *)key
+{
+  [[NSUserDefaults standardUserDefaults] setObject:object forKey:key];
+  [[NSUserDefaults standardUserDefaults] synchronize];
+  [self settingsUpdated];
+}
+
+- (BOOL)enableDev
+{
+  return [[NSUserDefaults standardUserDefaults] boolForKey:kRCTEnableDevKey];
+}
+
+- (BOOL)enableLiveReload
+{
+  return [[NSUserDefaults standardUserDefaults] boolForKey:kRCTEnableLiveReloadKey];
+}
+
+- (BOOL)enableMinification
+{
+  return [[NSUserDefaults standardUserDefaults] boolForKey:kRCTEnableMinificationKey];
+}
+
+- (NSString *)jsLocation
+{
+  return [[NSUserDefaults standardUserDefaults] stringForKey:kRCTJsLocationKey];
+}
+
+- (void)setEnableDev:(BOOL)enableDev
+{
+  [self updateValue:@(enableDev) forKey:kRCTEnableDevKey];
+}
+
+- (void)setEnableLiveReload:(BOOL)enableLiveReload
+{
+  [self updateValue:@(enableLiveReload) forKey:kRCTEnableLiveReloadKey];
+}
+
+- (void)setJsLocation:(NSString *)jsLocation
+{
+  [self updateValue:jsLocation forKey:kRCTJsLocationKey];
+}
+
+- (void)setEnableMinification:(BOOL)enableMinification
+{
+  [self updateValue:@(enableMinification) forKey:kRCTEnableMinificationKey];
+}
+
++ (instancetype)sharedSettings
+{
+  static RCTBundleURLProvider *sharedInstance;
+  static dispatch_once_t once_token;
+  dispatch_once(&once_token, ^{
+    sharedInstance = [RCTBundleURLProvider new];
+  });
+  return sharedInstance;
+}
+
+@end

node_modules/react-native/React/Base/RCTConvert.h

@@ -0,0 +1,259 @@
+/**
+ * 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 <QuartzCore/QuartzCore.h>
+#import <UIKit/UIKit.h>
+
+#import <React/RCTAnimationType.h>
+#import <React/RCTBorderStyle.h>
+#import <React/RCTDefines.h>
+#import <React/RCTLog.h>
+#import <React/RCTPointerEvents.h>
+#import <React/RCTTextDecorationLineType.h>
+#import <yoga/Yoga.h>
+
+/**
+ * This class provides a collection of conversion functions for mapping
+ * JSON objects to native types and classes. These are useful when writing
+ * custom RCTViewManager setter methods.
+ */
+@interface RCTConvert : NSObject
+
++ (id)id:(id)json;
+
++ (BOOL)BOOL:(id)json;
++ (double)double:(id)json;
++ (float)float:(id)json;
++ (int)int:(id)json;
+
++ (int64_t)int64_t:(id)json;
++ (uint64_t)uint64_t:(id)json;
+
++ (NSInteger)NSInteger:(id)json;
++ (NSUInteger)NSUInteger:(id)json;
+
++ (NSArray *)NSArray:(id)json;
++ (NSDictionary *)NSDictionary:(id)json;
++ (NSString *)NSString:(id)json;
++ (NSNumber *)NSNumber:(id)json;
+
++ (NSSet *)NSSet:(id)json;
++ (NSData *)NSData:(id)json;
++ (NSIndexSet *)NSIndexSet:(id)json;
+
++ (NSURLRequestCachePolicy)NSURLRequestCachePolicy:(id)json;
++ (NSURL *)NSURL:(id)json;
++ (NSURLRequest *)NSURLRequest:(id)json;
+
+typedef NSURL RCTFileURL;
++ (RCTFileURL *)RCTFileURL:(id)json;
+
++ (NSDate *)NSDate:(id)json;
++ (NSLocale *)NSLocale:(id)json;
++ (NSTimeZone *)NSTimeZone:(id)json;
++ (NSTimeInterval)NSTimeInterval:(id)json;
+
++ (NSLineBreakMode)NSLineBreakMode:(id)json;
++ (NSTextAlignment)NSTextAlignment:(id)json;
++ (NSUnderlineStyle)NSUnderlineStyle:(id)json;
++ (NSWritingDirection)NSWritingDirection:(id)json;
++ (UITextAutocapitalizationType)UITextAutocapitalizationType:(id)json;
++ (UITextFieldViewMode)UITextFieldViewMode:(id)json;
++ (UIKeyboardType)UIKeyboardType:(id)json;
++ (UIKeyboardAppearance)UIKeyboardAppearance:(id)json;
++ (UIReturnKeyType)UIReturnKeyType:(id)json;
+#if !TARGET_OS_TV
++ (UIDataDetectorTypes)UIDataDetectorTypes:(id)json;
+#endif
+
++ (UIViewContentMode)UIViewContentMode:(id)json;
+#if !TARGET_OS_TV
++ (UIBarStyle)UIBarStyle:(id)json;
+#endif
+
++ (CGFloat)CGFloat:(id)json;
++ (CGPoint)CGPoint:(id)json;
++ (CGSize)CGSize:(id)json;
++ (CGRect)CGRect:(id)json;
++ (UIEdgeInsets)UIEdgeInsets:(id)json;
+
++ (CGLineCap)CGLineCap:(id)json;
++ (CGLineJoin)CGLineJoin:(id)json;
+
++ (CGAffineTransform)CGAffineTransform:(id)json;
+
++ (UIColor *)UIColor:(id)json;
++ (CGColorRef)CGColor:(id)json CF_RETURNS_NOT_RETAINED;
+
++ (YGValue)YGValue:(id)json;
+
++ (NSArray<NSArray *> *)NSArrayArray:(id)json;
++ (NSArray<NSString *> *)NSStringArray:(id)json;
++ (NSArray<NSArray<NSString *> *> *)NSStringArrayArray:(id)json;
++ (NSArray<NSDictionary *> *)NSDictionaryArray:(id)json;
++ (NSArray<NSURL *> *)NSURLArray:(id)json;
++ (NSArray<RCTFileURL *> *)RCTFileURLArray:(id)json;
++ (NSArray<NSNumber *> *)NSNumberArray:(id)json;
++ (NSArray<UIColor *> *)UIColorArray:(id)json;
+
+typedef NSArray CGColorArray;
++ (CGColorArray *)CGColorArray:(id)json;
+
+/**
+ * Convert a JSON object to a Plist-safe equivalent by stripping null values.
+ */
+typedef id NSPropertyList;
++ (NSPropertyList)NSPropertyList:(id)json;
+
+typedef BOOL css_backface_visibility_t;
++ (YGOverflow)YGOverflow:(id)json;
++ (YGDisplay)YGDisplay:(id)json;
++ (css_backface_visibility_t)css_backface_visibility_t:(id)json;
++ (YGFlexDirection)YGFlexDirection:(id)json;
++ (YGJustify)YGJustify:(id)json;
++ (YGAlign)YGAlign:(id)json;
++ (YGPositionType)YGPositionType:(id)json;
++ (YGWrap)YGWrap:(id)json;
++ (YGDirection)YGDirection:(id)json;
+
++ (RCTPointerEvents)RCTPointerEvents:(id)json;
++ (RCTAnimationType)RCTAnimationType:(id)json;
++ (RCTBorderStyle)RCTBorderStyle:(id)json;
++ (RCTTextDecorationLineType)RCTTextDecorationLineType:(id)json;
+
+@end
+
+@interface RCTConvert (Deprecated)
+
+/**
+ * Use lightweight generics syntax instead, e.g. NSArray<NSString *>
+ */
+typedef NSArray NSArrayArray __deprecated_msg("Use NSArray<NSArray *>");
+typedef NSArray NSStringArray __deprecated_msg("Use NSArray<NSString *>");
+typedef NSArray NSStringArrayArray __deprecated_msg("Use NSArray<NSArray<NSString *> *>");
+typedef NSArray NSDictionaryArray __deprecated_msg("Use NSArray<NSDictionary *>");
+typedef NSArray NSURLArray __deprecated_msg("Use NSArray<NSURL *>");
+typedef NSArray RCTFileURLArray __deprecated_msg("Use NSArray<RCTFileURL *>");
+typedef NSArray NSNumberArray __deprecated_msg("Use NSArray<NSNumber *>");
+typedef NSArray UIColorArray __deprecated_msg("Use NSArray<UIColor *>");
+
+/**
+ * Synchronous image loading is generally a bad idea for performance reasons.
+ * If you need to pass image references, try to use `RCTImageSource` and then
+ * `RCTImageLoader` instead of converting directly to a UIImage.
+ */
++ (UIImage *)UIImage:(id)json;
++ (CGImageRef)CGImage:(id)json CF_RETURNS_NOT_RETAINED;
+
+@end
+
+/**
+ * Underlying implementations of RCT_XXX_CONVERTER macros. Ignore these.
+ */
+RCT_EXTERN NSNumber *RCTConvertEnumValue(const char *, NSDictionary *, NSNumber *, id);
+RCT_EXTERN NSNumber *RCTConvertMultiEnumValue(const char *, NSDictionary *, NSNumber *, id);
+RCT_EXTERN NSArray *RCTConvertArrayValue(SEL, id);
+
+/**
+ * This macro is used for logging conversion errors. This is just used to
+ * avoid repeating the same boilerplate for every error message.
+ */
+#define RCTLogConvertError(json, typeName) \
+RCTLogError(@"JSON value '%@' of type %@ cannot be converted to %@", \
+json, [json classForCoder], typeName)
+
+/**
+ * This macro is used for creating simple converter functions that just call
+ * the specified getter method on the json value.
+ */
+#define RCT_CONVERTER(type, name, getter) \
+RCT_CUSTOM_CONVERTER(type, name, [json getter])
+
+/**
+ * This macro is used for creating converter functions with arbitrary logic.
+ */
+#define RCT_CUSTOM_CONVERTER(type, name, code) \
++ (type)name:(id)json RCT_DYNAMIC              \
+{                                              \
+  if (!RCT_DEBUG) {                            \
+    return code;                               \
+  } else {                                     \
+    @try {                                     \
+      return code;                             \
+    }                                          \
+    @catch (__unused NSException *e) {         \
+      RCTLogConvertError(json, @#type);        \
+      json = nil;                              \
+      return code;                             \
+    }                                          \
+  }                                            \
+}
+
+/**
+ * This macro is similar to RCT_CONVERTER, but specifically geared towards
+ * numeric types. It will handle string input correctly, and provides more
+ * detailed error reporting if an invalid value is passed in.
+ */
+#define RCT_NUMBER_CONVERTER(type, getter) \
+RCT_CUSTOM_CONVERTER(type, type, [RCT_DEBUG ? [self NSNumber:json] : json getter])
+
+/**
+ * When using RCT_ENUM_CONVERTER in ObjC, the compiler is OK with us returning
+ * the underlying NSInteger/NSUInteger. In ObjC++, this is a type mismatch and
+ * we need to explicitly cast the return value to expected enum return type.
+ */
+#ifdef __cplusplus
+#define _RCT_CAST(type, expr) static_cast<type>(expr)
+#else
+#define _RCT_CAST(type, expr) expr
+#endif
+
+/**
+ * This macro is used for creating converters for enum types.
+ */
+#define RCT_ENUM_CONVERTER(type, values, default, getter) \
++ (type)type:(id)json RCT_DYNAMIC                         \
+{                                                         \
+  static NSDictionary *mapping;                           \
+  static dispatch_once_t onceToken;                       \
+  dispatch_once(&onceToken, ^{                            \
+    mapping = values;                                     \
+  });                                                     \
+  return _RCT_CAST(type, [RCTConvertEnumValue(#type, mapping, @(default), json) getter]); \
+}
+
+/**
+ * This macro is used for creating converters for enum types for
+ * multiple enum values combined with | operator
+ */
+#define RCT_MULTI_ENUM_CONVERTER(type, values, default, getter) \
++ (type)type:(id)json RCT_DYNAMIC                         \
+{                                                         \
+  static NSDictionary *mapping;                           \
+  static dispatch_once_t onceToken;                       \
+  dispatch_once(&onceToken, ^{                            \
+    mapping = values;                                     \
+  });                                                     \
+  return _RCT_CAST(type, [RCTConvertMultiEnumValue(#type, mapping, @(default), json) getter]); \
+}
+
+/**
+ * This macro is used for creating explicitly-named converter functions
+ * for typed arrays.
+ */
+#define RCT_ARRAY_CONVERTER_NAMED(type, name)          \
++ (NSArray<type *> *)name##Array:(id)json RCT_DYNAMIC  \
+{                                                      \
+  return RCTConvertArrayValue(@selector(name:), json); \
+}
+
+/**
+ * This macro is used for creating converter functions for typed arrays.
+ * RCT_ARRAY_CONVERTER_NAMED may be used when type contains characters
+ * which are disallowed in selector names.
+ */
+#define RCT_ARRAY_CONVERTER(type) RCT_ARRAY_CONVERTER_NAMED(type, type)

node_modules/react-native/React/Base/RCTConvert.m

@@ -0,0 +1,785 @@
+/**
+ * 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 "RCTConvert.h"
+
+#import <objc/message.h>
+
+#import <CoreText/CoreText.h>
+
+#import "RCTDefines.h"
+#import "RCTImageSource.h"
+#import "RCTParserUtils.h"
+#import "RCTUtils.h"
+
+@implementation RCTConvert
+
+RCT_CONVERTER(id, id, self)
+
+RCT_CONVERTER(BOOL, BOOL, boolValue)
+RCT_NUMBER_CONVERTER(double, doubleValue)
+RCT_NUMBER_CONVERTER(float, floatValue)
+RCT_NUMBER_CONVERTER(int, intValue)
+
+RCT_NUMBER_CONVERTER(int64_t, longLongValue);
+RCT_NUMBER_CONVERTER(uint64_t, unsignedLongLongValue);
+
+RCT_NUMBER_CONVERTER(NSInteger, integerValue)
+RCT_NUMBER_CONVERTER(NSUInteger, unsignedIntegerValue)
+
+/**
+ * This macro is used for creating converter functions for directly
+ * representable json values that require no conversion.
+ */
+#if RCT_DEBUG
+#define RCT_JSON_CONVERTER(type)           \
++ (type *)type:(id)json                    \
+{                                          \
+  if ([json isKindOfClass:[type class]]) { \
+    return json;                           \
+  } else if (json) {                       \
+    RCTLogConvertError(json, @#type);      \
+  }                                        \
+  return nil;                              \
+}
+#else
+#define RCT_JSON_CONVERTER(type)           \
++ (type *)type:(id)json { return json; }
+#endif
+
+RCT_JSON_CONVERTER(NSArray)
+RCT_JSON_CONVERTER(NSDictionary)
+RCT_JSON_CONVERTER(NSString)
+RCT_JSON_CONVERTER(NSNumber)
+
+RCT_CUSTOM_CONVERTER(NSSet *, NSSet, [NSSet setWithArray:json])
+RCT_CUSTOM_CONVERTER(NSData *, NSData, [json dataUsingEncoding:NSUTF8StringEncoding])
+
++ (NSIndexSet *)NSIndexSet:(id)json
+{
+  json = [self NSNumberArray:json];
+  NSMutableIndexSet *indexSet = [NSMutableIndexSet new];
+  for (NSNumber *number in json) {
+    NSInteger index = number.integerValue;
+    if (RCT_DEBUG && index < 0) {
+      RCTLogError(@"Invalid index value %lld. Indices must be positive.", (long long)index);
+    }
+    [indexSet addIndex:index];
+  }
+  return indexSet;
+}
+
++ (NSURL *)NSURL:(id)json
+{
+  NSString *path = [self NSString:json];
+  if (!path) {
+    return nil;
+  }
+
+  @try { // NSURL has a history of crashing with bad input, so let's be safe
+
+    NSURL *URL = [NSURL URLWithString:path];
+    if (URL.scheme) { // Was a well-formed absolute URL
+      return URL;
+    }
+
+    // Check if it has a scheme
+    if ([path rangeOfString:@":"].location != NSNotFound) {
+      path = [path stringByAddingPercentEscapesUsingEncoding:NSUTF8StringEncoding];
+      URL = [NSURL URLWithString:path];
+      if (URL) {
+        return URL;
+      }
+    }
+
+    // Assume that it's a local path
+    path = path.stringByRemovingPercentEncoding;
+    if ([path hasPrefix:@"~"]) {
+      // Path is inside user directory
+      path = path.stringByExpandingTildeInPath;
+    } else if (!path.absolutePath) {
+      // Assume it's a resource path
+      path = [[NSBundle mainBundle].resourcePath stringByAppendingPathComponent:path];
+    }
+    if (!(URL = [NSURL fileURLWithPath:path])) {
+      RCTLogConvertError(json, @"a valid URL");
+    }
+    return URL;
+  }
+  @catch (__unused NSException *e) {
+    RCTLogConvertError(json, @"a valid URL");
+    return nil;
+  }
+}
+
+RCT_ENUM_CONVERTER(NSURLRequestCachePolicy, (@{
+                                               @"default": @(NSURLRequestUseProtocolCachePolicy),
+                                               @"reload": @(NSURLRequestReloadIgnoringLocalCacheData),
+                                               @"force-cache": @(NSURLRequestReturnCacheDataElseLoad),
+                                               @"only-if-cached": @(NSURLRequestReturnCacheDataDontLoad),
+                                               }), NSURLRequestUseProtocolCachePolicy, integerValue)
+
+
++ (NSURLRequest *)NSURLRequest:(id)json
+{
+  if ([json isKindOfClass:[NSString class]]) {
+    NSURL *URL = [self NSURL:json];
+    return URL ? [NSURLRequest requestWithURL:URL] : nil;
+  }
+  if ([json isKindOfClass:[NSDictionary class]]) {
+    NSString *URLString = json[@"uri"] ?: json[@"url"];
+
+    NSURL *URL;
+    NSString *bundleName = json[@"bundle"];
+    if (bundleName) {
+      URLString = [NSString stringWithFormat:@"%@.bundle/%@", bundleName, URLString];
+    }
+
+    URL = [self NSURL:URLString];
+    if (!URL) {
+      return nil;
+    }
+
+    NSData *body = [self NSData:json[@"body"]];
+    NSString *method = [self NSString:json[@"method"]].uppercaseString ?: @"GET";
+    NSURLRequestCachePolicy cachePolicy = [self NSURLRequestCachePolicy:json[@"cache"]];
+    NSDictionary *headers = [self NSDictionary:json[@"headers"]];
+    if ([method isEqualToString:@"GET"] && headers == nil && body == nil && cachePolicy == NSURLRequestUseProtocolCachePolicy) {
+      return [NSURLRequest requestWithURL:URL];
+    }
+
+    if (headers) {
+      __block BOOL allHeadersAreStrings = YES;
+      [headers enumerateKeysAndObjectsUsingBlock:^(NSString *key, id header, BOOL *stop) {
+        if (![header isKindOfClass:[NSString class]]) {
+          RCTLogError(@"Values of HTTP headers passed must be  of type string. "
+                      "Value of header '%@' is not a string.", key);
+          allHeadersAreStrings = NO;
+          *stop = YES;
+        }
+      }];
+      if (!allHeadersAreStrings) {
+        // Set headers to nil here to avoid crashing later.
+        headers = nil;
+      }
+    }
+
+    NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:URL];
+    request.HTTPBody = body;
+    request.HTTPMethod = method;
+    request.cachePolicy = cachePolicy;
+    request.allHTTPHeaderFields = headers;
+    return [request copy];
+  }
+  if (json) {
+    RCTLogConvertError(json, @"a valid URLRequest");
+  }
+  return nil;
+}
+
++ (RCTFileURL *)RCTFileURL:(id)json
+{
+  NSURL *fileURL = [self NSURL:json];
+  if (!fileURL.fileURL) {
+    RCTLogError(@"URI must be a local file, '%@' isn't.", fileURL);
+    return nil;
+  }
+  if (![[NSFileManager defaultManager] fileExistsAtPath:fileURL.path]) {
+    RCTLogError(@"File '%@' could not be found.", fileURL);
+    return nil;
+  }
+  return fileURL;
+}
+
++ (NSDate *)NSDate:(id)json
+{
+  if ([json isKindOfClass:[NSNumber class]]) {
+    return [NSDate dateWithTimeIntervalSince1970:[self NSTimeInterval:json]];
+  } else if ([json isKindOfClass:[NSString class]]) {
+    static NSDateFormatter *formatter;
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+      formatter = [NSDateFormatter new];
+      formatter.dateFormat = @"yyyy-MM-dd'T'HH:mm:ss.SSSZZZZZ";
+      formatter.locale = [NSLocale localeWithLocaleIdentifier:@"en_US_POSIX"];
+      formatter.timeZone = [NSTimeZone timeZoneWithName:@"UTC"];
+    });
+    NSDate *date = [formatter dateFromString:json];
+    if (!date) {
+      RCTLogError(@"JSON String '%@' could not be interpreted as a date. "
+                  "Expected format: YYYY-MM-DD'T'HH:mm:ss.sssZ", json);
+    }
+    return date;
+  } else if (json) {
+    RCTLogConvertError(json, @"a date");
+  }
+  return nil;
+}
+
++ (NSLocale *)NSLocale:(id)json
+{
+  if ([json isKindOfClass:[NSString class]]) {
+    NSLocale *locale = [[NSLocale alloc] initWithLocaleIdentifier:json];
+    if (!locale) {
+      RCTLogError(@"JSON String '%@' could not be interpreted as a valid locale. ", json);
+    }
+    return locale;
+  } else if (json) {
+    RCTLogConvertError(json, @"a locale");
+  }
+  return nil;
+}
+
+// JS Standard for time is milliseconds
+RCT_CUSTOM_CONVERTER(NSTimeInterval, NSTimeInterval, [self double:json] / 1000.0)
+
+// JS standard for time zones is minutes.
+RCT_CUSTOM_CONVERTER(NSTimeZone *, NSTimeZone, [NSTimeZone timeZoneForSecondsFromGMT:[self double:json] * 60.0])
+
+NSNumber *RCTConvertEnumValue(const char *typeName, NSDictionary *mapping, NSNumber *defaultValue, id json)
+{
+  if (!json) {
+    return defaultValue;
+  }
+  if ([json isKindOfClass:[NSNumber class]]) {
+    NSArray *allValues = mapping.allValues;
+    if ([allValues containsObject:json] || [json isEqual:defaultValue]) {
+      return json;
+    }
+    RCTLogError(@"Invalid %s '%@'. should be one of: %@", typeName, json, allValues);
+    return defaultValue;
+  }
+  if (RCT_DEBUG && ![json isKindOfClass:[NSString class]]) {
+    RCTLogError(@"Expected NSNumber or NSString for %s, received %@: %@",
+                typeName, [json classForCoder], json);
+  }
+  id value = mapping[json];
+  if (RCT_DEBUG && !value && [json description].length > 0) {
+    RCTLogError(@"Invalid %s '%@'. should be one of: %@", typeName, json, [[mapping allKeys] sortedArrayUsingSelector: @selector(caseInsensitiveCompare:)]);
+  }
+  return value ?: defaultValue;
+}
+
+NSNumber *RCTConvertMultiEnumValue(const char *typeName, NSDictionary *mapping, NSNumber *defaultValue, id json)
+{
+  if ([json isKindOfClass:[NSArray class]]) {
+    if ([json count] == 0) {
+      return defaultValue;
+    }
+    long long result = 0;
+    for (id arrayElement in json) {
+      NSNumber *value = RCTConvertEnumValue(typeName, mapping, defaultValue, arrayElement);
+      result |= value.longLongValue;
+    }
+    return @(result);
+  }
+  return RCTConvertEnumValue(typeName, mapping, defaultValue, json);
+}
+
+RCT_ENUM_CONVERTER(NSLineBreakMode, (@{
+  @"clip": @(NSLineBreakByClipping),
+  @"head": @(NSLineBreakByTruncatingHead),
+  @"tail": @(NSLineBreakByTruncatingTail),
+  @"middle": @(NSLineBreakByTruncatingMiddle),
+  @"wordWrapping": @(NSLineBreakByWordWrapping),
+}), NSLineBreakByTruncatingTail, integerValue)
+
+RCT_ENUM_CONVERTER(NSTextAlignment, (@{
+  @"auto": @(NSTextAlignmentNatural),
+  @"left": @(NSTextAlignmentLeft),
+  @"center": @(NSTextAlignmentCenter),
+  @"right": @(NSTextAlignmentRight),
+  @"justify": @(NSTextAlignmentJustified),
+}), NSTextAlignmentNatural, integerValue)
+
+RCT_ENUM_CONVERTER(NSUnderlineStyle, (@{
+  @"solid": @(NSUnderlineStyleSingle),
+  @"double": @(NSUnderlineStyleDouble),
+  @"dotted": @(NSUnderlinePatternDot | NSUnderlineStyleSingle),
+  @"dashed": @(NSUnderlinePatternDash | NSUnderlineStyleSingle),
+}), NSUnderlineStyleSingle, integerValue)
+
+RCT_ENUM_CONVERTER(RCTBorderStyle, (@{
+  @"solid": @(RCTBorderStyleSolid),
+  @"dotted": @(RCTBorderStyleDotted),
+  @"dashed": @(RCTBorderStyleDashed),
+}), RCTBorderStyleSolid, integerValue)
+
+RCT_ENUM_CONVERTER(RCTTextDecorationLineType, (@{
+  @"none": @(RCTTextDecorationLineTypeNone),
+  @"underline": @(RCTTextDecorationLineTypeUnderline),
+  @"line-through": @(RCTTextDecorationLineTypeStrikethrough),
+  @"underline line-through": @(RCTTextDecorationLineTypeUnderlineStrikethrough),
+}), RCTTextDecorationLineTypeNone, integerValue)
+
+RCT_ENUM_CONVERTER(NSWritingDirection, (@{
+  @"auto": @(NSWritingDirectionNatural),
+  @"ltr": @(NSWritingDirectionLeftToRight),
+  @"rtl": @(NSWritingDirectionRightToLeft),
+}), NSWritingDirectionNatural, integerValue)
+
+RCT_ENUM_CONVERTER(UITextAutocapitalizationType, (@{
+  @"none": @(UITextAutocapitalizationTypeNone),
+  @"words": @(UITextAutocapitalizationTypeWords),
+  @"sentences": @(UITextAutocapitalizationTypeSentences),
+  @"characters": @(UITextAutocapitalizationTypeAllCharacters)
+}), UITextAutocapitalizationTypeSentences, integerValue)
+
+RCT_ENUM_CONVERTER(UITextFieldViewMode, (@{
+  @"never": @(UITextFieldViewModeNever),
+  @"while-editing": @(UITextFieldViewModeWhileEditing),
+  @"unless-editing": @(UITextFieldViewModeUnlessEditing),
+  @"always": @(UITextFieldViewModeAlways),
+}), UITextFieldViewModeNever, integerValue)
+
+RCT_ENUM_CONVERTER(UIKeyboardType, (@{
+  @"default": @(UIKeyboardTypeDefault),
+  @"ascii-capable": @(UIKeyboardTypeASCIICapable),
+  @"numbers-and-punctuation": @(UIKeyboardTypeNumbersAndPunctuation),
+  @"url": @(UIKeyboardTypeURL),
+  @"number-pad": @(UIKeyboardTypeNumberPad),
+  @"phone-pad": @(UIKeyboardTypePhonePad),
+  @"name-phone-pad": @(UIKeyboardTypeNamePhonePad),
+  @"email-address": @(UIKeyboardTypeEmailAddress),
+  @"decimal-pad": @(UIKeyboardTypeDecimalPad),
+  @"twitter": @(UIKeyboardTypeTwitter),
+  @"web-search": @(UIKeyboardTypeWebSearch),
+  // Added for Android compatibility
+  @"numeric": @(UIKeyboardTypeDecimalPad),
+}), UIKeyboardTypeDefault, integerValue)
+
+#if !TARGET_OS_TV
+RCT_MULTI_ENUM_CONVERTER(UIDataDetectorTypes, (@{
+  @"phoneNumber": @(UIDataDetectorTypePhoneNumber),
+  @"link": @(UIDataDetectorTypeLink),
+  @"address": @(UIDataDetectorTypeAddress),
+  @"calendarEvent": @(UIDataDetectorTypeCalendarEvent),
+  @"none": @(UIDataDetectorTypeNone),
+  @"all": @(UIDataDetectorTypeAll),
+}), UIDataDetectorTypePhoneNumber, unsignedLongLongValue)
+#endif
+
+RCT_ENUM_CONVERTER(UIKeyboardAppearance, (@{
+  @"default": @(UIKeyboardAppearanceDefault),
+  @"light": @(UIKeyboardAppearanceLight),
+  @"dark": @(UIKeyboardAppearanceDark),
+}), UIKeyboardAppearanceDefault, integerValue)
+
+RCT_ENUM_CONVERTER(UIReturnKeyType, (@{
+  @"default": @(UIReturnKeyDefault),
+  @"go": @(UIReturnKeyGo),
+  @"google": @(UIReturnKeyGoogle),
+  @"join": @(UIReturnKeyJoin),
+  @"next": @(UIReturnKeyNext),
+  @"route": @(UIReturnKeyRoute),
+  @"search": @(UIReturnKeySearch),
+  @"send": @(UIReturnKeySend),
+  @"yahoo": @(UIReturnKeyYahoo),
+  @"done": @(UIReturnKeyDone),
+  @"emergency-call": @(UIReturnKeyEmergencyCall),
+}), UIReturnKeyDefault, integerValue)
+
+RCT_ENUM_CONVERTER(UIViewContentMode, (@{
+  @"scale-to-fill": @(UIViewContentModeScaleToFill),
+  @"scale-aspect-fit": @(UIViewContentModeScaleAspectFit),
+  @"scale-aspect-fill": @(UIViewContentModeScaleAspectFill),
+  @"redraw": @(UIViewContentModeRedraw),
+  @"center": @(UIViewContentModeCenter),
+  @"top": @(UIViewContentModeTop),
+  @"bottom": @(UIViewContentModeBottom),
+  @"left": @(UIViewContentModeLeft),
+  @"right": @(UIViewContentModeRight),
+  @"top-left": @(UIViewContentModeTopLeft),
+  @"top-right": @(UIViewContentModeTopRight),
+  @"bottom-left": @(UIViewContentModeBottomLeft),
+  @"bottom-right": @(UIViewContentModeBottomRight),
+  // Cross-platform values
+  @"cover": @(UIViewContentModeScaleAspectFill),
+  @"contain": @(UIViewContentModeScaleAspectFit),
+  @"stretch": @(UIViewContentModeScaleToFill),
+}), UIViewContentModeScaleAspectFill, integerValue)
+
+#if !TARGET_OS_TV
+RCT_ENUM_CONVERTER(UIBarStyle, (@{
+  @"default": @(UIBarStyleDefault),
+  @"black": @(UIBarStyleBlack),
+}), UIBarStyleDefault, integerValue)
+#endif
+
+static void convertCGStruct(const char *type, NSArray *fields, CGFloat *result, id json)
+{
+  NSUInteger count = fields.count;
+  if ([json isKindOfClass:[NSArray class]]) {
+    if (RCT_DEBUG && [json count] != count) {
+      RCTLogError(@"Expected array with count %llu, but count is %llu: %@", (unsigned long long)count, (unsigned long long)[json count], json);
+    } else {
+      for (NSUInteger i = 0; i < count; i++) {
+        result[i] = [RCTConvert CGFloat:RCTNilIfNull(json[i])];
+      }
+    }
+  } else if ([json isKindOfClass:[NSDictionary class]]) {
+    for (NSUInteger i = 0; i < count; i++) {
+      result[i] = [RCTConvert CGFloat:RCTNilIfNull(json[fields[i]])];
+    }
+  } else if (json) {
+    RCTLogConvertError(json, @(type));
+  }
+}
+
+/**
+ * This macro is used for creating converter functions for structs that consist
+ * of a number of CGFloat properties, such as CGPoint, CGRect, etc.
+ */
+#define RCT_CGSTRUCT_CONVERTER(type, values)                \
++ (type)type:(id)json                                       \
+{                                                           \
+  static NSArray *fields;                                   \
+  static dispatch_once_t onceToken;                         \
+  dispatch_once(&onceToken, ^{                              \
+    fields = values;                                        \
+  });                                                       \
+  type result;                                              \
+  convertCGStruct(#type, fields, (CGFloat *)&result, json); \
+  return result;                                            \
+}
+
+RCT_CUSTOM_CONVERTER(CGFloat, CGFloat, [self double:json])
+
+RCT_CGSTRUCT_CONVERTER(CGPoint, (@[@"x", @"y"]))
+RCT_CGSTRUCT_CONVERTER(CGSize, (@[@"width", @"height"]))
+RCT_CGSTRUCT_CONVERTER(CGRect, (@[@"x", @"y", @"width", @"height"]))
+RCT_CGSTRUCT_CONVERTER(UIEdgeInsets, (@[@"top", @"left", @"bottom", @"right"]))
+
+RCT_ENUM_CONVERTER(CGLineJoin, (@{
+  @"miter": @(kCGLineJoinMiter),
+  @"round": @(kCGLineJoinRound),
+  @"bevel": @(kCGLineJoinBevel),
+}), kCGLineJoinMiter, intValue)
+
+RCT_ENUM_CONVERTER(CGLineCap, (@{
+  @"butt": @(kCGLineCapButt),
+  @"round": @(kCGLineCapRound),
+  @"square": @(kCGLineCapSquare),
+}), kCGLineCapButt, intValue)
+
+RCT_CGSTRUCT_CONVERTER(CGAffineTransform, (@[
+  @"a", @"b", @"c", @"d", @"tx", @"ty"
+]))
+
++ (UIColor *)UIColor:(id)json
+{
+  if (!json) {
+    return nil;
+  }
+  if ([json isKindOfClass:[NSArray class]]) {
+    NSArray *components = [self NSNumberArray:json];
+    CGFloat alpha = components.count > 3 ? [self CGFloat:components[3]] : 1.0;
+    return [UIColor colorWithRed:[self CGFloat:components[0]]
+                           green:[self CGFloat:components[1]]
+                            blue:[self CGFloat:components[2]]
+                           alpha:alpha];
+  } else if ([json isKindOfClass:[NSNumber class]]) {
+    NSUInteger argb = [self NSUInteger:json];
+    CGFloat a = ((argb >> 24) & 0xFF) / 255.0;
+    CGFloat r = ((argb >> 16) & 0xFF) / 255.0;
+    CGFloat g = ((argb >> 8) & 0xFF) / 255.0;
+    CGFloat b = (argb & 0xFF) / 255.0;
+    return [UIColor colorWithRed:r green:g blue:b alpha:a];
+  } else {
+    RCTLogConvertError(json, @"a UIColor. Did you forget to call processColor() on the JS side?");
+    return nil;
+  }
+}
+
++ (CGColorRef)CGColor:(id)json
+{
+  return [self UIColor:json].CGColor;
+}
+
++ (YGValue)YGValue:(id)json
+{
+  if (!json) {
+    return YGValueUndefined;
+  } else if ([json isKindOfClass:[NSNumber class]]) {
+    return (YGValue) { [json floatValue], YGUnitPoint };
+  } else if ([json isKindOfClass:[NSString class]]) {
+    NSString *s = (NSString *) json;
+    if ([s isEqualToString:@"auto"]) {
+      return (YGValue) { YGUndefined, YGUnitAuto };
+    } else if ([s hasSuffix:@"%"]) {
+      return (YGValue) { [[s substringToIndex:s.length] floatValue], YGUnitPercent };
+    } else {
+      RCTLogConvertError(json, @"a YGValue. Did you forget the % or pt suffix?");
+    }
+  } else {
+    RCTLogConvertError(json, @"a YGValue.");
+  }
+  return YGValueUndefined;
+}
+
+NSArray *RCTConvertArrayValue(SEL type, id json)
+{
+  __block BOOL copy = NO;
+  __block NSArray *values = json = [RCTConvert NSArray:json];
+  [json enumerateObjectsUsingBlock:^(id jsonValue, NSUInteger idx, __unused BOOL *stop) {
+    id value = ((id(*)(Class, SEL, id))objc_msgSend)([RCTConvert class], type, jsonValue);
+    if (copy) {
+      if (value) {
+        [(NSMutableArray *)values addObject:value];
+      }
+    } else if (value != jsonValue) {
+      // Converted value is different, so we'll need to copy the array
+      values = [[NSMutableArray alloc] initWithCapacity:values.count];
+      for (NSUInteger i = 0; i < idx; i++) {
+        [(NSMutableArray *)values addObject:json[i]];
+      }
+      if (value) {
+        [(NSMutableArray *)values addObject:value];
+      }
+      copy = YES;
+    }
+  }];
+  return values;
+}
+
+RCT_ARRAY_CONVERTER(NSURL)
+RCT_ARRAY_CONVERTER(RCTFileURL)
+RCT_ARRAY_CONVERTER(UIColor)
+
+/**
+ * This macro is used for creating converter functions for directly
+ * representable json array values that require no conversion.
+ */
+#if RCT_DEBUG
+#define RCT_JSON_ARRAY_CONVERTER_NAMED(type, name) RCT_ARRAY_CONVERTER_NAMED(type, name)
+#else
+#define RCT_JSON_ARRAY_CONVERTER_NAMED(type, name) + (NSArray *)name##Array:(id)json { return json; }
+#endif
+#define RCT_JSON_ARRAY_CONVERTER(type) RCT_JSON_ARRAY_CONVERTER_NAMED(type, type)
+
+RCT_JSON_ARRAY_CONVERTER(NSArray)
+RCT_JSON_ARRAY_CONVERTER(NSString)
+RCT_JSON_ARRAY_CONVERTER_NAMED(NSArray<NSString *>, NSStringArray)
+RCT_JSON_ARRAY_CONVERTER(NSDictionary)
+RCT_JSON_ARRAY_CONVERTER(NSNumber)
+
+// Can't use RCT_ARRAY_CONVERTER due to bridged cast
++ (NSArray *)CGColorArray:(id)json
+{
+  NSMutableArray *colors = [NSMutableArray new];
+  for (id value in [self NSArray:json]) {
+    [colors addObject:(__bridge id)[self CGColor:value]];
+  }
+  return colors;
+}
+
+static id RCTConvertPropertyListValue(id json)
+{
+  if (!json || json == (id)kCFNull) {
+    return nil;
+  }
+
+  if ([json isKindOfClass:[NSDictionary class]]) {
+    __block BOOL copy = NO;
+    NSMutableDictionary *values = [[NSMutableDictionary alloc] initWithCapacity:[json count]];
+    [json enumerateKeysAndObjectsUsingBlock:^(NSString *key, id jsonValue, __unused BOOL *stop) {
+      id value = RCTConvertPropertyListValue(jsonValue);
+      if (value) {
+        values[key] = value;
+      }
+      copy |= value != jsonValue;
+    }];
+    return copy ? values : json;
+  }
+
+  if ([json isKindOfClass:[NSArray class]]) {
+    __block BOOL copy = NO;
+    __block NSArray *values = json;
+    [json enumerateObjectsUsingBlock:^(id jsonValue, NSUInteger idx, __unused BOOL *stop) {
+      id value = RCTConvertPropertyListValue(jsonValue);
+      if (copy) {
+        if (value) {
+          [(NSMutableArray *)values addObject:value];
+        }
+      } else if (value != jsonValue) {
+        // Converted value is different, so we'll need to copy the array
+        values = [[NSMutableArray alloc] initWithCapacity:values.count];
+        for (NSUInteger i = 0; i < idx; i++) {
+          [(NSMutableArray *)values addObject:json[i]];
+        }
+        if (value) {
+          [(NSMutableArray *)values addObject:value];
+        }
+        copy = YES;
+      }
+    }];
+    return values;
+  }
+
+  // All other JSON types are supported by property lists
+  return json;
+}
+
++ (NSPropertyList)NSPropertyList:(id)json
+{
+  return RCTConvertPropertyListValue(json);
+}
+
+RCT_ENUM_CONVERTER(css_backface_visibility_t, (@{
+  @"hidden": @NO,
+  @"visible": @YES
+}), YES, boolValue)
+
+RCT_ENUM_CONVERTER(YGOverflow, (@{
+  @"hidden": @(YGOverflowHidden),
+  @"visible": @(YGOverflowVisible),
+  @"scroll": @(YGOverflowScroll),
+}), YGOverflowVisible, intValue)
+
+RCT_ENUM_CONVERTER(YGDisplay, (@{
+  @"flex": @(YGDisplayFlex),
+  @"none": @(YGDisplayNone),
+}), YGDisplayFlex, intValue)
+
+RCT_ENUM_CONVERTER(YGFlexDirection, (@{
+  @"row": @(YGFlexDirectionRow),
+  @"row-reverse": @(YGFlexDirectionRowReverse),
+  @"column": @(YGFlexDirectionColumn),
+  @"column-reverse": @(YGFlexDirectionColumnReverse)
+}), YGFlexDirectionColumn, intValue)
+
+RCT_ENUM_CONVERTER(YGJustify, (@{
+  @"flex-start": @(YGJustifyFlexStart),
+  @"flex-end": @(YGJustifyFlexEnd),
+  @"center": @(YGJustifyCenter),
+  @"space-between": @(YGJustifySpaceBetween),
+  @"space-around": @(YGJustifySpaceAround),
+  @"space-evenly": @(YGJustifySpaceEvenly)
+}), YGJustifyFlexStart, intValue)
+
+RCT_ENUM_CONVERTER(YGAlign, (@{
+  @"flex-start": @(YGAlignFlexStart),
+  @"flex-end": @(YGAlignFlexEnd),
+  @"center": @(YGAlignCenter),
+  @"auto": @(YGAlignAuto),
+  @"stretch": @(YGAlignStretch),
+  @"baseline": @(YGAlignBaseline),
+  @"space-between": @(YGAlignSpaceBetween),
+  @"space-around": @(YGAlignSpaceAround)
+}), YGAlignFlexStart, intValue)
+
+RCT_ENUM_CONVERTER(YGDirection, (@{
+  @"inherit": @(YGDirectionInherit),
+  @"ltr": @(YGDirectionLTR),
+  @"rtl": @(YGDirectionRTL),
+}), YGDirectionInherit, intValue)
+
+RCT_ENUM_CONVERTER(YGPositionType, (@{
+  @"absolute": @(YGPositionTypeAbsolute),
+  @"relative": @(YGPositionTypeRelative)
+}), YGPositionTypeRelative, intValue)
+
+RCT_ENUM_CONVERTER(YGWrap, (@{
+  @"wrap": @(YGWrapWrap),
+  @"nowrap": @(YGWrapNoWrap)
+}), YGWrapNoWrap, intValue)
+
+RCT_ENUM_CONVERTER(RCTPointerEvents, (@{
+  @"none": @(RCTPointerEventsNone),
+  @"box-only": @(RCTPointerEventsBoxOnly),
+  @"box-none": @(RCTPointerEventsBoxNone),
+  @"auto": @(RCTPointerEventsUnspecified)
+}), RCTPointerEventsUnspecified, integerValue)
+
+RCT_ENUM_CONVERTER(RCTAnimationType, (@{
+  @"spring": @(RCTAnimationTypeSpring),
+  @"linear": @(RCTAnimationTypeLinear),
+  @"easeIn": @(RCTAnimationTypeEaseIn),
+  @"easeOut": @(RCTAnimationTypeEaseOut),
+  @"easeInEaseOut": @(RCTAnimationTypeEaseInEaseOut),
+  @"keyboard": @(RCTAnimationTypeKeyboard),
+}), RCTAnimationTypeEaseInEaseOut, integerValue)
+
+@end
+
+@interface RCTImageSource (Packager)
+
+@property (nonatomic, assign) BOOL packagerAsset;
+
+@end
+
+@implementation RCTConvert (Deprecated)
+
+/* This method is only used when loading images synchronously, e.g. for tabbar icons */
++ (UIImage *)UIImage:(id)json
+{
+  if (!json) {
+    return nil;
+  }
+
+  RCTImageSource *imageSource = [self RCTImageSource:json];
+  if (!imageSource) {
+    return nil;
+  }
+
+  __block UIImage *image;
+  if (!RCTIsMainQueue()) {
+    // It seems that none of the UIImage loading methods can be guaranteed
+    // thread safe, so we'll pick the lesser of two evils here and block rather
+    // than run the risk of crashing
+    RCTLogWarn(@"Calling [RCTConvert UIImage:] on a background thread is not recommended");
+    RCTUnsafeExecuteOnMainQueueSync(^{
+      image = [self UIImage:json];
+    });
+    return image;
+  }
+
+  NSURL *URL = imageSource.request.URL;
+  NSString *scheme = URL.scheme.lowercaseString;
+  if ([scheme isEqualToString:@"file"]) {
+    image = RCTImageFromLocalAssetURL(URL);
+    if (!image) {
+      RCTLogConvertError(json, @"an image. File not found.");
+    }
+  } else if ([scheme isEqualToString:@"data"]) {
+    image = [UIImage imageWithData:[NSData dataWithContentsOfURL:URL]];
+  } else if ([scheme isEqualToString:@"http"] && imageSource.packagerAsset) {
+    image = [UIImage imageWithData:[NSData dataWithContentsOfURL:URL]];
+  } else {
+    RCTLogConvertError(json, @"an image. Only local files or data URIs are supported.");
+    return nil;
+  }
+
+  CGFloat scale = imageSource.scale;
+  if (!scale && imageSource.size.width) {
+    // If no scale provided, set scale to image width / source width
+    scale = CGImageGetWidth(image.CGImage) / imageSource.size.width;
+  }
+
+  if (scale) {
+    image = [UIImage imageWithCGImage:image.CGImage
+                                scale:scale
+                          orientation:image.imageOrientation];
+  }
+
+  if (!CGSizeEqualToSize(imageSource.size, CGSizeZero) &&
+      !CGSizeEqualToSize(imageSource.size, image.size)) {
+    RCTLogError(@"Image source %@ size %@ does not match loaded image size %@.",
+                URL.path.lastPathComponent,
+                NSStringFromCGSize(imageSource.size),
+                NSStringFromCGSize(image.size));
+  }
+
+  return image;
+}
+
++ (CGImageRef)CGImage:(id)json
+{
+  return [self UIImage:json].CGImage;
+}
+
+@end

node_modules/react-native/React/Base/RCTCxxConvert.h

@@ -0,0 +1,18 @@
+/**
+ * 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>
+
+/**
+ * This class provides a collection of conversion functions for mapping
+ * JSON objects to cxx types. Extensible via categories.
+ * Convert methods are expected to return cxx objects wraped in RCTManagedPointer.
+ */
+
+@interface RCTCxxConvert : NSObject
+
+@end

node_modules/react-native/React/Base/RCTCxxConvert.m

@@ -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 "RCTCxxConvert.h"
+
+@implementation RCTCxxConvert
+
+@end

node_modules/react-native/React/Base/RCTDefines.h

@@ -0,0 +1,127 @@
+/**
+ * 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.
+ */
+
+#if __OBJC__
+#  import <Foundation/Foundation.h>
+#endif
+
+/**
+ * Make global functions usable in C++
+ */
+#if defined(__cplusplus)
+#define RCT_EXTERN extern "C" __attribute__((visibility("default")))
+#define RCT_EXTERN_C_BEGIN extern "C" {
+#define RCT_EXTERN_C_END }
+#else
+#define RCT_EXTERN extern __attribute__((visibility("default")))
+#define RCT_EXTERN_C_BEGIN
+#define RCT_EXTERN_C_END
+#endif
+
+/**
+ * The RCT_DEBUG macro can be used to exclude error checking and logging code
+ * from release builds to improve performance and reduce binary size.
+ */
+#ifndef RCT_DEBUG
+#if DEBUG
+#define RCT_DEBUG 1
+#else
+#define RCT_DEBUG 0
+#endif
+#endif
+
+/**
+ * The RCT_DEV macro can be used to enable or disable development tools
+ * such as the debug executors, dev menu, red box, etc.
+ */
+#ifndef RCT_DEV
+#if DEBUG
+#define RCT_DEV 1
+#else
+#define RCT_DEV 0
+#endif
+#endif
+
+#ifndef RCT_ENABLE_INSPECTOR
+#if RCT_DEV && __has_include(<React/RCTInspectorDevServerHelper.h>)
+#define RCT_ENABLE_INSPECTOR 1
+#else
+#define RCT_ENABLE_INSPECTOR 0
+#endif
+#endif
+
+#ifndef ENABLE_PACKAGER_CONNECTION
+#if RCT_DEV && __has_include(<React/RCTPackagerConnection.h>)
+#define ENABLE_PACKAGER_CONNECTION 1
+#else
+#define ENABLE_PACKAGER_CONNECTION 0
+#endif
+#endif
+
+#if RCT_DEV
+#define RCT_IF_DEV(...) __VA_ARGS__
+#else
+#define RCT_IF_DEV(...)
+#endif
+
+#ifndef RCT_PROFILE
+#define RCT_PROFILE RCT_DEV
+#endif
+
+/**
+ * Add the default Metro packager port number
+ */
+#ifndef RCT_METRO_PORT
+#define RCT_METRO_PORT 8081
+#else
+// test if RCT_METRO_PORT is empty
+#define RCT_METRO_PORT_DO_EXPAND(VAL)  VAL ## 1
+#define RCT_METRO_PORT_EXPAND(VAL)     RCT_METRO_PORT_DO_EXPAND(VAL)
+#if !defined(RCT_METRO_PORT) || (RCT_METRO_PORT_EXPAND(RCT_METRO_PORT) == 1)
+// Only here if RCT_METRO_PORT is not defined
+// OR RCT_METRO_PORT is the empty string
+#undef RCT_METRO_PORT
+#define RCT_METRO_PORT 8081
+#endif
+#endif
+
+/**
+ * By default, only raise an NSAssertion in debug mode
+ * (custom assert functions will still be called).
+ */
+#ifndef RCT_NSASSERT
+#define RCT_NSASSERT RCT_DEBUG
+#endif
+
+/**
+ * Concat two literals. Supports macro expansions,
+ * e.g. RCT_CONCAT(foo, __FILE__).
+ */
+#define RCT_CONCAT2(A, B) A ## B
+#define RCT_CONCAT(A, B) RCT_CONCAT2(A, B)
+
+/**
+  * This attribute is used for static analysis.
+  */
+#if !defined RCT_DYNAMIC
+#if __has_attribute(objc_dynamic)
+#define RCT_DYNAMIC __attribute__((objc_dynamic))
+#else
+#define RCT_DYNAMIC
+#endif
+#endif
+
+/**
+ * Throw an assertion for unimplemented methods.
+ */
+#define RCT_NOT_IMPLEMENTED(method) \
+_Pragma("clang diagnostic push") \
+_Pragma("clang diagnostic ignored \"-Wmissing-method-return-type\"") \
+_Pragma("clang diagnostic ignored \"-Wunused-parameter\"") \
+RCT_EXTERN NSException *_RCTNotImplementedException(SEL, Class); \
+method NS_UNAVAILABLE { @throw _RCTNotImplementedException(_cmd, [self class]); } \
+_Pragma("clang diagnostic pop")

node_modules/react-native/React/Base/RCTDisplayLink.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>
+
+@protocol RCTBridgeModule;
+@class RCTModuleData;
+
+@interface RCTDisplayLink : NSObject
+
+- (instancetype)init;
+- (void)invalidate;
+- (void)registerModuleForFrameUpdates:(id<RCTBridgeModule>)module
+                       withModuleData:(RCTModuleData *)moduleData;
+- (void)addToRunLoop:(NSRunLoop *)runLoop;
+
+@end

node_modules/react-native/React/Base/RCTDisplayLink.m

@@ -0,0 +1,147 @@
+/**
+ * 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 "RCTDisplayLink.h"
+
+#import <Foundation/Foundation.h>
+#import <QuartzCore/CADisplayLink.h>
+
+#import "RCTAssert.h"
+#import "RCTBridgeModule.h"
+#import "RCTFrameUpdate.h"
+#import "RCTModuleData.h"
+#import "RCTProfile.h"
+
+#define RCTAssertRunLoop() \
+  RCTAssert(_runLoop == [NSRunLoop currentRunLoop], \
+  @"This method must be called on the CADisplayLink run loop")
+
+@implementation RCTDisplayLink
+{
+  CADisplayLink *_jsDisplayLink;
+  NSMutableSet<RCTModuleData *> *_frameUpdateObservers;
+  NSRunLoop *_runLoop;
+}
+
+- (instancetype)init
+{
+  if ((self = [super init])) {
+    _frameUpdateObservers = [NSMutableSet new];
+    _jsDisplayLink = [CADisplayLink displayLinkWithTarget:self selector:@selector(_jsThreadUpdate:)];
+  }
+
+  return self;
+}
+
+- (void)registerModuleForFrameUpdates:(id<RCTBridgeModule>)module
+                       withModuleData:(RCTModuleData *)moduleData
+{
+  if (![moduleData.moduleClass conformsToProtocol:@protocol(RCTFrameUpdateObserver)] ||
+      [_frameUpdateObservers containsObject:moduleData]) {
+    return;
+  }
+
+  [_frameUpdateObservers addObject:moduleData];
+
+  // Don't access the module instance via moduleData, as this will cause deadlock
+  id<RCTFrameUpdateObserver> observer = (id<RCTFrameUpdateObserver>)module;
+  __weak typeof(self) weakSelf = self;
+  observer.pauseCallback = ^{
+    typeof(self) strongSelf = weakSelf;
+    if (!strongSelf) {
+      return;
+    }
+
+    CFRunLoopRef cfRunLoop = [strongSelf->_runLoop getCFRunLoop];
+    if (!cfRunLoop) {
+      return;
+    }
+
+    if ([NSRunLoop currentRunLoop] == strongSelf->_runLoop) {
+      [weakSelf updateJSDisplayLinkState];
+    } else {
+      CFRunLoopPerformBlock(cfRunLoop, kCFRunLoopDefaultMode, ^{
+        [weakSelf updateJSDisplayLinkState];
+      });
+      CFRunLoopWakeUp(cfRunLoop);
+    }
+  };
+
+  // Assuming we're paused right now, we only need to update the display link's state
+  // when the new observer is not paused. If it not paused, the observer will immediately
+  // start receiving updates anyway.
+  if (![observer isPaused] && _runLoop) {
+    CFRunLoopPerformBlock([_runLoop getCFRunLoop], kCFRunLoopDefaultMode, ^{
+      [self updateJSDisplayLinkState];
+    });
+  }
+}
+
+- (void)addToRunLoop:(NSRunLoop *)runLoop
+{
+  _runLoop = runLoop;
+  [_jsDisplayLink addToRunLoop:runLoop forMode:NSRunLoopCommonModes];
+}
+
+- (void)invalidate
+{
+  [_jsDisplayLink invalidate];
+}
+
+- (void)dispatchBlock:(dispatch_block_t)block
+                queue:(dispatch_queue_t)queue
+{
+  if (queue == RCTJSThread) {
+    block();
+  } else if (queue) {
+    dispatch_async(queue, block);
+  }
+}
+
+- (void)_jsThreadUpdate:(CADisplayLink *)displayLink
+{
+  RCTAssertRunLoop();
+
+  RCT_PROFILE_BEGIN_EVENT(RCTProfileTagAlways, @"-[RCTDisplayLink _jsThreadUpdate:]", nil);
+
+  RCTFrameUpdate *frameUpdate = [[RCTFrameUpdate alloc] initWithDisplayLink:displayLink];
+  for (RCTModuleData *moduleData in _frameUpdateObservers) {
+    id<RCTFrameUpdateObserver> observer = (id<RCTFrameUpdateObserver>)moduleData.instance;
+    if (!observer.paused) {
+      RCTProfileBeginFlowEvent();
+
+      [self dispatchBlock:^{
+        RCTProfileEndFlowEvent();
+        [observer didUpdateFrame:frameUpdate];
+      } queue:moduleData.methodQueue];
+    }
+  }
+
+  [self updateJSDisplayLinkState];
+
+  RCTProfileImmediateEvent(RCTProfileTagAlways, @"JS Thread Tick", displayLink.timestamp, 'g');
+
+  RCT_PROFILE_END_EVENT(RCTProfileTagAlways, @"objc_call");
+}
+
+- (void)updateJSDisplayLinkState
+{
+  RCTAssertRunLoop();
+
+  BOOL pauseDisplayLink = YES;
+  for (RCTModuleData *moduleData in _frameUpdateObservers) {
+    id<RCTFrameUpdateObserver> observer = (id<RCTFrameUpdateObserver>)moduleData.instance;
+    if (!observer.paused) {
+      pauseDisplayLink = NO;
+      break;
+    }
+  }
+
+  _jsDisplayLink.paused = pauseDisplayLink;
+}
+
+@end

node_modules/react-native/React/Base/RCTErrorCustomizer.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 <Foundation/Foundation.h>
+
+@class RCTErrorInfo;
+
+/**
+ * Provides an interface to customize React Native error messages and stack
+ * traces from exceptions.
+ */
+@protocol RCTErrorCustomizer <NSObject>
+
+/**
+ * Customizes the given error, returning the passed info argument if no
+ * customization is required.
+ */
+- (nonnull RCTErrorInfo *)customizeErrorInfo:(nonnull RCTErrorInfo *)info;
+@end

node_modules/react-native/React/Base/RCTErrorInfo.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 <Foundation/Foundation.h>
+
+@class RCTJSStackFrame;
+
+/**
+ * An ObjC wrapper for React Native errors.
+ */
+@interface RCTErrorInfo : NSObject
+@property (nonatomic, copy, readonly) NSString *errorMessage;
+@property (nonatomic, copy, readonly) NSArray<RCTJSStackFrame *> *stack;
+
+
+- (instancetype)initWithErrorMessage:(NSString *)errorMessage
+                               stack:(NSArray<RCTJSStackFrame *> *)stack;
+
+@end

node_modules/react-native/React/Base/RCTErrorInfo.m

@@ -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 "RCTErrorInfo.h"
+
+#import "RCTJSStackFrame.h"
+
+@implementation RCTErrorInfo
+
+- (instancetype)initWithErrorMessage:(NSString *)errorMessage
+                               stack:(NSArray<RCTJSStackFrame *> *)stack {
+  self = [super init];
+  if (self) {
+    _errorMessage = [errorMessage copy];
+    _stack = [stack copy];
+  }
+  return self;
+}
+
+@end

node_modules/react-native/React/Base/RCTEventDispatcher.h

@@ -0,0 +1,123 @@
+/**
+ * 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>
+
+typedef NS_ENUM(NSInteger, RCTTextEventType)
+{
+  RCTTextEventTypeFocus,
+  RCTTextEventTypeBlur,
+  RCTTextEventTypeChange,
+  RCTTextEventTypeSubmit,
+  RCTTextEventTypeEnd,
+  RCTTextEventTypeKeyPress
+};
+
+/**
+ * The threshold at which text inputs will start warning that the JS thread
+ * has fallen behind (resulting in poor input performance, missed keys, etc.)
+ */
+RCT_EXTERN const NSInteger RCTTextUpdateLagWarningThreshold;
+
+/**
+ * Takes an input event name and normalizes it to the form that is required
+ * by the events system (currently that means starting with the "top" prefix,
+ * but that's an implementation detail that may change in future).
+ */
+RCT_EXTERN NSString *RCTNormalizeInputEventName(NSString *eventName);
+
+@protocol RCTEvent <NSObject>
+@required
+
+@property (nonatomic, strong, readonly) NSNumber *viewTag;
+@property (nonatomic, copy, readonly) NSString *eventName;
+@property (nonatomic, assign, readonly) uint16_t coalescingKey;
+
+- (BOOL)canCoalesce;
+- (id<RCTEvent>)coalesceWithEvent:(id<RCTEvent>)newEvent;
+
+// used directly for doing a JS call
++ (NSString *)moduleDotMethod;
+// must contain only JSON compatible values
+- (NSArray *)arguments;
+
+@end
+
+/**
+ * This protocol allows observing events dispatched by RCTEventDispatcher.
+ */
+@protocol RCTEventDispatcherObserver <NSObject>
+
+/**
+ * Called before dispatching an event, on the same thread the event was
+ * dispatched from.
+ */
+- (void)eventDispatcherWillDispatchEvent:(id<RCTEvent>)event;
+
+@end
+
+
+/**
+ * This class wraps the -[RCTBridge enqueueJSCall:args:] method, and
+ * provides some convenience methods for generating event calls.
+ */
+@interface RCTEventDispatcher : NSObject <RCTBridgeModule>
+
+/**
+ * Deprecated, do not use.
+ */
+- (void)sendAppEventWithName:(NSString *)name body:(id)body
+__deprecated_msg("Subclass RCTEventEmitter instead");
+
+/**
+ * Deprecated, do not use.
+ */
+- (void)sendDeviceEventWithName:(NSString *)name body:(id)body
+__deprecated_msg("Subclass RCTEventEmitter instead");
+
+/**
+ * Deprecated, do not use.
+ */
+- (void)sendInputEventWithName:(NSString *)name body:(NSDictionary *)body
+__deprecated_msg("Use RCTDirectEventBlock or RCTBubblingEventBlock instead");
+
+/**
+ * Send a text input/focus event. For internal use only.
+ */
+- (void)sendTextEventWithType:(RCTTextEventType)type
+                     reactTag:(NSNumber *)reactTag
+                         text:(NSString *)text
+                          key:(NSString *)key
+                   eventCount:(NSInteger)eventCount;
+
+/**
+ * Send a pre-prepared event object.
+ *
+ * Events are sent to JS as soon as the thread is free to process them.
+ * If an event can be coalesced and there is another compatible event waiting, the coalescing will happen immediately.
+ */
+- (void)sendEvent:(id<RCTEvent>)event;
+
+/**
+ * Add an event dispatcher observer.
+ */
+- (void)addDispatchObserver:(id<RCTEventDispatcherObserver>)observer;
+
+/**
+ * Remove an event dispatcher observer.
+ */
+- (void)removeDispatchObserver:(id<RCTEventDispatcherObserver>)observer;
+
+@end
+
+@interface RCTBridge (RCTEventDispatcher)
+
+- (RCTEventDispatcher *)eventDispatcher;
+
+@end

node_modules/react-native/React/Base/RCTEventDispatcher.m

@@ -0,0 +1,233 @@
+/**
+ * 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 "RCTEventDispatcher.h"
+
+#import "RCTAssert.h"
+#import "RCTBridge.h"
+#import "RCTBridge+Private.h"
+#import "RCTUtils.h"
+#import "RCTProfile.h"
+
+const NSInteger RCTTextUpdateLagWarningThreshold = 3;
+
+NSString *RCTNormalizeInputEventName(NSString *eventName)
+{
+  if ([eventName hasPrefix:@"on"]) {
+    eventName = [eventName stringByReplacingCharactersInRange:(NSRange){0, 2} withString:@"top"];
+  } else if (![eventName hasPrefix:@"top"]) {
+    eventName = [[@"top" stringByAppendingString:[eventName substringToIndex:1].uppercaseString]
+                 stringByAppendingString:[eventName substringFromIndex:1]];
+  }
+  return eventName;
+}
+
+static NSNumber *RCTGetEventID(id<RCTEvent> event)
+{
+  return @(
+    event.viewTag.intValue |
+    (((uint64_t)event.eventName.hash & 0xFFFF) << 32) |
+    (((uint64_t)event.coalescingKey) << 48)
+  );
+}
+
+@implementation RCTEventDispatcher
+{
+  // We need this lock to protect access to _events, _eventQueue and _eventsDispatchScheduled. It's filled in on main thread and consumed on js thread.
+  NSLock *_eventQueueLock;
+  // We have this id -> event mapping so we coalesce effectively.
+  NSMutableDictionary<NSNumber *, id<RCTEvent>> *_events;
+  // This array contains ids of events in order they come in, so we can emit them to JS in the exact same order.
+  NSMutableArray<NSNumber *> *_eventQueue;
+  BOOL _eventsDispatchScheduled;
+  NSHashTable<id<RCTEventDispatcherObserver>> *_observers;
+  NSLock *_observersLock;
+}
+
+@synthesize bridge = _bridge;
+
+RCT_EXPORT_MODULE()
+
+- (void)setBridge:(RCTBridge *)bridge
+{
+  _bridge = bridge;
+  _events = [NSMutableDictionary new];
+  _eventQueue = [NSMutableArray new];
+  _eventQueueLock = [NSLock new];
+  _eventsDispatchScheduled = NO;
+  _observers = [NSHashTable weakObjectsHashTable];
+  _observersLock = [NSLock new];
+}
+
+- (void)sendAppEventWithName:(NSString *)name body:(id)body
+{
+  [_bridge enqueueJSCall:@"RCTNativeAppEventEmitter"
+                  method:@"emit"
+                    args:body ? @[name, body] : @[name]
+              completion:NULL];
+}
+
+- (void)sendDeviceEventWithName:(NSString *)name body:(id)body
+{
+  [_bridge enqueueJSCall:@"RCTDeviceEventEmitter"
+                  method:@"emit"
+                    args:body ? @[name, body] : @[name]
+              completion:NULL];
+}
+
+- (void)sendInputEventWithName:(NSString *)name body:(NSDictionary *)body
+{
+  if (RCT_DEBUG) {
+    RCTAssert([body[@"target"] isKindOfClass:[NSNumber class]],
+      @"Event body dictionary must include a 'target' property containing a React tag");
+  }
+
+  name = RCTNormalizeInputEventName(name);
+  [_bridge enqueueJSCall:@"RCTEventEmitter"
+                  method:@"receiveEvent"
+                    args:body ? @[body[@"target"], name, body] : @[body[@"target"], name]
+              completion:NULL];
+}
+
+- (void)sendTextEventWithType:(RCTTextEventType)type
+                     reactTag:(NSNumber *)reactTag
+                         text:(NSString *)text
+                          key:(NSString *)key
+                   eventCount:(NSInteger)eventCount
+{
+  static NSString *events[] = {
+    @"focus",
+    @"blur",
+    @"change",
+    @"submitEditing",
+    @"endEditing",
+    @"keyPress"
+  };
+
+  NSMutableDictionary *body = [[NSMutableDictionary alloc] initWithDictionary:@{
+    @"eventCount": @(eventCount),
+    @"target": reactTag
+  }];
+
+  if (text) {
+    body[@"text"] = text;
+  }
+
+  if (key) {
+    if (key.length == 0) {
+      key = @"Backspace"; // backspace
+    } else {
+      switch ([key characterAtIndex:0]) {
+        case '\t':
+          key = @"Tab";
+          break;
+        case '\n':
+          key = @"Enter";
+        default:
+          break;
+      }
+    }
+    body[@"key"] = key;
+  }
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+  [self sendInputEventWithName:events[type] body:body];
+#pragma clang diagnostic pop
+}
+
+- (void)sendEvent:(id<RCTEvent>)event
+{
+  [_observersLock lock];
+
+  for (id<RCTEventDispatcherObserver> observer in _observers) {
+    [observer eventDispatcherWillDispatchEvent:event];
+  }
+
+  [_observersLock unlock];
+
+  [_eventQueueLock lock];
+
+  NSNumber *eventID = RCTGetEventID(event);
+
+  id<RCTEvent> previousEvent = _events[eventID];
+  if (previousEvent) {
+    RCTAssert([event canCoalesce], @"Got event %@ which cannot be coalesced, but has the same eventID %@ as the previous event %@", event, eventID, previousEvent);
+    event = [previousEvent coalesceWithEvent:event];
+  } else {
+    [_eventQueue addObject:eventID];
+  }
+  _events[eventID] = event;
+
+  BOOL scheduleEventsDispatch = NO;
+  if (!_eventsDispatchScheduled) {
+    _eventsDispatchScheduled = YES;
+    scheduleEventsDispatch = YES;
+  }
+
+  // We have to release the lock before dispatching block with events,
+  // since dispatchBlock: can be executed synchronously on the same queue.
+  // (This is happening when chrome debugging is turned on.)
+  [_eventQueueLock unlock];
+
+  if (scheduleEventsDispatch) {
+    [_bridge dispatchBlock:^{
+      [self flushEventsQueue];
+    } queue:RCTJSThread];
+  }
+}
+
+- (void)addDispatchObserver:(id<RCTEventDispatcherObserver>)observer
+{
+  [_observersLock lock];
+  [_observers addObject:observer];
+  [_observersLock unlock];
+}
+
+- (void)removeDispatchObserver:(id<RCTEventDispatcherObserver>)observer
+{
+  [_observersLock lock];
+  [_observers removeObject:observer];
+  [_observersLock unlock];
+}
+
+- (void)dispatchEvent:(id<RCTEvent>)event
+{
+  [_bridge enqueueJSCall:[[event class] moduleDotMethod] args:[event arguments]];
+}
+
+- (dispatch_queue_t)methodQueue
+{
+  return RCTJSThread;
+}
+
+// js thread only (which surprisingly can be the main thread, depends on used JS executor)
+- (void)flushEventsQueue
+{
+  [_eventQueueLock lock];
+  NSDictionary *events = _events;
+  _events = [NSMutableDictionary new];
+  NSMutableArray *eventQueue = _eventQueue;
+  _eventQueue = [NSMutableArray new];
+  _eventsDispatchScheduled = NO;
+  [_eventQueueLock unlock];
+
+  for (NSNumber *eventId in eventQueue) {
+    [self dispatchEvent:events[eventId]];
+  }
+}
+
+@end
+
+@implementation RCTBridge (RCTEventDispatcher)
+
+- (RCTEventDispatcher *)eventDispatcher
+{
+  return [self moduleForClass:[RCTEventDispatcher class]];
+}
+
+@end

node_modules/react-native/React/Base/RCTFrameUpdate.h

@@ -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 <Foundation/Foundation.h>
+
+@class CADisplayLink;
+
+/**
+ * Interface containing the information about the last screen refresh.
+ */
+@interface RCTFrameUpdate : NSObject
+
+/**
+ * Timestamp for the actual screen refresh
+ */
+@property (nonatomic, readonly) NSTimeInterval timestamp;
+
+/**
+ * Time since the last frame update ( >= 16.6ms )
+ */
+@property (nonatomic, readonly) NSTimeInterval deltaTime;
+
+- (instancetype)initWithDisplayLink:(CADisplayLink *)displayLink NS_DESIGNATED_INITIALIZER;
+
+@end
+
+/**
+ * Protocol that must be implemented for subscribing to display refreshes (DisplayLink updates)
+ */
+@protocol RCTFrameUpdateObserver <NSObject>
+
+/**
+ * Method called on every screen refresh (if paused != YES)
+ */
+- (void)didUpdateFrame:(RCTFrameUpdate *)update;
+
+/**
+ * Synthesize and set to true to pause the calls to -[didUpdateFrame:]
+ */
+@property (nonatomic, readonly, getter=isPaused) BOOL paused;
+
+/**
+ * Callback for pause/resume observer.
+ * Observer should call it when paused property is changed.
+ */
+@property (nonatomic, copy) dispatch_block_t pauseCallback;
+
+@end

node_modules/react-native/React/Base/RCTFrameUpdate.m

@@ -0,0 +1,27 @@
+/**
+ * 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 <QuartzCore/CADisplayLink.h>
+
+#import "RCTFrameUpdate.h"
+
+#import "RCTUtils.h"
+
+@implementation RCTFrameUpdate
+
+RCT_NOT_IMPLEMENTED(- (instancetype)init)
+
+- (instancetype)initWithDisplayLink:(CADisplayLink *)displayLink
+{
+  if ((self = [super init])) {
+    _timestamp = displayLink.timestamp;
+    _deltaTime = displayLink.duration;
+  }
+  return self;
+}
+
+@end

node_modules/react-native/React/Base/RCTImageSource.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 <Foundation/Foundation.h>
+
+#import <React/RCTConvert.h>
+
+/**
+ * Object containing an image URL and associated metadata.
+ */
+@interface RCTImageSource : NSObject
+
+@property (nonatomic, copy, readonly) NSURLRequest *request;
+@property (nonatomic, assign, readonly) CGSize size;
+@property (nonatomic, assign, readonly) CGFloat scale;
+
+/**
+ * Create a new image source object.
+ * Pass a size of CGSizeZero if you do not know or wish to specify the image
+ * size. Pass a scale of zero if you do not know or wish to specify the scale.
+ */
+- (instancetype)initWithURLRequest:(NSURLRequest *)request
+                              size:(CGSize)size
+                             scale:(CGFloat)scale;
+
+/**
+ * Create a copy of the image source with the specified size and scale.
+ */
+- (instancetype)imageSourceWithSize:(CGSize)size scale:(CGFloat)scale;
+
+@end
+
+@interface RCTConvert (ImageSource)
+
++ (RCTImageSource *)RCTImageSource:(id)json;
++ (NSArray<RCTImageSource *> *)RCTImageSourceArray:(id)json;
+
+@end

node_modules/react-native/React/Base/RCTImageSource.m

@@ -0,0 +1,90 @@
+/**
+ * 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 "RCTImageSource.h"
+#import "RCTUtils.h"
+
+@interface RCTImageSource ()
+
+@property (nonatomic, assign) BOOL packagerAsset;
+
+@end
+
+@implementation RCTImageSource
+
+- (instancetype)initWithURLRequest:(NSURLRequest *)request size:(CGSize)size scale:(CGFloat)scale
+{
+  if ((self = [super init])) {
+    _request = [request copy];
+    _size = size;
+    _scale = scale;
+  }
+  return self;
+}
+
+- (instancetype)imageSourceWithSize:(CGSize)size scale:(CGFloat)scale
+{
+  RCTImageSource *imageSource = [[RCTImageSource alloc] initWithURLRequest:_request
+                                                                      size:size
+                                                                     scale:scale];
+  imageSource.packagerAsset = _packagerAsset;
+  return imageSource;
+}
+
+- (BOOL)isEqual:(RCTImageSource *)object
+{
+  if (![object isKindOfClass:[RCTImageSource class]]) {
+    return NO;
+  }
+  return [_request isEqual:object.request] && _scale == object.scale &&
+  (CGSizeEqualToSize(_size, object.size) || CGSizeEqualToSize(object.size, CGSizeZero));
+}
+
+- (NSString *)description
+{
+  return [NSString stringWithFormat:@"<RCTImageSource: %p URL=%@, size=%@, scale=%0.f>",
+          self, _request.URL, NSStringFromCGSize(_size), _scale];
+}
+
+@end
+
+@implementation RCTConvert (ImageSource)
+
++ (RCTImageSource *)RCTImageSource:(id)json
+{
+  if (!json) {
+    return nil;
+  }
+
+  NSURLRequest *request;
+  CGSize size = CGSizeZero;
+  CGFloat scale = 1.0;
+  BOOL packagerAsset = NO;
+  if ([json isKindOfClass:[NSDictionary class]]) {
+    if (!(request = [self NSURLRequest:json])) {
+      return nil;
+    }
+    size = [self CGSize:json];
+    scale = [self CGFloat:json[@"scale"]] ?: [self BOOL:json[@"deprecated"]] ? 0.0 : 1.0;
+    packagerAsset = [self BOOL:json[@"__packager_asset"]];
+  } else if ([json isKindOfClass:[NSString class]]) {
+    request = [self NSURLRequest:json];
+  } else {
+    RCTLogConvertError(json, @"an image. Did you forget to call resolveAssetSource() on the JS side?");
+    return nil;
+  }
+
+  RCTImageSource *imageSource = [[RCTImageSource alloc] initWithURLRequest:request
+                                                                      size:size
+                                                                     scale:scale];
+  imageSource.packagerAsset = packagerAsset;
+  return imageSource;
+}
+
+RCT_ARRAY_CONVERTER(RCTImageSource)
+
+@end

node_modules/react-native/React/Base/RCTInvalidating.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>
+
+@protocol RCTInvalidating <NSObject>
+
+- (void)invalidate;
+
+@end

node_modules/react-native/React/Base/RCTJSCErrorHandling.h

@@ -0,0 +1,31 @@
+/**
+ * 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 <JavaScriptCore/JavaScriptCore.h>
+
+#import <React/RCTDefines.h>
+
+/**
+ Translates a given exception into an NSError.
+
+ @param exception The JavaScript exception object to translate into an NSError. This must be
+ a JavaScript Error object, otherwise no stack trace information will be available.
+
+ @return The translated NSError object
+
+ - The JS exception's name property is incorporated in the NSError's localized description
+ - The JS exception's message property is the NSError's failure reason
+ - The JS exception's unsymbolicated stack trace is available via the NSError userInfo's RCTJSExceptionUnsymbolicatedStackTraceKey
+ */
+RCT_EXTERN NSError *RCTNSErrorFromJSError(JSValue *exception);
+
+/**
+ Translates a given exception into an NSError.
+
+ @see RCTNSErrorFromJSError for details
+ */
+RCT_EXTERN NSError *RCTNSErrorFromJSErrorRef(JSValueRef exceptionRef, JSGlobalContextRef ctx);

node_modules/react-native/React/Base/RCTJSCErrorHandling.mm

@@ -0,0 +1,41 @@
+/**
+ * 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.
+ */
+
+#include "RCTJSCErrorHandling.h"
+
+#import <jschelpers/JavaScriptCore.h>
+
+#import "RCTAssert.h"
+#import "RCTJSStackFrame.h"
+#import "RCTLog.h"
+
+NSString *const RCTJSExceptionUnsymbolicatedStackTraceKey = @"RCTJSExceptionUnsymbolicatedStackTraceKey";
+
+NSError *RCTNSErrorFromJSError(JSValue *exception)
+{
+  NSMutableDictionary *userInfo = [NSMutableDictionary dictionary];
+  userInfo[NSLocalizedDescriptionKey] = [NSString stringWithFormat:@"Unhandled JS Exception: %@", [exception[@"name"] toString] ?: @"Unknown"];
+  NSString *const exceptionMessage = [exception[@"message"] toString];
+  if ([exceptionMessage length]) {
+    userInfo[NSLocalizedFailureReasonErrorKey] = exceptionMessage;
+  }
+  NSString *const stack = [exception[@"stack"] toString];
+  if ([@"undefined" isEqualToString:stack]) {
+    RCTLogWarn(@"Couldn't get stack trace for %@:%@", exception[@"sourceURL"], exception[@"line"]);
+  } else if ([stack length]) {
+    NSArray<RCTJSStackFrame *> *const unsymbolicatedFrames = [RCTJSStackFrame stackFramesWithLines:stack];
+    userInfo[RCTJSStackTraceKey] = unsymbolicatedFrames;
+  }
+  return [NSError errorWithDomain:RCTErrorDomain code:1 userInfo:userInfo];
+}
+
+NSError *RCTNSErrorFromJSErrorRef(JSValueRef exceptionRef, JSGlobalContextRef ctx)
+{
+  JSContext *context = [JSC_JSContext(ctx) contextWithJSGlobalContextRef:ctx];
+  JSValue *exception = [JSC_JSValue(ctx) valueWithJSValueRef:exceptionRef inContext:context];
+  return RCTNSErrorFromJSError(exception);
+}

node_modules/react-native/React/Base/RCTJSStackFrame.h

@@ -0,0 +1,25 @@
+/**
+ * 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>
+
+@interface RCTJSStackFrame : NSObject
+
+@property (nonatomic, copy, readonly) NSString *methodName;
+@property (nonatomic, copy, readonly) NSString *file;
+@property (nonatomic, readonly) NSInteger lineNumber;
+@property (nonatomic, readonly) NSInteger column;
+
+- (instancetype)initWithMethodName:(NSString *)methodName file:(NSString *)file lineNumber:(NSInteger)lineNumber column:(NSInteger)column;
+- (NSDictionary *)toDictionary;
+
++ (instancetype)stackFrameWithLine:(NSString *)line;
++ (instancetype)stackFrameWithDictionary:(NSDictionary *)dict;
++ (NSArray<RCTJSStackFrame *> *)stackFramesWithLines:(NSString *)lines;
++ (NSArray<RCTJSStackFrame *> *)stackFramesWithDictionaries:(NSArray<NSDictionary *> *)dicts;
+
+@end

node_modules/react-native/React/Base/RCTJSStackFrame.m

@@ -0,0 +1,112 @@
+/**
+ * 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 "RCTJSStackFrame.h"
+
+#import "RCTLog.h"
+#import "RCTUtils.h"
+
+static NSRegularExpression *RCTJSStackFrameRegex()
+{
+  static dispatch_once_t onceToken;
+  static NSRegularExpression *_regex;
+  dispatch_once(&onceToken, ^{
+    NSError *regexError;
+    _regex = [NSRegularExpression regularExpressionWithPattern:@"^(?:([^@]+)@)?(.*):(\\d+):(\\d+)$" options:0 error:&regexError];
+    if (regexError) {
+      RCTLogError(@"Failed to build regex: %@", [regexError localizedDescription]);
+    }
+  });
+  return _regex;
+}
+
+@implementation RCTJSStackFrame
+
+- (instancetype)initWithMethodName:(NSString *)methodName file:(NSString *)file lineNumber:(NSInteger)lineNumber column:(NSInteger)column
+{
+  if (self = [super init]) {
+    _methodName = methodName;
+    _file = file;
+    _lineNumber = lineNumber;
+    _column = column;
+  }
+  return self;
+}
+
+- (NSDictionary *)toDictionary
+{
+  return @{
+     @"methodName": RCTNullIfNil(self.methodName),
+     @"file": RCTNullIfNil(self.file),
+     @"lineNumber": @(self.lineNumber),
+     @"column": @(self.column)
+  };
+}
+
++ (instancetype)stackFrameWithLine:(NSString *)line
+{
+  NSTextCheckingResult *match = [RCTJSStackFrameRegex() firstMatchInString:line options:0 range:NSMakeRange(0, line.length)];
+  if (!match) {
+    return nil;
+  }
+
+  // methodName may not be present for e.g. anonymous functions
+  const NSRange methodNameRange = [match rangeAtIndex:1];
+  NSString *methodName = methodNameRange.location == NSNotFound ? nil : [line substringWithRange:methodNameRange];
+  NSString *file = [line substringWithRange:[match rangeAtIndex:2]];
+  NSString *lineNumber = [line substringWithRange:[match rangeAtIndex:3]];
+  NSString *column = [line substringWithRange:[match rangeAtIndex:4]];
+
+  return [[self alloc] initWithMethodName:methodName
+                                     file:file
+                               lineNumber:[lineNumber integerValue]
+                                   column:[column integerValue]];
+}
+
++ (instancetype)stackFrameWithDictionary:(NSDictionary *)dict
+{
+  return [[self alloc] initWithMethodName:RCTNilIfNull(dict[@"methodName"])
+                                     file:dict[@"file"]
+                               lineNumber:[RCTNilIfNull(dict[@"lineNumber"]) integerValue]
+                                   column:[RCTNilIfNull(dict[@"column"]) integerValue]];
+}
+
++ (NSArray<RCTJSStackFrame *> *)stackFramesWithLines:(NSString *)lines
+{
+  NSMutableArray *stack = [NSMutableArray new];
+  for (NSString *line in [lines componentsSeparatedByString:@"\n"]) {
+    RCTJSStackFrame *frame = [self stackFrameWithLine:line];
+    if (frame) {
+      [stack addObject:frame];
+    }
+  }
+  return stack;
+}
+
++ (NSArray<RCTJSStackFrame *> *)stackFramesWithDictionaries:(NSArray<NSDictionary *> *)dicts
+{
+  NSMutableArray *stack = [NSMutableArray new];
+  for (NSDictionary *dict in dicts) {
+    RCTJSStackFrame *frame = [self stackFrameWithDictionary:dict];
+    if (frame) {
+      [stack addObject:frame];
+    }
+  }
+  return stack;
+}
+
+- (NSString *)description {
+  return [NSString stringWithFormat:@"<%@: %p method name: %@; file name: %@; line: %ld; column: %ld>",
+          self.class,
+          self,
+          self.methodName,
+          self.file,
+          (long)self.lineNumber,
+          (long)self.column];
+}
+
+@end

node_modules/react-native/React/Base/RCTJavaScriptExecutor.h

@@ -0,0 +1,84 @@
+/**
+ * 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 <objc/runtime.h>
+
+#import <JavaScriptCore/JavaScriptCore.h>
+
+#import <React/RCTBridgeModule.h>
+#import <React/RCTInvalidating.h>
+
+typedef void (^RCTJavaScriptCompleteBlock)(NSError *error);
+typedef void (^RCTJavaScriptCallback)(id result, NSError *error);
+
+/**
+ * Abstracts away a JavaScript execution context - we may be running code in a
+ * web view (for debugging purposes), or may be running code in a `JSContext`.
+ */
+@protocol RCTJavaScriptExecutor <RCTInvalidating, RCTBridgeModule>
+
+/**
+ * Used to set up the executor after the bridge has been fully initialized.
+ * Do any expensive setup in this method instead of `-init`.
+ */
+- (void)setUp;
+
+/**
+ * Whether the executor has been invalidated
+ */
+@property (nonatomic, readonly, getter=isValid) BOOL valid;
+
+/**
+ * Executes BatchedBridge.flushedQueue on JS thread and calls the given callback
+ * with JSValue, containing the next queue, and JSContext.
+ */
+- (void)flushedQueue:(RCTJavaScriptCallback)onComplete;
+
+/**
+ * Executes BatchedBridge.callFunctionReturnFlushedQueue with the module name,
+ * method name and optional additional arguments on the JS thread and calls the
+ * given callback with JSValue, containing the next queue, and JSContext.
+ */
+- (void)callFunctionOnModule:(NSString *)module
+                      method:(NSString *)method
+                   arguments:(NSArray *)args
+                    callback:(RCTJavaScriptCallback)onComplete;
+
+/**
+ * Executes BatchedBridge.invokeCallbackAndReturnFlushedQueue with the cbID,
+ * and optional additional arguments on the JS thread and calls the
+ * given callback with JSValue, containing the next queue, and JSContext.
+ */
+- (void)invokeCallbackID:(NSNumber *)cbID
+               arguments:(NSArray *)args
+                callback:(RCTJavaScriptCallback)onComplete;
+
+/**
+ * Runs an application script, and notifies of the script load being complete via `onComplete`.
+ */
+- (void)executeApplicationScript:(NSData *)script
+                       sourceURL:(NSURL *)sourceURL
+                      onComplete:(RCTJavaScriptCompleteBlock)onComplete;
+
+- (void)injectJSONText:(NSString *)script
+   asGlobalObjectNamed:(NSString *)objectName
+              callback:(RCTJavaScriptCompleteBlock)onComplete;
+
+/**
+ * Enqueue a block to run in the executors JS thread. Fallback to `dispatch_async`
+ * on the main queue if the executor doesn't own a thread.
+ */
+- (void)executeBlockOnJavaScriptQueue:(dispatch_block_t)block;
+
+/**
+ * Special case for Timers + ContextExecutor - instead of the default
+ *   if jsthread then call else dispatch call on jsthread
+ * ensure the call is made async on the jsthread
+ */
+- (void)executeAsyncBlockOnJavaScriptQueue:(dispatch_block_t)block;
+
+@end

node_modules/react-native/React/Base/RCTJavaScriptLoader.h

@@ -0,0 +1,92 @@
+/**
+ * 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/RCTDefines.h>
+
+extern NSString *const RCTJavaScriptLoaderErrorDomain;
+
+NS_ENUM(NSInteger) {
+  RCTJavaScriptLoaderErrorNoScriptURL = 1,
+  RCTJavaScriptLoaderErrorFailedOpeningFile = 2,
+  RCTJavaScriptLoaderErrorFailedReadingFile = 3,
+  RCTJavaScriptLoaderErrorFailedStatingFile = 3,
+  RCTJavaScriptLoaderErrorURLLoadFailed = 3,
+  RCTJavaScriptLoaderErrorBCVersion = 4,
+  RCTJavaScriptLoaderErrorBCNotSupported = 4,
+
+  RCTJavaScriptLoaderErrorCannotBeLoadedSynchronously = 1000,
+};
+
+NS_ENUM(NSInteger) {
+  RCTSourceFilesChangedCountNotBuiltByBundler = -2,
+  RCTSourceFilesChangedCountRebuiltFromScratch = -1,
+};
+
+@interface RCTLoadingProgress : NSObject
+
+@property (nonatomic, copy) NSString *status;
+@property (strong, nonatomic) NSNumber *done;
+@property (strong, nonatomic) NSNumber *total;
+
+@end
+
+@interface RCTSource : NSObject
+
+/**
+ * URL of the source object.
+ */
+@property (strong, nonatomic, readonly) NSURL *url;
+
+/**
+ * JS source (or simply the binary header in the case of a RAM bundle).
+ */
+@property (strong, nonatomic, readonly) NSData *data;
+
+/**
+ * Length of the entire JS bundle. Note that self.length != self.data.length in the case of certain bundle formats. For
+ * instance, when using RAM bundles:
+ *
+ *  - self.data will point to the bundle header
+ *  - self.data.length is the length of the bundle header, i.e. sizeof(facebook::react::BundleHeader)
+ *  - self.length is the length of the entire bundle file (header + contents)
+ */
+@property (nonatomic, readonly) NSUInteger length;
+
+/**
+ * Returns number of files changed when building this bundle:
+ *
+ *  - RCTSourceFilesChangedCountNotBuiltByBundler if the source wasn't built by the bundler (e.g. read from disk)
+ *  - RCTSourceFilesChangedCountRebuiltFromScratch if the source was rebuilt from scratch by the bundler
+ *  - Otherwise, the number of files changed when incrementally rebuilding the source
+ */
+@property (nonatomic, readonly) NSInteger filesChangedCount;
+
+@end
+
+typedef void (^RCTSourceLoadProgressBlock)(RCTLoadingProgress *progressData);
+typedef void (^RCTSourceLoadBlock)(NSError *error, RCTSource *source);
+
+@interface RCTJavaScriptLoader : NSObject
+
++ (void)loadBundleAtURL:(NSURL *)scriptURL onProgress:(RCTSourceLoadProgressBlock)onProgress onComplete:(RCTSourceLoadBlock)onComplete;
+
+/**
+ * @experimental
+ * Attempts to synchronously load the script at the given URL. The following two conditions must be met:
+ *   1. It must be a file URL.
+ *   2. It must not point to a text/javascript file.
+ * If the URL does not meet those conditions, this method will return nil and supply an error with the domain
+ * RCTJavaScriptLoaderErrorDomain and the code RCTJavaScriptLoaderErrorCannotBeLoadedSynchronously.
+ */
++ (NSData *)attemptSynchronousLoadOfBundleAtURL:(NSURL *)scriptURL
+                               runtimeBCVersion:(int32_t)runtimeBCVersion
+                                   sourceLength:(int64_t *)sourceLength
+                                          error:(NSError **)error;
+
+@end

node_modules/react-native/React/Base/RCTJavaScriptLoader.mm

@@ -0,0 +1,365 @@
+/**
+ * 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 "RCTJavaScriptLoader.h"
+
+#import <sys/stat.h>
+
+#import <cxxreact/JSBundleType.h>
+#import <jschelpers/JavaScriptCore.h>
+
+#import "RCTBridge.h"
+#import "RCTConvert.h"
+#import "RCTMultipartDataTask.h"
+#import "RCTPerformanceLogger.h"
+#import "RCTUtils.h"
+
+NSString *const RCTJavaScriptLoaderErrorDomain = @"RCTJavaScriptLoaderErrorDomain";
+
+@interface RCTSource()
+{
+@public
+  NSURL *_url;
+  NSData *_data;
+  NSUInteger _length;
+  NSInteger _filesChangedCount;
+}
+
+@end
+
+@implementation RCTSource
+
+static RCTSource *RCTSourceCreate(NSURL *url, NSData *data, int64_t length) NS_RETURNS_RETAINED
+{
+  RCTSource *source = [RCTSource new];
+  source->_url = url;
+  source->_data = data;
+  source->_length = length;
+  source->_filesChangedCount = RCTSourceFilesChangedCountNotBuiltByBundler;
+  return source;
+}
+
+@end
+
+@implementation RCTLoadingProgress
+
+- (NSString *)description
+{
+  NSMutableString *desc = [NSMutableString new];
+  [desc appendString:_status ?: @"Loading"];
+
+  if ([_total integerValue] > 0) {
+    [desc appendFormat:@" %ld%% (%@/%@)", (long)(100 * [_done integerValue] / [_total integerValue]), _done, _total];
+  }
+  [desc appendString:@"\u2026"];
+  return desc;
+}
+
+@end
+
+@implementation RCTJavaScriptLoader
+
+RCT_NOT_IMPLEMENTED(- (instancetype)init)
+
++ (void)loadBundleAtURL:(NSURL *)scriptURL onProgress:(RCTSourceLoadProgressBlock)onProgress onComplete:(RCTSourceLoadBlock)onComplete
+{
+  int64_t sourceLength;
+  NSError *error;
+  NSData *data = [self attemptSynchronousLoadOfBundleAtURL:scriptURL
+                                          runtimeBCVersion:JSNoBytecodeFileFormatVersion
+                                              sourceLength:&sourceLength
+                                                     error:&error];
+  if (data) {
+    onComplete(nil, RCTSourceCreate(scriptURL, data, sourceLength));
+    return;
+  }
+
+  const BOOL isCannotLoadSyncError =
+  [error.domain isEqualToString:RCTJavaScriptLoaderErrorDomain]
+  && error.code == RCTJavaScriptLoaderErrorCannotBeLoadedSynchronously;
+
+  if (isCannotLoadSyncError) {
+    attemptAsynchronousLoadOfBundleAtURL(scriptURL, onProgress, onComplete);
+  } else {
+    onComplete(error, nil);
+  }
+}
+
++ (NSData *)attemptSynchronousLoadOfBundleAtURL:(NSURL *)scriptURL
+                               runtimeBCVersion:(int32_t)runtimeBCVersion
+                                   sourceLength:(int64_t *)sourceLength
+                                          error:(NSError **)error
+{
+  NSString *unsanitizedScriptURLString = scriptURL.absoluteString;
+  // Sanitize the script URL
+  scriptURL = sanitizeURL(scriptURL);
+
+  if (!scriptURL) {
+    if (error) {
+      *error = [NSError errorWithDomain:RCTJavaScriptLoaderErrorDomain
+                                   code:RCTJavaScriptLoaderErrorNoScriptURL
+                               userInfo:@{NSLocalizedDescriptionKey:
+                                            [NSString stringWithFormat:@"No script URL provided. Make sure the packager is "
+                                             @"running or you have embedded a JS bundle in your application bundle.\n\n"
+                                             @"unsanitizedScriptURLString = %@", unsanitizedScriptURLString]}];
+    }
+    return nil;
+  }
+
+  // Load local script file
+  if (!scriptURL.fileURL) {
+    if (error) {
+      *error = [NSError errorWithDomain:RCTJavaScriptLoaderErrorDomain
+                                   code:RCTJavaScriptLoaderErrorCannotBeLoadedSynchronously
+                               userInfo:@{NSLocalizedDescriptionKey:
+                                            [NSString stringWithFormat:@"Cannot load %@ URLs synchronously",
+                                             scriptURL.scheme]}];
+    }
+    return nil;
+  }
+
+  // Load the first 4 bytes to check if the bundle is regular or RAM ("Random Access Modules" bundle).
+  // The RAM bundle has a magic number in the 4 first bytes `(0xFB0BD1E5)`.
+  // The benefit of RAM bundle over a regular bundle is that we can lazily inject
+  // modules into JSC as they're required.
+  FILE *bundle = fopen(scriptURL.path.UTF8String, "r");
+  if (!bundle) {
+    if (error) {
+      *error = [NSError errorWithDomain:RCTJavaScriptLoaderErrorDomain
+                                   code:RCTJavaScriptLoaderErrorFailedOpeningFile
+                               userInfo:@{NSLocalizedDescriptionKey:
+                                            [NSString stringWithFormat:@"Error opening bundle %@", scriptURL.path]}];
+    }
+    return nil;
+  }
+
+  facebook::react::BundleHeader header;
+  size_t readResult = fread(&header, sizeof(header), 1, bundle);
+  fclose(bundle);
+  if (readResult != 1) {
+    if (error) {
+      *error = [NSError errorWithDomain:RCTJavaScriptLoaderErrorDomain
+                                   code:RCTJavaScriptLoaderErrorFailedReadingFile
+                               userInfo:@{NSLocalizedDescriptionKey:
+                                            [NSString stringWithFormat:@"Error reading bundle %@", scriptURL.path]}];
+    }
+    return nil;
+  }
+
+  facebook::react::ScriptTag tag = facebook::react::parseTypeFromHeader(header);
+  switch (tag) {
+  case facebook::react::ScriptTag::RAMBundle:
+    break;
+
+  case facebook::react::ScriptTag::String: {
+#if RCT_ENABLE_INSPECTOR
+    NSData *source = [NSData dataWithContentsOfFile:scriptURL.path
+                                            options:NSDataReadingMappedIfSafe
+                                              error:error];
+    if (sourceLength && source != nil) {
+      *sourceLength = source.length;
+    }
+    return source;
+#else
+    if (error) {
+      *error = [NSError errorWithDomain:RCTJavaScriptLoaderErrorDomain
+                                   code:RCTJavaScriptLoaderErrorCannotBeLoadedSynchronously
+                               userInfo:@{NSLocalizedDescriptionKey:
+                                            @"Cannot load text/javascript files synchronously"}];
+    }
+    return nil;
+#endif
+  }
+  case facebook::react::ScriptTag::BCBundle:
+    if (runtimeBCVersion == JSNoBytecodeFileFormatVersion || runtimeBCVersion < 0) {
+      if (error) {
+        *error = [NSError errorWithDomain:RCTJavaScriptLoaderErrorDomain
+                                     code:RCTJavaScriptLoaderErrorBCNotSupported
+                                 userInfo:@{NSLocalizedDescriptionKey:
+                                              @"Bytecode bundles are not supported by this runtime."}];
+      }
+      return nil;
+    }
+    else if ((uint32_t)runtimeBCVersion != header.version) {
+      if (error) {
+        NSString *errDesc =
+          [NSString stringWithFormat:@"BC Version Mismatch. Expect: %d, Actual: %u",
+                    runtimeBCVersion, header.version];
+
+        *error = [NSError errorWithDomain:RCTJavaScriptLoaderErrorDomain
+                                     code:RCTJavaScriptLoaderErrorBCVersion
+                                 userInfo:@{NSLocalizedDescriptionKey: errDesc}];
+      }
+      return nil;
+    }
+    break;
+  }
+
+  struct stat statInfo;
+  if (stat(scriptURL.path.UTF8String, &statInfo) != 0) {
+    if (error) {
+      *error = [NSError errorWithDomain:RCTJavaScriptLoaderErrorDomain
+                                   code:RCTJavaScriptLoaderErrorFailedStatingFile
+                               userInfo:@{NSLocalizedDescriptionKey:
+                                            [NSString stringWithFormat:@"Error stating bundle %@", scriptURL.path]}];
+    }
+    return nil;
+  }
+  if (sourceLength) {
+    *sourceLength = statInfo.st_size;
+  }
+  return [NSData dataWithBytes:&header length:sizeof(header)];
+}
+
+static void parseHeaders(NSDictionary *headers, RCTSource *source) {
+  source->_filesChangedCount = [headers[@"X-Metro-Files-Changed-Count"] integerValue];
+}
+
+static void attemptAsynchronousLoadOfBundleAtURL(NSURL *scriptURL, RCTSourceLoadProgressBlock onProgress, RCTSourceLoadBlock onComplete)
+{
+  scriptURL = sanitizeURL(scriptURL);
+
+  if (scriptURL.fileURL) {
+    // Reading in a large bundle can be slow. Dispatch to the background queue to do it.
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+      NSError *error = nil;
+      NSData *source = [NSData dataWithContentsOfFile:scriptURL.path
+                                              options:NSDataReadingMappedIfSafe
+                                                error:&error];
+      onComplete(error, RCTSourceCreate(scriptURL, source, source.length));
+    });
+    return;
+  }
+
+  RCTMultipartDataTask *task = [[RCTMultipartDataTask alloc] initWithURL:scriptURL partHandler:^(NSInteger statusCode, NSDictionary *headers, NSData *data, NSError *error, BOOL done) {
+    if (!done) {
+      if (onProgress) {
+        onProgress(progressEventFromData(data));
+      }
+      return;
+    }
+
+    // Handle general request errors
+    if (error) {
+      if ([error.domain isEqualToString:NSURLErrorDomain]) {
+        error = [NSError errorWithDomain:RCTJavaScriptLoaderErrorDomain
+                                    code:RCTJavaScriptLoaderErrorURLLoadFailed
+                                userInfo:
+                 @{
+                   NSLocalizedDescriptionKey:
+                     [@"Could not connect to development server.\n\n"
+                      "Ensure the following:\n"
+                      "- Node server is running and available on the same network - run 'npm start' from react-native root\n"
+                      "- Node server URL is correctly set in AppDelegate\n"
+                      "- WiFi is enabled and connected to the same network as the Node Server\n\n"
+                      "URL: " stringByAppendingString:scriptURL.absoluteString],
+                   NSLocalizedFailureReasonErrorKey: error.localizedDescription,
+                   NSUnderlyingErrorKey: error,
+                   }];
+      }
+      onComplete(error, nil);
+      return;
+    }
+
+    // For multipart responses packager sets X-Http-Status header in case HTTP status code
+    // is different from 200 OK
+    NSString *statusCodeHeader = headers[@"X-Http-Status"];
+    if (statusCodeHeader) {
+      statusCode = [statusCodeHeader integerValue];
+    }
+
+    if (statusCode != 200) {
+      error = [NSError errorWithDomain:@"JSServer"
+                                  code:statusCode
+                              userInfo:userInfoForRawResponse([[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding])];
+      onComplete(error, nil);
+      return;
+    }
+
+    // Validate that the packager actually returned javascript.
+    NSString *contentType = headers[@"Content-Type"];
+    NSString *mimeType = [[contentType componentsSeparatedByString:@";"] firstObject];
+    if (![mimeType isEqualToString:@"application/javascript"] &&
+        ![mimeType isEqualToString:@"text/javascript"]) {
+      NSString *description = [NSString stringWithFormat:@"Expected MIME-Type to be 'application/javascript' or 'text/javascript', but got '%@'.", mimeType];
+      error = [NSError errorWithDomain:@"JSServer"
+                                  code:NSURLErrorCannotParseResponse
+                              userInfo:@{
+                                         NSLocalizedDescriptionKey: description,
+                                         @"headers": headers,
+                                         @"data": data
+                                       }];
+      onComplete(error, nil);
+      return;
+    }
+
+    RCTSource *source = RCTSourceCreate(scriptURL, data, data.length);
+    parseHeaders(headers, source);
+    onComplete(nil, source);
+  } progressHandler:^(NSDictionary *headers, NSNumber *loaded, NSNumber *total) {
+    // Only care about download progress events for the javascript bundle part.
+    if ([headers[@"Content-Type"] isEqualToString:@"application/javascript"]) {
+      onProgress(progressEventFromDownloadProgress(loaded, total));
+    }
+  }];
+
+  [task startTask];
+}
+
+static NSURL *sanitizeURL(NSURL *url)
+{
+  // Why we do this is lost to time. We probably shouldn't; passing a valid URL is the caller's responsibility not ours.
+  return [RCTConvert NSURL:url.absoluteString];
+}
+
+static RCTLoadingProgress *progressEventFromData(NSData *rawData)
+{
+  NSString *text = [[NSString alloc] initWithData:rawData encoding:NSUTF8StringEncoding];
+  id info = RCTJSONParse(text, nil);
+  if (!info || ![info isKindOfClass:[NSDictionary class]]) {
+    return nil;
+  }
+
+  RCTLoadingProgress *progress = [RCTLoadingProgress new];
+  progress.status = info[@"status"];
+  progress.done = info[@"done"];
+  progress.total = info[@"total"];
+  return progress;
+}
+
+static RCTLoadingProgress *progressEventFromDownloadProgress(NSNumber *total, NSNumber *done)
+{
+  RCTLoadingProgress *progress = [RCTLoadingProgress new];
+  progress.status = @"Downloading JavaScript bundle";
+  // Progress values are in bytes transform them to kilobytes for smaller numbers.
+  progress.done = done != nil ? @([done integerValue] / 1024) : nil;
+  progress.total = total != nil ? @([total integerValue] / 1024) : nil;
+  return progress;
+}
+
+static NSDictionary *userInfoForRawResponse(NSString *rawText)
+{
+  NSDictionary *parsedResponse = RCTJSONParse(rawText, nil);
+  if (![parsedResponse isKindOfClass:[NSDictionary class]]) {
+    return @{NSLocalizedDescriptionKey: rawText};
+  }
+  NSArray *errors = parsedResponse[@"errors"];
+  if (![errors isKindOfClass:[NSArray class]]) {
+    return @{NSLocalizedDescriptionKey: rawText};
+  }
+  NSMutableArray<NSDictionary *> *fakeStack = [NSMutableArray new];
+  for (NSDictionary *err in errors) {
+    [fakeStack addObject: @{
+       @"methodName": err[@"description"] ?: @"",
+       @"file": err[@"filename"] ?: @"",
+       @"lineNumber": err[@"lineNumber"] ?: @0
+    }];
+  }
+  return @{NSLocalizedDescriptionKey: parsedResponse[@"message"] ?: @"No message provided", @"stack": [fakeStack copy]};
+}
+
+@end

node_modules/react-native/React/Base/RCTKeyCommands.h

@@ -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 <UIKit/UIKit.h>
+
+@interface RCTKeyCommands : NSObject
+
++ (instancetype)sharedInstance;
+
+/**
+ * Register a single-press keyboard command.
+ */
+- (void)registerKeyCommandWithInput:(NSString *)input
+                      modifierFlags:(UIKeyModifierFlags)flags
+                             action:(void (^)(UIKeyCommand *command))block;
+
+/**
+ * Unregister a single-press keyboard command.
+ */
+- (void)unregisterKeyCommandWithInput:(NSString *)input
+                        modifierFlags:(UIKeyModifierFlags)flags;
+
+/**
+ * Check if a single-press command is registered.
+ */
+- (BOOL)isKeyCommandRegisteredForInput:(NSString *)input
+                         modifierFlags:(UIKeyModifierFlags)flags;
+
+/**
+ * Register a double-press keyboard command.
+ */
+- (void)registerDoublePressKeyCommandWithInput:(NSString *)input
+                      modifierFlags:(UIKeyModifierFlags)flags
+                             action:(void (^)(UIKeyCommand *command))block;
+
+/**
+ * Unregister a double-press keyboard command.
+ */
+- (void)unregisterDoublePressKeyCommandWithInput:(NSString *)input
+                        modifierFlags:(UIKeyModifierFlags)flags;
+
+/**
+ * Check if a double-press command is registered.
+ */
+- (BOOL)isDoublePressKeyCommandRegisteredForInput:(NSString *)input
+                         modifierFlags:(UIKeyModifierFlags)flags;
+
+@end

node_modules/react-native/React/Base/RCTKeyCommands.m

@@ -0,0 +1,394 @@
+/**
+ * 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 "RCTKeyCommands.h"
+
+#import <UIKit/UIKit.h>
+
+#import "RCTDefines.h"
+#import "RCTUtils.h"
+
+#if RCT_DEV
+
+static BOOL RCTIsIOS8OrEarlier()
+{
+  return [UIDevice currentDevice].systemVersion.floatValue < 9;
+}
+
+@interface RCTKeyCommand : NSObject <NSCopying>
+
+@property (nonatomic, strong) UIKeyCommand *keyCommand;
+@property (nonatomic, copy) void (^block)(UIKeyCommand *);
+
+@end
+
+@implementation RCTKeyCommand
+
+- (instancetype)initWithKeyCommand:(UIKeyCommand *)keyCommand
+                             block:(void (^)(UIKeyCommand *))block
+{
+  if ((self = [super init])) {
+    _keyCommand = keyCommand;
+    _block = block;
+  }
+  return self;
+}
+
+RCT_NOT_IMPLEMENTED(- (instancetype)init)
+
+- (id)copyWithZone:(__unused NSZone *)zone
+{
+  return self;
+}
+
+- (NSUInteger)hash
+{
+  return _keyCommand.input.hash ^ _keyCommand.modifierFlags;
+}
+
+- (BOOL)isEqual:(RCTKeyCommand *)object
+{
+  if (![object isKindOfClass:[RCTKeyCommand class]]) {
+    return NO;
+  }
+  return [self matchesInput:object.keyCommand.input
+                      flags:object.keyCommand.modifierFlags];
+}
+
+- (BOOL)matchesInput:(NSString *)input flags:(UIKeyModifierFlags)flags
+{
+  return [_keyCommand.input isEqual:input] && _keyCommand.modifierFlags == flags;
+}
+
+- (NSString *)description
+{
+  return [NSString stringWithFormat:@"<%@:%p input=\"%@\" flags=%lld hasBlock=%@>",
+          [self class], self, _keyCommand.input, (long long)_keyCommand.modifierFlags,
+          _block ? @"YES" : @"NO"];
+}
+
+@end
+
+@interface RCTKeyCommands ()
+
+@property (nonatomic, strong) NSMutableSet<RCTKeyCommand *> *commands;
+
+@end
+
+@implementation UIResponder (RCTKeyCommands)
+
++ (UIResponder *)RCT_getFirstResponder:(UIResponder *)view
+{
+  UIResponder *firstResponder = nil;
+
+  if (view.isFirstResponder) {
+    return view;
+  } else if ([view isKindOfClass:[UIViewController class]]) {
+    if ([(UIViewController *)view parentViewController]) {
+      firstResponder = [UIResponder RCT_getFirstResponder: [(UIViewController *)view parentViewController]];
+    }
+    return firstResponder ? firstResponder : [UIResponder RCT_getFirstResponder: [(UIViewController *)view view]];
+  } else if ([view isKindOfClass:[UIView class]]) {
+    for (UIView *subview in [(UIView *)view subviews]) {
+      firstResponder = [UIResponder RCT_getFirstResponder: subview];
+      if (firstResponder) {
+        return firstResponder;
+      }
+    }
+  }
+
+  return firstResponder;
+}
+
+- (NSArray<UIKeyCommand *> *)RCT_keyCommands
+{
+  NSSet<RCTKeyCommand *> *commands = [RCTKeyCommands sharedInstance].commands;
+  return [[commands valueForKeyPath:@"keyCommand"] allObjects];
+}
+
+/**
+ * Single Press Key Command Response
+ * Command + KeyEvent (Command + R/D, etc.)
+ */
+- (void)RCT_handleKeyCommand:(UIKeyCommand *)key
+{
+  // NOTE: throttle the key handler because on iOS 9 the handleKeyCommand:
+  // method gets called repeatedly if the command key is held down.
+  static NSTimeInterval lastCommand = 0;
+  if (RCTIsIOS8OrEarlier() || CACurrentMediaTime() - lastCommand > 0.5) {
+    for (RCTKeyCommand *command in [RCTKeyCommands sharedInstance].commands) {
+      if ([command.keyCommand.input isEqualToString:key.input] &&
+          command.keyCommand.modifierFlags == key.modifierFlags) {
+        if (command.block) {
+          command.block(key);
+          lastCommand = CACurrentMediaTime();
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Double Press Key Command Response
+ * Double KeyEvent (Double R, etc.)
+ */
+- (void)RCT_handleDoublePressKeyCommand:(UIKeyCommand *)key
+{
+  static BOOL firstPress = YES;
+  static NSTimeInterval lastCommand = 0;
+  static NSTimeInterval lastDoubleCommand = 0;
+  static NSString *lastInput = nil;
+  static UIKeyModifierFlags lastModifierFlags = 0;
+
+  if (firstPress) {
+    for (RCTKeyCommand *command in [RCTKeyCommands sharedInstance].commands) {
+      if ([command.keyCommand.input isEqualToString:key.input] &&
+          command.keyCommand.modifierFlags == key.modifierFlags &&
+          command.block) {
+
+        firstPress = NO;
+        lastCommand = CACurrentMediaTime();
+        lastInput = key.input;
+        lastModifierFlags = key.modifierFlags;
+        return;
+      }
+    }
+  } else {
+    // Second keyevent within 0.2 second,
+    // with the same key as the first one.
+    if (CACurrentMediaTime() - lastCommand < 0.2 &&
+        lastInput == key.input &&
+        lastModifierFlags == key.modifierFlags) {
+
+      for (RCTKeyCommand *command in [RCTKeyCommands sharedInstance].commands) {
+        if ([command.keyCommand.input isEqualToString:key.input] &&
+            command.keyCommand.modifierFlags == key.modifierFlags &&
+            command.block) {
+
+          // NOTE: throttle the key handler because on iOS 9 the handleKeyCommand:
+          // method gets called repeatedly if the command key is held down.
+          if (RCTIsIOS8OrEarlier() || CACurrentMediaTime() - lastDoubleCommand > 0.5) {
+            command.block(key);
+            lastDoubleCommand = CACurrentMediaTime();
+          }
+          firstPress = YES;
+          return;
+        }
+      }
+    }
+
+    lastCommand = CACurrentMediaTime();
+    lastInput = key.input;
+    lastModifierFlags = key.modifierFlags;
+  }
+}
+
+@end
+
+@implementation UIApplication (RCTKeyCommands)
+
+// Required for iOS 8.x
+- (BOOL)RCT_sendAction:(SEL)action to:(id)target from:(id)sender forEvent:(UIEvent *)event
+{
+  if (action == @selector(RCT_handleKeyCommand:)) {
+    [self RCT_handleKeyCommand:sender];
+    return YES;
+  } else if (action == @selector(RCT_handleDoublePressKeyCommand:)) {
+    [self RCT_handleDoublePressKeyCommand:sender];
+    return YES;
+  }
+  return [self RCT_sendAction:action to:target from:sender forEvent:event];
+}
+
+@end
+
+@implementation RCTKeyCommands
+
++ (void)initialize
+{
+  if (RCTIsIOS8OrEarlier()) {
+
+    // swizzle UIApplication
+    RCTSwapInstanceMethods([UIApplication class],
+                           @selector(keyCommands),
+                           @selector(RCT_keyCommands));
+
+    RCTSwapInstanceMethods([UIApplication class],
+                           @selector(sendAction:to:from:forEvent:),
+                           @selector(RCT_sendAction:to:from:forEvent:));
+  } else {
+
+    // swizzle UIResponder
+    RCTSwapInstanceMethods([UIResponder class],
+                           @selector(keyCommands),
+                           @selector(RCT_keyCommands));
+  }
+}
+
++ (instancetype)sharedInstance
+{
+  static RCTKeyCommands *sharedInstance;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    sharedInstance = [self new];
+  });
+
+  return sharedInstance;
+}
+
+- (instancetype)init
+{
+  if ((self = [super init])) {
+    _commands = [NSMutableSet new];
+  }
+  return self;
+}
+
+- (void)registerKeyCommandWithInput:(NSString *)input
+                      modifierFlags:(UIKeyModifierFlags)flags
+                             action:(void (^)(UIKeyCommand *))block
+{
+  RCTAssertMainQueue();
+
+  if (input.length && flags && RCTIsIOS8OrEarlier()) {
+
+    // Workaround around the first cmd not working: http://openradar.appspot.com/19613391
+    // You can register just the cmd key and do nothing. This ensures that
+    // command-key modified commands will work first time. Fixed in iOS 9.
+
+    [self registerKeyCommandWithInput:@""
+                        modifierFlags:flags
+                               action:nil];
+  }
+
+  UIKeyCommand *command = [UIKeyCommand keyCommandWithInput:input
+                                              modifierFlags:flags
+                                                     action:@selector(RCT_handleKeyCommand:)];
+
+  RCTKeyCommand *keyCommand = [[RCTKeyCommand alloc] initWithKeyCommand:command block:block];
+  [_commands removeObject:keyCommand];
+  [_commands addObject:keyCommand];
+}
+
+- (void)unregisterKeyCommandWithInput:(NSString *)input
+                        modifierFlags:(UIKeyModifierFlags)flags
+{
+  RCTAssertMainQueue();
+
+  for (RCTKeyCommand *command in _commands.allObjects) {
+    if ([command matchesInput:input flags:flags]) {
+      [_commands removeObject:command];
+      break;
+    }
+  }
+}
+
+- (BOOL)isKeyCommandRegisteredForInput:(NSString *)input
+                         modifierFlags:(UIKeyModifierFlags)flags
+{
+  RCTAssertMainQueue();
+
+  for (RCTKeyCommand *command in _commands) {
+    if ([command matchesInput:input flags:flags]) {
+      return YES;
+    }
+  }
+  return NO;
+}
+
+- (void)registerDoublePressKeyCommandWithInput:(NSString *)input
+                      modifierFlags:(UIKeyModifierFlags)flags
+                             action:(void (^)(UIKeyCommand *))block
+{
+  RCTAssertMainQueue();
+
+  if (input.length && flags && RCTIsIOS8OrEarlier()) {
+
+    // Workaround around the first cmd not working: http://openradar.appspot.com/19613391
+    // You can register just the cmd key and do nothing. This ensures that
+    // command-key modified commands will work first time. Fixed in iOS 9.
+
+    [self registerDoublePressKeyCommandWithInput:@""
+                        modifierFlags:flags
+                               action:nil];
+  }
+
+  UIKeyCommand *command = [UIKeyCommand keyCommandWithInput:input
+                                              modifierFlags:flags
+                                                     action:@selector(RCT_handleDoublePressKeyCommand:)];
+
+  RCTKeyCommand *keyCommand = [[RCTKeyCommand alloc] initWithKeyCommand:command block:block];
+  [_commands removeObject:keyCommand];
+  [_commands addObject:keyCommand];
+}
+
+- (void)unregisterDoublePressKeyCommandWithInput:(NSString *)input
+                        modifierFlags:(UIKeyModifierFlags)flags
+{
+  RCTAssertMainQueue();
+
+  for (RCTKeyCommand *command in _commands.allObjects) {
+    if ([command matchesInput:input flags:flags]) {
+      [_commands removeObject:command];
+      break;
+    }
+  }
+}
+
+- (BOOL)isDoublePressKeyCommandRegisteredForInput:(NSString *)input
+                         modifierFlags:(UIKeyModifierFlags)flags
+{
+  RCTAssertMainQueue();
+
+  for (RCTKeyCommand *command in _commands) {
+    if ([command matchesInput:input flags:flags]) {
+      return YES;
+    }
+  }
+  return NO;
+}
+
+@end
+
+#else
+
+@implementation RCTKeyCommands
+
++ (instancetype)sharedInstance
+{
+  return nil;
+}
+
+- (void)registerKeyCommandWithInput:(NSString *)input
+                      modifierFlags:(UIKeyModifierFlags)flags
+                             action:(void (^)(UIKeyCommand *))block {}
+
+- (void)unregisterKeyCommandWithInput:(NSString *)input
+                        modifierFlags:(UIKeyModifierFlags)flags {}
+
+- (BOOL)isKeyCommandRegisteredForInput:(NSString *)input
+                         modifierFlags:(UIKeyModifierFlags)flags
+{
+  return NO;
+}
+
+- (void)registerDoublePressKeyCommandWithInput:(NSString *)input
+                      modifierFlags:(UIKeyModifierFlags)flags
+                             action:(void (^)(UIKeyCommand *))block {}
+
+- (void)unregisterDoublePressKeyCommandWithInput:(NSString *)input
+                        modifierFlags:(UIKeyModifierFlags)flags {}
+
+- (BOOL)isDoublePressKeyCommandRegisteredForInput:(NSString *)input
+                         modifierFlags:(UIKeyModifierFlags)flags
+{
+  return NO;
+}
+
+@end
+
+#endif

node_modules/react-native/React/Base/RCTLog.h

@@ -0,0 +1,133 @@
+/**
+ * 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>
+#import <React/RCTUtils.h>
+
+#ifndef RCTLOG_ENABLED
+#define RCTLOG_ENABLED 1
+#endif
+
+/**
+ * Thresholds for logs to display a redbox. You can override these values when debugging
+ * in order to tweak the default logging behavior.
+ */
+#ifndef RCTLOG_REDBOX_LEVEL
+#define RCTLOG_REDBOX_LEVEL RCTLogLevelError
+#endif
+
+/**
+ * Logging macros. Use these to log information, warnings and errors in your
+ * own code.
+ */
+#define RCTLog(...) _RCTLog(RCTLogLevelInfo, __VA_ARGS__)
+#define RCTLogTrace(...) _RCTLog(RCTLogLevelTrace, __VA_ARGS__)
+#define RCTLogInfo(...) _RCTLog(RCTLogLevelInfo, __VA_ARGS__)
+#define RCTLogAdvice(string, ...) RCTLogWarn([@"(ADVICE) " stringByAppendingString:(NSString *)string], __VA_ARGS__)
+#define RCTLogWarn(...) _RCTLog(RCTLogLevelWarning, __VA_ARGS__)
+#define RCTLogError(...) _RCTLog(RCTLogLevelError, __VA_ARGS__)
+
+/**
+ * An enum representing the severity of the log message.
+ */
+typedef NS_ENUM(NSInteger, RCTLogLevel) {
+  RCTLogLevelTrace = 0,
+  RCTLogLevelInfo = 1,
+  RCTLogLevelWarning = 2,
+  RCTLogLevelError = 3,
+  RCTLogLevelFatal = 4
+};
+
+/**
+ * An enum representing the source of a log message.
+ */
+typedef NS_ENUM(NSInteger, RCTLogSource) {
+  RCTLogSourceNative = 1,
+  RCTLogSourceJavaScript = 2
+};
+
+/**
+ * A block signature to be used for custom logging functions. In most cases you
+ * will want to pass these arguments to the RCTFormatLog function in order to
+ * generate a string.
+ */
+typedef void (^RCTLogFunction)(
+  RCTLogLevel level,
+  RCTLogSource source,
+  NSString *fileName,
+  NSNumber *lineNumber,
+  NSString *message
+);
+
+/**
+ * A method to generate a string from a collection of log data. To omit any
+ * particular data from the log, just pass nil or zero for the argument.
+ */
+RCT_EXTERN NSString *RCTFormatLog(
+  NSDate *timestamp,
+  RCTLogLevel level,
+  NSString *fileName,
+  NSNumber *lineNumber,
+  NSString *message
+);
+
+/**
+ * The default logging function used by RCTLogXX.
+ */
+extern RCTLogFunction RCTDefaultLogFunction;
+
+/**
+ * These methods get and set the global logging threshold. This is the level
+ * below which logs will be ignored. Default is RCTLogLevelInfo for debug and
+ * RCTLogLevelError for production.
+ */
+RCT_EXTERN void RCTSetLogThreshold(RCTLogLevel threshold);
+RCT_EXTERN RCTLogLevel RCTGetLogThreshold(void);
+
+/**
+ * These methods get and set the global logging function called by the RCTLogXX
+ * macros. You can use these to replace the standard behavior with custom log
+ * functionality.
+ */
+RCT_EXTERN void RCTSetLogFunction(RCTLogFunction logFunction);
+RCT_EXTERN RCTLogFunction RCTGetLogFunction(void);
+
+/**
+ * This appends additional code to the existing log function, without replacing
+ * the existing functionality. Useful if you just want to forward logs to an
+ * extra service without changing the default behavior.
+ */
+RCT_EXTERN void RCTAddLogFunction(RCTLogFunction logFunction);
+
+/**
+ * This method temporarily overrides the log function while performing the
+ * specified block. This is useful for testing purposes (to detect if a given
+ * function logs something) or to suppress or override logging temporarily.
+ */
+RCT_EXTERN void RCTPerformBlockWithLogFunction(void (^block)(void), RCTLogFunction logFunction);
+
+/**
+ * This method adds a conditional prefix to any messages logged within the scope
+ * of the passed block. This is useful for adding additional context to log
+ * messages. The block will be performed synchronously on the current thread.
+ */
+RCT_EXTERN void RCTPerformBlockWithLogPrefix(void (^block)(void), NSString *prefix);
+
+/**
+ * Private logging function - ignore this.
+ */
+#if RCTLOG_ENABLED
+#define _RCTLog(lvl, ...) _RCTLogNativeInternal(lvl, __FILE__, __LINE__, __VA_ARGS__)
+#else
+#define _RCTLog(lvl, ...) do { } while (0)
+#endif
+
+RCT_EXTERN void _RCTLogNativeInternal(RCTLogLevel, const char *, int, NSString *, ...) NS_FORMAT_FUNCTION(4,5);
+RCT_EXTERN void _RCTLogJavaScriptInternal(RCTLogLevel, NSString *);

node_modules/react-native/React/Base/RCTLog.mm

@@ -0,0 +1,276 @@
+/**
+ * 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 "RCTLog.h"
+
+#include <asl.h>
+#include <cxxabi.h>
+
+#import "RCTAssert.h"
+#import "RCTBridge+Private.h"
+#import "RCTBridge.h"
+#import "RCTDefines.h"
+#import "RCTRedBox.h"
+#import "RCTUtils.h"
+
+static NSString *const RCTLogFunctionStack = @"RCTLogFunctionStack";
+
+const char *RCTLogLevels[] = {
+  "trace",
+  "info",
+  "warn",
+  "error",
+  "fatal",
+};
+
+#if RCT_DEBUG
+static const RCTLogLevel RCTDefaultLogThreshold = (RCTLogLevel)(RCTLogLevelInfo - 1);
+#else
+static const RCTLogLevel RCTDefaultLogThreshold = RCTLogLevelError;
+#endif
+
+static RCTLogFunction RCTCurrentLogFunction;
+static RCTLogLevel RCTCurrentLogThreshold = RCTDefaultLogThreshold;
+
+RCTLogLevel RCTGetLogThreshold()
+{
+  return RCTCurrentLogThreshold;
+}
+
+void RCTSetLogThreshold(RCTLogLevel threshold) {
+  RCTCurrentLogThreshold = threshold;
+}
+
+RCTLogFunction RCTDefaultLogFunction = ^(
+  RCTLogLevel level,
+  __unused RCTLogSource source,
+  NSString *fileName,
+  NSNumber *lineNumber,
+  NSString *message
+)
+{
+  NSString *log = RCTFormatLog([NSDate date], level, fileName, lineNumber, message);
+  fprintf(stderr, "%s\n", log.UTF8String);
+  fflush(stderr);
+
+  int aslLevel;
+  switch(level) {
+    case RCTLogLevelTrace:
+      aslLevel = ASL_LEVEL_DEBUG;
+      break;
+    case RCTLogLevelInfo:
+      aslLevel = ASL_LEVEL_NOTICE;
+      break;
+    case RCTLogLevelWarning:
+      aslLevel = ASL_LEVEL_WARNING;
+      break;
+    case RCTLogLevelError:
+      aslLevel = ASL_LEVEL_ERR;
+      break;
+    case RCTLogLevelFatal:
+      aslLevel = ASL_LEVEL_CRIT;
+      break;
+  }
+  asl_log(NULL, NULL, aslLevel, "%s", message.UTF8String);
+};
+
+void RCTSetLogFunction(RCTLogFunction logFunction)
+{
+  RCTCurrentLogFunction = logFunction;
+}
+
+RCTLogFunction RCTGetLogFunction()
+{
+  if (!RCTCurrentLogFunction) {
+    RCTCurrentLogFunction = RCTDefaultLogFunction;
+  }
+  return RCTCurrentLogFunction;
+}
+
+void RCTAddLogFunction(RCTLogFunction logFunction)
+{
+  RCTLogFunction existing = RCTGetLogFunction();
+  if (existing) {
+    RCTSetLogFunction(^(RCTLogLevel level, RCTLogSource source, NSString *fileName, NSNumber *lineNumber, NSString *message) {
+      existing(level, source, fileName, lineNumber, message);
+      logFunction(level, source, fileName, lineNumber, message);
+    });
+  } else {
+    RCTSetLogFunction(logFunction);
+  }
+}
+
+/**
+ * returns the topmost stacked log function for the current thread, which
+ * may not be the same as the current value of RCTCurrentLogFunction.
+ */
+static RCTLogFunction RCTGetLocalLogFunction()
+{
+  NSMutableDictionary *threadDictionary = [NSThread currentThread].threadDictionary;
+  NSArray<RCTLogFunction> *functionStack = threadDictionary[RCTLogFunctionStack];
+  RCTLogFunction logFunction = functionStack.lastObject;
+  if (logFunction) {
+    return logFunction;
+  }
+  return RCTGetLogFunction();
+}
+
+void RCTPerformBlockWithLogFunction(void (^block)(void), RCTLogFunction logFunction)
+{
+  NSMutableDictionary *threadDictionary = [NSThread currentThread].threadDictionary;
+  NSMutableArray<RCTLogFunction> *functionStack = threadDictionary[RCTLogFunctionStack];
+  if (!functionStack) {
+    functionStack = [NSMutableArray new];
+    threadDictionary[RCTLogFunctionStack] = functionStack;
+  }
+  [functionStack addObject:logFunction];
+  block();
+  [functionStack removeLastObject];
+}
+
+void RCTPerformBlockWithLogPrefix(void (^block)(void), NSString *prefix)
+{
+  RCTLogFunction logFunction = RCTGetLocalLogFunction();
+  if (logFunction) {
+    RCTPerformBlockWithLogFunction(block, ^(RCTLogLevel level, RCTLogSource source,
+                                            NSString *fileName, NSNumber *lineNumber,
+                                            NSString *message) {
+      logFunction(level, source, fileName, lineNumber, [prefix stringByAppendingString:message]);
+    });
+  }
+}
+
+NSString *RCTFormatLog(
+  NSDate *timestamp,
+  RCTLogLevel level,
+  NSString *fileName,
+  NSNumber *lineNumber,
+  NSString *message
+)
+{
+  NSMutableString *log = [NSMutableString new];
+  if (timestamp) {
+    static NSDateFormatter *formatter;
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+      formatter = [NSDateFormatter new];
+      formatter.dateFormat = formatter.dateFormat = @"yyyy-MM-dd HH:mm:ss.SSS ";
+    });
+    [log appendString:[formatter stringFromDate:timestamp]];
+  }
+  if (level) {
+    [log appendFormat:@"[%s]", RCTLogLevels[level]];
+  }
+
+  [log appendFormat:@"[tid:%@]", RCTCurrentThreadName()];
+
+  if (fileName) {
+    fileName = fileName.lastPathComponent;
+    if (lineNumber) {
+      [log appendFormat:@"[%@:%@]", fileName, lineNumber];
+    } else {
+      [log appendFormat:@"[%@]", fileName];
+    }
+  }
+  if (message) {
+    [log appendString:@" "];
+    [log appendString:message];
+  }
+  return log;
+}
+
+static NSRegularExpression *nativeStackFrameRegex()
+{
+  static dispatch_once_t onceToken;
+  static NSRegularExpression *_regex;
+  dispatch_once(&onceToken, ^{
+    NSError *regexError;
+    _regex = [NSRegularExpression regularExpressionWithPattern:@"0x[0-9a-f]+ (.*) \\+ (\\d+)$" options:0 error:&regexError];
+    if (regexError) {
+      RCTLogError(@"Failed to build regex: %@", [regexError localizedDescription]);
+    }
+  });
+  return _regex;
+}
+
+void _RCTLogNativeInternal(RCTLogLevel level, const char *fileName, int lineNumber, NSString *format, ...)
+{
+  RCTLogFunction logFunction = RCTGetLocalLogFunction();
+  BOOL log = RCT_DEBUG || (logFunction != nil);
+  if (log && level >= RCTGetLogThreshold()) {
+    // Get message
+    va_list args;
+    va_start(args, format);
+    NSString *message = [[NSString alloc] initWithFormat:format arguments:args];
+    va_end(args);
+
+    // Call log function
+    if (logFunction) {
+      logFunction(level, RCTLogSourceNative, fileName ? @(fileName) : nil, lineNumber > 0 ? @(lineNumber) : nil, message);
+    }
+
+#if RCT_DEBUG
+
+    // Log to red box in debug mode.
+    if (RCTSharedApplication() && level >= RCTLOG_REDBOX_LEVEL) {
+      NSArray<NSString *> *stackSymbols = [NSThread callStackSymbols];
+      NSMutableArray<NSDictionary *> *stack =
+        [NSMutableArray arrayWithCapacity:(stackSymbols.count - 1)];
+      [stackSymbols enumerateObjectsUsingBlock:^(NSString *frameSymbols, NSUInteger idx, __unused BOOL *stop) {
+        if (idx == 0) {
+          // don't include the current frame
+          return;
+        }
+
+        NSRange range = NSMakeRange(0, frameSymbols.length);
+        NSTextCheckingResult *match = [nativeStackFrameRegex() firstMatchInString:frameSymbols options:0 range:range];
+        if (!match) {
+          return;
+        }
+
+        NSString *methodName = [frameSymbols substringWithRange:[match rangeAtIndex:1]];
+        char *demangledName = abi::__cxa_demangle([methodName UTF8String], NULL, NULL, NULL);
+        if (demangledName) {
+          methodName = @(demangledName);
+          free(demangledName);
+        }
+
+        if (idx == 1 && fileName) {
+          NSString *file = [@(fileName) componentsSeparatedByString:@"/"].lastObject;
+          [stack addObject:@{@"methodName": methodName, @"file": file, @"lineNumber": @(lineNumber)}];
+        } else {
+          [stack addObject:@{@"methodName": methodName}];
+        }
+      }];
+
+      dispatch_async(dispatch_get_main_queue(), ^{
+        // red box is thread safe, but by deferring to main queue we avoid a startup
+        // race condition that causes the module to be accessed before it has loaded
+        [[RCTBridge currentBridge].redBox showErrorMessage:message withStack:stack];
+      });
+    }
+
+    if (!RCTRunningInTestEnvironment()) {
+      // Log to JS executor
+      [[RCTBridge currentBridge] logMessage:message level:level ? @(RCTLogLevels[level]) : @"info"];
+    }
+
+#endif
+
+  }
+}
+
+void _RCTLogJavaScriptInternal(RCTLogLevel level, NSString *message)
+{
+  RCTLogFunction logFunction = RCTGetLocalLogFunction();
+  BOOL log = RCT_DEBUG || (logFunction != nil);
+  if (log && level >= RCTGetLogThreshold()) {
+    if (logFunction) {
+      logFunction(level, RCTLogSourceJavaScript, nil, nil, message);
+    }
+  }
+}

node_modules/react-native/React/Base/RCTManagedPointer.h

@@ -0,0 +1,39 @@
+/**
+ * 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.
+ */
+
+#ifdef __cplusplus
+
+#include <memory>
+
+#import <Foundation/Foundation.h>
+
+/**
+ * Type erased wrapper over any cxx value that can be passed as an argument
+ * to native method.
+ */
+
+@interface RCTManagedPointer: NSObject
+
+@property (nonatomic, readonly) void *voidPointer;
+
+- (instancetype)initWithPointer:(std::shared_ptr<void>)pointer;
+
+@end
+
+namespace facebook {
+namespace react {
+
+template <typename T, typename P>
+RCTManagedPointer *managedPointer(P initializer)
+{
+  auto ptr = std::shared_ptr<void>(new T(initializer));
+  return [[RCTManagedPointer alloc] initWithPointer:std::move(ptr)];
+}
+
+} }
+
+#endif

node_modules/react-native/React/Base/RCTManagedPointer.mm

@@ -0,0 +1,25 @@
+/**
+ * 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 "RCTManagedPointer.h"
+
+@implementation RCTManagedPointer {
+  std::shared_ptr<void> _pointer;
+}
+
+- (instancetype)initWithPointer:(std::shared_ptr<void>)pointer {
+  if (self = [super init]) {
+    _pointer = std::move(pointer);
+  }
+  return self;
+}
+
+- (void *)voidPointer {
+  return _pointer.get();
+}
+
+@end

node_modules/react-native/React/Base/RCTModuleData.h

@@ -0,0 +1,91 @@
+/**
+ * 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/RCTInvalidating.h>
+
+@protocol RCTBridgeMethod;
+@protocol RCTBridgeModule;
+@class RCTBridge;
+
+typedef id<RCTBridgeModule>(^RCTBridgeModuleProvider)(void);
+
+@interface RCTModuleData : NSObject <RCTInvalidating>
+
+- (instancetype)initWithModuleClass:(Class)moduleClass
+                             bridge:(RCTBridge *)bridge;
+
+- (instancetype)initWithModuleClass:(Class)moduleClass
+                     moduleProvider:(RCTBridgeModuleProvider)moduleProvider
+                             bridge:(RCTBridge *)bridge NS_DESIGNATED_INITIALIZER;
+
+- (instancetype)initWithModuleInstance:(id<RCTBridgeModule>)instance
+                                bridge:(RCTBridge *)bridge NS_DESIGNATED_INITIALIZER;
+
+/**
+ * Calls `constantsToExport` on the module and stores the result. Note that
+ * this will init the module if it has not already been created. This method
+ * can be called on any thread, but may block the main thread briefly if the
+ * module implements `constantsToExport`.
+ */
+- (void)gatherConstants;
+
+@property (nonatomic, strong, readonly) Class moduleClass;
+@property (nonatomic, copy, readonly) NSString *name;
+
+/**
+ * Returns the module methods. Note that this will gather the methods the first
+ * time it is called and then memoize the results.
+ */
+@property (nonatomic, copy, readonly) NSArray<id<RCTBridgeMethod>> *methods;
+
+/**
+ * Returns the module's constants, if it exports any
+ */
+@property (nonatomic, copy, readonly) NSDictionary<NSString *, id> *exportedConstants;
+
+/**
+ * Returns YES if module instance has already been initialized; NO otherwise.
+ */
+@property (nonatomic, assign, readonly) BOOL hasInstance;
+
+/**
+ * Returns YES if module instance must be created on the main thread.
+ */
+@property (nonatomic, assign) BOOL requiresMainQueueSetup;
+
+/**
+ * Returns YES if module has constants to export.
+ */
+@property (nonatomic, assign, readonly) BOOL hasConstantsToExport;
+
+/**
+ * Returns the current module instance. Note that this will init the instance
+ * if it has not already been created. To check if the module instance exists
+ * without causing it to be created, use `hasInstance` instead.
+ */
+@property (nonatomic, strong, readonly) id<RCTBridgeModule> instance;
+
+/**
+ * Returns the module method dispatch queue. Note that this will init both the
+ * queue and the module itself if they have not already been created.
+ */
+@property (nonatomic, strong, readonly) dispatch_queue_t methodQueue;
+
+/**
+ * Whether the receiver has a valid `instance` which implements -batchDidComplete.
+ */
+@property (nonatomic, assign, readonly) BOOL implementsBatchDidComplete;
+
+/**
+ * Whether the receiver has a valid `instance` which implements
+ * -partialBatchDidFlush.
+ */
+@property (nonatomic, assign, readonly) BOOL implementsPartialBatchDidFlush;
+
+@end

node_modules/react-native/React/Base/RCTModuleData.mm

@@ -0,0 +1,349 @@
+/**
+ * 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 "RCTModuleData.h"
+
+#import <objc/runtime.h>
+#include <mutex>
+
+#import "RCTBridge+Private.h"
+#import "RCTBridge.h"
+#import "RCTLog.h"
+#import "RCTModuleMethod.h"
+#import "RCTProfile.h"
+#import "RCTUtils.h"
+
+@implementation RCTModuleData
+{
+  NSDictionary<NSString *, id> *_constantsToExport;
+  NSString *_queueName;
+  __weak RCTBridge *_bridge;
+  RCTBridgeModuleProvider _moduleProvider;
+  std::mutex _instanceLock;
+  BOOL _setupComplete;
+}
+
+@synthesize methods = _methods;
+@synthesize instance = _instance;
+@synthesize methodQueue = _methodQueue;
+
+- (void)setUp
+{
+  _implementsBatchDidComplete = [_moduleClass instancesRespondToSelector:@selector(batchDidComplete)];
+  _implementsPartialBatchDidFlush = [_moduleClass instancesRespondToSelector:@selector(partialBatchDidFlush)];
+
+  // If a module overrides `constantsToExport` and doesn't implement `requiresMainQueueSetup`, then we must assume
+  // that it must be called on the main thread, because it may need to access UIKit.
+  _hasConstantsToExport = [_moduleClass instancesRespondToSelector:@selector(constantsToExport)];
+
+  const BOOL implementsRequireMainQueueSetup = [_moduleClass respondsToSelector:@selector(requiresMainQueueSetup)];
+  if (implementsRequireMainQueueSetup) {
+    _requiresMainQueueSetup = [_moduleClass requiresMainQueueSetup];
+  } else {
+    static IMP objectInitMethod;
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+      objectInitMethod = [NSObject instanceMethodForSelector:@selector(init)];
+    });
+
+    // If a module overrides `init` then we must assume that it expects to be
+    // initialized on the main thread, because it may need to access UIKit.
+    const BOOL hasCustomInit = !_instance && [_moduleClass instanceMethodForSelector:@selector(init)] != objectInitMethod;
+
+    _requiresMainQueueSetup = _hasConstantsToExport || hasCustomInit;
+    if (_requiresMainQueueSetup) {
+      const char *methodName = "";
+      if (_hasConstantsToExport) {
+        methodName = "constantsToExport";
+      } else if (hasCustomInit) {
+        methodName = "init";
+      }
+      RCTLogWarn(@"Module %@ requires main queue setup since it overrides `%s` but doesn't implement "
+        "`requiresMainQueueSetup`. In a future release React Native will default to initializing all native modules "
+        "on a background thread unless explicitly opted-out of.", _moduleClass, methodName);
+    }
+  }
+}
+
+- (instancetype)initWithModuleClass:(Class)moduleClass
+                             bridge:(RCTBridge *)bridge
+{
+  return [self initWithModuleClass:moduleClass
+                    moduleProvider:^id<RCTBridgeModule>{ return [moduleClass new]; }
+                            bridge:bridge];
+}
+
+- (instancetype)initWithModuleClass:(Class)moduleClass
+                     moduleProvider:(RCTBridgeModuleProvider)moduleProvider
+                             bridge:(RCTBridge *)bridge
+{
+  if (self = [super init]) {
+    _bridge = bridge;
+    _moduleClass = moduleClass;
+    _moduleProvider = [moduleProvider copy];
+    [self setUp];
+  }
+  return self;
+}
+
+- (instancetype)initWithModuleInstance:(id<RCTBridgeModule>)instance
+                                bridge:(RCTBridge *)bridge
+{
+  if (self = [super init]) {
+    _bridge = bridge;
+    _instance = instance;
+    _moduleClass = [instance class];
+    [self setUp];
+  }
+  return self;
+}
+
+RCT_NOT_IMPLEMENTED(- (instancetype)init);
+
+#pragma mark - private setup methods
+
+- (void)setUpInstanceAndBridge
+{
+  RCT_PROFILE_BEGIN_EVENT(RCTProfileTagAlways, @"[RCTModuleData setUpInstanceAndBridge]", @{
+    @"moduleClass": NSStringFromClass(_moduleClass)
+  });
+  {
+    std::unique_lock<std::mutex> lock(_instanceLock);
+
+    if (!_setupComplete && _bridge.valid) {
+      if (!_instance) {
+        if (RCT_DEBUG && _requiresMainQueueSetup) {
+          RCTAssertMainQueue();
+        }
+        RCT_PROFILE_BEGIN_EVENT(RCTProfileTagAlways, @"[RCTModuleData setUpInstanceAndBridge] Create module", nil);
+        _instance = _moduleProvider ? _moduleProvider() : nil;
+        RCT_PROFILE_END_EVENT(RCTProfileTagAlways, @"");
+        if (!_instance) {
+          // Module init returned nil, probably because automatic instantatiation
+          // of the module is not supported, and it is supposed to be passed in to
+          // the bridge constructor. Mark setup complete to avoid doing more work.
+          _setupComplete = YES;
+          RCTLogWarn(@"The module %@ is returning nil from its constructor. You "
+                     "may need to instantiate it yourself and pass it into the "
+                     "bridge.", _moduleClass);
+        }
+      }
+
+      if (_instance && RCTProfileIsProfiling()) {
+        RCTProfileHookInstance(_instance);
+      }
+
+      // Bridge must be set before methodQueue is set up, as methodQueue
+      // initialization requires it (View Managers get their queue by calling
+      // self.bridge.uiManager.methodQueue)
+      [self setBridgeForInstance];
+    }
+
+    [self setUpMethodQueue];
+  }
+  RCT_PROFILE_END_EVENT(RCTProfileTagAlways, @"");
+
+  // This is called outside of the lock in order to prevent deadlock issues
+  // because the logic in `finishSetupForInstance` can cause
+  // `moduleData.instance` to be accessed re-entrantly.
+  if (_bridge.moduleSetupComplete) {
+    [self finishSetupForInstance];
+  } else {
+    // If we're here, then the module is completely initialized,
+    // except for what finishSetupForInstance does.  When the instance
+    // method is called after moduleSetupComplete,
+    // finishSetupForInstance will run.  If _requiresMainQueueSetup
+    // is true, getting the instance will block waiting for the main
+    // thread, which could take a while if the main thread is busy
+    // (I've seen 50ms in testing).  So we clear that flag, since
+    // nothing in finishSetupForInstance needs to be run on the main
+    // thread.
+    _requiresMainQueueSetup = NO;
+  }
+}
+
+- (void)setBridgeForInstance
+{
+  if ([_instance respondsToSelector:@selector(bridge)] && _instance.bridge != _bridge) {
+    RCT_PROFILE_BEGIN_EVENT(RCTProfileTagAlways, @"[RCTModuleData setBridgeForInstance]", nil);
+    @try {
+      [(id)_instance setValue:_bridge forKey:@"bridge"];
+    }
+    @catch (NSException *exception) {
+      RCTLogError(@"%@ has no setter or ivar for its bridge, which is not "
+                  "permitted. You must either @synthesize the bridge property, "
+                  "or provide your own setter method.", self.name);
+    }
+    RCT_PROFILE_END_EVENT(RCTProfileTagAlways, @"");
+  }
+}
+
+- (void)finishSetupForInstance
+{
+  if (!_setupComplete && _instance) {
+    RCT_PROFILE_BEGIN_EVENT(RCTProfileTagAlways, @"[RCTModuleData finishSetupForInstance]", nil);
+    _setupComplete = YES;
+    [_bridge registerModuleForFrameUpdates:_instance withModuleData:self];
+    [[NSNotificationCenter defaultCenter] postNotificationName:RCTDidInitializeModuleNotification
+                                                        object:_bridge
+                                                      userInfo:@{@"module": _instance, @"bridge": RCTNullIfNil(_bridge.parentBridge)}];
+    RCT_PROFILE_END_EVENT(RCTProfileTagAlways, @"");
+  }
+}
+
+- (void)setUpMethodQueue
+{
+  if (_instance && !_methodQueue && _bridge.valid) {
+    RCT_PROFILE_BEGIN_EVENT(RCTProfileTagAlways, @"[RCTModuleData setUpMethodQueue]", nil);
+    BOOL implementsMethodQueue = [_instance respondsToSelector:@selector(methodQueue)];
+    if (implementsMethodQueue && _bridge.valid) {
+      _methodQueue = _instance.methodQueue;
+    }
+    if (!_methodQueue && _bridge.valid) {
+      // Create new queue (store queueName, as it isn't retained by dispatch_queue)
+      _queueName = [NSString stringWithFormat:@"com.facebook.react.%@Queue", self.name];
+      _methodQueue = dispatch_queue_create(_queueName.UTF8String, DISPATCH_QUEUE_SERIAL);
+
+      // assign it to the module
+      if (implementsMethodQueue) {
+        @try {
+          [(id)_instance setValue:_methodQueue forKey:@"methodQueue"];
+        }
+        @catch (NSException *exception) {
+          RCTLogError(@"%@ is returning nil for its methodQueue, which is not "
+                      "permitted. You must either return a pre-initialized "
+                      "queue, or @synthesize the methodQueue to let the bridge "
+                      "create a queue for you.", self.name);
+        }
+      }
+    }
+    RCT_PROFILE_END_EVENT(RCTProfileTagAlways, @"");
+  }
+}
+
+#pragma mark - public getters
+
+- (BOOL)hasInstance
+{
+  std::unique_lock<std::mutex> lock(_instanceLock);
+  return _instance != nil;
+}
+
+- (id<RCTBridgeModule>)instance
+{
+  if (!_setupComplete) {
+    RCT_PROFILE_BEGIN_EVENT(RCTProfileTagAlways, ([NSString stringWithFormat:@"[RCTModuleData instanceForClass:%@]", _moduleClass]), nil);
+    if (_requiresMainQueueSetup) {
+      // The chances of deadlock here are low, because module init very rarely
+      // calls out to other threads, however we can't control when a module might
+      // get accessed by client code during bridge setup, and a very low risk of
+      // deadlock is better than a fairly high risk of an assertion being thrown.
+      RCT_PROFILE_BEGIN_EVENT(RCTProfileTagAlways, @"[RCTModuleData instance] main thread setup", nil);
+
+      if (!RCTIsMainQueue()) {
+        RCTLogWarn(@"RCTBridge required dispatch_sync to load %@. This may lead to deadlocks", _moduleClass);
+      }
+
+      RCTUnsafeExecuteOnMainQueueSync(^{
+        [self setUpInstanceAndBridge];
+      });
+      RCT_PROFILE_END_EVENT(RCTProfileTagAlways, @"");
+    } else {
+      [self setUpInstanceAndBridge];
+    }
+    RCT_PROFILE_END_EVENT(RCTProfileTagAlways, @"");
+  }
+  return _instance;
+}
+
+- (NSString *)name
+{
+  return RCTBridgeModuleNameForClass(_moduleClass);
+}
+
+- (NSArray<id<RCTBridgeMethod>> *)methods
+{
+  if (!_methods) {
+    NSMutableArray<id<RCTBridgeMethod>> *moduleMethods = [NSMutableArray new];
+
+    if ([_moduleClass instancesRespondToSelector:@selector(methodsToExport)]) {
+      [moduleMethods addObjectsFromArray:[self.instance methodsToExport]];
+    }
+
+    unsigned int methodCount;
+    Class cls = _moduleClass;
+    while (cls && cls != [NSObject class] && cls != [NSProxy class]) {
+      Method *methods = class_copyMethodList(object_getClass(cls), &methodCount);
+
+      for (unsigned int i = 0; i < methodCount; i++) {
+        Method method = methods[i];
+        SEL selector = method_getName(method);
+        if ([NSStringFromSelector(selector) hasPrefix:@"__rct_export__"]) {
+          IMP imp = method_getImplementation(method);
+          auto exportedMethod = ((const RCTMethodInfo *(*)(id, SEL))imp)(_moduleClass, selector);
+          id<RCTBridgeMethod> moduleMethod = [[RCTModuleMethod alloc] initWithExportedMethod:exportedMethod
+                                                                                 moduleClass:_moduleClass];
+          [moduleMethods addObject:moduleMethod];
+        }
+      }
+
+      free(methods);
+      cls = class_getSuperclass(cls);
+    }
+
+    _methods = [moduleMethods copy];
+  }
+  return _methods;
+}
+
+- (void)gatherConstants
+{
+  if (_hasConstantsToExport && !_constantsToExport) {
+    RCT_PROFILE_BEGIN_EVENT(RCTProfileTagAlways, ([NSString stringWithFormat:@"[RCTModuleData gatherConstants] %@", _moduleClass]), nil);
+    (void)[self instance];
+    if (_requiresMainQueueSetup) {
+      if (!RCTIsMainQueue()) {
+        RCTLogWarn(@"Required dispatch_sync to load constants for %@. This may lead to deadlocks", _moduleClass);
+      }
+
+      RCTUnsafeExecuteOnMainQueueSync(^{
+        self->_constantsToExport = [self->_instance constantsToExport] ?: @{};
+      });
+    } else {
+      _constantsToExport = [_instance constantsToExport] ?: @{};
+    }
+    RCT_PROFILE_END_EVENT(RCTProfileTagAlways, @"");
+  }
+}
+
+- (NSDictionary<NSString *, id> *)exportedConstants
+{
+  [self gatherConstants];
+  NSDictionary<NSString *, id> *constants = _constantsToExport;
+  _constantsToExport = nil; // Not needed anymore
+  return constants;
+}
+
+- (dispatch_queue_t)methodQueue
+{
+  (void)[self instance];
+  RCTAssert(_methodQueue != nullptr, @"Module %@ has no methodQueue (instance: %@, bridge.valid: %d)",
+            self, _instance, _bridge.valid);
+  return _methodQueue;
+}
+
+- (void)invalidate
+{
+  _methodQueue = nil;
+}
+
+- (NSString *)description
+{
+  return [NSString stringWithFormat:@"<%@: %p; name=\"%@\">", [self class], self, self.name];
+}
+
+@end

node_modules/react-native/React/Base/RCTModuleMethod.h

@@ -0,0 +1,32 @@
+/**
+ * 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/RCTBridgeMethod.h>
+#import <React/RCTBridgeModule.h>
+#import <React/RCTNullability.h>
+
+@class RCTBridge;
+
+@interface RCTMethodArgument : NSObject
+
+@property (nonatomic, copy, readonly) NSString *type;
+@property (nonatomic, readonly) RCTNullability nullability;
+@property (nonatomic, readonly) BOOL unused;
+
+@end
+
+@interface RCTModuleMethod : NSObject <RCTBridgeMethod>
+
+@property (nonatomic, readonly) Class moduleClass;
+@property (nonatomic, readonly) SEL selector;
+
+- (instancetype)initWithExportedMethod:(const RCTMethodInfo *)exportMethod
+                           moduleClass:(Class)moduleClass NS_DESIGNATED_INITIALIZER;
+
+@end

node_modules/react-native/React/Base/RCTModuleMethod.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 "RCTModuleMethod.h"
+
+#import <objc/message.h>
+
+#import "RCTAssert.h"
+#import "RCTBridge+Private.h"
+#import "RCTBridge.h"
+#import "RCTConvert.h"
+#import "RCTCxxConvert.h"
+#import "RCTLog.h"
+#import "RCTManagedPointer.h"
+#import "RCTParserUtils.h"
+#import "RCTProfile.h"
+#import "RCTUtils.h"
+
+typedef BOOL (^RCTArgumentBlock)(RCTBridge *, NSUInteger, id);
+
+/**
+ * Get the converter function for the specified type
+ */
+static SEL selectorForType(NSString *type)
+{
+  const char *input = type.UTF8String;
+  return NSSelectorFromString([RCTParseType(&input) stringByAppendingString:@":"]);
+}
+
+@implementation RCTMethodArgument
+
+- (instancetype)initWithType:(NSString *)type
+                 nullability:(RCTNullability)nullability
+                      unused:(BOOL)unused
+{
+  if (self = [super init]) {
+    _type = [type copy];
+    _nullability = nullability;
+    _unused = unused;
+  }
+  return self;
+}
+
+@end
+
+@implementation RCTModuleMethod
+{
+  Class _moduleClass;
+  const RCTMethodInfo *_methodInfo;
+  NSString *_JSMethodName;
+
+  SEL _selector;
+  NSInvocation *_invocation;
+  NSArray<RCTArgumentBlock> *_argumentBlocks;
+  NSMutableArray *_retainedObjects;
+}
+
+static void RCTLogArgumentError(RCTModuleMethod *method, NSUInteger index,
+                                id valueOrType, const char *issue)
+{
+  RCTLogError(@"Argument %tu (%@) of %@.%s %s", index, valueOrType,
+              RCTBridgeModuleNameForClass(method->_moduleClass),
+              method.JSMethodName, issue);
+}
+
+RCT_NOT_IMPLEMENTED(- (instancetype)init)
+
+RCT_EXTERN_C_BEGIN
+
+// returns YES if the selector ends in a colon (indicating that there is at
+// least one argument, and maybe more selector parts) or NO if it doesn't.
+static BOOL RCTParseSelectorPart(const char **input, NSMutableString *selector)
+{
+  NSString *selectorPart;
+  if (RCTParseSelectorIdentifier(input, &selectorPart)) {
+    [selector appendString:selectorPart];
+  }
+  RCTSkipWhitespace(input);
+  if (RCTReadChar(input, ':')) {
+    [selector appendString:@":"];
+    RCTSkipWhitespace(input);
+    return YES;
+  }
+  return NO;
+}
+
+static BOOL RCTParseUnused(const char **input)
+{
+  return RCTReadString(input, "__unused") ||
+         RCTReadString(input, "__attribute__((unused))");
+}
+
+static RCTNullability RCTParseNullability(const char **input)
+{
+  if (RCTReadString(input, "nullable")) {
+    return RCTNullable;
+  } else if (RCTReadString(input, "nonnull")) {
+    return RCTNonnullable;
+  }
+  return RCTNullabilityUnspecified;
+}
+
+static RCTNullability RCTParseNullabilityPostfix(const char **input)
+{
+  if (RCTReadString(input, "_Nullable")) {
+    return RCTNullable;
+  } else if (RCTReadString(input, "_Nonnull")) {
+    return RCTNonnullable;
+  }
+  return RCTNullabilityUnspecified;
+}
+
+// returns YES if execution is safe to proceed (enqueue callback invocation), NO if callback has already been invoked
+#if RCT_DEBUG
+static BOOL checkCallbackMultipleInvocations(BOOL *didInvoke) {
+  if (*didInvoke) {
+      RCTFatal(RCTErrorWithMessage(@"Illegal callback invocation from native module. This callback type only permits a single invocation from native code."));
+      return NO;
+  } else {
+      *didInvoke = YES;
+      return YES;
+  }
+}
+#endif
+
+extern NSString *RCTParseMethodSignature(const char *input, NSArray<RCTMethodArgument *> **arguments);
+NSString *RCTParseMethodSignature(const char *input, NSArray<RCTMethodArgument *> **arguments)
+{
+  RCTSkipWhitespace(&input);
+
+  NSMutableArray *args;
+  NSMutableString *selector = [NSMutableString new];
+  while (RCTParseSelectorPart(&input, selector)) {
+    if (!args) {
+      args = [NSMutableArray new];
+    }
+
+    // Parse type
+    if (RCTReadChar(&input, '(')) {
+      RCTSkipWhitespace(&input);
+
+      BOOL unused = RCTParseUnused(&input);
+      RCTSkipWhitespace(&input);
+
+      RCTNullability nullability = RCTParseNullability(&input);
+      RCTSkipWhitespace(&input);
+
+      NSString *type = RCTParseType(&input);
+      RCTSkipWhitespace(&input);
+      if (nullability == RCTNullabilityUnspecified) {
+        nullability = RCTParseNullabilityPostfix(&input);
+      }
+      [args addObject:[[RCTMethodArgument alloc] initWithType:type
+                                                  nullability:nullability
+                                                       unused:unused]];
+      RCTSkipWhitespace(&input);
+      RCTReadChar(&input, ')');
+      RCTSkipWhitespace(&input);
+    } else {
+      // Type defaults to id if unspecified
+      [args addObject:[[RCTMethodArgument alloc] initWithType:@"id"
+                                                  nullability:RCTNullable
+                                                       unused:NO]];
+    }
+
+    // Argument name
+    RCTParseArgumentIdentifier(&input, NULL);
+    RCTSkipWhitespace(&input);
+  }
+
+  *arguments = [args copy];
+  return selector;
+}
+
+RCT_EXTERN_C_END
+
+- (instancetype)initWithExportedMethod:(const RCTMethodInfo *)exportedMethod
+                           moduleClass:(Class)moduleClass
+{
+  if (self = [super init]) {
+    _moduleClass = moduleClass;
+    _methodInfo = exportedMethod;
+  }
+  return self;
+}
+
+- (void)processMethodSignature
+{
+  NSArray<RCTMethodArgument *> *arguments;
+  _selector = NSSelectorFromString(RCTParseMethodSignature(_methodInfo->objcName, &arguments));
+  RCTAssert(_selector, @"%s is not a valid selector", _methodInfo->objcName);
+
+  // Create method invocation
+  NSMethodSignature *methodSignature = [_moduleClass instanceMethodSignatureForSelector:_selector];
+  RCTAssert(methodSignature, @"%s is not a recognized Objective-C method.", sel_getName(_selector));
+  NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:methodSignature];
+  invocation.selector = _selector;
+  _invocation = invocation;
+  NSMutableArray *retainedObjects = [NSMutableArray array];
+  _retainedObjects = retainedObjects;
+
+  // Process arguments
+  NSUInteger numberOfArguments = methodSignature.numberOfArguments;
+  NSMutableArray<RCTArgumentBlock> *argumentBlocks =
+    [[NSMutableArray alloc] initWithCapacity:numberOfArguments - 2];
+
+#if RCT_DEBUG
+  __weak RCTModuleMethod *weakSelf = self;
+#endif
+
+#define RCT_RETAINED_ARG_BLOCK(_logic) \
+[argumentBlocks addObject:^(__unused RCTBridge *bridge, NSUInteger index, id json) { \
+  _logic                                                                             \
+  [invocation setArgument:&value atIndex:(index) + 2];                               \
+  if (value) {                                                                       \
+    [retainedObjects addObject:value];                                               \
+  }                                                                                  \
+  return YES;                                                                        \
+}]
+
+#define __PRIMITIVE_CASE(_type, _nullable) {                                           \
+  isNullableType = _nullable;                                                          \
+  _type (*convert)(id, SEL, id) = (__typeof__(convert))objc_msgSend;                   \
+  [argumentBlocks addObject:^(__unused RCTBridge *bridge, NSUInteger index, id json) { \
+    _type value = convert([RCTConvert class], selector, json);                         \
+    [invocation setArgument:&value atIndex:(index) + 2];                               \
+    return YES;                                                                        \
+  }];                                                                                  \
+  break;                                                                               \
+}
+
+#define PRIMITIVE_CASE(_type) __PRIMITIVE_CASE(_type, NO)
+#define NULLABLE_PRIMITIVE_CASE(_type) __PRIMITIVE_CASE(_type, YES)
+
+// Explicitly copy the block
+#define __COPY_BLOCK(block...)         \
+  id value = [block copy];             \
+  if (value) {                         \
+    [retainedObjects addObject:value]; \
+  }                                    \
+
+#if RCT_DEBUG
+#define BLOCK_CASE(_block_args, _block) RCT_RETAINED_ARG_BLOCK(         \
+  if (json && ![json isKindOfClass:[NSNumber class]]) {                 \
+    RCTLogArgumentError(weakSelf, index, json, "should be a function"); \
+    return NO;                                                          \
+  }                                                                     \
+  __block BOOL didInvoke = NO;                                          \
+  __COPY_BLOCK(^_block_args {                                           \
+    if (checkCallbackMultipleInvocations(&didInvoke)) _block            \
+  });                                                                   \
+)
+#else
+#define BLOCK_CASE(_block_args, _block) \
+  RCT_RETAINED_ARG_BLOCK( __COPY_BLOCK(^_block_args { _block }); )
+#endif
+
+  for (NSUInteger i = 2; i < numberOfArguments; i++) {
+    const char *objcType = [methodSignature getArgumentTypeAtIndex:i];
+    BOOL isNullableType = NO;
+    RCTMethodArgument *argument = arguments[i - 2];
+    NSString *typeName = argument.type;
+    SEL selector = selectorForType(typeName);
+    if ([RCTConvert respondsToSelector:selector]) {
+      switch (objcType[0]) {
+        // Primitives
+        case _C_CHR: PRIMITIVE_CASE(char)
+        case _C_UCHR: PRIMITIVE_CASE(unsigned char)
+        case _C_SHT: PRIMITIVE_CASE(short)
+        case _C_USHT: PRIMITIVE_CASE(unsigned short)
+        case _C_INT: PRIMITIVE_CASE(int)
+        case _C_UINT: PRIMITIVE_CASE(unsigned int)
+        case _C_LNG: PRIMITIVE_CASE(long)
+        case _C_ULNG: PRIMITIVE_CASE(unsigned long)
+        case _C_LNG_LNG: PRIMITIVE_CASE(long long)
+        case _C_ULNG_LNG: PRIMITIVE_CASE(unsigned long long)
+        case _C_FLT: PRIMITIVE_CASE(float)
+        case _C_DBL: PRIMITIVE_CASE(double)
+        case _C_BOOL: PRIMITIVE_CASE(BOOL)
+        case _C_SEL: NULLABLE_PRIMITIVE_CASE(SEL)
+        case _C_CHARPTR: NULLABLE_PRIMITIVE_CASE(const char *)
+        case _C_PTR: NULLABLE_PRIMITIVE_CASE(void *)
+
+        case _C_ID: {
+          isNullableType = YES;
+          id (*convert)(id, SEL, id) = (__typeof__(convert))objc_msgSend;
+          RCT_RETAINED_ARG_BLOCK(
+            id value = convert([RCTConvert class], selector, json);
+          );
+          break;
+        }
+
+        case _C_STRUCT_B: {
+          NSMethodSignature *typeSignature = [RCTConvert methodSignatureForSelector:selector];
+          NSInvocation *typeInvocation = [NSInvocation invocationWithMethodSignature:typeSignature];
+          typeInvocation.selector = selector;
+          typeInvocation.target = [RCTConvert class];
+
+          [argumentBlocks addObject:^(__unused RCTBridge *bridge, NSUInteger index, id json) {
+            void *returnValue = malloc(typeSignature.methodReturnLength);
+            [typeInvocation setArgument:&json atIndex:2];
+            [typeInvocation invoke];
+            [typeInvocation getReturnValue:returnValue];
+            [invocation setArgument:returnValue atIndex:index + 2];
+            free(returnValue);
+            return YES;
+          }];
+          break;
+        }
+
+        default: {
+          static const char *blockType = @encode(__typeof__(^{}));
+          if (!strcmp(objcType, blockType)) {
+            BLOCK_CASE((NSArray *args), {
+              [bridge enqueueCallback:json args:args];
+            });
+          } else {
+            RCTLogError(@"Unsupported argument type '%@' in method %@.",
+                        typeName, [self methodName]);
+          }
+        }
+      }
+    } else if ([typeName isEqualToString:@"RCTResponseSenderBlock"]) {
+      BLOCK_CASE((NSArray *args), {
+        [bridge enqueueCallback:json args:args];
+      });
+    } else if ([typeName isEqualToString:@"RCTResponseErrorBlock"]) {
+      BLOCK_CASE((NSError *error), {
+        [bridge enqueueCallback:json args:@[RCTJSErrorFromNSError(error)]];
+      });
+    } else if ([typeName isEqualToString:@"RCTPromiseResolveBlock"]) {
+      RCTAssert(i == numberOfArguments - 2,
+                @"The RCTPromiseResolveBlock must be the second to last parameter in %@",
+                [self methodName]);
+      BLOCK_CASE((id result), {
+        [bridge enqueueCallback:json args:result ? @[result] : @[]];
+      });
+    } else if ([typeName isEqualToString:@"RCTPromiseRejectBlock"]) {
+      RCTAssert(i == numberOfArguments - 1,
+                @"The RCTPromiseRejectBlock must be the last parameter in %@",
+                [self methodName]);
+      BLOCK_CASE((NSString *code, NSString *message, NSError *error), {
+        NSDictionary *errorJSON = RCTJSErrorFromCodeMessageAndNSError(code, message, error);
+        [bridge enqueueCallback:json args:@[errorJSON]];
+      });
+    } else if ([typeName hasPrefix:@"JS::"]) {
+      NSString *selectorNameForCxxType =
+      [[typeName stringByReplacingOccurrencesOfString:@"::" withString:@"_"]
+       stringByAppendingString:@":"];
+      selector = NSSelectorFromString(selectorNameForCxxType);
+
+      [argumentBlocks addObject:^(__unused RCTBridge *bridge, NSUInteger index, id json) {
+        RCTManagedPointer *(*convert)(id, SEL, id) = (__typeof__(convert))objc_msgSend;
+        RCTManagedPointer *box = convert([RCTCxxConvert class], selector, json);
+
+        void *pointer = box.voidPointer;
+        [invocation setArgument:&pointer atIndex:index + 2];
+        [retainedObjects addObject:box];
+
+        return YES;
+      }];
+    } else {
+      // Unknown argument type
+      RCTLogError(@"Unknown argument type '%@' in method %@. Extend RCTConvert to support this type.",
+                  typeName, [self methodName]);
+    }
+
+#if RCT_DEBUG
+    RCTNullability nullability = argument.nullability;
+    if (!isNullableType) {
+      if (nullability == RCTNullable) {
+        RCTLogArgumentError(weakSelf, i - 2, typeName, "is marked as "
+                            "nullable, but is not a nullable type.");
+      }
+      nullability = RCTNonnullable;
+    }
+
+    /**
+     * Special case - Numbers are not nullable in Android, so we
+     * don't support this for now. In future we may allow it.
+     */
+    if ([typeName isEqualToString:@"NSNumber"]) {
+      BOOL unspecified = (nullability == RCTNullabilityUnspecified);
+      if (!argument.unused && (nullability == RCTNullable || unspecified)) {
+        RCTLogArgumentError(weakSelf, i - 2, typeName,
+          [unspecified ? @"has unspecified nullability" : @"is marked as nullable"
+           stringByAppendingString: @" but React requires that all NSNumber "
+           "arguments are explicitly marked as `nonnull` to ensure "
+           "compatibility with Android."].UTF8String);
+      }
+      nullability = RCTNonnullable;
+    }
+
+    if (nullability == RCTNonnullable) {
+      RCTArgumentBlock oldBlock = argumentBlocks[i - 2];
+      argumentBlocks[i - 2] = ^(RCTBridge *bridge, NSUInteger index, id json) {
+        if (json != nil) {
+          if (!oldBlock(bridge, index, json)) {
+            return NO;
+          }
+          if (isNullableType) {
+            // Check converted value wasn't null either, as method probably
+            // won't gracefully handle a nil vallue for a nonull argument
+            void *value;
+            [invocation getArgument:&value atIndex:index + 2];
+            if (value == NULL) {
+              return NO;
+            }
+          }
+          return YES;
+        }
+        RCTLogArgumentError(weakSelf, index, typeName, "must not be null");
+        return NO;
+      };
+    }
+#endif
+  }
+
+#if RCT_DEBUG
+  const char *objcType = _invocation.methodSignature.methodReturnType;
+  if (_methodInfo->isSync && objcType[0] != _C_ID) {
+    RCTLogError(@"Return type of %@.%s should be (id) as the method is \"sync\"",
+                RCTBridgeModuleNameForClass(_moduleClass), self.JSMethodName);
+  }
+#endif
+
+  _argumentBlocks = argumentBlocks;
+}
+
+- (SEL)selector
+{
+  if (_selector == NULL) {
+    RCT_PROFILE_BEGIN_EVENT(RCTProfileTagAlways, @"", (@{ @"module": NSStringFromClass(_moduleClass),
+                                                          @"method": @(_methodInfo->objcName) }));
+    [self processMethodSignature];
+    RCT_PROFILE_END_EVENT(RCTProfileTagAlways, @"");
+  }
+  return _selector;
+}
+
+- (const char *)JSMethodName
+{
+  NSString *methodName = _JSMethodName;
+  if (!methodName) {
+    const char *jsName = _methodInfo->jsName;
+    if (jsName && strlen(jsName) > 0) {
+      methodName = @(jsName);
+    } else {
+      methodName = @(_methodInfo->objcName);
+      NSRange colonRange = [methodName rangeOfString:@":"];
+      if (colonRange.location != NSNotFound) {
+        methodName = [methodName substringToIndex:colonRange.location];
+      }
+      methodName = [methodName stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]];
+      RCTAssert(methodName.length, @"%s is not a valid JS function name, please"
+                " supply an alternative using RCT_REMAP_METHOD()", _methodInfo->objcName);
+    }
+    _JSMethodName = methodName;
+  }
+  return methodName.UTF8String;
+}
+
+- (RCTFunctionType)functionType
+{
+  if (strstr(_methodInfo->objcName, "RCTPromise") != NULL) {
+    RCTAssert(!_methodInfo->isSync, @"Promises cannot be used in sync functions");
+    return RCTFunctionTypePromise;
+  } else if (_methodInfo->isSync) {
+    return RCTFunctionTypeSync;
+  } else {
+    return RCTFunctionTypeNormal;
+  }
+}
+
+- (id)invokeWithBridge:(RCTBridge *)bridge
+                module:(id)module
+             arguments:(NSArray *)arguments
+{
+  if (_argumentBlocks == nil) {
+    [self processMethodSignature];
+  }
+
+#if RCT_DEBUG
+  // Sanity check
+  RCTAssert([module class] == _moduleClass, @"Attempted to invoke method \
+            %@ on a module of class %@", [self methodName], [module class]);
+
+  // Safety check
+  if (arguments.count != _argumentBlocks.count) {
+    NSInteger actualCount = arguments.count;
+    NSInteger expectedCount = _argumentBlocks.count;
+
+    // Subtract the implicit Promise resolver and rejecter functions for implementations of async functions
+    if (self.functionType == RCTFunctionTypePromise) {
+      actualCount -= 2;
+      expectedCount -= 2;
+    }
+
+    RCTLogError(@"%@.%s was called with %lld arguments but expects %lld arguments. "
+                @"If you haven\'t changed this method yourself, this usually means that "
+                @"your versions of the native code and JavaScript code are out of sync. "
+                @"Updating both should make this error go away.",
+                RCTBridgeModuleNameForClass(_moduleClass), self.JSMethodName,
+                (long long)actualCount, (long long)expectedCount);
+    return nil;
+  }
+#endif
+
+  // Set arguments
+  NSUInteger index = 0;
+  for (id json in arguments) {
+    RCTArgumentBlock block = _argumentBlocks[index];
+    if (!block(bridge, index, RCTNilIfNull(json))) {
+      // Invalid argument, abort
+      RCTLogArgumentError(self, index, json, "could not be processed. Aborting method call.");
+      return nil;
+    }
+    index++;
+  }
+
+  // Invoke method
+#ifdef RCT_MAIN_THREAD_WATCH_DOG_THRESHOLD
+  if (RCTIsMainQueue()) {
+    CFTimeInterval start = CACurrentMediaTime();
+    [_invocation invokeWithTarget:module];
+    CFTimeInterval duration = CACurrentMediaTime() - start;
+    if (duration > RCT_MAIN_THREAD_WATCH_DOG_THRESHOLD) {
+      RCTLogWarn(
+                 @"Main Thread Watchdog: Invocation of %@ blocked the main thread for %dms. "
+                 "Consider using background-threaded modules and asynchronous calls "
+                 "to spend less time on the main thread and keep the app's UI responsive.",
+                 [self methodName],
+                 (int)(duration * 1000)
+                 );
+    }
+  } else {
+    [_invocation invokeWithTarget:module];
+  }
+#else
+  [_invocation invokeWithTarget:module];
+#endif
+
+  index = 2;
+  [_retainedObjects removeAllObjects];
+
+  if (_methodInfo->isSync) {
+    void *returnValue;
+    [_invocation getReturnValue:&returnValue];
+    return (__bridge id)returnValue;
+  }
+  return nil;
+}
+
+- (NSString *)methodName
+{
+  if (!_selector) {
+    [self processMethodSignature];
+  }
+  return [NSString stringWithFormat:@"-[%@ %s]", _moduleClass, sel_getName(_selector)];
+}
+
+- (NSString *)description
+{
+  return [NSString stringWithFormat:@"<%@: %p; exports %@ as %s(); type: %s>",
+          [self class], self, [self methodName], self.JSMethodName, RCTFunctionDescriptorFromType(self.functionType)];
+}
+
+@end

node_modules/react-native/React/Base/RCTMultipartDataTask.h

@@ -0,0 +1,22 @@
+/**
+ * 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/RCTMultipartStreamReader.h>
+
+typedef void (^RCTMultipartDataTaskCallback)(NSInteger statusCode, NSDictionary *headers, NSData *content, NSError *error, BOOL done);
+
+@interface RCTMultipartDataTask : NSObject
+
+- (instancetype)initWithURL:(NSURL *)url
+                partHandler:(RCTMultipartDataTaskCallback)partHandler
+            progressHandler:(RCTMultipartProgressCallback)progressHandler;
+
+- (void)startTask;
+
+@end

node_modules/react-native/React/Base/RCTMultipartDataTask.m

@@ -0,0 +1,131 @@
+/**
+ * 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 "RCTMultipartDataTask.h"
+
+@interface RCTMultipartDataTask () <NSURLSessionDataDelegate, NSURLSessionDataDelegate>
+
+@end
+
+// We need this ugly runtime check because [streamTask captureStreams] below fails on iOS version
+// earlier than 9.0. Unfortunately none of the proper ways of checking worked:
+//
+// - NSURLSessionStreamTask class is available and is not Null on iOS 8
+// - [[NSURLSessionStreamTask new] respondsToSelector:@selector(captureStreams)] is always NO
+// - The instance we get in URLSession:dataTask:didBecomeStreamTask: is of __NSCFURLLocalStreamTaskFromDataTask
+//   and it responds to captureStreams on iOS 9+ but doesn't on iOS 8. Which means we can't get direct access
+//   to the streams on iOS 8 and at that point it's too late to change the behavior back to dataTask
+// - The compile-time #ifdef's can't be used because an app compiled for iOS8 can still run on iOS9
+
+static BOOL isStreamTaskSupported() {
+  return [[NSProcessInfo processInfo] isOperatingSystemAtLeastVersion:(NSOperatingSystemVersion){9,0,0}];
+}
+
+@implementation RCTMultipartDataTask {
+  NSURL *_url;
+  RCTMultipartDataTaskCallback _partHandler;
+  RCTMultipartProgressCallback _progressHandler;
+  NSInteger _statusCode;
+  NSDictionary *_headers;
+  NSString *_boundary;
+  NSMutableData *_data;
+}
+
+- (instancetype)initWithURL:(NSURL *)url
+                partHandler:(RCTMultipartDataTaskCallback)partHandler
+            progressHandler:(RCTMultipartProgressCallback)progressHandler
+{
+  if (self = [super init]) {
+    _url = url;
+    _partHandler = [partHandler copy];
+    _progressHandler = [progressHandler copy];
+  }
+  return self;
+}
+
+- (void)startTask
+{
+  NSURLSession *session = [NSURLSession sessionWithConfiguration:[NSURLSessionConfiguration defaultSessionConfiguration]
+                                                        delegate:self delegateQueue:nil];
+  NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:_url];
+  if (isStreamTaskSupported()) {
+    [request addValue:@"multipart/mixed" forHTTPHeaderField:@"Accept"];
+  }
+  NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request];
+  [dataTask resume];
+  [session finishTasksAndInvalidate];
+}
+
+- (void)URLSession:(__unused NSURLSession *)session
+          dataTask:(__unused NSURLSessionDataTask *)dataTask
+didReceiveResponse:(NSURLResponse *)response
+ completionHandler:(void (^)(NSURLSessionResponseDisposition disposition))completionHandler
+{
+  if ([response isKindOfClass:[NSHTTPURLResponse class]]) {
+    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *)response;
+    _headers = [httpResponse allHeaderFields];
+    _statusCode = [httpResponse statusCode];
+
+    NSString *contentType = @"";
+    for (NSString *key in [_headers keyEnumerator]) {
+      if ([[key lowercaseString] isEqualToString:@"content-type"]) {
+        contentType = [_headers valueForKey:key];
+        break;
+      }
+    }
+
+    NSRegularExpression *regex = [NSRegularExpression regularExpressionWithPattern:@"multipart/mixed;.*boundary=\"([^\"]+)\"" options:0 error:nil];
+    NSTextCheckingResult *match = [regex firstMatchInString:contentType options:0 range:NSMakeRange(0, contentType.length)];
+    if (match) {
+      _boundary = [contentType substringWithRange:[match rangeAtIndex:1]];
+      completionHandler(NSURLSessionResponseBecomeStream);
+      return;
+    }
+  }
+
+  // In case the server doesn't support multipart/mixed responses, fallback to normal download
+  _data = [[NSMutableData alloc] initWithCapacity:1024 * 1024];
+  completionHandler(NSURLSessionResponseAllow);
+}
+
+- (void)URLSession:(__unused NSURLSession *)session task:(__unused NSURLSessionTask *)task didCompleteWithError:(NSError *)error
+{
+  if (_partHandler) {
+    _partHandler(_statusCode, _headers, _data, error, YES);
+  }
+}
+
+- (void)URLSession:(__unused NSURLSession *)session dataTask:(__unused NSURLSessionDataTask *)dataTask didReceiveData:(NSData *)data
+{
+  [_data appendData:data];
+}
+
+- (void)URLSession:(__unused NSURLSession *)session dataTask:(__unused NSURLSessionDataTask *)dataTask didBecomeStreamTask:(NSURLSessionStreamTask *)streamTask
+{
+  [streamTask captureStreams];
+}
+
+- (void)URLSession:(__unused NSURLSession *)session
+        streamTask:(__unused NSURLSessionStreamTask *)streamTask
+didBecomeInputStream:(NSInputStream *)inputStream
+      outputStream:(__unused NSOutputStream *)outputStream
+{
+  RCTMultipartStreamReader *reader = [[RCTMultipartStreamReader alloc] initWithInputStream:inputStream boundary:_boundary];
+  RCTMultipartDataTaskCallback partHandler = _partHandler;
+  _partHandler = nil;
+  NSInteger statusCode = _statusCode;
+
+  BOOL completed = [reader readAllPartsWithCompletionCallback:^(NSDictionary *headers, NSData *content, BOOL done) {
+    partHandler(statusCode, headers, content, nil, done);
+  } progressCallback:_progressHandler];
+  if (!completed) {
+    partHandler(statusCode, nil, nil, [NSError errorWithDomain:NSURLErrorDomain code:NSURLErrorCancelled userInfo:nil], YES);
+  }
+}
+
+
+@end

node_modules/react-native/React/Base/RCTMultipartStreamReader.h

@@ -0,0 +1,22 @@
+/**
+ * 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>
+
+typedef void (^RCTMultipartCallback)(NSDictionary *headers, NSData *content, BOOL done);
+typedef void (^RCTMultipartProgressCallback)(NSDictionary *headers, NSNumber *loaded, NSNumber *total);
+
+
+// RCTMultipartStreamReader can be used to parse responses with Content-Type: multipart/mixed
+// See https://www.w3.org/Protocols/rfc1341/7_2_Multipart.html
+@interface RCTMultipartStreamReader : NSObject
+
+- (instancetype)initWithInputStream:(NSInputStream *)stream boundary:(NSString *)boundary;
+- (BOOL)readAllPartsWithCompletionCallback:(RCTMultipartCallback)callback
+                          progressCallback:(RCTMultipartProgressCallback)progressCallback;
+
+@end

node_modules/react-native/React/Base/RCTMultipartStreamReader.m

@@ -0,0 +1,165 @@
+/**
+ * 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 "RCTMultipartStreamReader.h"
+
+#import <QuartzCore/CAAnimation.h>
+
+#define CRLF @"\r\n"
+
+@implementation RCTMultipartStreamReader {
+  __strong NSInputStream *_stream;
+  __strong NSString *_boundary;
+  CFTimeInterval _lastDownloadProgress;
+}
+
+- (instancetype)initWithInputStream:(NSInputStream *)stream boundary:(NSString *)boundary
+{
+  if (self = [super init]) {
+    _stream = stream;
+    _boundary = boundary;
+    _lastDownloadProgress = CACurrentMediaTime();
+  }
+  return self;
+}
+
+- (NSDictionary *)parseHeaders:(NSData *)data
+{
+  NSMutableDictionary *headers = [NSMutableDictionary new];
+  NSString *text = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
+  NSArray<NSString *> *lines = [text componentsSeparatedByString:CRLF];
+  for (NSString *line in lines) {
+    NSUInteger location = [line rangeOfString:@":"].location;
+    if (location == NSNotFound) {
+      continue;
+    }
+    NSString *key = [line substringToIndex:location];
+    NSString *value = [[line substringFromIndex:location + 1] stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]];
+    [headers setValue:value forKey:key];
+  }
+  return headers;
+}
+
+- (void)emitChunk:(NSData *)data headers:(NSDictionary *)headers callback:(RCTMultipartCallback)callback done:(BOOL)done
+{
+  NSData *marker = [CRLF CRLF dataUsingEncoding:NSUTF8StringEncoding];
+  NSRange range = [data rangeOfData:marker options:0 range:NSMakeRange(0, data.length)];
+  if (range.location == NSNotFound) {
+    callback(nil, data, done);
+  } else if (headers != nil) {
+    // If headers were parsed already just use that to avoid doing it twice.
+    NSInteger bodyStart = range.location + marker.length;
+    NSData *bodyData = [data subdataWithRange:NSMakeRange(bodyStart, data.length - bodyStart)];
+    callback(headers, bodyData, done);
+  } else {
+    NSData *headersData = [data subdataWithRange:NSMakeRange(0, range.location)];
+    NSInteger bodyStart = range.location + marker.length;
+    NSData *bodyData = [data subdataWithRange:NSMakeRange(bodyStart, data.length - bodyStart)];
+    callback([self parseHeaders:headersData], bodyData, done);
+  }
+}
+
+- (void)emitProgress:(NSDictionary *)headers
+       contentLength:(NSUInteger)contentLength
+               final:(BOOL)final
+            callback:(RCTMultipartProgressCallback)callback
+{
+  if (headers == nil) {
+    return;
+  }
+  // Throttle progress events so we don't send more that around 60 per second.
+  CFTimeInterval currentTime = CACurrentMediaTime();
+
+  NSInteger headersContentLength = headers[@"Content-Length"] != nil ? [headers[@"Content-Length"] integerValue] : 0;
+  if (callback && (currentTime - _lastDownloadProgress > 0.016 || final)) {
+    _lastDownloadProgress = currentTime;
+    callback(headers, @(headersContentLength), @(contentLength));
+  }
+}
+
+- (BOOL)readAllPartsWithCompletionCallback:(RCTMultipartCallback)callback
+                          progressCallback:(RCTMultipartProgressCallback)progressCallback
+{
+  NSInteger chunkStart = 0;
+  NSInteger bytesSeen = 0;
+
+  NSData *delimiter = [[NSString stringWithFormat:@"%@--%@%@", CRLF, _boundary, CRLF] dataUsingEncoding:NSUTF8StringEncoding];
+  NSData *closeDelimiter = [[NSString stringWithFormat:@"%@--%@--%@", CRLF, _boundary, CRLF] dataUsingEncoding:NSUTF8StringEncoding];
+  NSMutableData *content = [[NSMutableData alloc] initWithCapacity:1];
+  NSDictionary *currentHeaders = nil;
+  NSUInteger currentHeadersLength = 0;
+
+  const NSUInteger bufferLen = 4 * 1024;
+  uint8_t buffer[bufferLen];
+
+  [_stream open];
+  while (true) {
+    BOOL isCloseDelimiter = NO;
+    // Search only a subset of chunk that we haven't seen before + few bytes
+    // to allow for the edge case when the delimiter is cut by read call
+    NSInteger searchStart = MAX(bytesSeen - (NSInteger)closeDelimiter.length, chunkStart);
+    NSRange remainingBufferRange = NSMakeRange(searchStart, content.length - searchStart);
+
+    // Check for delimiters.
+    NSRange range = [content rangeOfData:delimiter options:0 range:remainingBufferRange];
+    if (range.location == NSNotFound) {
+      isCloseDelimiter = YES;
+      range = [content rangeOfData:closeDelimiter options:0 range:remainingBufferRange];
+    }
+
+    if (range.location == NSNotFound) {
+      if (currentHeaders == nil) {
+        // Check for the headers delimiter.
+        NSData *headersMarker = [CRLF CRLF dataUsingEncoding:NSUTF8StringEncoding];
+        NSRange headersRange = [content rangeOfData:headersMarker options:0 range:remainingBufferRange];
+        if (headersRange.location != NSNotFound) {
+          NSData *headersData = [content subdataWithRange:NSMakeRange(chunkStart, headersRange.location - chunkStart)];
+          currentHeadersLength = headersData.length;
+          currentHeaders = [self parseHeaders:headersData];
+        }
+      } else {
+        // When headers are loaded start sending progress callbacks.
+        [self emitProgress:currentHeaders
+             contentLength:content.length - currentHeadersLength
+                     final:NO
+                  callback:progressCallback];
+      }
+
+      bytesSeen = content.length;
+      NSInteger bytesRead = [_stream read:buffer maxLength:bufferLen];
+      if (bytesRead <= 0 || _stream.streamError) {
+        return NO;
+      }
+      [content appendBytes:buffer length:bytesRead];
+      continue;
+    }
+
+    NSInteger chunkEnd = range.location;
+    NSInteger length = chunkEnd - chunkStart;
+    bytesSeen = chunkEnd;
+
+    // Ignore preamble
+    if (chunkStart > 0) {
+      NSData *chunk = [content subdataWithRange:NSMakeRange(chunkStart, length)];
+      [self emitProgress:currentHeaders
+           contentLength:chunk.length - currentHeadersLength
+                   final:YES
+                callback:progressCallback];
+      [self emitChunk:chunk headers:currentHeaders callback:callback done:isCloseDelimiter];
+      currentHeaders = nil;
+      currentHeadersLength = 0;
+    }
+
+    if (isCloseDelimiter) {
+      return YES;
+    }
+
+    chunkStart = chunkEnd + delimiter.length;
+  }
+}
+
+@end

node_modules/react-native/React/Base/RCTNullability.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>
+
+typedef NS_ENUM(NSUInteger, RCTNullability) {
+  RCTNullabilityUnspecified,
+  RCTNullable,
+  RCTNonnullable,
+};

node_modules/react-native/React/Base/RCTParserUtils.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/RCTDefines.h>
+
+@interface RCTParserUtils : NSObject
+
+/**
+ * Generic utility functions for parsing Objective-C source code.
+ */
+RCT_EXTERN BOOL RCTReadChar(const char **input, char c);
+RCT_EXTERN BOOL RCTReadString(const char **input, const char *string);
+RCT_EXTERN void RCTSkipWhitespace(const char **input);
+RCT_EXTERN BOOL RCTParseSelectorIdentifier(const char **input, NSString **string);
+RCT_EXTERN BOOL RCTParseArgumentIdentifier(const char **input, NSString **string);
+
+/**
+ * Parse an Objective-C type into a form that can be used by RCTConvert.
+ * This doesn't really belong here, but it's used by both RCTConvert and
+ * RCTModuleMethod, which makes it difficult to find a better home for it.
+ */
+RCT_EXTERN NSString *RCTParseType(const char **input);
+
+@end

node_modules/react-native/React/Base/RCTParserUtils.m

@@ -0,0 +1,143 @@
+/**
+ * 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 "RCTParserUtils.h"
+
+#import "RCTLog.h"
+
+@implementation RCTParserUtils
+
+BOOL RCTReadChar(const char **input, char c)
+{
+  if (**input == c) {
+    (*input)++;
+    return YES;
+  }
+  return NO;
+}
+
+BOOL RCTReadString(const char **input, const char *string)
+{
+  int i;
+  for (i = 0; string[i] != 0; i++) {
+    if (string[i] != (*input)[i]) {
+      return NO;
+    }
+  }
+  *input += i;
+  return YES;
+}
+
+void RCTSkipWhitespace(const char **input)
+{
+  while (isspace(**input)) {
+    (*input)++;
+  }
+}
+
+static BOOL RCTIsIdentifierHead(const char c)
+{
+  return isalpha(c) || c == '_';
+}
+
+static BOOL RCTIsIdentifierTail(const char c)
+{
+  return isalnum(c) || c == '_';
+}
+
+BOOL RCTParseArgumentIdentifier(const char **input, NSString **string)
+{
+  const char *start = *input;
+
+  do {
+    if (!RCTIsIdentifierHead(**input)) {
+      return NO;
+    }
+    (*input)++;
+
+    while (RCTIsIdentifierTail(**input)) {
+      (*input)++;
+    }
+
+  // allow namespace resolution operator
+  } while (RCTReadString(input, "::"));
+
+  if (string) {
+    *string = [[NSString alloc] initWithBytes:start
+                                       length:(NSInteger)(*input - start)
+                                     encoding:NSASCIIStringEncoding];
+  }
+  return YES;
+}
+
+BOOL RCTParseSelectorIdentifier(const char **input, NSString **string)
+{
+  const char *start = *input;
+  if (!RCTIsIdentifierHead(**input)) {
+    return NO;
+  }
+  (*input)++;
+  while (RCTIsIdentifierTail(**input)) {
+    (*input)++;
+  }
+  if (string) {
+    *string = [[NSString alloc] initWithBytes:start
+                                       length:(NSInteger)(*input - start)
+                                     encoding:NSASCIIStringEncoding];
+  }
+  return YES;
+}
+
+static BOOL RCTIsCollectionType(NSString *type)
+{
+  static NSSet *collectionTypes;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    collectionTypes = [[NSSet alloc] initWithObjects:
+                       @"NSArray", @"NSSet", @"NSDictionary", nil];
+  });
+  return [collectionTypes containsObject:type];
+}
+
+NSString *RCTParseType(const char **input)
+{
+  NSString *type;
+  RCTParseArgumentIdentifier(input, &type);
+  RCTSkipWhitespace(input);
+  if (RCTReadChar(input, '<')) {
+    RCTSkipWhitespace(input);
+    NSString *subtype = RCTParseType(input);
+    if (RCTIsCollectionType(type)) {
+      if ([type isEqualToString:@"NSDictionary"]) {
+        // Dictionaries have both a key *and* value type, but the key type has
+        // to be a string for JSON, so we only care about the value type
+        if (RCT_DEBUG && ![subtype isEqualToString:@"NSString"]) {
+          RCTLogError(@"%@ is not a valid key type for a JSON dictionary", subtype);
+        }
+        RCTSkipWhitespace(input);
+        RCTReadChar(input, ',');
+        RCTSkipWhitespace(input);
+        subtype = RCTParseType(input);
+      }
+      if (![subtype isEqualToString:@"id"]) {
+        type = [type stringByReplacingCharactersInRange:(NSRange){0, 2 /* "NS" */}
+                                             withString:subtype];
+      }
+    } else {
+      // It's a protocol rather than a generic collection - ignore it
+    }
+    RCTSkipWhitespace(input);
+    RCTReadChar(input, '>');
+  }
+  RCTSkipWhitespace(input);
+  if (!RCTReadChar(input, '*')) {
+    RCTReadChar(input, '&');
+  }
+  return type;
+}
+
+@end

node_modules/react-native/React/Base/RCTPerformanceLogger.h

@@ -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 <Foundation/Foundation.h>
+
+typedef NS_ENUM(NSUInteger, RCTPLTag) {
+  RCTPLScriptDownload = 0,
+  RCTPLScriptExecution,
+  RCTPLRAMBundleLoad,
+  RCTPLRAMStartupCodeSize,
+  RCTPLRAMStartupNativeRequires,
+  RCTPLRAMStartupNativeRequiresCount,
+  RCTPLRAMNativeRequires,
+  RCTPLRAMNativeRequiresCount,
+  RCTPLNativeModuleInit,
+  RCTPLNativeModuleMainThread,
+  RCTPLNativeModulePrepareConfig,
+  RCTPLNativeModuleInjectConfig,
+  RCTPLNativeModuleMainThreadUsesCount,
+  RCTPLJSCWrapperOpenLibrary,
+  RCTPLJSCExecutorSetup,
+  RCTPLBridgeStartup,
+  RCTPLTTI,
+  RCTPLBundleSize,
+  RCTPLSize
+};
+
+@interface RCTPerformanceLogger : NSObject
+
+/**
+ * Starts measuring a metric with the given tag.
+ * Overrides previous value if the measurement has been already started.
+ * If RCTProfile is enabled it also begins appropriate async event.
+ * All work is scheduled on the background queue so this doesn't block current thread.
+ */
+- (void)markStartForTag:(RCTPLTag)tag;
+
+/**
+ * Stops measuring a metric with given tag.
+ * Checks if RCTPerformanceLoggerStart() has been called before
+ * and doesn't do anything and log a message if it hasn't.
+ * If RCTProfile is enabled it also ends appropriate async event.
+ * All work is scheduled on the background queue so this doesn't block current thread.
+ */
+- (void)markStopForTag:(RCTPLTag)tag;
+
+/**
+ * Sets given value for a metric with given tag.
+ * All work is scheduled on the background queue so this doesn't block current thread.
+ */
+- (void)setValue:(int64_t)value forTag:(RCTPLTag)tag;
+
+/**
+ * Adds given value to the current value for a metric with given tag.
+ * All work is scheduled on the background queue so this doesn't block current thread.
+ */
+- (void)addValue:(int64_t)value forTag:(RCTPLTag)tag;
+
+/**
+ * Starts an additional measurement for a metric with given tag.
+ * It doesn't override previous measurement, instead it'll append a new value
+ * to the old one.
+ * All work is scheduled on the background queue so this doesn't block current thread.
+ */
+- (void)appendStartForTag:(RCTPLTag)tag;
+
+/**
+ * Stops measurement and appends the result to the metric with given tag.
+ * Checks if RCTPerformanceLoggerAppendStart() has been called before
+ * and doesn't do anything and log a message if it hasn't.
+ * All work is scheduled on the background queue so this doesn't block current thread.
+ */
+- (void)appendStopForTag:(RCTPLTag)tag;
+
+/**
+ * Returns an array with values for all tags.
+ * Use RCTPLTag to go over the array, there's a pair of values
+ * for each tag: start and stop (with indexes 2 * tag and 2 * tag + 1).
+ */
+- (NSArray<NSNumber *> *)valuesForTags;
+
+/**
+ * Returns a duration in ms (stop_time - start_time) for given RCTPLTag.
+ */
+- (int64_t)durationForTag:(RCTPLTag)tag;
+
+/**
+ * Returns a value for given RCTPLTag.
+ */
+- (int64_t)valueForTag:(RCTPLTag)tag;
+
+/**
+ * Returns an array with values for all tags.
+ * Use RCTPLTag to go over the array.
+ */
+- (NSArray<NSString *> *)labelsForTags;
+
+@end

node_modules/react-native/React/Base/RCTPerformanceLogger.m

@@ -0,0 +1,129 @@
+/**
+ * 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 <QuartzCore/QuartzCore.h>
+
+#import "RCTPerformanceLogger.h"
+#import "RCTRootView.h"
+#import "RCTLog.h"
+#import "RCTProfile.h"
+
+@interface RCTPerformanceLogger ()
+{
+  int64_t _data[RCTPLSize][2];
+  NSUInteger _cookies[RCTPLSize];
+}
+
+@property (nonatomic, copy) NSArray<NSString *> *labelsForTags;
+
+@end
+
+@implementation RCTPerformanceLogger
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _labelsForTags = @[
+      @"ScriptDownload",
+      @"ScriptExecution",
+      @"RAMBundleLoad",
+      @"RAMStartupCodeSize",
+      @"RAMStartupNativeRequires",
+      @"RAMStartupNativeRequiresCount",
+      @"RAMNativeRequires",
+      @"RAMNativeRequiresCount",
+      @"NativeModuleInit",
+      @"NativeModuleMainThread",
+      @"NativeModulePrepareConfig",
+      @"NativeModuleInjectConfig",
+      @"NativeModuleMainThreadUsesCount",
+      @"JSCWrapperOpenLibrary",
+      @"JSCExecutorSetup",
+      @"BridgeStartup",
+      @"RootViewTTI",
+      @"BundleSize",
+    ];
+  }
+  return self;
+}
+
+- (void)markStartForTag:(RCTPLTag)tag
+{
+#if RCT_PROFILE
+  if (RCTProfileIsProfiling()) {
+    NSString *label = _labelsForTags[tag];
+    _cookies[tag] = RCTProfileBeginAsyncEvent(RCTProfileTagAlways, label, nil);
+  }
+#endif
+  _data[tag][0] = CACurrentMediaTime() * 1000;
+  _data[tag][1] = 0;
+}
+
+
+- (void)markStopForTag:(RCTPLTag)tag
+{
+#if RCT_PROFILE
+  if (RCTProfileIsProfiling()) {
+    NSString *label =_labelsForTags[tag];
+    RCTProfileEndAsyncEvent(RCTProfileTagAlways, @"native", _cookies[tag], label, @"RCTPerformanceLogger");
+  }
+#endif
+  if (_data[tag][0] != 0 && _data[tag][1] == 0) {
+    _data[tag][1] = CACurrentMediaTime() * 1000;
+  } else {
+    RCTLogInfo(@"Unbalanced calls start/end for tag %li", (unsigned long)tag);
+  }
+}
+
+- (void)setValue:(int64_t)value forTag:(RCTPLTag)tag
+{
+  _data[tag][0] = 0;
+  _data[tag][1] = value;
+}
+
+- (void)addValue:(int64_t)value forTag:(RCTPLTag)tag
+{
+  _data[tag][0] = 0;
+  _data[tag][1] += value;
+}
+
+- (void)appendStartForTag:(RCTPLTag)tag
+{
+  _data[tag][0] = CACurrentMediaTime() * 1000;
+}
+
+- (void)appendStopForTag:(RCTPLTag)tag
+{
+  if (_data[tag][0] != 0) {
+    _data[tag][1] += CACurrentMediaTime() * 1000 - _data[tag][0];
+    _data[tag][0] = 0;
+  } else {
+    RCTLogInfo(@"Unbalanced calls start/end for tag %li", (unsigned long)tag);
+  }
+}
+
+- (NSArray<NSNumber *> *)valuesForTags
+{
+  NSMutableArray *result = [NSMutableArray array];
+  for (NSUInteger index = 0; index < RCTPLSize; index++) {
+    [result addObject:@(_data[index][0])];
+    [result addObject:@(_data[index][1])];
+  }
+  return result;
+}
+
+- (int64_t)durationForTag:(RCTPLTag)tag
+{
+  return _data[tag][1] - _data[tag][0];
+}
+
+- (int64_t)valueForTag:(RCTPLTag)tag
+{
+  return _data[tag][1];
+}
+
+@end

node_modules/react-native/React/Base/RCTPlatform.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 RCTPlatform : NSObject <RCTBridgeModule>
+
+@end

node_modules/react-native/React/Base/RCTPlatform.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 "RCTPlatform.h"
+
+#import <UIKit/UIKit.h>
+
+#import "RCTUtils.h"
+#import "RCTVersion.h"
+
+static NSString *interfaceIdiom(UIUserInterfaceIdiom idiom) {
+  switch(idiom) {
+    case UIUserInterfaceIdiomPhone:
+      return @"phone";
+    case UIUserInterfaceIdiomPad:
+      return @"pad";
+    case UIUserInterfaceIdiomTV:
+      return @"tv";
+    case UIUserInterfaceIdiomCarPlay:
+      return @"carplay";
+    default:
+      return @"unknown";
+  }
+}
+
+@implementation RCTPlatform
+
+RCT_EXPORT_MODULE(PlatformConstants)
+
++ (BOOL)requiresMainQueueSetup
+{
+  return YES;
+}
+
+- (NSDictionary<NSString *, id> *)constantsToExport
+{
+  UIDevice *device = [UIDevice currentDevice];
+  return @{
+    @"forceTouchAvailable": @(RCTForceTouchAvailable()),
+    @"osVersion": [device systemVersion],
+    @"systemName": [device systemName],
+    @"interfaceIdiom": interfaceIdiom([device userInterfaceIdiom]),
+    @"isTesting": @(RCTRunningInTestEnvironment()),
+    @"reactNativeVersion": RCTGetReactNativeVersion(),
+  };
+}
+
+@end

node_modules/react-native/React/Base/RCTReloadCommand.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 <Foundation/Foundation.h>
+
+#import <React/RCTDefines.h>
+
+@protocol RCTReloadListener
+- (void)didReceiveReloadCommand;
+@end
+
+/** Registers a weakly-held observer of the Command+R reload key command. */
+RCT_EXTERN void RCTRegisterReloadCommandListener(id<RCTReloadListener> listener);
+
+/** Triggers a reload for all current listeners. You shouldn't need to use this directly in most cases. */
+RCT_EXTERN void RCTTriggerReloadCommandListeners(void);

node_modules/react-native/React/Base/RCTReloadCommand.m

@@ -0,0 +1,41 @@
+/**
+ * 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 "RCTReloadCommand.h"
+
+#import "RCTAssert.h"
+#import "RCTKeyCommands.h"
+
+/** main queue only */
+static NSHashTable<id<RCTReloadListener>> *listeners;
+
+void RCTRegisterReloadCommandListener(id<RCTReloadListener> listener)
+{
+  RCTAssertMainQueue(); // because registerKeyCommandWithInput: must be called on the main thread
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    listeners = [NSHashTable weakObjectsHashTable];
+    [[RCTKeyCommands sharedInstance] registerKeyCommandWithInput:@"r"
+                                                   modifierFlags:UIKeyModifierCommand
+                                                          action:
+     ^(__unused UIKeyCommand *command) {
+       RCTTriggerReloadCommandListeners();
+     }];
+  });
+  [listeners addObject:listener];
+}
+
+void RCTTriggerReloadCommandListeners(void)
+{
+  RCTAssertMainQueue();
+  // Copy to protect against mutation-during-enumeration.
+  // If listeners hasn't been initialized yet we get nil, which works just fine.
+  NSArray<id<RCTReloadListener>> *copiedListeners = [listeners allObjects];
+  for (id<RCTReloadListener> l in copiedListeners) {
+    [l didReceiveReloadCommand];
+  }
+}

node_modules/react-native/React/Base/RCTRootContentView.h

@@ -0,0 +1,32 @@
+/**
+ * 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/RCTInvalidating.h>
+#import <React/RCTRootView.h>
+#import <React/RCTView.h>
+
+@class RCTBridge;
+@class RCTTouchHandler;
+
+@interface RCTRootContentView : RCTView <RCTInvalidating>
+
+@property (nonatomic, readonly, weak) RCTBridge *bridge;
+@property (nonatomic, readonly, assign) BOOL contentHasAppeared;
+@property (nonatomic, readonly, strong) RCTTouchHandler *touchHandler;
+@property (nonatomic, readonly, assign) CGSize availableSize;
+
+@property (nonatomic, assign) BOOL passThroughTouches;
+@property (nonatomic, assign) RCTRootViewSizeFlexibility sizeFlexibility;
+
+- (instancetype)initWithFrame:(CGRect)frame
+                       bridge:(RCTBridge *)bridge
+                     reactTag:(NSNumber *)reactTag
+               sizeFlexiblity:(RCTRootViewSizeFlexibility)sizeFlexibility NS_DESIGNATED_INITIALIZER;
+
+@end

node_modules/react-native/React/Base/RCTRootContentView.m

@@ -0,0 +1,109 @@
+/**
+ * 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 "RCTRootContentView.h"
+
+#import "RCTBridge.h"
+#import "RCTPerformanceLogger.h"
+#import "RCTRootView.h"
+#import "RCTRootViewInternal.h"
+#import "RCTTouchHandler.h"
+#import "RCTUIManager.h"
+#import "UIView+React.h"
+
+@implementation RCTRootContentView
+
+- (instancetype)initWithFrame:(CGRect)frame
+                       bridge:(RCTBridge *)bridge
+                     reactTag:(NSNumber *)reactTag
+               sizeFlexiblity:(RCTRootViewSizeFlexibility)sizeFlexibility
+{
+  if ((self = [super initWithFrame:frame])) {
+    _bridge = bridge;
+    self.reactTag = reactTag;
+    _sizeFlexibility = sizeFlexibility;
+    _touchHandler = [[RCTTouchHandler alloc] initWithBridge:_bridge];
+    [_touchHandler attachToView:self];
+    [_bridge.uiManager registerRootView:self];
+  }
+  return self;
+}
+
+RCT_NOT_IMPLEMENTED(-(instancetype)initWithFrame:(CGRect)frame)
+RCT_NOT_IMPLEMENTED(-(instancetype)initWithCoder:(nonnull NSCoder *)aDecoder)
+
+- (void)layoutSubviews
+{
+  [super layoutSubviews];
+  [self updateAvailableSize];
+}
+
+- (void)insertReactSubview:(UIView *)subview atIndex:(NSInteger)atIndex
+{
+  [super insertReactSubview:subview atIndex:atIndex];
+  [_bridge.performanceLogger markStopForTag:RCTPLTTI];
+  dispatch_async(dispatch_get_main_queue(), ^{
+    if (!self->_contentHasAppeared) {
+      self->_contentHasAppeared = YES;
+      [[NSNotificationCenter defaultCenter] postNotificationName:RCTContentDidAppearNotification
+                                                          object:self.superview];
+    }
+  });
+}
+
+- (void)setSizeFlexibility:(RCTRootViewSizeFlexibility)sizeFlexibility
+{
+  if (_sizeFlexibility == sizeFlexibility) {
+    return;
+  }
+
+  _sizeFlexibility = sizeFlexibility;
+  [self setNeedsLayout];
+}
+
+- (CGSize)availableSize
+{
+  CGSize size = self.bounds.size;
+  return CGSizeMake(
+      _sizeFlexibility & RCTRootViewSizeFlexibilityWidth ? INFINITY : size.width,
+      _sizeFlexibility & RCTRootViewSizeFlexibilityHeight ? INFINITY : size.height
+    );
+}
+
+- (void)updateAvailableSize
+{
+  if (!self.reactTag || !_bridge.isValid) {
+    return;
+  }
+
+  [_bridge.uiManager setAvailableSize:self.availableSize forRootView:self];
+}
+
+- (UIView *)hitTest:(CGPoint)point withEvent:(UIEvent *)event
+{
+  // The root content view itself should never receive touches
+  UIView *hitView = [super hitTest:point withEvent:event];
+  if (_passThroughTouches && hitView == self) {
+    return nil;
+  }
+  return hitView;
+}
+
+- (void)invalidate
+{
+  if (self.userInteractionEnabled) {
+    self.userInteractionEnabled = NO;
+    [(RCTRootView *)self.superview contentViewInvalidated];
+
+    [_bridge enqueueJSCall:@"AppRegistry"
+                    method:@"unmountApplicationComponentAtRootTag"
+                      args:@[self.reactTag]
+                completion:NULL];
+  }
+}
+
+@end

node_modules/react-native/React/Base/RCTRootView.h

@@ -0,0 +1,163 @@
+/**
+ * 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>
+
+@protocol RCTRootViewDelegate;
+
+/**
+ * This enum is used to define size flexibility type of the root view.
+ * If a dimension is flexible, the view will recalculate that dimension
+ * so the content fits. Recalculations are performed when the root's frame,
+ * size flexibility mode or content size changes. After a recalculation,
+ * rootViewDidChangeIntrinsicSize method of the RCTRootViewDelegate will be called.
+ */
+typedef NS_ENUM(NSInteger, RCTRootViewSizeFlexibility) {
+  RCTRootViewSizeFlexibilityNone           = 0,
+  RCTRootViewSizeFlexibilityWidth          = 1 << 0,
+  RCTRootViewSizeFlexibilityHeight         = 1 << 1,
+  RCTRootViewSizeFlexibilityWidthAndHeight = RCTRootViewSizeFlexibilityWidth | RCTRootViewSizeFlexibilityHeight,
+};
+
+/**
+ * This notification is sent when the first subviews are added to the root view
+ * after the application has loaded. This is used to hide the `loadingView`, and
+ * is a good indicator that the application is ready to use.
+ */
+extern NSString *const RCTContentDidAppearNotification;
+
+/**
+ * Native view used to host React-managed views within the app. Can be used just
+ * like any ordinary UIView. You can have multiple RCTRootViews on screen at
+ * once, all controlled by the same JavaScript application.
+ */
+@interface RCTRootView : UIView
+
+/**
+ * - Designated initializer -
+ */
+- (instancetype)initWithBridge:(RCTBridge *)bridge
+                    moduleName:(NSString *)moduleName
+             initialProperties:(NSDictionary *)initialProperties NS_DESIGNATED_INITIALIZER;
+
+/**
+ * - Convenience initializer -
+ * A bridge will be created internally.
+ * This initializer is intended to be used when the app has a single RCTRootView,
+ * otherwise create an `RCTBridge` and pass it in via `initWithBridge:moduleName:`
+ * to all the instances.
+ */
+- (instancetype)initWithBundleURL:(NSURL *)bundleURL
+                       moduleName:(NSString *)moduleName
+                initialProperties:(NSDictionary *)initialProperties
+                    launchOptions:(NSDictionary *)launchOptions;
+
+
+/**
+ * The name of the JavaScript module to execute within the
+ * specified scriptURL (required). Setting this will not have
+ * any immediate effect, but it must be done prior to loading
+ * the script.
+ */
+@property (nonatomic, copy, readonly) NSString *moduleName;
+
+/**
+ * The bridge used by the root view. Bridges can be shared between multiple
+ * root views, so you can use this property to initialize another RCTRootView.
+ */
+@property (nonatomic, strong, readonly) RCTBridge *bridge;
+
+/**
+ * The properties to apply to the view. Use this property to update
+ * application properties and rerender the view. Initialized with
+ * initialProperties argument of the initializer.
+ *
+ * Set this property only on the main thread.
+ */
+@property (nonatomic, copy, readwrite) NSDictionary *appProperties;
+
+/**
+ * The size flexibility mode of the root view.
+ */
+@property (nonatomic, assign) RCTRootViewSizeFlexibility sizeFlexibility;
+
+/**
+ * The delegate that handles intrinsic size updates.
+ */
+@property (nonatomic, weak) id<RCTRootViewDelegate> delegate;
+
+/**
+ * The backing view controller of the root view.
+ */
+@property (nonatomic, weak) UIViewController *reactViewController;
+
+/**
+ * The React-managed contents view of the root view.
+ */
+@property (nonatomic, strong, readonly) UIView *contentView;
+
+/**
+ * A view to display while the JavaScript is loading, so users aren't presented
+ * with a blank screen. By default this is nil, but you can override it with
+ * (for example) a UIActivityIndicatorView or a placeholder image.
+ */
+@property (nonatomic, strong) UIView *loadingView;
+
+/**
+ * Calling this will result in emitting a "touches cancelled" event to js,
+ * which effectively cancels all js "gesture recognizers" such as touchable components
+ * (unless they explicitely ignore cancellation events, but no one should do that).
+ *
+ * This API is exposed for integration purposes where you embed RN rootView
+ * in a native view with a native gesture recognizer,
+ * whose activation should prevent any in-flight js "gesture recognizer" from activating.
+ *
+ * An example would be RN rootView embedded in an UIScrollView.
+ * When you touch down on a touchable component and drag your finger up,
+ * you don't want any touch to be registered as soon as the UIScrollView starts scrolling.
+ *
+ * Note that this doesn't help with tapping on a touchable element that is being scrolled,
+ * unless you can call cancelTouches exactly between "touches began" and "touches ended" events.
+ * This is a reason why this API may be soon removed in favor of a better solution.
+ */
+- (void)cancelTouches;
+
+/**
+ * When set, any touches on the RCTRootView that are not matched up to any of the child
+ * views will be passed to siblings of the RCTRootView. See -[UIView hitTest:withEvent:]
+ * for details on iOS hit testing.
+ *
+ * Enable this to support a semi-transparent RN view that occupies the whole screen but
+ * has visible content below it that the user can interact with.
+ *
+ * The default value is NO.
+ */
+@property (nonatomic, assign) BOOL passThroughTouches;
+
+/**
+ * Timings for hiding the loading view after the content has loaded. Both of
+ * these values default to 0.25 seconds.
+ */
+@property (nonatomic, assign) NSTimeInterval loadingViewFadeDelay;
+@property (nonatomic, assign) NSTimeInterval loadingViewFadeDuration;
+
+@end
+
+@interface RCTRootView (Deprecated)
+
+/**
+ * The intrinsic size of the root view's content. This is set right before the
+ * `rootViewDidChangeIntrinsicSize` method of `RCTRootViewDelegate` is called.
+ * This property is deprecated and will be removed in next releases.
+ * Use UIKit `intrinsicContentSize` propery instead.
+ */
+@property (readonly, nonatomic, assign) CGSize intrinsicSize
+__deprecated_msg("Use `intrinsicContentSize` instead.");
+
+@end

node_modules/react-native/React/Base/RCTRootView.m

@@ -0,0 +1,390 @@
+/**
+ * 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 "RCTRootView.h"
+#import "RCTRootViewDelegate.h"
+#import "RCTRootViewInternal.h"
+
+#import <objc/runtime.h>
+
+#import "RCTAssert.h"
+#import "RCTBridge.h"
+#import "RCTBridge+Private.h"
+#import "RCTEventDispatcher.h"
+#import "RCTKeyCommands.h"
+#import "RCTLog.h"
+#import "RCTPerformanceLogger.h"
+#import "RCTProfile.h"
+#import "RCTRootContentView.h"
+#import "RCTTouchHandler.h"
+#import "RCTUIManager.h"
+#import "RCTUIManagerUtils.h"
+#import "RCTUtils.h"
+#import "RCTView.h"
+#import "UIView+React.h"
+
+#if TARGET_OS_TV
+#import "RCTTVRemoteHandler.h"
+#import "RCTTVNavigationEventEmitter.h"
+#endif
+
+NSString *const RCTContentDidAppearNotification = @"RCTContentDidAppearNotification";
+
+@interface RCTUIManager (RCTRootView)
+
+- (NSNumber *)allocateRootTag;
+
+@end
+
+@implementation RCTRootView
+{
+  RCTBridge *_bridge;
+  NSString *_moduleName;
+  RCTRootContentView *_contentView;
+  BOOL _passThroughTouches;
+  CGSize _intrinsicContentSize;
+}
+
+- (instancetype)initWithBridge:(RCTBridge *)bridge
+                    moduleName:(NSString *)moduleName
+             initialProperties:(NSDictionary *)initialProperties
+{
+  RCTAssertMainQueue();
+  RCTAssert(bridge, @"A bridge instance is required to create an RCTRootView");
+  RCTAssert(moduleName, @"A moduleName is required to create an RCTRootView");
+
+  RCT_PROFILE_BEGIN_EVENT(RCTProfileTagAlways, @"-[RCTRootView init]", nil);
+  if (!bridge.isLoading) {
+    [bridge.performanceLogger markStartForTag:RCTPLTTI];
+  }
+
+  if (self = [super initWithFrame:CGRectZero]) {
+    self.backgroundColor = [UIColor whiteColor];
+
+    _bridge = bridge;
+    _moduleName = moduleName;
+    _appProperties = [initialProperties copy];
+    _loadingViewFadeDelay = 0.25;
+    _loadingViewFadeDuration = 0.25;
+    _sizeFlexibility = RCTRootViewSizeFlexibilityNone;
+
+    [[NSNotificationCenter defaultCenter] addObserver:self
+                                             selector:@selector(bridgeDidReload)
+                                                 name:RCTJavaScriptWillStartLoadingNotification
+                                               object:_bridge];
+
+    [[NSNotificationCenter defaultCenter] addObserver:self
+                                             selector:@selector(javaScriptDidLoad:)
+                                                 name:RCTJavaScriptDidLoadNotification
+                                               object:_bridge];
+
+    [[NSNotificationCenter defaultCenter] addObserver:self
+                                             selector:@selector(hideLoadingView)
+                                                 name:RCTContentDidAppearNotification
+                                               object:self];
+
+#if TARGET_OS_TV
+    self.tvRemoteHandler = [RCTTVRemoteHandler new];
+    for (NSString *key in [self.tvRemoteHandler.tvRemoteGestureRecognizers allKeys]) {
+      [self addGestureRecognizer:self.tvRemoteHandler.tvRemoteGestureRecognizers[key]];
+    }
+#endif
+
+    [self showLoadingView];
+
+    // Immediately schedule the application to be started.
+    // (Sometimes actual `_bridge` is already batched bridge here.)
+    [self bundleFinishedLoading:([_bridge batchedBridge] ?: _bridge)];
+  }
+
+  RCT_PROFILE_END_EVENT(RCTProfileTagAlways, @"");
+
+  return self;
+}
+
+- (instancetype)initWithBundleURL:(NSURL *)bundleURL
+                       moduleName:(NSString *)moduleName
+                initialProperties:(NSDictionary *)initialProperties
+                    launchOptions:(NSDictionary *)launchOptions
+{
+  RCTBridge *bridge = [[RCTBridge alloc] initWithBundleURL:bundleURL
+                                            moduleProvider:nil
+                                             launchOptions:launchOptions];
+
+  return [self initWithBridge:bridge moduleName:moduleName initialProperties:initialProperties];
+}
+
+RCT_NOT_IMPLEMENTED(- (instancetype)initWithFrame:(CGRect)frame)
+RCT_NOT_IMPLEMENTED(- (instancetype)initWithCoder:(NSCoder *)aDecoder)
+
+#if TARGET_OS_TV
+- (UIView *)preferredFocusedView
+{
+  if (self.reactPreferredFocusedView) {
+    return self.reactPreferredFocusedView;
+  }
+  return [super preferredFocusedView];
+}
+#endif
+
+#pragma mark - passThroughTouches
+
+- (BOOL)passThroughTouches
+{
+  return _contentView.passThroughTouches;
+}
+
+- (void)setPassThroughTouches:(BOOL)passThroughTouches
+{
+  _passThroughTouches = passThroughTouches;
+  _contentView.passThroughTouches = passThroughTouches;
+}
+
+#pragma mark - Layout
+
+- (CGSize)sizeThatFits:(CGSize)size
+{
+  CGSize fitSize = _intrinsicContentSize;
+  CGSize currentSize = self.bounds.size;
+
+  // Following the current `size` and current `sizeFlexibility` policy.
+  fitSize = CGSizeMake(
+      _sizeFlexibility & RCTRootViewSizeFlexibilityWidth ? fitSize.width : currentSize.width,
+      _sizeFlexibility & RCTRootViewSizeFlexibilityHeight ? fitSize.height : currentSize.height
+    );
+
+  // Following the given size constraints.
+  fitSize = CGSizeMake(
+      MIN(size.width, fitSize.width),
+      MIN(size.height, fitSize.height)
+    );
+
+  return fitSize;
+}
+
+- (void)layoutSubviews
+{
+  [super layoutSubviews];
+  _contentView.frame = self.bounds;
+  _loadingView.center = (CGPoint){
+    CGRectGetMidX(self.bounds),
+    CGRectGetMidY(self.bounds)
+  };
+}
+
+- (UIViewController *)reactViewController
+{
+  return _reactViewController ?: [super reactViewController];
+}
+
+- (BOOL)canBecomeFirstResponder
+{
+  return YES;
+}
+
+- (void)setLoadingView:(UIView *)loadingView
+{
+  _loadingView = loadingView;
+  if (!_contentView.contentHasAppeared) {
+    [self showLoadingView];
+  }
+}
+
+- (void)showLoadingView
+{
+  if (_loadingView && !_contentView.contentHasAppeared) {
+    _loadingView.hidden = NO;
+    [self addSubview:_loadingView];
+  }
+}
+
+- (void)hideLoadingView
+{
+  if (_loadingView.superview == self && _contentView.contentHasAppeared) {
+    if (_loadingViewFadeDuration > 0) {
+      dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(_loadingViewFadeDelay * NSEC_PER_SEC)),
+                     dispatch_get_main_queue(), ^{
+
+                       [UIView transitionWithView:self
+                                         duration:self->_loadingViewFadeDuration
+                                          options:UIViewAnimationOptionTransitionCrossDissolve
+                                       animations:^{
+                                         self->_loadingView.hidden = YES;
+                                       } completion:^(__unused BOOL finished) {
+                                         [self->_loadingView removeFromSuperview];
+                                       }];
+                     });
+    } else {
+      _loadingView.hidden = YES;
+      [_loadingView removeFromSuperview];
+    }
+  }
+}
+
+- (NSNumber *)reactTag
+{
+  RCTAssertMainQueue();
+  if (!super.reactTag) {
+    /**
+     * Every root view that is created must have a unique react tag.
+     * Numbering of these tags goes from 1, 11, 21, 31, etc
+     *
+     * NOTE: Since the bridge persists, the RootViews might be reused, so the
+     * react tag must be re-assigned every time a new UIManager is created.
+     */
+    self.reactTag = RCTAllocateRootViewTag();
+  }
+  return super.reactTag;
+}
+
+- (void)bridgeDidReload
+{
+  RCTAssertMainQueue();
+  // Clear the reactTag so it can be re-assigned
+  self.reactTag = nil;
+}
+
+- (void)javaScriptDidLoad:(NSNotification *)notification
+{
+  RCTAssertMainQueue();
+
+  // Use the (batched) bridge that's sent in the notification payload, so the
+  // RCTRootContentView is scoped to the right bridge
+  RCTBridge *bridge = notification.userInfo[@"bridge"];
+  if (bridge != _contentView.bridge) {
+    [self bundleFinishedLoading:bridge];
+  }
+}
+
+- (void)bundleFinishedLoading:(RCTBridge *)bridge
+{
+  RCTAssert(bridge != nil, @"Bridge cannot be nil");
+  if (!bridge.valid) {
+    return;
+  }
+
+  [_contentView removeFromSuperview];
+  _contentView = [[RCTRootContentView alloc] initWithFrame:self.bounds
+                                                    bridge:bridge
+                                                  reactTag:self.reactTag
+                                            sizeFlexiblity:_sizeFlexibility];
+  [self runApplication:bridge];
+
+  _contentView.passThroughTouches = _passThroughTouches;
+  [self insertSubview:_contentView atIndex:0];
+
+  if (_sizeFlexibility == RCTRootViewSizeFlexibilityNone) {
+    self.intrinsicContentSize = self.bounds.size;
+  }
+}
+
+- (void)runApplication:(RCTBridge *)bridge
+{
+  NSString *moduleName = _moduleName ?: @"";
+  NSDictionary *appParameters = @{
+    @"rootTag": _contentView.reactTag,
+    @"initialProps": _appProperties ?: @{},
+  };
+
+  RCTLogInfo(@"Running application %@ (%@)", moduleName, appParameters);
+  [bridge enqueueJSCall:@"AppRegistry"
+                 method:@"runApplication"
+                   args:@[moduleName, appParameters]
+             completion:NULL];
+}
+
+- (void)setSizeFlexibility:(RCTRootViewSizeFlexibility)sizeFlexibility
+{
+  if (_sizeFlexibility == sizeFlexibility) {
+    return;
+  }
+
+  _sizeFlexibility = sizeFlexibility;
+  [self setNeedsLayout];
+  _contentView.sizeFlexibility = _sizeFlexibility;
+}
+
+- (UIView *)hitTest:(CGPoint)point withEvent:(UIEvent *)event
+{
+  // The root view itself should never receive touches
+  UIView *hitView = [super hitTest:point withEvent:event];
+  if (self.passThroughTouches && hitView == self) {
+    return nil;
+  }
+  return hitView;
+}
+
+- (void)setAppProperties:(NSDictionary *)appProperties
+{
+  RCTAssertMainQueue();
+
+  if ([_appProperties isEqualToDictionary:appProperties]) {
+    return;
+  }
+
+  _appProperties = [appProperties copy];
+
+  if (_contentView && _bridge.valid && !_bridge.loading) {
+    [self runApplication:_bridge];
+  }
+}
+
+- (void)setIntrinsicContentSize:(CGSize)intrinsicContentSize
+{
+  BOOL oldSizeHasAZeroDimension = _intrinsicContentSize.height == 0 || _intrinsicContentSize.width == 0;
+  BOOL newSizeHasAZeroDimension = intrinsicContentSize.height == 0 || intrinsicContentSize.width == 0;
+  BOOL bothSizesHaveAZeroDimension = oldSizeHasAZeroDimension && newSizeHasAZeroDimension;
+
+  BOOL sizesAreEqual = CGSizeEqualToSize(_intrinsicContentSize, intrinsicContentSize);
+
+  _intrinsicContentSize = intrinsicContentSize;
+
+  [self invalidateIntrinsicContentSize];
+  [self.superview setNeedsLayout];
+
+  // Don't notify the delegate if the content remains invisible or its size has not changed
+  if (bothSizesHaveAZeroDimension || sizesAreEqual) {
+    return;
+  }
+
+  [_delegate rootViewDidChangeIntrinsicSize:self];
+}
+
+- (CGSize)intrinsicContentSize
+{
+  return _intrinsicContentSize;
+}
+
+- (void)contentViewInvalidated
+{
+  [_contentView removeFromSuperview];
+  _contentView = nil;
+  [self showLoadingView];
+}
+
+- (void)dealloc
+{
+  [[NSNotificationCenter defaultCenter] removeObserver:self];
+  [_contentView invalidate];
+}
+
+- (void)cancelTouches
+{
+  [[_contentView touchHandler] cancel];
+}
+
+@end
+
+@implementation RCTRootView (Deprecated)
+
+- (CGSize)intrinsicSize
+{
+  RCTLogWarn(@"Calling deprecated `[-RCTRootView intrinsicSize]`.");
+  return self.intrinsicContentSize;
+}
+
+@end

node_modules/react-native/React/Base/RCTRootViewDelegate.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>
+
+@class RCTRootView;
+
+@protocol RCTRootViewDelegate <NSObject>
+
+/**
+ * Called after the root view's intrinsic content size is changed.
+ *
+ * The method is not called when both old size and new size have
+ * a dimension that equals to zero.
+ *
+ * The delegate can use this callback to appropriately resize
+ * the root view's frame to fit the new intrinsic content view size,
+ * but usually it is not necessary because the root view will also call
+ * `setNeedsLayout` for its superview which in its turn will trigger relayout.
+ *
+ * The new intrinsic content size is available via the `intrinsicContentSize`
+ * propery of the root view. The view will not resize itself.
+ */
+- (void)rootViewDidChangeIntrinsicSize:(RCTRootView *)rootView;
+
+@end

node_modules/react-native/React/Base/RCTRootViewInternal.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/RCTRootView.h>
+
+@class RCTTVRemoteHandler;
+
+/**
+ * The interface provides a set of functions that allow other internal framework
+ * classes to change the RCTRootViews's internal state.
+ */
+@interface RCTRootView ()
+
+/**
+ * This setter should be used only by RCTUIManager on react root view
+ * intrinsic content size update.
+ */
+@property (readwrite, nonatomic, assign) CGSize intrinsicContentSize;
+
+/**
+ * TV remote gesture recognizers
+ */
+#if TARGET_OS_TV
+@property (nonatomic, strong) RCTTVRemoteHandler *tvRemoteHandler;
+@property (nonatomic, strong) UIView *reactPreferredFocusedView;
+#endif
+
+- (void)contentViewInvalidated;
+
+@end

node_modules/react-native/React/Base/RCTTVRemoteHandler.h

@@ -0,0 +1,32 @@
+/**
+ * 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>
+
+
+extern NSString *const RCTTVRemoteEventMenu;
+extern NSString *const RCTTVRemoteEventPlayPause;
+extern NSString *const RCTTVRemoteEventSelect;
+
+extern NSString *const RCTTVRemoteEventLongPlayPause;
+extern NSString *const RCTTVRemoteEventLongSelect;
+
+extern NSString *const RCTTVRemoteEventLeft;
+extern NSString *const RCTTVRemoteEventRight;
+extern NSString *const RCTTVRemoteEventUp;
+extern NSString *const RCTTVRemoteEventDown;
+
+extern NSString *const RCTTVRemoteEventSwipeLeft;
+extern NSString *const RCTTVRemoteEventSwipeRight;
+extern NSString *const RCTTVRemoteEventSwipeUp;
+extern NSString *const RCTTVRemoteEventSwipeDown;
+
+@interface RCTTVRemoteHandler : NSObject
+
+@property (nonatomic, copy, readonly) NSDictionary *tvRemoteGestureRecognizers;
+
+@end

node_modules/react-native/React/Base/RCTTVRemoteHandler.m

@@ -0,0 +1,212 @@
+/**
+ * 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 "RCTTVRemoteHandler.h"
+
+#import <UIKit/UIGestureRecognizerSubclass.h>
+
+#import "RCTAssert.h"
+#import "RCTBridge.h"
+#import "RCTEventDispatcher.h"
+#import "RCTLog.h"
+#import "RCTRootView.h"
+#import "RCTTVNavigationEventEmitter.h"
+#import "RCTUIManager.h"
+#import "RCTUtils.h"
+#import "RCTView.h"
+#import "UIView+React.h"
+
+#if __has_include("RCTDevMenu.h")
+#import "RCTDevMenu.h"
+#endif
+
+NSString *const RCTTVRemoteEventMenu = @"menu";
+NSString *const RCTTVRemoteEventPlayPause = @"playPause";
+NSString *const RCTTVRemoteEventSelect = @"select";
+
+NSString *const RCTTVRemoteEventLongPlayPause = @"longPlayPause";
+NSString *const RCTTVRemoteEventLongSelect = @"longSelect";
+
+NSString *const RCTTVRemoteEventLeft = @"left";
+NSString *const RCTTVRemoteEventRight = @"right";
+NSString *const RCTTVRemoteEventUp = @"up";
+NSString *const RCTTVRemoteEventDown = @"down";
+
+NSString *const RCTTVRemoteEventSwipeLeft = @"swipeLeft";
+NSString *const RCTTVRemoteEventSwipeRight = @"swipeRight";
+NSString *const RCTTVRemoteEventSwipeUp = @"swipeUp";
+NSString *const RCTTVRemoteEventSwipeDown = @"swipeDown";
+
+
+@implementation RCTTVRemoteHandler {
+  NSMutableDictionary<NSString *, UIGestureRecognizer *> *_tvRemoteGestureRecognizers;
+}
+
+- (instancetype)init
+{
+  if ((self = [super init])) {
+    _tvRemoteGestureRecognizers = [NSMutableDictionary dictionary];
+
+    // Recognizers for Apple TV remote buttons
+
+    // Play/Pause
+    [self addTapGestureRecognizerWithSelector:@selector(playPausePressed:)
+                                    pressType:UIPressTypePlayPause
+                                         name:RCTTVRemoteEventPlayPause];
+
+    // Menu
+    [self addTapGestureRecognizerWithSelector:@selector(menuPressed:)
+                                    pressType:UIPressTypeMenu
+                                         name:RCTTVRemoteEventMenu];
+
+    // Select
+    [self addTapGestureRecognizerWithSelector:@selector(selectPressed:)
+                                    pressType:UIPressTypeSelect
+                                         name:RCTTVRemoteEventSelect];
+
+    // Up
+    [self addTapGestureRecognizerWithSelector:@selector(swipedUp:)
+                                    pressType:UIPressTypeUpArrow
+                                         name:RCTTVRemoteEventUp];
+
+    // Down
+    [self addTapGestureRecognizerWithSelector:@selector(swipedDown:)
+                                    pressType:UIPressTypeDownArrow
+                                         name:RCTTVRemoteEventDown];
+
+    // Left
+    [self addTapGestureRecognizerWithSelector:@selector(swipedLeft:)
+                                    pressType:UIPressTypeLeftArrow
+                                         name:RCTTVRemoteEventLeft];
+
+    // Right
+    [self addTapGestureRecognizerWithSelector:@selector(swipedRight:)
+                                    pressType:UIPressTypeRightArrow
+                                         name:RCTTVRemoteEventRight];
+
+    // Recognizers for long button presses
+    // We don't intercept long menu press -- that's used by the system to go to the home screen
+
+    [self addLongPressGestureRecognizerWithSelector:@selector(longPlayPausePressed:)
+                                          pressType:UIPressTypePlayPause
+                                               name:RCTTVRemoteEventLongPlayPause];
+
+    [self addLongPressGestureRecognizerWithSelector:@selector(longSelectPressed:)
+                                          pressType:UIPressTypeSelect
+                                               name:RCTTVRemoteEventLongSelect];
+
+    // Recognizers for Apple TV remote trackpad swipes
+
+    // Up
+    [self addSwipeGestureRecognizerWithSelector:@selector(swipedUp:)
+                                      direction:UISwipeGestureRecognizerDirectionUp
+                                           name:RCTTVRemoteEventSwipeUp];
+
+    // Down
+    [self addSwipeGestureRecognizerWithSelector:@selector(swipedDown:)
+                                      direction:UISwipeGestureRecognizerDirectionDown
+                                           name:RCTTVRemoteEventSwipeDown];
+
+    // Left
+    [self addSwipeGestureRecognizerWithSelector:@selector(swipedLeft:)
+                                      direction:UISwipeGestureRecognizerDirectionLeft
+                                           name:RCTTVRemoteEventSwipeLeft];
+
+    // Right
+    [self addSwipeGestureRecognizerWithSelector:@selector(swipedRight:)
+                                      direction:UISwipeGestureRecognizerDirectionRight
+                                           name:RCTTVRemoteEventSwipeRight];
+
+  }
+
+  return self;
+}
+
+- (void)playPausePressed:(UIGestureRecognizer *)r
+{
+  [self sendAppleTVEvent:RCTTVRemoteEventPlayPause toView:r.view];
+}
+
+- (void)menuPressed:(UIGestureRecognizer *)r
+{
+  [self sendAppleTVEvent:RCTTVRemoteEventMenu toView:r.view];
+}
+
+- (void)selectPressed:(UIGestureRecognizer *)r
+{
+  [self sendAppleTVEvent:RCTTVRemoteEventSelect toView:r.view];
+}
+
+- (void)longPlayPausePressed:(UIGestureRecognizer *)r
+{
+  [self sendAppleTVEvent:RCTTVRemoteEventLongPlayPause toView:r.view];
+
+#if __has_include("RCTDevMenu.h") && RCT_DEV
+  // If shake to show is enabled on device, use long play/pause event to show dev menu
+  [[NSNotificationCenter defaultCenter] postNotificationName:RCTShowDevMenuNotification object:nil];
+#endif
+}
+
+- (void)longSelectPressed:(UIGestureRecognizer *)r
+{
+  [self sendAppleTVEvent:RCTTVRemoteEventLongSelect toView:r.view];
+}
+
+- (void)swipedUp:(UIGestureRecognizer *)r
+{
+  [self sendAppleTVEvent:RCTTVRemoteEventUp toView:r.view];
+}
+
+- (void)swipedDown:(UIGestureRecognizer *)r
+{
+  [self sendAppleTVEvent:RCTTVRemoteEventDown toView:r.view];
+}
+
+- (void)swipedLeft:(UIGestureRecognizer *)r
+{
+  [self sendAppleTVEvent:RCTTVRemoteEventLeft toView:r.view];
+}
+
+- (void)swipedRight:(UIGestureRecognizer *)r
+{
+  [self sendAppleTVEvent:RCTTVRemoteEventRight toView:r.view];
+}
+
+#pragma mark -
+
+- (void)addLongPressGestureRecognizerWithSelector:(nonnull SEL)selector pressType:(UIPressType)pressType name:(NSString *)name
+{
+  UILongPressGestureRecognizer *recognizer = [[UILongPressGestureRecognizer alloc] initWithTarget:self action:selector];
+  recognizer.allowedPressTypes = @[@(pressType)];
+
+  _tvRemoteGestureRecognizers[name] = recognizer;
+}
+
+- (void)addTapGestureRecognizerWithSelector:(nonnull SEL)selector pressType:(UIPressType)pressType name:(NSString *)name
+{
+  UITapGestureRecognizer *recognizer = [[UITapGestureRecognizer alloc] initWithTarget:self action:selector];
+  recognizer.allowedPressTypes = @[@(pressType)];
+
+  _tvRemoteGestureRecognizers[name] = recognizer;
+}
+
+- (void)addSwipeGestureRecognizerWithSelector:(nonnull SEL)selector direction:(UISwipeGestureRecognizerDirection)direction name:(NSString *)name
+{
+  UISwipeGestureRecognizer *recognizer = [[UISwipeGestureRecognizer alloc] initWithTarget:self action:selector];
+  recognizer.direction = direction;
+
+  _tvRemoteGestureRecognizers[name] = recognizer;
+}
+
+- (void)sendAppleTVEvent:(NSString *)eventType toView:(__unused UIView *)v
+{
+  [[NSNotificationCenter defaultCenter] postNotificationName:RCTTVNavigationEventNotification
+                                                      object:@{@"eventType":eventType}];
+}
+
+
+@end

node_modules/react-native/React/Base/RCTTouchEvent.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 <Foundation/Foundation.h>
+
+#import <React/RCTEventDispatcher.h>
+
+/**
+ * Represents a touch event, which may be composed of several touches (one for every finger).
+ * For more information on contents of passed data structures see RCTTouchHandler.
+ */
+@interface RCTTouchEvent : NSObject <RCTEvent>
+
+- (instancetype)initWithEventName:(NSString *)eventName
+                         reactTag:(NSNumber *)reactTag
+                     reactTouches:(NSArray<NSDictionary *> *)reactTouches
+                   changedIndexes:(NSArray<NSNumber *> *)changedIndexes
+                    coalescingKey:(uint16_t)coalescingKey NS_DESIGNATED_INITIALIZER;
+@end

node_modules/react-native/React/Base/RCTTouchEvent.m

@@ -0,0 +1,91 @@
+/**
+ * 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 "RCTTouchEvent.h"
+
+#import "RCTAssert.h"
+
+@implementation RCTTouchEvent
+{
+  NSArray<NSDictionary *> *_reactTouches;
+  NSArray<NSNumber *> *_changedIndexes;
+  uint16_t _coalescingKey;
+}
+
+@synthesize eventName = _eventName;
+@synthesize viewTag = _viewTag;
+
+- (instancetype)initWithEventName:(NSString *)eventName
+                         reactTag:(NSNumber *)reactTag
+                     reactTouches:(NSArray<NSDictionary *> *)reactTouches
+                   changedIndexes:(NSArray<NSNumber *> *)changedIndexes
+                    coalescingKey:(uint16_t)coalescingKey
+{
+  if (self = [super init]) {
+    _viewTag = reactTag;
+    _eventName = eventName;
+    _reactTouches = reactTouches;
+    _changedIndexes = changedIndexes;
+    _coalescingKey = coalescingKey;
+  }
+  return self;
+}
+
+RCT_NOT_IMPLEMENTED(- (instancetype)init)
+
+#pragma mark - RCTEvent
+
+- (BOOL)canCoalesce
+{
+  return [_eventName isEqual:@"touchMove"];
+}
+
+// We coalesce only move events, while holding some assumptions that seem reasonable but there are no explicit guarantees about them.
+- (id<RCTEvent>)coalesceWithEvent:(id<RCTEvent>)newEvent
+{
+  RCTAssert([newEvent isKindOfClass:[RCTTouchEvent class]], @"Touch event cannot be coalesced with any other type of event, such as provided %@", newEvent);
+  RCTTouchEvent *newTouchEvent = (RCTTouchEvent *)newEvent;
+  RCTAssert([_reactTouches count] == [newTouchEvent->_reactTouches count], @"Touch events have different number of touches. %@ %@", self, newEvent);
+
+  BOOL newEventIsMoreRecent = NO;
+  BOOL oldEventIsMoreRecent = NO;
+  NSInteger count = _reactTouches.count;
+  for (int i = 0; i<count; i++) {
+    NSDictionary *touch = _reactTouches[i];
+    NSDictionary *newTouch = newTouchEvent->_reactTouches[i];
+    RCTAssert([touch[@"identifier"] isEqual:newTouch[@"identifier"]], @"Touch events doesn't have touches in the same order. %@ %@", touch, newTouch);
+    if ([touch[@"timestamp"] doubleValue] > [newTouch[@"timestamp"] doubleValue]) {
+      oldEventIsMoreRecent = YES;
+    } else {
+      newEventIsMoreRecent = YES;
+    }
+  }
+  RCTAssert(!(oldEventIsMoreRecent && newEventIsMoreRecent), @"Neither touch event is exclusively more recent than the other one. %@ %@", _reactTouches, newTouchEvent->_reactTouches);
+  return newEventIsMoreRecent ? newEvent : self;
+}
+
++ (NSString *)moduleDotMethod
+{
+  return @"RCTEventEmitter.receiveTouches";
+}
+
+- (NSArray *)arguments
+{
+  return @[RCTNormalizeInputEventName(_eventName), _reactTouches, _changedIndexes];
+}
+
+- (uint16_t)coalescingKey
+{
+  return _coalescingKey;
+}
+
+- (NSString *)description
+{
+  return [NSString stringWithFormat:@"<%@: %p; name = %@; coalescing key = %hu>", [self class], self, _eventName, _coalescingKey];
+}
+
+@end

node_modules/react-native/React/Base/RCTTouchHandler.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/RCTFrameUpdate.h>
+
+@class RCTBridge;
+
+@interface RCTTouchHandler : UIGestureRecognizer
+
+- (instancetype)initWithBridge:(RCTBridge *)bridge NS_DESIGNATED_INITIALIZER;
+
+- (void)attachToView:(UIView *)view;
+- (void)detachFromView:(UIView *)view;
+
+- (void)cancel;
+
+@end

node_modules/react-native/React/Base/RCTTouchHandler.m

@@ -0,0 +1,380 @@
+/**
+ * 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 "RCTTouchHandler.h"
+
+#import <UIKit/UIGestureRecognizerSubclass.h>
+
+#import "RCTAssert.h"
+#import "RCTBridge.h"
+#import "RCTEventDispatcher.h"
+#import "RCTLog.h"
+#import "RCTTouchEvent.h"
+#import "RCTUIManager.h"
+#import "RCTUtils.h"
+#import "UIView+React.h"
+
+@interface RCTTouchHandler () <UIGestureRecognizerDelegate>
+@end
+
+// TODO: this class behaves a lot like a module, and could be implemented as a
+// module if we were to assume that modules and RootViews had a 1:1 relationship
+@implementation RCTTouchHandler
+{
+  __weak RCTEventDispatcher *_eventDispatcher;
+
+  /**
+   * Arrays managed in parallel tracking native touch object along with the
+   * native view that was touched, and the React touch data dictionary.
+   * These must be kept track of because `UIKit` destroys the touch targets
+   * if touches are canceled, and we have no other way to recover this info.
+   */
+  NSMutableOrderedSet<UITouch *> *_nativeTouches;
+  NSMutableArray<NSMutableDictionary *> *_reactTouches;
+  NSMutableArray<UIView *> *_touchViews;
+
+  __weak UIView *_cachedRootView;
+
+  uint16_t _coalescingKey;
+}
+
+- (instancetype)initWithBridge:(RCTBridge *)bridge
+{
+  RCTAssertParam(bridge);
+
+  if ((self = [super initWithTarget:nil action:NULL])) {
+    _eventDispatcher = [bridge moduleForClass:[RCTEventDispatcher class]];
+
+    _nativeTouches = [NSMutableOrderedSet new];
+    _reactTouches = [NSMutableArray new];
+    _touchViews = [NSMutableArray new];
+
+    // `cancelsTouchesInView` and `delaysTouches*` are needed in order to be used as a top level
+    // event delegated recognizer. Otherwise, lower-level components not built
+    // using RCT, will fail to recognize gestures.
+    self.cancelsTouchesInView = NO;
+    self.delaysTouchesBegan = NO; // This is default value.
+    self.delaysTouchesEnded = NO;
+
+    self.delegate = self;
+  }
+
+  return self;
+}
+
+RCT_NOT_IMPLEMENTED(- (instancetype)initWithTarget:(id)target action:(SEL)action)
+
+- (void)attachToView:(UIView *)view
+{
+  RCTAssert(self.view == nil, @"RCTTouchHandler already has attached view.");
+
+  [view addGestureRecognizer:self];
+}
+
+- (void)detachFromView:(UIView *)view
+{
+  RCTAssertParam(view);
+  RCTAssert(self.view == view, @"RCTTouchHandler attached to another view.");
+
+  [view removeGestureRecognizer:self];
+}
+
+#pragma mark - Bookkeeping for touch indices
+
+- (void)_recordNewTouches:(NSSet<UITouch *> *)touches
+{
+  for (UITouch *touch in touches) {
+
+    RCTAssert(![_nativeTouches containsObject:touch],
+              @"Touch is already recorded. This is a critical bug.");
+
+    // Find closest React-managed touchable view
+    UIView *targetView = touch.view;
+    while (targetView) {
+      if (targetView.reactTag && targetView.userInteractionEnabled) {
+        break;
+      }
+      targetView = targetView.superview;
+    }
+
+    NSNumber *reactTag = [targetView reactTagAtPoint:[touch locationInView:targetView]];
+    if (!reactTag || !targetView.userInteractionEnabled) {
+      continue;
+    }
+
+    // Get new, unique touch identifier for the react touch
+    const NSUInteger RCTMaxTouches = 11; // This is the maximum supported by iDevices
+    NSInteger touchID = ([_reactTouches.lastObject[@"identifier"] integerValue] + 1) % RCTMaxTouches;
+    for (NSDictionary *reactTouch in _reactTouches) {
+      NSInteger usedID = [reactTouch[@"identifier"] integerValue];
+      if (usedID == touchID) {
+        // ID has already been used, try next value
+        touchID ++;
+      } else if (usedID > touchID) {
+        // If usedID > touchID, touchID must be unique, so we can stop looking
+        break;
+      }
+    }
+
+    // Create touch
+    NSMutableDictionary *reactTouch = [[NSMutableDictionary alloc] initWithCapacity:RCTMaxTouches];
+    reactTouch[@"target"] = reactTag;
+    reactTouch[@"identifier"] = @(touchID);
+
+    // Add to arrays
+    [_touchViews addObject:targetView];
+    [_nativeTouches addObject:touch];
+    [_reactTouches addObject:reactTouch];
+  }
+}
+
+- (void)_recordRemovedTouches:(NSSet<UITouch *> *)touches
+{
+  for (UITouch *touch in touches) {
+    NSUInteger index = [_nativeTouches indexOfObject:touch];
+    if (index == NSNotFound) {
+      continue;
+    }
+
+    [_touchViews removeObjectAtIndex:index];
+    [_nativeTouches removeObjectAtIndex:index];
+    [_reactTouches removeObjectAtIndex:index];
+  }
+}
+
+- (void)_updateReactTouchAtIndex:(NSInteger)touchIndex
+{
+  UITouch *nativeTouch = _nativeTouches[touchIndex];
+  CGPoint windowLocation = [nativeTouch locationInView:nativeTouch.window];
+  RCTAssert(_cachedRootView, @"We were unable to find a root view for the touch");
+  CGPoint rootViewLocation = [nativeTouch.window convertPoint:windowLocation toView:_cachedRootView];
+
+  UIView *touchView = _touchViews[touchIndex];
+  CGPoint touchViewLocation = [nativeTouch.window convertPoint:windowLocation toView:touchView];
+
+  NSMutableDictionary *reactTouch = _reactTouches[touchIndex];
+  reactTouch[@"pageX"] = @(RCTSanitizeNaNValue(rootViewLocation.x, @"touchEvent.pageX"));
+  reactTouch[@"pageY"] = @(RCTSanitizeNaNValue(rootViewLocation.y, @"touchEvent.pageY"));
+  reactTouch[@"locationX"] = @(RCTSanitizeNaNValue(touchViewLocation.x, @"touchEvent.locationX"));
+  reactTouch[@"locationY"] = @(RCTSanitizeNaNValue(touchViewLocation.y, @"touchEvent.locationY"));
+  reactTouch[@"timestamp"] =  @(nativeTouch.timestamp * 1000); // in ms, for JS
+
+  // TODO: force for a 'normal' touch is usually 1.0;
+  // should we expose a `normalTouchForce` constant somewhere (which would
+  // have a value of `1.0 / nativeTouch.maximumPossibleForce`)?
+  if (RCTForceTouchAvailable()) {
+    reactTouch[@"force"] = @(RCTZeroIfNaN(nativeTouch.force / nativeTouch.maximumPossibleForce));
+  }
+}
+
+/**
+ * Constructs information about touch events to send across the serialized
+ * boundary. This data should be compliant with W3C `Touch` objects. This data
+ * alone isn't sufficient to construct W3C `Event` objects. To construct that,
+ * there must be a simple receiver on the other side of the bridge that
+ * organizes the touch objects into `Event`s.
+ *
+ * We send the data as an array of `Touch`es, the type of action
+ * (start/end/move/cancel) and the indices that represent "changed" `Touch`es
+ * from that array.
+ */
+- (void)_updateAndDispatchTouches:(NSSet<UITouch *> *)touches
+                        eventName:(NSString *)eventName
+{
+  // Update touches
+  NSMutableArray<NSNumber *> *changedIndexes = [NSMutableArray new];
+  for (UITouch *touch in touches) {
+    NSInteger index = [_nativeTouches indexOfObject:touch];
+    if (index == NSNotFound) {
+      continue;
+    }
+
+    [self _updateReactTouchAtIndex:index];
+    [changedIndexes addObject:@(index)];
+  }
+
+  if (changedIndexes.count == 0) {
+    return;
+  }
+
+  // Deep copy the touches because they will be accessed from another thread
+  // TODO: would it be safer to do this in the bridge or executor, rather than trusting caller?
+  NSMutableArray<NSDictionary *> *reactTouches =
+  [[NSMutableArray alloc] initWithCapacity:_reactTouches.count];
+  for (NSDictionary *touch in _reactTouches) {
+    [reactTouches addObject:[touch copy]];
+  }
+
+  BOOL canBeCoalesced = [eventName isEqualToString:@"touchMove"];
+
+  // We increment `_coalescingKey` twice here just for sure that
+  // this `_coalescingKey` will not be reused by ahother (preceding or following) event
+  // (yes, even if coalescing only happens (and makes sense) on events of the same type).
+
+  if (!canBeCoalesced) {
+    _coalescingKey++;
+  }
+
+  RCTTouchEvent *event = [[RCTTouchEvent alloc] initWithEventName:eventName
+                                                         reactTag:self.view.reactTag
+                                                     reactTouches:reactTouches
+                                                   changedIndexes:changedIndexes
+                                                    coalescingKey:_coalescingKey];
+
+  if (!canBeCoalesced) {
+    _coalescingKey++;
+  }
+
+  [_eventDispatcher sendEvent:event];
+}
+
+/***
+ * To ensure compatibilty when using UIManager.measure and RCTTouchHandler, we have to adopt
+ * UIManager.measure's behavior in finding a "root view".
+ * Usually RCTTouchHandler is already attached to a root view but in some cases (e.g. Modal),
+ * we are instead attached to some RCTView subtree. This is also the case when embedding some RN
+ * views inside a seperate ViewController not controlled by RN.
+ * This logic will either find the nearest rootView, or go all the way to the UIWindow.
+ * While this is not optimal, it is exactly what UIManager.measure does, and what Touchable.js
+ * relies on.
+ * We cache it here so that we don't have to repeat it for every touch in the gesture.
+ */
+- (void)_cacheRootView
+{
+  UIView *rootView = self.view;
+  while (rootView.superview && ![rootView isReactRootView]) {
+    rootView = rootView.superview;
+  }
+  _cachedRootView = rootView;
+}
+
+#pragma mark - Gesture Recognizer Delegate Callbacks
+
+static BOOL RCTAllTouchesAreCancelledOrEnded(NSSet<UITouch *> *touches)
+{
+  for (UITouch *touch in touches) {
+    if (touch.phase == UITouchPhaseBegan ||
+        touch.phase == UITouchPhaseMoved ||
+        touch.phase == UITouchPhaseStationary) {
+      return NO;
+    }
+  }
+  return YES;
+}
+
+static BOOL RCTAnyTouchesChanged(NSSet<UITouch *> *touches)
+{
+  for (UITouch *touch in touches) {
+    if (touch.phase == UITouchPhaseBegan ||
+        touch.phase == UITouchPhaseMoved) {
+      return YES;
+    }
+  }
+  return NO;
+}
+
+#pragma mark - `UIResponder`-ish touch-delivery methods
+
+- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesBegan:touches withEvent:event];
+
+  [self _cacheRootView];
+
+  // "start" has to record new touches *before* extracting the event.
+  // "end"/"cancel" needs to remove the touch *after* extracting the event.
+  [self _recordNewTouches:touches];
+
+  [self _updateAndDispatchTouches:touches eventName:@"touchStart"];
+
+  if (self.state == UIGestureRecognizerStatePossible) {
+    self.state = UIGestureRecognizerStateBegan;
+  } else if (self.state == UIGestureRecognizerStateBegan) {
+    self.state = UIGestureRecognizerStateChanged;
+  }
+}
+
+- (void)touchesMoved:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesMoved:touches withEvent:event];
+
+  [self _updateAndDispatchTouches:touches eventName:@"touchMove"];
+  self.state = UIGestureRecognizerStateChanged;
+}
+
+- (void)touchesEnded:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesEnded:touches withEvent:event];
+
+  [self _updateAndDispatchTouches:touches eventName:@"touchEnd"];
+
+  if (RCTAllTouchesAreCancelledOrEnded(event.allTouches)) {
+    self.state = UIGestureRecognizerStateEnded;
+  } else if (RCTAnyTouchesChanged(event.allTouches)) {
+    self.state = UIGestureRecognizerStateChanged;
+  }
+
+  [self _recordRemovedTouches:touches];
+}
+
+- (void)touchesCancelled:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesCancelled:touches withEvent:event];
+
+  [self _updateAndDispatchTouches:touches eventName:@"touchCancel"];
+
+  if (RCTAllTouchesAreCancelledOrEnded(event.allTouches)) {
+    self.state = UIGestureRecognizerStateCancelled;
+  } else if (RCTAnyTouchesChanged(event.allTouches)) {
+    self.state = UIGestureRecognizerStateChanged;
+  }
+
+  [self _recordRemovedTouches:touches];
+}
+
+- (BOOL)canPreventGestureRecognizer:(__unused UIGestureRecognizer *)preventedGestureRecognizer
+{
+  return NO;
+}
+
+- (BOOL)canBePreventedByGestureRecognizer:(UIGestureRecognizer *)preventingGestureRecognizer
+{
+  // We fail in favour of other external gesture recognizers.
+  // iOS will ask `delegate`'s opinion about this gesture recognizer little bit later.
+  return ![preventingGestureRecognizer.view isDescendantOfView:self.view];
+}
+
+- (void)reset
+{
+  if (_nativeTouches.count != 0) {
+    [self _updateAndDispatchTouches:_nativeTouches.set eventName:@"touchCancel"];
+
+    [_nativeTouches removeAllObjects];
+    [_reactTouches removeAllObjects];
+    [_touchViews removeAllObjects];
+
+    _cachedRootView = nil;
+  }
+}
+
+#pragma mark - Other
+
+- (void)cancel
+{
+  self.enabled = NO;
+  self.enabled = YES;
+}
+
+#pragma mark - UIGestureRecognizerDelegate
+
+- (BOOL)gestureRecognizer:(__unused UIGestureRecognizer *)gestureRecognizer shouldRequireFailureOfGestureRecognizer:(UIGestureRecognizer *)otherGestureRecognizer
+{
+  // Same condition for `failure of` as for `be prevented by`.
+  return [self canBePreventedByGestureRecognizer:otherGestureRecognizer];
+}
+
+@end

node_modules/react-native/React/Base/RCTURLRequestDelegate.h

@@ -0,0 +1,40 @@
+/**
+ * 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>
+
+/**
+ * An abstract interface used by request handler modules to send
+ * data back over the bridge back to JS.
+ */
+@protocol RCTURLRequestDelegate <NSObject>
+
+/**
+ * Call this when you send request data to the server. This is used to track
+ * upload progress, so should be called multiple times for large request bodies.
+ */
+- (void)URLRequest:(id)requestToken didSendDataWithProgress:(int64_t)bytesSent;
+
+/**
+ * Call this when you first receives a response from the server. This should
+ * include response headers, etc.
+ */
+- (void)URLRequest:(id)requestToken didReceiveResponse:(NSURLResponse *)response;
+
+/**
+ * Call this when you receive data from the server. This can be called multiple
+ * times with partial data chunks, or just once with the full data packet.
+ */
+- (void)URLRequest:(id)requestToken didReceiveData:(NSData *)data;
+
+/**
+ * Call this when the request is complete and/or if an error is encountered.
+ * For a successful request, the error parameter should be nil.
+ */
+- (void)URLRequest:(id)requestToken didCompleteWithError:(NSError *)error;
+
+@end

node_modules/react-native/React/Base/RCTURLRequestHandler.h

@@ -0,0 +1,53 @@
+/**
+ * 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/RCTURLRequestDelegate.h>
+
+/**
+ * Provides the interface needed to register a request handler. Request handlers
+ * are also bridge modules, so should be registered using RCT_EXPORT_MODULE().
+ */
+@protocol RCTURLRequestHandler <RCTBridgeModule>
+
+/**
+ * Indicates whether this handler is capable of processing the specified
+ * request. Typically the handler would examine the scheme/protocol of the
+ * request URL (and possibly the HTTP method and/or headers) to determine this.
+ */
+- (BOOL)canHandleRequest:(NSURLRequest *)request;
+
+/**
+ * Send a network request and call the delegate with the response data. The
+ * method should return a token, which can be anything, including the request
+ * itself. This will be used later to refer to the request in callbacks. The
+ * `sendRequest:withDelegate:` method *must* return before calling any of the
+ * delegate methods, or the delegate won't recognize the token.
+ * Following common Objective-C pattern, `delegate` will not be retained.
+ */
+- (id)sendRequest:(NSURLRequest *)request
+     withDelegate:(id<RCTURLRequestDelegate>)delegate;
+
+@optional
+
+/**
+ * Not all request types can be cancelled, but this method can be implemented
+ * for ones that can. It should be used to free up any resources on ongoing
+ * processes associated with the request.
+ */
+- (void)cancelRequest:(id)requestToken;
+
+/**
+ * If more than one RCTURLRequestHandler responds YES to `canHandleRequest:`
+ * then `handlerPriority` is used to determine which one to use. The handler
+ * with the highest priority will be selected. Default priority is zero. If
+ * two or more valid handlers have the same priority, the selection order is
+ * undefined.
+ */
+- (float)handlerPriority;
+
+@end

node_modules/react-native/React/Base/RCTUtils.h

@@ -0,0 +1,149 @@
+/**
+ * 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 <tgmath.h>
+
+#import <CoreGraphics/CoreGraphics.h>
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+
+#import <React/RCTAssert.h>
+#import <React/RCTDefines.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+// JSON serialization/deserialization
+RCT_EXTERN NSString *__nullable RCTJSONStringify(id __nullable jsonObject, NSError **error);
+RCT_EXTERN id __nullable RCTJSONParse(NSString *__nullable jsonString, NSError **error);
+RCT_EXTERN id __nullable RCTJSONParseMutable(NSString *__nullable jsonString, NSError **error);
+
+// Sanitize a JSON object by stripping invalid types and/or NaN values
+RCT_EXTERN id RCTJSONClean(id object);
+
+// Get MD5 hash of a string
+RCT_EXTERN NSString *RCTMD5Hash(NSString *string);
+
+// Check if we are currently on the main queue (not to be confused with
+// the main thread, which is not necessarily the same thing)
+// https://twitter.com/olebegemann/status/738656134731599872
+RCT_EXTERN BOOL RCTIsMainQueue(void);
+
+// Execute the specified block on the main queue. Unlike dispatch_async()
+// this will execute immediately if we're already on the main queue.
+RCT_EXTERN void RCTExecuteOnMainQueue(dispatch_block_t block);
+
+// Legacy function to execute the specified block on the main queue synchronously.
+// Please do not use this unless you know what you're doing.
+RCT_EXTERN void RCTUnsafeExecuteOnMainQueueSync(dispatch_block_t block);
+
+// Get screen metrics in a thread-safe way
+RCT_EXTERN CGFloat RCTScreenScale(void);
+RCT_EXTERN CGSize RCTScreenSize(void);
+
+// Round float coordinates to nearest whole screen pixel (not point)
+RCT_EXTERN CGFloat RCTRoundPixelValue(CGFloat value);
+RCT_EXTERN CGFloat RCTCeilPixelValue(CGFloat value);
+RCT_EXTERN CGFloat RCTFloorPixelValue(CGFloat value);
+
+// Convert a size in points to pixels, rounded up to the nearest integral size
+RCT_EXTERN CGSize RCTSizeInPixels(CGSize pointSize, CGFloat scale);
+
+// Method swizzling
+RCT_EXTERN void RCTSwapClassMethods(Class cls, SEL original, SEL replacement);
+RCT_EXTERN void RCTSwapInstanceMethods(Class cls, SEL original, SEL replacement);
+
+// Module subclass support
+RCT_EXTERN BOOL RCTClassOverridesClassMethod(Class cls, SEL selector);
+RCT_EXTERN BOOL RCTClassOverridesInstanceMethod(Class cls, SEL selector);
+
+// Creates a standardized error object to return in callbacks
+RCT_EXTERN NSDictionary<NSString *, id> *RCTMakeError(NSString *message, id __nullable toStringify, NSDictionary<NSString *, id> *__nullable extraData);
+RCT_EXTERN NSDictionary<NSString *, id> *RCTMakeAndLogError(NSString *message, id __nullable toStringify, NSDictionary<NSString *, id> *__nullable extraData);
+RCT_EXTERN NSDictionary<NSString *, id> *RCTJSErrorFromNSError(NSError *error);
+RCT_EXTERN NSDictionary<NSString *, id> *RCTJSErrorFromCodeMessageAndNSError(NSString *code, NSString *message, NSError *__nullable error);
+
+// The default error code to use as the `code` property for callback error objects
+RCT_EXTERN NSString *const RCTErrorUnspecified;
+
+// Returns YES if React is running in a test environment
+RCT_EXTERN BOOL RCTRunningInTestEnvironment(void);
+
+// Returns YES if React is running in an iOS App Extension
+RCT_EXTERN BOOL RCTRunningInAppExtension(void);
+
+// Returns the shared UIApplication instance, or nil if running in an App Extension
+RCT_EXTERN UIApplication *__nullable RCTSharedApplication(void);
+
+// Returns the current main window, useful if you need to access the root view
+// or view controller
+RCT_EXTERN UIWindow *__nullable RCTKeyWindow(void);
+
+// Returns the presented view controller, useful if you need
+// e.g. to present a modal view controller or alert over it
+RCT_EXTERN UIViewController *__nullable RCTPresentedViewController(void);
+
+// Does this device support force touch (aka 3D Touch)?
+RCT_EXTERN BOOL RCTForceTouchAvailable(void);
+
+// Create an NSError in the RCTErrorDomain
+RCT_EXTERN NSError *RCTErrorWithMessage(NSString *message);
+
+// Convert nil values to NSNull, and vice-versa
+#define RCTNullIfNil(value) (value ?: (id)kCFNull)
+#define RCTNilIfNull(value) \
+  ({ __typeof__(value) t = (value); (id)t == (id)kCFNull ? (__typeof(value))nil : t; })
+
+// Convert NaN or infinite values to zero, as these aren't JSON-safe
+RCT_EXTERN double RCTZeroIfNaN(double value);
+
+// Returns `0` and log special warning if value is NaN or INF.
+RCT_EXTERN double RCTSanitizeNaNValue(double value, NSString *property);
+
+// Convert data to a Base64-encoded data URL
+RCT_EXTERN NSURL *RCTDataURL(NSString *mimeType, NSData *data);
+
+// Gzip functionality - compression level in range 0 - 1 (-1 for default)
+RCT_EXTERN NSData *__nullable RCTGzipData(NSData *__nullable data, float level);
+
+// Returns the relative path within the main bundle for an absolute URL
+// (or nil, if the URL does not specify a path within the main bundle)
+RCT_EXTERN NSString *__nullable RCTBundlePathForURL(NSURL *__nullable URL);
+
+// Returns the Path of Library directory
+RCT_EXTERN NSString *__nullable RCTLibraryPath(void);
+
+// Returns the relative path within the library for an absolute URL
+// (or nil, if the URL does not specify a path within the Library directory)
+RCT_EXTERN NSString *__nullable RCTLibraryPathForURL(NSURL *__nullable URL);
+
+// Determines if a given image URL refers to a image in bundle
+RCT_EXTERN BOOL RCTIsBundleAssetURL(NSURL *__nullable imageURL);
+
+// Determines if a given image URL refers to a image in library
+RCT_EXTERN BOOL RCTIsLibraryAssetURL(NSURL *__nullable imageURL);
+
+// Determines if a given image URL refers to a local image
+RCT_EXTERN BOOL RCTIsLocalAssetURL(NSURL *__nullable imageURL);
+
+// Returns an UIImage for a local image asset. Returns nil if the URL
+// does not correspond to a local asset.
+RCT_EXTERN UIImage *__nullable RCTImageFromLocalAssetURL(NSURL *imageURL);
+
+// Creates a new, unique temporary file path with the specified extension
+RCT_EXTERN NSString *__nullable RCTTempFilePath(NSString *__nullable extension, NSError **error);
+
+// Converts a CGColor to a hex string
+RCT_EXTERN NSString *RCTColorToHexString(CGColorRef color);
+
+// Get standard localized string (if it exists)
+RCT_EXTERN NSString *RCTUIKitLocalizedString(NSString *string);
+
+// URL manipulation
+RCT_EXTERN NSString *__nullable RCTGetURLQueryParam(NSURL *__nullable URL, NSString *param);
+RCT_EXTERN NSURL *__nullable RCTURLByReplacingQueryParam(NSURL *__nullable URL, NSString *param, NSString *__nullable value);
+
+NS_ASSUME_NONNULL_END

node_modules/react-native/React/Base/RCTUtils.m

@@ -0,0 +1,900 @@
+/**
+ * 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 "RCTUtils.h"
+
+#import <dlfcn.h>
+#import <mach/mach_time.h>
+#import <objc/message.h>
+#import <objc/runtime.h>
+#import <zlib.h>
+
+#import <UIKit/UIKit.h>
+
+#import <CommonCrypto/CommonCrypto.h>
+
+#import "RCTAssert.h"
+#import "RCTLog.h"
+
+NSString *const RCTErrorUnspecified = @"EUNSPECIFIED";
+
+static NSString *__nullable _RCTJSONStringifyNoRetry(id __nullable jsonObject, NSError **error)
+{
+  if (!jsonObject) {
+    return nil;
+  }
+
+  static SEL JSONKitSelector = NULL;
+  static NSSet<Class> *collectionTypes;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    SEL selector = NSSelectorFromString(@"JSONStringWithOptions:error:");
+    if ([NSDictionary instancesRespondToSelector:selector]) {
+      JSONKitSelector = selector;
+      collectionTypes = [NSSet setWithObjects:
+                         [NSArray class], [NSMutableArray class],
+                         [NSDictionary class], [NSMutableDictionary class], nil];
+    }
+  });
+
+  @try {
+
+    // Use JSONKit if available and object is not a fragment
+    if (JSONKitSelector && [collectionTypes containsObject:[jsonObject classForCoder]]) {
+      return ((NSString *(*)(id, SEL, int, NSError **))objc_msgSend)(jsonObject, JSONKitSelector, 0, error);
+    }
+
+    // Use Foundation JSON method
+    NSData *jsonData = [NSJSONSerialization
+                        dataWithJSONObject:jsonObject options:(NSJSONWritingOptions)NSJSONReadingAllowFragments
+                        error:error];
+
+    return jsonData ? [[NSString alloc] initWithData:jsonData encoding:NSUTF8StringEncoding] : nil;
+  }
+  @catch (NSException *exception) {
+
+    // Convert exception to error
+    if (error) {
+      *error = [NSError errorWithDomain:RCTErrorDomain code:0 userInfo:@{
+        NSLocalizedDescriptionKey: exception.description ?: @""
+      }];
+    }
+    return nil;
+  }
+}
+
+NSString *__nullable RCTJSONStringify(id __nullable jsonObject, NSError **error)
+{
+  if (error) {
+    return _RCTJSONStringifyNoRetry(jsonObject, error);
+  } else {
+    NSError *localError;
+    NSString *json = _RCTJSONStringifyNoRetry(jsonObject, &localError);
+    if (localError) {
+      RCTLogError(@"RCTJSONStringify() encountered the following error: %@",
+                  localError.localizedDescription);
+      // Sanitize the data, then retry. This is slow, but it prevents uncaught
+      // data issues from crashing in production
+      return _RCTJSONStringifyNoRetry(RCTJSONClean(jsonObject), NULL);
+    }
+    return json;
+  }
+}
+
+static id __nullable _RCTJSONParse(NSString *__nullable jsonString, BOOL mutable, NSError **error)
+{
+  static SEL JSONKitSelector = NULL;
+  static SEL JSONKitMutableSelector = NULL;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    SEL selector = NSSelectorFromString(@"objectFromJSONStringWithParseOptions:error:");
+    if ([NSString instancesRespondToSelector:selector]) {
+      JSONKitSelector = selector;
+      JSONKitMutableSelector = NSSelectorFromString(@"mutableObjectFromJSONStringWithParseOptions:error:");
+    }
+  });
+
+  if (jsonString) {
+
+    // Use JSONKit if available and string is not a fragment
+    if (JSONKitSelector) {
+      NSInteger length = jsonString.length;
+      for (NSInteger i = 0; i < length; i++) {
+        unichar c = [jsonString characterAtIndex:i];
+        if (strchr("{[", c)) {
+          static const int options = (1 << 2); // loose unicode
+          SEL selector = mutable ? JSONKitMutableSelector : JSONKitSelector;
+          return ((id (*)(id, SEL, int, NSError **))objc_msgSend)(jsonString, selector, options, error);
+        }
+        if (!strchr(" \r\n\t", c)) {
+          break;
+        }
+      }
+    }
+
+    // Use Foundation JSON method
+    NSData *jsonData = [jsonString dataUsingEncoding:NSUTF8StringEncoding];
+    if (!jsonData) {
+      jsonData = [jsonString dataUsingEncoding:NSUTF8StringEncoding allowLossyConversion:YES];
+      if (jsonData) {
+        RCTLogWarn(@"RCTJSONParse received the following string, which could "
+                   "not be losslessly converted to UTF8 data: '%@'", jsonString);
+      } else {
+        NSString *errorMessage = @"RCTJSONParse received invalid UTF8 data";
+        if (error) {
+          *error = RCTErrorWithMessage(errorMessage);
+        } else {
+          RCTLogError(@"%@", errorMessage);
+        }
+        return nil;
+      }
+    }
+    NSJSONReadingOptions options = NSJSONReadingAllowFragments;
+    if (mutable) {
+      options |= NSJSONReadingMutableContainers;
+    }
+    return [NSJSONSerialization JSONObjectWithData:jsonData
+                                           options:options
+                                             error:error];
+  }
+  return nil;
+}
+
+id __nullable RCTJSONParse(NSString *__nullable jsonString, NSError **error)
+{
+  return _RCTJSONParse(jsonString, NO, error);
+}
+
+id __nullable RCTJSONParseMutable(NSString *__nullable jsonString, NSError **error)
+{
+  return _RCTJSONParse(jsonString, YES, error);
+}
+
+id RCTJSONClean(id object)
+{
+  static dispatch_once_t onceToken;
+  static NSSet<Class> *validLeafTypes;
+  dispatch_once(&onceToken, ^{
+    validLeafTypes = [[NSSet alloc] initWithArray:@[
+      [NSString class],
+      [NSMutableString class],
+      [NSNumber class],
+      [NSNull class],
+    ]];
+  });
+
+  if ([validLeafTypes containsObject:[object classForCoder]]) {
+    if ([object isKindOfClass:[NSNumber class]]) {
+      return @(RCTZeroIfNaN([object doubleValue]));
+    }
+    if ([object isKindOfClass:[NSString class]]) {
+      if ([object UTF8String] == NULL) {
+        return (id)kCFNull;
+      }
+    }
+    return object;
+  }
+
+  if ([object isKindOfClass:[NSDictionary class]]) {
+    __block BOOL copy = NO;
+    NSMutableDictionary<NSString *, id> *values = [[NSMutableDictionary alloc] initWithCapacity:[object count]];
+    [object enumerateKeysAndObjectsUsingBlock:^(NSString *key, id item, __unused BOOL *stop) {
+      id value = RCTJSONClean(item);
+      values[key] = value;
+      copy |= value != item;
+    }];
+    return copy ? values : object;
+  }
+
+  if ([object isKindOfClass:[NSArray class]]) {
+    __block BOOL copy = NO;
+    __block NSArray *values = object;
+    [object enumerateObjectsUsingBlock:^(id item, NSUInteger idx, __unused BOOL *stop) {
+      id value = RCTJSONClean(item);
+      if (copy) {
+        [(NSMutableArray *)values addObject:value];
+      } else if (value != item) {
+        // Converted value is different, so we'll need to copy the array
+        values = [[NSMutableArray alloc] initWithCapacity:values.count];
+        for (NSUInteger i = 0; i < idx; i++) {
+          [(NSMutableArray *)values addObject:object[i]];
+        }
+        [(NSMutableArray *)values addObject:value];
+        copy = YES;
+      }
+    }];
+    return values;
+  }
+
+  return (id)kCFNull;
+}
+
+NSString *RCTMD5Hash(NSString *string)
+{
+  const char *str = string.UTF8String;
+  unsigned char result[CC_MD5_DIGEST_LENGTH];
+  CC_MD5(str, (CC_LONG)strlen(str), result);
+
+  return [NSString stringWithFormat:@"%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
+    result[0], result[1], result[2], result[3],
+    result[4], result[5], result[6], result[7],
+    result[8], result[9], result[10], result[11],
+    result[12], result[13], result[14], result[15]
+  ];
+}
+
+BOOL RCTIsMainQueue()
+{
+  static void *mainQueueKey = &mainQueueKey;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    dispatch_queue_set_specific(dispatch_get_main_queue(),
+                                mainQueueKey, mainQueueKey, NULL);
+  });
+  return dispatch_get_specific(mainQueueKey) == mainQueueKey;
+}
+
+void RCTExecuteOnMainQueue(dispatch_block_t block)
+{
+  if (RCTIsMainQueue()) {
+    block();
+  } else {
+    dispatch_async(dispatch_get_main_queue(), ^{
+      block();
+    });
+  }
+}
+
+// Please do not use this method
+// unless you know what you are doing.
+void RCTUnsafeExecuteOnMainQueueSync(dispatch_block_t block)
+{
+  if (RCTIsMainQueue()) {
+    block();
+  } else {
+    dispatch_sync(dispatch_get_main_queue(), ^{
+      block();
+    });
+  }
+}
+
+static void RCTUnsafeExecuteOnMainQueueOnceSync(dispatch_once_t *onceToken, dispatch_block_t block)
+{
+  // The solution was borrowed from a post by Ben Alpert:
+  // https://benalpert.com/2014/04/02/dispatch-once-initialization-on-the-main-thread.html
+  // See also: https://www.mikeash.com/pyblog/friday-qa-2014-06-06-secrets-of-dispatch_once.html
+  if (RCTIsMainQueue()) {
+    dispatch_once(onceToken, block);
+  } else {
+    if (DISPATCH_EXPECT(*onceToken == 0L, NO)) {
+      dispatch_sync(dispatch_get_main_queue(), ^{
+        dispatch_once(onceToken, block);
+      });
+    }
+  }
+}
+
+CGFloat RCTScreenScale()
+{
+  static dispatch_once_t onceToken;
+  static CGFloat scale;
+
+  RCTUnsafeExecuteOnMainQueueOnceSync(&onceToken, ^{
+    scale = [UIScreen mainScreen].scale;
+  });
+
+  return scale;
+}
+
+CGSize RCTScreenSize()
+{
+  // FIXME: this caches the bounds at app start, whatever those were, and then
+  // doesn't update when the device is rotated. We need to find another thread-
+  // safe way to get the screen size.
+
+  static CGSize size;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    RCTUnsafeExecuteOnMainQueueSync(^{
+      size = [UIScreen mainScreen].bounds.size;
+    });
+  });
+
+  return size;
+}
+
+CGFloat RCTRoundPixelValue(CGFloat value)
+{
+  CGFloat scale = RCTScreenScale();
+  return round(value * scale) / scale;
+}
+
+CGFloat RCTCeilPixelValue(CGFloat value)
+{
+  CGFloat scale = RCTScreenScale();
+  return ceil(value * scale) / scale;
+}
+
+CGFloat RCTFloorPixelValue(CGFloat value)
+{
+  CGFloat scale = RCTScreenScale();
+  return floor(value * scale) / scale;
+}
+
+CGSize RCTSizeInPixels(CGSize pointSize, CGFloat scale)
+{
+  return (CGSize){
+    ceil(pointSize.width * scale),
+    ceil(pointSize.height * scale),
+  };
+}
+
+void RCTSwapClassMethods(Class cls, SEL original, SEL replacement)
+{
+  Method originalMethod = class_getClassMethod(cls, original);
+  IMP originalImplementation = method_getImplementation(originalMethod);
+  const char *originalArgTypes = method_getTypeEncoding(originalMethod);
+
+  Method replacementMethod = class_getClassMethod(cls, replacement);
+  IMP replacementImplementation = method_getImplementation(replacementMethod);
+  const char *replacementArgTypes = method_getTypeEncoding(replacementMethod);
+
+  if (class_addMethod(cls, original, replacementImplementation, replacementArgTypes)) {
+    class_replaceMethod(cls, replacement, originalImplementation, originalArgTypes);
+  } else {
+    method_exchangeImplementations(originalMethod, replacementMethod);
+  }
+}
+
+void RCTSwapInstanceMethods(Class cls, SEL original, SEL replacement)
+{
+  Method originalMethod = class_getInstanceMethod(cls, original);
+  IMP originalImplementation = method_getImplementation(originalMethod);
+  const char *originalArgTypes = method_getTypeEncoding(originalMethod);
+
+  Method replacementMethod = class_getInstanceMethod(cls, replacement);
+  IMP replacementImplementation = method_getImplementation(replacementMethod);
+  const char *replacementArgTypes = method_getTypeEncoding(replacementMethod);
+
+  if (class_addMethod(cls, original, replacementImplementation, replacementArgTypes)) {
+    class_replaceMethod(cls, replacement, originalImplementation, originalArgTypes);
+  } else {
+    method_exchangeImplementations(originalMethod, replacementMethod);
+  }
+}
+
+BOOL RCTClassOverridesClassMethod(Class cls, SEL selector)
+{
+  return RCTClassOverridesInstanceMethod(object_getClass(cls), selector);
+}
+
+BOOL RCTClassOverridesInstanceMethod(Class cls, SEL selector)
+{
+  unsigned int numberOfMethods;
+  Method *methods = class_copyMethodList(cls, &numberOfMethods);
+  for (unsigned int i = 0; i < numberOfMethods; i++) {
+    if (method_getName(methods[i]) == selector) {
+      free(methods);
+      return YES;
+    }
+  }
+  free(methods);
+  return NO;
+}
+
+NSDictionary<NSString *, id> *RCTMakeError(NSString *message,
+                                           id __nullable toStringify,
+                                           NSDictionary<NSString *, id> *__nullable extraData)
+{
+  if (toStringify) {
+    message = [message stringByAppendingString:[toStringify description]];
+  }
+
+  NSMutableDictionary<NSString *, id> *error = [extraData mutableCopy] ?: [NSMutableDictionary new];
+  error[@"message"] = message;
+  return error;
+}
+
+NSDictionary<NSString *, id> *RCTMakeAndLogError(NSString *message,
+                                                 id __nullable toStringify,
+                                                 NSDictionary<NSString *, id> *__nullable extraData)
+{
+  NSDictionary<NSString *, id> *error = RCTMakeError(message, toStringify, extraData);
+  RCTLogError(@"\nError: %@", error);
+  return error;
+}
+
+NSDictionary<NSString *, id> *RCTJSErrorFromNSError(NSError *error)
+{
+  NSString *codeWithDomain = [NSString stringWithFormat:@"E%@%lld", error.domain.uppercaseString, (long long)error.code];
+  return RCTJSErrorFromCodeMessageAndNSError(codeWithDomain,
+                                             error.localizedDescription,
+                                             error);
+}
+
+// TODO: Can we just replace RCTMakeError with this function instead?
+NSDictionary<NSString *, id> *RCTJSErrorFromCodeMessageAndNSError(NSString *code,
+                                                                  NSString *message,
+                                                                  NSError *__nullable error)
+{
+  NSString *errorMessage;
+  NSArray<NSString *> *stackTrace = [NSThread callStackSymbols];
+  NSMutableDictionary *userInfo;
+  NSMutableDictionary<NSString *, id> *errorInfo =
+  [NSMutableDictionary dictionaryWithObject:stackTrace forKey:@"nativeStackIOS"];
+
+  if (error) {
+    errorMessage = error.localizedDescription ?: @"Unknown error from a native module";
+    errorInfo[@"domain"] = error.domain ?: RCTErrorDomain;
+    if (error.userInfo) {
+      userInfo = [error.userInfo mutableCopy];
+      if (userInfo != nil && userInfo[NSUnderlyingErrorKey] != nil) {
+        NSError *underlyingError = error.userInfo[NSUnderlyingErrorKey];
+        NSString *underlyingCode = [NSString stringWithFormat:@"%d", (int)underlyingError.code];
+        userInfo[NSUnderlyingErrorKey] = RCTJSErrorFromCodeMessageAndNSError(underlyingCode, @"underlying error", underlyingError);
+      }
+    }
+  } else {
+    errorMessage = @"Unknown error from a native module";
+    errorInfo[@"domain"] = RCTErrorDomain;
+    userInfo = nil;
+  }
+  errorInfo[@"code"] = code ?: RCTErrorUnspecified;
+  errorInfo[@"userInfo"] = RCTNullIfNil(userInfo);
+
+  // Allow for explicit overriding of the error message
+  errorMessage = message ?: errorMessage;
+
+  return RCTMakeError(errorMessage, nil, errorInfo);
+}
+
+BOOL RCTRunningInTestEnvironment(void)
+{
+  static BOOL isTestEnvironment = NO;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    NSDictionary *environment = [[NSProcessInfo processInfo] environment];
+    isTestEnvironment = objc_lookUpClass("SenTestCase") || objc_lookUpClass("XCTest") ||
+      [environment[@"IS_TESTING"] boolValue];
+  });
+  return isTestEnvironment;
+}
+
+BOOL RCTRunningInAppExtension(void)
+{
+  return [[[[NSBundle mainBundle] bundlePath] pathExtension] isEqualToString:@"appex"];
+}
+
+UIApplication *__nullable RCTSharedApplication(void)
+{
+  if (RCTRunningInAppExtension()) {
+    return nil;
+  }
+  return [[UIApplication class] performSelector:@selector(sharedApplication)];
+}
+
+UIWindow *__nullable RCTKeyWindow(void)
+{
+  if (RCTRunningInAppExtension()) {
+    return nil;
+  }
+
+  // TODO: replace with a more robust solution
+  return RCTSharedApplication().keyWindow;
+}
+
+UIViewController *__nullable RCTPresentedViewController(void)
+{
+  if (RCTRunningInAppExtension()) {
+    return nil;
+  }
+
+  UIViewController *controller = RCTKeyWindow().rootViewController;
+  UIViewController *presentedController = controller.presentedViewController;
+  while (presentedController && ![presentedController isBeingDismissed]) {
+    controller = presentedController;
+    presentedController = controller.presentedViewController;
+  }
+
+  return controller;
+}
+
+BOOL RCTForceTouchAvailable(void)
+{
+  static BOOL forceSupported;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    forceSupported = [UITraitCollection class] &&
+    [UITraitCollection instancesRespondToSelector:@selector(forceTouchCapability)];
+  });
+
+  return forceSupported &&
+    (RCTKeyWindow() ?: [UIView new]).traitCollection.forceTouchCapability == UIForceTouchCapabilityAvailable;
+}
+
+NSError *RCTErrorWithMessage(NSString *message)
+{
+  NSDictionary<NSString *, id> *errorInfo = @{NSLocalizedDescriptionKey: message};
+  return [[NSError alloc] initWithDomain:RCTErrorDomain code:0 userInfo:errorInfo];
+}
+
+double RCTZeroIfNaN(double value)
+{
+  return isnan(value) || isinf(value) ? 0 : value;
+}
+
+double RCTSanitizeNaNValue(double value, NSString *property)
+{
+  if (!isnan(value) && !isinf(value)) {
+    return value;
+  }
+
+  RCTLogWarn(@"The value `%@` equals NaN or INF and will be replaced by `0`.", property);
+  return 0;
+}
+
+NSURL *RCTDataURL(NSString *mimeType, NSData *data)
+{
+  return [NSURL URLWithString:
+          [NSString stringWithFormat:@"data:%@;base64,%@", mimeType,
+           [data base64EncodedStringWithOptions:(NSDataBase64EncodingOptions)0]]];
+}
+
+BOOL RCTIsGzippedData(NSData *__nullable); // exposed for unit testing purposes
+BOOL RCTIsGzippedData(NSData *__nullable data)
+{
+  UInt8 *bytes = (UInt8 *)data.bytes;
+  return (data.length >= 2 && bytes[0] == 0x1f && bytes[1] == 0x8b);
+}
+
+NSData *__nullable RCTGzipData(NSData *__nullable input, float level)
+{
+  if (input.length == 0 || RCTIsGzippedData(input)) {
+    return input;
+  }
+
+  void *libz = dlopen("/usr/lib/libz.dylib", RTLD_LAZY);
+  int (*deflateInit2_)(z_streamp, int, int, int, int, int, const char *, int) = dlsym(libz, "deflateInit2_");
+  int (*deflate)(z_streamp, int) = dlsym(libz, "deflate");
+  int (*deflateEnd)(z_streamp) = dlsym(libz, "deflateEnd");
+
+  z_stream stream;
+  stream.zalloc = Z_NULL;
+  stream.zfree = Z_NULL;
+  stream.opaque = Z_NULL;
+  stream.avail_in = (uint)input.length;
+  stream.next_in = (Bytef *)input.bytes;
+  stream.total_out = 0;
+  stream.avail_out = 0;
+
+  static const NSUInteger RCTGZipChunkSize = 16384;
+
+  NSMutableData *output = nil;
+  int compression = (level < 0.0f)? Z_DEFAULT_COMPRESSION: (int)(roundf(level * 9));
+  if (deflateInit2(&stream, compression, Z_DEFLATED, 31, 8, Z_DEFAULT_STRATEGY) == Z_OK) {
+    output = [NSMutableData dataWithLength:RCTGZipChunkSize];
+    while (stream.avail_out == 0) {
+      if (stream.total_out >= output.length) {
+        output.length += RCTGZipChunkSize;
+      }
+      stream.next_out = (uint8_t *)output.mutableBytes + stream.total_out;
+      stream.avail_out = (uInt)(output.length - stream.total_out);
+      deflate(&stream, Z_FINISH);
+    }
+    deflateEnd(&stream);
+    output.length = stream.total_out;
+  }
+
+  dlclose(libz);
+
+  return output;
+}
+
+static NSString *RCTRelativePathForURL(NSString *basePath, NSURL *__nullable URL)
+{
+  if (!URL.fileURL) {
+    // Not a file path
+    return nil;
+  }
+  NSString *path = [NSString stringWithUTF8String:[URL fileSystemRepresentation]];
+  if (![path hasPrefix:basePath]) {
+    // Not a bundle-relative file
+    return nil;
+  }
+  path = [path substringFromIndex:basePath.length];
+  if ([path hasPrefix:@"/"]) {
+    path = [path substringFromIndex:1];
+  }
+  return path;
+}
+
+NSString *__nullable RCTLibraryPath(void)
+{
+    static NSString *libraryPath = nil;
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+        libraryPath = [NSSearchPathForDirectoriesInDomains(NSLibraryDirectory, NSUserDomainMask, YES) lastObject];
+    });
+    return libraryPath;
+}
+
+NSString *__nullable RCTBundlePathForURL(NSURL *__nullable URL)
+{
+  return RCTRelativePathForURL([[NSBundle mainBundle] resourcePath], URL);
+
+}
+
+NSString *__nullable RCTLibraryPathForURL(NSURL *__nullable URL)
+{
+  return RCTRelativePathForURL(RCTLibraryPath(), URL);
+}
+
+static BOOL RCTIsImageAssetsPath(NSString *path)
+{
+  NSString *extension = [path pathExtension];
+  return [extension isEqualToString:@"png"] || [extension isEqualToString:@"jpg"];
+}
+
+BOOL RCTIsBundleAssetURL(NSURL *__nullable imageURL)
+{
+  return RCTIsImageAssetsPath(RCTBundlePathForURL(imageURL));
+}
+
+BOOL RCTIsLibraryAssetURL(NSURL *__nullable imageURL)
+{
+  return RCTIsImageAssetsPath(RCTLibraryPathForURL(imageURL));
+}
+
+BOOL RCTIsLocalAssetURL(NSURL *__nullable imageURL)
+{
+  return RCTIsBundleAssetURL(imageURL) || RCTIsLibraryAssetURL(imageURL);
+}
+
+static NSString *bundleName(NSBundle *bundle)
+{
+  NSString *name = bundle.infoDictionary[@"CFBundleName"];
+  if (!name) {
+    name = [[bundle.bundlePath lastPathComponent] stringByDeletingPathExtension];
+  }
+  return name;
+}
+
+static NSBundle *bundleForPath(NSString *key)
+{
+  static NSMutableDictionary *bundleCache;
+  if (!bundleCache) {
+    bundleCache = [NSMutableDictionary new];
+    bundleCache[@"main"] = [NSBundle mainBundle];
+
+    // Initialize every bundle in the array
+    for (NSString *path in [[NSBundle mainBundle] pathsForResourcesOfType:@"bundle" inDirectory:nil]) {
+      [NSBundle bundleWithPath:path];
+    }
+
+    // The bundles initialized above will now also be in `allBundles`
+    for (NSBundle *bundle in [NSBundle allBundles]) {
+      bundleCache[bundleName(bundle)] = bundle;
+    }
+  }
+
+  return bundleCache[key];
+}
+
+UIImage *__nullable RCTImageFromLocalAssetURL(NSURL *imageURL)
+{
+  NSString *imageName = RCTBundlePathForURL(imageURL);
+
+  NSBundle *bundle = nil;
+  NSArray *imagePathComponents = [imageName pathComponents];
+  if ([imagePathComponents count] > 1 &&
+      [[[imagePathComponents firstObject] pathExtension] isEqualToString:@"bundle"]) {
+    NSString *bundlePath = [imagePathComponents firstObject];
+    bundle = bundleForPath([bundlePath stringByDeletingPathExtension]);
+    imageName = [imageName substringFromIndex:(bundlePath.length + 1)];
+  }
+
+  UIImage *image = nil;
+  if (bundle) {
+    image = [UIImage imageNamed:imageName inBundle:bundle compatibleWithTraitCollection:nil];
+  } else {
+    image = [UIImage imageNamed:imageName];
+  }
+
+  if (!image) {
+    // Attempt to load from the file system
+    NSData *fileData;
+    if (imageURL.pathExtension.length == 0) {
+      fileData = [NSData dataWithContentsOfURL:[imageURL URLByAppendingPathExtension:@"png"]];
+    } else {
+      fileData = [NSData dataWithContentsOfURL:imageURL];
+    }
+    image = [UIImage imageWithData:fileData];
+  }
+
+  if (!image && !bundle) {
+    // We did not find the image in the mainBundle, check in other shipped frameworks.
+    NSArray<NSURL *> *possibleFrameworks = [[NSFileManager defaultManager] contentsOfDirectoryAtURL:[[NSBundle mainBundle] privateFrameworksURL]
+                                                                        includingPropertiesForKeys:@[]
+                                                                                           options:0
+                                                                                             error:nil];
+    for (NSURL *frameworkURL in possibleFrameworks) {
+      bundle = [NSBundle bundleWithURL:frameworkURL];
+      image = [UIImage imageNamed:imageName inBundle:bundle compatibleWithTraitCollection:nil];
+      if (image) {
+        RCTLogWarn(@"Image %@ not found in mainBundle, but found in %@", imageName, bundle);
+        break;
+      }
+    }
+  }
+  return image;
+}
+
+RCT_EXTERN NSString *__nullable RCTTempFilePath(NSString *extension, NSError **error)
+{
+  static NSError *setupError = nil;
+  static NSString *directory;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    directory = [NSTemporaryDirectory() stringByAppendingPathComponent:@"ReactNative"];
+    // If the temporary directory already exists, we'll delete it to ensure
+    // that temp files from the previous run have all been deleted. This is not
+    // a security measure, it simply prevents the temp directory from using too
+    // much space, as the circumstances under which iOS clears it automatically
+    // are not well-defined.
+    NSFileManager *fileManager = [NSFileManager new];
+    if ([fileManager fileExistsAtPath:directory]) {
+      [fileManager removeItemAtPath:directory error:NULL];
+    }
+    if (![fileManager fileExistsAtPath:directory]) {
+      NSError *localError = nil;
+      if (![fileManager createDirectoryAtPath:directory
+                  withIntermediateDirectories:YES
+                                   attributes:nil
+                                        error:&localError]) {
+        // This is bad
+        RCTLogError(@"Failed to create temporary directory: %@", localError);
+        setupError = localError;
+        directory = nil;
+      }
+    }
+  });
+
+  if (!directory || setupError) {
+    if (error) {
+      *error = setupError;
+    }
+    return nil;
+  }
+
+  // Append a unique filename
+  NSString *filename = [NSUUID new].UUIDString;
+  if (extension) {
+    filename = [filename stringByAppendingPathExtension:extension];
+  }
+  return [directory stringByAppendingPathComponent:filename];
+}
+
+static void RCTGetRGBAColorComponents(CGColorRef color, CGFloat rgba[4])
+{
+  CGColorSpaceModel model = CGColorSpaceGetModel(CGColorGetColorSpace(color));
+  const CGFloat *components = CGColorGetComponents(color);
+  switch (model)
+  {
+    case kCGColorSpaceModelMonochrome:
+    {
+      rgba[0] = components[0];
+      rgba[1] = components[0];
+      rgba[2] = components[0];
+      rgba[3] = components[1];
+      break;
+    }
+    case kCGColorSpaceModelRGB:
+    {
+      rgba[0] = components[0];
+      rgba[1] = components[1];
+      rgba[2] = components[2];
+      rgba[3] = components[3];
+      break;
+    }
+    case kCGColorSpaceModelCMYK:
+    case kCGColorSpaceModelDeviceN:
+    case kCGColorSpaceModelIndexed:
+    case kCGColorSpaceModelLab:
+    case kCGColorSpaceModelPattern:
+    case kCGColorSpaceModelUnknown:
+    {
+
+#ifdef RCT_DEBUG
+      //unsupported format
+      RCTLogError(@"Unsupported color model: %i", model);
+#endif
+
+      rgba[0] = 0.0;
+      rgba[1] = 0.0;
+      rgba[2] = 0.0;
+      rgba[3] = 1.0;
+      break;
+    }
+  }
+}
+
+NSString *RCTColorToHexString(CGColorRef color)
+{
+  CGFloat rgba[4];
+  RCTGetRGBAColorComponents(color, rgba);
+  uint8_t r = rgba[0]*255;
+  uint8_t g = rgba[1]*255;
+  uint8_t b = rgba[2]*255;
+  uint8_t a = rgba[3]*255;
+  if (a < 255) {
+    return [NSString stringWithFormat:@"#%02x%02x%02x%02x", r, g, b, a];
+  } else {
+    return [NSString stringWithFormat:@"#%02x%02x%02x", r, g, b];
+  }
+}
+
+// (https://github.com/0xced/XCDFormInputAccessoryView/blob/master/XCDFormInputAccessoryView/XCDFormInputAccessoryView.m#L10-L14)
+NSString *RCTUIKitLocalizedString(NSString *string)
+{
+  NSBundle *UIKitBundle = [NSBundle bundleForClass:[UIApplication class]];
+  return UIKitBundle ? [UIKitBundle localizedStringForKey:string value:string table:nil] : string;
+}
+
+NSString *__nullable RCTGetURLQueryParam(NSURL *__nullable URL, NSString *param)
+{
+  RCTAssertParam(param);
+  if (!URL) {
+    return nil;
+  }
+
+  NSURLComponents *components = [NSURLComponents componentsWithURL:URL
+                                           resolvingAgainstBaseURL:YES];
+  for (NSURLQueryItem *queryItem in [components.queryItems reverseObjectEnumerator]) {
+    if ([queryItem.name isEqualToString:param]) {
+      return queryItem.value;
+    }
+  }
+
+  return nil;
+}
+
+NSURL *__nullable RCTURLByReplacingQueryParam(NSURL *__nullable URL, NSString *param, NSString *__nullable value)
+{
+  RCTAssertParam(param);
+  if (!URL) {
+    return nil;
+  }
+
+  NSURLComponents *components = [NSURLComponents componentsWithURL:URL
+                                           resolvingAgainstBaseURL:YES];
+
+  __block NSInteger paramIndex = NSNotFound;
+  NSMutableArray<NSURLQueryItem *> *queryItems = [components.queryItems mutableCopy];
+  [queryItems enumerateObjectsWithOptions:NSEnumerationReverse usingBlock:
+   ^(NSURLQueryItem *item, NSUInteger i, BOOL *stop) {
+     if ([item.name isEqualToString:param]) {
+       paramIndex = i;
+       *stop = YES;
+     }
+   }];
+
+  if (!value) {
+    if (paramIndex != NSNotFound) {
+      [queryItems removeObjectAtIndex:paramIndex];
+    }
+  } else {
+    NSURLQueryItem *newItem  = [NSURLQueryItem queryItemWithName:param
+                                                           value:value];
+    if (paramIndex == NSNotFound) {
+      [queryItems addObject:newItem];
+    } else {
+      [queryItems replaceObjectAtIndex:paramIndex withObject:newItem];
+    }
+  }
+  components.queryItems = queryItems;
+  return components.URL;
+}

node_modules/react-native/React/Base/RCTVersion.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>
+
+extern NSString* const RCTVersionMajor;
+extern NSString* const RCTVersionMinor;
+extern NSString* const RCTVersionPatch;
+extern NSString* const RCTVersionPrerelease;
+
+extern NSDictionary* RCTGetReactNativeVersion(void);

node_modules/react-native/React/Base/RCTVersion.m

@@ -0,0 +1,33 @@
+/**
+ * @generated by scripts/bump-oss-version.js
+ *
+ * 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 "RCTVersion.h"
+
+NSString* const RCTVersionMajor = @"major";
+NSString* const RCTVersionMinor = @"minor";
+NSString* const RCTVersionPatch = @"patch";
+NSString* const RCTVersionPrerelease = @"prerelease";
+
+static NSDictionary* __rnVersion;
+
+__attribute__((constructor))
+static void __makeVersion()
+{
+  __rnVersion = @{
+                  RCTVersionMajor: @(0),
+                  RCTVersionMinor: @(55),
+                  RCTVersionPatch: @(4),
+                  RCTVersionPrerelease: [NSNull null],
+                  };
+}
+
+NSDictionary* RCTGetReactNativeVersion(void)
+{
+  return __rnVersion;
+}

node_modules/react-native/React/Base/Surface/RCTSurface.h

@@ -0,0 +1,133 @@
+/**
+ * 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/RCTSurfaceStage.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class RCTBridge;
+@class RCTSurfaceView;
+@protocol RCTSurfaceDelegate;
+
+/**
+ * RCTSurface instance represents React Native-powered piece of a user interface
+ * which can be a full-screen app, separate modal view controller,
+ * or even small widget.
+ * It is called "Surface".
+ *
+ * The RCTSurface instance is completely thread-safe by design;
+ * it can be created on any thread, and any its method can be called from
+ * any thread (if the opposite is not mentioned explicitly).
+ *
+ * The primary goals of the RCTSurface are:
+ *  * ability to measure and layout the surface in a thread-safe
+ *    and synchronous manner;
+ *  * ability to create a UIView instance on demand (later);
+ *  * ability to communicate the current stage of the surface granularly.
+ */
+@interface RCTSurface : NSObject
+
+@property (atomic, readonly) RCTSurfaceStage stage;
+@property (atomic, readonly) RCTBridge *bridge;
+@property (atomic, readonly) NSString *moduleName;
+@property (atomic, readonly) NSNumber *rootViewTag;
+
+@property (atomic, readwrite, weak, nullable) id<RCTSurfaceDelegate> delegate;
+
+@property (atomic, copy, readwrite) NSDictionary *properties;
+
+- (instancetype)initWithBridge:(RCTBridge *)bridge
+                    moduleName:(NSString *)moduleName
+             initialProperties:(NSDictionary *)initialProperties NS_DESIGNATED_INITIALIZER;
+
+#pragma mark - Dealing with UIView representation, the Main thread only access
+
+/**
+ * Creates (if needed) and returns `UIView` instance which represents the Surface.
+ * The Surface will cache and *retain* this object.
+ * Returning the UIView instance does not mean that the Surface is ready
+ * to execute and layout. It can be just a handler which Surface will use later
+ * to mount the actual views.
+ * RCTSurface does not control (or influence in any way) the size or origin
+ * of this view. Some superview (or another owner) must use other methods
+ * of this class to setup proper layout and interop interactions with UIKit
+ * or another UI framework.
+ * This method must be called only from the main queue.
+ */
+- (RCTSurfaceView *)view;
+
+#pragma mark - Layout: Setting the size constrains
+
+/**
+ * Sets `minimumSize` and `maximumSize` layout constraints for the Surface.
+ */
+- (void)setMinimumSize:(CGSize)minimumSize
+           maximumSize:(CGSize)maximumSize;
+
+/**
+ * Previously set `minimumSize` layout constraint.
+ * Defaults to `{0, 0}`.
+ */
+@property (atomic, assign, readonly) CGSize minimumSize;
+
+/**
+ * Previously set `maximumSize` layout constraint.
+ * Defaults to `{CGFLOAT_MAX, CGFLOAT_MAX}`.
+ */
+@property (atomic, assign, readonly) CGSize maximumSize;
+
+/**
+ * Simple shortcut to `-[RCTSurface setMinimumSize:size maximumSize:size]`.
+ */
+- (void)setSize:(CGSize)size;
+
+#pragma mark - Layout: Measuring
+
+/**
+ * Measures the Surface with given constraints.
+ * This method does not cause any side effects on the surface object.
+ */
+- (CGSize)sizeThatFitsMinimumSize:(CGSize)minimumSize
+                      maximumSize:(CGSize)maximumSize;
+
+/**
+ * Return the current size of the root view based on (but not clamp by) current
+ * size constraints.
+ */
+@property (atomic, assign, readonly) CGSize intrinsicSize;
+
+#pragma mark - Synchronous waiting
+
+/**
+ * Synchronously blocks the current thread up to given `timeout` until
+ * the Surface reaches `stage`.
+ * Limitations:
+ *  - Do nothing, if called on `UIManager` queue.
+ *  - Calling on the main queue with `RCTSurfaceStageSurfaceDidInitialMounting`
+ *    stage temporary is not supported; in this case the stage will be
+ *    downgraded to `RCTSurfaceStageSurfaceDidInitialLayout`.
+ */
+- (BOOL)synchronouslyWaitForStage:(RCTSurfaceStage)stage timeout:(NSTimeInterval)timeout;
+
+#pragma mark - Mounting/Unmounting of React components
+
+/**
+ * Mount the React component specified by the given moduleName. This is typically
+ * calling runApplication.js from the native side.
+ */
+- (void)mountReactComponentWithBridge:(RCTBridge *)bridge moduleName:(NSString *)moduleName params:(NSDictionary *)params;
+
+/**
+ * Unmount the React component specified by the given rootViewTag, called from native.
+ */
+- (void)unmountReactComponentWithBridge:(RCTBridge *)bridge rootViewTag:(NSNumber *)rootViewTag;
+
+@end
+
+NS_ASSUME_NONNULL_END

node_modules/react-native/React/Base/Surface/RCTSurface.mm

@@ -0,0 +1,575 @@
+/**
+ * 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 "RCTSurface.h"
+#import "RCTSurfaceView+Internal.h"
+
+#import <mutex>
+#import <stdatomic.h>
+
+#import "RCTAssert.h"
+#import "RCTBridge+Private.h"
+#import "RCTBridge.h"
+#import "RCTShadowView+Layout.h"
+#import "RCTSurfaceDelegate.h"
+#import "RCTSurfaceRootShadowView.h"
+#import "RCTSurfaceRootShadowViewDelegate.h"
+#import "RCTSurfaceRootView.h"
+#import "RCTSurfaceView.h"
+#import "RCTTouchHandler.h"
+#import "RCTUIManager.h"
+#import "RCTUIManagerObserverCoordinator.h"
+#import "RCTUIManagerUtils.h"
+
+@interface RCTSurface () <RCTSurfaceRootShadowViewDelegate, RCTUIManagerObserver>
+@end
+
+@implementation RCTSurface {
+  // Immutable
+  RCTBridge *_bridge;
+  NSString *_moduleName;
+  NSNumber *_rootViewTag;
+
+  // Protected by the `_mutex`
+  std::mutex _mutex;
+  RCTBridge *_batchedBridge;
+  RCTSurfaceStage _stage;
+  NSDictionary *_properties;
+  CGSize _minimumSize;
+  CGSize _maximumSize;
+  CGSize _intrinsicSize;
+  RCTUIManagerMountingBlock _mountingBlock;
+
+  // The Main thread only
+  RCTSurfaceView *_Nullable _view;
+  RCTTouchHandler *_Nullable _touchHandler;
+
+  // Semaphores
+  dispatch_semaphore_t _rootShadowViewDidStartRenderingSemaphore;
+  dispatch_semaphore_t _rootShadowViewDidStartLayingOutSemaphore;
+  dispatch_semaphore_t _uiManagerDidPerformMountingSemaphore;
+
+  // Atomics
+  atomic_bool _waitingForMountingStageOnMainQueue;
+}
+
+
+- (instancetype)initWithBridge:(RCTBridge *)bridge
+                    moduleName:(NSString *)moduleName
+             initialProperties:(NSDictionary *)initialProperties
+{
+  RCTAssert(bridge.valid, @"Valid bridge is required to instanciate `RCTSurface`.");
+
+  if (self = [super init]) {
+    _bridge = bridge;
+    _batchedBridge = [_bridge batchedBridge] ?: _bridge;
+    _moduleName = moduleName;
+    _properties = [initialProperties copy];
+    _rootViewTag = RCTAllocateRootViewTag();
+
+    _rootShadowViewDidStartRenderingSemaphore = dispatch_semaphore_create(0);
+    _rootShadowViewDidStartLayingOutSemaphore = dispatch_semaphore_create(0);
+    _uiManagerDidPerformMountingSemaphore = dispatch_semaphore_create(0);
+
+    _minimumSize = CGSizeZero;
+    _maximumSize = CGSizeMake(CGFLOAT_MAX, CGFLOAT_MAX);
+
+    [[NSNotificationCenter defaultCenter] addObserver:self
+                                             selector:@selector(handleBridgeWillLoadJavaScriptNotification:)
+                                                 name:RCTJavaScriptWillStartLoadingNotification
+                                               object:_bridge];
+
+    [[NSNotificationCenter defaultCenter] addObserver:self
+                                             selector:@selector(handleBridgeDidLoadJavaScriptNotification:)
+                                                 name:RCTJavaScriptDidLoadNotification
+                                               object:_bridge];
+
+    _stage = RCTSurfaceStageSurfaceDidInitialize;
+
+    if (!bridge.loading) {
+      _stage = _stage | RCTSurfaceStageBridgeDidLoad;
+    }
+
+    [_bridge.uiManager.observerCoordinator addObserver:self];
+
+    [self _registerRootView];
+    [self _run];
+  }
+
+  return self;
+}
+
+- (void)dealloc
+{
+  [self _stop];
+  [[NSNotificationCenter defaultCenter] removeObserver:self];
+}
+
+#pragma mark - Immutable Properties (no need to enforce synchonization)
+
+- (RCTBridge *)bridge
+{
+  return _bridge;
+}
+
+- (NSString *)moduleName
+{
+  return _moduleName;
+}
+
+- (NSNumber *)rootViewTag
+{
+  return _rootViewTag;
+}
+
+#pragma mark - Convinience Internal Thread-Safe Properties
+
+- (RCTBridge *)_batchedBridge
+{
+  std::lock_guard<std::mutex> lock(_mutex);
+  return _batchedBridge;
+}
+
+- (RCTUIManager *)_uiManager
+{
+  return self._batchedBridge.uiManager;
+}
+
+#pragma mark - Main-Threaded Routines
+
+- (RCTSurfaceView *)view
+{
+  RCTAssertMainQueue();
+
+  if (!_view) {
+    _view = [[RCTSurfaceView alloc] initWithSurface:self];
+
+    _touchHandler = [[RCTTouchHandler alloc] initWithBridge:self.bridge];
+    [_touchHandler attachToView:_view];
+
+    [self _mountRootViewIfNeeded];
+  }
+
+  return _view;
+}
+
+- (void)_mountRootViewIfNeeded
+{
+  RCTAssertMainQueue();
+
+  RCTSurfaceView *view = self->_view;
+  if (!view) {
+    return;
+  }
+
+  RCTSurfaceRootView *rootView =
+    (RCTSurfaceRootView *)[self._uiManager viewForReactTag:self->_rootViewTag];
+  if (!rootView) {
+    return;
+  }
+
+  RCTAssert([rootView isKindOfClass:[RCTSurfaceRootView class]],
+    @"Received root view is not an instanse of `RCTSurfaceRootView`.");
+
+  if (rootView.superview != view) {
+    view.rootView = rootView;
+  }
+}
+
+#pragma mark - Bridge Events
+
+- (void)handleBridgeWillLoadJavaScriptNotification:(NSNotification *)notification
+{
+  RCTAssertMainQueue();
+
+  // Reset states because the bridge is reloading. This is similar to initialization phase.
+  _stage = RCTSurfaceStageSurfaceDidInitialize;
+  _view = nil;
+  _touchHandler = nil;
+  [self _setStage:RCTSurfaceStageBridgeDidLoad];
+}
+
+- (void)handleBridgeDidLoadJavaScriptNotification:(NSNotification *)notification
+{
+  RCTAssertMainQueue();
+
+  [self _setStage:RCTSurfaceStageModuleDidLoad];
+
+  RCTBridge *bridge = notification.userInfo[@"bridge"];
+
+  BOOL isRerunNeeded = NO;
+
+  {
+    std::lock_guard<std::mutex> lock(_mutex);
+
+    if (bridge != _batchedBridge) {
+      _batchedBridge = bridge;
+      isRerunNeeded = YES;
+    }
+  }
+
+  if (isRerunNeeded) {
+    [self _registerRootView];
+    [self _run];
+  }
+}
+
+#pragma mark - Stage management
+
+- (RCTSurfaceStage)stage
+{
+  std::lock_guard<std::mutex> lock(_mutex);
+  return _stage;
+}
+
+- (void)_setStage:(RCTSurfaceStage)stage
+{
+  RCTSurfaceStage updatedStage;
+  {
+    std::lock_guard<std::mutex> lock(_mutex);
+
+    if (_stage & stage) {
+      return;
+    }
+
+    updatedStage = (RCTSurfaceStage)(_stage | stage);
+    _stage = updatedStage;
+  }
+
+  [self _propagateStageChange:updatedStage];
+}
+
+- (void)_propagateStageChange:(RCTSurfaceStage)stage
+{
+  // Updating the `view`
+  RCTExecuteOnMainQueue(^{
+    self->_view.stage = stage;
+  });
+
+  // Notifying the `delegate`
+  id<RCTSurfaceDelegate> delegate = self.delegate;
+  if ([delegate respondsToSelector:@selector(surface:didChangeStage:)]) {
+    [delegate surface:self didChangeStage:stage];
+  }
+}
+
+#pragma mark - Properties Management
+
+- (NSDictionary *)properties
+{
+  std::lock_guard<std::mutex> lock(_mutex);
+  return _properties;
+}
+
+- (void)setProperties:(NSDictionary *)properties
+{
+  {
+    std::lock_guard<std::mutex> lock(_mutex);
+
+    if ([properties isEqualToDictionary:_properties]) {
+      return;
+    }
+
+    _properties = [properties copy];
+  }
+
+  [self _run];
+}
+
+#pragma mark - Running
+
+- (void)_run
+{
+  RCTBridge *batchedBridge;
+  NSDictionary *properties;
+
+  {
+    std::lock_guard<std::mutex> lock(_mutex);
+
+    batchedBridge = _batchedBridge;
+    properties = _properties;
+  }
+
+  if (!batchedBridge.valid) {
+    return;
+  }
+
+  NSDictionary *applicationParameters =
+    @{
+      @"rootTag": _rootViewTag,
+      @"initialProps": properties,
+    };
+
+  RCTLogInfo(@"Running surface %@ (%@)", _moduleName, applicationParameters);
+
+  [self mountReactComponentWithBridge:batchedBridge moduleName:_moduleName params:applicationParameters];
+
+  [self _setStage:RCTSurfaceStageSurfaceDidRun];
+}
+
+- (void)_stop
+{
+  [self unmountReactComponentWithBridge:self._batchedBridge rootViewTag:self->_rootViewTag];
+}
+
+- (void)_registerRootView
+{
+  RCTBridge *batchedBridge;
+  CGSize minimumSize;
+  CGSize maximumSize;
+
+  {
+    std::lock_guard<std::mutex> lock(_mutex);
+    batchedBridge = _batchedBridge;
+    minimumSize = _minimumSize;
+    maximumSize = _maximumSize;
+  }
+
+  RCTUIManager *uiManager = batchedBridge.uiManager;
+
+  // If we are on the main queue now, we have to proceed synchronously.
+  // Otherwise, we cannot perform synchronous waiting for some stages later.
+  (RCTIsMainQueue() ? RCTUnsafeExecuteOnUIManagerQueueSync : RCTExecuteOnUIManagerQueue)(^{
+    [uiManager registerRootViewTag:self->_rootViewTag];
+
+    RCTSurfaceRootShadowView *rootShadowView =
+      (RCTSurfaceRootShadowView *)[uiManager shadowViewForReactTag:self->_rootViewTag];
+    RCTAssert([rootShadowView isKindOfClass:[RCTSurfaceRootShadowView class]],
+      @"Received shadow view is not an instanse of `RCTSurfaceRootShadowView`.");
+
+    [rootShadowView setMinimumSize:minimumSize
+                       maximumSize:maximumSize];
+    rootShadowView.delegate = self;
+  });
+}
+
+#pragma mark - Layout
+
+- (CGSize)sizeThatFitsMinimumSize:(CGSize)minimumSize
+                      maximumSize:(CGSize)maximumSize
+{
+  RCTUIManager *uiManager = self._uiManager;
+  __block CGSize fittingSize;
+
+  RCTUnsafeExecuteOnUIManagerQueueSync(^{
+    RCTSurfaceRootShadowView *rootShadowView =
+      (RCTSurfaceRootShadowView *)[uiManager shadowViewForReactTag:self->_rootViewTag];
+
+    RCTAssert([rootShadowView isKindOfClass:[RCTSurfaceRootShadowView class]],
+      @"Received shadow view is not an instanse of `RCTSurfaceRootShadowView`.");
+
+    fittingSize = [rootShadowView sizeThatFitsMinimumSize:minimumSize
+                                              maximumSize:maximumSize];
+  });
+
+  return fittingSize;
+}
+
+#pragma mark - Size Constraints
+
+- (void)setSize:(CGSize)size
+{
+  [self setMinimumSize:size maximumSize:size];
+}
+
+- (void)setMinimumSize:(CGSize)minimumSize
+           maximumSize:(CGSize)maximumSize
+{
+  {
+    std::lock_guard<std::mutex> lock(_mutex);
+    if (CGSizeEqualToSize(minimumSize, _minimumSize) &&
+        CGSizeEqualToSize(maximumSize, _maximumSize)) {
+      return;
+    }
+
+    _maximumSize = maximumSize;
+    _minimumSize = minimumSize;
+  }
+
+  RCTUIManager *uiManager = self._uiManager;
+
+  RCTUnsafeExecuteOnUIManagerQueueSync(^{
+    RCTSurfaceRootShadowView *rootShadowView =
+      (RCTSurfaceRootShadowView *)[uiManager shadowViewForReactTag:self->_rootViewTag];
+    RCTAssert([rootShadowView isKindOfClass:[RCTSurfaceRootShadowView class]],
+      @"Received shadow view is not an instanse of `RCTSurfaceRootShadowView`.");
+
+    [rootShadowView setMinimumSize:minimumSize maximumSize:maximumSize];
+    [uiManager setNeedsLayout];
+  });
+}
+
+- (CGSize)minimumSize
+{
+  std::lock_guard<std::mutex> lock(_mutex);
+  return _minimumSize;
+}
+
+- (CGSize)maximumSize
+{
+  std::lock_guard<std::mutex> lock(_mutex);
+  return _maximumSize;
+}
+
+#pragma mark - intrinsicSize
+
+- (void)setIntrinsicSize:(CGSize)intrinsicSize
+{
+  {
+    std::lock_guard<std::mutex> lock(_mutex);
+    if (CGSizeEqualToSize(intrinsicSize, _intrinsicSize)) {
+      return;
+    }
+
+    _intrinsicSize = intrinsicSize;
+  }
+
+  // Notifying `delegate`
+  id<RCTSurfaceDelegate> delegate = self.delegate;
+  if ([delegate respondsToSelector:@selector(surface:didChangeIntrinsicSize:)]) {
+    [delegate surface:self didChangeIntrinsicSize:intrinsicSize];
+  }
+}
+
+- (CGSize)intrinsicSize
+{
+  std::lock_guard<std::mutex> lock(_mutex);
+  return _intrinsicSize;
+}
+
+#pragma mark - Synchronous Waiting
+
+- (BOOL)synchronouslyWaitForStage:(RCTSurfaceStage)stage timeout:(NSTimeInterval)timeout
+{
+  if (RCTIsUIManagerQueue()) {
+    RCTLogInfo(@"Synchronous waiting is not supported on UIManager queue.");
+    return NO;
+  }
+
+  if (RCTIsMainQueue() && (stage == RCTSurfaceStageSurfaceDidInitialMounting)) {
+    // All main-threaded execution (especially mounting process) has to be
+    // intercepted, captured and performed synchnously at the end of this method
+    // right after the semaphore signals.
+
+    // Atomic variant of `_waitingForMountingStageOnMainQueue = YES;`
+    atomic_fetch_or(&_waitingForMountingStageOnMainQueue, 1);
+  }
+
+  dispatch_semaphore_t semaphore;
+  switch (stage) {
+    case RCTSurfaceStageSurfaceDidInitialLayout:
+      semaphore = _rootShadowViewDidStartLayingOutSemaphore;
+      break;
+    case RCTSurfaceStageSurfaceDidInitialRendering:
+      semaphore = _rootShadowViewDidStartRenderingSemaphore;
+      break;
+    case RCTSurfaceStageSurfaceDidInitialMounting:
+      semaphore = _uiManagerDidPerformMountingSemaphore;
+      break;
+    default:
+      RCTAssert(NO, @"Only waiting for `RCTSurfaceStageSurfaceDidInitialRendering`, `RCTSurfaceStageSurfaceDidInitialLayout` and `RCTSurfaceStageSurfaceDidInitialMounting` stages are supported.");
+  }
+
+  BOOL timeoutOccurred = dispatch_semaphore_wait(semaphore, dispatch_time(DISPATCH_TIME_NOW, timeout * NSEC_PER_SEC));
+
+  // Atomic equivalent of `_waitingForMountingStageOnMainQueue = NO;`.
+  atomic_fetch_and(&_waitingForMountingStageOnMainQueue, 0);
+
+  if (!timeoutOccurred) {
+    // Balancing the semaphore.
+    // Note: `dispatch_semaphore_wait` reverts the decrement in case when timeout occurred.
+    dispatch_semaphore_signal(semaphore);
+  }
+
+  if (RCTIsMainQueue() && (stage == RCTSurfaceStageSurfaceDidInitialMounting)) {
+    // Time to apply captured mounting block.
+    RCTUIManagerMountingBlock mountingBlock;
+    {
+      std::lock_guard<std::mutex> lock(_mutex);
+      mountingBlock = _mountingBlock;
+      _mountingBlock = nil;
+    }
+
+    if (mountingBlock) {
+      mountingBlock();
+      [self _mountRootViewIfNeeded];
+    }
+  }
+
+  return !timeoutOccurred;
+}
+
+#pragma mark - RCTSurfaceRootShadowViewDelegate
+
+- (void)rootShadowView:(RCTRootShadowView *)rootShadowView didChangeIntrinsicSize:(CGSize)intrinsicSize
+{
+  self.intrinsicSize = intrinsicSize;
+}
+
+- (void)rootShadowViewDidStartRendering:(RCTSurfaceRootShadowView *)rootShadowView
+{
+  [self _setStage:RCTSurfaceStageSurfaceDidInitialRendering];
+
+  dispatch_semaphore_signal(_rootShadowViewDidStartRenderingSemaphore);
+}
+
+- (void)rootShadowViewDidStartLayingOut:(RCTSurfaceRootShadowView *)rootShadowView
+{
+  [self _setStage:RCTSurfaceStageSurfaceDidInitialLayout];
+
+  dispatch_semaphore_signal(_rootShadowViewDidStartLayingOutSemaphore);
+
+  RCTExecuteOnMainQueue(^{
+    // Rendering is happening, let's mount `rootView` into `view` if we already didn't do this.
+    [self _mountRootViewIfNeeded];
+  });
+}
+
+#pragma mark - RCTUIManagerObserver
+
+- (BOOL)uiManager:(RCTUIManager *)manager performMountingWithBlock:(RCTUIManagerMountingBlock)block
+{
+  if (atomic_load(&_waitingForMountingStageOnMainQueue) && (self.stage & RCTSurfaceStageSurfaceDidInitialLayout)) {
+    // Atomic equivalent of `_waitingForMountingStageOnMainQueue = NO;`.
+    atomic_fetch_and(&_waitingForMountingStageOnMainQueue, 0);
+
+    {
+      std::lock_guard<std::mutex> lock(_mutex);
+      _mountingBlock = block;
+    }
+    return YES;
+  }
+
+  return NO;
+}
+
+- (void)uiManagerDidPerformMounting:(RCTUIManager *)manager
+{
+  if (self.stage & RCTSurfaceStageSurfaceDidInitialLayout) {
+    [self _setStage:RCTSurfaceStageSurfaceDidInitialMounting];
+    dispatch_semaphore_signal(_uiManagerDidPerformMountingSemaphore);
+
+    // No need to listen to UIManager anymore.
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0), ^{
+      [self->_bridge.uiManager.observerCoordinator removeObserver:self];
+    });
+  }
+}
+
+#pragma mark - Mounting/Unmounting of React components
+
+- (void)mountReactComponentWithBridge:(RCTBridge *)bridge moduleName:(NSString *)moduleName params:(NSDictionary *)params
+{
+  [bridge enqueueJSCall:@"AppRegistry" method:@"runApplication" args:@[moduleName, params] completion:NULL];
+}
+
+- (void)unmountReactComponentWithBridge:(RCTBridge *)bridge rootViewTag:(NSNumber *)rootViewTag
+{
+  [bridge enqueueJSCall:@"AppRegistry" method:@"unmountApplicationComponentAtRootTag" args:@[rootViewTag] completion:NULL];
+}
+
+@end

node_modules/react-native/React/Base/Surface/RCTSurfaceDelegate.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 <UIKit/UIKit.h>
+
+#import <React/RCTSurfaceStage.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class RCTSurface;
+
+@protocol RCTSurfaceDelegate <NSObject>
+
+@optional
+
+/**
+ * Notifies a receiver that a surface transitioned to a new stage.
+ * See `RCTSurfaceStage` for more details.
+ */
+- (void)surface:(RCTSurface *)surface didChangeStage:(RCTSurfaceStage)stage;
+
+/**
+ * Notifies a receiver that root view got a new (intrinsic) size during the last
+ * layout pass.
+ */
+- (void)surface:(RCTSurface *)surface didChangeIntrinsicSize:(CGSize)intrinsicSize;
+
+@end
+
+NS_ASSUME_NONNULL_END

node_modules/react-native/React/Base/Surface/RCTSurfaceRootShadowView.h

@@ -0,0 +1,32 @@
+/**
+ * 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/RCTShadowView.h>
+#import <React/RCTSurfaceRootShadowViewDelegate.h>
+#import <yoga/YGEnums.h>
+
+@interface RCTSurfaceRootShadowView : RCTShadowView
+
+@property (nonatomic, assign, readonly) CGSize minimumSize;
+@property (nonatomic, assign, readonly) CGSize maximumSize;
+
+- (void)setMinimumSize:(CGSize)size maximumSize:(CGSize)maximumSize;
+
+@property (nonatomic, assign, readonly) CGSize intrinsicSize;
+
+@property (nonatomic, weak) id<RCTSurfaceRootShadowViewDelegate> delegate;
+
+/**
+ * Layout direction (LTR or RTL) inherited from native environment and
+ * is using as a base direction value in layout engine.
+ * Defaults to value inferred from current locale.
+ */
+@property (nonatomic, assign) YGDirection baseDirection;
+
+- (void)layoutWithAffectedShadowViews:(NSHashTable<RCTShadowView *> *)affectedShadowViews;
+
+@end

node_modules/react-native/React/Base/Surface/RCTSurfaceRootShadowView.m

@@ -0,0 +1,93 @@
+/**
+ * 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 "RCTSurfaceRootShadowView.h"
+
+#import "RCTI18nUtil.h"
+#import "RCTShadowView+Layout.h"
+#import "RCTUIManagerUtils.h"
+
+@implementation RCTSurfaceRootShadowView {
+  CGSize _intrinsicSize;
+  BOOL _isRendered;
+  BOOL _isLaidOut;
+}
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    self.viewName = @"RCTSurfaceRootView";
+    _baseDirection = [[RCTI18nUtil sharedInstance] isRTL] ? YGDirectionRTL : YGDirectionLTR;
+    _minimumSize = CGSizeZero;
+    _maximumSize = CGSizeMake(CGFLOAT_MAX, CGFLOAT_MAX);
+
+    self.alignSelf = YGAlignStretch;
+    self.flex = 1;
+  }
+
+  return self;
+}
+
+- (void)insertReactSubview:(RCTShadowView *)subview atIndex:(NSInteger)atIndex
+{
+  [super insertReactSubview:subview atIndex:atIndex];
+  if (!_isRendered) {
+    [_delegate rootShadowViewDidStartRendering:self];
+    _isRendered = YES;
+  }
+}
+
+- (void)layoutWithAffectedShadowViews:(NSHashTable<RCTShadowView *> *)affectedShadowViews
+{
+  NSHashTable<NSString *> *other = [NSHashTable new];
+
+  RCTLayoutContext layoutContext = {};
+  layoutContext.absolutePosition = CGPointZero;
+  layoutContext.affectedShadowViews = affectedShadowViews;
+  layoutContext.other = other;
+
+  [self layoutWithMinimumSize:_minimumSize
+                  maximumSize:_maximumSize
+              layoutDirection:RCTUIKitLayoutDirectionFromYogaLayoutDirection(_baseDirection)
+                layoutContext:layoutContext];
+
+  self.intrinsicSize = self.layoutMetrics.frame.size;
+
+  if (_isRendered && !_isLaidOut) {
+    [_delegate rootShadowViewDidStartLayingOut:self];
+    _isLaidOut = YES;
+  }
+}
+
+- (void)setMinimumSize:(CGSize)minimumSize maximumSize:(CGSize)maximumSize
+{
+  if (CGSizeEqualToSize(minimumSize, _minimumSize) &&
+      CGSizeEqualToSize(maximumSize, _maximumSize)) {
+    return;
+  }
+
+  _maximumSize = maximumSize;
+  _minimumSize = minimumSize;
+}
+
+- (void)setIntrinsicSize:(CGSize)intrinsicSize
+{
+  if (CGSizeEqualToSize(_intrinsicSize, intrinsicSize)) {
+    return;
+  }
+
+  _intrinsicSize = intrinsicSize;
+
+  [_delegate rootShadowView:self didChangeIntrinsicSize:intrinsicSize];
+}
+
+- (CGSize)intrinsicSize
+{
+  return _intrinsicSize;
+}
+
+@end

node_modules/react-native/React/Base/Surface/RCTSurfaceRootShadowViewDelegate.h

@@ -0,0 +1,22 @@
+/**
+ * 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>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class RCTSurfaceRootShadowView;
+
+@protocol RCTSurfaceRootShadowViewDelegate <NSObject>
+
+- (void)rootShadowView:(RCTSurfaceRootShadowView *)rootShadowView didChangeIntrinsicSize:(CGSize)instrinsicSize;
+- (void)rootShadowViewDidStartRendering:(RCTSurfaceRootShadowView *)rootShadowView;
+- (void)rootShadowViewDidStartLayingOut:(RCTSurfaceRootShadowView *)rootShadowView;
+
+@end
+
+NS_ASSUME_NONNULL_END

node_modules/react-native/React/Base/Surface/RCTSurfaceRootView.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 <UIKit/UIKit.h>
+
+#import <React/RCTView.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * Internal class represents Surface's root view.
+ */
+@interface RCTSurfaceRootView : RCTView
+
+@end
+
+NS_ASSUME_NONNULL_END

node_modules/react-native/React/Base/Surface/RCTSurfaceRootView.mm

@@ -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 "RCTSurfaceRootView.h"
+
+#import "RCTDefines.h"
+
+@implementation RCTSurfaceRootView
+
+RCT_NOT_IMPLEMENTED(- (nullable instancetype)initWithCoder:(NSCoder *)coder)
+
+@end

node_modules/react-native/React/Base/Surface/RCTSurfaceStage.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 <UIKit/UIKit.h>
+
+#import <React/RCTDefines.h>
+
+/**
+ * The stage of the Surface
+ */
+typedef NS_OPTIONS(NSInteger, RCTSurfaceStage) {
+  RCTSurfaceStageSurfaceDidInitialize = 1 << 0,        // Surface object was created
+  RCTSurfaceStageBridgeDidLoad = 1 << 1,               // Bridge was loaded
+  RCTSurfaceStageModuleDidLoad = 1 << 2,               // Module (JavaScript code) was loaded
+  RCTSurfaceStageSurfaceDidRun = 1 << 3,               // Module (JavaScript code) was run
+  RCTSurfaceStageSurfaceDidInitialRendering = 1 << 4,  // UIManager created the first shadow views
+  RCTSurfaceStageSurfaceDidInitialLayout = 1 << 5,     // UIManager completed the first layout pass
+  RCTSurfaceStageSurfaceDidInitialMounting = 1 << 6,   // UIManager completed the first mounting pass
+  RCTSurfaceStageSurfaceDidStop = 1 << 7,              // Surface stopped
+};
+
+/**
+ * Returns `YES` if the stage is suitable for displaying normal React Native app.
+ */
+RCT_EXTERN BOOL RCTSurfaceStageIsRunning(RCTSurfaceStage stage);
+
+/**
+ * Returns `YES` if the stage is suitable for displaying activity indicator.
+ */
+RCT_EXTERN BOOL RCTSurfaceStageIsPreparing(RCTSurfaceStage stage);

node_modules/react-native/React/Base/Surface/RCTSurfaceStage.m

@@ -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 "RCTSurfaceStage.h"
+
+BOOL RCTSurfaceStageIsRunning(RCTSurfaceStage stage) {
+  return
+    (stage & RCTSurfaceStageSurfaceDidInitialLayout) &&
+    !(stage & RCTSurfaceStageSurfaceDidStop);
+}
+
+BOOL RCTSurfaceStageIsPreparing(RCTSurfaceStage stage) {
+  return
+    !(stage & RCTSurfaceStageSurfaceDidInitialLayout) &&
+    !(stage & RCTSurfaceStageSurfaceDidStop);
+}

node_modules/react-native/React/Base/Surface/RCTSurfaceView+Internal.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/RCTSurfaceStage.h>
+#import <React/RCTSurfaceView.h>
+
+@class RCTSurfaceRootView;
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RCTSurfaceView (Internal)
+
+@property (nonatomic, strong) RCTSurfaceRootView *rootView;
+@property (nonatomic, assign) RCTSurfaceStage stage;
+
+@end
+
+NS_ASSUME_NONNULL_END

node_modules/react-native/React/Base/Surface/RCTSurfaceView.h

@@ -0,0 +1,25 @@
+/**
+ * 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>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class RCTSurface;
+
+/**
+ * UIView instance which represents the Surface
+ */
+@interface RCTSurfaceView : UIView
+
+- (instancetype)initWithSurface:(RCTSurface *)surface NS_DESIGNATED_INITIALIZER;
+
+@property (nonatomic, weak, readonly, nullable) RCTSurface *surface;
+
+@end
+
+NS_ASSUME_NONNULL_END

node_modules/react-native/React/Base/Surface/RCTSurfaceView.mm

@@ -0,0 +1,84 @@
+/**
+ * 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 "RCTSurfaceView.h"
+#import "RCTSurfaceView+Internal.h"
+
+#import "RCTDefines.h"
+#import "RCTSurface.h"
+#import "RCTSurfaceRootView.h"
+
+@implementation RCTSurfaceView {
+  RCTSurfaceRootView *_Nullable _rootView;
+  RCTSurfaceStage _stage;
+}
+
+RCT_NOT_IMPLEMENTED(- (instancetype)init)
+RCT_NOT_IMPLEMENTED(- (instancetype)initWithFrame:(CGRect)frame)
+RCT_NOT_IMPLEMENTED(- (nullable instancetype)initWithCoder:(NSCoder *)coder)
+
+- (instancetype)initWithSurface:(RCTSurface *)surface
+{
+  if (self = [super initWithFrame:CGRectZero]) {
+    _stage = surface.stage;
+    _surface = surface;
+  }
+
+  return self;
+}
+
+#pragma mark - Internal Interface
+
+- (void)setRootView:(RCTSurfaceRootView *)rootView
+{
+  if (_rootView == rootView) {
+    return;
+  }
+
+  [_rootView removeFromSuperview];
+  _rootView = rootView;
+  [self _updateStage];
+}
+
+- (RCTSurfaceRootView *)rootView
+{
+  return _rootView;
+}
+
+#pragma mark - stage
+
+- (void)setStage:(RCTSurfaceStage)stage
+{
+  if (stage == _stage) {
+    return;
+  }
+
+  _stage = stage;
+
+  [self _updateStage];
+}
+
+- (RCTSurfaceStage)stage
+{
+  return _stage;
+}
+
+#pragma mark - Private
+
+- (void)_updateStage
+{
+  if (RCTSurfaceStageIsRunning(_stage)) {
+    if (_rootView.superview != self) {
+      [self addSubview:_rootView];
+    }
+  }
+  else {
+    [_rootView removeFromSuperview];
+  }
+}
+
+@end

node_modules/react-native/React/Base/Surface/SurfaceHostingView/RCTSurfaceHostingProxyRootView.h

@@ -0,0 +1,53 @@
+/**
+ * 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/RCTRootView.h>
+
+#import "RCTSurfaceHostingView.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * This is a RCTRootView-compatible implementation of RCTSurfaceHostingView.
+ * Use this class to replace all usages of RCTRootView in the app for easier migration
+ * to RCTSurfaceHostingView.
+ *
+ * WARNING: In the future, RCTRootView will be deprecated in favor of RCTSurfaceHostingView.
+ */
+@interface RCTSurfaceHostingProxyRootView : RCTSurfaceHostingView
+
+#pragma mark RCTRootView compatibility - keep these sync'ed with RCTRootView.h
+
+@property (nonatomic, copy, readonly) NSString *moduleName;
+@property (nonatomic, strong, readonly) RCTBridge *bridge;
+@property (nonatomic, copy, readwrite) NSDictionary *appProperties;
+@property (nonatomic, assign) RCTRootViewSizeFlexibility sizeFlexibility;
+@property (nonatomic, weak) id<RCTRootViewDelegate> delegate;
+@property (nonatomic, weak) UIViewController *reactViewController;
+@property (nonatomic, strong, readonly) UIView *contentView;
+@property (nonatomic, strong) UIView *loadingView;
+@property (nonatomic, assign) BOOL passThroughTouches;
+@property (nonatomic, assign) NSTimeInterval loadingViewFadeDelay;
+@property (nonatomic, assign) NSTimeInterval loadingViewFadeDuration;
+
+- (instancetype)initWithBridge:(RCTBridge *)bridge
+                    moduleName:(NSString *)moduleName
+             initialProperties:(NSDictionary *)initialProperties NS_DESIGNATED_INITIALIZER;
+
+- (instancetype)initWithBundleURL:(NSURL *)bundleURL
+                       moduleName:(NSString *)moduleName
+                initialProperties:(NSDictionary *)initialProperties
+                    launchOptions:(NSDictionary *)launchOptions;
+
+- (void)cancelTouches;
+
+@end
+
+NS_ASSUME_NONNULL_END
+

node_modules/react-native/React/Base/Surface/SurfaceHostingView/RCTSurfaceHostingProxyRootView.mm

@@ -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 "RCTSurfaceHostingProxyRootView.h"
+
+#import <objc/runtime.h>
+
+#import "RCTAssert.h"
+#import "RCTBridge.h"
+#import "RCTLog.h"
+#import "RCTPerformanceLogger.h"
+#import "RCTProfile.h"
+#import "RCTRootContentView.h"
+#import "RCTRootViewDelegate.h"
+#import "RCTSurface.h"
+#import "UIView+React.h"
+
+static RCTSurfaceSizeMeasureMode convertToSurfaceSizeMeasureMode(RCTRootViewSizeFlexibility sizeFlexibility) {
+  switch (sizeFlexibility) {
+    case RCTRootViewSizeFlexibilityWidthAndHeight:
+      return RCTSurfaceSizeMeasureModeWidthUndefined | RCTSurfaceSizeMeasureModeHeightUndefined;
+    case RCTRootViewSizeFlexibilityWidth:
+      return RCTSurfaceSizeMeasureModeWidthUndefined | RCTSurfaceSizeMeasureModeHeightExact;
+    case RCTRootViewSizeFlexibilityHeight:
+      return RCTSurfaceSizeMeasureModeWidthExact | RCTSurfaceSizeMeasureModeHeightUndefined;
+    case RCTRootViewSizeFlexibilityNone:
+      return RCTSurfaceSizeMeasureModeWidthExact | RCTSurfaceSizeMeasureModeHeightExact;
+  }
+}
+
+static RCTRootViewSizeFlexibility convertToRootViewSizeFlexibility(RCTSurfaceSizeMeasureMode sizeMeasureMode) {
+  switch (sizeMeasureMode) {
+    case RCTSurfaceSizeMeasureModeWidthUndefined | RCTSurfaceSizeMeasureModeHeightUndefined:
+      return RCTRootViewSizeFlexibilityWidthAndHeight;
+    case RCTSurfaceSizeMeasureModeWidthUndefined | RCTSurfaceSizeMeasureModeHeightExact:
+      return RCTRootViewSizeFlexibilityWidth;
+    case RCTSurfaceSizeMeasureModeWidthExact | RCTSurfaceSizeMeasureModeHeightUndefined:
+      return RCTRootViewSizeFlexibilityHeight;
+    case RCTSurfaceSizeMeasureModeWidthExact | RCTSurfaceSizeMeasureModeHeightExact:
+    default:
+      return RCTRootViewSizeFlexibilityNone;
+  }
+}
+
+@implementation RCTSurfaceHostingProxyRootView
+
+- (instancetype)initWithBridge:(RCTBridge *)bridge
+                    moduleName:(NSString *)moduleName
+             initialProperties:(NSDictionary *)initialProperties
+{
+  RCTAssertMainQueue();
+  RCTAssert(bridge, @"A bridge instance is required to create an RCTSurfaceHostingProxyRootView");
+  RCTAssert(moduleName, @"A moduleName is required to create an RCTSurfaceHostingProxyRootView");
+
+  RCT_PROFILE_BEGIN_EVENT(RCTProfileTagAlways, @"-[RCTSurfaceHostingProxyRootView init]", nil);
+  if (!bridge.isLoading) {
+    [bridge.performanceLogger markStartForTag:RCTPLTTI];
+  }
+
+  if (self = [super initWithBridge:bridge moduleName:moduleName initialProperties:initialProperties]) {
+    self.backgroundColor = [UIColor whiteColor];
+  }
+
+  RCT_PROFILE_END_EVENT(RCTProfileTagAlways, @"");
+
+  return self;
+}
+
+- (instancetype)initWithBundleURL:(NSURL *)bundleURL
+                       moduleName:(NSString *)moduleName
+                initialProperties:(NSDictionary *)initialProperties
+                    launchOptions:(NSDictionary *)launchOptions
+{
+  RCTBridge *bridge = [[RCTBridge alloc] initWithBundleURL:bundleURL
+                                            moduleProvider:nil
+                                             launchOptions:launchOptions];
+
+  return [self initWithBridge:bridge moduleName:moduleName initialProperties:initialProperties];
+}
+
+RCT_NOT_IMPLEMENTED(- (instancetype)initWithFrame:(CGRect)frame)
+RCT_NOT_IMPLEMENTED(- (instancetype)initWithCoder:(NSCoder *)aDecoder)
+
+# pragma mark proxy methods to RCTSurfaceHostingView
+
+- (NSString *)moduleName
+{
+  return super.surface.moduleName;
+}
+
+- (RCTBridge *)bridge
+{
+  return super.surface.bridge;
+}
+
+- (UIView *)contentView
+{
+  return self;
+}
+
+- (NSNumber *)reactTag
+{
+  return super.surface.rootViewTag;
+}
+
+- (RCTRootViewSizeFlexibility)sizeFlexibility
+{
+  return convertToRootViewSizeFlexibility(super.sizeMeasureMode);
+}
+
+- (void)setSizeFlexibility:(RCTRootViewSizeFlexibility)sizeFlexibility
+{
+  super.sizeMeasureMode = convertToSurfaceSizeMeasureMode(sizeFlexibility);
+}
+
+- (NSDictionary *)appProperties
+{
+  return super.surface.properties;
+}
+
+- (void)setAppProperties:(NSDictionary *)appProperties
+{
+  [super.surface setProperties:appProperties];
+}
+
+- (CGSize)intrinsicContentSize
+{
+  return super.surface.intrinsicSize;
+}
+
+- (UIView *)loadingView
+{
+  return super.activityIndicatorViewFactory ? super.activityIndicatorViewFactory() : nil;
+}
+
+- (void)setLoadingView:(UIView *)loadingView
+{
+  super.activityIndicatorViewFactory = ^UIView *(void) {
+    return loadingView;
+  };
+}
+
+#pragma mark RCTSurfaceDelegate proxying
+
+- (void)surface:(RCTSurface *)surface didChangeStage:(RCTSurfaceStage)stage
+{
+  [super surface:surface didChangeStage:stage];
+  if (RCTSurfaceStageIsRunning(stage)) {
+    [super.surface.bridge.performanceLogger markStopForTag:RCTPLTTI];
+    dispatch_async(dispatch_get_main_queue(), ^{
+      [[NSNotificationCenter defaultCenter] postNotificationName:RCTContentDidAppearNotification
+                                                          object:self];
+    });
+  }
+}
+
+- (void)surface:(RCTSurface *)surface didChangeIntrinsicSize:(CGSize)intrinsicSize
+{
+  [super surface:surface didChangeIntrinsicSize:intrinsicSize];
+
+  [_delegate rootViewDidChangeIntrinsicSize:(RCTRootView *)self];
+}
+
+#pragma mark legacy
+
+- (UIViewController *)reactViewController
+{
+  return _reactViewController ?: [super reactViewController];
+}
+
+#pragma mark unsupported
+
+- (void)cancelTouches
+{
+  // Not supported.
+}
+
+@end
+

node_modules/react-native/React/Base/Surface/SurfaceHostingView/RCTSurfaceHostingView.h

@@ -0,0 +1,75 @@
+/**
+ * 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/RCTSurfaceDelegate.h>
+#import <React/RCTSurfaceSizeMeasureMode.h>
+#import <React/RCTSurfaceStage.h>
+
+@class RCTBridge;
+@class RCTSurface;
+
+typedef UIView *(^RCTSurfaceHostingViewActivityIndicatorViewFactory)();
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * UIView subclass which providers interoperability between UIKit and
+ * Surface regarding layout and life-cycle.
+ * This class can be used as easy-to-use general purpose integration point
+ * of ReactNative-powered experiences in UIKit based apps.
+ */
+@interface RCTSurfaceHostingView : UIView <RCTSurfaceDelegate>
+
+/**
+ * Designated initializer.
+ * Instanciates a view with given Surface object.
+ * Note: The view retains the surface object.
+ */
+- (instancetype)initWithSurface:(RCTSurface *)surface NS_DESIGNATED_INITIALIZER;
+
+/**
+ * Convenience initializer.
+ * Instanciates a Surface object with given `bridge`, `moduleName`, and
+ * `initialProperties`, and then use it to instanciate a view.
+ */
+- (instancetype)initWithBridge:(RCTBridge *)bridge
+                    moduleName:(NSString *)moduleName
+             initialProperties:(NSDictionary *)initialProperties;
+
+/**
+ * Create an instance of RCTSurface to be hosted.
+ */
+- (RCTSurface *)createSurfaceWithBridge:(RCTBridge *)bridge
+                             moduleName:(NSString *)moduleName
+                      initialProperties:(NSDictionary *)initialProperties;
+
+/**
+ * Surface object which is currently using to power the view.
+ * Read-only.
+ */
+@property (nonatomic, strong, readonly) RCTSurface *surface;
+
+/**
+ * Size measure mode which are defining relationship between UIKit and ReactNative
+ * layout approaches.
+ * Defaults to `RCTSurfaceSizeMeasureModeWidthAtMost | RCTSurfaceSizeMeasureModeHeightAtMost`.
+ */
+@property (nonatomic, assign) RCTSurfaceSizeMeasureMode sizeMeasureMode;
+
+/**
+ * Activity indicator factory.
+ * A hosting view may use this block to instantiate and display custom activity
+ * (loading) indicator (aka "spinner") when it needed.
+ * Defaults to `nil` (no activity indicator).
+ */
+@property (nonatomic, copy, nullable) RCTSurfaceHostingViewActivityIndicatorViewFactory activityIndicatorViewFactory;
+
+@end
+
+NS_ASSUME_NONNULL_END

node_modules/react-native/React/Base/Surface/SurfaceHostingView/RCTSurfaceHostingView.mm

@@ -0,0 +1,240 @@
+/**
+ * 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 "RCTSurfaceHostingView.h"
+
+#import "RCTDefines.h"
+#import "RCTSurface.h"
+#import "RCTSurfaceDelegate.h"
+#import "RCTSurfaceView.h"
+#import "RCTUtils.h"
+
+@interface RCTSurfaceHostingView ()
+
+@property (nonatomic, assign) BOOL isActivityIndicatorViewVisible;
+@property (nonatomic, assign) BOOL isSurfaceViewVisible;
+
+@end
+
+@implementation RCTSurfaceHostingView {
+  UIView *_Nullable _activityIndicatorView;
+  UIView *_Nullable _surfaceView;
+  RCTSurfaceStage _stage;
+}
+
+RCT_NOT_IMPLEMENTED(- (instancetype)init)
+RCT_NOT_IMPLEMENTED(- (instancetype)initWithFrame:(CGRect)frame)
+RCT_NOT_IMPLEMENTED(- (nullable instancetype)initWithCoder:(NSCoder *)coder)
+
+- (instancetype)initWithBridge:(RCTBridge *)bridge
+                    moduleName:(NSString *)moduleName
+             initialProperties:(NSDictionary *)initialProperties
+{
+  RCTSurface *surface = [self createSurfaceWithBridge:bridge moduleName:moduleName initialProperties:initialProperties];
+  return [self initWithSurface:surface];
+
+}
+
+- (instancetype)initWithSurface:(RCTSurface *)surface
+{
+  if (self = [super initWithFrame:CGRectZero]) {
+    _surface = surface;
+
+    _sizeMeasureMode =
+      RCTSurfaceSizeMeasureModeWidthAtMost |
+      RCTSurfaceSizeMeasureModeHeightAtMost;
+
+    _surface.delegate = self;
+    _stage = surface.stage;
+    [self _updateViews];
+  }
+
+  return self;
+}
+
+- (RCTSurface *)createSurfaceWithBridge:(RCTBridge *)bridge
+                             moduleName:(NSString *)moduleName
+                      initialProperties:(NSDictionary *)initialProperties
+{
+  return [[RCTSurface alloc] initWithBridge:bridge moduleName:moduleName initialProperties:initialProperties];
+}
+
+- (void)setFrame:(CGRect)frame
+{
+  [super setFrame:frame];
+
+  CGSize minimumSize;
+  CGSize maximumSize;
+
+  RCTSurfaceMinimumSizeAndMaximumSizeFromSizeAndSizeMeasureMode(
+    self.bounds.size,
+    _sizeMeasureMode,
+    &minimumSize,
+    &maximumSize
+  );
+
+  [_surface setMinimumSize:minimumSize
+               maximumSize:maximumSize];
+}
+
+- (CGSize)intrinsicContentSize
+{
+  if (RCTSurfaceStageIsPreparing(_stage)) {
+    if (_activityIndicatorView) {
+      return _activityIndicatorView.intrinsicContentSize;
+    }
+
+    return CGSizeZero;
+  }
+
+  return _surface.intrinsicSize;
+}
+
+- (CGSize)sizeThatFits:(CGSize)size
+{
+  if (RCTSurfaceStageIsPreparing(_stage)) {
+    if (_activityIndicatorView) {
+      return [_activityIndicatorView sizeThatFits:size];
+    }
+
+    return CGSizeZero;
+  }
+
+  CGSize minimumSize;
+  CGSize maximumSize;
+
+  RCTSurfaceMinimumSizeAndMaximumSizeFromSizeAndSizeMeasureMode(
+    size,
+    _sizeMeasureMode,
+    &minimumSize,
+    &maximumSize
+  );
+
+  return [_surface sizeThatFitsMinimumSize:minimumSize
+                               maximumSize:maximumSize];
+}
+
+- (void)setStage:(RCTSurfaceStage)stage
+{
+  if (stage == _stage) {
+    return;
+  }
+
+  BOOL shouldInvalidateLayout =
+    RCTSurfaceStageIsRunning(stage) != RCTSurfaceStageIsRunning(_stage) ||
+    RCTSurfaceStageIsPreparing(stage) != RCTSurfaceStageIsPreparing(_stage);
+
+  _stage = stage;
+
+  if (shouldInvalidateLayout) {
+    [self _invalidateLayout];
+    [self _updateViews];
+  }
+}
+
+- (void)setSizeMeasureMode:(RCTSurfaceSizeMeasureMode)sizeMeasureMode
+{
+  if (sizeMeasureMode == _sizeMeasureMode) {
+    return;
+  }
+
+  _sizeMeasureMode = sizeMeasureMode;
+  [self _invalidateLayout];
+}
+
+#pragma mark - isActivityIndicatorViewVisible
+
+- (void)setIsActivityIndicatorViewVisible:(BOOL)visible
+{
+  if (_isActivityIndicatorViewVisible == visible) {
+    return;
+  }
+
+  _isActivityIndicatorViewVisible = visible;
+
+  if (visible) {
+    if (_activityIndicatorViewFactory) {
+      _activityIndicatorView = _activityIndicatorViewFactory();
+      _activityIndicatorView.frame = self.bounds;
+      _activityIndicatorView.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
+      [self addSubview:_activityIndicatorView];
+    }
+  } else {
+    [_activityIndicatorView removeFromSuperview];
+    _activityIndicatorView = nil;
+  }
+}
+
+#pragma mark - isSurfaceViewVisible
+
+- (void)setIsSurfaceViewVisible:(BOOL)visible
+{
+  if (_isSurfaceViewVisible == visible) {
+    return;
+  }
+
+  _isSurfaceViewVisible = visible;
+
+  if (visible) {
+    _surfaceView = _surface.view;
+    _surfaceView.frame = self.bounds;
+    _surfaceView.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
+    [self addSubview:_surfaceView];
+  } else {
+    [_surfaceView removeFromSuperview];
+    _surfaceView = nil;
+  }
+}
+
+#pragma mark - activityIndicatorViewFactory
+
+- (void)setActivityIndicatorViewFactory:(RCTSurfaceHostingViewActivityIndicatorViewFactory)activityIndicatorViewFactory
+{
+  _activityIndicatorViewFactory = activityIndicatorViewFactory;
+  if (_isActivityIndicatorViewVisible) {
+    self.isActivityIndicatorViewVisible = NO;
+    self.isActivityIndicatorViewVisible = YES;
+  }
+}
+
+#pragma mark - Private stuff
+
+- (void)_invalidateLayout
+{
+  [self invalidateIntrinsicContentSize];
+  [self.superview setNeedsLayout];
+}
+
+- (void)_updateViews
+{
+  self.isSurfaceViewVisible = RCTSurfaceStageIsRunning(_stage);
+  self.isActivityIndicatorViewVisible = RCTSurfaceStageIsPreparing(_stage);
+}
+
+- (void)didMoveToWindow
+{
+  [super didMoveToWindow];
+  [self _updateViews];
+}
+
+#pragma mark - RCTSurfaceDelegate
+
+- (void)surface:(RCTSurface *)surface didChangeStage:(RCTSurfaceStage)stage
+{
+  RCTExecuteOnMainQueue(^{
+    [self setStage:stage];
+  });
+}
+
+- (void)surface:(RCTSurface *)surface didChangeIntrinsicSize:(CGSize)intrinsicSize
+{
+  RCTExecuteOnMainQueue(^{
+    [self _invalidateLayout];
+  });
+}
+
+@end

node_modules/react-native/React/Base/Surface/SurfaceHostingView/RCTSurfaceSizeMeasureMode.h

@@ -0,0 +1,33 @@
+/**
+ * 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/RCTDefines.h>
+
+/**
+ * Bitmask defines how size constrains from `-[UIView sizeThatFits:]`
+ * are translated to `-[RCTSurface sizeThatFitsMinimumSize:maximumSize:]`.
+ */
+typedef NS_OPTIONS(NSInteger, RCTSurfaceSizeMeasureMode) {
+  RCTSurfaceSizeMeasureModeWidthUndefined    = 0 << 0,
+  RCTSurfaceSizeMeasureModeWidthExact        = 1 << 0,
+  RCTSurfaceSizeMeasureModeWidthAtMost       = 2 << 0,
+  RCTSurfaceSizeMeasureModeHeightUndefined   = 0 << 2,
+  RCTSurfaceSizeMeasureModeHeightExact       = 1 << 2,
+  RCTSurfaceSizeMeasureModeHeightAtMost      = 2 << 2,
+};
+
+/**
+ * Returns size constraints based on `size` and `sizeMeasureMode`.
+ */
+RCT_EXTERN void RCTSurfaceMinimumSizeAndMaximumSizeFromSizeAndSizeMeasureMode(
+  CGSize size,
+  RCTSurfaceSizeMeasureMode sizeMeasureMode,
+  CGSize *minimumSize,
+  CGSize *maximumSize
+);

node_modules/react-native/React/Base/Surface/SurfaceHostingView/RCTSurfaceSizeMeasureMode.mm

@@ -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 "RCTSurfaceSizeMeasureMode.h"
+
+void RCTSurfaceMinimumSizeAndMaximumSizeFromSizeAndSizeMeasureMode(
+  CGSize size,
+  RCTSurfaceSizeMeasureMode sizeMeasureMode,
+  CGSize *minimumSize,
+  CGSize *maximumSize
+) {
+  *minimumSize = CGSizeZero;
+  *maximumSize = CGSizeMake(CGFLOAT_MAX, CGFLOAT_MAX);
+
+  if (sizeMeasureMode & RCTSurfaceSizeMeasureModeWidthExact) {
+    minimumSize->width = size.width;
+    maximumSize->width = size.width;
+  }
+  else if (sizeMeasureMode & RCTSurfaceSizeMeasureModeWidthAtMost) {
+    maximumSize->width = size.width;
+  }
+
+  if (sizeMeasureMode & RCTSurfaceSizeMeasureModeHeightExact) {
+    minimumSize->height = size.height;
+    maximumSize->height = size.height;
+  }
+  else if (sizeMeasureMode & RCTSurfaceSizeMeasureModeHeightAtMost) {
+    maximumSize->height = size.height;
+  }
+}

node_modules/react-native/React/CxxBridge/NSDataBigString.h

@@ -0,0 +1,38 @@
+/**
+ * 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>
+
+#include <cxxreact/JSBigString.h>
+
+namespace facebook {
+namespace react {
+
+class NSDataBigString : public JSBigString {
+public:
+  // The NSData passed in must be be null-terminated.
+  NSDataBigString(NSData *data);
+
+  // The ASCII optimization is not enabled on iOS
+  bool isAscii() const override {
+    return false;
+  }
+
+  const char *c_str() const override {
+    return (const char *)[m_data bytes];
+  }
+
+  size_t size() const override {
+    return m_length;
+  }
+
+private:
+  NSData *m_data;
+  size_t m_length;
+};
+
+} }

node_modules/react-native/React/CxxBridge/NSDataBigString.mm

@@ -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 "NSDataBigString.h"
+
+namespace facebook {
+namespace react {
+
+static NSData *ensureNullTerminated(NSData *source)
+{
+  if (!source || source.length == 0) {
+    return nil;
+  }
+
+  NSUInteger sourceLength = source.length;
+  unsigned char lastByte;
+  [source getBytes:&lastByte range:NSMakeRange(sourceLength - 1, 1)];
+
+  // TODO: bundles from the packager should always include a NULL byte
+  // or we should we relax this requirement and only read as much from the
+  // buffer as length indicates
+  if (lastByte == '\0') {
+    return source;
+  } else {
+    NSMutableData *data = [source mutableCopy];
+    unsigned char nullByte = '\0';
+    [data appendBytes:&nullByte length:1];
+    return data;
+  }
+}
+
+NSDataBigString::NSDataBigString(NSData *data)
+{
+  m_length = [data length];
+  m_data = ensureNullTerminated(data);
+}
+
+} }

node_modules/react-native/React/CxxBridge/RCTCxxBridgeDelegate.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.
+ */
+
+#include <memory>
+
+#import <React/RCTBridgeDelegate.h>
+#import <jschelpers/JavaScriptCore.h>
+
+namespace facebook {
+namespace react {
+
+class JSExecutorFactory;
+
+}
+}
+
+// This is a separate class so non-C++ implementations don't need to
+// take a C++ dependency.
+
+@protocol RCTCxxBridgeDelegate <RCTBridgeDelegate>
+
+/**
+ * In the RCTCxxBridge, if this method is implemented, return a
+ * ExecutorFactory instance which can be used to create the executor.
+ * If not implemented, or returns an empty pointer, JSCExecutorFactory
+ * will be used.
+ */
+- (std::unique_ptr<facebook::react::JSExecutorFactory>)jsExecutorFactoryForBridge:(RCTBridge *)bridge;
+
+@optional
+
+/**
+ * Experimental: Perform installation of extra JS binding on the given JS context, as appropriate.
+ */
+- (void)installExtraJSBinding:(JSGlobalContextRef)jsContextRef;
+
+/**
+ * Experimental: Get the instance of the extra module/class which gets bound via `installExtraJSBinding:`
+ */
+- (id)jsBoundExtraModuleForClass:(Class)moduleClass;
+
+@end

node_modules/react-native/React/CxxBridge/RCTJSCHelpers.h

@@ -0,0 +1,17 @@
+// Copyright 2004-present Facebook. All Rights Reserved.
+
+/**
+ * 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.
+ */
+
+#pragma once
+
+/**
+ * This must be invoked on iOS to set up platform dependencies before
+ * creating an instance of JSCExecutor.
+ */
+
+void RCTPrepareJSCExecutor();

node_modules/react-native/React/CxxBridge/RCTJSCHelpers.mm

@@ -0,0 +1,52 @@
+// Copyright 2004-present Facebook. All Rights Reserved.
+
+/**
+ * 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.
+ */
+
+#include "RCTJSCHelpers.h"
+
+#import <Foundation/Foundation.h>
+
+#import <React/RCTBridge+Private.h>
+#import <React/RCTCxxUtils.h>
+#import <React/RCTLog.h>
+#import <cxxreact/Platform.h>
+#import <jschelpers/Value.h>
+
+using namespace facebook::react;
+
+namespace {
+
+JSValueRef nativeLoggingHook(
+    JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount,
+    const JSValueRef arguments[], JSValueRef *exception) {
+  RCTLogLevel level = RCTLogLevelInfo;
+  if (argumentCount > 1) {
+    level = MAX(level, (RCTLogLevel)Value(ctx, arguments[1]).asNumber());
+  }
+  if (argumentCount > 0) {
+    JSContext *contextObj = contextForGlobalContextRef(JSC_JSContextGetGlobalContext(ctx));
+    JSValue *msg = [JSC_JSValue(ctx) valueWithJSValueRef:arguments[0] inContext:contextObj];
+    _RCTLogJavaScriptInternal(level, [msg toString]);
+  }
+  return Value::makeUndefined(ctx);
+}
+
+JSValueRef nativePerformanceNow(
+    JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount,
+    const JSValueRef arguments[], JSValueRef *exception) {
+  return Value::makeNumber(ctx, CACurrentMediaTime() * 1000);
+}
+
+}
+
+void RCTPrepareJSCExecutor() {
+  ReactMarker::logTaggedMarker = [](const ReactMarker::ReactMarkerId, const char *tag) {};
+  JSCNativeHooks::loggingHook = nativeLoggingHook;
+  JSCNativeHooks::nowHook = nativePerformanceNow;
+  JSCNativeHooks::installPerfHooks = RCTFBQuickPerformanceLoggerConfigureHooks;
+}