./set-version.py 3.2.1

Summary:
Pull Request resolved: https://github.com/facebook/yoga/pull/1766

While we added support for 16K pages for yoga through React Native,
the standalone version we upload to Maven Central wasn't handled.
This fixes it.

Reviewed By: NickGerleman

Differential Revision: D66975933

fbshipit-source-id: 36a8404e2f2a60a44b9a39e478b23d1829bc542e

Yoga.podspec

@@ -6,7 +6,7 @@
 
 Pod::Spec.new do |spec|
   spec.name = 'Yoga'
-  spec.version = '0.0.0'
+  spec.version = '3.2.1'
   spec.license =  { :type => 'MIT', :file => "LICENSE" }
   spec.homepage = 'https://yogalayout.dev/'
   spec.documentation_url = 'https://yogalayout.dev/docs'

build.gradle

@@ -6,8 +6,8 @@
  */
 
 plugins {
-    id("com.android.library") version "8.2.1" apply false
-    id("com.android.application") version "8.2.1" apply false
+    id("com.android.library") version "8.7.1" apply false
+    id("com.android.application") version "8.7.1" apply false
     id("io.github.gradle-nexus.publish-plugin") version "1.3.0"
 }
 

enums.py

@@ -31,7 +31,7 @@ ENUMS = {
         "SpaceEvenly",
     ],
     "PositionType": ["Static", "Relative", "Absolute"],
-    "Display": ["Flex", "None"],
+    "Display": ["Flex", "None", "Contents"],
     "Wrap": ["NoWrap", "Wrap", "WrapReverse"],
     "BoxSizing": ["BorderBox", "ContentBox"],
     "MeasureMode": ["Undefined", "Exactly", "AtMost"],
