diff --git a/extras/tests/ResourceManager/StringBuffer.cpp b/extras/tests/ResourceManager/StringBuffer.cpp
index 167120f4..fc164a5d 100644
--- a/extras/tests/ResourceManager/StringBuffer.cpp
+++ b/extras/tests/ResourceManager/StringBuffer.cpp
@@ -21,7 +21,7 @@ TEST_CASE("StringBuffer") {
     strcpy(ptr, "hi!");
     sb.save(&variant);
 
-    REQUIRE(variant.type() == VariantType::TinyString);
+    REQUIRE(variant.type == VariantType::TinyString);
     REQUIRE(variant.asString() == "hi!");
   }
 
@@ -30,7 +30,7 @@ TEST_CASE("StringBuffer") {
     memcpy(ptr, "a\0b", 3);
     sb.save(&variant);
 
-    REQUIRE(variant.type() == VariantType::LongString);
+    REQUIRE(variant.type == VariantType::LongString);
 
     auto str = variant.asString();
     REQUIRE(str.size() == 3);
@@ -44,7 +44,7 @@ TEST_CASE("StringBuffer") {
     strcpy(ptr, "alfa");
     sb.save(&variant);
 
-    REQUIRE(variant.type() == VariantType::LongString);
+    REQUIRE(variant.type == VariantType::LongString);
     REQUIRE(variant.asString() == "alfa");
   }
 }
diff --git a/extras/tests/ResourceManager/StringBuilder.cpp b/extras/tests/ResourceManager/StringBuilder.cpp
index 5c6dd220..541bbb60 100644
--- a/extras/tests/ResourceManager/StringBuilder.cpp
+++ b/extras/tests/ResourceManager/StringBuilder.cpp
@@ -26,7 +26,7 @@ TEST_CASE("StringBuilder") {
     REQUIRE(spyingAllocator.log() == AllocatorLog{
                                          Allocate(sizeofStringBuffer()),
                                      });
-    REQUIRE(data.type() == VariantType::TinyString);
+    REQUIRE(data.type == VariantType::TinyString);
   }
 
   SECTION("Tiny string") {
@@ -45,7 +45,7 @@ TEST_CASE("StringBuilder") {
     str.save(&data);
 
     REQUIRE(resources.overflowed() == false);
-    REQUIRE(data.type() == VariantType::TinyString);
+    REQUIRE(data.type == VariantType::TinyString);
     REQUIRE(data.asString() == "url");
   }
 
diff --git a/src/ArduinoJson/Array/ElementProxy.hpp b/src/ArduinoJson/Array/ElementProxy.hpp
index 05f69d95..c42c2432 100644
--- a/src/ArduinoJson/Array/ElementProxy.hpp
+++ b/src/ArduinoJson/Array/ElementProxy.hpp
@@ -55,17 +55,12 @@ class ElementProxy : public VariantRefBase<ElementProxy<TUpstream>>,
   }
 
   FORCE_INLINE VariantData* getData() const {
-    auto data = VariantAttorney::getData(upstream_);
-    auto resources = VariantAttorney::getResourceManager(upstream_);
-    return VariantData::asArray(data, resources).getElement(index_);
+    return VariantAttorney::getVariantImpl(upstream_).getElement(index_);
   }
 
   VariantData* getOrCreateData() const {
-    auto data = VariantAttorney::getOrCreateData(upstream_);
-    if (!data)
-      return nullptr;
-    return data->getOrAddElement(
-        index_, VariantAttorney::getResourceManager(upstream_));
+    return VariantAttorney::getOrCreateVariantImpl(upstream_).getOrAddElement(
+        index_);
   }
 
   TUpstream upstream_;
