initial commit taken from gitlab.lrz.de

node_modules/react-native/ReactCommon/yoga/Android.mk

@@ -0,0 +1,14 @@
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := yogacore
+
+LOCAL_SRC_FILES := $(wildcard $(LOCAL_PATH)/yoga/*.cpp)
+
+LOCAL_C_INCLUDES := $(LOCAL_PATH)
+LOCAL_EXPORT_C_INCLUDES := $(LOCAL_C_INCLUDES)
+
+LOCAL_CFLAGS := -Wall -Werror -fexceptions -frtti -std=c++1y -O3
+
+include $(BUILD_STATIC_LIBRARY)

node_modules/react-native/ReactCommon/yoga/BUCK

@@ -0,0 +1,20 @@
+load("//ReactNative:DEFS.bzl", "rn_xplat_cxx_library")
+
+rn_xplat_cxx_library(
+    name = "yoga",
+    srcs = glob(["yoga/*.cpp"]),
+    header_namespace = "",
+    exported_headers = glob(["yoga/*.h"]),
+    compiler_flags = [
+        "-fno-omit-frame-pointer",
+        "-fexceptions",
+        "-Wall",
+        "-Werror",
+        "-std=c++1y",
+        "-O3",
+    ],
+    force_static = True,
+    visibility = ["PUBLIC"],
+    deps = [
+    ],
+)

node_modules/react-native/ReactCommon/yoga/yoga.podspec

@@ -0,0 +1,44 @@
+package = JSON.parse(File.read(File.expand_path('../../package.json', __dir__)))
+version = package['version']
+
+source = { :git => ENV['INSTALL_YOGA_FROM_LOCATION'] || 'https://github.com/facebook/react-native.git' }
+if version == '1000.0.0'
+  # This is an unpublished version, use the latest commit hash of the react-native repo, which we’re presumably in.
+  source[:commit] = `git rev-parse HEAD`.strip
+else
+  source[:tag] = "v#{version}"
+end
+
+Pod::Spec.new do |spec|
+  spec.name = 'yoga'
+  spec.version = "#{version}.React"
+  spec.license =  { :type => 'MIT' }
+  spec.homepage = 'https://facebook.github.io/yoga/'
+  spec.documentation_url = 'https://facebook.github.io/yoga/docs/api/c/'
+
+  spec.summary = 'Yoga is a cross-platform layout engine which implements Flexbox.'
+  spec.description = 'Yoga is a cross-platform layout engine enabling maximum collaboration within your team by implementing an API many designers are familiar with, and opening it up to developers across different platforms.'
+
+  spec.authors = 'Facebook'
+  spec.source = source
+
+  spec.module_name = 'yoga'
+  spec.requires_arc = false
+  spec.compiler_flags = [
+      '-fno-omit-frame-pointer',
+      '-fexceptions',
+      '-Wall',
+      '-Werror',
+      '-std=c++1y',
+      '-fPIC'
+  ]
+
+  # Pinning to the same version as React.podspec.
+  spec.platforms = { :ios => "8.0", :tvos => "9.2" }
+
+  # Set this environment variable when not using the `:path` option to install the pod.
+  # E.g. when publishing this spec to a spec repo.
+  source_files = 'yoga/**/*.{cpp,h}'
+  source_files = File.join('ReactCommon/yoga', source_files) if ENV['INSTALL_YOGA_WITHOUT_PATH_OPTION']
+  spec.source_files = source_files
+end

node_modules/react-native/ReactCommon/yoga/yoga/Utils.cpp

@@ -0,0 +1,51 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "Utils.h"
+
+YGFlexDirection YGFlexDirectionCross(
+    const YGFlexDirection flexDirection,
+    const YGDirection direction) {
+  return YGFlexDirectionIsColumn(flexDirection)
+      ? YGResolveFlexDirection(YGFlexDirectionRow, direction)
+      : YGFlexDirectionColumn;
+}
+
+float YGFloatMax(const float a, const float b) {
+  if (!YGFloatIsUndefined(a) && !YGFloatIsUndefined(b)) {
+    return fmaxf(a, b);
+  }
+  return YGFloatIsUndefined(a) ? b : a;
+}
+
+float YGFloatMin(const float a, const float b) {
+  if (!YGFloatIsUndefined(a) && !YGFloatIsUndefined(b)) {
+    return fminf(a, b);
+  }
+
+  return YGFloatIsUndefined(a) ? b : a;
+}
+
+bool YGValueEqual(const YGValue a, const YGValue b) {
+  if (a.unit != b.unit) {
+    return false;
+  }
+
+  if (a.unit == YGUnitUndefined ||
+      (YGFloatIsUndefined(a.value) && YGFloatIsUndefined(b.value))) {
+    return true;
+  }
+
+  return fabs(a.value - b.value) < 0.0001f;
+}
+
+bool YGFloatsEqual(const float a, const float b) {
+  if (!YGFloatIsUndefined(a) && !YGFloatIsUndefined(b)) {
+    return fabs(a - b) < 0.0001f;
+  }
+  return YGFloatIsUndefined(a) && YGFloatIsUndefined(b);
+}

node_modules/react-native/ReactCommon/yoga/yoga/Utils.h

@@ -0,0 +1,134 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+#include "YGNode.h"
+#include "Yoga-internal.h"
+
+// This struct is an helper model to hold the data for step 4 of flexbox
+// algo, which is collecting the flex items in a line.
+//
+// - itemsOnLine: Number of items which can fit in a line considering the
+// available Inner dimension, the flex items computed flexbasis and their
+// margin. It may be different than the difference between start and end
+// indicates because we skip over absolute-positioned items.
+//
+// - sizeConsumedOnCurrentLine: It is accumulation of the dimensions and margin
+// of all the children on the current line. This will be used in order to either
+// set the dimensions of the node if none already exist or to compute the
+// remaining space left for the flexible children.
+//
+// - totalFlexGrowFactors: total flex grow factors of flex items which are to be
+// layed in the current line
+//
+// - totalFlexShrinkFactors: total flex shrink factors of flex items which are
+// to be layed in the current line
+//
+// - endOfLineIndex: Its the end index of the last flex item which was examined
+// and it may or may not be part of the current line(as it may be absolutely
+// positioned or inculding it may have caused to overshoot availableInnerDim)
+//
+// - relativeChildren: Maintain a vector of the child nodes that can shrink
+// and/or grow.
+
+struct YGCollectFlexItemsRowValues {
+  uint32_t itemsOnLine;
+  float sizeConsumedOnCurrentLine;
+  float totalFlexGrowFactors;
+  float totalFlexShrinkScaledFactors;
+  float endOfLineIndex;
+  std::vector<YGNodeRef> relativeChildren;
+  float remainingFreeSpace;
+  // The size of the mainDim for the row after considering size, padding, margin
+  // and border of flex items. This is used to calculate maxLineDim after going
+  // through all the rows to decide on the main axis size of parent.
+  float mainDim;
+  // The size of the crossDim for the row after considering size, padding,
+  // margin and border of flex items. Used for calculating containers crossSize.
+  float crossDim;
+};
+
+bool YGValueEqual(const YGValue a, const YGValue b);
+
+// This custom float equality function returns true if either absolute
+// difference between two floats is less than 0.0001f or both are undefined.
+bool YGFloatsEqual(const float a, const float b);
+
+// We need custom max function, since we want that, if one argument is
+// YGUndefined then the max funtion should return the other argument as the max
+// value. We wouldn't have needed a custom max function if YGUndefined was NAN
+// as fmax has the same behaviour, but with NAN we cannot use `-ffast-math`
+// compiler flag.
+float YGFloatMax(const float a, const float b);
+
+// We need custom min function, since we want that, if one argument is
+// YGUndefined then the min funtion should return the other argument as the min
+// value. We wouldn't have needed a custom min function if YGUndefined was NAN
+// as fmin has the same behaviour, but with NAN we cannot use `-ffast-math`
+// compiler flag.
+float YGFloatMin(const float a, const float b);
+
+// This custom float comparision function compares the array of float with
+// YGFloatsEqual, as the default float comparision operator will not work(Look
+// at the comments of YGFloatsEqual function).
+template <std::size_t size>
+bool YGFloatArrayEqual(
+    const std::array<float, size>& val1,
+    const std::array<float, size>& val2) {
+  bool areEqual = true;
+  for (std::size_t i = 0; i < size && areEqual; ++i) {
+    areEqual = YGFloatsEqual(val1[i], val2[i]);
+  }
+  return areEqual;
+}
+
+YGFlexDirection YGFlexDirectionCross(
+    const YGFlexDirection flexDirection,
+    const YGDirection direction);
+
+inline bool YGFlexDirectionIsRow(const YGFlexDirection flexDirection) {
+  return flexDirection == YGFlexDirectionRow ||
+      flexDirection == YGFlexDirectionRowReverse;
+}
+
+inline float YGResolveValue(const YGValue value, const float parentSize) {
+  switch (value.unit) {
+    case YGUnitUndefined:
+    case YGUnitAuto:
+      return YGUndefined;
+    case YGUnitPoint:
+      return value.value;
+    case YGUnitPercent:
+      return value.value * parentSize * 0.01;
+  }
+  return YGUndefined;
+}
+
+inline bool YGFlexDirectionIsColumn(const YGFlexDirection flexDirection) {
+  return flexDirection == YGFlexDirectionColumn ||
+      flexDirection == YGFlexDirectionColumnReverse;
+}
+
+inline YGFlexDirection YGResolveFlexDirection(
+    const YGFlexDirection flexDirection,
+    const YGDirection direction) {
+  if (direction == YGDirectionRTL) {
+    if (flexDirection == YGFlexDirectionRow) {
+      return YGFlexDirectionRowReverse;
+    } else if (flexDirection == YGFlexDirectionRowReverse) {
+      return YGFlexDirectionRow;
+    }
+  }
+
+  return flexDirection;
+}
+
+static inline float YGResolveValueMargin(
+    const YGValue value,
+    const float parentSize) {
+  return value.unit == YGUnitAuto ? 0 : YGResolveValue(value, parentSize);
+}

node_modules/react-native/ReactCommon/yoga/yoga/YGEnums.cpp

@@ -0,0 +1,226 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "YGEnums.h"
+
+const char *YGAlignToString(const YGAlign value){
+  switch(value){
+    case YGAlignAuto:
+      return "auto";
+    case YGAlignFlexStart:
+      return "flex-start";
+    case YGAlignCenter:
+      return "center";
+    case YGAlignFlexEnd:
+      return "flex-end";
+    case YGAlignStretch:
+      return "stretch";
+    case YGAlignBaseline:
+      return "baseline";
+    case YGAlignSpaceBetween:
+      return "space-between";
+    case YGAlignSpaceAround:
+      return "space-around";
+  }
+  return "unknown";
+}
+
+const char *YGDimensionToString(const YGDimension value){
+  switch(value){
+    case YGDimensionWidth:
+      return "width";
+    case YGDimensionHeight:
+      return "height";
+  }
+  return "unknown";
+}
+
+const char *YGDirectionToString(const YGDirection value){
+  switch(value){
+    case YGDirectionInherit:
+      return "inherit";
+    case YGDirectionLTR:
+      return "ltr";
+    case YGDirectionRTL:
+      return "rtl";
+  }
+  return "unknown";
+}
+
+const char *YGDisplayToString(const YGDisplay value){
+  switch(value){
+    case YGDisplayFlex:
+      return "flex";
+    case YGDisplayNone:
+      return "none";
+  }
+  return "unknown";
+}
+
+const char *YGEdgeToString(const YGEdge value){
+  switch(value){
+    case YGEdgeLeft:
+      return "left";
+    case YGEdgeTop:
+      return "top";
+    case YGEdgeRight:
+      return "right";
+    case YGEdgeBottom:
+      return "bottom";
+    case YGEdgeStart:
+      return "start";
+    case YGEdgeEnd:
+      return "end";
+    case YGEdgeHorizontal:
+      return "horizontal";
+    case YGEdgeVertical:
+      return "vertical";
+    case YGEdgeAll:
+      return "all";
+  }
+  return "unknown";
+}
+
+const char *YGExperimentalFeatureToString(const YGExperimentalFeature value){
+  switch(value){
+    case YGExperimentalFeatureWebFlexBasis:
+      return "web-flex-basis";
+  }
+  return "unknown";
+}
+
+const char *YGFlexDirectionToString(const YGFlexDirection value){
+  switch(value){
+    case YGFlexDirectionColumn:
+      return "column";
+    case YGFlexDirectionColumnReverse:
+      return "column-reverse";
+    case YGFlexDirectionRow:
+      return "row";
+    case YGFlexDirectionRowReverse:
+      return "row-reverse";
+  }
+  return "unknown";
+}
+
+const char *YGJustifyToString(const YGJustify value){
+  switch(value){
+    case YGJustifyFlexStart:
+      return "flex-start";
+    case YGJustifyCenter:
+      return "center";
+    case YGJustifyFlexEnd:
+      return "flex-end";
+    case YGJustifySpaceBetween:
+      return "space-between";
+    case YGJustifySpaceAround:
+      return "space-around";
+    case YGJustifySpaceEvenly:
+      return "space-evenly";
+  }
+  return "unknown";
+}
+
+const char *YGLogLevelToString(const YGLogLevel value){
+  switch(value){
+    case YGLogLevelError:
+      return "error";
+    case YGLogLevelWarn:
+      return "warn";
+    case YGLogLevelInfo:
+      return "info";
+    case YGLogLevelDebug:
+      return "debug";
+    case YGLogLevelVerbose:
+      return "verbose";
+    case YGLogLevelFatal:
+      return "fatal";
+  }
+  return "unknown";
+}
+
+const char *YGMeasureModeToString(const YGMeasureMode value){
+  switch(value){
+    case YGMeasureModeUndefined:
+      return "undefined";
+    case YGMeasureModeExactly:
+      return "exactly";
+    case YGMeasureModeAtMost:
+      return "at-most";
+  }
+  return "unknown";
+}
+
+const char *YGNodeTypeToString(const YGNodeType value){
+  switch(value){
+    case YGNodeTypeDefault:
+      return "default";
+    case YGNodeTypeText:
+      return "text";
+  }
+  return "unknown";
+}
+
+const char *YGOverflowToString(const YGOverflow value){
+  switch(value){
+    case YGOverflowVisible:
+      return "visible";
+    case YGOverflowHidden:
+      return "hidden";
+    case YGOverflowScroll:
+      return "scroll";
+  }
+  return "unknown";
+}
+
+const char *YGPositionTypeToString(const YGPositionType value){
+  switch(value){
+    case YGPositionTypeRelative:
+      return "relative";
+    case YGPositionTypeAbsolute:
+      return "absolute";
+  }
+  return "unknown";
+}
+
+const char *YGPrintOptionsToString(const YGPrintOptions value){
+  switch(value){
+    case YGPrintOptionsLayout:
+      return "layout";
+    case YGPrintOptionsStyle:
+      return "style";
+    case YGPrintOptionsChildren:
+      return "children";
+  }
+  return "unknown";
+}
+
+const char *YGUnitToString(const YGUnit value){
+  switch(value){
+    case YGUnitUndefined:
+      return "undefined";
+    case YGUnitPoint:
+      return "point";
+    case YGUnitPercent:
+      return "percent";
+    case YGUnitAuto:
+      return "auto";
+  }
+  return "unknown";
+}
+
+const char *YGWrapToString(const YGWrap value){
+  switch(value){
+    case YGWrapNoWrap:
+      return "no-wrap";
+    case YGWrapWrap:
+      return "wrap";
+    case YGWrapWrapReverse:
+      return "wrap-reverse";
+  }
+  return "unknown";
+}

node_modules/react-native/ReactCommon/yoga/yoga/YGEnums.h

@@ -0,0 +1,155 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include "YGMacros.h"
+
+YG_EXTERN_C_BEGIN
+
+#define YGAlignCount 8
+typedef YG_ENUM_BEGIN(YGAlign) {
+  YGAlignAuto,
+  YGAlignFlexStart,
+  YGAlignCenter,
+  YGAlignFlexEnd,
+  YGAlignStretch,
+  YGAlignBaseline,
+  YGAlignSpaceBetween,
+  YGAlignSpaceAround,
+} YG_ENUM_END(YGAlign);
+WIN_EXPORT const char *YGAlignToString(const YGAlign value);
+
+#define YGDimensionCount 2
+typedef YG_ENUM_BEGIN(YGDimension) {
+  YGDimensionWidth,
+  YGDimensionHeight,
+} YG_ENUM_END(YGDimension);
+WIN_EXPORT const char *YGDimensionToString(const YGDimension value);
+
+#define YGDirectionCount 3
+typedef YG_ENUM_BEGIN(YGDirection) {
+  YGDirectionInherit,
+  YGDirectionLTR,
+  YGDirectionRTL,
+} YG_ENUM_END(YGDirection);
+WIN_EXPORT const char *YGDirectionToString(const YGDirection value);
+
+#define YGDisplayCount 2
+typedef YG_ENUM_BEGIN(YGDisplay) {
+  YGDisplayFlex,
+  YGDisplayNone,
+} YG_ENUM_END(YGDisplay);
+WIN_EXPORT const char *YGDisplayToString(const YGDisplay value);
+
+#define YGEdgeCount 9
+typedef YG_ENUM_BEGIN(YGEdge) {
+  YGEdgeLeft,
+  YGEdgeTop,
+  YGEdgeRight,
+  YGEdgeBottom,
+  YGEdgeStart,
+  YGEdgeEnd,
+  YGEdgeHorizontal,
+  YGEdgeVertical,
+  YGEdgeAll,
+} YG_ENUM_END(YGEdge);
+WIN_EXPORT const char *YGEdgeToString(const YGEdge value);
+
+#define YGExperimentalFeatureCount 1
+typedef YG_ENUM_BEGIN(YGExperimentalFeature) {
+  YGExperimentalFeatureWebFlexBasis,
+} YG_ENUM_END(YGExperimentalFeature);
+WIN_EXPORT const char *YGExperimentalFeatureToString(const YGExperimentalFeature value);
+
+#define YGFlexDirectionCount 4
+typedef YG_ENUM_BEGIN(YGFlexDirection) {
+  YGFlexDirectionColumn,
+  YGFlexDirectionColumnReverse,
+  YGFlexDirectionRow,
+  YGFlexDirectionRowReverse,
+} YG_ENUM_END(YGFlexDirection);
+WIN_EXPORT const char *YGFlexDirectionToString(const YGFlexDirection value);
+
+#define YGJustifyCount 6
+typedef YG_ENUM_BEGIN(YGJustify){
+    YGJustifyFlexStart,
+    YGJustifyCenter,
+    YGJustifyFlexEnd,
+    YGJustifySpaceBetween,
+    YGJustifySpaceAround,
+    YGJustifySpaceEvenly,
+} YG_ENUM_END(YGJustify);
+WIN_EXPORT const char *YGJustifyToString(const YGJustify value);
+
+#define YGLogLevelCount 6
+typedef YG_ENUM_BEGIN(YGLogLevel) {
+  YGLogLevelError,
+  YGLogLevelWarn,
+  YGLogLevelInfo,
+  YGLogLevelDebug,
+  YGLogLevelVerbose,
+  YGLogLevelFatal,
+} YG_ENUM_END(YGLogLevel);
+WIN_EXPORT const char *YGLogLevelToString(const YGLogLevel value);
+
+#define YGMeasureModeCount 3
+typedef YG_ENUM_BEGIN(YGMeasureMode) {
+  YGMeasureModeUndefined,
+  YGMeasureModeExactly,
+  YGMeasureModeAtMost,
+} YG_ENUM_END(YGMeasureMode);
+WIN_EXPORT const char *YGMeasureModeToString(const YGMeasureMode value);
+
+#define YGNodeTypeCount 2
+typedef YG_ENUM_BEGIN(YGNodeType) {
+  YGNodeTypeDefault,
+  YGNodeTypeText,
+} YG_ENUM_END(YGNodeType);
+WIN_EXPORT const char *YGNodeTypeToString(const YGNodeType value);
+
+#define YGOverflowCount 3
+typedef YG_ENUM_BEGIN(YGOverflow) {
+  YGOverflowVisible,
+  YGOverflowHidden,
+  YGOverflowScroll,
+} YG_ENUM_END(YGOverflow);
+WIN_EXPORT const char *YGOverflowToString(const YGOverflow value);
+
+#define YGPositionTypeCount 2
+typedef YG_ENUM_BEGIN(YGPositionType) {
+  YGPositionTypeRelative,
+  YGPositionTypeAbsolute,
+} YG_ENUM_END(YGPositionType);
+WIN_EXPORT const char *YGPositionTypeToString(const YGPositionType value);
+
+#define YGPrintOptionsCount 3
+typedef YG_ENUM_BEGIN(YGPrintOptions) {
+  YGPrintOptionsLayout = 1,
+  YGPrintOptionsStyle = 2,
+  YGPrintOptionsChildren = 4,
+} YG_ENUM_END(YGPrintOptions);
+WIN_EXPORT const char *YGPrintOptionsToString(const YGPrintOptions value);
+
+#define YGUnitCount 4
+typedef YG_ENUM_BEGIN(YGUnit) {
+  YGUnitUndefined,
+  YGUnitPoint,
+  YGUnitPercent,
+  YGUnitAuto,
+} YG_ENUM_END(YGUnit);
+WIN_EXPORT const char *YGUnitToString(const YGUnit value);
+
+#define YGWrapCount 3
+typedef YG_ENUM_BEGIN(YGWrap) {
+  YGWrapNoWrap,
+  YGWrapWrap,
+  YGWrapWrapReverse,
+} YG_ENUM_END(YGWrap);
+WIN_EXPORT const char *YGWrapToString(const YGWrap value);
+
+YG_EXTERN_C_END

node_modules/react-native/ReactCommon/yoga/yoga/YGLayout.cpp

@@ -0,0 +1,68 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "YGLayout.h"
+#include "Utils.h"
+
+const std::array<float, 2> kYGDefaultDimensionValues = {
+    {YGUndefined, YGUndefined}};
+
+YGLayout::YGLayout()
+    : position(),
+      dimensions(kYGDefaultDimensionValues),
+      margin(),
+      border(),
+      padding(),
+      direction(YGDirectionInherit),
+      computedFlexBasisGeneration(0),
+      computedFlexBasis(YGUndefined),
+      hadOverflow(false),
+      generationCount(0),
+      lastParentDirection((YGDirection)-1),
+      nextCachedMeasurementsIndex(0),
+      cachedMeasurements(),
+      measuredDimensions(kYGDefaultDimensionValues),
+      cachedLayout(YGCachedMeasurement()),
+      didUseLegacyFlag(false),
+      doesLegacyStretchFlagAffectsLayout(false) {}
+
+bool YGLayout::operator==(YGLayout layout) const {
+  bool isEqual = YGFloatArrayEqual(position, layout.position) &&
+      YGFloatArrayEqual(dimensions, layout.dimensions) &&
+      YGFloatArrayEqual(margin, layout.margin) &&
+      YGFloatArrayEqual(border, layout.border) &&
+      YGFloatArrayEqual(padding, layout.padding) &&
+      direction == layout.direction && hadOverflow == layout.hadOverflow &&
+      lastParentDirection == layout.lastParentDirection &&
+      nextCachedMeasurementsIndex == layout.nextCachedMeasurementsIndex &&
+      cachedLayout == layout.cachedLayout;
+
+  for (uint32_t i = 0; i < YG_MAX_CACHED_RESULT_COUNT && isEqual; ++i) {
+    isEqual = isEqual && cachedMeasurements[i] == layout.cachedMeasurements[i];
+  }
+
+  if (!YGFloatIsUndefined(computedFlexBasis) ||
+      !YGFloatIsUndefined(layout.computedFlexBasis)) {
+    isEqual = isEqual && (computedFlexBasis == layout.computedFlexBasis);
+  }
+  if (!YGFloatIsUndefined(measuredDimensions[0]) ||
+      !YGFloatIsUndefined(layout.measuredDimensions[0])) {
+    isEqual =
+        isEqual && (measuredDimensions[0] == layout.measuredDimensions[0]);
+  }
+  if (!YGFloatIsUndefined(measuredDimensions[1]) ||
+      !YGFloatIsUndefined(layout.measuredDimensions[1])) {
+    isEqual =
+        isEqual && (measuredDimensions[1] == layout.measuredDimensions[1]);
+  }
+
+  return isEqual;
+}
+
+bool YGLayout::operator!=(YGLayout layout) const {
+  return !(*this == layout);
+}

node_modules/react-native/ReactCommon/yoga/yoga/YGLayout.h

@@ -0,0 +1,41 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+#include "Yoga-internal.h"
+
+struct YGLayout {
+  std::array<float, 4> position;
+  std::array<float, 2> dimensions;
+  std::array<float, 6> margin;
+  std::array<float, 6> border;
+  std::array<float, 6> padding;
+  YGDirection direction;
+
+  uint32_t computedFlexBasisGeneration;
+  float computedFlexBasis;
+  bool hadOverflow;
+
+  // Instead of recomputing the entire layout every single time, we
+  // cache some information to break early when nothing changed
+  uint32_t generationCount;
+  YGDirection lastParentDirection;
+
+  uint32_t nextCachedMeasurementsIndex;
+  std::array<YGCachedMeasurement, YG_MAX_CACHED_RESULT_COUNT>
+      cachedMeasurements;
+  std::array<float, 2> measuredDimensions;
+
+  YGCachedMeasurement cachedLayout;
+  bool didUseLegacyFlag;
+  bool doesLegacyStretchFlagAffectsLayout;
+
+  YGLayout();
+
+  bool operator==(YGLayout layout) const;
+  bool operator!=(YGLayout layout) const;
+};

node_modules/react-native/ReactCommon/yoga/yoga/YGMacros.h

@@ -0,0 +1,41 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#ifdef __cplusplus
+#define YG_EXTERN_C_BEGIN extern "C" {
+#define YG_EXTERN_C_END }
+#else
+#define YG_EXTERN_C_BEGIN
+#define YG_EXTERN_C_END
+#endif
+
+#ifdef _WINDLL
+#define WIN_EXPORT __declspec(dllexport)
+#else
+#define WIN_EXPORT
+#endif
+
+#ifdef WINARMDLL
+#define WIN_STRUCT(type) type *
+#define WIN_STRUCT_REF(value) &value
+#else
+#define WIN_STRUCT(type) type
+#define WIN_STRUCT_REF(value) value
+#endif
+
+#ifdef NS_ENUM
+// Cannot use NSInteger as NSInteger has a different size than int (which is the default type of a
+// enum).
+// Therefor when linking the Yoga C library into obj-c the header is a missmatch for the Yoga ABI.
+#define YG_ENUM_BEGIN(name) NS_ENUM(int, name)
+#define YG_ENUM_END(name)
+#else
+#define YG_ENUM_BEGIN(name) enum name
+#define YG_ENUM_END(name) name
+#endif

node_modules/react-native/ReactCommon/yoga/yoga/YGNode.cpp

@@ -0,0 +1,750 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "YGNode.h"
+#include <iostream>
+#include "Utils.h"
+
+void* YGNode::getContext() const {
+  return context_;
+}
+
+YGPrintFunc YGNode::getPrintFunc() const {
+  return print_;
+}
+
+bool YGNode::getHasNewLayout() const {
+  return hasNewLayout_;
+}
+
+YGNodeType YGNode::getNodeType() const {
+  return nodeType_;
+}
+
+YGMeasureFunc YGNode::getMeasure() const {
+  return measure_;
+}
+
+YGBaselineFunc YGNode::getBaseline() const {
+  return baseline_;
+}
+
+YGDirtiedFunc YGNode::getDirtied() const {
+  return dirtied_;
+}
+
+YGStyle& YGNode::getStyle() {
+  return style_;
+}
+
+YGLayout& YGNode::getLayout() {
+  return layout_;
+}
+
+uint32_t YGNode::getLineIndex() const {
+  return lineIndex_;
+}
+
+YGNodeRef YGNode::getParent() const {
+  return parent_;
+}
+
+YGVector YGNode::getChildren() const {
+  return children_;
+}
+
+uint32_t YGNode::getChildrenCount() const {
+  return static_cast<uint32_t>(children_.size());
+}
+
+YGNodeRef YGNode::getChild(uint32_t index) const {
+  return children_.at(index);
+}
+
+YGNodeRef YGNode::getNextChild() const {
+  return nextChild_;
+}
+
+YGConfigRef YGNode::getConfig() const {
+  return config_;
+}
+
+bool YGNode::isDirty() const {
+  return isDirty_;
+}
+
+YGValue YGNode::getResolvedDimension(int index) {
+  return resolvedDimensions_[index];
+}
+
+std::array<YGValue, 2> YGNode::getResolvedDimensions() const {
+  return resolvedDimensions_;
+}
+
+float YGNode::getLeadingPosition(
+    const YGFlexDirection axis,
+    const float axisSize) {
+  if (YGFlexDirectionIsRow(axis)) {
+    const YGValue* leadingPosition =
+        YGComputedEdgeValue(style_.position, YGEdgeStart, &YGValueUndefined);
+    if (leadingPosition->unit != YGUnitUndefined) {
+      return YGResolveValue(*leadingPosition, axisSize);
+    }
+  }
+
+  const YGValue* leadingPosition =
+      YGComputedEdgeValue(style_.position, leading[axis], &YGValueUndefined);
+
+  return leadingPosition->unit == YGUnitUndefined
+      ? 0.0f
+      : YGResolveValue(*leadingPosition, axisSize);
+}
+
+float YGNode::getTrailingPosition(
+    const YGFlexDirection axis,
+    const float axisSize) {
+  if (YGFlexDirectionIsRow(axis)) {
+    const YGValue* trailingPosition =
+        YGComputedEdgeValue(style_.position, YGEdgeEnd, &YGValueUndefined);
+    if (trailingPosition->unit != YGUnitUndefined) {
+      return YGResolveValue(*trailingPosition, axisSize);
+    }
+  }
+
+  const YGValue* trailingPosition =
+      YGComputedEdgeValue(style_.position, trailing[axis], &YGValueUndefined);
+
+  return trailingPosition->unit == YGUnitUndefined
+      ? 0.0f
+      : YGResolveValue(*trailingPosition, axisSize);
+}
+
+bool YGNode::isLeadingPositionDefined(const YGFlexDirection axis) {
+  return (YGFlexDirectionIsRow(axis) &&
+          YGComputedEdgeValue(style_.position, YGEdgeStart, &YGValueUndefined)
+                  ->unit != YGUnitUndefined) ||
+      YGComputedEdgeValue(style_.position, leading[axis], &YGValueUndefined)
+          ->unit != YGUnitUndefined;
+}
+
+bool YGNode::isTrailingPosDefined(const YGFlexDirection axis) {
+  return (YGFlexDirectionIsRow(axis) &&
+          YGComputedEdgeValue(style_.position, YGEdgeEnd, &YGValueUndefined)
+                  ->unit != YGUnitUndefined) ||
+      YGComputedEdgeValue(style_.position, trailing[axis], &YGValueUndefined)
+          ->unit != YGUnitUndefined;
+}
+
+float YGNode::getLeadingMargin(
+    const YGFlexDirection axis,
+    const float widthSize) {
+  if (YGFlexDirectionIsRow(axis) &&
+      style_.margin[YGEdgeStart].unit != YGUnitUndefined) {
+    return YGResolveValueMargin(style_.margin[YGEdgeStart], widthSize);
+  }
+
+  return YGResolveValueMargin(
+      *YGComputedEdgeValue(style_.margin, leading[axis], &YGValueZero),
+      widthSize);
+}
+
+float YGNode::getTrailingMargin(
+    const YGFlexDirection axis,
+    const float widthSize) {
+  if (YGFlexDirectionIsRow(axis) &&
+      style_.margin[YGEdgeEnd].unit != YGUnitUndefined) {
+    return YGResolveValueMargin(style_.margin[YGEdgeEnd], widthSize);
+  }
+
+  return YGResolveValueMargin(
+      *YGComputedEdgeValue(style_.margin, trailing[axis], &YGValueZero),
+      widthSize);
+}
+
+float YGNode::getMarginForAxis(
+    const YGFlexDirection axis,
+    const float widthSize) {
+  return getLeadingMargin(axis, widthSize) + getTrailingMargin(axis, widthSize);
+}
+
+// Setters
+
+void YGNode::setContext(void* context) {
+  context_ = context;
+}
+
+void YGNode::setPrintFunc(YGPrintFunc printFunc) {
+  print_ = printFunc;
+}
+
+void YGNode::setHasNewLayout(bool hasNewLayout) {
+  hasNewLayout_ = hasNewLayout;
+}
+
+void YGNode::setNodeType(YGNodeType nodeType) {
+  nodeType_ = nodeType;
+}
+
+void YGNode::setStyleFlexDirection(YGFlexDirection direction) {
+  style_.flexDirection = direction;
+}
+
+void YGNode::setStyleAlignContent(YGAlign alignContent) {
+  style_.alignContent = alignContent;
+}
+
+void YGNode::setMeasureFunc(YGMeasureFunc measureFunc) {
+  if (measureFunc == nullptr) {
+    measure_ = nullptr;
+    // TODO: t18095186 Move nodeType to opt-in function and mark appropriate
+    // places in Litho
+    nodeType_ = YGNodeTypeDefault;
+  } else {
+    YGAssertWithNode(
+        this,
+        children_.size() == 0,
+        "Cannot set measure function: Nodes with measure functions cannot have children.");
+    measure_ = measureFunc;
+    // TODO: t18095186 Move nodeType to opt-in function and mark appropriate
+    // places in Litho
+    setNodeType(YGNodeTypeText);
+  }
+
+  measure_ = measureFunc;
+}
+
+void YGNode::setBaseLineFunc(YGBaselineFunc baseLineFunc) {
+  baseline_ = baseLineFunc;
+}
+
+void YGNode::setDirtiedFunc(YGDirtiedFunc dirtiedFunc) {
+  dirtied_ = dirtiedFunc;
+}
+
+void YGNode::setStyle(YGStyle style) {
+  style_ = style;
+}
+
+void YGNode::setLayout(YGLayout layout) {
+  layout_ = layout;
+}
+
+void YGNode::setLineIndex(uint32_t lineIndex) {
+  lineIndex_ = lineIndex;
+}
+
+void YGNode::setParent(YGNodeRef parent) {
+  parent_ = parent;
+}
+
+void YGNode::setChildren(YGVector children) {
+  children_ = children;
+}
+
+void YGNode::setNextChild(YGNodeRef nextChild) {
+  nextChild_ = nextChild;
+}
+
+void YGNode::replaceChild(YGNodeRef child, uint32_t index) {
+  children_[index] = child;
+}
+
+void YGNode::replaceChild(YGNodeRef oldChild, YGNodeRef newChild) {
+  std::replace(children_.begin(), children_.end(), oldChild, newChild);
+}
+
+void YGNode::insertChild(YGNodeRef child, uint32_t index) {
+  children_.insert(children_.begin() + index, child);
+}
+
+void YGNode::setConfig(YGConfigRef config) {
+  config_ = config;
+}
+
+void YGNode::setDirty(bool isDirty) {
+  if (isDirty == isDirty_) {
+    return;
+  }
+  isDirty_ = isDirty;
+  if (isDirty && dirtied_) {
+    dirtied_(this);
+  }
+}
+
+bool YGNode::removeChild(YGNodeRef child) {
+  std::vector<YGNodeRef>::iterator p =
+      std::find(children_.begin(), children_.end(), child);
+  if (p != children_.end()) {
+    children_.erase(p);
+    return true;
+  }
+  return false;
+}
+
+void YGNode::removeChild(uint32_t index) {
+  children_.erase(children_.begin() + index);
+}
+
+void YGNode::setLayoutDirection(YGDirection direction) {
+  layout_.direction = direction;
+}
+
+void YGNode::setLayoutMargin(float margin, int index) {
+  layout_.margin[index] = margin;
+}
+
+void YGNode::setLayoutBorder(float border, int index) {
+  layout_.border[index] = border;
+}
+
+void YGNode::setLayoutPadding(float padding, int index) {
+  layout_.padding[index] = padding;
+}
+
+void YGNode::setLayoutLastParentDirection(YGDirection direction) {
+  layout_.lastParentDirection = direction;
+}
+
+void YGNode::setLayoutComputedFlexBasis(float computedFlexBasis) {
+  layout_.computedFlexBasis = computedFlexBasis;
+}
+
+void YGNode::setLayoutPosition(float position, int index) {
+  layout_.position[index] = position;
+}
+
+void YGNode::setLayoutComputedFlexBasisGeneration(
+    uint32_t computedFlexBasisGeneration) {
+  layout_.computedFlexBasisGeneration = computedFlexBasisGeneration;
+}
+
+void YGNode::setLayoutMeasuredDimension(float measuredDimension, int index) {
+  layout_.measuredDimensions[index] = measuredDimension;
+}
+
+void YGNode::setLayoutHadOverflow(bool hadOverflow) {
+  layout_.hadOverflow = hadOverflow;
+}
+
+void YGNode::setLayoutDimension(float dimension, int index) {
+  layout_.dimensions[index] = dimension;
+}
+
+// If both left and right are defined, then use left. Otherwise return
+// +left or -right depending on which is defined.
+float YGNode::relativePosition(
+    const YGFlexDirection axis,
+    const float axisSize) {
+  return isLeadingPositionDefined(axis) ? getLeadingPosition(axis, axisSize)
+                                        : -getTrailingPosition(axis, axisSize);
+}
+
+void YGNode::setPosition(
+    const YGDirection direction,
+    const float mainSize,
+    const float crossSize,
+    const float parentWidth) {
+  /* Root nodes should be always layouted as LTR, so we don't return negative
+   * values. */
+  const YGDirection directionRespectingRoot =
+      parent_ != nullptr ? direction : YGDirectionLTR;
+  const YGFlexDirection mainAxis =
+      YGResolveFlexDirection(style_.flexDirection, directionRespectingRoot);
+  const YGFlexDirection crossAxis =
+      YGFlexDirectionCross(mainAxis, directionRespectingRoot);
+
+  const float relativePositionMain = relativePosition(mainAxis, mainSize);
+  const float relativePositionCross = relativePosition(crossAxis, crossSize);
+
+  setLayoutPosition(
+      getLeadingMargin(mainAxis, parentWidth) + relativePositionMain,
+      leading[mainAxis]);
+  setLayoutPosition(
+      getTrailingMargin(mainAxis, parentWidth) + relativePositionMain,
+      trailing[mainAxis]);
+  setLayoutPosition(
+      getLeadingMargin(crossAxis, parentWidth) + relativePositionCross,
+      leading[crossAxis]);
+  setLayoutPosition(
+      getTrailingMargin(crossAxis, parentWidth) + relativePositionCross,
+      trailing[crossAxis]);
+}
+
+YGNode::YGNode()
+    : context_(nullptr),
+      print_(nullptr),
+      hasNewLayout_(true),
+      nodeType_(YGNodeTypeDefault),
+      measure_(nullptr),
+      baseline_(nullptr),
+      dirtied_(nullptr),
+      style_(YGStyle()),
+      layout_(YGLayout()),
+      lineIndex_(0),
+      parent_(nullptr),
+      children_(YGVector()),
+      nextChild_(nullptr),
+      config_(nullptr),
+      isDirty_(false),
+      resolvedDimensions_({{YGValueUndefined, YGValueUndefined}}) {}
+
+YGNode::YGNode(const YGNode& node)
+    : context_(node.context_),
+      print_(node.print_),
+      hasNewLayout_(node.hasNewLayout_),
+      nodeType_(node.nodeType_),
+      measure_(node.measure_),
+      baseline_(node.baseline_),
+      dirtied_(node.dirtied_),
+      style_(node.style_),
+      layout_(node.layout_),
+      lineIndex_(node.lineIndex_),
+      parent_(node.parent_),
+      children_(node.children_),
+      nextChild_(node.nextChild_),
+      config_(node.config_),
+      isDirty_(node.isDirty_),
+      resolvedDimensions_(node.resolvedDimensions_) {}
+
+YGNode::YGNode(const YGConfigRef newConfig) : YGNode() {
+  config_ = newConfig;
+}
+
+YGNode::YGNode(
+    void* context,
+    YGPrintFunc print,
+    bool hasNewLayout,
+    YGNodeType nodeType,
+    YGMeasureFunc measure,
+    YGBaselineFunc baseline,
+    YGDirtiedFunc dirtied,
+    YGStyle style,
+    YGLayout layout,
+    uint32_t lineIndex,
+    YGNodeRef parent,
+    YGVector children,
+    YGNodeRef nextChild,
+    YGConfigRef config,
+    bool isDirty,
+    std::array<YGValue, 2> resolvedDimensions)
+    : context_(context),
+      print_(print),
+      hasNewLayout_(hasNewLayout),
+      nodeType_(nodeType),
+      measure_(measure),
+      baseline_(baseline),
+      dirtied_(dirtied),
+      style_(style),
+      layout_(layout),
+      lineIndex_(lineIndex),
+      parent_(parent),
+      children_(children),
+      nextChild_(nextChild),
+      config_(config),
+      isDirty_(isDirty),
+      resolvedDimensions_(resolvedDimensions) {}
+
+YGNode& YGNode::operator=(const YGNode& node) {
+  if (&node == this) {
+    return *this;
+  }
+
+  for (auto child : children_) {
+    delete child;
+  }
+
+  context_ = node.getContext();
+  print_ = node.getPrintFunc();
+  hasNewLayout_ = node.getHasNewLayout();
+  nodeType_ = node.getNodeType();
+  measure_ = node.getMeasure();
+  baseline_ = node.getBaseline();
+  dirtied_ = node.getDirtied();
+  style_ = node.style_;
+  layout_ = node.layout_;
+  lineIndex_ = node.getLineIndex();
+  parent_ = node.getParent();
+  children_ = node.getChildren();
+  nextChild_ = node.getNextChild();
+  config_ = node.getConfig();
+  isDirty_ = node.isDirty();
+  resolvedDimensions_ = node.getResolvedDimensions();
+
+  return *this;
+}
+
+YGValue YGNode::marginLeadingValue(const YGFlexDirection axis) const {
+  if (YGFlexDirectionIsRow(axis) &&
+      style_.margin[YGEdgeStart].unit != YGUnitUndefined) {
+    return style_.margin[YGEdgeStart];
+  } else {
+    return style_.margin[leading[axis]];
+  }
+}
+
+YGValue YGNode::marginTrailingValue(const YGFlexDirection axis) const {
+  if (YGFlexDirectionIsRow(axis) &&
+      style_.margin[YGEdgeEnd].unit != YGUnitUndefined) {
+    return style_.margin[YGEdgeEnd];
+  } else {
+    return style_.margin[trailing[axis]];
+  }
+}
+
+YGValue YGNode::resolveFlexBasisPtr() const {
+  YGValue flexBasis = style_.flexBasis;
+  if (flexBasis.unit != YGUnitAuto && flexBasis.unit != YGUnitUndefined) {
+    return flexBasis;
+  }
+  if (!YGFloatIsUndefined(style_.flex) && style_.flex > 0.0f) {
+    return config_->useWebDefaults ? YGValueAuto : YGValueZero;
+  }
+  return YGValueAuto;
+}
+
+void YGNode::resolveDimension() {
+  for (uint32_t dim = YGDimensionWidth; dim < YGDimensionCount; dim++) {
+    if (getStyle().maxDimensions[dim].unit != YGUnitUndefined &&
+        YGValueEqual(
+            getStyle().maxDimensions[dim], style_.minDimensions[dim])) {
+      resolvedDimensions_[dim] = style_.maxDimensions[dim];
+    } else {
+      resolvedDimensions_[dim] = style_.dimensions[dim];
+    }
+  }
+}
+
+YGDirection YGNode::resolveDirection(const YGDirection parentDirection) {
+  if (style_.direction == YGDirectionInherit) {
+    return parentDirection > YGDirectionInherit ? parentDirection
+                                                : YGDirectionLTR;
+  } else {
+    return style_.direction;
+  }
+}
+
+void YGNode::clearChildren() {
+  children_.clear();
+  children_.shrink_to_fit();
+}
+
+YGNode::~YGNode() {
+  // All the member variables are deallocated externally, so no need to
+  // deallocate here
+}
+
+// Other Methods
+
+void YGNode::cloneChildrenIfNeeded() {
+  // YGNodeRemoveChild in yoga.cpp has a forked variant of this algorithm
+  // optimized for deletions.
+
+  const uint32_t childCount = static_cast<uint32_t>(children_.size());
+  if (childCount == 0) {
+    // This is an empty set. Nothing to clone.
+    return;
+  }
+
+  const YGNodeRef firstChild = children_.front();
+  if (firstChild->getParent() == this) {
+    // If the first child has this node as its parent, we assume that it is
+    // already unique. We can do this because if we have it has a child, that
+    // means that its parent was at some point cloned which made that subtree
+    // immutable. We also assume that all its sibling are cloned as well.
+    return;
+  }
+
+  const YGNodeClonedFunc cloneNodeCallback = config_->cloneNodeCallback;
+  for (uint32_t i = 0; i < childCount; ++i) {
+    const YGNodeRef oldChild = children_[i];
+    const YGNodeRef newChild = YGNodeClone(oldChild);
+    replaceChild(newChild, i);
+    newChild->setParent(this);
+    if (cloneNodeCallback) {
+      cloneNodeCallback(oldChild, newChild, this, i);
+    }
+  }
+}
+
+void YGNode::markDirtyAndPropogate() {
+  if (!isDirty_) {
+    setDirty(true);
+    setLayoutComputedFlexBasis(YGUndefined);
+    if (parent_) {
+      parent_->markDirtyAndPropogate();
+    }
+  }
+}
+
+void YGNode::markDirtyAndPropogateDownwards() {
+  isDirty_ = true;
+  for_each(children_.begin(), children_.end(), [](YGNodeRef childNode) {
+    childNode->markDirtyAndPropogateDownwards();
+  });
+}
+
+float YGNode::resolveFlexGrow() {
+  // Root nodes flexGrow should always be 0
+  if (parent_ == nullptr) {
+    return 0.0;
+  }
+  if (!YGFloatIsUndefined(style_.flexGrow)) {
+    return style_.flexGrow;
+  }
+  if (!YGFloatIsUndefined(style_.flex) && style_.flex > 0.0f) {
+    return style_.flex;
+  }
+  return kDefaultFlexGrow;
+}
+
+float YGNode::resolveFlexShrink() {
+  if (parent_ == nullptr) {
+    return 0.0;
+  }
+  if (!YGFloatIsUndefined(style_.flexShrink)) {
+    return style_.flexShrink;
+  }
+  if (!config_->useWebDefaults && !YGFloatIsUndefined(style_.flex) &&
+      style_.flex < 0.0f) {
+    return -style_.flex;
+  }
+  return config_->useWebDefaults ? kWebDefaultFlexShrink : kDefaultFlexShrink;
+}
+
+bool YGNode::isNodeFlexible() {
+  return (
+      (style_.positionType == YGPositionTypeRelative) &&
+      (resolveFlexGrow() != 0 || resolveFlexShrink() != 0));
+}
+
+float YGNode::getLeadingBorder(const YGFlexDirection axis) {
+  if (YGFlexDirectionIsRow(axis) &&
+      style_.border[YGEdgeStart].unit != YGUnitUndefined &&
+      !YGFloatIsUndefined(style_.border[YGEdgeStart].value) &&
+      style_.border[YGEdgeStart].value >= 0.0f) {
+    return style_.border[YGEdgeStart].value;
+  }
+
+  float computedEdgeValue =
+      YGComputedEdgeValue(style_.border, leading[axis], &YGValueZero)->value;
+  return YGFloatMax(computedEdgeValue, 0.0f);
+}
+
+float YGNode::getTrailingBorder(const YGFlexDirection flexDirection) {
+  if (YGFlexDirectionIsRow(flexDirection) &&
+      style_.border[YGEdgeEnd].unit != YGUnitUndefined &&
+      !YGFloatIsUndefined(style_.border[YGEdgeEnd].value) &&
+      style_.border[YGEdgeEnd].value >= 0.0f) {
+    return style_.border[YGEdgeEnd].value;
+  }
+
+  float computedEdgeValue =
+      YGComputedEdgeValue(style_.border, trailing[flexDirection], &YGValueZero)
+          ->value;
+  return YGFloatMax(computedEdgeValue, 0.0f);
+}
+
+float YGNode::getLeadingPadding(
+    const YGFlexDirection axis,
+    const float widthSize) {
+  if (YGFlexDirectionIsRow(axis) &&
+      style_.padding[YGEdgeStart].unit != YGUnitUndefined &&
+      !YGFloatIsUndefined(
+          YGResolveValue(style_.padding[YGEdgeStart], widthSize)) &&
+      YGResolveValue(style_.padding[YGEdgeStart], widthSize) > 0.0f) {
+    return YGResolveValue(style_.padding[YGEdgeStart], widthSize);
+  }
+
+  float resolvedValue = YGResolveValue(
+      *YGComputedEdgeValue(style_.padding, leading[axis], &YGValueZero),
+      widthSize);
+  return YGFloatMax(resolvedValue, 0.0f);
+}
+
+float YGNode::getTrailingPadding(
+    const YGFlexDirection axis,
+    const float widthSize) {
+  if (YGFlexDirectionIsRow(axis) &&
+      style_.padding[YGEdgeEnd].unit != YGUnitUndefined &&
+      !YGFloatIsUndefined(
+          YGResolveValue(style_.padding[YGEdgeEnd], widthSize)) &&
+      YGResolveValue(style_.padding[YGEdgeEnd], widthSize) >= 0.0f) {
+    return YGResolveValue(style_.padding[YGEdgeEnd], widthSize);
+  }
+
+  float resolvedValue = YGResolveValue(
+      *YGComputedEdgeValue(style_.padding, trailing[axis], &YGValueZero),
+      widthSize);
+
+  return YGFloatMax(resolvedValue, 0.0f);
+}
+
+float YGNode::getLeadingPaddingAndBorder(
+    const YGFlexDirection axis,
+    const float widthSize) {
+  return getLeadingPadding(axis, widthSize) + getLeadingBorder(axis);
+}
+
+float YGNode::getTrailingPaddingAndBorder(
+    const YGFlexDirection axis,
+    const float widthSize) {
+  return getTrailingPadding(axis, widthSize) + getTrailingBorder(axis);
+}
+
+bool YGNode::didUseLegacyFlag() {
+  bool didUseLegacyFlag = layout_.didUseLegacyFlag;
+  if (didUseLegacyFlag) {
+    return true;
+  }
+  for (const auto& child : children_) {
+    if (child->layout_.didUseLegacyFlag) {
+      didUseLegacyFlag = true;
+      break;
+    }
+  }
+  return didUseLegacyFlag;
+}
+
+void YGNode::setAndPropogateUseLegacyFlag(bool useLegacyFlag) {
+  config_->useLegacyStretchBehaviour = useLegacyFlag;
+  for_each(children_.begin(), children_.end(), [=](YGNodeRef childNode) {
+    childNode->getConfig()->useLegacyStretchBehaviour = useLegacyFlag;
+  });
+}
+
+void YGNode::setLayoutDoesLegacyFlagAffectsLayout(
+    bool doesLegacyFlagAffectsLayout) {
+  layout_.doesLegacyStretchFlagAffectsLayout = doesLegacyFlagAffectsLayout;
+}
+
+void YGNode::setLayoutDidUseLegacyFlag(bool didUseLegacyFlag) {
+  layout_.didUseLegacyFlag = didUseLegacyFlag;
+}
+
+bool YGNode::isLayoutTreeEqualToNode(const YGNode& node) const {
+  if (children_.size() != node.children_.size()) {
+    return false;
+  }
+  if (layout_ != node.layout_) {
+    return false;
+  }
+  if (children_.size() == 0) {
+    return true;
+  }
+
+  bool isLayoutTreeEqual = true;
+  YGNodeRef otherNodeChildren = nullptr;
+  for (std::vector<YGNodeRef>::size_type i = 0; i < children_.size(); ++i) {
+    otherNodeChildren = node.children_[i];
+    isLayoutTreeEqual =
+        children_[i]->isLayoutTreeEqualToNode(*otherNodeChildren);
+    if (!isLayoutTreeEqual) {
+      return false;
+    }
+  }
+  return isLayoutTreeEqual;
+}

node_modules/react-native/ReactCommon/yoga/yoga/YGNode.h

@@ -0,0 +1,163 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+#include <stdio.h>
+#include "YGLayout.h"
+#include "YGStyle.h"
+#include "Yoga-internal.h"
+
+struct YGNode {
+ private:
+  void* context_;
+  YGPrintFunc print_;
+  bool hasNewLayout_;
+  YGNodeType nodeType_;
+  YGMeasureFunc measure_;
+  YGBaselineFunc baseline_;
+  YGDirtiedFunc dirtied_;
+  YGStyle style_;
+  YGLayout layout_;
+  uint32_t lineIndex_;
+  YGNodeRef parent_;
+  YGVector children_;
+  YGNodeRef nextChild_;
+  YGConfigRef config_;
+  bool isDirty_;
+  std::array<YGValue, 2> resolvedDimensions_;
+
+  float relativePosition(const YGFlexDirection axis, const float axisSize);
+
+ public:
+  YGNode();
+  ~YGNode();
+  explicit YGNode(const YGConfigRef newConfig);
+  YGNode(const YGNode& node);
+  YGNode& operator=(const YGNode& node);
+  YGNode(
+      void* context,
+      YGPrintFunc print,
+      bool hasNewLayout,
+      YGNodeType nodeType,
+      YGMeasureFunc measure,
+      YGBaselineFunc baseline,
+      YGDirtiedFunc dirtied,
+      YGStyle style,
+      YGLayout layout,
+      uint32_t lineIndex,
+      YGNodeRef parent,
+      YGVector children,
+      YGNodeRef nextChild,
+      YGConfigRef config,
+      bool isDirty,
+      std::array<YGValue, 2> resolvedDimensions);
+
+  // Getters
+  void* getContext() const;
+  YGPrintFunc getPrintFunc() const;
+  bool getHasNewLayout() const;
+  YGNodeType getNodeType() const;
+  YGMeasureFunc getMeasure() const;
+  YGBaselineFunc getBaseline() const;
+  YGDirtiedFunc getDirtied() const;
+  // For Performance reasons passing as reference.
+  YGStyle& getStyle();
+  // For Performance reasons passing as reference.
+  YGLayout& getLayout();
+  uint32_t getLineIndex() const;
+  YGNodeRef getParent() const;
+  YGVector getChildren() const;
+  uint32_t getChildrenCount() const;
+  YGNodeRef getChild(uint32_t index) const;
+  YGNodeRef getNextChild() const;
+  YGConfigRef getConfig() const;
+  bool isDirty() const;
+  std::array<YGValue, 2> getResolvedDimensions() const;
+  YGValue getResolvedDimension(int index);
+
+  // Methods related to positions, margin, padding and border
+  float getLeadingPosition(const YGFlexDirection axis, const float axisSize);
+  bool isLeadingPositionDefined(const YGFlexDirection axis);
+  bool isTrailingPosDefined(const YGFlexDirection axis);
+  float getTrailingPosition(const YGFlexDirection axis, const float axisSize);
+  float getLeadingMargin(const YGFlexDirection axis, const float widthSize);
+  float getTrailingMargin(const YGFlexDirection axis, const float widthSize);
+  float getLeadingBorder(const YGFlexDirection flexDirection);
+  float getTrailingBorder(const YGFlexDirection flexDirection);
+  float getLeadingPadding(const YGFlexDirection axis, const float widthSize);
+  float getTrailingPadding(const YGFlexDirection axis, const float widthSize);
+  float getLeadingPaddingAndBorder(
+      const YGFlexDirection axis,
+      const float widthSize);
+  float getTrailingPaddingAndBorder(
+      const YGFlexDirection axis,
+      const float widthSize);
+  float getMarginForAxis(const YGFlexDirection axis, const float widthSize);
+  // Setters
+
+  void setContext(void* context);
+  void setPrintFunc(YGPrintFunc printFunc);
+  void setHasNewLayout(bool hasNewLayout);
+  void setNodeType(YGNodeType nodeTye);
+  void setMeasureFunc(YGMeasureFunc measureFunc);
+  void setBaseLineFunc(YGBaselineFunc baseLineFunc);
+  void setDirtiedFunc(YGDirtiedFunc dirtiedFunc);
+  void setStyle(YGStyle style);
+  void setStyleFlexDirection(YGFlexDirection direction);
+  void setStyleAlignContent(YGAlign alignContent);
+  void setLayout(YGLayout layout);
+  void setLineIndex(uint32_t lineIndex);
+  void setParent(YGNodeRef parent);
+  void setChildren(YGVector children);
+  void setNextChild(YGNodeRef nextChild);
+  void setConfig(YGConfigRef config);
+  void setDirty(bool isDirty);
+  void setLayoutLastParentDirection(YGDirection direction);
+  void setLayoutComputedFlexBasis(float computedFlexBasis);
+  void setLayoutComputedFlexBasisGeneration(
+      uint32_t computedFlexBasisGeneration);
+  void setLayoutMeasuredDimension(float measuredDimension, int index);
+  void setLayoutHadOverflow(bool hadOverflow);
+  void setLayoutDimension(float dimension, int index);
+  void setLayoutDirection(YGDirection direction);
+  void setLayoutMargin(float margin, int index);
+  void setLayoutBorder(float border, int index);
+  void setLayoutPadding(float padding, int index);
+  void setLayoutPosition(float position, int index);
+  void setPosition(
+      const YGDirection direction,
+      const float mainSize,
+      const float crossSize,
+      const float parentWidth);
+  void setAndPropogateUseLegacyFlag(bool useLegacyFlag);
+  void setLayoutDoesLegacyFlagAffectsLayout(bool doesLegacyFlagAffectsLayout);
+  void setLayoutDidUseLegacyFlag(bool didUseLegacyFlag);
+  void markDirtyAndPropogateDownwards();
+
+  // Other methods
+  YGValue marginLeadingValue(const YGFlexDirection axis) const;
+  YGValue marginTrailingValue(const YGFlexDirection axis) const;
+  YGValue resolveFlexBasisPtr() const;
+  void resolveDimension();
+  YGDirection resolveDirection(const YGDirection parentDirection);
+  void clearChildren();
+  /// Replaces the occurrences of oldChild with newChild
+  void replaceChild(YGNodeRef oldChild, YGNodeRef newChild);
+  void replaceChild(YGNodeRef child, uint32_t index);
+  void insertChild(YGNodeRef child, uint32_t index);
+  /// Removes the first occurrence of child
+  bool removeChild(YGNodeRef child);
+  void removeChild(uint32_t index);
+
+  void cloneChildrenIfNeeded();
+  void markDirtyAndPropogate();
+  float resolveFlexGrow();
+  float resolveFlexShrink();
+  bool isNodeFlexible();
+  bool didUseLegacyFlag();
+  bool isLayoutTreeEqualToNode(const YGNode& node) const;
+};

node_modules/react-native/ReactCommon/yoga/yoga/YGNodePrint.cpp

@@ -0,0 +1,225 @@
+/*
+ * Copyright (c) 2017-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "YGNodePrint.h"
+#include <stdarg.h>
+#include "YGEnums.h"
+#include "YGNode.h"
+#include "Yoga-internal.h"
+
+namespace facebook {
+namespace yoga {
+typedef std::string string;
+
+static void indent(string* base, uint32_t level) {
+  for (uint32_t i = 0; i < level; ++i) {
+    base->append("  ");
+  }
+}
+
+static bool areFourValuesEqual(const std::array<YGValue, YGEdgeCount>& four) {
+  return YGValueEqual(four[0], four[1]) && YGValueEqual(four[0], four[2]) &&
+      YGValueEqual(four[0], four[3]);
+}
+
+static void appendFormatedString(string* str, const char* fmt, ...) {
+  va_list args;
+  va_start(args, fmt);
+  va_list argsCopy;
+  va_copy(argsCopy, args);
+  std::vector<char> buf(1 + vsnprintf(NULL, 0, fmt, args));
+  va_end(args);
+  vsnprintf(buf.data(), buf.size(), fmt, argsCopy);
+  va_end(argsCopy);
+  string result = string(buf.begin(), buf.end() - 1);
+  str->append(result);
+}
+
+static void
+appendFloatIfNotUndefined(string* base, const string key, const float num) {
+  if (!YGFloatIsUndefined(num)) {
+    appendFormatedString(base, "%s: %g; ", key.c_str(), num);
+  }
+}
+
+static void appendNumberIfNotUndefined(
+    string* base,
+    const string key,
+    const YGValue number) {
+  if (number.unit != YGUnitUndefined) {
+    if (number.unit == YGUnitAuto) {
+      base->append(key + ": auto; ");
+    } else {
+      string unit = number.unit == YGUnitPoint ? "px" : "%%";
+      appendFormatedString(
+          base, "%s: %g%s; ", key.c_str(), number.value, unit.c_str());
+    }
+  }
+}
+
+static void
+appendNumberIfNotAuto(string* base, const string& key, const YGValue number) {
+  if (number.unit != YGUnitAuto) {
+    appendNumberIfNotUndefined(base, key, number);
+  }
+}
+
+static void
+appendNumberIfNotZero(string* base, const string& str, const YGValue number) {
+  if (!YGFloatsEqual(number.value, 0)) {
+    appendNumberIfNotUndefined(base, str, number);
+  }
+}
+
+static void appendEdges(
+    string* base,
+    const string& key,
+    const std::array<YGValue, YGEdgeCount>& edges) {
+  if (areFourValuesEqual(edges)) {
+    appendNumberIfNotZero(base, key, edges[YGEdgeLeft]);
+  } else {
+    for (int edge = YGEdgeLeft; edge != YGEdgeAll; ++edge) {
+      string str = key + "-" + YGEdgeToString(static_cast<YGEdge>(edge));
+      appendNumberIfNotZero(base, str, edges[edge]);
+    }
+  }
+}
+
+static void appendEdgeIfNotUndefined(
+    string* base,
+    const string& str,
+    const std::array<YGValue, YGEdgeCount>& edges,
+    const YGEdge edge) {
+  appendNumberIfNotUndefined(
+      base, str, *YGComputedEdgeValue(edges, edge, &YGValueUndefined));
+}
+
+void YGNodeToString(
+    std::string* str,
+    YGNodeRef node,
+    YGPrintOptions options,
+    uint32_t level) {
+  indent(str, level);
+  appendFormatedString(str, "<div ");
+  if (node->getPrintFunc() != nullptr) {
+    node->getPrintFunc()(node);
+  }
+
+  if (options & YGPrintOptionsLayout) {
+    appendFormatedString(str, "layout=\"");
+    appendFormatedString(
+        str, "width: %g; ", node->getLayout().dimensions[YGDimensionWidth]);
+    appendFormatedString(
+        str, "height: %g; ", node->getLayout().dimensions[YGDimensionHeight]);
+    appendFormatedString(
+        str, "top: %g; ", node->getLayout().position[YGEdgeTop]);
+    appendFormatedString(
+        str, "left: %g;", node->getLayout().position[YGEdgeLeft]);
+    appendFormatedString(str, "\" ");
+  }
+
+  if (options & YGPrintOptionsStyle) {
+    appendFormatedString(str, "style=\"");
+    if (node->getStyle().flexDirection != YGNode().getStyle().flexDirection) {
+      appendFormatedString(
+          str,
+          "flex-direction: %s; ",
+          YGFlexDirectionToString(node->getStyle().flexDirection));
+    }
+    if (node->getStyle().justifyContent != YGNode().getStyle().justifyContent) {
+      appendFormatedString(
+          str,
+          "justify-content: %s; ",
+          YGJustifyToString(node->getStyle().justifyContent));
+    }
+    if (node->getStyle().alignItems != YGNode().getStyle().alignItems) {
+      appendFormatedString(
+          str,
+          "align-items: %s; ",
+          YGAlignToString(node->getStyle().alignItems));
+    }
+    if (node->getStyle().alignContent != YGNode().getStyle().alignContent) {
+      appendFormatedString(
+          str,
+          "align-content: %s; ",
+          YGAlignToString(node->getStyle().alignContent));
+    }
+    if (node->getStyle().alignSelf != YGNode().getStyle().alignSelf) {
+      appendFormatedString(
+          str, "align-self: %s; ", YGAlignToString(node->getStyle().alignSelf));
+    }
+    appendFloatIfNotUndefined(str, "flex-grow", node->getStyle().flexGrow);
+    appendFloatIfNotUndefined(str, "flex-shrink", node->getStyle().flexShrink);
+    appendNumberIfNotAuto(str, "flex-basis", node->getStyle().flexBasis);
+    appendFloatIfNotUndefined(str, "flex", node->getStyle().flex);
+
+    if (node->getStyle().flexWrap != YGNode().getStyle().flexWrap) {
+      appendFormatedString(
+          str, "flexWrap: %s; ", YGWrapToString(node->getStyle().flexWrap));
+    }
+
+    if (node->getStyle().overflow != YGNode().getStyle().overflow) {
+      appendFormatedString(
+          str, "overflow: %s; ", YGOverflowToString(node->getStyle().overflow));
+    }
+
+    if (node->getStyle().display != YGNode().getStyle().display) {
+      appendFormatedString(
+          str, "display: %s; ", YGDisplayToString(node->getStyle().display));
+    }
+    appendEdges(str, "margin", node->getStyle().margin);
+    appendEdges(str, "padding", node->getStyle().padding);
+    appendEdges(str, "border", node->getStyle().border);
+
+    appendNumberIfNotAuto(
+        str, "width", node->getStyle().dimensions[YGDimensionWidth]);
+    appendNumberIfNotAuto(
+        str, "height", node->getStyle().dimensions[YGDimensionHeight]);
+    appendNumberIfNotAuto(
+        str, "max-width", node->getStyle().maxDimensions[YGDimensionWidth]);
+    appendNumberIfNotAuto(
+        str, "max-height", node->getStyle().maxDimensions[YGDimensionHeight]);
+    appendNumberIfNotAuto(
+        str, "min-width", node->getStyle().minDimensions[YGDimensionWidth]);
+    appendNumberIfNotAuto(
+        str, "min-height", node->getStyle().minDimensions[YGDimensionHeight]);
+
+    if (node->getStyle().positionType != YGNode().getStyle().positionType) {
+      appendFormatedString(
+          str,
+          "position: %s; ",
+          YGPositionTypeToString(node->getStyle().positionType));
+    }
+
+    appendEdgeIfNotUndefined(
+        str, "left", node->getStyle().position, YGEdgeLeft);
+    appendEdgeIfNotUndefined(
+        str, "right", node->getStyle().position, YGEdgeRight);
+    appendEdgeIfNotUndefined(str, "top", node->getStyle().position, YGEdgeTop);
+    appendEdgeIfNotUndefined(
+        str, "bottom", node->getStyle().position, YGEdgeBottom);
+    appendFormatedString(str, "\" ");
+
+    if (node->getMeasure() != nullptr) {
+      appendFormatedString(str, "has-custom-measure=\"true\"");
+    }
+  }
+  appendFormatedString(str, ">");
+
+  const uint32_t childCount = static_cast<uint32_t>(node->getChildren().size());
+  if (options & YGPrintOptionsChildren && childCount > 0) {
+    for (uint32_t i = 0; i < childCount; i++) {
+      appendFormatedString(str, "\n");
+      YGNodeToString(str, YGNodeGetChild(node, i), options, level + 1);
+    }
+    appendFormatedString(str, "\n");
+    indent(str, level);
+  }
+  appendFormatedString(str, "</div>");
+}
+} // namespace yoga
+} // namespace facebook

node_modules/react-native/ReactCommon/yoga/yoga/YGNodePrint.h

@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+#pragma once
+#include <string>
+
+#include "Yoga.h"
+
+namespace facebook {
+namespace yoga {
+
+void YGNodeToString(
+    std::string* str,
+    YGNodeRef node,
+    YGPrintOptions options,
+    uint32_t level);
+
+} // namespace yoga
+} // namespace facebook

node_modules/react-native/ReactCommon/yoga/yoga/YGStyle.cpp

@@ -0,0 +1,100 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "YGStyle.h"
+
+const YGValue kYGValueUndefined = {YGUndefined, YGUnitUndefined};
+
+const YGValue kYGValueAuto = {YGUndefined, YGUnitAuto};
+
+const std::array<YGValue, YGEdgeCount> kYGDefaultEdgeValuesUnit = {
+    {kYGValueUndefined,
+     kYGValueUndefined,
+     kYGValueUndefined,
+     kYGValueUndefined,
+     kYGValueUndefined,
+     kYGValueUndefined,
+     kYGValueUndefined,
+     kYGValueUndefined,
+     kYGValueUndefined}};
+
+const std::array<YGValue, 2> kYGDefaultDimensionValuesAutoUnit = {
+    {kYGValueAuto, kYGValueAuto}};
+
+const std::array<YGValue, 2> kYGDefaultDimensionValuesUnit = {
+    {kYGValueUndefined, kYGValueUndefined}};
+
+YGStyle::YGStyle()
+    : direction(YGDirectionInherit),
+      flexDirection(YGFlexDirectionColumn),
+      justifyContent(YGJustifyFlexStart),
+      alignContent(YGAlignFlexStart),
+      alignItems(YGAlignStretch),
+      alignSelf(YGAlignAuto),
+      positionType(YGPositionTypeRelative),
+      flexWrap(YGWrapNoWrap),
+      overflow(YGOverflowVisible),
+      display(YGDisplayFlex),
+      flex(YGUndefined),
+      flexGrow(YGUndefined),
+      flexShrink(YGUndefined),
+      flexBasis(kYGValueAuto),
+      margin(kYGDefaultEdgeValuesUnit),
+      position(kYGDefaultEdgeValuesUnit),
+      padding(kYGDefaultEdgeValuesUnit),
+      border(kYGDefaultEdgeValuesUnit),
+      dimensions(kYGDefaultDimensionValuesAutoUnit),
+      minDimensions(kYGDefaultDimensionValuesUnit),
+      maxDimensions(kYGDefaultDimensionValuesUnit),
+      aspectRatio(YGUndefined) {}
+
+// Yoga specific properties, not compatible with flexbox specification
+bool YGStyle::operator==(const YGStyle& style) {
+  bool areNonFloatValuesEqual = direction == style.direction &&
+      flexDirection == style.flexDirection &&
+      justifyContent == style.justifyContent &&
+      alignContent == style.alignContent && alignItems == style.alignItems &&
+      alignSelf == style.alignSelf && positionType == style.positionType &&
+      flexWrap == style.flexWrap && overflow == style.overflow &&
+      display == style.display && YGValueEqual(flexBasis, style.flexBasis) &&
+      YGValueArrayEqual(margin, style.margin) &&
+      YGValueArrayEqual(position, style.position) &&
+      YGValueArrayEqual(padding, style.padding) &&
+      YGValueArrayEqual(border, style.border) &&
+      YGValueArrayEqual(dimensions, style.dimensions) &&
+      YGValueArrayEqual(minDimensions, style.minDimensions) &&
+      YGValueArrayEqual(maxDimensions, style.maxDimensions);
+
+  if (!(YGFloatIsUndefined(flex) && YGFloatIsUndefined(style.flex))) {
+    areNonFloatValuesEqual = areNonFloatValuesEqual && flex == style.flex;
+  }
+
+  if (!(YGFloatIsUndefined(flexGrow) && YGFloatIsUndefined(style.flexGrow))) {
+    areNonFloatValuesEqual =
+        areNonFloatValuesEqual && flexGrow == style.flexGrow;
+  }
+
+  if (!(YGFloatIsUndefined(flexShrink) &&
+        YGFloatIsUndefined(style.flexShrink))) {
+    areNonFloatValuesEqual =
+        areNonFloatValuesEqual && flexShrink == style.flexShrink;
+  }
+
+  if (!(YGFloatIsUndefined(aspectRatio) &&
+        YGFloatIsUndefined(style.aspectRatio))) {
+    areNonFloatValuesEqual =
+        areNonFloatValuesEqual && aspectRatio == style.aspectRatio;
+  }
+
+  return areNonFloatValuesEqual;
+}
+
+bool YGStyle::operator!=(YGStyle style) {
+  return !(*this == style);
+}
+
+YGStyle::~YGStyle() {}

node_modules/react-native/ReactCommon/yoga/yoga/YGStyle.h

@@ -0,0 +1,42 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+#include "Yoga-internal.h"
+#include "Yoga.h"
+
+struct YGStyle {
+  YGDirection direction;
+  YGFlexDirection flexDirection;
+  YGJustify justifyContent;
+  YGAlign alignContent;
+  YGAlign alignItems;
+  YGAlign alignSelf;
+  YGPositionType positionType;
+  YGWrap flexWrap;
+  YGOverflow overflow;
+  YGDisplay display;
+  float flex;
+  float flexGrow;
+  float flexShrink;
+  YGValue flexBasis;
+  std::array<YGValue, YGEdgeCount> margin;
+  std::array<YGValue, YGEdgeCount> position;
+  std::array<YGValue, YGEdgeCount> padding;
+  std::array<YGValue, YGEdgeCount> border;
+  std::array<YGValue, 2> dimensions;
+  std::array<YGValue, 2> minDimensions;
+  std::array<YGValue, 2> maxDimensions;
+  float aspectRatio;
+
+  YGStyle();
+  // Yoga specific properties, not compatible with flexbox specification
+  bool operator==(const YGStyle& style);
+
+  bool operator!=(YGStyle style);
+  ~YGStyle();
+};

node_modules/react-native/ReactCommon/yoga/yoga/Yoga-internal.h

@@ -0,0 +1,110 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <vector>
+#include "Yoga.h"
+
+using YGVector = std::vector<YGNodeRef>;
+
+YG_EXTERN_C_BEGIN
+
+WIN_EXPORT float YGRoundValueToPixelGrid(const float value,
+                                         const float pointScaleFactor,
+                                         const bool forceCeil,
+                                         const bool forceFloor);
+
+YG_EXTERN_C_END
+
+extern const std::array<YGEdge, 4> trailing;
+extern const std::array<YGEdge, 4> leading;
+extern bool YGValueEqual(const YGValue a, const YGValue b);
+extern const YGValue YGValueUndefined;
+extern const YGValue YGValueAuto;
+extern const YGValue YGValueZero;
+
+template <std::size_t size>
+bool YGValueArrayEqual(
+    const std::array<YGValue, size> val1,
+    const std::array<YGValue, size> val2) {
+  bool areEqual = true;
+  for (uint32_t i = 0; i < size && areEqual; ++i) {
+    areEqual = YGValueEqual(val1[i], val2[i]);
+  }
+  return areEqual;
+}
+
+struct YGCachedMeasurement {
+  float availableWidth;
+  float availableHeight;
+  YGMeasureMode widthMeasureMode;
+  YGMeasureMode heightMeasureMode;
+
+  float computedWidth;
+  float computedHeight;
+
+  YGCachedMeasurement()
+      : availableWidth(0),
+        availableHeight(0),
+        widthMeasureMode((YGMeasureMode)-1),
+        heightMeasureMode((YGMeasureMode)-1),
+        computedWidth(-1),
+        computedHeight(-1) {}
+
+  bool operator==(YGCachedMeasurement measurement) const {
+    bool isEqual = widthMeasureMode == measurement.widthMeasureMode &&
+        heightMeasureMode == measurement.heightMeasureMode;
+
+    if (!YGFloatIsUndefined(availableWidth) ||
+        !YGFloatIsUndefined(measurement.availableWidth)) {
+      isEqual = isEqual && availableWidth == measurement.availableWidth;
+    }
+    if (!YGFloatIsUndefined(availableHeight) ||
+        !YGFloatIsUndefined(measurement.availableHeight)) {
+      isEqual = isEqual && availableHeight == measurement.availableHeight;
+    }
+    if (!YGFloatIsUndefined(computedWidth) ||
+        !YGFloatIsUndefined(measurement.computedWidth)) {
+      isEqual = isEqual && computedWidth == measurement.computedWidth;
+    }
+    if (!YGFloatIsUndefined(computedHeight) ||
+        !YGFloatIsUndefined(measurement.computedHeight)) {
+      isEqual = isEqual && computedHeight == measurement.computedHeight;
+    }
+
+    return isEqual;
+  }
+};
+
+// This value was chosen based on empiracle data. Even the most complicated
+// layouts should not require more than 16 entries to fit within the cache.
+#define YG_MAX_CACHED_RESULT_COUNT 16
+
+struct YGConfig {
+  bool experimentalFeatures[YGExperimentalFeatureCount + 1];
+  bool useWebDefaults;
+  bool useLegacyStretchBehaviour;
+  bool shouldDiffLayoutWithoutLegacyStretchBehaviour;
+  float pointScaleFactor;
+  YGLogger logger;
+  YGNodeClonedFunc cloneNodeCallback;
+  void* context;
+};
+
+static const float kDefaultFlexGrow = 0.0f;
+static const float kDefaultFlexShrink = 0.0f;
+static const float kWebDefaultFlexShrink = 1.0f;
+
+extern bool YGFloatsEqual(const float a, const float b);
+extern bool YGValueEqual(const YGValue a, const YGValue b);
+extern const YGValue* YGComputedEdgeValue(
+    const std::array<YGValue, YGEdgeCount>& edges,
+    const YGEdge edge,
+    const YGValue* const defaultValue);

node_modules/react-native/ReactCommon/yoga/yoga/Yoga.h

@@ -0,0 +1,298 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <assert.h>
+#include <math.h>
+#include <stdarg.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifndef __cplusplus
+#include <stdbool.h>
+#endif
+
+/** Large positive number signifies that the property(float) is undefined.
+ *Earlier we used to have YGundefined as NAN, but the downside of this is that
+ *we can't use -ffast-math compiler flag as it assumes all floating-point
+ *calculation involve and result into finite numbers. For more information
+ *regarding -ffast-math compiler flag in clang, have a look at
+ *https://clang.llvm.org/docs/UsersManual.html#cmdoption-ffast-math
+ **/
+#define YGUndefined 10E20F
+
+#include "YGEnums.h"
+#include "YGMacros.h"
+
+YG_EXTERN_C_BEGIN
+
+typedef struct YGSize {
+  float width;
+  float height;
+} YGSize;
+
+typedef struct YGValue {
+  float value;
+  YGUnit unit;
+} YGValue;
+
+extern const YGValue YGValueUndefined;
+extern const YGValue YGValueAuto;
+
+typedef struct YGConfig *YGConfigRef;
+
+typedef struct YGNode* YGNodeRef;
+
+typedef YGSize (*YGMeasureFunc)(YGNodeRef node,
+                                float width,
+                                YGMeasureMode widthMode,
+                                float height,
+                                YGMeasureMode heightMode);
+typedef float (*YGBaselineFunc)(YGNodeRef node, const float width, const float height);
+typedef void (*YGDirtiedFunc)(YGNodeRef node);
+typedef void (*YGPrintFunc)(YGNodeRef node);
+typedef int (*YGLogger)(const YGConfigRef config,
+                        const YGNodeRef node,
+                        YGLogLevel level,
+                        const char *format,
+                        va_list args);
+typedef void (*YGNodeClonedFunc)(YGNodeRef oldNode,
+                                 YGNodeRef newNode,
+                                 YGNodeRef parent,
+                                 int childIndex);
+
+// YGNode
+WIN_EXPORT YGNodeRef YGNodeNew(void);
+WIN_EXPORT YGNodeRef YGNodeNewWithConfig(const YGConfigRef config);
+WIN_EXPORT YGNodeRef YGNodeClone(const YGNodeRef node);
+WIN_EXPORT void YGNodeFree(const YGNodeRef node);
+WIN_EXPORT void YGNodeFreeRecursive(const YGNodeRef node);
+WIN_EXPORT void YGNodeReset(const YGNodeRef node);
+WIN_EXPORT int32_t YGNodeGetInstanceCount(void);
+
+WIN_EXPORT void YGNodeInsertChild(const YGNodeRef node,
+                                  const YGNodeRef child,
+                                  const uint32_t index);
+WIN_EXPORT void YGNodeRemoveChild(const YGNodeRef node, const YGNodeRef child);
+WIN_EXPORT void YGNodeRemoveAllChildren(const YGNodeRef node);
+WIN_EXPORT YGNodeRef YGNodeGetChild(const YGNodeRef node, const uint32_t index);
+WIN_EXPORT YGNodeRef YGNodeGetParent(const YGNodeRef node);
+WIN_EXPORT uint32_t YGNodeGetChildCount(const YGNodeRef node);
+
+WIN_EXPORT void YGNodeCalculateLayout(const YGNodeRef node,
+                                      const float availableWidth,
+                                      const float availableHeight,
+                                      const YGDirection parentDirection);
+
+// Mark a node as dirty. Only valid for nodes with a custom measure function
+// set.
+// YG knows when to mark all other nodes as dirty but because nodes with
+// measure functions
+// depends on information not known to YG they must perform this dirty
+// marking manually.
+WIN_EXPORT void YGNodeMarkDirty(const YGNodeRef node);
+
+// This function marks the current node and all its descendants as dirty. This function is added to test yoga benchmarks.
+// This function is not expected to be used in production as calling `YGCalculateLayout` will cause the recalculation of each and every node.
+WIN_EXPORT void YGNodeMarkDirtyAndPropogateToDescendants(const YGNodeRef node);
+
+WIN_EXPORT void YGNodePrint(const YGNodeRef node, const YGPrintOptions options);
+
+WIN_EXPORT bool YGFloatIsUndefined(const float value);
+
+WIN_EXPORT bool YGNodeCanUseCachedMeasurement(const YGMeasureMode widthMode,
+                                              const float width,
+                                              const YGMeasureMode heightMode,
+                                              const float height,
+                                              const YGMeasureMode lastWidthMode,
+                                              const float lastWidth,
+                                              const YGMeasureMode lastHeightMode,
+                                              const float lastHeight,
+                                              const float lastComputedWidth,
+                                              const float lastComputedHeight,
+                                              const float marginRow,
+                                              const float marginColumn,
+                                              const YGConfigRef config);
+
+WIN_EXPORT void YGNodeCopyStyle(const YGNodeRef dstNode, const YGNodeRef srcNode);
+
+#define YG_NODE_PROPERTY(type, name, paramName)                          \
+  WIN_EXPORT void YGNodeSet##name(const YGNodeRef node, type paramName); \
+  WIN_EXPORT type YGNodeGet##name(const YGNodeRef node);
+
+#define YG_NODE_STYLE_PROPERTY(type, name, paramName)                               \
+  WIN_EXPORT void YGNodeStyleSet##name(const YGNodeRef node, const type paramName); \
+  WIN_EXPORT type YGNodeStyleGet##name(const YGNodeRef node);
+
+#define YG_NODE_STYLE_PROPERTY_UNIT(type, name, paramName)                                    \
+  WIN_EXPORT void YGNodeStyleSet##name(const YGNodeRef node, const float paramName);          \
+  WIN_EXPORT void YGNodeStyleSet##name##Percent(const YGNodeRef node, const float paramName); \
+  WIN_EXPORT type YGNodeStyleGet##name(const YGNodeRef node);
+
+#define YG_NODE_STYLE_PROPERTY_UNIT_AUTO(type, name, paramName) \
+  YG_NODE_STYLE_PROPERTY_UNIT(type, name, paramName)            \
+  WIN_EXPORT void YGNodeStyleSet##name##Auto(const YGNodeRef node);
+
+#define YG_NODE_STYLE_EDGE_PROPERTY(type, name, paramName)    \
+  WIN_EXPORT void YGNodeStyleSet##name(const YGNodeRef node,  \
+                                       const YGEdge edge,     \
+                                       const type paramName); \
+  WIN_EXPORT type YGNodeStyleGet##name(const YGNodeRef node, const YGEdge edge);
+
+#define YG_NODE_STYLE_EDGE_PROPERTY_UNIT(type, name, paramName)         \
+  WIN_EXPORT void YGNodeStyleSet##name(const YGNodeRef node,            \
+                                       const YGEdge edge,               \
+                                       const float paramName);          \
+  WIN_EXPORT void YGNodeStyleSet##name##Percent(const YGNodeRef node,   \
+                                                const YGEdge edge,      \
+                                                const float paramName); \
+  WIN_EXPORT WIN_STRUCT(type) YGNodeStyleGet##name(const YGNodeRef node, const YGEdge edge);
+
+#define YG_NODE_STYLE_EDGE_PROPERTY_UNIT_AUTO(type, name) \
+  WIN_EXPORT void YGNodeStyleSet##name##Auto(const YGNodeRef node, const YGEdge edge);
+
+#define YG_NODE_LAYOUT_PROPERTY(type, name) \
+  WIN_EXPORT type YGNodeLayoutGet##name(const YGNodeRef node);
+
+#define YG_NODE_LAYOUT_EDGE_PROPERTY(type, name) \
+  WIN_EXPORT type YGNodeLayoutGet##name(const YGNodeRef node, const YGEdge edge);
+
+void* YGNodeGetContext(YGNodeRef node);
+void YGNodeSetContext(YGNodeRef node, void* context);
+YGMeasureFunc YGNodeGetMeasureFunc(YGNodeRef node);
+void YGNodeSetMeasureFunc(YGNodeRef node, YGMeasureFunc measureFunc);
+YGBaselineFunc YGNodeGetBaselineFunc(YGNodeRef node);
+void YGNodeSetBaselineFunc(YGNodeRef node, YGBaselineFunc baselineFunc);
+YGDirtiedFunc YGNodeGetDirtiedFunc(YGNodeRef node);
+void YGNodeSetDirtiedFunc(YGNodeRef node, YGDirtiedFunc dirtiedFunc);
+YGPrintFunc YGNodeGetPrintFunc(YGNodeRef node);
+void YGNodeSetPrintFunc(YGNodeRef node, YGPrintFunc printFunc);
+bool YGNodeGetHasNewLayout(YGNodeRef node);
+void YGNodeSetHasNewLayout(YGNodeRef node, bool hasNewLayout);
+YGNodeType YGNodeGetNodeType(YGNodeRef node);
+void YGNodeSetNodeType(YGNodeRef node, YGNodeType nodeType);
+bool YGNodeIsDirty(YGNodeRef node);
+bool YGNodeLayoutGetDidUseLegacyFlag(const YGNodeRef node);
+
+YG_NODE_STYLE_PROPERTY(YGDirection, Direction, direction);
+YG_NODE_STYLE_PROPERTY(YGFlexDirection, FlexDirection, flexDirection);
+YG_NODE_STYLE_PROPERTY(YGJustify, JustifyContent, justifyContent);
+YG_NODE_STYLE_PROPERTY(YGAlign, AlignContent, alignContent);
+YG_NODE_STYLE_PROPERTY(YGAlign, AlignItems, alignItems);
+YG_NODE_STYLE_PROPERTY(YGAlign, AlignSelf, alignSelf);
+YG_NODE_STYLE_PROPERTY(YGPositionType, PositionType, positionType);
+YG_NODE_STYLE_PROPERTY(YGWrap, FlexWrap, flexWrap);
+YG_NODE_STYLE_PROPERTY(YGOverflow, Overflow, overflow);
+YG_NODE_STYLE_PROPERTY(YGDisplay, Display, display);
+
+YG_NODE_STYLE_PROPERTY(float, Flex, flex);
+YG_NODE_STYLE_PROPERTY(float, FlexGrow, flexGrow);
+YG_NODE_STYLE_PROPERTY(float, FlexShrink, flexShrink);
+YG_NODE_STYLE_PROPERTY_UNIT_AUTO(YGValue, FlexBasis, flexBasis);
+
+YG_NODE_STYLE_EDGE_PROPERTY_UNIT(YGValue, Position, position);
+YG_NODE_STYLE_EDGE_PROPERTY_UNIT(YGValue, Margin, margin);
+YG_NODE_STYLE_EDGE_PROPERTY_UNIT_AUTO(YGValue, Margin);
+YG_NODE_STYLE_EDGE_PROPERTY_UNIT(YGValue, Padding, padding);
+YG_NODE_STYLE_EDGE_PROPERTY(float, Border, border);
+
+YG_NODE_STYLE_PROPERTY_UNIT_AUTO(YGValue, Width, width);
+YG_NODE_STYLE_PROPERTY_UNIT_AUTO(YGValue, Height, height);
+YG_NODE_STYLE_PROPERTY_UNIT(YGValue, MinWidth, minWidth);
+YG_NODE_STYLE_PROPERTY_UNIT(YGValue, MinHeight, minHeight);
+YG_NODE_STYLE_PROPERTY_UNIT(YGValue, MaxWidth, maxWidth);
+YG_NODE_STYLE_PROPERTY_UNIT(YGValue, MaxHeight, maxHeight);
+
+// Yoga specific properties, not compatible with flexbox specification
+// Aspect ratio control the size of the undefined dimension of a node.
+// Aspect ratio is encoded as a floating point value width/height. e.g. A value of 2 leads to a node
+// with a width twice the size of its height while a value of 0.5 gives the opposite effect.
+//
+// - On a node with a set width/height aspect ratio control the size of the unset dimension
+// - On a node with a set flex basis aspect ratio controls the size of the node in the cross axis if
+// unset
+// - On a node with a measure function aspect ratio works as though the measure function measures
+// the flex basis
+// - On a node with flex grow/shrink aspect ratio controls the size of the node in the cross axis if
+// unset
+// - Aspect ratio takes min/max dimensions into account
+YG_NODE_STYLE_PROPERTY(float, AspectRatio, aspectRatio);
+
+YG_NODE_LAYOUT_PROPERTY(float, Left);
+YG_NODE_LAYOUT_PROPERTY(float, Top);
+YG_NODE_LAYOUT_PROPERTY(float, Right);
+YG_NODE_LAYOUT_PROPERTY(float, Bottom);
+YG_NODE_LAYOUT_PROPERTY(float, Width);
+YG_NODE_LAYOUT_PROPERTY(float, Height);
+YG_NODE_LAYOUT_PROPERTY(YGDirection, Direction);
+YG_NODE_LAYOUT_PROPERTY(bool, HadOverflow);
+
+// Get the computed values for these nodes after performing layout. If they were set using
+// point values then the returned value will be the same as YGNodeStyleGetXXX. However if
+// they were set using a percentage value then the returned value is the computed value used
+// during layout.
+YG_NODE_LAYOUT_EDGE_PROPERTY(float, Margin);
+YG_NODE_LAYOUT_EDGE_PROPERTY(float, Border);
+YG_NODE_LAYOUT_EDGE_PROPERTY(float, Padding);
+
+WIN_EXPORT void YGConfigSetLogger(const YGConfigRef config, YGLogger logger);
+WIN_EXPORT void YGLog(const YGNodeRef node, YGLogLevel level, const char *message, ...);
+WIN_EXPORT void YGLogWithConfig(const YGConfigRef config, YGLogLevel level, const char *format, ...);
+WIN_EXPORT void YGAssert(const bool condition, const char *message);
+WIN_EXPORT void YGAssertWithNode(const YGNodeRef node, const bool condition, const char *message);
+WIN_EXPORT void YGAssertWithConfig(const YGConfigRef config,
+                                   const bool condition,
+                                   const char *message);
+
+// Set this to number of pixels in 1 point to round calculation results
+// If you want to avoid rounding - set PointScaleFactor to 0
+WIN_EXPORT void YGConfigSetPointScaleFactor(const YGConfigRef config, const float pixelsInPoint);
+
+// Yoga previously had an error where containers would take the maximum space possible instead of
+// the minimum
+// like they are supposed to. In practice this resulted in implicit behaviour similar to align-self:
+// stretch;
+// Because this was such a long-standing bug we must allow legacy users to switch back to this
+// behaviour.
+WIN_EXPORT void YGConfigSetUseLegacyStretchBehaviour(const YGConfigRef config,
+                                                     const bool useLegacyStretchBehaviour);
+
+// YGConfig
+WIN_EXPORT YGConfigRef YGConfigNew(void);
+WIN_EXPORT void YGConfigFree(const YGConfigRef config);
+WIN_EXPORT void YGConfigCopy(const YGConfigRef dest, const YGConfigRef src);
+WIN_EXPORT int32_t YGConfigGetInstanceCount(void);
+
+WIN_EXPORT void YGConfigSetExperimentalFeatureEnabled(const YGConfigRef config,
+                                                      const YGExperimentalFeature feature,
+                                                      const bool enabled);
+WIN_EXPORT bool YGConfigIsExperimentalFeatureEnabled(const YGConfigRef config,
+                                                     const YGExperimentalFeature feature);
+
+// Using the web defaults is the prefered configuration for new projects.
+// Usage of non web defaults should be considered as legacy.
+WIN_EXPORT void YGConfigSetUseWebDefaults(const YGConfigRef config, const bool enabled);
+WIN_EXPORT bool YGConfigGetUseWebDefaults(const YGConfigRef config);
+
+WIN_EXPORT void YGConfigSetNodeClonedFunc(const YGConfigRef config,
+                                          const YGNodeClonedFunc callback);
+
+// Export only for C#
+WIN_EXPORT YGConfigRef YGConfigGetDefault(void);
+
+WIN_EXPORT void YGConfigSetContext(const YGConfigRef config, void *context);
+WIN_EXPORT void *YGConfigGetContext(const YGConfigRef config);
+
+WIN_EXPORT float YGRoundValueToPixelGrid(
+    const float value,
+    const float pointScaleFactor,
+    const bool forceCeil,
+    const bool forceFloor);
+
+YG_EXTERN_C_END