@@ -61,9 +61,10 @@ ENUMS = {
         # Allows main-axis flex basis to be stretched without flexGrow being
         # set (previously referred to as "UseLegacyStretchBehaviour")
         ("StretchFlexBasis", 1 << 0),
-        # Positioning of absolute nodes will have various bugs related to
-        # justification, alignment, and insets
-        ("AbsolutePositioningIncorrect", 1 << 1),
+        # Absolute position in a given axis will be relative to the padding
+        # edge of the parent container instead of the content edge when a
+        # specific inset (top/bottom/left/right) is not set.
+        ("AbsolutePositionWithoutInsetsExcludesPadding", 1 << 1),
         # Absolute nodes will resolve percentages against the inner size of
         # their containing node, not the padding box
         ("AbsolutePercentAgainstInnerSize", 1 << 2),

gentest/fixtures/YGAlignContentTest.html

@@ -448,3 +448,32 @@
   </div>
   <div style="height: 50px; width: 50px; margin-left: 20px;"></div>
 </div>
+
+<div id="align_content_stretch_and_align_items_flex_end_with_flex_wrap"
+  style="width: 300px; height: 300px; flex-direction: row; flex-wrap: wrap; align-content: stretch;align-items: flex-end;">
+  <div style="height: 50px; width: 150px; align-self: flex-start;"></div>
+  <div style="height: 100px; width: 120px;"></div>
+  <div style="height: 50px; width: 120px;"></div>
+</div>
+
+
+<div id="align_content_stretch_and_align_items_flex_start_with_flex_wrap"
+  style="width: 300px; height: 300px; flex-direction: row; flex-wrap: wrap; align-content: stretch;align-items: flex-start;">
+  <div style="height: 50px; width: 150px; align-self: flex-end;"></div>
+  <div style="height: 100px; width: 120px;"></div>
+  <div style="height: 50px; width: 120px;"></div>
+</div>
+
+<div id="align_content_stretch_and_align_items_center_with_flex_wrap"
+  style="width: 300px; height: 300px; flex-direction: row; flex-wrap: wrap; align-content: stretch;align-items: center;">
+  <div style="height: 50px; width: 150px; align-self: flex-end;"></div>
+  <div style="height: 100px; width: 120px;"></div>
+  <div style="height: 50px; width: 120px;"></div>
+</div>
+
+<div id="align_content_stretch_and_align_items_stretch_with_flex_wrap"
+  style="width: 300px; height: 300px; flex-direction: row; flex-wrap: wrap; align-content: stretch;align-items: stretch;">
+  <div style="height: 50px; width: 150px; align-self: flex-end;"></div>
+  <div style="height: 100px; width: 120px;"></div>
+  <div style="height: 50px; width: 120px;"></div>
+</div>

gentest/fixtures/YGDisplayTest.html

@@ -29,3 +29,61 @@
 <div id="display_none_with_position_absolute" style="width: 100px; height: 100px;">
   <div style="display:none; position: absolute; width: 100px; height: 100px"></div>
 </div>
+
+<div id="display_contents" style="width: 100px; height: 100px; flex-direction: row;">
+  <div style="display: contents;">
+    <div style="flex: 1; height: 10px;"></div>
+    <div style="flex: 1; height: 20px;"></div>
+  </div>
+</div>
+
+<div id="display_contents_fixed_size" style="width: 100px; height: 100px; flex-direction: row;">
+  <div style="display: contents; width: 50px; height: 50px;">
+    <div style="flex: 1; height: 10px;"></div>
+    <div style="flex: 1; height: 20px;"></div>
+  </div>
+</div>
+
+<div id="display_contents_with_margin" style="width: 100px; height: 100px; flex-direction: row;">
+  <div style="width: 20px; height: 20px; display: contents; margin: 10px;"></div>
+  <div style="flex-grow: 1;"></div>
+</div>
+
+<div id="display_contents_with_padding" style="width: 100px; height: 100px; flex-direction: row;">
+  <div style="display: contents; padding: 10px;">
+    <div style="flex: 1; height: 10px;"></div>
+    <div style="flex: 1; height: 20px;"></div>
+  </div>
+</div>
+
+<div id="display_contents_with_position" style="width: 100px; height: 100px; flex-direction: row;">
+  <div style="display: contents; top: 10px;">
+    <div style="flex: 1; height: 10px;"></div>
+    <div style="flex: 1; height: 20px;"></div>
+  </div>
+</div>
+
+<div id="display_contents_with_position_absolute" style="width: 100px; height: 100px; flex-direction: row;">
+  <div style="display: contents; position: absolute; width: 50px; height: 50px;">
+    <div style="flex: 1; height: 10px;"></div>
+    <div style="flex: 1; height: 20px;"></div>
+  </div>
+</div>
+
+<div id="display_contents_nested" style="width: 100px; height: 100px; flex-direction: row;">
+  <div style="display: contents;">
+    <div style="display: contents;">
+      <div style="flex: 1; height: 10px;"></div>
+      <div style="flex: 1; height: 20px;"></div>
+    </div>
+  </div>
+</div>
+
+<div id="display_contents_with_siblings" style="width: 100px; height: 100px; flex-direction: row;">
+  <div style="flex: 1; height: 30px;"></div>
+  <div style="display: contents;">
+    <div style="flex: 1; height: 10px;"></div>
+    <div style="flex: 1; height: 20px;"></div>
+  </div>
+  <div style="flex: 1; height: 30px;"></div>
+</div>

gentest/fixtures/YGJustifyContentTest.html

@@ -157,13 +157,15 @@
   <div style="width: 40px;"></div>
 </div>
 
-<div id="justify_content_overflow_row_reverse_space_around" style="width: 102px; height: 102px; flex-direction: row-reverse; justify-content: space-around;">
+<!-- TODO T208209388: fallback to start vs flexstart in overflowed cases -->
+<div data-disabled="true" id="justify_content_overflow_row_reverse_space_around" style="width: 102px; height: 102px; flex-direction: row-reverse; justify-content: space-around;">
   <div style="width: 40px;"></div>
   <div style="width: 40px;"></div>
   <div style="width: 40px;"></div>
 </div>
 
-<div id="justify_content_overflow_row_reverse_space_evenly" style="width: 102px; height: 102px; flex-direction: row-reverse; justify-content: space-evenly;">
+<!-- TODO T208209388: fallback to start vs flexstart in overflowed cases -->
+<div data-disabled="true" id="justify_content_overflow_row_reverse_space_evenly" style="width: 102px; height: 102px; flex-direction: row-reverse; justify-content: space-evenly;">
   <div style="width: 40px;"></div>
   <div style="width: 40px;"></div>
   <div style="width: 40px;"></div>

gentest/gentest-cpp.js

@@ -160,6 +160,7 @@ CPPEmitter.prototype = Object.create(Emitter.prototype, {
 
   YGDisplayFlex: {value: 'YGDisplayFlex'},
   YGDisplayNone: {value: 'YGDisplayNone'},
+  YGDisplayContents: {value: 'YGDisplayContents'},
   YGAuto: {value: 'YGAuto'},
 
   YGNodeCalculateLayout: {

gentest/gentest-java.js

@@ -195,6 +195,7 @@ JavaEmitter.prototype = Object.create(Emitter.prototype, {
 
   YGDisplayFlex: {value: 'YogaDisplay.FLEX'},
   YGDisplayNone: {value: 'YogaDisplay.NONE'},
+  YGDisplayContents: {value: 'YogaDisplay.CONTENTS'},
   YGAuto: {value: 'YogaConstants.AUTO'},
 
   YGWrapNoWrap: {value: 'YogaWrap.NO_WRAP'},

gentest/gentest-javascript.js

@@ -171,6 +171,7 @@ JavascriptEmitter.prototype = Object.create(Emitter.prototype, {
 
   YGDisplayFlex: {value: 'Display.Flex'},
   YGDisplayNone: {value: 'Display.None'},
+  YGDisplayContents: {value: 'Display.Contents'},
 
   YGBoxSizingBorderBox: {value: 'BoxSizing.BorderBox'},
   YGBoxSizingContentBox: {value: 'BoxSizing.ContentBox'},

gentest/gentest.js

@@ -665,6 +665,8 @@ function displayValue(e, value) {
       return e.YGDisplayFlex;
     case 'none':
       return e.YGDisplayNone;
+    case 'contents':
+      return e.YGDisplayContents;
   }
 }
 

gradle.properties

@@ -11,4 +11,4 @@ android.useAndroidX=true
 
 org.gradle.jvmargs=-Xmx1536M
 
-VERSION_NAME=0.0.0
+VERSION_NAME=3.2.1

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.3-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.9-all.zip
 networkTimeout=10000
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

java/build.gradle.kts

@@ -23,13 +23,14 @@ android {
   namespace = "com.facebook.yoga"
   compileSdk = 35
   buildToolsVersion = "35.0.0"
-  ndkVersion = "26.0.10792818"
+  ndkVersion = "27.1.12297006"
 
   defaultConfig {
     minSdk = 21
     consumerProguardFiles("proguard-rules.pro")
 
     ndk { abiFilters.addAll(setOf("x86", "x86_64", "armeabi-v7a", "arm64-v8a")) }
+    externalNativeBuild { cmake { arguments("-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON") } }
   }
 
   externalNativeBuild { cmake { path("CMakeLists.txt") } }

java/com/facebook/yoga/YogaDisplay.java

@@ -11,7 +11,8 @@ package com.facebook.yoga;
 
 public enum YogaDisplay {
   FLEX(0),
-  NONE(1);
+  NONE(1),
+  CONTENTS(2);
 
   private final int mIntValue;
 
@@ -27,6 +28,7 @@ public enum YogaDisplay {
     switch (value) {
       case 0: return FLEX;
       case 1: return NONE;
+      case 2: return CONTENTS;
       default: throw new IllegalArgumentException("Unknown enum value: " + value);
     }
   }

java/com/facebook/yoga/YogaErrata.java

@@ -12,7 +12,7 @@ package com.facebook.yoga;
 public enum YogaErrata {
   NONE(0),
   STRETCH_FLEX_BASIS(1),
-  ABSOLUTE_POSITIONING_INCORRECT(2),
+  ABSOLUTE_POSITION_WITHOUT_INSETS_EXCLUDES_PADDING(2),
   ABSOLUTE_PERCENT_AGAINST_INNER_SIZE(4),
   ALL(2147483647),
   CLASSIC(2147483646);
@@ -31,7 +31,7 @@ public enum YogaErrata {
     switch (value) {
       case 0: return NONE;
       case 1: return STRETCH_FLEX_BASIS;
-      case 2: return ABSOLUTE_POSITIONING_INCORRECT;
+      case 2: return ABSOLUTE_POSITION_WITHOUT_INSETS_EXCLUDES_PADDING;
       case 4: return ABSOLUTE_PERCENT_AGAINST_INNER_SIZE;
       case 2147483647: return ALL;
       case 2147483646: return CLASSIC;

java/tests/generated/com/facebook/yoga/YGAlignContentTest.java

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<c85d60ce23aa6d921d52316d3ff35f17>>
+ * @generated SignedSource<<cafd5a49032616243a68af66ae440904>>
  * generated by gentest/gentest-driver.ts from gentest/fixtures/YGAlignContentTest.html
  */
 
@@ -5207,6 +5207,305 @@ public class YGAlignContentTest {
     assertEquals(50f, root_child2.getLayoutHeight(), 0.0f);
   }
 
+  @Test
+  public void test_align_content_stretch_and_align_items_flex_end_with_flex_wrap() {
+    YogaConfig config = YogaConfigFactory.create();
+
+    final YogaNode root = createNode(config);
+    root.setFlexDirection(YogaFlexDirection.ROW);
+    root.setAlignContent(YogaAlign.STRETCH);
+    root.setAlignItems(YogaAlign.FLEX_END);
+    root.setPositionType(YogaPositionType.ABSOLUTE);
+    root.setWrap(YogaWrap.WRAP);
+    root.setWidth(300f);
+    root.setHeight(300f);
+
+    final YogaNode root_child0 = createNode(config);
+    root_child0.setAlignSelf(YogaAlign.FLEX_START);
+    root_child0.setWidth(150f);
+    root_child0.setHeight(50f);
+    root.addChildAt(root_child0, 0);
+
+    final YogaNode root_child1 = createNode(config);
+    root_child1.setWidth(120f);
+    root_child1.setHeight(100f);
+    root.addChildAt(root_child1, 1);
+
+    final YogaNode root_child2 = createNode(config);
+    root_child2.setWidth(120f);
+    root_child2.setHeight(50f);
+    root.addChildAt(root_child2, 2);
+    root.setDirection(YogaDirection.LTR);
+    root.calculateLayout(YogaConstants.UNDEFINED, YogaConstants.UNDEFINED);
+
+    assertEquals(0f, root.getLayoutX(), 0.0f);
+    assertEquals(0f, root.getLayoutY(), 0.0f);
+    assertEquals(300f, root.getLayoutWidth(), 0.0f);
+    assertEquals(300f, root.getLayoutHeight(), 0.0f);
+
+    assertEquals(0f, root_child0.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutY(), 0.0f);
+    assertEquals(150f, root_child0.getLayoutWidth(), 0.0f);
+    assertEquals(50f, root_child0.getLayoutHeight(), 0.0f);
+
+    assertEquals(150f, root_child1.getLayoutX(), 0.0f);
+    assertEquals(75f, root_child1.getLayoutY(), 0.0f);
+    assertEquals(120f, root_child1.getLayoutWidth(), 0.0f);
+    assertEquals(100f, root_child1.getLayoutHeight(), 0.0f);
+
+    assertEquals(0f, root_child2.getLayoutX(), 0.0f);
+    assertEquals(250f, root_child2.getLayoutY(), 0.0f);
+    assertEquals(120f, root_child2.getLayoutWidth(), 0.0f);
+    assertEquals(50f, root_child2.getLayoutHeight(), 0.0f);
+
+    root.setDirection(YogaDirection.RTL);
+    root.calculateLayout(YogaConstants.UNDEFINED, YogaConstants.UNDEFINED);
+
+    assertEquals(0f, root.getLayoutX(), 0.0f);
+    assertEquals(0f, root.getLayoutY(), 0.0f);
+    assertEquals(300f, root.getLayoutWidth(), 0.0f);
+    assertEquals(300f, root.getLayoutHeight(), 0.0f);
+
+    assertEquals(150f, root_child0.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutY(), 0.0f);
+    assertEquals(150f, root_child0.getLayoutWidth(), 0.0f);
+    assertEquals(50f, root_child0.getLayoutHeight(), 0.0f);
+
+    assertEquals(30f, root_child1.getLayoutX(), 0.0f);
+    assertEquals(75f, root_child1.getLayoutY(), 0.0f);
+    assertEquals(120f, root_child1.getLayoutWidth(), 0.0f);
+    assertEquals(100f, root_child1.getLayoutHeight(), 0.0f);
+
+    assertEquals(180f, root_child2.getLayoutX(), 0.0f);
+    assertEquals(250f, root_child2.getLayoutY(), 0.0f);
+    assertEquals(120f, root_child2.getLayoutWidth(), 0.0f);
+    assertEquals(50f, root_child2.getLayoutHeight(), 0.0f);
+  }
+
+  @Test
+  public void test_align_content_stretch_and_align_items_flex_start_with_flex_wrap() {
+    YogaConfig config = YogaConfigFactory.create();
+
+    final YogaNode root = createNode(config);
+    root.setFlexDirection(YogaFlexDirection.ROW);
+    root.setAlignContent(YogaAlign.STRETCH);
+    root.setAlignItems(YogaAlign.FLEX_START);
+    root.setPositionType(YogaPositionType.ABSOLUTE);
+    root.setWrap(YogaWrap.WRAP);
+    root.setWidth(300f);
+    root.setHeight(300f);
+
+    final YogaNode root_child0 = createNode(config);
+    root_child0.setAlignSelf(YogaAlign.FLEX_END);
+    root_child0.setWidth(150f);
+    root_child0.setHeight(50f);
+    root.addChildAt(root_child0, 0);
+
+    final YogaNode root_child1 = createNode(config);
+    root_child1.setWidth(120f);
+    root_child1.setHeight(100f);
+    root.addChildAt(root_child1, 1);
+
+    final YogaNode root_child2 = createNode(config);
+    root_child2.setWidth(120f);
+    root_child2.setHeight(50f);
+    root.addChildAt(root_child2, 2);
+    root.setDirection(YogaDirection.LTR);
+    root.calculateLayout(YogaConstants.UNDEFINED, YogaConstants.UNDEFINED);
+
+    assertEquals(0f, root.getLayoutX(), 0.0f);
+    assertEquals(0f, root.getLayoutY(), 0.0f);
+    assertEquals(300f, root.getLayoutWidth(), 0.0f);
+    assertEquals(300f, root.getLayoutHeight(), 0.0f);
+
+    assertEquals(0f, root_child0.getLayoutX(), 0.0f);
+    assertEquals(125f, root_child0.getLayoutY(), 0.0f);
+    assertEquals(150f, root_child0.getLayoutWidth(), 0.0f);
+    assertEquals(50f, root_child0.getLayoutHeight(), 0.0f);
+
+    assertEquals(150f, root_child1.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child1.getLayoutY(), 0.0f);
+    assertEquals(120f, root_child1.getLayoutWidth(), 0.0f);
+    assertEquals(100f, root_child1.getLayoutHeight(), 0.0f);
+
+    assertEquals(0f, root_child2.getLayoutX(), 0.0f);
+    assertEquals(175f, root_child2.getLayoutY(), 0.0f);
+    assertEquals(120f, root_child2.getLayoutWidth(), 0.0f);
+    assertEquals(50f, root_child2.getLayoutHeight(), 0.0f);
+
+    root.setDirection(YogaDirection.RTL);
+    root.calculateLayout(YogaConstants.UNDEFINED, YogaConstants.UNDEFINED);
+
+    assertEquals(0f, root.getLayoutX(), 0.0f);
+    assertEquals(0f, root.getLayoutY(), 0.0f);
+    assertEquals(300f, root.getLayoutWidth(), 0.0f);
+    assertEquals(300f, root.getLayoutHeight(), 0.0f);
+
+    assertEquals(150f, root_child0.getLayoutX(), 0.0f);
+    assertEquals(125f, root_child0.getLayoutY(), 0.0f);
+    assertEquals(150f, root_child0.getLayoutWidth(), 0.0f);
+    assertEquals(50f, root_child0.getLayoutHeight(), 0.0f);
+
+    assertEquals(30f, root_child1.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child1.getLayoutY(), 0.0f);
+    assertEquals(120f, root_child1.getLayoutWidth(), 0.0f);
+    assertEquals(100f, root_child1.getLayoutHeight(), 0.0f);
+
+    assertEquals(180f, root_child2.getLayoutX(), 0.0f);
+    assertEquals(175f, root_child2.getLayoutY(), 0.0f);
+    assertEquals(120f, root_child2.getLayoutWidth(), 0.0f);
+    assertEquals(50f, root_child2.getLayoutHeight(), 0.0f);
+  }
+
+  @Test
+  public void test_align_content_stretch_and_align_items_center_with_flex_wrap() {
+    YogaConfig config = YogaConfigFactory.create();
+
+    final YogaNode root = createNode(config);
+    root.setFlexDirection(YogaFlexDirection.ROW);
+    root.setAlignContent(YogaAlign.STRETCH);
+    root.setAlignItems(YogaAlign.CENTER);
+    root.setPositionType(YogaPositionType.ABSOLUTE);
+    root.setWrap(YogaWrap.WRAP);
+    root.setWidth(300f);
+    root.setHeight(300f);
+
+    final YogaNode root_child0 = createNode(config);
+    root_child0.setAlignSelf(YogaAlign.FLEX_END);
+    root_child0.setWidth(150f);
+    root_child0.setHeight(50f);
+    root.addChildAt(root_child0, 0);
+
+    final YogaNode root_child1 = createNode(config);
+    root_child1.setWidth(120f);
+    root_child1.setHeight(100f);
+    root.addChildAt(root_child1, 1);
+
+    final YogaNode root_child2 = createNode(config);
+    root_child2.setWidth(120f);
+    root_child2.setHeight(50f);
+    root.addChildAt(root_child2, 2);
+    root.setDirection(YogaDirection.LTR);
+    root.calculateLayout(YogaConstants.UNDEFINED, YogaConstants.UNDEFINED);
+
+    assertEquals(0f, root.getLayoutX(), 0.0f);
+    assertEquals(0f, root.getLayoutY(), 0.0f);
+    assertEquals(300f, root.getLayoutWidth(), 0.0f);
+    assertEquals(300f, root.getLayoutHeight(), 0.0f);
+
+    assertEquals(0f, root_child0.getLayoutX(), 0.0f);
+    assertEquals(125f, root_child0.getLayoutY(), 0.0f);
+    assertEquals(150f, root_child0.getLayoutWidth(), 0.0f);
+    assertEquals(50f, root_child0.getLayoutHeight(), 0.0f);
+
+    assertEquals(150f, root_child1.getLayoutX(), 0.0f);
+    assertEquals(38f, root_child1.getLayoutY(), 0.0f);
+    assertEquals(120f, root_child1.getLayoutWidth(), 0.0f);
+    assertEquals(100f, root_child1.getLayoutHeight(), 0.0f);
+
+    assertEquals(0f, root_child2.getLayoutX(), 0.0f);
+    assertEquals(213f, root_child2.getLayoutY(), 0.0f);
+    assertEquals(120f, root_child2.getLayoutWidth(), 0.0f);
+    assertEquals(50f, root_child2.getLayoutHeight(), 0.0f);
+
+    root.setDirection(YogaDirection.RTL);
+    root.calculateLayout(YogaConstants.UNDEFINED, YogaConstants.UNDEFINED);
+
+    assertEquals(0f, root.getLayoutX(), 0.0f);
+    assertEquals(0f, root.getLayoutY(), 0.0f);
+    assertEquals(300f, root.getLayoutWidth(), 0.0f);
+    assertEquals(300f, root.getLayoutHeight(), 0.0f);
+
+    assertEquals(150f, root_child0.getLayoutX(), 0.0f);
+    assertEquals(125f, root_child0.getLayoutY(), 0.0f);
+    assertEquals(150f, root_child0.getLayoutWidth(), 0.0f);
+    assertEquals(50f, root_child0.getLayoutHeight(), 0.0f);
+
+    assertEquals(30f, root_child1.getLayoutX(), 0.0f);
+    assertEquals(38f, root_child1.getLayoutY(), 0.0f);
+    assertEquals(120f, root_child1.getLayoutWidth(), 0.0f);
+    assertEquals(100f, root_child1.getLayoutHeight(), 0.0f);
+
+    assertEquals(180f, root_child2.getLayoutX(), 0.0f);
+    assertEquals(213f, root_child2.getLayoutY(), 0.0f);
+    assertEquals(120f, root_child2.getLayoutWidth(), 0.0f);
+    assertEquals(50f, root_child2.getLayoutHeight(), 0.0f);
+  }
+
+  @Test
+  public void test_align_content_stretch_and_align_items_stretch_with_flex_wrap() {
+    YogaConfig config = YogaConfigFactory.create();
+
+    final YogaNode root = createNode(config);
+    root.setFlexDirection(YogaFlexDirection.ROW);
+    root.setAlignContent(YogaAlign.STRETCH);
+    root.setPositionType(YogaPositionType.ABSOLUTE);
+    root.setWrap(YogaWrap.WRAP);
+    root.setWidth(300f);
+    root.setHeight(300f);
+
+    final YogaNode root_child0 = createNode(config);
+    root_child0.setAlignSelf(YogaAlign.FLEX_END);
+    root_child0.setWidth(150f);
+    root_child0.setHeight(50f);
+    root.addChildAt(root_child0, 0);
+
+    final YogaNode root_child1 = createNode(config);
+    root_child1.setWidth(120f);
+    root_child1.setHeight(100f);
+    root.addChildAt(root_child1, 1);
+
+    final YogaNode root_child2 = createNode(config);
+    root_child2.setWidth(120f);
+    root_child2.setHeight(50f);
+    root.addChildAt(root_child2, 2);
+    root.setDirection(YogaDirection.LTR);
+    root.calculateLayout(YogaConstants.UNDEFINED, YogaConstants.UNDEFINED);
+
+    assertEquals(0f, root.getLayoutX(), 0.0f);
+    assertEquals(0f, root.getLayoutY(), 0.0f);
+    assertEquals(300f, root.getLayoutWidth(), 0.0f);
+    assertEquals(300f, root.getLayoutHeight(), 0.0f);
+
+    assertEquals(0f, root_child0.getLayoutX(), 0.0f);
+    assertEquals(125f, root_child0.getLayoutY(), 0.0f);
+    assertEquals(150f, root_child0.getLayoutWidth(), 0.0f);
+    assertEquals(50f, root_child0.getLayoutHeight(), 0.0f);
+
+    assertEquals(150f, root_child1.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child1.getLayoutY(), 0.0f);
+    assertEquals(120f, root_child1.getLayoutWidth(), 0.0f);
+    assertEquals(100f, root_child1.getLayoutHeight(), 0.0f);
+
+    assertEquals(0f, root_child2.getLayoutX(), 0.0f);
+    assertEquals(175f, root_child2.getLayoutY(), 0.0f);
+    assertEquals(120f, root_child2.getLayoutWidth(), 0.0f);
+    assertEquals(50f, root_child2.getLayoutHeight(), 0.0f);
+
+    root.setDirection(YogaDirection.RTL);
+    root.calculateLayout(YogaConstants.UNDEFINED, YogaConstants.UNDEFINED);
+
+    assertEquals(0f, root.getLayoutX(), 0.0f);
+    assertEquals(0f, root.getLayoutY(), 0.0f);
+    assertEquals(300f, root.getLayoutWidth(), 0.0f);
+    assertEquals(300f, root.getLayoutHeight(), 0.0f);
+
+    assertEquals(150f, root_child0.getLayoutX(), 0.0f);
+    assertEquals(125f, root_child0.getLayoutY(), 0.0f);
+    assertEquals(150f, root_child0.getLayoutWidth(), 0.0f);
+    assertEquals(50f, root_child0.getLayoutHeight(), 0.0f);
+
+    assertEquals(30f, root_child1.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child1.getLayoutY(), 0.0f);
+    assertEquals(120f, root_child1.getLayoutWidth(), 0.0f);
+    assertEquals(100f, root_child1.getLayoutHeight(), 0.0f);
+
+    assertEquals(180f, root_child2.getLayoutX(), 0.0f);
+    assertEquals(175f, root_child2.getLayoutY(), 0.0f);
+    assertEquals(120f, root_child2.getLayoutWidth(), 0.0f);
+    assertEquals(50f, root_child2.getLayoutHeight(), 0.0f);
+  }
+
   private YogaNode createNode(YogaConfig config) {
     return mNodeFactory.create(config);
   }

java/tests/generated/com/facebook/yoga/YGDisplayContentsTest.java

@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @generated SignedSource<<be0d102e74e15f15050520f21afcaee1>>
+ * generated by gentest/gentest-driver.ts from gentest/fixtures/YGDisplayContentsTest.html
+ */
+
+package com.facebook.yoga;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import com.facebook.yoga.utils.TestUtils;
+
+@RunWith(Parameterized.class)
+public class YGDisplayContentsTest {
+  @Parameterized.Parameters(name = "{0}")
+  public static Iterable<TestParametrization.NodeFactory> nodeFactories() {
+    return TestParametrization.nodeFactories();
+  }
+
+  @Parameterized.Parameter public TestParametrization.NodeFactory mNodeFactory;
+
+  @Test
+  public void test_test1() {
+    YogaConfig config = YogaConfigFactory.create();
+
+    final YogaNode root = createNode(config);
+    root.setFlexDirection(YogaFlexDirection.ROW);
+    root.setPositionType(YogaPositionType.ABSOLUTE);
+    root.setWidth(100f);
+    root.setHeight(100f);
+
+    final YogaNode root_child0 = createNode(config);
+    root_child0.setDisplay(YogaDisplay.CONTENTS);
+    root.addChildAt(root_child0, 0);
+
+    final YogaNode root_child0_child0 = createNode(config);
+    root_child0_child0.setFlexGrow(1f);
+    root_child0_child0.setFlexShrink(1f);
+    root_child0_child0.setFlexBasisPercent(0f);
+    root_child0_child0.setHeight(10f);
+    root_child0.addChildAt(root_child0_child0, 0);
+
+    final YogaNode root_child0_child1 = createNode(config);
+    root_child0_child1.setFlexGrow(1f);
+    root_child0_child1.setFlexShrink(1f);
+    root_child0_child1.setFlexBasisPercent(0f);
+    root_child0_child1.setHeight(20f);
+    root_child0.addChildAt(root_child0_child1, 1);
+    root.setDirection(YogaDirection.LTR);
+    root.calculateLayout(YogaConstants.UNDEFINED, YogaConstants.UNDEFINED);
+
+    assertEquals(0f, root.getLayoutX(), 0.0f);
+    assertEquals(0f, root.getLayoutY(), 0.0f);
+    assertEquals(100f, root.getLayoutWidth(), 0.0f);
+    assertEquals(100f, root.getLayoutHeight(), 0.0f);
+
+    assertEquals(0f, root_child0.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutY(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutWidth(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutHeight(), 0.0f);
+
+    assertEquals(0f, root_child0_child0.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0_child0.getLayoutY(), 0.0f);
+    assertEquals(50f, root_child0_child0.getLayoutWidth(), 0.0f);
+    assertEquals(10f, root_child0_child0.getLayoutHeight(), 0.0f);
+
+    assertEquals(50f, root_child0_child1.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0_child1.getLayoutY(), 0.0f);
+    assertEquals(50f, root_child0_child1.getLayoutWidth(), 0.0f);
+    assertEquals(20f, root_child0_child1.getLayoutHeight(), 0.0f);
+
+    root.setDirection(YogaDirection.RTL);
+    root.calculateLayout(YogaConstants.UNDEFINED, YogaConstants.UNDEFINED);
+
+    assertEquals(0f, root.getLayoutX(), 0.0f);
+    assertEquals(0f, root.getLayoutY(), 0.0f);
+    assertEquals(100f, root.getLayoutWidth(), 0.0f);
+    assertEquals(100f, root.getLayoutHeight(), 0.0f);
+
+    assertEquals(0f, root_child0.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutY(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutWidth(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutHeight(), 0.0f);
+
+    assertEquals(50f, root_child0_child0.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0_child0.getLayoutY(), 0.0f);
+    assertEquals(50f, root_child0_child0.getLayoutWidth(), 0.0f);
+    assertEquals(10f, root_child0_child0.getLayoutHeight(), 0.0f);
+
+    assertEquals(0f, root_child0_child1.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0_child1.getLayoutY(), 0.0f);
+    assertEquals(50f, root_child0_child1.getLayoutWidth(), 0.0f);
+    assertEquals(20f, root_child0_child1.getLayoutHeight(), 0.0f);
+  }
+
+  private YogaNode createNode(YogaConfig config) {
+    return mNodeFactory.create(config);
+  }
+}

java/tests/generated/com/facebook/yoga/YGDisplayTest.java

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<8db61c1e5703262c1afcf489be4d6abf>>
+ * @generated SignedSource<<4c1ad4613638039be1599a39a766a2bc>>
  * generated by gentest/gentest-driver.ts from gentest/fixtures/YGDisplayTest.html
  */
 
@@ -388,6 +388,642 @@ public class YGDisplayTest {
     assertEquals(0f, root_child0.getLayoutHeight(), 0.0f);
   }
 
+  @Test
+  public void test_display_contents() {
+    YogaConfig config = YogaConfigFactory.create();
+
+    final YogaNode root = createNode(config);
+    root.setFlexDirection(YogaFlexDirection.ROW);
+    root.setPositionType(YogaPositionType.ABSOLUTE);
+    root.setWidth(100f);
+    root.setHeight(100f);
+
+    final YogaNode root_child0 = createNode(config);
+    root_child0.setDisplay(YogaDisplay.CONTENTS);
+    root.addChildAt(root_child0, 0);
+
+    final YogaNode root_child0_child0 = createNode(config);
+    root_child0_child0.setFlexGrow(1f);
+    root_child0_child0.setFlexShrink(1f);
+    root_child0_child0.setFlexBasisPercent(0f);
+    root_child0_child0.setHeight(10f);
+    root_child0.addChildAt(root_child0_child0, 0);
+
+    final YogaNode root_child0_child1 = createNode(config);
+    root_child0_child1.setFlexGrow(1f);
+    root_child0_child1.setFlexShrink(1f);
+    root_child0_child1.setFlexBasisPercent(0f);
+    root_child0_child1.setHeight(20f);
+    root_child0.addChildAt(root_child0_child1, 1);
+    root.setDirection(YogaDirection.LTR);
+    root.calculateLayout(YogaConstants.UNDEFINED, YogaConstants.UNDEFINED);
+
+    assertEquals(0f, root.getLayoutX(), 0.0f);
+    assertEquals(0f, root.getLayoutY(), 0.0f);
+    assertEquals(100f, root.getLayoutWidth(), 0.0f);
+    assertEquals(100f, root.getLayoutHeight(), 0.0f);
+
+    assertEquals(0f, root_child0.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutY(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutWidth(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutHeight(), 0.0f);
+
+    assertEquals(0f, root_child0_child0.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0_child0.getLayoutY(), 0.0f);
+    assertEquals(50f, root_child0_child0.getLayoutWidth(), 0.0f);
+    assertEquals(10f, root_child0_child0.getLayoutHeight(), 0.0f);
+
+    assertEquals(50f, root_child0_child1.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0_child1.getLayoutY(), 0.0f);
+    assertEquals(50f, root_child0_child1.getLayoutWidth(), 0.0f);
+    assertEquals(20f, root_child0_child1.getLayoutHeight(), 0.0f);
+
+    root.setDirection(YogaDirection.RTL);
+    root.calculateLayout(YogaConstants.UNDEFINED, YogaConstants.UNDEFINED);
+
+    assertEquals(0f, root.getLayoutX(), 0.0f);
+    assertEquals(0f, root.getLayoutY(), 0.0f);
+    assertEquals(100f, root.getLayoutWidth(), 0.0f);
+    assertEquals(100f, root.getLayoutHeight(), 0.0f);
+
+    assertEquals(0f, root_child0.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutY(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutWidth(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutHeight(), 0.0f);
+
+    assertEquals(50f, root_child0_child0.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0_child0.getLayoutY(), 0.0f);
+    assertEquals(50f, root_child0_child0.getLayoutWidth(), 0.0f);
+    assertEquals(10f, root_child0_child0.getLayoutHeight(), 0.0f);
+
+    assertEquals(0f, root_child0_child1.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0_child1.getLayoutY(), 0.0f);
+    assertEquals(50f, root_child0_child1.getLayoutWidth(), 0.0f);
+    assertEquals(20f, root_child0_child1.getLayoutHeight(), 0.0f);
+  }
+
+  @Test
+  public void test_display_contents_fixed_size() {
+    YogaConfig config = YogaConfigFactory.create();
+
+    final YogaNode root = createNode(config);
+    root.setFlexDirection(YogaFlexDirection.ROW);
+    root.setPositionType(YogaPositionType.ABSOLUTE);
+    root.setWidth(100f);
+    root.setHeight(100f);
+
+    final YogaNode root_child0 = createNode(config);
+    root_child0.setWidth(50f);
+    root_child0.setHeight(50f);
+    root_child0.setDisplay(YogaDisplay.CONTENTS);
+    root.addChildAt(root_child0, 0);
+
+    final YogaNode root_child0_child0 = createNode(config);
+    root_child0_child0.setFlexGrow(1f);
+    root_child0_child0.setFlexShrink(1f);
+    root_child0_child0.setFlexBasisPercent(0f);
+    root_child0_child0.setHeight(10f);
+    root_child0.addChildAt(root_child0_child0, 0);
+
+    final YogaNode root_child0_child1 = createNode(config);
+    root_child0_child1.setFlexGrow(1f);
+    root_child0_child1.setFlexShrink(1f);
+    root_child0_child1.setFlexBasisPercent(0f);
+    root_child0_child1.setHeight(20f);
+    root_child0.addChildAt(root_child0_child1, 1);
+    root.setDirection(YogaDirection.LTR);
+    root.calculateLayout(YogaConstants.UNDEFINED, YogaConstants.UNDEFINED);
+
+    assertEquals(0f, root.getLayoutX(), 0.0f);
+    assertEquals(0f, root.getLayoutY(), 0.0f);
+    assertEquals(100f, root.getLayoutWidth(), 0.0f);
+    assertEquals(100f, root.getLayoutHeight(), 0.0f);
+
+    assertEquals(0f, root_child0.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutY(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutWidth(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutHeight(), 0.0f);
+
+    assertEquals(0f, root_child0_child0.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0_child0.getLayoutY(), 0.0f);
+    assertEquals(50f, root_child0_child0.getLayoutWidth(), 0.0f);
+    assertEquals(10f, root_child0_child0.getLayoutHeight(), 0.0f);
+
+    assertEquals(50f, root_child0_child1.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0_child1.getLayoutY(), 0.0f);
+    assertEquals(50f, root_child0_child1.getLayoutWidth(), 0.0f);
+    assertEquals(20f, root_child0_child1.getLayoutHeight(), 0.0f);
+
+    root.setDirection(YogaDirection.RTL);
+    root.calculateLayout(YogaConstants.UNDEFINED, YogaConstants.UNDEFINED);
+
+    assertEquals(0f, root.getLayoutX(), 0.0f);
+    assertEquals(0f, root.getLayoutY(), 0.0f);
+    assertEquals(100f, root.getLayoutWidth(), 0.0f);
+    assertEquals(100f, root.getLayoutHeight(), 0.0f);
+
+    assertEquals(0f, root_child0.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutY(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutWidth(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutHeight(), 0.0f);
+
+    assertEquals(50f, root_child0_child0.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0_child0.getLayoutY(), 0.0f);
+    assertEquals(50f, root_child0_child0.getLayoutWidth(), 0.0f);
+    assertEquals(10f, root_child0_child0.getLayoutHeight(), 0.0f);
+
+    assertEquals(0f, root_child0_child1.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0_child1.getLayoutY(), 0.0f);
+    assertEquals(50f, root_child0_child1.getLayoutWidth(), 0.0f);
+    assertEquals(20f, root_child0_child1.getLayoutHeight(), 0.0f);
+  }
+
+  @Test
+  public void test_display_contents_with_margin() {
+    YogaConfig config = YogaConfigFactory.create();
+
+    final YogaNode root = createNode(config);
+    root.setFlexDirection(YogaFlexDirection.ROW);
+    root.setPositionType(YogaPositionType.ABSOLUTE);
+    root.setWidth(100f);
+    root.setHeight(100f);
+
+    final YogaNode root_child0 = createNode(config);
+    root_child0.setMargin(YogaEdge.LEFT, 10f);
+    root_child0.setMargin(YogaEdge.TOP, 10f);
+    root_child0.setMargin(YogaEdge.RIGHT, 10f);
+    root_child0.setMargin(YogaEdge.BOTTOM, 10f);
+    root_child0.setWidth(20f);
+    root_child0.setHeight(20f);
+    root_child0.setDisplay(YogaDisplay.CONTENTS);
+    root.addChildAt(root_child0, 0);
+
+    final YogaNode root_child1 = createNode(config);
+    root_child1.setFlexGrow(1f);
+    root.addChildAt(root_child1, 1);
+    root.setDirection(YogaDirection.LTR);
+    root.calculateLayout(YogaConstants.UNDEFINED, YogaConstants.UNDEFINED);
+
+    assertEquals(0f, root.getLayoutX(), 0.0f);
+    assertEquals(0f, root.getLayoutY(), 0.0f);
+    assertEquals(100f, root.getLayoutWidth(), 0.0f);
+    assertEquals(100f, root.getLayoutHeight(), 0.0f);
+
+    assertEquals(0f, root_child0.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutY(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutWidth(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutHeight(), 0.0f);
+
+    assertEquals(0f, root_child1.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child1.getLayoutY(), 0.0f);
+    assertEquals(100f, root_child1.getLayoutWidth(), 0.0f);
+    assertEquals(100f, root_child1.getLayoutHeight(), 0.0f);
+
+    root.setDirection(YogaDirection.RTL);
+    root.calculateLayout(YogaConstants.UNDEFINED, YogaConstants.UNDEFINED);
+
+    assertEquals(0f, root.getLayoutX(), 0.0f);
+    assertEquals(0f, root.getLayoutY(), 0.0f);
+    assertEquals(100f, root.getLayoutWidth(), 0.0f);
+    assertEquals(100f, root.getLayoutHeight(), 0.0f);
+
+    assertEquals(0f, root_child0.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutY(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutWidth(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutHeight(), 0.0f);
+
+    assertEquals(0f, root_child1.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child1.getLayoutY(), 0.0f);
+    assertEquals(100f, root_child1.getLayoutWidth(), 0.0f);
+    assertEquals(100f, root_child1.getLayoutHeight(), 0.0f);
+  }
+
+  @Test
+  public void test_display_contents_with_padding() {
+    YogaConfig config = YogaConfigFactory.create();
+
+    final YogaNode root = createNode(config);
+    root.setFlexDirection(YogaFlexDirection.ROW);
+    root.setPositionType(YogaPositionType.ABSOLUTE);
+    root.setWidth(100f);
+    root.setHeight(100f);
+
+    final YogaNode root_child0 = createNode(config);
+    root_child0.setPadding(YogaEdge.LEFT, 10);
+    root_child0.setPadding(YogaEdge.TOP, 10);
+    root_child0.setPadding(YogaEdge.RIGHT, 10);
+    root_child0.setPadding(YogaEdge.BOTTOM, 10);
+    root_child0.setDisplay(YogaDisplay.CONTENTS);
+    root.addChildAt(root_child0, 0);
+
+    final YogaNode root_child0_child0 = createNode(config);
+    root_child0_child0.setFlexGrow(1f);
+    root_child0_child0.setFlexShrink(1f);
+    root_child0_child0.setFlexBasisPercent(0f);
+    root_child0_child0.setHeight(10f);
+    root_child0.addChildAt(root_child0_child0, 0);
+
+    final YogaNode root_child0_child1 = createNode(config);
+    root_child0_child1.setFlexGrow(1f);
+    root_child0_child1.setFlexShrink(1f);
+    root_child0_child1.setFlexBasisPercent(0f);
+    root_child0_child1.setHeight(20f);
+    root_child0.addChildAt(root_child0_child1, 1);
+    root.setDirection(YogaDirection.LTR);
+    root.calculateLayout(YogaConstants.UNDEFINED, YogaConstants.UNDEFINED);
+
+    assertEquals(0f, root.getLayoutX(), 0.0f);
+    assertEquals(0f, root.getLayoutY(), 0.0f);
+    assertEquals(100f, root.getLayoutWidth(), 0.0f);
+    assertEquals(100f, root.getLayoutHeight(), 0.0f);
+
+    assertEquals(0f, root_child0.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutY(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutWidth(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutHeight(), 0.0f);
+
+    assertEquals(0f, root_child0_child0.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0_child0.getLayoutY(), 0.0f);
+    assertEquals(50f, root_child0_child0.getLayoutWidth(), 0.0f);
+    assertEquals(10f, root_child0_child0.getLayoutHeight(), 0.0f);
+
+    assertEquals(50f, root_child0_child1.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0_child1.getLayoutY(), 0.0f);
+    assertEquals(50f, root_child0_child1.getLayoutWidth(), 0.0f);
+    assertEquals(20f, root_child0_child1.getLayoutHeight(), 0.0f);
+
+    root.setDirection(YogaDirection.RTL);
+    root.calculateLayout(YogaConstants.UNDEFINED, YogaConstants.UNDEFINED);
+
+    assertEquals(0f, root.getLayoutX(), 0.0f);
+    assertEquals(0f, root.getLayoutY(), 0.0f);
+    assertEquals(100f, root.getLayoutWidth(), 0.0f);
+    assertEquals(100f, root.getLayoutHeight(), 0.0f);
+
+    assertEquals(0f, root_child0.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutY(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutWidth(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutHeight(), 0.0f);
+
+    assertEquals(50f, root_child0_child0.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0_child0.getLayoutY(), 0.0f);
+    assertEquals(50f, root_child0_child0.getLayoutWidth(), 0.0f);
+    assertEquals(10f, root_child0_child0.getLayoutHeight(), 0.0f);
+
+    assertEquals(0f, root_child0_child1.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0_child1.getLayoutY(), 0.0f);
+    assertEquals(50f, root_child0_child1.getLayoutWidth(), 0.0f);
+    assertEquals(20f, root_child0_child1.getLayoutHeight(), 0.0f);
+  }
+
+  @Test
+  public void test_display_contents_with_position() {
+    YogaConfig config = YogaConfigFactory.create();
+
+    final YogaNode root = createNode(config);
+    root.setFlexDirection(YogaFlexDirection.ROW);
+    root.setPositionType(YogaPositionType.ABSOLUTE);
+    root.setWidth(100f);
+    root.setHeight(100f);
+
+    final YogaNode root_child0 = createNode(config);
+    root_child0.setPosition(YogaEdge.TOP, 10f);
+    root_child0.setDisplay(YogaDisplay.CONTENTS);
+    root.addChildAt(root_child0, 0);
+
+    final YogaNode root_child0_child0 = createNode(config);
+    root_child0_child0.setFlexGrow(1f);
+    root_child0_child0.setFlexShrink(1f);
+    root_child0_child0.setFlexBasisPercent(0f);
+    root_child0_child0.setHeight(10f);
+    root_child0.addChildAt(root_child0_child0, 0);
+
+    final YogaNode root_child0_child1 = createNode(config);
+    root_child0_child1.setFlexGrow(1f);
+    root_child0_child1.setFlexShrink(1f);
+    root_child0_child1.setFlexBasisPercent(0f);
+    root_child0_child1.setHeight(20f);
+    root_child0.addChildAt(root_child0_child1, 1);
+    root.setDirection(YogaDirection.LTR);
+    root.calculateLayout(YogaConstants.UNDEFINED, YogaConstants.UNDEFINED);
+
+    assertEquals(0f, root.getLayoutX(), 0.0f);
+    assertEquals(0f, root.getLayoutY(), 0.0f);
+    assertEquals(100f, root.getLayoutWidth(), 0.0f);
+    assertEquals(100f, root.getLayoutHeight(), 0.0f);
+
+    assertEquals(0f, root_child0.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutY(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutWidth(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutHeight(), 0.0f);
+
+    assertEquals(0f, root_child0_child0.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0_child0.getLayoutY(), 0.0f);
+    assertEquals(50f, root_child0_child0.getLayoutWidth(), 0.0f);
+    assertEquals(10f, root_child0_child0.getLayoutHeight(), 0.0f);
+
+    assertEquals(50f, root_child0_child1.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0_child1.getLayoutY(), 0.0f);
+    assertEquals(50f, root_child0_child1.getLayoutWidth(), 0.0f);
+    assertEquals(20f, root_child0_child1.getLayoutHeight(), 0.0f);
+
+    root.setDirection(YogaDirection.RTL);
+    root.calculateLayout(YogaConstants.UNDEFINED, YogaConstants.UNDEFINED);
+
+    assertEquals(0f, root.getLayoutX(), 0.0f);
+    assertEquals(0f, root.getLayoutY(), 0.0f);
+    assertEquals(100f, root.getLayoutWidth(), 0.0f);
+    assertEquals(100f, root.getLayoutHeight(), 0.0f);
+
+    assertEquals(0f, root_child0.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutY(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutWidth(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutHeight(), 0.0f);
+
+    assertEquals(50f, root_child0_child0.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0_child0.getLayoutY(), 0.0f);
+    assertEquals(50f, root_child0_child0.getLayoutWidth(), 0.0f);
+    assertEquals(10f, root_child0_child0.getLayoutHeight(), 0.0f);
+
+    assertEquals(0f, root_child0_child1.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0_child1.getLayoutY(), 0.0f);
+    assertEquals(50f, root_child0_child1.getLayoutWidth(), 0.0f);
+    assertEquals(20f, root_child0_child1.getLayoutHeight(), 0.0f);
+  }
+
+  @Test
+  public void test_display_contents_with_position_absolute() {
+    YogaConfig config = YogaConfigFactory.create();
+
+    final YogaNode root = createNode(config);
+    root.setFlexDirection(YogaFlexDirection.ROW);
+    root.setPositionType(YogaPositionType.ABSOLUTE);
+    root.setWidth(100f);
+    root.setHeight(100f);
+
+    final YogaNode root_child0 = createNode(config);
+    root_child0.setPositionType(YogaPositionType.ABSOLUTE);
+    root_child0.setWidth(50f);
+    root_child0.setHeight(50f);
+    root_child0.setDisplay(YogaDisplay.CONTENTS);
+    root.addChildAt(root_child0, 0);
+
+    final YogaNode root_child0_child0 = createNode(config);
+    root_child0_child0.setFlexGrow(1f);
+    root_child0_child0.setFlexShrink(1f);
+    root_child0_child0.setFlexBasisPercent(0f);
+    root_child0_child0.setHeight(10f);
+    root_child0.addChildAt(root_child0_child0, 0);
+
+    final YogaNode root_child0_child1 = createNode(config);
+    root_child0_child1.setFlexGrow(1f);
+    root_child0_child1.setFlexShrink(1f);
+    root_child0_child1.setFlexBasisPercent(0f);
+    root_child0_child1.setHeight(20f);
+    root_child0.addChildAt(root_child0_child1, 1);
+    root.setDirection(YogaDirection.LTR);
+    root.calculateLayout(YogaConstants.UNDEFINED, YogaConstants.UNDEFINED);
+
+    assertEquals(0f, root.getLayoutX(), 0.0f);
+    assertEquals(0f, root.getLayoutY(), 0.0f);
+    assertEquals(100f, root.getLayoutWidth(), 0.0f);
+    assertEquals(100f, root.getLayoutHeight(), 0.0f);
+
+    assertEquals(0f, root_child0.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutY(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutWidth(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutHeight(), 0.0f);
+
+    assertEquals(0f, root_child0_child0.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0_child0.getLayoutY(), 0.0f);
+    assertEquals(50f, root_child0_child0.getLayoutWidth(), 0.0f);
+    assertEquals(10f, root_child0_child0.getLayoutHeight(), 0.0f);
+
+    assertEquals(50f, root_child0_child1.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0_child1.getLayoutY(), 0.0f);
+    assertEquals(50f, root_child0_child1.getLayoutWidth(), 0.0f);
+    assertEquals(20f, root_child0_child1.getLayoutHeight(), 0.0f);
+
+    root.setDirection(YogaDirection.RTL);
+    root.calculateLayout(YogaConstants.UNDEFINED, YogaConstants.UNDEFINED);
+
+    assertEquals(0f, root.getLayoutX(), 0.0f);
+    assertEquals(0f, root.getLayoutY(), 0.0f);
+    assertEquals(100f, root.getLayoutWidth(), 0.0f);
+    assertEquals(100f, root.getLayoutHeight(), 0.0f);
+
+    assertEquals(0f, root_child0.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutY(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutWidth(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutHeight(), 0.0f);
+
+    assertEquals(50f, root_child0_child0.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0_child0.getLayoutY(), 0.0f);
+    assertEquals(50f, root_child0_child0.getLayoutWidth(), 0.0f);
+    assertEquals(10f, root_child0_child0.getLayoutHeight(), 0.0f);
+
+    assertEquals(0f, root_child0_child1.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0_child1.getLayoutY(), 0.0f);
+    assertEquals(50f, root_child0_child1.getLayoutWidth(), 0.0f);
+    assertEquals(20f, root_child0_child1.getLayoutHeight(), 0.0f);
+  }
+
+  @Test
+  public void test_display_contents_nested() {
+    YogaConfig config = YogaConfigFactory.create();
+
+    final YogaNode root = createNode(config);
+    root.setFlexDirection(YogaFlexDirection.ROW);
+    root.setPositionType(YogaPositionType.ABSOLUTE);
+    root.setWidth(100f);
+    root.setHeight(100f);
+
+    final YogaNode root_child0 = createNode(config);
+    root_child0.setDisplay(YogaDisplay.CONTENTS);
+    root.addChildAt(root_child0, 0);
+
+    final YogaNode root_child0_child0 = createNode(config);
+    root_child0_child0.setDisplay(YogaDisplay.CONTENTS);
+    root_child0.addChildAt(root_child0_child0, 0);
+
+    final YogaNode root_child0_child0_child0 = createNode(config);
+    root_child0_child0_child0.setFlexGrow(1f);
+    root_child0_child0_child0.setFlexShrink(1f);
+    root_child0_child0_child0.setFlexBasisPercent(0f);
+    root_child0_child0_child0.setHeight(10f);
+    root_child0_child0.addChildAt(root_child0_child0_child0, 0);
+
+    final YogaNode root_child0_child0_child1 = createNode(config);
+    root_child0_child0_child1.setFlexGrow(1f);
+    root_child0_child0_child1.setFlexShrink(1f);
+    root_child0_child0_child1.setFlexBasisPercent(0f);
+    root_child0_child0_child1.setHeight(20f);
+    root_child0_child0.addChildAt(root_child0_child0_child1, 1);
+    root.setDirection(YogaDirection.LTR);
+    root.calculateLayout(YogaConstants.UNDEFINED, YogaConstants.UNDEFINED);
+
+    assertEquals(0f, root.getLayoutX(), 0.0f);
+    assertEquals(0f, root.getLayoutY(), 0.0f);
+    assertEquals(100f, root.getLayoutWidth(), 0.0f);
+    assertEquals(100f, root.getLayoutHeight(), 0.0f);
+
+    assertEquals(0f, root_child0.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutY(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutWidth(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutHeight(), 0.0f);
+
+    assertEquals(0f, root_child0_child0.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0_child0.getLayoutY(), 0.0f);
+    assertEquals(0f, root_child0_child0.getLayoutWidth(), 0.0f);
+    assertEquals(0f, root_child0_child0.getLayoutHeight(), 0.0f);
+
+    assertEquals(0f, root_child0_child0_child0.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0_child0_child0.getLayoutY(), 0.0f);
+    assertEquals(50f, root_child0_child0_child0.getLayoutWidth(), 0.0f);
+    assertEquals(10f, root_child0_child0_child0.getLayoutHeight(), 0.0f);
+
+    assertEquals(50f, root_child0_child0_child1.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0_child0_child1.getLayoutY(), 0.0f);
+    assertEquals(50f, root_child0_child0_child1.getLayoutWidth(), 0.0f);
+    assertEquals(20f, root_child0_child0_child1.getLayoutHeight(), 0.0f);
+
+    root.setDirection(YogaDirection.RTL);
+    root.calculateLayout(YogaConstants.UNDEFINED, YogaConstants.UNDEFINED);
+
+    assertEquals(0f, root.getLayoutX(), 0.0f);
+    assertEquals(0f, root.getLayoutY(), 0.0f);
+    assertEquals(100f, root.getLayoutWidth(), 0.0f);
+    assertEquals(100f, root.getLayoutHeight(), 0.0f);
+
+    assertEquals(0f, root_child0.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutY(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutWidth(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutHeight(), 0.0f);
+
+    assertEquals(0f, root_child0_child0.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0_child0.getLayoutY(), 0.0f);
+    assertEquals(0f, root_child0_child0.getLayoutWidth(), 0.0f);
+    assertEquals(0f, root_child0_child0.getLayoutHeight(), 0.0f);
+
+    assertEquals(50f, root_child0_child0_child0.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0_child0_child0.getLayoutY(), 0.0f);
+    assertEquals(50f, root_child0_child0_child0.getLayoutWidth(), 0.0f);
+    assertEquals(10f, root_child0_child0_child0.getLayoutHeight(), 0.0f);
+
+    assertEquals(0f, root_child0_child0_child1.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0_child0_child1.getLayoutY(), 0.0f);
+    assertEquals(50f, root_child0_child0_child1.getLayoutWidth(), 0.0f);
+    assertEquals(20f, root_child0_child0_child1.getLayoutHeight(), 0.0f);
+  }
+
+  @Test
+  public void test_display_contents_with_siblings() {
+    YogaConfig config = YogaConfigFactory.create();
+
+    final YogaNode root = createNode(config);
+    root.setFlexDirection(YogaFlexDirection.ROW);
+    root.setPositionType(YogaPositionType.ABSOLUTE);
+    root.setWidth(100f);
+    root.setHeight(100f);
+
+    final YogaNode root_child0 = createNode(config);
+    root_child0.setFlexGrow(1f);
+    root_child0.setFlexShrink(1f);
+    root_child0.setFlexBasisPercent(0f);
+    root_child0.setHeight(30f);
+    root.addChildAt(root_child0, 0);
+
+    final YogaNode root_child1 = createNode(config);
+    root_child1.setDisplay(YogaDisplay.CONTENTS);
+    root.addChildAt(root_child1, 1);
+
+    final YogaNode root_child1_child0 = createNode(config);
+    root_child1_child0.setFlexGrow(1f);
+    root_child1_child0.setFlexShrink(1f);
+    root_child1_child0.setFlexBasisPercent(0f);
+    root_child1_child0.setHeight(10f);
+    root_child1.addChildAt(root_child1_child0, 0);
+
+    final YogaNode root_child1_child1 = createNode(config);
+    root_child1_child1.setFlexGrow(1f);
+    root_child1_child1.setFlexShrink(1f);
+    root_child1_child1.setFlexBasisPercent(0f);
+    root_child1_child1.setHeight(20f);
+    root_child1.addChildAt(root_child1_child1, 1);
+
+    final YogaNode root_child2 = createNode(config);
+    root_child2.setFlexGrow(1f);
+    root_child2.setFlexShrink(1f);
+    root_child2.setFlexBasisPercent(0f);
+    root_child2.setHeight(30f);
+    root.addChildAt(root_child2, 2);
+    root.setDirection(YogaDirection.LTR);
+    root.calculateLayout(YogaConstants.UNDEFINED, YogaConstants.UNDEFINED);
+
+    assertEquals(0f, root.getLayoutX(), 0.0f);
+    assertEquals(0f, root.getLayoutY(), 0.0f);
+    assertEquals(100f, root.getLayoutWidth(), 0.0f);
+    assertEquals(100f, root.getLayoutHeight(), 0.0f);
+
+    assertEquals(0f, root_child0.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutY(), 0.0f);
+    assertEquals(25f, root_child0.getLayoutWidth(), 0.0f);
+    assertEquals(30f, root_child0.getLayoutHeight(), 0.0f);
+
+    assertEquals(0f, root_child1.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child1.getLayoutY(), 0.0f);
+    assertEquals(0f, root_child1.getLayoutWidth(), 0.0f);
+    assertEquals(0f, root_child1.getLayoutHeight(), 0.0f);
+
+    assertEquals(25f, root_child1_child0.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child1_child0.getLayoutY(), 0.0f);
+    assertEquals(25f, root_child1_child0.getLayoutWidth(), 0.0f);
+    assertEquals(10f, root_child1_child0.getLayoutHeight(), 0.0f);
+
+    assertEquals(50f, root_child1_child1.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child1_child1.getLayoutY(), 0.0f);
+    assertEquals(25f, root_child1_child1.getLayoutWidth(), 0.0f);
+    assertEquals(20f, root_child1_child1.getLayoutHeight(), 0.0f);
+
+    assertEquals(75f, root_child2.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child2.getLayoutY(), 0.0f);
+    assertEquals(25f, root_child2.getLayoutWidth(), 0.0f);
+    assertEquals(30f, root_child2.getLayoutHeight(), 0.0f);
+
+    root.setDirection(YogaDirection.RTL);
+    root.calculateLayout(YogaConstants.UNDEFINED, YogaConstants.UNDEFINED);
+
+    assertEquals(0f, root.getLayoutX(), 0.0f);
+    assertEquals(0f, root.getLayoutY(), 0.0f);
+    assertEquals(100f, root.getLayoutWidth(), 0.0f);
+    assertEquals(100f, root.getLayoutHeight(), 0.0f);
+
+    assertEquals(75f, root_child0.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child0.getLayoutY(), 0.0f);
+    assertEquals(25f, root_child0.getLayoutWidth(), 0.0f);
+    assertEquals(30f, root_child0.getLayoutHeight(), 0.0f);
+
+    assertEquals(0f, root_child1.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child1.getLayoutY(), 0.0f);
+    assertEquals(0f, root_child1.getLayoutWidth(), 0.0f);
+    assertEquals(0f, root_child1.getLayoutHeight(), 0.0f);
+
+    assertEquals(50f, root_child1_child0.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child1_child0.getLayoutY(), 0.0f);
+    assertEquals(25f, root_child1_child0.getLayoutWidth(), 0.0f);
+    assertEquals(10f, root_child1_child0.getLayoutHeight(), 0.0f);
+
+    assertEquals(25f, root_child1_child1.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child1_child1.getLayoutY(), 0.0f);
+    assertEquals(25f, root_child1_child1.getLayoutWidth(), 0.0f);
+    assertEquals(20f, root_child1_child1.getLayoutHeight(), 0.0f);
+
+    assertEquals(0f, root_child2.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child2.getLayoutY(), 0.0f);
+    assertEquals(25f, root_child2.getLayoutWidth(), 0.0f);
+    assertEquals(30f, root_child2.getLayoutHeight(), 0.0f);
+  }
+
   private YogaNode createNode(YogaConfig config) {
     return mNodeFactory.create(config);
   }

java/tests/generated/com/facebook/yoga/YGJustifyContentTest.java

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<6aaf6f020cdc74d09e440206957507aa>>
+ * @generated SignedSource<<ebd50ee9980922e7e6f3beabff5375ea>>
  * generated by gentest/gentest-driver.ts from gentest/fixtures/YGJustifyContentTest.html
  */
 
@@ -1790,6 +1790,7 @@ public class YGJustifyContentTest {
   }
 
   @Test
+  @Ignore
   public void test_justify_content_overflow_row_reverse_space_around() {
     YogaConfig config = YogaConfigFactory.create();
 
@@ -1819,17 +1820,17 @@ public class YGJustifyContentTest {
     assertEquals(102f, root.getLayoutWidth(), 0.0f);
     assertEquals(102f, root.getLayoutHeight(), 0.0f);
 
-    assertEquals(62f, root_child0.getLayoutX(), 0.0f);
+    assertEquals(80f, root_child0.getLayoutX(), 0.0f);
     assertEquals(0f, root_child0.getLayoutY(), 0.0f);
     assertEquals(40f, root_child0.getLayoutWidth(), 0.0f);
     assertEquals(102f, root_child0.getLayoutHeight(), 0.0f);
 
-    assertEquals(22f, root_child1.getLayoutX(), 0.0f);
+    assertEquals(40f, root_child1.getLayoutX(), 0.0f);
     assertEquals(0f, root_child1.getLayoutY(), 0.0f);
     assertEquals(40f, root_child1.getLayoutWidth(), 0.0f);
     assertEquals(102f, root_child1.getLayoutHeight(), 0.0f);
 
-    assertEquals(-18f, root_child2.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child2.getLayoutX(), 0.0f);
     assertEquals(0f, root_child2.getLayoutY(), 0.0f);
     assertEquals(40f, root_child2.getLayoutWidth(), 0.0f);
     assertEquals(102f, root_child2.getLayoutHeight(), 0.0f);
@@ -1842,23 +1843,24 @@ public class YGJustifyContentTest {
     assertEquals(102f, root.getLayoutWidth(), 0.0f);
     assertEquals(102f, root.getLayoutHeight(), 0.0f);
 
-    assertEquals(0f, root_child0.getLayoutX(), 0.0f);
+    assertEquals(-18f, root_child0.getLayoutX(), 0.0f);
     assertEquals(0f, root_child0.getLayoutY(), 0.0f);
     assertEquals(40f, root_child0.getLayoutWidth(), 0.0f);
     assertEquals(102f, root_child0.getLayoutHeight(), 0.0f);
 
-    assertEquals(40f, root_child1.getLayoutX(), 0.0f);
+    assertEquals(22f, root_child1.getLayoutX(), 0.0f);
     assertEquals(0f, root_child1.getLayoutY(), 0.0f);
     assertEquals(40f, root_child1.getLayoutWidth(), 0.0f);
     assertEquals(102f, root_child1.getLayoutHeight(), 0.0f);
 
-    assertEquals(80f, root_child2.getLayoutX(), 0.0f);
+    assertEquals(62f, root_child2.getLayoutX(), 0.0f);
     assertEquals(0f, root_child2.getLayoutY(), 0.0f);
     assertEquals(40f, root_child2.getLayoutWidth(), 0.0f);
     assertEquals(102f, root_child2.getLayoutHeight(), 0.0f);
   }
 
   @Test
+  @Ignore
   public void test_justify_content_overflow_row_reverse_space_evenly() {
     YogaConfig config = YogaConfigFactory.create();
 
@@ -1888,17 +1890,17 @@ public class YGJustifyContentTest {
     assertEquals(102f, root.getLayoutWidth(), 0.0f);
     assertEquals(102f, root.getLayoutHeight(), 0.0f);
 
-    assertEquals(62f, root_child0.getLayoutX(), 0.0f);
+    assertEquals(80f, root_child0.getLayoutX(), 0.0f);
     assertEquals(0f, root_child0.getLayoutY(), 0.0f);
     assertEquals(40f, root_child0.getLayoutWidth(), 0.0f);
     assertEquals(102f, root_child0.getLayoutHeight(), 0.0f);
 
-    assertEquals(22f, root_child1.getLayoutX(), 0.0f);
+    assertEquals(40f, root_child1.getLayoutX(), 0.0f);
     assertEquals(0f, root_child1.getLayoutY(), 0.0f);
     assertEquals(40f, root_child1.getLayoutWidth(), 0.0f);
     assertEquals(102f, root_child1.getLayoutHeight(), 0.0f);
 
-    assertEquals(-18f, root_child2.getLayoutX(), 0.0f);
+    assertEquals(0f, root_child2.getLayoutX(), 0.0f);
     assertEquals(0f, root_child2.getLayoutY(), 0.0f);
     assertEquals(40f, root_child2.getLayoutWidth(), 0.0f);
     assertEquals(102f, root_child2.getLayoutHeight(), 0.0f);
@@ -1911,17 +1913,17 @@ public class YGJustifyContentTest {
     assertEquals(102f, root.getLayoutWidth(), 0.0f);
     assertEquals(102f, root.getLayoutHeight(), 0.0f);
 
-    assertEquals(0f, root_child0.getLayoutX(), 0.0f);
+    assertEquals(-18f, root_child0.getLayoutX(), 0.0f);
     assertEquals(0f, root_child0.getLayoutY(), 0.0f);
     assertEquals(40f, root_child0.getLayoutWidth(), 0.0f);
     assertEquals(102f, root_child0.getLayoutHeight(), 0.0f);
 
-    assertEquals(40f, root_child1.getLayoutX(), 0.0f);
+    assertEquals(22f, root_child1.getLayoutX(), 0.0f);
     assertEquals(0f, root_child1.getLayoutY(), 0.0f);
     assertEquals(40f, root_child1.getLayoutWidth(), 0.0f);
     assertEquals(102f, root_child1.getLayoutHeight(), 0.0f);
 
-    assertEquals(80f, root_child2.getLayoutX(), 0.0f);
+    assertEquals(62f, root_child2.getLayoutX(), 0.0f);
     assertEquals(0f, root_child2.getLayoutY(), 0.0f);
     assertEquals(40f, root_child2.getLayoutWidth(), 0.0f);
     assertEquals(102f, root_child2.getLayoutHeight(), 0.0f);

javascript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yoga-layout",
-  "version": "0.0.0",
+  "version": "3.2.1",
   "description": "An embeddable and performant flexbox layout engine with bindings for multiple languages",
   "license": "MIT",
   "author": "Meta Open Source",

javascript/src/generated/YGEnums.ts

@@ -38,6 +38,7 @@ export enum Direction {
 export enum Display {
   Flex = 0,
   None = 1,
+  Contents = 2,
 }
 
 export enum Edge {
@@ -55,7 +56,7 @@ export enum Edge {
 export enum Errata {
   None = 0,
   StretchFlexBasis = 1,
-  AbsolutePositioningIncorrect = 2,
+  AbsolutePositionWithoutInsetsExcludesPadding = 2,
   AbsolutePercentAgainstInnerSize = 4,
   All = 2147483647,
   Classic = 2147483646,
@@ -151,6 +152,7 @@ const constants = {
   DIRECTION_RTL: Direction.RTL,
   DISPLAY_FLEX: Display.Flex,
   DISPLAY_NONE: Display.None,
+  DISPLAY_CONTENTS: Display.Contents,
   EDGE_LEFT: Edge.Left,
   EDGE_TOP: Edge.Top,
   EDGE_RIGHT: Edge.Right,
@@ -162,7 +164,7 @@ const constants = {
   EDGE_ALL: Edge.All,
   ERRATA_NONE: Errata.None,
   ERRATA_STRETCH_FLEX_BASIS: Errata.StretchFlexBasis,
-  ERRATA_ABSOLUTE_POSITIONING_INCORRECT: Errata.AbsolutePositioningIncorrect,
+  ERRATA_ABSOLUTE_POSITION_WITHOUT_INSETS_EXCLUDES_PADDING: Errata.AbsolutePositionWithoutInsetsExcludesPadding,
   ERRATA_ABSOLUTE_PERCENT_AGAINST_INNER_SIZE: Errata.AbsolutePercentAgainstInnerSize,
   ERRATA_ALL: Errata.All,
   ERRATA_CLASSIC: Errata.Classic,

javascript/tests/generated/YGAlignContentTest.test.ts

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<25f4cf395ff39619966d6f0ff993e99d>>
+ * @generated SignedSource<<ae2a56d91c60e30ea10b12d6d143ff73>>
  * generated by gentest/gentest-driver.ts from gentest/fixtures/YGAlignContentTest.html
  */
 
@@ -5508,3 +5508,322 @@ test('align_content_space_evenly_stretch_does_influence_line_box_dim', () => {
     config.free();
   }
 });
+test('align_content_stretch_and_align_items_flex_end_with_flex_wrap', () => {
+  const config = Yoga.Config.create();
+  let root;
+
+  try {
+    root = Yoga.Node.create(config);
+    root.setFlexDirection(FlexDirection.Row);
+    root.setAlignContent(Align.Stretch);
+    root.setAlignItems(Align.FlexEnd);
+    root.setPositionType(PositionType.Absolute);
+    root.setFlexWrap(Wrap.Wrap);
+    root.setWidth(300);
+    root.setHeight(300);
+
+    const root_child0 = Yoga.Node.create(config);
+    root_child0.setAlignSelf(Align.FlexStart);
+    root_child0.setWidth(150);
+    root_child0.setHeight(50);
+    root.insertChild(root_child0, 0);
+
+    const root_child1 = Yoga.Node.create(config);
+    root_child1.setWidth(120);
+    root_child1.setHeight(100);
+    root.insertChild(root_child1, 1);
+
+    const root_child2 = Yoga.Node.create(config);
+    root_child2.setWidth(120);
+    root_child2.setHeight(50);
+    root.insertChild(root_child2, 2);
+    root.calculateLayout(undefined, undefined, Direction.LTR);
+
+    expect(root.getComputedLeft()).toBe(0);
+    expect(root.getComputedTop()).toBe(0);
+    expect(root.getComputedWidth()).toBe(300);
+    expect(root.getComputedHeight()).toBe(300);
+
+    expect(root_child0.getComputedLeft()).toBe(0);
+    expect(root_child0.getComputedTop()).toBe(0);
+    expect(root_child0.getComputedWidth()).toBe(150);
+    expect(root_child0.getComputedHeight()).toBe(50);
+
+    expect(root_child1.getComputedLeft()).toBe(150);
+    expect(root_child1.getComputedTop()).toBe(75);
+    expect(root_child1.getComputedWidth()).toBe(120);
+    expect(root_child1.getComputedHeight()).toBe(100);
+
+    expect(root_child2.getComputedLeft()).toBe(0);
+    expect(root_child2.getComputedTop()).toBe(250);
+    expect(root_child2.getComputedWidth()).toBe(120);
+    expect(root_child2.getComputedHeight()).toBe(50);
+
+    root.calculateLayout(undefined, undefined, Direction.RTL);
+
+    expect(root.getComputedLeft()).toBe(0);
+    expect(root.getComputedTop()).toBe(0);
+    expect(root.getComputedWidth()).toBe(300);
+    expect(root.getComputedHeight()).toBe(300);
+
+    expect(root_child0.getComputedLeft()).toBe(150);
+    expect(root_child0.getComputedTop()).toBe(0);
+    expect(root_child0.getComputedWidth()).toBe(150);
+    expect(root_child0.getComputedHeight()).toBe(50);
+
+    expect(root_child1.getComputedLeft()).toBe(30);
+    expect(root_child1.getComputedTop()).toBe(75);
+    expect(root_child1.getComputedWidth()).toBe(120);
+    expect(root_child1.getComputedHeight()).toBe(100);
+
+    expect(root_child2.getComputedLeft()).toBe(180);
+    expect(root_child2.getComputedTop()).toBe(250);
+    expect(root_child2.getComputedWidth()).toBe(120);
+    expect(root_child2.getComputedHeight()).toBe(50);
+  } finally {
+    if (typeof root !== 'undefined') {
+      root.freeRecursive();
+    }
+
+    config.free();
+  }
+});
+test('align_content_stretch_and_align_items_flex_start_with_flex_wrap', () => {
+  const config = Yoga.Config.create();
+  let root;
+
+  try {
+    root = Yoga.Node.create(config);
+    root.setFlexDirection(FlexDirection.Row);
+    root.setAlignContent(Align.Stretch);
+    root.setAlignItems(Align.FlexStart);
+    root.setPositionType(PositionType.Absolute);
+    root.setFlexWrap(Wrap.Wrap);
+    root.setWidth(300);
+    root.setHeight(300);
+
+    const root_child0 = Yoga.Node.create(config);
+    root_child0.setAlignSelf(Align.FlexEnd);
+    root_child0.setWidth(150);
+    root_child0.setHeight(50);
+    root.insertChild(root_child0, 0);
+
+    const root_child1 = Yoga.Node.create(config);
+    root_child1.setWidth(120);
+    root_child1.setHeight(100);
+    root.insertChild(root_child1, 1);
+
+    const root_child2 = Yoga.Node.create(config);
+    root_child2.setWidth(120);
+    root_child2.setHeight(50);
+    root.insertChild(root_child2, 2);
+    root.calculateLayout(undefined, undefined, Direction.LTR);
+
+    expect(root.getComputedLeft()).toBe(0);
+    expect(root.getComputedTop()).toBe(0);
+    expect(root.getComputedWidth()).toBe(300);
+    expect(root.getComputedHeight()).toBe(300);
+
+    expect(root_child0.getComputedLeft()).toBe(0);
+    expect(root_child0.getComputedTop()).toBe(125);
+    expect(root_child0.getComputedWidth()).toBe(150);
+    expect(root_child0.getComputedHeight()).toBe(50);
+
+    expect(root_child1.getComputedLeft()).toBe(150);
+    expect(root_child1.getComputedTop()).toBe(0);
+    expect(root_child1.getComputedWidth()).toBe(120);
+    expect(root_child1.getComputedHeight()).toBe(100);
+
+    expect(root_child2.getComputedLeft()).toBe(0);
+    expect(root_child2.getComputedTop()).toBe(175);
+    expect(root_child2.getComputedWidth()).toBe(120);
+    expect(root_child2.getComputedHeight()).toBe(50);
+
+    root.calculateLayout(undefined, undefined, Direction.RTL);
+
+    expect(root.getComputedLeft()).toBe(0);
+    expect(root.getComputedTop()).toBe(0);
+    expect(root.getComputedWidth()).toBe(300);
+    expect(root.getComputedHeight()).toBe(300);
+
+    expect(root_child0.getComputedLeft()).toBe(150);
+    expect(root_child0.getComputedTop()).toBe(125);
+    expect(root_child0.getComputedWidth()).toBe(150);
+    expect(root_child0.getComputedHeight()).toBe(50);
+
+    expect(root_child1.getComputedLeft()).toBe(30);
+    expect(root_child1.getComputedTop()).toBe(0);
+    expect(root_child1.getComputedWidth()).toBe(120);
+    expect(root_child1.getComputedHeight()).toBe(100);
+
+    expect(root_child2.getComputedLeft()).toBe(180);
+    expect(root_child2.getComputedTop()).toBe(175);
+    expect(root_child2.getComputedWidth()).toBe(120);
+    expect(root_child2.getComputedHeight()).toBe(50);
+  } finally {
+    if (typeof root !== 'undefined') {
+      root.freeRecursive();
+    }
+
+    config.free();
+  }
+});
+test('align_content_stretch_and_align_items_center_with_flex_wrap', () => {
+  const config = Yoga.Config.create();
+  let root;
+
+  try {
+    root = Yoga.Node.create(config);
+    root.setFlexDirection(FlexDirection.Row);
+    root.setAlignContent(Align.Stretch);
+    root.setAlignItems(Align.Center);
+    root.setPositionType(PositionType.Absolute);
+    root.setFlexWrap(Wrap.Wrap);
+    root.setWidth(300);
+    root.setHeight(300);
+
+    const root_child0 = Yoga.Node.create(config);
+    root_child0.setAlignSelf(Align.FlexEnd);
+    root_child0.setWidth(150);
+    root_child0.setHeight(50);
+    root.insertChild(root_child0, 0);
+
+    const root_child1 = Yoga.Node.create(config);
+    root_child1.setWidth(120);
+    root_child1.setHeight(100);
+    root.insertChild(root_child1, 1);
+
+    const root_child2 = Yoga.Node.create(config);
+    root_child2.setWidth(120);
+    root_child2.setHeight(50);
+    root.insertChild(root_child2, 2);
+    root.calculateLayout(undefined, undefined, Direction.LTR);
+
+    expect(root.getComputedLeft()).toBe(0);
+    expect(root.getComputedTop()).toBe(0);
+    expect(root.getComputedWidth()).toBe(300);
+    expect(root.getComputedHeight()).toBe(300);
+
+    expect(root_child0.getComputedLeft()).toBe(0);
+    expect(root_child0.getComputedTop()).toBe(125);
+    expect(root_child0.getComputedWidth()).toBe(150);
+    expect(root_child0.getComputedHeight()).toBe(50);
+
+    expect(root_child1.getComputedLeft()).toBe(150);
+    expect(root_child1.getComputedTop()).toBe(38);
+    expect(root_child1.getComputedWidth()).toBe(120);
+    expect(root_child1.getComputedHeight()).toBe(100);
+
+    expect(root_child2.getComputedLeft()).toBe(0);
+    expect(root_child2.getComputedTop()).toBe(213);
+    expect(root_child2.getComputedWidth()).toBe(120);
+    expect(root_child2.getComputedHeight()).toBe(50);
+
+    root.calculateLayout(undefined, undefined, Direction.RTL);
+
+    expect(root.getComputedLeft()).toBe(0);
+    expect(root.getComputedTop()).toBe(0);
+    expect(root.getComputedWidth()).toBe(300);
+    expect(root.getComputedHeight()).toBe(300);
+
+    expect(root_child0.getComputedLeft()).toBe(150);
+    expect(root_child0.getComputedTop()).toBe(125);
+    expect(root_child0.getComputedWidth()).toBe(150);
+    expect(root_child0.getComputedHeight()).toBe(50);
+
+    expect(root_child1.getComputedLeft()).toBe(30);
+    expect(root_child1.getComputedTop()).toBe(38);
+    expect(root_child1.getComputedWidth()).toBe(120);
+    expect(root_child1.getComputedHeight()).toBe(100);
+
+    expect(root_child2.getComputedLeft()).toBe(180);
+    expect(root_child2.getComputedTop()).toBe(213);
+    expect(root_child2.getComputedWidth()).toBe(120);
+    expect(root_child2.getComputedHeight()).toBe(50);
+  } finally {
+    if (typeof root !== 'undefined') {
+      root.freeRecursive();
+    }
+
+    config.free();
+  }
+});
+test('align_content_stretch_and_align_items_stretch_with_flex_wrap', () => {
+  const config = Yoga.Config.create();
+  let root;
+
+  try {
+    root = Yoga.Node.create(config);
+    root.setFlexDirection(FlexDirection.Row);
+    root.setAlignContent(Align.Stretch);
+    root.setPositionType(PositionType.Absolute);
+    root.setFlexWrap(Wrap.Wrap);
+    root.setWidth(300);
+    root.setHeight(300);
+
+    const root_child0 = Yoga.Node.create(config);
+    root_child0.setAlignSelf(Align.FlexEnd);
+    root_child0.setWidth(150);
+    root_child0.setHeight(50);
+    root.insertChild(root_child0, 0);
+
+    const root_child1 = Yoga.Node.create(config);
+    root_child1.setWidth(120);
+    root_child1.setHeight(100);
+    root.insertChild(root_child1, 1);
+
+    const root_child2 = Yoga.Node.create(config);
+    root_child2.setWidth(120);
+    root_child2.setHeight(50);
+    root.insertChild(root_child2, 2);
+    root.calculateLayout(undefined, undefined, Direction.LTR);
+
+    expect(root.getComputedLeft()).toBe(0);
+    expect(root.getComputedTop()).toBe(0);
+    expect(root.getComputedWidth()).toBe(300);
+    expect(root.getComputedHeight()).toBe(300);
+
+    expect(root_child0.getComputedLeft()).toBe(0);
+    expect(root_child0.getComputedTop()).toBe(125);
+    expect(root_child0.getComputedWidth()).toBe(150);
+    expect(root_child0.getComputedHeight()).toBe(50);
+
+    expect(root_child1.getComputedLeft()).toBe(150);
+    expect(root_child1.getComputedTop()).toBe(0);
+    expect(root_child1.getComputedWidth()).toBe(120);
+    expect(root_child1.getComputedHeight()).toBe(100);
+
+    expect(root_child2.getComputedLeft()).toBe(0);
+    expect(root_child2.getComputedTop()).toBe(175);
+    expect(root_child2.getComputedWidth()).toBe(120);
+    expect(root_child2.getComputedHeight()).toBe(50);
+
+    root.calculateLayout(undefined, undefined, Direction.RTL);
+
+    expect(root.getComputedLeft()).toBe(0);
+    expect(root.getComputedTop()).toBe(0);
+    expect(root.getComputedWidth()).toBe(300);
+    expect(root.getComputedHeight()).toBe(300);
+
+    expect(root_child0.getComputedLeft()).toBe(150);
+    expect(root_child0.getComputedTop()).toBe(125);
+    expect(root_child0.getComputedWidth()).toBe(150);
+    expect(root_child0.getComputedHeight()).toBe(50);
+
+    expect(root_child1.getComputedLeft()).toBe(30);
+    expect(root_child1.getComputedTop()).toBe(0);
+    expect(root_child1.getComputedWidth()).toBe(120);
+    expect(root_child1.getComputedHeight()).toBe(100);
+
+    expect(root_child2.getComputedLeft()).toBe(180);
+    expect(root_child2.getComputedTop()).toBe(175);
+    expect(root_child2.getComputedWidth()).toBe(120);
+    expect(root_child2.getComputedHeight()).toBe(50);
+  } finally {
+    if (typeof root !== 'undefined') {
+      root.freeRecursive();
+    }
+
+    config.free();
+  }
+});

javascript/tests/generated/YGDisplayContentsTest.test.ts

@@ -0,0 +1,109 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @generated SignedSource<<64d58fa2d33230f4eafc9ecbb6012a0d>>
+ * generated by gentest/gentest-driver.ts from gentest/fixtures/YGDisplayContentsTest.html
+ */
+
+import { instrinsicSizeMeasureFunc } from '../tools/utils.ts'
+import Yoga from 'yoga-layout';
+import {
+  Align,
+  BoxSizing,
+  Direction,
+  Display,
+  Edge,
+  Errata,
+  ExperimentalFeature,
+  FlexDirection,
+  Gutter,
+  Justify,
+  MeasureMode,
+  Overflow,
+  PositionType,
+  Unit,
+  Wrap,
+} from 'yoga-layout';
+
+test('test1', () => {
+  const config = Yoga.Config.create();
+  let root;
+
+  try {
+    root = Yoga.Node.create(config);
+    root.setFlexDirection(FlexDirection.Row);
+    root.setPositionType(PositionType.Absolute);
+    root.setWidth(100);
+    root.setHeight(100);
+
+    const root_child0 = Yoga.Node.create(config);
+    root_child0.setDisplay(Display.Contents);
+    root.insertChild(root_child0, 0);
+
+    const root_child0_child0 = Yoga.Node.create(config);
+    root_child0_child0.setFlexGrow(1);
+    root_child0_child0.setFlexShrink(1);
+    root_child0_child0.setFlexBasis("0%");
+    root_child0_child0.setHeight(10);
+    root_child0.insertChild(root_child0_child0, 0);
+
+    const root_child0_child1 = Yoga.Node.create(config);
+    root_child0_child1.setFlexGrow(1);
+    root_child0_child1.setFlexShrink(1);
+    root_child0_child1.setFlexBasis("0%");
+    root_child0_child1.setHeight(20);
+    root_child0.insertChild(root_child0_child1, 1);
+    root.calculateLayout(undefined, undefined, Direction.LTR);
+
+    expect(root.getComputedLeft()).toBe(0);
+    expect(root.getComputedTop()).toBe(0);
+    expect(root.getComputedWidth()).toBe(100);
+    expect(root.getComputedHeight()).toBe(100);
+
+    expect(root_child0.getComputedLeft()).toBe(0);
+    expect(root_child0.getComputedTop()).toBe(0);
+    expect(root_child0.getComputedWidth()).toBe(0);
+    expect(root_child0.getComputedHeight()).toBe(0);
+
+    expect(root_child0_child0.getComputedLeft()).toBe(0);
+    expect(root_child0_child0.getComputedTop()).toBe(0);
+    expect(root_child0_child0.getComputedWidth()).toBe(50);
+    expect(root_child0_child0.getComputedHeight()).toBe(10);
+
+    expect(root_child0_child1.getComputedLeft()).toBe(50);
+    expect(root_child0_child1.getComputedTop()).toBe(0);
+    expect(root_child0_child1.getComputedWidth()).toBe(50);
+    expect(root_child0_child1.getComputedHeight()).toBe(20);
+
+    root.calculateLayout(undefined, undefined, Direction.RTL);
+
+    expect(root.getComputedLeft()).toBe(0);
+    expect(root.getComputedTop()).toBe(0);
+    expect(root.getComputedWidth()).toBe(100);
+    expect(root.getComputedHeight()).toBe(100);
+
+    expect(root_child0.getComputedLeft()).toBe(0);
+    expect(root_child0.getComputedTop()).toBe(0);
+    expect(root_child0.getComputedWidth()).toBe(0);
+    expect(root_child0.getComputedHeight()).toBe(0);
+
+    expect(root_child0_child0.getComputedLeft()).toBe(50);
+    expect(root_child0_child0.getComputedTop()).toBe(0);
+    expect(root_child0_child0.getComputedWidth()).toBe(50);
+    expect(root_child0_child0.getComputedHeight()).toBe(10);
+
+    expect(root_child0_child1.getComputedLeft()).toBe(0);
+    expect(root_child0_child1.getComputedTop()).toBe(0);
+    expect(root_child0_child1.getComputedWidth()).toBe(50);
+    expect(root_child0_child1.getComputedHeight()).toBe(20);
+  } finally {
+    if (typeof root !== 'undefined') {
+      root.freeRecursive();
+    }
+
+    config.free();
+  }
+});

javascript/tests/generated/YGDisplayTest.test.ts

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<1f15f9628f43eed206466695ec6e683c>>
+ * @generated SignedSource<<ef1ab99e8f13c0a59342ca17f63181ef>>
  * generated by gentest/gentest-driver.ts from gentest/fixtures/YGDisplayTest.html
  */
 
@@ -419,3 +419,679 @@ test('display_none_with_position_absolute', () => {
     config.free();
   }
 });
+test('display_contents', () => {
+  const config = Yoga.Config.create();
+  let root;
+
+  try {
+    root = Yoga.Node.create(config);
+    root.setFlexDirection(FlexDirection.Row);
+    root.setPositionType(PositionType.Absolute);
+    root.setWidth(100);
+    root.setHeight(100);
+
+    const root_child0 = Yoga.Node.create(config);
+    root_child0.setDisplay(Display.Contents);
+    root.insertChild(root_child0, 0);
+
+    const root_child0_child0 = Yoga.Node.create(config);
+    root_child0_child0.setFlexGrow(1);
+    root_child0_child0.setFlexShrink(1);
+    root_child0_child0.setFlexBasis("0%");
+    root_child0_child0.setHeight(10);
+    root_child0.insertChild(root_child0_child0, 0);
+
+    const root_child0_child1 = Yoga.Node.create(config);
+    root_child0_child1.setFlexGrow(1);
+    root_child0_child1.setFlexShrink(1);
+    root_child0_child1.setFlexBasis("0%");
+    root_child0_child1.setHeight(20);
+    root_child0.insertChild(root_child0_child1, 1);
+    root.calculateLayout(undefined, undefined, Direction.LTR);
+
+    expect(root.getComputedLeft()).toBe(0);
+    expect(root.getComputedTop()).toBe(0);
+    expect(root.getComputedWidth()).toBe(100);
+    expect(root.getComputedHeight()).toBe(100);
+
+    expect(root_child0.getComputedLeft()).toBe(0);
+    expect(root_child0.getComputedTop()).toBe(0);
+    expect(root_child0.getComputedWidth()).toBe(0);
+    expect(root_child0.getComputedHeight()).toBe(0);
+
+    expect(root_child0_child0.getComputedLeft()).toBe(0);
+    expect(root_child0_child0.getComputedTop()).toBe(0);
+    expect(root_child0_child0.getComputedWidth()).toBe(50);
+    expect(root_child0_child0.getComputedHeight()).toBe(10);
+
+    expect(root_child0_child1.getComputedLeft()).toBe(50);
+    expect(root_child0_child1.getComputedTop()).toBe(0);
+    expect(root_child0_child1.getComputedWidth()).toBe(50);
+    expect(root_child0_child1.getComputedHeight()).toBe(20);
+
+    root.calculateLayout(undefined, undefined, Direction.RTL);
+
+    expect(root.getComputedLeft()).toBe(0);
+    expect(root.getComputedTop()).toBe(0);
+    expect(root.getComputedWidth()).toBe(100);
+    expect(root.getComputedHeight()).toBe(100);
+
+    expect(root_child0.getComputedLeft()).toBe(0);
+    expect(root_child0.getComputedTop()).toBe(0);
+    expect(root_child0.getComputedWidth()).toBe(0);
+    expect(root_child0.getComputedHeight()).toBe(0);
+
+    expect(root_child0_child0.getComputedLeft()).toBe(50);
+    expect(root_child0_child0.getComputedTop()).toBe(0);
+    expect(root_child0_child0.getComputedWidth()).toBe(50);
+    expect(root_child0_child0.getComputedHeight()).toBe(10);
+
+    expect(root_child0_child1.getComputedLeft()).toBe(0);
+    expect(root_child0_child1.getComputedTop()).toBe(0);
+    expect(root_child0_child1.getComputedWidth()).toBe(50);
+    expect(root_child0_child1.getComputedHeight()).toBe(20);
+  } finally {
+    if (typeof root !== 'undefined') {
+      root.freeRecursive();
+    }
+
+    config.free();
+  }
+});
+test('display_contents_fixed_size', () => {
+  const config = Yoga.Config.create();
+  let root;
+
+  try {
+    root = Yoga.Node.create(config);
+    root.setFlexDirection(FlexDirection.Row);
+    root.setPositionType(PositionType.Absolute);
+    root.setWidth(100);
+    root.setHeight(100);
+
+    const root_child0 = Yoga.Node.create(config);
+    root_child0.setWidth(50);
+    root_child0.setHeight(50);
+    root_child0.setDisplay(Display.Contents);
+    root.insertChild(root_child0, 0);
+
+    const root_child0_child0 = Yoga.Node.create(config);
+    root_child0_child0.setFlexGrow(1);
+    root_child0_child0.setFlexShrink(1);
+    root_child0_child0.setFlexBasis("0%");
+    root_child0_child0.setHeight(10);
+    root_child0.insertChild(root_child0_child0, 0);
+
+    const root_child0_child1 = Yoga.Node.create(config);
+    root_child0_child1.setFlexGrow(1);
+    root_child0_child1.setFlexShrink(1);
+    root_child0_child1.setFlexBasis("0%");
+    root_child0_child1.setHeight(20);
+    root_child0.insertChild(root_child0_child1, 1);
+    root.calculateLayout(undefined, undefined, Direction.LTR);
+
+    expect(root.getComputedLeft()).toBe(0);
+    expect(root.getComputedTop()).toBe(0);
+    expect(root.getComputedWidth()).toBe(100);
+    expect(root.getComputedHeight()).toBe(100);
+
+    expect(root_child0.getComputedLeft()).toBe(0);
+    expect(root_child0.getComputedTop()).toBe(0);
+    expect(root_child0.getComputedWidth()).toBe(0);
+    expect(root_child0.getComputedHeight()).toBe(0);
+
+    expect(root_child0_child0.getComputedLeft()).toBe(0);
+    expect(root_child0_child0.getComputedTop()).toBe(0);
+    expect(root_child0_child0.getComputedWidth()).toBe(50);
+    expect(root_child0_child0.getComputedHeight()).toBe(10);
+
+    expect(root_child0_child1.getComputedLeft()).toBe(50);
+    expect(root_child0_child1.getComputedTop()).toBe(0);
+    expect(root_child0_child1.getComputedWidth()).toBe(50);
+    expect(root_child0_child1.getComputedHeight()).toBe(20);
+
+    root.calculateLayout(undefined, undefined, Direction.RTL);
+
+    expect(root.getComputedLeft()).toBe(0);
+    expect(root.getComputedTop()).toBe(0);
+    expect(root.getComputedWidth()).toBe(100);
+    expect(root.getComputedHeight()).toBe(100);
+
+    expect(root_child0.getComputedLeft()).toBe(0);
+    expect(root_child0.getComputedTop()).toBe(0);
+    expect(root_child0.getComputedWidth()).toBe(0);
+    expect(root_child0.getComputedHeight()).toBe(0);
+
+    expect(root_child0_child0.getComputedLeft()).toBe(50);
+    expect(root_child0_child0.getComputedTop()).toBe(0);
+    expect(root_child0_child0.getComputedWidth()).toBe(50);
+    expect(root_child0_child0.getComputedHeight()).toBe(10);
+
+    expect(root_child0_child1.getComputedLeft()).toBe(0);
+    expect(root_child0_child1.getComputedTop()).toBe(0);
+    expect(root_child0_child1.getComputedWidth()).toBe(50);
+    expect(root_child0_child1.getComputedHeight()).toBe(20);
+  } finally {
+    if (typeof root !== 'undefined') {
+      root.freeRecursive();
+    }
+
+    config.free();
+  }
+});
+test('display_contents_with_margin', () => {
+  const config = Yoga.Config.create();
+  let root;
+
+  try {
+    root = Yoga.Node.create(config);
+    root.setFlexDirection(FlexDirection.Row);
+    root.setPositionType(PositionType.Absolute);
+    root.setWidth(100);
+    root.setHeight(100);
+
+    const root_child0 = Yoga.Node.create(config);
+    root_child0.setMargin(Edge.Left, 10);
+    root_child0.setMargin(Edge.Top, 10);
+    root_child0.setMargin(Edge.Right, 10);
+    root_child0.setMargin(Edge.Bottom, 10);
+    root_child0.setWidth(20);
+    root_child0.setHeight(20);
+    root_child0.setDisplay(Display.Contents);
+    root.insertChild(root_child0, 0);
+
+    const root_child1 = Yoga.Node.create(config);
+    root_child1.setFlexGrow(1);
+    root.insertChild(root_child1, 1);
+    root.calculateLayout(undefined, undefined, Direction.LTR);
+
+    expect(root.getComputedLeft()).toBe(0);
+    expect(root.getComputedTop()).toBe(0);
+    expect(root.getComputedWidth()).toBe(100);
+    expect(root.getComputedHeight()).toBe(100);
+
+    expect(root_child0.getComputedLeft()).toBe(0);
+    expect(root_child0.getComputedTop()).toBe(0);
+    expect(root_child0.getComputedWidth()).toBe(0);
+    expect(root_child0.getComputedHeight()).toBe(0);
+
+    expect(root_child1.getComputedLeft()).toBe(0);
+    expect(root_child1.getComputedTop()).toBe(0);
+    expect(root_child1.getComputedWidth()).toBe(100);
+    expect(root_child1.getComputedHeight()).toBe(100);
+
+    root.calculateLayout(undefined, undefined, Direction.RTL);
+
+    expect(root.getComputedLeft()).toBe(0);
+    expect(root.getComputedTop()).toBe(0);
+    expect(root.getComputedWidth()).toBe(100);
+    expect(root.getComputedHeight()).toBe(100);
+
+    expect(root_child0.getComputedLeft()).toBe(0);
+    expect(root_child0.getComputedTop()).toBe(0);
+    expect(root_child0.getComputedWidth()).toBe(0);
+    expect(root_child0.getComputedHeight()).toBe(0);
+
+    expect(root_child1.getComputedLeft()).toBe(0);
+    expect(root_child1.getComputedTop()).toBe(0);
+    expect(root_child1.getComputedWidth()).toBe(100);
+    expect(root_child1.getComputedHeight()).toBe(100);
+  } finally {
+    if (typeof root !== 'undefined') {
+      root.freeRecursive();
+    }
+
+    config.free();
+  }
+});
+test('display_contents_with_padding', () => {
+  const config = Yoga.Config.create();
+  let root;
+
+  try {
+    root = Yoga.Node.create(config);
+    root.setFlexDirection(FlexDirection.Row);
+    root.setPositionType(PositionType.Absolute);
+    root.setWidth(100);
+    root.setHeight(100);
+
+    const root_child0 = Yoga.Node.create(config);
+    root_child0.setPadding(Edge.Left, 10);
+    root_child0.setPadding(Edge.Top, 10);
+    root_child0.setPadding(Edge.Right, 10);
+    root_child0.setPadding(Edge.Bottom, 10);
+    root_child0.setDisplay(Display.Contents);
+    root.insertChild(root_child0, 0);
+
+    const root_child0_child0 = Yoga.Node.create(config);
+    root_child0_child0.setFlexGrow(1);
+    root_child0_child0.setFlexShrink(1);
+    root_child0_child0.setFlexBasis("0%");
+    root_child0_child0.setHeight(10);
+    root_child0.insertChild(root_child0_child0, 0);
+
+    const root_child0_child1 = Yoga.Node.create(config);
+    root_child0_child1.setFlexGrow(1);
+    root_child0_child1.setFlexShrink(1);
+    root_child0_child1.setFlexBasis("0%");
+    root_child0_child1.setHeight(20);
+    root_child0.insertChild(root_child0_child1, 1);
+    root.calculateLayout(undefined, undefined, Direction.LTR);
+
+    expect(root.getComputedLeft()).toBe(0);
+    expect(root.getComputedTop()).toBe(0);
+    expect(root.getComputedWidth()).toBe(100);
+    expect(root.getComputedHeight()).toBe(100);
+
+    expect(root_child0.getComputedLeft()).toBe(0);
+    expect(root_child0.getComputedTop()).toBe(0);
+    expect(root_child0.getComputedWidth()).toBe(0);
+    expect(root_child0.getComputedHeight()).toBe(0);
+
+    expect(root_child0_child0.getComputedLeft()).toBe(0);
+    expect(root_child0_child0.getComputedTop()).toBe(0);
+    expect(root_child0_child0.getComputedWidth()).toBe(50);
+    expect(root_child0_child0.getComputedHeight()).toBe(10);
+
+    expect(root_child0_child1.getComputedLeft()).toBe(50);
+    expect(root_child0_child1.getComputedTop()).toBe(0);
+    expect(root_child0_child1.getComputedWidth()).toBe(50);
+    expect(root_child0_child1.getComputedHeight()).toBe(20);
+
+    root.calculateLayout(undefined, undefined, Direction.RTL);
+
+    expect(root.getComputedLeft()).toBe(0);
+    expect(root.getComputedTop()).toBe(0);
+    expect(root.getComputedWidth()).toBe(100);
+    expect(root.getComputedHeight()).toBe(100);
+
+    expect(root_child0.getComputedLeft()).toBe(0);
+    expect(root_child0.getComputedTop()).toBe(0);
+    expect(root_child0.getComputedWidth()).toBe(0);
+    expect(root_child0.getComputedHeight()).toBe(0);
+
+    expect(root_child0_child0.getComputedLeft()).toBe(50);
+    expect(root_child0_child0.getComputedTop()).toBe(0);
+    expect(root_child0_child0.getComputedWidth()).toBe(50);
+    expect(root_child0_child0.getComputedHeight()).toBe(10);
+
+    expect(root_child0_child1.getComputedLeft()).toBe(0);
+    expect(root_child0_child1.getComputedTop()).toBe(0);
+    expect(root_child0_child1.getComputedWidth()).toBe(50);
+    expect(root_child0_child1.getComputedHeight()).toBe(20);
+  } finally {
+    if (typeof root !== 'undefined') {
+      root.freeRecursive();
+    }
+
+    config.free();
+  }
+});
+test('display_contents_with_position', () => {
+  const config = Yoga.Config.create();
+  let root;
+
+  try {
+    root = Yoga.Node.create(config);
+    root.setFlexDirection(FlexDirection.Row);
+    root.setPositionType(PositionType.Absolute);
+    root.setWidth(100);
+    root.setHeight(100);
+
+    const root_child0 = Yoga.Node.create(config);
+    root_child0.setPosition(Edge.Top, 10);
+    root_child0.setDisplay(Display.Contents);
+    root.insertChild(root_child0, 0);
+
+    const root_child0_child0 = Yoga.Node.create(config);
+    root_child0_child0.setFlexGrow(1);
+    root_child0_child0.setFlexShrink(1);
+    root_child0_child0.setFlexBasis("0%");
+    root_child0_child0.setHeight(10);
+    root_child0.insertChild(root_child0_child0, 0);
+
+    const root_child0_child1 = Yoga.Node.create(config);
+    root_child0_child1.setFlexGrow(1);
+    root_child0_child1.setFlexShrink(1);
+    root_child0_child1.setFlexBasis("0%");
+    root_child0_child1.setHeight(20);
+    root_child0.insertChild(root_child0_child1, 1);
+    root.calculateLayout(undefined, undefined, Direction.LTR);
+
+    expect(root.getComputedLeft()).toBe(0);
+    expect(root.getComputedTop()).toBe(0);
+    expect(root.getComputedWidth()).toBe(100);
+    expect(root.getComputedHeight()).toBe(100);
+
+    expect(root_child0.getComputedLeft()).toBe(0);
+    expect(root_child0.getComputedTop()).toBe(0);
+    expect(root_child0.getComputedWidth()).toBe(0);
+    expect(root_child0.getComputedHeight()).toBe(0);
+
+    expect(root_child0_child0.getComputedLeft()).toBe(0);
+    expect(root_child0_child0.getComputedTop()).toBe(0);
+    expect(root_child0_child0.getComputedWidth()).toBe(50);
+    expect(root_child0_child0.getComputedHeight()).toBe(10);
+
+    expect(root_child0_child1.getComputedLeft()).toBe(50);
+    expect(root_child0_child1.getComputedTop()).toBe(0);
+    expect(root_child0_child1.getComputedWidth()).toBe(50);
+    expect(root_child0_child1.getComputedHeight()).toBe(20);
+
+    root.calculateLayout(undefined, undefined, Direction.RTL);
+
+    expect(root.getComputedLeft()).toBe(0);
+    expect(root.getComputedTop()).toBe(0);
+    expect(root.getComputedWidth()).toBe(100);
+    expect(root.getComputedHeight()).toBe(100);
+
+    expect(root_child0.getComputedLeft()).toBe(0);
+    expect(root_child0.getComputedTop()).toBe(0);
+    expect(root_child0.getComputedWidth()).toBe(0);
+    expect(root_child0.getComputedHeight()).toBe(0);
+
+    expect(root_child0_child0.getComputedLeft()).toBe(50);
+    expect(root_child0_child0.getComputedTop()).toBe(0);
+    expect(root_child0_child0.getComputedWidth()).toBe(50);
+    expect(root_child0_child0.getComputedHeight()).toBe(10);
+
+    expect(root_child0_child1.getComputedLeft()).toBe(0);
+    expect(root_child0_child1.getComputedTop()).toBe(0);
+    expect(root_child0_child1.getComputedWidth()).toBe(50);
+    expect(root_child0_child1.getComputedHeight()).toBe(20);
+  } finally {
+    if (typeof root !== 'undefined') {
+      root.freeRecursive();
+    }
+
+    config.free();
+  }
+});
+test('display_contents_with_position_absolute', () => {
+  const config = Yoga.Config.create();
+  let root;
+
+  try {
+    root = Yoga.Node.create(config);
+    root.setFlexDirection(FlexDirection.Row);
+    root.setPositionType(PositionType.Absolute);
+    root.setWidth(100);
+    root.setHeight(100);
+
+    const root_child0 = Yoga.Node.create(config);
+    root_child0.setPositionType(PositionType.Absolute);
+    root_child0.setWidth(50);
+    root_child0.setHeight(50);
+    root_child0.setDisplay(Display.Contents);
+    root.insertChild(root_child0, 0);
+
+    const root_child0_child0 = Yoga.Node.create(config);
+    root_child0_child0.setFlexGrow(1);
+    root_child0_child0.setFlexShrink(1);
+    root_child0_child0.setFlexBasis("0%");
+    root_child0_child0.setHeight(10);
+    root_child0.insertChild(root_child0_child0, 0);
+
+    const root_child0_child1 = Yoga.Node.create(config);
+    root_child0_child1.setFlexGrow(1);
+    root_child0_child1.setFlexShrink(1);
+    root_child0_child1.setFlexBasis("0%");
+    root_child0_child1.setHeight(20);
+    root_child0.insertChild(root_child0_child1, 1);
+    root.calculateLayout(undefined, undefined, Direction.LTR);
+
+    expect(root.getComputedLeft()).toBe(0);
+    expect(root.getComputedTop()).toBe(0);
+    expect(root.getComputedWidth()).toBe(100);
+    expect(root.getComputedHeight()).toBe(100);
+
+    expect(root_child0.getComputedLeft()).toBe(0);
+    expect(root_child0.getComputedTop()).toBe(0);
+    expect(root_child0.getComputedWidth()).toBe(0);
+    expect(root_child0.getComputedHeight()).toBe(0);
+
+    expect(root_child0_child0.getComputedLeft()).toBe(0);
+    expect(root_child0_child0.getComputedTop()).toBe(0);
+    expect(root_child0_child0.getComputedWidth()).toBe(50);
+    expect(root_child0_child0.getComputedHeight()).toBe(10);
+
+    expect(root_child0_child1.getComputedLeft()).toBe(50);
+    expect(root_child0_child1.getComputedTop()).toBe(0);
+    expect(root_child0_child1.getComputedWidth()).toBe(50);
+    expect(root_child0_child1.getComputedHeight()).toBe(20);
+
+    root.calculateLayout(undefined, undefined, Direction.RTL);
+
+    expect(root.getComputedLeft()).toBe(0);
+    expect(root.getComputedTop()).toBe(0);
+    expect(root.getComputedWidth()).toBe(100);
+    expect(root.getComputedHeight()).toBe(100);
+
+    expect(root_child0.getComputedLeft()).toBe(0);
+    expect(root_child0.getComputedTop()).toBe(0);
+    expect(root_child0.getComputedWidth()).toBe(0);
+    expect(root_child0.getComputedHeight()).toBe(0);
+
+    expect(root_child0_child0.getComputedLeft()).toBe(50);
+    expect(root_child0_child0.getComputedTop()).toBe(0);
+    expect(root_child0_child0.getComputedWidth()).toBe(50);
+    expect(root_child0_child0.getComputedHeight()).toBe(10);
+
+    expect(root_child0_child1.getComputedLeft()).toBe(0);
+    expect(root_child0_child1.getComputedTop()).toBe(0);
+    expect(root_child0_child1.getComputedWidth()).toBe(50);
+    expect(root_child0_child1.getComputedHeight()).toBe(20);
+  } finally {
+    if (typeof root !== 'undefined') {
+      root.freeRecursive();
+    }
+
+    config.free();
+  }
+});
+test('display_contents_nested', () => {
+  const config = Yoga.Config.create();
+  let root;
+
+  try {
+    root = Yoga.Node.create(config);
+    root.setFlexDirection(FlexDirection.Row);
+    root.setPositionType(PositionType.Absolute);
+    root.setWidth(100);
+    root.setHeight(100);
+
+    const root_child0 = Yoga.Node.create(config);
+    root_child0.setDisplay(Display.Contents);
+    root.insertChild(root_child0, 0);
+
+    const root_child0_child0 = Yoga.Node.create(config);
+    root_child0_child0.setDisplay(Display.Contents);
+    root_child0.insertChild(root_child0_child0, 0);
+
+    const root_child0_child0_child0 = Yoga.Node.create(config);
+    root_child0_child0_child0.setFlexGrow(1);
+    root_child0_child0_child0.setFlexShrink(1);
+    root_child0_child0_child0.setFlexBasis("0%");
+    root_child0_child0_child0.setHeight(10);
+    root_child0_child0.insertChild(root_child0_child0_child0, 0);
+
+    const root_child0_child0_child1 = Yoga.Node.create(config);
+    root_child0_child0_child1.setFlexGrow(1);
+    root_child0_child0_child1.setFlexShrink(1);
+    root_child0_child0_child1.setFlexBasis("0%");
+    root_child0_child0_child1.setHeight(20);
+    root_child0_child0.insertChild(root_child0_child0_child1, 1);
+    root.calculateLayout(undefined, undefined, Direction.LTR);
+
+    expect(root.getComputedLeft()).toBe(0);
+    expect(root.getComputedTop()).toBe(0);
+    expect(root.getComputedWidth()).toBe(100);
+    expect(root.getComputedHeight()).toBe(100);
+
+    expect(root_child0.getComputedLeft()).toBe(0);
+    expect(root_child0.getComputedTop()).toBe(0);
+    expect(root_child0.getComputedWidth()).toBe(0);
+    expect(root_child0.getComputedHeight()).toBe(0);
+
+    expect(root_child0_child0.getComputedLeft()).toBe(0);
+    expect(root_child0_child0.getComputedTop()).toBe(0);
+    expect(root_child0_child0.getComputedWidth()).toBe(0);
+    expect(root_child0_child0.getComputedHeight()).toBe(0);
+
+    expect(root_child0_child0_child0.getComputedLeft()).toBe(0);
+    expect(root_child0_child0_child0.getComputedTop()).toBe(0);
+    expect(root_child0_child0_child0.getComputedWidth()).toBe(50);
+    expect(root_child0_child0_child0.getComputedHeight()).toBe(10);
+
+    expect(root_child0_child0_child1.getComputedLeft()).toBe(50);
+    expect(root_child0_child0_child1.getComputedTop()).toBe(0);
+    expect(root_child0_child0_child1.getComputedWidth()).toBe(50);
+    expect(root_child0_child0_child1.getComputedHeight()).toBe(20);
+
+    root.calculateLayout(undefined, undefined, Direction.RTL);
+
+    expect(root.getComputedLeft()).toBe(0);
+    expect(root.getComputedTop()).toBe(0);
+    expect(root.getComputedWidth()).toBe(100);
+    expect(root.getComputedHeight()).toBe(100);
+
+    expect(root_child0.getComputedLeft()).toBe(0);
+    expect(root_child0.getComputedTop()).toBe(0);
+    expect(root_child0.getComputedWidth()).toBe(0);
+    expect(root_child0.getComputedHeight()).toBe(0);
+
+    expect(root_child0_child0.getComputedLeft()).toBe(0);
+    expect(root_child0_child0.getComputedTop()).toBe(0);
+    expect(root_child0_child0.getComputedWidth()).toBe(0);
+    expect(root_child0_child0.getComputedHeight()).toBe(0);
+
+    expect(root_child0_child0_child0.getComputedLeft()).toBe(50);
+    expect(root_child0_child0_child0.getComputedTop()).toBe(0);
+    expect(root_child0_child0_child0.getComputedWidth()).toBe(50);
+    expect(root_child0_child0_child0.getComputedHeight()).toBe(10);
+
+    expect(root_child0_child0_child1.getComputedLeft()).toBe(0);
+    expect(root_child0_child0_child1.getComputedTop()).toBe(0);
+    expect(root_child0_child0_child1.getComputedWidth()).toBe(50);
+    expect(root_child0_child0_child1.getComputedHeight()).toBe(20);
+  } finally {
+    if (typeof root !== 'undefined') {
+      root.freeRecursive();
+    }
+
+    config.free();
+  }
+});
+test('display_contents_with_siblings', () => {
+  const config = Yoga.Config.create();
+  let root;
+
+  try {
+    root = Yoga.Node.create(config);
+    root.setFlexDirection(FlexDirection.Row);
+    root.setPositionType(PositionType.Absolute);
+    root.setWidth(100);
+    root.setHeight(100);
+
+    const root_child0 = Yoga.Node.create(config);
+    root_child0.setFlexGrow(1);
+    root_child0.setFlexShrink(1);
+    root_child0.setFlexBasis("0%");
+    root_child0.setHeight(30);
+    root.insertChild(root_child0, 0);
+
+    const root_child1 = Yoga.Node.create(config);
+    root_child1.setDisplay(Display.Contents);
+    root.insertChild(root_child1, 1);
+
+    const root_child1_child0 = Yoga.Node.create(config);
+    root_child1_child0.setFlexGrow(1);
+    root_child1_child0.setFlexShrink(1);
+    root_child1_child0.setFlexBasis("0%");
+    root_child1_child0.setHeight(10);
+    root_child1.insertChild(root_child1_child0, 0);
+
+    const root_child1_child1 = Yoga.Node.create(config);
+    root_child1_child1.setFlexGrow(1);
+    root_child1_child1.setFlexShrink(1);
+    root_child1_child1.setFlexBasis("0%");
+    root_child1_child1.setHeight(20);
+    root_child1.insertChild(root_child1_child1, 1);
+
+    const root_child2 = Yoga.Node.create(config);
+    root_child2.setFlexGrow(1);
+    root_child2.setFlexShrink(1);
+    root_child2.setFlexBasis("0%");
+    root_child2.setHeight(30);
+    root.insertChild(root_child2, 2);
+    root.calculateLayout(undefined, undefined, Direction.LTR);
+
+    expect(root.getComputedLeft()).toBe(0);
+    expect(root.getComputedTop()).toBe(0);
+    expect(root.getComputedWidth()).toBe(100);
+    expect(root.getComputedHeight()).toBe(100);
+
+    expect(root_child0.getComputedLeft()).toBe(0);
+    expect(root_child0.getComputedTop()).toBe(0);
+    expect(root_child0.getComputedWidth()).toBe(25);
+    expect(root_child0.getComputedHeight()).toBe(30);
+
+    expect(root_child1.getComputedLeft()).toBe(0);
+    expect(root_child1.getComputedTop()).toBe(0);
+    expect(root_child1.getComputedWidth()).toBe(0);
+    expect(root_child1.getComputedHeight()).toBe(0);
+
+    expect(root_child1_child0.getComputedLeft()).toBe(25);
+    expect(root_child1_child0.getComputedTop()).toBe(0);
+    expect(root_child1_child0.getComputedWidth()).toBe(25);
+    expect(root_child1_child0.getComputedHeight()).toBe(10);
+
+    expect(root_child1_child1.getComputedLeft()).toBe(50);
+    expect(root_child1_child1.getComputedTop()).toBe(0);
+    expect(root_child1_child1.getComputedWidth()).toBe(25);
+    expect(root_child1_child1.getComputedHeight()).toBe(20);
+
+    expect(root_child2.getComputedLeft()).toBe(75);
+    expect(root_child2.getComputedTop()).toBe(0);
+    expect(root_child2.getComputedWidth()).toBe(25);
+    expect(root_child2.getComputedHeight()).toBe(30);
+
+    root.calculateLayout(undefined, undefined, Direction.RTL);
+
+    expect(root.getComputedLeft()).toBe(0);
+    expect(root.getComputedTop()).toBe(0);
+    expect(root.getComputedWidth()).toBe(100);
+    expect(root.getComputedHeight()).toBe(100);
+
+    expect(root_child0.getComputedLeft()).toBe(75);
+    expect(root_child0.getComputedTop()).toBe(0);
+    expect(root_child0.getComputedWidth()).toBe(25);
+    expect(root_child0.getComputedHeight()).toBe(30);
+
+    expect(root_child1.getComputedLeft()).toBe(0);
+    expect(root_child1.getComputedTop()).toBe(0);
+    expect(root_child1.getComputedWidth()).toBe(0);
+    expect(root_child1.getComputedHeight()).toBe(0);
+
+    expect(root_child1_child0.getComputedLeft()).toBe(50);
+    expect(root_child1_child0.getComputedTop()).toBe(0);
+    expect(root_child1_child0.getComputedWidth()).toBe(25);
+    expect(root_child1_child0.getComputedHeight()).toBe(10);
+
+    expect(root_child1_child1.getComputedLeft()).toBe(25);
+    expect(root_child1_child1.getComputedTop()).toBe(0);
+    expect(root_child1_child1.getComputedWidth()).toBe(25);
+    expect(root_child1_child1.getComputedHeight()).toBe(20);
+
+    expect(root_child2.getComputedLeft()).toBe(0);
+    expect(root_child2.getComputedTop()).toBe(0);
+    expect(root_child2.getComputedWidth()).toBe(25);
+    expect(root_child2.getComputedHeight()).toBe(30);
+  } finally {
+    if (typeof root !== 'undefined') {
+      root.freeRecursive();
+    }
+
+    config.free();
+  }
+});

javascript/tests/generated/YGJustifyContentTest.test.ts

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<4d367d399575872c385f254588d91fb5>>
+ * @generated SignedSource<<d9c3d3430edadef3cd6ba8bbacbb31a2>>
  * generated by gentest/gentest-driver.ts from gentest/fixtures/YGJustifyContentTest.html
  */
 
@@ -1925,7 +1925,7 @@ test('justify_content_overflow_row_space_evenly', () => {
     config.free();
   }
 });
-test('justify_content_overflow_row_reverse_space_around', () => {
+test.skip('justify_content_overflow_row_reverse_space_around', () => {
   const config = Yoga.Config.create();
   let root;
 
@@ -1955,17 +1955,17 @@ test('justify_content_overflow_row_reverse_space_around', () => {
     expect(root.getComputedWidth()).toBe(102);
     expect(root.getComputedHeight()).toBe(102);
 
-    expect(root_child0.getComputedLeft()).toBe(62);
+    expect(root_child0.getComputedLeft()).toBe(80);
     expect(root_child0.getComputedTop()).toBe(0);
     expect(root_child0.getComputedWidth()).toBe(40);
     expect(root_child0.getComputedHeight()).toBe(102);
 
-    expect(root_child1.getComputedLeft()).toBe(22);
+    expect(root_child1.getComputedLeft()).toBe(40);
     expect(root_child1.getComputedTop()).toBe(0);
     expect(root_child1.getComputedWidth()).toBe(40);
     expect(root_child1.getComputedHeight()).toBe(102);
 
-    expect(root_child2.getComputedLeft()).toBe(-18);
+    expect(root_child2.getComputedLeft()).toBe(0);
     expect(root_child2.getComputedTop()).toBe(0);
     expect(root_child2.getComputedWidth()).toBe(40);
     expect(root_child2.getComputedHeight()).toBe(102);
@@ -1977,17 +1977,17 @@ test('justify_content_overflow_row_reverse_space_around', () => {
     expect(root.getComputedWidth()).toBe(102);
     expect(root.getComputedHeight()).toBe(102);
 
-    expect(root_child0.getComputedLeft()).toBe(0);
+    expect(root_child0.getComputedLeft()).toBe(-18);
     expect(root_child0.getComputedTop()).toBe(0);
     expect(root_child0.getComputedWidth()).toBe(40);
     expect(root_child0.getComputedHeight()).toBe(102);
 
-    expect(root_child1.getComputedLeft()).toBe(40);
+    expect(root_child1.getComputedLeft()).toBe(22);
     expect(root_child1.getComputedTop()).toBe(0);
     expect(root_child1.getComputedWidth()).toBe(40);
     expect(root_child1.getComputedHeight()).toBe(102);
 
-    expect(root_child2.getComputedLeft()).toBe(80);
+    expect(root_child2.getComputedLeft()).toBe(62);
     expect(root_child2.getComputedTop()).toBe(0);
     expect(root_child2.getComputedWidth()).toBe(40);
     expect(root_child2.getComputedHeight()).toBe(102);
@@ -1999,7 +1999,7 @@ test('justify_content_overflow_row_reverse_space_around', () => {
     config.free();
   }
 });
-test('justify_content_overflow_row_reverse_space_evenly', () => {
+test.skip('justify_content_overflow_row_reverse_space_evenly', () => {
   const config = Yoga.Config.create();
   let root;
 
@@ -2029,17 +2029,17 @@ test('justify_content_overflow_row_reverse_space_evenly', () => {
     expect(root.getComputedWidth()).toBe(102);
     expect(root.getComputedHeight()).toBe(102);
 
-    expect(root_child0.getComputedLeft()).toBe(62);
+    expect(root_child0.getComputedLeft()).toBe(80);
     expect(root_child0.getComputedTop()).toBe(0);
     expect(root_child0.getComputedWidth()).toBe(40);
     expect(root_child0.getComputedHeight()).toBe(102);
 
-    expect(root_child1.getComputedLeft()).toBe(22);
+    expect(root_child1.getComputedLeft()).toBe(40);
     expect(root_child1.getComputedTop()).toBe(0);
     expect(root_child1.getComputedWidth()).toBe(40);
     expect(root_child1.getComputedHeight()).toBe(102);
 
-    expect(root_child2.getComputedLeft()).toBe(-18);
+    expect(root_child2.getComputedLeft()).toBe(0);
     expect(root_child2.getComputedTop()).toBe(0);
     expect(root_child2.getComputedWidth()).toBe(40);
     expect(root_child2.getComputedHeight()).toBe(102);
@@ -2051,17 +2051,17 @@ test('justify_content_overflow_row_reverse_space_evenly', () => {
     expect(root.getComputedWidth()).toBe(102);
     expect(root.getComputedHeight()).toBe(102);
 
-    expect(root_child0.getComputedLeft()).toBe(0);
+    expect(root_child0.getComputedLeft()).toBe(-18);
     expect(root_child0.getComputedTop()).toBe(0);
     expect(root_child0.getComputedWidth()).toBe(40);
     expect(root_child0.getComputedHeight()).toBe(102);
 
-    expect(root_child1.getComputedLeft()).toBe(40);
+    expect(root_child1.getComputedLeft()).toBe(22);
     expect(root_child1.getComputedTop()).toBe(0);
     expect(root_child1.getComputedWidth()).toBe(40);
     expect(root_child1.getComputedHeight()).toBe(102);
 
-    expect(root_child2.getComputedLeft()).toBe(80);
+    expect(root_child2.getComputedLeft()).toBe(62);
     expect(root_child2.getComputedTop()).toBe(0);
     expect(root_child2.getComputedWidth()).toBe(40);
     expect(root_child2.getComputedHeight()).toBe(102);

tests/YGLayoutableChildrenTest.cpp

@@ -0,0 +1,191 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include <gtest/gtest.h>
+#include <yoga/Yoga.h>
+#include <yoga/node/Node.h>
+#include <cstdio>
+
+TEST(YogaTest, layoutable_children_single_contents_node) {
+  YGNodeRef root = YGNodeNew();
+
+  YGNodeRef root_child0 = YGNodeNew();
+  YGNodeRef root_child1 = YGNodeNew();
+  YGNodeRef root_child2 = YGNodeNew();
+
+  YGNodeRef root_grandchild0 = YGNodeNew();
+  YGNodeRef root_grandchild1 = YGNodeNew();
+
+  YGNodeInsertChild(root, root_child0, 0);
+  YGNodeInsertChild(root, root_child1, 1);
+  YGNodeInsertChild(root, root_child2, 2);
+
+  YGNodeInsertChild(root_child1, root_grandchild0, 0);
+  YGNodeInsertChild(root_child1, root_grandchild1, 1);
+
+  YGNodeStyleSetDisplay(root_child1, YGDisplayContents);
+
+  std::vector<facebook::yoga::Node*> order = {
+      facebook::yoga::resolveRef(root_child0),
+      facebook::yoga::resolveRef(root_grandchild0),
+      facebook::yoga::resolveRef(root_grandchild1),
+      facebook::yoga::resolveRef(root_child2),
+  };
+  auto correctOrderIt = order.begin();
+
+  for (auto node : facebook::yoga::resolveRef(root)->getLayoutChildren()) {
+    ASSERT_EQ(node, *correctOrderIt);
+    correctOrderIt++;
+  }
+
+  YGNodeFreeRecursive(root);
+}
+
+TEST(YogaTest, layoutable_children_multiple_contents_nodes) {
+  YGNodeRef root = YGNodeNew();
+
+  YGNodeRef root_child0 = YGNodeNew();
+  YGNodeRef root_child1 = YGNodeNew();
+  YGNodeRef root_child2 = YGNodeNew();
+
+  YGNodeRef root_grandchild0 = YGNodeNew();
+  YGNodeRef root_grandchild1 = YGNodeNew();
+  YGNodeRef root_grandchild2 = YGNodeNew();
+  YGNodeRef root_grandchild3 = YGNodeNew();
+  YGNodeRef root_grandchild4 = YGNodeNew();
+  YGNodeRef root_grandchild5 = YGNodeNew();
+
+  YGNodeInsertChild(root, root_child0, 0);
+  YGNodeInsertChild(root, root_child1, 1);
+  YGNodeInsertChild(root, root_child2, 2);
+
+  YGNodeInsertChild(root_child0, root_grandchild0, 0);
+  YGNodeInsertChild(root_child0, root_grandchild1, 1);
+  YGNodeInsertChild(root_child1, root_grandchild2, 0);
+  YGNodeInsertChild(root_child1, root_grandchild3, 1);
+  YGNodeInsertChild(root_child2, root_grandchild4, 0);
+  YGNodeInsertChild(root_child2, root_grandchild5, 1);
+
+  YGNodeStyleSetDisplay(root_child0, YGDisplayContents);
+  YGNodeStyleSetDisplay(root_child1, YGDisplayContents);
+  YGNodeStyleSetDisplay(root_child2, YGDisplayContents);
+
+  std::vector<facebook::yoga::Node*> order = {
+      facebook::yoga::resolveRef(root_grandchild0),
+      facebook::yoga::resolveRef(root_grandchild1),
+      facebook::yoga::resolveRef(root_grandchild2),
+      facebook::yoga::resolveRef(root_grandchild3),
+      facebook::yoga::resolveRef(root_grandchild4),
+      facebook::yoga::resolveRef(root_grandchild5),
+  };
+  auto correctOrderIt = order.begin();
+
+  for (auto node : facebook::yoga::resolveRef(root)->getLayoutChildren()) {
+    ASSERT_EQ(node, *correctOrderIt);
+    correctOrderIt++;
+  }
+
+  YGNodeFreeRecursive(root);
+}
+
+TEST(YogaTest, layoutable_children_nested_contents_nodes) {
+  YGNodeRef root = YGNodeNew();
+
+  YGNodeRef root_child0 = YGNodeNew();
+  YGNodeRef root_child1 = YGNodeNew();
+  YGNodeRef root_child2 = YGNodeNew();
+
+  YGNodeRef root_grandchild0 = YGNodeNew();
+  YGNodeRef root_grandchild1 = YGNodeNew();
+
+  YGNodeRef root_great_grandchild0 = YGNodeNew();
+  YGNodeRef root_great_grandchild1 = YGNodeNew();
+
+  YGNodeInsertChild(root, root_child0, 0);
+  YGNodeInsertChild(root, root_child1, 1);
+  YGNodeInsertChild(root, root_child2, 2);
+
+  YGNodeInsertChild(root_child1, root_grandchild0, 0);
+  YGNodeInsertChild(root_child1, root_grandchild1, 1);
+
+  YGNodeInsertChild(root_grandchild1, root_great_grandchild0, 0);
+  YGNodeInsertChild(root_grandchild1, root_great_grandchild1, 1);
+
+  YGNodeStyleSetDisplay(root_child1, YGDisplayContents);
+  YGNodeStyleSetDisplay(root_grandchild1, YGDisplayContents);
+
+  std::vector<facebook::yoga::Node*> order = {
+      facebook::yoga::resolveRef(root_child0),
+      facebook::yoga::resolveRef(root_grandchild0),
+      facebook::yoga::resolveRef(root_great_grandchild0),
+      facebook::yoga::resolveRef(root_great_grandchild1),
+      facebook::yoga::resolveRef(root_child2),
+  };
+  auto correctOrderIt = order.begin();
+
+  for (auto node : facebook::yoga::resolveRef(root)->getLayoutChildren()) {
+    ASSERT_EQ(node, *correctOrderIt);
+    correctOrderIt++;
+  }
+
+  YGNodeFreeRecursive(root);
+}
+
+TEST(YogaTest, layoutable_children_contents_leaf_node) {
+  YGNodeRef root = YGNodeNew();
+
+  YGNodeRef root_child0 = YGNodeNew();
+  YGNodeRef root_child1 = YGNodeNew();
+  YGNodeRef root_child2 = YGNodeNew();
+
+  YGNodeInsertChild(root, root_child0, 0);
+  YGNodeInsertChild(root, root_child1, 1);
+  YGNodeInsertChild(root, root_child2, 2);
+
+  YGNodeStyleSetDisplay(root_child1, YGDisplayContents);
+
+  std::vector<facebook::yoga::Node*> order = {
+      facebook::yoga::resolveRef(root_child0),
+      facebook::yoga::resolveRef(root_child2),
+  };
+  auto correctOrderIt = order.begin();
+
+  for (auto node : facebook::yoga::resolveRef(root)->getLayoutChildren()) {
+    ASSERT_EQ(node, *correctOrderIt);
+    correctOrderIt++;
+  }
+
+  YGNodeFreeRecursive(root);
+}
+
+TEST(YogaTest, layoutable_children_contents_root_node) {
+  YGNodeRef root = YGNodeNew();
+
+  YGNodeRef root_child0 = YGNodeNew();
+  YGNodeRef root_child1 = YGNodeNew();
+  YGNodeRef root_child2 = YGNodeNew();
+
+  YGNodeInsertChild(root, root_child0, 0);
+  YGNodeInsertChild(root, root_child1, 1);
+  YGNodeInsertChild(root, root_child2, 2);
+
+  YGNodeStyleSetDisplay(root, YGDisplayContents);
+
+  std::vector<facebook::yoga::Node*> order = {
+      facebook::yoga::resolveRef(root_child0),
+      facebook::yoga::resolveRef(root_child1),
+      facebook::yoga::resolveRef(root_child2),
+  };
+  auto correctOrderIt = order.begin();
+
+  for (auto node : facebook::yoga::resolveRef(root)->getLayoutChildren()) {
+    ASSERT_EQ(node, *correctOrderIt);
+    correctOrderIt++;
+  }
+
+  YGNodeFreeRecursive(root);
+}

tests/generated/YGAlignContentTest.cpp

@@ -5,7 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  *
  * clang-format off
- * @generated SignedSource<<37e5721da82615c5e6543420f2bfc792>>
+ * @generated SignedSource<<a0af76959fbfcb6b0a0f5ac394ceafe9>>
  * generated by gentest/gentest-driver.ts from gentest/fixtures/YGAlignContentTest.html
  */
 
@@ -5252,3 +5252,306 @@ TEST(YogaTest, align_content_space_evenly_stretch_does_influence_line_box_dim) {
 
   YGConfigFree(config);
 }
+
+TEST(YogaTest, align_content_stretch_and_align_items_flex_end_with_flex_wrap) {
+  YGConfigRef config = YGConfigNew();
+
+  YGNodeRef root = YGNodeNewWithConfig(config);
+  YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
+  YGNodeStyleSetAlignContent(root, YGAlignStretch);
+  YGNodeStyleSetAlignItems(root, YGAlignFlexEnd);
+  YGNodeStyleSetPositionType(root, YGPositionTypeAbsolute);
+  YGNodeStyleSetFlexWrap(root, YGWrapWrap);
+  YGNodeStyleSetWidth(root, 300);
+  YGNodeStyleSetHeight(root, 300);
+
+  YGNodeRef root_child0 = YGNodeNewWithConfig(config);
+  YGNodeStyleSetAlignSelf(root_child0, YGAlignFlexStart);
+  YGNodeStyleSetWidth(root_child0, 150);
+  YGNodeStyleSetHeight(root_child0, 50);
+  YGNodeInsertChild(root, root_child0, 0);
+
+  YGNodeRef root_child1 = YGNodeNewWithConfig(config);
+  YGNodeStyleSetWidth(root_child1, 120);
+  YGNodeStyleSetHeight(root_child1, 100);
+  YGNodeInsertChild(root, root_child1, 1);
+
+  YGNodeRef root_child2 = YGNodeNewWithConfig(config);
+  YGNodeStyleSetWidth(root_child2, 120);
+  YGNodeStyleSetHeight(root_child2, 50);
+  YGNodeInsertChild(root, root_child2, 2);
+  YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
+  ASSERT_FLOAT_EQ(300, YGNodeLayoutGetWidth(root));
+  ASSERT_FLOAT_EQ(300, YGNodeLayoutGetHeight(root));
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
+  ASSERT_FLOAT_EQ(150, YGNodeLayoutGetWidth(root_child0));
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0));
+
+  ASSERT_FLOAT_EQ(150, YGNodeLayoutGetLeft(root_child1));
+  ASSERT_FLOAT_EQ(75, YGNodeLayoutGetTop(root_child1));
+  ASSERT_FLOAT_EQ(120, YGNodeLayoutGetWidth(root_child1));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root_child1));
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child2));
+  ASSERT_FLOAT_EQ(250, YGNodeLayoutGetTop(root_child2));
+  ASSERT_FLOAT_EQ(120, YGNodeLayoutGetWidth(root_child2));
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child2));
+
+  YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
+  ASSERT_FLOAT_EQ(300, YGNodeLayoutGetWidth(root));
+  ASSERT_FLOAT_EQ(300, YGNodeLayoutGetHeight(root));
+
+  ASSERT_FLOAT_EQ(150, YGNodeLayoutGetLeft(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
+  ASSERT_FLOAT_EQ(150, YGNodeLayoutGetWidth(root_child0));
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0));
+
+  ASSERT_FLOAT_EQ(30, YGNodeLayoutGetLeft(root_child1));
+  ASSERT_FLOAT_EQ(75, YGNodeLayoutGetTop(root_child1));
+  ASSERT_FLOAT_EQ(120, YGNodeLayoutGetWidth(root_child1));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root_child1));
+
+  ASSERT_FLOAT_EQ(180, YGNodeLayoutGetLeft(root_child2));
+  ASSERT_FLOAT_EQ(250, YGNodeLayoutGetTop(root_child2));
+  ASSERT_FLOAT_EQ(120, YGNodeLayoutGetWidth(root_child2));
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child2));
+
+  YGNodeFreeRecursive(root);
+
+  YGConfigFree(config);
+}
+
+TEST(YogaTest, align_content_stretch_and_align_items_flex_start_with_flex_wrap) {
+  YGConfigRef config = YGConfigNew();
+
+  YGNodeRef root = YGNodeNewWithConfig(config);
+  YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
+  YGNodeStyleSetAlignContent(root, YGAlignStretch);
+  YGNodeStyleSetAlignItems(root, YGAlignFlexStart);
+  YGNodeStyleSetPositionType(root, YGPositionTypeAbsolute);
+  YGNodeStyleSetFlexWrap(root, YGWrapWrap);
+  YGNodeStyleSetWidth(root, 300);
+  YGNodeStyleSetHeight(root, 300);
+
+  YGNodeRef root_child0 = YGNodeNewWithConfig(config);
+  YGNodeStyleSetAlignSelf(root_child0, YGAlignFlexEnd);
+  YGNodeStyleSetWidth(root_child0, 150);
+  YGNodeStyleSetHeight(root_child0, 50);
+  YGNodeInsertChild(root, root_child0, 0);
+
+  YGNodeRef root_child1 = YGNodeNewWithConfig(config);
+  YGNodeStyleSetWidth(root_child1, 120);
+  YGNodeStyleSetHeight(root_child1, 100);
+  YGNodeInsertChild(root, root_child1, 1);
+
+  YGNodeRef root_child2 = YGNodeNewWithConfig(config);
+  YGNodeStyleSetWidth(root_child2, 120);
+  YGNodeStyleSetHeight(root_child2, 50);
+  YGNodeInsertChild(root, root_child2, 2);
+  YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
+  ASSERT_FLOAT_EQ(300, YGNodeLayoutGetWidth(root));
+  ASSERT_FLOAT_EQ(300, YGNodeLayoutGetHeight(root));
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
+  ASSERT_FLOAT_EQ(125, YGNodeLayoutGetTop(root_child0));
+  ASSERT_FLOAT_EQ(150, YGNodeLayoutGetWidth(root_child0));
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0));
+
+  ASSERT_FLOAT_EQ(150, YGNodeLayoutGetLeft(root_child1));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child1));
+  ASSERT_FLOAT_EQ(120, YGNodeLayoutGetWidth(root_child1));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root_child1));
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child2));
+  ASSERT_FLOAT_EQ(175, YGNodeLayoutGetTop(root_child2));
+  ASSERT_FLOAT_EQ(120, YGNodeLayoutGetWidth(root_child2));
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child2));
+
+  YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
+  ASSERT_FLOAT_EQ(300, YGNodeLayoutGetWidth(root));
+  ASSERT_FLOAT_EQ(300, YGNodeLayoutGetHeight(root));
+
+  ASSERT_FLOAT_EQ(150, YGNodeLayoutGetLeft(root_child0));
+  ASSERT_FLOAT_EQ(125, YGNodeLayoutGetTop(root_child0));
+  ASSERT_FLOAT_EQ(150, YGNodeLayoutGetWidth(root_child0));
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0));
+
+  ASSERT_FLOAT_EQ(30, YGNodeLayoutGetLeft(root_child1));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child1));
+  ASSERT_FLOAT_EQ(120, YGNodeLayoutGetWidth(root_child1));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root_child1));
+
+  ASSERT_FLOAT_EQ(180, YGNodeLayoutGetLeft(root_child2));
+  ASSERT_FLOAT_EQ(175, YGNodeLayoutGetTop(root_child2));
+  ASSERT_FLOAT_EQ(120, YGNodeLayoutGetWidth(root_child2));
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child2));
+
+  YGNodeFreeRecursive(root);
+
+  YGConfigFree(config);
+}
+
+TEST(YogaTest, align_content_stretch_and_align_items_center_with_flex_wrap) {
+  YGConfigRef config = YGConfigNew();
+
+  YGNodeRef root = YGNodeNewWithConfig(config);
+  YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
+  YGNodeStyleSetAlignContent(root, YGAlignStretch);
+  YGNodeStyleSetAlignItems(root, YGAlignCenter);
+  YGNodeStyleSetPositionType(root, YGPositionTypeAbsolute);
+  YGNodeStyleSetFlexWrap(root, YGWrapWrap);
+  YGNodeStyleSetWidth(root, 300);
+  YGNodeStyleSetHeight(root, 300);
+
+  YGNodeRef root_child0 = YGNodeNewWithConfig(config);
+  YGNodeStyleSetAlignSelf(root_child0, YGAlignFlexEnd);
+  YGNodeStyleSetWidth(root_child0, 150);
+  YGNodeStyleSetHeight(root_child0, 50);
+  YGNodeInsertChild(root, root_child0, 0);
+
+  YGNodeRef root_child1 = YGNodeNewWithConfig(config);
+  YGNodeStyleSetWidth(root_child1, 120);
+  YGNodeStyleSetHeight(root_child1, 100);
+  YGNodeInsertChild(root, root_child1, 1);
+
+  YGNodeRef root_child2 = YGNodeNewWithConfig(config);
+  YGNodeStyleSetWidth(root_child2, 120);
+  YGNodeStyleSetHeight(root_child2, 50);
+  YGNodeInsertChild(root, root_child2, 2);
+  YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
+  ASSERT_FLOAT_EQ(300, YGNodeLayoutGetWidth(root));
+  ASSERT_FLOAT_EQ(300, YGNodeLayoutGetHeight(root));
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
+  ASSERT_FLOAT_EQ(125, YGNodeLayoutGetTop(root_child0));
+  ASSERT_FLOAT_EQ(150, YGNodeLayoutGetWidth(root_child0));
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0));
+
+  ASSERT_FLOAT_EQ(150, YGNodeLayoutGetLeft(root_child1));
+  ASSERT_FLOAT_EQ(38, YGNodeLayoutGetTop(root_child1));
+  ASSERT_FLOAT_EQ(120, YGNodeLayoutGetWidth(root_child1));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root_child1));
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child2));
+  ASSERT_FLOAT_EQ(213, YGNodeLayoutGetTop(root_child2));
+  ASSERT_FLOAT_EQ(120, YGNodeLayoutGetWidth(root_child2));
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child2));
+
+  YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
+  ASSERT_FLOAT_EQ(300, YGNodeLayoutGetWidth(root));
+  ASSERT_FLOAT_EQ(300, YGNodeLayoutGetHeight(root));
+
+  ASSERT_FLOAT_EQ(150, YGNodeLayoutGetLeft(root_child0));
+  ASSERT_FLOAT_EQ(125, YGNodeLayoutGetTop(root_child0));
+  ASSERT_FLOAT_EQ(150, YGNodeLayoutGetWidth(root_child0));
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0));
+
+  ASSERT_FLOAT_EQ(30, YGNodeLayoutGetLeft(root_child1));
+  ASSERT_FLOAT_EQ(38, YGNodeLayoutGetTop(root_child1));
+  ASSERT_FLOAT_EQ(120, YGNodeLayoutGetWidth(root_child1));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root_child1));
+
+  ASSERT_FLOAT_EQ(180, YGNodeLayoutGetLeft(root_child2));
+  ASSERT_FLOAT_EQ(213, YGNodeLayoutGetTop(root_child2));
+  ASSERT_FLOAT_EQ(120, YGNodeLayoutGetWidth(root_child2));
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child2));
+
+  YGNodeFreeRecursive(root);
+
+  YGConfigFree(config);
+}
+
+TEST(YogaTest, align_content_stretch_and_align_items_stretch_with_flex_wrap) {
+  YGConfigRef config = YGConfigNew();
+
+  YGNodeRef root = YGNodeNewWithConfig(config);
+  YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
+  YGNodeStyleSetAlignContent(root, YGAlignStretch);
+  YGNodeStyleSetPositionType(root, YGPositionTypeAbsolute);
+  YGNodeStyleSetFlexWrap(root, YGWrapWrap);
+  YGNodeStyleSetWidth(root, 300);
+  YGNodeStyleSetHeight(root, 300);
+
+  YGNodeRef root_child0 = YGNodeNewWithConfig(config);
+  YGNodeStyleSetAlignSelf(root_child0, YGAlignFlexEnd);
+  YGNodeStyleSetWidth(root_child0, 150);
+  YGNodeStyleSetHeight(root_child0, 50);
+  YGNodeInsertChild(root, root_child0, 0);
+
+  YGNodeRef root_child1 = YGNodeNewWithConfig(config);
+  YGNodeStyleSetWidth(root_child1, 120);
+  YGNodeStyleSetHeight(root_child1, 100);
+  YGNodeInsertChild(root, root_child1, 1);
+
+  YGNodeRef root_child2 = YGNodeNewWithConfig(config);
+  YGNodeStyleSetWidth(root_child2, 120);
+  YGNodeStyleSetHeight(root_child2, 50);
+  YGNodeInsertChild(root, root_child2, 2);
+  YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
+  ASSERT_FLOAT_EQ(300, YGNodeLayoutGetWidth(root));
+  ASSERT_FLOAT_EQ(300, YGNodeLayoutGetHeight(root));
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
+  ASSERT_FLOAT_EQ(125, YGNodeLayoutGetTop(root_child0));
+  ASSERT_FLOAT_EQ(150, YGNodeLayoutGetWidth(root_child0));
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0));
+
+  ASSERT_FLOAT_EQ(150, YGNodeLayoutGetLeft(root_child1));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child1));
+  ASSERT_FLOAT_EQ(120, YGNodeLayoutGetWidth(root_child1));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root_child1));
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child2));
+  ASSERT_FLOAT_EQ(175, YGNodeLayoutGetTop(root_child2));
+  ASSERT_FLOAT_EQ(120, YGNodeLayoutGetWidth(root_child2));
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child2));
+
+  YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
+  ASSERT_FLOAT_EQ(300, YGNodeLayoutGetWidth(root));
+  ASSERT_FLOAT_EQ(300, YGNodeLayoutGetHeight(root));
+
+  ASSERT_FLOAT_EQ(150, YGNodeLayoutGetLeft(root_child0));
+  ASSERT_FLOAT_EQ(125, YGNodeLayoutGetTop(root_child0));
+  ASSERT_FLOAT_EQ(150, YGNodeLayoutGetWidth(root_child0));
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child0));
+
+  ASSERT_FLOAT_EQ(30, YGNodeLayoutGetLeft(root_child1));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child1));
+  ASSERT_FLOAT_EQ(120, YGNodeLayoutGetWidth(root_child1));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root_child1));
+
+  ASSERT_FLOAT_EQ(180, YGNodeLayoutGetLeft(root_child2));
+  ASSERT_FLOAT_EQ(175, YGNodeLayoutGetTop(root_child2));
+  ASSERT_FLOAT_EQ(120, YGNodeLayoutGetWidth(root_child2));
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetHeight(root_child2));
+
+  YGNodeFreeRecursive(root);
+
+  YGConfigFree(config);
+}

tests/generated/YGDisplayContentsTest.cpp

@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * clang-format off
+ * @generated SignedSource<<a314a86c9d90aabdfd6ac470fe385f06>>
+ * generated by gentest/gentest-driver.ts from gentest/fixtures/YGDisplayContentsTest.html
+ */
+
+#include <gtest/gtest.h>
+#include <yoga/Yoga.h>
+#include "../util/TestUtil.h"
+
+TEST(YogaTest, test1) {
+  YGConfigRef config = YGConfigNew();
+
+  YGNodeRef root = YGNodeNewWithConfig(config);
+  YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
+  YGNodeStyleSetPositionType(root, YGPositionTypeAbsolute);
+  YGNodeStyleSetWidth(root, 100);
+  YGNodeStyleSetHeight(root, 100);
+
+  YGNodeRef root_child0 = YGNodeNewWithConfig(config);
+  YGNodeStyleSetDisplay(root_child0, YGDisplayContents);
+  YGNodeInsertChild(root, root_child0, 0);
+
+  YGNodeRef root_child0_child0 = YGNodeNewWithConfig(config);
+  YGNodeStyleSetFlexGrow(root_child0_child0, 1);
+  YGNodeStyleSetFlexShrink(root_child0_child0, 1);
+  YGNodeStyleSetFlexBasisPercent(root_child0_child0, 0);
+  YGNodeStyleSetHeight(root_child0_child0, 10);
+  YGNodeInsertChild(root_child0, root_child0_child0, 0);
+
+  YGNodeRef root_child0_child1 = YGNodeNewWithConfig(config);
+  YGNodeStyleSetFlexGrow(root_child0_child1, 1);
+  YGNodeStyleSetFlexShrink(root_child0_child1, 1);
+  YGNodeStyleSetFlexBasisPercent(root_child0_child1, 0);
+  YGNodeStyleSetHeight(root_child0_child1, 20);
+  YGNodeInsertChild(root_child0, root_child0_child1, 1);
+  YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root));
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetWidth(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetHeight(root_child0));
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child0));
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0_child0));
+  ASSERT_FLOAT_EQ(10, YGNodeLayoutGetHeight(root_child0_child0));
+
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetLeft(root_child0_child1));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child1));
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0_child1));
+  ASSERT_FLOAT_EQ(20, YGNodeLayoutGetHeight(root_child0_child1));
+
+  YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root));
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetWidth(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetHeight(root_child0));
+
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetLeft(root_child0_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child0));
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0_child0));
+  ASSERT_FLOAT_EQ(10, YGNodeLayoutGetHeight(root_child0_child0));
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0_child1));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child1));
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0_child1));
+  ASSERT_FLOAT_EQ(20, YGNodeLayoutGetHeight(root_child0_child1));
+
+  YGNodeFreeRecursive(root);
+
+  YGConfigFree(config);
+}