diff --git a/src/ArduinoJson/Array/JsonArray.hpp b/src/ArduinoJson/Array/JsonArray.hpp
index a2d2c1ae..37676d50 100644
--- a/src/ArduinoJson/Array/JsonArray.hpp
+++ b/src/ArduinoJson/Array/JsonArray.hpp
@@ -24,7 +24,7 @@ class JsonArray : public detail::VariantOperators<JsonArray> {
 
   // INTERNAL USE ONLY
   JsonArray(detail::VariantData* data, detail::ResourceManager* resources)
-      : impl_(detail::VariantData::asArray(data, resources)) {}
+      : impl_(detail::VariantImpl::asArray(data, resources)) {}
 
   // INTERNAL USE ONLY
   JsonArray(const detail::ArrayImpl& impl) : impl_(impl) {}
diff --git a/src/ArduinoJson/Array/JsonArrayConst.hpp b/src/ArduinoJson/Array/JsonArrayConst.hpp
index 918f5f95..8dc20516 100644
--- a/src/ArduinoJson/Array/JsonArrayConst.hpp
+++ b/src/ArduinoJson/Array/JsonArrayConst.hpp
@@ -38,7 +38,7 @@ class JsonArrayConst : public detail::VariantOperators<JsonArrayConst> {
 
   // INTERNAL USE ONLY
   JsonArrayConst(detail::VariantData* data, detail::ResourceManager* resources)
-      : impl_(detail::VariantData::asArray(data, resources)) {}
+      : impl_(detail::VariantImpl::asArray(data, resources)) {}
 
   // INTERNAL USE ONLY
   JsonArrayConst(const detail::ArrayImpl& impl) : impl_(impl) {}
diff --git a/src/ArduinoJson/Collection/CollectionData.hpp b/src/ArduinoJson/Collection/CollectionData.hpp
index 8548b8a9..46ec0b21 100644
--- a/src/ArduinoJson/Collection/CollectionData.hpp
+++ b/src/ArduinoJson/Collection/CollectionData.hpp
@@ -12,7 +12,7 @@
 
 ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
 
-class VariantData;
+struct VariantData;
 class ResourceManager;
 
 class CollectionIterator {
diff --git a/src/ArduinoJson/Collection/CollectionImpl.hpp b/src/ArduinoJson/Collection/CollectionImpl.hpp
index b15a8095..f0e88ef1 100644
--- a/src/ArduinoJson/Collection/CollectionImpl.hpp
+++ b/src/ArduinoJson/Collection/CollectionImpl.hpp
@@ -14,7 +14,7 @@ ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
 
 inline void CollectionIterator::next(const ResourceManager* resources) {
   ARDUINOJSON_ASSERT(slot_);
-  auto nextId = slot_->next();
+  auto nextId = slot_->next;
   slot_ = resources->getVariant(nextId);
   currentId_ = nextId;
 }
@@ -31,7 +31,7 @@ inline void CollectionImpl::appendOne(Slot<VariantData> slot) {
 
   if (data_->tail != NULL_SLOT) {
     auto tail = resources_->getVariant(data_->tail);
-    tail->setNext(slot.id());
+    tail->next = slot.id();
     data_->tail = slot.id();
   } else {
     data_->head = slot.id();
@@ -44,11 +44,11 @@ inline void CollectionImpl::appendPair(Slot<VariantData> key,
   ARDUINOJSON_ASSERT(data_ != nullptr);
   ARDUINOJSON_ASSERT(resources_ != nullptr);
 
-  key->setNext(value.id());
+  key->next = value.id();
 
   if (data_->tail != NULL_SLOT) {
     auto tail = resources_->getVariant(data_->tail);
-    tail->setNext(key.id());
+    tail->next = key.id();
     data_->tail = value.id();
   } else {
     data_->head = key.id();
@@ -63,7 +63,7 @@ inline void CollectionImpl::clear() {
   while (next != NULL_SLOT) {
     auto currId = next;
     auto slot = resources_->getVariant(next);
-    next = slot->next();
+    next = slot->next;
     resources_->freeVariant({slot, currId});
   }
 
@@ -80,7 +80,7 @@ inline Slot<VariantData> CollectionImpl::getPreviousSlot(
     if (currentSlot == target)
       break;
     prev = Slot<VariantData>(currentSlot, currentId);
-    currentId = currentSlot->next();
+    currentId = currentSlot->next;
   }
   return prev;
 }
@@ -90,9 +90,9 @@ inline void CollectionImpl::removeOne(iterator it) {
     return;
   auto curr = it.slot_;
   auto prev = getPreviousSlot(curr);
-  auto next = curr->next();
+  auto next = curr->next;
   if (prev)
-    prev->setNext(next);
+    prev->next = next;
   else
     data_->head = next;
   if (next == NULL_SLOT)
@@ -106,11 +106,11 @@ inline void CollectionImpl::removePair(ObjectImpl::iterator it) {
 
   auto keySlot = it.slot_;
 
-  auto valueId = keySlot->next();
+  auto valueId = keySlot->next;
   auto valueSlot = resources_->getVariant(valueId);
 
   // remove value slot
-  keySlot->setNext(valueSlot->next());
+  keySlot->next = valueSlot->next;
   resources_->freeVariant({valueSlot, valueId});
 
   // remove key slot
@@ -122,7 +122,7 @@ inline size_t CollectionImpl::nesting() const {
     return 0;
   size_t maxChildNesting = 0;
   for (auto it = createIterator(); !it.done(); it.next(resources_)) {
-    size_t childNesting = it->nesting(resources_);
+    size_t childNesting = VariantImpl(it.data(), resources_).nesting();
     if (childNesting > maxChildNesting)
       maxChildNesting = childNesting;
   }
diff --git a/src/ArduinoJson/Document/JsonDocument.hpp b/src/ArduinoJson/Document/JsonDocument.hpp
index 9980c424..5da7b0a6 100644
--- a/src/ArduinoJson/Document/JsonDocument.hpp
+++ b/src/ArduinoJson/Document/JsonDocument.hpp
@@ -88,7 +88,7 @@ class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
   // https://arduinojson.org/v7/api/jsondocument/clear/
   void clear() {
     resources_.clear();
-    data_.reset();
+    data_.type = detail::VariantType::Null;
   }
 
   // Returns true if the root is of the specified type.
@@ -120,13 +120,13 @@ class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
   // Returns the depth (nesting level) of the array.
   // https://arduinojson.org/v7/api/jsondocument/nesting/
   size_t nesting() const {
-    return data_.nesting(&resources_);
+    return getVariantImpl().nesting();
   }
 
   // Returns the number of elements in the root array or object.
   // https://arduinojson.org/v7/api/jsondocument/size/
   size_t size() const {
-    return data_.size(&resources_);
+    return getVariantImpl().size();
   }
 
   // Copies the specified document.
@@ -165,7 +165,7 @@ class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
   template <typename TChar>
   ARDUINOJSON_DEPRECATED("use doc[\"key\"].is<T>() instead")
   bool containsKey(TChar* key) const {
-    return data_.getMember(detail::adaptString(key), &resources_) != 0;
+    return getVariantImpl().getMember(detail::adaptString(key)) != 0;
   }
 
   // DEPRECATED: use obj[key].is<T>() instead
@@ -174,7 +174,7 @@ class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
             detail::enable_if_t<detail::IsString<TString>::value, int> = 0>
   ARDUINOJSON_DEPRECATED("use doc[key].is<T>() instead")
   bool containsKey(const TString& key) const {
-    return data_.getMember(detail::adaptString(key), &resources_) != 0;
+    return getVariantImpl().getMember(detail::adaptString(key)) != 0;
   }
 
   // DEPRECATED: use obj[key].is<T>() instead
@@ -212,7 +212,7 @@ class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
             detail::enable_if_t<detail::IsString<TString>::value, int> = 0>
   JsonVariantConst operator[](const TString& key) const {
     return JsonVariantConst(
-        data_.getMember(detail::adaptString(key), &resources_), &resources_);
+        getVariantImpl().getMember(detail::adaptString(key)), &resources_);
   }
 
   // Gets a root object's member.
@@ -223,7 +223,7 @@ class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
                                 int> = 0>
   JsonVariantConst operator[](TChar* key) const {
     return JsonVariantConst(
-        data_.getMember(detail::adaptString(key), &resources_), &resources_);
+        getVariantImpl().getMember(detail::adaptString(key)), &resources_);
   }
 
   // Gets or sets a root array's element.
@@ -237,7 +237,7 @@ class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
   // Gets a root array's member.
   // https://arduinojson.org/v7/api/jsondocument/subscript/
   JsonVariantConst operator[](size_t index) const {
-    return JsonVariantConst(data_.getElement(index, &resources_), &resources_);
+    return JsonVariantConst(getVariantImpl().getElement(index), &resources_);
   }
 
   // Gets or sets a root object's member.
@@ -267,14 +267,14 @@ class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
   template <typename T, detail::enable_if_t<
                             detail::is_same<T, JsonVariant>::value, int> = 0>
   JsonVariant add() {
-    return JsonVariant(data_.addElement(&resources_), &resources_);
+    return JsonVariant(getVariantImpl().addElement(), &resources_);
   }
 
   // Appends a value to the root array.
   // https://arduinojson.org/v7/api/jsondocument/add/
   template <typename TValue>
   bool add(const TValue& value) {
-    return data_.addValue(value, &resources_);
+    return getVariantImpl().addValue(value);
   }
 
   // Appends a value to the root array.
@@ -282,7 +282,7 @@ class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
   template <typename TChar,
             detail::enable_if_t<!detail::is_const<TChar>::value, int> = 0>
   bool add(TChar* value) {
-    return data_.addValue(value, &resources_);
+    return getVariantImpl().addValue(value);
   }
 
   // Removes an element of the root array.
@@ -290,8 +290,7 @@ class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
   template <typename T,
             detail::enable_if_t<detail::is_integral<T>::value, int> = 0>
   void remove(T index) {
-    detail::VariantData::removeElement(getData(), size_t(index),
-                                       getResourceManager());
+    getVariantImpl().removeElement(size_t(index));
   }
 
   // Removes a member of the root object.
@@ -301,8 +300,7 @@ class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
                                     !detail::is_const<TChar>::value,
                                 int> = 0>
   void remove(TChar* key) {
-    detail::VariantData::removeMember(getData(), detail::adaptString(key),
-                                      getResourceManager());
+    getVariantImpl().removeMember(detail::adaptString(key));
   }
 
   // Removes a member of the root object.
@@ -310,8 +308,7 @@ class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
   template <typename TString,
             detail::enable_if_t<detail::IsString<TString>::value, int> = 0>
   void remove(const TString& key) {
-    detail::VariantData::removeMember(getData(), detail::adaptString(key),
-                                      getResourceManager());
+    getVariantImpl().removeMember(detail::adaptString(key));
   }
 
   // Removes a member of the root object or an element of the root array.
@@ -391,6 +388,10 @@ class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
   }
 
  private:
+  detail::VariantImpl getVariantImpl() const {
+    return detail::VariantImpl(&data_, &resources_);
+  }
+
   JsonVariant getVariant() {
     return JsonVariant(&data_, &resources_);
   }
diff --git a/src/ArduinoJson/Json/JsonDeserializer.hpp b/src/ArduinoJson/Json/JsonDeserializer.hpp
index 91449229..dfb1f165 100644
--- a/src/ArduinoJson/Json/JsonDeserializer.hpp
+++ b/src/ArduinoJson/Json/JsonDeserializer.hpp
@@ -71,13 +71,14 @@ class JsonDeserializer {
     switch (current()) {
       case '[':
         if (filter.allowArray())
-          return parseArray(variant->toArray(resources_), filter, nestingLimit);
+          return parseArray(VariantImpl::toArray(variant, resources_), filter,
+                            nestingLimit);
         else
           return skipArray(nestingLimit);
 
       case '{':
         if (filter.allowObject())
-          return parseObject(variant->toObject(resources_), filter,
+          return parseObject(VariantImpl::toObject(variant, resources_), filter,
                              nestingLimit);
         else
           return skipObject(nestingLimit);
@@ -282,7 +283,7 @@ class JsonDeserializer {
 
           stringBuilder_.save(keyVariant);
         } else {
-          member->clear(resources_);
+          VariantImpl::clear(member, resources_);
         }
 
         // Parse value
@@ -519,26 +520,28 @@ class JsonDeserializer {
     auto number = parseNumber(buffer_);
     switch (number.type()) {
       case NumberType::UnsignedInteger:
-        if (result->setInteger(number.asUnsignedInteger(), resources_))
+        if (VariantImpl::setInteger(number.asUnsignedInteger(), result,
+                                    resources_))
           return DeserializationError::Ok;
         else
           return DeserializationError::NoMemory;
 
       case NumberType::SignedInteger:
-        if (result->setInteger(number.asSignedInteger(), resources_))
+        if (VariantImpl::setInteger(number.asSignedInteger(), result,
+                                    resources_))
           return DeserializationError::Ok;
         else
           return DeserializationError::NoMemory;
 
       case NumberType::Float:
-        if (result->setFloat(number.asFloat(), resources_))
+        if (VariantImpl::setFloat(number.asFloat(), result, resources_))
           return DeserializationError::Ok;
         else
           return DeserializationError::NoMemory;
 
 #if ARDUINOJSON_USE_DOUBLE
       case NumberType::Double:
-        if (result->setFloat(number.asDouble(), resources_))
+        if (VariantImpl::setFloat(number.asDouble(), result, resources_))
           return DeserializationError::Ok;
         else
           return DeserializationError::NoMemory;
diff --git a/src/ArduinoJson/Json/JsonSerializer.hpp b/src/ArduinoJson/Json/JsonSerializer.hpp
index e1bb6da8..80314438 100644
--- a/src/ArduinoJson/Json/JsonSerializer.hpp
+++ b/src/ArduinoJson/Json/JsonSerializer.hpp
@@ -27,9 +27,9 @@ class JsonSerializer : public VariantDataVisitor<size_t> {
     while (slotId != NULL_SLOT) {
       auto slot = resources_->getVariant(slotId);
 
-      slot->accept(*this, resources_);
+      VariantImpl::accept(*this, slot, resources_);
 
-      slotId = slot->next();
+      slotId = slot->next;
 
       if (slotId != NULL_SLOT)
         write(',');
@@ -48,9 +48,9 @@ class JsonSerializer : public VariantDataVisitor<size_t> {
 
     while (slotId != NULL_SLOT) {
       auto slot = resources_->getVariant(slotId);
-      slot->accept(*this, resources_);
+      VariantImpl::accept(*this, slot, resources_);
 
-      slotId = slot->next();
+      slotId = slot->next;
 
       if (slotId != NULL_SLOT)
         write(isKey ? ':' : ',');
diff --git a/src/ArduinoJson/Json/PrettyJsonSerializer.hpp b/src/ArduinoJson/Json/PrettyJsonSerializer.hpp
index 29c01f8c..99567c95 100644
--- a/src/ArduinoJson/Json/PrettyJsonSerializer.hpp
+++ b/src/ArduinoJson/Json/PrettyJsonSerializer.hpp
@@ -26,7 +26,7 @@ class PrettyJsonSerializer : public JsonSerializer<TWriter> {
       nesting_++;
       while (!it.done()) {
         indent();
-        it->accept(*this, base::resources_);
+        VariantImpl::accept(*this, it.data(), base::resources_);
 
         it.next(base::resources_);
         base::write(it.done() ? "\r\n" : ",\r\n");
@@ -49,7 +49,7 @@ class PrettyJsonSerializer : public JsonSerializer<TWriter> {
       while (!it.done()) {
         if (isKey)
           indent();
-        it->accept(*this, base::resources_);
+        VariantImpl::accept(*this, it.data(), base::resources_);
         it.next(base::resources_);
         if (isKey)
           base::write(": ");
diff --git a/src/ArduinoJson/Memory/ResourceManager.hpp b/src/ArduinoJson/Memory/ResourceManager.hpp
index 0a0cfe4c..fb353e4e 100644
--- a/src/ArduinoJson/Memory/ResourceManager.hpp
+++ b/src/ArduinoJson/Memory/ResourceManager.hpp
@@ -14,7 +14,7 @@
 
 ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
 
-class VariantData;
+struct VariantData;
 class VariantWithId;
 
 class ResourceManager {
diff --git a/src/ArduinoJson/Memory/ResourceManagerImpl.hpp b/src/ArduinoJson/Memory/ResourceManagerImpl.hpp
index c5cf7df2..409af0ab 100644
--- a/src/ArduinoJson/Memory/ResourceManagerImpl.hpp
+++ b/src/ArduinoJson/Memory/ResourceManagerImpl.hpp
@@ -22,7 +22,7 @@ inline Slot<VariantData> ResourceManager::allocVariant() {
 }
 
 inline void ResourceManager::freeVariant(Slot<VariantData> slot) {
-  slot->clear(this);
+  VariantImpl::clear(slot.ptr(), this);
   variantPools_.freeSlot(slot);
 }
 
diff --git a/src/ArduinoJson/MsgPack/MsgPackBinary.hpp b/src/ArduinoJson/MsgPack/MsgPackBinary.hpp
index 2c0f6b71..6b1c179b 100644
--- a/src/ArduinoJson/MsgPack/MsgPackBinary.hpp
+++ b/src/ArduinoJson/MsgPack/MsgPackBinary.hpp
@@ -29,7 +29,7 @@ struct Converter<MsgPackBinary> : private detail::VariantAttorney {
     if (!data)
       return;
     auto resources = getResourceManager(dst);
-    data->clear(resources);
+    detail::VariantImpl::clear(data, resources);
     if (src.data()) {
       size_t headerSize = src.size() >= 0x10000 ? 5
                           : src.size() >= 0x100 ? 3
diff --git a/src/ArduinoJson/MsgPack/MsgPackDeserializer.hpp b/src/ArduinoJson/MsgPack/MsgPackDeserializer.hpp
index 42ec422e..f3d280d7 100644
--- a/src/ArduinoJson/MsgPack/MsgPackDeserializer.hpp
+++ b/src/ArduinoJson/MsgPack/MsgPackDeserializer.hpp
@@ -91,7 +91,7 @@ class MsgPackDeserializer {
 
     if (code <= 0x7f || code >= 0xe0) {  // fixint
       if (allowValue)
-        variant->setInteger(static_cast<int8_t>(code), resources_);
+        VariantImpl::setInteger(static_cast<int8_t>(code), variant, resources_);
       return DeserializationError::Ok;
     }
 
@@ -231,14 +231,14 @@ class MsgPackDeserializer {
     if (isSigned) {
       auto truncatedValue = static_cast<JsonInteger>(signedValue);
       if (truncatedValue == signedValue) {
-        if (!variant->setInteger(truncatedValue, resources_))
+        if (!VariantImpl::setInteger(truncatedValue, variant, resources_))
           return DeserializationError::NoMemory;
       }
       // else set null on overflow
     } else {
       auto truncatedValue = static_cast<JsonUInt>(unsignedValue);
       if (truncatedValue == unsignedValue)
-        if (!variant->setInteger(truncatedValue, resources_))
+        if (!VariantImpl::setInteger(truncatedValue, variant, resources_))
           return DeserializationError::NoMemory;
       // else set null on overflow
     }
@@ -257,7 +257,7 @@ class MsgPackDeserializer {
       return err;
 
     fixEndianness(value);
-    variant->setFloat(value, resources_);
+    VariantImpl::setFloat(value, variant, resources_);
 
     return DeserializationError::Ok;
   }
@@ -273,7 +273,7 @@ class MsgPackDeserializer {
       return err;
 
     fixEndianness(value);
-    if (variant->setFloat(value, resources_))
+    if (VariantImpl::setFloat(value, variant, resources_))
       return DeserializationError::Ok;
     else
       return DeserializationError::NoMemory;
@@ -293,7 +293,7 @@ class MsgPackDeserializer {
 
     doubleToFloat(i, o);
     fixEndianness(value);
-    variant->setFloat(value, resources_);
+    VariantImpl::setFloat(value, variant, resources_);
 
     return DeserializationError::Ok;
   }
@@ -352,7 +352,7 @@ class MsgPackDeserializer {
     ArrayImpl array;
     if (allowArray) {
       ARDUINOJSON_ASSERT(variant != 0);
-      array = variant->toArray(resources_);
+      array = VariantImpl::toArray(variant, resources_);
     }
 
     TFilter elementFilter = filter[0U];
@@ -388,7 +388,7 @@ class MsgPackDeserializer {
     ObjectImpl object;
     if (filter.allowObject()) {
       ARDUINOJSON_ASSERT(variant != 0);
-      object = variant->toObject(resources_);
+      object = VariantImpl::toObject(variant, resources_);
     }
 
     for (; n; --n) {
diff --git a/src/ArduinoJson/MsgPack/MsgPackExtension.hpp b/src/ArduinoJson/MsgPack/MsgPackExtension.hpp
index b51eb30b..696e42d7 100644
--- a/src/ArduinoJson/MsgPack/MsgPackExtension.hpp
+++ b/src/ArduinoJson/MsgPack/MsgPackExtension.hpp
@@ -31,11 +31,11 @@ class MsgPackExtension {
 template <>
 struct Converter<MsgPackExtension> : private detail::VariantAttorney {
   static void toJson(MsgPackExtension src, JsonVariant dst) {
-    auto data = VariantAttorney::getData(dst);
+    auto data = getData(dst);
     if (!data)
       return;
     auto resources = getResourceManager(dst);
-    data->clear(resources);
+    detail::VariantImpl::clear(data, resources);
     if (src.data()) {
       uint8_t format, sizeBytes;
       if (src.size() >= 0x10000) {
diff --git a/src/ArduinoJson/MsgPack/MsgPackSerializer.hpp b/src/ArduinoJson/MsgPack/MsgPackSerializer.hpp
index 56e725fe..a9d05206 100644
--- a/src/ArduinoJson/MsgPack/MsgPackSerializer.hpp
+++ b/src/ArduinoJson/MsgPack/MsgPackSerializer.hpp
@@ -62,8 +62,8 @@ class MsgPackSerializer : public VariantDataVisitor<size_t> {
     auto slotId = array.head();
     while (slotId != NULL_SLOT) {
       auto slot = resources_->getVariant(slotId);
-      slot->accept(*this, resources_);
-      slotId = slot->next();
+      VariantImpl::accept(*this, slot, resources_);
+      slotId = slot->next;
     }
 
     return bytesWritten();
@@ -84,8 +84,8 @@ class MsgPackSerializer : public VariantDataVisitor<size_t> {
     auto slotId = object.head();
     while (slotId != NULL_SLOT) {
       auto slot = resources_->getVariant(slotId);
-      slot->accept(*this, resources_);
-      slotId = slot->next();
+      VariantImpl::accept(*this, slot, resources_);
+      slotId = slot->next;
     }
 
     return bytesWritten();
diff --git a/src/ArduinoJson/Object/JsonObject.hpp b/src/ArduinoJson/Object/JsonObject.hpp
index 87c49299..c6b55626 100644
--- a/src/ArduinoJson/Object/JsonObject.hpp
+++ b/src/ArduinoJson/Object/JsonObject.hpp
@@ -27,7 +27,7 @@ class JsonObject : public detail::VariantOperators<JsonObject> {
 
   // INTERNAL USE ONLY
   JsonObject(detail::VariantData* data, detail::ResourceManager* resource)
-      : impl_(detail::VariantData::asObject(data, resource)) {}
+      : impl_(detail::VariantImpl::asObject(data, resource)) {}
 
   operator JsonVariant() const {
     return JsonVariant(getData(), getResourceManager());
diff --git a/src/ArduinoJson/Object/JsonObjectConst.hpp b/src/ArduinoJson/Object/JsonObjectConst.hpp
index 264f729f..19531c0d 100644
--- a/src/ArduinoJson/Object/JsonObjectConst.hpp
+++ b/src/ArduinoJson/Object/JsonObjectConst.hpp
@@ -23,7 +23,7 @@ class JsonObjectConst : public detail::VariantOperators<JsonObjectConst> {
 
   // INTERNAL USE ONLY
   JsonObjectConst(detail::VariantData* data, detail::ResourceManager* resources)
-      : impl_(detail::VariantData::asObject(data, resources)) {}
+      : impl_(detail::VariantImpl::asObject(data, resources)) {}
 
   // INTERNAL USE ONLY
   JsonObjectConst(const detail::ObjectImpl& impl) : impl_(impl) {}
diff --git a/src/ArduinoJson/Object/MemberProxy.hpp b/src/ArduinoJson/Object/MemberProxy.hpp
index 7e43d38d..7bdd642b 100644
--- a/src/ArduinoJson/Object/MemberProxy.hpp
+++ b/src/ArduinoJson/Object/MemberProxy.hpp
@@ -56,17 +56,12 @@ class MemberProxy
   }
 
   VariantData* getData() const {
-    return VariantData::getMember(
-        VariantAttorney::getData(upstream_), key_,
-        VariantAttorney::getResourceManager(upstream_));
+    return VariantAttorney::getVariantImpl(upstream_).getMember(key_);
   }
 
   VariantData* getOrCreateData() const {
-    auto data = VariantAttorney::getOrCreateData(upstream_);
-    if (!data)
-      return nullptr;
-    return data->getOrAddMember(key_,
-                                VariantAttorney::getResourceManager(upstream_));
+    return VariantAttorney::getOrCreateVariantImpl(upstream_).getOrAddMember(
+        key_);
   }
 
  private:
diff --git a/src/ArduinoJson/Object/ObjectData.hpp b/src/ArduinoJson/Object/ObjectData.hpp
index 3d3cd946..a52f8b96 100644
--- a/src/ArduinoJson/Object/ObjectData.hpp
+++ b/src/ArduinoJson/Object/ObjectData.hpp
@@ -8,6 +8,8 @@
 
 ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
 
+class VariantImpl;
+
 class ObjectImpl : public CollectionImpl {
  public:
   ObjectImpl() {}
diff --git a/src/ArduinoJson/Object/ObjectImpl.hpp b/src/ArduinoJson/Object/ObjectImpl.hpp
index 127ce77c..a91ba63c 100644
--- a/src/ArduinoJson/Object/ObjectImpl.hpp
+++ b/src/ArduinoJson/Object/ObjectImpl.hpp
@@ -59,7 +59,7 @@ inline VariantData* ObjectImpl::addMember(TAdaptedString key) {
   if (!valueSlot)
     return nullptr;
 
-  if (!keySlot->setString(key, resources_))
+  if (!VariantImpl::setString(key, keySlot.ptr(), resources_))
     return nullptr;
 
   CollectionImpl::appendPair(keySlot, valueSlot);
diff --git a/src/ArduinoJson/Serialization/measure.hpp b/src/ArduinoJson/Serialization/measure.hpp
index 62d8fce1..cd8a1bac 100644
--- a/src/ArduinoJson/Serialization/measure.hpp
+++ b/src/ArduinoJson/Serialization/measure.hpp
@@ -14,7 +14,7 @@ size_t measure(ArduinoJson::JsonVariantConst source) {
   auto data = VariantAttorney::getData(source);
   auto resources = VariantAttorney::getResourceManager(source);
   TSerializer<DummyWriter> serializer(dp, resources);
-  return VariantData::accept(data, resources, serializer);
+  return VariantImpl::accept(serializer, data, resources);
 }
 
 ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/src/ArduinoJson/Serialization/serialize.hpp b/src/ArduinoJson/Serialization/serialize.hpp
index ad93adec..5af72296 100644
--- a/src/ArduinoJson/Serialization/serialize.hpp
+++ b/src/ArduinoJson/Serialization/serialize.hpp
@@ -13,7 +13,7 @@ size_t doSerialize(ArduinoJson::JsonVariantConst source, TWriter writer) {
   auto data = VariantAttorney::getData(source);
   auto resources = VariantAttorney::getResourceManager(source);
   TSerializer<TWriter> serializer(writer, resources);
-  return VariantData::accept(data, resources, serializer);
+  return VariantImpl::accept(serializer, data, resources);
 }
 
 template <template <typename> class TSerializer, typename TDestination>
diff --git a/src/ArduinoJson/Variant/ConverterImpl.hpp b/src/ArduinoJson/Variant/ConverterImpl.hpp
index 0ac9fafd..3b8cd9d6 100644
--- a/src/ArduinoJson/Variant/ConverterImpl.hpp
+++ b/src/ArduinoJson/Variant/ConverterImpl.hpp
@@ -60,25 +60,16 @@ struct Converter<T, detail::enable_if_t<detail::is_integral<T>::value &&
     : private detail::VariantAttorney {
   static bool toJson(T src, JsonVariant dst) {
     ARDUINOJSON_ASSERT_INTEGER_TYPE_IS_SUPPORTED(T);
-    auto data = getData(dst);
-    if (!data)
-      return false;
-    auto resources = getResourceManager(dst);
-    data->clear(resources);
-    return data->setInteger(src, resources);
+    return getVariantImpl(dst).setInteger(src);
   }
 
   static T fromJson(JsonVariantConst src) {
     ARDUINOJSON_ASSERT_INTEGER_TYPE_IS_SUPPORTED(T);
-    auto data = getData(src);
-    auto resources = getResourceManager(src);
-    return data ? data->template asIntegral<T>(resources) : T();
+    return getVariantImpl(src).template asIntegral<T>();
   }
 
   static bool checkJson(JsonVariantConst src) {
-    auto data = getData(src);
-    auto resources = getResourceManager(src);
-    return data && data->template isInteger<T>(resources);
+    return getVariantImpl(src).template isInteger<T>();
   }
 };
 
@@ -90,35 +81,22 @@ struct Converter<T, detail::enable_if_t<detail::is_enum<T>::value>>
   }
 
   static T fromJson(JsonVariantConst src) {
-    auto data = getData(src);
-    auto resources = getResourceManager(src);
-    return data ? static_cast<T>(data->template asIntegral<int>(resources))
-                : T();
+    return static_cast<T>(getVariantImpl(src).template asIntegral<int>());
   }
 
   static bool checkJson(JsonVariantConst src) {
-    auto data = getData(src);
-    auto resources = getResourceManager(src);
-    return data && data->template isInteger<int>(resources);
+    return getVariantImpl(src).template isInteger<int>();
   }
 };
 
 template <>
 struct Converter<bool> : private detail::VariantAttorney {
   static bool toJson(bool src, JsonVariant dst) {
-    auto data = getData(dst);
-    if (!data)
-      return false;
-    auto resources = getResourceManager(dst);
-    data->clear(resources);
-    data->setBoolean(src);
-    return true;
+    return getVariantImpl(dst).setBoolean(src);
   }
 
   static bool fromJson(JsonVariantConst src) {
-    auto data = getData(src);
-    auto resources = getResourceManager(src);
-    return data ? data->asBoolean(resources) : false;
+    return getVariantImpl(src).asBoolean();
   }
 
   static bool checkJson(JsonVariantConst src) {
@@ -131,18 +109,11 @@ template <typename T>
 struct Converter<T, detail::enable_if_t<detail::is_floating_point<T>::value>>
     : private detail::VariantAttorney {
   static bool toJson(T src, JsonVariant dst) {
-    auto data = getData(dst);
-    if (!data)
-      return false;
-    auto resources = getResourceManager(dst);
-    data->clear(resources);
-    return data->setFloat(src, resources);
+    return getVariantImpl(dst).setFloat(src);
   }
 
   static T fromJson(JsonVariantConst src) {
-    auto data = getData(src);
-    auto resources = getResourceManager(src);
-    return data ? data->template asFloat<T>(resources) : 0;
+    return getVariantImpl(src).template asFloat<T>();
   }
 
   static bool checkJson(JsonVariantConst src) {
@@ -154,8 +125,7 @@ struct Converter<T, detail::enable_if_t<detail::is_floating_point<T>::value>>
 template <>
 struct Converter<const char*> : private detail::VariantAttorney {
   static void toJson(const char* src, JsonVariant dst) {
-    detail::VariantData::setString(getData(dst), detail::adaptString(src),
-                                   getResourceManager(dst));
+    getVariantImpl(dst).setString(detail::adaptString(src));
   }
 
   static const char* fromJson(JsonVariantConst src) {
@@ -171,9 +141,8 @@ struct Converter<const char*> : private detail::VariantAttorney {
 
 template <>
 struct Converter<JsonString> : private detail::VariantAttorney {
-  static void toJson(JsonString src, JsonVariant dst) {
-    detail::VariantData::setString(getData(dst), detail::adaptString(src),
-                                   getResourceManager(dst));
+  static bool toJson(JsonString src, JsonVariant dst) {
+    return getVariantImpl(dst).setString(detail::adaptString(src));
   }
 
   static JsonString fromJson(JsonVariantConst src) {
@@ -188,12 +157,10 @@ struct Converter<JsonString> : private detail::VariantAttorney {
 };
 
 template <typename T>
-inline detail::enable_if_t<detail::IsString<T>::value> convertToJson(
+inline detail::enable_if_t<detail::IsString<T>::value, bool> convertToJson(
     const T& src, JsonVariant dst) {
-  using namespace detail;
-  auto data = VariantAttorney::getData(dst);
-  auto resources = VariantAttorney::getResourceManager(dst);
-  detail::VariantData::setString(data, adaptString(src), resources);
+  return detail::VariantAttorney::getVariantImpl(dst).setString(
+      detail::adaptString(src));
 }
 
 // SerializedValue<std::string>
@@ -202,15 +169,14 @@ inline detail::enable_if_t<detail::IsString<T>::value> convertToJson(
 template <typename T>
 struct Converter<SerializedValue<T>> : private detail::VariantAttorney {
   static void toJson(SerializedValue<T> src, JsonVariant dst) {
-    detail::VariantData::setRawString(getData(dst), src,
-                                      getResourceManager(dst));
+    getVariantImpl(dst).setRawString(src);
   }
 };
 
 template <>
 struct Converter<detail::nullptr_t> : private detail::VariantAttorney {
   static void toJson(detail::nullptr_t, JsonVariant dst) {
-    detail::VariantData::clear(getData(dst), getResourceManager(dst));
+    getVariantImpl(dst).clear();
   }
   static detail::nullptr_t fromJson(JsonVariantConst) {
     return nullptr;
@@ -263,7 +229,7 @@ inline void convertToJson(const ::Printable& src, JsonVariant dst) {
   auto data = detail::VariantAttorney::getData(dst);
   if (!resources || !data)
     return;
-  data->clear(resources);
+  detail::VariantImpl::clear(data, resources);
   detail::StringBuilderPrint print(resources);
   src.printTo(print);
   if (print.overflowed())
diff --git a/src/ArduinoJson/Variant/JsonVariant.hpp b/src/ArduinoJson/Variant/JsonVariant.hpp
index aed1ba95..e3c09e1f 100644
--- a/src/ArduinoJson/Variant/JsonVariant.hpp
+++ b/src/ArduinoJson/Variant/JsonVariant.hpp
@@ -16,27 +16,29 @@ class JsonVariant : public detail::VariantRefBase<JsonVariant>,
 
  public:
   // Creates an unbound reference.
-  JsonVariant() : data_(0), resources_(0) {}
+  JsonVariant() {}
 
   // INTERNAL USE ONLY
   JsonVariant(detail::VariantData* data, detail::ResourceManager* resources)
-      : data_(data), resources_(resources) {}
+      : impl_(data, resources) {}
+
+  // INTERNAL USE ONLY
+  JsonVariant(detail::VariantImpl impl) : impl_(impl) {}
 
  private:
   detail::ResourceManager* getResourceManager() const {
-    return resources_;
+    return impl_.getResourceManager();
   }
 
   detail::VariantData* getData() const {
-    return data_;
+    return impl_.getData();
   }
 
   detail::VariantData* getOrCreateData() const {
-    return data_;
+    return impl_.getData();
   }
 
-  detail::VariantData* data_;
-  detail::ResourceManager* resources_;
+  mutable detail::VariantImpl impl_;
 };
 
 namespace detail {
diff --git a/src/ArduinoJson/Variant/JsonVariantConst.hpp b/src/ArduinoJson/Variant/JsonVariantConst.hpp
index 8d80d69f..46683926 100644
--- a/src/ArduinoJson/Variant/JsonVariantConst.hpp
+++ b/src/ArduinoJson/Variant/JsonVariantConst.hpp
@@ -35,34 +35,34 @@ class JsonVariantConst : public detail::VariantTag,
 
  public:
   // Creates an unbound reference.
-  JsonVariantConst() : data_(nullptr), resources_(nullptr) {}
+  JsonVariantConst() {}
 
   // INTERNAL USE ONLY
   explicit JsonVariantConst(detail::VariantData* data,
                             detail::ResourceManager* resources)
-      : data_(data), resources_(resources) {}
+      : impl_(data, resources) {}
 
   // Returns true if the value is null or the reference is unbound.
   // https://arduinojson.org/v7/api/jsonvariantconst/isnull/
   bool isNull() const {
-    return detail::VariantData::isNull(data_);
+    return impl_.isNull();
   }
 
   // Returns true if the reference is unbound.
   bool isUnbound() const {
-    return !data_;
+    return impl_.getData() == nullptr;
   }
 
   // Returns the depth (nesting level) of the value.
   // https://arduinojson.org/v7/api/jsonvariantconst/nesting/
   size_t nesting() const {
-    return detail::VariantData::nesting(data_, resources_);
+    return impl_.nesting();
   }
 
   // Returns the size of the array or object.
   // https://arduinojson.org/v7/api/jsonvariantconst/size/
   size_t size() const {
-    return detail::VariantData::size(data_, resources_);
+    return impl_.size();
   }
 
   // Casts the value to the specified type.
@@ -104,9 +104,8 @@ class JsonVariantConst : public detail::VariantTag,
   template <typename T,
             detail::enable_if_t<detail::is_integral<T>::value, int> = 0>
   JsonVariantConst operator[](T index) const {
-    return JsonVariantConst(
-        detail::VariantData::getElement(data_, size_t(index), resources_),
-        resources_);
+    return JsonVariantConst(impl_.getElement(size_t(index)),
+                            impl_.getResourceManager());
   }
 
   // Gets object's member with specified key.
@@ -114,9 +113,8 @@ class JsonVariantConst : public detail::VariantTag,
   template <typename TString,
             detail::enable_if_t<detail::IsString<TString>::value, int> = 0>
   JsonVariantConst operator[](const TString& key) const {
-    return JsonVariantConst(detail::VariantData::getMember(
-                                data_, detail::adaptString(key), resources_),
-                            resources_);
+    return JsonVariantConst(impl_.getMember(detail::adaptString(key)),
+                            impl_.getResourceManager());
   }
 
   // Gets object's member with specified key.
@@ -126,9 +124,8 @@ class JsonVariantConst : public detail::VariantTag,
                                     !detail::is_const<TChar>::value,
                                 int> = 0>
   JsonVariantConst operator[](TChar* key) const {
-    return JsonVariantConst(detail::VariantData::getMember(
-                                data_, detail::adaptString(key), resources_),
-                            resources_);
+    return JsonVariantConst(impl_.getMember(detail::adaptString(key)),
+                            impl_.getResourceManager());
   }
 
   // Gets object's member with specified key or the array's element at the
@@ -149,8 +146,7 @@ class JsonVariantConst : public detail::VariantTag,
             detail::enable_if_t<detail::IsString<TString>::value, int> = 0>
   ARDUINOJSON_DEPRECATED("use var[key].is<T>() instead")
   bool containsKey(const TString& key) const {
-    return detail::VariantData::getMember(getData(), detail::adaptString(key),
-                                          resources_) != 0;
+    return impl_.getMember(detail::adaptString(key)) != 0;
   }
 
   // DEPRECATED: use obj["key"].is<T>() instead
@@ -161,8 +157,7 @@ class JsonVariantConst : public detail::VariantTag,
                                 int> = 0>
   ARDUINOJSON_DEPRECATED("use obj[\"key\"].is<T>() instead")
   bool containsKey(TChar* key) const {
-    return detail::VariantData::getMember(getData(), detail::adaptString(key),
-                                          resources_) != 0;
+    return impl_.getMember(detail::adaptString(key)) != 0;
   }
 
   // DEPRECATED: use obj[key].is<T>() instead
@@ -182,16 +177,15 @@ class JsonVariantConst : public detail::VariantTag,
 
  protected:
   detail::VariantData* getData() const {
-    return data_;
+    return impl_.getData();
   }
 
   detail::ResourceManager* getResourceManager() const {
-    return resources_;
+    return impl_.getResourceManager();
   }
 
  private:
-  mutable detail::VariantData* data_;
-  mutable detail::ResourceManager* resources_;
+  mutable detail::VariantImpl impl_;
 };
 
 ARDUINOJSON_END_PUBLIC_NAMESPACE
diff --git a/src/ArduinoJson/Variant/JsonVariantVisitor.hpp b/src/ArduinoJson/Variant/JsonVariantVisitor.hpp
index c9169f71..3d3fcaf2 100644
--- a/src/ArduinoJson/Variant/JsonVariantVisitor.hpp
+++ b/src/ArduinoJson/Variant/JsonVariantVisitor.hpp
@@ -48,12 +48,8 @@ class VisitorAdapter {
 template <typename TVisitor>
 typename TVisitor::result_type accept(JsonVariantConst variant,
                                       TVisitor& visit) {
-  auto data = VariantAttorney::getData(variant);
-  if (!data)
-    return visit.visit(nullptr);
-  auto resources = VariantAttorney::getResourceManager(variant);
   VisitorAdapter<TVisitor> adapter(visit);
-  return data->accept(adapter, resources);
+  return VariantAttorney::getVariantImpl(variant).accept(adapter);
 }
 
 ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/src/ArduinoJson/Variant/VariantAttorney.hpp b/src/ArduinoJson/Variant/VariantAttorney.hpp
index d97641bb..41fe61b9 100644
--- a/src/ArduinoJson/Variant/VariantAttorney.hpp
+++ b/src/ArduinoJson/Variant/VariantAttorney.hpp
@@ -26,6 +26,16 @@ class VariantAttorney {
     return client.getData();
   }
 
+  template <typename TClient>
+  static VariantImpl getVariantImpl(TClient& client) {
+    return VariantImpl(client.getData(), client.getResourceManager());
+  }
+
+  template <typename TClient>
+  static VariantImpl getOrCreateVariantImpl(TClient& client) {
+    return VariantImpl(client.getOrCreateData(), client.getResourceManager());
+  }
+
   template <typename TClient>
   static VariantData* getOrCreateData(TClient& client) {
     return client.getOrCreateData();
diff --git a/src/ArduinoJson/Variant/VariantData.hpp b/src/ArduinoJson/Variant/VariantData.hpp
index 4b31a9ea..3ab0a895 100644
--- a/src/ArduinoJson/Variant/VariantData.hpp
+++ b/src/ArduinoJson/Variant/VariantData.hpp
@@ -27,12 +27,11 @@ static bool isTinyString(const T& s, size_t n) {
   return !containsNul;
 }
 
-class VariantData {
-  VariantContent content_;  // must be first to allow cast from array to variant
-  VariantType type_;
-  SlotId next_;
+struct VariantData {
+  VariantContent content;  // must be first to allow cast from array to variant
+  VariantType type = VariantType::Null;
+  SlotId next = NULL_SLOT;
 
- public:
   // Placement new
   static void* operator new(size_t, void* p) noexcept {
     return p;
@@ -40,121 +39,175 @@ class VariantData {
 
   static void operator delete(void*, void*) noexcept {}
 
-  VariantData() : type_(VariantType::Null), next_(NULL_SLOT) {}
-
-  SlotId next() const {
-    return next_;
-  }
-
-  void setNext(SlotId slot) {
-    next_ = slot;
-  }
-
-  template <typename TVisitor>
-  typename TVisitor::result_type accept(TVisitor& visit,
-                                        ResourceManager* resources) {
-#if ARDUINOJSON_USE_8_BYTE_POOL
-    auto eightByteValue = getEightByte(resources);
-#else
-    (void)resources;  // silence warning
-#endif
-    switch (type_) {
-      case VariantType::Float:
-        return visit.visit(content_.asFloat);
-
-#if ARDUINOJSON_USE_DOUBLE
-      case VariantType::Double:
-        return visit.visit(eightByteValue->asDouble);
-#endif
-
-      case VariantType::Array:
-        return visit.visit(asArray(resources));
-
-      case VariantType::Object:
-        return visit.visit(asObject(resources));
-
-      case VariantType::TinyString:
-        return visit.visit(JsonString(content_.asTinyString));
-
-      case VariantType::LongString:
-        return visit.visit(JsonString(content_.asStringNode->data,
-                                      content_.asStringNode->length));
-
+  JsonString asRawString() const {
+    switch (type) {
       case VariantType::RawString:
-        return visit.visit(RawString(content_.asStringNode->data,
-                                     content_.asStringNode->length));
-
-      case VariantType::Int32:
-        return visit.visit(static_cast<JsonInteger>(content_.asInt32));
-
-      case VariantType::Uint32:
-        return visit.visit(static_cast<JsonUInt>(content_.asUint32));
-
-#if ARDUINOJSON_USE_LONG_LONG
-      case VariantType::Int64:
-        return visit.visit(eightByteValue->asInt64);
-
-      case VariantType::Uint64:
-        return visit.visit(eightByteValue->asUint64);
-#endif
-
-      case VariantType::Boolean:
-        return visit.visit(content_.asBoolean != 0);
-
+        return JsonString(content.asStringNode->data,
+                          content.asStringNode->length);
       default:
-        return visit.visit(nullptr);
+        return JsonString();
     }
   }
 
-  template <typename TVisitor>
-  static typename TVisitor::result_type accept(VariantData* var,
-                                               ResourceManager* resources,
-                                               TVisitor& visit) {
-    if (var != 0)
-      return var->accept(visit, resources);
-    else
-      return visit.visit(nullptr);
+  JsonString asString() const {
+    switch (type) {
+      case VariantType::TinyString:
+        return JsonString(content.asTinyString);
+      case VariantType::LongString:
+        return JsonString(content.asStringNode->data,
+                          content.asStringNode->length);
+      default:
+        return JsonString();
+    }
   }
 
-  VariantData* addElement(ResourceManager* resources) {
-    auto array = isNull() ? toArray(resources) : asArray(resources);
+  bool isArray() const {
+    return type == VariantType::Array;
+  }
+
+  bool isBoolean() const {
+    return type == VariantType::Boolean;
+  }
+
+  bool isFloat() const {
+    return type & VariantTypeBits::NumberBit;
+  }
+
+  bool isNull() const {
+    return type == VariantType::Null;
+  }
+
+  bool isObject() const {
+    return type == VariantType::Object;
+  }
+
+  bool isString() const {
+    return type == VariantType::LongString || type == VariantType::TinyString;
+  }
+
+  void setBoolean(bool value) {
+    ARDUINOJSON_ASSERT(type == VariantType::Null);
+    type = VariantType::Boolean;
+    content.asBoolean = value;
+  }
+
+  void setRawString(StringNode* s) {
+    ARDUINOJSON_ASSERT(type == VariantType::Null);
+    ARDUINOJSON_ASSERT(s);
+    type = VariantType::RawString;
+    content.asStringNode = s;
+  }
+
+  template <typename TAdaptedString>
+  void setTinyString(const TAdaptedString& s) {
+    ARDUINOJSON_ASSERT(type == VariantType::Null);
+    ARDUINOJSON_ASSERT(s.size() <= tinyStringMaxLength);
+
+    type = VariantType::TinyString;
+
+    auto n = uint8_t(s.size());
+    for (uint8_t i = 0; i < n; i++) {
+      char c = s[i];
+      ARDUINOJSON_ASSERT(c != 0);  // no NUL in tiny string
+      content.asTinyString[i] = c;
+    }
+
+    content.asTinyString[n] = 0;
+  }
+
+  void setLongString(StringNode* s) {
+    ARDUINOJSON_ASSERT(type == VariantType::Null);
+    ARDUINOJSON_ASSERT(s);
+    type = VariantType::LongString;
+    content.asStringNode = s;
+  }
+
+  CollectionData* toArray() {
+    ARDUINOJSON_ASSERT(type == VariantType::Null);
+    type = VariantType::Array;
+    return new (&content.asCollection) CollectionData();
+  }
+
+  CollectionData* toObject() {
+    ARDUINOJSON_ASSERT(type == VariantType::Null);
+    type = VariantType::Object;
+    return new (&content.asCollection) CollectionData();
+  }
+};
+
+// HACK: large functions are implemented in static function to give opportunity
+// to the compiler to optimize the `this` pointer away.
+class VariantImpl {
+ public:
+  VariantImpl() : data_(nullptr), resources_(nullptr) {}
+
+  VariantImpl(VariantData* data, ResourceManager* resources)
+      : data_(data), resources_(resources) {}
+
+  VariantData* getData() const {
+    return data_;
+  }
+
+  ResourceManager* getResourceManager() const {
+    return resources_;
+  }
+
+  template <typename TVisitor>
+  typename TVisitor::result_type accept(TVisitor& visit) {
+    return accept(visit, data_, resources_);
+  }
+
+  template <typename TVisitor>
+  static typename TVisitor::result_type accept(TVisitor&, VariantData*,
+                                               ResourceManager*);
+
+  VariantData* addElement() {
+    return addElement(data_, resources_);
+  }
+
+  static VariantData* addElement(VariantData* data,
+                                 ResourceManager* resources) {
+    if (!data)
+      return nullptr;
+    auto array = data->type == VariantType::Null ? toArray(data, resources)
+                                                 : asArray(data, resources);
     return array.addElement();
   }
 
-  static VariantData* addElement(VariantData* var, ResourceManager* resources) {
-    if (!var)
-      return nullptr;
-    return var->addElement(resources);
+  template <typename T>
+  bool addValue(const T& value) {
+    return addValue(value, data_, resources_);
   }
 
   template <typename T>
-  bool addValue(const T& value, ResourceManager* resources) {
-    auto array = isNull() ? toArray(resources) : asArray(resources);
+  static bool addValue(const T& value, VariantData* data,
+                       ResourceManager* resources) {
+    if (!data)
+      return false;
+    auto array = data->type == VariantType::Null ? toArray(data, resources)
+                                                 : asArray(data, resources);
     return array.addValue(value);
   }
 
-  template <typename T>
-  static bool addValue(VariantData* var, const T& value,
-                       ResourceManager* resources) {
-    if (!var)
-      return false;
-    return var->addValue(value, resources);
+  bool asBoolean() const {
+    return asBoolean(data_, resources_);
   }
 
-  bool asBoolean(const ResourceManager* resources) const {
+  static bool asBoolean(VariantData* data, ResourceManager* resources) {
+    if (!data)
+      return false;
+
 #if ARDUINOJSON_USE_8_BYTE_POOL
-    auto eightByteValue = getEightByte(resources);
-#else
-    (void)resources;  // silence warning
+    auto eightByteValue = getEightByte(data, resources);
 #endif
-    switch (type_) {
+    switch (data->type) {
       case VariantType::Boolean:
-        return content_.asBoolean;
+        return data->content.asBoolean;
       case VariantType::Uint32:
       case VariantType::Int32:
-        return content_.asUint32 != 0;
+        return data->content.asUint32 != 0;
       case VariantType::Float:
-        return content_.asFloat != 0;
+        return data->content.asFloat != 0;
 #if ARDUINOJSON_USE_DOUBLE
       case VariantType::Double:
         return eightByteValue->asDouble != 0;
@@ -171,37 +224,44 @@ class VariantData {
     }
   }
 
-  ArrayImpl asArray(ResourceManager* resources) {
-    return ArrayImpl(isArray() ? &content_.asCollection : nullptr, resources);
+  ArrayImpl asArray() {
+    return asArray(data_, resources_);
   }
 
-  static ArrayImpl asArray(VariantData* var, ResourceManager* resources) {
-    return ArrayImpl(
-        var && var->isArray() ? &var->content_.asCollection : nullptr,
-        resources);
+  static ArrayImpl asArray(VariantData* data, ResourceManager* resources) {
+    return ArrayImpl(data && data->type == VariantType::Array
+                         ? &data->content.asCollection
+                         : nullptr,
+                     resources);
   }
 
-  CollectionImpl asCollection(ResourceManager* resources) {
-    return CollectionImpl(isCollection() ? &content_.asCollection : nullptr,
-                          resources);
+  CollectionImpl asCollection() {
+    return CollectionImpl(
+        isCollection() ? &data_->content.asCollection : nullptr, resources_);
   }
 
   template <typename T>
-  T asFloat(const ResourceManager* resources) const {
+  T asFloat() const {
+    return asFloat<T>(data_, resources_);
+  }
+
+  template <typename T>
+  static T asFloat(VariantData* data, ResourceManager* resources) {
+    if (!data)
+      return 0.0;
+
     static_assert(is_floating_point<T>::value, "T must be a floating point");
 #if ARDUINOJSON_USE_8_BYTE_POOL
-    auto eightByteValue = getEightByte(resources);
-#else
-    (void)resources;  // silence warning
+    auto eightByteValue = getEightByte(data, resources);
 #endif
     const char* str = nullptr;
-    switch (type_) {
+    switch (data->type) {
       case VariantType::Boolean:
-        return static_cast<T>(content_.asBoolean);
+        return static_cast<T>(data->content.asBoolean);
       case VariantType::Uint32:
-        return static_cast<T>(content_.asUint32);
+        return static_cast<T>(data->content.asUint32);
       case VariantType::Int32:
-        return static_cast<T>(content_.asInt32);
+        return static_cast<T>(data->content.asInt32);
 #if ARDUINOJSON_USE_LONG_LONG
       case VariantType::Uint64:
         return static_cast<T>(eightByteValue->asUint64);
@@ -209,13 +269,13 @@ class VariantData {
         return static_cast<T>(eightByteValue->asInt64);
 #endif
       case VariantType::TinyString:
-        str = content_.asTinyString;
+        str = data->content.asTinyString;
         break;
       case VariantType::LongString:
-        str = content_.asStringNode->data;
+        str = data->content.asStringNode->data;
         break;
       case VariantType::Float:
-        return static_cast<T>(content_.asFloat);
+        return static_cast<T>(data->content.asFloat);
 #if ARDUINOJSON_USE_DOUBLE
       case VariantType::Double:
         return static_cast<T>(eightByteValue->asDouble);
@@ -229,21 +289,27 @@ class VariantData {
   }
 
   template <typename T>
-  T asIntegral(const ResourceManager* resources) const {
+  T asIntegral() const {
+    return asIntegral<T>(data_, resources_);
+  }
+
+  template <typename T>
+  static T asIntegral(VariantData* data, ResourceManager* resources) {
+    if (!data)
+      return 0;
+
     static_assert(is_integral<T>::value, "T must be an integral type");
 #if ARDUINOJSON_USE_8_BYTE_POOL
-    auto eightByteValue = getEightByte(resources);
-#else
-    (void)resources;  // silence warning
+    auto eightByteValue = getEightByte(data, resources);
 #endif
     const char* str = nullptr;
-    switch (type_) {
+    switch (data->type) {
       case VariantType::Boolean:
-        return content_.asBoolean;
+        return data->content.asBoolean;
       case VariantType::Uint32:
-        return convertNumber<T>(content_.asUint32);
+        return convertNumber<T>(data->content.asUint32);
       case VariantType::Int32:
-        return convertNumber<T>(content_.asInt32);
+        return convertNumber<T>(data->content.asInt32);
 #if ARDUINOJSON_USE_LONG_LONG
       case VariantType::Uint64:
         return convertNumber<T>(eightByteValue->asUint64);
@@ -251,13 +317,13 @@ class VariantData {
         return convertNumber<T>(eightByteValue->asInt64);
 #endif
       case VariantType::TinyString:
-        str = content_.asTinyString;
+        str = data->content.asTinyString;
         break;
       case VariantType::LongString:
-        str = content_.asStringNode->data;
+        str = data->content.asStringNode->data;
         break;
       case VariantType::Float:
-        return convertNumber<T>(content_.asFloat);
+        return convertNumber<T>(data->content.asFloat);
 #if ARDUINOJSON_USE_DOUBLE
       case VariantType::Double:
         return convertNumber<T>(eightByteValue->asDouble);
@@ -270,108 +336,81 @@ class VariantData {
     return parseNumber<T>(str);
   }
 
-  ObjectImpl asObject(ResourceManager* resources) {
-    return ObjectImpl(isObject() ? &content_.asCollection : nullptr, resources);
+  ObjectImpl asObject() {
+    return asObject(data_, resources_);
   }
 
-  static ObjectImpl asObject(VariantData* var, ResourceManager* resources) {
-    return ObjectImpl(
-        var && var->isObject() ? &var->content_.asCollection : nullptr,
-        resources);
-  }
-
-  JsonString asRawString() const {
-    switch (type_) {
-      case VariantType::RawString:
-        return JsonString(content_.asStringNode->data,
-                          content_.asStringNode->length);
-      default:
-        return JsonString();
-    }
-  }
-
-  JsonString asString() const {
-    switch (type_) {
-      case VariantType::TinyString:
-        return JsonString(content_.asTinyString);
-      case VariantType::LongString:
-        return JsonString(content_.asStringNode->data,
-                          content_.asStringNode->length);
-      default:
-        return JsonString();
-    }
+  static ObjectImpl asObject(VariantData* data, ResourceManager* resources) {
+    return ObjectImpl(data && data->type == VariantType::Object
+                          ? &data->content.asCollection
+                          : nullptr,
+                      resources);
   }
 
 #if ARDUINOJSON_USE_8_BYTE_POOL
-  const EightByteValue* getEightByte(const ResourceManager* resources) const;
+  static const EightByteValue* getEightByte(VariantData*, ResourceManager*);
 #endif
 
-  VariantData* getElement(size_t index, ResourceManager* resources) {
-    return asArray(resources).getElement(index);
-  }
-
-  static VariantData* getElement(VariantData* var, size_t index,
-                                 ResourceManager* resources) {
-    if (!var)
-      return nullptr;
-    return var->asArray(resources).getElement(index);
+  VariantData* getElement(size_t index) {
+    return asArray().getElement(index);
   }
 
   template <typename TAdaptedString>
-  VariantData* getMember(TAdaptedString key, ResourceManager* resources) {
-    return asObject(resources).getMember(key);
+  VariantData* getMember(TAdaptedString key) {
+    return asObject().getMember(key);
   }
 
-  template <typename TAdaptedString>
-  static VariantData* getMember(VariantData* var, TAdaptedString key,
-                                ResourceManager* resources) {
-    if (!var)
-      return 0;
-    return var->getMember(key, resources);
-  }
-
-  VariantData* getOrAddElement(size_t index, ResourceManager* resources) {
-    auto array = isNull() ? toArray(resources) : asArray(resources);
+  VariantData* getOrAddElement(size_t index) {
+    auto array = isNull() ? toArray() : asArray();
     return array.getOrAddElement(index);
   }
 
   template <typename TAdaptedString>
-  VariantData* getOrAddMember(TAdaptedString key, ResourceManager* resources) {
+  VariantData* getOrAddMember(TAdaptedString key) {
+    return getOrAddMember(key, data_, resources_);
+  }
+
+  template <typename TAdaptedString>
+  static VariantData* getOrAddMember(TAdaptedString key, VariantData* data,
+                                     ResourceManager* resources) {
     if (key.isNull())
       return nullptr;
-    auto obj = isNull() ? toObject(resources) : asObject(resources);
+    if (!data)
+      return nullptr;
+    auto obj = data->type == VariantType::Null ? toObject(data, resources)
+                                               : asObject(data, resources);
     return obj.getOrAddMember(key);
   }
 
   bool isArray() const {
-    return type_ == VariantType::Array;
-  }
-
-  bool isBoolean() const {
-    return type_ == VariantType::Boolean;
+    return type() == VariantType::Array;
   }
 
   bool isCollection() const {
-    return type_ & VariantTypeBits::CollectionMask;
-  }
-
-  bool isFloat() const {
-    return type_ & VariantTypeBits::NumberBit;
+    return type() & VariantTypeBits::CollectionMask;
   }
 
   template <typename T>
-  bool isInteger(const ResourceManager* resources) const {
+  bool isInteger() const {
+    return isInteger<T>(data_, resources_);
+  }
+
+  template <typename T>
+  static bool isInteger(VariantData* data, ResourceManager* resources) {
+    if (!data)
+      return false;
+
 #if ARDUINOJSON_USE_LONG_LONG
-    auto eightByteValue = getEightByte(resources);
+    auto eightByteValue = getEightByte(data, resources);
 #else
-    (void)resources;  // silence warning
+    (void)resources;
 #endif
-    switch (type_) {
+    switch (data->type) {
       case VariantType::Uint32:
-        return canConvertNumber<T>(content_.asUint32);
+        return canConvertNumber<T>(data->content.asUint32);
 
       case VariantType::Int32:
-        return canConvertNumber<T>(content_.asInt32);
+        return canConvertNumber<T>(data->content.asInt32);
 
 #if ARDUINOJSON_USE_LONG_LONG
       case VariantType::Uint64:
@@ -387,193 +426,139 @@ class VariantData {
   }
 
   bool isNull() const {
-    return type_ == VariantType::Null;
-  }
-
-  static bool isNull(const VariantData* var) {
-    if (!var)
-      return true;
-    return var->isNull();
+    return type() == VariantType::Null;
   }
 
   bool isObject() const {
-    return type_ == VariantType::Object;
+    return type() == VariantType::Object;
   }
 
-  bool isString() const {
-    return type_ == VariantType::LongString || type_ == VariantType::TinyString;
+  size_t nesting() {
+    return asCollection().nesting();
   }
 
-  size_t nesting(ResourceManager* resources) {
-    return asCollection(resources).nesting();
-  }
-
-  static size_t nesting(VariantData* var, ResourceManager* resources) {
-    if (!var)
-      return 0;
-    return var->nesting(resources);
-  }
-
-  void removeElement(size_t index, ResourceManager* resources) {
-    asArray(resources).removeElement(index);
-  }
-
-  static void removeElement(VariantData* var, size_t index,
-                            ResourceManager* resources) {
-    if (!var)
-      return;
-    var->removeElement(index, resources);
+  void removeElement(size_t index) {
+    asArray().removeElement(index);
   }
 
   template <typename TAdaptedString>
-  void removeMember(TAdaptedString key, ResourceManager* resources) {
-    asObject(resources).removeMember(key);
+  void removeMember(TAdaptedString key) {
+    asObject().removeMember(key);
   }
 
-  template <typename TAdaptedString>
-  static void removeMember(VariantData* var, TAdaptedString key,
-                           ResourceManager* resources) {
-    if (!var)
-      return;
-    var->removeMember(key, resources);
-  }
-
-  void reset() {  // TODO: remove
-    type_ = VariantType::Null;
-  }
-
-  void setBoolean(bool value) {
-    ARDUINOJSON_ASSERT(type_ == VariantType::Null);  // must call clear() first
-    type_ = VariantType::Boolean;
-    content_.asBoolean = value;
-  }
-
-  template <typename T>
-  enable_if_t<sizeof(T) == 4, bool> setFloat(T value, ResourceManager*) {
-    ARDUINOJSON_ASSERT(type_ == VariantType::Null);  // must call clear() first
-    type_ = VariantType::Float;
-    content_.asFloat = value;
+  bool setBoolean(bool value) {
+    if (!data_)
+      return false;
+    clear(data_, resources_);
+    data_->setBoolean(value);
     return true;
   }
 
   template <typename T>
-  enable_if_t<sizeof(T) == 8, bool> setFloat(T value, ResourceManager*);
-
-  template <typename T>
-  enable_if_t<is_signed<T>::value, bool> setInteger(T value,
-                                                    ResourceManager* resources);
-
-  template <typename T>
-  enable_if_t<is_unsigned<T>::value, bool> setInteger(
-      T value, ResourceManager* resources);
-
-  void setRawString(StringNode* s) {
-    ARDUINOJSON_ASSERT(type_ == VariantType::Null);  // must call clear() first
-    ARDUINOJSON_ASSERT(s);
-    type_ = VariantType::RawString;
-    content_.asStringNode = s;
+  bool setFloat(T value) {
+    if (!data_)
+      return false;
+    clear(data_, resources_);
+    return setFloat(value, data_, resources_);
   }
 
   template <typename T>
-  void setRawString(SerializedValue<T> value, ResourceManager* resources);
+  static enable_if_t<sizeof(T) == 4, bool> setFloat(T value, VariantData* data,
+                                                    ResourceManager*) {
+    ARDUINOJSON_ASSERT(data != nullptr);
+    ARDUINOJSON_ASSERT(data->type == VariantType::Null);
+    data->type = VariantType::Float;
+    data->content.asFloat = value;
+    return true;
+  }
 
   template <typename T>
-  static void setRawString(VariantData* var, SerializedValue<T> value,
-                           ResourceManager* resources) {
-    if (!var)
-      return;
-    var->clear(resources);
-    var->setRawString(value, resources);
+  static enable_if_t<sizeof(T) == 8, bool> setFloat(T value, VariantData*,
+                                                    ResourceManager*);
+
+  template <typename T>
+  bool setInteger(T value) {
+    if (!data_)
+      return false;
+    clear(data_, resources_);
+    return setInteger(value, data_, resources_);
+  }
+
+  template <typename T>
+  static enable_if_t<is_signed<T>::value, bool> setInteger(T value,
+                                                           VariantData*,
+                                                           ResourceManager*);
+
+  template <typename T>
+  static enable_if_t<is_unsigned<T>::value, bool> setInteger(T value,
+                                                             VariantData*,
+                                                             ResourceManager*);
+
+  template <typename T>
+  void setRawString(SerializedValue<T> value);
+
+  template <typename TAdaptedString>
+  bool setString(TAdaptedString value) {
+    if (!data_)
+      return false;
+    clear(data_, resources_);
+    return setString(value, data_, resources_);
   }
 
   template <typename TAdaptedString>
-  bool setString(TAdaptedString value, ResourceManager* resources);
+  static bool setString(TAdaptedString value, VariantData*, ResourceManager*);
 
-  template <typename TAdaptedString>
-  static void setString(VariantData* var, TAdaptedString value,
-                        ResourceManager* resources) {
-    if (!var)
-      return;
-    var->clear(resources);
-    var->setString(value, resources);
-  }
-
-  template <typename TAdaptedString>
-  void setTinyString(const TAdaptedString& s) {
-    ARDUINOJSON_ASSERT(type_ == VariantType::Null);  // must call clear() first
-    ARDUINOJSON_ASSERT(s.size() <= tinyStringMaxLength);
-
-    type_ = VariantType::TinyString;
-
-    auto n = uint8_t(s.size());
-    for (uint8_t i = 0; i < n; i++) {
-      char c = s[i];
-      ARDUINOJSON_ASSERT(c != 0);  // no NUL in tiny string
-      content_.asTinyString[i] = c;
-    }
-
-    content_.asTinyString[n] = 0;
-  }
-
-  void setLongString(StringNode* s) {
-    ARDUINOJSON_ASSERT(type_ == VariantType::Null);  // must call clear() first
-    ARDUINOJSON_ASSERT(s);
-    type_ = VariantType::LongString;
-    content_.asStringNode = s;
-  }
-
-  size_t size(ResourceManager* resources) {
+  size_t size() {
     if (isObject())
-      return asObject(resources).size();
+      return asObject().size();
 
     if (isArray())
-      return asArray(resources).size();
+      return asArray().size();
 
     return 0;
   }
 
-  static size_t size(VariantData* var, ResourceManager* resources) {
-    return var != 0 ? var->size(resources) : 0;
+  ArrayImpl toArray() {
+    if (!data_)
+      return ArrayImpl();
+    clear(data_, resources_);
+    return toArray(data_, resources_);
   }
 
-  ArrayImpl toArray(ResourceManager* resources) {
-    ARDUINOJSON_ASSERT(type_ == VariantType::Null);  // must call clear() first
-    type_ = VariantType::Array;
-    return ArrayImpl(new (&content_.asCollection) CollectionData(), resources);
+  static ArrayImpl toArray(VariantData* data, ResourceManager* resources) {
+    ARDUINOJSON_ASSERT(data != nullptr);
+    ARDUINOJSON_ASSERT(resources != nullptr);
+    return ArrayImpl(data->toArray(), resources);
   }
 
-  static ArrayImpl toArray(VariantData* var, ResourceManager* resources) {
-    if (!var)
-      return ArrayImpl(nullptr, resources);
-    var->clear(resources);
-    return var->toArray(resources);
-  }
-
-  ObjectImpl toObject(ResourceManager* resources) {
-    ARDUINOJSON_ASSERT(type_ == VariantType::Null);  // must call clear() first
-    type_ = VariantType::Object;
-    return ObjectImpl(new (&content_.asCollection) CollectionData(), resources);
-  }
-
-  static ObjectImpl toObject(VariantData* var, ResourceManager* resources) {
-    if (!var)
+  ObjectImpl toObject() {
+    if (!data_)
       return ObjectImpl();
-    var->clear(resources);
-    return var->toObject(resources);
+    clear(data_, resources_);
+    return toObject(data_, resources_);
+  }
+
+  static ObjectImpl toObject(VariantData* data, ResourceManager* resources) {
+    ARDUINOJSON_ASSERT(data != nullptr);
+    ARDUINOJSON_ASSERT(resources != nullptr);
+    return ObjectImpl(data->toObject(), resources);
   }
 
   VariantType type() const {
-    return type_;
+    return data_ ? data_->type : VariantType::Null;
   }
 
   // Release the resources used by this variant and set it to null.
-  void clear(ResourceManager* resources);
-
-  static void clear(VariantData* var, ResourceManager* resources) {
-    if (!var)
-      return;
-    var->clear(resources);
+  void clear() {
+    if (data_)
+      clear(data_, resources_);
   }
+
+  static void clear(VariantData*, ResourceManager*);
+
+ private:
+  VariantData* data_;
+  ResourceManager* resources_;
 };
 
 ARDUINOJSON_END_PRIVATE_NAMESPACE
diff --git a/src/ArduinoJson/Variant/VariantImpl.hpp b/src/ArduinoJson/Variant/VariantImpl.hpp
index 6923b347..da93b184 100644
--- a/src/ArduinoJson/Variant/VariantImpl.hpp
+++ b/src/ArduinoJson/Variant/VariantImpl.hpp
@@ -9,129 +9,204 @@
 
 ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
 
+template <typename TVisitor>
+typename TVisitor::result_type VariantImpl::accept(TVisitor& visit,
+                                                   VariantData* data,
+                                                   ResourceManager* resources) {
+  if (!data)
+    return visit.visit(nullptr);
+
+#if ARDUINOJSON_USE_8_BYTE_POOL
+  auto eightByteValue = getEightByte(data, resources);
+#endif
+  switch (data->type) {
+    case VariantType::Float:
+      return visit.visit(data->content.asFloat);
+
+#if ARDUINOJSON_USE_DOUBLE
+    case VariantType::Double:
+      return visit.visit(eightByteValue->asDouble);
+#endif
+
+    case VariantType::Array:
+      return visit.visit(ArrayImpl(&data->content.asCollection, resources));
+
+    case VariantType::Object:
+      return visit.visit(ObjectImpl(&data->content.asCollection, resources));
+
+    case VariantType::TinyString:
+      return visit.visit(JsonString(data->content.asTinyString));
+
+    case VariantType::LongString:
+      return visit.visit(JsonString(data->content.asStringNode->data,
+                                    data->content.asStringNode->length));
+
+    case VariantType::RawString:
+      return visit.visit(RawString(data->content.asStringNode->data,
+                                   data->content.asStringNode->length));
+
+    case VariantType::Int32:
+      return visit.visit(static_cast<JsonInteger>(data->content.asInt32));
+
+    case VariantType::Uint32:
+      return visit.visit(static_cast<JsonUInt>(data->content.asUint32));
+
+#if ARDUINOJSON_USE_LONG_LONG
+    case VariantType::Int64:
+      return visit.visit(eightByteValue->asInt64);
+
+    case VariantType::Uint64:
+      return visit.visit(eightByteValue->asUint64);
+#endif
+
+    case VariantType::Boolean:
+      return visit.visit(data->content.asBoolean != 0);
+
+    default:
+      return visit.visit(nullptr);
+  }
+}
+
 template <typename T>
-inline void VariantData::setRawString(SerializedValue<T> value,
-                                      ResourceManager* resources) {
-  ARDUINOJSON_ASSERT(type_ == VariantType::Null);  // must call clear() first
-  auto dup = resources->saveString(adaptString(value.data(), value.size()));
+inline void VariantImpl::setRawString(SerializedValue<T> value) {
+  if (!data_)
+    return;
+  clear(data_, resources_);
+  auto dup = resources_->saveString(adaptString(value.data(), value.size()));
   if (dup)
-    setRawString(dup);
+    data_->setRawString(dup);
 }
 
 template <typename TAdaptedString>
-inline bool VariantData::setString(TAdaptedString value,
+inline bool VariantImpl::setString(TAdaptedString value, VariantData* data,
                                    ResourceManager* resources) {
-  ARDUINOJSON_ASSERT(type_ == VariantType::Null);  // must call clear() first
+  ARDUINOJSON_ASSERT(data != nullptr);
+  ARDUINOJSON_ASSERT(data->type == VariantType::Null);
+  ARDUINOJSON_ASSERT(resources != nullptr);
 
   if (value.isNull())
     return false;
 
   if (isTinyString(value, value.size())) {
-    setTinyString(value);
+    data->setTinyString(value);
     return true;
   }
 
   auto dup = resources->saveString(value);
   if (dup) {
-    setLongString(dup);
+    data->setLongString(dup);
     return true;
   }
 
   return false;
 }
 
-inline void VariantData::clear(ResourceManager* resources) {
-  if (type_ & VariantTypeBits::OwnedStringBit)
-    resources->dereferenceString(content_.asStringNode->data);
+inline void VariantImpl::clear(VariantData* data, ResourceManager* resources) {
+  ARDUINOJSON_ASSERT(data != nullptr);
+  ARDUINOJSON_ASSERT(resources != nullptr);
+
+  if (data->type & VariantTypeBits::OwnedStringBit)
+    resources->dereferenceString(data->content.asStringNode->data);
 
 #if ARDUINOJSON_USE_8_BYTE_POOL
-  if (type_ & VariantTypeBits::EightByteBit)
-    resources->freeEightByte(content_.asSlotId);
+  if (data->type & VariantTypeBits::EightByteBit)
+    resources->freeEightByte(data->content.asSlotId);
 #endif
 
-  asCollection(resources).clear();
+  if (data->type & VariantTypeBits::CollectionMask)
+    CollectionImpl(&data->content.asCollection, resources).clear();
 
-  type_ = VariantType::Null;
+  data->type = VariantType::Null;
 }
 
 #if ARDUINOJSON_USE_8_BYTE_POOL
-inline const EightByteValue* VariantData::getEightByte(
-    const ResourceManager* resources) const {
-  return type_ & VariantTypeBits::EightByteBit
-             ? resources->getEightByte(content_.asSlotId)
+inline const EightByteValue* VariantImpl::getEightByte(
+    VariantData* data, ResourceManager* resources) {
+  ARDUINOJSON_ASSERT(data != nullptr);
+  ARDUINOJSON_ASSERT(resources != nullptr);
+  return data->type & VariantTypeBits::EightByteBit
+             ? resources->getEightByte(data->content.asSlotId)
              : 0;
 }
+
 #endif
 
 template <typename T>
-enable_if_t<sizeof(T) == 8, bool> VariantData::setFloat(
-    T value, ResourceManager* resources) {
-  ARDUINOJSON_ASSERT(type_ == VariantType::Null);  // must call clear() first
-  (void)resources;                                 // silence warning
+enable_if_t<sizeof(T) == 8, bool> VariantImpl::setFloat(
+    T value, VariantData* data, ResourceManager* resources) {
+  ARDUINOJSON_ASSERT(data != nullptr);
+  ARDUINOJSON_ASSERT(data->type == VariantType::Null);
+  ARDUINOJSON_ASSERT(resources != nullptr);
 
   float valueAsFloat = static_cast<float>(value);
 
 #if ARDUINOJSON_USE_DOUBLE
   if (value == valueAsFloat) {
-    type_ = VariantType::Float;
-    content_.asFloat = valueAsFloat;
+    data->type = VariantType::Float;
+    data->content.asFloat = valueAsFloat;
   } else {
     auto slot = resources->allocEightByte();
     if (!slot)
       return false;
-    type_ = VariantType::Double;
-    content_.asSlotId = slot.id();
+    data->type = VariantType::Double;
+    data->content.asSlotId = slot.id();
     slot->asDouble = value;
   }
 #else
-  type_ = VariantType::Float;
-  content_.asFloat = valueAsFloat;
+  data->type = VariantType::Float;
+  data->content.asFloat = valueAsFloat;
 #endif
   return true;
 }
 
 template <typename T>
-enable_if_t<is_signed<T>::value, bool> VariantData::setInteger(
-    T value, ResourceManager* resources) {
-  ARDUINOJSON_ASSERT(type_ == VariantType::Null);  // must call clear() first
-  (void)resources;                                 // silence warning
+enable_if_t<is_signed<T>::value, bool> VariantImpl::setInteger(
+    T value, VariantData* data, ResourceManager* resources) {
+  ARDUINOJSON_ASSERT(data != nullptr);
+  ARDUINOJSON_ASSERT(data->type == VariantType::Null);
+  ARDUINOJSON_ASSERT(resources != nullptr);
 
   if (canConvertNumber<int32_t>(value)) {
-    type_ = VariantType::Int32;
-    content_.asInt32 = static_cast<int32_t>(value);
+    data->type = VariantType::Int32;
+    data->content.asInt32 = static_cast<int32_t>(value);
   }
 #if ARDUINOJSON_USE_LONG_LONG
   else {
     auto slot = resources->allocEightByte();
     if (!slot)
       return false;
-    type_ = VariantType::Int64;
-    content_.asSlotId = slot.id();
+    data->type = VariantType::Int64;
+    data->content.asSlotId = slot.id();
     slot->asInt64 = value;
   }
+#else
+  (void)resources;
 #endif
   return true;
 }
 
 template <typename T>
-enable_if_t<is_unsigned<T>::value, bool> VariantData::setInteger(
-    T value, ResourceManager* resources) {
-  ARDUINOJSON_ASSERT(type_ == VariantType::Null);  // must call clear() first
-  (void)resources;                                 // silence warning
+enable_if_t<is_unsigned<T>::value, bool> VariantImpl::setInteger(
+    T value, VariantData* data, ResourceManager* resources) {
+  ARDUINOJSON_ASSERT(data != nullptr);
+  ARDUINOJSON_ASSERT(data->type == VariantType::Null);
+  ARDUINOJSON_ASSERT(resources != nullptr);
 
   if (canConvertNumber<uint32_t>(value)) {
-    type_ = VariantType::Uint32;
-    content_.asUint32 = static_cast<uint32_t>(value);
+    data->type = VariantType::Uint32;
+    data->content.asUint32 = static_cast<uint32_t>(value);
   }
 #if ARDUINOJSON_USE_LONG_LONG
   else {
     auto slot = resources->allocEightByte();
     if (!slot)
       return false;
-    type_ = VariantType::Uint64;
-    content_.asSlotId = slot.id();
+    data->type = VariantType::Uint64;
+    data->content.asSlotId = slot.id();
     slot->asUint64 = value;
   }
+#else
+  (void)resources;
 #endif
   return true;
 }
diff --git a/src/ArduinoJson/Variant/VariantRefBase.hpp b/src/ArduinoJson/Variant/VariantRefBase.hpp
index 975c9610..3ad24fb8 100644
--- a/src/ArduinoJson/Variant/VariantRefBase.hpp
+++ b/src/ArduinoJson/Variant/VariantRefBase.hpp
@@ -29,13 +29,13 @@ class VariantRefBase : public VariantTag {
   // Sets the value to null.
   // https://arduinojson.org/v7/api/jsonvariant/clear/
   void clear() const {
-    VariantData::clear(getOrCreateData(), getResourceManager());
+    getOrCreateVariantImpl().clear();
   }
 
   // Returns true if the value is null or the reference is unbound.
   // https://arduinojson.org/v7/api/jsonvariant/isnull/
   bool isNull() const {
-    return VariantData::isNull(getData());
+    return getVariantImpl().isNull();
   }
 
   // Returns true if the reference is unbound.
@@ -93,13 +93,13 @@ class VariantRefBase : public VariantTag {
   // Returns the size of the array or object.
   // https://arduinojson.org/v7/api/jsonvariant/size/
   size_t size() const {
-    return VariantData::size(getData(), getResourceManager());
+    return getVariantImpl().size();
   }
 
   // Returns the depth (nesting level) of the value.
   // https://arduinojson.org/v7/api/jsonvariant/nesting/
   size_t nesting() const {
-    return VariantData::nesting(getData(), getResourceManager());
+    return getVariantImpl().nesting();
   }
 
   // Appends a new (empty) element to the array.
@@ -120,38 +120,34 @@ class VariantRefBase : public VariantTag {
   // https://arduinojson.org/v7/api/jsonvariant/add/
   template <typename T>
   bool add(const T& value) const {
-    return detail::VariantData::addValue(getOrCreateData(), value,
-                                         getResourceManager());
+    return getOrCreateVariantImpl().addValue(value);
   }
 
   // Appends a value to the array.
   // https://arduinojson.org/v7/api/jsonvariant/add/
   template <typename T, enable_if_t<!is_const<T>::value, int> = 0>
   bool add(T* value) const {
-    return detail::VariantData::addValue(getOrCreateData(), value,
-                                         getResourceManager());
+    return getOrCreateVariantImpl().addValue(value);
   }
 
   // Removes an element of the array.
   // https://arduinojson.org/v7/api/jsonvariant/remove/
   void remove(size_t index) const {
-    VariantData::removeElement(getData(), index, getResourceManager());
+    getVariantImpl().removeElement(index);
   }
 
   // Removes a member of the object.
   // https://arduinojson.org/v7/api/jsonvariant/remove/
   template <typename TChar, enable_if_t<IsString<TChar*>::value, int> = 0>
   void remove(TChar* key) const {
-    VariantData::removeMember(getData(), adaptString(key),
-                              getResourceManager());
+    getVariantImpl().removeMember(adaptString(key));
   }
 
   // Removes a member of the object.
   // https://arduinojson.org/v7/api/jsonvariant/remove/
   template <typename TString, enable_if_t<IsString<TString>::value, int> = 0>
   void remove(const TString& key) const {
-    VariantData::removeMember(getData(), adaptString(key),
-                              getResourceManager());
+    getVariantImpl().removeMember(adaptString(key));
   }
 
   // Removes a member of the object or an element of the array.
@@ -275,6 +271,14 @@ class VariantRefBase : public VariantTag {
     return VariantAttorney::getOrCreateData(derived());
   }
 
+  VariantImpl getVariantImpl() const {
+    return VariantImpl(getData(), getResourceManager());
+  }
+
+  VariantImpl getOrCreateVariantImpl() const {
+    return VariantImpl(getOrCreateData(), getResourceManager());
+  }
+
   FORCE_INLINE ArduinoJson::JsonVariant getVariant() const;
 
   FORCE_INLINE ArduinoJson::JsonVariantConst getVariantConst() const {
diff --git a/src/ArduinoJson/Variant/VariantRefBaseImpl.hpp b/src/ArduinoJson/Variant/VariantRefBaseImpl.hpp
index 1d4bc2a5..4621ef65 100644
--- a/src/ArduinoJson/Variant/VariantRefBaseImpl.hpp
+++ b/src/ArduinoJson/Variant/VariantRefBaseImpl.hpp
@@ -69,23 +69,20 @@ inline void convertToJson(const VariantRefBase<TDerived>& src,
 template <typename TDerived>
 template <typename T, enable_if_t<is_same<T, JsonVariant>::value, int>>
 inline T VariantRefBase<TDerived>::add() const {
-  return JsonVariant(
-      detail::VariantData::addElement(getOrCreateData(), getResourceManager()),
-      getResourceManager());
+  return JsonVariant(getOrCreateVariantImpl().addElement(),
+                     getResourceManager());
 }
 
 template <typename TDerived>
 template <typename TString, enable_if_t<IsString<TString>::value, int>>
 inline bool VariantRefBase<TDerived>::containsKey(const TString& key) const {
-  return VariantData::getMember(getData(), adaptString(key),
-                                getResourceManager()) != 0;
+  return getVariantImpl().getMember(adaptString(key)) != 0;
 }
 
 template <typename TDerived>
 template <typename TChar, enable_if_t<IsString<TChar*>::value, int>>
 inline bool VariantRefBase<TDerived>::containsKey(TChar* key) const {
-  return VariantData::getMember(getData(), adaptString(key),
-                                getResourceManager()) != 0;
+  return getVariantImpl().getMember(adaptString(key)) != 0;
 }
 
 template <typename TDerived>
@@ -150,24 +147,21 @@ inline bool VariantRefBase<TDerived>::doSet(const T& value, true_type) const {
 template <typename TDerived>
 template <typename T, enable_if_t<is_same<T, JsonArray>::value, int>>
 inline JsonArray VariantRefBase<TDerived>::to() const {
-  return JsonArray(
-      VariantData::toArray(getOrCreateData(), getResourceManager()));
+  return JsonArray(getOrCreateVariantImpl().toArray());
 }
 
 template <typename TDerived>
 template <typename T, enable_if_t<is_same<T, JsonObject>::value, int>>
 JsonObject VariantRefBase<TDerived>::to() const {
-  return JsonObject(
-      VariantData::toObject(getOrCreateData(), getResourceManager()));
+  return JsonObject(getOrCreateVariantImpl().toObject());
 }
 
 template <typename TDerived>
 template <typename T, enable_if_t<is_same<T, JsonVariant>::value, int>>
 JsonVariant VariantRefBase<TDerived>::to() const {
-  auto data = getOrCreateData();
-  auto resources = getResourceManager();
-  detail::VariantData::clear(data, resources);
-  return JsonVariant(data, resources);
+  auto impl = getOrCreateVariantImpl();
+  impl.clear();
+  return JsonVariant(impl);
 }
 
 ARDUINOJSON_END_PRIVATE_NAMESPACE