initial commit taken from gitlab.lrz.de

node_modules/react-native/.flowconfig

@@ -0,0 +1,55 @@
+[ignore]
+; We fork some components by platform
+.*/*[.]android.js
+
+; Ignore templates for 'react-native init'
+.*/local-cli/templates/.*
+
+; Ignore the Dangerfile
+<PROJECT_ROOT>/bots/dangerfile.js
+
+; Ignore "BUCK" generated dirs
+<PROJECT_ROOT>/\.buckd/
+
+; Ignore unexpected extra "@providesModule"
+.*/node_modules/.*/node_modules/fbjs/.*
+
+; Ignore duplicate module providers
+; For RN Apps installed via npm, "Libraries" folder is inside
+; "node_modules/react-native" but in the source repo it is in the root
+.*/Libraries/react-native/React.js
+
+; Ignore polyfills
+.*/Libraries/polyfills/.*
+
+; Ignore metro
+.*/node_modules/metro/.*
+
+[include]
+
+[libs]
+Libraries/react-native/react-native-interface.js
+flow/
+flow-github/
+
+[options]
+emoji=true
+
+module.system=haste
+
+munge_underscores=true
+
+module.name_mapper='^[./a-zA-Z0-9$_-]+\.\(bmp\|gif\|jpg\|jpeg\|png\|psd\|svg\|webp\|m4v\|mov\|mp4\|mpeg\|mpg\|webm\|aac\|aiff\|caf\|m4a\|mp3\|wav\|html\|pdf\)$' -> 'RelativeImageStub'
+
+suppress_type=$FlowIssue
+suppress_type=$FlowFixMe
+suppress_type=$FlowFixMeProps
+suppress_type=$FlowFixMeState
+
+suppress_comment=\\(.\\|\n\\)*\\$FlowFixMe\\($\\|[^(]\\|(\\(<VERSION>\\)? *\\(site=[a-z,_]*[react_native_oss|react_native_fb][a-z,_]*\\)?)\\)
+suppress_comment=\\(.\\|\n\\)*\\$FlowIssue\\((\\(<VERSION>\\)? *\\(site=[a-z,_]*[react_native_oss|react_native_fb][a-z,_]*\\)?)\\)?:? #[0-9]+
+suppress_comment=\\(.\\|\n\\)*\\$FlowFixedInNextDeploy
+suppress_comment=\\(.\\|\n\\)*\\$FlowExpectedError
+
+[version]
+^0.67.0

node_modules/react-native/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2015-present, Facebook, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/react-native/Libraries/.npmignore

@@ -0,0 +1 @@
+__tests__

node_modules/react-native/Libraries/ART/ART.xcodeproj/project.pbxproj

@@ -0,0 +1,491 @@
+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 46;
+	objects = {
+
+/* Begin PBXBuildFile section */
+		0CF68B051AF0549300FF9E5C /* ARTGroup.m in Sources */ = {isa = PBXBuildFile; fileRef = 0CF68ADE1AF0549300FF9E5C /* ARTGroup.m */; };
+		0CF68B061AF0549300FF9E5C /* ARTNode.m in Sources */ = {isa = PBXBuildFile; fileRef = 0CF68AE01AF0549300FF9E5C /* ARTNode.m */; };
+		0CF68B071AF0549300FF9E5C /* ARTRenderable.m in Sources */ = {isa = PBXBuildFile; fileRef = 0CF68AE21AF0549300FF9E5C /* ARTRenderable.m */; };
+		0CF68B081AF0549300FF9E5C /* ARTShape.m in Sources */ = {isa = PBXBuildFile; fileRef = 0CF68AE41AF0549300FF9E5C /* ARTShape.m */; };
+		0CF68B091AF0549300FF9E5C /* ARTSurfaceView.m in Sources */ = {isa = PBXBuildFile; fileRef = 0CF68AE61AF0549300FF9E5C /* ARTSurfaceView.m */; };
+		0CF68B0A1AF0549300FF9E5C /* ARTText.m in Sources */ = {isa = PBXBuildFile; fileRef = 0CF68AE81AF0549300FF9E5C /* ARTText.m */; };
+		0CF68B0B1AF0549300FF9E5C /* ARTBrush.m in Sources */ = {isa = PBXBuildFile; fileRef = 0CF68AEC1AF0549300FF9E5C /* ARTBrush.m */; };
+		0CF68B0C1AF0549300FF9E5C /* ARTLinearGradient.m in Sources */ = {isa = PBXBuildFile; fileRef = 0CF68AEE1AF0549300FF9E5C /* ARTLinearGradient.m */; };
+		0CF68B0D1AF0549300FF9E5C /* ARTPattern.m in Sources */ = {isa = PBXBuildFile; fileRef = 0CF68AF01AF0549300FF9E5C /* ARTPattern.m */; };
+		0CF68B0E1AF0549300FF9E5C /* ARTRadialGradient.m in Sources */ = {isa = PBXBuildFile; fileRef = 0CF68AF21AF0549300FF9E5C /* ARTRadialGradient.m */; };
+		0CF68B0F1AF0549300FF9E5C /* ARTSolidColor.m in Sources */ = {isa = PBXBuildFile; fileRef = 0CF68AF41AF0549300FF9E5C /* ARTSolidColor.m */; };
+		0CF68B101AF0549300FF9E5C /* RCTConvert+ART.m in Sources */ = {isa = PBXBuildFile; fileRef = 0CF68AF71AF0549300FF9E5C /* RCTConvert+ART.m */; };
+		0CF68B111AF0549300FF9E5C /* ARTGroupManager.m in Sources */ = {isa = PBXBuildFile; fileRef = 0CF68AFA1AF0549300FF9E5C /* ARTGroupManager.m */; };
+		0CF68B121AF0549300FF9E5C /* ARTNodeManager.m in Sources */ = {isa = PBXBuildFile; fileRef = 0CF68AFC1AF0549300FF9E5C /* ARTNodeManager.m */; };
+		0CF68B131AF0549300FF9E5C /* ARTRenderableManager.m in Sources */ = {isa = PBXBuildFile; fileRef = 0CF68AFE1AF0549300FF9E5C /* ARTRenderableManager.m */; };
+		0CF68B141AF0549300FF9E5C /* ARTShapeManager.m in Sources */ = {isa = PBXBuildFile; fileRef = 0CF68B001AF0549300FF9E5C /* ARTShapeManager.m */; };
+		0CF68B151AF0549300FF9E5C /* ARTSurfaceViewManager.m in Sources */ = {isa = PBXBuildFile; fileRef = 0CF68B021AF0549300FF9E5C /* ARTSurfaceViewManager.m */; };
+		0CF68B161AF0549300FF9E5C /* ARTTextManager.m in Sources */ = {isa = PBXBuildFile; fileRef = 0CF68B041AF0549300FF9E5C /* ARTTextManager.m */; };
+		325CF7AD1E5F2ABA00AC9606 /* ARTBrush.m in Sources */ = {isa = PBXBuildFile; fileRef = 0CF68AEC1AF0549300FF9E5C /* ARTBrush.m */; };
+		325CF7AE1E5F2ABA00AC9606 /* ARTLinearGradient.m in Sources */ = {isa = PBXBuildFile; fileRef = 0CF68AEE1AF0549300FF9E5C /* ARTLinearGradient.m */; };
+		325CF7AF1E5F2ABA00AC9606 /* ARTPattern.m in Sources */ = {isa = PBXBuildFile; fileRef = 0CF68AF01AF0549300FF9E5C /* ARTPattern.m */; };
+		325CF7B01E5F2ABA00AC9606 /* ARTRadialGradient.m in Sources */ = {isa = PBXBuildFile; fileRef = 0CF68AF21AF0549300FF9E5C /* ARTRadialGradient.m */; };
+		325CF7B11E5F2ABA00AC9606 /* ARTSolidColor.m in Sources */ = {isa = PBXBuildFile; fileRef = 0CF68AF41AF0549300FF9E5C /* ARTSolidColor.m */; };
+		325CF7B21E5F2ABA00AC9606 /* ARTGroupManager.m in Sources */ = {isa = PBXBuildFile; fileRef = 0CF68AFA1AF0549300FF9E5C /* ARTGroupManager.m */; };
+		325CF7B31E5F2ABA00AC9606 /* ARTNodeManager.m in Sources */ = {isa = PBXBuildFile; fileRef = 0CF68AFC1AF0549300FF9E5C /* ARTNodeManager.m */; };
+		325CF7B41E5F2ABA00AC9606 /* ARTRenderableManager.m in Sources */ = {isa = PBXBuildFile; fileRef = 0CF68AFE1AF0549300FF9E5C /* ARTRenderableManager.m */; };
+		325CF7B51E5F2ABA00AC9606 /* ARTShapeManager.m in Sources */ = {isa = PBXBuildFile; fileRef = 0CF68B001AF0549300FF9E5C /* ARTShapeManager.m */; };
+		325CF7B61E5F2ABA00AC9606 /* ARTSurfaceViewManager.m in Sources */ = {isa = PBXBuildFile; fileRef = 0CF68B021AF0549300FF9E5C /* ARTSurfaceViewManager.m */; };
+		325CF7B71E5F2ABA00AC9606 /* ARTTextManager.m in Sources */ = {isa = PBXBuildFile; fileRef = 0CF68B041AF0549300FF9E5C /* ARTTextManager.m */; };
+		325CF7B81E5F2ABA00AC9606 /* ARTGroup.m in Sources */ = {isa = PBXBuildFile; fileRef = 0CF68ADE1AF0549300FF9E5C /* ARTGroup.m */; };
+		325CF7B91E5F2ABA00AC9606 /* ARTNode.m in Sources */ = {isa = PBXBuildFile; fileRef = 0CF68AE01AF0549300FF9E5C /* ARTNode.m */; };
+		325CF7BA1E5F2ABA00AC9606 /* ARTRenderable.m in Sources */ = {isa = PBXBuildFile; fileRef = 0CF68AE21AF0549300FF9E5C /* ARTRenderable.m */; };
+		325CF7BB1E5F2ABA00AC9606 /* ARTShape.m in Sources */ = {isa = PBXBuildFile; fileRef = 0CF68AE41AF0549300FF9E5C /* ARTShape.m */; };
+		325CF7BC1E5F2ABA00AC9606 /* ARTSurfaceView.m in Sources */ = {isa = PBXBuildFile; fileRef = 0CF68AE61AF0549300FF9E5C /* ARTSurfaceView.m */; };
+		325CF7BD1E5F2ABA00AC9606 /* ARTText.m in Sources */ = {isa = PBXBuildFile; fileRef = 0CF68AE81AF0549300FF9E5C /* ARTText.m */; };
+		325CF7BE1E5F2ABA00AC9606 /* RCTConvert+ART.m in Sources */ = {isa = PBXBuildFile; fileRef = 0CF68AF71AF0549300FF9E5C /* RCTConvert+ART.m */; };
+/* End PBXBuildFile section */
+
+/* Begin PBXCopyFilesBuildPhase section */
+		0CF68ABF1AF0540F00FF9E5C /* CopyFiles */ = {
+			isa = PBXCopyFilesBuildPhase;
+			buildActionMask = 2147483647;
+			dstPath = "include/$(PRODUCT_NAME)";
+			dstSubfolderSpec = 16;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		323A12851E5F266B004975B8 /* CopyFiles */ = {
+			isa = PBXCopyFilesBuildPhase;
+			buildActionMask = 2147483647;
+			dstPath = "include/$(PRODUCT_NAME)";
+			dstSubfolderSpec = 16;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXCopyFilesBuildPhase section */
+
+/* Begin PBXFileReference section */
+		0CF68AC11AF0540F00FF9E5C /* libART.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libART.a; sourceTree = BUILT_PRODUCTS_DIR; };
+		0CF68ADB1AF0549300FF9E5C /* ARTCGFloatArray.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ARTCGFloatArray.h; sourceTree = "<group>"; };
+		0CF68ADC1AF0549300FF9E5C /* ARTContainer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ARTContainer.h; sourceTree = "<group>"; };
+		0CF68ADD1AF0549300FF9E5C /* ARTGroup.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ARTGroup.h; sourceTree = "<group>"; };
+		0CF68ADE1AF0549300FF9E5C /* ARTGroup.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ARTGroup.m; sourceTree = "<group>"; };
+		0CF68ADF1AF0549300FF9E5C /* ARTNode.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ARTNode.h; sourceTree = "<group>"; };
+		0CF68AE01AF0549300FF9E5C /* ARTNode.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ARTNode.m; sourceTree = "<group>"; };
+		0CF68AE11AF0549300FF9E5C /* ARTRenderable.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ARTRenderable.h; sourceTree = "<group>"; };
+		0CF68AE21AF0549300FF9E5C /* ARTRenderable.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ARTRenderable.m; sourceTree = "<group>"; };
+		0CF68AE31AF0549300FF9E5C /* ARTShape.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ARTShape.h; sourceTree = "<group>"; };
+		0CF68AE41AF0549300FF9E5C /* ARTShape.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ARTShape.m; sourceTree = "<group>"; };
+		0CF68AE51AF0549300FF9E5C /* ARTSurfaceView.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ARTSurfaceView.h; sourceTree = "<group>"; };
+		0CF68AE61AF0549300FF9E5C /* ARTSurfaceView.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ARTSurfaceView.m; sourceTree = "<group>"; };
+		0CF68AE71AF0549300FF9E5C /* ARTText.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ARTText.h; sourceTree = "<group>"; };
+		0CF68AE81AF0549300FF9E5C /* ARTText.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ARTText.m; sourceTree = "<group>"; };
+		0CF68AE91AF0549300FF9E5C /* ARTTextFrame.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ARTTextFrame.h; sourceTree = "<group>"; };
+		0CF68AEB1AF0549300FF9E5C /* ARTBrush.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ARTBrush.h; sourceTree = "<group>"; };
+		0CF68AEC1AF0549300FF9E5C /* ARTBrush.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ARTBrush.m; sourceTree = "<group>"; };
+		0CF68AED1AF0549300FF9E5C /* ARTLinearGradient.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ARTLinearGradient.h; sourceTree = "<group>"; };
+		0CF68AEE1AF0549300FF9E5C /* ARTLinearGradient.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ARTLinearGradient.m; sourceTree = "<group>"; };
+		0CF68AEF1AF0549300FF9E5C /* ARTPattern.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ARTPattern.h; sourceTree = "<group>"; };
+		0CF68AF01AF0549300FF9E5C /* ARTPattern.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ARTPattern.m; sourceTree = "<group>"; };
+		0CF68AF11AF0549300FF9E5C /* ARTRadialGradient.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ARTRadialGradient.h; sourceTree = "<group>"; };
+		0CF68AF21AF0549300FF9E5C /* ARTRadialGradient.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ARTRadialGradient.m; sourceTree = "<group>"; };
+		0CF68AF31AF0549300FF9E5C /* ARTSolidColor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ARTSolidColor.h; sourceTree = "<group>"; };
+		0CF68AF41AF0549300FF9E5C /* ARTSolidColor.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ARTSolidColor.m; sourceTree = "<group>"; };
+		0CF68AF61AF0549300FF9E5C /* RCTConvert+ART.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "RCTConvert+ART.h"; sourceTree = "<group>"; };
+		0CF68AF71AF0549300FF9E5C /* RCTConvert+ART.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "RCTConvert+ART.m"; sourceTree = "<group>"; };
+		0CF68AF91AF0549300FF9E5C /* ARTGroupManager.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ARTGroupManager.h; sourceTree = "<group>"; };
+		0CF68AFA1AF0549300FF9E5C /* ARTGroupManager.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ARTGroupManager.m; sourceTree = "<group>"; };
+		0CF68AFB1AF0549300FF9E5C /* ARTNodeManager.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ARTNodeManager.h; sourceTree = "<group>"; };
+		0CF68AFC1AF0549300FF9E5C /* ARTNodeManager.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ARTNodeManager.m; sourceTree = "<group>"; };
+		0CF68AFD1AF0549300FF9E5C /* ARTRenderableManager.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ARTRenderableManager.h; sourceTree = "<group>"; };
+		0CF68AFE1AF0549300FF9E5C /* ARTRenderableManager.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ARTRenderableManager.m; sourceTree = "<group>"; };
+		0CF68AFF1AF0549300FF9E5C /* ARTShapeManager.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ARTShapeManager.h; sourceTree = "<group>"; };
+		0CF68B001AF0549300FF9E5C /* ARTShapeManager.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ARTShapeManager.m; sourceTree = "<group>"; };
+		0CF68B011AF0549300FF9E5C /* ARTSurfaceViewManager.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ARTSurfaceViewManager.h; sourceTree = "<group>"; };
+		0CF68B021AF0549300FF9E5C /* ARTSurfaceViewManager.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ARTSurfaceViewManager.m; sourceTree = "<group>"; };
+		0CF68B031AF0549300FF9E5C /* ARTTextManager.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ARTTextManager.h; sourceTree = "<group>"; };
+		0CF68B041AF0549300FF9E5C /* ARTTextManager.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ARTTextManager.m; sourceTree = "<group>"; };
+		323A12871E5F266B004975B8 /* libART-tvOS.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = "libART-tvOS.a"; sourceTree = BUILT_PRODUCTS_DIR; };
+/* End PBXFileReference section */
+
+/* Begin PBXFrameworksBuildPhase section */
+		0CF68ABE1AF0540F00FF9E5C /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		323A12841E5F266B004975B8 /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXFrameworksBuildPhase section */
+
+/* Begin PBXGroup section */
+		0CF68AB81AF0540F00FF9E5C = {
+			isa = PBXGroup;
+			children = (
+				0CF68AEA1AF0549300FF9E5C /* Brushes */,
+				0CF68AF81AF0549300FF9E5C /* ViewManagers */,
+				0CF68ADB1AF0549300FF9E5C /* ARTCGFloatArray.h */,
+				0CF68ADC1AF0549300FF9E5C /* ARTContainer.h */,
+				0CF68ADD1AF0549300FF9E5C /* ARTGroup.h */,
+				0CF68ADE1AF0549300FF9E5C /* ARTGroup.m */,
+				0CF68ADF1AF0549300FF9E5C /* ARTNode.h */,
+				0CF68AE01AF0549300FF9E5C /* ARTNode.m */,
+				0CF68AE11AF0549300FF9E5C /* ARTRenderable.h */,
+				0CF68AE21AF0549300FF9E5C /* ARTRenderable.m */,
+				0CF68AE31AF0549300FF9E5C /* ARTShape.h */,
+				0CF68AE41AF0549300FF9E5C /* ARTShape.m */,
+				0CF68AE51AF0549300FF9E5C /* ARTSurfaceView.h */,
+				0CF68AE61AF0549300FF9E5C /* ARTSurfaceView.m */,
+				0CF68AE71AF0549300FF9E5C /* ARTText.h */,
+				0CF68AE81AF0549300FF9E5C /* ARTText.m */,
+				0CF68AE91AF0549300FF9E5C /* ARTTextFrame.h */,
+				0CF68AF61AF0549300FF9E5C /* RCTConvert+ART.h */,
+				0CF68AF71AF0549300FF9E5C /* RCTConvert+ART.m */,
+				0CF68AC21AF0540F00FF9E5C /* Products */,
+			);
+			indentWidth = 2;
+			sourceTree = "<group>";
+			tabWidth = 2;
+			usesTabs = 0;
+		};
+		0CF68AC21AF0540F00FF9E5C /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				0CF68AC11AF0540F00FF9E5C /* libART.a */,
+				323A12871E5F266B004975B8 /* libART-tvOS.a */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		0CF68AEA1AF0549300FF9E5C /* Brushes */ = {
+			isa = PBXGroup;
+			children = (
+				0CF68AEB1AF0549300FF9E5C /* ARTBrush.h */,
+				0CF68AEC1AF0549300FF9E5C /* ARTBrush.m */,
+				0CF68AED1AF0549300FF9E5C /* ARTLinearGradient.h */,
+				0CF68AEE1AF0549300FF9E5C /* ARTLinearGradient.m */,
+				0CF68AEF1AF0549300FF9E5C /* ARTPattern.h */,
+				0CF68AF01AF0549300FF9E5C /* ARTPattern.m */,
+				0CF68AF11AF0549300FF9E5C /* ARTRadialGradient.h */,
+				0CF68AF21AF0549300FF9E5C /* ARTRadialGradient.m */,
+				0CF68AF31AF0549300FF9E5C /* ARTSolidColor.h */,
+				0CF68AF41AF0549300FF9E5C /* ARTSolidColor.m */,
+			);
+			path = Brushes;
+			sourceTree = "<group>";
+		};
+		0CF68AF81AF0549300FF9E5C /* ViewManagers */ = {
+			isa = PBXGroup;
+			children = (
+				0CF68AF91AF0549300FF9E5C /* ARTGroupManager.h */,
+				0CF68AFA1AF0549300FF9E5C /* ARTGroupManager.m */,
+				0CF68AFB1AF0549300FF9E5C /* ARTNodeManager.h */,
+				0CF68AFC1AF0549300FF9E5C /* ARTNodeManager.m */,
+				0CF68AFD1AF0549300FF9E5C /* ARTRenderableManager.h */,
+				0CF68AFE1AF0549300FF9E5C /* ARTRenderableManager.m */,
+				0CF68AFF1AF0549300FF9E5C /* ARTShapeManager.h */,
+				0CF68B001AF0549300FF9E5C /* ARTShapeManager.m */,
+				0CF68B011AF0549300FF9E5C /* ARTSurfaceViewManager.h */,
+				0CF68B021AF0549300FF9E5C /* ARTSurfaceViewManager.m */,
+				0CF68B031AF0549300FF9E5C /* ARTTextManager.h */,
+				0CF68B041AF0549300FF9E5C /* ARTTextManager.m */,
+			);
+			path = ViewManagers;
+			sourceTree = "<group>";
+		};
+/* End PBXGroup section */
+
+/* Begin PBXNativeTarget section */
+		0CF68AC01AF0540F00FF9E5C /* ART */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 0CF68AD51AF0540F00FF9E5C /* Build configuration list for PBXNativeTarget "ART" */;
+			buildPhases = (
+				0CF68ABD1AF0540F00FF9E5C /* Sources */,
+				0CF68ABE1AF0540F00FF9E5C /* Frameworks */,
+				0CF68ABF1AF0540F00FF9E5C /* CopyFiles */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = ART;
+			productName = ART;
+			productReference = 0CF68AC11AF0540F00FF9E5C /* libART.a */;
+			productType = "com.apple.product-type.library.static";
+		};
+		323A12861E5F266B004975B8 /* ART-tvOS */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 323A128D1E5F266B004975B8 /* Build configuration list for PBXNativeTarget "ART-tvOS" */;
+			buildPhases = (
+				323A12831E5F266B004975B8 /* Sources */,
+				323A12841E5F266B004975B8 /* Frameworks */,
+				323A12851E5F266B004975B8 /* CopyFiles */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = "ART-tvOS";
+			productName = "ART-tvOS";
+			productReference = 323A12871E5F266B004975B8 /* libART-tvOS.a */;
+			productType = "com.apple.product-type.library.static";
+		};
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+		0CF68AB91AF0540F00FF9E5C /* Project object */ = {
+			isa = PBXProject;
+			attributes = {
+				LastUpgradeCheck = 0620;
+				TargetAttributes = {
+					0CF68AC01AF0540F00FF9E5C = {
+						CreatedOnToolsVersion = 6.2;
+					};
+					323A12861E5F266B004975B8 = {
+						CreatedOnToolsVersion = 6.2;
+						ProvisioningStyle = Automatic;
+					};
+				};
+			};
+			buildConfigurationList = 0CF68ABC1AF0540F00FF9E5C /* Build configuration list for PBXProject "ART" */;
+			compatibilityVersion = "Xcode 3.2";
+			developmentRegion = English;
+			hasScannedForEncodings = 0;
+			knownRegions = (
+				en,
+			);
+			mainGroup = 0CF68AB81AF0540F00FF9E5C;
+			productRefGroup = 0CF68AC21AF0540F00FF9E5C /* Products */;
+			projectDirPath = "";
+			projectRoot = "";
+			targets = (
+				0CF68AC01AF0540F00FF9E5C /* ART */,
+				323A12861E5F266B004975B8 /* ART-tvOS */,
+			);
+		};
+/* End PBXProject section */
+
+/* Begin PBXSourcesBuildPhase section */
+		0CF68ABD1AF0540F00FF9E5C /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				0CF68B161AF0549300FF9E5C /* ARTTextManager.m in Sources */,
+				0CF68B111AF0549300FF9E5C /* ARTGroupManager.m in Sources */,
+				0CF68B0D1AF0549300FF9E5C /* ARTPattern.m in Sources */,
+				0CF68B0A1AF0549300FF9E5C /* ARTText.m in Sources */,
+				0CF68B121AF0549300FF9E5C /* ARTNodeManager.m in Sources */,
+				0CF68B051AF0549300FF9E5C /* ARTGroup.m in Sources */,
+				0CF68B131AF0549300FF9E5C /* ARTRenderableManager.m in Sources */,
+				0CF68B091AF0549300FF9E5C /* ARTSurfaceView.m in Sources */,
+				0CF68B0E1AF0549300FF9E5C /* ARTRadialGradient.m in Sources */,
+				0CF68B151AF0549300FF9E5C /* ARTSurfaceViewManager.m in Sources */,
+				0CF68B081AF0549300FF9E5C /* ARTShape.m in Sources */,
+				0CF68B071AF0549300FF9E5C /* ARTRenderable.m in Sources */,
+				0CF68B101AF0549300FF9E5C /* RCTConvert+ART.m in Sources */,
+				0CF68B061AF0549300FF9E5C /* ARTNode.m in Sources */,
+				0CF68B0F1AF0549300FF9E5C /* ARTSolidColor.m in Sources */,
+				0CF68B0C1AF0549300FF9E5C /* ARTLinearGradient.m in Sources */,
+				0CF68B0B1AF0549300FF9E5C /* ARTBrush.m in Sources */,
+				0CF68B141AF0549300FF9E5C /* ARTShapeManager.m in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		323A12831E5F266B004975B8 /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				325CF7B71E5F2ABA00AC9606 /* ARTTextManager.m in Sources */,
+				325CF7B21E5F2ABA00AC9606 /* ARTGroupManager.m in Sources */,
+				325CF7AF1E5F2ABA00AC9606 /* ARTPattern.m in Sources */,
+				325CF7BD1E5F2ABA00AC9606 /* ARTText.m in Sources */,
+				325CF7B31E5F2ABA00AC9606 /* ARTNodeManager.m in Sources */,
+				325CF7B81E5F2ABA00AC9606 /* ARTGroup.m in Sources */,
+				325CF7B41E5F2ABA00AC9606 /* ARTRenderableManager.m in Sources */,
+				325CF7BC1E5F2ABA00AC9606 /* ARTSurfaceView.m in Sources */,
+				325CF7B01E5F2ABA00AC9606 /* ARTRadialGradient.m in Sources */,
+				325CF7B61E5F2ABA00AC9606 /* ARTSurfaceViewManager.m in Sources */,
+				325CF7BB1E5F2ABA00AC9606 /* ARTShape.m in Sources */,
+				325CF7BA1E5F2ABA00AC9606 /* ARTRenderable.m in Sources */,
+				325CF7BE1E5F2ABA00AC9606 /* RCTConvert+ART.m in Sources */,
+				325CF7B91E5F2ABA00AC9606 /* ARTNode.m in Sources */,
+				325CF7B11E5F2ABA00AC9606 /* ARTSolidColor.m in Sources */,
+				325CF7AE1E5F2ABA00AC9606 /* ARTLinearGradient.m in Sources */,
+				325CF7AD1E5F2ABA00AC9606 /* ARTBrush.m in Sources */,
+				325CF7B51E5F2ABA00AC9606 /* ARTShapeManager.m in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXSourcesBuildPhase section */
+
+/* Begin XCBuildConfiguration section */
+		0CF68AD31AF0540F00FF9E5C /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				COPY_PHASE_STRIP = NO;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_DYNAMIC_NO_PIC = NO;
+				GCC_OPTIMIZATION_LEVEL = 0;
+				GCC_PREPROCESSOR_DEFINITIONS = (
+					"DEBUG=1",
+					"$(inherited)",
+				);
+				GCC_SYMBOLS_PRIVATE_EXTERN = NO;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 8.0;
+				MTL_ENABLE_DEBUG_INFO = YES;
+				ONLY_ACTIVE_ARCH = YES;
+				SDKROOT = iphoneos;
+				SKIP_INSTALL = YES;
+			};
+			name = Debug;
+		};
+		0CF68AD41AF0540F00FF9E5C /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				COPY_PHASE_STRIP = NO;
+				ENABLE_NS_ASSERTIONS = NO;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 8.0;
+				MTL_ENABLE_DEBUG_INFO = NO;
+				SDKROOT = iphoneos;
+				SKIP_INSTALL = YES;
+				VALIDATE_PRODUCT = YES;
+			};
+			name = Release;
+		};
+		0CF68AD61AF0540F00FF9E5C /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				OTHER_LDFLAGS = "-ObjC";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+			};
+			name = Debug;
+		};
+		0CF68AD71AF0540F00FF9E5C /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				OTHER_LDFLAGS = "-ObjC";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+			};
+			name = Release;
+		};
+		323A128E1E5F266B004975B8 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				CLANG_ANALYZER_NONNULL = YES;
+				CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				DEBUG_INFORMATION_FORMAT = dwarf;
+				ENABLE_TESTABILITY = YES;
+				GCC_NO_COMMON_BLOCKS = YES;
+				OTHER_LDFLAGS = "-ObjC";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SDKROOT = appletvos;
+				SKIP_INSTALL = YES;
+				TVOS_DEPLOYMENT_TARGET = 9.2;
+			};
+			name = Debug;
+		};
+		323A128F1E5F266B004975B8 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				CLANG_ANALYZER_NONNULL = YES;
+				CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				GCC_NO_COMMON_BLOCKS = YES;
+				OTHER_LDFLAGS = "-ObjC";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SDKROOT = appletvos;
+				SKIP_INSTALL = YES;
+				TVOS_DEPLOYMENT_TARGET = 9.2;
+			};
+			name = Release;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		0CF68ABC1AF0540F00FF9E5C /* Build configuration list for PBXProject "ART" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				0CF68AD31AF0540F00FF9E5C /* Debug */,
+				0CF68AD41AF0540F00FF9E5C /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		0CF68AD51AF0540F00FF9E5C /* Build configuration list for PBXNativeTarget "ART" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				0CF68AD61AF0540F00FF9E5C /* Debug */,
+				0CF68AD71AF0540F00FF9E5C /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		323A128D1E5F266B004975B8 /* Build configuration list for PBXNativeTarget "ART-tvOS" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				323A128E1E5F266B004975B8 /* Debug */,
+				323A128F1E5F266B004975B8 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+/* End XCConfigurationList section */
+	};
+	rootObject = 0CF68AB91AF0540F00FF9E5C /* Project object */;
+}

node_modules/react-native/Libraries/ART/ARTCGFloatArray.h

@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+// A little helper to make sure we have the right memory allocation ready for use.
+// We assume that we will only this in one place so no reference counting is necessary.
+// Needs to be freed when dealloced.
+
+// This is fragile since this relies on these values not getting reused. Consider
+// wrapping these in an Obj-C class or some ARC hackery to get refcounting.
+
+typedef struct {
+  size_t count;
+  CGFloat *array;
+} ARTCGFloatArray;

node_modules/react-native/Libraries/ART/ARTContainer.h

@@ -0,0 +1,16 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <Foundation/Foundation.h>
+
+@protocol ARTContainer <NSObject>
+
+// This is used as a hook for child to mark it's parent as dirty.
+// This bubbles up to the root which gets marked as dirty.
+- (void)invalidate;
+
+@end

node_modules/react-native/Libraries/ART/ARTGroup.h

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <Foundation/Foundation.h>
+
+#import "ARTContainer.h"
+#import "ARTNode.h"
+
+@interface ARTGroup : ARTNode <ARTContainer>
+
+@property (nonatomic, assign) CGRect clipping;
+
+@end

node_modules/react-native/Libraries/ART/ARTGroup.m

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "ARTGroup.h"
+
+@implementation ARTGroup
+
+- (void)renderLayerTo:(CGContextRef)context
+{
+
+  if (!CGRectIsEmpty(self.clipping)) {
+    CGContextClipToRect(context, self.clipping);
+  }
+
+  for (ARTNode *node in self.subviews) {
+    [node renderTo:context];
+  }
+}
+
+@end

node_modules/react-native/Libraries/ART/ARTNode.h

@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/UIView+React.h>
+
+/**
+ * ART nodes are implemented as empty UIViews but this is just an implementation detail to fit
+ * into the existing view management. They should also be shadow views and painted on a background
+ * thread.
+ */
+
+@interface ARTNode : UIView
+
+@property (nonatomic, assign) CGFloat opacity;
+
+- (void)invalidate;
+- (void)renderTo:(CGContextRef)context;
+
+/**
+ * renderTo will take opacity into account and draw renderLayerTo off-screen if there is opacity
+ * specified, then composite that onto the context. renderLayerTo always draws at opacity=1.
+ * @abstract
+ */
+- (void)renderLayerTo:(CGContextRef)context;
+
+@end

node_modules/react-native/Libraries/ART/ARTNode.m

@@ -0,0 +1,80 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "ARTNode.h"
+
+#import "ARTContainer.h"
+
+@implementation ARTNode
+
+- (void)insertReactSubview:(UIView *)subview atIndex:(NSInteger)atIndex
+{
+  [super insertReactSubview:subview atIndex:atIndex];
+  [self insertSubview:subview atIndex:atIndex];
+  [self invalidate];
+}
+
+- (void)removeReactSubview:(UIView *)subview
+{
+  [super removeReactSubview:subview];
+  [self invalidate];
+}
+
+- (void)didUpdateReactSubviews
+{
+  // Do nothing, as subviews are inserted by insertReactSubview:
+}
+
+- (void)setOpacity:(CGFloat)opacity
+{
+  [self invalidate];
+  _opacity = opacity;
+}
+
+- (void)setTransform:(CGAffineTransform)transform
+{
+  [self invalidate];
+  super.transform = transform;
+}
+
+- (void)invalidate
+{
+  id<ARTContainer> container = (id<ARTContainer>)self.superview;
+  [container invalidate];
+}
+
+- (void)renderTo:(CGContextRef)context
+{
+  if (self.opacity <= 0) {
+    // Nothing to paint
+    return;
+  }
+  if (self.opacity >= 1) {
+    // Just paint at full opacity
+    CGContextSaveGState(context);
+    CGContextConcatCTM(context, self.transform);
+    CGContextSetAlpha(context, 1);
+    [self renderLayerTo:context];
+    CGContextRestoreGState(context);
+    return;
+  }
+  // This needs to be painted on a layer before being composited.
+  CGContextSaveGState(context);
+  CGContextConcatCTM(context, self.transform);
+  CGContextSetAlpha(context, self.opacity);
+  CGContextBeginTransparencyLayer(context, NULL);
+  [self renderLayerTo:context];
+  CGContextEndTransparencyLayer(context);
+  CGContextRestoreGState(context);
+}
+
+- (void)renderLayerTo:(CGContextRef)context
+{
+  // abstract
+}
+
+@end

node_modules/react-native/Libraries/ART/ARTRenderable.h

@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <Foundation/Foundation.h>
+
+#import "ARTBrush.h"
+#import "ARTCGFloatArray.h"
+#import "ARTNode.h"
+
+@interface ARTRenderable : ARTNode
+
+@property (nonatomic, strong) ARTBrush *fill;
+@property (nonatomic, assign) CGColorRef stroke;
+@property (nonatomic, assign) CGFloat strokeWidth;
+@property (nonatomic, assign) CGLineCap strokeCap;
+@property (nonatomic, assign) CGLineJoin strokeJoin;
+@property (nonatomic, assign) ARTCGFloatArray strokeDash;
+
+@end

node_modules/react-native/Libraries/ART/ARTRenderable.m

@@ -0,0 +1,87 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "ARTRenderable.h"
+
+@implementation ARTRenderable
+
+- (void)setFill:(ARTBrush *)fill
+{
+  [self invalidate];
+  _fill = fill;
+}
+
+- (void)setStroke:(CGColorRef)stroke
+{
+  if (stroke == _stroke) {
+    return;
+  }
+  [self invalidate];
+  CGColorRelease(_stroke);
+  _stroke = CGColorRetain(stroke);
+}
+
+- (void)setStrokeWidth:(CGFloat)strokeWidth
+{
+  [self invalidate];
+  _strokeWidth = strokeWidth;
+}
+
+- (void)setStrokeCap:(CGLineCap)strokeCap
+{
+  [self invalidate];
+  _strokeCap = strokeCap;
+}
+
+- (void)setStrokeJoin:(CGLineJoin)strokeJoin
+{
+  [self invalidate];
+  _strokeJoin = strokeJoin;
+}
+
+- (void)setStrokeDash:(ARTCGFloatArray)strokeDash
+{
+  if (strokeDash.array == _strokeDash.array) {
+    return;
+  }
+  if (_strokeDash.array) {
+    free(_strokeDash.array);
+  }
+  [self invalidate];
+  _strokeDash = strokeDash;
+}
+
+- (void)dealloc
+{
+  CGColorRelease(_stroke);
+  if (_strokeDash.array) {
+    free(_strokeDash.array);
+  }
+}
+
+- (void)renderTo:(CGContextRef)context
+{
+  if (self.opacity <= 0 || self.opacity >= 1 || (self.fill && self.stroke)) {
+    // If we have both fill and stroke, we will need to paint this using normal compositing
+    [super renderTo: context];
+    return;
+  }
+  // This is a terminal with only one painting. Therefore we don't need to paint this
+  // off-screen. We can just composite it straight onto the buffer.
+  CGContextSaveGState(context);
+  CGContextConcatCTM(context, self.transform);
+  CGContextSetAlpha(context, self.opacity);
+  [self renderLayerTo:context];
+  CGContextRestoreGState(context);
+}
+
+- (void)renderLayerTo:(CGContextRef)context
+{
+  // abstract
+}
+
+@end

node_modules/react-native/Libraries/ART/ARTSerializablePath.js