tests/generated/YGDisplayTest.cpp

@@ -5,7 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  *
  * clang-format off
- * @generated SignedSource<<69ab4deb447f7daa2a701ed648532b50>>
+ * @generated SignedSource<<d91c4f580be7ed7ca61c5a3b98d47333>>
  * generated by gentest/gentest-driver.ts from gentest/fixtures/YGDisplayTest.html
  */
 
@@ -379,3 +379,647 @@ TEST(YogaTest, display_none_with_position_absolute) {
 
   YGConfigFree(config);
 }
+
+TEST(YogaTest, display_contents) {
+  YGConfigRef config = YGConfigNew();
+
+  YGNodeRef root = YGNodeNewWithConfig(config);
+  YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
+  YGNodeStyleSetPositionType(root, YGPositionTypeAbsolute);
+  YGNodeStyleSetWidth(root, 100);
+  YGNodeStyleSetHeight(root, 100);
+
+  YGNodeRef root_child0 = YGNodeNewWithConfig(config);
+  YGNodeStyleSetDisplay(root_child0, YGDisplayContents);
+  YGNodeInsertChild(root, root_child0, 0);
+
+  YGNodeRef root_child0_child0 = YGNodeNewWithConfig(config);
+  YGNodeStyleSetFlexGrow(root_child0_child0, 1);
+  YGNodeStyleSetFlexShrink(root_child0_child0, 1);
+  YGNodeStyleSetFlexBasisPercent(root_child0_child0, 0);
+  YGNodeStyleSetHeight(root_child0_child0, 10);
+  YGNodeInsertChild(root_child0, root_child0_child0, 0);
+
+  YGNodeRef root_child0_child1 = YGNodeNewWithConfig(config);
+  YGNodeStyleSetFlexGrow(root_child0_child1, 1);
+  YGNodeStyleSetFlexShrink(root_child0_child1, 1);
+  YGNodeStyleSetFlexBasisPercent(root_child0_child1, 0);
+  YGNodeStyleSetHeight(root_child0_child1, 20);
+  YGNodeInsertChild(root_child0, root_child0_child1, 1);
+  YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root));
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetWidth(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetHeight(root_child0));
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child0));
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0_child0));
+  ASSERT_FLOAT_EQ(10, YGNodeLayoutGetHeight(root_child0_child0));
+
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetLeft(root_child0_child1));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child1));
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0_child1));
+  ASSERT_FLOAT_EQ(20, YGNodeLayoutGetHeight(root_child0_child1));
+
+  YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root));
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetWidth(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetHeight(root_child0));
+
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetLeft(root_child0_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child0));
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0_child0));
+  ASSERT_FLOAT_EQ(10, YGNodeLayoutGetHeight(root_child0_child0));
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0_child1));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child1));
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0_child1));
+  ASSERT_FLOAT_EQ(20, YGNodeLayoutGetHeight(root_child0_child1));
+
+  YGNodeFreeRecursive(root);
+
+  YGConfigFree(config);
+}
+
+TEST(YogaTest, display_contents_fixed_size) {
+  YGConfigRef config = YGConfigNew();
+
+  YGNodeRef root = YGNodeNewWithConfig(config);
+  YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
+  YGNodeStyleSetPositionType(root, YGPositionTypeAbsolute);
+  YGNodeStyleSetWidth(root, 100);
+  YGNodeStyleSetHeight(root, 100);
+
+  YGNodeRef root_child0 = YGNodeNewWithConfig(config);
+  YGNodeStyleSetWidth(root_child0, 50);
+  YGNodeStyleSetHeight(root_child0, 50);
+  YGNodeStyleSetDisplay(root_child0, YGDisplayContents);
+  YGNodeInsertChild(root, root_child0, 0);
+
+  YGNodeRef root_child0_child0 = YGNodeNewWithConfig(config);
+  YGNodeStyleSetFlexGrow(root_child0_child0, 1);
+  YGNodeStyleSetFlexShrink(root_child0_child0, 1);
+  YGNodeStyleSetFlexBasisPercent(root_child0_child0, 0);
+  YGNodeStyleSetHeight(root_child0_child0, 10);
+  YGNodeInsertChild(root_child0, root_child0_child0, 0);
+
+  YGNodeRef root_child0_child1 = YGNodeNewWithConfig(config);
+  YGNodeStyleSetFlexGrow(root_child0_child1, 1);
+  YGNodeStyleSetFlexShrink(root_child0_child1, 1);
+  YGNodeStyleSetFlexBasisPercent(root_child0_child1, 0);
+  YGNodeStyleSetHeight(root_child0_child1, 20);
+  YGNodeInsertChild(root_child0, root_child0_child1, 1);
+  YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root));
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetWidth(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetHeight(root_child0));
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child0));
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0_child0));
+  ASSERT_FLOAT_EQ(10, YGNodeLayoutGetHeight(root_child0_child0));
+
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetLeft(root_child0_child1));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child1));
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0_child1));
+  ASSERT_FLOAT_EQ(20, YGNodeLayoutGetHeight(root_child0_child1));
+
+  YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root));
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetWidth(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetHeight(root_child0));
+
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetLeft(root_child0_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child0));
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0_child0));
+  ASSERT_FLOAT_EQ(10, YGNodeLayoutGetHeight(root_child0_child0));
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0_child1));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child1));
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0_child1));
+  ASSERT_FLOAT_EQ(20, YGNodeLayoutGetHeight(root_child0_child1));
+
+  YGNodeFreeRecursive(root);
+
+  YGConfigFree(config);
+}
+
+TEST(YogaTest, display_contents_with_margin) {
+  YGConfigRef config = YGConfigNew();
+
+  YGNodeRef root = YGNodeNewWithConfig(config);
+  YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
+  YGNodeStyleSetPositionType(root, YGPositionTypeAbsolute);
+  YGNodeStyleSetWidth(root, 100);
+  YGNodeStyleSetHeight(root, 100);
+
+  YGNodeRef root_child0 = YGNodeNewWithConfig(config);
+  YGNodeStyleSetMargin(root_child0, YGEdgeLeft, 10);
+  YGNodeStyleSetMargin(root_child0, YGEdgeTop, 10);
+  YGNodeStyleSetMargin(root_child0, YGEdgeRight, 10);
+  YGNodeStyleSetMargin(root_child0, YGEdgeBottom, 10);
+  YGNodeStyleSetWidth(root_child0, 20);
+  YGNodeStyleSetHeight(root_child0, 20);
+  YGNodeStyleSetDisplay(root_child0, YGDisplayContents);
+  YGNodeInsertChild(root, root_child0, 0);
+
+  YGNodeRef root_child1 = YGNodeNewWithConfig(config);
+  YGNodeStyleSetFlexGrow(root_child1, 1);
+  YGNodeInsertChild(root, root_child1, 1);
+  YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root));
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetWidth(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetHeight(root_child0));
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child1));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child1));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root_child1));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root_child1));
+
+  YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root));
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetWidth(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetHeight(root_child0));
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child1));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child1));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root_child1));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root_child1));
+
+  YGNodeFreeRecursive(root);
+
+  YGConfigFree(config);
+}
+
+TEST(YogaTest, display_contents_with_padding) {
+  YGConfigRef config = YGConfigNew();
+
+  YGNodeRef root = YGNodeNewWithConfig(config);
+  YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
+  YGNodeStyleSetPositionType(root, YGPositionTypeAbsolute);
+  YGNodeStyleSetWidth(root, 100);
+  YGNodeStyleSetHeight(root, 100);
+
+  YGNodeRef root_child0 = YGNodeNewWithConfig(config);
+  YGNodeStyleSetPadding(root_child0, YGEdgeLeft, 10);
+  YGNodeStyleSetPadding(root_child0, YGEdgeTop, 10);
+  YGNodeStyleSetPadding(root_child0, YGEdgeRight, 10);
+  YGNodeStyleSetPadding(root_child0, YGEdgeBottom, 10);
+  YGNodeStyleSetDisplay(root_child0, YGDisplayContents);
+  YGNodeInsertChild(root, root_child0, 0);
+
+  YGNodeRef root_child0_child0 = YGNodeNewWithConfig(config);
+  YGNodeStyleSetFlexGrow(root_child0_child0, 1);
+  YGNodeStyleSetFlexShrink(root_child0_child0, 1);
+  YGNodeStyleSetFlexBasisPercent(root_child0_child0, 0);
+  YGNodeStyleSetHeight(root_child0_child0, 10);
+  YGNodeInsertChild(root_child0, root_child0_child0, 0);
+
+  YGNodeRef root_child0_child1 = YGNodeNewWithConfig(config);
+  YGNodeStyleSetFlexGrow(root_child0_child1, 1);
+  YGNodeStyleSetFlexShrink(root_child0_child1, 1);
+  YGNodeStyleSetFlexBasisPercent(root_child0_child1, 0);
+  YGNodeStyleSetHeight(root_child0_child1, 20);
+  YGNodeInsertChild(root_child0, root_child0_child1, 1);
+  YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root));
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetWidth(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetHeight(root_child0));
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child0));
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0_child0));
+  ASSERT_FLOAT_EQ(10, YGNodeLayoutGetHeight(root_child0_child0));
+
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetLeft(root_child0_child1));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child1));
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0_child1));
+  ASSERT_FLOAT_EQ(20, YGNodeLayoutGetHeight(root_child0_child1));
+
+  YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root));
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetWidth(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetHeight(root_child0));
+
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetLeft(root_child0_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child0));
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0_child0));
+  ASSERT_FLOAT_EQ(10, YGNodeLayoutGetHeight(root_child0_child0));
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0_child1));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child1));
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0_child1));
+  ASSERT_FLOAT_EQ(20, YGNodeLayoutGetHeight(root_child0_child1));
+
+  YGNodeFreeRecursive(root);
+
+  YGConfigFree(config);
+}
+
+TEST(YogaTest, display_contents_with_position) {
+  YGConfigRef config = YGConfigNew();
+
+  YGNodeRef root = YGNodeNewWithConfig(config);
+  YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
+  YGNodeStyleSetPositionType(root, YGPositionTypeAbsolute);
+  YGNodeStyleSetWidth(root, 100);
+  YGNodeStyleSetHeight(root, 100);
+
+  YGNodeRef root_child0 = YGNodeNewWithConfig(config);
+  YGNodeStyleSetPosition(root_child0, YGEdgeTop, 10);
+  YGNodeStyleSetDisplay(root_child0, YGDisplayContents);
+  YGNodeInsertChild(root, root_child0, 0);
+
+  YGNodeRef root_child0_child0 = YGNodeNewWithConfig(config);
+  YGNodeStyleSetFlexGrow(root_child0_child0, 1);
+  YGNodeStyleSetFlexShrink(root_child0_child0, 1);
+  YGNodeStyleSetFlexBasisPercent(root_child0_child0, 0);
+  YGNodeStyleSetHeight(root_child0_child0, 10);
+  YGNodeInsertChild(root_child0, root_child0_child0, 0);
+
+  YGNodeRef root_child0_child1 = YGNodeNewWithConfig(config);
+  YGNodeStyleSetFlexGrow(root_child0_child1, 1);
+  YGNodeStyleSetFlexShrink(root_child0_child1, 1);
+  YGNodeStyleSetFlexBasisPercent(root_child0_child1, 0);
+  YGNodeStyleSetHeight(root_child0_child1, 20);
+  YGNodeInsertChild(root_child0, root_child0_child1, 1);
+  YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root));
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetWidth(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetHeight(root_child0));
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child0));
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0_child0));
+  ASSERT_FLOAT_EQ(10, YGNodeLayoutGetHeight(root_child0_child0));
+
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetLeft(root_child0_child1));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child1));
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0_child1));
+  ASSERT_FLOAT_EQ(20, YGNodeLayoutGetHeight(root_child0_child1));
+
+  YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root));
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetWidth(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetHeight(root_child0));
+
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetLeft(root_child0_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child0));
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0_child0));
+  ASSERT_FLOAT_EQ(10, YGNodeLayoutGetHeight(root_child0_child0));
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0_child1));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child1));
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0_child1));
+  ASSERT_FLOAT_EQ(20, YGNodeLayoutGetHeight(root_child0_child1));
+
+  YGNodeFreeRecursive(root);
+
+  YGConfigFree(config);
+}
+
+TEST(YogaTest, display_contents_with_position_absolute) {
+  YGConfigRef config = YGConfigNew();
+
+  YGNodeRef root = YGNodeNewWithConfig(config);
+  YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
+  YGNodeStyleSetPositionType(root, YGPositionTypeAbsolute);
+  YGNodeStyleSetWidth(root, 100);
+  YGNodeStyleSetHeight(root, 100);
+
+  YGNodeRef root_child0 = YGNodeNewWithConfig(config);
+  YGNodeStyleSetPositionType(root_child0, YGPositionTypeAbsolute);
+  YGNodeStyleSetWidth(root_child0, 50);
+  YGNodeStyleSetHeight(root_child0, 50);
+  YGNodeStyleSetDisplay(root_child0, YGDisplayContents);
+  YGNodeInsertChild(root, root_child0, 0);
+
+  YGNodeRef root_child0_child0 = YGNodeNewWithConfig(config);
+  YGNodeStyleSetFlexGrow(root_child0_child0, 1);
+  YGNodeStyleSetFlexShrink(root_child0_child0, 1);
+  YGNodeStyleSetFlexBasisPercent(root_child0_child0, 0);
+  YGNodeStyleSetHeight(root_child0_child0, 10);
+  YGNodeInsertChild(root_child0, root_child0_child0, 0);
+
+  YGNodeRef root_child0_child1 = YGNodeNewWithConfig(config);
+  YGNodeStyleSetFlexGrow(root_child0_child1, 1);
+  YGNodeStyleSetFlexShrink(root_child0_child1, 1);
+  YGNodeStyleSetFlexBasisPercent(root_child0_child1, 0);
+  YGNodeStyleSetHeight(root_child0_child1, 20);
+  YGNodeInsertChild(root_child0, root_child0_child1, 1);
+  YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root));
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetWidth(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetHeight(root_child0));
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child0));
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0_child0));
+  ASSERT_FLOAT_EQ(10, YGNodeLayoutGetHeight(root_child0_child0));
+
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetLeft(root_child0_child1));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child1));
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0_child1));
+  ASSERT_FLOAT_EQ(20, YGNodeLayoutGetHeight(root_child0_child1));
+
+  YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root));
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetWidth(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetHeight(root_child0));
+
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetLeft(root_child0_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child0));
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0_child0));
+  ASSERT_FLOAT_EQ(10, YGNodeLayoutGetHeight(root_child0_child0));
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0_child1));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child1));
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0_child1));
+  ASSERT_FLOAT_EQ(20, YGNodeLayoutGetHeight(root_child0_child1));
+
+  YGNodeFreeRecursive(root);
+
+  YGConfigFree(config);
+}
+
+TEST(YogaTest, display_contents_nested) {
+  YGConfigRef config = YGConfigNew();
+
+  YGNodeRef root = YGNodeNewWithConfig(config);
+  YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
+  YGNodeStyleSetPositionType(root, YGPositionTypeAbsolute);
+  YGNodeStyleSetWidth(root, 100);
+  YGNodeStyleSetHeight(root, 100);
+
+  YGNodeRef root_child0 = YGNodeNewWithConfig(config);
+  YGNodeStyleSetDisplay(root_child0, YGDisplayContents);
+  YGNodeInsertChild(root, root_child0, 0);
+
+  YGNodeRef root_child0_child0 = YGNodeNewWithConfig(config);
+  YGNodeStyleSetDisplay(root_child0_child0, YGDisplayContents);
+  YGNodeInsertChild(root_child0, root_child0_child0, 0);
+
+  YGNodeRef root_child0_child0_child0 = YGNodeNewWithConfig(config);
+  YGNodeStyleSetFlexGrow(root_child0_child0_child0, 1);
+  YGNodeStyleSetFlexShrink(root_child0_child0_child0, 1);
+  YGNodeStyleSetFlexBasisPercent(root_child0_child0_child0, 0);
+  YGNodeStyleSetHeight(root_child0_child0_child0, 10);
+  YGNodeInsertChild(root_child0_child0, root_child0_child0_child0, 0);
+
+  YGNodeRef root_child0_child0_child1 = YGNodeNewWithConfig(config);
+  YGNodeStyleSetFlexGrow(root_child0_child0_child1, 1);
+  YGNodeStyleSetFlexShrink(root_child0_child0_child1, 1);
+  YGNodeStyleSetFlexBasisPercent(root_child0_child0_child1, 0);
+  YGNodeStyleSetHeight(root_child0_child0_child1, 20);
+  YGNodeInsertChild(root_child0_child0, root_child0_child0_child1, 1);
+  YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root));
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetWidth(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetHeight(root_child0));
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetWidth(root_child0_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetHeight(root_child0_child0));
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0_child0_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child0_child0));
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0_child0_child0));
+  ASSERT_FLOAT_EQ(10, YGNodeLayoutGetHeight(root_child0_child0_child0));
+
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetLeft(root_child0_child0_child1));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child0_child1));
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0_child0_child1));
+  ASSERT_FLOAT_EQ(20, YGNodeLayoutGetHeight(root_child0_child0_child1));
+
+  YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root));
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetWidth(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetHeight(root_child0));
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetWidth(root_child0_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetHeight(root_child0_child0));
+
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetLeft(root_child0_child0_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child0_child0));
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0_child0_child0));
+  ASSERT_FLOAT_EQ(10, YGNodeLayoutGetHeight(root_child0_child0_child0));
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0_child0_child1));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child0_child1));
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetWidth(root_child0_child0_child1));
+  ASSERT_FLOAT_EQ(20, YGNodeLayoutGetHeight(root_child0_child0_child1));
+
+  YGNodeFreeRecursive(root);
+
+  YGConfigFree(config);
+}
+
+TEST(YogaTest, display_contents_with_siblings) {
+  YGConfigRef config = YGConfigNew();
+
+  YGNodeRef root = YGNodeNewWithConfig(config);
+  YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
+  YGNodeStyleSetPositionType(root, YGPositionTypeAbsolute);
+  YGNodeStyleSetWidth(root, 100);
+  YGNodeStyleSetHeight(root, 100);
+
+  YGNodeRef root_child0 = YGNodeNewWithConfig(config);
+  YGNodeStyleSetFlexGrow(root_child0, 1);
+  YGNodeStyleSetFlexShrink(root_child0, 1);
+  YGNodeStyleSetFlexBasisPercent(root_child0, 0);
+  YGNodeStyleSetHeight(root_child0, 30);
+  YGNodeInsertChild(root, root_child0, 0);
+
+  YGNodeRef root_child1 = YGNodeNewWithConfig(config);
+  YGNodeStyleSetDisplay(root_child1, YGDisplayContents);
+  YGNodeInsertChild(root, root_child1, 1);
+
+  YGNodeRef root_child1_child0 = YGNodeNewWithConfig(config);
+  YGNodeStyleSetFlexGrow(root_child1_child0, 1);
+  YGNodeStyleSetFlexShrink(root_child1_child0, 1);
+  YGNodeStyleSetFlexBasisPercent(root_child1_child0, 0);
+  YGNodeStyleSetHeight(root_child1_child0, 10);
+  YGNodeInsertChild(root_child1, root_child1_child0, 0);
+
+  YGNodeRef root_child1_child1 = YGNodeNewWithConfig(config);
+  YGNodeStyleSetFlexGrow(root_child1_child1, 1);
+  YGNodeStyleSetFlexShrink(root_child1_child1, 1);
+  YGNodeStyleSetFlexBasisPercent(root_child1_child1, 0);
+  YGNodeStyleSetHeight(root_child1_child1, 20);
+  YGNodeInsertChild(root_child1, root_child1_child1, 1);
+
+  YGNodeRef root_child2 = YGNodeNewWithConfig(config);
+  YGNodeStyleSetFlexGrow(root_child2, 1);
+  YGNodeStyleSetFlexShrink(root_child2, 1);
+  YGNodeStyleSetFlexBasisPercent(root_child2, 0);
+  YGNodeStyleSetHeight(root_child2, 30);
+  YGNodeInsertChild(root, root_child2, 2);
+  YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root));
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
+  ASSERT_FLOAT_EQ(25, YGNodeLayoutGetWidth(root_child0));
+  ASSERT_FLOAT_EQ(30, YGNodeLayoutGetHeight(root_child0));
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child1));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child1));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetWidth(root_child1));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetHeight(root_child1));
+
+  ASSERT_FLOAT_EQ(25, YGNodeLayoutGetLeft(root_child1_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child1_child0));
+  ASSERT_FLOAT_EQ(25, YGNodeLayoutGetWidth(root_child1_child0));
+  ASSERT_FLOAT_EQ(10, YGNodeLayoutGetHeight(root_child1_child0));
+
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetLeft(root_child1_child1));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child1_child1));
+  ASSERT_FLOAT_EQ(25, YGNodeLayoutGetWidth(root_child1_child1));
+  ASSERT_FLOAT_EQ(20, YGNodeLayoutGetHeight(root_child1_child1));
+
+  ASSERT_FLOAT_EQ(75, YGNodeLayoutGetLeft(root_child2));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child2));
+  ASSERT_FLOAT_EQ(25, YGNodeLayoutGetWidth(root_child2));
+  ASSERT_FLOAT_EQ(30, YGNodeLayoutGetHeight(root_child2));
+
+  YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetWidth(root));
+  ASSERT_FLOAT_EQ(100, YGNodeLayoutGetHeight(root));
+
+  ASSERT_FLOAT_EQ(75, YGNodeLayoutGetLeft(root_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
+  ASSERT_FLOAT_EQ(25, YGNodeLayoutGetWidth(root_child0));
+  ASSERT_FLOAT_EQ(30, YGNodeLayoutGetHeight(root_child0));
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child1));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child1));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetWidth(root_child1));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetHeight(root_child1));
+
+  ASSERT_FLOAT_EQ(50, YGNodeLayoutGetLeft(root_child1_child0));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child1_child0));
+  ASSERT_FLOAT_EQ(25, YGNodeLayoutGetWidth(root_child1_child0));
+  ASSERT_FLOAT_EQ(10, YGNodeLayoutGetHeight(root_child1_child0));
+
+  ASSERT_FLOAT_EQ(25, YGNodeLayoutGetLeft(root_child1_child1));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child1_child1));
+  ASSERT_FLOAT_EQ(25, YGNodeLayoutGetWidth(root_child1_child1));
+  ASSERT_FLOAT_EQ(20, YGNodeLayoutGetHeight(root_child1_child1));
+
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child2));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child2));
+  ASSERT_FLOAT_EQ(25, YGNodeLayoutGetWidth(root_child2));
+  ASSERT_FLOAT_EQ(30, YGNodeLayoutGetHeight(root_child2));
+
+  YGNodeFreeRecursive(root);
+
+  YGConfigFree(config);
+}

