diff --git a/tests/BitUtilsTest.cpp b/tests/BitUtilsTest.cpp
deleted file mode 100644
index 211a155ca9..0000000000
--- a/tests/BitUtilsTest.cpp
+++ /dev/null
@@ -1,204 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#include <gtest/gtest.h>
-
-#include <cstdint>
-#include <yoga/BitUtils.h>
-
-namespace facebook::yoga {
-
-TEST(BitUtils, one_boolean_defaults_to_false) {
-  constexpr uint8_t flags = 0;
-
-  ASSERT_EQ(detail::getBooleanData(flags, 0), false);
-  static_assert(
-      detail::getBooleanData(flags, 0) == false,
-      "first boolean member must default to false");
-}
-
-TEST(BitUtils, one_boolean_can_be_initialized_to_true) {
-  constexpr uint8_t flags = 1;
-
-  ASSERT_EQ(detail::getBooleanData(flags, 0), true);
-  static_assert(
-      detail::getBooleanData(flags, 0) == true,
-      "first boolean member must be initialized to true");
-}
-
-TEST(BitUtils, one_boolean_can_be_set_to_true) {
-  uint8_t flags = 0;
-
-  detail::setBooleanData(flags, 0, true);
-  ASSERT_EQ(detail::getBooleanData(flags, 0), true);
-}
-
-TEST(BitUtils, second_boolean_defaults_to_false) {
-  constexpr uint8_t flags = 0;
-
-  ASSERT_EQ(detail::getBooleanData(flags, 1), false);
-  static_assert(
-      detail::getBooleanData(flags, 1) == false,
-      "second boolean member must default to false");
-}
-
-TEST(BitUtils, second_boolean_can_be_initialized_to_true) {
-  constexpr uint8_t flags = 2;
-
-  ASSERT_EQ(detail::getBooleanData(flags, 0), false);
-  ASSERT_EQ(detail::getBooleanData(flags, 1), true);
-  static_assert(
-      detail::getBooleanData(flags, 0) == false,
-      "first boolean member must default to false");
-  static_assert(
-      detail::getBooleanData(flags, 1) == true,
-      "second boolean member must be initialized to true");
-}
-
-TEST(BitUtils, second_boolean_can_be_set_to_true) {
-  uint8_t flags = 0;
-
-  detail::setBooleanData(flags, 1, true);
-  ASSERT_EQ(detail::getBooleanData(flags, 0), false);
-  ASSERT_EQ(detail::getBooleanData(flags, 1), true);
-}
-
-TEST(BitUtils, third_boolean_defaults_to_false) {
-  constexpr uint8_t flags = 0;
-
-  ASSERT_EQ(detail::getBooleanData(flags, 2), false);
-  static_assert(
-      detail::getBooleanData(flags, 2) == false,
-      "second boolean member must default to false");
-}
-
-TEST(BitUtils, third_boolean_can_be_initialized_to_true) {
-  constexpr uint8_t flags = 4;
-
-  ASSERT_EQ(detail::getBooleanData(flags, 0), false);
-  ASSERT_EQ(detail::getBooleanData(flags, 1), false);
-  ASSERT_EQ(detail::getBooleanData(flags, 2), true);
-  static_assert(
-      detail::getBooleanData(flags, 0) == false,
-      "first boolean member must default to false");
-  static_assert(
-      detail::getBooleanData(flags, 1) == false,
-      "second boolean member must default to false");
-  static_assert(
-      detail::getBooleanData(flags, 2) == true,
-      "second boolean member must be initialized to true");
-}
-
-TEST(BitUtils, third_boolean_can_be_set_to_true) {
-  uint8_t flags = 0;
-
-  detail::setBooleanData(flags, 2, true);
-  ASSERT_EQ(detail::getBooleanData(flags, 0), false);
-  ASSERT_EQ(detail::getBooleanData(flags, 1), false);
-  ASSERT_EQ(detail::getBooleanData(flags, 2), true);
-}
-
-TEST(BitUtils, setting_boolean_values_does_not_spill_over) {
-  uint8_t flags = 0;
-
-  detail::setBooleanData(flags, 1, (bool) 7);
-
-  ASSERT_EQ(detail::getBooleanData(flags, 0), false);
-  ASSERT_EQ(detail::getBooleanData(flags, 1), true);
-  ASSERT_EQ(detail::getBooleanData(flags, 2), false);
-}
-
-TEST(BitUtils, first_enum_defaults_to_0) {
-  constexpr uint8_t flags = 0;
-
-  ASSERT_EQ(detail::getEnumData<YGAlign>(flags, 0), YGAlignAuto);
-  static_assert(
-      detail::getEnumData<YGAlign>(flags, 0) == YGAlignAuto,
-      "first enum member must default to 0");
-}
-
-TEST(BitUtils, first_enum_can_be_set) {
-  uint8_t flags = 0;
-
-  detail::setEnumData<YGAlign>(flags, 0, YGAlignSpaceBetween);
-
-  ASSERT_EQ(detail::getEnumData<YGAlign>(flags, 0), YGAlignSpaceBetween);
-}
-
-TEST(BitUtils, second_enum_defaults_to_0) {
-  constexpr uint8_t flags = 0;
-  static constexpr size_t alignOffset = 0;
-  static constexpr size_t edgeOffset = 3;
-
-  ASSERT_EQ(detail::getEnumData<YGAlign>(flags, alignOffset), YGAlignAuto);
-  ASSERT_EQ(detail::getEnumData<YGEdge>(flags, edgeOffset), YGEdgeLeft);
-  static_assert(
-      detail::getEnumData<YGAlign>(flags, alignOffset) == YGAlignAuto,
-      "first enum member must default to 0");
-  static_assert(
-      detail::getEnumData<YGEdge>(flags, edgeOffset) == YGEdgeLeft,
-      "second enum member must default to 0");
-}
-
-TEST(BitUtils, second_enum_can_be_set) {
-  uint8_t flags = 0;
-  static constexpr size_t alignOffset = 0;
-  static constexpr size_t edgeOffset = 3;
-
-  detail::setEnumData<YGEdge>(flags, edgeOffset, YGEdgeAll);
-
-  ASSERT_EQ(detail::getEnumData<YGAlign>(flags, alignOffset), YGAlignAuto);
-  ASSERT_EQ(detail::getEnumData<YGEdge>(flags, edgeOffset), YGEdgeAll);
-}
-
-TEST(BitUtils, third_enum_defaults_to_0) {
-  constexpr uint8_t flags = 0;
-  static constexpr size_t alignOffset = 0;
-  static constexpr size_t boolOffset = 3;
-  static constexpr size_t edgesOffset = 4;
-
-  ASSERT_EQ(detail::getEnumData<YGAlign>(flags, alignOffset), YGAlignAuto);
-  ASSERT_EQ(detail::getBooleanData(flags, boolOffset), false);
-  ASSERT_EQ(detail::getEnumData<YGEdge>(flags, edgesOffset), YGEdgeLeft);
-  static_assert(
-      detail::getEnumData<YGAlign>(flags, alignOffset) == YGAlignAuto,
-      "first enum member must default to 0");
-  static_assert(
-      detail::getBooleanData(flags, boolOffset) == false,
-      "middle boolean member must default to false");
-  static_assert(
-      detail::getEnumData<YGEdge>(flags, edgesOffset) == YGEdgeLeft,
-      "last enum member must default to 0");
-}
-
-TEST(BitUtils, third_enum_can_be_set) {
-  uint8_t flags = 0;
-  static constexpr size_t alignOffset = 0;
-  static constexpr size_t boolOffset = 3;
-  static constexpr size_t edgesOffset = 4;
-
-  detail::setEnumData<YGEdge>(flags, edgesOffset, YGEdgeVertical);
-
-  ASSERT_EQ(detail::getEnumData<YGAlign>(flags, alignOffset), YGAlignAuto);
-  ASSERT_EQ(detail::getBooleanData(flags, boolOffset), false);
-  ASSERT_EQ(detail::getEnumData<YGEdge>(flags, edgesOffset), YGEdgeVertical);
-}
-
-TEST(BitUtils, setting_values_does_not_spill_over) {
-  uint8_t flags = 0;
-  static constexpr size_t alignOffset = 0;
-  static constexpr size_t edgesOffset = 3;
-  static constexpr size_t boolOffset = 7;
-
-  detail::setEnumData<YGEdge>(flags, edgesOffset, (YGEdge) 0xffffff);
-
-  ASSERT_EQ(detail::getEnumData<YGAlign>(flags, alignOffset), 0);
-  ASSERT_EQ(detail::getBooleanData(flags, boolOffset), false);
-  ASSERT_EQ(detail::getEnumData<YGEdge>(flags, edgesOffset), 0xf);
-}
-
-} // namespace facebook::yoga
diff --git a/tests/NumericBitfieldTest.cpp b/tests/NumericBitfieldTest.cpp
new file mode 100644
index 0000000000..9b487cee21
--- /dev/null
+++ b/tests/NumericBitfieldTest.cpp
@@ -0,0 +1,204 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include <gtest/gtest.h>
+
+#include <cstdint>
+#include <yoga/bits/NumericBitfield.h>
+
+namespace facebook::yoga {
+
+TEST(NumericBitfield, one_boolean_defaults_to_false) {
+  constexpr uint8_t flags = 0;
+
+  ASSERT_EQ(getBooleanData(flags, 0), false);
+  static_assert(
+      getBooleanData(flags, 0) == false,
+      "first boolean member must default to false");
+}
+
+TEST(NumericBitfield, one_boolean_can_be_initialized_to_true) {
+  constexpr uint8_t flags = 1;
+
+  ASSERT_EQ(getBooleanData(flags, 0), true);
+  static_assert(
+      getBooleanData(flags, 0) == true,
+      "first boolean member must be initialized to true");
+}
+
+TEST(NumericBitfield, one_boolean_can_be_set_to_true) {
+  uint8_t flags = 0;
+
+  setBooleanData(flags, 0, true);
+  ASSERT_EQ(getBooleanData(flags, 0), true);
+}
+
+TEST(NumericBitfield, second_boolean_defaults_to_false) {
+  constexpr uint8_t flags = 0;
+
+  ASSERT_EQ(getBooleanData(flags, 1), false);
+  static_assert(
+      getBooleanData(flags, 1) == false,
+      "second boolean member must default to false");
+}
+
+TEST(NumericBitfield, second_boolean_can_be_initialized_to_true) {
+  constexpr uint8_t flags = 2;
+
+  ASSERT_EQ(getBooleanData(flags, 0), false);
+  ASSERT_EQ(getBooleanData(flags, 1), true);
+  static_assert(
+      getBooleanData(flags, 0) == false,
+      "first boolean member must default to false");
+  static_assert(
+      getBooleanData(flags, 1) == true,
+      "second boolean member must be initialized to true");
+}
+
+TEST(NumericBitfield, second_boolean_can_be_set_to_true) {
+  uint8_t flags = 0;
+
+  setBooleanData(flags, 1, true);
+  ASSERT_EQ(getBooleanData(flags, 0), false);
+  ASSERT_EQ(getBooleanData(flags, 1), true);
+}
+
+TEST(NumericBitfield, third_boolean_defaults_to_false) {
+  constexpr uint8_t flags = 0;
+
+  ASSERT_EQ(getBooleanData(flags, 2), false);
+  static_assert(
+      getBooleanData(flags, 2) == false,
+      "second boolean member must default to false");
+}
+
+TEST(NumericBitfield, third_boolean_can_be_initialized_to_true) {
+  constexpr uint8_t flags = 4;
+
+  ASSERT_EQ(getBooleanData(flags, 0), false);
+  ASSERT_EQ(getBooleanData(flags, 1), false);
+  ASSERT_EQ(getBooleanData(flags, 2), true);
+  static_assert(
+      getBooleanData(flags, 0) == false,
+      "first boolean member must default to false");
+  static_assert(
+      getBooleanData(flags, 1) == false,
+      "second boolean member must default to false");
+  static_assert(
+      getBooleanData(flags, 2) == true,
+      "second boolean member must be initialized to true");
+}
+
+TEST(NumericBitfield, third_boolean_can_be_set_to_true) {
+  uint8_t flags = 0;
+
+  setBooleanData(flags, 2, true);
+  ASSERT_EQ(getBooleanData(flags, 0), false);
+  ASSERT_EQ(getBooleanData(flags, 1), false);
+  ASSERT_EQ(getBooleanData(flags, 2), true);
+}
+
+TEST(NumericBitfield, setting_boolean_values_does_not_spill_over) {
+  uint8_t flags = 0;
+
+  setBooleanData(flags, 1, (bool) 7);
+
+  ASSERT_EQ(getBooleanData(flags, 0), false);
+  ASSERT_EQ(getBooleanData(flags, 1), true);
+  ASSERT_EQ(getBooleanData(flags, 2), false);
+}
+
+TEST(NumericBitfield, first_enum_defaults_to_0) {
+  constexpr uint8_t flags = 0;
+
+  ASSERT_EQ(getEnumData<YGAlign>(flags, 0), YGAlignAuto);
+  static_assert(
+      getEnumData<YGAlign>(flags, 0) == YGAlignAuto,
+      "first enum member must default to 0");
+}
+
+TEST(NumericBitfield, first_enum_can_be_set) {
+  uint8_t flags = 0;
+
+  setEnumData<YGAlign>(flags, 0, YGAlignSpaceBetween);
+
+  ASSERT_EQ(getEnumData<YGAlign>(flags, 0), YGAlignSpaceBetween);
+}
+
+TEST(NumericBitfield, second_enum_defaults_to_0) {
+  constexpr uint8_t flags = 0;
+  static constexpr size_t alignOffset = 0;
+  static constexpr size_t edgeOffset = 3;
+
+  ASSERT_EQ(getEnumData<YGAlign>(flags, alignOffset), YGAlignAuto);
+  ASSERT_EQ(getEnumData<YGEdge>(flags, edgeOffset), YGEdgeLeft);
+  static_assert(
+      getEnumData<YGAlign>(flags, alignOffset) == YGAlignAuto,
+      "first enum member must default to 0");
+  static_assert(
+      getEnumData<YGEdge>(flags, edgeOffset) == YGEdgeLeft,
+      "second enum member must default to 0");
+}
+
+TEST(NumericBitfield, second_enum_can_be_set) {
+  uint8_t flags = 0;
+  static constexpr size_t alignOffset = 0;
+  static constexpr size_t edgeOffset = 3;
+
+  setEnumData<YGEdge>(flags, edgeOffset, YGEdgeAll);
+
+  ASSERT_EQ(getEnumData<YGAlign>(flags, alignOffset), YGAlignAuto);
+  ASSERT_EQ(getEnumData<YGEdge>(flags, edgeOffset), YGEdgeAll);
+}
+
+TEST(NumericBitfield, third_enum_defaults_to_0) {
+  constexpr uint8_t flags = 0;
+  static constexpr size_t alignOffset = 0;
+  static constexpr size_t boolOffset = 3;
+  static constexpr size_t edgesOffset = 4;
+
+  ASSERT_EQ(getEnumData<YGAlign>(flags, alignOffset), YGAlignAuto);
+  ASSERT_EQ(getBooleanData(flags, boolOffset), false);
+  ASSERT_EQ(getEnumData<YGEdge>(flags, edgesOffset), YGEdgeLeft);
+  static_assert(
+      getEnumData<YGAlign>(flags, alignOffset) == YGAlignAuto,
+      "first enum member must default to 0");
+  static_assert(
+      getBooleanData(flags, boolOffset) == false,
+      "middle boolean member must default to false");
+  static_assert(
+      getEnumData<YGEdge>(flags, edgesOffset) == YGEdgeLeft,
+      "last enum member must default to 0");
+}
+
+TEST(NumericBitfield, third_enum_can_be_set) {
+  uint8_t flags = 0;
+  static constexpr size_t alignOffset = 0;
+  static constexpr size_t boolOffset = 3;
+  static constexpr size_t edgesOffset = 4;
+
+  setEnumData<YGEdge>(flags, edgesOffset, YGEdgeVertical);
+
+  ASSERT_EQ(getEnumData<YGAlign>(flags, alignOffset), YGAlignAuto);
+  ASSERT_EQ(getBooleanData(flags, boolOffset), false);
+  ASSERT_EQ(getEnumData<YGEdge>(flags, edgesOffset), YGEdgeVertical);
+}
+
+TEST(NumericBitfield, setting_values_does_not_spill_over) {
+  uint8_t flags = 0;
+  static constexpr size_t alignOffset = 0;
+  static constexpr size_t edgesOffset = 3;
+  static constexpr size_t boolOffset = 7;
+
+  setEnumData<YGEdge>(flags, edgesOffset, (YGEdge) 0xffffff);
+
+  ASSERT_EQ(getEnumData<YGAlign>(flags, alignOffset), 0);
+  ASSERT_EQ(getBooleanData(flags, boolOffset), false);
+  ASSERT_EQ(getEnumData<YGEdge>(flags, edgesOffset), 0xf);
+}
+
+} // namespace facebook::yoga
diff --git a/yoga/bits/EnumBitset.h b/yoga/bits/EnumBitset.h
new file mode 100644
index 0000000000..3dff663f8f
--- /dev/null
+++ b/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/yoga/BitUtils.h b/yoga/bits/NumericBitfield.h
similarity index 64%
rename from yoga/BitUtils.h
rename to yoga/bits/NumericBitfield.h
index 7c91550585..af3fc6927d 100644
--- a/yoga/BitUtils.h
+++ b/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/yoga/config/Config.cpp b/yoga/config/Config.cpp
index 2f07454b97..d8809cf5a2 100644
--- a/yoga/config/Config.cpp
+++ b/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/yoga/config/Config.h b/yoga/config/Config.h
index 6470ebde4d..d0894b86be 100644
--- a/yoga/config/Config.h
+++ b/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 @@ class YOGA_EXPORT Config : public ::YGConfig {
       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 @@ class YOGA_EXPORT Config : public ::YGConfig {
   } logger_;
 
   ConfigFlags flags_{};
-  ExperimentalFeatureSet experimentalFeatures_{};
+  EnumBitset<YGExperimentalFeature> experimentalFeatures_{};
   YGErrata errata_ = YGErrataNone;
   float pointScaleFactor_ = 1.0f;
   void* context_ = nullptr;
diff --git a/yoga/node/LayoutResults.h b/yoga/node/LayoutResults.h
index d920e9a24c..c0d2bee26d 100644
--- a/yoga/node/LayoutResults.h
+++ b/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 @@ struct LayoutResults {
   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/yoga/style/Style.h b/yoga/style/Style.h
index 49bb8ece67..10854fd6fb 100644
--- a/yoga/style/Style.h
+++ b/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 @@ class YOGA_EXPORT Style {
   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 @@ class YOGA_EXPORT Style {
 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 @@ class YOGA_EXPORT Style {
   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}; }