@@ -0,0 +1,74 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule ARTSerializablePath
+ */
+'use strict';
+
+// TODO: Move this into an ART mode called "serialized" or something
+
+var Class = require('art/core/class.js');
+var Path = require('art/core/path.js');
+
+var MOVE_TO = 0;
+var CLOSE = 1;
+var LINE_TO = 2;
+var CURVE_TO = 3;
+var ARC = 4;
+
+var SerializablePath = Class(Path, {
+
+  initialize: function(path) {
+    this.reset();
+    if (path instanceof SerializablePath) {
+      this.path = path.path.slice(0);
+    } else if (path) {
+      if (path.applyToPath) {
+        path.applyToPath(this);
+      } else {
+        this.push(path);
+      }
+    }
+  },
+
+  onReset: function() {
+    this.path = [];
+  },
+
+  onMove: function(sx, sy, x, y) {
+    this.path.push(MOVE_TO, x, y);
+  },
+
+  onLine: function(sx, sy, x, y) {
+    this.path.push(LINE_TO, x, y);
+  },
+
+  onBezierCurve: function(sx, sy, p1x, p1y, p2x, p2y, x, y) {
+    this.path.push(CURVE_TO, p1x, p1y, p2x, p2y, x, y);
+  },
+
+  _arcToBezier: Path.prototype.onArc,
+
+  onArc: function(sx, sy, ex, ey, cx, cy, rx, ry, sa, ea, ccw, rotation) {
+    if (rx !== ry || rotation) {
+      return this._arcToBezier(
+        sx, sy, ex, ey, cx, cy, rx, ry, sa, ea, ccw, rotation
+      );
+    }
+    this.path.push(ARC, cx, cy, rx, sa, ea, ccw ? 0 : 1);
+  },
+
+  onClose: function() {
+    this.path.push(CLOSE);
+  },
+
+  toJSON: function() {
+    return this.path;
+  }
+
+});
+
+module.exports = SerializablePath;

node_modules/react-native/Libraries/ART/ARTShape.h

@@ -0,0 +1,16 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <Foundation/Foundation.h>
+
+#import "ARTRenderable.h"
+
+@interface ARTShape : ARTRenderable
+
+@property (nonatomic, assign) CGPathRef d;
+
+@end

node_modules/react-native/Libraries/ART/ARTShape.m

@@ -0,0 +1,66 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "ARTShape.h"
+
+@implementation ARTShape
+
+- (void)setD:(CGPathRef)d
+{
+  if (d == _d) {
+    return;
+  }
+  [self invalidate];
+  CGPathRelease(_d);
+  _d = CGPathRetain(d);
+}
+
+- (void)dealloc
+{
+  CGPathRelease(_d);
+}
+
+- (void)renderLayerTo:(CGContextRef)context
+{
+  if ((!self.fill && !self.stroke) || !self.d) {
+    return;
+  }
+
+  CGPathDrawingMode mode = kCGPathStroke;
+  if (self.fill) {
+    if ([self.fill applyFillColor:context]) {
+      mode = kCGPathFill;
+    } else {
+      CGContextSaveGState(context);
+      CGContextAddPath(context, self.d);
+      CGContextClip(context);
+      [self.fill paint:context];
+      CGContextRestoreGState(context);
+      if (!self.stroke) {
+        return;
+      }
+    }
+  }
+  if (self.stroke) {
+    CGContextSetStrokeColorWithColor(context, self.stroke);
+    CGContextSetLineWidth(context, self.strokeWidth);
+    CGContextSetLineCap(context, self.strokeCap);
+    CGContextSetLineJoin(context, self.strokeJoin);
+    ARTCGFloatArray dash = self.strokeDash;
+    if (dash.count) {
+      CGContextSetLineDash(context, 0, dash.array, dash.count);
+    }
+    if (mode == kCGPathFill) {
+      mode = kCGPathFillStroke;
+    }
+  }
+
+  CGContextAddPath(context, self.d);
+  CGContextDrawPath(context, mode);
+}
+
+@end

node_modules/react-native/Libraries/ART/ARTSurfaceView.h

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

node_modules/react-native/Libraries/ART/ARTSurfaceView.m

@@ -0,0 +1,56 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "ARTSurfaceView.h"
+
+#import <React/RCTLog.h>
+
+#import "ARTNode.h"
+
+@implementation ARTSurfaceView
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    self.opaque = NO;
+  }
+
+  return self;
+}
+
+- (void)insertReactSubview:(UIView *)subview atIndex:(NSInteger)atIndex
+{
+  [super insertReactSubview:subview atIndex:atIndex];
+  [self insertSubview:subview atIndex:atIndex];
+  [self invalidate];
+}
+
+- (void)removeReactSubview:(UIView *)subview
+{
+  [super removeReactSubview:subview];
+  [self invalidate];
+}
+
+- (void)didUpdateReactSubviews
+{
+  // Do nothing, as subviews are inserted by insertReactSubview:
+}
+
+- (void)invalidate
+{
+  [self setNeedsDisplay];
+}
+
+- (void)drawRect:(CGRect)rect
+{
+  CGContextRef context = UIGraphicsGetCurrentContext();
+  for (ARTNode *node in self.subviews) {
+    [node renderTo:context];
+  }
+}
+
+@end

node_modules/react-native/Libraries/ART/ARTText.h

@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <Foundation/Foundation.h>
+
+#import "ARTRenderable.h"
+#import "ARTTextFrame.h"
+
+@interface ARTText : ARTRenderable
+
+@property (nonatomic, assign) CTTextAlignment alignment;
+@property (nonatomic, assign) ARTTextFrame textFrame;
+
+@end

node_modules/react-native/Libraries/ART/ARTText.m

@@ -0,0 +1,125 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "ARTText.h"
+
+#import <CoreText/CoreText.h>
+
+@implementation ARTText
+
+- (void)setAlignment:(CTTextAlignment)alignment
+{
+  [self invalidate];
+  _alignment = alignment;
+}
+
+static void ARTFreeTextFrame(ARTTextFrame frame)
+{
+  if (frame.count) {
+    // We must release each line before freeing up this struct
+    for (int i = 0; i < frame.count; i++) {
+      CFRelease(frame.lines[i]);
+    }
+    free(frame.lines);
+    free(frame.widths);
+  }
+}
+
+- (void)setTextFrame:(ARTTextFrame)frame
+{
+  if (frame.lines != _textFrame.lines) {
+    ARTFreeTextFrame(_textFrame);
+  }
+  [self invalidate];
+  _textFrame = frame;
+}
+
+- (void)dealloc
+{
+  ARTFreeTextFrame(_textFrame);
+}
+
+- (void)renderLayerTo:(CGContextRef)context
+{
+  ARTTextFrame frame = self.textFrame;
+
+  if ((!self.fill && !self.stroke) || !frame.count) {
+    return;
+  }
+
+  // to-do: draw along a path
+
+  CGTextDrawingMode mode = kCGTextStroke;
+  if (self.fill) {
+    if ([self.fill applyFillColor:context]) {
+      mode = kCGTextFill;
+    } else {
+
+      for (int i = 0; i < frame.count; i++) {
+        CGContextSaveGState(context);
+        // Inverse the coordinate space since CoreText assumes a bottom-up coordinate space
+        CGContextScaleCTM(context, 1.0, -1.0);
+        CGContextSetTextDrawingMode(context, kCGTextClip);
+        [self renderLineTo:context atIndex:i];
+        // Inverse the coordinate space back to the original before filling
+        CGContextScaleCTM(context, 1.0, -1.0);
+        [self.fill paint:context];
+        // Restore the state so that the next line can be clipped separately
+        CGContextRestoreGState(context);
+      }
+
+      if (!self.stroke) {
+        return;
+      }
+    }
+  }
+  if (self.stroke) {
+    CGContextSetStrokeColorWithColor(context, self.stroke);
+    CGContextSetLineWidth(context, self.strokeWidth);
+    CGContextSetLineCap(context, self.strokeCap);
+    CGContextSetLineJoin(context, self.strokeJoin);
+    ARTCGFloatArray dash = self.strokeDash;
+    if (dash.count) {
+      CGContextSetLineDash(context, 0, dash.array, dash.count);
+    }
+    if (mode == kCGTextFill) {
+      mode = kCGTextFillStroke;
+    }
+  }
+
+  CGContextSetTextDrawingMode(context, mode);
+
+  // Inverse the coordinate space since CoreText assumes a bottom-up coordinate space
+  CGContextScaleCTM(context, 1.0, -1.0);
+  for (int i = 0; i < frame.count; i++) {
+    [self renderLineTo:context atIndex:i];
+  }
+}
+
+- (void)renderLineTo:(CGContextRef)context atIndex:(int)index
+{
+  ARTTextFrame frame = self.textFrame;
+  CGFloat shift;
+  switch (self.alignment) {
+    case kCTTextAlignmentRight:
+      shift = frame.widths[index];
+      break;
+    case kCTTextAlignmentCenter:
+      shift = (frame.widths[index] / 2);
+      break;
+    default:
+      shift = 0;
+      break;
+  }
+  // We should consider snapping this shift to device pixels to improve rendering quality
+  // when a line has subpixel width.
+  CGContextSetTextPosition(context, -shift, -frame.baseLine - frame.lineHeight * index);
+  CTLineRef line = frame.lines[index];
+  CTLineDraw(line, context);
+}
+
+@end

node_modules/react-native/Libraries/ART/ARTTextFrame.h

@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <CoreText/CoreText.h>
+
+// A little helper to make sure we have a set of lines including width ready for use.
+// We assume that we will only this in one place so no reference counting is necessary.
+// Needs to be freed when dealloced.
+
+// This is fragile since this relies on these values not getting reused. Consider
+// wrapping these in an Obj-C class or some ARC hackery to get refcounting.
+
+typedef struct {
+  size_t count;
+  CGFloat baseLine; // Distance from the origin to the base line of the first line
+  CGFloat lineHeight; // Distance between lines
+  CTLineRef *lines;
+  CGFloat *widths; // Width of each line
+} ARTTextFrame;

node_modules/react-native/Libraries/ART/Brushes/ARTBrush.h

@@ -0,0 +1,33 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <CoreGraphics/CoreGraphics.h>
+#import <Foundation/Foundation.h>
+
+@interface ARTBrush : NSObject
+
+/* @abstract */
+- (instancetype)initWithArray:(NSArray *)data NS_DESIGNATED_INITIALIZER;
+
+/**
+ * For certain brushes we can fast path a combined fill and stroke.
+ * For those brushes we override applyFillColor which sets the fill
+ * color to be used by those batch paints. Those return YES.
+ * We can't batch gradient painting in CoreGraphics, so those will
+ * return NO and paint gets called instead.
+ * @abstract
+ */
+- (BOOL)applyFillColor:(CGContextRef)context;
+
+/**
+ * paint fills the context with a brush. The context is assumed to
+ * be clipped.
+ * @abstract
+ */
+- (void)paint:(CGContextRef)context;
+
+@end

node_modules/react-native/Libraries/ART/Brushes/ARTBrush.m

@@ -0,0 +1,31 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "ARTBrush.h"
+
+#import <React/RCTDefines.h>
+
+@implementation ARTBrush
+
+- (instancetype)initWithArray:(NSArray *)data
+{
+  return [super init];
+}
+
+RCT_NOT_IMPLEMENTED(- (instancetype)init)
+
+- (BOOL)applyFillColor:(CGContextRef)context
+{
+  return NO;
+}
+
+- (void)paint:(CGContextRef)context
+{
+  // abstract
+}
+
+@end

node_modules/react-native/Libraries/ART/Brushes/ARTLinearGradient.h

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

node_modules/react-native/Libraries/ART/Brushes/ARTLinearGradient.m

@@ -0,0 +1,48 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "ARTLinearGradient.h"
+
+#import <React/RCTLog.h>
+
+#import "RCTConvert+ART.h"
+
+@implementation ARTLinearGradient
+{
+  CGGradientRef _gradient;
+  CGPoint _startPoint;
+  CGPoint _endPoint;
+}
+
+- (instancetype)initWithArray:(NSArray<NSNumber *> *)array
+{
+  if ((self = [super initWithArray:array])) {
+    if (array.count < 5) {
+      RCTLogError(@"-[%@ %@] expects 5 elements, received %@",
+                  self.class, NSStringFromSelector(_cmd), array);
+      return nil;
+    }
+    _startPoint = [RCTConvert CGPoint:array offset:1];
+    _endPoint = [RCTConvert CGPoint:array offset:3];
+    _gradient = CGGradientRetain([RCTConvert CGGradient:array offset:5]);
+  }
+  return self;
+}
+
+- (void)dealloc
+{
+  CGGradientRelease(_gradient);
+}
+
+- (void)paint:(CGContextRef)context
+{
+  CGGradientDrawingOptions extendOptions =
+    kCGGradientDrawsBeforeStartLocation | kCGGradientDrawsAfterEndLocation;
+  CGContextDrawLinearGradient(context, _gradient, _startPoint, _endPoint, extendOptions);
+}
+
+@end

node_modules/react-native/Libraries/ART/Brushes/ARTPattern.h

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

node_modules/react-native/Libraries/ART/Brushes/ARTPattern.m

@@ -0,0 +1,49 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "ARTPattern.h"
+
+#import <React/RCTLog.h>
+
+#import "RCTConvert+ART.h"
+
+@implementation ARTPattern
+{
+  CGImageRef _image;
+  CGRect _rect;
+}
+
+- (instancetype)initWithArray:(NSArray<id /* imagesource + numbers */> *)array
+{
+  if ((self = [super initWithArray:array])) {
+    if (array.count < 6) {
+      RCTLogError(@"-[%@ %@] expects 6 elements, received %@",
+                  self.class, NSStringFromSelector(_cmd), array);
+      return nil;
+    }
+    _image = CGImageRetain([RCTConvert CGImage:array[1]]);
+    _rect = [RCTConvert CGRect:array offset:2];
+  }
+  return self;
+}
+
+- (void)dealloc
+{
+  CGImageRelease(_image);
+}
+
+// Note: This could use applyFillColor with a pattern. This could be more efficient but
+// to do that, we need to calculate our own user space CTM.
+
+- (void)paint:(CGContextRef)context
+{
+  CGContextDrawTiledImage(context, _rect, _image);
+}
+
+
+
+@end

node_modules/react-native/Libraries/ART/Brushes/ARTRadialGradient.h

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

node_modules/react-native/Libraries/ART/Brushes/ARTRadialGradient.m

@@ -0,0 +1,55 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "ARTRadialGradient.h"
+
+#import <React/RCTLog.h>
+
+#import "RCTConvert+ART.h"
+
+@implementation ARTRadialGradient
+{
+  CGGradientRef _gradient;
+  CGPoint _focusPoint;
+  CGPoint _centerPoint;
+  CGFloat _radius;
+  CGFloat _radiusRatio;
+}
+
+- (instancetype)initWithArray:(NSArray<NSNumber *> *)array
+{
+  if ((self = [super initWithArray:array])) {
+    if (array.count < 7) {
+      RCTLogError(@"-[%@ %@] expects 7 elements, received %@",
+                  self.class, NSStringFromSelector(_cmd), array);
+      return nil;
+    }
+    _radius = [RCTConvert CGFloat:array[3]];
+    _radiusRatio = [RCTConvert CGFloat:array[4]] / _radius;
+    _focusPoint.x = [RCTConvert CGFloat:array[1]];
+    _focusPoint.y = [RCTConvert CGFloat:array[2]] / _radiusRatio;
+    _centerPoint.x = [RCTConvert CGFloat:array[5]];
+    _centerPoint.y = [RCTConvert CGFloat:array[6]] / _radiusRatio;
+    _gradient = CGGradientRetain([RCTConvert CGGradient:array offset:7]);
+  }
+  return self;
+}
+
+- (void)dealloc
+{
+  CGGradientRelease(_gradient);
+}
+
+- (void)paint:(CGContextRef)context
+{
+  CGAffineTransform transform = CGAffineTransformMakeScale(1, _radiusRatio);
+  CGContextConcatCTM(context, transform);
+  CGGradientDrawingOptions extendOptions = kCGGradientDrawsBeforeStartLocation | kCGGradientDrawsAfterEndLocation;
+  CGContextDrawRadialGradient(context, _gradient, _focusPoint, 0, _centerPoint, _radius, extendOptions);
+}
+
+@end

node_modules/react-native/Libraries/ART/Brushes/ARTSolidColor.h

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

node_modules/react-native/Libraries/ART/Brushes/ARTSolidColor.m

@@ -0,0 +1,38 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "ARTSolidColor.h"
+
+#import <React/RCTLog.h>
+
+#import "RCTConvert+ART.h"
+
+@implementation ARTSolidColor
+{
+  CGColorRef _color;
+}
+
+- (instancetype)initWithArray:(NSArray<NSNumber *> *)array
+{
+  if ((self = [super initWithArray:array])) {
+    _color = CGColorRetain([RCTConvert CGColor:array offset:1]);
+  }
+  return self;
+}
+
+- (void)dealloc
+{
+  CGColorRelease(_color);
+}
+
+- (BOOL)applyFillColor:(CGContextRef)context
+{
+  CGContextSetFillColorWithColor(context, _color);
+  return YES;
+}
+
+@end

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

@@ -0,0 +1,29 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <QuartzCore/QuartzCore.h>
+
+#import <React/RCTConvert.h>
+
+#import "ARTBrush.h"
+#import "ARTCGFloatArray.h"
+#import "ARTTextFrame.h"
+
+@interface RCTConvert (ART)
+
++ (CGPathRef)CGPath:(id)json;
++ (CTTextAlignment)CTTextAlignment:(id)json;
++ (ARTTextFrame)ARTTextFrame:(id)json;
++ (ARTCGFloatArray)ARTCGFloatArray:(id)json;
++ (ARTBrush *)ARTBrush:(id)json;
+
++ (CGPoint)CGPoint:(id)json offset:(NSUInteger)offset;
++ (CGRect)CGRect:(id)json offset:(NSUInteger)offset;
++ (CGColorRef)CGColor:(id)json offset:(NSUInteger)offset;
++ (CGGradientRef)CGGradient:(id)json offset:(NSUInteger)offset;
+
+@end

node_modules/react-native/Libraries/ART/RCTConvert+ART.m

@@ -0,0 +1,222 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTConvert+ART.h"
+
+#import <React/RCTFont.h>
+#import <React/RCTLog.h>
+
+#import "ARTLinearGradient.h"
+#import "ARTPattern.h"
+#import "ARTRadialGradient.h"
+#import "ARTSolidColor.h"
+
+@implementation RCTConvert (ART)
+
++ (CGPathRef)CGPath:(id)json
+{
+  NSArray *arr = [self NSNumberArray:json];
+
+  NSUInteger count = [arr count];
+
+#define NEXT_VALUE [self double:arr[i++]]
+
+  CGMutablePathRef path = CGPathCreateMutable();
+  CGPathMoveToPoint(path, NULL, 0, 0);
+
+  @try {
+    NSUInteger i = 0;
+    while (i < count) {
+      NSUInteger type = [arr[i++] unsignedIntegerValue];
+      switch (type) {
+        case 0:
+          CGPathMoveToPoint(path, NULL, NEXT_VALUE, NEXT_VALUE);
+          break;
+        case 1:
+          CGPathCloseSubpath(path);
+          break;
+        case 2:
+          CGPathAddLineToPoint(path, NULL, NEXT_VALUE, NEXT_VALUE);
+          break;
+        case 3:
+          CGPathAddCurveToPoint(path, NULL, NEXT_VALUE, NEXT_VALUE, NEXT_VALUE, NEXT_VALUE, NEXT_VALUE, NEXT_VALUE);
+          break;
+        case 4:
+          CGPathAddArc(path, NULL, NEXT_VALUE, NEXT_VALUE, NEXT_VALUE, NEXT_VALUE, NEXT_VALUE, NEXT_VALUE == 0);
+          break;
+        default:
+          RCTLogError(@"Invalid CGPath type %llu at element %llu of %@", (unsigned long long)type, (unsigned long long)i, arr);
+          CGPathRelease(path);
+          return NULL;
+      }
+    }
+  }
+  @catch (NSException *exception) {
+    RCTLogError(@"Invalid CGPath format: %@", arr);
+    CGPathRelease(path);
+    return NULL;
+  }
+
+  return (CGPathRef)CFAutorelease(path);
+}
+
+RCT_ENUM_CONVERTER(CTTextAlignment, (@{
+  @"auto": @(kCTTextAlignmentNatural),
+  @"left": @(kCTTextAlignmentLeft),
+  @"center": @(kCTTextAlignmentCenter),
+  @"right": @(kCTTextAlignmentRight),
+  @"justify": @(kCTTextAlignmentJustified),
+}), kCTTextAlignmentNatural, integerValue)
+
+// This takes a tuple of text lines and a font to generate a CTLine for each text line.
+// This prepares everything for rendering a frame of text in ARTText.
++ (ARTTextFrame)ARTTextFrame:(id)json
+{
+  NSDictionary *dict = [self NSDictionary:json];
+  ARTTextFrame frame;
+  frame.count = 0;
+
+  NSArray *lines = [self NSArray:dict[@"lines"]];
+  NSUInteger lineCount = [lines count];
+  if (lineCount == 0) {
+    return frame;
+  }
+
+  CTFontRef font = (__bridge CTFontRef)[self UIFont:dict[@"font"]];
+  if (!font) {
+    return frame;
+  }
+
+  // Create a dictionary for this font
+  CFDictionaryRef attributes = (__bridge CFDictionaryRef)@{
+    (NSString *)kCTFontAttributeName:(__bridge id)font,
+    (NSString *)kCTForegroundColorFromContextAttributeName: @YES
+  };
+
+  // Set up text frame with font metrics
+  CGFloat size = CTFontGetSize(font);
+  frame.count = lineCount;
+  frame.baseLine = size; // estimate base line
+  frame.lineHeight = size * 1.1; // Base on ART canvas line height estimate
+  frame.lines = malloc(sizeof(CTLineRef) * lineCount);
+  frame.widths = malloc(sizeof(CGFloat) * lineCount);
+
+  [lines enumerateObjectsUsingBlock:^(NSString *text, NSUInteger i, BOOL *stop) {
+
+    CFStringRef string = (__bridge CFStringRef)text;
+    CFAttributedStringRef attrString = CFAttributedStringCreate(kCFAllocatorDefault, string, attributes);
+    CTLineRef line = CTLineCreateWithAttributedString(attrString);
+    CFRelease(attrString);
+
+    frame.lines[i] = line;
+    frame.widths[i] = CTLineGetTypographicBounds(line, NULL, NULL, NULL);
+  }];
+
+  return frame;
+}
+
++ (ARTCGFloatArray)ARTCGFloatArray:(id)json
+{
+  NSArray *arr = [self NSNumberArray:json];
+  NSUInteger count = arr.count;
+
+  ARTCGFloatArray array;
+  array.count = count;
+  array.array = NULL;
+
+  if (count) {
+    // Ideally, these arrays should already use the same memory layout.
+    // In that case we shouldn't need this new malloc.
+    array.array = malloc(sizeof(CGFloat) * count);
+    for (NSUInteger i = 0; i < count; i++) {
+      array.array[i] = [arr[i] doubleValue];
+    }
+  }
+
+  return array;
+}
+
++ (ARTBrush *)ARTBrush:(id)json
+{
+  NSArray *arr = [self NSArray:json];
+  NSUInteger type = [self NSUInteger:arr.firstObject];
+  switch (type) {
+    case 0: // solid color
+      // These are probably expensive allocations since it's often the same value.
+      // We should memoize colors but look ups may be just as expensive.
+      return [[ARTSolidColor alloc] initWithArray:arr];
+    case 1: // linear gradient
+      return [[ARTLinearGradient alloc] initWithArray:arr];
+    case 2: // radial gradient
+      return [[ARTRadialGradient alloc] initWithArray:arr];
+    case 3: // pattern
+      return [[ARTPattern alloc] initWithArray:arr];
+    default:
+      RCTLogError(@"Unknown brush type: %llu", (unsigned long long)type);
+      return nil;
+  }
+}
+
++ (CGPoint)CGPoint:(id)json offset:(NSUInteger)offset
+{
+  NSArray *arr = [self NSArray:json];
+  if (arr.count < offset + 2) {
+    RCTLogError(@"Too few elements in array (expected at least %llu): %@", (unsigned long long)(2 + offset), arr);
+    return CGPointZero;
+  }
+  return (CGPoint){
+    [self CGFloat:arr[offset]],
+    [self CGFloat:arr[offset + 1]],
+  };
+}
+
++ (CGRect)CGRect:(id)json offset:(NSUInteger)offset
+{
+  NSArray *arr = [self NSArray:json];
+  if (arr.count < offset + 4) {
+    RCTLogError(@"Too few elements in array (expected at least %llu): %@", (unsigned long long)(4 + offset), arr);
+    return CGRectZero;
+  }
+  return (CGRect){
+    {[self CGFloat:arr[offset]], [self CGFloat:arr[offset + 1]]},
+    {[self CGFloat:arr[offset + 2]], [self CGFloat:arr[offset + 3]]},
+  };
+}
+
++ (CGColorRef)CGColor:(id)json offset:(NSUInteger)offset
+{
+  NSArray *arr = [self NSArray:json];
+  if (arr.count < offset + 4) {
+    RCTLogError(@"Too few elements in array (expected at least %llu): %@", (unsigned long long)(4 + offset), arr);
+    return NULL;
+  }
+  return [self CGColor:[arr subarrayWithRange:(NSRange){offset, 4}]];
+}
+
++ (CGGradientRef)CGGradient:(id)json offset:(NSUInteger)offset
+{
+  NSArray *arr = [self NSArray:json];
+  if (arr.count < offset) {
+    RCTLogError(@"Too few elements in array (expected at least %llu): %@", (unsigned long long)offset, arr);
+    return NULL;
+  }
+  arr = [arr subarrayWithRange:(NSRange){offset, arr.count - offset}];
+  ARTCGFloatArray colorsAndOffsets = [self ARTCGFloatArray:arr];
+  size_t stops = colorsAndOffsets.count / 5;
+  CGColorSpaceRef rgb = CGColorSpaceCreateDeviceRGB();
+  CGGradientRef gradient = CGGradientCreateWithColorComponents(
+    rgb,
+    colorsAndOffsets.array,
+    colorsAndOffsets.array + stops * 4,
+    stops
+  );
+  CGColorSpaceRelease(rgb);
+  free(colorsAndOffsets.array);
+  return (CGGradientRef)CFAutorelease(gradient);
+}
+
+@end

node_modules/react-native/Libraries/ART/ReactNativeART.js