tests/generated/YGJustifyContentTest.cpp

@@ -5,7 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  *
  * clang-format off
- * @generated SignedSource<<acb28ab0d3486089ff07a8763f92e22f>>
+ * @generated SignedSource<<07092062f14f233462a4678c392df76a>>
  * generated by gentest/gentest-driver.ts from gentest/fixtures/YGJustifyContentTest.html
  */
 
@@ -1803,6 +1803,8 @@ TEST(YogaTest, justify_content_overflow_row_space_evenly) {
 }
 
 TEST(YogaTest, justify_content_overflow_row_reverse_space_around) {
+  GTEST_SKIP();
+
   YGConfigRef config = YGConfigNew();
 
   YGNodeRef root = YGNodeNewWithConfig(config);
@@ -1830,17 +1832,17 @@ TEST(YogaTest, justify_content_overflow_row_reverse_space_around) {
   ASSERT_FLOAT_EQ(102, YGNodeLayoutGetWidth(root));
   ASSERT_FLOAT_EQ(102, YGNodeLayoutGetHeight(root));
 
-  ASSERT_FLOAT_EQ(62, YGNodeLayoutGetLeft(root_child0));
+  ASSERT_FLOAT_EQ(80, YGNodeLayoutGetLeft(root_child0));
   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
   ASSERT_FLOAT_EQ(40, YGNodeLayoutGetWidth(root_child0));
   ASSERT_FLOAT_EQ(102, YGNodeLayoutGetHeight(root_child0));
 
-  ASSERT_FLOAT_EQ(22, YGNodeLayoutGetLeft(root_child1));
+  ASSERT_FLOAT_EQ(40, YGNodeLayoutGetLeft(root_child1));
   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child1));
   ASSERT_FLOAT_EQ(40, YGNodeLayoutGetWidth(root_child1));
   ASSERT_FLOAT_EQ(102, YGNodeLayoutGetHeight(root_child1));
 
