diff --git a/packages/react-native/ReactCommon/yoga/yoga/bits/EnumBitset.h b/packages/react-native/ReactCommon/yoga/yoga/bits/EnumBitset.h
new file mode 100644
index 00000000000..3dff663f8fc
--- /dev/null
+++ b/packages/react-native/ReactCommon/yoga/yoga/bits/EnumBitset.h
@@ -0,0 +1,19 @@
+/*
+ * 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 <bitset>
+#include <yoga/YGEnums.h>
+
+namespace facebook::yoga {
+
+// std::bitset with one bit for each option defined in YG_ENUM_SEQ_DECL
+template <typename Enum>
+using EnumBitset = std::bitset<enums::count<Enum>()>;
+
+} // namespace facebook::yoga
diff --git a/packages/react-native/ReactCommon/yoga/yoga/BitUtils.h b/packages/react-native/ReactCommon/yoga/yoga/bits/NumericBitfield.h
similarity index 64%
rename from packages/react-native/ReactCommon/yoga/yoga/BitUtils.h
rename to packages/react-native/ReactCommon/yoga/yoga/bits/NumericBitfield.h
index 7c91550585d..af3fc6927d1 100644
--- a/packages/react-native/ReactCommon/yoga/yoga/BitUtils.h
+++ b/packages/react-native/ReactCommon/yoga/yoga/bits/NumericBitfield.h
@@ -13,11 +13,7 @@
 
 #include <yoga/YGEnums.h>
 
-namespace facebook::yoga::detail {
-
-// std::bitset with one bit for each option defined in YG_ENUM_SEQ_DECL
-template <typename Enum>
-using EnumBitset = std::bitset<facebook::yoga::enums::count<Enum>()>;
+namespace facebook::yoga::details {
 
 constexpr size_t log2ceilFn(size_t n) {
   return n < 1 ? 0 : (1 + log2ceilFn(n / 2));
@@ -27,30 +23,37 @@ constexpr int mask(size_t bitWidth, size_t index) {
   return ((1 << bitWidth) - 1) << index;
 }
 
+} // namespace facebook::yoga::details
+
+namespace facebook::yoga {
+
 // The number of bits necessary to represent enums defined with YG_ENUM_SEQ_DECL
 template <typename Enum>
-constexpr size_t bitWidthFn() {
+constexpr size_t minimumBitCount() {
   static_assert(
       enums::count<Enum>() > 0, "Enums must have at least one entries");
-  return log2ceilFn(enums::count<Enum>() - 1);
+  return details::log2ceilFn(enums::count<Enum>() - 1);
 }
 
 template <typename Enum>
 constexpr Enum getEnumData(int flags, size_t index) {
-  return static_cast<Enum>((flags & mask(bitWidthFn<Enum>(), index)) >> index);
+  return static_cast<Enum>(
+      (flags & details::mask(minimumBitCount<Enum>(), index)) >> index);
 }
 
 template <typename Enum>
 void setEnumData(uint32_t& flags, size_t index, int newValue) {
-  flags = (flags & ~mask(bitWidthFn<Enum>(), index)) |
-      ((newValue << index) & (mask(bitWidthFn<Enum>(), index)));
+  flags = (flags & ~details::mask(minimumBitCount<Enum>(), index)) |
+      ((newValue << index) & (details::mask(minimumBitCount<Enum>(), index)));
 }
 
 template <typename Enum>
 void setEnumData(uint8_t& flags, size_t index, int newValue) {
-  flags = (flags & ~static_cast<uint8_t>(mask(bitWidthFn<Enum>(), index))) |
+  flags =
+      (flags &
+       ~static_cast<uint8_t>(details::mask(minimumBitCount<Enum>(), index))) |
       ((newValue << index) &
-       (static_cast<uint8_t>(mask(bitWidthFn<Enum>(), index))));
+       (static_cast<uint8_t>(details::mask(minimumBitCount<Enum>(), index))));
 }
 
 constexpr bool getBooleanData(int flags, size_t index) {
@@ -65,4 +68,4 @@ inline void setBooleanData(uint8_t& flags, size_t index, bool value) {
   }
 }
 
-} // namespace facebook::yoga::detail
+} // namespace facebook::yoga
diff --git a/packages/react-native/ReactCommon/yoga/yoga/config/Config.cpp b/packages/react-native/ReactCommon/yoga/yoga/config/Config.cpp
index 2f07454b976..d8809cf5a2c 100644
--- a/packages/react-native/ReactCommon/yoga/yoga/config/Config.cpp
+++ b/packages/react-native/ReactCommon/yoga/yoga/config/Config.cpp
@@ -46,7 +46,7 @@ bool Config::isExperimentalFeatureEnabled(YGExperimentalFeature feature) const {
   return experimentalFeatures_.test(feature);
 }
 
-ExperimentalFeatureSet Config::getEnabledExperiments() const {
+EnumBitset<YGExperimentalFeature> Config::getEnabledExperiments() const {
   return experimentalFeatures_;
 }
 
diff --git a/packages/react-native/ReactCommon/yoga/yoga/config/Config.h b/packages/react-native/ReactCommon/yoga/yoga/config/Config.h
index 6470ebde4db..d0894b86be3 100644
--- a/packages/react-native/ReactCommon/yoga/yoga/config/Config.h
+++ b/packages/react-native/ReactCommon/yoga/yoga/config/Config.h
@@ -9,7 +9,7 @@
 
 #include <yoga/Yoga.h>
 
-#include <yoga/BitUtils.h>
+#include <yoga/bits/EnumBitset.h>
 #include <yoga/Yoga-internal.h>
 
 // Tag struct used to form the opaque YGConfigRef for the public C API
@@ -38,8 +38,6 @@ using CloneWithContextFn = YGNodeRef (*)(
     int childIndex,
     void* cloneContext);
 
-using ExperimentalFeatureSet = detail::EnumBitset<YGExperimentalFeature>;
-
 #pragma pack(push)
 #pragma pack(1)
 // Packed structure of <32-bit options to miminize size per node.
@@ -65,7 +63,7 @@ public:
       YGExperimentalFeature feature,
       bool enabled);
   bool isExperimentalFeatureEnabled(YGExperimentalFeature feature) const;
-  ExperimentalFeatureSet getEnabledExperiments() const;
+  EnumBitset<YGExperimentalFeature> getEnabledExperiments() const;
 
   void setErrata(YGErrata errata);
   void addErrata(YGErrata errata);
@@ -104,7 +102,7 @@ private:
   } logger_;
 
   ConfigFlags flags_{};
-  ExperimentalFeatureSet experimentalFeatures_{};
+  EnumBitset<YGExperimentalFeature> experimentalFeatures_{};
   YGErrata errata_ = YGErrataNone;
   float pointScaleFactor_ = 1.0f;
   void* context_ = nullptr;
diff --git a/packages/react-native/ReactCommon/yoga/yoga/node/LayoutResults.h b/packages/react-native/ReactCommon/yoga/yoga/node/LayoutResults.h
index d920e9a24cf..c0d2bee26d1 100644
--- a/packages/react-native/ReactCommon/yoga/yoga/node/LayoutResults.h
+++ b/packages/react-native/ReactCommon/yoga/yoga/node/LayoutResults.h
@@ -7,7 +7,7 @@
 
 #pragma once
 
-#include <yoga/BitUtils.h>
+#include <yoga/bits/NumericBitfield.h>
 #include <yoga/numeric/FloatOptional.h>
 #include <yoga/Yoga-internal.h>
 
@@ -23,7 +23,7 @@ struct LayoutResults {
 private:
   static constexpr size_t directionOffset = 0;
   static constexpr size_t hadOverflowOffset =
-      directionOffset + facebook::yoga::detail::bitWidthFn<YGDirection>();
+      directionOffset + minimumBitCount<YGDirection>();
   uint8_t flags = 0;
 
 public:
@@ -43,21 +43,16 @@ public:
   YGCachedMeasurement cachedLayout = YGCachedMeasurement();
 
   YGDirection direction() const {
-    return facebook::yoga::detail::getEnumData<YGDirection>(
-        flags, directionOffset);
+    return getEnumData<YGDirection>(flags, directionOffset);
   }
 
   void setDirection(YGDirection direction) {
-    facebook::yoga::detail::setEnumData<YGDirection>(
-        flags, directionOffset, direction);
+    setEnumData<YGDirection>(flags, directionOffset, direction);
   }
 
-  bool hadOverflow() const {
-    return facebook::yoga::detail::getBooleanData(flags, hadOverflowOffset);
-  }
+  bool hadOverflow() const { return getBooleanData(flags, hadOverflowOffset); }
   void setHadOverflow(bool hadOverflow) {
-    facebook::yoga::detail::setBooleanData(
-        flags, hadOverflowOffset, hadOverflow);
+    setBooleanData(flags, hadOverflowOffset, hadOverflow);
   }
 
   bool operator==(LayoutResults layout) const;
diff --git a/packages/react-native/ReactCommon/yoga/yoga/style/Style.h b/packages/react-native/ReactCommon/yoga/yoga/style/Style.h
index 49bb8ece672..10854fd6fb8 100644
--- a/packages/react-native/ReactCommon/yoga/yoga/style/Style.h
+++ b/packages/react-native/ReactCommon/yoga/yoga/style/Style.h
@@ -14,8 +14,8 @@
 
 #include <yoga/Yoga.h>
 #include <yoga/Yoga-internal.h>
-#include <yoga/BitUtils.h>
 
+#include <yoga/bits/NumericBitfield.h>
 #include <yoga/numeric/FloatOptional.h>
 #include <yoga/style/CompactValue.h>
 
@@ -34,11 +34,9 @@ public:
   struct BitfieldRef {
     Style& style;
     size_t offset;
-    operator T() const {
-      return facebook::yoga::detail::getEnumData<T>(style.flags, offset);
-    }
+    operator T() const { return getEnumData<T>(style.flags, offset); }
     BitfieldRef<T>& operator=(T x) {
-      facebook::yoga::detail::setEnumData<T>(style.flags, offset, x);
+      setEnumData<T>(style.flags, offset, x);
       return *this;
     }
   };
@@ -85,23 +83,23 @@ public:
 private:
   static constexpr size_t directionOffset = 0;
   static constexpr size_t flexdirectionOffset =
-      directionOffset + facebook::yoga::detail::bitWidthFn<YGDirection>();
-  static constexpr size_t justifyContentOffset = flexdirectionOffset +
-      facebook::yoga::detail::bitWidthFn<YGFlexDirection>();
+      directionOffset + minimumBitCount<YGDirection>();
+  static constexpr size_t justifyContentOffset =
+      flexdirectionOffset + minimumBitCount<YGFlexDirection>();
   static constexpr size_t alignContentOffset =
-      justifyContentOffset + facebook::yoga::detail::bitWidthFn<YGJustify>();
+      justifyContentOffset + minimumBitCount<YGJustify>();
   static constexpr size_t alignItemsOffset =
-      alignContentOffset + facebook::yoga::detail::bitWidthFn<YGAlign>();
+      alignContentOffset + minimumBitCount<YGAlign>();
   static constexpr size_t alignSelfOffset =
-      alignItemsOffset + facebook::yoga::detail::bitWidthFn<YGAlign>();
+      alignItemsOffset + minimumBitCount<YGAlign>();
   static constexpr size_t positionTypeOffset =
-      alignSelfOffset + facebook::yoga::detail::bitWidthFn<YGAlign>();
+      alignSelfOffset + minimumBitCount<YGAlign>();
   static constexpr size_t flexWrapOffset =
-      positionTypeOffset + facebook::yoga::detail::bitWidthFn<YGPositionType>();
+      positionTypeOffset + minimumBitCount<YGPositionType>();
   static constexpr size_t overflowOffset =
-      flexWrapOffset + facebook::yoga::detail::bitWidthFn<YGWrap>();
+      flexWrapOffset + minimumBitCount<YGWrap>();
   static constexpr size_t displayOffset =
-      overflowOffset + facebook::yoga::detail::bitWidthFn<YGOverflow>();
+      overflowOffset + minimumBitCount<YGOverflow>();
 
   uint32_t flags = 0;
 
@@ -125,65 +123,56 @@ public:
   using ValueRepr = std::remove_reference<decltype(margin_[0])>::type;
 
   YGDirection direction() const {
-    return facebook::yoga::detail::getEnumData<YGDirection>(
-        flags, directionOffset);
+    return getEnumData<YGDirection>(flags, directionOffset);
   }
   BitfieldRef<YGDirection> direction() { return {*this, directionOffset}; }
 
   YGFlexDirection flexDirection() const {
-    return facebook::yoga::detail::getEnumData<YGFlexDirection>(
-        flags, flexdirectionOffset);
+    return getEnumData<YGFlexDirection>(flags, flexdirectionOffset);
   }
   BitfieldRef<YGFlexDirection> flexDirection() {
     return {*this, flexdirectionOffset};
   }
 
   YGJustify justifyContent() const {
-    return facebook::yoga::detail::getEnumData<YGJustify>(
-        flags, justifyContentOffset);
+    return getEnumData<YGJustify>(flags, justifyContentOffset);
   }
   BitfieldRef<YGJustify> justifyContent() {
     return {*this, justifyContentOffset};
   }
 
   YGAlign alignContent() const {
-    return facebook::yoga::detail::getEnumData<YGAlign>(
-        flags, alignContentOffset);
+    return getEnumData<YGAlign>(flags, alignContentOffset);
   }
   BitfieldRef<YGAlign> alignContent() { return {*this, alignContentOffset}; }
 
   YGAlign alignItems() const {
-    return facebook::yoga::detail::getEnumData<YGAlign>(
-        flags, alignItemsOffset);
+    return getEnumData<YGAlign>(flags, alignItemsOffset);
   }
   BitfieldRef<YGAlign> alignItems() { return {*this, alignItemsOffset}; }
 
   YGAlign alignSelf() const {
-    return facebook::yoga::detail::getEnumData<YGAlign>(flags, alignSelfOffset);
+    return getEnumData<YGAlign>(flags, alignSelfOffset);
   }
   BitfieldRef<YGAlign> alignSelf() { return {*this, alignSelfOffset}; }
 
   YGPositionType positionType() const {
-    return facebook::yoga::detail::getEnumData<YGPositionType>(
-        flags, positionTypeOffset);
+    return getEnumData<YGPositionType>(flags, positionTypeOffset);
   }
   BitfieldRef<YGPositionType> positionType() {
     return {*this, positionTypeOffset};
   }
 
-  YGWrap flexWrap() const {
-    return facebook::yoga::detail::getEnumData<YGWrap>(flags, flexWrapOffset);
-  }
+  YGWrap flexWrap() const { return getEnumData<YGWrap>(flags, flexWrapOffset); }
   BitfieldRef<YGWrap> flexWrap() { return {*this, flexWrapOffset}; }
 
   YGOverflow overflow() const {
-    return facebook::yoga::detail::getEnumData<YGOverflow>(
-        flags, overflowOffset);
+    return getEnumData<YGOverflow>(flags, overflowOffset);
   }
   BitfieldRef<YGOverflow> overflow() { return {*this, overflowOffset}; }
 
   YGDisplay display() const {
-    return facebook::yoga::detail::getEnumData<YGDisplay>(flags, displayOffset);
+    return getEnumData<YGDisplay>(flags, displayOffset);
   }
   BitfieldRef<YGDisplay> display() { return {*this, displayOffset}; }