@@ -0,0 +1,588 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule ReactNativeART
+ */
+'use strict';
+
+var Color = require('art/core/color');
+var Path = require('ARTSerializablePath');
+var Transform = require('art/core/transform');
+
+var React = require('React');
+var PropTypes = require('prop-types');
+var ReactNativeViewAttributes = require('ReactNativeViewAttributes');
+
+var createReactNativeComponentClass = require('createReactNativeComponentClass');
+var merge = require('merge');
+var invariant = require('fbjs/lib/invariant');
+
+// Diff Helpers
+
+function arrayDiffer(a, b) {
+  if (a == null || b == null) {
+    return true;
+  }
+  if (a.length !== b.length) {
+    return true;
+  }
+  for (var i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function fontAndLinesDiffer(a, b) {
+  if (a === b) {
+    return false;
+  }
+  if (a.font !== b.font) {
+    if (a.font === null) {
+      return true;
+    }
+    if (b.font === null) {
+      return true;
+    }
+
+    if (
+      a.font.fontFamily !== b.font.fontFamily ||
+      a.font.fontSize !== b.font.fontSize ||
+      a.font.fontWeight !== b.font.fontWeight ||
+      a.font.fontStyle !== b.font.fontStyle
+    ) {
+      return true;
+    }
+  }
+  return arrayDiffer(a.lines, b.lines);
+}
+
+// Native Attributes
+
+var SurfaceViewAttributes = merge(ReactNativeViewAttributes.UIView, {
+  // This should contain pixel information such as width, height and
+  // resolution to know what kind of buffer needs to be allocated.
+  // Currently we rely on UIViews and style to figure that out.
+});
+
+var NodeAttributes = {
+  transform: { diff: arrayDiffer },
+  opacity: true,
+};
+
+var GroupAttributes = merge(NodeAttributes, {
+  clipping: { diff: arrayDiffer }
+});
+
+var RenderableAttributes = merge(NodeAttributes, {
+  fill: { diff: arrayDiffer },
+  stroke: { diff: arrayDiffer },
+  strokeWidth: true,
+  strokeCap: true,
+  strokeJoin: true,
+  strokeDash: { diff: arrayDiffer },
+});
+
+var ShapeAttributes = merge(RenderableAttributes, {
+  d: { diff: arrayDiffer },
+});
+
+var TextAttributes = merge(RenderableAttributes, {
+  alignment: true,
+  frame: { diff: fontAndLinesDiffer },
+  path: { diff: arrayDiffer }
+});
+
+// Native Components
+
+var NativeSurfaceView = createReactNativeComponentClass('ARTSurfaceView',
+  () => ({
+    validAttributes: SurfaceViewAttributes,
+    uiViewClassName: 'ARTSurfaceView',
+  }));
+
+var NativeGroup = createReactNativeComponentClass('ARTGroup',
+  () => ({
+    validAttributes: GroupAttributes,
+    uiViewClassName: 'ARTGroup',
+  }));
+
+var NativeShape = createReactNativeComponentClass('ARTShape',
+  () => ({
+    validAttributes: ShapeAttributes,
+    uiViewClassName: 'ARTShape',
+  }));
+
+var NativeText = createReactNativeComponentClass('ARTText',
+  () => ({
+    validAttributes: TextAttributes,
+    uiViewClassName: 'ARTText',
+  }));
+
+// Utilities
+
+function childrenAsString(children) {
+  if (!children) {
+    return '';
+  }
+  if (typeof children === 'string') {
+    return children;
+  }
+  if (children.length) {
+    return children.join('\n');
+  }
+  return '';
+}
+
+// Surface - Root node of all ART
+
+class Surface extends React.Component {
+  static childContextTypes = {
+    isInSurface: PropTypes.bool,
+  };
+
+  getChildContext() {
+    return { isInSurface: true };
+  }
+
+  render() {
+    var props = this.props;
+    var w = extractNumber(props.width, 0);
+    var h = extractNumber(props.height, 0);
+    return (
+      <NativeSurfaceView style={[props.style, { width: w, height: h }]}>
+        {this.props.children}
+      </NativeSurfaceView>
+    );
+  }
+}
+
+// Node Props
+
+// TODO: The desktop version of ART has title and cursor. We should have
+// accessibility support here too even though hovering doesn't work.
+
+function extractNumber(value, defaultValue) {
+  if (value == null) {
+    return defaultValue;
+  }
+  return +value;
+}
+
+var pooledTransform = new Transform();
+
+function extractTransform(props) {
+  var scaleX = props.scaleX != null ? props.scaleX :
+               props.scale != null ? props.scale : 1;
+  var scaleY = props.scaleY != null ? props.scaleY :
+               props.scale != null ? props.scale : 1;
+
+  pooledTransform
+    .transformTo(1, 0, 0, 1, 0, 0)
+    .move(props.x || 0, props.y || 0)
+    .rotate(props.rotation || 0, props.originX, props.originY)
+    .scale(scaleX, scaleY, props.originX, props.originY);
+
+  if (props.transform != null) {
+    pooledTransform.transform(props.transform);
+  }
+
+  return [
+    pooledTransform.xx, pooledTransform.yx,
+    pooledTransform.xy, pooledTransform.yy,
+    pooledTransform.x,  pooledTransform.y,
+  ];
+}
+
+function extractOpacity(props) {
+  // TODO: visible === false should also have no hit detection
+  if (props.visible === false) {
+    return 0;
+  }
+  if (props.opacity == null) {
+    return 1;
+  }
+  return +props.opacity;
+}
+
+// Groups
+
+// Note: ART has a notion of width and height on Group but AFAIK it's a noop in
+// ReactART.
+
+class Group extends React.Component {
+  static contextTypes = {
+    isInSurface: PropTypes.bool.isRequired,
+  };
+
+  render() {
+    var props = this.props;
+    invariant(
+      this.context.isInSurface,
+      'ART: <Group /> must be a child of a <Surface />'
+    );
+    return (
+      <NativeGroup
+        opacity={extractOpacity(props)}
+        transform={extractTransform(props)}>
+        {this.props.children}
+      </NativeGroup>
+    );
+  }
+}
+
+class ClippingRectangle extends React.Component {
+  render() {
+    var props = this.props;
+    var x = extractNumber(props.x, 0);
+    var y = extractNumber(props.y, 0);
+    var w = extractNumber(props.width, 0);
+    var h = extractNumber(props.height, 0);
+    var clipping = [x, y, w, h];
+    // The current clipping API requires x and y to be ignored in the transform
+    var propsExcludingXAndY = merge(props);
+    delete propsExcludingXAndY.x;
+    delete propsExcludingXAndY.y;
+    return (
+      <NativeGroup
+        clipping={clipping}
+        opacity={extractOpacity(props)}
+        transform={extractTransform(propsExcludingXAndY)}>
+        {this.props.children}
+      </NativeGroup>
+    );
+  }
+}
+
+// Renderables
+
+var SOLID_COLOR = 0;
+var LINEAR_GRADIENT = 1;
+var RADIAL_GRADIENT = 2;
+var PATTERN = 3;
+
+function insertColorIntoArray(color, targetArray, atIndex) {
+  var c = new Color(color);
+  targetArray[atIndex + 0] = c.red / 255;
+  targetArray[atIndex + 1] = c.green / 255;
+  targetArray[atIndex + 2] = c.blue / 255;
+  targetArray[atIndex + 3] = c.alpha;
+}
+
+function insertColorsIntoArray(stops, targetArray, atIndex) {
+  var i = 0;
+  if ('length' in stops) {
+    while (i < stops.length) {
+      insertColorIntoArray(stops[i], targetArray, atIndex + i * 4);
+      i++;
+    }
+  } else {
+    for (var offset in stops) {
+      insertColorIntoArray(stops[offset], targetArray, atIndex + i * 4);
+      i++;
+    }
+  }
+  return atIndex + i * 4;
+}
+
+function insertOffsetsIntoArray(stops, targetArray, atIndex, multi, reverse) {
+  var offsetNumber;
+  var i = 0;
+  if ('length' in stops) {
+    while (i < stops.length) {
+      offsetNumber = i / (stops.length - 1) * multi;
+      targetArray[atIndex + i] = reverse ? 1 - offsetNumber : offsetNumber;
+      i++;
+    }
+  } else {
+    for (var offsetString in stops) {
+      offsetNumber = (+offsetString) * multi;
+      targetArray[atIndex + i] = reverse ? 1 - offsetNumber : offsetNumber;
+      i++;
+    }
+  }
+  return atIndex + i;
+}
+
+function insertColorStopsIntoArray(stops, targetArray, atIndex) {
+  var lastIndex = insertColorsIntoArray(stops, targetArray, atIndex);
+  insertOffsetsIntoArray(stops, targetArray, lastIndex, 1, false);
+}
+
+function insertDoubleColorStopsIntoArray(stops, targetArray, atIndex) {
+  var lastIndex = insertColorsIntoArray(stops, targetArray, atIndex);
+  lastIndex = insertColorsIntoArray(stops, targetArray, lastIndex);
+  lastIndex = insertOffsetsIntoArray(stops, targetArray, lastIndex, 0.5, false);
+  insertOffsetsIntoArray(stops, targetArray, lastIndex, 0.5, true);
+}
+
+function applyBoundingBoxToBrushData(brushData, props) {
+  var type = brushData[0];
+  var width = +props.width;
+  var height = +props.height;
+  if (type === LINEAR_GRADIENT) {
+    brushData[1] *= width;
+    brushData[2] *= height;
+    brushData[3] *= width;
+    brushData[4] *= height;
+  } else if (type === RADIAL_GRADIENT) {
+    brushData[1] *= width;
+    brushData[2] *= height;
+    brushData[3] *= width;
+    brushData[4] *= height;
+    brushData[5] *= width;
+    brushData[6] *= height;
+  } else if (type === PATTERN) {
+    // todo
+  }
+}
+
+function extractBrush(colorOrBrush, props) {
+  if (colorOrBrush == null) {
+    return null;
+  }
+  if (colorOrBrush._brush) {
+    if (colorOrBrush._bb) {
+      // The legacy API for Gradients allow for the bounding box to be used
+      // as a convenience for specifying gradient positions. This should be
+      // deprecated. It's not properly implemented in canvas mode. ReactART
+      // doesn't handle update to the bounding box correctly. That's why we
+      // mutate this so that if it's reused, we reuse the same resolved box.
+      applyBoundingBoxToBrushData(colorOrBrush._brush, props);
+      colorOrBrush._bb = false;
+    }
+    return colorOrBrush._brush;
+  }
+  var c = new Color(colorOrBrush);
+  return [SOLID_COLOR, c.red / 255, c.green / 255, c.blue / 255, c.alpha];
+}
+
+function extractColor(color) {
+  if (color == null) {
+    return null;
+  }
+  var c = new Color(color);
+  return [c.red / 255, c.green / 255, c.blue / 255, c.alpha];
+}
+
+function extractStrokeCap(strokeCap) {
+  switch (strokeCap) {
+    case 'butt': return 0;
+    case 'square': return 2;
+    default: return 1; // round
+  }
+}
+
+function extractStrokeJoin(strokeJoin) {
+  switch (strokeJoin) {
+    case 'miter': return 0;
+    case 'bevel': return 2;
+    default: return 1; // round
+  }
+}
+
+// Shape
+
+// Note: ART has a notion of width and height on Shape but AFAIK it's a noop in
+// ReactART.
+
+class Shape extends React.Component {
+  render() {
+    var props = this.props;
+    var path = props.d || childrenAsString(props.children);
+    var d = (path instanceof Path ? path : new Path(path)).toJSON();
+    return (
+      <NativeShape
+        fill={extractBrush(props.fill, props)}
+        opacity={extractOpacity(props)}
+        stroke={extractColor(props.stroke)}
+        strokeCap={extractStrokeCap(props.strokeCap)}
+        strokeDash={props.strokeDash || null}
+        strokeJoin={extractStrokeJoin(props.strokeJoin)}
+        strokeWidth={extractNumber(props.strokeWidth, 1)}
+        transform={extractTransform(props)}
+
+        d={d}
+      />
+    );
+  }
+}
+
+// Text
+
+var cachedFontObjectsFromString = {};
+
+var fontFamilyPrefix = /^[\s"']*/;
+var fontFamilySuffix = /[\s"']*$/;
+
+function extractSingleFontFamily(fontFamilyString) {
+  // ART on the web allows for multiple font-families to be specified.
+  // For compatibility, we extract the first font-family, hoping
+  // we'll get a match.
+  return fontFamilyString.split(',')[0]
+         .replace(fontFamilyPrefix, '')
+         .replace(fontFamilySuffix, '');
+}
+
+function parseFontString(font) {
+  if (cachedFontObjectsFromString.hasOwnProperty(font)) {
+    return cachedFontObjectsFromString[font];
+  }
+  var regexp = /^\s*((?:(?:normal|bold|italic)\s+)*)(?:(\d+(?:\.\d+)?)[ptexm\%]*(?:\s*\/.*?)?\s+)?\s*\"?([^\"]*)/i;
+  var match = regexp.exec(font);
+  if (!match) {
+    return null;
+  }
+  var fontFamily = extractSingleFontFamily(match[3]);
+  var fontSize = +match[2] || 12;
+  var isBold = /bold/.exec(match[1]);
+  var isItalic = /italic/.exec(match[1]);
+  cachedFontObjectsFromString[font] = {
+    fontFamily: fontFamily,
+    fontSize: fontSize,
+    fontWeight: isBold ? 'bold' : 'normal',
+    fontStyle: isItalic ? 'italic' : 'normal',
+  };
+  return cachedFontObjectsFromString[font];
+}
+
+function extractFont(font) {
+  if (font == null) {
+    return null;
+  }
+  if (typeof font === 'string') {
+    return parseFontString(font);
+  }
+  var fontFamily = extractSingleFontFamily(font.fontFamily);
+  var fontSize = +font.fontSize || 12;
+  var fontWeight = font.fontWeight != null ? font.fontWeight.toString() : '400';
+  return {
+    // Normalize
+    fontFamily: fontFamily,
+    fontSize: fontSize,
+    fontWeight: fontWeight,
+    fontStyle: font.fontStyle,
+  };
+}
+
+var newLine = /\n/g;
+function extractFontAndLines(font, text) {
+  return { font: extractFont(font), lines: text.split(newLine) };
+}
+
+function extractAlignment(alignment) {
+  switch (alignment) {
+    case 'right':
+      return 1;
+    case 'center':
+      return 2;
+    default:
+      return 0;
+  }
+}
+
+class Text extends React.Component {
+  render() {
+    var props = this.props;
+    var path = props.path;
+    var textPath = path ? (path instanceof Path ? path : new Path(path)).toJSON() : null;
+    var textFrame = extractFontAndLines(
+      props.font,
+      childrenAsString(props.children)
+    );
+    return (
+      <NativeText
+        fill={extractBrush(props.fill, props)}
+        opacity={extractOpacity(props)}
+        stroke={extractColor(props.stroke)}
+        strokeCap={extractStrokeCap(props.strokeCap)}
+        strokeDash={props.strokeDash || null}
+        strokeJoin={extractStrokeJoin(props.strokeJoin)}
+        strokeWidth={extractNumber(props.strokeWidth, 1)}
+        transform={extractTransform(props)}
+
+        alignment={extractAlignment(props.alignment)}
+        frame={textFrame}
+        path={textPath}
+      />
+    );
+  }
+}
+
+// Declarative fill type objects - API design not finalized
+
+function LinearGradient(stops, x1, y1, x2, y2) {
+  var type = LINEAR_GRADIENT;
+
+  if (arguments.length < 5) {
+    var angle = ((x1 == null) ? 270 : x1) * Math.PI / 180;
+
+    var x = Math.cos(angle);
+    var y = -Math.sin(angle);
+    var l = (Math.abs(x) + Math.abs(y)) / 2;
+
+    x *= l; y *= l;
+
+    x1 = 0.5 - x;
+    x2 = 0.5 + x;
+    y1 = 0.5 - y;
+    y2 = 0.5 + y;
+    this._bb = true;
+  } else {
+    this._bb = false;
+  }
+
+  var brushData = [type, +x1, +y1, +x2, +y2];
+  insertColorStopsIntoArray(stops, brushData, 5);
+  this._brush = brushData;
+}
+
+function RadialGradient(stops, fx, fy, rx, ry, cx, cy) {
+  if (ry == null) {
+    ry = rx;
+  }
+  if (cx == null) {
+    cx = fx;
+  }
+  if (cy == null) {
+    cy = fy;
+  }
+  if (fx == null) {
+    // As a convenience we allow the whole radial gradient to cover the
+    // bounding box. We should consider dropping this API.
+    fx = fy = rx = ry = cx = cy = 0.5;
+    this._bb = true;
+  } else {
+    this._bb = false;
+  }
+  // The ART API expects the radial gradient to be repeated at the edges.
+  // To simulate this we render the gradient twice as large and add double
+  // color stops. Ideally this API would become more restrictive so that this
+  // extra work isn't needed.
+  var brushData = [RADIAL_GRADIENT, +fx, +fy, +rx * 2, +ry * 2, +cx, +cy];
+  insertDoubleColorStopsIntoArray(stops, brushData, 7);
+  this._brush = brushData;
+}
+
+function Pattern(url, width, height, left, top) {
+  this._brush = [PATTERN, url, +left || 0, +top || 0, +width, +height];
+}
+
+var ReactART = {
+  LinearGradient: LinearGradient,
+  RadialGradient: RadialGradient,
+  Pattern: Pattern,
+  Transform: Transform,
+  Path: Path,
+  Surface: Surface,
+  Group: Group,
+  ClippingRectangle: ClippingRectangle,
+  Shape: Shape,
+  Text: Text,
+};
+
+module.exports = ReactART;

node_modules/react-native/Libraries/ART/ViewManagers/ARTGroupManager.h

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

node_modules/react-native/Libraries/ART/ViewManagers/ARTGroupManager.m

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "ARTGroupManager.h"
+
+#import "ARTGroup.h"
+#import "RCTConvert+ART.h"
+
+@implementation ARTGroupManager
+
+RCT_EXPORT_MODULE()
+
+- (ARTNode *)node
+{
+  return [ARTGroup new];
+}
+
+RCT_EXPORT_VIEW_PROPERTY(clipping, CGRect)
+
+@end

node_modules/react-native/Libraries/ART/ViewManagers/ARTNodeManager.h

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

node_modules/react-native/Libraries/ART/ViewManagers/ARTNodeManager.m

@@ -0,0 +1,34 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "ARTNodeManager.h"
+
+#import "ARTNode.h"
+
+@implementation ARTNodeManager
+
+RCT_EXPORT_MODULE()
+
+- (ARTNode *)node
+{
+  return [ARTNode new];
+}
+
+- (UIView *)view
+{
+  return [self node];
+}
+
+- (RCTShadowView *)shadowView
+{
+  return nil;
+}
+
+RCT_EXPORT_VIEW_PROPERTY(opacity, CGFloat)
+RCT_EXPORT_VIEW_PROPERTY(transform, CGAffineTransform)
+
+@end

node_modules/react-native/Libraries/ART/ViewManagers/ARTRenderableManager.h

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "ARTNodeManager.h"
+#import "ARTRenderable.h"
+
+@interface ARTRenderableManager : ARTNodeManager
+
+- (ARTRenderable *)node;
+
+@end

node_modules/react-native/Libraries/ART/ViewManagers/ARTRenderableManager.m

@@ -0,0 +1,28 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "ARTRenderableManager.h"
+
+#import "RCTConvert+ART.h"
+
+@implementation ARTRenderableManager
+
+RCT_EXPORT_MODULE()
+
+- (ARTRenderable *)node
+{
+  return [ARTRenderable new];
+}
+
+RCT_EXPORT_VIEW_PROPERTY(strokeWidth, CGFloat)
+RCT_EXPORT_VIEW_PROPERTY(strokeCap, CGLineCap)
+RCT_EXPORT_VIEW_PROPERTY(strokeJoin, CGLineJoin)
+RCT_EXPORT_VIEW_PROPERTY(fill, ARTBrush)
+RCT_EXPORT_VIEW_PROPERTY(stroke, CGColor)
+RCT_EXPORT_VIEW_PROPERTY(strokeDash, ARTCGFloatArray)
+
+@end

node_modules/react-native/Libraries/ART/ViewManagers/ARTShapeManager.h

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

node_modules/react-native/Libraries/ART/ViewManagers/ARTShapeManager.m

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "ARTShapeManager.h"
+
+#import "ARTShape.h"
+#import "RCTConvert+ART.h"
+
+@implementation ARTShapeManager
+
+RCT_EXPORT_MODULE()
+
+- (ARTRenderable *)node
+{
+  return [ARTShape new];
+}
+
+RCT_EXPORT_VIEW_PROPERTY(d, CGPath)
+
+@end

node_modules/react-native/Libraries/ART/ViewManagers/ARTSurfaceViewManager.h

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

node_modules/react-native/Libraries/ART/ViewManagers/ARTSurfaceViewManager.m

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "ARTSurfaceViewManager.h"
+
+#import "ARTSurfaceView.h"
+
+@implementation ARTSurfaceViewManager
+
+RCT_EXPORT_MODULE()
+
+- (UIView *)view
+{
+  return [ARTSurfaceView new];
+}
+
+@end

node_modules/react-native/Libraries/ART/ViewManagers/ARTTextManager.h

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

node_modules/react-native/Libraries/ART/ViewManagers/ARTTextManager.m

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "ARTTextManager.h"
+
+#import "ARTText.h"
+#import "RCTConvert+ART.h"
+
+@implementation ARTTextManager
+
+RCT_EXPORT_MODULE()
+
+- (ARTRenderable *)node
+{
+  return [ARTText new];
+}
+
+RCT_EXPORT_VIEW_PROPERTY(alignment, CTTextAlignment)
+RCT_REMAP_VIEW_PROPERTY(frame, textFrame, ARTTextFrame)
+
+@end

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

@@ -0,0 +1,112 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule ActionSheetIOS
+ * @flow
+ * @format
+ */
+'use strict';
+
+const RCTActionSheetManager = require('NativeModules').ActionSheetManager;
+
+const invariant = require('fbjs/lib/invariant');
+const processColor = require('processColor');
+
+/**
+ * Display action sheets and share sheets on iOS.
+ *
+ * See http://facebook.github.io/react-native/docs/actionsheetios.html
+ */
+const ActionSheetIOS = {
+  /**
+   * Display an iOS action sheet.
+   *
+   * The `options` object must contain one or more of:
+   *
+   * - `options` (array of strings) - a list of button titles (required)
+   * - `cancelButtonIndex` (int) - index of cancel button in `options`
+   * - `destructiveButtonIndex` (int) - index of destructive button in `options`
+   * - `title` (string) - a title to show above the action sheet
+   * - `message` (string) - a message to show below the title
+   *
+   * The 'callback' function takes one parameter, the zero-based index
+   * of the selected item.
+   *
+   * See http://facebook.github.io/react-native/docs/actionsheetios.html#showactionsheetwithoptions
+   */
+  showActionSheetWithOptions(
+    options: {|
+      +title?: ?string,
+      +message?: ?string,
+      +options: Array<string>,
+      +destructiveButtonIndex?: ?number,
+      +cancelButtonIndex?: ?number,
+      +anchor?: ?number,
+      +tintColor?: number | string,
+    |},
+    callback: (buttonIndex: number) => void,
+  ) {
+    invariant(
+      typeof options === 'object' && options !== null,
+      'Options must be a valid object',
+    );
+    invariant(typeof callback === 'function', 'Must provide a valid callback');
+
+    RCTActionSheetManager.showActionSheetWithOptions(
+      {...options, tintColor: processColor(options.tintColor)},
+      callback,
+    );
+  },
+
+  /**
+   * Display the iOS share sheet. The `options` object should contain
+   * one or both of `message` and `url` and can additionally have
+   * a `subject` or `excludedActivityTypes`:
+   *
+   * - `url` (string) - a URL to share
+   * - `message` (string) - a message to share
+   * - `subject` (string) - a subject for the message
+   * - `excludedActivityTypes` (array) - the activities to exclude from
+   *   the ActionSheet
+   * - `tintColor` (color) - tint color of the buttons
+   *
+   * The 'failureCallback' function takes one parameter, an error object.
+   * The only property defined on this object is an optional `stack` property
+   * of type `string`.
+   *
+   * The 'successCallback' function takes two parameters:
+   *
+   * - a boolean value signifying success or failure
+   * - a string that, in the case of success, indicates the method of sharing
+   *
+   * See http://facebook.github.io/react-native/docs/actionsheetios.html#showshareactionsheetwithoptions
+   */
+  showShareActionSheetWithOptions(
+    options: Object,
+    failureCallback: Function,
+    successCallback: Function,
+  ) {
+    invariant(
+      typeof options === 'object' && options !== null,
+      'Options must be a valid object',
+    );
+    invariant(
+      typeof failureCallback === 'function',
+      'Must provide a valid failureCallback',
+    );
+    invariant(
+      typeof successCallback === 'function',
+      'Must provide a valid successCallback',
+    );
+    RCTActionSheetManager.showShareActionSheetWithOptions(
+      {...options, tintColor: processColor(options.tintColor)},
+      failureCallback,
+      successCallback,
+    );
+  },
+};
+
+module.exports = ActionSheetIOS;

node_modules/react-native/Libraries/ActionSheetIOS/RCTActionSheet.xcodeproj/project.pbxproj

@@ -0,0 +1,235 @@
+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 46;
+	objects = {
+
+/* Begin PBXBuildFile section */
+		14C644C41AB0DFC900DE3C65 /* RCTActionSheetManager.m in Sources */ = {isa = PBXBuildFile; fileRef = 14C644C21AB0DFC900DE3C65 /* RCTActionSheetManager.m */; };
+/* End PBXBuildFile section */
+
+/* Begin PBXFileReference section */
+		134814201AA4EA6300B7C361 /* libRCTActionSheet.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libRCTActionSheet.a; sourceTree = BUILT_PRODUCTS_DIR; };
+		14C644C11AB0DFC900DE3C65 /* RCTActionSheetManager.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; lineEnding = 0; path = RCTActionSheetManager.h; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.objcpp; };
+		14C644C21AB0DFC900DE3C65 /* RCTActionSheetManager.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RCTActionSheetManager.m; sourceTree = "<group>"; };
+/* End PBXFileReference section */
+
+/* Begin PBXGroup section */
+		134814211AA4EA7D00B7C361 /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				134814201AA4EA6300B7C361 /* libRCTActionSheet.a */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		58B511D21A9E6C8500147676 = {
+			isa = PBXGroup;
+			children = (
+				14C644C11AB0DFC900DE3C65 /* RCTActionSheetManager.h */,
+				14C644C21AB0DFC900DE3C65 /* RCTActionSheetManager.m */,
+				134814211AA4EA7D00B7C361 /* Products */,
+			);
+			indentWidth = 2;
+			sourceTree = "<group>";
+			tabWidth = 2;
+			usesTabs = 0;
+		};
+/* End PBXGroup section */
+
+/* Begin PBXNativeTarget section */
+		58B511DA1A9E6C8500147676 /* RCTActionSheet */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 58B511EF1A9E6C8500147676 /* Build configuration list for PBXNativeTarget "RCTActionSheet" */;
+			buildPhases = (
+				58B511D71A9E6C8500147676 /* Sources */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = RCTActionSheet;
+			productName = RCTDataManager;
+			productReference = 134814201AA4EA6300B7C361 /* libRCTActionSheet.a */;
+			productType = "com.apple.product-type.library.static";
+		};
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+		58B511D31A9E6C8500147676 /* Project object */ = {
+			isa = PBXProject;
+			attributes = {
+				LastUpgradeCheck = 0610;
+				ORGANIZATIONNAME = Facebook;
+				TargetAttributes = {
+					58B511DA1A9E6C8500147676 = {
+						CreatedOnToolsVersion = 6.1.1;
+					};
+				};
+			};
+			buildConfigurationList = 58B511D61A9E6C8500147676 /* Build configuration list for PBXProject "RCTActionSheet" */;
+			compatibilityVersion = "Xcode 3.2";
+			developmentRegion = English;
+			hasScannedForEncodings = 0;
+			knownRegions = (
+				en,
+			);
+			mainGroup = 58B511D21A9E6C8500147676;
+			productRefGroup = 58B511D21A9E6C8500147676;
+			projectDirPath = "";
+			projectRoot = "";
+			targets = (
+				58B511DA1A9E6C8500147676 /* RCTActionSheet */,
+			);
+		};
+/* End PBXProject section */
+
+/* Begin PBXSourcesBuildPhase section */
+		58B511D71A9E6C8500147676 /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				14C644C41AB0DFC900DE3C65 /* RCTActionSheetManager.m in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXSourcesBuildPhase section */
+
+/* Begin XCBuildConfiguration section */
+		58B511ED1A9E6C8500147676 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				COPY_PHASE_STRIP = NO;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_DYNAMIC_NO_PIC = NO;
+				GCC_OPTIMIZATION_LEVEL = 0;
+				GCC_PREPROCESSOR_DEFINITIONS = (
+					"DEBUG=1",
+					"$(inherited)",
+				);
+				GCC_SYMBOLS_PRIVATE_EXTERN = NO;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_INITIALIZER_NOT_FULLY_BRACKETED = YES;
+				GCC_WARN_SHADOW = YES;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 8.0;
+				MTL_ENABLE_DEBUG_INFO = YES;
+				ONLY_ACTIVE_ARCH = YES;
+				SDKROOT = iphoneos;
+				SKIP_INSTALL = YES;
+				WARNING_CFLAGS = (
+					"-Werror",
+					"-Wall",
+				);
+			};
+			name = Debug;
+		};
+		58B511EE1A9E6C8500147676 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				COPY_PHASE_STRIP = YES;
+				ENABLE_NS_ASSERTIONS = NO;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_INITIALIZER_NOT_FULLY_BRACKETED = YES;
+				GCC_WARN_SHADOW = YES;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 8.0;
+				MTL_ENABLE_DEBUG_INFO = NO;
+				SDKROOT = iphoneos;
+				SKIP_INSTALL = YES;
+				VALIDATE_PRODUCT = YES;
+				WARNING_CFLAGS = (
+					"-Werror",
+					"-Wall",
+				);
+			};
+			name = Release;
+		};
+		58B511F01A9E6C8500147676 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				CLANG_STATIC_ANALYZER_MODE = deep;
+				LIBRARY_SEARCH_PATHS = "$(inherited)";
+				OTHER_LDFLAGS = "-ObjC";
+				PRODUCT_NAME = RCTActionSheet;
+				RUN_CLANG_STATIC_ANALYZER = YES;
+			};
+			name = Debug;
+		};
+		58B511F11A9E6C8500147676 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				CLANG_STATIC_ANALYZER_MODE = deep;
+				LIBRARY_SEARCH_PATHS = "$(inherited)";
+				OTHER_LDFLAGS = "-ObjC";
+				PRODUCT_NAME = RCTActionSheet;
+				RUN_CLANG_STATIC_ANALYZER = NO;
+			};
+			name = Release;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		58B511D61A9E6C8500147676 /* Build configuration list for PBXProject "RCTActionSheet" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				58B511ED1A9E6C8500147676 /* Debug */,
+				58B511EE1A9E6C8500147676 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		58B511EF1A9E6C8500147676 /* Build configuration list for PBXNativeTarget "RCTActionSheet" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				58B511F01A9E6C8500147676 /* Debug */,
+				58B511F11A9E6C8500147676 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+/* End XCConfigurationList section */
+	};
+	rootObject = 58B511D31A9E6C8500147676 /* Project object */;
+}

node_modules/react-native/Libraries/ActionSheetIOS/RCTActionSheetManager.h

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

node_modules/react-native/Libraries/ActionSheetIOS/RCTActionSheetManager.m

@@ -0,0 +1,202 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTActionSheetManager.h"
+
+#import <React/RCTBridge.h>
+#import <React/RCTConvert.h>
+#import <React/RCTLog.h>
+#import <React/RCTUIManager.h>
+#import <React/RCTUtils.h>
+
+@interface RCTActionSheetManager () <UIActionSheetDelegate>
+@end
+
+@implementation RCTActionSheetManager
+{
+  // Use NSMapTable, as UIAlertViews do not implement <NSCopying>
+  // which is required for NSDictionary keys
+  NSMapTable *_callbacks;
+}
+
+RCT_EXPORT_MODULE()
+
+@synthesize bridge = _bridge;
+
+- (dispatch_queue_t)methodQueue
+{
+  return dispatch_get_main_queue();
+}
+
+/*
+ * The `anchor` option takes a view to set as the anchor for the share
+ * popup to point to, on iPads running iOS 8. If it is not passed, it
+ * defaults to centering the share popup on screen without any arrows.
+ */
+- (CGRect)sourceRectInView:(UIView *)sourceView
+             anchorViewTag:(NSNumber *)anchorViewTag
+{
+  if (anchorViewTag) {
+    UIView *anchorView = [self.bridge.uiManager viewForReactTag:anchorViewTag];
+    return [anchorView convertRect:anchorView.bounds toView:sourceView];
+  } else {
+    return (CGRect){sourceView.center, {1, 1}};
+  }
+}
+
+RCT_EXPORT_METHOD(showActionSheetWithOptions:(NSDictionary *)options
+                  callback:(RCTResponseSenderBlock)callback)
+{
+  if (RCTRunningInAppExtension()) {
+    RCTLogError(@"Unable to show action sheet from app extension");
+    return;
+  }
+
+  if (!_callbacks) {
+    _callbacks = [NSMapTable strongToStrongObjectsMapTable];
+  }
+
+  NSString *title = [RCTConvert NSString:options[@"title"]];
+  NSString *message = [RCTConvert NSString:options[@"message"]];
+  NSArray<NSString *> *buttons = [RCTConvert NSStringArray:options[@"options"]];
+  NSInteger destructiveButtonIndex = options[@"destructiveButtonIndex"] ? [RCTConvert NSInteger:options[@"destructiveButtonIndex"]] : -1;
+  NSInteger cancelButtonIndex = options[@"cancelButtonIndex"] ? [RCTConvert NSInteger:options[@"cancelButtonIndex"]] : -1;
+
+  UIViewController *controller = RCTPresentedViewController();
+
+  if (controller == nil) {
+    RCTLogError(@"Tried to display action sheet but there is no application window. options: %@", options);
+    return;
+  }
+
+  /*
+   * The `anchor` option takes a view to set as the anchor for the share
+   * popup to point to, on iPads running iOS 8. If it is not passed, it
+   * defaults to centering the share popup on screen without any arrows.
+   */
+  NSNumber *anchorViewTag = [RCTConvert NSNumber:options[@"anchor"]];
+  UIView *sourceView = controller.view;
+  CGRect sourceRect = [self sourceRectInView:sourceView anchorViewTag:anchorViewTag];
+
+  UIAlertController *alertController =
+  [UIAlertController alertControllerWithTitle:title
+                                      message:message
+                               preferredStyle:UIAlertControllerStyleActionSheet];
+
+  NSInteger index = 0;
+  for (NSString *option in buttons) {
+    UIAlertActionStyle style = UIAlertActionStyleDefault;
+    if (index == destructiveButtonIndex) {
+      style = UIAlertActionStyleDestructive;
+    } else if (index == cancelButtonIndex) {
+      style = UIAlertActionStyleCancel;
+    }
+
+    NSInteger localIndex = index;
+    [alertController addAction:[UIAlertAction actionWithTitle:option
+                                                        style:style
+                                                      handler:^(__unused UIAlertAction *action){
+      callback(@[@(localIndex)]);
+    }]];
+
+    index++;
+  }
+
+  alertController.modalPresentationStyle = UIModalPresentationPopover;
+  alertController.popoverPresentationController.sourceView = sourceView;
+  alertController.popoverPresentationController.sourceRect = sourceRect;
+  if (!anchorViewTag) {
+    alertController.popoverPresentationController.permittedArrowDirections = 0;
+  }
+  [controller presentViewController:alertController animated:YES completion:nil];
+
+  alertController.view.tintColor = [RCTConvert UIColor:options[@"tintColor"]];
+}
+
+RCT_EXPORT_METHOD(showShareActionSheetWithOptions:(NSDictionary *)options
+                  failureCallback:(RCTResponseErrorBlock)failureCallback
+                  successCallback:(RCTResponseSenderBlock)successCallback)
+{
+  if (RCTRunningInAppExtension()) {
+    RCTLogError(@"Unable to show action sheet from app extension");
+    return;
+  }
+
+  NSMutableArray<id> *items = [NSMutableArray array];
+  NSString *message = [RCTConvert NSString:options[@"message"]];
+  if (message) {
+    [items addObject:message];
+  }
+  NSURL *URL = [RCTConvert NSURL:options[@"url"]];
+  if (URL) {
+    if ([URL.scheme.lowercaseString isEqualToString:@"data"]) {
+      NSError *error;
+      NSData *data = [NSData dataWithContentsOfURL:URL
+                                           options:(NSDataReadingOptions)0
+                                             error:&error];
+      if (!data) {
+        failureCallback(error);
+        return;
+      }
+      [items addObject:data];
+    } else {
+      [items addObject:URL];
+    }
+  }
+  if (items.count == 0) {
+    RCTLogError(@"No `url` or `message` to share");
+    return;
+  }
+
+  UIActivityViewController *shareController = [[UIActivityViewController alloc] initWithActivityItems:items applicationActivities:nil];
+
+  NSString *subject = [RCTConvert NSString:options[@"subject"]];
+  if (subject) {
+    [shareController setValue:subject forKey:@"subject"];
+  }
+
+  NSArray *excludedActivityTypes = [RCTConvert NSStringArray:options[@"excludedActivityTypes"]];
+  if (excludedActivityTypes) {
+    shareController.excludedActivityTypes = excludedActivityTypes;
+  }
+
+  UIViewController *controller = RCTPresentedViewController();
+  shareController.completionWithItemsHandler = ^(NSString *activityType, BOOL completed, __unused NSArray *returnedItems, NSError *activityError) {
+    if (activityError) {
+      failureCallback(activityError);
+    } else {
+      successCallback(@[@(completed), RCTNullIfNil(activityType)]);
+    }
+  };
+
+  shareController.modalPresentationStyle = UIModalPresentationPopover;
+  NSNumber *anchorViewTag = [RCTConvert NSNumber:options[@"anchor"]];
+  if (!anchorViewTag) {
+    shareController.popoverPresentationController.permittedArrowDirections = 0;
+  }
+  shareController.popoverPresentationController.sourceView = controller.view;
+  shareController.popoverPresentationController.sourceRect = [self sourceRectInView:controller.view anchorViewTag:anchorViewTag];
+
+  [controller presentViewController:shareController animated:YES completion:nil];
+
+  shareController.view.tintColor = [RCTConvert UIColor:options[@"tintColor"]];
+}
+
+#pragma mark UIActionSheetDelegate Methods
+
+- (void)actionSheet:(UIActionSheet *)actionSheet clickedButtonAtIndex:(NSInteger)buttonIndex
+{
+  RCTResponseSenderBlock callback = [_callbacks objectForKey:actionSheet];
+  if (callback) {
+    callback(@[@(buttonIndex)]);
+    [_callbacks removeObjectForKey:actionSheet];
+  } else {
+    RCTLogWarn(@"No callback registered for action sheet: %@", actionSheet.title);
+  }
+}
+
+@end

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

@@ -0,0 +1,115 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule Alert
+ * @flow
+ */
+'use strict';
+
+const AlertIOS = require('AlertIOS');
+const NativeModules = require('NativeModules');
+const Platform = require('Platform');
+
+import type { AlertType, AlertButtonStyle } from 'AlertIOS';
+
+export type Buttons = Array<{
+  text?: string,
+  onPress?: ?Function,
+  style?: AlertButtonStyle,
+}>;
+
+type Options = {
+  cancelable?: ?boolean,
+  onDismiss?: ?Function,
+};
+
+/**
+ * Launches an alert dialog with the specified title and message.
+ *
+ * See http://facebook.github.io/react-native/docs/alert.html
+ */
+class Alert {
+
+  /**
+   * Launches an alert dialog with the specified title and message.
+   *
+   * See http://facebook.github.io/react-native/docs/alert.html#alert
+   */
+  static alert(
+    title: ?string,
+    message?: ?string,
+    buttons?: Buttons,
+    options?: Options,
+    type?: AlertType,
+  ): void {
+    if (Platform.OS === 'ios') {
+      if (typeof type !== 'undefined') {
+        console.warn('Alert.alert() with a 5th "type" parameter is deprecated and will be removed. Use AlertIOS.prompt() instead.');
+        AlertIOS.alert(title, message, buttons, type);
+        return;
+      }
+      AlertIOS.alert(title, message, buttons);
+    } else if (Platform.OS === 'android') {
+      AlertAndroid.alert(title, message, buttons, options);
+    }
+  }
+}
+
+/**
+ * Wrapper around the Android native module.
+ */
+class AlertAndroid {
+
+  static alert(
+    title: ?string,
+    message?: ?string,
+    buttons?: Buttons,
+    options?: Options,
+  ): void {
+    var config = {
+      title: title || '',
+      message: message || '',
+    };
+
+    if (options) {
+      config = {...config, cancelable: options.cancelable};
+    }
+    // At most three buttons (neutral, negative, positive). Ignore rest.
+    // The text 'OK' should be probably localized. iOS Alert does that in native.
+    var validButtons: Buttons = buttons ? buttons.slice(0, 3) : [{text: 'OK'}];
+    var buttonPositive = validButtons.pop();
+    var buttonNegative = validButtons.pop();
+    var buttonNeutral = validButtons.pop();
+    if (buttonNeutral) {
+      config = {...config, buttonNeutral: buttonNeutral.text || '' };
+    }
+    if (buttonNegative) {
+      config = {...config, buttonNegative: buttonNegative.text || '' };
+    }
+    if (buttonPositive) {
+      config = {...config, buttonPositive: buttonPositive.text || '' };
+    }
+    NativeModules.DialogManagerAndroid.showAlert(
+      config,
+      (errorMessage) => console.warn(errorMessage),
+      (action, buttonKey) => {
+        if (action === NativeModules.DialogManagerAndroid.buttonClicked) {
+          if (buttonKey === NativeModules.DialogManagerAndroid.buttonNeutral) {
+            buttonNeutral.onPress && buttonNeutral.onPress();
+          } else if (buttonKey === NativeModules.DialogManagerAndroid.buttonNegative) {
+            buttonNegative.onPress && buttonNegative.onPress();
+          } else if (buttonKey === NativeModules.DialogManagerAndroid.buttonPositive) {
+            buttonPositive.onPress && buttonPositive.onPress();
+          }
+        } else if (action === NativeModules.DialogManagerAndroid.dismissed) {
+          options && options.onDismiss && options.onDismiss();
+        }
+      }
+    );
+  }
+}
+
+module.exports = Alert;

node_modules/react-native/Libraries/Alert/AlertIOS.js

@@ -0,0 +1,172 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule AlertIOS
+ * @flow
+ * @jsdoc
+ */
+'use strict';
+
+var RCTAlertManager = require('NativeModules').AlertManager;
+
+/**
+ * An Alert button type
+ */
+export type AlertType = $Enum<{
+  /**
+   * Default alert with no inputs
+   */
+  'default': string,
+  /**
+   * Plain text input alert
+   */
+  'plain-text': string,
+  /**
+   * Secure text input alert
+   */
+  'secure-text': string,
+  /**
+   * Login and password alert
+   */
+  'login-password': string,
+}>;
+
+/**
+ * An Alert button style
+ */
+export type AlertButtonStyle = $Enum<{
+  /**
+   * Default button style
+   */
+  'default': string,
+  /**
+   * Cancel button style
+   */
+  'cancel': string,
+  /**
+   * Destructive button style
+   */
+  'destructive': string,
+}>;
+
+/**
+ * Array or buttons
+ * @typedef {Array} ButtonsArray
+ * @property {string=} text Button label
+ * @property {Function=} onPress Callback function when button pressed
+ * @property {AlertButtonStyle=} style Button style
+ */
+export type ButtonsArray = Array<{
+  /**
+   * Button label
+   */
+  text?: string,
+  /**
+   * Callback function when button pressed
+   */
+  onPress?: ?Function,
+  /**
+   * Button style
+   */
+  style?: AlertButtonStyle,
+}>;
+
+/**
+ * Use `AlertIOS` to display an alert dialog with a message or to create a prompt for user input on iOS. If you don't need to prompt for user input, we recommend using `Alert.alert() for cross-platform support.
+ *
+ * See http://facebook.github.io/react-native/docs/alertios.html
+ */
+class AlertIOS {
+  /**
+   * Create and display a popup alert.
+   *
+   * See http://facebook.github.io/react-native/docs/alertios.html#alert
+   */
+  static alert(
+    title: ?string,
+    message?: ?string,
+    callbackOrButtons?: ?(() => void) | ButtonsArray,
+    type?: AlertType,
+  ): void {
+    if (typeof type !== 'undefined') {
+      console.warn('AlertIOS.alert() with a 4th "type" parameter is deprecated and will be removed. Use AlertIOS.prompt() instead.');
+      this.prompt(title, message, callbackOrButtons, type);
+      return;
+    }
+    this.prompt(title, message, callbackOrButtons, 'default');
+  }
+
+  /**
+   * Create and display a prompt to enter some text.
+   *
+   * See http://facebook.github.io/react-native/docs/alertios.html#prompt
+   */
+  static prompt(
+    title: ?string,
+    message?: ?string,
+    callbackOrButtons?: ?((text: string) => void) | ButtonsArray,
+    type?: ?AlertType = 'plain-text',
+    defaultValue?: string,
+    keyboardType?: string
+  ): void {
+    if (typeof type === 'function') {
+      console.warn(
+        'You passed a callback function as the "type" argument to AlertIOS.prompt(). React Native is ' +
+        'assuming  you want to use the deprecated AlertIOS.prompt(title, defaultValue, buttons, callback) ' +
+        'signature. The current signature is AlertIOS.prompt(title, message, callbackOrButtons, type, defaultValue, ' +
+        'keyboardType) and the old syntax will be removed in a future version.');
+
+      var callback = type;
+      RCTAlertManager.alertWithArgs({
+        title: title || '',
+        type: 'plain-text',
+        defaultValue: message,
+      }, (id, value) => {
+        callback(value);
+      });
+      return;
+    }
+
+    var callbacks = [];
+    var buttons = [];
+    var cancelButtonKey;
+    var destructiveButtonKey;
+    if (typeof callbackOrButtons === 'function') {
+      callbacks = [callbackOrButtons];
+    }
+    else if (callbackOrButtons instanceof Array) {
+      callbackOrButtons.forEach((btn, index) => {
+        callbacks[index] = btn.onPress;
+        if (btn.style === 'cancel') {
+          cancelButtonKey = String(index);
+        } else if (btn.style === 'destructive') {
+          destructiveButtonKey = String(index);
+        }
+        if (btn.text || index < (callbackOrButtons || []).length - 1) {
+          var btnDef = {};
+          btnDef[index] = btn.text || '';
+          buttons.push(btnDef);
+        }
+      });
+    }
+
+    RCTAlertManager.alertWithArgs({
+      title: title || '',
+      message: message || undefined,
+      buttons,
+      type: type || undefined,
+      defaultValue,
+      cancelButtonKey,
+      destructiveButtonKey,
+      keyboardType,
+    }, (id, value) => {
+      var cb = callbacks[id];
+      cb && cb(value);
+    });
+  }
+}
+
+module.exports = AlertIOS;

node_modules/react-native/Libraries/Alert/RCTAlertManager.android.js

@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule RCTAlertManager
+*/
+'use strict';
+
+var NativeModules = require('NativeModules');
+
+function emptyCallback() {}
+
+module.exports = {
+  alertWithArgs: function(args, callback) {
+    // TODO(5998984): Polyfill it correctly with DialogManagerAndroid
+    NativeModules.DialogManagerAndroid.showAlert(
+        args,
+        emptyCallback,
+        callback || emptyCallback);
+  },
+};

node_modules/react-native/Libraries/Alert/RCTAlertManager.ios.js

@@ -0,0 +1,14 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule RCTAlertManager
+ * @flow
+ */
+'use strict';
+
+var RCTAlertManager = require('NativeModules').AlertManager;
+
+module.exports = RCTAlertManager;

node_modules/react-native/Libraries/Animated/examples/demo.html