-  ASSERT_FLOAT_EQ(-18, YGNodeLayoutGetLeft(root_child2));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child2));
   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child2));
   ASSERT_FLOAT_EQ(40, YGNodeLayoutGetWidth(root_child2));
   ASSERT_FLOAT_EQ(102, YGNodeLayoutGetHeight(root_child2));
@@ -1852,17 +1854,17 @@ TEST(YogaTest, justify_content_overflow_row_reverse_space_around) {
   ASSERT_FLOAT_EQ(102, YGNodeLayoutGetWidth(root));
   ASSERT_FLOAT_EQ(102, YGNodeLayoutGetHeight(root));
 
-  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
+  ASSERT_FLOAT_EQ(-18, YGNodeLayoutGetLeft(root_child0));
   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
   ASSERT_FLOAT_EQ(40, YGNodeLayoutGetWidth(root_child0));
   ASSERT_FLOAT_EQ(102, YGNodeLayoutGetHeight(root_child0));
 
-  ASSERT_FLOAT_EQ(40, YGNodeLayoutGetLeft(root_child1));
+  ASSERT_FLOAT_EQ(22, YGNodeLayoutGetLeft(root_child1));
   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child1));
   ASSERT_FLOAT_EQ(40, YGNodeLayoutGetWidth(root_child1));
   ASSERT_FLOAT_EQ(102, YGNodeLayoutGetHeight(root_child1));
 
