Bump cross-spawn from 7.0.3 to 7.0.6

Bumps [cross-spawn](https://github.com/moxystudio/node-cross-spawn) from 7.0.3 to 7.0.6. - [Changelog](https://github.com/moxystudio/node-cross-spawn/blob/master/CHANGELOG.md) - [Commits](https://github.com/moxystudio/node-cross-spawn/compare/v7.0.3...v7.0.6) --- updated-dependencies: - dependency-name: cross-spawn dependency-type: indirect ... Signed-off-by: dependabot[bot] <support@github.com>
2024-11-21 19:14:09 +00:00
41 changed files with 7338 additions and 517 deletions
--- a/Yoga.podspec
+++ b/Yoga.podspec
@@ -6,7 +6,7 @@

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

 ENUMS = {
    "Direction": ["Inherit", "LTR", "RTL"],
-    "Unit": ["Undefined", "Point", "Percent", "Auto"],
+    "Unit": [
+        "Undefined",
+        "Point",
+        "Percent",
+        "Auto",
+        "MaxContent",
+        "FitContent",
+        "Stretch",
+    ],
    "FlexDirection": ["Column", "ColumnReverse", "Row", "RowReverse"],
    "Justify": [
        "FlexStart",
--- a/gentest/fixtures/YGIntrinsicSizeTest.html
+++ b/gentest/fixtures/YGIntrinsicSizeTest.html
@@ -219,3 +219,251 @@
        Sed at consectetur ipsum.
    </div>
 </div>
+
+<div id="max_content_width" style="flex-direction: row; width:max-content; flex-wrap: wrap;">
+    <div style="width: 50px; height: 50px;">
+    </div>
+    <div style="width: 100px; height: 50px;">
+    </div>
+    <div style="width: 25px; height: 50px;">
+    </div>
+</div>
+
+<div data-disabled="true" id="fit_content_width" style="width: 90px; position: relative;">
+    <div style="flex-direction: row; width: fit-content; flex-wrap: wrap;">
+        <div style="width: 50px; height: 50px;">
+        </div>
+        <div style="width: 100px; height: 50px;">
+        </div>
+        <div style="width: 25px; height: 50px;">
+        </div>
+    </div>
+</div>
+
+<div data-disabled="true" id="stretch_width" style="width: 500px; position: relative;">
+    <div style="flex-direction: row; width: -webkit-fill-available; flex-wrap: wrap;">
+        <div style="width: 50px; height: 50px;">
+        </div>
+        <div style="width: 100px; height: 50px;">
+        </div>
+        <div style="width: 25px; height: 50px;">
+        </div>
+    </div>
+</div>
+
+<div id="max_content_height" style="height:max-content; flex-wrap: wrap;">
+    <div style="width: 50px; height: 50px;">
+    </div>
+    <div style="width: 50px; height: 100px;">
+    </div>
+    <div style="width: 50px; height: 25px;">
+    </div>
+</div>
+
+<div data-disabled="true" id="fit_content_height" style="height: 90px; position: relative;">
+    <div style="height: fit-content; flex-wrap: wrap;">
+        <div style="width: 50px; height: 50px;">
+        </div>
+        <div style="width: 50px; height: 100px;">
+        </div>
+        <div style="width: 50px; height: 25px;">
+        </div>
+    </div>
+</div>
+
+<div data-disabled="true" id="stretch_height" style="height: 500px; position: relative;">
+    <div style="height: -webkit-fill-available; flex-wrap: wrap;">
+        <div style="width: 50px; height: 50px;">
+        </div>
+        <div style="width: 50px; height: 100px;">
+        </div>
+        <div style="width: 50px; height: 25px;">
+        </div>
+    </div>
+</div>
+
+<div id="max_content_flex_basis_column" style="flex-basis: max-content; flex-wrap: wrap;">
+    <div style="width: 50px; height: 50px;">
+    </div>
+    <div style="width: 50px; height: 100px;">
+    </div>
+    <div style="width: 50px; height: 25px;">
+    </div>
+</div>
+
+<div data-disabled="true" id="fit_content_flex_basis_column" style="height: 90px; position: relative;">
+    <div style="flex-basis: fit-content; flex-wrap: wrap;">
+        <div style="width: 50px; height: 50px;">
+        </div>
+        <div style="width: 50px; height: 100px;">
+        </div>
+        <div style="width: 50px; height: 25px;">
+        </div>
+    </div>
+</div>
+
+<div data-disabled="true" id="stretch_flex_basis_column" style="height: 500px; position: relative;">
+    <div style="flex-basis: -webkit-fill-available; flex-wrap: wrap;">
+        <div style="width: 50px; height: 50px;">
+        </div>
+        <div style="width: 50px; height: 100px;">
+        </div>
+        <div style="width: 50px; height: 25px;">
+        </div>
+    </div>
+</div>
+
+<div id="max_content_flex_basis_row" style="flex-direction: row; flex-basis: max-content; flex-wrap: wrap;">
+    <div style="width: 50px; height: 50px;">
+    </div>
+    <div style="width: 100px; height: 500px;">
+    </div>
+    <div style="width: 25px; height: 50px;">
+    </div>
+</div>
+
+<div data-disabled="true" id="fit_content_flex_basis_row" style="width: 90px; position: relative;">
+    <div style="flex-direction: row; flex-basis: fit-content; flex-wrap: wrap;">
+        <div style="width: 50px; height: 50px;">
+        </div>
+        <div style="width: 100px; height: 50px;">
+        </div>
+        <div style="width: 25px; height: 50px;">
+        </div>
+    </div>
+</div>
+
+<div data-disabled="true" id="stretch_flex_basis_row" style="width: 500px; position: relative;">
+    <div style="flex-direction: row; flex-basis: -webkit-fill-available; flex-wrap: wrap;">
+        <div style="width: 50px; height: 50px;">
+        </div>
+        <div style="width: 100px; height: 50px;">
+        </div>
+        <div style="width: 25px; height: 50px;">
+        </div>
+    </div>
+</div>
+
+<div data-disabled="true" id="max_content_max_width" style="flex-direction: row; max-width:max-content; width: 200px; flex-wrap: wrap;">
+    <div style="width: 50px; height: 50px;">
+    </div>
+    <div style="width: 100px; height: 50px;">
+    </div>
+    <div style="width: 25px; height: 50px;">
+    </div>
+</div>
+
+<div data-disabled="true" id="fit_content_max_width" style="width: 90px; position: relative;">
+    <div style="flex-direction: row; max-width: fit-content; width: 110px; flex-wrap: wrap;">
+        <div style="width: 50px; height: 50px;">
+        </div>
+        <div style="width: 100px; height: 50px;">
+        </div>
+        <div style="width: 25px; height: 50px;">
+        </div>
+    </div>
+</div>
+
+<div data-disabled="true" id="stretch_max_width" style="width: 500px; position: relative;">
+    <div style="flex-direction: row; max-width: -webkit-fill-available; width: 600px; flex-wrap: wrap;">
+        <div style="width: 50px; height: 50px;">
+        </div>
+        <div style="width: 100px; height: 50px;">
+        </div>
+        <div style="width: 25px; height: 50px;">
+        </div>
+    </div>
+</div>
+
+<div data-disabled="true" id="max_content_min_width" style="flex-direction: row; min-width:max-content; width: 100px; flex-wrap: wrap;">
+    <div style="width: 50px; height: 50px;">
+    </div>
+    <div style="width: 100px; height: 50px;">
+    </div>
+    <div style="width: 25px; height: 50px;">
+    </div>
+</div>
+
+<div data-disabled="true" id="fit_content_min_width" style="width: 90px; position: relative;">
+    <div style="flex-direction: row; min-width: fit-content; width: 90px; flex-wrap: wrap;">
+        <div style="width: 50px; height: 50px;">
+        </div>
+        <div style="width: 100px; height: 50px;">
+        </div>
+        <div style="width: 25px; height: 50px;">
+        </div>
+    </div>
+</div>
+
+<div data-disabled="true" id="stretch_min_width" style="width: 500px; position: relative;">
+    <div style="flex-direction: row; min-width: -webkit-fill-available; width: 400px; flex-wrap: wrap;">
+        <div style="width: 50px; height: 50px;">
+        </div>
+        <div style="width: 100px; height: 50px;">
+        </div>
+        <div style="width: 25px; height: 50px;">
+        </div>
+    </div>
+</div>
+
+<div data-disabled="true" id="max_content_max_height" style="max-height:max-content; height: 200px; flex-wrap: wrap;">
+    <div style="width: 50px; height: 50px;">
+    </div>
+    <div style="width: 50px; height: 100px;">
+    </div>
+    <div style="width: 50px; height: 25px;">
+    </div>
+</div>
+
+<div data-disabled="true" id="fit_content_max_height" style="height: 90px; position: relative;">
+    <div style="max-height: fit-content; height: 110px; flex-wrap: wrap;">
+        <div style="width: 50px; height: 50px;">
+        </div>
+        <div style="width: 50px; height: 100px;">
+        </div>
+        <div style="width: 50px; height: 25px;">
+        </div>
+    </div>
+</div>
+
+<div data-disabled="true" id="stretch_max_height" style="height: 500px; position: relative;">
+    <div style="max-height: -webkit-fill-available; flex-wrap: wrap; height: 600px;">
+        <div style="width: 50px; height: 50px;">
+        </div>
+        <div style="width: 50px; height: 100px;">
+        </div>
+        <div style="width: 50px; height: 25px;">
+        </div>
+    </div>
+</div>
+
+<div data-disabled="true" id="max_content_min_height" style="min-height:max-content; height: 100px; flex-wrap: wrap;">
+    <div style="width: 50px; height: 50px;">
+    </div>
+    <div style="width: 50px; height: 100px;">
+    </div>
+    <div style="width: 50px; height: 25px;">
+    </div>
+</div>
+
+<div data-disabled="true" id="fit_content_min_height" style="height: 90px; position: relative;">
+    <div style="min-height: fit-content; height: 90px; flex-wrap: wrap;">
+        <div style="width: 50px; height: 50px;">
+        </div>
+        <div style="width: 50px; height: 100px;">
+        </div>
+        <div style="width: 50px; height: 25px;">
+        </div>
+    </div>
+</div>
+
+<div data-disabled="true" id="stretch_min_height" style="height: 500px; position: relative;">
+    <div style="min-height: -webkit-fill-available; flex-wrap: wrap; height: 400px;">
+        <div style="width: 50px; height: 50px;">
+        </div>
+        <div style="width: 50px; height: 100px;">
+        </div>
+        <div style="width: 50px; height: 25px;">
+        </div>
+    </div>
+</div>
--- a/gentest/gentest-cpp.js
+++ b/gentest/gentest-cpp.js
@@ -17,13 +17,25 @@ function toFunctionNameCpp(value) {
    return 'Percent';
  } else if (value.indexOf('Auto') >= 0) {
    return 'Auto';
+  } else if (value.indexOf('MaxContent') >= 0) {
+    return 'MaxContent';
+  } else if (value.indexOf('FitContent') >= 0) {
+    return 'FitContent';
+  } else if (value.indexOf('Stretch') >= 0) {
+    return 'Stretch';
  }
+
  return '';
 }

 function keywordFunctionCpp(functionPrefix, nodeName, value) {
  const functionSuffix = toFunctionNameCpp(value);
-  if (functionSuffix == 'Auto') {
+  if (
+    functionSuffix == 'Auto' ||
+    functionSuffix == 'MaxContent' ||
+    functionSuffix == 'FitContent' ||
+    functionSuffix == 'Stretch'
+  ) {
    return functionPrefix + functionSuffix + '(' + nodeName + ');';
  } else {
    return (
@@ -163,6 +175,10 @@ CPPEmitter.prototype = Object.create(Emitter.prototype, {
  YGDisplayContents: {value: 'YGDisplayContents'},
  YGAuto: {value: 'YGAuto'},

+  YGMaxContent: {value: 'MaxContent'},
+  YGFitContent: {value: 'FitContent'},
+  YGStretch: {value: 'Stretch'},
+
  YGNodeCalculateLayout: {
    value: function (node, dir, _experiments) {
      this.push(
@@ -382,57 +398,25 @@ CPPEmitter.prototype = Object.create(Emitter.prototype, {

  YGNodeStyleSetMaxHeight: {
    value: function (nodeName, value) {
-      this.push(
-        'YGNodeStyleSetMaxHeight' +
-          toFunctionNameCpp(value) +
-          '(' +
-          nodeName +
-          ', ' +
-          toValueCpp(value) +
-          ');',
-      );
+      this.push(keywordFunctionCpp('YGNodeStyleSetMaxHeight', nodeName, value));
    },
  },

  YGNodeStyleSetMaxWidth: {
    value: function (nodeName, value) {
-      this.push(
-        'YGNodeStyleSetMaxWidth' +
-          toFunctionNameCpp(value) +
-          '(' +
-          nodeName +
-          ', ' +
-          toValueCpp(value) +
-          ');',
-      );
+      this.push(keywordFunctionCpp('YGNodeStyleSetMaxWidth', nodeName, value));
    },
  },

  YGNodeStyleSetMinHeight: {
    value: function (nodeName, value) {
-      this.push(
-        'YGNodeStyleSetMinHeight' +
-          toFunctionNameCpp(value) +
-          '(' +
-          nodeName +
-          ', ' +
-          toValueCpp(value) +
-          ');',
-      );
+      this.push(keywordFunctionCpp('YGNodeStyleSetMinHeight', nodeName, value));
    },
  },

  YGNodeStyleSetMinWidth: {
    value: function (nodeName, value) {
-      this.push(
-        'YGNodeStyleSetMinWidth' +
-          toFunctionNameCpp(value) +
-          '(' +
-          nodeName +
-          ', ' +
-          toValueCpp(value) +
-          ');',
-      );
+      this.push(keywordFunctionCpp('YGNodeStyleSetMinWidth', nodeName, value));
    },
  },

--- a/gentest/gentest-java.js
+++ b/gentest/gentest-java.js
@@ -17,13 +17,24 @@ function toMethodName(value) {
    return 'Percent';
  } else if (value.indexOf('AUTO') >= 0) {
    return 'Auto';
+  } else if (value.indexOf('MAX_CONTENT') >= 0) {
+    return 'MaxContent';
+  } else if (value.indexOf('FIT_CONTENT') >= 0) {
+    return 'FitContent';
+  } else if (value.indexOf('STRETCH') >= 0) {
+    return 'Stretch';
  }
  return '';
 }

 function keywordMethod(methodPrefix, nodeName, value) {
  const methodSuffix = toMethodName(value);
-  if (methodSuffix == 'Auto') {
+  if (
+    methodSuffix == 'Auto' ||
+    methodSuffix == 'MaxContent' ||
+    methodSuffix == 'FitContent' ||
+    methodSuffix == 'Stretch'
+  ) {
    return nodeName + '.' + methodPrefix + methodSuffix + '();';
  } else {
    return (
@@ -205,6 +216,10 @@ JavaEmitter.prototype = Object.create(Emitter.prototype, {
  YGBoxSizingBorderBox: {value: 'YogaBoxSizing.BORDER_BOX'},
  YGBoxSizingContentBox: {value: 'YogaBoxSizing.CONTENT_BOX'},

+  YGMaxContent: {value: 'MAX_CONTENT'},
+  YGFitContent: {value: 'FIT_CONTENT'},
+  YGStretch: {value: 'STRETCH'},
+
  YGNodeCalculateLayout: {
    value: function (node, dir, _experiments) {
      this.push(node + '.setDirection(' + dir + ');');
@@ -360,53 +375,25 @@ JavaEmitter.prototype = Object.create(Emitter.prototype, {

  YGNodeStyleSetMaxHeight: {
    value: function (nodeName, value) {
-      this.push(
-        nodeName +
-          '.setMaxHeight' +
-          toMethodName(value) +
-          '(' +
-          toValueJava(value) +
-          'f);',
-      );
+      this.push(keywordMethod('setMaxHeight', nodeName, value));
    },
  },

  YGNodeStyleSetMaxWidth: {
    value: function (nodeName, value) {
-      this.push(
-        nodeName +
-          '.setMaxWidth' +
-          toMethodName(value) +
-          '(' +
-          toValueJava(value) +
-          'f);',
-      );
+      this.push(keywordMethod('setMaxWidth', nodeName, value));
    },
  },

  YGNodeStyleSetMinHeight: {
    value: function (nodeName, value) {
-      this.push(
-        nodeName +
-          '.setMinHeight' +
-          toMethodName(value) +
-          '(' +
-          toValueJava(value) +
-          'f);',
-      );
+      this.push(keywordMethod('setMinHeight', nodeName, value));
    },
  },

  YGNodeStyleSetMinWidth: {
    value: function (nodeName, value) {
-      this.push(
-        nodeName +
-          '.setMinWidth' +
-          toMethodName(value) +
-          '(' +
-          toValueJava(value) +
-          'f);',
-      );
+      this.push(keywordMethod('setMinWidth', nodeName, value));
    },
  },

--- a/gentest/gentest-javascript.js
+++ b/gentest/gentest-javascript.js
@@ -15,6 +15,9 @@ function toValueJavascript(value) {
  if (value.match(/^[0-9.e+-]+px$/i)) return parseFloat(value);
  if (value.match(/^[0-9.e+-]+%/i)) return JSON.stringify(value);
  if (value == 'Yoga.AUTO') return '"auto"';
+  if (value == 'max-content') return '"max-content"';
+  if (value == 'fit-content') return '"fit-content"';
+  if (value == 'stretch') return '"stretch"';
  return value;
 }

@@ -176,6 +179,10 @@ JavascriptEmitter.prototype = Object.create(Emitter.prototype, {
  YGBoxSizingBorderBox: {value: 'BoxSizing.BorderBox'},
  YGBoxSizingContentBox: {value: 'BoxSizing.ContentBox'},

+  YGMaxContent: {value: 'max-content'},
+  YGFitContent: {value: 'fit-content'},
+  YGStretch: {value: 'stretch'},
+
  YGNodeCalculateLayout: {
    value: function (node, dir, _experiments) {
      this.push(node + '.calculateLayout(undefined, undefined, ' + dir + ');');
--- a/gentest/gentest.js
+++ b/gentest/gentest.js
@@ -654,6 +654,13 @@ function pointValue(e, value) {
      return e.YGAuto;
    case 'undefined':
      return e.YGUndefined;
+    case 'max-content':
+      return e.YGMaxContent;
+    case 'fit-content':
+      return e.YGFitContent;
+    case 'stretch':
+    case '-webkit-fill-available':
+      return e.YGStretch;
    default:
      return value;
  }
--- a/gradle.properties
+++ b/gradle.properties
@@ -11,4 +11,4 @@ android.useAndroidX=true

 org.gradle.jvmargs=-Xmx1536M

-VERSION_NAME=3.2.1
+VERSION_NAME=0.0.0
--- a/java/build.gradle.kts
+++ b/java/build.gradle.kts
@@ -30,7 +30,6 @@ android {
    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") } }
--- a/java/com/facebook/yoga/YogaNative.java
+++ b/java/com/facebook/yoga/YogaNative.java
@@ -74,6 +74,9 @@ public class YogaNative {
  static native void jni_YGNodeStyleSetFlexBasisJNI(long nativePointer, float flexBasis);
  static native void jni_YGNodeStyleSetFlexBasisPercentJNI(long nativePointer, float percent);
  static native void jni_YGNodeStyleSetFlexBasisAutoJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetFlexBasisMaxContentJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetFlexBasisFitContentJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetFlexBasisStretchJNI(long nativePointer);
  static native long jni_YGNodeStyleGetMarginJNI(long nativePointer, int edge);
  static native void jni_YGNodeStyleSetMarginJNI(long nativePointer, int edge, float margin);
  static native void jni_YGNodeStyleSetMarginPercentJNI(long nativePointer, int edge, float percent);
@@ -91,22 +94,40 @@ public class YogaNative {
  static native void jni_YGNodeStyleSetWidthJNI(long nativePointer, float width);
  static native void jni_YGNodeStyleSetWidthPercentJNI(long nativePointer, float percent);
  static native void jni_YGNodeStyleSetWidthAutoJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetWidthMaxContentJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetWidthFitContentJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetWidthStretchJNI(long nativePointer);
  static native long jni_YGNodeStyleGetHeightJNI(long nativePointer);
  static native void jni_YGNodeStyleSetHeightJNI(long nativePointer, float height);
  static native void jni_YGNodeStyleSetHeightPercentJNI(long nativePointer, float percent);
  static native void jni_YGNodeStyleSetHeightAutoJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetHeightMaxContentJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetHeightFitContentJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetHeightStretchJNI(long nativePointer);
  static native long jni_YGNodeStyleGetMinWidthJNI(long nativePointer);
  static native void jni_YGNodeStyleSetMinWidthJNI(long nativePointer, float minWidth);
  static native void jni_YGNodeStyleSetMinWidthPercentJNI(long nativePointer, float percent);
+  static native void jni_YGNodeStyleSetMinWidthMaxContentJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetMinWidthFitContentJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetMinWidthStretchJNI(long nativePointer);
  static native long jni_YGNodeStyleGetMinHeightJNI(long nativePointer);
  static native void jni_YGNodeStyleSetMinHeightJNI(long nativePointer, float minHeight);
  static native void jni_YGNodeStyleSetMinHeightPercentJNI(long nativePointer, float percent);
+  static native void jni_YGNodeStyleSetMinHeightMaxContentJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetMinHeightFitContentJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetMinHeightStretchJNI(long nativePointer);
  static native long jni_YGNodeStyleGetMaxWidthJNI(long nativePointer);
  static native void jni_YGNodeStyleSetMaxWidthJNI(long nativePointer, float maxWidth);
  static native void jni_YGNodeStyleSetMaxWidthPercentJNI(long nativePointer, float percent);
+  static native void jni_YGNodeStyleSetMaxWidthMaxContentJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetMaxWidthFitContentJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetMaxWidthStretchJNI(long nativePointer);
  static native long jni_YGNodeStyleGetMaxHeightJNI(long nativePointer);
  static native void jni_YGNodeStyleSetMaxHeightJNI(long nativePointer, float maxheight);
  static native void jni_YGNodeStyleSetMaxHeightPercentJNI(long nativePointer, float percent);
+  static native void jni_YGNodeStyleSetMaxHeightMaxContentJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetMaxHeightFitContentJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetMaxHeightStretchJNI(long nativePointer);
  static native float jni_YGNodeStyleGetAspectRatioJNI(long nativePointer);
  static native void jni_YGNodeStyleSetAspectRatioJNI(long nativePointer, float aspectRatio);
  static native float jni_YGNodeStyleGetGapJNI(long nativePointer, int gutter);
--- a/java/com/facebook/yoga/YogaNode.java
+++ b/java/com/facebook/yoga/YogaNode.java
@@ -124,6 +124,12 @@ public abstract class YogaNode implements YogaProps {

  public abstract void setFlexBasisAuto();

+  public abstract void setFlexBasisMaxContent();
+
+  public abstract void setFlexBasisFitContent();
+
+  public abstract void setFlexBasisStretch();
+
  public abstract YogaValue getMargin(YogaEdge edge);

  public abstract void setMargin(YogaEdge edge, float margin);
@@ -158,6 +164,12 @@ public abstract class YogaNode implements YogaProps {

  public abstract void setWidthAuto();

+  public abstract void setWidthMaxContent();
+
+  public abstract void setWidthFitContent();
+
+  public abstract void setWidthStretch();
+
  public abstract YogaValue getHeight();

  public abstract void setHeight(float height);
@@ -166,30 +178,60 @@ public abstract class YogaNode implements YogaProps {

  public abstract void setHeightAuto();

+  public abstract void setHeightMaxContent();
+
+  public abstract void setHeightFitContent();
+
+  public abstract void setHeightStretch();
+
  public abstract YogaValue getMinWidth();

  public abstract void setMinWidth(float minWidth);

  public abstract void setMinWidthPercent(float percent);

+  public abstract void setMinWidthMaxContent();
+
+  public abstract void setMinWidthFitContent();
+
+  public abstract void setMinWidthStretch();
+
  public abstract YogaValue getMinHeight();

  public abstract void setMinHeight(float minHeight);

  public abstract void setMinHeightPercent(float percent);

+  public abstract void setMinHeightMaxContent();
+
+  public abstract void setMinHeightFitContent();
+
+  public abstract void setMinHeightStretch();
+
  public abstract YogaValue getMaxWidth();

  public abstract void setMaxWidth(float maxWidth);

  public abstract void setMaxWidthPercent(float percent);

+  public abstract void setMaxWidthMaxContent();
+
+  public abstract void setMaxWidthFitContent();
+
+  public abstract void setMaxWidthStretch();
+
  public abstract YogaValue getMaxHeight();

  public abstract void setMaxHeight(float maxheight);

  public abstract void setMaxHeightPercent(float percent);

+  public abstract void setMaxHeightMaxContent();
+
+  public abstract void setMaxHeightFitContent();
+
+  public abstract void setMaxHeightStretch();
+
  public abstract float getAspectRatio();

  public abstract void setAspectRatio(float aspectRatio);
--- a/java/com/facebook/yoga/YogaNodeJNIBase.java
+++ b/java/com/facebook/yoga/YogaNodeJNIBase.java
@@ -373,6 +373,18 @@ public abstract class YogaNodeJNIBase extends YogaNode implements Cloneable {
    YogaNative.jni_YGNodeStyleSetFlexBasisAutoJNI(mNativePointer);
  }

+  public void setFlexBasisMaxContent() {
+    YogaNative.jni_YGNodeStyleSetFlexBasisMaxContentJNI(mNativePointer);
+  }
+
+  public void setFlexBasisFitContent() {
+    YogaNative.jni_YGNodeStyleSetFlexBasisFitContentJNI(mNativePointer);
+  }
+
+  public void setFlexBasisStretch() {
+    YogaNative.jni_YGNodeStyleSetFlexBasisStretchJNI(mNativePointer);
+  }
+
  public YogaValue getMargin(YogaEdge edge) {
    return valueFromLong(YogaNative.jni_YGNodeStyleGetMarginJNI(mNativePointer, edge.intValue()));
  }
@@ -441,6 +453,18 @@ public abstract class YogaNodeJNIBase extends YogaNode implements Cloneable {
    YogaNative.jni_YGNodeStyleSetWidthAutoJNI(mNativePointer);
  }

+  public void setWidthMaxContent() {
+    YogaNative.jni_YGNodeStyleSetWidthMaxContentJNI(mNativePointer);
+  }
+
+  public void setWidthFitContent() {
+    YogaNative.jni_YGNodeStyleSetWidthFitContentJNI(mNativePointer);
+  }
+
+  public void setWidthStretch() {
+    YogaNative.jni_YGNodeStyleSetWidthStretchJNI(mNativePointer);
+  }
+
  public YogaValue getHeight() {
    return valueFromLong(YogaNative.jni_YGNodeStyleGetHeightJNI(mNativePointer));
  }
@@ -457,6 +481,18 @@ public abstract class YogaNodeJNIBase extends YogaNode implements Cloneable {
    YogaNative.jni_YGNodeStyleSetHeightAutoJNI(mNativePointer);
  }

+  public void setHeightMaxContent() {
+    YogaNative.jni_YGNodeStyleSetHeightMaxContentJNI(mNativePointer);
+  }
+
+  public void setHeightFitContent() {
+    YogaNative.jni_YGNodeStyleSetHeightFitContentJNI(mNativePointer);
+  }
+
+  public void setHeightStretch() {
+    YogaNative.jni_YGNodeStyleSetHeightStretchJNI(mNativePointer);
+  }
+
  public YogaValue getMinWidth() {
    return valueFromLong(YogaNative.jni_YGNodeStyleGetMinWidthJNI(mNativePointer));
  }
@@ -469,6 +505,18 @@ public abstract class YogaNodeJNIBase extends YogaNode implements Cloneable {
    YogaNative.jni_YGNodeStyleSetMinWidthPercentJNI(mNativePointer, percent);
  }

+  public void setMinWidthMaxContent() {
+    YogaNative.jni_YGNodeStyleSetMinWidthMaxContentJNI(mNativePointer);
+  }
+
+  public void setMinWidthFitContent() {
+    YogaNative.jni_YGNodeStyleSetMinWidthFitContentJNI(mNativePointer);
+  }
+
+  public void setMinWidthStretch() {
+    YogaNative.jni_YGNodeStyleSetMinWidthStretchJNI(mNativePointer);
+  }
+
  public YogaValue getMinHeight() {
    return valueFromLong(YogaNative.jni_YGNodeStyleGetMinHeightJNI(mNativePointer));
  }
@@ -481,6 +529,18 @@ public abstract class YogaNodeJNIBase extends YogaNode implements Cloneable {
    YogaNative.jni_YGNodeStyleSetMinHeightPercentJNI(mNativePointer, percent);
  }

+  public void setMinHeightMaxContent() {
+    YogaNative.jni_YGNodeStyleSetMinHeightMaxContentJNI(mNativePointer);
+  }
+
+  public void setMinHeightFitContent() {
+    YogaNative.jni_YGNodeStyleSetMinHeightFitContentJNI(mNativePointer);
+  }
+
+  public void setMinHeightStretch() {
+    YogaNative.jni_YGNodeStyleSetMinHeightStretchJNI(mNativePointer);
+  }
+
  public YogaValue getMaxWidth() {
    return valueFromLong(YogaNative.jni_YGNodeStyleGetMaxWidthJNI(mNativePointer));
  }
@@ -493,6 +553,18 @@ public abstract class YogaNodeJNIBase extends YogaNode implements Cloneable {
    YogaNative.jni_YGNodeStyleSetMaxWidthPercentJNI(mNativePointer, percent);
  }

+  public void setMaxWidthMaxContent() {
+    YogaNative.jni_YGNodeStyleSetMaxWidthMaxContentJNI(mNativePointer);
+  }
+
+  public void setMaxWidthFitContent() {
+    YogaNative.jni_YGNodeStyleSetMaxWidthFitContentJNI(mNativePointer);
+  }
+
+  public void setMaxWidthStretch() {
+    YogaNative.jni_YGNodeStyleSetMaxWidthStretchJNI(mNativePointer);
+  }
+
  public YogaValue getMaxHeight() {
    return valueFromLong(YogaNative.jni_YGNodeStyleGetMaxHeightJNI(mNativePointer));
  }
@@ -505,6 +577,18 @@ public abstract class YogaNodeJNIBase extends YogaNode implements Cloneable {
    YogaNative.jni_YGNodeStyleSetMaxHeightPercentJNI(mNativePointer, percent);
  }

+  public void setMaxHeightMaxContent() {
+    YogaNative.jni_YGNodeStyleSetMaxHeightMaxContentJNI(mNativePointer);
+  }
+
+  public void setMaxHeightFitContent() {
+    YogaNative.jni_YGNodeStyleSetMaxHeightFitContentJNI(mNativePointer);
+  }
+
+  public void setMaxHeightStretch() {
+    YogaNative.jni_YGNodeStyleSetMaxHeightStretchJNI(mNativePointer);
+  }
+
  public float getAspectRatio() {
    return YogaNative.jni_YGNodeStyleGetAspectRatioJNI(mNativePointer);
  }
--- a/java/com/facebook/yoga/YogaProps.java
+++ b/java/com/facebook/yoga/YogaProps.java
@@ -15,15 +15,33 @@ public interface YogaProps {

  void setWidthPercent(float percent);

+  void setWidthAuto();
+
+  void setWidthMaxContent();
+
+  void setWidthFitContent();
+
+  void setWidthStretch();
+
  void setMinWidth(float minWidth);

  void setMinWidthPercent(float percent);

+  void setMinWidthMaxContent();
+
+  void setMinWidthFitContent();
+
+  void setMinWidthStretch();
+
  void setMaxWidth(float maxWidth);

  void setMaxWidthPercent(float percent);

-  void setWidthAuto();
+  void setMaxWidthMaxContent();
+
+  void setMaxWidthFitContent();
+
+  void setMaxWidthStretch();

  /* Height properties */

@@ -31,15 +49,33 @@ public interface YogaProps {

  void setHeightPercent(float percent);

+  void setHeightAuto();
+
+  void setHeightMaxContent();
+
+  void setHeightFitContent();
+
+  void setHeightStretch();
+
  void setMinHeight(float minHeight);

  void setMinHeightPercent(float percent);

+  void setMinHeightMaxContent();
+
+  void setMinHeightFitContent();
+
+  void setMinHeightStretch();
+
  void setMaxHeight(float maxHeight);

  void setMaxHeightPercent(float percent);

-  void setHeightAuto();
+  void setMaxHeightMaxContent();
+
+  void setMaxHeightFitContent();
+
+  void setMaxHeightStretch();

  /* Margin properties */

@@ -81,6 +117,12 @@ public interface YogaProps {

  void setFlexBasis(float flexBasis);

+  void setFlexBasisMaxContent();
+
+  void setFlexBasisFitContent();
+
+  void setFlexBasisStretch();
+
  void setFlexDirection(YogaFlexDirection direction);

  void setFlexGrow(float flexGrow);
--- a/java/com/facebook/yoga/YogaUnit.java
+++ b/java/com/facebook/yoga/YogaUnit.java
@@ -13,7 +13,10 @@ public enum YogaUnit {
  UNDEFINED(0),
  POINT(1),
  PERCENT(2),
-  AUTO(3);
+  AUTO(3),
+  MAX_CONTENT(4),
+  FIT_CONTENT(5),
+  STRETCH(6);

  private final int mIntValue;

@@ -31,6 +34,9 @@ public enum YogaUnit {
      case 1: return POINT;
      case 2: return PERCENT;
      case 3: return AUTO;
+      case 4: return MAX_CONTENT;
+      case 5: return FIT_CONTENT;
+      case 6: return STRETCH;
      default: throw new IllegalArgumentException("Unknown enum value: " + value);
    }
  }
--- a/java/jni/YGJNIVanilla.cpp
+++ b/java/jni/YGJNIVanilla.cpp
@@ -429,6 +429,28 @@ static void jni_YGNodeCopyStyleJNI(
    YGNodeStyleSet##name##Auto(_jlong2YGNodeRef(nativePointer)); \
  }

+#define YG_NODE_JNI_STYLE_UNIT_PROP_AUTO_INTRINSIC(name) \
+  YG_NODE_JNI_STYLE_UNIT_PROP_AUTO(name)                 \
+  YG_NODE_JNI_STYLE_UNIT_INTRINSIC(name)
+
+#define YG_NODE_JNI_STYLE_UNIT_PROP_INTRINSIC(name) \
+  YG_NODE_JNI_STYLE_UNIT_PROP(name)                 \
+  YG_NODE_JNI_STYLE_UNIT_INTRINSIC(name)
+
+#define YG_NODE_JNI_STYLE_UNIT_INTRINSIC(name)                         \
+  static void jni_YGNodeStyleSet##name##MaxContentJNI(                 \
+      JNIEnv* /*env*/, jobject /*obj*/, jlong nativePointer) {         \
+    YGNodeStyleSet##name##MaxContent(_jlong2YGNodeRef(nativePointer)); \
+  }                                                                    \
+  static void jni_YGNodeStyleSet##name##FitContentJNI(                 \
+      JNIEnv* /*env*/, jobject /*obj*/, jlong nativePointer) {         \
+    YGNodeStyleSet##name##FitContent(_jlong2YGNodeRef(nativePointer)); \
+  }                                                                    \
+  static void jni_YGNodeStyleSet##name##StretchJNI(                    \
+      JNIEnv* /*env*/, jobject /*obj*/, jlong nativePointer) {         \
+    YGNodeStyleSet##name##Stretch(_jlong2YGNodeRef(nativePointer));    \
+  }
+
 #define YG_NODE_JNI_STYLE_EDGE_UNIT_PROP(name)                            \
  static jlong jni_YGNodeStyleGet##name##JNI(                             \
      JNIEnv* /*env*/, jobject /*obj*/, jlong nativePointer, jint edge) { \
@@ -483,13 +505,13 @@ YG_NODE_JNI_STYLE_PROP(jfloat, float, Flex);
 YG_NODE_JNI_STYLE_PROP(jfloat, float, FlexGrow);
 YG_NODE_JNI_STYLE_PROP(jfloat, float, FlexShrink);

-YG_NODE_JNI_STYLE_UNIT_PROP_AUTO(FlexBasis);
-YG_NODE_JNI_STYLE_UNIT_PROP_AUTO(Width);
-YG_NODE_JNI_STYLE_UNIT_PROP(MinWidth);
-YG_NODE_JNI_STYLE_UNIT_PROP(MaxWidth);
-YG_NODE_JNI_STYLE_UNIT_PROP_AUTO(Height);
-YG_NODE_JNI_STYLE_UNIT_PROP(MinHeight);
-YG_NODE_JNI_STYLE_UNIT_PROP(MaxHeight);
+YG_NODE_JNI_STYLE_UNIT_PROP_AUTO_INTRINSIC(FlexBasis);
+YG_NODE_JNI_STYLE_UNIT_PROP_AUTO_INTRINSIC(Width);
+YG_NODE_JNI_STYLE_UNIT_PROP_INTRINSIC(MinWidth);
+YG_NODE_JNI_STYLE_UNIT_PROP_INTRINSIC(MaxWidth);
+YG_NODE_JNI_STYLE_UNIT_PROP_AUTO_INTRINSIC(Height);
+YG_NODE_JNI_STYLE_UNIT_PROP_INTRINSIC(MinHeight);
+YG_NODE_JNI_STYLE_UNIT_PROP_INTRINSIC(MaxHeight);

 YG_NODE_JNI_STYLE_EDGE_UNIT_PROP_AUTO(Position);

@@ -870,6 +892,15 @@ static JNINativeMethod methods[] = {
    {"jni_YGNodeStyleSetFlexBasisAutoJNI",
     "(J)V",
     (void*)jni_YGNodeStyleSetFlexBasisAutoJNI},
+    {"jni_YGNodeStyleSetFlexBasisMaxContentJNI",
+     "(J)V",
+     (void*)jni_YGNodeStyleSetFlexBasisMaxContentJNI},
+    {"jni_YGNodeStyleSetFlexBasisFitContentJNI",
+     "(J)V",
+     (void*)jni_YGNodeStyleSetFlexBasisFitContentJNI},
+    {"jni_YGNodeStyleSetFlexBasisStretchJNI",
+     "(J)V",
+     (void*)jni_YGNodeStyleSetFlexBasisStretchJNI},
    {"jni_YGNodeStyleGetMarginJNI",
     "(JI)J",
     (void*)jni_YGNodeStyleGetMarginJNI},
@@ -917,6 +948,15 @@ static JNINativeMethod methods[] = {
    {"jni_YGNodeStyleSetWidthAutoJNI",
     "(J)V",
     (void*)jni_YGNodeStyleSetWidthAutoJNI},
+    {"jni_YGNodeStyleSetWidthMaxContentJNI",
+     "(J)V",
+     (void*)jni_YGNodeStyleSetWidthMaxContentJNI},
+    {"jni_YGNodeStyleSetWidthFitContentJNI",
+     "(J)V",
+     (void*)jni_YGNodeStyleSetWidthFitContentJNI},
+    {"jni_YGNodeStyleSetWidthStretchJNI",
+     "(J)V",
+     (void*)jni_YGNodeStyleSetWidthStretchJNI},
    {"jni_YGNodeStyleGetHeightJNI", "(J)J", (void*)jni_YGNodeStyleGetHeightJNI},
    {"jni_YGNodeStyleSetHeightJNI",
     "(JF)V",
@@ -927,6 +967,15 @@ static JNINativeMethod methods[] = {
    {"jni_YGNodeStyleSetHeightAutoJNI",
     "(J)V",
     (void*)jni_YGNodeStyleSetHeightAutoJNI},
+    {"jni_YGNodeStyleSetHeightMaxContentJNI",
+     "(J)V",
+     (void*)jni_YGNodeStyleSetHeightMaxContentJNI},
+    {"jni_YGNodeStyleSetHeightFitContentJNI",
+     "(J)V",
+     (void*)jni_YGNodeStyleSetHeightFitContentJNI},
+    {"jni_YGNodeStyleSetHeightStretchJNI",
+     "(J)V",
+     (void*)jni_YGNodeStyleSetHeightStretchJNI},
    {"jni_YGNodeStyleGetMinWidthJNI",
     "(J)J",
     (void*)jni_YGNodeStyleGetMinWidthJNI},
@@ -936,6 +985,15 @@ static JNINativeMethod methods[] = {
    {"jni_YGNodeStyleSetMinWidthPercentJNI",
     "(JF)V",
     (void*)jni_YGNodeStyleSetMinWidthPercentJNI},
+    {"jni_YGNodeStyleSetMinWidthMaxContentJNI",
+     "(J)V",
+     (void*)jni_YGNodeStyleSetMinWidthMaxContentJNI},
+    {"jni_YGNodeStyleSetMinWidthFitContentJNI",
+     "(J)V",
+     (void*)jni_YGNodeStyleSetMinWidthFitContentJNI},
+    {"jni_YGNodeStyleSetMinWidthStretchJNI",
+     "(J)V",
+     (void*)jni_YGNodeStyleSetMinWidthStretchJNI},
    {"jni_YGNodeStyleGetMinHeightJNI",
     "(J)J",
     (void*)jni_YGNodeStyleGetMinHeightJNI},
@@ -945,6 +1003,15 @@ static JNINativeMethod methods[] = {
    {"jni_YGNodeStyleSetMinHeightPercentJNI",
     "(JF)V",
     (void*)jni_YGNodeStyleSetMinHeightPercentJNI},
+    {"jni_YGNodeStyleSetMinHeightMaxContentJNI",
+     "(J)V",
+     (void*)jni_YGNodeStyleSetMinHeightMaxContentJNI},
+    {"jni_YGNodeStyleSetMinHeightFitContentJNI",
+     "(J)V",
+     (void*)jni_YGNodeStyleSetMinHeightFitContentJNI},
+    {"jni_YGNodeStyleSetMinHeightStretchJNI",
+     "(J)V",
+     (void*)jni_YGNodeStyleSetMinHeightStretchJNI},
    {"jni_YGNodeStyleGetMaxWidthJNI",
     "(J)J",
     (void*)jni_YGNodeStyleGetMaxWidthJNI},
@@ -954,6 +1021,15 @@ static JNINativeMethod methods[] = {
    {"jni_YGNodeStyleSetMaxWidthPercentJNI",
     "(JF)V",
     (void*)jni_YGNodeStyleSetMaxWidthPercentJNI},
+    {"jni_YGNodeStyleSetMaxWidthMaxContentJNI",
+     "(J)V",
+     (void*)jni_YGNodeStyleSetMaxWidthMaxContentJNI},
+    {"jni_YGNodeStyleSetMaxWidthFitContentJNI",
+     "(J)V",
+     (void*)jni_YGNodeStyleSetMaxWidthFitContentJNI},
+    {"jni_YGNodeStyleSetMaxWidthStretchJNI",
+     "(J)V",
+     (void*)jni_YGNodeStyleSetMaxWidthStretchJNI},
    {"jni_YGNodeStyleGetMaxHeightJNI",
     "(J)J",
     (void*)jni_YGNodeStyleGetMaxHeightJNI},
@@ -963,6 +1039,15 @@ static JNINativeMethod methods[] = {
    {"jni_YGNodeStyleSetMaxHeightPercentJNI",
     "(JF)V",
     (void*)jni_YGNodeStyleSetMaxHeightPercentJNI},
+    {"jni_YGNodeStyleSetMaxHeightMaxContentJNI",
+     "(J)V",
+     (void*)jni_YGNodeStyleSetMaxHeightMaxContentJNI},
+    {"jni_YGNodeStyleSetMaxHeightFitContentJNI",
+     "(J)V",
+     (void*)jni_YGNodeStyleSetMaxHeightFitContentJNI},
+    {"jni_YGNodeStyleSetMaxHeightStretchJNI",
+     "(J)V",
+     (void*)jni_YGNodeStyleSetMaxHeightStretchJNI},
    {"jni_YGNodeStyleGetAspectRatioJNI",
     "(J)F",
     (void*)jni_YGNodeStyleGetAspectRatioJNI},
--- a/java/tests/generated/com/facebook/yoga/YGIntrinsicSizeTest.java
+++ b/java/tests/generated/com/facebook/yoga/YGIntrinsicSizeTest.java
--- a/javascript/package.json
+++ b/javascript/package.json
@@ -1,6 +1,6 @@
 {
  "name": "yoga-layout",
-  "version": "3.2.1",
+  "version": "0.0.0",
  "description": "An embeddable and performant flexbox layout engine with bindings for multiple languages",
  "license": "MIT",
  "author": "Meta Open Source",
--- a/javascript/src/Node.cpp
+++ b/javascript/src/Node.cpp
@@ -160,6 +160,18 @@ void Node::setFlexBasisAuto() {
  YGNodeStyleSetFlexBasisAuto(m_node);
 }

+void Node::setFlexBasisMaxContent() {
+  YGNodeStyleSetFlexBasisMaxContent(m_node);
+}
+
+void Node::setFlexBasisFitContent() {
+  YGNodeStyleSetFlexBasisFitContent(m_node);
+}
+
+void Node::setFlexBasisStretch() {
+  YGNodeStyleSetFlexBasisStretch(m_node);
+}
+
 void Node::setFlexGrow(double flexGrow) {
  YGNodeStyleSetFlexGrow(m_node, flexGrow);
 }
@@ -180,6 +192,18 @@ void Node::setWidthAuto() {
  YGNodeStyleSetWidthAuto(m_node);
 }

+void Node::setWidthMaxContent() {
+  YGNodeStyleSetWidthMaxContent(m_node);
+}
+
+void Node::setWidthFitContent() {
+  YGNodeStyleSetWidthFitContent(m_node);
+}
+
+void Node::setWidthStretch() {
+  YGNodeStyleSetWidthStretch(m_node);
+}
+
 void Node::setHeight(double height) {
  YGNodeStyleSetHeight(m_node, height);
 }
@@ -192,6 +216,18 @@ void Node::setHeightAuto() {
  YGNodeStyleSetHeightAuto(m_node);
 }

+void Node::setHeightMaxContent() {
+  YGNodeStyleSetHeightMaxContent(m_node);
+}
+
+void Node::setHeightFitContent() {
+  YGNodeStyleSetHeightFitContent(m_node);
+}
+
+void Node::setHeightStretch() {
+  YGNodeStyleSetHeightStretch(m_node);
+}
+
 void Node::setMinWidth(double minWidth) {
  YGNodeStyleSetMinWidth(m_node, minWidth);
 }
@@ -200,6 +236,18 @@ void Node::setMinWidthPercent(double minWidth) {
  YGNodeStyleSetMinWidthPercent(m_node, minWidth);
 }

+void Node::setMinWidthMaxContent() {
+  YGNodeStyleSetMinWidthMaxContent(m_node);
+}
+
+void Node::setMinWidthFitContent() {
+  YGNodeStyleSetMinWidthFitContent(m_node);
+}
+
+void Node::setMinWidthStretch() {
+  YGNodeStyleSetMinWidthStretch(m_node);
+}
+
 void Node::setMinHeight(double minHeight) {
  YGNodeStyleSetMinHeight(m_node, minHeight);
 }
@@ -208,6 +256,18 @@ void Node::setMinHeightPercent(double minHeight) {
  YGNodeStyleSetMinHeightPercent(m_node, minHeight);
 }

+void Node::setMinHeightMaxContent() {
+  YGNodeStyleSetMinHeightMaxContent(m_node);
+}
+
+void Node::setMinHeightFitContent() {
+  YGNodeStyleSetMinHeightFitContent(m_node);
+}
+
+void Node::setMinHeightStretch() {
+  YGNodeStyleSetMinHeightStretch(m_node);
+}
+
 void Node::setMaxWidth(double maxWidth) {
  YGNodeStyleSetMaxWidth(m_node, maxWidth);
 }
@@ -216,6 +276,18 @@ void Node::setMaxWidthPercent(double maxWidth) {
  YGNodeStyleSetMaxWidthPercent(m_node, maxWidth);
 }

+void Node::setMaxWidthMaxContent() {
+  YGNodeStyleSetMaxWidthMaxContent(m_node);
+}
+
+void Node::setMaxWidthFitContent() {
+  YGNodeStyleSetMaxWidthFitContent(m_node);
+}
+
+void Node::setMaxWidthStretch() {
+  YGNodeStyleSetMaxWidthStretch(m_node);
+}
+
 void Node::setMaxHeight(double maxHeight) {
  YGNodeStyleSetMaxHeight(m_node, maxHeight);
 }
@@ -224,6 +296,18 @@ void Node::setMaxHeightPercent(double maxHeight) {
  YGNodeStyleSetMaxHeightPercent(m_node, maxHeight);
 }

+void Node::setMaxHeightMaxContent() {
+  YGNodeStyleSetMaxHeightMaxContent(m_node);
+}
+
+void Node::setMaxHeightFitContent() {
+  YGNodeStyleSetMaxHeightFitContent(m_node);
+}
+
+void Node::setMaxHeightStretch() {
+  YGNodeStyleSetMaxHeightStretch(m_node);
+}
+
 void Node::setAspectRatio(double aspectRatio) {
  YGNodeStyleSetAspectRatio(m_node, aspectRatio);
 }
--- a/javascript/src/Node.h
+++ b/javascript/src/Node.h
@@ -97,25 +97,46 @@ class Node {
  void setFlexBasis(double flexBasis);
  void setFlexBasisPercent(double flexBasis);
  void setFlexBasisAuto();
+  void setFlexBasisMaxContent();
+  void setFlexBasisFitContent();
+  void setFlexBasisStretch();
  void setFlexGrow(double flexGrow);
  void setFlexShrink(double flexShrink);

  void setWidth(double width);
  void setWidthPercent(double width);
  void setWidthAuto();
+  void setWidthMaxContent();
+  void setWidthFitContent();
+  void setWidthStretch();
  void setHeight(double height);
  void setHeightPercent(double height);
  void setHeightAuto();
+  void setHeightMaxContent();
+  void setHeightFitContent();
+  void setHeightStretch();

  void setMinWidth(double minWidth);
  void setMinWidthPercent(double minWidth);
+  void setMinWidthMaxContent();
+  void setMinWidthFitContent();
+  void setMinWidthStretch();
  void setMinHeight(double minHeight);
  void setMinHeightPercent(double minHeight);
+  void setMinHeightMaxContent();
+  void setMinHeightFitContent();
+  void setMinHeightStretch();

  void setMaxWidth(double maxWidth);
  void setMaxWidthPercent(double maxWidth);
+  void setMaxWidthMaxContent();
+  void setMaxWidthFitContent();
+  void setMaxWidthStretch();
  void setMaxHeight(double maxHeight);
  void setMaxHeightPercent(double maxHeight);
+  void setMaxHeightMaxContent();
+  void setMaxHeightFitContent();
+  void setMaxHeightStretch();

  void setAspectRatio(double aspectRatio);

--- a/javascript/src/embind.cpp
+++ b/javascript/src/embind.cpp
@@ -90,25 +90,46 @@ EMSCRIPTEN_BINDINGS(YOGA_LAYOUT) {
      .function("setFlexBasis", &Node::setFlexBasis)
      .function("setFlexBasisPercent", &Node::setFlexBasisPercent)
      .function("setFlexBasisAuto", &Node::setFlexBasisAuto)
+      .function("setFlexBasisMaxContent", &Node::setFlexBasisMaxContent)
+      .function("setFlexBasisFitContent", &Node::setFlexBasisFitContent)
+      .function("setFlexBasisStretch", &Node::setFlexBasisStretch)
      .function("setFlexGrow", &Node::setFlexGrow)
      .function("setFlexShrink", &Node::setFlexShrink)

      .function("setWidth", &Node::setWidth)
      .function("setWidthPercent", &Node::setWidthPercent)
      .function("setWidthAuto", &Node::setWidthAuto)
+      .function("setWidthMaxContent", &Node::setWidthMaxContent)
+      .function("setWidthFitContent", &Node::setWidthFitContent)
+      .function("setWidthStretch", &Node::setWidthStretch)
      .function("setHeight", &Node::setHeight)
      .function("setHeightPercent", &Node::setHeightPercent)
      .function("setHeightAuto", &Node::setHeightAuto)
+      .function("setHeightMaxContent", &Node::setHeightMaxContent)
+      .function("setHeightFitContent", &Node::setHeightFitContent)
+      .function("setHeightStretch", &Node::setHeightStretch)

      .function("setMinWidth", &Node::setMinWidth)
      .function("setMinWidthPercent", &Node::setMinWidthPercent)
+      .function("setMinWidthMaxContent", &Node::setMinWidthMaxContent)
+      .function("setMinWidthFitContent", &Node::setMinWidthFitContent)
+      .function("setMinWidthStretch", &Node::setMinWidthStretch)
      .function("setMinHeight", &Node::setMinHeight)
      .function("setMinHeightPercent", &Node::setMinHeightPercent)
+      .function("setMinHeightMaxContent", &Node::setMinHeightMaxContent)
+      .function("setMinHeightFitContent", &Node::setMinHeightFitContent)
+      .function("setMinHeightStretch", &Node::setMinHeightStretch)

      .function("setMaxWidth", &Node::setMaxWidth)
      .function("setMaxWidthPercent", &Node::setMaxWidthPercent)
+      .function("setMaxWidthMaxContent", &Node::setMaxWidthMaxContent)
+      .function("setMaxWidthFitContent", &Node::setMaxWidthFitContent)
+      .function("setMaxWidthStretch", &Node::setMaxWidthStretch)
      .function("setMaxHeight", &Node::setMaxHeight)
      .function("setMaxHeightPercent", &Node::setMaxHeightPercent)
+      .function("setMaxHeightMaxContent", &Node::setMaxHeightMaxContent)
+      .function("setMaxHeightFitContent", &Node::setMaxHeightFitContent)
+      .function("setMaxHeightStretch", &Node::setMaxHeightStretch)

      .function("setBoxSizing", &Node::setBoxSizing)

--- a/javascript/src/generated/YGEnums.ts
+++ b/javascript/src/generated/YGEnums.ts
@@ -125,6 +125,9 @@ export enum Unit {
  Point = 1,
  Percent = 2,
  Auto = 3,
+  MaxContent = 4,
+  FitContent = 5,
+  Stretch = 6,
 }

 export enum Wrap {
@@ -203,6 +206,9 @@ const constants = {
  UNIT_POINT: Unit.Point,
  UNIT_PERCENT: Unit.Percent,
  UNIT_AUTO: Unit.Auto,
+  UNIT_MAX_CONTENT: Unit.MaxContent,
+  UNIT_FIT_CONTENT: Unit.FitContent,
+  UNIT_STRETCH: Unit.Stretch,
  WRAP_NO_WRAP: Wrap.NoWrap,
  WRAP_WRAP: Wrap.Wrap,
  WRAP_WRAP_REVERSE: Wrap.WrapReverse,
--- a/javascript/src/wrapAssembly.ts
+++ b/javascript/src/wrapAssembly.ts
@@ -134,17 +134,41 @@ export type Node = {
  setDirection(direction: Direction): void;
  setDisplay(display: Display): void;
  setFlex(flex: number | undefined): void;
-  setFlexBasis(flexBasis: number | 'auto' | `${number}%` | undefined): void;
+  setFlexBasis(
+    flexBasis:
+      | number
+      | 'auto'
+      | 'fit-content'
+      | 'max-content'
+      | 'stretch'
+      | `${number}%`
+      | undefined,
+  ): void;
  setFlexBasisPercent(flexBasis: number | undefined): void;
  setFlexBasisAuto(): void;
+  setFlexBasisFitContent(): void;
+  setFlexBasisMaxContent(): void;
+  setFlexBasisStretch(): void;
  setFlexDirection(flexDirection: FlexDirection): void;
  setFlexGrow(flexGrow: number | undefined): void;
  setFlexShrink(flexShrink: number | undefined): void;
  setFlexWrap(flexWrap: Wrap): void;
-  setHeight(height: number | 'auto' | `${number}%` | undefined): void;
+  setHeight(
+    height:
+      | number
+      | 'auto'
+      | 'fit-content'
+      | 'max-content'
+      | 'stretch'
+      | `${number}%`
+      | undefined,
+  ): void;
  setIsReferenceBaseline(isReferenceBaseline: boolean): void;
  setHeightAuto(): void;
+  setHeightFitContent(): void;
+  setHeightMaxContent(): void;
  setHeightPercent(height: number | undefined): void;
+  setHeightStretch(): void;
  setJustifyContent(justifyContent: Justify): void;
  setGap(gutter: Gutter, gapLength: number | `${number}%` | undefined): Value;
  setGapPercent(gutter: Gutter, gapLength: number | undefined): Value;
@@ -154,16 +178,60 @@ export type Node = {
  ): void;
  setMarginAuto(edge: Edge): void;
  setMarginPercent(edge: Edge, margin: number | undefined): void;
-  setMaxHeight(maxHeight: number | `${number}%` | undefined): void;
+  setMaxHeight(
+    maxHeight:
+      | number
+      | 'fit-content'
+      | 'max-content'
+      | 'stretch'
+      | `${number}%`
+      | undefined,
+  ): void;
+  setMaxHeightFitContent(): void;
+  setMaxHeightMaxContent(): void;
  setMaxHeightPercent(maxHeight: number | undefined): void;
-  setMaxWidth(maxWidth: number | `${number}%` | undefined): void;
+  setMaxHeightStretch(): void;
+  setMaxWidth(
+    maxWidth:
+      | number
+      | 'fit-content'
+      | 'max-content'
+      | 'stretch'
+      | `${number}%`
+      | undefined,
+  ): void;
+  setMaxWidthFitContent(): void;
+  setMaxWidthMaxContent(): void;
  setMaxWidthPercent(maxWidth: number | undefined): void;
+  setMaxWidthStretch(): void;
  setDirtiedFunc(dirtiedFunc: DirtiedFunction | null): void;
  setMeasureFunc(measureFunc: MeasureFunction | null): void;
-  setMinHeight(minHeight: number | `${number}%` | undefined): void;
+  setMinHeight(
+    minHeight:
+      | number
+      | 'fit-content'
+      | 'max-content'
+      | 'stretch'
+      | `${number}%`
+      | undefined,
+  ): void;
+  setMinHeightFitContent(): void;
+  setMinHeightMaxContent(): void;
  setMinHeightPercent(minHeight: number | undefined): void;
-  setMinWidth(minWidth: number | `${number}%` | undefined): void;
+  setMinHeightStretch(): void;
+  setMinWidth(
+    minWidth:
+      | number
+      | 'fit-content'
+      | 'max-content'
+      | 'stretch'
+      | `${number}%`
+      | undefined,
+  ): void;
+  setMinWidthFitContent(): void;
+  setMinWidthMaxContent(): void;
  setMinWidthPercent(minWidth: number | undefined): void;
+  setMinWidthStretch(): void;
  setOverflow(overflow: Overflow): void;
  setPadding(edge: Edge, padding: number | `${number}%` | undefined): void;
  setPaddingPercent(edge: Edge, padding: number | undefined): void;
@@ -172,9 +240,21 @@ export type Node = {
  setPositionType(positionType: PositionType): void;
  setPositionAuto(edge: Edge): void;
  setBoxSizing(boxSizing: BoxSizing): void;
-  setWidth(width: number | 'auto' | `${number}%` | undefined): void;
+  setWidth(
+    width:
+      | number
+      | 'auto'
+      | 'fit-content'
+      | 'max-content'
+      | 'stretch'
+      | `${number}%`
+      | undefined,
+  ): void;
  setWidthAuto(): void;
+  setWidthFitContent(): void;
+  setWidthMaxContent(): void;
  setWidthPercent(width: number | undefined): void;
+  setWidthStretch(): void;
  unsetDirtiedFunc(): void;
  unsetMeasureFunc(): void;
  setAlwaysFormsContainingBlock(alwaysFormsContainingBlock: boolean): void;
@@ -220,6 +300,9 @@ export default function wrapAssembly(lib: any): Yoga {
      [Unit.Point]: lib.Node.prototype[fnName],
      [Unit.Percent]: lib.Node.prototype[`${fnName}Percent`],
      [Unit.Auto]: lib.Node.prototype[`${fnName}Auto`],
+      [Unit.MaxContent]: lib.Node.prototype[`${fnName}MaxContent`],
+      [Unit.FitContent]: lib.Node.prototype[`${fnName}FitContent`],
+      [Unit.Stretch]: lib.Node.prototype[`${fnName}Stretch`],
    };

    patch(lib.Node.prototype, fnName, function (original, ...args) {
@@ -232,6 +315,15 @@ export default function wrapAssembly(lib: any): Yoga {
      if (value === 'auto') {
        unit = Unit.Auto;
        asNumber = undefined;
+      } else if (value == 'max-content') {
+        unit = Unit.MaxContent;
+        asNumber = undefined;
+      } else if (value == 'fit-content') {
+        unit = Unit.FitContent;
+        asNumber = undefined;
+      } else if (value == 'stretch') {
+        unit = Unit.Stretch;
+        asNumber = undefined;
      } else if (typeof value === 'object') {
        unit = value.unit;
        asNumber = value.valueOf();
--- a/javascript/tests/generated/YGIntrinsicSizeTest.test.ts
+++ b/javascript/tests/generated/YGIntrinsicSizeTest.test.ts
--- a/tests/StyleValuePoolTest.cpp
+++ b/tests/StyleValuePoolTest.cpp
@@ -128,4 +128,19 @@ TEST(StyleValuePool, store_undefined_after_large_int) {
  EXPECT_EQ(pool.getLength(handle), StyleLength::undefined());
 }

+TEST(StyleValuePool, store_keywords) {
+  StyleValuePool pool;
+  StyleValueHandle handleMaxContent;
+  StyleValueHandle handleFitContent;
+  StyleValueHandle handleStretch;
+
+  pool.store(handleMaxContent, StyleSizeLength::ofMaxContent());
+  pool.store(handleFitContent, StyleSizeLength::ofFitContent());
+  pool.store(handleStretch, StyleSizeLength::ofStretch());
+
+  EXPECT_EQ(pool.getSize(handleMaxContent), StyleSizeLength::ofMaxContent());
+  EXPECT_EQ(pool.getSize(handleFitContent), StyleSizeLength::ofFitContent());
+  EXPECT_EQ(pool.getSize(handleStretch), StyleSizeLength::ofStretch());
+}
+
 } // namespace facebook::yoga
--- a/tests/generated/YGIntrinsicSizeTest.cpp
+++ b/tests/generated/YGIntrinsicSizeTest.cpp
--- a/website/package.json
+++ b/website/package.json
@@ -27,7 +27,7 @@
    "react": "^18.3.0",
    "react-dom": "^18.3.0",
    "react-live": "^4.1.5",
-    "yoga-layout": "3.2.1"
+    "yoga-layout": "0.0.0"
  },
  "devDependencies": {
    "@docusaurus/module-type-aliases": "3.6.0",
--- a/yarn.lock
+++ b/yarn.lock
--- a/yoga/YGEnums.cpp
+++ b/yoga/YGEnums.cpp
@@ -245,6 +245,12 @@ const char* YGUnitToString(const YGUnit value) {
      return "percent";
    case YGUnitAuto:
      return "auto";
+    case YGUnitMaxContent:
+      return "max-content";
+    case YGUnitFitContent:
+      return "fit-content";
+    case YGUnitStretch:
+      return "stretch";
  }
  return "unknown";
 }
--- a/yoga/YGEnums.h
+++ b/yoga/YGEnums.h
@@ -131,7 +131,10 @@ YG_ENUM_DECL(
    YGUnitUndefined,
    YGUnitPoint,
    YGUnitPercent,
-    YGUnitAuto)
+    YGUnitAuto,
+    YGUnitMaxContent,
+    YGUnitFitContent,
+    YGUnitStretch)

 YG_ENUM_DECL(
    YGWrap,
--- a/yoga/YGNodeStyle.cpp
+++ b/yoga/YGNodeStyle.cpp
@@ -177,19 +177,34 @@ float YGNodeStyleGetFlexShrink(const YGNodeConstRef nodeRef) {

 void YGNodeStyleSetFlexBasis(const YGNodeRef node, const float flexBasis) {
  updateStyle<&Style::flexBasis, &Style::setFlexBasis>(
-      node, StyleLength::points(flexBasis));
+      node, StyleSizeLength::points(flexBasis));
 }

 void YGNodeStyleSetFlexBasisPercent(
    const YGNodeRef node,
    const float flexBasisPercent) {
  updateStyle<&Style::flexBasis, &Style::setFlexBasis>(
-      node, StyleLength::percent(flexBasisPercent));
+      node, StyleSizeLength::percent(flexBasisPercent));
 }

 void YGNodeStyleSetFlexBasisAuto(const YGNodeRef node) {
  updateStyle<&Style::flexBasis, &Style::setFlexBasis>(
-      node, StyleLength::ofAuto());
+      node, StyleSizeLength::ofAuto());
+}
+
+void YGNodeStyleSetFlexBasisMaxContent(const YGNodeRef node) {
+  updateStyle<&Style::flexBasis, &Style::setFlexBasis>(
+      node, StyleSizeLength::ofMaxContent());
+}
+
+void YGNodeStyleSetFlexBasisFitContent(const YGNodeRef node) {
+  updateStyle<&Style::flexBasis, &Style::setFlexBasis>(
+      node, StyleSizeLength::ofFitContent());
+}
+
+void YGNodeStyleSetFlexBasisStretch(const YGNodeRef node) {
+  updateStyle<&Style::flexBasis, &Style::setFlexBasis>(
+      node, StyleSizeLength::ofStretch());
 }

 YGValue YGNodeStyleGetFlexBasis(const YGNodeConstRef node) {
@@ -308,17 +323,32 @@ YGBoxSizing YGNodeStyleGetBoxSizing(const YGNodeConstRef node) {

 void YGNodeStyleSetWidth(YGNodeRef node, float points) {
  updateStyle<&Style::dimension, &Style::setDimension>(
-      node, Dimension::Width, StyleLength::points(points));
+      node, Dimension::Width, StyleSizeLength::points(points));
 }

 void YGNodeStyleSetWidthPercent(YGNodeRef node, float percent) {
  updateStyle<&Style::dimension, &Style::setDimension>(
-      node, Dimension::Width, StyleLength::percent(percent));
+      node, Dimension::Width, StyleSizeLength::percent(percent));
 }

 void YGNodeStyleSetWidthAuto(YGNodeRef node) {
  updateStyle<&Style::dimension, &Style::setDimension>(
-      node, Dimension::Width, StyleLength::ofAuto());
+      node, Dimension::Width, StyleSizeLength::ofAuto());
+}
+
+void YGNodeStyleSetWidthMaxContent(YGNodeRef node) {
+  updateStyle<&Style::dimension, &Style::setDimension>(
+      node, Dimension::Width, StyleSizeLength::ofMaxContent());
+}
+
+void YGNodeStyleSetWidthFitContent(YGNodeRef node) {
+  updateStyle<&Style::dimension, &Style::setDimension>(
+      node, Dimension::Width, StyleSizeLength::ofFitContent());
+}
+
+void YGNodeStyleSetWidthStretch(YGNodeRef node) {
+  updateStyle<&Style::dimension, &Style::setDimension>(
+      node, Dimension::Width, StyleSizeLength::ofStretch());
 }

 YGValue YGNodeStyleGetWidth(YGNodeConstRef node) {
@@ -327,17 +357,32 @@ YGValue YGNodeStyleGetWidth(YGNodeConstRef node) {

 void YGNodeStyleSetHeight(YGNodeRef node, float points) {
  updateStyle<&Style::dimension, &Style::setDimension>(
-      node, Dimension::Height, StyleLength::points(points));
+      node, Dimension::Height, StyleSizeLength::points(points));
 }

 void YGNodeStyleSetHeightPercent(YGNodeRef node, float percent) {
  updateStyle<&Style::dimension, &Style::setDimension>(
-      node, Dimension::Height, StyleLength::percent(percent));
+      node, Dimension::Height, StyleSizeLength::percent(percent));
 }

 void YGNodeStyleSetHeightAuto(YGNodeRef node) {
  updateStyle<&Style::dimension, &Style::setDimension>(
-      node, Dimension::Height, StyleLength::ofAuto());
+      node, Dimension::Height, StyleSizeLength::ofAuto());
+}
+
+void YGNodeStyleSetHeightMaxContent(YGNodeRef node) {
+  updateStyle<&Style::dimension, &Style::setDimension>(
+      node, Dimension::Height, StyleSizeLength::ofMaxContent());
+}
+
+void YGNodeStyleSetHeightFitContent(YGNodeRef node) {
+  updateStyle<&Style::dimension, &Style::setDimension>(
+      node, Dimension::Height, StyleSizeLength::ofFitContent());
+}
+
+void YGNodeStyleSetHeightStretch(YGNodeRef node) {
+  updateStyle<&Style::dimension, &Style::setDimension>(
+      node, Dimension::Height, StyleSizeLength::ofStretch());
 }

 YGValue YGNodeStyleGetHeight(YGNodeConstRef node) {
@@ -346,12 +391,27 @@ YGValue YGNodeStyleGetHeight(YGNodeConstRef node) {

 void YGNodeStyleSetMinWidth(const YGNodeRef node, const float minWidth) {
  updateStyle<&Style::minDimension, &Style::setMinDimension>(
-      node, Dimension::Width, StyleLength::points(minWidth));
+      node, Dimension::Width, StyleSizeLength::points(minWidth));
 }

 void YGNodeStyleSetMinWidthPercent(const YGNodeRef node, const float minWidth) {
  updateStyle<&Style::minDimension, &Style::setMinDimension>(
-      node, Dimension::Width, StyleLength::percent(minWidth));
+      node, Dimension::Width, StyleSizeLength::percent(minWidth));
+}
+
+void YGNodeStyleSetMinWidthMaxContent(const YGNodeRef node) {
+  updateStyle<&Style::minDimension, &Style::setMinDimension>(
+      node, Dimension::Width, StyleSizeLength::ofMaxContent());
+}
+
+void YGNodeStyleSetMinWidthFitContent(const YGNodeRef node) {
+  updateStyle<&Style::minDimension, &Style::setMinDimension>(
+      node, Dimension::Width, StyleSizeLength::ofFitContent());
+}
+
+void YGNodeStyleSetMinWidthStretch(const YGNodeRef node) {
+  updateStyle<&Style::minDimension, &Style::setMinDimension>(
+      node, Dimension::Width, StyleSizeLength::ofStretch());
 }

 YGValue YGNodeStyleGetMinWidth(const YGNodeConstRef node) {
@@ -360,14 +420,29 @@ YGValue YGNodeStyleGetMinWidth(const YGNodeConstRef node) {

 void YGNodeStyleSetMinHeight(const YGNodeRef node, const float minHeight) {
  updateStyle<&Style::minDimension, &Style::setMinDimension>(
-      node, Dimension::Height, StyleLength::points(minHeight));
+      node, Dimension::Height, StyleSizeLength::points(minHeight));
 }

 void YGNodeStyleSetMinHeightPercent(
    const YGNodeRef node,
    const float minHeight) {
  updateStyle<&Style::minDimension, &Style::setMinDimension>(
-      node, Dimension::Height, StyleLength::percent(minHeight));
+      node, Dimension::Height, StyleSizeLength::percent(minHeight));
+}
+
+void YGNodeStyleSetMinHeightMaxContent(const YGNodeRef node) {
+  updateStyle<&Style::minDimension, &Style::setMinDimension>(
+      node, Dimension::Height, StyleSizeLength::ofMaxContent());
+}
+
+void YGNodeStyleSetMinHeightFitContent(const YGNodeRef node) {
+  updateStyle<&Style::minDimension, &Style::setMinDimension>(
+      node, Dimension::Height, StyleSizeLength::ofFitContent());
+}
+
+void YGNodeStyleSetMinHeightStretch(const YGNodeRef node) {
+  updateStyle<&Style::minDimension, &Style::setMinDimension>(
+      node, Dimension::Height, StyleSizeLength::ofStretch());
 }

 YGValue YGNodeStyleGetMinHeight(const YGNodeConstRef node) {
@@ -376,12 +451,27 @@ YGValue YGNodeStyleGetMinHeight(const YGNodeConstRef node) {

 void YGNodeStyleSetMaxWidth(const YGNodeRef node, const float maxWidth) {
  updateStyle<&Style::maxDimension, &Style::setMaxDimension>(
-      node, Dimension::Width, StyleLength::points(maxWidth));
+      node, Dimension::Width, StyleSizeLength::points(maxWidth));
 }

 void YGNodeStyleSetMaxWidthPercent(const YGNodeRef node, const float maxWidth) {
  updateStyle<&Style::maxDimension, &Style::setMaxDimension>(
-      node, Dimension::Width, StyleLength::percent(maxWidth));
+      node, Dimension::Width, StyleSizeLength::percent(maxWidth));
+}
+
+void YGNodeStyleSetMaxWidthMaxContent(const YGNodeRef node) {
+  updateStyle<&Style::maxDimension, &Style::setMaxDimension>(
+      node, Dimension::Width, StyleSizeLength::ofMaxContent());
+}
+
+void YGNodeStyleSetMaxWidthFitContent(const YGNodeRef node) {
+  updateStyle<&Style::maxDimension, &Style::setMaxDimension>(
+      node, Dimension::Width, StyleSizeLength::ofFitContent());
+}
+
+void YGNodeStyleSetMaxWidthStretch(const YGNodeRef node) {
+  updateStyle<&Style::maxDimension, &Style::setMaxDimension>(
+      node, Dimension::Width, StyleSizeLength::ofStretch());
 }

 YGValue YGNodeStyleGetMaxWidth(const YGNodeConstRef node) {
@@ -390,14 +480,29 @@ YGValue YGNodeStyleGetMaxWidth(const YGNodeConstRef node) {

 void YGNodeStyleSetMaxHeight(const YGNodeRef node, const float maxHeight) {
  updateStyle<&Style::maxDimension, &Style::setMaxDimension>(
-      node, Dimension::Height, StyleLength::points(maxHeight));
+      node, Dimension::Height, StyleSizeLength::points(maxHeight));
 }

 void YGNodeStyleSetMaxHeightPercent(
    const YGNodeRef node,
    const float maxHeight) {
  updateStyle<&Style::maxDimension, &Style::setMaxDimension>(
-      node, Dimension::Height, StyleLength::percent(maxHeight));
+      node, Dimension::Height, StyleSizeLength::percent(maxHeight));
+}
+
+void YGNodeStyleSetMaxHeightMaxContent(const YGNodeRef node) {
+  updateStyle<&Style::maxDimension, &Style::setMaxDimension>(
+      node, Dimension::Height, StyleSizeLength::ofMaxContent());
+}
+
+void YGNodeStyleSetMaxHeightFitContent(const YGNodeRef node) {
+  updateStyle<&Style::maxDimension, &Style::setMaxDimension>(
+      node, Dimension::Height, StyleSizeLength::ofFitContent());
+}
+
+void YGNodeStyleSetMaxHeightStretch(const YGNodeRef node) {
+  updateStyle<&Style::maxDimension, &Style::setMaxDimension>(
+      node, Dimension::Height, StyleSizeLength::ofStretch());
 }

 YGValue YGNodeStyleGetMaxHeight(const YGNodeConstRef node) {
--- a/yoga/YGNodeStyle.h
+++ b/yoga/YGNodeStyle.h
@@ -64,6 +64,9 @@ YG_EXPORT float YGNodeStyleGetFlexShrink(YGNodeConstRef node);
 YG_EXPORT void YGNodeStyleSetFlexBasis(YGNodeRef node, float flexBasis);
 YG_EXPORT void YGNodeStyleSetFlexBasisPercent(YGNodeRef node, float flexBasis);
 YG_EXPORT void YGNodeStyleSetFlexBasisAuto(YGNodeRef node);
+YG_EXPORT void YGNodeStyleSetFlexBasisMaxContent(YGNodeRef node);
+YG_EXPORT void YGNodeStyleSetFlexBasisFitContent(YGNodeRef node);
+YG_EXPORT void YGNodeStyleSetFlexBasisStretch(YGNodeRef node);
 YG_EXPORT YGValue YGNodeStyleGetFlexBasis(YGNodeConstRef node);

 YG_EXPORT void
@@ -101,27 +104,45 @@ YG_EXPORT YGBoxSizing YGNodeStyleGetBoxSizing(YGNodeConstRef node);
 YG_EXPORT void YGNodeStyleSetWidth(YGNodeRef node, float width);
 YG_EXPORT void YGNodeStyleSetWidthPercent(YGNodeRef node, float width);
 YG_EXPORT void YGNodeStyleSetWidthAuto(YGNodeRef node);
+YG_EXPORT void YGNodeStyleSetWidthMaxContent(YGNodeRef node);
+YG_EXPORT void YGNodeStyleSetWidthFitContent(YGNodeRef node);
+YG_EXPORT void YGNodeStyleSetWidthStretch(YGNodeRef node);
 YG_EXPORT YGValue YGNodeStyleGetWidth(YGNodeConstRef node);

 YG_EXPORT void YGNodeStyleSetHeight(YGNodeRef node, float height);
 YG_EXPORT void YGNodeStyleSetHeightPercent(YGNodeRef node, float height);
 YG_EXPORT void YGNodeStyleSetHeightAuto(YGNodeRef node);
+YG_EXPORT void YGNodeStyleSetHeightMaxContent(YGNodeRef node);
+YG_EXPORT void YGNodeStyleSetHeightFitContent(YGNodeRef node);
+YG_EXPORT void YGNodeStyleSetHeightStretch(YGNodeRef node);
 YG_EXPORT YGValue YGNodeStyleGetHeight(YGNodeConstRef node);

 YG_EXPORT void YGNodeStyleSetMinWidth(YGNodeRef node, float minWidth);
 YG_EXPORT void YGNodeStyleSetMinWidthPercent(YGNodeRef node, float minWidth);
+YG_EXPORT void YGNodeStyleSetMinWidthMaxContent(YGNodeRef node);
+YG_EXPORT void YGNodeStyleSetMinWidthFitContent(YGNodeRef node);
+YG_EXPORT void YGNodeStyleSetMinWidthStretch(YGNodeRef node);
 YG_EXPORT YGValue YGNodeStyleGetMinWidth(YGNodeConstRef node);

 YG_EXPORT void YGNodeStyleSetMinHeight(YGNodeRef node, float minHeight);
 YG_EXPORT void YGNodeStyleSetMinHeightPercent(YGNodeRef node, float minHeight);
+YG_EXPORT void YGNodeStyleSetMinHeightMaxContent(YGNodeRef node);
+YG_EXPORT void YGNodeStyleSetMinHeightFitContent(YGNodeRef node);
+YG_EXPORT void YGNodeStyleSetMinHeightStretch(YGNodeRef node);
 YG_EXPORT YGValue YGNodeStyleGetMinHeight(YGNodeConstRef node);

 YG_EXPORT void YGNodeStyleSetMaxWidth(YGNodeRef node, float maxWidth);
 YG_EXPORT void YGNodeStyleSetMaxWidthPercent(YGNodeRef node, float maxWidth);
+YG_EXPORT void YGNodeStyleSetMaxWidthMaxContent(YGNodeRef node);
+YG_EXPORT void YGNodeStyleSetMaxWidthFitContent(YGNodeRef node);
+YG_EXPORT void YGNodeStyleSetMaxWidthStretch(YGNodeRef node);
 YG_EXPORT YGValue YGNodeStyleGetMaxWidth(YGNodeConstRef node);

 YG_EXPORT void YGNodeStyleSetMaxHeight(YGNodeRef node, float maxHeight);
 YG_EXPORT void YGNodeStyleSetMaxHeightPercent(YGNodeRef node, float maxHeight);
+YG_EXPORT void YGNodeStyleSetMaxHeightMaxContent(YGNodeRef node);
+YG_EXPORT void YGNodeStyleSetMaxHeightFitContent(YGNodeRef node);
+YG_EXPORT void YGNodeStyleSetMaxHeightStretch(YGNodeRef node);
 YG_EXPORT YGValue YGNodeStyleGetMaxHeight(YGNodeConstRef node);

 YG_EXPORT void YGNodeStyleSetAspectRatio(YGNodeRef node, float aspectRatio);
--- a/yoga/YGValue.h
+++ b/yoga/YGValue.h
@@ -65,6 +65,9 @@ inline bool operator==(const YGValue& lhs, const YGValue& rhs) {
  switch (lhs.unit) {
    case YGUnitUndefined:
    case YGUnitAuto:
+    case YGUnitFitContent:
+    case YGUnitMaxContent:
+    case YGUnitStretch:
      return true;
    case YGUnitPoint:
    case YGUnitPercent:
--- a/yoga/algorithm/CalculateLayout.cpp
+++ b/yoga/algorithm/CalculateLayout.cpp
@@ -741,7 +741,7 @@ static float distributeFreeSpaceSecondPass(
          marginCross;
      const bool isLoosePercentageMeasurement =
          currentLineChild->getProcessedDimension(dimension(crossAxis))
-                  .unit() == Unit::Percent &&
+              .isPercent() &&
          sizingModeCrossDim != SizingMode::StretchFit;
      childCrossSizingMode =
          yoga::isUndefined(childCrossSize) || isLoosePercentageMeasurement
--- a/yoga/enums/Unit.h
+++ b/yoga/enums/Unit.h
@@ -20,11 +20,14 @@ enum class Unit : uint8_t {
  Point = YGUnitPoint,
  Percent = YGUnitPercent,
  Auto = YGUnitAuto,
+  MaxContent = YGUnitMaxContent,
+  FitContent = YGUnitFitContent,
+  Stretch = YGUnitStretch,
 };

 template <>
 constexpr int32_t ordinalCount<Unit>() {
-  return 4;
+  return 7;
 }

 constexpr Unit scopedEnum(YGUnit unscoped) {
--- a/yoga/node/Node.cpp
+++ b/yoga/node/Node.cpp
@@ -314,16 +314,16 @@ void Node::setPosition(
      crossAxisTrailingEdge);
 }

-Style::Length Node::processFlexBasis() const {
-  Style::Length flexBasis = style_.flexBasis();
-  if (flexBasis.unit() != Unit::Auto && flexBasis.unit() != Unit::Undefined) {
+Style::SizeLength Node::processFlexBasis() const {
+  Style::SizeLength flexBasis = style_.flexBasis();
+  if (!flexBasis.isAuto() && !flexBasis.isUndefined()) {
    return flexBasis;
  }
  if (style_.flex().isDefined() && style_.flex().unwrap() > 0.0f) {
-    return config_->useWebDefaults() ? StyleLength::ofAuto()
-                                     : StyleLength::points(0);
+    return config_->useWebDefaults() ? StyleSizeLength::ofAuto()
+                                     : StyleSizeLength::points(0);
  }
-  return StyleLength::ofAuto();
+  return StyleSizeLength::ofAuto();
 }

 FloatOptional Node::resolveFlexBasis(
--- a/yoga/node/Node.h
+++ b/yoga/node/Node.h
@@ -172,7 +172,7 @@ class YG_EXPORT Node : public ::YGNode {
    return isDirty_;
  }

-  Style::Length getProcessedDimension(Dimension dimension) const {
+  Style::SizeLength getProcessedDimension(Dimension dimension) const {
    return processedDimensions_[static_cast<size_t>(dimension)];
  }

@@ -268,7 +268,7 @@ class YG_EXPORT Node : public ::YGNode {
  void setPosition(Direction direction, float ownerWidth, float ownerHeight);

  // Other methods
-  Style::Length processFlexBasis() const;
+  Style::SizeLength processFlexBasis() const;
  FloatOptional resolveFlexBasis(
      Direction direction,
      FlexDirection flexDirection,
@@ -322,8 +322,8 @@ class YG_EXPORT Node : public ::YGNode {
  Node* owner_ = nullptr;
  std::vector<Node*> children_;
  const Config* config_;
-  std::array<Style::Length, 2> processedDimensions_{
-      {StyleLength::undefined(), StyleLength::undefined()}};
+  std::array<Style::SizeLength, 2> processedDimensions_{
+      {StyleSizeLength::undefined(), StyleSizeLength::undefined()}};
 };

 inline Node* resolveRef(const YGNodeRef ref) {
--- a/yoga/style/Style.h
+++ b/yoga/style/Style.h
@@ -30,6 +30,7 @@
 #include <yoga/enums/Wrap.h>
 #include <yoga/numeric/FloatOptional.h>
 #include <yoga/style/StyleLength.h>
+#include <yoga/style/StyleSizeLength.h>
 #include <yoga/style/StyleValuePool.h>

 namespace facebook::yoga {
@@ -37,6 +38,7 @@ namespace facebook::yoga {
 class YG_EXPORT Style {
 public:
  using Length = StyleLength;
+  using SizeLength = StyleSizeLength;

  static constexpr float DefaultFlexGrow = 0.0f;
  static constexpr float DefaultFlexShrink = 0.0f;
@@ -133,10 +135,10 @@ class YG_EXPORT Style {
    pool_.store(flexShrink_, value);
  }

-  Style::Length flexBasis() const {
-    return pool_.getLength(flexBasis_);
+  Style::SizeLength flexBasis() const {
+    return pool_.getSize(flexBasis_);
  }
-  void setFlexBasis(Style::Length value) {
+  void setFlexBasis(Style::SizeLength value) {
    pool_.store(flexBasis_, value);
  }

@@ -175,17 +177,17 @@ class YG_EXPORT Style {
    pool_.store(gap_[yoga::to_underlying(gutter)], value);
  }

-  Style::Length dimension(Dimension axis) const {
-    return pool_.getLength(dimensions_[yoga::to_underlying(axis)]);
+  Style::SizeLength dimension(Dimension axis) const {
+    return pool_.getSize(dimensions_[yoga::to_underlying(axis)]);
  }
-  void setDimension(Dimension axis, Style::Length value) {
+  void setDimension(Dimension axis, Style::SizeLength value) {
    pool_.store(dimensions_[yoga::to_underlying(axis)], value);
  }

-  Style::Length minDimension(Dimension axis) const {
-    return pool_.getLength(minDimensions_[yoga::to_underlying(axis)]);
+  Style::SizeLength minDimension(Dimension axis) const {
+    return pool_.getSize(minDimensions_[yoga::to_underlying(axis)]);
  }
-  void setMinDimension(Dimension axis, Style::Length value) {
+  void setMinDimension(Dimension axis, Style::SizeLength value) {
    pool_.store(minDimensions_[yoga::to_underlying(axis)], value);
  }

@@ -207,10 +209,10 @@ class YG_EXPORT Style {
                                               : FloatOptional{0.0});
  }

-  Style::Length maxDimension(Dimension axis) const {
-    return pool_.getLength(maxDimensions_[yoga::to_underlying(axis)]);
+  Style::SizeLength maxDimension(Dimension axis) const {
+    return pool_.getSize(maxDimensions_[yoga::to_underlying(axis)]);
  }
-  void setMaxDimension(Dimension axis, Style::Length value) {
+  void setMaxDimension(Dimension axis, Style::SizeLength value) {
    pool_.store(maxDimensions_[yoga::to_underlying(axis)], value);
  }

--- a/yoga/style/StyleLength.h
+++ b/yoga/style/StyleLength.h
@@ -19,13 +19,11 @@ namespace facebook::yoga {
 * 3. A CSS <length-percentage> value:
 *    a. <length> value (e.g. 10px)
 *    b. <percentage> value of a reference <length>
- * 4. (soon) A math function which returns a <length-percentage> value
 *
 * References:
 * 1. https://www.w3.org/TR/css-values-4/#lengths
 * 2. https://www.w3.org/TR/css-values-4/#percentage-value
 * 3. https://www.w3.org/TR/css-values-4/#mixed-percentages
- * 4. https://www.w3.org/TR/css-values-4/#math
 */
 class StyleLength {
 public:
@@ -59,6 +57,14 @@ class StyleLength {
    return unit_ == Unit::Undefined;
  }

+  constexpr bool isPoints() const {
+    return unit_ == Unit::Point;
+  }
+
+  constexpr bool isPercent() const {
+    return unit_ == Unit::Percent;
+  }
+
  constexpr bool isDefined() const {
    return !isUndefined();
  }
@@ -67,10 +73,6 @@ class StyleLength {
    return value_;
  }

-  constexpr Unit unit() const {
-    return unit_;
-  }
-
  constexpr FloatOptional resolve(float referenceLength) {
    switch (unit_) {
      case Unit::Point:
@@ -90,6 +92,11 @@ class StyleLength {
    return value_ == rhs.value_ && unit_ == rhs.unit_;
  }

+  constexpr bool inexactEquals(const StyleLength& other) const {
+    return unit_ == other.unit_ &&
+        facebook::yoga::inexactEquals(value_, other.value_);
+  }
+
 private:
  // We intentionally do not allow direct construction using value and unit, to
  // avoid invalid, or redundant combinations.
@@ -101,7 +108,7 @@ class StyleLength {
 };

 inline bool inexactEquals(const StyleLength& a, const StyleLength& b) {
-  return a.unit() == b.unit() && inexactEquals(a.value(), b.value());
+  return a.inexactEquals(b);
 }

 } // namespace facebook::yoga
--- a/yoga/style/StyleSizeLength.h
+++ b/yoga/style/StyleSizeLength.h
@@ -0,0 +1,139 @@
+/*
+ * 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 <yoga/enums/Unit.h>
+#include <yoga/numeric/FloatOptional.h>
+
+namespace facebook::yoga {
+
+/**
+ * This class represents a CSS Value for sizes (e.g. width, height, min-width,
+ * etc.). It may be one of:
+ * 1. Undefined
+ * 2. A keyword (e.g. auto, max-content, stretch, etc.)
+ * 3. A CSS <length-percentage> value:
+ *    a. <length> value (e.g. 10px)
+ *    b. <percentage> value of a reference <length>
+ *
+ * References:
+ * 1. https://www.w3.org/TR/css-values-4/#lengths
+ * 2. https://www.w3.org/TR/css-values-4/#percentage-value
+ * 3. https://www.w3.org/TR/css-values-4/#mixed-percentages
+ */
+class StyleSizeLength {
+ public:
+  constexpr StyleSizeLength() = default;
+
+  constexpr static StyleSizeLength points(float value) {
+    return yoga::isUndefined(value) || yoga::isinf(value)
+        ? undefined()
+        : StyleSizeLength{FloatOptional{value}, Unit::Point};
+  }
+
+  constexpr static StyleSizeLength percent(float value) {
+    return yoga::isUndefined(value) || yoga::isinf(value)
+        ? undefined()
+        : StyleSizeLength{FloatOptional{value}, Unit::Percent};
+  }
+
+  constexpr static StyleSizeLength ofAuto() {
+    return StyleSizeLength{{}, Unit::Auto};
+  }
+
+  constexpr static StyleSizeLength ofMaxContent() {
+    return StyleSizeLength{{}, Unit::MaxContent};
+  }
+
+  constexpr static StyleSizeLength ofFitContent() {
+    return StyleSizeLength{{}, Unit::FitContent};
+  }
+
+  constexpr static StyleSizeLength ofStretch() {
+    return StyleSizeLength{{}, Unit::Stretch};
+  }
+
+  constexpr static StyleSizeLength undefined() {
+    return StyleSizeLength{{}, Unit::Undefined};
+  }
+
+  constexpr bool isAuto() const {
+    return unit_ == Unit::Auto;
+  }
+
+  constexpr bool isMaxContent() const {
+    return unit_ == Unit::MaxContent;
+  }
+
+  constexpr bool isFitContent() const {
+    return unit_ == Unit::FitContent;
+  }
+
+  constexpr bool isStretch() const {
+    return unit_ == Unit::Stretch;
+  }
+
+  constexpr bool isUndefined() const {
+    return unit_ == Unit::Undefined;
+  }
+
+  constexpr bool isDefined() const {
+    return !isUndefined();
+  }
+
+  constexpr bool isPoints() const {
+    return unit_ == Unit::Point;
+  }
+
+  constexpr bool isPercent() const {
+    return unit_ == Unit::Percent;
+  }
+
+  constexpr FloatOptional value() const {
+    return value_;
+  }
+
+  constexpr FloatOptional resolve(float referenceLength) {
+    switch (unit_) {
+      case Unit::Point:
+        return value_;
+      case Unit::Percent:
+        return FloatOptional{value_.unwrap() * referenceLength * 0.01f};
+      default:
+        return FloatOptional{};
+    }
+  }
+
+  explicit constexpr operator YGValue() const {
+    return YGValue{value_.unwrap(), unscopedEnum(unit_)};
+  }
+
+  constexpr bool operator==(const StyleSizeLength& rhs) const {
+    return value_ == rhs.value_ && unit_ == rhs.unit_;
+  }
+
+  constexpr bool inexactEquals(const StyleSizeLength& other) const {
+    return unit_ == other.unit_ &&
+        facebook::yoga::inexactEquals(value_, other.value_);
+  }
+
+ private:
+  // We intentionally do not allow direct construction using value and unit, to
+  // avoid invalid, or redundant combinations.
+  constexpr StyleSizeLength(FloatOptional value, Unit unit)
+      : value_(value), unit_(unit) {}
+
+  FloatOptional value_{};
+  Unit unit_{Unit::Undefined};
+};
+
+inline bool inexactEquals(const StyleSizeLength& a, const StyleSizeLength& b) {
+  return a.inexactEquals(b);
+}
+
+} // namespace facebook::yoga
--- a/yoga/style/StyleValueHandle.h
+++ b/yoga/style/StyleValueHandle.h
@@ -62,8 +62,16 @@ class StyleValueHandle {
    Percent,
    Number,
    Auto,
+    Keyword
  };

+  // Intentionally leaving out auto as a fast path
+  enum class Keyword : uint8_t { MaxContent, FitContent, Stretch };
+
+  constexpr bool isKeyword(Keyword keyword) const {
+    return type() == Type::Keyword && value() == static_cast<uint16_t>(keyword);
+  }
+
  constexpr Type type() const {
    return static_cast<Type>(repr_ & kHandleTypeMask);
  }
--- a/yoga/style/StyleValuePool.h
+++ b/yoga/style/StyleValuePool.h
@@ -13,6 +13,7 @@
 #include <yoga/numeric/FloatOptional.h>
 #include <yoga/style/SmallValueBuffer.h>
 #include <yoga/style/StyleLength.h>
+#include <yoga/style/StyleSizeLength.h>
 #include <yoga/style/StyleValueHandle.h>

 namespace facebook::yoga {
@@ -32,13 +33,30 @@ class StyleValuePool {
    } else if (length.isAuto()) {
      handle.setType(StyleValueHandle::Type::Auto);
    } else {
-      auto type = length.unit() == Unit::Point
-          ? StyleValueHandle::Type::Point
-          : StyleValueHandle::Type::Percent;
+      auto type = length.isPoints() ? StyleValueHandle::Type::Point
+                                    : StyleValueHandle::Type::Percent;
      storeValue(handle, length.value().unwrap(), type);
    }
  }

+  void store(StyleValueHandle& handle, StyleSizeLength sizeValue) {
+    if (sizeValue.isUndefined()) {
+      handle.setType(StyleValueHandle::Type::Undefined);
+    } else if (sizeValue.isAuto()) {
+      handle.setType(StyleValueHandle::Type::Auto);
+    } else if (sizeValue.isMaxContent()) {
+      storeKeyword(handle, StyleValueHandle::Keyword::MaxContent);
+    } else if (sizeValue.isStretch()) {
+      storeKeyword(handle, StyleValueHandle::Keyword::Stretch);
+    } else if (sizeValue.isFitContent()) {
+      storeKeyword(handle, StyleValueHandle::Keyword::FitContent);
+    } else {
+      auto type = sizeValue.isPoints() ? StyleValueHandle::Type::Point
+                                       : StyleValueHandle::Type::Percent;
+      storeValue(handle, sizeValue.value().unwrap(), type);
+    }
+  }
+
  void store(StyleValueHandle& handle, FloatOptional number) {
    if (number.isUndefined()) {
      handle.setType(StyleValueHandle::Type::Undefined);
@@ -66,6 +84,31 @@ class StyleValuePool {
    }
  }

+  StyleSizeLength getSize(StyleValueHandle handle) const {
+    if (handle.isUndefined()) {
+      return StyleSizeLength::undefined();
+    } else if (handle.isAuto()) {
+      return StyleSizeLength::ofAuto();
+    } else if (handle.isKeyword(StyleValueHandle::Keyword::MaxContent)) {
+      return StyleSizeLength::ofMaxContent();
+    } else if (handle.isKeyword(StyleValueHandle::Keyword::FitContent)) {
+      return StyleSizeLength::ofFitContent();
+    } else if (handle.isKeyword(StyleValueHandle::Keyword::Stretch)) {
+      return StyleSizeLength::ofStretch();
+    } else {
+      assert(
+          handle.type() == StyleValueHandle::Type::Point ||
+          handle.type() == StyleValueHandle::Type::Percent);
+      float value = (handle.isValueIndexed())
+          ? std::bit_cast<float>(buffer_.get32(handle.value()))
+          : unpackInlineInteger(handle.value());
+
+      return handle.type() == StyleValueHandle::Type::Point
+          ? StyleSizeLength::points(value)
+          : StyleSizeLength::percent(value);
+    }
+  }
+
  FloatOptional getNumber(StyleValueHandle handle) const {
    if (handle.isUndefined()) {
      return FloatOptional{};
@@ -98,6 +141,20 @@ class StyleValuePool {
    }
  }

+  void storeKeyword(
+      StyleValueHandle& handle,
+      StyleValueHandle::Keyword keyword) {
+    handle.setType(StyleValueHandle::Type::Keyword);
+
+    if (handle.isValueIndexed()) {
+      auto newIndex =
+          buffer_.replace(handle.value(), static_cast<uint32_t>(keyword));
+      handle.setValue(newIndex);
+    } else {
+      handle.setValue(static_cast<uint16_t>(keyword));
+    }
+  }
+
  static constexpr bool isIntegerPackable(float f) {
    constexpr uint16_t kMaxInlineAbsValue = (1 << 11) - 1;