@@ -0,0 +1,712 @@
+
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta http-equiv='Content-type' content='text/html; charset=utf-8'>
+    <title>Animated</title>
+    <link href="./style.css" rel="stylesheet" type="text/css">
+    <script src="https://fb.me/react-with-addons-0.13.3.js"></script>
+    <script src="https://fb.me/JSXTransformer-0.13.3.js"></script>
+    <script src="../release/dist/animated.js"></script>
+    <style>
+
+    </style>
+    <script>
+    var TOTAL_EXAMPLES = 0;
+    function example() {
+      var scripts = document.getElementsByTagName('script');
+      var last = scripts[scripts.length - 2];
+      last.className = 'Example' + (++TOTAL_EXAMPLES);
+    }
+    </script>
+    <script type="text/jsx;harmony=true;stripTypes=true">
+
+    var HorizontalPan = function(anim, config) {
+      config = config || {};
+      return {
+        onMouseDown: function(event) {
+          anim.stopAnimation(startValue => {
+            config.onStart && config.onStart();
+            var startPosition = event.clientX;
+            var lastTime = Date.now();
+            var lastPosition = event.clientX;
+            var velocity = 0;
+
+            function updateVelocity(event) {
+              var now = Date.now();
+              if (event.clientX === lastPosition || now === lastTime) {
+                return;
+              }
+              velocity = (event.clientX - lastPosition) / (now - lastTime);
+              lastTime = now;
+              lastPosition = event.clientX;
+            }
+
+            var moveListener, upListener;
+            window.addEventListener('mousemove', moveListener = (event) => {
+              var value = startValue + (event.clientX - startPosition);
+              anim.setValue(value);
+              updateVelocity(event);
+            });
+            window.addEventListener('mouseup', upListener = (event) => {
+              updateVelocity(event);
+              window.removeEventListener('mousemove', moveListener);
+              window.removeEventListener('mouseup', upListener);
+              config.onEnd && config.onEnd({velocity});
+            });
+          });
+        }
+      }
+    };
+
+    var EXAMPLE_COUNT = 0;
+    function examplify(Component) {
+      if (EXAMPLE_COUNT) {
+        var previousScript = document.getElementsByClassName('Example' + EXAMPLE_COUNT)[0].innerText;
+      } else {
+        var previousScript = `
+        examplify(React.createClass({
+          getInitialState: function() {
+            return {
+              anim: new Animated.Value(0), // ignore
+            };
+          },
+          render: function() {
+            return (
+              <Animated.div // ignore
+                style={{left: this.state.anim}} // ignore
+                className="circle"
+              />
+            );
+          },
+        }));
+        `;
+      }
+
+      var script = document.getElementsByClassName('Example' + ++EXAMPLE_COUNT)[0];
+
+      var previousLines = {};
+      previousScript.split(/\n/g).forEach(line => { previousLines[line.trim()] = 1; });
+      var code = document.createElement('div');
+      script.parentNode.insertBefore(code, script);
+
+      var Example = React.createClass({
+        render() {
+          return (
+            <div className="code">
+              <div className="example">
+                <button
+                  className="reset"
+                  onClick={() => this.forceUpdate()}>
+                  Reset
+                </button>
+                <Component key={Math.random()} />
+              </div>
+              <hr />
+              <pre>{'React.createClass({'}</pre>
+              {script.innerText
+                .trim()
+                .split(/\n/g)
+                .slice(1, -1)
+                .map(line =>
+                  <pre
+                    className={!previousLines[line.trim()] && 'highlight'}>
+                    {line}
+                  </pre>
+                )
+              }
+              <pre>{'});'}</pre>
+            </div>
+          );
+        }
+      })
+
+      React.render(<Example />, code);
+    }
+    </script>
+
+  </head>
+
+  <body>
+  <div class="container">
+
+  <h1>Animated</h1>
+  <p>Animations have for a long time been a weak point of the React ecosystem. The <code>Animated</code> library aims at solving this problem. It embraces the declarative aspect of React and obtains performance by using raw DOM manipulation behind the scenes instead of the usual diff.</p>
+
+  <h2>Animated.Value</h2>
+
+  <p>The basic building block of this library is <code>Animated.Value</code>. This is a variable that's going to drive the animation. You use it like a normal value in <code>style</code> attribute. Only animated components such as <code>Animated.div</code> will understand it.</p>
+
+<script type="text/jsx;harmony=true;stripTypes=true">
+examplify(React.createClass({
+  getInitialState: function() {
+    return {
+      anim: new Animated.Value(100),
+    };
+  },
+  render: function() {
+    return (
+      <Animated.div
+        style={{left: this.state.anim}}
+        className="circle"
+      />
+    );
+  },
+}));
+</script><script>example();</script>
+
+<h2>setValue</h2>
+
+<p>As you can see, the value is being used inside of <code>render()</code> as you would expect. However, you don't call <code>setState()</code> in order to update the value. Instead, you can call <code>setValue()</code> directly on the value itself. We are using a form of data binding.</p>
+
+<p>The <code>Animated.div</code> component when rendered tracks which animated values it received. This way, whenever that value changes, we don't need to re-render the entire component, we can directly update the specific style attribute that changed.</p>
+
+<script type="text/jsx;harmony=true;stripTypes=true">
+examplify(React.createClass({
+  getInitialState: function() {
+    return {
+      anim: new Animated.Value(0),
+    };
+  },
+  render: function() {
+    return (
+      <Animated.div
+        style={{left: this.state.anim}}
+        className="circle"
+        onClick={this.handleClick}>
+        Click
+      </Animated.div>
+    );
+  },
+  handleClick: function() {
+    this.state.anim.setValue(400);
+  },
+}));
+</script><script>example();</script>
+
+<h2>Animated.timing</h2>
+
+<p>Now that we understand how the system works, let's play with some animations! The hello world of animations is to move the element somewhere else. To do that, we're going to animate the value from the current value 0 to the value 400.</p>
+
+<p>On every frame (via <code>requestAnimationFrame</code>), the <code>timing</code> animation is going to figure out the new value based on the current time, update the animated value which in turn is going to update the corresponding DOM node.</p>
+
+<script type="text/jsx;harmony=true;stripTypes=true">
+examplify(React.createClass({
+  getInitialState: function() {
+    return {
+      anim: new Animated.Value(0),
+    };
+  },
+  render: function() {
+    return (
+      <Animated.div
+        style={{left: this.state.anim}}
+        className="circle"
+        onClick={this.handleClick}>
+        Click
+      </Animated.div>
+    );
+  },
+  handleClick: function() {
+    Animated.timing(this.state.anim, {toValue: 400}).start();
+  },
+}));
+</script><script>example();</script>
+
+<h2>Interrupt Animations</h2>
+
+<p>As a developer, the mental model is that most animations are fire and forget. When the user presses the button, you want it to shrink to 80% and when she releases, you want it to go back to 100%.</p>
+
+<p>There are multiple challenges to implement this correctly. You need to stop the current animation, grab the current value and restart an animation from there. As this is pretty tedious to do manually, <code>Animated</code> will do that automatically for you.</p>
+
+<script type="text/jsx;harmony=true;stripTypes=true">
+examplify(React.createClass({
+  getInitialState: function() {
+    return {
+      anim: new Animated.Value(1),
+    };
+  },
+  render: function() {
+    return (
+      <Animated.div
+        style={{transform: [{scale: this.state.anim}]}}
+        className="circle"
+        onMouseDown={this.handleMouseDown}
+        onMouseUp={this.handleMouseUp}>
+        Press
+      </Animated.div>
+    );
+  },
+  handleMouseDown: function() {
+    Animated.timing(this.state.anim, { toValue: 0.8 }).start();
+  },
+  handleMouseUp: function() {
+    Animated.timing(this.state.anim, { toValue: 1 }).start();
+  },
+}));
+</script><script>example();</script>
+
+<h2>Animated.spring</h2>
+
+<p>Unfortunately, the <code>timing</code> animation doesn't feel good. The main reason is that no matter how far you are in the animation, it will trigger a new one with always the same duration.</p>
+
+<p>The commonly used solution for this problem is to use the equation of a real-world spring. Imagine that you attach a spring to the target value, stretch it to the current value and let it go. The spring movement is going to be the same as the update.</p>
+
+<p>It turns out that this model is useful in a very wide range of animations. I highly recommend you to always start with a <code>spring</code> animation instead of a <code>timing</code> animation. It will make your interface feels much better.</p>
+
+<script type="text/jsx;harmony=true;stripTypes=true">
+examplify(React.createClass({
+  getInitialState: function() {
+    return {
+      anim: new Animated.Value(1),
+    };
+  },
+  render: function() {
+    return (
+      <Animated.div
+        style={{transform: [{scale: this.state.anim}]}}
+        className="circle"
+        onMouseDown={this.handleMouseDown}
+        onMouseUp={this.handleMouseUp}>
+        Press
+      </Animated.div>
+    );
+  },
+  handleMouseDown: function() {
+    Animated.spring(this.state.anim, { toValue: 0.8 }).start();
+  },
+  handleMouseUp: function() {
+    Animated.spring(this.state.anim, { toValue: 1 }).start();
+  },
+}));
+</script><script>example();</script>
+
+<h2>interpolate</h2>
+
+<p>It is very common to animate multiple attributes during the same animation. The usual way to implement it is to start a separate animation for each of the attribute. The downside is that you now have to manage a different state per attribute which is not ideal.</p>
+
+<p>With <code>Animated</code>, you can use a single state variable and render it in multiple attributes. When the value is updated, all the places will reflect the change.</p>
+
+<p>In the following example, we're going to model the animation with a variable where 1 means fully visible and 0 means fully hidden. We can pass it directly to the scale attribute as the ranges match. But for the rotation, we need to convert [0 ; 1] range to [260deg ; 0deg]. This is where <code>interpolate()</code> comes handy.</p>
+
+<script type="text/jsx;harmony=true;stripTypes=true">
+examplify(React.createClass({
+  getInitialState: function() {
+    return {
+      anim: new Animated.Value(1),
+    };
+  },
+  render: function() {
+    return (
+      <Animated.div
+        style={{
+          transform: [
+            {rotate: this.state.anim.interpolate({
+              inputRange: [0, 1],
+              outputRange: ['260deg', '0deg']
+            })},
+            {scale: this.state.anim},
+          ]
+        }}
+        className="circle"
+        onClick={this.handleClick}>
+        Click
+      </Animated.div>
+    );
+  },
+  handleClick: function() {
+    Animated.spring(this.state.anim, {toValue: 0}).start();
+  }
+}));
+</script><script>example();</script>
+
+<h2>stopAnimation</h2>
+
+<p>The reason why we can get away with not calling <code>render()</code> and instead modify the DOM directly on updates is because the animated values are <strong>opaque</strong>. In render, <strong>you cannot know the current value</strong>, which prevents you from being able to modify the structure of the DOM.</p>
+
+<p><code>Animated</code> can offload the animation to a different thread (CoreAnimation, CSS transitions, main thread...) and we don't have a good way to know the real value. If you try to query the value then modify it, you are going to be out of sync and the result will look terrible.</p>
+
+<p>There's however one exception: when you want to stop the current animation. You need to know where it stopped in order to continue from there. We cannot know the value synchronously so we give it via a callback in <code>stopAnimation</code>. It will not suffer from being out of sync since the animation is no longer running.</p>
+
+<script type="text/jsx;harmony=true;stripTypes=true">
+examplify(React.createClass({
+  getInitialState: function() {
+    return {
+      anim: new Animated.Value(0)
+    };
+  },
+  render: function() {
+    return (
+      <div>
+        <button onClick={() => this.handleClick(-1)}>&lt;</button>
+        <Animated.div
+          style={{
+            transform: [
+              {rotate: this.state.anim.interpolate({
+                inputRange: [0, 4],
+                outputRange: ['0deg', '360deg']
+              })},
+            ],
+            position: 'relative'
+          }}
+          className="circle"
+        />
+        <button onClick={() => this.handleClick(+1)}>&gt;</button>
+      </div>
+    );
+  },
+  handleClick: function(delta) {
+    this.state.anim.stopAnimation(value => {
+      Animated.spring(this.state.anim, {
+        toValue: Math.round(value) + delta
+      }).start();
+    });
+  },
+}));
+</script><script>example();</script>
+
+
+<h1>Gesture-based Animations</h1>
+
+<p>Most animations libraries only deal with time-based animations. But, as we move to mobile, a lot of animations are also gesture driven. Even more problematic, they often switch between both modes: once the gesture is over, you start a time-based animation using the same interpolations.</p>
+
+<p><code>Animated</code> has been designed with this use case in mind. The key aspect is that there are three distinct and separate concepts: inputs, value, output. The same value can be updated either from a time-based animation or a gesture-based one. Because we use this intermediate representation for the animation, we can keep the same rendering as output.</p>
+
+<h2>HorizontalPan</h2>
+
+<p>The code needed to drag elements around is very messy with the DOM APIs. On mousedown, you need to register a mousemove listener on window otherwise you may drop touches if you move too fast. <code>removeEventListener</code> takes the same arguments as <code>addEventListener</code> instead of an id like <code>clearTimeout</code>. It's also really easy to forget to remove a listener and have a leak. And finally, you need to store the current position and value at the beginning and update only compared to it.</p>
+
+<p>We introduce a little helper called <code>HorizontalPan</code> which handles all this annoying code for us. It takes an <code>Animated.Value</code> as first argument and returns the event handlers required for it to work. We just have to bind this value to the <code>left</code> attribute and we're good to go.</p>
+
+<script type="text/jsx;harmony=true;stripTypes=true">
+examplify(React.createClass({
+  getInitialState: function() {
+    return {
+      anim: new Animated.Value(0),
+    };
+  },
+  render: function() {
+    return (
+      <Animated.div
+        style={{left: this.state.anim}}
+        className="circle"
+        {...HorizontalPan(this.state.anim)}>
+        Drag
+      </Animated.div>
+    );
+  },
+}));
+</script><script>example();</script>
+
+<h2>Animated.decay</h2>
+
+<p>One of the big breakthrough of the iPhone is the fact that when you release the finger while scrolling, it will not abruptly stop but instead keep going for some time.</p>
+
+<p>In order to implement this effect, we are using a second real-world simulation: an object moving on an icy surface. All it needs is two values: the current velocity and a deceleration coefficient. It is implemented by <code>Animated.decay</code>.</p>
+
+<script type="text/jsx;harmony=true;stripTypes=true">
+examplify(React.createClass({
+  getInitialState: function() {
+    return {
+      anim: new Animated.Value(0),
+    };
+  },
+  render: function() {
+    return (
+      <Animated.div
+        style={{left: this.state.anim}}
+        className="circle"
+        {...HorizontalPan(this.state.anim, {
+          onEnd: this.handleEnd
+        })}>
+        Throw
+      </Animated.div>
+    );
+  },
+  handleEnd: function({velocity}) {
+    Animated.decay(this.state.anim, {velocity}).start();
+  }
+}));
+</script><script>example();</script>
+
+<h2>Animation Chaining</h2>
+
+<p>The target for an animation is usually a number but sometimes it is convenient to use another value as a target. This way, the first value will track the second. Using a spring animation, we can get a nice trailing effect.</p>
+
+<script type="text/jsx;harmony=true;stripTypes=true">
+examplify(React.createClass({
+  getInitialState: function() {
+    var anims = [0, 1, 2, 3, 4].map((_, i) => new Animated.Value(0));
+    Animated.spring(anims[0], {toValue: anims[1]}).start();
+    Animated.spring(anims[1], {toValue: anims[2]}).start();
+    Animated.spring(anims[2], {toValue: anims[3]}).start();
+    Animated.spring(anims[3], {toValue: anims[4]}).start();
+    return {
+      anims: anims,
+    };
+  },
+  render: function() {
+    return (
+      <div>
+        {this.state.anims.map((anim, i) =>
+          <Animated.div
+            style={{left: anim}}
+            className="circle"
+            {...(i === 4 && HorizontalPan(anim, {
+              onEnd: this.handleEnd
+            }))}>
+            {i === 4 && 'Drag'}
+          </Animated.div>
+        )}
+      </div>
+    );
+  },
+  handleEnd: function({velocity}) {
+    Animated.decay(this.state.anims[4], {velocity}).start();
+  }
+}));
+</script><script>example();</script>
+
+<h2>addListener</h2>
+
+<p>As I said earlier, if you track a spring</p>
+
+<script type="text/jsx;harmony=true;stripTypes=true">
+examplify(React.createClass({
+  getInitialState: function() {
+    var anims = [0, 1, 2, 3, 4].map((_, i) => new Animated.Value(i * 100));
+    anims[0].addListener(this.handleChange);
+    return {
+      selected: null,
+      anims: anims,
+    };
+  },
+  render: function() {
+    return (
+      <div>
+        {this.state.anims.map((anim, i) =>
+          <Animated.div
+            style={{
+              left: anim,
+              opacity: i === 0 || i === this.state.selected ? 1 : 0.5
+            }}
+            className="circle"
+            {...(i === 0 && HorizontalPan(anim, { onEnd: this.handleEnd }))}>
+            {i === 0 && 'Drag'}
+            {i === this.state.selected && 'Selected!'}
+          </Animated.div>
+        )}
+      </div>
+    );
+  },
+  handleChange: function({value}) {
+    var selected = null;
+    this.state.anims.forEach((_, i) => {
+      if (i !== 0 && i * 100 - 50 < value && value <= i * 100 + 50) {
+        selected = i;
+      }
+    });
+    if (selected !== this.state.selected) {
+      this.select(selected)
+    }
+  },
+  select(selected) {
+    this.setState({selected}, () => {
+      this.state.anims.forEach((anim, i) => {
+        if (i === 0) { return; }
+        if (selected === i) {
+          Animated.spring(anim, {toValue: this.state.anims[0]}).start();
+        } else {
+          Animated.spring(anim, {toValue: i * 100}).start();
+        }
+      });
+    });
+  },
+  handleEnd() {
+    this.select(null);
+    Animated.spring(this.state.anims[0], {toValue: 0}).start();
+  }
+}));
+</script><script>example();</script>
+
+
+<h2>Animated.sequence</h2>
+
+<p>It is very common to animate </p>
+
+<script type="text/jsx;harmony=true;stripTypes=true">
+examplify(React.createClass({
+  getInitialState: function() {
+    return {
+      anims: [0, 1, 2, 3, 4].map((_, i) => new Animated.Value(0.2)),
+    };
+  },
+  render: function() {
+    return (
+      <div>
+        {this.state.anims.map((anim, i) =>
+          <Animated.div
+            style={{opacity: anim, position: 'relative'}}
+            className="circle"
+            onClick={i === 0 && this.handleClick}>
+            {i === 0 && 'Click'}
+          </Animated.div>
+        )}
+      </div>
+    );
+  },
+  handleClick: function() {
+    this.state.anims.forEach(anim => { anim.setValue(0.2); });
+    Animated.sequence(
+      this.state.anims.map(anim => Animated.spring(anim, { toValue: 1 }))
+    ).start();
+  },
+}));
+</script><script>example();</script>
+
+
+<script type="text/jsx;harmony=true;stripTypes=true">
+examplify(React.createClass({
+  getInitialState: function() {
+    return {
+      anims: [0, 1, 2, 3, 4].map((_, i) => new Animated.Value(0.2)),
+    };
+  },
+  render: function() {
+    return (
+      <div>
+        {this.state.anims.map((anim, i) =>
+          <Animated.div
+            style={{opacity: anim, position: 'relative'}}
+            className="circle"
+            onClick={i === 0 && this.handleClick}>
+            {i === 0 && 'Click'}
+          </Animated.div>
+        )}
+      </div>
+    );
+  },
+  handleClick: function() {
+    this.state.anims.forEach(anim => { anim.setValue(0.2); });
+    Animated.stagger(
+      100,
+      this.state.anims.map(anim => Animated.spring(anim, { toValue: 1 }))
+    ).start();
+  },
+}));
+</script><script>example();</script>
+
+<script type="text/jsx;harmony=true;stripTypes=true">
+examplify(React.createClass({
+  getInitialState: function() {
+    return {
+      anims: [0, 1, 2, 3, 4].map((_, i) => new Animated.Value(0.2)),
+    };
+  },
+  render: function() {
+    return (
+      <div>
+        {this.state.anims.map((anim, i) =>
+          <Animated.div
+            style={{opacity: anim, position: 'relative'}}
+            className="circle"
+            onClick={i === 0 && this.handleClick}>
+            {i === 0 && 'Click'}
+          </Animated.div>
+        )}
+      </div>
+    );
+  },
+  handleClick: function() {
+    this.state.anims.forEach(anim => { anim.setValue(0.2); });
+    Animated.sequence([
+      Animated.parallel(
+        this.state.anims.map(anim => Animated.spring(anim, { toValue: 1 }))
+      ),
+      Animated.stagger(
+        100,
+        this.state.anims.map(anim => Animated.spring(anim, { toValue: 0.2 }))
+      ),
+    ]).start();
+  },
+}));
+</script><script>example();</script>
+
+<script type="text/jsx;harmony=true;stripTypes=true">
+examplify(React.createClass({
+  getInitialState: function() {
+    return {
+      anim: new Animated.Value(0),
+    };
+  },
+  handleClick: function() {
+    var rec = () => {
+      Animated.sequence([
+        Animated.timing(this.state.anim, {toValue: -1, duration: 150}),
+        Animated.timing(this.state.anim, {toValue: 1, duration: 150}),
+      ]).start(rec);
+    };
+    rec();
+  },
+  render: function() {
+    return (
+      <Animated.div
+        style={{
+          left: this.state.anim.interpolate({
+            inputRange: [-1, -0.5, 0.5, 1],
+            outputRange: [0, 5, 0, 5]
+          }),
+          transform: [
+            {rotate: this.state.anim.interpolate({
+              inputRange: [-1, 1],
+              outputRange: ['-10deg', '10deg']
+            })}
+          ]
+        }}
+        className="circle"
+        onClick={this.handleClick}>
+        Click
+      </Animated.div>
+    );
+  },
+}));
+</script><script>example();</script>
+
+<script type="text/jsx;harmony=true;stripTypes=true">
+examplify(React.createClass({
+  getInitialState: function() {
+    return {
+      anim: new Animated.Value(0)
+    };
+  },
+  render: function() {
+    return (
+      <div
+        style={{overflow: 'scroll', height: 60}}
+        onScroll={Animated.event([
+          {target: {scrollLeft: this.state.anim}}
+        ])}>
+        <div style={{width: 1000, height: 1}} />
+        {[0, 1, 2, 3, 4].map(i =>
+          <Animated.div
+            style={{
+              left: this.state.anim.interpolate({
+                inputRange: [0, 1],
+                outputRange: [0, (i + 1)]
+              }),
+              pointerEvents: 'none',
+            }}
+            className="circle">
+            {i === 4 && 'H-Scroll'}
+          </Animated.div>
+        )}
+      </div>
+    );
+  },
+}));
+</script><script>example();</script>
+
+
+  </div>
+  </body>
+</html>

node_modules/react-native/Libraries/Animated/examples/style.css

@@ -0,0 +1,81 @@
+html, h1, h2 {
+ font-family: 'Roboto', sans-serif;
+ font-weight: 300;
+}
+
+.container {
+  width: 800px;
+  margin: 0 auto;
+}
+
+.circle {
+  margin: 2px;
+  width: 50px;
+  height: 50px;
+  position: absolute;
+  display: inline-block;
+  box-shadow: 0 1px 2px #999;
+  text-shadow: 0 1px 2px #999;
+  background-image: url(pic1.jpg);
+  background-size: cover;
+  line-height: 80px;
+  vertical-align: bottom;
+  text-align: center;
+  color: white;
+  font-size: 10px;
+}
+
+.circle:nth-child(2) {
+  background-image: url(pic2.jpg);
+}
+
+.circle:nth-child(3) {
+  background-image: url(pic3.jpg);
+}
+
+div.code {
+  box-shadow: 0 1px 2px #999;
+  width: 600px;
+  padding: 5px;
+  position: relative;
+  margin: 0 auto;
+  margin-bottom: 40px;
+}
+
+div.code .reset {
+  float: right;
+}
+
+div.code pre {
+  padding: 2px;
+}
+
+hr {
+  border: none;
+  border-bottom: 1px solid #D9D9D9;
+  margin: 0;
+}
+
+button {
+  vertical-align: top;
+}
+
+.example > span {
+  color: #333;
+  font-size: 13px;
+}
+
+.example {
+  position: relative;
+  height: 60px;
+}
+
+.code pre {
+  margin: 0;
+  font-size: 11px;
+  line-height: 1;
+}
+
+.highlight {
+  background: rgb(228, 254, 253);
+}

node_modules/react-native/Libraries/Animated/release/gulpfile.js

@@ -0,0 +1,156 @@
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ * @providesModule gulpfile
+ */
+
+'use strict';
+
+var babel = require('gulp-babel');
+var babelPluginDEV = require('fbjs-scripts/babel/dev-expression');
+var babelPluginModules = require('fbjs-scripts/babel/rewrite-modules');
+var del = require('del');
+var derequire = require('gulp-derequire');
+var flatten = require('gulp-flatten');
+var gulp = require('gulp');
+var gulpUtil = require('gulp-util');
+var header = require('gulp-header');
+var objectAssign = require('object-assign');
+var runSequence = require('run-sequence');
+var webpackStream = require('webpack-stream');
+
+var DEVELOPMENT_HEADER = [
+  '/**',
+  ' * Animated v<%= version %>',
+  ' */'
+].join('\n') + '\n';
+var PRODUCTION_HEADER = [
+  '/**',
+  ' * Animated v<%= version %>',
+  ' *',
+  ' * Copyright (c) 2013-present, Facebook, Inc.',
+  ' *',
+  ' * This source code is licensed under the MIT license found in the',
+  ' * LICENSE file in the root directory of this source tree.',
+  ' */'
+].join('\n') + '\n';
+
+var babelOpts = {
+  nonStandard: true,
+  loose: [
+    'es6.classes'
+  ],
+  stage: 1,
+  plugins: [babelPluginDEV, babelPluginModules],
+  _moduleMap: objectAssign({}, require('fbjs/module-map'), {
+    'React': 'react',
+  })
+};
+
+var buildDist = function(opts) {
+  var webpackOpts = {
+    debug: opts.debug,
+    externals: {
+      'react': 'React',
+    },
+    module: {
+      loaders: [
+        {test: /\.js$/, loader: 'babel'}
+      ],
+    },
+    output: {
+      filename: opts.output,
+      library: 'Animated'
+    },
+    plugins: [
+      new webpackStream.webpack.DefinePlugin({
+        'process.env.NODE_ENV': JSON.stringify(
+          opts.debug ? 'development' : 'production'
+        ),
+      }),
+      new webpackStream.webpack.optimize.OccurenceOrderPlugin(),
+      new webpackStream.webpack.optimize.DedupePlugin()
+    ]
+  };
+  if (!opts.debug) {
+    webpackOpts.plugins.push(
+      new webpackStream.webpack.optimize.UglifyJsPlugin({
+        compress: {
+          hoist_vars: true,
+          screw_ie8: true,
+          warnings: false
+        }
+      })
+    );
+  }
+  return webpackStream(webpackOpts, null, function(err, stats) {
+    if (err) {
+      throw new gulpUtil.PluginError('webpack', err);
+    }
+    if (stats.compilation.errors.length) {
+      throw new gulpUtil.PluginError('webpack', stats.toString());
+    }
+  });
+};
+
+var paths = {
+  dist: 'dist',
+  entry: 'lib/AnimatedWeb.js',
+  lib: 'lib',
+  src: [
+    '*src/**/*.js',
+    '!src/**/__tests__/**/*.js',
+    '!src/**/__mocks__/**/*.js'
+  ],
+};
+
+gulp.task('clean', function(cb) {
+  del([paths.dist, paths.lib], cb);
+});
+
+gulp.task('modules', function() {
+  return gulp
+    .src(paths.src, {cwd: '../'})
+    .pipe(babel(babelOpts))
+    .pipe(flatten())
+    .pipe(gulp.dest(paths.lib));
+});
+
+gulp.task('dist', ['modules'], function () {
+  var distOpts = {
+    debug: true,
+    output: 'animated.js'
+  };
+  return gulp
+    .src(paths.entry)
+    .pipe(buildDist(distOpts))
+    .pipe(derequire())
+    .pipe(header(DEVELOPMENT_HEADER, {
+      version: process.env.npm_package_version
+    }))
+    .pipe(gulp.dest(paths.dist));
+});
+
+gulp.task('dist:min', ['modules'], function () {
+  var distOpts = {
+    debug: false,
+    output: 'animated.min.js'
+  };
+  return gulp
+    .src(paths.entry)
+    .pipe(buildDist(distOpts))
+    .pipe(header(PRODUCTION_HEADER, {
+      version: process.env.npm_package_version
+    }))
+    .pipe(gulp.dest(paths.dist));
+});
+
+gulp.task('watch', function() {
+  gulp.watch(paths.src, ['modules']);
+});
+
+gulp.task('default', function(cb) {
+  runSequence('clean', 'modules', ['dist', 'dist:min'], cb);
+});

node_modules/react-native/Libraries/Animated/release/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "react-animated",
+  "description": "Animated provides powerful mechanisms for animating your React views",
+  "version": "0.1.0",
+  "keywords": [
+    "react",
+    "animated",
+    "animation"
+  ],
+  "license": "MIT",
+  "main": "Animated.js",
+  "dependencies": {
+    "fbjs": "^0.2.1"
+  },
+  "scripts": {
+    "build": "gulp"
+  },
+  "devDependencies": {
+    "babel-core": "^5.8.25",
+    "babel-loader": "^5.3.2",
+    "del": "^1.2.0",
+    "fbjs-scripts": "^0.2.0",
+    "gulp": "^3.9.0",
+    "gulp-babel": "^5.1.0",
+    "gulp-derequire": "^2.1.0",
+    "gulp-flatten": "^0.1.0",
+    "gulp-header": "^1.2.2",
+    "gulp-util": "^3.0.6",
+    "object-assign": "^3.0.0",
+    "run-sequence": "^1.1.2",
+    "webpack": "1.11.0",
+    "webpack-stream": "^2.1.0"
+  }
+}

node_modules/react-native/Libraries/Animated/src/Animated.js

@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule Animated
+ * @flow
+ * @format
+ */
+
+'use strict';
+
+const AnimatedImplementation = require('AnimatedImplementation');
+const Image = require('Image');
+const ScrollView = require('ScrollView');
+const Text = require('Text');
+const View = require('View');
+
+const Animated = {
+  View: AnimatedImplementation.createAnimatedComponent(View),
+  Text: AnimatedImplementation.createAnimatedComponent(Text),
+  Image: AnimatedImplementation.createAnimatedComponent(Image),
+  ScrollView: AnimatedImplementation.createAnimatedComponent(ScrollView),
+};
+
+Object.assign((Animated: Object), AnimatedImplementation);
+
+module.exports = ((Animated: any): typeof AnimatedImplementation &
+  typeof Animated);

node_modules/react-native/Libraries/Animated/src/AnimatedEvent.js

@@ -0,0 +1,194 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule AnimatedEvent
+ * @flow
+ * @format
+ */
+'use strict';
+
+const AnimatedValue = require('./nodes/AnimatedValue');
+const NativeAnimatedHelper = require('./NativeAnimatedHelper');
+const ReactNative = require('ReactNative');
+
+const invariant = require('fbjs/lib/invariant');
+const {shouldUseNativeDriver} = require('./NativeAnimatedHelper');
+
+export type Mapping = {[key: string]: Mapping} | AnimatedValue;
+export type EventConfig = {
+  listener?: ?Function,
+  useNativeDriver?: boolean,
+};
+
+function attachNativeEvent(
+  viewRef: any,
+  eventName: string,
+  argMapping: Array<?Mapping>,
+) {
+  // Find animated values in `argMapping` and create an array representing their
+  // key path inside the `nativeEvent` object. Ex.: ['contentOffset', 'x'].
+  const eventMappings = [];
+
+  const traverse = (value, path) => {
+    if (value instanceof AnimatedValue) {
+      value.__makeNative();
+
+      eventMappings.push({
+        nativeEventPath: path,
+        animatedValueTag: value.__getNativeTag(),
+      });
+    } else if (typeof value === 'object') {
+      for (const key in value) {
+        traverse(value[key], path.concat(key));
+      }
+    }
+  };
+
+  invariant(
+    argMapping[0] && argMapping[0].nativeEvent,
+    'Native driven events only support animated values contained inside `nativeEvent`.',
+  );
+
+  // Assume that the event containing `nativeEvent` is always the first argument.
+  traverse(argMapping[0].nativeEvent, []);
+
+  const viewTag = ReactNative.findNodeHandle(viewRef);
+
+  eventMappings.forEach(mapping => {
+    NativeAnimatedHelper.API.addAnimatedEventToView(
+      viewTag,
+      eventName,
+      mapping,
+    );
+  });
+
+  return {
+    detach() {
+      eventMappings.forEach(mapping => {
+        NativeAnimatedHelper.API.removeAnimatedEventFromView(
+          viewTag,
+          eventName,
+          mapping.animatedValueTag,
+        );
+      });
+    },
+  };
+}
+
+class AnimatedEvent {
+  _argMapping: Array<?Mapping>;
+  _listeners: Array<Function> = [];
+  _callListeners: Function;
+  _attachedEvent: ?{
+    detach: () => void,
+  };
+  __isNative: boolean;
+
+  constructor(argMapping: Array<?Mapping>, config?: EventConfig = {}) {
+    this._argMapping = argMapping;
+    if (config.listener) {
+      this.__addListener(config.listener);
+    }
+    this._callListeners = this._callListeners.bind(this);
+    this._attachedEvent = null;
+    this.__isNative = shouldUseNativeDriver(config);
+
+    if (__DEV__) {
+      this._validateMapping();
+    }
+  }
+
+  __addListener(callback: Function): void {
+    this._listeners.push(callback);
+  }
+
+  __removeListener(callback: Function): void {
+    this._listeners = this._listeners.filter(listener => listener !== callback);
+  }
+
+  __attach(viewRef: any, eventName: string) {
+    invariant(
+      this.__isNative,
+      'Only native driven events need to be attached.',
+    );
+
+    this._attachedEvent = attachNativeEvent(
+      viewRef,
+      eventName,
+      this._argMapping,
+    );
+  }
+
+  __detach(viewTag: any, eventName: string) {
+    invariant(
+      this.__isNative,
+      'Only native driven events need to be detached.',
+    );
+
+    this._attachedEvent && this._attachedEvent.detach();
+  }
+
+  __getHandler() {
+    if (this.__isNative) {
+      return this._callListeners;
+    }
+
+    return (...args: any) => {
+      const traverse = (recMapping, recEvt, key) => {
+        if (typeof recEvt === 'number' && recMapping instanceof AnimatedValue) {
+          recMapping.setValue(recEvt);
+        } else if (typeof recMapping === 'object') {
+          for (const mappingKey in recMapping) {
+            /* $FlowFixMe(>=0.53.0 site=react_native_fb,react_native_oss) This
+             * comment suppresses an error when upgrading Flow's support for
+             * React. To see the error delete this comment and run Flow. */
+            traverse(recMapping[mappingKey], recEvt[mappingKey], mappingKey);
+          }
+        }
+      };
+
+      if (!this.__isNative) {
+        this._argMapping.forEach((mapping, idx) => {
+          traverse(mapping, args[idx], 'arg' + idx);
+        });
+      }
+      this._callListeners(...args);
+    };
+  }
+
+  _callListeners(...args) {
+    this._listeners.forEach(listener => listener(...args));
+  }
+
+  _validateMapping() {
+    const traverse = (recMapping, recEvt, key) => {
+      if (typeof recEvt === 'number') {
+        invariant(
+          recMapping instanceof AnimatedValue,
+          'Bad mapping of type ' +
+            typeof recMapping +
+            ' for key ' +
+            key +
+            ', event value must map to AnimatedValue',
+        );
+        return;
+      }
+      invariant(
+        typeof recMapping === 'object',
+        'Bad mapping of type ' + typeof recMapping + ' for key ' + key,
+      );
+      invariant(
+        typeof recEvt === 'object',
+        'Bad event of type ' + typeof recEvt + ' for key ' + key,
+      );
+      for (const mappingKey in recMapping) {
+        traverse(recMapping[mappingKey], recEvt[mappingKey], mappingKey);
+      }
+    };
+  }
+}
+
+module.exports = {AnimatedEvent, attachNativeEvent};

node_modules/react-native/Libraries/Animated/src/AnimatedImplementation.js