-  ASSERT_FLOAT_EQ(80, YGNodeLayoutGetLeft(root_child2));
+  ASSERT_FLOAT_EQ(62, YGNodeLayoutGetLeft(root_child2));
   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child2));
   ASSERT_FLOAT_EQ(40, YGNodeLayoutGetWidth(root_child2));
   ASSERT_FLOAT_EQ(102, YGNodeLayoutGetHeight(root_child2));
@@ -1873,6 +1875,8 @@ TEST(YogaTest, justify_content_overflow_row_reverse_space_around) {
 }
 
 TEST(YogaTest, justify_content_overflow_row_reverse_space_evenly) {
+  GTEST_SKIP();
+
   YGConfigRef config = YGConfigNew();
 
   YGNodeRef root = YGNodeNewWithConfig(config);
@@ -1900,17 +1904,17 @@ TEST(YogaTest, justify_content_overflow_row_reverse_space_evenly) {
   ASSERT_FLOAT_EQ(102, YGNodeLayoutGetWidth(root));
   ASSERT_FLOAT_EQ(102, YGNodeLayoutGetHeight(root));
 
-  ASSERT_FLOAT_EQ(62, YGNodeLayoutGetLeft(root_child0));
+  ASSERT_FLOAT_EQ(80, YGNodeLayoutGetLeft(root_child0));
   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
   ASSERT_FLOAT_EQ(40, YGNodeLayoutGetWidth(root_child0));
   ASSERT_FLOAT_EQ(102, YGNodeLayoutGetHeight(root_child0));
 
-  ASSERT_FLOAT_EQ(22, YGNodeLayoutGetLeft(root_child1));
+  ASSERT_FLOAT_EQ(40, YGNodeLayoutGetLeft(root_child1));
   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child1));
   ASSERT_FLOAT_EQ(40, YGNodeLayoutGetWidth(root_child1));
   ASSERT_FLOAT_EQ(102, YGNodeLayoutGetHeight(root_child1));
 
