add files

+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#import <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

+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#import "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];
+}

+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#import <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

+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#import <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 starts loading the JS bundle.
+ */
+RCT_EXTERN NSString *const RCTJavaScriptWillStartLoadingNotification;
+
+/**
+ * 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 is used to call functions in the JavaScript application context
+ * synchronously.  This is intended for use by applications which do their own
+ * thread management and are careful to manage multi-threaded access to the JSVM.
+ * See also -[RCTBridgeDelgate shouldBridgeLoadJavaScriptSynchronously], which
+ * may be needed to ensure that any requires JS code is loaded before this method
+ * is called.  If the underlying executor is not JSC, this will return nil.  Safe
+ * to call from any thread.
+ *
+ * @experimental
+ */
+- (JSValue *)callFunctionOnModule:(NSString *)module
+                           method:(NSString *)method
+                        arguments:(NSArray *)arguments
+                            error:(NSError **)error;
+
+/**
+ * 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;
+
+/**
+ * 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

+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#import "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 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];
+}
+
+- (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];
+}
+
+- (JSValue *)callFunctionOnModule:(NSString *)module
+                           method:(NSString *)method
+                        arguments:(NSArray *)arguments
+                            error:(NSError **)error
+{
+  return [self.batchedBridge callFunctionOnModule:module method:method arguments:arguments error:error];
+}
+
+- (void)registerSegmentWithId:(NSUInteger)segmentId path:(NSString *)path
+{
+  [self.batchedBridge registerSegmentWithId:segmentId path:path];
+}
+
+- (JSGlobalContextRef)jsContextRef
+{
+  return [self.batchedBridge jsContextRef];
+}
+
+@end

+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#import <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

+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#import <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

+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#import <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;
+
+/**
+ * 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;
+
+/**
+ * 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

+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#import <Foundation/Foundation.h>
+
+extern NSString *const RCTBundleURLProviderUpdatedNotification;
+
+extern const NSUInteger kRCTBundleURLProviderDefaultPort;
+
+@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

+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#import "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

+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#import <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                          \
+{                                              \
+  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                                     \
+{                                                         \
+  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                                     \
+{                                                         \
+  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              \
+{                                                      \
+  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)

+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#import "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

+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#import <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

+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#import "RCTCxxConvert.h"
+
+@implementation RCTCxxConvert
+
+@end

+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#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)
+
+/**
+ * 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")

+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#import <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

+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#import "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

+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#import <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

+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#import <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

+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#import "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

+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#import <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

+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#import "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

+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#import <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

+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#import <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

+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#import <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

+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#import "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

+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#import <Foundation/Foundation.h>
+
+@protocol RCTInvalidating <NSObject>
+
+- (void)invalidate;
+
+@end

+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#import <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);

+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#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);
+}

+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#import <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

+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#import "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

+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#import <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

+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#import <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

+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#import "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

+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#import <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