@@ -0,0 +1,674 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule AnimatedImplementation
+ * @flow
+ * @format
+ * @preventMunge
+ */
+'use strict';
+
+const {AnimatedEvent, attachNativeEvent} = require('./AnimatedEvent');
+const AnimatedAddition = require('./nodes/AnimatedAddition');
+const AnimatedDiffClamp = require('./nodes/AnimatedDiffClamp');
+const AnimatedDivision = require('./nodes/AnimatedDivision');
+const AnimatedInterpolation = require('./nodes/AnimatedInterpolation');
+const AnimatedModulo = require('./nodes/AnimatedModulo');
+const AnimatedMultiplication = require('./nodes/AnimatedMultiplication');
+const AnimatedNode = require('./nodes/AnimatedNode');
+const AnimatedProps = require('./nodes/AnimatedProps');
+const AnimatedTracking = require('./nodes/AnimatedTracking');
+const AnimatedValue = require('./nodes/AnimatedValue');
+const AnimatedValueXY = require('./nodes/AnimatedValueXY');
+const DecayAnimation = require('./animations/DecayAnimation');
+const SpringAnimation = require('./animations/SpringAnimation');
+const TimingAnimation = require('./animations/TimingAnimation');
+
+const createAnimatedComponent = require('./createAnimatedComponent');
+
+import type {
+  AnimationConfig,
+  EndCallback,
+  EndResult,
+} from './animations/Animation';
+import type {TimingAnimationConfig} from './animations/TimingAnimation';
+import type {DecayAnimationConfig} from './animations/DecayAnimation';
+import type {SpringAnimationConfig} from './animations/SpringAnimation';
+import type {Mapping, EventConfig} from './AnimatedEvent';
+
+export type CompositeAnimation = {
+  start: (callback?: ?EndCallback) => void,
+  stop: () => void,
+  reset: () => void,
+  _startNativeLoop: (iterations?: number) => void,
+  _isUsingNativeDriver: () => boolean,
+};
+
+const add = function(
+  a: AnimatedNode | number,
+  b: AnimatedNode | number,
+): AnimatedAddition {
+  return new AnimatedAddition(a, b);
+};
+
+const divide = function(
+  a: AnimatedNode | number,
+  b: AnimatedNode | number,
+): AnimatedDivision {
+  return new AnimatedDivision(a, b);
+};
+
+const multiply = function(
+  a: AnimatedNode | number,
+  b: AnimatedNode | number,
+): AnimatedMultiplication {
+  return new AnimatedMultiplication(a, b);
+};
+
+const modulo = function(a: AnimatedNode, modulus: number): AnimatedModulo {
+  return new AnimatedModulo(a, modulus);
+};
+
+const diffClamp = function(
+  a: AnimatedNode,
+  min: number,
+  max: number,
+): AnimatedDiffClamp {
+  return new AnimatedDiffClamp(a, min, max);
+};
+
+const _combineCallbacks = function(
+  callback: ?EndCallback,
+  config: AnimationConfig,
+) {
+  if (callback && config.onComplete) {
+    return (...args) => {
+      config.onComplete && config.onComplete(...args);
+      callback && callback(...args);
+    };
+  } else {
+    return callback || config.onComplete;
+  }
+};
+
+const maybeVectorAnim = function(
+  value: AnimatedValue | AnimatedValueXY,
+  config: Object,
+  anim: (value: AnimatedValue, config: Object) => CompositeAnimation,
+): ?CompositeAnimation {
+  if (value instanceof AnimatedValueXY) {
+    const configX = {...config};
+    const configY = {...config};
+    for (const key in config) {
+      const {x, y} = config[key];
+      if (x !== undefined && y !== undefined) {
+        configX[key] = x;
+        configY[key] = y;
+      }
+    }
+    const aX = anim((value: AnimatedValueXY).x, configX);
+    const aY = anim((value: AnimatedValueXY).y, configY);
+    // We use `stopTogether: false` here because otherwise tracking will break
+    // because the second animation will get stopped before it can update.
+    return parallel([aX, aY], {stopTogether: false});
+  }
+  return null;
+};
+
+const spring = function(
+  value: AnimatedValue | AnimatedValueXY,
+  config: SpringAnimationConfig,
+): CompositeAnimation {
+  const start = function(
+    animatedValue: AnimatedValue | AnimatedValueXY,
+    configuration: SpringAnimationConfig,
+    callback?: ?EndCallback,
+  ): void {
+    callback = _combineCallbacks(callback, configuration);
+    const singleValue: any = animatedValue;
+    const singleConfig: any = configuration;
+    singleValue.stopTracking();
+    if (configuration.toValue instanceof AnimatedNode) {
+      singleValue.track(
+        new AnimatedTracking(
+          singleValue,
+          configuration.toValue,
+          SpringAnimation,
+          singleConfig,
+          callback,
+        ),
+      );
+    } else {
+      singleValue.animate(new SpringAnimation(singleConfig), callback);
+    }
+  };
+  return (
+    maybeVectorAnim(value, config, spring) || {
+      start: function(callback?: ?EndCallback): void {
+        start(value, config, callback);
+      },
+
+      stop: function(): void {
+        value.stopAnimation();
+      },
+
+      reset: function(): void {
+        value.resetAnimation();
+      },
+
+      _startNativeLoop: function(iterations?: number): void {
+        const singleConfig = {...config, iterations};
+        start(value, singleConfig);
+      },
+
+      _isUsingNativeDriver: function(): boolean {
+        return config.useNativeDriver || false;
+      },
+    }
+  );
+};
+
+const timing = function(
+  value: AnimatedValue | AnimatedValueXY,
+  config: TimingAnimationConfig,
+): CompositeAnimation {
+  const start = function(
+    animatedValue: AnimatedValue | AnimatedValueXY,
+    configuration: TimingAnimationConfig,
+    callback?: ?EndCallback,
+  ): void {
+    callback = _combineCallbacks(callback, configuration);
+    const singleValue: any = animatedValue;
+    const singleConfig: any = configuration;
+    singleValue.stopTracking();
+    if (configuration.toValue instanceof AnimatedNode) {
+      singleValue.track(
+        new AnimatedTracking(
+          singleValue,
+          configuration.toValue,
+          TimingAnimation,
+          singleConfig,
+          callback,
+        ),
+      );
+    } else {
+      singleValue.animate(new TimingAnimation(singleConfig), callback);
+    }
+  };
+
+  return (
+    maybeVectorAnim(value, config, timing) || {
+      start: function(callback?: ?EndCallback): void {
+        start(value, config, callback);
+      },
+
+      stop: function(): void {
+        value.stopAnimation();
+      },
+
+      reset: function(): void {
+        value.resetAnimation();
+      },
+
+      _startNativeLoop: function(iterations?: number): void {
+        const singleConfig = {...config, iterations};
+        start(value, singleConfig);
+      },
+
+      _isUsingNativeDriver: function(): boolean {
+        return config.useNativeDriver || false;
+      },
+    }
+  );
+};
+
+const decay = function(
+  value: AnimatedValue | AnimatedValueXY,
+  config: DecayAnimationConfig,
+): CompositeAnimation {
+  const start = function(
+    animatedValue: AnimatedValue | AnimatedValueXY,
+    configuration: DecayAnimationConfig,
+    callback?: ?EndCallback,
+  ): void {
+    callback = _combineCallbacks(callback, configuration);
+    const singleValue: any = animatedValue;
+    const singleConfig: any = configuration;
+    singleValue.stopTracking();
+    singleValue.animate(new DecayAnimation(singleConfig), callback);
+  };
+
+  return (
+    maybeVectorAnim(value, config, decay) || {
+      start: function(callback?: ?EndCallback): void {
+        start(value, config, callback);
+      },
+
+      stop: function(): void {
+        value.stopAnimation();
+      },
+
+      reset: function(): void {
+        value.resetAnimation();
+      },
+
+      _startNativeLoop: function(iterations?: number): void {
+        const singleConfig = {...config, iterations};
+        start(value, singleConfig);
+      },
+
+      _isUsingNativeDriver: function(): boolean {
+        return config.useNativeDriver || false;
+      },
+    }
+  );
+};
+
+const sequence = function(
+  animations: Array<CompositeAnimation>,
+): CompositeAnimation {
+  let current = 0;
+  return {
+    start: function(callback?: ?EndCallback) {
+      const onComplete = function(result) {
+        if (!result.finished) {
+          callback && callback(result);
+          return;
+        }
+
+        current++;
+
+        if (current === animations.length) {
+          callback && callback(result);
+          return;
+        }
+
+        animations[current].start(onComplete);
+      };
+
+      if (animations.length === 0) {
+        callback && callback({finished: true});
+      } else {
+        animations[current].start(onComplete);
+      }
+    },
+
+    stop: function() {
+      if (current < animations.length) {
+        animations[current].stop();
+      }
+    },
+
+    reset: function() {
+      animations.forEach((animation, idx) => {
+        if (idx <= current) {
+          animation.reset();
+        }
+      });
+      current = 0;
+    },
+
+    _startNativeLoop: function() {
+      throw new Error(
+        'Loops run using the native driver cannot contain Animated.sequence animations',
+      );
+    },
+
+    _isUsingNativeDriver: function(): boolean {
+      return false;
+    },
+  };
+};
+
+type ParallelConfig = {
+  stopTogether?: boolean, // If one is stopped, stop all.  default: true
+};
+const parallel = function(
+  animations: Array<CompositeAnimation>,
+  config?: ?ParallelConfig,
+): CompositeAnimation {
+  let doneCount = 0;
+  // Make sure we only call stop() at most once for each animation
+  const hasEnded = {};
+  const stopTogether = !(config && config.stopTogether === false);
+
+  const result = {
+    start: function(callback?: ?EndCallback) {
+      if (doneCount === animations.length) {
+        callback && callback({finished: true});
+        return;
+      }
+
+      animations.forEach((animation, idx) => {
+        const cb = function(endResult) {
+          hasEnded[idx] = true;
+          doneCount++;
+          if (doneCount === animations.length) {
+            doneCount = 0;
+            callback && callback(endResult);
+            return;
+          }
+
+          if (!endResult.finished && stopTogether) {
+            result.stop();
+          }
+        };
+
+        if (!animation) {
+          cb({finished: true});
+        } else {
+          animation.start(cb);
+        }
+      });
+    },
+
+    stop: function(): void {
+      animations.forEach((animation, idx) => {
+        !hasEnded[idx] && animation.stop();
+        hasEnded[idx] = true;
+      });
+    },
+
+    reset: function(): void {
+      animations.forEach((animation, idx) => {
+        animation.reset();
+        hasEnded[idx] = false;
+        doneCount = 0;
+      });
+    },
+
+    _startNativeLoop: function() {
+      throw new Error(
+        'Loops run using the native driver cannot contain Animated.parallel animations',
+      );
+    },
+
+    _isUsingNativeDriver: function(): boolean {
+      return false;
+    },
+  };
+
+  return result;
+};
+
+const delay = function(time: number): CompositeAnimation {
+  // Would be nice to make a specialized implementation
+  return timing(new AnimatedValue(0), {toValue: 0, delay: time, duration: 0});
+};
+
+const stagger = function(
+  time: number,
+  animations: Array<CompositeAnimation>,
+): CompositeAnimation {
+  return parallel(
+    animations.map((animation, i) => {
+      return sequence([delay(time * i), animation]);
+    }),
+  );
+};
+
+type LoopAnimationConfig = {iterations: number};
+
+const loop = function(
+  animation: CompositeAnimation,
+  {iterations = -1}: LoopAnimationConfig = {},
+): CompositeAnimation {
+  let isFinished = false;
+  let iterationsSoFar = 0;
+  return {
+    start: function(callback?: ?EndCallback) {
+      const restart = function(result: EndResult = {finished: true}): void {
+        if (
+          isFinished ||
+          iterationsSoFar === iterations ||
+          result.finished === false
+        ) {
+          callback && callback(result);
+        } else {
+          iterationsSoFar++;
+          animation.reset();
+          animation.start(restart);
+        }
+      };
+      if (!animation || iterations === 0) {
+        callback && callback({finished: true});
+      } else {
+        if (animation._isUsingNativeDriver()) {
+          animation._startNativeLoop(iterations);
+        } else {
+          restart(); // Start looping recursively on the js thread
+        }
+      }
+    },
+
+    stop: function(): void {
+      isFinished = true;
+      animation.stop();
+    },
+
+    reset: function(): void {
+      iterationsSoFar = 0;
+      isFinished = false;
+      animation.reset();
+    },
+
+    _startNativeLoop: function() {
+      throw new Error(
+        'Loops run using the native driver cannot contain Animated.loop animations',
+      );
+    },
+
+    _isUsingNativeDriver: function(): boolean {
+      return animation._isUsingNativeDriver();
+    },
+  };
+};
+
+function forkEvent(
+  event: ?AnimatedEvent | ?Function,
+  listener: Function,
+): AnimatedEvent | Function {
+  if (!event) {
+    return listener;
+  } else if (event instanceof AnimatedEvent) {
+    event.__addListener(listener);
+    return event;
+  } else {
+    return (...args) => {
+      typeof event === 'function' && event(...args);
+      listener(...args);
+    };
+  }
+}
+
+function unforkEvent(
+  event: ?AnimatedEvent | ?Function,
+  listener: Function,
+): void {
+  if (event && event instanceof AnimatedEvent) {
+    event.__removeListener(listener);
+  }
+}
+
+const event = function(argMapping: Array<?Mapping>, config?: EventConfig): any {
+  const animatedEvent = new AnimatedEvent(argMapping, config);
+  if (animatedEvent.__isNative) {
+    return animatedEvent;
+  } else {
+    return animatedEvent.__getHandler();
+  }
+};
+
+/**
+ * The `Animated` library is designed to make animations fluid, powerful, and
+ * easy to build and maintain. `Animated` focuses on declarative relationships
+ * between inputs and outputs, with configurable transforms in between, and
+ * simple `start`/`stop` methods to control time-based animation execution.
+ *
+ * See http://facebook.github.io/react-native/docs/animated.html
+ */
+module.exports = {
+  /**
+   * Standard value class for driving animations.  Typically initialized with
+   * `new Animated.Value(0);`
+   *
+   * See http://facebook.github.io/react-native/docs/animated.html#value
+   */
+  Value: AnimatedValue,
+  /**
+   * 2D value class for driving 2D animations, such as pan gestures.
+   *
+   * See https://facebook.github.io/react-native/releases/next/docs/animatedvaluexy.html
+   */
+  ValueXY: AnimatedValueXY,
+  /**
+   * Exported to use the Interpolation type in flow.
+   *
+   * See http://facebook.github.io/react-native/docs/animated.html#interpolation
+   */
+  Interpolation: AnimatedInterpolation,
+  /**
+   * Exported for ease of type checking. All animated values derive from this
+   * class.
+   *
+   * See http://facebook.github.io/react-native/docs/animated.html#node
+   */
+  Node: AnimatedNode,
+
+  /**
+   * Animates a value from an initial velocity to zero based on a decay
+   * coefficient.
+   *
+   * See http://facebook.github.io/react-native/docs/animated.html#decay
+   */
+  decay,
+  /**
+   * Animates a value along a timed easing curve. The Easing module has tons of
+   * predefined curves, or you can use your own function.
+   *
+   * See http://facebook.github.io/react-native/docs/animated.html#timing
+   */
+  timing,
+  /**
+   * Animates a value according to an analytical spring model based on
+   * damped harmonic oscillation.
+   *
+   * See http://facebook.github.io/react-native/docs/animated.html#spring
+   */
+  spring,
+
+  /**
+   * Creates a new Animated value composed from two Animated values added
+   * together.
+   *
+   * See http://facebook.github.io/react-native/docs/animated.html#add
+   */
+  add,
+
+  /**
+   * Creates a new Animated value composed by dividing the first Animated value
+   * by the second Animated value.
+   *
+   * See http://facebook.github.io/react-native/docs/animated.html#divide
+   */
+  divide,
+
+  /**
+   * Creates a new Animated value composed from two Animated values multiplied
+   * together.
+   *
+   * See http://facebook.github.io/react-native/docs/animated.html#multiply
+   */
+  multiply,
+
+  /**
+   * Creates a new Animated value that is the (non-negative) modulo of the
+   * provided Animated value.
+   *
+   * See http://facebook.github.io/react-native/docs/animated.html#modulo
+   */
+  modulo,
+
+  /**
+   * Create a new Animated value that is limited between 2 values. It uses the
+   * difference between the last value so even if the value is far from the
+   * bounds it will start changing when the value starts getting closer again.
+   *
+   * See http://facebook.github.io/react-native/docs/animated.html#diffclamp
+   */
+  diffClamp,
+
+  /**
+   * Starts an animation after the given delay.
+   *
+   * See http://facebook.github.io/react-native/docs/animated.html#delay
+   */
+  delay,
+  /**
+   * Starts an array of animations in order, waiting for each to complete
+   * before starting the next. If the current running animation is stopped, no
+   * following animations will be started.
+   *
+   * See http://facebook.github.io/react-native/docs/animated.html#sequence
+   */
+  sequence,
+  /**
+   * Starts an array of animations all at the same time. By default, if one
+   * of the animations is stopped, they will all be stopped. You can override
+   * this with the `stopTogether` flag.
+   *
+   * See http://facebook.github.io/react-native/docs/animated.html#parallel
+   */
+  parallel,
+  /**
+   * Array of animations may run in parallel (overlap), but are started in
+   * sequence with successive delays.  Nice for doing trailing effects.
+   *
+   * See http://facebook.github.io/react-native/docs/animated.html#stagger
+   */
+  stagger,
+  /**
+   * Loops a given animation continuously, so that each time it reaches the
+   * end, it resets and begins again from the start.
+   *
+   * See http://facebook.github.io/react-native/docs/animated.html#loop
+   */
+  loop,
+
+  /**
+   * Takes an array of mappings and extracts values from each arg accordingly,
+   * then calls `setValue` on the mapped outputs.
+   *
+   * See http://facebook.github.io/react-native/docs/animated.html#event
+   */
+  event,
+
+  /**
+   * Make any React component Animatable.  Used to create `Animated.View`, etc.
+   *
+   * See http://facebook.github.io/react-native/docs/animated.html#createanimatedcomponent
+   */
+  createAnimatedComponent,
+
+  /**
+   * Imperative API to attach an animated value to an event on a view. Prefer
+   * using `Animated.event` with `useNativeDrive: true` if possible.
+   *
+   * See http://facebook.github.io/react-native/docs/animated.html#attachnativeevent
+   */
+  attachNativeEvent,
+
+  /**
+   * Advanced imperative API for snooping on animated events that are passed in
+   * through props. Use values directly where possible.
+   *
+   * See http://facebook.github.io/react-native/docs/animated.html#forkevent
+   */
+  forkEvent,
+  unforkEvent,
+
+  __PropsOnlyForTests: AnimatedProps,
+};

node_modules/react-native/Libraries/Animated/src/AnimatedWeb.js

@@ -0,0 +1,19 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ * @providesModule AnimatedWeb
+ */
+'use strict';
+
+var AnimatedImplementation = require('AnimatedImplementation');
+
+module.exports = {
+  ...AnimatedImplementation,
+  div: AnimatedImplementation.createAnimatedComponent('div'),
+  span: AnimatedImplementation.createAnimatedComponent('span'),
+  img: AnimatedImplementation.createAnimatedComponent('img'),
+};

node_modules/react-native/Libraries/Animated/src/Easing.js

@@ -0,0 +1,260 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule Easing
+ * @flow
+ */
+'use strict';
+
+let ease;
+
+/**
+ * The `Easing` module implements common easing functions. This module is used
+ * by [Animate.timing()](docs/animate.html#timing) to convey physically
+ * believable motion in animations.
+ *
+ * You can find a visualization of some common easing functions at
+ * http://easings.net/
+ *
+ * ### Predefined animations
+ *
+ * The `Easing` module provides several predefined animations through the
+ * following methods:
+ *
+ * - [`back`](docs/easing.html#back) provides a simple animation where the
+ *   object goes slightly back before moving forward
+ * - [`bounce`](docs/easing.html#bounce) provides a bouncing animation
+ * - [`ease`](docs/easing.html#ease) provides a simple inertial animation
+ * - [`elastic`](docs/easing.html#elastic) provides a simple spring interaction
+ *
+ * ### Standard functions
+ *
+ * Three standard easing functions are provided:
+ *
+ * - [`linear`](docs/easing.html#linear)
+ * - [`quad`](docs/easing.html#quad)
+ * - [`cubic`](docs/easing.html#cubic)
+ *
+ * The [`poly`](docs/easing.html#poly) function can be used to implement
+ * quartic, quintic, and other higher power functions.
+ *
+ * ### Additional functions
+ *
+ * Additional mathematical functions are provided by the following methods:
+ *
+ * - [`bezier`](docs/easing.html#bezier) provides a cubic bezier curve
+ * - [`circle`](docs/easing.html#circle) provides a circular function
+ * - [`sin`](docs/easing.html#sin) provides a sinusoidal function
+ * - [`exp`](docs/easing.html#exp) provides an exponential function
+ *
+ * The following helpers are used to modify other easing functions.
+ *
+ * - [`in`](docs/easing.html#in) runs an easing function forwards
+ * - [`inOut`](docs/easing.html#inout) makes any easing function symmetrical
+ * - [`out`](docs/easing.html#out) runs an easing function backwards
+ */
+class Easing {
+  /**
+   * A stepping function, returns 1 for any positive value of `n`.
+   */
+  static step0(n: number) {
+    return n > 0 ? 1 : 0;
+  }
+
+  /**
+   * A stepping function, returns 1 if `n` is greater than or equal to 1.
+   */
+  static step1(n: number) {
+    return n >= 1 ? 1 : 0;
+  }
+
+  /**
+   * A linear function, `f(t) = t`. Position correlates to elapsed time one to
+   * one.
+   *
+   * http://cubic-bezier.com/#0,0,1,1
+   */
+  static linear(t: number) {
+    return t;
+  }
+
+  /**
+   * A simple inertial interaction, similar to an object slowly accelerating to
+   * speed.
+   *
+   * http://cubic-bezier.com/#.42,0,1,1
+   */
+  static ease(t: number): number {
+    if (!ease) {
+      ease = Easing.bezier(0.42, 0, 1, 1);
+    }
+    return ease(t);
+  }
+
+  /**
+   * A quadratic function, `f(t) = t * t`. Position equals the square of elapsed
+   * time.
+   *
+   * http://easings.net/#easeInQuad
+   */
+  static quad(t: number) {
+    return t * t;
+  }
+
+  /**
+   * A cubic function, `f(t) = t * t * t`. Position equals the cube of elapsed
+   * time.
+   *
+   * http://easings.net/#easeInCubic
+   */
+  static cubic(t: number) {
+    return t * t * t;
+  }
+
+  /**
+   * A power function. Position is equal to the Nth power of elapsed time.
+   *
+   * n = 4: http://easings.net/#easeInQuart
+   * n = 5: http://easings.net/#easeInQuint
+   */
+  static poly(n: number) {
+    return (t: number) => Math.pow(t, n);
+  }
+
+  /**
+   * A sinusoidal function.
+   *
+   * http://easings.net/#easeInSine
+   */
+  static sin(t: number) {
+    return 1 - Math.cos(t * Math.PI / 2);
+  }
+
+  /**
+   * A circular function.
+   *
+   * http://easings.net/#easeInCirc
+   */
+  static circle(t: number) {
+    return 1 - Math.sqrt(1 - t * t);
+  }
+
+  /**
+   * An exponential function.
+   *
+   * http://easings.net/#easeInExpo
+   */
+  static exp(t: number) {
+    return Math.pow(2, 10 * (t - 1));
+  }
+
+  /**
+   * A simple elastic interaction, similar to a spring oscillating back and
+   * forth.
+   *
+   * Default bounciness is 1, which overshoots a little bit once. 0 bounciness
+   * doesn't overshoot at all, and bounciness of N > 1 will overshoot about N
+   * times.
+   *
+   * http://easings.net/#easeInElastic
+   */
+  static elastic(bounciness: number = 1): (t: number) => number {
+    const p = bounciness * Math.PI;
+    return (t) => 1 - Math.pow(Math.cos(t * Math.PI / 2), 3) * Math.cos(t * p);
+  }
+
+  /**
+   * Use with `Animated.parallel()` to create a simple effect where the object
+   * animates back slightly as the animation starts.
+   *
+   * Wolfram Plot:
+   *
+   * - http://tiny.cc/back_default (s = 1.70158, default)
+   */
+  static back(s: number): (t: number) => number {
+    if (s === undefined) {
+      s = 1.70158;
+    }
+    return (t) => t * t * ((s + 1) * t - s);
+  }
+
+  /**
+   * Provides a simple bouncing effect.
+   *
+   * http://easings.net/#easeInBounce
+   */
+  static bounce(t: number): number {
+    if (t < 1 / 2.75) {
+      return 7.5625 * t * t;
+    }
+
+    if (t < 2 / 2.75) {
+      t -= 1.5 / 2.75;
+      return 7.5625 * t * t + 0.75;
+    }
+
+    if (t < 2.5 / 2.75) {
+      t -= 2.25 / 2.75;
+      return 7.5625 * t * t + 0.9375;
+    }
+
+    t -= 2.625 / 2.75;
+    return 7.5625 * t * t + 0.984375;
+  }
+
+  /**
+   * Provides a cubic bezier curve, equivalent to CSS Transitions'
+   * `transition-timing-function`.
+   *
+   * A useful tool to visualize cubic bezier curves can be found at
+   * http://cubic-bezier.com/
+   */
+  static bezier(
+    x1: number,
+    y1: number,
+    x2: number,
+    y2: number
+  ): (t: number) => number {
+    const _bezier = require('bezier');
+    return _bezier(x1, y1, x2, y2);
+  }
+
+  /**
+   * Runs an easing function forwards.
+   */
+  static in(
+    easing: (t: number) => number,
+  ): (t: number) => number {
+    return easing;
+  }
+
+  /**
+   * Runs an easing function backwards.
+   */
+  static out(
+    easing: (t: number) => number,
+  ): (t: number) => number {
+    return (t) => 1 - easing(1 - t);
+  }
+
+  /**
+   * Makes any easing function symmetrical. The easing function will run
+   * forwards for half of the duration, then backwards for the rest of the
+   * duration.
+   */
+  static inOut(
+    easing: (t: number) => number,
+  ): (t: number) => number {
+    return (t) => {
+      if (t < 0.5) {
+        return easing(t * 2) / 2;
+      }
+      return 1 - easing((1 - t) * 2) / 2;
+    };
+  }
+}
+
+module.exports = Easing;

node_modules/react-native/Libraries/Animated/src/NativeAnimatedHelper.js

@@ -0,0 +1,272 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule NativeAnimatedHelper
+ * @flow
+ * @format
+ */
+'use strict';
+
+const NativeAnimatedModule = require('NativeModules').NativeAnimatedModule;
+const NativeEventEmitter = require('NativeEventEmitter');
+
+const invariant = require('fbjs/lib/invariant');
+
+import type {AnimationConfig} from './animations/Animation';
+import type {EventConfig} from './AnimatedEvent';
+
+let __nativeAnimatedNodeTagCount = 1; /* used for animated nodes */
+let __nativeAnimationIdCount = 1; /* used for started animations */
+
+type EndResult = {finished: boolean};
+type EndCallback = (result: EndResult) => void;
+type EventMapping = {
+  nativeEventPath: Array<string>,
+  animatedValueTag: ?number,
+};
+
+let nativeEventEmitter;
+
+/**
+ * Simple wrappers around NativeAnimatedModule to provide flow and autocmplete support for
+ * the native module methods
+ */
+const API = {
+  createAnimatedNode: function(tag: ?number, config: Object): void {
+    assertNativeAnimatedModule();
+    NativeAnimatedModule.createAnimatedNode(tag, config);
+  },
+  startListeningToAnimatedNodeValue: function(tag: ?number) {
+    assertNativeAnimatedModule();
+    NativeAnimatedModule.startListeningToAnimatedNodeValue(tag);
+  },
+  stopListeningToAnimatedNodeValue: function(tag: ?number) {
+    assertNativeAnimatedModule();
+    NativeAnimatedModule.stopListeningToAnimatedNodeValue(tag);
+  },
+  connectAnimatedNodes: function(parentTag: ?number, childTag: ?number): void {
+    assertNativeAnimatedModule();
+    NativeAnimatedModule.connectAnimatedNodes(parentTag, childTag);
+  },
+  disconnectAnimatedNodes: function(
+    parentTag: ?number,
+    childTag: ?number,
+  ): void {
+    assertNativeAnimatedModule();
+    NativeAnimatedModule.disconnectAnimatedNodes(parentTag, childTag);
+  },
+  startAnimatingNode: function(
+    animationId: ?number,
+    nodeTag: ?number,
+    config: Object,
+    endCallback: EndCallback,
+  ): void {
+    assertNativeAnimatedModule();
+    NativeAnimatedModule.startAnimatingNode(
+      animationId,
+      nodeTag,
+      config,
+      endCallback,
+    );
+  },
+  stopAnimation: function(animationId: ?number) {
+    assertNativeAnimatedModule();
+    NativeAnimatedModule.stopAnimation(animationId);
+  },
+  setAnimatedNodeValue: function(nodeTag: ?number, value: ?number): void {
+    assertNativeAnimatedModule();
+    NativeAnimatedModule.setAnimatedNodeValue(nodeTag, value);
+  },
+  setAnimatedNodeOffset: function(nodeTag: ?number, offset: ?number): void {
+    assertNativeAnimatedModule();
+    NativeAnimatedModule.setAnimatedNodeOffset(nodeTag, offset);
+  },
+  flattenAnimatedNodeOffset: function(nodeTag: ?number): void {
+    assertNativeAnimatedModule();
+    NativeAnimatedModule.flattenAnimatedNodeOffset(nodeTag);
+  },
+  extractAnimatedNodeOffset: function(nodeTag: ?number): void {
+    assertNativeAnimatedModule();
+    NativeAnimatedModule.extractAnimatedNodeOffset(nodeTag);
+  },
+  connectAnimatedNodeToView: function(
+    nodeTag: ?number,
+    viewTag: ?number,
+  ): void {
+    assertNativeAnimatedModule();
+    NativeAnimatedModule.connectAnimatedNodeToView(nodeTag, viewTag);
+  },
+  disconnectAnimatedNodeFromView: function(
+    nodeTag: ?number,
+    viewTag: ?number,
+  ): void {
+    assertNativeAnimatedModule();
+    NativeAnimatedModule.disconnectAnimatedNodeFromView(nodeTag, viewTag);
+  },
+  dropAnimatedNode: function(tag: ?number): void {
+    assertNativeAnimatedModule();
+    NativeAnimatedModule.dropAnimatedNode(tag);
+  },
+  addAnimatedEventToView: function(
+    viewTag: ?number,
+    eventName: string,
+    eventMapping: EventMapping,
+  ) {
+    assertNativeAnimatedModule();
+    NativeAnimatedModule.addAnimatedEventToView(
+      viewTag,
+      eventName,
+      eventMapping,
+    );
+  },
+  removeAnimatedEventFromView(
+    viewTag: ?number,
+    eventName: string,
+    animatedNodeTag: ?number,
+  ) {
+    assertNativeAnimatedModule();
+    NativeAnimatedModule.removeAnimatedEventFromView(
+      viewTag,
+      eventName,
+      animatedNodeTag,
+    );
+  },
+};
+
+/**
+ * Styles allowed by the native animated implementation.
+ *
+ * In general native animated implementation should support any numeric property that doesn't need
+ * to be updated through the shadow view hierarchy (all non-layout properties).
+ */
+const STYLES_WHITELIST = {
+  opacity: true,
+  transform: true,
+  /* ios styles */
+  shadowOpacity: true,
+  shadowRadius: true,
+  /* legacy android transform properties */
+  scaleX: true,
+  scaleY: true,
+  translateX: true,
+  translateY: true,
+};
+
+const TRANSFORM_WHITELIST = {
+  translateX: true,
+  translateY: true,
+  scale: true,
+  scaleX: true,
+  scaleY: true,
+  rotate: true,
+  rotateX: true,
+  rotateY: true,
+  perspective: true,
+};
+
+const SUPPORTED_INTERPOLATION_PARAMS = {
+  inputRange: true,
+  outputRange: true,
+  extrapolate: true,
+  extrapolateRight: true,
+  extrapolateLeft: true,
+};
+
+function addWhitelistedStyleProp(prop: string): void {
+  STYLES_WHITELIST[prop] = true;
+}
+
+function addWhitelistedTransformProp(prop: string): void {
+  TRANSFORM_WHITELIST[prop] = true;
+}
+
+function addWhitelistedInterpolationParam(param: string): void {
+  SUPPORTED_INTERPOLATION_PARAMS[param] = true;
+}
+
+function validateTransform(configs: Array<Object>): void {
+  configs.forEach(config => {
+    if (!TRANSFORM_WHITELIST.hasOwnProperty(config.property)) {
+      throw new Error(
+        `Property '${
+          config.property
+        }' is not supported by native animated module`,
+      );
+    }
+  });
+}
+
+function validateStyles(styles: Object): void {
+  for (var key in styles) {
+    if (!STYLES_WHITELIST.hasOwnProperty(key)) {
+      throw new Error(
+        `Style property '${key}' is not supported by native animated module`,
+      );
+    }
+  }
+}
+
+function validateInterpolation(config: Object): void {
+  for (var key in config) {
+    if (!SUPPORTED_INTERPOLATION_PARAMS.hasOwnProperty(key)) {
+      throw new Error(
+        `Interpolation property '${key}' is not supported by native animated module`,
+      );
+    }
+  }
+}
+
+function generateNewNodeTag(): number {
+  return __nativeAnimatedNodeTagCount++;
+}
+
+function generateNewAnimationId(): number {
+  return __nativeAnimationIdCount++;
+}
+
+function assertNativeAnimatedModule(): void {
+  invariant(NativeAnimatedModule, 'Native animated module is not available');
+}
+
+let _warnedMissingNativeAnimated = false;
+
+function shouldUseNativeDriver(config: AnimationConfig | EventConfig): boolean {
+  if (config.useNativeDriver && !NativeAnimatedModule) {
+    if (!_warnedMissingNativeAnimated) {
+      console.warn(
+        'Animated: `useNativeDriver` is not supported because the native ' +
+          'animated module is missing. Falling back to JS-based animation. To ' +
+          'resolve this, add `RCTAnimation` module to this app, or remove ' +
+          '`useNativeDriver`. ' +
+          'More info: https://github.com/facebook/react-native/issues/11094#issuecomment-263240420',
+      );
+      _warnedMissingNativeAnimated = true;
+    }
+    return false;
+  }
+
+  return config.useNativeDriver || false;
+}
+
+module.exports = {
+  API,
+  addWhitelistedStyleProp,
+  addWhitelistedTransformProp,
+  addWhitelistedInterpolationParam,
+  validateStyles,
+  validateTransform,
+  validateInterpolation,
+  generateNewNodeTag,
+  generateNewAnimationId,
+  assertNativeAnimatedModule,
+  shouldUseNativeDriver,
+  get nativeEventEmitter() {
+    if (!nativeEventEmitter) {
+      nativeEventEmitter = new NativeEventEmitter(NativeAnimatedModule);
+    }
+    return nativeEventEmitter;
+  },
+};

node_modules/react-native/Libraries/Animated/src/SpringConfig.js

@@ -0,0 +1,100 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule SpringConfig
+ * @flow
+ */
+
+'use strict';
+
+type SpringConfigType = {
+  stiffness: number,
+  damping: number,
+};
+
+function stiffnessFromOrigamiValue(oValue) {
+  return (oValue - 30) * 3.62 + 194;
+}
+
+function dampingFromOrigamiValue(oValue) {
+  return (oValue - 8) * 3 + 25;
+}
+
+function fromOrigamiTensionAndFriction(
+  tension: number,
+  friction: number,
+): SpringConfigType {
+  return {
+    stiffness: stiffnessFromOrigamiValue(tension),
+    damping: dampingFromOrigamiValue(friction),
+  };
+}
+
+function fromBouncinessAndSpeed(
+  bounciness: number,
+  speed: number,
+): SpringConfigType {
+  function normalize(value, startValue, endValue) {
+    return (value - startValue) / (endValue - startValue);
+  }
+
+  function projectNormal(n, start, end) {
+    return start + (n * (end - start));
+  }
+
+  function linearInterpolation(t, start, end) {
+    return t * end + (1 - t) * start;
+  }
+
+  function quadraticOutInterpolation(t, start, end) {
+    return linearInterpolation(2 * t - t * t, start, end);
+  }
+
+  function b3Friction1(x) {
+    return (0.0007 * Math.pow(x, 3)) -
+      (0.031 * Math.pow(x, 2)) + 0.64 * x + 1.28;
+  }
+
+  function b3Friction2(x) {
+    return (0.000044 * Math.pow(x, 3)) -
+      (0.006 * Math.pow(x, 2)) + 0.36 * x + 2;
+  }
+
+  function b3Friction3(x) {
+    return (0.00000045 * Math.pow(x, 3)) -
+      (0.000332 * Math.pow(x, 2)) + 0.1078 * x + 5.84;
+  }
+
+  function b3Nobounce(tension) {
+    if (tension <= 18) {
+      return b3Friction1(tension);
+    } else if (tension > 18 && tension <= 44) {
+      return b3Friction2(tension);
+    } else {
+      return b3Friction3(tension);
+    }
+  }
+
+  var b = normalize(bounciness / 1.7, 0, 20);
+  b = projectNormal(b, 0, 0.8);
+  var s = normalize(speed / 1.7, 0, 20);
+  var bouncyTension = projectNormal(s, 0.5, 200);
+  var bouncyFriction = quadraticOutInterpolation(
+    b,
+    b3Nobounce(bouncyTension),
+    0.01
+  );
+
+  return {
+    stiffness: stiffnessFromOrigamiValue(bouncyTension),
+    damping: dampingFromOrigamiValue(bouncyFriction),
+  };
+}
+
+module.exports = {
+  fromOrigamiTensionAndFriction,
+  fromBouncinessAndSpeed,
+};

node_modules/react-native/Libraries/Animated/src/animations/Animation.js

@@ -0,0 +1,71 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule Animation
+ * @flow
+ * @format
+ */
+'use strict';
+
+const NativeAnimatedHelper = require('NativeAnimatedHelper');
+
+import type AnimatedValue from '../nodes/AnimatedValue';
+
+export type EndResult = {finished: boolean};
+export type EndCallback = (result: EndResult) => void;
+
+export type AnimationConfig = {
+  isInteraction?: boolean,
+  useNativeDriver?: boolean,
+  onComplete?: ?EndCallback,
+  iterations?: number,
+};
+
+// Important note: start() and stop() will only be called at most once.
+// Once an animation has been stopped or finished its course, it will
+// not be reused.
+class Animation {
+  __active: boolean;
+  __isInteraction: boolean;
+  __nativeId: number;
+  __onEnd: ?EndCallback;
+  __iterations: number;
+  start(
+    fromValue: number,
+    onUpdate: (value: number) => void,
+    onEnd: ?EndCallback,
+    previousAnimation: ?Animation,
+    animatedValue: AnimatedValue,
+  ): void {}
+  stop(): void {
+    if (this.__nativeId) {
+      NativeAnimatedHelper.API.stopAnimation(this.__nativeId);
+    }
+  }
+  __getNativeAnimationConfig(): any {
+    // Subclasses that have corresponding animation implementation done in native
+    // should override this method
+    throw new Error('This animation type cannot be offloaded to native');
+  }
+  // Helper function for subclasses to make sure onEnd is only called once.
+  __debouncedOnEnd(result: EndResult): void {
+    const onEnd = this.__onEnd;
+    this.__onEnd = null;
+    onEnd && onEnd(result);
+  }
+  __startNativeAnimation(animatedValue: AnimatedValue): void {
+    animatedValue.__makeNative();
+    this.__nativeId = NativeAnimatedHelper.generateNewAnimationId();
+    NativeAnimatedHelper.API.startAnimatingNode(
+      this.__nativeId,
+      animatedValue.__getNativeTag(),
+      this.__getNativeAnimationConfig(),
+      this.__debouncedOnEnd.bind(this),
+    );
+  }
+}
+
+module.exports = Animation;

node_modules/react-native/Libraries/Animated/src/animations/DecayAnimation.js

@@ -0,0 +1,110 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule DecayAnimation
+ * @flow
+ * @format
+ */
+'use strict';
+
+const Animation = require('./Animation');
+
+const {shouldUseNativeDriver} = require('../NativeAnimatedHelper');
+
+import type {AnimationConfig, EndCallback} from './Animation';
+import type AnimatedValue from '../nodes/AnimatedValue';
+
+export type DecayAnimationConfig = AnimationConfig & {
+  velocity: number | {x: number, y: number},
+  deceleration?: number,
+};
+
+export type DecayAnimationConfigSingle = AnimationConfig & {
+  velocity: number,
+  deceleration?: number,
+};
+
+class DecayAnimation extends Animation {
+  _startTime: number;
+  _lastValue: number;
+  _fromValue: number;
+  _deceleration: number;
+  _velocity: number;
+  _onUpdate: (value: number) => void;
+  _animationFrame: any;
+  _useNativeDriver: boolean;
+
+  constructor(config: DecayAnimationConfigSingle) {
+    super();
+    this._deceleration =
+      config.deceleration !== undefined ? config.deceleration : 0.998;
+    this._velocity = config.velocity;
+    this._useNativeDriver = shouldUseNativeDriver(config);
+    this.__isInteraction =
+      config.isInteraction !== undefined ? config.isInteraction : true;
+    this.__iterations = config.iterations !== undefined ? config.iterations : 1;
+  }
+
+  __getNativeAnimationConfig() {
+    return {
+      type: 'decay',
+      deceleration: this._deceleration,
+      velocity: this._velocity,
+      iterations: this.__iterations,
+    };
+  }
+
+  start(
+    fromValue: number,
+    onUpdate: (value: number) => void,
+    onEnd: ?EndCallback,
+    previousAnimation: ?Animation,
+    animatedValue: AnimatedValue,
+  ): void {
+    this.__active = true;
+    this._lastValue = fromValue;
+    this._fromValue = fromValue;
+    this._onUpdate = onUpdate;
+    this.__onEnd = onEnd;
+    this._startTime = Date.now();
+    if (this._useNativeDriver) {
+      this.__startNativeAnimation(animatedValue);
+    } else {
+      this._animationFrame = requestAnimationFrame(this.onUpdate.bind(this));
+    }
+  }
+
+  onUpdate(): void {
+    const now = Date.now();
+
+    const value =
+      this._fromValue +
+      this._velocity /
+        (1 - this._deceleration) *
+        (1 - Math.exp(-(1 - this._deceleration) * (now - this._startTime)));
+
+    this._onUpdate(value);
+
+    if (Math.abs(this._lastValue - value) < 0.1) {
+      this.__debouncedOnEnd({finished: true});
+      return;
+    }
+
+    this._lastValue = value;
+    if (this.__active) {
+      this._animationFrame = requestAnimationFrame(this.onUpdate.bind(this));
+    }
+  }
+
+  stop(): void {
+    super.stop();
+    this.__active = false;
+    global.cancelAnimationFrame(this._animationFrame);
+    this.__debouncedOnEnd({finished: false});
+  }
+}
+
+module.exports = DecayAnimation;

node_modules/react-native/Libraries/Animated/src/animations/SpringAnimation.js