-  ASSERT_FLOAT_EQ(-18, YGNodeLayoutGetLeft(root_child2));
+  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child2));
   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child2));
   ASSERT_FLOAT_EQ(40, YGNodeLayoutGetWidth(root_child2));
   ASSERT_FLOAT_EQ(102, YGNodeLayoutGetHeight(root_child2));
@@ -1922,17 +1926,17 @@ TEST(YogaTest, justify_content_overflow_row_reverse_space_evenly) {
   ASSERT_FLOAT_EQ(102, YGNodeLayoutGetWidth(root));
   ASSERT_FLOAT_EQ(102, YGNodeLayoutGetHeight(root));
 
-  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
+  ASSERT_FLOAT_EQ(-18, YGNodeLayoutGetLeft(root_child0));
   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
   ASSERT_FLOAT_EQ(40, YGNodeLayoutGetWidth(root_child0));
   ASSERT_FLOAT_EQ(102, YGNodeLayoutGetHeight(root_child0));
 
-  ASSERT_FLOAT_EQ(40, YGNodeLayoutGetLeft(root_child1));
+  ASSERT_FLOAT_EQ(22, YGNodeLayoutGetLeft(root_child1));
   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child1));
   ASSERT_FLOAT_EQ(40, YGNodeLayoutGetWidth(root_child1));
   ASSERT_FLOAT_EQ(102, YGNodeLayoutGetHeight(root_child1));
 
-  ASSERT_FLOAT_EQ(80, YGNodeLayoutGetLeft(root_child2));
+  ASSERT_FLOAT_EQ(62, YGNodeLayoutGetLeft(root_child2));
   ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child2));
   ASSERT_FLOAT_EQ(40, YGNodeLayoutGetWidth(root_child2));
   ASSERT_FLOAT_EQ(102, YGNodeLayoutGetHeight(root_child2));

website/package.json

@@ -17,8 +17,8 @@
     "lint:fix": "eslint . --fix"
   },
   "dependencies": {
-    "@docusaurus/core": "3.4.0",
-    "@docusaurus/preset-classic": "3.4.0",
+    "@docusaurus/core": "3.6.0",
+    "@docusaurus/preset-classic": "3.6.0",
     "@mdx-js/react": "^3.0.0",
     "clsx": "^2.0.0",
     "lz-string": "^1.5.0",
@@ -27,12 +27,12 @@
     "react": "^18.3.0",
     "react-dom": "^18.3.0",
     "react-live": "^4.1.5",
-    "yoga-layout": "0.0.0"
+    "yoga-layout": "3.2.1"
   },
   "devDependencies": {
-    "@docusaurus/module-type-aliases": "3.4.0",
-    "@docusaurus/tsconfig": "3.4.0",
-    "@docusaurus/types": "3.4.0",
+    "@docusaurus/module-type-aliases": "3.6.0",
+    "@docusaurus/tsconfig": "3.6.0",
+    "@docusaurus/types": "3.6.0",
     "eslint-plugin-react": "^7.33.2",
     "eslint-plugin-react-hooks": "^4.6.0"
   },

yoga/YGEnums.cpp

@@ -71,6 +71,8 @@ const char* YGDisplayToString(const YGDisplay value) {
       return "flex";
     case YGDisplayNone:
       return "none";
+    case YGDisplayContents:
+      return "contents";
   }
   return "unknown";
 }