@@ -0,0 +1,340 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule SpringAnimation
+ * @flow
+ * @format
+ */
+'use strict';
+
+const AnimatedValue = require('../nodes/AnimatedValue');
+const AnimatedValueXY = require('../nodes/AnimatedValueXY');
+const Animation = require('./Animation');
+const SpringConfig = require('../SpringConfig');
+
+const invariant = require('fbjs/lib/invariant');
+const {shouldUseNativeDriver} = require('../NativeAnimatedHelper');
+
+import type {AnimationConfig, EndCallback} from './Animation';
+
+export type SpringAnimationConfig = AnimationConfig & {
+  toValue: number | AnimatedValue | {x: number, y: number} | AnimatedValueXY,
+  overshootClamping?: boolean,
+  restDisplacementThreshold?: number,
+  restSpeedThreshold?: number,
+  velocity?: number | {x: number, y: number},
+  bounciness?: number,
+  speed?: number,
+  tension?: number,
+  friction?: number,
+  stiffness?: number,
+  damping?: number,
+  mass?: number,
+  delay?: number,
+};
+
+export type SpringAnimationConfigSingle = AnimationConfig & {
+  toValue: number | AnimatedValue,
+  overshootClamping?: boolean,
+  restDisplacementThreshold?: number,
+  restSpeedThreshold?: number,
+  velocity?: number,
+  bounciness?: number,
+  speed?: number,
+  tension?: number,
+  friction?: number,
+  stiffness?: number,
+  damping?: number,
+  mass?: number,
+  delay?: number,
+};
+
+function withDefault<T>(value: ?T, defaultValue: T): T {
+  if (value === undefined || value === null) {
+    return defaultValue;
+  }
+  return value;
+}
+
+class SpringAnimation extends Animation {
+  _overshootClamping: boolean;
+  _restDisplacementThreshold: number;
+  _restSpeedThreshold: number;
+  _lastVelocity: number;
+  _startPosition: number;
+  _lastPosition: number;
+  _fromValue: number;
+  _toValue: any;
+  _stiffness: number;
+  _damping: number;
+  _mass: number;
+  _initialVelocity: number;
+  _delay: number;
+  _timeout: any;
+  _startTime: number;
+  _lastTime: number;
+  _frameTime: number;
+  _onUpdate: (value: number) => void;
+  _animationFrame: any;
+  _useNativeDriver: boolean;
+
+  constructor(config: SpringAnimationConfigSingle) {
+    super();
+
+    this._overshootClamping = withDefault(config.overshootClamping, false);
+    this._restDisplacementThreshold = withDefault(
+      config.restDisplacementThreshold,
+      0.001,
+    );
+    this._restSpeedThreshold = withDefault(config.restSpeedThreshold, 0.001);
+    this._initialVelocity = withDefault(config.velocity, 0);
+    this._lastVelocity = withDefault(config.velocity, 0);
+    this._toValue = config.toValue;
+    this._delay = withDefault(config.delay, 0);
+    this._useNativeDriver = shouldUseNativeDriver(config);
+    this.__isInteraction =
+      config.isInteraction !== undefined ? config.isInteraction : true;
+    this.__iterations = config.iterations !== undefined ? config.iterations : 1;
+
+    if (
+      config.stiffness !== undefined ||
+      config.damping !== undefined ||
+      config.mass !== undefined
+    ) {
+      invariant(
+        config.bounciness === undefined &&
+          config.speed === undefined &&
+          config.tension === undefined &&
+          config.friction === undefined,
+        'You can define one of bounciness/speed, tension/friction, or stiffness/damping/mass, but not more than one',
+      );
+      this._stiffness = withDefault(config.stiffness, 100);
+      this._damping = withDefault(config.damping, 10);
+      this._mass = withDefault(config.mass, 1);
+    } else if (config.bounciness !== undefined || config.speed !== undefined) {
+      // Convert the origami bounciness/speed values to stiffness/damping
+      // We assume mass is 1.
+      invariant(
+        config.tension === undefined &&
+          config.friction === undefined &&
+          config.stiffness === undefined &&
+          config.damping === undefined &&
+          config.mass === undefined,
+        'You can define one of bounciness/speed, tension/friction, or stiffness/damping/mass, but not more than one',
+      );
+      const springConfig = SpringConfig.fromBouncinessAndSpeed(
+        withDefault(config.bounciness, 8),
+        withDefault(config.speed, 12),
+      );
+      this._stiffness = springConfig.stiffness;
+      this._damping = springConfig.damping;
+      this._mass = 1;
+    } else {
+      // Convert the origami tension/friction values to stiffness/damping
+      // We assume mass is 1.
+      const springConfig = SpringConfig.fromOrigamiTensionAndFriction(
+        withDefault(config.tension, 40),
+        withDefault(config.friction, 7),
+      );
+      this._stiffness = springConfig.stiffness;
+      this._damping = springConfig.damping;
+      this._mass = 1;
+    }
+
+    invariant(this._stiffness > 0, 'Stiffness value must be greater than 0');
+    invariant(this._damping > 0, 'Damping value must be greater than 0');
+    invariant(this._mass > 0, 'Mass value must be greater than 0');
+  }
+
+  __getNativeAnimationConfig() {
+    return {
+      type: 'spring',
+      overshootClamping: this._overshootClamping,
+      restDisplacementThreshold: this._restDisplacementThreshold,
+      restSpeedThreshold: this._restSpeedThreshold,
+      stiffness: this._stiffness,
+      damping: this._damping,
+      mass: this._mass,
+      initialVelocity: withDefault(this._initialVelocity, this._lastVelocity),
+      toValue: this._toValue,
+      iterations: this.__iterations,
+    };
+  }
+
+  start(
+    fromValue: number,
+    onUpdate: (value: number) => void,
+    onEnd: ?EndCallback,
+    previousAnimation: ?Animation,
+    animatedValue: AnimatedValue,
+  ): void {
+    this.__active = true;
+    this._startPosition = fromValue;
+    this._lastPosition = this._startPosition;
+
+    this._onUpdate = onUpdate;
+    this.__onEnd = onEnd;
+    this._lastTime = Date.now();
+    this._frameTime = 0.0;
+
+    if (previousAnimation instanceof SpringAnimation) {
+      const internalState = previousAnimation.getInternalState();
+      this._lastPosition = internalState.lastPosition;
+      this._lastVelocity = internalState.lastVelocity;
+      // Set the initial velocity to the last velocity
+      this._initialVelocity = this._lastVelocity;
+      this._lastTime = internalState.lastTime;
+    }
+
+    const start = () => {
+      if (this._useNativeDriver) {
+        this.__startNativeAnimation(animatedValue);
+      } else {
+        this.onUpdate();
+      }
+    };
+
+    //  If this._delay is more than 0, we start after the timeout.
+    if (this._delay) {
+      this._timeout = setTimeout(start, this._delay);
+    } else {
+      start();
+    }
+  }
+
+  getInternalState(): Object {
+    return {
+      lastPosition: this._lastPosition,
+      lastVelocity: this._lastVelocity,
+      lastTime: this._lastTime,
+    };
+  }
+
+  /**
+   * This spring model is based off of a damped harmonic oscillator
+   * (https://en.wikipedia.org/wiki/Harmonic_oscillator#Damped_harmonic_oscillator).
+   *
+   * We use the closed form of the second order differential equation:
+   *
+   * x'' + (2ζ⍵_0)x' + ⍵^2x = 0
+   *
+   * where
+   *    ⍵_0 = √(k / m) (undamped angular frequency of the oscillator),
+   *    ζ = c / 2√mk (damping ratio),
+   *    c = damping constant
+   *    k = stiffness
+   *    m = mass
+   *
+   * The derivation of the closed form is described in detail here:
+   * http://planetmath.org/sites/default/files/texpdf/39745.pdf
+   *
+   * This algorithm happens to match the algorithm used by CASpringAnimation,
+   * a QuartzCore (iOS) API that creates spring animations.
+   */
+  onUpdate(): void {
+    // If for some reason we lost a lot of frames (e.g. process large payload or
+    // stopped in the debugger), we only advance by 4 frames worth of
+    // computation and will continue on the next frame. It's better to have it
+    // running at faster speed than jumping to the end.
+    const MAX_STEPS = 64;
+    let now = Date.now();
+    if (now > this._lastTime + MAX_STEPS) {
+      now = this._lastTime + MAX_STEPS;
+    }
+
+    const deltaTime = (now - this._lastTime) / 1000;
+    this._frameTime += deltaTime;
+
+    const c: number = this._damping;
+    const m: number = this._mass;
+    const k: number = this._stiffness;
+    const v0: number = -this._initialVelocity;
+
+    const zeta = c / (2 * Math.sqrt(k * m)); // damping ratio
+    const omega0 = Math.sqrt(k / m); // undamped angular frequency of the oscillator (rad/ms)
+    const omega1 = omega0 * Math.sqrt(1.0 - zeta * zeta); // exponential decay
+    const x0 = this._toValue - this._startPosition; // calculate the oscillation from x0 = 1 to x = 0
+
+    let position = 0.0;
+    let velocity = 0.0;
+    const t = this._frameTime;
+    if (zeta < 1) {
+      // Under damped
+      const envelope = Math.exp(-zeta * omega0 * t);
+      position =
+        this._toValue -
+        envelope *
+          ((v0 + zeta * omega0 * x0) / omega1 * Math.sin(omega1 * t) +
+            x0 * Math.cos(omega1 * t));
+      // This looks crazy -- it's actually just the derivative of the
+      // oscillation function
+      velocity =
+        zeta *
+          omega0 *
+          envelope *
+          (Math.sin(omega1 * t) * (v0 + zeta * omega0 * x0) / omega1 +
+            x0 * Math.cos(omega1 * t)) -
+        envelope *
+          (Math.cos(omega1 * t) * (v0 + zeta * omega0 * x0) -
+            omega1 * x0 * Math.sin(omega1 * t));
+    } else {
+      // Critically damped
+      const envelope = Math.exp(-omega0 * t);
+      position = this._toValue - envelope * (x0 + (v0 + omega0 * x0) * t);
+      velocity =
+        envelope * (v0 * (t * omega0 - 1) + t * x0 * (omega0 * omega0));
+    }
+
+    this._lastTime = now;
+    this._lastPosition = position;
+    this._lastVelocity = velocity;
+
+    this._onUpdate(position);
+    if (!this.__active) {
+      // a listener might have stopped us in _onUpdate
+      return;
+    }
+
+    // Conditions for stopping the spring animation
+    let isOvershooting = false;
+    if (this._overshootClamping && this._stiffness !== 0) {
+      if (this._startPosition < this._toValue) {
+        isOvershooting = position > this._toValue;
+      } else {
+        isOvershooting = position < this._toValue;
+      }
+    }
+    const isVelocity = Math.abs(velocity) <= this._restSpeedThreshold;
+    let isDisplacement = true;
+    if (this._stiffness !== 0) {
+      isDisplacement =
+        Math.abs(this._toValue - position) <= this._restDisplacementThreshold;
+    }
+
+    if (isOvershooting || (isVelocity && isDisplacement)) {
+      if (this._stiffness !== 0) {
+        // Ensure that we end up with a round value
+        this._lastPosition = this._toValue;
+        this._lastVelocity = 0;
+        this._onUpdate(this._toValue);
+      }
+
+      this.__debouncedOnEnd({finished: true});
+      return;
+    }
+    this._animationFrame = requestAnimationFrame(this.onUpdate.bind(this));
+  }
+
+  stop(): void {
+    super.stop();
+    this.__active = false;
+    clearTimeout(this._timeout);
+    global.cancelAnimationFrame(this._animationFrame);
+    this.__debouncedOnEnd({finished: false});
+  }
+}
+
+module.exports = SpringAnimation;

node_modules/react-native/Libraries/Animated/src/animations/TimingAnimation.js

@@ -0,0 +1,153 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule TimingAnimation
+ * @flow
+ * @format
+ */
+'use strict';
+
+const AnimatedValue = require('../nodes/AnimatedValue');
+const AnimatedValueXY = require('../nodes/AnimatedValueXY');
+const Animation = require('./Animation');
+
+const {shouldUseNativeDriver} = require('../NativeAnimatedHelper');
+
+import type {AnimationConfig, EndCallback} from './Animation';
+
+export type TimingAnimationConfig = AnimationConfig & {
+  toValue: number | AnimatedValue | {x: number, y: number} | AnimatedValueXY,
+  easing?: (value: number) => number,
+  duration?: number,
+  delay?: number,
+};
+
+export type TimingAnimationConfigSingle = AnimationConfig & {
+  toValue: number | AnimatedValue,
+  easing?: (value: number) => number,
+  duration?: number,
+  delay?: number,
+};
+
+let _easeInOut;
+function easeInOut() {
+  if (!_easeInOut) {
+    const Easing = require('Easing');
+    _easeInOut = Easing.inOut(Easing.ease);
+  }
+  return _easeInOut;
+}
+
+class TimingAnimation extends Animation {
+  _startTime: number;
+  _fromValue: number;
+  _toValue: any;
+  _duration: number;
+  _delay: number;
+  _easing: (value: number) => number;
+  _onUpdate: (value: number) => void;
+  _animationFrame: any;
+  _timeout: any;
+  _useNativeDriver: boolean;
+
+  constructor(config: TimingAnimationConfigSingle) {
+    super();
+    this._toValue = config.toValue;
+    this._easing = config.easing !== undefined ? config.easing : easeInOut();
+    this._duration = config.duration !== undefined ? config.duration : 500;
+    this._delay = config.delay !== undefined ? config.delay : 0;
+    this.__iterations = config.iterations !== undefined ? config.iterations : 1;
+    this.__isInteraction =
+      config.isInteraction !== undefined ? config.isInteraction : true;
+    this._useNativeDriver = shouldUseNativeDriver(config);
+  }
+
+  __getNativeAnimationConfig(): any {
+    const frameDuration = 1000.0 / 60.0;
+    const frames = [];
+    for (let dt = 0.0; dt < this._duration; dt += frameDuration) {
+      frames.push(this._easing(dt / this._duration));
+    }
+    frames.push(this._easing(1));
+    return {
+      type: 'frames',
+      frames,
+      toValue: this._toValue,
+      iterations: this.__iterations,
+    };
+  }
+
+  start(
+    fromValue: number,
+    onUpdate: (value: number) => void,
+    onEnd: ?EndCallback,
+    previousAnimation: ?Animation,
+    animatedValue: AnimatedValue,
+  ): void {
+    this.__active = true;
+    this._fromValue = fromValue;
+    this._onUpdate = onUpdate;
+    this.__onEnd = onEnd;
+
+    const start = () => {
+      // Animations that sometimes have 0 duration and sometimes do not
+      // still need to use the native driver when duration is 0 so as to
+      // not cause intermixed JS and native animations.
+      if (this._duration === 0 && !this._useNativeDriver) {
+        this._onUpdate(this._toValue);
+        this.__debouncedOnEnd({finished: true});
+      } else {
+        this._startTime = Date.now();
+        if (this._useNativeDriver) {
+          this.__startNativeAnimation(animatedValue);
+        } else {
+          this._animationFrame = requestAnimationFrame(
+            this.onUpdate.bind(this),
+          );
+        }
+      }
+    };
+    if (this._delay) {
+      this._timeout = setTimeout(start, this._delay);
+    } else {
+      start();
+    }
+  }
+
+  onUpdate(): void {
+    const now = Date.now();
+    if (now >= this._startTime + this._duration) {
+      if (this._duration === 0) {
+        this._onUpdate(this._toValue);
+      } else {
+        this._onUpdate(
+          this._fromValue + this._easing(1) * (this._toValue - this._fromValue),
+        );
+      }
+      this.__debouncedOnEnd({finished: true});
+      return;
+    }
+
+    this._onUpdate(
+      this._fromValue +
+        this._easing((now - this._startTime) / this._duration) *
+          (this._toValue - this._fromValue),
+    );
+    if (this.__active) {
+      this._animationFrame = requestAnimationFrame(this.onUpdate.bind(this));
+    }
+  }
+
+  stop(): void {
+    super.stop();
+    this.__active = false;
+    clearTimeout(this._timeout);
+    global.cancelAnimationFrame(this._animationFrame);
+    this.__debouncedOnEnd({finished: false});
+  }
+}
+
+module.exports = TimingAnimation;

node_modules/react-native/Libraries/Animated/src/bezier.js

@@ -0,0 +1,108 @@
+/**
+ * BezierEasing - use bezier curve for transition easing function
+ * https://github.com/gre/bezier-easing
+ *
+ * @copyright 2014-2015 Gaëtan Renaudeau. MIT License.
+ * @providesModule bezier
+ * @noflow
+ */
+'use strict';
+
+ // These values are established by empiricism with tests (tradeoff: performance VS precision)
+ var NEWTON_ITERATIONS = 4;
+ var NEWTON_MIN_SLOPE = 0.001;
+ var SUBDIVISION_PRECISION = 0.0000001;
+ var SUBDIVISION_MAX_ITERATIONS = 10;
+
+ var kSplineTableSize = 11;
+ var kSampleStepSize = 1.0 / (kSplineTableSize - 1.0);
+
+ var float32ArraySupported = typeof Float32Array === 'function';
+
+ function A (aA1, aA2) { return 1.0 - 3.0 * aA2 + 3.0 * aA1; }
+ function B (aA1, aA2) { return 3.0 * aA2 - 6.0 * aA1; }
+ function C (aA1)      { return 3.0 * aA1; }
+
+ // Returns x(t) given t, x1, and x2, or y(t) given t, y1, and y2.
+ function calcBezier (aT, aA1, aA2) { return ((A(aA1, aA2) * aT + B(aA1, aA2)) * aT + C(aA1)) * aT; }
+
+ // Returns dx/dt given t, x1, and x2, or dy/dt given t, y1, and y2.
+ function getSlope (aT, aA1, aA2) { return 3.0 * A(aA1, aA2) * aT * aT + 2.0 * B(aA1, aA2) * aT + C(aA1); }
+
+ function binarySubdivide (aX, aA, aB, mX1, mX2) {
+   var currentX, currentT, i = 0;
+   do {
+     currentT = aA + (aB - aA) / 2.0;
+     currentX = calcBezier(currentT, mX1, mX2) - aX;
+     if (currentX > 0.0) {
+       aB = currentT;
+     } else {
+       aA = currentT;
+     }
+   } while (Math.abs(currentX) > SUBDIVISION_PRECISION && ++i < SUBDIVISION_MAX_ITERATIONS);
+   return currentT;
+ }
+
+ function newtonRaphsonIterate (aX, aGuessT, mX1, mX2) {
+  for (var i = 0; i < NEWTON_ITERATIONS; ++i) {
+    var currentSlope = getSlope(aGuessT, mX1, mX2);
+    if (currentSlope === 0.0) {
+      return aGuessT;
+    }
+    var currentX = calcBezier(aGuessT, mX1, mX2) - aX;
+    aGuessT -= currentX / currentSlope;
+  }
+  return aGuessT;
+ }
+
+ module.exports = function bezier (mX1, mY1, mX2, mY2) {
+   if (!(0 <= mX1 && mX1 <= 1 && 0 <= mX2 && mX2 <= 1)) { // eslint-disable-line yoda
+     throw new Error('bezier x values must be in [0, 1] range');
+   }
+
+   // Precompute samples table
+   var sampleValues = float32ArraySupported ? new Float32Array(kSplineTableSize) : new Array(kSplineTableSize);
+   if (mX1 !== mY1 || mX2 !== mY2) {
+     for (var i = 0; i < kSplineTableSize; ++i) {
+       sampleValues[i] = calcBezier(i * kSampleStepSize, mX1, mX2);
+     }
+   }
+
+   function getTForX (aX) {
+     var intervalStart = 0.0;
+     var currentSample = 1;
+     var lastSample = kSplineTableSize - 1;
+
+     for (; currentSample !== lastSample && sampleValues[currentSample] <= aX; ++currentSample) {
+       intervalStart += kSampleStepSize;
+     }
+     --currentSample;
+
+     // Interpolate to provide an initial guess for t
+     var dist = (aX - sampleValues[currentSample]) / (sampleValues[currentSample + 1] - sampleValues[currentSample]);
+     var guessForT = intervalStart + dist * kSampleStepSize;
+
+     var initialSlope = getSlope(guessForT, mX1, mX2);
+     if (initialSlope >= NEWTON_MIN_SLOPE) {
+       return newtonRaphsonIterate(aX, guessForT, mX1, mX2);
+     } else if (initialSlope === 0.0) {
+       return guessForT;
+     } else {
+       return binarySubdivide(aX, intervalStart, intervalStart + kSampleStepSize, mX1, mX2);
+     }
+   }
+
+   return function BezierEasing (x) {
+     if (mX1 === mY1 && mX2 === mY2) {
+       return x; // linear
+     }
+     // Because JavaScript number are imprecise, we should guarantee the extremes are right.
+     if (x === 0) {
+       return 0;
+     }
+     if (x === 1) {
+       return 1;
+     }
+     return calcBezier(getTForX(x), mY1, mY2);
+   };
+ };

node_modules/react-native/Libraries/Animated/src/createAnimatedComponent.js

@@ -0,0 +1,207 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule createAnimatedComponent
+ * @flow
+ * @format
+ */
+'use strict';
+
+const {AnimatedEvent} = require('./AnimatedEvent');
+const AnimatedProps = require('./nodes/AnimatedProps');
+const React = require('React');
+const ViewStylePropTypes = require('ViewStylePropTypes');
+
+const invariant = require('fbjs/lib/invariant');
+
+function createAnimatedComponent(Component: any): any {
+  invariant(
+    typeof Component === 'string' ||
+      (Component.prototype && Component.prototype.isReactComponent),
+    '`createAnimatedComponent` does not support stateless functional components; ' +
+      'use a class component instead.',
+  );
+
+  class AnimatedComponent extends React.Component<Object> {
+    _component: any;
+    _invokeAnimatedPropsCallbackOnMount: boolean = false;
+    _prevComponent: any;
+    _propsAnimated: AnimatedProps;
+    _eventDetachers: Array<Function> = [];
+    _setComponentRef: Function;
+
+    static __skipSetNativeProps_FOR_TESTS_ONLY = false;
+
+    constructor(props: Object) {
+      super(props);
+      this._setComponentRef = this._setComponentRef.bind(this);
+    }
+
+    componentWillUnmount() {
+      this._propsAnimated && this._propsAnimated.__detach();
+      this._detachNativeEvents();
+    }
+
+    setNativeProps(props) {
+      this._component.setNativeProps(props);
+    }
+
+    UNSAFE_componentWillMount() {
+      this._attachProps(this.props);
+    }
+
+    componentDidMount() {
+      if (this._invokeAnimatedPropsCallbackOnMount) {
+        this._invokeAnimatedPropsCallbackOnMount = false;
+        this._animatedPropsCallback();
+      }
+
+      this._propsAnimated.setNativeView(this._component);
+      this._attachNativeEvents();
+    }
+
+    _attachNativeEvents() {
+      // Make sure to get the scrollable node for components that implement
+      // `ScrollResponder.Mixin`.
+      const scrollableNode = this._component.getScrollableNode
+        ? this._component.getScrollableNode()
+        : this._component;
+
+      for (const key in this.props) {
+        const prop = this.props[key];
+        if (prop instanceof AnimatedEvent && prop.__isNative) {
+          prop.__attach(scrollableNode, key);
+          this._eventDetachers.push(() => prop.__detach(scrollableNode, key));
+        }
+      }
+    }
+
+    _detachNativeEvents() {
+      this._eventDetachers.forEach(remove => remove());
+      this._eventDetachers = [];
+    }
+
+    // The system is best designed when setNativeProps is implemented. It is
+    // able to avoid re-rendering and directly set the attributes that changed.
+    // However, setNativeProps can only be implemented on leaf native
+    // components. If you want to animate a composite component, you need to
+    // re-render it. In this case, we have a fallback that uses forceUpdate.
+    _animatedPropsCallback = () => {
+      if (this._component == null) {
+        // AnimatedProps is created in will-mount because it's used in render.
+        // But this callback may be invoked before mount in async mode,
+        // In which case we should defer the setNativeProps() call.
+        // React may throw away uncommitted work in async mode,
+        // So a deferred call won't always be invoked.
+        this._invokeAnimatedPropsCallbackOnMount = true;
+      } else if (
+        AnimatedComponent.__skipSetNativeProps_FOR_TESTS_ONLY ||
+        typeof this._component.setNativeProps !== 'function'
+      ) {
+        this.forceUpdate();
+      } else if (!this._propsAnimated.__isNative) {
+        this._component.setNativeProps(
+          this._propsAnimated.__getAnimatedValue(),
+        );
+      } else {
+        throw new Error(
+          'Attempting to run JS driven animation on animated ' +
+            'node that has been moved to "native" earlier by starting an ' +
+            'animation with `useNativeDriver: true`',
+        );
+      }
+    };
+
+    _attachProps(nextProps) {
+      const oldPropsAnimated = this._propsAnimated;
+
+      this._propsAnimated = new AnimatedProps(
+        nextProps,
+        this._animatedPropsCallback,
+      );
+
+      // When you call detach, it removes the element from the parent list
+      // of children. If it goes to 0, then the parent also detaches itself
+      // and so on.
+      // An optimization is to attach the new elements and THEN detach the old
+      // ones instead of detaching and THEN attaching.
+      // This way the intermediate state isn't to go to 0 and trigger
+      // this expensive recursive detaching to then re-attach everything on
+      // the very next operation.
+      oldPropsAnimated && oldPropsAnimated.__detach();
+    }
+
+    UNSAFE_componentWillReceiveProps(newProps) {
+      this._attachProps(newProps);
+    }
+
+    componentDidUpdate(prevProps) {
+      if (this._component !== this._prevComponent) {
+        this._propsAnimated.setNativeView(this._component);
+      }
+      if (this._component !== this._prevComponent || prevProps !== this.props) {
+        this._detachNativeEvents();
+        this._attachNativeEvents();
+      }
+    }
+
+    render() {
+      const props = this._propsAnimated.__getValue();
+      return (
+        <Component
+          {...props}
+          ref={this._setComponentRef}
+          // The native driver updates views directly through the UI thread so we
+          // have to make sure the view doesn't get optimized away because it cannot
+          // go through the NativeViewHierarchyManager since it operates on the shadow
+          // thread.
+          collapsable={
+            this._propsAnimated.__isNative ? false : props.collapsable
+          }
+        />
+      );
+    }
+
+    _setComponentRef(c) {
+      this._prevComponent = this._component;
+      this._component = c;
+    }
+
+    // A third party library can use getNode()
+    // to get the node reference of the decorated component
+    getNode() {
+      return this._component;
+    }
+  }
+
+  const propTypes = Component.propTypes;
+
+  AnimatedComponent.propTypes = {
+    style: function(props, propName, componentName) {
+      if (!propTypes) {
+        return;
+      }
+
+      for (const key in ViewStylePropTypes) {
+        if (!propTypes[key] && props[key] !== undefined) {
+          console.warn(
+            'You are setting the style `{ ' +
+              key +
+              ': ... }` as a prop. You ' +
+              'should nest it in a style object. ' +
+              'E.g. `{ style: { ' +
+              key +
+              ': ... } }`',
+          );
+        }
+      }
+    },
+  };
+
+  return AnimatedComponent;
+}
+
+module.exports = createAnimatedComponent;

node_modules/react-native/Libraries/Animated/src/nodes/AnimatedAddition.js

@@ -0,0 +1,63 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule AnimatedAddition
+ * @flow
+ * @format
+ */
+'use strict';
+
+const AnimatedInterpolation = require('./AnimatedInterpolation');
+const AnimatedNode = require('./AnimatedNode');
+const AnimatedValue = require('./AnimatedValue');
+const AnimatedWithChildren = require('./AnimatedWithChildren');
+
+import type {InterpolationConfigType} from './AnimatedInterpolation';
+
+class AnimatedAddition extends AnimatedWithChildren {
+  _a: AnimatedNode;
+  _b: AnimatedNode;
+
+  constructor(a: AnimatedNode | number, b: AnimatedNode | number) {
+    super();
+    this._a = typeof a === 'number' ? new AnimatedValue(a) : a;
+    this._b = typeof b === 'number' ? new AnimatedValue(b) : b;
+  }
+
+  __makeNative() {
+    this._a.__makeNative();
+    this._b.__makeNative();
+    super.__makeNative();
+  }
+
+  __getValue(): number {
+    return this._a.__getValue() + this._b.__getValue();
+  }
+
+  interpolate(config: InterpolationConfigType): AnimatedInterpolation {
+    return new AnimatedInterpolation(this, config);
+  }
+
+  __attach(): void {
+    this._a.__addChild(this);
+    this._b.__addChild(this);
+  }
+
+  __detach(): void {
+    this._a.__removeChild(this);
+    this._b.__removeChild(this);
+    super.__detach();
+  }
+
+  __getNativeConfig(): any {
+    return {
+      type: 'addition',
+      input: [this._a.__getNativeTag(), this._b.__getNativeTag()],
+    };
+  }
+}
+
+module.exports = AnimatedAddition;

node_modules/react-native/Libraries/Animated/src/nodes/AnimatedDiffClamp.js

@@ -0,0 +1,71 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule AnimatedDiffClamp
+ * @flow
+ * @format
+ */
+'use strict';
+
+const AnimatedInterpolation = require('./AnimatedInterpolation');
+const AnimatedNode = require('./AnimatedNode');
+const AnimatedWithChildren = require('./AnimatedWithChildren');
+
+import type {InterpolationConfigType} from './AnimatedInterpolation';
+
+class AnimatedDiffClamp extends AnimatedWithChildren {
+  _a: AnimatedNode;
+  _min: number;
+  _max: number;
+  _value: number;
+  _lastValue: number;
+
+  constructor(a: AnimatedNode, min: number, max: number) {
+    super();
+
+    this._a = a;
+    this._min = min;
+    this._max = max;
+    this._value = this._lastValue = this._a.__getValue();
+  }
+
+  __makeNative() {
+    this._a.__makeNative();
+    super.__makeNative();
+  }
+
+  interpolate(config: InterpolationConfigType): AnimatedInterpolation {
+    return new AnimatedInterpolation(this, config);
+  }
+
+  __getValue(): number {
+    const value = this._a.__getValue();
+    const diff = value - this._lastValue;
+    this._lastValue = value;
+    this._value = Math.min(Math.max(this._value + diff, this._min), this._max);
+    return this._value;
+  }
+
+  __attach(): void {
+    this._a.__addChild(this);
+  }
+
+  __detach(): void {
+    this._a.__removeChild(this);
+    super.__detach();
+  }
+
+  __getNativeConfig(): any {
+    return {
+      type: 'diffclamp',
+      input: this._a.__getNativeTag(),
+      min: this._min,
+      max: this._max,
+    };
+  }
+}
+
+module.exports = AnimatedDiffClamp;

node_modules/react-native/Libraries/Animated/src/nodes/AnimatedDivision.js

@@ -0,0 +1,68 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule AnimatedDivision
+ * @flow
+ * @format
+ */
+'use strict';
+
+const AnimatedInterpolation = require('./AnimatedInterpolation');
+const AnimatedNode = require('./AnimatedNode');
+const AnimatedValue = require('./AnimatedValue');
+const AnimatedWithChildren = require('./AnimatedWithChildren');
+
+import type {InterpolationConfigType} from './AnimatedInterpolation';
+
+class AnimatedDivision extends AnimatedWithChildren {
+  _a: AnimatedNode;
+  _b: AnimatedNode;
+
+  constructor(a: AnimatedNode | number, b: AnimatedNode | number) {
+    super();
+    this._a = typeof a === 'number' ? new AnimatedValue(a) : a;
+    this._b = typeof b === 'number' ? new AnimatedValue(b) : b;
+  }
+
+  __makeNative() {
+    this._a.__makeNative();
+    this._b.__makeNative();
+    super.__makeNative();
+  }
+
+  __getValue(): number {
+    const a = this._a.__getValue();
+    const b = this._b.__getValue();
+    if (b === 0) {
+      console.error('Detected division by zero in AnimatedDivision');
+    }
+    return a / b;
+  }
+
+  interpolate(config: InterpolationConfigType): AnimatedInterpolation {
+    return new AnimatedInterpolation(this, config);
+  }
+
+  __attach(): void {
+    this._a.__addChild(this);
+    this._b.__addChild(this);
+  }
+
+  __detach(): void {
+    this._a.__removeChild(this);
+    this._b.__removeChild(this);
+    super.__detach();
+  }
+
+  __getNativeConfig(): any {
+    return {
+      type: 'division',
+      input: [this._a.__getNativeTag(), this._b.__getNativeTag()],
+    };
+  }
+}
+
+module.exports = AnimatedDivision;

node_modules/react-native/Libraries/Animated/src/nodes/AnimatedInterpolation.js

@@ -0,0 +1,386 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule AnimatedInterpolation
+ * @flow
+ * @format
+ */
+/* eslint no-bitwise: 0 */
+'use strict';
+
+const AnimatedNode = require('./AnimatedNode');
+const AnimatedWithChildren = require('./AnimatedWithChildren');
+const NativeAnimatedHelper = require('../NativeAnimatedHelper');
+
+const invariant = require('fbjs/lib/invariant');
+const normalizeColor = require('normalizeColor');
+
+type ExtrapolateType = 'extend' | 'identity' | 'clamp';
+
+export type InterpolationConfigType = {
+  inputRange: Array<number>,
+  /* $FlowFixMe(>=0.38.0 site=react_native_fb,react_native_oss) - Flow error
+   * detected during the deployment of v0.38.0. To see the error, remove this
+   * comment and run flow
+   */
+  outputRange: Array<number> | Array<string>,
+  easing?: (input: number) => number,
+  extrapolate?: ExtrapolateType,
+  extrapolateLeft?: ExtrapolateType,
+  extrapolateRight?: ExtrapolateType,
+};
+
+const linear = t => t;
+
+/**
+ * Very handy helper to map input ranges to output ranges with an easing
+ * function and custom behavior outside of the ranges.
+ */
+function createInterpolation(
+  config: InterpolationConfigType,
+): (input: number) => number | string {
+  if (config.outputRange && typeof config.outputRange[0] === 'string') {
+    return createInterpolationFromStringOutputRange(config);
+  }
+
+  const outputRange: Array<number> = (config.outputRange: any);
+  checkInfiniteRange('outputRange', outputRange);
+
+  const inputRange = config.inputRange;
+  checkInfiniteRange('inputRange', inputRange);
+  checkValidInputRange(inputRange);
+
+  invariant(
+    inputRange.length === outputRange.length,
+    'inputRange (' +
+      inputRange.length +
+      ') and outputRange (' +
+      outputRange.length +
+      ') must have the same length',
+  );
+
+  const easing = config.easing || linear;
+
+  let extrapolateLeft: ExtrapolateType = 'extend';
+  if (config.extrapolateLeft !== undefined) {
+    extrapolateLeft = config.extrapolateLeft;
+  } else if (config.extrapolate !== undefined) {
+    extrapolateLeft = config.extrapolate;
+  }
+
+  let extrapolateRight: ExtrapolateType = 'extend';
+  if (config.extrapolateRight !== undefined) {
+    extrapolateRight = config.extrapolateRight;
+  } else if (config.extrapolate !== undefined) {
+    extrapolateRight = config.extrapolate;
+  }
+
+  return input => {
+    invariant(
+      typeof input === 'number',
+      'Cannot interpolation an input which is not a number',
+    );
+
+    const range = findRange(input, inputRange);
+    return interpolate(
+      input,
+      inputRange[range],
+      inputRange[range + 1],
+      outputRange[range],
+      outputRange[range + 1],
+      easing,
+      extrapolateLeft,
+      extrapolateRight,
+    );
+  };
+}
+
+function interpolate(
+  input: number,
+  inputMin: number,
+  inputMax: number,
+  outputMin: number,
+  outputMax: number,
+  easing: (input: number) => number,
+  extrapolateLeft: ExtrapolateType,
+  extrapolateRight: ExtrapolateType,
+) {
+  let result = input;
+
+  // Extrapolate
+  if (result < inputMin) {
+    if (extrapolateLeft === 'identity') {
+      return result;
+    } else if (extrapolateLeft === 'clamp') {
+      result = inputMin;
+    } else if (extrapolateLeft === 'extend') {
+      // noop
+    }
+  }
+
+  if (result > inputMax) {
+    if (extrapolateRight === 'identity') {
+      return result;
+    } else if (extrapolateRight === 'clamp') {
+      result = inputMax;
+    } else if (extrapolateRight === 'extend') {
+      // noop
+    }
+  }
+
+  if (outputMin === outputMax) {
+    return outputMin;
+  }
+
+  if (inputMin === inputMax) {
+    if (input <= inputMin) {
+      return outputMin;
+    }
+    return outputMax;
+  }
+
+  // Input Range
+  if (inputMin === -Infinity) {
+    result = -result;
+  } else if (inputMax === Infinity) {
+    result = result - inputMin;
+  } else {
+    result = (result - inputMin) / (inputMax - inputMin);
+  }
+
+  // Easing
+  result = easing(result);
+
+  // Output Range
+  if (outputMin === -Infinity) {
+    result = -result;
+  } else if (outputMax === Infinity) {
+    result = result + outputMin;
+  } else {
+    result = result * (outputMax - outputMin) + outputMin;
+  }
+
+  return result;
+}
+
+function colorToRgba(input: string): string {
+  let int32Color = normalizeColor(input);
+  if (int32Color === null) {
+    return input;
+  }
+
+  int32Color = int32Color || 0;
+
+  const r = (int32Color & 0xff000000) >>> 24;
+  const g = (int32Color & 0x00ff0000) >>> 16;
+  const b = (int32Color & 0x0000ff00) >>> 8;
+  const a = (int32Color & 0x000000ff) / 255;
+
+  return `rgba(${r}, ${g}, ${b}, ${a})`;
+}
+
+const stringShapeRegex = /[0-9\.-]+/g;
+
+/**
+ * Supports string shapes by extracting numbers so new values can be computed,
+ * and recombines those values into new strings of the same shape.  Supports
+ * things like:
+ *
+ *   rgba(123, 42, 99, 0.36) // colors
+ *   -45deg                  // values with units
+ */
+function createInterpolationFromStringOutputRange(
+  config: InterpolationConfigType,
+): (input: number) => string {
+  let outputRange: Array<string> = (config.outputRange: any);
+  invariant(outputRange.length >= 2, 'Bad output range');
+  outputRange = outputRange.map(colorToRgba);
+  checkPattern(outputRange);
+
+  // ['rgba(0, 100, 200, 0)', 'rgba(50, 150, 250, 0.5)']
+  // ->
+  // [
+  //   [0, 50],
+  //   [100, 150],
+  //   [200, 250],
+  //   [0, 0.5],
+  // ]
+  /* $FlowFixMe(>=0.18.0): `outputRange[0].match()` can return `null`. Need to
+   * guard against this possibility.
+   */
+  const outputRanges = outputRange[0].match(stringShapeRegex).map(() => []);
+  outputRange.forEach(value => {
+    /* $FlowFixMe(>=0.18.0): `value.match()` can return `null`. Need to guard
+     * against this possibility.
+     */
+    value.match(stringShapeRegex).forEach((number, i) => {
+      outputRanges[i].push(+number);
+    });
+  });
+
+  /* $FlowFixMe(>=0.18.0): `outputRange[0].match()` can return `null`. Need to
+   * guard against this possibility.
+   */
+  const interpolations = outputRange[0]
+    .match(stringShapeRegex)
+    .map((value, i) => {
+      return createInterpolation({
+        ...config,
+        outputRange: outputRanges[i],
+      });
+    });
+
+  // rgba requires that the r,g,b are integers.... so we want to round them, but we *dont* want to
+  // round the opacity (4th column).
+  const shouldRound = isRgbOrRgba(outputRange[0]);
+
+  return input => {
+    let i = 0;
+    // 'rgba(0, 100, 200, 0)'
+    // ->
+    // 'rgba(${interpolations[0](input)}, ${interpolations[1](input)}, ...'
+    return outputRange[0].replace(stringShapeRegex, () => {
+      const val = +interpolations[i++](input);
+      const rounded =
+        shouldRound && i < 4 ? Math.round(val) : Math.round(val * 1000) / 1000;
+      return String(rounded);
+    });
+  };
+}
+
+function isRgbOrRgba(range) {
+  return typeof range === 'string' && range.startsWith('rgb');
+}
+
+function checkPattern(arr: Array<string>) {
+  const pattern = arr[0].replace(stringShapeRegex, '');
+  for (let i = 1; i < arr.length; ++i) {
+    invariant(
+      pattern === arr[i].replace(stringShapeRegex, ''),
+      'invalid pattern ' + arr[0] + ' and ' + arr[i],
+    );
+  }
+}
+
+function findRange(input: number, inputRange: Array<number>) {
+  let i;
+  for (i = 1; i < inputRange.length - 1; ++i) {
+    if (inputRange[i] >= input) {
+      break;
+    }
+  }
+  return i - 1;
+}
+
+function checkValidInputRange(arr: Array<number>) {
+  invariant(arr.length >= 2, 'inputRange must have at least 2 elements');
+  for (let i = 1; i < arr.length; ++i) {
+    invariant(
+      arr[i] >= arr[i - 1],
+      /* $FlowFixMe(>=0.13.0) - In the addition expression below this comment,
+       * one or both of the operands may be something that doesn't cleanly
+       * convert to a string, like undefined, null, and object, etc. If you really
+       * mean this implicit string conversion, you can do something like
+       * String(myThing)
+       */
+      'inputRange must be monotonically increasing ' + arr,
+    );
+  }
+}
+
+function checkInfiniteRange(name: string, arr: Array<number>) {
+  invariant(arr.length >= 2, name + ' must have at least 2 elements');
+  invariant(
+    arr.length !== 2 || arr[0] !== -Infinity || arr[1] !== Infinity,
+    /* $FlowFixMe(>=0.13.0) - In the addition expression below this comment,
+     * one or both of the operands may be something that doesn't cleanly convert
+     * to a string, like undefined, null, and object, etc. If you really mean
+     * this implicit string conversion, you can do something like
+     * String(myThing)
+     */
+    name + 'cannot be ]-infinity;+infinity[ ' + arr,
+  );
+}
+
+class AnimatedInterpolation extends AnimatedWithChildren {
+  // Export for testing.
+  static __createInterpolation = createInterpolation;
+
+  _parent: AnimatedNode;
+  _config: InterpolationConfigType;
+  _interpolation: (input: number) => number | string;
+
+  constructor(parent: AnimatedNode, config: InterpolationConfigType) {
+    super();
+    this._parent = parent;
+    this._config = config;
+    this._interpolation = createInterpolation(config);
+  }
+
+  __makeNative() {
+    this._parent.__makeNative();
+    super.__makeNative();
+  }
+
+  __getValue(): number | string {
+    const parentValue: number = this._parent.__getValue();
+    invariant(
+      typeof parentValue === 'number',
+      'Cannot interpolate an input which is not a number.',
+    );
+    return this._interpolation(parentValue);
+  }
+
+  interpolate(config: InterpolationConfigType): AnimatedInterpolation {
+    return new AnimatedInterpolation(this, config);
+  }
+
+  __attach(): void {
+    this._parent.__addChild(this);
+  }
+
+  __detach(): void {
+    this._parent.__removeChild(this);
+    super.__detach();
+  }
+
+  __transformDataType(range: Array<any>) {
+    // Change the string array type to number array
+    // So we can reuse the same logic in iOS and Android platform
+    return range.map(function(value) {
+      if (typeof value !== 'string') {
+        return value;
+      }
+      if (/deg$/.test(value)) {
+        const degrees = parseFloat(value) || 0;
+        const radians = degrees * Math.PI / 180.0;
+        return radians;
+      } else {
+        // Assume radians
+        return parseFloat(value) || 0;
+      }
+    });
+  }
+
+  __getNativeConfig(): any {
+    if (__DEV__) {
+      NativeAnimatedHelper.validateInterpolation(this._config);
+    }
+
+    return {
+      inputRange: this._config.inputRange,
+      // Only the `outputRange` can contain strings so we don't need to transform `inputRange` here
+      outputRange: this.__transformDataType(this._config.outputRange),
+      extrapolateLeft:
+        this._config.extrapolateLeft || this._config.extrapolate || 'extend',
+      extrapolateRight:
+        this._config.extrapolateRight || this._config.extrapolate || 'extend',
+      type: 'interpolation',
+    };
+  }
+}
+
+module.exports = AnimatedInterpolation;