@@ -105,8 +107,8 @@ const char* YGErrataToString(const YGErrata value) {
       return "none";
     case YGErrataStretchFlexBasis:
       return "stretch-flex-basis";
-    case YGErrataAbsolutePositioningIncorrect:
-      return "absolute-positioning-incorrect";
+    case YGErrataAbsolutePositionWithoutInsetsExcludesPadding:
+      return "absolute-position-without-insets-excludes-padding";
     case YGErrataAbsolutePercentAgainstInnerSize:
       return "absolute-percent-against-inner-size";
     case YGErrataAll:

yoga/YGEnums.h

@@ -43,7 +43,8 @@ YG_ENUM_DECL(
 YG_ENUM_DECL(
     YGDisplay,
     YGDisplayFlex,
-    YGDisplayNone)
+    YGDisplayNone,
+    YGDisplayContents)
 
 YG_ENUM_DECL(
     YGEdge,
@@ -61,7 +62,7 @@ YG_ENUM_DECL(
     YGErrata,
     YGErrataNone = 0,
     YGErrataStretchFlexBasis = 1,
-    YGErrataAbsolutePositioningIncorrect = 2,
+    YGErrataAbsolutePositionWithoutInsetsExcludesPadding = 2,
     YGErrataAbsolutePercentAgainstInnerSize = 4,
     YGErrataAll = 2147483647,
     YGErrataClassic = 2147483646)

yoga/algorithm/AbsoluteLayout.cpp

@@ -19,12 +19,15 @@ static inline void setFlexStartLayoutPosition(
     const Direction direction,
     const FlexDirection axis,
     const float containingBlockWidth) {
-  child->setLayoutPosition(
-      child->style().computeFlexStartMargin(
-          axis, direction, containingBlockWidth) +
-          parent->getLayout().border(flexStartEdge(axis)) +
-          parent->getLayout().padding(flexStartEdge(axis)),
-      flexStartEdge(axis));
+  float position = child->style().computeFlexStartMargin(
+                       axis, direction, containingBlockWidth) +
+      parent->getLayout().border(flexStartEdge(axis));
+
+  if (!child->hasErrata(Errata::AbsolutePositionWithoutInsetsExcludesPadding)) {
+    position += parent->getLayout().padding(flexStartEdge(axis));
+  }
+
+  child->setLayoutPosition(position, flexStartEdge(axis));
 }
 
 static inline void setFlexEndLayoutPosition(
@@ -33,15 +36,16 @@ static inline void setFlexEndLayoutPosition(
     const Direction direction,
     const FlexDirection axis,
     const float containingBlockWidth) {
+  float flexEndPosition = parent->getLayout().border(flexEndEdge(axis)) +
+      child->style().computeFlexEndMargin(
+          axis, direction, containingBlockWidth);
+
+  if (!child->hasErrata(Errata::AbsolutePositionWithoutInsetsExcludesPadding)) {
+    flexEndPosition += parent->getLayout().padding(flexEndEdge(axis));
+  }
+
   child->setLayoutPosition(
-      getPositionOfOppositeEdge(
-          parent->getLayout().border(flexEndEdge(axis)) +
-              parent->getLayout().padding(flexEndEdge(axis)) +
-              child->style().computeFlexEndMargin(
-                  axis, direction, containingBlockWidth),
-          axis,
-          parent,
-          child),
+      getPositionOfOppositeEdge(flexEndPosition, axis, parent, child),
       flexStartEdge(axis));
 }
 
@@ -51,22 +55,30 @@ static inline void setCenterLayoutPosition(
     const Direction direction,
     const FlexDirection axis,
     const float containingBlockWidth) {
-  const float parentContentBoxSize =
+  float parentContentBoxSize =
       parent->getLayout().measuredDimension(dimension(axis)) -
       parent->getLayout().border(flexStartEdge(axis)) -
-      parent->getLayout().border(flexEndEdge(axis)) -
-      parent->getLayout().padding(flexStartEdge(axis)) -
-      parent->getLayout().padding(flexEndEdge(axis));
+      parent->getLayout().border(flexEndEdge(axis));
+
+  if (!child->hasErrata(Errata::AbsolutePositionWithoutInsetsExcludesPadding)) {
+    parentContentBoxSize -= parent->getLayout().padding(flexStartEdge(axis));
+    parentContentBoxSize -= parent->getLayout().padding(flexEndEdge(axis));
+  }
+
   const float childOuterSize =
       child->getLayout().measuredDimension(dimension(axis)) +
       child->style().computeMarginForAxis(axis, containingBlockWidth);
-  child->setLayoutPosition(
-      (parentContentBoxSize - childOuterSize) / 2.0f +
-          parent->getLayout().border(flexStartEdge(axis)) +
-          parent->getLayout().padding(flexStartEdge(axis)) +
-          child->style().computeFlexStartMargin(
-              axis, direction, containingBlockWidth),
-      flexStartEdge(axis));
+
+  float position = (parentContentBoxSize - childOuterSize) / 2.0f +
+      parent->getLayout().border(flexStartEdge(axis)) +
+      child->style().computeFlexStartMargin(
+          axis, direction, containingBlockWidth);
+
+  if (!child->hasErrata(Errata::AbsolutePositionWithoutInsetsExcludesPadding)) {
+    position += parent->getLayout().padding(flexStartEdge(axis));
+  }
+
+  child->setLayoutPosition(position, flexStartEdge(axis));
 }
 
 static void justifyAbsoluteChild(
@@ -133,62 +145,6 @@ static void alignAbsoluteChild(
   }
 }
 
-// To ensure no breaking changes, we preserve the legacy way of positioning
-// absolute children and determine if we should use it using an errata.
-static void positionAbsoluteChildLegacy(
-    const yoga::Node* const containingNode,
-    const yoga::Node* const parent,
-    yoga::Node* child,
-    const Direction direction,
-    const FlexDirection axis,
-    const bool isMainAxis,
-    const float containingBlockWidth,
-    const float containingBlockHeight) {
-  const bool isAxisRow = isRow(axis);
-  const bool shouldCenter = isMainAxis
-      ? parent->style().justifyContent() == Justify::Center
-      : resolveChildAlignment(parent, child) == Align::Center;
-  const bool shouldFlexEnd = isMainAxis
-      ? parent->style().justifyContent() == Justify::FlexEnd
-      : ((resolveChildAlignment(parent, child) == Align::FlexEnd) ^
-         (parent->style().flexWrap() == Wrap::WrapReverse));
-
-  if (child->style().isFlexEndPositionDefined(axis, direction) &&
-      (!child->style().isFlexStartPositionDefined(axis, direction) ||
-       child->style().isFlexStartPositionAuto(axis, direction))) {
-    child->setLayoutPosition(
-        containingNode->getLayout().measuredDimension(dimension(axis)) -
-            child->getLayout().measuredDimension(dimension(axis)) -
-            containingNode->style().computeFlexEndBorder(axis, direction) -
-            child->style().computeFlexEndMargin(
-                axis,
-                direction,
-                isAxisRow ? containingBlockWidth : containingBlockHeight) -
-            child->style().computeFlexEndPosition(
-                axis,
-                direction,
-                isAxisRow ? containingBlockWidth : containingBlockHeight),
-        flexStartEdge(axis));
-  } else if (
-      (!child->style().isFlexStartPositionDefined(axis, direction) ||
-       child->style().isFlexStartPositionAuto(axis, direction)) &&
-      shouldCenter) {
-    child->setLayoutPosition(
-        (parent->getLayout().measuredDimension(dimension(axis)) -
-         child->getLayout().measuredDimension(dimension(axis))) /
-            2.0f,
-        flexStartEdge(axis));
-  } else if (
-      (!child->style().isFlexStartPositionDefined(axis, direction) ||
-       child->style().isFlexStartPositionAuto(axis, direction)) &&
-      shouldFlexEnd) {
-    child->setLayoutPosition(
-        (parent->getLayout().measuredDimension(dimension(axis)) -
-         child->getLayout().measuredDimension(dimension(axis))),
-        flexStartEdge(axis));
-  }
-}
-
 /*
  * Absolutely positioned nodes do not participate in flex layout and thus their
  * positions can be determined independently from the rest of their siblings.
@@ -205,7 +161,7 @@ static void positionAbsoluteChildLegacy(
  * This function does that positioning for the given axis. The spec has more
  * information on this topic: https://www.w3.org/TR/css-flexbox-1/#abspos-items
  */
-static void positionAbsoluteChildImpl(
+static void positionAbsoluteChild(
     const yoga::Node* const containingNode,
     const yoga::Node* const parent,
     yoga::Node* child,
@@ -267,36 +223,6 @@ static void positionAbsoluteChildImpl(
   }
 }
 
-static void positionAbsoluteChild(
-    const yoga::Node* const containingNode,
-    const yoga::Node* const parent,
-    yoga::Node* child,
-    const Direction direction,
-    const FlexDirection axis,
-    const bool isMainAxis,
-    const float containingBlockWidth,
-    const float containingBlockHeight) {
-  child->hasErrata(Errata::AbsolutePositioningIncorrect)
-      ? positionAbsoluteChildLegacy(
-            containingNode,
-            parent,
-            child,
-            direction,
-            axis,
-            isMainAxis,
-            containingBlockWidth,
-            containingBlockHeight)
-      : positionAbsoluteChildImpl(
-            containingNode,
-            parent,
-            child,
-            direction,
-            axis,
-            isMainAxis,
-            containingBlockWidth,
-            containingBlockHeight);
-}
-
 void layoutAbsoluteChild(
     const yoga::Node* const containingNode,
     const yoga::Node* const node,
@@ -508,7 +434,7 @@ bool layoutAbsoluteDescendants(
     float containingNodeAvailableInnerWidth,
     float containingNodeAvailableInnerHeight) {
   bool hasNewLayout = false;
-  for (auto child : currentNode->getChildren()) {
+  for (auto child : currentNode->getLayoutChildren()) {
     if (child->style().display() == Display::None) {
       continue;
     } else if (child->style().positionType() == PositionType::Absolute) {

yoga/algorithm/Align.h

@@ -37,8 +37,8 @@ constexpr Align fallbackAlignment(Align align) {
     case Align::Stretch:
       return Align::FlexStart;
 
-    // Fallback to safe center. TODO: This should be aligned to Start
-    // instead of FlexStart (for row-reverse containers)
+    // Fallback to safe center. TODO (T208209388): This should be aligned to
+    // Start instead of FlexStart (for row-reverse containers)
     case Align::SpaceAround:
     case Align::SpaceEvenly:
       return Align::FlexStart;
@@ -59,8 +59,8 @@ constexpr Justify fallbackAlignment(Justify align) {
       // case Justify::Stretch:
       return Justify::FlexStart;
 
-    // Fallback to safe center. TODO: This should be aligned to Start
-    // instead of FlexStart (for row-reverse containers)
+    // Fallback to safe center. TODO (T208209388): This should be aligned to
+    // Start instead of FlexStart (for row-reverse containers)
     case Justify::SpaceAround:
     case Justify::SpaceEvenly:
       return Justify::FlexStart;

yoga/algorithm/Baseline.cpp

@@ -32,9 +32,7 @@ float calculateBaseline(const yoga::Node* node) {
   }
 
   yoga::Node* baselineChild = nullptr;
-  const size_t childCount = node->getChildCount();
-  for (size_t i = 0; i < childCount; i++) {
-    auto child = node->getChild(i);
+  for (auto child : node->getLayoutChildren()) {
     if (child->getLineIndex() > 0) {
       break;
     }
@@ -67,9 +65,7 @@ bool isBaselineLayout(const yoga::Node* node) {
   if (node->style().alignItems() == Align::Baseline) {
     return true;
   }
-  const auto childCount = node->getChildCount();
-  for (size_t i = 0; i < childCount; i++) {
-    auto child = node->getChild(i);
+  for (auto child : node->getLayoutChildren()) {
     if (child->style().positionType() != PositionType::Absolute &&
         child->style().alignSelf() == Align::Baseline) {
       return true;

yoga/algorithm/CalculateLayout.cpp

@@ -10,7 +10,6 @@
 #include <cfloat>
 #include <cmath>
 #include <cstring>
-#include <string>
 
 #include <yoga/Yoga.h>
 
@@ -476,6 +475,21 @@ static void zeroOutLayoutRecursively(yoga::Node* const node) {
   }
 }
 
+static void cleanupContentsNodesRecursively(yoga::Node* const node) {
+  for (auto child : node->getChildren()) {
+    if (child->style().display() == Display::Contents) {
+      child->getLayout() = {};
+      child->setLayoutDimension(0, Dimension::Width);
+      child->setLayoutDimension(0, Dimension::Height);
+      child->setHasNewLayout(true);
+      child->setDirty(false);
+      child->cloneChildrenIfNeeded();
+
+      cleanupContentsNodesRecursively(child);
+    }
+  }
+}
+
 static float calculateAvailableInnerDimension(
     const yoga::Node* const node,
     const Direction direction,
@@ -525,7 +539,7 @@ static float computeFlexBasisForChildren(
     const uint32_t generationCount) {
   float totalOuterFlexBasis = 0.0f;
   YGNodeRef singleFlexChild = nullptr;
-  const auto& children = node->getChildren();
+  auto children = node->getLayoutChildren();
   SizingMode sizingModeMainDim =
       isRow(mainAxis) ? widthSizingMode : heightSizingMode;
   // If there is only one child with flexGrow + flexShrink it means we can set
@@ -678,13 +692,6 @@ static float distributeFreeSpaceSecondPass(
       }
     }
 
-    yoga::assertFatalWithNode(
-        currentLineChild,
-        yoga::isDefined(updatedMainSize),
-        ("updatedMainSize is undefined. mainAxisOwnerSize: " +
-         std::to_string(mainAxisOwnerSize))
-            .c_str());
-
     deltaFreeSpace += updatedMainSize - childFlexBasis;
 
     const float marginMain = currentLineChild->style().computeMarginForAxis(
@@ -778,20 +785,6 @@ static float distributeFreeSpaceSecondPass(
     const bool isLayoutPass = performLayout && !requiresStretchLayout;
     // Recursively call the layout algorithm for this child with the updated
     // main size.
-
-    yoga::assertFatalWithNode(
-        currentLineChild,
-        yoga::isUndefined(childMainSize)
-            ? childMainSizingMode == SizingMode::MaxContent
-            : true,
-        "childMainSize is undefined so childMainSizingMode must be MaxContent");
-    yoga::assertFatalWithNode(
-        currentLineChild,
-        yoga::isUndefined(childCrossSize)
-            ? childCrossSizingMode == SizingMode::MaxContent
-            : true,
-        "childCrossSize is undefined so childCrossSizingMode must be MaxContent");
-
     calculateLayoutInternal(
         currentLineChild,
         childWidth,
@@ -981,7 +974,6 @@ static void resolveFlexibleLength(
 static void justifyMainAxis(
     yoga::Node* const node,
     FlexLine& flexLine,
-    const size_t startOfLineIndex,
     const FlexDirection mainAxis,
     const FlexDirection crossAxis,
     const Direction direction,
@@ -1081,102 +1073,69 @@ static void justifyMainAxis(
   float maxAscentForCurrentLine = 0;
   float maxDescentForCurrentLine = 0;
   bool isNodeBaselineLayout = isBaselineLayout(node);
-  for (size_t i = startOfLineIndex; i < flexLine.endOfLineIndex; i++) {
-    const auto child = node->getChild(i);
-    const Style& childStyle = child->style();
+  for (auto child : flexLine.itemsInFlow) {
     const LayoutResults& childLayout = child->getLayout();
-    if (childStyle.display() == Display::None) {
-      continue;
+    if (child->style().flexStartMarginIsAuto(mainAxis, direction) &&
+        flexLine.layout.remainingFreeSpace > 0.0f) {
+      flexLine.layout.mainDim += flexLine.layout.remainingFreeSpace /
+          static_cast<float>(flexLine.numberOfAutoMargins);
     }
-    if (childStyle.positionType() == PositionType::Absolute &&
-        child->style().isFlexStartPositionDefined(mainAxis, direction) &&
-        !child->style().isFlexStartPositionAuto(mainAxis, direction)) {
-      if (performLayout) {
-        // In case the child is position absolute and has left/top being
-        // defined, we override the position to whatever the user said (and
-        // margin/border).
-        child->setLayoutPosition(
-            child->style().computeFlexStartPosition(
-                mainAxis, direction, availableInnerMainDim) +
-                node->style().computeFlexStartBorder(mainAxis, direction) +
-                child->style().computeFlexStartMargin(
-                    mainAxis, direction, availableInnerWidth),
-            flexStartEdge(mainAxis));
-      }
+
+    if (performLayout) {
+      child->setLayoutPosition(
+          childLayout.position(flexStartEdge(mainAxis)) +
+              flexLine.layout.mainDim,
+          flexStartEdge(mainAxis));
+    }
+
+    if (child != flexLine.itemsInFlow.back()) {
+      flexLine.layout.mainDim += betweenMainDim;
+    }
+
+    if (child->style().flexEndMarginIsAuto(mainAxis, direction) &&
+        flexLine.layout.remainingFreeSpace > 0.0f) {
+      flexLine.layout.mainDim += flexLine.layout.remainingFreeSpace /
+          static_cast<float>(flexLine.numberOfAutoMargins);
+    }
+    bool canSkipFlex =
+        !performLayout && sizingModeCrossDim == SizingMode::StretchFit;
+    if (canSkipFlex) {
+      // If we skipped the flex step, then we can't rely on the measuredDims
+      // because they weren't computed. This means we can't call
+      // dimensionWithMargin.
+      flexLine.layout.mainDim +=
+          child->style().computeMarginForAxis(mainAxis, availableInnerWidth) +
+          childLayout.computedFlexBasis.unwrap();
+      flexLine.layout.crossDim = availableInnerCrossDim;
     } else {
-      // Now that we placed the element, we need to update the variables.
-      // We need to do that only for relative elements. Absolute elements do not
-      // take part in that phase.
-      if (childStyle.positionType() != PositionType::Absolute) {
-        if (child->style().flexStartMarginIsAuto(mainAxis, direction) &&
-            flexLine.layout.remainingFreeSpace > 0.0f) {
-          flexLine.layout.mainDim += flexLine.layout.remainingFreeSpace /
-              static_cast<float>(flexLine.numberOfAutoMargins);
-        }
+      // The main dimension is the sum of all the elements dimension plus
+      // the spacing.
+      flexLine.layout.mainDim +=
+          child->dimensionWithMargin(mainAxis, availableInnerWidth);
 
-        if (performLayout) {
-          child->setLayoutPosition(
-              childLayout.position(flexStartEdge(mainAxis)) +
-                  flexLine.layout.mainDim,
-              flexStartEdge(mainAxis));
-        }
+      if (isNodeBaselineLayout) {
+        // If the child is baseline aligned then the cross dimension is
+        // calculated by adding maxAscent and maxDescent from the baseline.
+        const float ascent = calculateBaseline(child) +
+            child->style().computeFlexStartMargin(
+                FlexDirection::Column, direction, availableInnerWidth);
+        const float descent =
+            child->getLayout().measuredDimension(Dimension::Height) +
+            child->style().computeMarginForAxis(
+                FlexDirection::Column, availableInnerWidth) -
+            ascent;
 
-        if (child != flexLine.itemsInFlow.back()) {
-          flexLine.layout.mainDim += betweenMainDim;
-        }
-
-        if (child->style().flexEndMarginIsAuto(mainAxis, direction) &&
-            flexLine.layout.remainingFreeSpace > 0.0f) {
-          flexLine.layout.mainDim += flexLine.layout.remainingFreeSpace /
-              static_cast<float>(flexLine.numberOfAutoMargins);
-        }
-        bool canSkipFlex =
-            !performLayout && sizingModeCrossDim == SizingMode::StretchFit;
-        if (canSkipFlex) {
-          // If we skipped the flex step, then we can't rely on the measuredDims
-          // because they weren't computed. This means we can't call
-          // dimensionWithMargin.
-          flexLine.layout.mainDim += child->style().computeMarginForAxis(
-                                         mainAxis, availableInnerWidth) +
-              childLayout.computedFlexBasis.unwrap();
-          flexLine.layout.crossDim = availableInnerCrossDim;
-        } else {
-          // The main dimension is the sum of all the elements dimension plus
-          // the spacing.
-          flexLine.layout.mainDim +=
-              child->dimensionWithMargin(mainAxis, availableInnerWidth);
-
-          if (isNodeBaselineLayout) {
-            // If the child is baseline aligned then the cross dimension is
-            // calculated by adding maxAscent and maxDescent from the baseline.
-            const float ascent = calculateBaseline(child) +
-                child->style().computeFlexStartMargin(
-                    FlexDirection::Column, direction, availableInnerWidth);
-            const float descent =
-                child->getLayout().measuredDimension(Dimension::Height) +
-                child->style().computeMarginForAxis(
-                    FlexDirection::Column, availableInnerWidth) -
-                ascent;
-
-            maxAscentForCurrentLine =
-                yoga::maxOrDefined(maxAscentForCurrentLine, ascent);
-            maxDescentForCurrentLine =
-                yoga::maxOrDefined(maxDescentForCurrentLine, descent);
-          } else {
-            // The cross dimension is the max of the elements dimension since
-            // there can only be one element in that cross dimension in the case
-            // when the items are not baseline aligned
-            flexLine.layout.crossDim = yoga::maxOrDefined(
-                flexLine.layout.crossDim,
-                child->dimensionWithMargin(crossAxis, availableInnerWidth));
-          }
-        }
-      } else if (performLayout) {
-        child->setLayoutPosition(
-            childLayout.position(flexStartEdge(mainAxis)) +
-                node->style().computeFlexStartBorder(mainAxis, direction) +
-                leadingMainDim,
-            flexStartEdge(mainAxis));
+        maxAscentForCurrentLine =
+            yoga::maxOrDefined(maxAscentForCurrentLine, ascent);
+        maxDescentForCurrentLine =
+            yoga::maxOrDefined(maxDescentForCurrentLine, descent);
+      } else {
+        // The cross dimension is the max of the elements dimension since
+        // there can only be one element in that cross dimension in the case
+        // when the items are not baseline aligned
+        flexLine.layout.crossDim = yoga::maxOrDefined(
+            flexLine.layout.crossDim,
+            child->dimensionWithMargin(crossAxis, availableInnerWidth));
       }
     }
   }
@@ -1347,10 +1306,14 @@ static void calculateLayoutImpl(
         ownerHeight,
         layoutMarkerData,
         reason);
+
+    // Clean and update all display: contents nodes with a direct path to the
+    // current node as they will not be traversed
+    cleanupContentsNodesRecursively(node);
     return;
   }
 
-  const auto childCount = node->getChildCount();
+  const auto childCount = node->getLayoutChildCount();
   if (childCount == 0) {
     measureNodeWithoutChildren(
         node,
@@ -1361,6 +1324,10 @@ static void calculateLayoutImpl(
         heightSizingMode,
         ownerWidth,
         ownerHeight);
+
+    // Clean and update all display: contents nodes with a direct path to the
+    // current node as they will not be traversed
+    cleanupContentsNodesRecursively(node);
     return;
   }
 
@@ -1376,6 +1343,9 @@ static void calculateLayoutImpl(
           heightSizingMode,
           ownerWidth,
           ownerHeight)) {
+    // Clean and update all display: contents nodes with a direct path to the
+    // current node as they will not be traversed
+    cleanupContentsNodesRecursively(node);
     return;
   }
 
@@ -1385,6 +1355,10 @@ static void calculateLayoutImpl(
   // Reset layout flags, as they could have changed.
   node->setLayoutHadOverflow(false);
 
+  // Clean and update all display: contents nodes with a direct path to the
+  // current node as they will not be traversed
+  cleanupContentsNodesRecursively(node);
+
   // STEP 1: CALCULATE VALUES FOR REMAINDER OF ALGORITHM
   const FlexDirection mainAxis =
       resolveDirection(node->style().flexDirection(), direction);
@@ -1470,9 +1444,9 @@ static void calculateLayoutImpl(
   }
   // STEP 4: COLLECT FLEX ITEMS INTO FLEX LINES
 
-  // Indexes of children that represent the first and last items in the line.
-  size_t startOfLineIndex = 0;
-  size_t endOfLineIndex = 0;
+  // Iterator representing the beginning of the current line
+  Node::LayoutableChildren::Iterator startOfLineIterator =
+      node->getLayoutChildren().begin();
 
   // Number of lines.
   size_t lineCount = 0;
@@ -1485,8 +1459,7 @@ static void calculateLayoutImpl(
 
   // Max main dimension of all the lines.
   float maxLineMainDim = 0;
-  for (; endOfLineIndex < childCount;
-       lineCount++, startOfLineIndex = endOfLineIndex) {
+  for (; startOfLineIterator != node->getLayoutChildren().end(); lineCount++) {
     auto flexLine = calculateFlexLine(
         node,
         ownerDirection,
@@ -1494,11 +1467,9 @@ static void calculateLayoutImpl(
         mainAxisOwnerSize,
         availableInnerWidth,
         availableInnerMainDim,
-        startOfLineIndex,
+        startOfLineIterator,
         lineCount);
 
-    endOfLineIndex = flexLine.endOfLineIndex;
-
     // If we don't need to measure the cross axis, we can skip the entire flex
     // step.
     const bool canSkipFlex =
@@ -1616,7 +1587,6 @@ static void calculateLayoutImpl(
     justifyMainAxis(
         node,
         flexLine,
-        startOfLineIndex,
         mainAxis,
         crossAxis,
         direction,
@@ -1668,151 +1638,116 @@ static void calculateLayoutImpl(
     // STEP 7: CROSS-AXIS ALIGNMENT
     // We can skip child alignment if we're just measuring the container.
     if (performLayout) {
-      for (size_t i = startOfLineIndex; i < endOfLineIndex; i++) {
-        const auto child = node->getChild(i);
-        if (child->style().display() == Display::None) {
-          continue;
-        }
-        if (child->style().positionType() == PositionType::Absolute) {
-          // If the child is absolutely positioned and has a
-          // top/left/bottom/right set, override all the previously computed
-          // positions to set it correctly.
-          const bool isChildLeadingPosDefined =
-              child->style().isFlexStartPositionDefined(crossAxis, direction) &&
-              !child->style().isFlexStartPositionAuto(crossAxis, direction);
-          if (isChildLeadingPosDefined) {
-            child->setLayoutPosition(
-                child->style().computeFlexStartPosition(
-                    crossAxis, direction, availableInnerCrossDim) +
-                    node->style().computeFlexStartBorder(crossAxis, direction) +
-                    child->style().computeFlexStartMargin(
-                        crossAxis, direction, availableInnerWidth),
-                flexStartEdge(crossAxis));
-          }
-          // If leading position is not defined or calculations result in Nan,
-          // default to border + margin
-          if (!isChildLeadingPosDefined ||
-              yoga::isUndefined(
-                  child->getLayout().position(flexStartEdge(crossAxis)))) {
-            child->setLayoutPosition(
-                node->style().computeFlexStartBorder(crossAxis, direction) +
-                    child->style().computeFlexStartMargin(
-                        crossAxis, direction, availableInnerWidth),
-                flexStartEdge(crossAxis));
+      for (auto child : flexLine.itemsInFlow) {
+        float leadingCrossDim = leadingPaddingAndBorderCross;
+
+        // For a relative children, we're either using alignItems (owner) or
+        // alignSelf (child) in order to determine the position in the cross
+        // axis
+        const Align alignItem = resolveChildAlignment(node, child);
+
+        // If the child uses align stretch, we need to lay it out one more
+        // time, this time forcing the cross-axis size to be the computed
+        // cross size for the current line.
+        if (alignItem == Align::Stretch &&
+            !child->style().flexStartMarginIsAuto(crossAxis, direction) &&
+            !child->style().flexEndMarginIsAuto(crossAxis, direction)) {
+          // If the child defines a definite size for its cross axis, there's
+          // no need to stretch.
+          if (!child->hasDefiniteLength(
+                  dimension(crossAxis), availableInnerCrossDim)) {
+            float childMainSize =
+                child->getLayout().measuredDimension(dimension(mainAxis));
+            const auto& childStyle = child->style();
+            float childCrossSize = childStyle.aspectRatio().isDefined()
+                ? child->style().computeMarginForAxis(
+                      crossAxis, availableInnerWidth) +
+                    (isMainAxisRow
+                         ? childMainSize / childStyle.aspectRatio().unwrap()
+                         : childMainSize * childStyle.aspectRatio().unwrap())
+                : flexLine.layout.crossDim;
+
+            childMainSize += child->style().computeMarginForAxis(
+                mainAxis, availableInnerWidth);
+
+            SizingMode childMainSizingMode = SizingMode::StretchFit;
+            SizingMode childCrossSizingMode = SizingMode::StretchFit;
+            constrainMaxSizeForMode(
+                child,
+                direction,
+                mainAxis,
+                availableInnerMainDim,
+                availableInnerWidth,
+                &childMainSizingMode,
+                &childMainSize);
+            constrainMaxSizeForMode(
+                child,
+                direction,
+                crossAxis,
+                availableInnerCrossDim,
+                availableInnerWidth,
+                &childCrossSizingMode,
+                &childCrossSize);
+
+            const float childWidth =
+                isMainAxisRow ? childMainSize : childCrossSize;
+            const float childHeight =
+                !isMainAxisRow ? childMainSize : childCrossSize;
+
+            auto alignContent = node->style().alignContent();
+            auto crossAxisDoesNotGrow =
+                alignContent != Align::Stretch && isNodeFlexWrap;
+            const SizingMode childWidthSizingMode =
+                yoga::isUndefined(childWidth) ||
+                    (!isMainAxisRow && crossAxisDoesNotGrow)
+                ? SizingMode::MaxContent
+                : SizingMode::StretchFit;
+            const SizingMode childHeightSizingMode =
+                yoga::isUndefined(childHeight) ||
+                    (isMainAxisRow && crossAxisDoesNotGrow)
+                ? SizingMode::MaxContent
+                : SizingMode::StretchFit;
+
+            calculateLayoutInternal(
+                child,
+                childWidth,
+                childHeight,
+                direction,
+                childWidthSizingMode,
+                childHeightSizingMode,
+                availableInnerWidth,
+                availableInnerHeight,
+                true,
+                LayoutPassReason::kStretch,
+                layoutMarkerData,
+                depth,
+                generationCount);
           }
         } else {
-          float leadingCrossDim = leadingPaddingAndBorderCross;
+          const float remainingCrossDim = containerCrossAxis -
+              child->dimensionWithMargin(crossAxis, availableInnerWidth);
 
-          // For a relative children, we're either using alignItems (owner) or
-          // alignSelf (child) in order to determine the position in the cross
-          // axis
-          const Align alignItem = resolveChildAlignment(node, child);
-
-          // If the child uses align stretch, we need to lay it out one more
-          // time, this time forcing the cross-axis size to be the computed
-          // cross size for the current line.
-          if (alignItem == Align::Stretch &&
-              !child->style().flexStartMarginIsAuto(crossAxis, direction) &&
-              !child->style().flexEndMarginIsAuto(crossAxis, direction)) {
-            // If the child defines a definite size for its cross axis, there's
-            // no need to stretch.
-            if (!child->hasDefiniteLength(
-                    dimension(crossAxis), availableInnerCrossDim)) {
-              float childMainSize =
-                  child->getLayout().measuredDimension(dimension(mainAxis));
-              const auto& childStyle = child->style();
-              float childCrossSize = childStyle.aspectRatio().isDefined()
-                  ? child->style().computeMarginForAxis(
-                        crossAxis, availableInnerWidth) +
-                      (isMainAxisRow
-                           ? childMainSize / childStyle.aspectRatio().unwrap()
-                           : childMainSize * childStyle.aspectRatio().unwrap())
-                  : flexLine.layout.crossDim;
-
-              childMainSize += child->style().computeMarginForAxis(
-                  mainAxis, availableInnerWidth);
-
-              SizingMode childMainSizingMode = SizingMode::StretchFit;
-              SizingMode childCrossSizingMode = SizingMode::StretchFit;
-              constrainMaxSizeForMode(
-                  child,
-                  direction,
-                  mainAxis,
-                  availableInnerMainDim,
-                  availableInnerWidth,
-                  &childMainSizingMode,
-                  &childMainSize);
-              constrainMaxSizeForMode(
-                  child,
-                  direction,
-                  crossAxis,
-                  availableInnerCrossDim,
-                  availableInnerWidth,
-                  &childCrossSizingMode,
-                  &childCrossSize);
-
-              const float childWidth =
-                  isMainAxisRow ? childMainSize : childCrossSize;
-              const float childHeight =
-                  !isMainAxisRow ? childMainSize : childCrossSize;
-
-              auto alignContent = node->style().alignContent();
-              auto crossAxisDoesNotGrow =
-                  alignContent != Align::Stretch && isNodeFlexWrap;
-              const SizingMode childWidthSizingMode =
-                  yoga::isUndefined(childWidth) ||
-                      (!isMainAxisRow && crossAxisDoesNotGrow)
-                  ? SizingMode::MaxContent
-                  : SizingMode::StretchFit;
-              const SizingMode childHeightSizingMode =
-                  yoga::isUndefined(childHeight) ||
-                      (isMainAxisRow && crossAxisDoesNotGrow)
-                  ? SizingMode::MaxContent
-                  : SizingMode::StretchFit;
-
-              calculateLayoutInternal(
-                  child,
-                  childWidth,
-                  childHeight,
-                  direction,
-                  childWidthSizingMode,
-                  childHeightSizingMode,
-                  availableInnerWidth,
-                  availableInnerHeight,
-                  true,
-                  LayoutPassReason::kStretch,
-                  layoutMarkerData,
-                  depth,
-                  generationCount);
-            }
+          if (child->style().flexStartMarginIsAuto(crossAxis, direction) &&
+              child->style().flexEndMarginIsAuto(crossAxis, direction)) {
+            leadingCrossDim += yoga::maxOrDefined(0.0f, remainingCrossDim / 2);
+          } else if (child->style().flexEndMarginIsAuto(crossAxis, direction)) {
+            // No-Op
+          } else if (child->style().flexStartMarginIsAuto(
+                         crossAxis, direction)) {
+            leadingCrossDim += yoga::maxOrDefined(0.0f, remainingCrossDim);
+          } else if (alignItem == Align::FlexStart) {
+            // No-Op
+          } else if (alignItem == Align::Center) {
+            leadingCrossDim += remainingCrossDim / 2;
           } else {
-            const float remainingCrossDim = containerCrossAxis -
-                child->dimensionWithMargin(crossAxis, availableInnerWidth);
-
-            if (child->style().flexStartMarginIsAuto(crossAxis, direction) &&
-                child->style().flexEndMarginIsAuto(crossAxis, direction)) {
-              leadingCrossDim +=
-                  yoga::maxOrDefined(0.0f, remainingCrossDim / 2);
-            } else if (child->style().flexEndMarginIsAuto(
-                           crossAxis, direction)) {
-              // No-Op
-            } else if (child->style().flexStartMarginIsAuto(
-                           crossAxis, direction)) {
-              leadingCrossDim += yoga::maxOrDefined(0.0f, remainingCrossDim);
-            } else if (alignItem == Align::FlexStart) {
-              // No-Op
-            } else if (alignItem == Align::Center) {
-              leadingCrossDim += remainingCrossDim / 2;
-            } else {
-              leadingCrossDim += remainingCrossDim;
-            }
+            leadingCrossDim += remainingCrossDim;
           }
-          // And we apply the position
-          child->setLayoutPosition(
-              child->getLayout().position(flexStartEdge(crossAxis)) +
-                  totalLineCrossDim + leadingCrossDim,
-              flexStartEdge(crossAxis));
         }
+        // And we apply the position
+        child->setLayoutPosition(
+            child->getLayout().position(flexStartEdge(crossAxis)) +
+                totalLineCrossDim + leadingCrossDim,
+            flexStartEdge(crossAxis));
       }
     }
 
@@ -1827,6 +1762,7 @@ static void calculateLayoutImpl(
   if (performLayout && (isNodeFlexWrap || isBaselineLayout(node))) {
     float leadPerLine = 0;
     float currentLead = leadingPaddingAndBorderCross;
+    float extraSpacePerLine = 0;
 
     const float unclampedCrossDim = sizingModeCrossDim == SizingMode::StretchFit
         ? availableInnerCrossDim + paddingAndBorderAxisCross
@@ -1862,7 +1798,8 @@ static void calculateLayoutImpl(
         currentLead += remainingAlignContentDim / 2;
         break;
       case Align::Stretch:
-        leadPerLine = remainingAlignContentDim / static_cast<float>(lineCount);
+        extraSpacePerLine =
+            remainingAlignContentDim / static_cast<float>(lineCount);
         break;
       case Align::SpaceAround:
         currentLead +=
@@ -1886,17 +1823,18 @@ static void calculateLayoutImpl(
       case Align::Baseline:
         break;
     }
-    size_t endIndex = 0;
+    Node::LayoutableChildren::Iterator endIterator =
+        node->getLayoutChildren().begin();
     for (size_t i = 0; i < lineCount; i++) {
-      const size_t startIndex = endIndex;
-      size_t ii = startIndex;
+      const Node::LayoutableChildren::Iterator startIterator = endIterator;
+      auto iterator = startIterator;
 
       // compute the line's height and find the endIndex
       float lineHeight = 0;
       float maxAscentForCurrentLine = 0;
       float maxDescentForCurrentLine = 0;
-      for (; ii < childCount; ii++) {
-        const auto child = node->getChild(ii);
+      for (; iterator != node->getLayoutChildren().end(); iterator++) {
+        const auto child = *iterator;
         if (child->style().display() == Display::None) {
           continue;
         }
@@ -1929,11 +1867,12 @@ static void calculateLayoutImpl(
           }
         }
       }
-      endIndex = ii;
+      endIterator = iterator;
       currentLead += i != 0 ? crossAxisGap : 0;
+      lineHeight += extraSpacePerLine;
 
-      for (ii = startIndex; ii < endIndex; ii++) {
-        const auto child = node->getChild(ii);
+      for (iterator = startIterator; iterator != endIterator; iterator++) {
+        const auto child = *iterator;
         if (child->style().display() == Display::None) {
           continue;
         }
@@ -2136,8 +2075,7 @@ static void calculateLayoutImpl(
   // As we only wrapped in normal direction yet, we need to reverse the
   // positions on wrap-reverse.
   if (performLayout && node->style().flexWrap() == Wrap::WrapReverse) {
-    for (size_t i = 0; i < childCount; i++) {
-      const auto child = node->getChild(i);
+    for (auto child : node->getLayoutChildren()) {
       if (child->style().positionType() != PositionType::Absolute) {
         child->setLayoutPosition(
             node->getLayout().measuredDimension(dimension(crossAxis)) -
@@ -2154,8 +2092,7 @@ static void calculateLayoutImpl(
     const bool needsCrossTrailingPos = needsTrailingPosition(crossAxis);
 
     if (needsMainTrailingPos || needsCrossTrailingPos) {
-      for (size_t i = 0; i < childCount; i++) {
-        const auto child = node->getChild(i);
+      for (auto child : node->getLayoutChildren()) {
         // Absolute children will be handled by their containing block since we
         // cannot guarantee that their positions are set when their parents are
         // done with layout.

yoga/algorithm/FlexLine.cpp

@@ -20,17 +20,16 @@ FlexLine calculateFlexLine(
     const float mainAxisownerSize,
     const float availableInnerWidth,
     const float availableInnerMainDim,
-    const size_t startOfLineIndex,
+    Node::LayoutableChildren::Iterator& iterator,
     const size_t lineCount) {
   std::vector<yoga::Node*> itemsInFlow;
-  itemsInFlow.reserve(node->getChildren().size());
+  itemsInFlow.reserve(node->getChildCount());
 
   float sizeConsumed = 0.0f;
   float totalFlexGrowFactors = 0.0f;
   float totalFlexShrinkScaledFactors = 0.0f;
   size_t numberOfAutoMargins = 0;
-  size_t endOfLineIndex = startOfLineIndex;
-  size_t firstElementInLineIndex = startOfLineIndex;
+  yoga::Node* firstElementInLine = nullptr;
 
   float sizeConsumedIncludingMinConstraint = 0;
   const Direction direction = node->resolveDirection(ownerDirection);
@@ -40,18 +39,19 @@ FlexLine calculateFlexLine(
   const float gap =
       node->style().computeGapForAxis(mainAxis, availableInnerMainDim);
 
+  const auto childrenEnd = node->getLayoutChildren().end();
   // Add items to the current line until it's full or we run out of items.
-  for (; endOfLineIndex < node->getChildren().size(); endOfLineIndex++) {
-    auto child = node->getChild(endOfLineIndex);
+  for (; iterator != childrenEnd; iterator++) {
+    auto child = *iterator;
     if (child->style().display() == Display::None ||
         child->style().positionType() == PositionType::Absolute) {
-      if (firstElementInLineIndex == endOfLineIndex) {
-        // We haven't found the first contributing element in the line yet.
-        firstElementInLineIndex++;
-      }
       continue;
     }
 
+    if (firstElementInLine == nullptr) {
+      firstElementInLine = child;
+    }
+
     if (child->style().flexStartMarginIsAuto(mainAxis, ownerDirection)) {
       numberOfAutoMargins++;
     }
@@ -59,13 +59,11 @@ FlexLine calculateFlexLine(
       numberOfAutoMargins++;
     }
 
-    const bool isFirstElementInLine =
-        (endOfLineIndex - firstElementInLineIndex) == 0;
-
     child->setLineIndex(lineCount);
     const float childMarginMainAxis =
         child->style().computeMarginForAxis(mainAxis, availableInnerWidth);
-    const float childLeadingGapMainAxis = isFirstElementInLine ? 0.0f : gap;
+    const float childLeadingGapMainAxis =
+        child == firstElementInLine ? 0.0f : gap;
     const float flexBasisWithMinAndMaxConstraints =
         boundAxisWithinMinAndMax(
             child,
@@ -116,7 +114,6 @@ FlexLine calculateFlexLine(
   return FlexLine{
       .itemsInFlow = std::move(itemsInFlow),
       .sizeConsumed = sizeConsumed,
-      .endOfLineIndex = endOfLineIndex,
       .numberOfAutoMargins = numberOfAutoMargins,
       .layout = FlexLineRunningLayout{
           totalFlexGrowFactors,

yoga/algorithm/FlexLine.h

@@ -49,9 +49,6 @@ struct FlexLine {
   // the flexible children.
   const float sizeConsumed{0.0f};
 
-  // The index of the first item beyond the current line.
-  const size_t endOfLineIndex{0};
-
   // Number of edges along the line flow with an auto margin.
   const size_t numberOfAutoMargins{0};
 
@@ -72,7 +69,7 @@ FlexLine calculateFlexLine(
     float mainAxisownerSize,
     float availableInnerWidth,
     float availableInnerMainDim,
-    size_t startOfLineIndex,
+    Node::LayoutableChildren::Iterator& iterator,
     size_t lineCount);
 
 } // namespace facebook::yoga

yoga/enums/Display.h

@@ -18,11 +18,12 @@ namespace facebook::yoga {
 enum class Display : uint8_t {
   Flex = YGDisplayFlex,
   None = YGDisplayNone,
+  Contents = YGDisplayContents,
 };
 
 template <>
 constexpr int32_t ordinalCount<Display>() {
-  return 2;
+  return 3;
 }
 
 constexpr Display scopedEnum(YGDisplay unscoped) {

yoga/enums/Errata.h

@@ -18,7 +18,7 @@ namespace facebook::yoga {
 enum class Errata : uint32_t {
   None = YGErrataNone,
   StretchFlexBasis = YGErrataStretchFlexBasis,
-  AbsolutePositioningIncorrect = YGErrataAbsolutePositioningIncorrect,
+  AbsolutePositionWithoutInsetsExcludesPadding = YGErrataAbsolutePositionWithoutInsetsExcludesPadding,
   AbsolutePercentAgainstInnerSize = YGErrataAbsolutePercentAgainstInnerSize,
   All = YGErrataAll,
   Classic = YGErrataClassic,

yoga/node/LayoutableChildren.h

@@ -0,0 +1,148 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * 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 <cstdint>
+#include <forward_list>
+#include <utility>
+
+#include <yoga/enums/Display.h>
+
+namespace facebook::yoga {
+
+class Node;
+
+template <typename T>
+class LayoutableChildren {
+ public:
+  struct Iterator {
+    using iterator_category = std::input_iterator_tag;
+    using difference_type = std::ptrdiff_t;
+    using value_type = T*;
+    using pointer = T*;
+    using reference = T*;
+
+    Iterator() = default;
+
+    Iterator(const T* node, size_t childIndex)
+        : node_(node), childIndex_(childIndex) {}
+
+    T* operator*() const {
+      return node_->getChild(childIndex_);
+    }
+
+    Iterator& operator++() {
+      next();
+      return *this;
+    }
+
+    Iterator operator++(int) {
+      Iterator tmp = *this;
+      ++(*this);
+      return tmp;
+    }
+
+    friend bool operator==(const Iterator& a, const Iterator& b) {
+      return a.node_ == b.node_ && a.childIndex_ == b.childIndex_;
+    }
+
+    friend bool operator!=(const Iterator& a, const Iterator& b) {
+      return a.node_ != b.node_ || a.childIndex_ != b.childIndex_;
+    }
+
+   private:
+    void next() {
+      if (childIndex_ + 1 >= node_->getChildCount()) {
+        // if the current node has no more children, try to backtrack and
+        // visit its successor
+        if (backtrack_.empty()) [[likely]] {
+          // if there are no nodes to backtrack to, the last node has been
+          // visited
+          *this = Iterator{};
+        } else {
+          // pop and restore the latest backtrack entry
+          const auto& back = backtrack_.front();
+          node_ = back.first;
+          childIndex_ = back.second;
+          backtrack_.pop_front();
+
+          // go to the next node
+          next();
+        }
+      } else {
+        // current node has more children to visit, go to next
+        ++childIndex_;
+        // skip all display: contents nodes, possibly going deeper into the
+        // tree
+        if (node_->getChild(childIndex_)->style().display() ==
+            Display::Contents) [[unlikely]] {
+          skipContentsNodes();
+        }
+      }
+    }
+
+    void skipContentsNodes() {
+      // get the node that would be returned from the iterator
+      auto currentNode = node_->getChild(childIndex_);
+      while (currentNode->style().display() == Display::Contents &&
+             currentNode->getChildCount() > 0) {
+        // if it has display: contents set, it shouldn't be returned but its
+        // children should in its place push the current node and child index
+        // so that the current state can be restored when backtracking
+        backtrack_.push_front({node_, childIndex_});
+        // traverse the child
+        node_ = currentNode;
+        childIndex_ = 0;
+
+        // repeat until a node without display: contents is found in the
+        // subtree or a leaf is reached
+        currentNode = currentNode->getChild(childIndex_);
+      }
+
+      // if no node without display: contents was found, try to backtrack
+      if (currentNode->style().display() == Display::Contents) {
+        next();
+      }
+    }
+
+    const T* node_{nullptr};
+    size_t childIndex_{0};
+    std::forward_list<std::pair<const T*, size_t>> backtrack_;
+
+    friend LayoutableChildren;
+  };
+
+  explicit LayoutableChildren(const T* node) : node_(node) {
+    static_assert(std::input_iterator<LayoutableChildren<T>::Iterator>);
+    static_assert(
+        std::is_base_of<Node, T>::value,
+        "Type parameter of LayoutableChildren must derive from yoga::Node");
+  }
+
+  Iterator begin() const {
+    if (node_->getChildCount() > 0) {
+      auto result = Iterator(node_, 0);
+      if (node_->getChild(0)->style().display() == Display::Contents)
+          [[unlikely]] {
+        result.skipContentsNodes();
+      }
+      return result;
+    } else {
+      return Iterator{};
+    }
+  }
+
+  Iterator end() const {
+    return Iterator{};
+  }
+
+ private:
+  const T* node_;
+};
+
+} // namespace facebook::yoga

yoga/node/Node.cpp

@@ -41,6 +41,7 @@ Node::Node(Node&& node) noexcept
       style_(std::move(node.style_)),
       layout_(node.layout_),
       lineIndex_(node.lineIndex_),
+      contentsChildrenCount_(node.contentsChildrenCount_),
       owner_(node.owner_),
       children_(std::move(node.children_)),
       config_(node.config_),
@@ -116,14 +117,37 @@ void Node::setMeasureFunc(YGMeasureFunc measureFunc) {
 }
 
 void Node::replaceChild(Node* child, size_t index) {
+  auto previousChild = children_[index];
+  if (previousChild->style().display() == Display::Contents &&
+      child->style().display() != Display::Contents) {
+    contentsChildrenCount_--;
+  } else if (
+      previousChild->style().display() != Display::Contents &&
+      child->style().display() == Display::Contents) {
+    contentsChildrenCount_++;
+  }
+
   children_[index] = child;
 }
 
 void Node::replaceChild(Node* oldChild, Node* newChild) {
+  if (oldChild->style().display() == Display::Contents &&
+      newChild->style().display() != Display::Contents) {
+    contentsChildrenCount_--;
+  } else if (
+      oldChild->style().display() != Display::Contents &&
+      newChild->style().display() == Display::Contents) {
+    contentsChildrenCount_++;
+  }
+
   std::replace(children_.begin(), children_.end(), oldChild, newChild);
 }
 
 void Node::insertChild(Node* child, size_t index) {
+  if (child->style().display() == Display::Contents) {
+    contentsChildrenCount_++;
+  }
+
   children_.insert(children_.begin() + static_cast<ptrdiff_t>(index), child);
 }
 
@@ -160,6 +184,10 @@ void Node::setDirty(bool isDirty) {
 bool Node::removeChild(Node* child) {
   auto p = std::find(children_.begin(), children_.end(), child);
   if (p != children_.end()) {
+    if (child->style().display() == Display::Contents) {
+      contentsChildrenCount_--;
+    }
+
     children_.erase(p);
     return true;
   }
@@ -167,6 +195,10 @@ bool Node::removeChild(Node* child) {
 }
 
 void Node::removeChild(size_t index) {
+  if (children_[index]->style().display() == Display::Contents) {
+    contentsChildrenCount_--;
+  }
+
   children_.erase(children_.begin() + static_cast<ptrdiff_t>(index));
 }
 

yoga/node/Node.h

@@ -12,6 +12,7 @@
 #include <vector>
 
 #include <yoga/Yoga.h>
+#include <yoga/node/LayoutableChildren.h>
 
 #include <yoga/config/Config.h>
 #include <yoga/enums/Dimension.h>
@@ -31,6 +32,7 @@ namespace facebook::yoga {
 
 class YG_EXPORT Node : public ::YGNode {
  public:
+  using LayoutableChildren = yoga::LayoutableChildren<Node>;
   Node();
   explicit Node(const Config* config);
 
@@ -144,6 +146,24 @@ class YG_EXPORT Node : public ::YGNode {
     return children_.size();
   }
 
+  LayoutableChildren getLayoutChildren() const {
+    return LayoutableChildren(this);
+  }
+
+  size_t getLayoutChildCount() const {
+    if (contentsChildrenCount_ == 0) {
+      return children_.size();
+    } else {
+      size_t count = 0;
+      for (auto iter = getLayoutChildren().begin();
+           iter != getLayoutChildren().end();
+           iter++) {
+        count++;
+      }
+      return count;
+    }
+  }
+
   const Config* getConfig() const {
     return config_;
   }
@@ -298,6 +318,7 @@ class YG_EXPORT Node : public ::YGNode {
   Style style_;
   LayoutResults layout_;
   size_t lineIndex_ = 0;
+  size_t contentsChildrenCount_ = 0;
   Node* owner_ = nullptr;
   std::vector<Node*> children_;
   const Config* config_;