node_modules/react-native/Libraries/Animated/src/nodes/AnimatedModulo.js

@@ -0,0 +1,62 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule AnimatedModulo
+ * @flow
+ * @format
+ */
+'use strict';
+
+const AnimatedInterpolation = require('./AnimatedInterpolation');
+const AnimatedNode = require('./AnimatedNode');
+const AnimatedWithChildren = require('./AnimatedWithChildren');
+
+import type {InterpolationConfigType} from './AnimatedInterpolation';
+
+class AnimatedModulo extends AnimatedWithChildren {
+  _a: AnimatedNode;
+  _modulus: number;
+
+  constructor(a: AnimatedNode, modulus: number) {
+    super();
+    this._a = a;
+    this._modulus = modulus;
+  }
+
+  __makeNative() {
+    this._a.__makeNative();
+    super.__makeNative();
+  }
+
+  __getValue(): number {
+    return (
+      (this._a.__getValue() % this._modulus + this._modulus) % this._modulus
+    );
+  }
+
+  interpolate(config: InterpolationConfigType): AnimatedInterpolation {
+    return new AnimatedInterpolation(this, config);
+  }
+
+  __attach(): void {
+    this._a.__addChild(this);
+  }
+
+  __detach(): void {
+    this._a.__removeChild(this);
+    super.__detach();
+  }
+
+  __getNativeConfig(): any {
+    return {
+      type: 'modulus',
+      input: this._a.__getNativeTag(),
+      modulus: this._modulus,
+    };
+  }
+}
+
+module.exports = AnimatedModulo;

node_modules/react-native/Libraries/Animated/src/nodes/AnimatedMultiplication.js

@@ -0,0 +1,63 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule AnimatedMultiplication
+ * @flow
+ * @format
+ */
+'use strict';
+
+const AnimatedInterpolation = require('./AnimatedInterpolation');
+const AnimatedNode = require('./AnimatedNode');
+const AnimatedValue = require('./AnimatedValue');
+const AnimatedWithChildren = require('./AnimatedWithChildren');
+
+import type {InterpolationConfigType} from './AnimatedInterpolation';
+
+class AnimatedMultiplication extends AnimatedWithChildren {
+  _a: AnimatedNode;
+  _b: AnimatedNode;
+
+  constructor(a: AnimatedNode | number, b: AnimatedNode | number) {
+    super();
+    this._a = typeof a === 'number' ? new AnimatedValue(a) : a;
+    this._b = typeof b === 'number' ? new AnimatedValue(b) : b;
+  }
+
+  __makeNative() {
+    this._a.__makeNative();
+    this._b.__makeNative();
+    super.__makeNative();
+  }
+
+  __getValue(): number {
+    return this._a.__getValue() * this._b.__getValue();
+  }
+
+  interpolate(config: InterpolationConfigType): AnimatedInterpolation {
+    return new AnimatedInterpolation(this, config);
+  }
+
+  __attach(): void {
+    this._a.__addChild(this);
+    this._b.__addChild(this);
+  }
+
+  __detach(): void {
+    this._a.__removeChild(this);
+    this._b.__removeChild(this);
+    super.__detach();
+  }
+
+  __getNativeConfig(): any {
+    return {
+      type: 'multiplication',
+      input: [this._a.__getNativeTag(), this._b.__getNativeTag()],
+    };
+  }
+}
+
+module.exports = AnimatedMultiplication;

node_modules/react-native/Libraries/Animated/src/nodes/AnimatedNode.js

@@ -0,0 +1,71 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule AnimatedNode
+ * @flow
+ * @format
+ */
+'use strict';
+
+const NativeAnimatedHelper = require('../NativeAnimatedHelper');
+
+const invariant = require('fbjs/lib/invariant');
+
+// Note(vjeux): this would be better as an interface but flow doesn't
+// support them yet
+class AnimatedNode {
+  __attach(): void {}
+  __detach(): void {
+    if (this.__isNative && this.__nativeTag != null) {
+      NativeAnimatedHelper.API.dropAnimatedNode(this.__nativeTag);
+      this.__nativeTag = undefined;
+    }
+  }
+  __getValue(): any {}
+  __getAnimatedValue(): any {
+    return this.__getValue();
+  }
+  __addChild(child: AnimatedNode) {}
+  __removeChild(child: AnimatedNode) {}
+  __getChildren(): Array<AnimatedNode> {
+    return [];
+  }
+
+  /* Methods and props used by native Animated impl */
+  __isNative: boolean;
+  __nativeTag: ?number;
+  __makeNative() {
+    if (!this.__isNative) {
+      throw new Error('This node cannot be made a "native" animated node');
+    }
+  }
+  __getNativeTag(): ?number {
+    NativeAnimatedHelper.assertNativeAnimatedModule();
+    invariant(
+      this.__isNative,
+      'Attempt to get native tag from node not marked as "native"',
+    );
+    if (this.__nativeTag == null) {
+      const nativeTag: ?number = NativeAnimatedHelper.generateNewNodeTag();
+      NativeAnimatedHelper.API.createAnimatedNode(
+        nativeTag,
+        this.__getNativeConfig(),
+      );
+      this.__nativeTag = nativeTag;
+    }
+    return this.__nativeTag;
+  }
+  __getNativeConfig(): Object {
+    throw new Error(
+      'This JS animated node type cannot be used as native animated node',
+    );
+  }
+  toJSON(): any {
+    return this.__getValue();
+  }
+}
+
+module.exports = AnimatedNode;

node_modules/react-native/Libraries/Animated/src/nodes/AnimatedProps.js

@@ -0,0 +1,165 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule AnimatedProps
+ * @flow
+ * @format
+ */
+'use strict';
+
+const {AnimatedEvent} = require('../AnimatedEvent');
+const AnimatedNode = require('./AnimatedNode');
+const AnimatedStyle = require('./AnimatedStyle');
+const NativeAnimatedHelper = require('../NativeAnimatedHelper');
+const ReactNative = require('ReactNative');
+
+const invariant = require('fbjs/lib/invariant');
+
+class AnimatedProps extends AnimatedNode {
+  _props: Object;
+  _animatedView: any;
+  _callback: () => void;
+
+  constructor(props: Object, callback: () => void) {
+    super();
+    if (props.style) {
+      props = {
+        ...props,
+        style: new AnimatedStyle(props.style),
+      };
+    }
+    this._props = props;
+    this._callback = callback;
+    this.__attach();
+  }
+
+  __getValue(): Object {
+    const props = {};
+    for (const key in this._props) {
+      const value = this._props[key];
+      if (value instanceof AnimatedNode) {
+        if (!value.__isNative || value instanceof AnimatedStyle) {
+          // We cannot use value of natively driven nodes this way as the value we have access from
+          // JS may not be up to date.
+          props[key] = value.__getValue();
+        }
+      } else if (value instanceof AnimatedEvent) {
+        props[key] = value.__getHandler();
+      } else {
+        props[key] = value;
+      }
+    }
+    return props;
+  }
+
+  __getAnimatedValue(): Object {
+    const props = {};
+    for (const key in this._props) {
+      const value = this._props[key];
+      if (value instanceof AnimatedNode) {
+        props[key] = value.__getAnimatedValue();
+      }
+    }
+    return props;
+  }
+
+  __attach(): void {
+    for (const key in this._props) {
+      const value = this._props[key];
+      if (value instanceof AnimatedNode) {
+        value.__addChild(this);
+      }
+    }
+  }
+
+  __detach(): void {
+    if (this.__isNative && this._animatedView) {
+      this.__disconnectAnimatedView();
+    }
+    for (const key in this._props) {
+      const value = this._props[key];
+      if (value instanceof AnimatedNode) {
+        value.__removeChild(this);
+      }
+    }
+    super.__detach();
+  }
+
+  update(): void {
+    this._callback();
+  }
+
+  __makeNative(): void {
+    if (!this.__isNative) {
+      this.__isNative = true;
+      for (const key in this._props) {
+        const value = this._props[key];
+        if (value instanceof AnimatedNode) {
+          value.__makeNative();
+        }
+      }
+      if (this._animatedView) {
+        this.__connectAnimatedView();
+      }
+    }
+  }
+
+  setNativeView(animatedView: any): void {
+    if (this._animatedView === animatedView) {
+      return;
+    }
+    this._animatedView = animatedView;
+    if (this.__isNative) {
+      this.__connectAnimatedView();
+    }
+  }
+
+  __connectAnimatedView(): void {
+    invariant(this.__isNative, 'Expected node to be marked as "native"');
+    const nativeViewTag: ?number = ReactNative.findNodeHandle(
+      this._animatedView,
+    );
+    invariant(
+      nativeViewTag != null,
+      'Unable to locate attached view in the native tree',
+    );
+    NativeAnimatedHelper.API.connectAnimatedNodeToView(
+      this.__getNativeTag(),
+      nativeViewTag,
+    );
+  }
+
+  __disconnectAnimatedView(): void {
+    invariant(this.__isNative, 'Expected node to be marked as "native"');
+    const nativeViewTag: ?number = ReactNative.findNodeHandle(
+      this._animatedView,
+    );
+    invariant(
+      nativeViewTag != null,
+      'Unable to locate attached view in the native tree',
+    );
+    NativeAnimatedHelper.API.disconnectAnimatedNodeFromView(
+      this.__getNativeTag(),
+      nativeViewTag,
+    );
+  }
+
+  __getNativeConfig(): Object {
+    const propsConfig = {};
+    for (const propKey in this._props) {
+      const value = this._props[propKey];
+      if (value instanceof AnimatedNode) {
+        propsConfig[propKey] = value.__getNativeTag();
+      }
+    }
+    return {
+      type: 'props',
+      props: propsConfig,
+    };
+  }
+}
+
+module.exports = AnimatedProps;

node_modules/react-native/Libraries/Animated/src/nodes/AnimatedStyle.js

@@ -0,0 +1,125 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule AnimatedStyle
+ * @flow
+ * @format
+ */
+'use strict';
+
+const AnimatedNode = require('./AnimatedNode');
+const AnimatedTransform = require('./AnimatedTransform');
+const AnimatedWithChildren = require('./AnimatedWithChildren');
+const NativeAnimatedHelper = require('../NativeAnimatedHelper');
+
+const flattenStyle = require('flattenStyle');
+
+class AnimatedStyle extends AnimatedWithChildren {
+  _style: Object;
+
+  constructor(style: any) {
+    super();
+    style = flattenStyle(style) || {};
+    if (style.transform) {
+      style = {
+        ...style,
+        transform: new AnimatedTransform(style.transform),
+      };
+    }
+    this._style = style;
+  }
+
+  // Recursively get values for nested styles (like iOS's shadowOffset)
+  _walkStyleAndGetValues(style) {
+    const updatedStyle = {};
+    for (const key in style) {
+      const value = style[key];
+      if (value instanceof AnimatedNode) {
+        if (!value.__isNative) {
+          // We cannot use value of natively driven nodes this way as the value we have access from
+          // JS may not be up to date.
+          updatedStyle[key] = value.__getValue();
+        }
+      } else if (value && !Array.isArray(value) && typeof value === 'object') {
+        // Support animating nested values (for example: shadowOffset.height)
+        updatedStyle[key] = this._walkStyleAndGetValues(value);
+      } else {
+        updatedStyle[key] = value;
+      }
+    }
+    return updatedStyle;
+  }
+
+  __getValue(): Object {
+    return this._walkStyleAndGetValues(this._style);
+  }
+
+  // Recursively get animated values for nested styles (like iOS's shadowOffset)
+  _walkStyleAndGetAnimatedValues(style) {
+    const updatedStyle = {};
+    for (const key in style) {
+      const value = style[key];
+      if (value instanceof AnimatedNode) {
+        updatedStyle[key] = value.__getAnimatedValue();
+      } else if (value && !Array.isArray(value) && typeof value === 'object') {
+        // Support animating nested values (for example: shadowOffset.height)
+        updatedStyle[key] = this._walkStyleAndGetAnimatedValues(value);
+      }
+    }
+    return updatedStyle;
+  }
+
+  __getAnimatedValue(): Object {
+    return this._walkStyleAndGetAnimatedValues(this._style);
+  }
+
+  __attach(): void {
+    for (const key in this._style) {
+      const value = this._style[key];
+      if (value instanceof AnimatedNode) {
+        value.__addChild(this);
+      }
+    }
+  }
+
+  __detach(): void {
+    for (const key in this._style) {
+      const value = this._style[key];
+      if (value instanceof AnimatedNode) {
+        value.__removeChild(this);
+      }
+    }
+    super.__detach();
+  }
+
+  __makeNative() {
+    super.__makeNative();
+    for (const key in this._style) {
+      const value = this._style[key];
+      if (value instanceof AnimatedNode) {
+        value.__makeNative();
+      }
+    }
+  }
+
+  __getNativeConfig(): Object {
+    const styleConfig = {};
+    for (const styleKey in this._style) {
+      if (this._style[styleKey] instanceof AnimatedNode) {
+        styleConfig[styleKey] = this._style[styleKey].__getNativeTag();
+      }
+      // Non-animated styles are set using `setNativeProps`, no need
+      // to pass those as a part of the node config
+    }
+    NativeAnimatedHelper.validateStyles(styleConfig);
+    return {
+      type: 'style',
+      style: styleConfig,
+    };
+  }
+}
+
+module.exports = AnimatedStyle;

node_modules/react-native/Libraries/Animated/src/nodes/AnimatedTracking.js

@@ -0,0 +1,102 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule AnimatedTracking
+ * @flow
+ * @format
+ */
+'use strict';
+
+const AnimatedValue = require('./AnimatedValue');
+const AnimatedNode = require('./AnimatedNode');
+const {
+  generateNewAnimationId,
+  shouldUseNativeDriver,
+} = require('../NativeAnimatedHelper');
+
+import type {EndCallback} from '../animations/Animation';
+
+class AnimatedTracking extends AnimatedNode {
+  _value: AnimatedValue;
+  _parent: AnimatedNode;
+  _callback: ?EndCallback;
+  _animationConfig: Object;
+  _animationClass: any;
+  _useNativeDriver: boolean;
+
+  constructor(
+    value: AnimatedValue,
+    parent: AnimatedNode,
+    animationClass: any,
+    animationConfig: Object,
+    callback?: ?EndCallback,
+  ) {
+    super();
+    this._value = value;
+    this._parent = parent;
+    this._animationClass = animationClass;
+    this._animationConfig = animationConfig;
+    this._useNativeDriver = shouldUseNativeDriver(animationConfig);
+    this._callback = callback;
+    this.__attach();
+  }
+
+  __makeNative() {
+    this.__isNative = true;
+    this._parent.__makeNative();
+    super.__makeNative();
+    this._value.__makeNative();
+  }
+
+  __getValue(): Object {
+    return this._parent.__getValue();
+  }
+
+  __attach(): void {
+    this._parent.__addChild(this);
+    if (this._useNativeDriver) {
+      // when the tracking starts we need to convert this node to a "native node"
+      // so that the parent node will be made "native" too. This is necessary as
+      // if we don't do this `update` method will get called. At that point it
+      // may be too late as it would mean the JS driver has already started
+      // updating node values
+      this.__makeNative();
+    }
+  }
+
+  __detach(): void {
+    this._parent.__removeChild(this);
+    super.__detach();
+  }
+
+  update(): void {
+    this._value.animate(
+      new this._animationClass({
+        ...this._animationConfig,
+        toValue: (this._animationConfig.toValue: any).__getValue(),
+      }),
+      this._callback,
+    );
+  }
+
+  __getNativeConfig(): any {
+    const animation = new this._animationClass({
+      ...this._animationConfig,
+      // remove toValue from the config as it's a ref to Animated.Value
+      toValue: undefined,
+    });
+    const animationConfig = animation.__getNativeAnimationConfig();
+    return {
+      type: 'tracking',
+      animationId: generateNewAnimationId(),
+      animationConfig,
+      toValue: this._parent.__getNativeTag(),
+      value: this._value.__getNativeTag(),
+    };
+  }
+}
+
+module.exports = AnimatedTracking;

node_modules/react-native/Libraries/Animated/src/nodes/AnimatedTransform.js

@@ -0,0 +1,121 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule AnimatedTransform
+ * @flow
+ * @format
+ */
+'use strict';
+
+const AnimatedNode = require('./AnimatedNode');
+const AnimatedWithChildren = require('./AnimatedWithChildren');
+const NativeAnimatedHelper = require('../NativeAnimatedHelper');
+
+class AnimatedTransform extends AnimatedWithChildren {
+  _transforms: $ReadOnlyArray<Object>;
+
+  constructor(transforms: $ReadOnlyArray<Object>) {
+    super();
+    this._transforms = transforms;
+  }
+
+  __makeNative() {
+    super.__makeNative();
+    this._transforms.forEach(transform => {
+      for (const key in transform) {
+        const value = transform[key];
+        if (value instanceof AnimatedNode) {
+          value.__makeNative();
+        }
+      }
+    });
+  }
+
+  __getValue(): $ReadOnlyArray<Object> {
+    return this._transforms.map(transform => {
+      const result = {};
+      for (const key in transform) {
+        const value = transform[key];
+        if (value instanceof AnimatedNode) {
+          result[key] = value.__getValue();
+        } else {
+          result[key] = value;
+        }
+      }
+      return result;
+    });
+  }
+
+  __getAnimatedValue(): $ReadOnlyArray<Object> {
+    return this._transforms.map(transform => {
+      const result = {};
+      for (const key in transform) {
+        const value = transform[key];
+        if (value instanceof AnimatedNode) {
+          result[key] = value.__getAnimatedValue();
+        } else {
+          // All transform components needed to recompose matrix
+          result[key] = value;
+        }
+      }
+      return result;
+    });
+  }
+
+  __attach(): void {
+    this._transforms.forEach(transform => {
+      for (const key in transform) {
+        const value = transform[key];
+        if (value instanceof AnimatedNode) {
+          value.__addChild(this);
+        }
+      }
+    });
+  }
+
+  __detach(): void {
+    this._transforms.forEach(transform => {
+      for (const key in transform) {
+        const value = transform[key];
+        if (value instanceof AnimatedNode) {
+          value.__removeChild(this);
+        }
+      }
+    });
+    super.__detach();
+  }
+
+  __getNativeConfig(): any {
+    const transConfigs = [];
+
+    this._transforms.forEach(transform => {
+      for (const key in transform) {
+        const value = transform[key];
+        if (value instanceof AnimatedNode) {
+          transConfigs.push({
+            type: 'animated',
+            property: key,
+            nodeTag: value.__getNativeTag(),
+          });
+        } else {
+          transConfigs.push({
+            type: 'static',
+            property: key,
+            value,
+          });
+        }
+      }
+    });
+
+    NativeAnimatedHelper.validateTransform(transConfigs);
+    return {
+      type: 'transform',
+      transforms: transConfigs,
+    };
+  }
+}
+
+module.exports = AnimatedTransform;

node_modules/react-native/Libraries/Animated/src/nodes/AnimatedValue.js

@@ -0,0 +1,337 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule AnimatedValue
+ * @flow
+ * @format
+ */
+'use strict';
+
+const AnimatedInterpolation = require('./AnimatedInterpolation');
+const AnimatedNode = require('./AnimatedNode');
+const AnimatedWithChildren = require('./AnimatedWithChildren');
+const InteractionManager = require('InteractionManager');
+const NativeAnimatedHelper = require('../NativeAnimatedHelper');
+
+import type Animation, {EndCallback} from '../animations/Animation';
+import type {InterpolationConfigType} from './AnimatedInterpolation';
+import type AnimatedTracking from './AnimatedTracking';
+
+const NativeAnimatedAPI = NativeAnimatedHelper.API;
+
+type ValueListenerCallback = (state: {value: number}) => void;
+
+let _uniqueId = 1;
+
+/**
+ * Animated works by building a directed acyclic graph of dependencies
+ * transparently when you render your Animated components.
+ *
+ *               new Animated.Value(0)
+ *     .interpolate()        .interpolate()    new Animated.Value(1)
+ *         opacity               translateY      scale
+ *          style                         transform
+ *         View#234                         style
+ *                                         View#123
+ *
+ * A) Top Down phase
+ * When an Animated.Value is updated, we recursively go down through this
+ * graph in order to find leaf nodes: the views that we flag as needing
+ * an update.
+ *
+ * B) Bottom Up phase
+ * When a view is flagged as needing an update, we recursively go back up
+ * in order to build the new value that it needs. The reason why we need
+ * this two-phases process is to deal with composite props such as
+ * transform which can receive values from multiple parents.
+ */
+function _flush(rootNode: AnimatedValue): void {
+  const animatedStyles = new Set();
+  function findAnimatedStyles(node) {
+    if (typeof node.update === 'function') {
+      animatedStyles.add(node);
+    } else {
+      node.__getChildren().forEach(findAnimatedStyles);
+    }
+  }
+  findAnimatedStyles(rootNode);
+  /* $FlowFixMe */
+  animatedStyles.forEach(animatedStyle => animatedStyle.update());
+}
+
+/**
+ * Standard value for driving animations.  One `Animated.Value` can drive
+ * multiple properties in a synchronized fashion, but can only be driven by one
+ * mechanism at a time.  Using a new mechanism (e.g. starting a new animation,
+ * or calling `setValue`) will stop any previous ones.
+ *
+ * See http://facebook.github.io/react-native/docs/animatedvalue.html
+ */
+class AnimatedValue extends AnimatedWithChildren {
+  _value: number;
+  _startingValue: number;
+  _offset: number;
+  _animation: ?Animation;
+  _tracking: ?AnimatedTracking;
+  _listeners: {[key: string]: ValueListenerCallback};
+  __nativeAnimatedValueListener: ?any;
+
+  constructor(value: number) {
+    super();
+    this._startingValue = this._value = value;
+    this._offset = 0;
+    this._animation = null;
+    this._listeners = {};
+  }
+
+  __detach() {
+    this.stopAnimation();
+    super.__detach();
+  }
+
+  __getValue(): number {
+    return this._value + this._offset;
+  }
+
+  __makeNative() {
+    super.__makeNative();
+
+    if (Object.keys(this._listeners).length) {
+      this._startListeningToNativeValueUpdates();
+    }
+  }
+
+  /**
+   * Directly set the value.  This will stop any animations running on the value
+   * and update all the bound properties.
+   *
+   * See http://facebook.github.io/react-native/docs/animatedvalue.html#setvalue
+   */
+  setValue(value: number): void {
+    if (this._animation) {
+      this._animation.stop();
+      this._animation = null;
+    }
+    this._updateValue(
+      value,
+      !this.__isNative /* don't perform a flush for natively driven values */,
+    );
+    if (this.__isNative) {
+      NativeAnimatedAPI.setAnimatedNodeValue(this.__getNativeTag(), value);
+    }
+  }
+
+  /**
+   * Sets an offset that is applied on top of whatever value is set, whether via
+   * `setValue`, an animation, or `Animated.event`.  Useful for compensating
+   * things like the start of a pan gesture.
+   *
+   * See http://facebook.github.io/react-native/docs/animatedvalue.html#setoffset
+   */
+  setOffset(offset: number): void {
+    this._offset = offset;
+    if (this.__isNative) {
+      NativeAnimatedAPI.setAnimatedNodeOffset(this.__getNativeTag(), offset);
+    }
+  }
+
+  /**
+   * Merges the offset value into the base value and resets the offset to zero.
+   * The final output of the value is unchanged.
+   *
+   * See http://facebook.github.io/react-native/docs/animatedvalue.html#flattenoffset
+   */
+  flattenOffset(): void {
+    this._value += this._offset;
+    this._offset = 0;
+    if (this.__isNative) {
+      NativeAnimatedAPI.flattenAnimatedNodeOffset(this.__getNativeTag());
+    }
+  }
+
+  /**
+   * Sets the offset value to the base value, and resets the base value to zero.
+   * The final output of the value is unchanged.
+   *
+   * See http://facebook.github.io/react-native/docs/animatedvalue.html#extractoffset
+   */
+  extractOffset(): void {
+    this._offset += this._value;
+    this._value = 0;
+    if (this.__isNative) {
+      NativeAnimatedAPI.extractAnimatedNodeOffset(this.__getNativeTag());
+    }
+  }
+
+  /**
+   * Adds an asynchronous listener to the value so you can observe updates from
+   * animations.  This is useful because there is no way to
+   * synchronously read the value because it might be driven natively.
+   *
+   * See http://facebook.github.io/react-native/docs/animatedvalue.html#addlistener
+   */
+  addListener(callback: ValueListenerCallback): string {
+    const id = String(_uniqueId++);
+    this._listeners[id] = callback;
+    if (this.__isNative) {
+      this._startListeningToNativeValueUpdates();
+    }
+    return id;
+  }
+
+  /**
+   * Unregister a listener. The `id` param shall match the identifier
+   * previously returned by `addListener()`.
+   *
+   * See http://facebook.github.io/react-native/docs/animatedvalue.html#removelistener
+   */
+  removeListener(id: string): void {
+    delete this._listeners[id];
+    if (this.__isNative && Object.keys(this._listeners).length === 0) {
+      this._stopListeningForNativeValueUpdates();
+    }
+  }
+
+  /**
+   * Remove all registered listeners.
+   *
+   * See http://facebook.github.io/react-native/docs/animatedvalue.html#removealllisteners
+   */
+  removeAllListeners(): void {
+    this._listeners = {};
+    if (this.__isNative) {
+      this._stopListeningForNativeValueUpdates();
+    }
+  }
+
+  _startListeningToNativeValueUpdates() {
+    if (this.__nativeAnimatedValueListener) {
+      return;
+    }
+
+    NativeAnimatedAPI.startListeningToAnimatedNodeValue(this.__getNativeTag());
+    this.__nativeAnimatedValueListener = NativeAnimatedHelper.nativeEventEmitter.addListener(
+      'onAnimatedValueUpdate',
+      data => {
+        if (data.tag !== this.__getNativeTag()) {
+          return;
+        }
+        this._updateValue(data.value, false /* flush */);
+      },
+    );
+  }
+
+  _stopListeningForNativeValueUpdates() {
+    if (!this.__nativeAnimatedValueListener) {
+      return;
+    }
+
+    this.__nativeAnimatedValueListener.remove();
+    this.__nativeAnimatedValueListener = null;
+    NativeAnimatedAPI.stopListeningToAnimatedNodeValue(this.__getNativeTag());
+  }
+
+  /**
+   * Stops any running animation or tracking. `callback` is invoked with the
+   * final value after stopping the animation, which is useful for updating
+   * state to match the animation position with layout.
+   *
+   * See http://facebook.github.io/react-native/docs/animatedvalue.html#stopanimation
+   */
+  stopAnimation(callback?: ?(value: number) => void): void {
+    this.stopTracking();
+    this._animation && this._animation.stop();
+    this._animation = null;
+    callback && callback(this.__getValue());
+  }
+
+  /**
+   * Stops any animation and resets the value to its original.
+   *
+   * See http://facebook.github.io/react-native/docs/animatedvalue.html#resetanimation
+   */
+  resetAnimation(callback?: ?(value: number) => void): void {
+    this.stopAnimation(callback);
+    this._value = this._startingValue;
+  }
+
+  /**
+   * Interpolates the value before updating the property, e.g. mapping 0-1 to
+   * 0-10.
+   */
+  interpolate(config: InterpolationConfigType): AnimatedInterpolation {
+    return new AnimatedInterpolation(this, config);
+  }
+
+  /**
+   * Typically only used internally, but could be used by a custom Animation
+   * class.
+   *
+   * See http://facebook.github.io/react-native/docs/animatedvalue.html#animate
+   */
+  animate(animation: Animation, callback: ?EndCallback): void {
+    let handle = null;
+    if (animation.__isInteraction) {
+      handle = InteractionManager.createInteractionHandle();
+    }
+    const previousAnimation = this._animation;
+    this._animation && this._animation.stop();
+    this._animation = animation;
+    animation.start(
+      this._value,
+      value => {
+        // Natively driven animations will never call into that callback, therefore we can always
+        // pass flush = true to allow the updated value to propagate to native with setNativeProps
+        this._updateValue(value, true /* flush */);
+      },
+      result => {
+        this._animation = null;
+        if (handle !== null) {
+          InteractionManager.clearInteractionHandle(handle);
+        }
+        callback && callback(result);
+      },
+      previousAnimation,
+      this,
+    );
+  }
+
+  /**
+   * Typically only used internally.
+   */
+  stopTracking(): void {
+    this._tracking && this._tracking.__detach();
+    this._tracking = null;
+  }
+
+  /**
+   * Typically only used internally.
+   */
+  track(tracking: AnimatedTracking): void {
+    this.stopTracking();
+    this._tracking = tracking;
+  }
+
+  _updateValue(value: number, flush: boolean): void {
+    this._value = value;
+    if (flush) {
+      _flush(this);
+    }
+    for (const key in this._listeners) {
+      this._listeners[key]({value: this.__getValue()});
+    }
+  }
+
+  __getNativeConfig(): Object {
+    return {
+      type: 'value',
+      value: this._value,
+      offset: this._offset,
+    };
+  }
+}
+
+module.exports = AnimatedValue;

node_modules/react-native/Libraries/Animated/src/nodes/AnimatedValueXY.js

@@ -0,0 +1,195 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule AnimatedValueXY
+ * @flow
+ * @format
+ */
+'use strict';
+
+const AnimatedValue = require('./AnimatedValue');
+const AnimatedWithChildren = require('./AnimatedWithChildren');
+
+const invariant = require('fbjs/lib/invariant');
+
+type ValueXYListenerCallback = (value: {x: number, y: number}) => void;
+
+let _uniqueId = 1;
+
+/**
+ * 2D Value for driving 2D animations, such as pan gestures. Almost identical
+ * API to normal `Animated.Value`, but multiplexed.
+ *
+ * See http://facebook.github.io/react-native/docs/animatedvaluexy.html
+ */
+class AnimatedValueXY extends AnimatedWithChildren {
+  x: AnimatedValue;
+  y: AnimatedValue;
+  _listeners: {[key: string]: {x: string, y: string}};
+
+  constructor(
+    valueIn?: ?{+x: number | AnimatedValue, +y: number | AnimatedValue},
+  ) {
+    super();
+    const value: any = valueIn || {x: 0, y: 0}; // @flowfixme: shouldn't need `: any`
+    if (typeof value.x === 'number' && typeof value.y === 'number') {
+      this.x = new AnimatedValue(value.x);
+      this.y = new AnimatedValue(value.y);
+    } else {
+      invariant(
+        value.x instanceof AnimatedValue && value.y instanceof AnimatedValue,
+        'AnimatedValueXY must be initialized with an object of numbers or ' +
+          'AnimatedValues.',
+      );
+      this.x = value.x;
+      this.y = value.y;
+    }
+    this._listeners = {};
+  }
+
+  /**
+   * Directly set the value. This will stop any animations running on the value
+   * and update all the bound properties.
+   *
+   * See http://facebook.github.io/react-native/docs/animatedvaluexy.html#setvalue
+   */
+  setValue(value: {x: number, y: number}) {
+    this.x.setValue(value.x);
+    this.y.setValue(value.y);
+  }
+
+  /**
+   * Sets an offset that is applied on top of whatever value is set, whether
+   * via `setValue`, an animation, or `Animated.event`. Useful for compensating
+   * things like the start of a pan gesture.
+   *
+   * See http://facebook.github.io/react-native/docs/animatedvaluexy.html#setoffset
+   */
+  setOffset(offset: {x: number, y: number}) {
+    this.x.setOffset(offset.x);
+    this.y.setOffset(offset.y);
+  }
+
+  /**
+   * Merges the offset value into the base value and resets the offset to zero.
+   * The final output of the value is unchanged.
+   *
+   * See http://facebook.github.io/react-native/docs/animatedvaluexy.html#flattenoffset
+   */
+  flattenOffset(): void {
+    this.x.flattenOffset();
+    this.y.flattenOffset();
+  }
+
+  /**
+   * Sets the offset value to the base value, and resets the base value to
+   * zero. The final output of the value is unchanged.
+   *
+   * See http://facebook.github.io/react-native/docs/animatedvaluexy.html#extractoffset
+   */
+  extractOffset(): void {
+    this.x.extractOffset();
+    this.y.extractOffset();
+  }
+
+  __getValue(): {x: number, y: number} {
+    return {
+      x: this.x.__getValue(),
+      y: this.y.__getValue(),
+    };
+  }
+
+  /**
+   * Stops any animation and resets the value to its original.
+   *
+   * See http://facebook.github.io/react-native/docs/animatedvaluexy.html#resetanimation
+   */
+  resetAnimation(callback?: (value: {x: number, y: number}) => void): void {
+    this.x.resetAnimation();
+    this.y.resetAnimation();
+    callback && callback(this.__getValue());
+  }
+
+  /**
+   * Stops any running animation or tracking. `callback` is invoked with the
+   * final value after stopping the animation, which is useful for updating
+   * state to match the animation position with layout.
+   *
+   * See http://facebook.github.io/react-native/docs/animatedvaluexy.html#stopanimation
+   */
+  stopAnimation(callback?: (value: {x: number, y: number}) => void): void {
+    this.x.stopAnimation();
+    this.y.stopAnimation();
+    callback && callback(this.__getValue());
+  }
+
+  /**
+   * Adds an asynchronous listener to the value so you can observe updates from
+   * animations.  This is useful because there is no way to synchronously read
+   * the value because it might be driven natively.
+   *
+   * Returns a string that serves as an identifier for the listener.
+   *
+   * See http://facebook.github.io/react-native/docs/animatedvaluexy.html#addlistener
+   */
+  addListener(callback: ValueXYListenerCallback): string {
+    const id = String(_uniqueId++);
+    const jointCallback = ({value: number}) => {
+      callback(this.__getValue());
+    };
+    this._listeners[id] = {
+      x: this.x.addListener(jointCallback),
+      y: this.y.addListener(jointCallback),
+    };
+    return id;
+  }
+
+  /**
+   * Unregister a listener. The `id` param shall match the identifier
+   * previously returned by `addListener()`.
+   *
+   * See http://facebook.github.io/react-native/docs/animatedvaluexy.html#removelistener
+   */
+  removeListener(id: string): void {
+    this.x.removeListener(this._listeners[id].x);
+    this.y.removeListener(this._listeners[id].y);
+    delete this._listeners[id];
+  }
+
+  /**
+   * Remove all registered listeners.
+   *
+   * See http://facebook.github.io/react-native/docs/animatedvaluexy.html#removealllisteners
+   */
+  removeAllListeners(): void {
+    this.x.removeAllListeners();
+    this.y.removeAllListeners();
+    this._listeners = {};
+  }
+
+  /**
+   * Converts `{x, y}` into `{left, top}` for use in style.
+   *
+   * See http://facebook.github.io/react-native/docs/animatedvaluexy.html#getlayout
+   */
+  getLayout(): {[key: string]: AnimatedValue} {
+    return {
+      left: this.x,
+      top: this.y,
+    };
+  }
+
+  /**
+   * Converts `{x, y}` into a useable translation transform.
+   *
+   * See http://facebook.github.io/react-native/docs/animatedvaluexy.html#gettranslatetransform
+   */
+  getTranslateTransform(): Array<{[key: string]: AnimatedValue}> {
+    return [{translateX: this.x}, {translateY: this.y}];
+  }
+}
+
+module.exports = AnimatedValueXY;

node_modules/react-native/Libraries/Animated/src/nodes/AnimatedWithChildren.js

@@ -0,0 +1,75 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule AnimatedWithChildren
+ * @flow
+ * @format
+ */
+'use strict';
+
+const AnimatedNode = require('./AnimatedNode');
+const NativeAnimatedHelper = require('../NativeAnimatedHelper');
+
+class AnimatedWithChildren extends AnimatedNode {
+  _children: Array<AnimatedNode>;
+
+  constructor() {
+    super();
+    this._children = [];
+  }
+
+  __makeNative() {
+    if (!this.__isNative) {
+      this.__isNative = true;
+      for (const child of this._children) {
+        child.__makeNative();
+        NativeAnimatedHelper.API.connectAnimatedNodes(
+          this.__getNativeTag(),
+          child.__getNativeTag(),
+        );
+      }
+    }
+  }
+
+  __addChild(child: AnimatedNode): void {
+    if (this._children.length === 0) {
+      this.__attach();
+    }
+    this._children.push(child);
+    if (this.__isNative) {
+      // Only accept "native" animated nodes as children
+      child.__makeNative();
+      NativeAnimatedHelper.API.connectAnimatedNodes(
+        this.__getNativeTag(),
+        child.__getNativeTag(),
+      );
+    }
+  }
+
+  __removeChild(child: AnimatedNode): void {
+    const index = this._children.indexOf(child);
+    if (index === -1) {
+      console.warn("Trying to remove a child that doesn't exist");
+      return;
+    }
+    if (this.__isNative && child.__isNative) {
+      NativeAnimatedHelper.API.disconnectAnimatedNodes(
+        this.__getNativeTag(),
+        child.__getNativeTag(),
+      );
+    }
+    this._children.splice(index, 1);
+    if (this._children.length === 0) {
+      this.__detach();
+    }
+  }
+
+  __getChildren(): Array<AnimatedNode> {
+    return this._children;
+  }
+}
+
+module.exports = AnimatedWithChildren;

node_modules/react-native/Libraries/Animated/src/polyfills/InteractionManager.js

@@ -0,0 +1,13 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+'use strict';
+
+module.exports = {
+  createInteractionHandle: function() {},
+  clearInteractionHandle: function() {}
+};

node_modules/react-native/Libraries/Animated/src/polyfills/Set.js

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+'use strict';
+
+function SetPolyfill() {
+  this._cache = [];
+}
+
+SetPolyfill.prototype.add = function(e) {
+  if (this._cache.indexOf(e) === -1) {
+    this._cache.push(e);
+  }
+};
+
+SetPolyfill.prototype.forEach = function(cb) {
+  this._cache.forEach(cb);
+};
+
+module.exports = SetPolyfill;

node_modules/react-native/Libraries/Animated/src/polyfills/flattenStyle.js

@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+module.exports = function(style) {
+  return style;
+};

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

@@ -0,0 +1,155 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule AppState
+ * @flow
+ */
+'use strict';
+
+const MissingNativeEventEmitterShim = require('MissingNativeEventEmitterShim');
+const NativeEventEmitter = require('NativeEventEmitter');
+const NativeModules = require('NativeModules');
+const RCTAppState = NativeModules.AppState;
+
+const logError = require('logError');
+const invariant = require('fbjs/lib/invariant');
+
+/**
+ * `AppState` can tell you if the app is in the foreground or background,
+ * and notify you when the state changes.
+ *
+ * See http://facebook.github.io/react-native/docs/appstate.html
+ */
+class AppState extends NativeEventEmitter {
+
+  _eventHandlers: Object;
+  currentState: ?string;
+  isAvailable: boolean = true;
+
+  constructor() {
+    super(RCTAppState);
+
+    this.isAvailable = true;
+    this._eventHandlers = {
+      change: new Map(),
+      memoryWarning: new Map(),
+    };
+
+    // TODO: Remove the 'active' fallback after `initialAppState` is exported by
+    // the Android implementation.
+    this.currentState = RCTAppState.initialAppState || 'active';
+
+    let eventUpdated = false;
+
+    // TODO: this is a terrible solution - in order to ensure `currentState`
+    // prop is up to date, we have to register an observer that updates it
+    // whenever the state changes, even if nobody cares. We should just
+    // deprecate the `currentState` property and get rid of this.
+    this.addListener(
+      'appStateDidChange',
+      (appStateData) => {
+        eventUpdated = true;
+        this.currentState = appStateData.app_state;
+      }
+    );
+
+    // TODO: see above - this request just populates the value of `currentState`
+    // when the module is first initialized. Would be better to get rid of the
+    // prop and expose `getCurrentAppState` method directly.
+    RCTAppState.getCurrentAppState(
+      (appStateData) => {
+        if (!eventUpdated) {
+          this.currentState = appStateData.app_state;
+        }
+      },
+      logError
+    );
+  }
+
+  // TODO: now that AppState is a subclass of NativeEventEmitter, we could
+  // deprecate `addEventListener` and `removeEventListener` and just use
+  // addListener` and `listener.remove()` directly. That will be a breaking
+  // change though, as both the method and event names are different
+  // (addListener events are currently required to be globally unique).
+   /**
+   * Add a handler to AppState changes by listening to the `change` event type
+   * and providing the handler.
+   *
+   * See http://facebook.github.io/react-native/docs/appstate.html#addeventlistener
+   */
+  addEventListener(
+    type: string,
+    handler: Function
+  ) {
+    invariant(
+      ['change', 'memoryWarning'].indexOf(type) !== -1,
+      'Trying to subscribe to unknown event: "%s"', type
+    );
+    if (type === 'change') {
+      this._eventHandlers[type].set(handler, this.addListener(
+        'appStateDidChange',
+        (appStateData) => {
+          handler(appStateData.app_state);
+        }
+      ));
+    } else if (type === 'memoryWarning') {
+      this._eventHandlers[type].set(handler, this.addListener(
+        'memoryWarning',
+        handler
+      ));
+    }
+  }
+
+  /**
+   * Remove a handler by passing the `change` event type and the handler.
+   *
+   * See http://facebook.github.io/react-native/docs/appstate.html#removeeventlistener
+   */
+  removeEventListener(
+    type: string,
+    handler: Function
+  ) {
+    invariant(
+      ['change', 'memoryWarning'].indexOf(type) !== -1,
+      'Trying to remove listener for unknown event: "%s"', type
+    );
+    if (!this._eventHandlers[type].has(handler)) {
+      return;
+    }
+    this._eventHandlers[type].get(handler).remove();
+    this._eventHandlers[type].delete(handler);
+  }
+}
+
+if (__DEV__ && !RCTAppState) {
+  class MissingNativeAppStateShim extends MissingNativeEventEmitterShim {
+    constructor() {
+      super('RCTAppState', 'AppState');
+    }
+
+    get currentState(): ?string {
+      this.throwMissingNativeModule();
+    }
+
+    addEventListener(...args: Array<any>) {
+      this.throwMissingNativeModule();
+    }
+
+    removeEventListener(...args: Array<any>) {
+      this.throwMissingNativeModule();
+    }
+  }
+
+  // This module depends on the native `RCTAppState` module. If you don't
+  // include it, `AppState.isAvailable` will return `false`, and any method
+  // calls will throw. We reassign the class variable to keep the autodoc
+  // generator happy.
+  AppState = new MissingNativeAppStateShim();
+} else {
+  AppState = new AppState();
+}
+
+module.exports = AppState;

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

@@ -0,0 +1,40 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule BatchedBridge
+ * @flow
+ */
+'use strict';
+
+const MessageQueue = require('MessageQueue');
+
+// MessageQueue can install a global handler to catch all exceptions where JS users can register their own behavior
+// This handler makes all exceptions to be handled inside MessageQueue rather than by the VM at its origin
+// This makes stacktraces to be placed at MessageQueue rather than at where they were launched
+// The parameter __fbUninstallRNGlobalErrorHandler is passed to MessageQueue to prevent the handler from being installed
+//
+// __fbUninstallRNGlobalErrorHandler is conditionally set by the Inspector while the VM is paused for initialization
+// If the Inspector isn't present it defaults to undefined and the global error handler is installed
+// The Inspector can still call MessageQueue#uninstallGlobalErrorHandler to uninstalled on attach
+
+const BatchedBridge = new MessageQueue(
+  // $FlowFixMe
+  typeof __fbUninstallRNGlobalErrorHandler !== 'undefined' &&
+    __fbUninstallRNGlobalErrorHandler === true, // eslint-disable-line no-undef
+);
+
+// Wire up the batched bridge on the global object so that we can call into it.
+// Ideally, this would be the inverse relationship. I.e. the native environment
+// provides this global directly with its script embedded. Then this module
+// would export it. A possible fix would be to trim the dependencies in
+// MessageQueue to its minimal features and embed that in the native runtime.
+
+Object.defineProperty(global, '__fbBatchedBridge', {
+  configurable: true,
+  value: BatchedBridge,
+});
+
+module.exports = BatchedBridge;

node_modules/react-native/Libraries/BatchedBridge/MessageQueue.js

@@ -0,0 +1,406 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule MessageQueue
+ * @flow
+ * @format
+ */
+
+'use strict';
+
+const ErrorUtils = require('ErrorUtils');
+const Systrace = require('Systrace');
+
+const deepFreezeAndThrowOnMutationInDev = require('deepFreezeAndThrowOnMutationInDev');
+const invariant = require('fbjs/lib/invariant');
+const stringifySafe = require('stringifySafe');
+
+export type SpyData = {
+  type: number,
+  module: ?string,
+  method: string | number,
+  args: any[],
+};
+
+const TO_JS = 0;
+const TO_NATIVE = 1;
+
+const MODULE_IDS = 0;
+const METHOD_IDS = 1;
+const PARAMS = 2;
+const MIN_TIME_BETWEEN_FLUSHES_MS = 5;
+
+// eslint-disable-next-line no-bitwise
+const TRACE_TAG_REACT_APPS = 1 << 17;
+
+const DEBUG_INFO_LIMIT = 32;
+
+// Work around an initialization order issue
+let JSTimers = null;
+
+class MessageQueue {
+  _lazyCallableModules: {[key: string]: (void) => Object};
+  _queue: [number[], number[], any[], number];
+  _successCallbacks: (?Function)[];
+  _failureCallbacks: (?Function)[];
+  _callID: number;
+  _inCall: number;
+  _lastFlush: number;
+  _eventLoopStartTime: number;
+
+  _debugInfo: {[number]: [number, number]};
+  _remoteModuleTable: {[number]: string};
+  _remoteMethodTable: {[number]: string[]};
+
+  __spy: ?(data: SpyData) => void;
+
+  __guard: (() => void) => void;
+
+  constructor(shouldUninstallGlobalErrorHandler: boolean = false) {
+    this._lazyCallableModules = {};
+    this._queue = [[], [], [], 0];
+    this._successCallbacks = [];
+    this._failureCallbacks = [];
+    this._callID = 0;
+    this._lastFlush = 0;
+    this._eventLoopStartTime = new Date().getTime();
+    if (shouldUninstallGlobalErrorHandler) {
+      this.uninstallGlobalErrorHandler();
+    } else {
+      this.installGlobalErrorHandler();
+    }
+
+    if (__DEV__) {
+      this._debugInfo = {};
+      this._remoteModuleTable = {};
+      this._remoteMethodTable = {};
+    }
+
+    (this: any).callFunctionReturnFlushedQueue = this.callFunctionReturnFlushedQueue.bind(
+      this,
+    );
+    (this: any).callFunctionReturnResultAndFlushedQueue = this.callFunctionReturnResultAndFlushedQueue.bind(
+      this,
+    );
+    (this: any).flushedQueue = this.flushedQueue.bind(this);
+    (this: any).invokeCallbackAndReturnFlushedQueue = this.invokeCallbackAndReturnFlushedQueue.bind(
+      this,
+    );
+  }
+
+  /**
+   * Public APIs
+   */
+
+  static spy(spyOrToggle: boolean | ((data: SpyData) => void)) {
+    if (spyOrToggle === true) {
+      MessageQueue.prototype.__spy = info => {
+        console.log(
+          `${info.type === TO_JS ? 'N->JS' : 'JS->N'} : ` +
+            `${info.module ? info.module + '.' : ''}${info.method}` +
+            `(${JSON.stringify(info.args)})`,
+        );
+      };
+    } else if (spyOrToggle === false) {
+      MessageQueue.prototype.__spy = null;
+    } else {
+      MessageQueue.prototype.__spy = spyOrToggle;
+    }
+  }
+
+  callFunctionReturnFlushedQueue(module: string, method: string, args: any[]) {
+    this.__guard(() => {
+      this.__callFunction(module, method, args);
+    });
+
+    return this.flushedQueue();
+  }
+
+  callFunctionReturnResultAndFlushedQueue(
+    module: string,
+    method: string,
+    args: any[],
+  ) {
+    let result;
+    this.__guard(() => {
+      result = this.__callFunction(module, method, args);
+    });
+
+    return [result, this.flushedQueue()];
+  }
+
+  invokeCallbackAndReturnFlushedQueue(cbID: number, args: any[]) {
+    this.__guard(() => {
+      this.__invokeCallback(cbID, args);
+    });
+
+    return this.flushedQueue();
+  }
+
+  flushedQueue() {
+    this.__guard(() => {
+      this.__callImmediates();
+    });
+
+    const queue = this._queue;
+    this._queue = [[], [], [], this._callID];
+    return queue[0].length ? queue : null;
+  }
+
+  getEventLoopRunningTime() {
+    return new Date().getTime() - this._eventLoopStartTime;
+  }
+
+  registerCallableModule(name: string, module: Object) {
+    this._lazyCallableModules[name] = () => module;
+  }
+
+  registerLazyCallableModule(name: string, factory: void => Object) {
+    let module: Object;
+    let getValue: ?(void) => Object = factory;
+    this._lazyCallableModules[name] = () => {
+      if (getValue) {
+        module = getValue();
+        getValue = null;
+      }
+      return module;
+    };
+  }
+
+  getCallableModule(name: string) {
+    const getValue = this._lazyCallableModules[name];
+    return getValue ? getValue() : null;
+  }
+
+  enqueueNativeCall(
+    moduleID: number,
+    methodID: number,
+    params: any[],
+    onFail: ?Function,
+    onSucc: ?Function,
+  ) {
+    if (onFail || onSucc) {
+      if (__DEV__) {
+        this._debugInfo[this._callID] = [moduleID, methodID];
+        if (this._callID > DEBUG_INFO_LIMIT) {
+          delete this._debugInfo[this._callID - DEBUG_INFO_LIMIT];
+        }
+      }
+      // Encode callIDs into pairs of callback identifiers by shifting left and using the rightmost bit
+      // to indicate fail (0) or success (1)
+      // eslint-disable-next-line no-bitwise
+      onFail && params.push(this._callID << 1);
+      // eslint-disable-next-line no-bitwise
+      onSucc && params.push((this._callID << 1) | 1);
+      this._successCallbacks[this._callID] = onSucc;
+      this._failureCallbacks[this._callID] = onFail;
+    }
+
+    if (__DEV__) {
+      global.nativeTraceBeginAsyncFlow &&
+        global.nativeTraceBeginAsyncFlow(
+          TRACE_TAG_REACT_APPS,
+          'native',
+          this._callID,
+        );
+    }
+    this._callID++;
+
+    this._queue[MODULE_IDS].push(moduleID);
+    this._queue[METHOD_IDS].push(methodID);
+
+    if (__DEV__) {
+      // Validate that parameters passed over the bridge are
+      // folly-convertible.  As a special case, if a prop value is a
+      // function it is permitted here, and special-cased in the
+      // conversion.
+      const isValidArgument = val => {
+        const t = typeof val;
+        if (
+          t === 'undefined' ||
+          t === 'null' ||
+          t === 'boolean' ||
+          t === 'number' ||
+          t === 'string'
+        ) {
+          return true;
+        }
+        if (t === 'function' || t !== 'object') {
+          return false;
+        }
+        if (Array.isArray(val)) {
+          return val.every(isValidArgument);
+        }
+        for (const k in val) {
+          if (typeof val[k] !== 'function' && !isValidArgument(val[k])) {
+            return false;
+          }
+        }
+        return true;
+      };
+
+      invariant(
+        isValidArgument(params),
+        '%s is not usable as a native method argument',
+        params,
+      );
+
+      // The params object should not be mutated after being queued
+      deepFreezeAndThrowOnMutationInDev((params: any));
+    }
+    this._queue[PARAMS].push(params);
+
+    const now = new Date().getTime();
+    if (
+      global.nativeFlushQueueImmediate &&
+      (now - this._lastFlush >= MIN_TIME_BETWEEN_FLUSHES_MS ||
+        this._inCall === 0)
+    ) {
+      var queue = this._queue;
+      this._queue = [[], [], [], this._callID];
+      this._lastFlush = now;
+      global.nativeFlushQueueImmediate(queue);
+    }
+    Systrace.counterEvent('pending_js_to_native_queue', this._queue[0].length);
+    if (__DEV__ && this.__spy && isFinite(moduleID)) {
+      this.__spy({
+        type: TO_NATIVE,
+        module: this._remoteModuleTable[moduleID],
+        method: this._remoteMethodTable[moduleID][methodID],
+        args: params,
+      });
+    } else if (this.__spy) {
+      this.__spy({
+        type: TO_NATIVE,
+        module: moduleID + '',
+        method: methodID,
+        args: params,
+      });
+    }
+  }
+
+  createDebugLookup(moduleID: number, name: string, methods: string[]) {
+    if (__DEV__) {
+      this._remoteModuleTable[moduleID] = name;
+      this._remoteMethodTable[moduleID] = methods;
+    }
+  }
+
+  uninstallGlobalErrorHandler() {
+    this.__guard = this.__guardUnsafe;
+  }
+
+  installGlobalErrorHandler() {
+    this.__guard = this.__guardSafe;
+  }
+
+  /**
+   * Private methods
+   */
+
+  // Lets exceptions propagate to be handled by the VM at the origin
+  __guardUnsafe(fn: () => void) {
+    this._inCall++;
+    fn();
+    this._inCall--;
+  }
+
+  __guardSafe(fn: () => void) {
+    this._inCall++;
+    try {
+      fn();
+    } catch (error) {
+      ErrorUtils.reportFatalError(error);
+    } finally {
+      this._inCall--;
+    }
+  }
+
+  __callImmediates() {
+    Systrace.beginEvent('JSTimers.callImmediates()');
+    if (!JSTimers) {
+      JSTimers = require('JSTimers');
+    }
+    JSTimers.callImmediates();
+    Systrace.endEvent();
+  }
+
+  __callFunction(module: string, method: string, args: any[]): any {
+    this._lastFlush = new Date().getTime();
+    this._eventLoopStartTime = this._lastFlush;
+    Systrace.beginEvent(`${module}.${method}()`);
+    if (this.__spy) {
+      this.__spy({type: TO_JS, module, method, args});
+    }
+    const moduleMethods = this.getCallableModule(module);
+    invariant(
+      !!moduleMethods,
+      'Module %s is not a registered callable module (calling %s)',
+      module,
+      method,
+    );
+    invariant(
+      !!moduleMethods[method],
+      'Method %s does not exist on module %s',
+      method,
+      module,
+    );
+    const result = moduleMethods[method].apply(moduleMethods, args);
+    Systrace.endEvent();
+    return result;
+  }
+
+  __invokeCallback(cbID: number, args: any[]) {
+    this._lastFlush = new Date().getTime();
+    this._eventLoopStartTime = this._lastFlush;
+
+    // The rightmost bit of cbID indicates fail (0) or success (1), the other bits are the callID shifted left.
+    // eslint-disable-next-line no-bitwise
+    const callID = cbID >>> 1;
+    // eslint-disable-next-line no-bitwise
+    const isSuccess = cbID & 1;
+    const callback = isSuccess
+      ? this._successCallbacks[callID]
+      : this._failureCallbacks[callID];
+
+    if (__DEV__) {
+      const debug = this._debugInfo[callID];
+      const module = debug && this._remoteModuleTable[debug[0]];
+      const method = debug && this._remoteMethodTable[debug[0]][debug[1]];
+      if (!callback) {
+        let errorMessage = `Callback with id ${cbID}: ${module}.${method}() not found`;
+        if (method) {
+          errorMessage =
+            `The callback ${method}() exists in module ${module}, ` +
+            'but only one callback may be registered to a function in a native module.';
+        }
+        invariant(callback, errorMessage);
+      }
+      const profileName = debug
+        ? '<callback for ' + module + '.' + method + '>'
+        : cbID;
+      if (callback && this.__spy) {
+        this.__spy({type: TO_JS, module: null, method: profileName, args});
+      }
+      Systrace.beginEvent(
+        `MessageQueue.invokeCallback(${profileName}, ${stringifySafe(args)})`,
+      );
+    }
+
+    if (!callback) {
+      return;
+    }
+
+    this._successCallbacks[callID] = this._failureCallbacks[callID] = null;
+    callback(...args);
+
+    if (__DEV__) {
+      Systrace.endEvent();
+    }
+  }
+}
+
+module.exports = MessageQueue;

node_modules/react-native/Libraries/BatchedBridge/NativeModules.js

@@ -0,0 +1,154 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule NativeModules
+ * @flow
+ */
+'use strict';
+
+const BatchedBridge = require('BatchedBridge');
+
+const invariant = require('fbjs/lib/invariant');
+
+import type {ExtendedError} from 'parseErrorStack';
+
+type ModuleConfig = [
+  string, /* name */
+  ?Object, /* constants */
+  Array<string>, /* functions */
+  Array<number>, /* promise method IDs */
+  Array<number>, /* sync method IDs */
+];
+
+export type MethodType = 'async' | 'promise' | 'sync';
+
+function genModule(config: ?ModuleConfig, moduleID: number): ?{name: string, module?: Object} {
+  if (!config) {
+    return null;
+  }
+
+  const [moduleName, constants, methods, promiseMethods, syncMethods] = config;
+  invariant(!moduleName.startsWith('RCT') && !moduleName.startsWith('RK'),
+    'Module name prefixes should\'ve been stripped by the native side ' +
+    'but wasn\'t for ' + moduleName);
+
+  if (!constants && !methods) {
+    // Module contents will be filled in lazily later
+    return { name: moduleName };
+  }
+
+  const module = {};
+  methods && methods.forEach((methodName, methodID) => {
+    const isPromise = promiseMethods && arrayContains(promiseMethods, methodID);
+    const isSync = syncMethods && arrayContains(syncMethods, methodID);
+    invariant(!isPromise || !isSync, 'Cannot have a method that is both async and a sync hook');
+    const methodType = isPromise ? 'promise' : isSync ? 'sync' : 'async';
+    module[methodName] = genMethod(moduleID, methodID, methodType);
+  });
+  Object.assign(module, constants);
+
+  if (__DEV__) {
+    BatchedBridge.createDebugLookup(moduleID, moduleName, methods);
+  }
+
+  return { name: moduleName, module };
+}
+
+// export this method as a global so we can call it from native
+global.__fbGenNativeModule = genModule;
+
+function loadModule(name: string, moduleID: number): ?Object {
+  invariant(global.nativeRequireModuleConfig,
+    'Can\'t lazily create module without nativeRequireModuleConfig');
+  const config = global.nativeRequireModuleConfig(name);
+  const info = genModule(config, moduleID);
+  return info && info.module;
+}
+
+function genMethod(moduleID: number, methodID: number, type: MethodType) {
+  let fn = null;
+  if (type === 'promise') {
+    fn = function(...args: Array<any>) {
+      return new Promise((resolve, reject) => {
+        BatchedBridge.enqueueNativeCall(moduleID, methodID, args,
+          (data) => resolve(data),
+          (errorData) => reject(createErrorFromErrorData(errorData)));
+      });
+    };
+  } else if (type === 'sync') {
+    fn = function(...args: Array<any>) {
+      if (__DEV__) {
+        invariant(global.nativeCallSyncHook, 'Calling synchronous methods on native ' +
+          'modules is not supported in Chrome.\n\n Consider providing alternative ' +
+          'methods to expose this method in debug mode, e.g. by exposing constants ' +
+          'ahead-of-time.');
+      }
+      return global.nativeCallSyncHook(moduleID, methodID, args);
+    };
+  } else {
+    fn = function(...args: Array<any>) {
+      const lastArg = args.length > 0 ? args[args.length - 1] : null;
+      const secondLastArg = args.length > 1 ? args[args.length - 2] : null;
+      const hasSuccessCallback = typeof lastArg === 'function';
+      const hasErrorCallback = typeof secondLastArg === 'function';
+      hasErrorCallback && invariant(
+        hasSuccessCallback,
+        'Cannot have a non-function arg after a function arg.'
+      );
+      const onSuccess = hasSuccessCallback ? lastArg : null;
+      const onFail = hasErrorCallback ? secondLastArg : null;
+      const callbackCount = hasSuccessCallback + hasErrorCallback;
+      args = args.slice(0, args.length - callbackCount);
+      BatchedBridge.enqueueNativeCall(moduleID, methodID, args, onFail, onSuccess);
+    };
+  }
+  fn.type = type;
+  return fn;
+}
+
+function arrayContains<T>(array: Array<T>, value: T): boolean {
+  return array.indexOf(value) !== -1;
+}
+
+function createErrorFromErrorData(errorData: {message: string}): ExtendedError {
+  const {
+    message,
+    ...extraErrorInfo
+  } = errorData || {};
+  const error : ExtendedError = new Error(message);
+  error.framesToPop = 1;
+  return Object.assign(error, extraErrorInfo);
+}
+
+let NativeModules : {[moduleName: string]: Object} = {};
+if (global.nativeModuleProxy) {
+  NativeModules = global.nativeModuleProxy;
+} else {
+  const bridgeConfig = global.__fbBatchedBridgeConfig;
+  invariant(bridgeConfig, '__fbBatchedBridgeConfig is not set, cannot invoke native modules');
+
+  const defineLazyObjectProperty = require('defineLazyObjectProperty');
+  (bridgeConfig.remoteModuleConfig || []).forEach((config: ModuleConfig, moduleID: number) => {
+    // Initially this config will only contain the module name when running in JSC. The actual
+    // configuration of the module will be lazily loaded.
+    const info = genModule(config, moduleID);
+    if (!info) {
+      return;
+    }
+
+    if (info.module) {
+      NativeModules[info.name] = info.module;
+    }
+    // If there's no module config, define a lazy getter
+    else {
+      defineLazyObjectProperty(NativeModules, info.name, {
+        get: () => loadModule(info.name, moduleID)
+      });
+    }
+  });
+}
+
+module.exports = NativeModules;

node_modules/react-native/Libraries/BatchedBridge/__mocks__/MessageQueueTestConfig.js

@@ -0,0 +1,19 @@
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * These don't actually exist anywhere in the code.
+ */
+'use strict';
+var remoteModulesConfig = [
+  ['RemoteModule1',null,['remoteMethod','promiseMethod'],[]],
+  ['RemoteModule2',null,['remoteMethod','promiseMethod'],[]],
+];
+
+var MessageQueueTestConfig = {
+  remoteModuleConfig: remoteModulesConfig,
+};
+
+module.exports = MessageQueueTestConfig;

node_modules/react-native/Libraries/BatchedBridge/__mocks__/MessageQueueTestModule.js

@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+'use strict';
+
+/**
+ * Dummy module that only exists for the sake of proving that the message queue
+ * correctly dispatches to commonJS modules. The `testHook` is overriden by test
+ * cases.
+ */
+var MessageQueueTestModule = {
+  testHook1: function() {
+  },
+  testHook2: function() {
+  }
+};
+
+module.exports = MessageQueueTestModule;

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

@@ -0,0 +1,142 @@
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule Blob
+ * @flow
+ * @format
+ */
+
+'use strict';
+
+import type {BlobData, BlobOptions} from 'BlobTypes';
+
+/**
+ * Opaque JS representation of some binary data in native.
+ *
+ * The API is modeled after the W3C Blob API, with one caveat
+ * regarding explicit deallocation. Refer to the `close()`
+ * method for further details.
+ *
+ * Example usage in a React component:
+ *
+ *   class WebSocketImage extends React.Component {
+ *      state = {blob: null};
+ *      componentDidMount() {
+ *        let ws = this.ws = new WebSocket(...);
+ *        ws.binaryType = 'blob';
+ *        ws.onmessage = (event) => {
+ *          if (this.state.blob) {
+ *            this.state.blob.close();
+ *          }
+ *          this.setState({blob: event.data});
+ *        };
+ *      }
+ *      componentUnmount() {
+ *        if (this.state.blob) {
+ *          this.state.blob.close();
+ *        }
+ *        this.ws.close();
+ *      }
+ *      render() {
+ *        if (!this.state.blob) {
+ *          return <View />;
+ *        }
+ *        return <Image source={{uri: URL.createObjectURL(this.state.blob)}} />;
+ *      }
+ *   }
+ *
+ * Reference: https://developer.mozilla.org/en-US/docs/Web/API/Blob
+ */
+class Blob {
+  _data: ?BlobData;
+
+  /**
+   * Constructor for JS consumers.
+   * Currently we only support creating Blobs from other Blobs.
+   * Reference: https://developer.mozilla.org/en-US/docs/Web/API/Blob/Blob
+   */
+  constructor(parts: Array<Blob | string> = [], options?: BlobOptions) {
+    const BlobManager = require('BlobManager');
+    this.data = BlobManager.createFromParts(parts, options).data;
+  }
+
+  /*
+   * This method is used to create a new Blob object containing
+   * the data in the specified range of bytes of the source Blob.
+   * Reference: https://developer.mozilla.org/en-US/docs/Web/API/Blob/slice
+   */
+  set data(data: ?BlobData) {
+    this._data = data;
+  }
+
+  get data(): BlobData {
+    if (!this._data) {
+      throw new Error('Blob has been closed and is no longer available');
+    }
+
+    return this._data;
+  }
+
+  slice(start?: number, end?: number): Blob {
+    const BlobManager = require('BlobManager');
+    let {offset, size} = this.data;
+
+    if (typeof start === 'number') {
+      if (start > size) {
+        start = size;
+      }
+      offset += start;
+      size -= start;
+
+      if (typeof end === 'number') {
+        if (end < 0) {
+          end = this.size + end;
+        }
+        size = end - start;
+      }
+    }
+    return BlobManager.createFromOptions({
+      blobId: this.data.blobId,
+      offset,
+      size,
+    });
+  }
+
+  /**
+   * This method is in the standard, but not actually implemented by
+   * any browsers at this point. It's important for how Blobs work in
+   * React Native, however, since we cannot de-allocate resources automatically,
+   * so consumers need to explicitly de-allocate them.
+   *
+   * Note that the semantics around Blobs created via `blob.slice()`
+   * and `new Blob([blob])` are different. `blob.slice()` creates a
+   * new *view* onto the same binary data, so calling `close()` on any
+   * of those views is enough to deallocate the data, whereas
+   * `new Blob([blob, ...])` actually copies the data in memory.
+   */
+  close() {
+    const BlobManager = require('BlobManager');
+    BlobManager.release(this.data.blobId);
+    this.data = null;
+  }
+
+  /**
+   * Size of the data contained in the Blob object, in bytes.
+   */
+  get size(): number {
+    return this.data.size;
+  }
+
+  /*
+   * String indicating the MIME type of the data contained in the Blob.
+   * If the type is unknown, this string is empty.
+   */
+  get type(): string {
+    return this.data.type || '';
+  }
+}
+
+module.exports = Blob;

node_modules/react-native/Libraries/Blob/BlobManager.js

@@ -0,0 +1,144 @@
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule BlobManager
+ * @flow
+ * @format
+ */
+
+'use strict';
+
+const Blob = require('Blob');
+const BlobRegistry = require('BlobRegistry');
+const {BlobModule} = require('NativeModules');
+
+import type {BlobData, BlobOptions} from 'BlobTypes';
+
+/*eslint-disable no-bitwise */
+/*eslint-disable eqeqeq */
+
+/**
+ * Based on the rfc4122-compliant solution posted at
+ * http://stackoverflow.com/questions/105034
+ */
+function uuidv4(): string {
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
+    const r = (Math.random() * 16) | 0,
+      v = c == 'x' ? r : (r & 0x3) | 0x8;
+    return v.toString(16);
+  });
+}
+
+/**
+ * Module to manage blobs. Wrapper around the native blob module.
+ */
+class BlobManager {
+  /**
+   * If the native blob module is available.
+   */
+  static isAvailable = !!BlobModule;
+
+  /**
+   * Create blob from existing array of blobs.
+   */
+  static createFromParts(
+    parts: Array<Blob | string>,
+    options?: BlobOptions,
+  ): Blob {
+    const blobId = uuidv4();
+    const items = parts.map(part => {
+      if (
+        part instanceof ArrayBuffer ||
+        (global.ArrayBufferView && part instanceof global.ArrayBufferView)
+      ) {
+        throw new Error(
+          "Creating blobs from 'ArrayBuffer' and 'ArrayBufferView' are not supported",
+        );
+      }
+      if (part instanceof Blob) {
+        return {
+          data: part.data,
+          type: 'blob',
+        };
+      } else {
+        return {
+          data: String(part),
+          type: 'string',
+        };
+      }
+    });
+    const size = items.reduce((acc, curr) => {
+      if (curr.type === 'string') {
+        return acc + global.unescape(encodeURI(curr.data)).length;
+      } else {
+        return acc + curr.data.size;
+      }
+    }, 0);
+
+    BlobModule.createFromParts(items, blobId);
+
+    return BlobManager.createFromOptions({
+      blobId,
+      offset: 0,
+      size,
+      type: options ? options.type : '',
+      lastModified: options ? options.lastModified : Date.now(),
+    });
+  }
+
+  /**
+   * Create blob instance from blob data from native.
+   * Used internally by modules like XHR, WebSocket, etc.
+   */
+  static createFromOptions(options: BlobData): Blob {
+    BlobRegistry.register(options.blobId);
+    return Object.assign(Object.create(Blob.prototype), {data: options});
+  }
+
+  /**
+   * Deallocate resources for a blob.
+   */
+  static release(blobId: string): void {
+    BlobRegistry.unregister(blobId);
+    if (BlobRegistry.has(blobId)) {
+      return;
+    }
+    BlobModule.release(blobId);
+  }
+
+  /**
+   * Inject the blob content handler in the networking module to support blob
+   * requests and responses.
+   */
+  static addNetworkingHandler(): void {
+    BlobModule.addNetworkingHandler();
+  }
+
+  /**
+   * Indicate the websocket should return a blob for incoming binary
+   * messages.
+   */
+  static addWebSocketHandler(socketId: number): void {
+    BlobModule.addWebSocketHandler(socketId);
+  }
+
+  /**
+   * Indicate the websocket should no longer return a blob for incoming
+   * binary messages.
+   */
+  static removeWebSocketHandler(socketId: number): void {
+    BlobModule.removeWebSocketHandler(socketId);
+  }
+
+  /**
+   * Send a blob message to a websocket.
+   */
+  static sendOverSocket(blob: Blob, socketId: number): void {
+    BlobModule.sendOverSocket(blob.data, socketId);
+  }
+}
+
+module.exports = BlobManager;

node_modules/react-native/Libraries/Blob/BlobRegistry.js

@@ -0,0 +1,39 @@
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule BlobRegistry
+ * @flow
+ * @format
+ */
+
+const registry: {[key: string]: number} = {};
+
+const register = (id: string) => {
+  if (registry[id]) {
+    registry[id]++;
+  } else {
+    registry[id] = 1;
+  }
+};
+
+const unregister = (id: string) => {
+  if (registry[id]) {
+    registry[id]--;
+    if (registry[id] <= 0) {
+      delete registry[id];
+    }
+  }
+};
+
+const has = (id: string) => {
+  return registry[id] && registry[id] > 0;
+};
+
+module.exports = {
+  register,
+  unregister,
+  has,
+};

node_modules/react-native/Libraries/Blob/BlobTypes.js

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule BlobTypes
+ * @flow
+ * @format
+ */
+
+'use strict';
+
+export type BlobData = {
+  blobId: string,
+  offset: number,
+  size: number,
+  name?: string,
+  type?: string,
+  lastModified?: number,
+};
+
+export type BlobOptions = {
+  type: string,
+  lastModified: number,
+};