add arduinoJson

lib/ArduinoJson/src/ArduinoJson.h

@@ -0,0 +1,17 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#ifdef __cplusplus
+
+#  include "ArduinoJson.hpp"
+
+using namespace ArduinoJson;
+
+#else
+
+#error ArduinoJson requires a C++ compiler, please change file extension to .cc or .cpp
+
+#endif

lib/ArduinoJson/src/ArduinoJson.hpp

@@ -0,0 +1,80 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include "ArduinoJson/Configuration.hpp"
+
+// Include Arduino.h before stdlib.h to avoid conflict with atexit()
+// https://github.com/bblanchon/ArduinoJson/pull/1693#issuecomment-1001060240
+#if ARDUINOJSON_ENABLE_ARDUINO_STRING || ARDUINOJSON_ENABLE_ARDUINO_STREAM || \
+    ARDUINOJSON_ENABLE_ARDUINO_PRINT || ARDUINOJSON_ENABLE_PROGMEM
+#  include <Arduino.h>
+#endif
+
+#if !ARDUINOJSON_DEBUG
+#  ifdef __clang__
+#    pragma clang system_header
+#  elif defined __GNUC__
+#    pragma GCC system_header
+#  endif
+#endif
+
+#include "ArduinoJson/Array/JsonArray.hpp"
+#include "ArduinoJson/Object/JsonObject.hpp"
+#include "ArduinoJson/Variant/JsonVariantConst.hpp"
+
+#include "ArduinoJson/Document/DynamicJsonDocument.hpp"
+#include "ArduinoJson/Document/StaticJsonDocument.hpp"
+
+#include "ArduinoJson/Array/ElementProxy.hpp"
+#include "ArduinoJson/Array/JsonArrayImpl.hpp"
+#include "ArduinoJson/Array/Utilities.hpp"
+#include "ArduinoJson/Collection/CollectionImpl.hpp"
+#include "ArduinoJson/Object/JsonObjectImpl.hpp"
+#include "ArduinoJson/Object/MemberProxy.hpp"
+#include "ArduinoJson/Variant/ConverterImpl.hpp"
+#include "ArduinoJson/Variant/VariantCompare.hpp"
+#include "ArduinoJson/Variant/VariantImpl.hpp"
+
+#include "ArduinoJson/Json/JsonDeserializer.hpp"
+#include "ArduinoJson/Json/JsonSerializer.hpp"
+#include "ArduinoJson/Json/PrettyJsonSerializer.hpp"
+#include "ArduinoJson/MsgPack/MsgPackDeserializer.hpp"
+#include "ArduinoJson/MsgPack/MsgPackSerializer.hpp"
+
+#include "ArduinoJson/compatibility.hpp"
+
+namespace ArduinoJson {
+using ARDUINOJSON_NAMESPACE::BasicJsonDocument;
+using ARDUINOJSON_NAMESPACE::copyArray;
+using ARDUINOJSON_NAMESPACE::DeserializationError;
+using ARDUINOJSON_NAMESPACE::deserializeJson;
+using ARDUINOJSON_NAMESPACE::deserializeMsgPack;
+using ARDUINOJSON_NAMESPACE::DynamicJsonDocument;
+using ARDUINOJSON_NAMESPACE::JsonArray;
+using ARDUINOJSON_NAMESPACE::JsonArrayConst;
+using ARDUINOJSON_NAMESPACE::JsonDocument;
+using ARDUINOJSON_NAMESPACE::JsonFloat;
+using ARDUINOJSON_NAMESPACE::JsonInteger;
+using ARDUINOJSON_NAMESPACE::JsonObject;
+using ARDUINOJSON_NAMESPACE::JsonObjectConst;
+using ARDUINOJSON_NAMESPACE::JsonPair;
+using ARDUINOJSON_NAMESPACE::JsonPairConst;
+using ARDUINOJSON_NAMESPACE::JsonString;
+using ARDUINOJSON_NAMESPACE::JsonUInt;
+using ARDUINOJSON_NAMESPACE::JsonVariant;
+using ARDUINOJSON_NAMESPACE::JsonVariantConst;
+using ARDUINOJSON_NAMESPACE::measureJson;
+using ARDUINOJSON_NAMESPACE::serialized;
+using ARDUINOJSON_NAMESPACE::serializeJson;
+using ARDUINOJSON_NAMESPACE::serializeJsonPretty;
+using ARDUINOJSON_NAMESPACE::serializeMsgPack;
+using ARDUINOJSON_NAMESPACE::StaticJsonDocument;
+
+namespace DeserializationOption {
+using ARDUINOJSON_NAMESPACE::Filter;
+using ARDUINOJSON_NAMESPACE::NestingLimit;
+}  // namespace DeserializationOption
+}  // namespace ArduinoJson

lib/ArduinoJson/src/ArduinoJson/Array/ElementProxy.hpp

@@ -0,0 +1,60 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Variant/VariantRefBase.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+// A proxy class to get or set an element of an array.
+// https://arduinojson.org/v6/api/jsonarray/subscript/
+template <typename TUpstream>
+class ElementProxy : public VariantRefBase<ElementProxy<TUpstream> >,
+                     public VariantOperators<ElementProxy<TUpstream> > {
+  friend class VariantAttorney;
+
+ public:
+  ElementProxy(TUpstream upstream, size_t index)
+      : _upstream(upstream), _index(index) {}
+
+  ElementProxy(const ElementProxy& src)
+      : _upstream(src._upstream), _index(src._index) {}
+
+  FORCE_INLINE ElementProxy& operator=(const ElementProxy& src) {
+    this->set(src);
+    return *this;
+  }
+
+  template <typename T>
+  FORCE_INLINE ElementProxy& operator=(const T& src) {
+    this->set(src);
+    return *this;
+  }
+
+  template <typename T>
+  FORCE_INLINE ElementProxy& operator=(T* src) {
+    this->set(src);
+    return *this;
+  }
+
+ private:
+  FORCE_INLINE MemoryPool* getPool() const {
+    return VariantAttorney::getPool(_upstream);
+  }
+
+  FORCE_INLINE VariantData* getData() const {
+    return variantGetElement(VariantAttorney::getData(_upstream), _index);
+  }
+
+  FORCE_INLINE VariantData* getOrCreateData() const {
+    return variantGetOrAddElement(VariantAttorney::getOrCreateData(_upstream),
+                                  _index, VariantAttorney::getPool(_upstream));
+  }
+
+  TUpstream _upstream;
+  size_t _index;
+};
+
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Array/JsonArray.hpp

@@ -0,0 +1,210 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Array/ElementProxy.hpp>
+#include <ArduinoJson/Array/JsonArrayConst.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+class JsonObject;
+
+// A reference to an array in a JsonDocument
+// https://arduinojson.org/v6/api/jsonarray/
+class JsonArray : public VariantOperators<JsonArray> {
+  friend class VariantAttorney;
+
+ public:
+  typedef JsonArrayIterator iterator;
+
+  // Constructs an unbound reference.
+  FORCE_INLINE JsonArray() : _data(0), _pool(0) {}
+
+  // INTERNAL USE ONLY
+  FORCE_INLINE JsonArray(MemoryPool* pool, CollectionData* data)
+      : _data(data), _pool(pool) {}
+
+  // Returns a JsonVariant pointing to the array.
+  // https://arduinojson.org/v6/api/jsonvariant/
+  operator JsonVariant() {
+    void* data = _data;  // prevent warning cast-align
+    return JsonVariant(_pool, reinterpret_cast<VariantData*>(data));
+  }
+
+  // Returns a read-only reference to the array.
+  // https://arduinojson.org/v6/api/jsonarrayconst/
+  operator JsonArrayConst() const {
+    return JsonArrayConst(_data);
+  }
+
+  // Appends a new (null) element to the array.
+  // Returns a reference to the new element.
+  // https://arduinojson.org/v6/api/jsonarray/add/
+  JsonVariant add() const {
+    if (!_data)
+      return JsonVariant();
+    return JsonVariant(_pool, _data->addElement(_pool));
+  }
+
+  // Appends a value to the array.
+  // https://arduinojson.org/v6/api/jsonarray/add/
+  template <typename T>
+  FORCE_INLINE bool add(const T& value) const {
+    return add().set(value);
+  }
+
+  // Appends a value to the array.
+  // https://arduinojson.org/v6/api/jsonarray/add/
+  template <typename T>
+  FORCE_INLINE bool add(T* value) const {
+    return add().set(value);
+  }
+
+  // Returns an iterator to the first element of the array.
+  // https://arduinojson.org/v6/api/jsonarray/begin/
+  FORCE_INLINE iterator begin() const {
+    if (!_data)
+      return iterator();
+    return iterator(_pool, _data->head());
+  }
+
+  // Returns an iterator following the last element of the array.
+  // https://arduinojson.org/v6/api/jsonarray/end/
+  FORCE_INLINE iterator end() const {
+    return iterator();
+  }
+
+  // Copies an array.
+  // https://arduinojson.org/v6/api/jsonarray/set/
+  FORCE_INLINE bool set(JsonArrayConst src) const {
+    if (!_data || !src._data)
+      return false;
+    return _data->copyFrom(*src._data, _pool);
+  }
+
+  // Compares the content of two arrays.
+  FORCE_INLINE bool operator==(JsonArray rhs) const {
+    return JsonArrayConst(_data) == JsonArrayConst(rhs._data);
+  }
+
+  // Removes the element at the specified iterator.
+  // ⚠️ Doesn't release the memory associated with the removed element.
+  // https://arduinojson.org/v6/api/jsonarray/remove/
+  FORCE_INLINE void remove(iterator it) const {
+    if (!_data)
+      return;
+    _data->removeSlot(it._slot);
+  }
+
+  // Removes the element at the specified index.
+  // ⚠️ Doesn't release the memory associated with the removed element.
+  // https://arduinojson.org/v6/api/jsonarray/remove/
+  FORCE_INLINE void remove(size_t index) const {
+    if (!_data)
+      return;
+    _data->removeElement(index);
+  }
+
+  // Removes all the elements of the array.
+  // ⚠️ Doesn't release the memory associated with the removed elements.
+  // https://arduinojson.org/v6/api/jsonarray/clear/
+  void clear() const {
+    if (!_data)
+      return;
+    _data->clear();
+  }
+
+  // Gets or sets the element at the specified index.
+  // https://arduinojson.org/v6/api/jsonarray/subscript/
+  FORCE_INLINE ElementProxy<JsonArray> operator[](size_t index) const {
+    return ElementProxy<JsonArray>(*this, index);
+  }
+
+  // Creates an object and appends it to the array.
+  // https://arduinojson.org/v6/api/jsonarray/createnestedobject/
+  FORCE_INLINE JsonObject createNestedObject() const;
+
+  // Creates an array and appends it to the array.
+  // https://arduinojson.org/v6/api/jsonarray/createnestedarray/
+  FORCE_INLINE JsonArray createNestedArray() const {
+    return add().to<JsonArray>();
+  }
+
+  operator JsonVariantConst() const {
+    return JsonVariantConst(collectionToVariant(_data));
+  }
+
+  // Returns true if the reference is unbound.
+  // https://arduinojson.org/v6/api/jsonarray/isnull/
+  FORCE_INLINE bool isNull() const {
+    return _data == 0;
+  }
+
+  // Returns true if the reference is bound.
+  // https://arduinojson.org/v6/api/jsonarray/isnull/
+  FORCE_INLINE operator bool() const {
+    return _data != 0;
+  }
+
+  // Returns the number of bytes occupied by the array.
+  // https://arduinojson.org/v6/api/jsonarray/memoryusage/
+  FORCE_INLINE size_t memoryUsage() const {
+    return _data ? _data->memoryUsage() : 0;
+  }
+
+  // Returns the depth (nesting level) of the array.
+  // https://arduinojson.org/v6/api/jsonarray/nesting/
+  FORCE_INLINE size_t nesting() const {
+    return variantNesting(collectionToVariant(_data));
+  }
+
+  // Returns the number of elements in the array.
+  // https://arduinojson.org/v6/api/jsonarray/size/
+  FORCE_INLINE size_t size() const {
+    return _data ? _data->size() : 0;
+  }
+
+ private:
+  MemoryPool* getPool() const {
+    return _pool;
+  }
+
+  VariantData* getData() const {
+    return collectionToVariant(_data);
+  }
+
+  VariantData* getOrCreateData() const {
+    return collectionToVariant(_data);
+  }
+
+  CollectionData* _data;
+  MemoryPool* _pool;
+};
+
+template <>
+struct Converter<JsonArray> : private VariantAttorney {
+  static void toJson(JsonVariantConst src, JsonVariant dst) {
+    variantCopyFrom(getData(dst), getData(src), getPool(dst));
+  }
+
+  static JsonArray fromJson(JsonVariant src) {
+    VariantData* data = getData(src);
+    MemoryPool* pool = getPool(src);
+    return JsonArray(pool, data != 0 ? data->asArray() : 0);
+  }
+
+  static InvalidConversion<JsonVariantConst, JsonArray> fromJson(
+      JsonVariantConst);
+
+  static bool checkJson(JsonVariantConst) {
+    return false;
+  }
+
+  static bool checkJson(JsonVariant src) {
+    VariantData* data = getData(src);
+    return data && data->isArray();
+  }
+};
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Array/JsonArrayConst.hpp

@@ -0,0 +1,134 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Array/JsonArrayIterator.hpp>
+#include <ArduinoJson/Variant/VariantAttorney.hpp>
+#include <ArduinoJson/Variant/VariantData.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+class JsonObject;
+
+// A read-only reference to an array in a JsonDocument
+// https://arduinojson.org/v6/api/jsonarrayconst/
+class JsonArrayConst : public VariantOperators<JsonArrayConst> {
+  friend class JsonArray;
+  friend class VariantAttorney;
+
+ public:
+  typedef JsonArrayConstIterator iterator;
+
+  // Returns an iterator to the first element of the array.
+  // https://arduinojson.org/v6/api/jsonarrayconst/begin/
+  FORCE_INLINE iterator begin() const {
+    if (!_data)
+      return iterator();
+    return iterator(_data->head());
+  }
+
+  // Returns an iterator to the element following the last element of the array.
+  // https://arduinojson.org/v6/api/jsonarrayconst/end/
+  FORCE_INLINE iterator end() const {
+    return iterator();
+  }
+
+  // Creates an unbound reference.
+  FORCE_INLINE JsonArrayConst() : _data(0) {}
+
+  // INTERNAL USE ONLY
+  FORCE_INLINE JsonArrayConst(const CollectionData* data) : _data(data) {}
+
+  // Compares the content of two arrays.
+  // Returns true if the two arrays are equal.
+  FORCE_INLINE bool operator==(JsonArrayConst rhs) const {
+    if (_data == rhs._data)
+      return true;
+    if (!_data || !rhs._data)
+      return false;
+
+    iterator it1 = begin();
+    iterator it2 = rhs.begin();
+
+    for (;;) {
+      bool end1 = it1 == end();
+      bool end2 = it2 == rhs.end();
+      if (end1 && end2)
+        return true;
+      if (end1 || end2)
+        return false;
+      if (*it1 != *it2)
+        return false;
+      ++it1;
+      ++it2;
+    }
+  }
+
+  // Returns the element at the specified index.
+  // https://arduinojson.org/v6/api/jsonarrayconst/subscript/
+  FORCE_INLINE JsonVariantConst operator[](size_t index) const {
+    return JsonVariantConst(_data ? _data->getElement(index) : 0);
+  }
+
+  operator JsonVariantConst() const {
+    return JsonVariantConst(collectionToVariant(_data));
+  }
+
+  // Returns true if the reference is unbound.
+  // https://arduinojson.org/v6/api/jsonarrayconst/isnull/
+  FORCE_INLINE bool isNull() const {
+    return _data == 0;
+  }
+
+  // Returns true if the reference is bound.
+  // https://arduinojson.org/v6/api/jsonarrayconst/isnull/
+  FORCE_INLINE operator bool() const {
+    return _data != 0;
+  }
+
+  // Returns the number of bytes occupied by the array.
+  // https://arduinojson.org/v6/api/jsonarrayconst/memoryusage/
+  FORCE_INLINE size_t memoryUsage() const {
+    return _data ? _data->memoryUsage() : 0;
+  }
+
+  // Returns the depth (nesting level) of the array.
+  // https://arduinojson.org/v6/api/jsonarrayconst/nesting/
+  FORCE_INLINE size_t nesting() const {
+    return variantNesting(collectionToVariant(_data));
+  }
+
+  // Returns the number of elements in the array.
+  // https://arduinojson.org/v6/api/jsonarrayconst/size/
+  FORCE_INLINE size_t size() const {
+    return _data ? _data->size() : 0;
+  }
+
+ private:
+  const VariantData* getData() const {
+    return collectionToVariant(_data);
+  }
+
+  const CollectionData* _data;
+};
+
+template <>
+struct Converter<JsonArrayConst> : private VariantAttorney {
+  static void toJson(JsonVariantConst src, JsonVariant dst) {
+    variantCopyFrom(getData(dst), getData(src), getPool(dst));
+  }
+
+  static JsonArrayConst fromJson(JsonVariantConst src) {
+    const VariantData* data = getData(src);
+    return data ? data->asArray() : 0;
+  }
+
+  static bool checkJson(JsonVariantConst src) {
+    const VariantData* data = getData(src);
+    return data && data->isArray();
+  }
+};
+
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Array/JsonArrayImpl.hpp

@@ -0,0 +1,32 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Array/JsonArray.hpp>
+#include <ArduinoJson/Object/JsonObject.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+inline JsonObject JsonArray::createNestedObject() const {
+  return add().to<JsonObject>();
+}
+
+template <typename TDerived>
+inline JsonArray VariantRefBase<TDerived>::createNestedArray() const {
+  return add().template to<JsonArray>();
+}
+
+template <typename TDerived>
+inline JsonObject VariantRefBase<TDerived>::createNestedObject() const {
+  return add().template to<JsonObject>();
+}
+
+template <typename TDerived>
+inline ElementProxy<TDerived> VariantRefBase<TDerived>::operator[](
+    size_t index) const {
+  return ElementProxy<TDerived>(derived(), index);
+}
+
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Array/JsonArrayIterator.hpp

@@ -0,0 +1,117 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Variant/JsonVariant.hpp>
+#include <ArduinoJson/Variant/SlotFunctions.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+class VariantPtr {
+ public:
+  VariantPtr(MemoryPool* pool, VariantData* data) : _variant(pool, data) {}
+
+  JsonVariant* operator->() {
+    return &_variant;
+  }
+
+  JsonVariant& operator*() {
+    return _variant;
+  }
+
+ private:
+  JsonVariant _variant;
+};
+
+class JsonArrayIterator {
+  friend class JsonArray;
+
+ public:
+  JsonArrayIterator() : _slot(0) {}
+  explicit JsonArrayIterator(MemoryPool* pool, VariantSlot* slot)
+      : _pool(pool), _slot(slot) {}
+
+  JsonVariant operator*() const {
+    return JsonVariant(_pool, _slot->data());
+  }
+  VariantPtr operator->() {
+    return VariantPtr(_pool, _slot->data());
+  }
+
+  bool operator==(const JsonArrayIterator& other) const {
+    return _slot == other._slot;
+  }
+
+  bool operator!=(const JsonArrayIterator& other) const {
+    return _slot != other._slot;
+  }
+
+  JsonArrayIterator& operator++() {
+    _slot = _slot->next();
+    return *this;
+  }
+
+  JsonArrayIterator& operator+=(size_t distance) {
+    _slot = _slot->next(distance);
+    return *this;
+  }
+
+ private:
+  MemoryPool* _pool;
+  VariantSlot* _slot;
+};
+
+class VariantConstPtr {
+ public:
+  VariantConstPtr(const VariantData* data) : _variant(data) {}
+
+  JsonVariantConst* operator->() {
+    return &_variant;
+  }
+
+  JsonVariantConst& operator*() {
+    return _variant;
+  }
+
+ private:
+  JsonVariantConst _variant;
+};
+
+class JsonArrayConstIterator {
+  friend class JsonArray;
+
+ public:
+  JsonArrayConstIterator() : _slot(0) {}
+  explicit JsonArrayConstIterator(const VariantSlot* slot) : _slot(slot) {}
+
+  JsonVariantConst operator*() const {
+    return JsonVariantConst(_slot->data());
+  }
+  VariantConstPtr operator->() {
+    return VariantConstPtr(_slot->data());
+  }
+
+  bool operator==(const JsonArrayConstIterator& other) const {
+    return _slot == other._slot;
+  }
+
+  bool operator!=(const JsonArrayConstIterator& other) const {
+    return _slot != other._slot;
+  }
+
+  JsonArrayConstIterator& operator++() {
+    _slot = _slot->next();
+    return *this;
+  }
+
+  JsonArrayConstIterator& operator+=(size_t distance) {
+    _slot = _slot->next(distance);
+    return *this;
+  }
+
+ private:
+  const VariantSlot* _slot;
+};
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Array/Utilities.hpp

@@ -0,0 +1,113 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Array/JsonArray.hpp>
+#include <ArduinoJson/Document/JsonDocument.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+// Copies a value to a JsonVariant.
+// This is a degenerated form of copyArray() to stop the recursion.
+template <typename T>
+inline typename enable_if<!is_array<T>::value, bool>::type copyArray(
+    const T& src, JsonVariant dst) {
+  return dst.set(src);
+}
+
+// Copies values from an array to a JsonArray or a JsonVariant.
+// https://arduinojson.org/v6/api/misc/copyarray/
+template <typename T, size_t N, typename TDestination>
+inline typename enable_if<!is_base_of<JsonDocument, TDestination>::value,
+                          bool>::type
+copyArray(T (&src)[N], const TDestination& dst) {
+  return copyArray(src, N, dst);
+}
+
+// Copies values from an array to a JsonArray or a JsonVariant.
+// https://arduinojson.org/v6/api/misc/copyarray/
+template <typename T, typename TDestination>
+inline typename enable_if<!is_base_of<JsonDocument, TDestination>::value,
+                          bool>::type
+copyArray(const T* src, size_t len, const TDestination& dst) {
+  bool ok = true;
+  for (size_t i = 0; i < len; i++) {
+    ok &= copyArray(src[i], dst.add());
+  }
+  return ok;
+}
+
+// Copies a string to a JsonVariant.
+// This is a degenerated form of copyArray() to handle strings.
+template <typename TDestination>
+inline bool copyArray(const char* src, size_t, const TDestination& dst) {
+  return dst.set(src);
+}
+
+// Copies values from an array to a JsonDocument.
+// https://arduinojson.org/v6/api/misc/copyarray/
+template <typename T>
+inline bool copyArray(const T& src, JsonDocument& dst) {
+  return copyArray(src, dst.to<JsonArray>());
+}
+
+// Copies an array to a JsonDocument.
+// https://arduinojson.org/v6/api/misc/copyarray/
+template <typename T>
+inline bool copyArray(const T* src, size_t len, JsonDocument& dst) {
+  return copyArray(src, len, dst.to<JsonArray>());
+}
+
+// Copies a value from a JsonVariant.
+// This is a degenerated form of copyArray() to stop the recursion.
+template <typename T>
+inline typename enable_if<!is_array<T>::value, size_t>::type copyArray(
+    JsonVariantConst src, T& dst) {
+  dst = src.as<T>();
+  return 1;
+}
+
+// Copies values from a JsonArray or JsonVariant to an array.
+// https://arduinojson.org/v6/api/misc/copyarray/
+template <typename T, size_t N>
+inline size_t copyArray(JsonArrayConst src, T (&dst)[N]) {
+  return copyArray(src, dst, N);
+}
+
+// Copies values from a JsonArray or JsonVariant to an array.
+// https://arduinojson.org/v6/api/misc/copyarray/
+template <typename T>
+inline size_t copyArray(JsonArrayConst src, T* dst, size_t len) {
+  size_t i = 0;
+  for (JsonArrayConst::iterator it = src.begin(); it != src.end() && i < len;
+       ++it)
+    copyArray(*it, dst[i++]);
+  return i;
+}
+
+// Copies a string from a JsonVariant.
+// This is a degenerated form of copyArray() to handle strings.
+template <size_t N>
+inline size_t copyArray(JsonVariantConst src, char (&dst)[N]) {
+  JsonString s = src;
+  size_t len = N - 1;
+  if (len > s.size())
+    len = s.size();
+  memcpy(dst, s.c_str(), len);
+  dst[len] = 0;
+  return 1;
+}
+
+// Copies values from a JsonDocument to an array.
+// https://arduinojson.org/v6/api/misc/copyarray/
+template <typename TSource, typename T>
+inline typename enable_if<is_array<T>::value &&
+                              is_base_of<JsonDocument, TSource>::value,
+                          size_t>::type
+copyArray(const TSource& src, T& dst) {
+  return copyArray(src.template as<JsonArrayConst>(), dst);
+}
+
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Collection/CollectionData.hpp

@@ -0,0 +1,94 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+#include <ArduinoJson/Polyfills/assert.hpp>
+
+#include <stddef.h>  // size_t
+
+namespace ARDUINOJSON_NAMESPACE {
+
+class MemoryPool;
+class VariantData;
+class VariantSlot;
+
+class CollectionData {
+  VariantSlot* _head;
+  VariantSlot* _tail;
+
+ public:
+  // Must be a POD!
+  // - no constructor
+  // - no destructor
+  // - no virtual
+  // - no inheritance
+
+  // Array only
+
+  VariantData* addElement(MemoryPool* pool);
+
+  VariantData* getElement(size_t index) const;
+
+  VariantData* getOrAddElement(size_t index, MemoryPool* pool);
+
+  void removeElement(size_t index);
+
+  // Object only
+
+  template <typename TAdaptedString>
+  VariantData* addMember(TAdaptedString key, MemoryPool* pool);
+
+  template <typename TAdaptedString>
+  VariantData* getMember(TAdaptedString key) const;
+
+  template <typename TAdaptedString>
+  VariantData* getOrAddMember(TAdaptedString key, MemoryPool* pool);
+
+  template <typename TAdaptedString>
+  void removeMember(TAdaptedString key) {
+    removeSlot(getSlot(key));
+  }
+
+  template <typename TAdaptedString>
+  bool containsKey(const TAdaptedString& key) const;
+
+  // Generic
+
+  void clear();
+  size_t memoryUsage() const;
+  size_t size() const;
+
+  VariantSlot* addSlot(MemoryPool*);
+  void removeSlot(VariantSlot* slot);
+
+  bool copyFrom(const CollectionData& src, MemoryPool* pool);
+
+  VariantSlot* head() const {
+    return _head;
+  }
+
+  void movePointers(ptrdiff_t stringDistance, ptrdiff_t variantDistance);
+
+ private:
+  VariantSlot* getSlot(size_t index) const;
+
+  template <typename TAdaptedString>
+  VariantSlot* getSlot(TAdaptedString key) const;
+
+  VariantSlot* getPreviousSlot(VariantSlot*) const;
+};
+
+inline const VariantData* collectionToVariant(
+    const CollectionData* collection) {
+  const void* data = collection;  // prevent warning cast-align
+  return reinterpret_cast<const VariantData*>(data);
+}
+
+inline VariantData* collectionToVariant(CollectionData* collection) {
+  void* data = collection;  // prevent warning cast-align
+  return reinterpret_cast<VariantData*>(data);
+}
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Collection/CollectionImpl.hpp

@@ -0,0 +1,197 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Collection/CollectionData.hpp>
+#include <ArduinoJson/Strings/StoragePolicy.hpp>
+#include <ArduinoJson/Strings/StringAdapters.hpp>
+#include <ArduinoJson/Variant/VariantData.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+inline VariantSlot* CollectionData::addSlot(MemoryPool* pool) {
+  VariantSlot* slot = pool->allocVariant();
+  if (!slot)
+    return 0;
+
+  if (_tail) {
+    ARDUINOJSON_ASSERT(pool->owns(_tail));  // Can't alter a linked array/object
+    _tail->setNextNotNull(slot);
+    _tail = slot;
+  } else {
+    _head = slot;
+    _tail = slot;
+  }
+
+  slot->clear();
+  return slot;
+}
+
+inline VariantData* CollectionData::addElement(MemoryPool* pool) {
+  return slotData(addSlot(pool));
+}
+
+template <typename TAdaptedString>
+inline VariantData* CollectionData::addMember(TAdaptedString key,
+                                              MemoryPool* pool) {
+  VariantSlot* slot = addSlot(pool);
+  if (!slotSetKey(slot, key, pool)) {
+    removeSlot(slot);
+    return 0;
+  }
+  return slot->data();
+}
+
+inline void CollectionData::clear() {
+  _head = 0;
+  _tail = 0;
+}
+
+template <typename TAdaptedString>
+inline bool CollectionData::containsKey(const TAdaptedString& key) const {
+  return getSlot(key) != 0;
+}
+
+inline bool CollectionData::copyFrom(const CollectionData& src,
+                                     MemoryPool* pool) {
+  clear();
+  for (VariantSlot* s = src._head; s; s = s->next()) {
+    VariantData* var;
+    if (s->key() != 0) {
+      JsonString key(s->key(),
+                     s->ownsKey() ? JsonString::Copied : JsonString::Linked);
+      var = addMember(adaptString(key), pool);
+    } else {
+      var = addElement(pool);
+    }
+    if (!var)
+      return false;
+    if (!var->copyFrom(*s->data(), pool))
+      return false;
+  }
+  return true;
+}
+
+template <typename TAdaptedString>
+inline VariantSlot* CollectionData::getSlot(TAdaptedString key) const {
+  if (key.isNull())
+    return 0;
+  VariantSlot* slot = _head;
+  while (slot) {
+    if (stringEquals(key, adaptString(slot->key())))
+      break;
+    slot = slot->next();
+  }
+  return slot;
+}
+
+inline VariantSlot* CollectionData::getSlot(size_t index) const {
+  if (!_head)
+    return 0;
+  return _head->next(index);
+}
+
+inline VariantSlot* CollectionData::getPreviousSlot(VariantSlot* target) const {
+  VariantSlot* current = _head;
+  while (current) {
+    VariantSlot* next = current->next();
+    if (next == target)
+      return current;
+    current = next;
+  }
+  return 0;
+}
+
+template <typename TAdaptedString>
+inline VariantData* CollectionData::getMember(TAdaptedString key) const {
+  VariantSlot* slot = getSlot(key);
+  return slot ? slot->data() : 0;
+}
+
+template <typename TAdaptedString>
+inline VariantData* CollectionData::getOrAddMember(TAdaptedString key,
+                                                   MemoryPool* pool) {
+  // ignore null key
+  if (key.isNull())
+    return 0;
+
+  // search a matching key
+  VariantSlot* slot = getSlot(key);
+  if (slot)
+    return slot->data();
+
+  return addMember(key, pool);
+}
+
+inline VariantData* CollectionData::getElement(size_t index) const {
+  VariantSlot* slot = getSlot(index);
+  return slot ? slot->data() : 0;
+}
+
+inline VariantData* CollectionData::getOrAddElement(size_t index,
+                                                    MemoryPool* pool) {
+  VariantSlot* slot = _head;
+  while (slot && index > 0) {
+    slot = slot->next();
+    index--;
+  }
+  if (!slot)
+    index++;
+  while (index > 0) {
+    slot = addSlot(pool);
+    index--;
+  }
+  return slotData(slot);
+}
+
+inline void CollectionData::removeSlot(VariantSlot* slot) {
+  if (!slot)
+    return;
+  VariantSlot* prev = getPreviousSlot(slot);
+  VariantSlot* next = slot->next();
+  if (prev)
+    prev->setNext(next);
+  else
+    _head = next;
+  if (!next)
+    _tail = prev;
+}
+
+inline void CollectionData::removeElement(size_t index) {
+  removeSlot(getSlot(index));
+}
+
+inline size_t CollectionData::memoryUsage() const {
+  size_t total = 0;
+  for (VariantSlot* s = _head; s; s = s->next()) {
+    total += sizeof(VariantSlot) + s->data()->memoryUsage();
+    if (s->ownsKey())
+      total += strlen(s->key()) + 1;
+  }
+  return total;
+}
+
+inline size_t CollectionData::size() const {
+  return slotSize(_head);
+}
+
+template <typename T>
+inline void movePointer(T*& p, ptrdiff_t offset) {
+  if (!p)
+    return;
+  p = reinterpret_cast<T*>(
+      reinterpret_cast<void*>(reinterpret_cast<char*>(p) + offset));
+  ARDUINOJSON_ASSERT(isAligned(p));
+}
+
+inline void CollectionData::movePointers(ptrdiff_t stringDistance,
+                                         ptrdiff_t variantDistance) {
+  movePointer(_head, variantDistance);
+  movePointer(_tail, variantDistance);
+  for (VariantSlot* slot = _head; slot; slot = slot->next())
+    slot->movePointers(stringDistance, variantDistance);
+}
+
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Configuration.hpp

@@ -0,0 +1,236 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#if __cplusplus >= 201103L
+#  define ARDUINOJSON_HAS_LONG_LONG 1
+#  define ARDUINOJSON_HAS_RVALUE_REFERENCES 1
+#else
+#  define ARDUINOJSON_HAS_LONG_LONG 0
+#  define ARDUINOJSON_HAS_RVALUE_REFERENCES 0
+#endif
+
+#ifndef ARDUINOJSON_HAS_NULLPTR
+#  if __cplusplus >= 201103L
+#    define ARDUINOJSON_HAS_NULLPTR 1
+#  else
+#    define ARDUINOJSON_HAS_NULLPTR 0
+#  endif
+#endif
+
+#if defined(_MSC_VER) && !ARDUINOJSON_HAS_LONG_LONG
+#  define ARDUINOJSON_HAS_INT64 1
+#else
+#  define ARDUINOJSON_HAS_INT64 0
+#endif
+
+// Support std::istream and std::ostream
+#ifndef ARDUINOJSON_ENABLE_STD_STREAM
+#  ifdef __has_include
+#    if __has_include(<istream>) && \
+    __has_include(<ostream>) && \
+    !defined(min) && \
+    !defined(max)
+#      define ARDUINOJSON_ENABLE_STD_STREAM 1
+#    else
+#      define ARDUINOJSON_ENABLE_STD_STREAM 0
+#    endif
+#  else
+#    ifdef ARDUINO
+#      define ARDUINOJSON_ENABLE_STD_STREAM 0
+#    else
+#      define ARDUINOJSON_ENABLE_STD_STREAM 1
+#    endif
+#  endif
+#endif
+
+// Support std::string
+#ifndef ARDUINOJSON_ENABLE_STD_STRING
+#  ifdef __has_include
+#    if __has_include(<string>) && !defined(min) && !defined(max)
+#      define ARDUINOJSON_ENABLE_STD_STRING 1
+#    else
+#      define ARDUINOJSON_ENABLE_STD_STRING 0
+#    endif
+#  else
+#    ifdef ARDUINO
+#      define ARDUINOJSON_ENABLE_STD_STRING 0
+#    else
+#      define ARDUINOJSON_ENABLE_STD_STRING 1
+#    endif
+#  endif
+#endif
+
+// Support for std::string_view
+#ifndef ARDUINOJSON_ENABLE_STRING_VIEW
+#  ifdef __has_include
+#    if __has_include(<string_view>) && __cplusplus >= 201703L
+#      define ARDUINOJSON_ENABLE_STRING_VIEW 1
+#    else
+#      define ARDUINOJSON_ENABLE_STRING_VIEW 0
+#    endif
+#  else
+#    define ARDUINOJSON_ENABLE_STRING_VIEW 0
+#  endif
+#endif
+
+// Store floating-point values with float (0) or double (1)
+#ifndef ARDUINOJSON_USE_DOUBLE
+#  define ARDUINOJSON_USE_DOUBLE 1
+#endif
+
+// Store integral values with long (0) or long long (1)
+#ifndef ARDUINOJSON_USE_LONG_LONG
+#  if ARDUINOJSON_HAS_LONG_LONG && defined(__SIZEOF_POINTER__) && \
+          __SIZEOF_POINTER__ >= 4 ||                              \
+      defined(_MSC_VER)
+#    define ARDUINOJSON_USE_LONG_LONG 1
+#  endif
+#endif
+#ifndef ARDUINOJSON_USE_LONG_LONG
+#  define ARDUINOJSON_USE_LONG_LONG 0
+#endif
+
+// Limit nesting as the stack is likely to be small
+#ifndef ARDUINOJSON_DEFAULT_NESTING_LIMIT
+#  define ARDUINOJSON_DEFAULT_NESTING_LIMIT 10
+#endif
+
+// Number of bits to store the pointer to next node
+// (saves RAM but limits the number of values in a document)
+#ifndef ARDUINOJSON_SLOT_OFFSET_SIZE
+#  if defined(__SIZEOF_POINTER__) && __SIZEOF_POINTER__ <= 2
+// Address space == 16-bit => max 127 values
+#    define ARDUINOJSON_SLOT_OFFSET_SIZE 1
+#  elif defined(__SIZEOF_POINTER__) && __SIZEOF_POINTER__ >= 8 || \
+      defined(_WIN64) && _WIN64
+// Address space == 64-bit => max 2147483647 values
+#    define ARDUINOJSON_SLOT_OFFSET_SIZE 4
+#  else
+// Address space == 32-bit => max 32767 values
+#    define ARDUINOJSON_SLOT_OFFSET_SIZE 2
+#  endif
+#endif
+
+#ifdef ARDUINO
+
+// Enable support for Arduino's String class
+#  ifndef ARDUINOJSON_ENABLE_ARDUINO_STRING
+#    define ARDUINOJSON_ENABLE_ARDUINO_STRING 1
+#  endif
+
+// Enable support for Arduino's Stream class
+#  ifndef ARDUINOJSON_ENABLE_ARDUINO_STREAM
+#    define ARDUINOJSON_ENABLE_ARDUINO_STREAM 1
+#  endif
+
+// Enable support for Arduino's Print class
+#  ifndef ARDUINOJSON_ENABLE_ARDUINO_PRINT
+#    define ARDUINOJSON_ENABLE_ARDUINO_PRINT 1
+#  endif
+
+// Enable support for PROGMEM
+#  ifndef ARDUINOJSON_ENABLE_PROGMEM
+#    define ARDUINOJSON_ENABLE_PROGMEM 1
+#  endif
+
+#else  // ARDUINO
+
+// Disable support for Arduino's String class
+#  ifndef ARDUINOJSON_ENABLE_ARDUINO_STRING
+#    define ARDUINOJSON_ENABLE_ARDUINO_STRING 0
+#  endif
+
+// Disable support for Arduino's Stream class
+#  ifndef ARDUINOJSON_ENABLE_ARDUINO_STREAM
+#    define ARDUINOJSON_ENABLE_ARDUINO_STREAM 0
+#  endif
+
+// Disable support for Arduino's Print class
+#  ifndef ARDUINOJSON_ENABLE_ARDUINO_PRINT
+#    define ARDUINOJSON_ENABLE_ARDUINO_PRINT 0
+#  endif
+
+// Disable support for PROGMEM
+#  ifndef ARDUINOJSON_ENABLE_PROGMEM
+#    define ARDUINOJSON_ENABLE_PROGMEM 0
+#  endif
+
+#endif  // ARDUINO
+
+// Convert unicode escape sequence (\u0123) to UTF-8
+#ifndef ARDUINOJSON_DECODE_UNICODE
+#  define ARDUINOJSON_DECODE_UNICODE 1
+#endif
+
+// Ignore comments in input
+#ifndef ARDUINOJSON_ENABLE_COMMENTS
+#  define ARDUINOJSON_ENABLE_COMMENTS 0
+#endif
+
+// Support NaN in JSON
+#ifndef ARDUINOJSON_ENABLE_NAN
+#  define ARDUINOJSON_ENABLE_NAN 0
+#endif
+
+// Support Infinity in JSON
+#ifndef ARDUINOJSON_ENABLE_INFINITY
+#  define ARDUINOJSON_ENABLE_INFINITY 0
+#endif
+
+// Control the exponentiation threshold for big numbers
+// CAUTION: cannot be more that 1e9 !!!!
+#ifndef ARDUINOJSON_POSITIVE_EXPONENTIATION_THRESHOLD
+#  define ARDUINOJSON_POSITIVE_EXPONENTIATION_THRESHOLD 1e7
+#endif
+
+// Control the exponentiation threshold for small numbers
+#ifndef ARDUINOJSON_NEGATIVE_EXPONENTIATION_THRESHOLD
+#  define ARDUINOJSON_NEGATIVE_EXPONENTIATION_THRESHOLD 1e-5
+#endif
+
+#ifndef ARDUINOJSON_LITTLE_ENDIAN
+#  if defined(_MSC_VER) ||                           \
+      (defined(__BYTE_ORDER__) &&                    \
+       __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) || \
+      defined(__LITTLE_ENDIAN__) || defined(__i386) || defined(__x86_64)
+#    define ARDUINOJSON_LITTLE_ENDIAN 1
+#  else
+#    define ARDUINOJSON_LITTLE_ENDIAN 0
+#  endif
+#endif
+
+#ifndef ARDUINOJSON_ENABLE_ALIGNMENT
+#  if defined(__AVR)
+#    define ARDUINOJSON_ENABLE_ALIGNMENT 0
+#  else
+#    define ARDUINOJSON_ENABLE_ALIGNMENT 1
+#  endif
+#endif
+
+#ifndef ARDUINOJSON_TAB
+#  define ARDUINOJSON_TAB "  "
+#endif
+
+#ifndef ARDUINOJSON_ENABLE_STRING_DEDUPLICATION
+#  define ARDUINOJSON_ENABLE_STRING_DEDUPLICATION 1
+#endif
+
+#ifndef ARDUINOJSON_STRING_BUFFER_SIZE
+#  define ARDUINOJSON_STRING_BUFFER_SIZE 32
+#endif
+
+#ifndef ARDUINOJSON_DEBUG
+#  ifdef __PLATFORMIO_BUILD_DEBUG__
+#    define ARDUINOJSON_DEBUG 1
+#  else
+#    define ARDUINOJSON_DEBUG 0
+#  endif
+#endif
+
+#if ARDUINOJSON_HAS_NULLPTR && defined(nullptr)
+#  error nullptr is defined as a macro. Remove the faulty #define or #undef nullptr
+// See https://github.com/bblanchon/ArduinoJson/issues/1355
+#endif

lib/ArduinoJson/src/ArduinoJson/Deserialization/DeserializationError.hpp

@@ -0,0 +1,107 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Misc/SafeBoolIdiom.hpp>
+#include <ArduinoJson/Namespace.hpp>
+#include <ArduinoJson/Polyfills/pgmspace_generic.hpp>
+#include <ArduinoJson/Polyfills/preprocessor.hpp>
+
+#if ARDUINOJSON_ENABLE_STD_STREAM
+#  include <ostream>
+#endif
+
+namespace ARDUINOJSON_NAMESPACE {
+
+class DeserializationError : public SafeBoolIdom<DeserializationError> {
+ public:
+  enum Code {
+    Ok,
+    EmptyInput,
+    IncompleteInput,
+    InvalidInput,
+    NoMemory,
+    TooDeep
+  };
+
+  DeserializationError() {}
+  DeserializationError(Code c) : _code(c) {}
+
+  // Compare with DeserializationError
+  friend bool operator==(const DeserializationError& lhs,
+                         const DeserializationError& rhs) {
+    return lhs._code == rhs._code;
+  }
+  friend bool operator!=(const DeserializationError& lhs,
+                         const DeserializationError& rhs) {
+    return lhs._code != rhs._code;
+  }
+
+  // Compare with Code
+  friend bool operator==(const DeserializationError& lhs, Code rhs) {
+    return lhs._code == rhs;
+  }
+  friend bool operator==(Code lhs, const DeserializationError& rhs) {
+    return lhs == rhs._code;
+  }
+  friend bool operator!=(const DeserializationError& lhs, Code rhs) {
+    return lhs._code != rhs;
+  }
+  friend bool operator!=(Code lhs, const DeserializationError& rhs) {
+    return lhs != rhs._code;
+  }
+
+  // Behaves like a bool
+  operator bool_type() const {
+    return _code != Ok ? safe_true() : safe_false();
+  }
+
+  // Returns internal enum, useful for switch statement
+  Code code() const {
+    return _code;
+  }
+
+  const char* c_str() const {
+    static const char* messages[] = {
+        "Ok",           "EmptyInput", "IncompleteInput",
+        "InvalidInput", "NoMemory",   "TooDeep"};
+    ARDUINOJSON_ASSERT(static_cast<size_t>(_code) <
+                       sizeof(messages) / sizeof(messages[0]));
+    return messages[_code];
+  }
+
+#if ARDUINOJSON_ENABLE_PROGMEM
+  const __FlashStringHelper* f_str() const {
+    ARDUINOJSON_DEFINE_PROGMEM_ARRAY(char, s0, "Ok");
+    ARDUINOJSON_DEFINE_PROGMEM_ARRAY(char, s1, "EmptyInput");
+    ARDUINOJSON_DEFINE_PROGMEM_ARRAY(char, s2, "IncompleteInput");
+    ARDUINOJSON_DEFINE_PROGMEM_ARRAY(char, s3, "InvalidInput");
+    ARDUINOJSON_DEFINE_PROGMEM_ARRAY(char, s4, "NoMemory");
+    ARDUINOJSON_DEFINE_PROGMEM_ARRAY(char, s5, "TooDeep");
+    ARDUINOJSON_DEFINE_PROGMEM_ARRAY(
+        const char*, messages, ARDUINOJSON_EXPAND6({s0, s1, s2, s3, s4, s5}));
+    return reinterpret_cast<const __FlashStringHelper*>(
+        pgm_read(messages + _code));
+  }
+#endif
+
+ private:
+  Code _code;
+};
+
+#if ARDUINOJSON_ENABLE_STD_STREAM
+inline std::ostream& operator<<(std::ostream& s,
+                                const DeserializationError& e) {
+  s << e.c_str();
+  return s;
+}
+
+inline std::ostream& operator<<(std::ostream& s, DeserializationError::Code c) {
+  s << DeserializationError(c).c_str();
+  return s;
+}
+#endif
+
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Deserialization/Filter.hpp

@@ -0,0 +1,66 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+class Filter {
+ public:
+  explicit Filter(JsonVariantConst v) : _variant(v) {}
+
+  bool allow() const {
+    return _variant;
+  }
+
+  bool allowArray() const {
+    return _variant == true || _variant.is<JsonArrayConst>();
+  }
+
+  bool allowObject() const {
+    return _variant == true || _variant.is<JsonObjectConst>();
+  }
+
+  bool allowValue() const {
+    return _variant == true;
+  }
+
+  template <typename TKey>
+  Filter operator[](const TKey& key) const {
+    if (_variant == true)  // "true" means "allow recursively"
+      return *this;
+    JsonVariantConst member = _variant[key];
+    return Filter(member.isNull() ? _variant["*"] : member);
+  }
+
+ private:
+  JsonVariantConst _variant;
+};
+
+struct AllowAllFilter {
+  bool allow() const {
+    return true;
+  }
+
+  bool allowArray() const {
+    return true;
+  }
+
+  bool allowObject() const {
+    return true;
+  }
+
+  bool allowValue() const {
+    return true;
+  }
+
+  template <typename TKey>
+  AllowAllFilter operator[](const TKey&) const {
+    return AllowAllFilter();
+  }
+};
+
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Deserialization/NestingLimit.hpp

@@ -0,0 +1,29 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+#include <ArduinoJson/Polyfills/assert.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+class NestingLimit {
+ public:
+  NestingLimit() : _value(ARDUINOJSON_DEFAULT_NESTING_LIMIT) {}
+  explicit NestingLimit(uint8_t n) : _value(n) {}
+
+  NestingLimit decrement() const {
+    ARDUINOJSON_ASSERT(_value > 0);
+    return NestingLimit(static_cast<uint8_t>(_value - 1));
+  }
+
+  bool reached() const {
+    return _value == 0;
+  }
+
+ private:
+  uint8_t _value;
+};
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Deserialization/Reader.hpp

@@ -0,0 +1,56 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+#include <stdlib.h>  // for size_t
+
+namespace ARDUINOJSON_NAMESPACE {
+
+// The default reader is a simple wrapper for Readers that are not copiable
+template <typename TSource, typename Enable = void>
+struct Reader {
+ public:
+  Reader(TSource& source) : _source(&source) {}
+
+  int read() {
+    return _source->read();  // Error here? You passed an unsupported input type
+  }
+
+  size_t readBytes(char* buffer, size_t length) {
+    return _source->readBytes(buffer, length);
+  }
+
+ private:
+  TSource* _source;
+};
+
+template <typename TSource, typename Enable = void>
+struct BoundedReader {
+  // no default implementation because we need to pass the size to the
+  // constructor
+};
+}  // namespace ARDUINOJSON_NAMESPACE
+
+#include <ArduinoJson/Deserialization/Readers/IteratorReader.hpp>
+#include <ArduinoJson/Deserialization/Readers/RamReader.hpp>
+#include <ArduinoJson/Deserialization/Readers/VariantReader.hpp>
+
+#if ARDUINOJSON_ENABLE_ARDUINO_STREAM
+#  include <ArduinoJson/Deserialization/Readers/ArduinoStreamReader.hpp>
+#endif
+
+#if ARDUINOJSON_ENABLE_ARDUINO_STRING
+#  include <ArduinoJson/Deserialization/Readers/ArduinoStringReader.hpp>
+#endif
+
+#if ARDUINOJSON_ENABLE_PROGMEM
+#  include <ArduinoJson/Deserialization/Readers/FlashReader.hpp>
+#endif
+
+#if ARDUINOJSON_ENABLE_STD_STREAM
+#  include <ArduinoJson/Deserialization/Readers/StdStreamReader.hpp>
+#endif

lib/ArduinoJson/src/ArduinoJson/Deserialization/Readers/ArduinoStreamReader.hpp

@@ -0,0 +1,31 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <Arduino.h>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+template <typename TSource>
+struct Reader<TSource,
+              typename enable_if<is_base_of<Stream, TSource>::value>::type> {
+ public:
+  explicit Reader(Stream& stream) : _stream(&stream) {}
+
+  int read() {
+    // don't use _stream.read() as it ignores the timeout
+    char c;
+    return _stream->readBytes(&c, 1) ? static_cast<unsigned char>(c) : -1;
+  }
+
+  size_t readBytes(char* buffer, size_t length) {
+    return _stream->readBytes(buffer, length);
+  }
+
+ private:
+  Stream* _stream;
+};
+
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Deserialization/Readers/ArduinoStringReader.hpp

@@ -0,0 +1,19 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <Arduino.h>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+template <typename TSource>
+struct Reader<TSource,
+              typename enable_if<is_base_of< ::String, TSource>::value>::type>
+    : BoundedReader<const char*> {
+  explicit Reader(const ::String& s)
+      : BoundedReader<const char*>(s.c_str(), s.length()) {}
+};
+
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Deserialization/Readers/FlashReader.hpp

@@ -0,0 +1,55 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <Arduino.h>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+template <>
+struct Reader<const __FlashStringHelper*, void> {
+  const char* _ptr;
+
+ public:
+  explicit Reader(const __FlashStringHelper* ptr)
+      : _ptr(reinterpret_cast<const char*>(ptr)) {}
+
+  int read() {
+    return pgm_read_byte(_ptr++);
+  }
+
+  size_t readBytes(char* buffer, size_t length) {
+    memcpy_P(buffer, _ptr, length);
+    _ptr += length;
+    return length;
+  }
+};
+
+template <>
+struct BoundedReader<const __FlashStringHelper*, void> {
+  const char* _ptr;
+  const char* _end;
+
+ public:
+  explicit BoundedReader(const __FlashStringHelper* ptr, size_t size)
+      : _ptr(reinterpret_cast<const char*>(ptr)), _end(_ptr + size) {}
+
+  int read() {
+    if (_ptr < _end)
+      return pgm_read_byte(_ptr++);
+    else
+      return -1;
+  }
+
+  size_t readBytes(char* buffer, size_t length) {
+    size_t available = static_cast<size_t>(_end - _ptr);
+    if (available < length)
+      length = available;
+    memcpy_P(buffer, _ptr, length);
+    _ptr += length;
+    return length;
+  }
+};
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Deserialization/Readers/IteratorReader.hpp

@@ -0,0 +1,44 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+namespace ARDUINOJSON_NAMESPACE {
+
+template <typename TIterator>
+class IteratorReader {
+  TIterator _ptr, _end;
+
+ public:
+  explicit IteratorReader(TIterator begin, TIterator end)
+      : _ptr(begin), _end(end) {}
+
+  int read() {
+    if (_ptr < _end)
+      return static_cast<unsigned char>(*_ptr++);
+    else
+      return -1;
+  }
+
+  size_t readBytes(char* buffer, size_t length) {
+    size_t i = 0;
+    while (i < length && _ptr < _end)
+      buffer[i++] = *_ptr++;
+    return i;
+  }
+};
+
+template <typename T>
+struct void_ {
+  typedef void type;
+};
+
+template <typename TSource>
+struct Reader<TSource, typename void_<typename TSource::const_iterator>::type>
+    : IteratorReader<typename TSource::const_iterator> {
+  explicit Reader(const TSource& source)
+      : IteratorReader<typename TSource::const_iterator>(source.begin(),
+                                                         source.end()) {}
+};
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Deserialization/Readers/RamReader.hpp

@@ -0,0 +1,51 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Polyfills/type_traits.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+template <typename T>
+struct IsCharOrVoid {
+  static const bool value =
+      is_same<T, void>::value || is_same<T, char>::value ||
+      is_same<T, unsigned char>::value || is_same<T, signed char>::value;
+};
+
+template <typename T>
+struct IsCharOrVoid<const T> : IsCharOrVoid<T> {};
+
+template <typename TSource>
+struct Reader<TSource*,
+              typename enable_if<IsCharOrVoid<TSource>::value>::type> {
+  const char* _ptr;
+
+ public:
+  explicit Reader(const void* ptr)
+      : _ptr(ptr ? reinterpret_cast<const char*>(ptr) : "") {}
+
+  int read() {
+    return static_cast<unsigned char>(*_ptr++);
+  }
+
+  size_t readBytes(char* buffer, size_t length) {
+    for (size_t i = 0; i < length; i++)
+      buffer[i] = *_ptr++;
+    return length;
+  }
+};
+
+template <typename TSource>
+struct BoundedReader<TSource*,
+                     typename enable_if<IsCharOrVoid<TSource>::value>::type>
+    : public IteratorReader<const char*> {
+ public:
+  explicit BoundedReader(const void* ptr, size_t len)
+      : IteratorReader<const char*>(reinterpret_cast<const char*>(ptr),
+                                    reinterpret_cast<const char*>(ptr) + len) {}
+};
+
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Deserialization/Readers/StdStreamReader.hpp

@@ -0,0 +1,29 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <istream>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+template <typename TSource>
+struct Reader<TSource, typename enable_if<
+                           is_base_of<std::istream, TSource>::value>::type> {
+ public:
+  explicit Reader(std::istream& stream) : _stream(&stream) {}
+
+  int read() {
+    return _stream->get();
+  }
+
+  size_t readBytes(char* buffer, size_t length) {
+    _stream->read(buffer, static_cast<std::streamsize>(length));
+    return static_cast<size_t>(_stream->gcount());
+  }
+
+ private:
+  std::istream* _stream;
+};
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Deserialization/Readers/VariantReader.hpp

@@ -0,0 +1,19 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Object/MemberProxy.hpp>
+#include <ArduinoJson/Variant/JsonVariantConst.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+template <typename TVariant>
+struct Reader<TVariant, typename enable_if<IsVariant<TVariant>::value>::type>
+    : Reader<char*, void> {
+  explicit Reader(const TVariant& x)
+      : Reader<char*, void>(x.template as<const char*>()) {}
+};
+
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Deserialization/deserialize.hpp

@@ -0,0 +1,75 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Deserialization/DeserializationError.hpp>
+#include <ArduinoJson/Deserialization/Filter.hpp>
+#include <ArduinoJson/Deserialization/NestingLimit.hpp>
+#include <ArduinoJson/Deserialization/Reader.hpp>
+#include <ArduinoJson/StringStorage/StringStorage.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+template <template <typename, typename> class TDeserializer, typename TReader,
+          typename TWriter>
+TDeserializer<TReader, TWriter> makeDeserializer(MemoryPool* pool,
+                                                 TReader reader,
+                                                 TWriter writer) {
+  ARDUINOJSON_ASSERT(pool != 0);
+  return TDeserializer<TReader, TWriter>(pool, reader, writer);
+}
+
+// deserialize(JsonDocument&, const std::string&, NestingLimit, Filter);
+// deserialize(JsonDocument&, const String&, NestingLimit, Filter);
+// deserialize(JsonDocument&, char*, NestingLimit, Filter);
+// deserialize(JsonDocument&, const char*, NestingLimit, Filter);
+// deserialize(JsonDocument&, const __FlashStringHelper*, NestingLimit, Filter);
+template <template <typename, typename> class TDeserializer, typename TString,
+          typename TFilter>
+typename enable_if<!is_array<TString>::value, DeserializationError>::type
+deserialize(JsonDocument& doc, const TString& input, NestingLimit nestingLimit,
+            TFilter filter) {
+  Reader<TString> reader(input);
+  VariantData* data = VariantAttorney::getData(doc);
+  MemoryPool* pool = VariantAttorney::getPool(doc);
+  doc.clear();
+  return makeDeserializer<TDeserializer>(pool, reader,
+                                         makeStringStorage(input, pool))
+      .parse(*data, filter, nestingLimit);
+}
+//
+// deserialize(JsonDocument&, char*, size_t, NestingLimit, Filter);
+// deserialize(JsonDocument&, const char*, size_t, NestingLimit, Filter);
+// deserialize(JsonDocument&, const __FlashStringHelper*, size_t, NL, Filter);
+template <template <typename, typename> class TDeserializer, typename TChar,
+          typename TFilter>
+DeserializationError deserialize(JsonDocument& doc, TChar* input,
+                                 size_t inputSize, NestingLimit nestingLimit,
+                                 TFilter filter) {
+  BoundedReader<TChar*> reader(input, inputSize);
+  VariantData* data = VariantAttorney::getData(doc);
+  MemoryPool* pool = VariantAttorney::getPool(doc);
+  doc.clear();
+  return makeDeserializer<TDeserializer>(pool, reader,
+                                         makeStringStorage(input, pool))
+      .parse(*data, filter, nestingLimit);
+}
+//
+// deserialize(JsonDocument&, std::istream&, NestingLimit, Filter);
+// deserialize(JsonDocument&, Stream&, NestingLimit, Filter);
+template <template <typename, typename> class TDeserializer, typename TStream,
+          typename TFilter>
+DeserializationError deserialize(JsonDocument& doc, TStream& input,
+                                 NestingLimit nestingLimit, TFilter filter) {
+  Reader<TStream> reader(input);
+  VariantData* data = VariantAttorney::getData(doc);
+  MemoryPool* pool = VariantAttorney::getPool(doc);
+  doc.clear();
+  return makeDeserializer<TDeserializer>(pool, reader,
+                                         makeStringStorage(input, pool))
+      .parse(*data, filter, nestingLimit);
+}
+
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Document/BasicJsonDocument.hpp

@@ -0,0 +1,172 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Document/JsonDocument.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+// Helper to implement the "base-from-member" idiom
+// (we need to store the allocator before constructing JsonDocument)
+template <typename TAllocator>
+class AllocatorOwner {
+ public:
+  AllocatorOwner() {}
+  AllocatorOwner(TAllocator a) : _allocator(a) {}
+
+  void* allocate(size_t size) {
+    return _allocator.allocate(size);
+  }
+
+  void deallocate(void* ptr) {
+    if (ptr)
+      _allocator.deallocate(ptr);
+  }
+
+  void* reallocate(void* ptr, size_t new_size) {
+    return _allocator.reallocate(ptr, new_size);
+  }
+
+  TAllocator& allocator() {
+    return _allocator;
+  }
+
+ private:
+  TAllocator _allocator;
+};
+
+// A JsonDocument that uses the provided allocator to allocate its memory pool.
+// https://arduinojson.org/v6/api/basicjsondocument/
+template <typename TAllocator>
+class BasicJsonDocument : AllocatorOwner<TAllocator>, public JsonDocument {
+ public:
+  explicit BasicJsonDocument(size_t capa, TAllocator alloc = TAllocator())
+      : AllocatorOwner<TAllocator>(alloc), JsonDocument(allocPool(capa)) {}
+
+  // Copy-constructor
+  BasicJsonDocument(const BasicJsonDocument& src)
+      : AllocatorOwner<TAllocator>(src), JsonDocument() {
+    copyAssignFrom(src);
+  }
+
+  // Move-constructor
+#if ARDUINOJSON_HAS_RVALUE_REFERENCES
+  BasicJsonDocument(BasicJsonDocument&& src) : AllocatorOwner<TAllocator>(src) {
+    moveAssignFrom(src);
+  }
+#endif
+
+  BasicJsonDocument(const JsonDocument& src) {
+    copyAssignFrom(src);
+  }
+
+  // Construct from variant, array, or object
+  template <typename T>
+  BasicJsonDocument(
+      const T& src,
+      typename enable_if<
+          is_same<T, JsonVariant>::value ||
+          is_same<T, JsonVariantConst>::value || is_same<T, JsonArray>::value ||
+          is_same<T, JsonArrayConst>::value || is_same<T, JsonObject>::value ||
+          is_same<T, JsonObjectConst>::value>::type* = 0)
+      : JsonDocument(allocPool(src.memoryUsage())) {
+    set(src);
+  }
+
+  // disambiguate
+  BasicJsonDocument(JsonVariant src)
+      : JsonDocument(allocPool(src.memoryUsage())) {
+    set(src);
+  }
+
+  ~BasicJsonDocument() {
+    freePool();
+  }
+
+  BasicJsonDocument& operator=(const BasicJsonDocument& src) {
+    copyAssignFrom(src);
+    return *this;
+  }
+
+#if ARDUINOJSON_HAS_RVALUE_REFERENCES
+  BasicJsonDocument& operator=(BasicJsonDocument&& src) {
+    moveAssignFrom(src);
+    return *this;
+  }
+#endif
+
+  template <typename T>
+  BasicJsonDocument& operator=(const T& src) {
+    size_t requiredSize = src.memoryUsage();
+    if (requiredSize > capacity())
+      reallocPool(requiredSize);
+    set(src);
+    return *this;
+  }
+
+  // Reduces the capacity of the memory pool to match the current usage.
+  // https://arduinojson.org/v6/api/basicjsondocument/shrinktofit/
+  void shrinkToFit() {
+    ptrdiff_t bytes_reclaimed = _pool.squash();
+    if (bytes_reclaimed == 0)
+      return;
+
+    void* old_ptr = _pool.buffer();
+    void* new_ptr = this->reallocate(old_ptr, _pool.capacity());
+
+    ptrdiff_t ptr_offset =
+        static_cast<char*>(new_ptr) - static_cast<char*>(old_ptr);
+
+    _pool.movePointers(ptr_offset);
+    _data.movePointers(ptr_offset, ptr_offset - bytes_reclaimed);
+  }
+
+  // Reclaims the memory leaked when removing and replacing values.
+  // https://arduinojson.org/v6/api/jsondocument/garbagecollect/
+  bool garbageCollect() {
+    // make a temporary clone and move assign
+    BasicJsonDocument tmp(*this);
+    if (!tmp.capacity())
+      return false;
+    tmp.set(*this);
+    moveAssignFrom(tmp);
+    return true;
+  }
+
+  using AllocatorOwner<TAllocator>::allocator;
+
+ private:
+  MemoryPool allocPool(size_t requiredSize) {
+    size_t capa = addPadding(requiredSize);
+    return MemoryPool(reinterpret_cast<char*>(this->allocate(capa)), capa);
+  }
+
+  void reallocPool(size_t requiredSize) {
+    size_t capa = addPadding(requiredSize);
+    if (capa == _pool.capacity())
+      return;
+    freePool();
+    replacePool(allocPool(addPadding(requiredSize)));
+  }
+
+  void freePool() {
+    this->deallocate(getPool()->buffer());
+  }
+
+  void copyAssignFrom(const JsonDocument& src) {
+    reallocPool(src.capacity());
+    set(src);
+  }
+
+  void moveAssignFrom(BasicJsonDocument& src) {
+    freePool();
+    _data = src._data;
+    _pool = src._pool;
+    src._data.setNull();
+    src._pool = MemoryPool(0, 0);
+  }
+};
+
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Document/DynamicJsonDocument.hpp

@@ -0,0 +1,32 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Document/BasicJsonDocument.hpp>
+
+#include <stdlib.h>  // malloc, free
+
+namespace ARDUINOJSON_NAMESPACE {
+
+// The allocator of DynamicJsonDocument.
+struct DefaultAllocator {
+  void* allocate(size_t size) {
+    return malloc(size);
+  }
+
+  void deallocate(void* ptr) {
+    free(ptr);
+  }
+
+  void* reallocate(void* ptr, size_t new_size) {
+    return realloc(ptr, new_size);
+  }
+};
+
+// A JsonDocument with a memory pool in the heap.
+// https://arduinojson.org/v6/api/dynamicjsondocument/
+typedef BasicJsonDocument<DefaultAllocator> DynamicJsonDocument;
+
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Document/JsonDocument.hpp

@@ -0,0 +1,328 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Array/ElementProxy.hpp>
+#include <ArduinoJson/Memory/MemoryPool.hpp>
+#include <ArduinoJson/Object/JsonObject.hpp>
+#include <ArduinoJson/Object/MemberProxy.hpp>
+#include <ArduinoJson/Strings/StoragePolicy.hpp>
+#include <ArduinoJson/Variant/JsonVariantConst.hpp>
+#include <ArduinoJson/Variant/VariantTo.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+// A JSON document.
+// https://arduinojson.org/v6/api/jsondocument/
+class JsonDocument : public VariantOperators<const JsonDocument&> {
+  friend class VariantAttorney;
+
+ public:
+  // Casts the root to the specified type.
+  // https://arduinojson.org/v6/api/jsondocument/as/
+  template <typename T>
+  T as() {
+    return getVariant().template as<T>();
+  }
+
+  // Casts the root to the specified type.
+  // https://arduinojson.org/v6/api/jsondocument/as/
+  template <typename T>
+  T as() const {
+    return getVariant().template as<T>();
+  }
+
+  // Empties the document and resets the memory pool
+  // https://arduinojson.org/v6/api/jsondocument/clear/
+  void clear() {
+    _pool.clear();
+    _data.init();
+  }
+
+  // Returns true if the root is of the specified type.
+  // https://arduinojson.org/v6/api/jsondocument/is/
+  template <typename T>
+  bool is() {
+    return getVariant().template is<T>();
+  }
+
+  // Returns true if the root is of the specified type.
+  // https://arduinojson.org/v6/api/jsondocument/is/
+  template <typename T>
+  bool is() const {
+    return getVariant().template is<T>();
+  }
+
+  // Returns true if the root is null.
+  // https://arduinojson.org/v6/api/jsondocument/isnull/
+  bool isNull() const {
+    return getVariant().isNull();
+  }
+
+  // Returns the number of used bytes in the memory pool.
+  // https://arduinojson.org/v6/api/jsondocument/memoryusage/
+  size_t memoryUsage() const {
+    return _pool.size();
+  }
+
+  // Returns trues if the memory pool was too small.
+  // https://arduinojson.org/v6/api/jsondocument/overflowed/
+  bool overflowed() const {
+    return _pool.overflowed();
+  }
+
+  // Returns the depth (nesting level) of the array.
+  // https://arduinojson.org/v6/api/jsondocument/nesting/
+  size_t nesting() const {
+    return variantNesting(&_data);
+  }
+
+  // Returns the capacity of the memory pool.
+  // https://arduinojson.org/v6/api/jsondocument/capacity/
+  size_t capacity() const {
+    return _pool.capacity();
+  }
+
+  // Returns the number of elements in the root array or object.
+  // https://arduinojson.org/v6/api/jsondocument/size/
+  size_t size() const {
+    return _data.size();
+  }
+
+  // Copies the specified document.
+  // https://arduinojson.org/v6/api/jsondocument/set/
+  bool set(const JsonDocument& src) {
+    return to<JsonVariant>().set(src.as<JsonVariantConst>());
+  }
+
+  // Replaces the root with the specified value.
+  // https://arduinojson.org/v6/api/jsondocument/set/
+  template <typename T>
+  typename enable_if<!is_base_of<JsonDocument, T>::value, bool>::type set(
+      const T& src) {
+    return to<JsonVariant>().set(src);
+  }
+
+  // Clears the document and converts it to the specified type.
+  // https://arduinojson.org/v6/api/jsondocument/to/
+  template <typename T>
+  typename VariantTo<T>::type to() {
+    clear();
+    return getVariant().template to<T>();
+  }
+
+  // Creates an array and appends it to the root array.
+  // https://arduinojson.org/v6/api/jsondocument/createnestedarray/
+  JsonArray createNestedArray() {
+    return add().to<JsonArray>();
+  }
+
+  // Creates an array and adds it to the root object.
+  // https://arduinojson.org/v6/api/jsondocument/createnestedarray/
+  template <typename TChar>
+  JsonArray createNestedArray(TChar* key) {
+    return operator[](key).template to<JsonArray>();
+  }
+
+  // Creates an array and adds it to the root object.
+  // https://arduinojson.org/v6/api/jsondocument/createnestedarray/
+  template <typename TString>
+  JsonArray createNestedArray(const TString& key) {
+    return operator[](key).template to<JsonArray>();
+  }
+
+  // Creates an object and appends it to the root array.
+  // https://arduinojson.org/v6/api/jsondocument/createnestedobject/
+  JsonObject createNestedObject() {
+    return add().to<JsonObject>();
+  }
+
+  // Creates an object and adds it to the root object.
+  // https://arduinojson.org/v6/api/jsondocument/createnestedobject/
+  template <typename TChar>
+  JsonObject createNestedObject(TChar* key) {
+    return operator[](key).template to<JsonObject>();
+  }
+
+  // Creates an object and adds it to the root object.
+  // https://arduinojson.org/v6/api/jsondocument/createnestedobject/
+  template <typename TString>
+  JsonObject createNestedObject(const TString& key) {
+    return operator[](key).template to<JsonObject>();
+  }
+
+  // Returns true if the root object contains the specified key.
+  // https://arduinojson.org/v6/api/jsondocument/containskey/
+  template <typename TChar>
+  bool containsKey(TChar* key) const {
+    return _data.getMember(adaptString(key)) != 0;
+  }
+
+  // Returns true if the root object contains the specified key.
+  // https://arduinojson.org/v6/api/jsondocument/containskey/
+  template <typename TString>
+  bool containsKey(const TString& key) const {
+    return _data.getMember(adaptString(key)) != 0;
+  }
+
+  // Gets or sets a root object's member.
+  // https://arduinojson.org/v6/api/jsondocument/subscript/
+  template <typename TString>
+  FORCE_INLINE typename enable_if<IsString<TString>::value,
+                                  MemberProxy<JsonDocument&, TString> >::type
+  operator[](const TString& key) {
+    return MemberProxy<JsonDocument&, TString>(*this, key);
+  }
+
+  // Gets or sets a root object's member.
+  // https://arduinojson.org/v6/api/jsondocument/subscript/
+  template <typename TChar>
+  FORCE_INLINE typename enable_if<IsString<TChar*>::value,
+                                  MemberProxy<JsonDocument&, TChar*> >::type
+  operator[](TChar* key) {
+    return MemberProxy<JsonDocument&, TChar*>(*this, key);
+  }
+
+  // Gets a root object's member.
+  // https://arduinojson.org/v6/api/jsondocument/subscript/
+  template <typename TString>
+  FORCE_INLINE
+      typename enable_if<IsString<TString>::value, JsonVariantConst>::type
+      operator[](const TString& key) const {
+    return JsonVariantConst(_data.getMember(adaptString(key)));
+  }
+
+  // Gets a root object's member.
+  // https://arduinojson.org/v6/api/jsondocument/subscript/
+  template <typename TChar>
+  FORCE_INLINE
+      typename enable_if<IsString<TChar*>::value, JsonVariantConst>::type
+      operator[](TChar* key) const {
+    return JsonVariantConst(_data.getMember(adaptString(key)));
+  }
+
+  // Gets or sets a root array's element.
+  // https://arduinojson.org/v6/api/jsondocument/subscript/
+  FORCE_INLINE ElementProxy<JsonDocument&> operator[](size_t index) {
+    return ElementProxy<JsonDocument&>(*this, index);
+  }
+
+  // Gets a root array's member.
+  // https://arduinojson.org/v6/api/jsondocument/subscript/
+  FORCE_INLINE JsonVariantConst operator[](size_t index) const {
+    return JsonVariantConst(_data.getElement(index));
+  }
+
+  // Appends a new (null) element to the root array.
+  // Returns a reference to the new element.
+  // https://arduinojson.org/v6/api/jsondocument/add/
+  FORCE_INLINE JsonVariant add() {
+    return JsonVariant(&_pool, _data.addElement(&_pool));
+  }
+
+  // Appends a value to the root array.
+  // https://arduinojson.org/v6/api/jsondocument/add/
+  template <typename TValue>
+  FORCE_INLINE bool add(const TValue& value) {
+    return add().set(value);
+  }
+
+  // Appends a value to the root array.
+  // https://arduinojson.org/v6/api/jsondocument/add/
+  template <typename TChar>
+  FORCE_INLINE bool add(TChar* value) {
+    return add().set(value);
+  }
+
+  // Removes an element of the root array.
+  // ⚠️ Doesn't release the memory associated with the removed element.
+  // https://arduinojson.org/v6/api/jsondocument/remove/
+  FORCE_INLINE void remove(size_t index) {
+    _data.remove(index);
+  }
+
+  // Removes a member of the root object.
+  // ⚠️ Doesn't release the memory associated with the removed element.
+  // https://arduinojson.org/v6/api/jsondocument/remove/
+  template <typename TChar>
+  FORCE_INLINE typename enable_if<IsString<TChar*>::value>::type remove(
+      TChar* key) {
+    _data.remove(adaptString(key));
+  }
+
+  // Removes a member of the root object.
+  // ⚠️ Doesn't release the memory associated with the removed element.
+  // https://arduinojson.org/v6/api/jsondocument/remove/
+  template <typename TString>
+  FORCE_INLINE typename enable_if<IsString<TString>::value>::type remove(
+      const TString& key) {
+    _data.remove(adaptString(key));
+  }
+
+  FORCE_INLINE operator JsonVariant() {
+    return getVariant();
+  }
+
+  FORCE_INLINE operator JsonVariantConst() const {
+    return getVariant();
+  }
+
+ protected:
+  JsonDocument() : _pool(0, 0) {
+    _data.init();
+  }
+
+  JsonDocument(MemoryPool pool) : _pool(pool) {
+    _data.init();
+  }
+
+  JsonDocument(char* buf, size_t capa) : _pool(buf, capa) {
+    _data.init();
+  }
+
+  ~JsonDocument() {}
+
+  void replacePool(MemoryPool pool) {
+    _pool = pool;
+  }
+
+  JsonVariant getVariant() {
+    return JsonVariant(&_pool, &_data);
+  }
+
+  JsonVariantConst getVariant() const {
+    return JsonVariantConst(&_data);
+  }
+
+  MemoryPool _pool;
+  VariantData _data;
+
+ private:
+  JsonDocument(const JsonDocument&);
+  JsonDocument& operator=(const JsonDocument&);
+
+ protected:
+  MemoryPool* getPool() {
+    return &_pool;
+  }
+
+  VariantData* getData() {
+    return &_data;
+  }
+
+  const VariantData* getData() const {
+    return &_data;
+  }
+
+  VariantData* getOrCreateData() {
+    return &_data;
+  }
+};
+
+inline void convertToJson(const JsonDocument& src, JsonVariant dst) {
+  dst.set(src.as<JsonVariantConst>());
+}
+
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Document/StaticJsonDocument.hpp

@@ -0,0 +1,60 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Document/JsonDocument.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+// A JsonDocument with a memory pool on the stack.
+template <size_t desiredCapacity>
+class StaticJsonDocument : public JsonDocument {
+  static const size_t _capacity =
+      AddPadding<Max<1, desiredCapacity>::value>::value;
+
+ public:
+  StaticJsonDocument() : JsonDocument(_buffer, _capacity) {}
+
+  StaticJsonDocument(const StaticJsonDocument& src)
+      : JsonDocument(_buffer, _capacity) {
+    set(src);
+  }
+
+  template <typename T>
+  StaticJsonDocument(
+      const T& src,
+      typename enable_if<is_convertible<T, JsonVariantConst>::value>::type* = 0)
+      : JsonDocument(_buffer, _capacity) {
+    set(src);
+  }
+
+  // disambiguate
+  StaticJsonDocument(JsonVariant src) : JsonDocument(_buffer, _capacity) {
+    set(src);
+  }
+
+  StaticJsonDocument& operator=(const StaticJsonDocument& src) {
+    set(src);
+    return *this;
+  }
+
+  template <typename T>
+  StaticJsonDocument& operator=(const T& src) {
+    set(src);
+    return *this;
+  }
+
+  // Reclaims the memory leaked when removing and replacing values.
+  // https://arduinojson.org/v6/api/jsondocument/garbagecollect/
+  void garbageCollect() {
+    StaticJsonDocument tmp(*this);
+    set(tmp);
+  }
+
+ private:
+  char _buffer[_capacity];
+};
+
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Json/EscapeSequence.hpp

@@ -0,0 +1,39 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+class EscapeSequence {
+ public:
+  // Optimized for code size on a 8-bit AVR
+  static char escapeChar(char c) {
+    const char* p = escapeTable(true);
+    while (p[0] && p[1] != c) {
+      p += 2;
+    }
+    return p[0];
+  }
+
+  // Optimized for code size on a 8-bit AVR
+  static char unescapeChar(char c) {
+    const char* p = escapeTable(false);
+    for (;;) {
+      if (p[0] == '\0')
+        return 0;
+      if (p[0] == c)
+        return p[1];
+      p += 2;
+    }
+  }
+
+ private:
+  static const char* escapeTable(bool excludeSolidus) {
+    return &"//\"\"\\\\b\bf\fn\nr\rt\t"[excludeSolidus ? 2 : 0];
+  }
+};
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Json/JsonDeserializer.hpp

@@ -0,0 +1,775 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Deserialization/deserialize.hpp>
+#include <ArduinoJson/Json/EscapeSequence.hpp>
+#include <ArduinoJson/Json/Latch.hpp>
+#include <ArduinoJson/Json/Utf16.hpp>
+#include <ArduinoJson/Json/Utf8.hpp>
+#include <ArduinoJson/Memory/MemoryPool.hpp>
+#include <ArduinoJson/Numbers/parseNumber.hpp>
+#include <ArduinoJson/Polyfills/assert.hpp>
+#include <ArduinoJson/Polyfills/type_traits.hpp>
+#include <ArduinoJson/Variant/VariantData.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+template <typename TReader, typename TStringStorage>
+class JsonDeserializer {
+ public:
+  JsonDeserializer(MemoryPool* pool, TReader reader,
+                   TStringStorage stringStorage)
+      : _stringStorage(stringStorage),
+        _foundSomething(false),
+        _latch(reader),
+        _pool(pool) {}
+
+  template <typename TFilter>
+  DeserializationError parse(VariantData& variant, TFilter filter,
+                             NestingLimit nestingLimit) {
+    DeserializationError::Code err;
+
+    err = parseVariant(variant, filter, nestingLimit);
+
+    if (!err && _latch.last() != 0 && !variant.isEnclosed()) {
+      // We don't detect trailing characters earlier, so we need to check now
+      return DeserializationError::InvalidInput;
+    }
+
+    return err;
+  }
+
+ private:
+  char current() {
+    return _latch.current();
+  }
+
+  void move() {
+    _latch.clear();
+  }
+
+  bool eat(char charToSkip) {
+    if (current() != charToSkip)
+      return false;
+    move();
+    return true;
+  }
+
+  template <typename TFilter>
+  DeserializationError::Code parseVariant(VariantData& variant, TFilter filter,
+                                          NestingLimit nestingLimit) {
+    DeserializationError::Code err;
+
+    err = skipSpacesAndComments();
+    if (err)
+      return err;
+
+    switch (current()) {
+      case '[':
+        if (filter.allowArray())
+          return parseArray(variant.toArray(), filter, nestingLimit);
+        else
+          return skipArray(nestingLimit);
+
+      case '{':
+        if (filter.allowObject())
+          return parseObject(variant.toObject(), filter, nestingLimit);
+        else
+          return skipObject(nestingLimit);
+
+      case '\"':
+      case '\'':
+        if (filter.allowValue())
+          return parseStringValue(variant);
+        else
+          return skipQuotedString();
+
+      case 't':
+        if (filter.allowValue())
+          variant.setBoolean(true);
+        return skipKeyword("true");
+
+      case 'f':
+        if (filter.allowValue())
+          variant.setBoolean(false);
+        return skipKeyword("false");
+
+      case 'n':
+        // the variant should already by null, except if the same object key was
+        // used twice, as in {"a":1,"a":null}
+        return skipKeyword("null");
+
+      default:
+        if (filter.allowValue())
+          return parseNumericValue(variant);
+        else
+          return skipNumericValue();
+    }
+  }
+
+  DeserializationError::Code skipVariant(NestingLimit nestingLimit) {
+    DeserializationError::Code err;
+
+    err = skipSpacesAndComments();
+    if (err)
+      return err;
+
+    switch (current()) {
+      case '[':
+        return skipArray(nestingLimit);
+
+      case '{':
+        return skipObject(nestingLimit);
+
+      case '\"':
+      case '\'':
+        return skipQuotedString();
+
+      case 't':
+        return skipKeyword("true");
+
+      case 'f':
+        return skipKeyword("false");
+
+      case 'n':
+        return skipKeyword("null");
+
+      default:
+        return skipNumericValue();
+    }
+  }
+
+  template <typename TFilter>
+  DeserializationError::Code parseArray(CollectionData& array, TFilter filter,
+                                        NestingLimit nestingLimit) {
+    DeserializationError::Code err;
+
+    if (nestingLimit.reached())
+      return DeserializationError::TooDeep;
+
+    // Skip opening braket
+    ARDUINOJSON_ASSERT(current() == '[');
+    move();
+
+    // Skip spaces
+    err = skipSpacesAndComments();
+    if (err)
+      return err;
+
+    // Empty array?
+    if (eat(']'))
+      return DeserializationError::Ok;
+
+    TFilter memberFilter = filter[0UL];
+
+    // Read each value
+    for (;;) {
+      if (memberFilter.allow()) {
+        // Allocate slot in array
+        VariantData* value = array.addElement(_pool);
+        if (!value)
+          return DeserializationError::NoMemory;
+
+        // 1 - Parse value
+        err = parseVariant(*value, memberFilter, nestingLimit.decrement());
+        if (err)
+          return err;
+      } else {
+        err = skipVariant(nestingLimit.decrement());
+        if (err)
+          return err;
+      }
+
+      // 2 - Skip spaces
+      err = skipSpacesAndComments();
+      if (err)
+        return err;
+
+      // 3 - More values?
+      if (eat(']'))
+        return DeserializationError::Ok;
+      if (!eat(','))
+        return DeserializationError::InvalidInput;
+    }
+  }
+
+  DeserializationError::Code skipArray(NestingLimit nestingLimit) {
+    DeserializationError::Code err;
+
+    if (nestingLimit.reached())
+      return DeserializationError::TooDeep;
+
+    // Skip opening braket
+    ARDUINOJSON_ASSERT(current() == '[');
+    move();
+
+    // Read each value
+    for (;;) {
+      // 1 - Skip value
+      err = skipVariant(nestingLimit.decrement());
+      if (err)
+        return err;
+
+      // 2 - Skip spaces
+      err = skipSpacesAndComments();
+      if (err)
+        return err;
+
+      // 3 - More values?
+      if (eat(']'))
+        return DeserializationError::Ok;
+      if (!eat(','))
+        return DeserializationError::InvalidInput;
+    }
+  }
+
+  template <typename TFilter>
+  DeserializationError::Code parseObject(CollectionData& object, TFilter filter,
+                                         NestingLimit nestingLimit) {
+    DeserializationError::Code err;
+
+    if (nestingLimit.reached())
+      return DeserializationError::TooDeep;
+
+    // Skip opening brace
+    ARDUINOJSON_ASSERT(current() == '{');
+    move();
+
+    // Skip spaces
+    err = skipSpacesAndComments();
+    if (err)
+      return err;
+
+    // Empty object?
+    if (eat('}'))
+      return DeserializationError::Ok;
+
+    // Read each key value pair
+    for (;;) {
+      // Parse key
+      err = parseKey();
+      if (err)
+        return err;
+
+      // Skip spaces
+      err = skipSpacesAndComments();
+      if (err)
+        return err;
+
+      // Colon
+      if (!eat(':'))
+        return DeserializationError::InvalidInput;
+
+      JsonString key = _stringStorage.str();
+
+      TFilter memberFilter = filter[key.c_str()];
+
+      if (memberFilter.allow()) {
+        VariantData* variant = object.getMember(adaptString(key.c_str()));
+        if (!variant) {
+          // Save key in memory pool.
+          // This MUST be done before adding the slot.
+          key = _stringStorage.save();
+
+          // Allocate slot in object
+          VariantSlot* slot = object.addSlot(_pool);
+          if (!slot)
+            return DeserializationError::NoMemory;
+
+          slot->setKey(key);
+
+          variant = slot->data();
+        }
+
+        // Parse value
+        err = parseVariant(*variant, memberFilter, nestingLimit.decrement());
+        if (err)
+          return err;
+      } else {
+        err = skipVariant(nestingLimit.decrement());
+        if (err)
+          return err;
+      }
+
+      // Skip spaces
+      err = skipSpacesAndComments();
+      if (err)
+        return err;
+
+      // More keys/values?
+      if (eat('}'))
+        return DeserializationError::Ok;
+      if (!eat(','))
+        return DeserializationError::InvalidInput;
+
+      // Skip spaces
+      err = skipSpacesAndComments();
+      if (err)
+        return err;
+    }
+  }
+
+  DeserializationError::Code skipObject(NestingLimit nestingLimit) {
+    DeserializationError::Code err;
+
+    if (nestingLimit.reached())
+      return DeserializationError::TooDeep;
+
+    // Skip opening brace
+    ARDUINOJSON_ASSERT(current() == '{');
+    move();
+
+    // Skip spaces
+    err = skipSpacesAndComments();
+    if (err)
+      return err;
+
+    // Empty object?
+    if (eat('}'))
+      return DeserializationError::Ok;
+
+    // Read each key value pair
+    for (;;) {
+      // Skip key
+      err = skipKey();
+      if (err)
+        return err;
+
+      // Skip spaces
+      err = skipSpacesAndComments();
+      if (err)
+        return err;
+
+      // Colon
+      if (!eat(':'))
+        return DeserializationError::InvalidInput;
+
+      // Skip value
+      err = skipVariant(nestingLimit.decrement());
+      if (err)
+        return err;
+
+      // Skip spaces
+      err = skipSpacesAndComments();
+      if (err)
+        return err;
+
+      // More keys/values?
+      if (eat('}'))
+        return DeserializationError::Ok;
+      if (!eat(','))
+        return DeserializationError::InvalidInput;
+
+      err = skipSpacesAndComments();
+      if (err)
+        return err;
+    }
+  }
+
+  DeserializationError::Code parseKey() {
+    _stringStorage.startString();
+    if (isQuote(current())) {
+      return parseQuotedString();
+    } else {
+      return parseNonQuotedString();
+    }
+  }
+
+  DeserializationError::Code parseStringValue(VariantData& variant) {
+    DeserializationError::Code err;
+
+    _stringStorage.startString();
+
+    err = parseQuotedString();
+    if (err)
+      return err;
+
+    variant.setString(_stringStorage.save());
+
+    return DeserializationError::Ok;
+  }
+
+  DeserializationError::Code parseQuotedString() {
+#if ARDUINOJSON_DECODE_UNICODE
+    Utf16::Codepoint codepoint;
+    DeserializationError::Code err;
+#endif
+    const char stopChar = current();
+
+    move();
+    for (;;) {
+      char c = current();
+      move();
+      if (c == stopChar)
+        break;
+
+      if (c == '\0')
+        return DeserializationError::IncompleteInput;
+
+      if (c == '\\') {
+        c = current();
+
+        if (c == '\0')
+          return DeserializationError::IncompleteInput;
+
+        if (c == 'u') {
+#if ARDUINOJSON_DECODE_UNICODE
+          move();
+          uint16_t codeunit;
+          err = parseHex4(codeunit);
+          if (err)
+            return err;
+          if (codepoint.append(codeunit))
+            Utf8::encodeCodepoint(codepoint.value(), _stringStorage);
+#else
+          _stringStorage.append('\\');
+#endif
+          continue;
+        }
+
+        // replace char
+        c = EscapeSequence::unescapeChar(c);
+        if (c == '\0')
+          return DeserializationError::InvalidInput;
+        move();
+      }
+
+      _stringStorage.append(c);
+    }
+
+    if (!_stringStorage.isValid())
+      return DeserializationError::NoMemory;
+
+    return DeserializationError::Ok;
+  }
+
+  DeserializationError::Code parseNonQuotedString() {
+    char c = current();
+    ARDUINOJSON_ASSERT(c);
+
+    if (canBeInNonQuotedString(c)) {  // no quotes
+      do {
+        move();
+        _stringStorage.append(c);
+        c = current();
+      } while (canBeInNonQuotedString(c));
+    } else {
+      return DeserializationError::InvalidInput;
+    }
+
+    if (!_stringStorage.isValid())
+      return DeserializationError::NoMemory;
+
+    return DeserializationError::Ok;
+  }
+
+  DeserializationError::Code skipKey() {
+    if (isQuote(current())) {
+      return skipQuotedString();
+    } else {
+      return skipNonQuotedString();
+    }
+  }
+
+  DeserializationError::Code skipQuotedString() {
+    const char stopChar = current();
+
+    move();
+    for (;;) {
+      char c = current();
+      move();
+      if (c == stopChar)
+        break;
+      if (c == '\0')
+        return DeserializationError::IncompleteInput;
+      if (c == '\\') {
+        if (current() != '\0')
+          move();
+      }
+    }
+
+    return DeserializationError::Ok;
+  }
+
+  DeserializationError::Code skipNonQuotedString() {
+    char c = current();
+    while (canBeInNonQuotedString(c)) {
+      move();
+      c = current();
+    }
+    return DeserializationError::Ok;
+  }
+
+  DeserializationError::Code parseNumericValue(VariantData& result) {
+    uint8_t n = 0;
+
+    char c = current();
+    while (canBeInNumber(c) && n < 63) {
+      move();
+      _buffer[n++] = c;
+      c = current();
+    }
+    _buffer[n] = 0;
+
+    if (!parseNumber(_buffer, result))
+      return DeserializationError::InvalidInput;
+
+    return DeserializationError::Ok;
+  }
+
+  DeserializationError::Code skipNumericValue() {
+    char c = current();
+    while (canBeInNumber(c)) {
+      move();
+      c = current();
+    }
+    return DeserializationError::Ok;
+  }
+
+  DeserializationError::Code parseHex4(uint16_t& result) {
+    result = 0;
+    for (uint8_t i = 0; i < 4; ++i) {
+      char digit = current();
+      if (!digit)
+        return DeserializationError::IncompleteInput;
+      uint8_t value = decodeHex(digit);
+      if (value > 0x0F)
+        return DeserializationError::InvalidInput;
+      result = uint16_t((result << 4) | value);
+      move();
+    }
+    return DeserializationError::Ok;
+  }
+
+  static inline bool isBetween(char c, char min, char max) {
+    return min <= c && c <= max;
+  }
+
+  static inline bool canBeInNumber(char c) {
+    return isBetween(c, '0', '9') || c == '+' || c == '-' || c == '.' ||
+#if ARDUINOJSON_ENABLE_NAN || ARDUINOJSON_ENABLE_INFINITY
+           isBetween(c, 'A', 'Z') || isBetween(c, 'a', 'z');
+#else
+           c == 'e' || c == 'E';
+#endif
+  }
+
+  static inline bool canBeInNonQuotedString(char c) {
+    return isBetween(c, '0', '9') || isBetween(c, '_', 'z') ||
+           isBetween(c, 'A', 'Z');
+  }
+
+  static inline bool isQuote(char c) {
+    return c == '\'' || c == '\"';
+  }
+
+  static inline uint8_t decodeHex(char c) {
+    if (c < 'A')
+      return uint8_t(c - '0');
+    c = char(c & ~0x20);  // uppercase
+    return uint8_t(c - 'A' + 10);
+  }
+
+  DeserializationError::Code skipSpacesAndComments() {
+    for (;;) {
+      switch (current()) {
+        // end of string
+        case '\0':
+          return _foundSomething ? DeserializationError::IncompleteInput
+                                 : DeserializationError::EmptyInput;
+
+        // spaces
+        case ' ':
+        case '\t':
+        case '\r':
+        case '\n':
+          move();
+          continue;
+
+#if ARDUINOJSON_ENABLE_COMMENTS
+        // comments
+        case '/':
+          move();  // skip '/'
+          switch (current()) {
+            // block comment
+            case '*': {
+              move();  // skip '*'
+              bool wasStar = false;
+              for (;;) {
+                char c = current();
+                if (c == '\0')
+                  return DeserializationError::IncompleteInput;
+                if (c == '/' && wasStar) {
+                  move();
+                  break;
+                }
+                wasStar = c == '*';
+                move();
+              }
+              break;
+            }
+
+            // trailing comment
+            case '/':
+              // no need to skip "//"
+              for (;;) {
+                move();
+                char c = current();
+                if (c == '\0')
+                  return DeserializationError::IncompleteInput;
+                if (c == '\n')
+                  break;
+              }
+              break;
+
+            // not a comment, just a '/'
+            default:
+              return DeserializationError::InvalidInput;
+          }
+          break;
+#endif
+
+        default:
+          _foundSomething = true;
+          return DeserializationError::Ok;
+      }
+    }
+  }
+
+  DeserializationError::Code skipKeyword(const char* s) {
+    while (*s) {
+      char c = current();
+      if (c == '\0')
+        return DeserializationError::IncompleteInput;
+      if (*s != c)
+        return DeserializationError::InvalidInput;
+      ++s;
+      move();
+    }
+    return DeserializationError::Ok;
+  }
+
+  TStringStorage _stringStorage;
+  bool _foundSomething;
+  Latch<TReader> _latch;
+  MemoryPool* _pool;
+  char _buffer[64];  // using a member instead of a local variable because it
+                     // ended in the recursive path after compiler inlined the
+                     // code
+};
+
+// Parses a JSON input and puts the result in a JsonDocument.
+// https://arduinojson.org/v6/api/json/deserializejson/
+template <typename TString>
+DeserializationError deserializeJson(
+    JsonDocument& doc, const TString& input,
+    NestingLimit nestingLimit = NestingLimit()) {
+  return deserialize<JsonDeserializer>(doc, input, nestingLimit,
+                                       AllowAllFilter());
+}
+
+// Parses a JSON input, filters, and puts the result in a JsonDocument.
+// https://arduinojson.org/v6/api/json/deserializejson/
+template <typename TString>
+DeserializationError deserializeJson(
+    JsonDocument& doc, const TString& input, Filter filter,
+    NestingLimit nestingLimit = NestingLimit()) {
+  return deserialize<JsonDeserializer>(doc, input, nestingLimit, filter);
+}
+
+// Parses a JSON input, filters, and puts the result in a JsonDocument.
+// https://arduinojson.org/v6/api/json/deserializejson/
+template <typename TString>
+DeserializationError deserializeJson(JsonDocument& doc, const TString& input,
+                                     NestingLimit nestingLimit, Filter filter) {
+  return deserialize<JsonDeserializer>(doc, input, nestingLimit, filter);
+}
+
+// Parses a JSON input and puts the result in a JsonDocument.
+// https://arduinojson.org/v6/api/json/deserializejson/
+template <typename TStream>
+DeserializationError deserializeJson(
+    JsonDocument& doc, TStream& input,
+    NestingLimit nestingLimit = NestingLimit()) {
+  return deserialize<JsonDeserializer>(doc, input, nestingLimit,
+                                       AllowAllFilter());
+}
+
+// Parses a JSON input, filters, and puts the result in a JsonDocument.
+// https://arduinojson.org/v6/api/json/deserializejson/
+template <typename TStream>
+DeserializationError deserializeJson(
+    JsonDocument& doc, TStream& input, Filter filter,
+    NestingLimit nestingLimit = NestingLimit()) {
+  return deserialize<JsonDeserializer>(doc, input, nestingLimit, filter);
+}
+
+// Parses a JSON input, filters, and puts the result in a JsonDocument.
+// https://arduinojson.org/v6/api/json/deserializejson/
+template <typename TStream>
+DeserializationError deserializeJson(JsonDocument& doc, TStream& input,
+                                     NestingLimit nestingLimit, Filter filter) {
+  return deserialize<JsonDeserializer>(doc, input, nestingLimit, filter);
+}
+
+// Parses a JSON input and puts the result in a JsonDocument.
+// https://arduinojson.org/v6/api/json/deserializejson/
+template <typename TChar>
+DeserializationError deserializeJson(
+    JsonDocument& doc, TChar* input,
+    NestingLimit nestingLimit = NestingLimit()) {
+  return deserialize<JsonDeserializer>(doc, input, nestingLimit,
+                                       AllowAllFilter());
+}
+
+// Parses a JSON input, filters, and puts the result in a JsonDocument.
+// https://arduinojson.org/v6/api/json/deserializejson/
+template <typename TChar>
+DeserializationError deserializeJson(
+    JsonDocument& doc, TChar* input, Filter filter,
+    NestingLimit nestingLimit = NestingLimit()) {
+  return deserialize<JsonDeserializer>(doc, input, nestingLimit, filter);
+}
+
+// Parses a JSON input, filters, and puts the result in a JsonDocument.
+// https://arduinojson.org/v6/api/json/deserializejson/
+template <typename TChar>
+DeserializationError deserializeJson(JsonDocument& doc, TChar* input,
+                                     NestingLimit nestingLimit, Filter filter) {
+  return deserialize<JsonDeserializer>(doc, input, nestingLimit, filter);
+}
+
+// Parses a JSON input and puts the result in a JsonDocument.
+// https://arduinojson.org/v6/api/json/deserializejson/
+template <typename TChar>
+DeserializationError deserializeJson(
+    JsonDocument& doc, TChar* input, size_t inputSize,
+    NestingLimit nestingLimit = NestingLimit()) {
+  return deserialize<JsonDeserializer>(doc, input, inputSize, nestingLimit,
+                                       AllowAllFilter());
+}
+
+// Parses a JSON input, filters, and puts the result in a JsonDocument.
+// https://arduinojson.org/v6/api/json/deserializejson/
+template <typename TChar>
+DeserializationError deserializeJson(
+    JsonDocument& doc, TChar* input, size_t inputSize, Filter filter,
+    NestingLimit nestingLimit = NestingLimit()) {
+  return deserialize<JsonDeserializer>(doc, input, inputSize, nestingLimit,
+                                       filter);
+}
+
+// Parses a JSON input, filters, and puts the result in a JsonDocument.
+// https://arduinojson.org/v6/api/json/deserializejson/
+template <typename TChar>
+DeserializationError deserializeJson(JsonDocument& doc, TChar* input,
+                                     size_t inputSize,
+                                     NestingLimit nestingLimit, Filter filter) {
+  return deserialize<JsonDeserializer>(doc, input, inputSize, nestingLimit,
+                                       filter);
+}
+
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Json/JsonSerializer.hpp

@@ -0,0 +1,148 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Json/TextFormatter.hpp>
+#include <ArduinoJson/Serialization/measure.hpp>
+#include <ArduinoJson/Serialization/serialize.hpp>
+#include <ArduinoJson/Variant/Visitor.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+template <typename TWriter>
+class JsonSerializer : public Visitor<size_t> {
+ public:
+  static const bool producesText = true;
+
+  JsonSerializer(TWriter writer) : _formatter(writer) {}
+
+  FORCE_INLINE size_t visitArray(const CollectionData& array) {
+    write('[');
+
+    const VariantSlot* slot = array.head();
+
+    while (slot != 0) {
+      slot->data()->accept(*this);
+
+      slot = slot->next();
+      if (slot == 0)
+        break;
+
+      write(',');
+    }
+
+    write(']');
+    return bytesWritten();
+  }
+
+  size_t visitObject(const CollectionData& object) {
+    write('{');
+
+    const VariantSlot* slot = object.head();
+
+    while (slot != 0) {
+      _formatter.writeString(slot->key());
+      write(':');
+      slot->data()->accept(*this);
+
+      slot = slot->next();
+      if (slot == 0)
+        break;
+
+      write(',');
+    }
+
+    write('}');
+    return bytesWritten();
+  }
+
+  size_t visitFloat(JsonFloat value) {
+    _formatter.writeFloat(value);
+    return bytesWritten();
+  }
+
+  size_t visitString(const char* value) {
+    _formatter.writeString(value);
+    return bytesWritten();
+  }
+
+  size_t visitString(const char* value, size_t n) {
+    _formatter.writeString(value, n);
+    return bytesWritten();
+  }
+
+  size_t visitRawJson(const char* data, size_t n) {
+    _formatter.writeRaw(data, n);
+    return bytesWritten();
+  }
+
+  size_t visitSignedInteger(JsonInteger value) {
+    _formatter.writeInteger(value);
+    return bytesWritten();
+  }
+
+  size_t visitUnsignedInteger(JsonUInt value) {
+    _formatter.writeInteger(value);
+    return bytesWritten();
+  }
+
+  size_t visitBoolean(bool value) {
+    _formatter.writeBoolean(value);
+    return bytesWritten();
+  }
+
+  size_t visitNull() {
+    _formatter.writeRaw("null");
+    return bytesWritten();
+  }
+
+ protected:
+  size_t bytesWritten() const {
+    return _formatter.bytesWritten();
+  }
+
+  void write(char c) {
+    _formatter.writeRaw(c);
+  }
+
+  void write(const char* s) {
+    _formatter.writeRaw(s);
+  }
+
+ private:
+  TextFormatter<TWriter> _formatter;
+};
+
+// Produces a minified JSON document.
+// https://arduinojson.org/v6/api/json/serializejson/
+template <typename TDestination>
+size_t serializeJson(JsonVariantConst source, TDestination& destination) {
+  return serialize<JsonSerializer>(source, destination);
+}
+
+// Produces a minified JSON document.
+// https://arduinojson.org/v6/api/json/serializejson/
+inline size_t serializeJson(JsonVariantConst source, void* buffer,
+                            size_t bufferSize) {
+  return serialize<JsonSerializer>(source, buffer, bufferSize);
+}
+
+// Computes the length of the document that serializeJson() produces.
+// https://arduinojson.org/v6/api/json/measurejson/
+inline size_t measureJson(JsonVariantConst source) {
+  return measure<JsonSerializer>(source);
+}
+
+#if ARDUINOJSON_ENABLE_STD_STREAM
+template <typename T>
+inline typename enable_if<is_convertible<T, JsonVariantConst>::value,
+                          std::ostream&>::type
+operator<<(std::ostream& os, const T& source) {
+  serializeJson(source, os);
+  return os;
+}
+#endif
+
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Json/Latch.hpp

@@ -0,0 +1,56 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Polyfills/assert.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+template <typename TReader>
+class Latch {
+ public:
+  Latch(TReader reader) : _reader(reader), _loaded(false) {
+#if ARDUINOJSON_DEBUG
+    _ended = false;
+#endif
+  }
+
+  void clear() {
+    _loaded = false;
+  }
+
+  int last() const {
+    return _current;
+  }
+
+  FORCE_INLINE char current() {
+    if (!_loaded) {
+      load();
+    }
+    return _current;
+  }
+
+ private:
+  void load() {
+    ARDUINOJSON_ASSERT(!_ended);
+    int c = _reader.read();
+#if ARDUINOJSON_DEBUG
+    if (c <= 0)
+      _ended = true;
+#endif
+    _current = static_cast<char>(c > 0 ? c : 0);
+    _loaded = true;
+  }
+
+  TReader _reader;
+  char _current;  // NOLINT(clang-analyzer-optin.cplusplus.UninitializedObject)
+                  // Not initialized in constructor (+10 bytes on AVR)
+  bool _loaded;
+#if ARDUINOJSON_DEBUG
+  bool _ended;
+#endif
+};
+
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Json/PrettyJsonSerializer.hpp

@@ -0,0 +1,94 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Configuration.hpp>
+#include <ArduinoJson/Json/JsonSerializer.hpp>
+#include <ArduinoJson/Serialization/measure.hpp>
+#include <ArduinoJson/Serialization/serialize.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+template <typename TWriter>
+class PrettyJsonSerializer : public JsonSerializer<TWriter> {
+  typedef JsonSerializer<TWriter> base;
+
+ public:
+  PrettyJsonSerializer(TWriter writer) : base(writer), _nesting(0) {}
+
+  size_t visitArray(const CollectionData& array) {
+    const VariantSlot* slot = array.head();
+    if (slot) {
+      base::write("[\r\n");
+      _nesting++;
+      while (slot != 0) {
+        indent();
+        slot->data()->accept(*this);
+
+        slot = slot->next();
+        base::write(slot ? ",\r\n" : "\r\n");
+      }
+      _nesting--;
+      indent();
+      base::write("]");
+    } else {
+      base::write("[]");
+    }
+    return this->bytesWritten();
+  }
+
+  size_t visitObject(const CollectionData& object) {
+    const VariantSlot* slot = object.head();
+    if (slot) {
+      base::write("{\r\n");
+      _nesting++;
+      while (slot != 0) {
+        indent();
+        base::visitString(slot->key());
+        base::write(": ");
+        slot->data()->accept(*this);
+
+        slot = slot->next();
+        base::write(slot ? ",\r\n" : "\r\n");
+      }
+      _nesting--;
+      indent();
+      base::write("}");
+    } else {
+      base::write("{}");
+    }
+    return this->bytesWritten();
+  }
+
+ private:
+  void indent() {
+    for (uint8_t i = 0; i < _nesting; i++)
+      base::write(ARDUINOJSON_TAB);
+  }
+
+  uint8_t _nesting;
+};
+
+// Produces JsonDocument to create a prettified JSON document.
+// https://arduinojson.org/v6/api/json/serializejsonpretty/
+template <typename TDestination>
+size_t serializeJsonPretty(JsonVariantConst source, TDestination& destination) {
+  return serialize<PrettyJsonSerializer>(source, destination);
+}
+
+// Produces JsonDocument to create a prettified JSON document.
+// https://arduinojson.org/v6/api/json/serializejsonpretty/
+inline size_t serializeJsonPretty(JsonVariantConst source, void* buffer,
+                                  size_t bufferSize) {
+  return serialize<PrettyJsonSerializer>(source, buffer, bufferSize);
+}
+
+// Computes the length of the document that serializeJsonPretty() produces.
+// https://arduinojson.org/v6/api/json/measurejsonpretty/
+inline size_t measureJsonPretty(JsonVariantConst source) {
+  return measure<PrettyJsonSerializer>(source);
+}
+
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Json/TextFormatter.hpp

@@ -0,0 +1,173 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <stdint.h>
+#include <string.h>  // for strlen
+
+#include <ArduinoJson/Json/EscapeSequence.hpp>
+#include <ArduinoJson/Numbers/FloatParts.hpp>
+#include <ArduinoJson/Numbers/JsonInteger.hpp>
+#include <ArduinoJson/Polyfills/assert.hpp>
+#include <ArduinoJson/Polyfills/attributes.hpp>
+#include <ArduinoJson/Polyfills/type_traits.hpp>
+#include <ArduinoJson/Serialization/CountingDecorator.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+template <typename TWriter>
+class TextFormatter {
+ public:
+  explicit TextFormatter(TWriter writer) : _writer(writer) {}
+
+  // Returns the number of bytes sent to the TWriter implementation.
+  size_t bytesWritten() const {
+    return _writer.count();
+  }
+
+  void writeBoolean(bool value) {
+    if (value)
+      writeRaw("true");
+    else
+      writeRaw("false");
+  }
+
+  void writeString(const char* value) {
+    ARDUINOJSON_ASSERT(value != NULL);
+    writeRaw('\"');
+    while (*value)
+      writeChar(*value++);
+    writeRaw('\"');
+  }
+
+  void writeString(const char* value, size_t n) {
+    ARDUINOJSON_ASSERT(value != NULL);
+    writeRaw('\"');
+    while (n--)
+      writeChar(*value++);
+    writeRaw('\"');
+  }
+
+  void writeChar(char c) {
+    char specialChar = EscapeSequence::escapeChar(c);
+    if (specialChar) {
+      writeRaw('\\');
+      writeRaw(specialChar);
+    } else if (c) {
+      writeRaw(c);
+    } else {
+      writeRaw("\\u0000");
+    }
+  }
+
+  template <typename T>
+  void writeFloat(T value) {
+    if (isnan(value))
+      return writeRaw(ARDUINOJSON_ENABLE_NAN ? "NaN" : "null");
+
+#if ARDUINOJSON_ENABLE_INFINITY
+    if (value < 0.0) {
+      writeRaw('-');
+      value = -value;
+    }
+
+    if (isinf(value))
+      return writeRaw("Infinity");
+#else
+    if (isinf(value))
+      return writeRaw("null");
+
+    if (value < 0.0) {
+      writeRaw('-');
+      value = -value;
+    }
+#endif
+
+    FloatParts<T> parts(value);
+
+    writeInteger(parts.integral);
+    if (parts.decimalPlaces)
+      writeDecimals(parts.decimal, parts.decimalPlaces);
+
+    if (parts.exponent) {
+      writeRaw('e');
+      writeInteger(parts.exponent);
+    }
+  }
+
+  template <typename T>
+  typename enable_if<is_signed<T>::value>::type writeInteger(T value) {
+    typedef typename make_unsigned<T>::type unsigned_type;
+    unsigned_type unsigned_value;
+    if (value < 0) {
+      writeRaw('-');
+      unsigned_value = unsigned_type(unsigned_type(~value) + 1);
+    } else {
+      unsigned_value = unsigned_type(value);
+    }
+    writeInteger(unsigned_value);
+  }
+
+  template <typename T>
+  typename enable_if<is_unsigned<T>::value>::type writeInteger(T value) {
+    char buffer[22];
+    char* end = buffer + sizeof(buffer);
+    char* begin = end;
+
+    // write the string in reverse order
+    do {
+      *--begin = char(value % 10 + '0');
+      value = T(value / 10);
+    } while (value);
+
+    // and dump it in the right order
+    writeRaw(begin, end);
+  }
+
+  void writeDecimals(uint32_t value, int8_t width) {
+    // buffer should be big enough for all digits and the dot
+    char buffer[16];
+    char* end = buffer + sizeof(buffer);
+    char* begin = end;
+
+    // write the string in reverse order
+    while (width--) {
+      *--begin = char(value % 10 + '0');
+      value /= 10;
+    }
+    *--begin = '.';
+
+    // and dump it in the right order
+    writeRaw(begin, end);
+  }
+
+  void writeRaw(const char* s) {
+    _writer.write(reinterpret_cast<const uint8_t*>(s), strlen(s));
+  }
+
+  void writeRaw(const char* s, size_t n) {
+    _writer.write(reinterpret_cast<const uint8_t*>(s), n);
+  }
+
+  void writeRaw(const char* begin, const char* end) {
+    _writer.write(reinterpret_cast<const uint8_t*>(begin),
+                  static_cast<size_t>(end - begin));
+  }
+
+  template <size_t N>
+  void writeRaw(const char (&s)[N]) {
+    _writer.write(reinterpret_cast<const uint8_t*>(s), N - 1);
+  }
+  void writeRaw(char c) {
+    _writer.write(static_cast<uint8_t>(c));
+  }
+
+ protected:
+  CountingDecorator<TWriter> _writer;
+
+ private:
+  TextFormatter& operator=(const TextFormatter&);  // cannot be assigned
+};
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Json/Utf16.hpp

@@ -0,0 +1,67 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+#include <stdint.h>  // uint16_t, uint32_t
+
+// The high surrogate may be uninitialized if the pair is invalid,
+// we choose to ignore the problem to reduce the size of the code
+// Garbage in => Garbage out
+#if defined(__GNUC__)
+#  if __GNUC__ >= 7
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#  endif
+#endif
+
+namespace ARDUINOJSON_NAMESPACE {
+
+namespace Utf16 {
+inline bool isHighSurrogate(uint16_t codeunit) {
+  return codeunit >= 0xD800 && codeunit < 0xDC00;
+}
+
+inline bool isLowSurrogate(uint16_t codeunit) {
+  return codeunit >= 0xDC00 && codeunit < 0xE000;
+}
+
+class Codepoint {
+ public:
+  Codepoint() : _highSurrogate(0), _codepoint(0) {}
+
+  bool append(uint16_t codeunit) {
+    if (isHighSurrogate(codeunit)) {
+      _highSurrogate = codeunit & 0x3FF;
+      return false;
+    }
+
+    if (isLowSurrogate(codeunit)) {
+      _codepoint =
+          uint32_t(0x10000 + ((_highSurrogate << 10) | (codeunit & 0x3FF)));
+      return true;
+    }
+
+    _codepoint = codeunit;
+    return true;
+  }
+
+  uint32_t value() const {
+    return _codepoint;
+  }
+
+ private:
+  uint16_t _highSurrogate;
+  uint32_t _codepoint;
+};
+}  // namespace Utf16
+}  // namespace ARDUINOJSON_NAMESPACE
+
+#if defined(__GNUC__)
+#  if __GNUC__ >= 8
+#    pragma GCC diagnostic pop
+#  endif
+#endif

lib/ArduinoJson/src/ArduinoJson/Json/Utf8.hpp

@@ -0,0 +1,46 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+namespace Utf8 {
+template <typename TStringBuilder>
+inline void encodeCodepoint(uint32_t codepoint32, TStringBuilder& str) {
+  // this function was optimize for code size on AVR
+
+  if (codepoint32 < 0x80) {
+    str.append(char(codepoint32));
+  } else {
+    // a buffer to store the string in reverse
+    char buf[5];
+    char* p = buf;
+
+    *(p++) = 0;
+    *(p++) = char((codepoint32 | 0x80) & 0xBF);
+    uint16_t codepoint16 = uint16_t(codepoint32 >> 6);
+    if (codepoint16 < 0x20) {  // 0x800
+      *(p++) = char(codepoint16 | 0xC0);
+    } else {
+      *(p++) = char((codepoint16 | 0x80) & 0xBF);
+      codepoint16 = uint16_t(codepoint16 >> 6);
+      if (codepoint16 < 0x10) {  // 0x10000
+        *(p++) = char(codepoint16 | 0xE0);
+      } else {
+        *(p++) = char((codepoint16 | 0x80) & 0xBF);
+        codepoint16 = uint16_t(codepoint16 >> 6);
+        *(p++) = char(codepoint16 | 0xF0);
+      }
+    }
+
+    while (*(--p)) {
+      str.append(*p);
+    }
+  }
+}
+}  // namespace Utf8
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Memory/Alignment.hpp

@@ -0,0 +1,60 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+#include <stddef.h>  // size_t
+
+namespace ARDUINOJSON_NAMESPACE {
+
+#if ARDUINOJSON_ENABLE_ALIGNMENT
+
+inline bool isAligned(size_t value) {
+  const size_t mask = sizeof(void*) - 1;
+  size_t addr = value;
+  return (addr & mask) == 0;
+}
+
+inline size_t addPadding(size_t bytes) {
+  const size_t mask = sizeof(void*) - 1;
+  return (bytes + mask) & ~mask;
+}
+
+template <size_t bytes>
+struct AddPadding {
+  static const size_t mask = sizeof(void*) - 1;
+  static const size_t value = (bytes + mask) & ~mask;
+};
+
+#else
+
+inline bool isAligned(size_t) {
+  return true;
+}
+
+inline size_t addPadding(size_t bytes) {
+  return bytes;
+}
+
+template <size_t bytes>
+struct AddPadding {
+  static const size_t value = bytes;
+};
+
+#endif
+
+template <typename T>
+inline bool isAligned(T* ptr) {
+  return isAligned(reinterpret_cast<size_t>(ptr));
+}
+
+template <typename T>
+inline T* addPadding(T* p) {
+  size_t address = addPadding(reinterpret_cast<size_t>(p));
+  return reinterpret_cast<T*>(address);
+}
+
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Memory/MemoryPool.hpp

@@ -0,0 +1,253 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Memory/Alignment.hpp>
+#include <ArduinoJson/Polyfills/assert.hpp>
+#include <ArduinoJson/Polyfills/mpl/max.hpp>
+#include <ArduinoJson/Strings/StringAdapters.hpp>
+#include <ArduinoJson/Variant/VariantSlot.hpp>
+
+#include <string.h>  // memmove
+
+#define JSON_STRING_SIZE(SIZE) (SIZE + 1)
+
+// Computes the size required to store an array in a JsonDocument.
+// https://arduinojson.org/v6/how-to/determine-the-capacity-of-the-jsondocument/
+#define JSON_ARRAY_SIZE(NUMBER_OF_ELEMENTS) \
+  ((NUMBER_OF_ELEMENTS) * sizeof(ARDUINOJSON_NAMESPACE::VariantSlot))
+
+// Returns the size (in bytes) of an object with n elements.
+// Can be very handy to determine the size of a StaticMemoryPool.
+#define JSON_OBJECT_SIZE(NUMBER_OF_ELEMENTS) \
+  ((NUMBER_OF_ELEMENTS) * sizeof(ARDUINOJSON_NAMESPACE::VariantSlot))
+
+namespace ARDUINOJSON_NAMESPACE {
+
+// _begin                                   _end
+// v                                           v
+// +-------------+--------------+--------------+
+// | strings...  |   (free)     |  ...variants |
+// +-------------+--------------+--------------+
+//               ^              ^
+//             _left          _right
+
+class MemoryPool {
+ public:
+  MemoryPool(char* buf, size_t capa)
+      : _begin(buf),
+        _left(buf),
+        _right(buf ? buf + capa : 0),
+        _end(buf ? buf + capa : 0),
+        _overflowed(false) {
+    ARDUINOJSON_ASSERT(isAligned(_begin));
+    ARDUINOJSON_ASSERT(isAligned(_right));
+    ARDUINOJSON_ASSERT(isAligned(_end));
+  }
+
+  void* buffer() {
+    return _begin;  // NOLINT(clang-analyzer-unix.Malloc)
+                    // movePointers() alters this pointer
+  }
+
+  // Gets the capacity of the memoryPool in bytes
+  size_t capacity() const {
+    return size_t(_end - _begin);
+  }
+
+  size_t size() const {
+    return size_t(_left - _begin + _end - _right);
+  }
+
+  bool overflowed() const {
+    return _overflowed;
+  }
+
+  VariantSlot* allocVariant() {
+    return allocRight<VariantSlot>();
+  }
+
+  template <typename TAdaptedString>
+  const char* saveString(TAdaptedString str) {
+    if (str.isNull())
+      return 0;
+
+#if ARDUINOJSON_ENABLE_STRING_DEDUPLICATION
+    const char* existingCopy = findString(str);
+    if (existingCopy)
+      return existingCopy;
+#endif
+
+    size_t n = str.size();
+
+    char* newCopy = allocString(n + 1);
+    if (newCopy) {
+      stringGetChars(str, newCopy, n);
+      newCopy[n] = 0;  // force null-terminator
+    }
+    return newCopy;
+  }
+
+  void getFreeZone(char** zoneStart, size_t* zoneSize) const {
+    *zoneStart = _left;
+    *zoneSize = size_t(_right - _left);
+  }
+
+  const char* saveStringFromFreeZone(size_t len) {
+#if ARDUINOJSON_ENABLE_STRING_DEDUPLICATION
+    const char* dup = findString(adaptString(_left, len));
+    if (dup)
+      return dup;
+#endif
+
+    const char* str = _left;
+    _left += len;
+    *_left++ = 0;
+    checkInvariants();
+    return str;
+  }
+
+  void markAsOverflowed() {
+    _overflowed = true;
+  }
+
+  void clear() {
+    _left = _begin;
+    _right = _end;
+    _overflowed = false;
+  }
+
+  bool canAlloc(size_t bytes) const {
+    return _left + bytes <= _right;
+  }
+
+  bool owns(void* p) const {
+    return _begin <= p && p < _end;
+  }
+
+  // Workaround for missing placement new
+  void* operator new(size_t, void* p) {
+    return p;
+  }
+
+  // Squash the free space between strings and variants
+  //
+  // _begin                    _end
+  // v                            v
+  // +-------------+--------------+
+  // | strings...  |  ...variants |
+  // +-------------+--------------+
+  //               ^
+  //          _left _right
+  //
+  // This funcion is called before a realloc.
+  ptrdiff_t squash() {
+    char* new_right = addPadding(_left);
+    if (new_right >= _right)
+      return 0;
+
+    size_t right_size = static_cast<size_t>(_end - _right);
+    memmove(new_right, _right, right_size);
+
+    ptrdiff_t bytes_reclaimed = _right - new_right;
+    _right = new_right;
+    _end = new_right + right_size;
+    return bytes_reclaimed;
+  }
+
+  // Move all pointers together
+  // This funcion is called after a realloc.
+  void movePointers(ptrdiff_t offset) {
+    _begin += offset;
+    _left += offset;
+    _right += offset;
+    _end += offset;
+  }
+
+ private:
+  void checkInvariants() {
+    ARDUINOJSON_ASSERT(_begin <= _left);
+    ARDUINOJSON_ASSERT(_left <= _right);
+    ARDUINOJSON_ASSERT(_right <= _end);
+    ARDUINOJSON_ASSERT(isAligned(_right));
+  }
+
+#if ARDUINOJSON_ENABLE_STRING_DEDUPLICATION
+  template <typename TAdaptedString>
+  const char* findString(const TAdaptedString& str) const {
+    size_t n = str.size();
+    for (char* next = _begin; next + n < _left; ++next) {
+      if (next[n] == '\0' && stringEquals(str, adaptString(next, n)))
+        return next;
+
+      // jump to next terminator
+      while (*next)
+        ++next;
+    }
+    return 0;
+  }
+#endif
+
+  char* allocString(size_t n) {
+    if (!canAlloc(n)) {
+      _overflowed = true;
+      return 0;
+    }
+    char* s = _left;
+    _left += n;
+    checkInvariants();
+    return s;
+  }
+
+  template <typename T>
+  T* allocRight() {
+    return reinterpret_cast<T*>(allocRight(sizeof(T)));
+  }
+
+  void* allocRight(size_t bytes) {
+    if (!canAlloc(bytes)) {
+      _overflowed = true;
+      return 0;
+    }
+    _right -= bytes;
+    return _right;
+  }
+
+  char *_begin, *_left, *_right, *_end;
+  bool _overflowed;
+};
+
+template <typename TAdaptedString, typename TCallback>
+bool storeString(MemoryPool* pool, TAdaptedString str,
+                 StringStoragePolicy::Copy, TCallback callback) {
+  const char* copy = pool->saveString(str);
+  JsonString storedString(copy, str.size(), JsonString::Copied);
+  callback(storedString);
+  return copy != 0;
+}
+
+template <typename TAdaptedString, typename TCallback>
+bool storeString(MemoryPool*, TAdaptedString str, StringStoragePolicy::Link,
+                 TCallback callback) {
+  JsonString storedString(str.data(), str.size(), JsonString::Linked);
+  callback(storedString);
+  return !str.isNull();
+}
+
+template <typename TAdaptedString, typename TCallback>
+bool storeString(MemoryPool* pool, TAdaptedString str,
+                 StringStoragePolicy::LinkOrCopy policy, TCallback callback) {
+  if (policy.link)
+    return storeString(pool, str, StringStoragePolicy::Link(), callback);
+  else
+    return storeString(pool, str, StringStoragePolicy::Copy(), callback);
+}
+
+template <typename TAdaptedString, typename TCallback>
+bool storeString(MemoryPool* pool, TAdaptedString str, TCallback callback) {
+  return storeString(pool, str, str.storagePolicy(), callback);
+}
+
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Misc/SafeBoolIdiom.hpp

@@ -0,0 +1,26 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Polyfills/type_traits.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+template <typename T>
+class SafeBoolIdom {
+ protected:
+  typedef void (T::*bool_type)() const;
+  void safeBoolHelper() const {}
+
+  static bool_type safe_true() {
+    return &SafeBoolIdom::safeBoolHelper;
+  }
+
+  static bool_type safe_false() {
+    return 0;
+  }
+};
+
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Misc/SerializedValue.hpp

@@ -0,0 +1,68 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Strings/StringAdapters.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+// A special type of data that can be used to insert pregenerated JSON portions.
+template <typename T>
+class SerializedValue {
+ public:
+  explicit SerializedValue(T str) : _str(str) {}
+  operator T() const {
+    return _str;
+  }
+
+  const char* data() const {
+    return _str.c_str();
+  }
+
+  size_t size() const {
+    // CAUTION: the old Arduino String doesn't have size()
+    return _str.length();
+  }
+
+ private:
+  T _str;
+};
+
+template <typename TChar>
+class SerializedValue<TChar*> {
+ public:
+  explicit SerializedValue(TChar* p, size_t n) : _data(p), _size(n) {}
+  operator TChar*() const {
+    return _data;
+  }
+
+  TChar* data() const {
+    return _data;
+  }
+
+  size_t size() const {
+    return _size;
+  }
+
+ private:
+  TChar* _data;
+  size_t _size;
+};
+
+template <typename T>
+inline SerializedValue<T> serialized(T str) {
+  return SerializedValue<T>(str);
+}
+
+template <typename TChar>
+inline SerializedValue<TChar*> serialized(TChar* p) {
+  return SerializedValue<TChar*>(p, adaptString(p).size());
+}
+
+template <typename TChar>
+inline SerializedValue<TChar*> serialized(TChar* p, size_t n) {
+  return SerializedValue<TChar*>(p, n);
+}
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/MsgPack/MsgPackDeserializer.hpp

@@ -0,0 +1,662 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Deserialization/deserialize.hpp>
+#include <ArduinoJson/Memory/MemoryPool.hpp>
+#include <ArduinoJson/MsgPack/endianess.hpp>
+#include <ArduinoJson/MsgPack/ieee754.hpp>
+#include <ArduinoJson/Polyfills/type_traits.hpp>
+#include <ArduinoJson/Variant/VariantData.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+template <typename TReader, typename TStringStorage>
+class MsgPackDeserializer {
+ public:
+  MsgPackDeserializer(MemoryPool* pool, TReader reader,
+                      TStringStorage stringStorage)
+      : _pool(pool),
+        _reader(reader),
+        _stringStorage(stringStorage),
+        _foundSomething(false) {}
+
+  template <typename TFilter>
+  DeserializationError parse(VariantData& variant, TFilter filter,
+                             NestingLimit nestingLimit) {
+    DeserializationError::Code err;
+    err = parseVariant(&variant, filter, nestingLimit);
+    return _foundSomething ? err : DeserializationError::EmptyInput;
+  }
+
+ private:
+  template <typename TFilter>
+  DeserializationError::Code parseVariant(VariantData* variant, TFilter filter,
+                                          NestingLimit nestingLimit) {
+    DeserializationError::Code err;
+
+    uint8_t code = 0;  // TODO: why do we need to initialize this variable?
+    err = readByte(code);
+    if (err)
+      return err;
+
+    _foundSomething = true;
+
+    bool allowValue = filter.allowValue();
+
+    if (allowValue) {
+      // callers pass a null pointer only when value must be ignored
+      ARDUINOJSON_ASSERT(variant != 0);
+    }
+
+    switch (code) {
+      case 0xc0:
+        // already null
+        return DeserializationError::Ok;
+
+      case 0xc1:
+        return DeserializationError::InvalidInput;
+
+      case 0xc2:
+        if (allowValue)
+          variant->setBoolean(false);
+        return DeserializationError::Ok;
+
+      case 0xc3:
+        if (allowValue)
+          variant->setBoolean(true);
+        return DeserializationError::Ok;
+
+      case 0xc4:  // bin 8 (not supported)
+        return skipString<uint8_t>();
+
+      case 0xc5:  // bin 16 (not supported)
+        return skipString<uint16_t>();
+
+      case 0xc6:  // bin 32 (not supported)
+        return skipString<uint32_t>();
+
+      case 0xc7:  // ext 8 (not supported)
+        return skipExt<uint8_t>();
+
+      case 0xc8:  // ext 16 (not supported)
+        return skipExt<uint16_t>();
+
+      case 0xc9:  // ext 32 (not supported)
+        return skipExt<uint32_t>();
+
+      case 0xca:
+        if (allowValue)
+          return readFloat<float>(variant);
+        else
+          return skipBytes(4);
+
+      case 0xcb:
+        if (allowValue)
+          return readDouble<double>(variant);
+        else
+          return skipBytes(8);
+
+      case 0xcc:
+        if (allowValue)
+          return readInteger<uint8_t>(variant);
+        else
+          return skipBytes(1);
+
+      case 0xcd:
+        if (allowValue)
+          return readInteger<uint16_t>(variant);
+        else
+          return skipBytes(2);
+
+      case 0xce:
+        if (allowValue)
+          return readInteger<uint32_t>(variant);
+        else
+          return skipBytes(4);
+
+      case 0xcf:
+#if ARDUINOJSON_USE_LONG_LONG
+        if (allowValue)
+          return readInteger<uint64_t>(variant);
+        else
+          return skipBytes(8);
+#else
+        return skipBytes(8);  // not supported
+#endif
+
+      case 0xd0:
+        if (allowValue)
+          return readInteger<int8_t>(variant);
+        else
+          return skipBytes(1);
+
+      case 0xd1:
+        if (allowValue)
+          return readInteger<int16_t>(variant);
+        else
+          return skipBytes(2);
+
+      case 0xd2:
+        if (allowValue)
+          return readInteger<int32_t>(variant);
+        else
+          return skipBytes(4);
+
+      case 0xd3:
+#if ARDUINOJSON_USE_LONG_LONG
+        if (allowValue)
+          return readInteger<int64_t>(variant);
+        else
+          return skipBytes(8);  // not supported
+#else
+        return skipBytes(8);
+#endif
+
+      case 0xd4:  // fixext 1 (not supported)
+        return skipBytes(2);
+
+      case 0xd5:  // fixext 2 (not supported)
+        return skipBytes(3);
+
+      case 0xd6:  // fixext 4 (not supported)
+        return skipBytes(5);
+
+      case 0xd7:  // fixext 8 (not supported)
+        return skipBytes(9);
+
+      case 0xd8:  // fixext 16 (not supported)
+        return skipBytes(17);
+
+      case 0xd9:
+        if (allowValue)
+          return readString<uint8_t>(variant);
+        else
+          return skipString<uint8_t>();
+
+      case 0xda:
+        if (allowValue)
+          return readString<uint16_t>(variant);
+        else
+          return skipString<uint16_t>();
+
+      case 0xdb:
+        if (allowValue)
+          return readString<uint32_t>(variant);
+        else
+          return skipString<uint32_t>();
+
+      case 0xdc:
+        return readArray<uint16_t>(variant, filter, nestingLimit);
+
+      case 0xdd:
+        return readArray<uint32_t>(variant, filter, nestingLimit);
+
+      case 0xde:
+        return readObject<uint16_t>(variant, filter, nestingLimit);
+
+      case 0xdf:
+        return readObject<uint32_t>(variant, filter, nestingLimit);
+    }
+
+    switch (code & 0xf0) {
+      case 0x80:
+        return readObject(variant, code & 0x0F, filter, nestingLimit);
+
+      case 0x90:
+        return readArray(variant, code & 0x0F, filter, nestingLimit);
+    }
+
+    if ((code & 0xe0) == 0xa0) {
+      if (allowValue)
+        return readString(variant, code & 0x1f);
+      else
+        return skipBytes(code & 0x1f);
+    }
+
+    if (allowValue)
+      variant->setInteger(static_cast<int8_t>(code));
+
+    return DeserializationError::Ok;
+  }
+
+  DeserializationError::Code readByte(uint8_t& value) {
+    int c = _reader.read();
+    if (c < 0)
+      return DeserializationError::IncompleteInput;
+    value = static_cast<uint8_t>(c);
+    return DeserializationError::Ok;
+  }
+
+  DeserializationError::Code readBytes(uint8_t* p, size_t n) {
+    if (_reader.readBytes(reinterpret_cast<char*>(p), n) == n)
+      return DeserializationError::Ok;
+    return DeserializationError::IncompleteInput;
+  }
+
+  template <typename T>
+  DeserializationError::Code readBytes(T& value) {
+    return readBytes(reinterpret_cast<uint8_t*>(&value), sizeof(value));
+  }
+
+  DeserializationError::Code skipBytes(size_t n) {
+    for (; n; --n) {
+      if (_reader.read() < 0)
+        return DeserializationError::IncompleteInput;
+    }
+    return DeserializationError::Ok;
+  }
+
+  template <typename T>
+  DeserializationError::Code readInteger(T& value) {
+    DeserializationError::Code err;
+
+    err = readBytes(value);
+    if (err)
+      return err;
+
+    fixEndianess(value);
+
+    return DeserializationError::Ok;
+  }
+
+  template <typename T>
+  DeserializationError::Code readInteger(VariantData* variant) {
+    DeserializationError::Code err;
+    T value;
+
+    err = readInteger(value);
+    if (err)
+      return err;
+
+    variant->setInteger(value);
+
+    return DeserializationError::Ok;
+  }
+
+  template <typename T>
+  typename enable_if<sizeof(T) == 4, DeserializationError::Code>::type
+  readFloat(VariantData* variant) {
+    DeserializationError::Code err;
+    T value;
+
+    err = readBytes(value);
+    if (err)
+      return err;
+
+    fixEndianess(value);
+    variant->setFloat(value);
+
+    return DeserializationError::Ok;
+  }
+
+  template <typename T>
+  typename enable_if<sizeof(T) == 8, DeserializationError::Code>::type
+  readDouble(VariantData* variant) {
+    DeserializationError::Code err;
+    T value;
+
+    err = readBytes(value);
+    if (err)
+      return err;
+
+    fixEndianess(value);
+    variant->setFloat(value);
+
+    return DeserializationError::Ok;
+  }
+
+  template <typename T>
+  typename enable_if<sizeof(T) == 4, DeserializationError::Code>::type
+  readDouble(VariantData* variant) {
+    DeserializationError::Code err;
+    uint8_t i[8];  // input is 8 bytes
+    T value;       // output is 4 bytes
+    uint8_t* o = reinterpret_cast<uint8_t*>(&value);
+
+    err = readBytes(i, 8);
+    if (err)
+      return err;
+
+    doubleToFloat(i, o);
+    fixEndianess(value);
+    variant->setFloat(value);
+
+    return DeserializationError::Ok;
+  }
+
+  template <typename T>
+  DeserializationError::Code readString(VariantData* variant) {
+    DeserializationError::Code err;
+    T size;
+
+    err = readInteger(size);
+    if (err)
+      return err;
+
+    return readString(variant, size);
+  }
+
+  template <typename T>
+  DeserializationError::Code readString() {
+    DeserializationError::Code err;
+    T size;
+
+    err = readInteger(size);
+    if (err)
+      return err;
+
+    return readString(size);
+  }
+
+  template <typename T>
+  DeserializationError::Code skipString() {
+    DeserializationError::Code err;
+    T size;
+
+    err = readInteger(size);
+    if (err)
+      return err;
+
+    return skipBytes(size);
+  }
+
+  DeserializationError::Code readString(VariantData* variant, size_t n) {
+    DeserializationError::Code err;
+
+    err = readString(n);
+    if (err)
+      return err;
+
+    variant->setString(_stringStorage.save());
+    return DeserializationError::Ok;
+  }
+
+  DeserializationError::Code readString(size_t n) {
+    DeserializationError::Code err;
+
+    _stringStorage.startString();
+    for (; n; --n) {
+      uint8_t c;
+
+      err = readBytes(c);
+      if (err)
+        return err;
+
+      _stringStorage.append(static_cast<char>(c));
+    }
+
+    if (!_stringStorage.isValid())
+      return DeserializationError::NoMemory;
+
+    return DeserializationError::Ok;
+  }
+
+  template <typename TSize, typename TFilter>
+  DeserializationError::Code readArray(VariantData* variant, TFilter filter,
+                                       NestingLimit nestingLimit) {
+    DeserializationError::Code err;
+    TSize size;
+
+    err = readInteger(size);
+    if (err)
+      return err;
+
+    return readArray(variant, size, filter, nestingLimit);
+  }
+
+  template <typename TFilter>
+  DeserializationError::Code readArray(VariantData* variant, size_t n,
+                                       TFilter filter,
+                                       NestingLimit nestingLimit) {
+    DeserializationError::Code err;
+
+    if (nestingLimit.reached())
+      return DeserializationError::TooDeep;
+
+    bool allowArray = filter.allowArray();
+
+    CollectionData* array = allowArray ? &variant->toArray() : 0;
+
+    TFilter memberFilter = filter[0U];
+
+    for (; n; --n) {
+      VariantData* value;
+
+      if (memberFilter.allow()) {
+        value = array->addElement(_pool);
+        if (!value)
+          return DeserializationError::NoMemory;
+      } else {
+        value = 0;
+      }
+
+      err = parseVariant(value, memberFilter, nestingLimit.decrement());
+      if (err)
+        return err;
+    }
+
+    return DeserializationError::Ok;
+  }
+
+  template <typename TSize, typename TFilter>
+  DeserializationError::Code readObject(VariantData* variant, TFilter filter,
+                                        NestingLimit nestingLimit) {
+    DeserializationError::Code err;
+    TSize size;
+
+    err = readInteger(size);
+    if (err)
+      return err;
+
+    return readObject(variant, size, filter, nestingLimit);
+  }
+
+  template <typename TFilter>
+  DeserializationError::Code readObject(VariantData* variant, size_t n,
+                                        TFilter filter,
+                                        NestingLimit nestingLimit) {
+    DeserializationError::Code err;
+
+    if (nestingLimit.reached())
+      return DeserializationError::TooDeep;
+
+    CollectionData* object = filter.allowObject() ? &variant->toObject() : 0;
+
+    for (; n; --n) {
+      err = readKey();
+      if (err)
+        return err;
+
+      JsonString key = _stringStorage.str();
+      TFilter memberFilter = filter[key.c_str()];
+      VariantData* member;
+
+      if (memberFilter.allow()) {
+        ARDUINOJSON_ASSERT(object);
+
+        // Save key in memory pool.
+        // This MUST be done before adding the slot.
+        key = _stringStorage.save();
+
+        VariantSlot* slot = object->addSlot(_pool);
+        if (!slot)
+          return DeserializationError::NoMemory;
+
+        slot->setKey(key);
+
+        member = slot->data();
+      } else {
+        member = 0;
+      }
+
+      err = parseVariant(member, memberFilter, nestingLimit.decrement());
+      if (err)
+        return err;
+    }
+
+    return DeserializationError::Ok;
+  }
+
+  DeserializationError::Code readKey() {
+    DeserializationError::Code err;
+    uint8_t code;
+
+    err = readByte(code);
+    if (err)
+      return err;
+
+    if ((code & 0xe0) == 0xa0)
+      return readString(code & 0x1f);
+
+    switch (code) {
+      case 0xd9:
+        return readString<uint8_t>();
+
+      case 0xda:
+        return readString<uint16_t>();
+
+      case 0xdb:
+        return readString<uint32_t>();
+
+      default:
+        return DeserializationError::InvalidInput;
+    }
+  }
+
+  template <typename T>
+  DeserializationError::Code skipExt() {
+    DeserializationError::Code err;
+    T size;
+
+    err = readInteger(size);
+    if (err)
+      return err;
+
+    return skipBytes(size + 1U);
+  }
+
+  MemoryPool* _pool;
+  TReader _reader;
+  TStringStorage _stringStorage;
+  bool _foundSomething;
+};
+
+// Parses a MessagePack input and puts the result in a JsonDocument.
+// https://arduinojson.org/v6/api/msgpack/deserializemsgpack/
+template <typename TString>
+DeserializationError deserializeMsgPack(
+    JsonDocument& doc, const TString& input,
+    NestingLimit nestingLimit = NestingLimit()) {
+  return deserialize<MsgPackDeserializer>(doc, input, nestingLimit,
+                                          AllowAllFilter());
+}
+
+// Parses a MessagePack input, filters, and puts the result in a JsonDocument.
+// https://arduinojson.org/v6/api/msgpack/deserializemsgpack/
+template <typename TString>
+DeserializationError deserializeMsgPack(
+    JsonDocument& doc, const TString& input, Filter filter,
+    NestingLimit nestingLimit = NestingLimit()) {
+  return deserialize<MsgPackDeserializer>(doc, input, nestingLimit, filter);
+}
+
+// Parses a MessagePack input, filters, and puts the result in a JsonDocument.
+// https://arduinojson.org/v6/api/msgpack/deserializemsgpack/
+template <typename TString>
+DeserializationError deserializeMsgPack(JsonDocument& doc, const TString& input,
+                                        NestingLimit nestingLimit,
+                                        Filter filter) {
+  return deserialize<MsgPackDeserializer>(doc, input, nestingLimit, filter);
+}
+
+// Parses a MessagePack input and puts the result in a JsonDocument.
+// https://arduinojson.org/v6/api/msgpack/deserializemsgpack/
+template <typename TStream>
+DeserializationError deserializeMsgPack(
+    JsonDocument& doc, TStream& input,
+    NestingLimit nestingLimit = NestingLimit()) {
+  return deserialize<MsgPackDeserializer>(doc, input, nestingLimit,
+                                          AllowAllFilter());
+}
+
+// Parses a MessagePack input, filters, and puts the result in a JsonDocument.
+// https://arduinojson.org/v6/api/msgpack/deserializemsgpack/
+template <typename TStream>
+DeserializationError deserializeMsgPack(
+    JsonDocument& doc, TStream& input, Filter filter,
+    NestingLimit nestingLimit = NestingLimit()) {
+  return deserialize<MsgPackDeserializer>(doc, input, nestingLimit, filter);
+}
+
+// Parses a MessagePack input, filters, and puts the result in a JsonDocument.
+// https://arduinojson.org/v6/api/msgpack/deserializemsgpack/
+template <typename TStream>
+DeserializationError deserializeMsgPack(JsonDocument& doc, TStream& input,
+                                        NestingLimit nestingLimit,
+                                        Filter filter) {
+  return deserialize<MsgPackDeserializer>(doc, input, nestingLimit, filter);
+}
+
+// Parses a MessagePack input and puts the result in a JsonDocument.
+// https://arduinojson.org/v6/api/msgpack/deserializemsgpack/
+template <typename TChar>
+DeserializationError deserializeMsgPack(
+    JsonDocument& doc, TChar* input,
+    NestingLimit nestingLimit = NestingLimit()) {
+  return deserialize<MsgPackDeserializer>(doc, input, nestingLimit,
+                                          AllowAllFilter());
+}
+
+// Parses a MessagePack input, filters, and puts the result in a JsonDocument.
+// https://arduinojson.org/v6/api/msgpack/deserializemsgpack/
+template <typename TChar>
+DeserializationError deserializeMsgPack(
+    JsonDocument& doc, TChar* input, Filter filter,
+    NestingLimit nestingLimit = NestingLimit()) {
+  return deserialize<MsgPackDeserializer>(doc, input, nestingLimit, filter);
+}
+
+// Parses a MessagePack input, filters, and puts the result in a JsonDocument.
+// https://arduinojson.org/v6/api/msgpack/deserializemsgpack/
+template <typename TChar>
+DeserializationError deserializeMsgPack(JsonDocument& doc, TChar* input,
+                                        NestingLimit nestingLimit,
+                                        Filter filter) {
+  return deserialize<MsgPackDeserializer>(doc, input, nestingLimit, filter);
+}
+
+// Parses a MessagePack input and puts the result in a JsonDocument.
+// https://arduinojson.org/v6/api/msgpack/deserializemsgpack/
+template <typename TChar>
+DeserializationError deserializeMsgPack(
+    JsonDocument& doc, TChar* input, size_t inputSize,
+    NestingLimit nestingLimit = NestingLimit()) {
+  return deserialize<MsgPackDeserializer>(doc, input, inputSize, nestingLimit,
+                                          AllowAllFilter());
+}
+
+// Parses a MessagePack input, filters, and puts the result in a JsonDocument.
+// https://arduinojson.org/v6/api/msgpack/deserializemsgpack/
+template <typename TChar>
+DeserializationError deserializeMsgPack(
+    JsonDocument& doc, TChar* input, size_t inputSize, Filter filter,
+    NestingLimit nestingLimit = NestingLimit()) {
+  return deserialize<MsgPackDeserializer>(doc, input, inputSize, nestingLimit,
+                                          filter);
+}
+
+// Parses a MessagePack input, filters, and puts the result in a JsonDocument.
+// https://arduinojson.org/v6/api/msgpack/deserializemsgpack/
+template <typename TChar>
+DeserializationError deserializeMsgPack(JsonDocument& doc, TChar* input,
+                                        size_t inputSize,
+                                        NestingLimit nestingLimit,
+                                        Filter filter) {
+  return deserialize<MsgPackDeserializer>(doc, input, inputSize, nestingLimit,
+                                          filter);
+}
+
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/MsgPack/MsgPackSerializer.hpp

@@ -0,0 +1,220 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/MsgPack/endianess.hpp>
+#include <ArduinoJson/Polyfills/assert.hpp>
+#include <ArduinoJson/Polyfills/type_traits.hpp>
+#include <ArduinoJson/Serialization/CountingDecorator.hpp>
+#include <ArduinoJson/Serialization/measure.hpp>
+#include <ArduinoJson/Serialization/serialize.hpp>
+#include <ArduinoJson/Variant/VariantData.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+template <typename TWriter>
+class MsgPackSerializer : public Visitor<size_t> {
+ public:
+  static const bool producesText = false;
+
+  MsgPackSerializer(TWriter writer) : _writer(writer) {}
+
+  template <typename T>
+  typename enable_if<sizeof(T) == 4, size_t>::type visitFloat(T value32) {
+    if (canConvertNumber<JsonInteger>(value32)) {
+      JsonInteger truncatedValue = JsonInteger(value32);
+      if (value32 == T(truncatedValue))
+        return visitSignedInteger(truncatedValue);
+    }
+    writeByte(0xCA);
+    writeInteger(value32);
+    return bytesWritten();
+  }
+
+  template <typename T>
+  ARDUINOJSON_NO_SANITIZE("float-cast-overflow")
+  typename enable_if<sizeof(T) == 8, size_t>::type visitFloat(T value64) {
+    float value32 = float(value64);
+    if (value32 == value64)
+      return visitFloat(value32);
+    writeByte(0xCB);
+    writeInteger(value64);
+    return bytesWritten();
+  }
+
+  size_t visitArray(const CollectionData& array) {
+    size_t n = array.size();
+    if (n < 0x10) {
+      writeByte(uint8_t(0x90 + array.size()));
+    } else if (n < 0x10000) {
+      writeByte(0xDC);
+      writeInteger(uint16_t(n));
+    } else {
+      writeByte(0xDD);
+      writeInteger(uint32_t(n));
+    }
+    for (const VariantSlot* slot = array.head(); slot; slot = slot->next()) {
+      slot->data()->accept(*this);
+    }
+    return bytesWritten();
+  }
+
+  size_t visitObject(const CollectionData& object) {
+    size_t n = object.size();
+    if (n < 0x10) {
+      writeByte(uint8_t(0x80 + n));
+    } else if (n < 0x10000) {
+      writeByte(0xDE);
+      writeInteger(uint16_t(n));
+    } else {
+      writeByte(0xDF);
+      writeInteger(uint32_t(n));
+    }
+    for (const VariantSlot* slot = object.head(); slot; slot = slot->next()) {
+      visitString(slot->key());
+      slot->data()->accept(*this);
+    }
+    return bytesWritten();
+  }
+
+  size_t visitString(const char* value) {
+    return visitString(value, strlen(value));
+  }
+
+  size_t visitString(const char* value, size_t n) {
+    ARDUINOJSON_ASSERT(value != NULL);
+
+    if (n < 0x20) {
+      writeByte(uint8_t(0xA0 + n));
+    } else if (n < 0x100) {
+      writeByte(0xD9);
+      writeInteger(uint8_t(n));
+    } else if (n < 0x10000) {
+      writeByte(0xDA);
+      writeInteger(uint16_t(n));
+    } else {
+      writeByte(0xDB);
+      writeInteger(uint32_t(n));
+    }
+    writeBytes(reinterpret_cast<const uint8_t*>(value), n);
+    return bytesWritten();
+  }
+
+  size_t visitRawJson(const char* data, size_t size) {
+    writeBytes(reinterpret_cast<const uint8_t*>(data), size);
+    return bytesWritten();
+  }
+
+  size_t visitSignedInteger(JsonInteger value) {
+    if (value > 0) {
+      visitUnsignedInteger(static_cast<JsonUInt>(value));
+    } else if (value >= -0x20) {
+      writeInteger(int8_t(value));
+    } else if (value >= -0x80) {
+      writeByte(0xD0);
+      writeInteger(int8_t(value));
+    } else if (value >= -0x8000) {
+      writeByte(0xD1);
+      writeInteger(int16_t(value));
+    }
+#if ARDUINOJSON_USE_LONG_LONG
+    else if (value >= -0x80000000LL)
+#else
+    else
+#endif
+    {
+      writeByte(0xD2);
+      writeInteger(int32_t(value));
+    }
+#if ARDUINOJSON_USE_LONG_LONG
+    else {
+      writeByte(0xD3);
+      writeInteger(int64_t(value));
+    }
+#endif
+    return bytesWritten();
+  }
+
+  size_t visitUnsignedInteger(JsonUInt value) {
+    if (value <= 0x7F) {
+      writeInteger(uint8_t(value));
+    } else if (value <= 0xFF) {
+      writeByte(0xCC);
+      writeInteger(uint8_t(value));
+    } else if (value <= 0xFFFF) {
+      writeByte(0xCD);
+      writeInteger(uint16_t(value));
+    }
+#if ARDUINOJSON_USE_LONG_LONG
+    else if (value <= 0xFFFFFFFF)
+#else
+    else
+#endif
+    {
+      writeByte(0xCE);
+      writeInteger(uint32_t(value));
+    }
+#if ARDUINOJSON_USE_LONG_LONG
+    else {
+      writeByte(0xCF);
+      writeInteger(uint64_t(value));
+    }
+#endif
+    return bytesWritten();
+  }
+
+  size_t visitBoolean(bool value) {
+    writeByte(value ? 0xC3 : 0xC2);
+    return bytesWritten();
+  }
+
+  size_t visitNull() {
+    writeByte(0xC0);
+    return bytesWritten();
+  }
+
+ private:
+  size_t bytesWritten() const {
+    return _writer.count();
+  }
+
+  void writeByte(uint8_t c) {
+    _writer.write(c);
+  }
+
+  void writeBytes(const uint8_t* p, size_t n) {
+    _writer.write(p, n);
+  }
+
+  template <typename T>
+  void writeInteger(T value) {
+    fixEndianess(value);
+    writeBytes(reinterpret_cast<uint8_t*>(&value), sizeof(value));
+  }
+
+  CountingDecorator<TWriter> _writer;
+};
+
+// Produces a MessagePack document.
+// https://arduinojson.org/v6/api/msgpack/serializemsgpack/
+template <typename TDestination>
+inline size_t serializeMsgPack(JsonVariantConst source, TDestination& output) {
+  return serialize<MsgPackSerializer>(source, output);
+}
+
+// Produces a MessagePack document.
+// https://arduinojson.org/v6/api/msgpack/serializemsgpack/
+inline size_t serializeMsgPack(JsonVariantConst source, void* output,
+                               size_t size) {
+  return serialize<MsgPackSerializer>(source, output, size);
+}
+
+// Computes the length of the document that serializeMsgPack() produces.
+// https://arduinojson.org/v6/api/msgpack/measuremsgpack/
+inline size_t measureMsgPack(JsonVariantConst source) {
+  return measure<MsgPackSerializer>(source);
+}
+
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/MsgPack/endianess.hpp

@@ -0,0 +1,46 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Polyfills/type_traits.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+#if ARDUINOJSON_LITTLE_ENDIAN
+inline void swapBytes(uint8_t& a, uint8_t& b) {
+  uint8_t t(a);
+  a = b;
+  b = t;
+}
+
+inline void fixEndianess(uint8_t* p, integral_constant<size_t, 8>) {
+  swapBytes(p[0], p[7]);
+  swapBytes(p[1], p[6]);
+  swapBytes(p[2], p[5]);
+  swapBytes(p[3], p[4]);
+}
+
+inline void fixEndianess(uint8_t* p, integral_constant<size_t, 4>) {
+  swapBytes(p[0], p[3]);
+  swapBytes(p[1], p[2]);
+}
+
+inline void fixEndianess(uint8_t* p, integral_constant<size_t, 2>) {
+  swapBytes(p[0], p[1]);
+}
+
+inline void fixEndianess(uint8_t*, integral_constant<size_t, 1>) {}
+
+template <typename T>
+inline void fixEndianess(T& value) {
+  fixEndianess(reinterpret_cast<uint8_t*>(&value),
+               integral_constant<size_t, sizeof(T)>());
+}
+#else
+template <typename T>
+inline void fixEndianess(T&) {}
+#endif
+
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/MsgPack/ieee754.hpp

@@ -0,0 +1,18 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+inline void doubleToFloat(const uint8_t d[8], uint8_t f[4]) {
+  f[0] = uint8_t((d[0] & 0xC0) | (d[0] << 3 & 0x3f) | (d[1] >> 5));
+  f[1] = uint8_t((d[1] << 3) | (d[2] >> 5));
+  f[2] = uint8_t((d[2] << 3) | (d[3] >> 5));
+  f[3] = uint8_t((d[3] << 3) | (d[4] >> 5));
+}
+
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Namespace.hpp

@@ -0,0 +1,26 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Configuration.hpp>
+#include <ArduinoJson/Polyfills/preprocessor.hpp>
+#include <ArduinoJson/version.hpp>
+
+#ifndef ARDUINOJSON_NAMESPACE
+
+#  define ARDUINOJSON_NAMESPACE                                               \
+    ARDUINOJSON_CONCAT4(                                                      \
+        ARDUINOJSON_CONCAT4(ArduinoJson, ARDUINOJSON_VERSION_MAJOR,           \
+                            ARDUINOJSON_VERSION_MINOR,                        \
+                            ARDUINOJSON_VERSION_REVISION),                    \
+        _,                                                                    \
+        ARDUINOJSON_HEX_DIGIT(                                                \
+            ARDUINOJSON_ENABLE_PROGMEM, ARDUINOJSON_USE_LONG_LONG,            \
+            ARDUINOJSON_USE_DOUBLE, ARDUINOJSON_ENABLE_STRING_DEDUPLICATION), \
+        ARDUINOJSON_HEX_DIGIT(                                                \
+            ARDUINOJSON_ENABLE_NAN, ARDUINOJSON_ENABLE_INFINITY,              \
+            ARDUINOJSON_ENABLE_COMMENTS, ARDUINOJSON_DECODE_UNICODE))
+
+#endif

lib/ArduinoJson/src/ArduinoJson/Numbers/FloatParts.hpp

@@ -0,0 +1,87 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Configuration.hpp>
+#include <ArduinoJson/Numbers/FloatTraits.hpp>
+#include <ArduinoJson/Polyfills/math.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+template <typename TFloat>
+struct FloatParts {
+  uint32_t integral;
+  uint32_t decimal;
+  int16_t exponent;
+  int8_t decimalPlaces;
+
+  FloatParts(TFloat value) {
+    uint32_t maxDecimalPart = sizeof(TFloat) >= 8 ? 1000000000 : 1000000;
+    decimalPlaces = sizeof(TFloat) >= 8 ? 9 : 6;
+
+    exponent = normalize(value);
+
+    integral = uint32_t(value);
+    // reduce number of decimal places by the number of integral places
+    for (uint32_t tmp = integral; tmp >= 10; tmp /= 10) {
+      maxDecimalPart /= 10;
+      decimalPlaces--;
+    }
+
+    TFloat remainder = (value - TFloat(integral)) * TFloat(maxDecimalPart);
+
+    decimal = uint32_t(remainder);
+    remainder = remainder - TFloat(decimal);
+
+    // rounding:
+    // increment by 1 if remainder >= 0.5
+    decimal += uint32_t(remainder * 2);
+    if (decimal >= maxDecimalPart) {
+      decimal = 0;
+      integral++;
+      if (exponent && integral >= 10) {
+        exponent++;
+        integral = 1;
+      }
+    }
+
+    // remove trailing zeros
+    while (decimal % 10 == 0 && decimalPlaces > 0) {
+      decimal /= 10;
+      decimalPlaces--;
+    }
+  }
+
+  static int16_t normalize(TFloat& value) {
+    typedef FloatTraits<TFloat> traits;
+    int16_t powersOf10 = 0;
+
+    int8_t index = sizeof(TFloat) == 8 ? 8 : 5;
+    int bit = 1 << index;
+
+    if (value >= ARDUINOJSON_POSITIVE_EXPONENTIATION_THRESHOLD) {
+      for (; index >= 0; index--) {
+        if (value >= traits::positiveBinaryPowerOfTen(index)) {
+          value *= traits::negativeBinaryPowerOfTen(index);
+          powersOf10 = int16_t(powersOf10 + bit);
+        }
+        bit >>= 1;
+      }
+    }
+
+    if (value > 0 && value <= ARDUINOJSON_NEGATIVE_EXPONENTIATION_THRESHOLD) {
+      for (; index >= 0; index--) {
+        if (value < traits::negativeBinaryPowerOfTenPlusOne(index)) {
+          value *= traits::positiveBinaryPowerOfTen(index);
+          powersOf10 = int16_t(powersOf10 - bit);
+        }
+        bit >>= 1;
+      }
+    }
+
+    return powersOf10;
+  }
+};
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Numbers/FloatTraits.hpp

@@ -0,0 +1,265 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <stddef.h>  // for size_t
+#include <stdint.h>
+
+#include <ArduinoJson/Configuration.hpp>
+#include <ArduinoJson/Polyfills/alias_cast.hpp>
+#include <ArduinoJson/Polyfills/math.hpp>
+#include <ArduinoJson/Polyfills/pgmspace_generic.hpp>
+#include <ArduinoJson/Polyfills/preprocessor.hpp>
+#include <ArduinoJson/Polyfills/type_traits.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+template <typename T, size_t = sizeof(T)>
+struct FloatTraits {};
+
+template <typename T>
+struct FloatTraits<T, 8 /*64bits*/> {
+  typedef uint64_t mantissa_type;
+  static const short mantissa_bits = 52;
+  static const mantissa_type mantissa_max =
+      (mantissa_type(1) << mantissa_bits) - 1;
+
+  typedef int16_t exponent_type;
+  static const exponent_type exponent_max = 308;
+
+  template <typename TExponent>
+  static T make_float(T m, TExponent e) {
+    if (e > 0) {
+      for (uint8_t index = 0; e != 0; index++) {
+        if (e & 1)
+          m *= positiveBinaryPowerOfTen(index);
+        e >>= 1;
+      }
+    } else {
+      e = TExponent(-e);
+      for (uint8_t index = 0; e != 0; index++) {
+        if (e & 1)
+          m *= negativeBinaryPowerOfTen(index);
+        e >>= 1;
+      }
+    }
+    return m;
+  }
+
+  static T positiveBinaryPowerOfTen(int index) {
+    ARDUINOJSON_DEFINE_PROGMEM_ARRAY(  //
+        uint32_t, factors,
+        ARDUINOJSON_EXPAND18({
+            0x40240000, 0x00000000,  // 1e1
+            0x40590000, 0x00000000,  // 1e2
+            0x40C38800, 0x00000000,  // 1e4
+            0x4197D784, 0x00000000,  // 1e8
+            0x4341C379, 0x37E08000,  // 1e16
+            0x4693B8B5, 0xB5056E17,  // 1e32
+            0x4D384F03, 0xE93FF9F5,  // 1e64
+            0x5A827748, 0xF9301D32,  // 1e128
+            0x75154FDD, 0x7F73BF3C   // 1e256
+        }));
+    return forge(pgm_read(factors + 2 * index),
+                 pgm_read(factors + 2 * index + 1));
+  }
+
+  static T negativeBinaryPowerOfTen(int index) {
+    ARDUINOJSON_DEFINE_PROGMEM_ARRAY(  //
+        uint32_t, factors,
+        ARDUINOJSON_EXPAND18({
+            0x3FB99999, 0x9999999A,  // 1e-1
+            0x3F847AE1, 0x47AE147B,  // 1e-2
+            0x3F1A36E2, 0xEB1C432D,  // 1e-4
+            0x3E45798E, 0xE2308C3A,  // 1e-8
+            0x3C9CD2B2, 0x97D889BC,  // 1e-16
+            0x3949F623, 0xD5A8A733,  // 1e-32
+            0x32A50FFD, 0x44F4A73D,  // 1e-64
+            0x255BBA08, 0xCF8C979D,  // 1e-128
+            0x0AC80628, 0x64AC6F43   // 1e-256
+        }));
+    return forge(pgm_read(factors + 2 * index),
+                 pgm_read(factors + 2 * index + 1));
+  }
+
+  static T negativeBinaryPowerOfTenPlusOne(int index) {
+    ARDUINOJSON_DEFINE_PROGMEM_ARRAY(  //
+        uint32_t, factors,
+        ARDUINOJSON_EXPAND18({
+            0x3FF00000, 0x00000000,  // 1e0
+            0x3FB99999, 0x9999999A,  // 1e-1
+            0x3F50624D, 0xD2F1A9FC,  // 1e-3
+            0x3E7AD7F2, 0x9ABCAF48,  // 1e-7
+            0x3CD203AF, 0x9EE75616,  // 1e-15
+            0x398039D6, 0x65896880,  // 1e-31
+            0x32DA53FC, 0x9631D10D,  // 1e-63
+            0x25915445, 0x81B7DEC2,  // 1e-127
+            0x0AFE07B2, 0x7DD78B14   // 1e-255
+        }));
+    return forge(pgm_read(factors + 2 * index),
+                 pgm_read(factors + 2 * index + 1));
+  }
+
+  static T nan() {
+    return forge(0x7ff80000, 0x00000000);
+  }
+
+  static T inf() {
+    return forge(0x7ff00000, 0x00000000);
+  }
+
+  static T highest() {
+    return forge(0x7FEFFFFF, 0xFFFFFFFF);
+  }
+
+  template <typename TOut>  // int64_t
+  static T highest_for(
+      typename enable_if<is_integral<TOut>::value && is_signed<TOut>::value &&
+                             sizeof(TOut) == 8,
+                         signed>::type* = 0) {
+    return forge(0x43DFFFFF, 0xFFFFFFFF);  //  9.2233720368547748e+18
+  }
+
+  template <typename TOut>  // uint64_t
+  static T highest_for(
+      typename enable_if<is_integral<TOut>::value && is_unsigned<TOut>::value &&
+                             sizeof(TOut) == 8,
+                         unsigned>::type* = 0) {
+    return forge(0x43EFFFFF, 0xFFFFFFFF);  //  1.8446744073709549568e+19
+  }
+
+  static T lowest() {
+    return forge(0xFFEFFFFF, 0xFFFFFFFF);
+  }
+
+  // constructs a double floating point values from its binary representation
+  // we use this function to workaround platforms with single precision literals
+  // (for example, when -fsingle-precision-constant is passed to GCC)
+  static T forge(uint32_t msb, uint32_t lsb) {
+    return alias_cast<T>((uint64_t(msb) << 32) | lsb);
+  }
+};
+
+template <typename T>
+struct FloatTraits<T, 4 /*32bits*/> {
+  typedef uint32_t mantissa_type;
+  static const short mantissa_bits = 23;
+  static const mantissa_type mantissa_max =
+      (mantissa_type(1) << mantissa_bits) - 1;
+
+  typedef int8_t exponent_type;
+  static const exponent_type exponent_max = 38;
+
+  template <typename TExponent>
+  static T make_float(T m, TExponent e) {
+    if (e > 0) {
+      for (uint8_t index = 0; e != 0; index++) {
+        if (e & 1)
+          m *= positiveBinaryPowerOfTen(index);
+        e >>= 1;
+      }
+    } else {
+      e = -e;
+      for (uint8_t index = 0; e != 0; index++) {
+        if (e & 1)
+          m *= negativeBinaryPowerOfTen(index);
+        e >>= 1;
+      }
+    }
+    return m;
+  }
+
+  static T positiveBinaryPowerOfTen(int index) {
+    ARDUINOJSON_DEFINE_PROGMEM_ARRAY(uint32_t, factors,
+                                     ARDUINOJSON_EXPAND6({
+                                         0x41200000,  // 1e1f
+                                         0x42c80000,  // 1e2f
+                                         0x461c4000,  // 1e4f
+                                         0x4cbebc20,  // 1e8f
+                                         0x5a0e1bca,  // 1e16f
+                                         0x749dc5ae   // 1e32f
+                                     }));
+    return forge(pgm_read(factors + index));
+  }
+
+  static T negativeBinaryPowerOfTen(int index) {
+    ARDUINOJSON_DEFINE_PROGMEM_ARRAY(uint32_t, factors,
+                                     ARDUINOJSON_EXPAND6({
+                                         0x3dcccccd,  // 1e-1f
+                                         0x3c23d70a,  // 1e-2f
+                                         0x38d1b717,  // 1e-4f
+                                         0x322bcc77,  // 1e-8f
+                                         0x24e69595,  // 1e-16f
+                                         0x0a4fb11f   // 1e-32f
+                                     }));
+    return forge(pgm_read(factors + index));
+  }
+
+  static T negativeBinaryPowerOfTenPlusOne(int index) {
+    ARDUINOJSON_DEFINE_PROGMEM_ARRAY(uint32_t, factors,
+                                     ARDUINOJSON_EXPAND6({
+                                         0x3f800000,  // 1e0f
+                                         0x3dcccccd,  // 1e-1f
+                                         0x3a83126f,  // 1e-3f
+                                         0x33d6bf95,  // 1e-7f
+                                         0x26901d7d,  // 1e-15f
+                                         0x0c01ceb3   // 1e-31f
+                                     }));
+    return forge(pgm_read(factors + index));
+  }
+
+  static T forge(uint32_t bits) {
+    return alias_cast<T>(bits);
+  }
+
+  static T nan() {
+    return forge(0x7fc00000);
+  }
+
+  static T inf() {
+    return forge(0x7f800000);
+  }
+
+  static T highest() {
+    return forge(0x7f7fffff);
+  }
+
+  template <typename TOut>  // int32_t
+  static T highest_for(
+      typename enable_if<is_integral<TOut>::value && is_signed<TOut>::value &&
+                             sizeof(TOut) == 4,
+                         signed>::type* = 0) {
+    return forge(0x4EFFFFFF);  // 2.14748352E9
+  }
+
+  template <typename TOut>  // uint32_t
+  static T highest_for(
+      typename enable_if<is_integral<TOut>::value && is_unsigned<TOut>::value &&
+                             sizeof(TOut) == 4,
+                         unsigned>::type* = 0) {
+    return forge(0x4F7FFFFF);  // 4.29496704E9
+  }
+
+  template <typename TOut>  // int64_t
+  static T highest_for(
+      typename enable_if<is_integral<TOut>::value && is_signed<TOut>::value &&
+                             sizeof(TOut) == 8,
+                         signed>::type* = 0) {
+    return forge(0x5EFFFFFF);  // 9.22337148709896192E18
+  }
+
+  template <typename TOut>  // uint64_t
+  static T highest_for(
+      typename enable_if<is_integral<TOut>::value && is_unsigned<TOut>::value &&
+                             sizeof(TOut) == 8,
+                         unsigned>::type* = 0) {
+    return forge(0x5F7FFFFF);  // 1.844674297419792384E19
+  }
+
+  static T lowest() {
+    return forge(0xFf7fffff);
+  }
+};
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Numbers/JsonFloat.hpp

@@ -0,0 +1,17 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Configuration.hpp>
+#include <ArduinoJson/Namespace.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+#if ARDUINOJSON_USE_DOUBLE
+typedef double JsonFloat;
+#else
+typedef float JsonFloat;
+#endif
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Numbers/JsonInteger.hpp

@@ -0,0 +1,32 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Configuration.hpp>
+#include <ArduinoJson/Namespace.hpp>
+
+#include <stdint.h>  // int64_t
+
+namespace ARDUINOJSON_NAMESPACE {
+
+#if ARDUINOJSON_USE_LONG_LONG
+typedef int64_t JsonInteger;
+typedef uint64_t JsonUInt;
+#else
+typedef long JsonInteger;
+typedef unsigned long JsonUInt;
+#endif
+
+}  // namespace ARDUINOJSON_NAMESPACE
+
+#if ARDUINOJSON_HAS_LONG_LONG && !ARDUINOJSON_USE_LONG_LONG
+#  define ARDUINOJSON_ASSERT_INTEGER_TYPE_IS_SUPPORTED(T)                  \
+    static_assert(sizeof(T) <= sizeof(ARDUINOJSON_NAMESPACE::JsonInteger), \
+                  "To use 64-bit integers with ArduinoJson, you must set " \
+                  "ARDUINOJSON_USE_LONG_LONG to 1. See "                   \
+                  "https://arduinojson.org/v6/api/config/use_long_long/");
+#else
+#  define ARDUINOJSON_ASSERT_INTEGER_TYPE_IS_SUPPORTED(T)
+#endif

lib/ArduinoJson/src/ArduinoJson/Numbers/arithmeticCompare.hpp

@@ -0,0 +1,123 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Numbers/JsonInteger.hpp>
+#include <ArduinoJson/Polyfills/type_traits.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+enum CompareResult {
+  COMPARE_RESULT_DIFFER = 0,
+  COMPARE_RESULT_EQUAL = 1,
+  COMPARE_RESULT_GREATER = 2,
+  COMPARE_RESULT_LESS = 4,
+
+  COMPARE_RESULT_GREATER_OR_EQUAL = 3,
+  COMPARE_RESULT_LESS_OR_EQUAL = 5
+};
+
+template <typename T>
+CompareResult arithmeticCompare(const T& lhs, const T& rhs) {
+  if (lhs < rhs)
+    return COMPARE_RESULT_LESS;
+  else if (lhs > rhs)
+    return COMPARE_RESULT_GREATER;
+  else
+    return COMPARE_RESULT_EQUAL;
+}
+
+template <typename T1, typename T2>
+CompareResult arithmeticCompare(
+    const T1& lhs, const T2& rhs,
+    typename enable_if<is_integral<T1>::value && is_integral<T2>::value &&
+                           sizeof(T1) < sizeof(T2),
+                       int  // Using int instead of void to avoid C2572 on
+                            // Visual Studio 2012, 2013, and 2015
+                       >::type* = 0) {
+  return arithmeticCompare<T2>(static_cast<T2>(lhs), rhs);
+}
+
+template <typename T1, typename T2>
+CompareResult arithmeticCompare(
+    const T1& lhs, const T2& rhs,
+    typename enable_if<is_integral<T1>::value && is_integral<T2>::value &&
+                       sizeof(T2) < sizeof(T1)>::type* = 0) {
+  return arithmeticCompare<T1>(lhs, static_cast<T1>(rhs));
+}
+
+template <typename T1, typename T2>
+CompareResult arithmeticCompare(
+    const T1& lhs, const T2& rhs,
+    typename enable_if<is_integral<T1>::value && is_integral<T2>::value &&
+                       is_signed<T1>::value == is_signed<T2>::value &&
+                       sizeof(T2) == sizeof(T1)>::type* = 0) {
+  return arithmeticCompare<T1>(lhs, static_cast<T1>(rhs));
+}
+
+template <typename T1, typename T2>
+CompareResult arithmeticCompare(
+    const T1& lhs, const T2& rhs,
+    typename enable_if<is_integral<T1>::value && is_integral<T2>::value &&
+                       is_unsigned<T1>::value && is_signed<T2>::value &&
+                       sizeof(T2) == sizeof(T1)>::type* = 0) {
+  if (rhs < 0)
+    return COMPARE_RESULT_GREATER;
+  return arithmeticCompare<T1>(lhs, static_cast<T1>(rhs));
+}
+
+template <typename T1, typename T2>
+CompareResult arithmeticCompare(
+    const T1& lhs, const T2& rhs,
+    typename enable_if<is_integral<T1>::value && is_integral<T2>::value &&
+                       is_signed<T1>::value && is_unsigned<T2>::value &&
+                       sizeof(T2) == sizeof(T1)>::type* = 0) {
+  if (lhs < 0)
+    return COMPARE_RESULT_LESS;
+  return arithmeticCompare<T2>(static_cast<T2>(lhs), rhs);
+}
+
+template <typename T1, typename T2>
+CompareResult arithmeticCompare(
+    const T1& lhs, const T2& rhs,
+    typename enable_if<is_floating_point<T1>::value ||
+                       is_floating_point<T2>::value>::type* = 0) {
+  return arithmeticCompare<double>(static_cast<double>(lhs),
+                                   static_cast<double>(rhs));
+}
+
+template <typename T2>
+CompareResult arithmeticCompareNegateLeft(
+    JsonUInt, const T2&,
+    typename enable_if<is_unsigned<T2>::value>::type* = 0) {
+  return COMPARE_RESULT_LESS;
+}
+
+template <typename T2>
+CompareResult arithmeticCompareNegateLeft(
+    JsonUInt lhs, const T2& rhs,
+    typename enable_if<is_signed<T2>::value>::type* = 0) {
+  if (rhs > 0)
+    return COMPARE_RESULT_LESS;
+  return arithmeticCompare(-rhs, static_cast<T2>(lhs));
+}
+
+template <typename T1>
+CompareResult arithmeticCompareNegateRight(
+    const T1&, JsonUInt,
+    typename enable_if<is_unsigned<T1>::value>::type* = 0) {
+  return COMPARE_RESULT_GREATER;
+}
+
+template <typename T1>
+CompareResult arithmeticCompareNegateRight(
+    const T1& lhs, JsonUInt rhs,
+    typename enable_if<is_signed<T1>::value>::type* = 0) {
+  if (lhs > 0)
+    return COMPARE_RESULT_GREATER;
+  return arithmeticCompare(static_cast<T1>(rhs), -lhs);
+}
+
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Numbers/convertNumber.hpp

@@ -0,0 +1,139 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#if defined(__clang__)
+#  pragma clang diagnostic push
+#  pragma clang diagnostic ignored "-Wconversion"
+#elif defined(__GNUC__)
+#  if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
+#    pragma GCC diagnostic push
+#  endif
+#  pragma GCC diagnostic ignored "-Wconversion"
+#endif
+
+#include <ArduinoJson/Numbers/FloatTraits.hpp>
+#include <ArduinoJson/Numbers/JsonFloat.hpp>
+#include <ArduinoJson/Polyfills/limits.hpp>
+#include <ArduinoJson/Polyfills/type_traits.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+// uint32 -> int32
+// uint64 -> int32
+template <typename TOut, typename TIn>
+typename enable_if<is_integral<TIn>::value && is_unsigned<TIn>::value &&
+                       is_integral<TOut>::value && sizeof(TOut) <= sizeof(TIn),
+                   bool>::type
+canConvertNumber(TIn value) {
+  return value <= TIn(numeric_limits<TOut>::highest());
+}
+
+// uint32 -> int64
+template <typename TOut, typename TIn>
+typename enable_if<is_integral<TIn>::value && is_unsigned<TIn>::value &&
+                       is_integral<TOut>::value && sizeof(TIn) < sizeof(TOut),
+                   bool>::type
+canConvertNumber(TIn) {
+  return true;
+}
+
+// uint32 -> float
+// int32 -> float
+template <typename TOut, typename TIn>
+typename enable_if<is_integral<TIn>::value && is_floating_point<TOut>::value,
+                   bool>::type
+canConvertNumber(TIn) {
+  return true;
+}
+
+// int64 -> int32
+template <typename TOut, typename TIn>
+typename enable_if<is_integral<TIn>::value && is_signed<TIn>::value &&
+                       is_integral<TOut>::value && is_signed<TOut>::value &&
+                       sizeof(TOut) < sizeof(TIn),
+                   bool>::type
+canConvertNumber(TIn value) {
+  return value >= TIn(numeric_limits<TOut>::lowest()) &&
+         value <= TIn(numeric_limits<TOut>::highest());
+}
+
+// int32 -> int32
+// int32 -> int64
+template <typename TOut, typename TIn>
+typename enable_if<is_integral<TIn>::value && is_signed<TIn>::value &&
+                       is_integral<TOut>::value && is_signed<TOut>::value &&
+                       sizeof(TIn) <= sizeof(TOut),
+                   bool>::type
+canConvertNumber(TIn) {
+  return true;
+}
+
+// int32 -> uint32
+// int32 -> uint64
+template <typename TOut, typename TIn>
+typename enable_if<is_integral<TIn>::value && is_signed<TIn>::value &&
+                       is_integral<TOut>::value && is_unsigned<TOut>::value &&
+                       sizeof(TOut) >= sizeof(TIn),
+                   bool>::type
+canConvertNumber(TIn value) {
+  if (value < 0)
+    return false;
+  return TOut(value) <= numeric_limits<TOut>::highest();
+}
+
+// int32 -> uint16
+template <typename TOut, typename TIn>
+typename enable_if<is_integral<TIn>::value && is_signed<TIn>::value &&
+                       is_integral<TOut>::value && is_unsigned<TOut>::value &&
+                       sizeof(TOut) < sizeof(TIn),
+                   bool>::type
+canConvertNumber(TIn value) {
+  if (value < 0)
+    return false;
+  return value <= TIn(numeric_limits<TOut>::highest());
+}
+
+// float32 -> int16
+// float64 -> int32
+template <typename TOut, typename TIn>
+typename enable_if<is_floating_point<TIn>::value && is_integral<TOut>::value &&
+                       sizeof(TOut) < sizeof(TIn),
+                   bool>::type
+canConvertNumber(TIn value) {
+  return value >= numeric_limits<TOut>::lowest() &&
+         value <= numeric_limits<TOut>::highest();
+}
+
+// float32 -> int32
+// float32 -> uint32
+// float32 -> int64
+// float32 -> uint64
+// float64 -> int64
+// float64 -> uint64
+template <typename TOut, typename TIn>
+typename enable_if<is_floating_point<TIn>::value && is_integral<TOut>::value &&
+                       sizeof(TOut) >= sizeof(TIn),
+                   bool>::type
+canConvertNumber(TIn value) {
+  // Avoid error "9.22337e+18 is outside the range of representable values of
+  // type 'long'"
+  return value >= numeric_limits<TOut>::lowest() &&
+         value <= FloatTraits<TIn>::template highest_for<TOut>();
+}
+
+template <typename TOut, typename TIn>
+TOut convertNumber(TIn value) {
+  return canConvertNumber<TOut>(value) ? TOut(value) : 0;
+}
+}  // namespace ARDUINOJSON_NAMESPACE
+
+#if defined(__clang__)
+#  pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#  if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
+#    pragma GCC diagnostic pop
+#  endif
+#endif

lib/ArduinoJson/src/ArduinoJson/Numbers/parseNumber.hpp

@@ -0,0 +1,153 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Numbers/FloatTraits.hpp>
+#include <ArduinoJson/Numbers/convertNumber.hpp>
+#include <ArduinoJson/Polyfills/assert.hpp>
+#include <ArduinoJson/Polyfills/ctype.hpp>
+#include <ArduinoJson/Polyfills/math.hpp>
+#include <ArduinoJson/Polyfills/type_traits.hpp>
+#include <ArduinoJson/Variant/Converter.hpp>
+#include <ArduinoJson/Variant/VariantData.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+template <typename A, typename B>
+struct choose_largest : conditional<(sizeof(A) > sizeof(B)), A, B> {};
+
+inline bool parseNumber(const char* s, VariantData& result) {
+  typedef FloatTraits<JsonFloat> traits;
+  typedef choose_largest<traits::mantissa_type, JsonUInt>::type mantissa_t;
+  typedef traits::exponent_type exponent_t;
+
+  ARDUINOJSON_ASSERT(s != 0);
+
+  bool is_negative = false;
+  switch (*s) {
+    case '-':
+      is_negative = true;
+      s++;
+      break;
+    case '+':
+      s++;
+      break;
+  }
+
+#if ARDUINOJSON_ENABLE_NAN
+  if (*s == 'n' || *s == 'N') {
+    result.setFloat(traits::nan());
+    return true;
+  }
+#endif
+
+#if ARDUINOJSON_ENABLE_INFINITY
+  if (*s == 'i' || *s == 'I') {
+    result.setFloat(is_negative ? -traits::inf() : traits::inf());
+    return true;
+  }
+#endif
+
+  if (!isdigit(*s) && *s != '.')
+    return false;
+
+  mantissa_t mantissa = 0;
+  exponent_t exponent_offset = 0;
+  const mantissa_t maxUint = JsonUInt(-1);
+
+  while (isdigit(*s)) {
+    uint8_t digit = uint8_t(*s - '0');
+    if (mantissa > maxUint / 10)
+      break;
+    mantissa *= 10;
+    if (mantissa > maxUint - digit)
+      break;
+    mantissa += digit;
+    s++;
+  }
+
+  if (*s == '\0') {
+    if (is_negative) {
+      const mantissa_t sintMantissaMax = mantissa_t(1)
+                                         << (sizeof(JsonInteger) * 8 - 1);
+      if (mantissa <= sintMantissaMax) {
+        result.setInteger(JsonInteger(~mantissa + 1));
+        return true;
+      }
+    } else {
+      result.setInteger(JsonUInt(mantissa));
+      return true;
+    }
+  }
+
+  // avoid mantissa overflow
+  while (mantissa > traits::mantissa_max) {
+    mantissa /= 10;
+    exponent_offset++;
+  }
+
+  // remaing digits can't fit in the mantissa
+  while (isdigit(*s)) {
+    exponent_offset++;
+    s++;
+  }
+
+  if (*s == '.') {
+    s++;
+    while (isdigit(*s)) {
+      if (mantissa < traits::mantissa_max / 10) {
+        mantissa = mantissa * 10 + uint8_t(*s - '0');
+        exponent_offset--;
+      }
+      s++;
+    }
+  }
+
+  int exponent = 0;
+  if (*s == 'e' || *s == 'E') {
+    s++;
+    bool negative_exponent = false;
+    if (*s == '-') {
+      negative_exponent = true;
+      s++;
+    } else if (*s == '+') {
+      s++;
+    }
+
+    while (isdigit(*s)) {
+      exponent = exponent * 10 + (*s - '0');
+      if (exponent + exponent_offset > traits::exponent_max) {
+        if (negative_exponent)
+          result.setFloat(is_negative ? -0.0f : 0.0f);
+        else
+          result.setFloat(is_negative ? -traits::inf() : traits::inf());
+        return true;
+      }
+      s++;
+    }
+    if (negative_exponent)
+      exponent = -exponent;
+  }
+  exponent += exponent_offset;
+
+  // we should be at the end of the string, otherwise it's an error
+  if (*s != '\0')
+    return false;
+
+  JsonFloat final_result =
+      traits::make_float(static_cast<JsonFloat>(mantissa), exponent);
+
+  result.setFloat(is_negative ? -final_result : final_result);
+  return true;
+}
+
+template <typename T>
+inline T parseNumber(const char* s) {
+  VariantData value;
+  value.init();  // VariantData is a POD, so it has no constructor
+  parseNumber(s, value);
+  return Converter<T>::fromJson(JsonVariantConst(&value));
+}
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Object/JsonObject.hpp

@@ -0,0 +1,246 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Object/JsonObjectConst.hpp>
+#include <ArduinoJson/Object/MemberProxy.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+class JsonArray;
+
+// A reference to an object in a JsonDocument.
+// https://arduinojson.org/v6/api/jsonobject/
+class JsonObject : public VariantOperators<JsonObject> {
+  friend class VariantAttorney;
+
+ public:
+  typedef JsonObjectIterator iterator;
+
+  // Creates an unbound reference.
+  FORCE_INLINE JsonObject() : _data(0), _pool(0) {}
+
+  // INTERNAL USE ONLY
+  FORCE_INLINE JsonObject(MemoryPool* buf, CollectionData* data)
+      : _data(data), _pool(buf) {}
+
+  operator JsonVariant() const {
+    void* data = _data;  // prevent warning cast-align
+    return JsonVariant(_pool, reinterpret_cast<VariantData*>(data));
+  }
+
+  operator JsonObjectConst() const {
+    return JsonObjectConst(_data);
+  }
+
+  operator JsonVariantConst() const {
+    return JsonVariantConst(collectionToVariant(_data));
+  }
+
+  // Returns true if the reference is unbound.
+  // https://arduinojson.org/v6/api/jsonobject/isnull/
+  FORCE_INLINE bool isNull() const {
+    return _data == 0;
+  }
+
+  // Returns true if the reference is bound.
+  // https://arduinojson.org/v6/api/jsonobject/isnull/
+  FORCE_INLINE operator bool() const {
+    return _data != 0;
+  }
+
+  // Returns the number of bytes occupied by the object.
+  // https://arduinojson.org/v6/api/jsonobject/memoryusage/
+  FORCE_INLINE size_t memoryUsage() const {
+    return _data ? _data->memoryUsage() : 0;
+  }
+
+  // Returns the depth (nesting level) of the object.
+  // https://arduinojson.org/v6/api/jsonobject/nesting/
+  FORCE_INLINE size_t nesting() const {
+    return variantNesting(collectionToVariant(_data));
+  }
+
+  // Returns the number of members in the object.
+  // https://arduinojson.org/v6/api/jsonobject/size/
+  FORCE_INLINE size_t size() const {
+    return _data ? _data->size() : 0;
+  }
+
+  // Returns an iterator to the first key-value pair of the object.
+  // https://arduinojson.org/v6/api/jsonobject/begin/
+  FORCE_INLINE iterator begin() const {
+    if (!_data)
+      return iterator();
+    return iterator(_pool, _data->head());
+  }
+
+  // Returns an iterator following the last key-value pair of the object.
+  // https://arduinojson.org/v6/api/jsonobject/end/
+  FORCE_INLINE iterator end() const {
+    return iterator();
+  }
+
+  // Removes all the members of the object.
+  // ⚠️ Doesn't release the memory associated with the removed members.
+  // https://arduinojson.org/v6/api/jsonobject/clear/
+  void clear() const {
+    if (!_data)
+      return;
+    _data->clear();
+  }
+
+  // Copies an object.
+  // https://arduinojson.org/v6/api/jsonobject/set/
+  FORCE_INLINE bool set(JsonObjectConst src) {
+    if (!_data || !src._data)
+      return false;
+    return _data->copyFrom(*src._data, _pool);
+  }
+
+  // Compares the content of two objects.
+  FORCE_INLINE bool operator==(JsonObject rhs) const {
+    return JsonObjectConst(_data) == JsonObjectConst(rhs._data);
+  }
+
+  // Gets or sets the member with specified key.
+  // https://arduinojson.org/v6/api/jsonobject/subscript/
+  template <typename TString>
+  FORCE_INLINE typename enable_if<IsString<TString>::value,
+                                  MemberProxy<JsonObject, TString> >::type
+  operator[](const TString& key) const {
+    return MemberProxy<JsonObject, TString>(*this, key);
+  }
+
+  // Gets or sets the member with specified key.
+  // https://arduinojson.org/v6/api/jsonobject/subscript/
+  template <typename TChar>
+  FORCE_INLINE typename enable_if<IsString<TChar*>::value,
+                                  MemberProxy<JsonObject, TChar*> >::type
+  operator[](TChar* key) const {
+    return MemberProxy<JsonObject, TChar*>(*this, key);
+  }
+
+  // Removes the member at the specified iterator.
+  // ⚠️ Doesn't release the memory associated with the removed member.
+  // https://arduinojson.org/v6/api/jsonobject/remove/
+  FORCE_INLINE void remove(iterator it) const {
+    if (!_data)
+      return;
+    _data->removeSlot(it._slot);
+  }
+
+  // Removes the member with the specified key.
+  // ⚠️ Doesn't release the memory associated with the removed member.
+  // https://arduinojson.org/v6/api/jsonobject/remove/
+  template <typename TString>
+  FORCE_INLINE void remove(const TString& key) const {
+    removeMember(adaptString(key));
+  }
+
+  // Removes the member with the specified key.
+  // ⚠️ Doesn't release the memory associated with the removed member.
+  // https://arduinojson.org/v6/api/jsonobject/remove/
+  template <typename TChar>
+  FORCE_INLINE void remove(TChar* key) const {
+    removeMember(adaptString(key));
+  }
+
+  // Returns true if the object contains the specified key.
+  // https://arduinojson.org/v6/api/jsonobject/containskey/
+  template <typename TString>
+  FORCE_INLINE typename enable_if<IsString<TString>::value, bool>::type
+  containsKey(const TString& key) const {
+    return getMember(adaptString(key)) != 0;
+  }
+
+  // Returns true if the object contains the specified key.
+  // https://arduinojson.org/v6/api/jsonobject/containskey/
+  template <typename TChar>
+  FORCE_INLINE typename enable_if<IsString<TChar*>::value, bool>::type
+  containsKey(TChar* key) const {
+    return getMember(adaptString(key)) != 0;
+  }
+
+  // Creates an array and adds it to the object.
+  // https://arduinojson.org/v6/api/jsonobject/createnestedarray/
+  template <typename TString>
+  FORCE_INLINE JsonArray createNestedArray(const TString& key) const;
+
+  // Creates an array and adds it to the object.
+  // https://arduinojson.org/v6/api/jsonobject/createnestedarray/
+  template <typename TChar>
+  FORCE_INLINE JsonArray createNestedArray(TChar* key) const;
+
+  // Creates an object and adds it to the object.
+  // https://arduinojson.org/v6/api/jsonobject/createnestedobject/
+  template <typename TString>
+  JsonObject createNestedObject(const TString& key) const {
+    return operator[](key).template to<JsonObject>();
+  }
+
+  // Creates an object and adds it to the object.
+  // https://arduinojson.org/v6/api/jsonobject/createnestedobject/
+  template <typename TChar>
+  JsonObject createNestedObject(TChar* key) const {
+    return operator[](key).template to<JsonObject>();
+  }
+
+ private:
+  MemoryPool* getPool() const {
+    return _pool;
+  }
+
+  VariantData* getData() const {
+    return collectionToVariant(_data);
+  }
+
+  VariantData* getOrCreateData() const {
+    return collectionToVariant(_data);
+  }
+
+  template <typename TAdaptedString>
+  inline VariantData* getMember(TAdaptedString key) const {
+    if (!_data)
+      return 0;
+    return _data->getMember(key);
+  }
+
+  template <typename TAdaptedString>
+  void removeMember(TAdaptedString key) const {
+    if (!_data)
+      return;
+    _data->removeMember(key);
+  }
+
+  CollectionData* _data;
+  MemoryPool* _pool;
+};
+
+template <>
+struct Converter<JsonObject> : private VariantAttorney {
+  static void toJson(JsonVariantConst src, JsonVariant dst) {
+    variantCopyFrom(getData(dst), getData(src), getPool(dst));
+  }
+
+  static JsonObject fromJson(JsonVariant src) {
+    VariantData* data = getData(src);
+    MemoryPool* pool = getPool(src);
+    return JsonObject(pool, data != 0 ? data->asObject() : 0);
+  }
+
+  static InvalidConversion<JsonVariantConst, JsonObject> fromJson(
+      JsonVariantConst);
+
+  static bool checkJson(JsonVariantConst) {
+    return false;
+  }
+
+  static bool checkJson(JsonVariant src) {
+    VariantData* data = getData(src);
+    return data && data->isObject();
+  }
+};
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Object/JsonObjectConst.hpp

@@ -0,0 +1,156 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Object/JsonObjectIterator.hpp>
+#include <ArduinoJson/Variant/VariantOperators.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+// A read-only reference to an object in a JsonDocument.
+// https://arduinojson.org/v6/api/jsonobjectconst/
+class JsonObjectConst : public VariantOperators<JsonObjectConst> {
+  friend class JsonObject;
+  friend class VariantAttorney;
+
+ public:
+  typedef JsonObjectConstIterator iterator;
+
+  // Creates an unbound reference.
+  JsonObjectConst() : _data(0) {}
+
+  // INTERNAL USE ONLY
+  JsonObjectConst(const CollectionData* data) : _data(data) {}
+
+  operator JsonVariantConst() const {
+    return JsonVariantConst(collectionToVariant(_data));
+  }
+
+  // Returns true if the reference is unbound.
+  // https://arduinojson.org/v6/api/jsonobjectconst/isnull/
+  FORCE_INLINE bool isNull() const {
+    return _data == 0;
+  }
+
+  // Returns true if the reference is bound.
+  // https://arduinojson.org/v6/api/jsonobjectconst/isnull/
+  FORCE_INLINE operator bool() const {
+    return _data != 0;
+  }
+
+  // Returns the number of bytes occupied by the object.
+  // https://arduinojson.org/v6/api/jsonobjectconst/memoryusage/
+  FORCE_INLINE size_t memoryUsage() const {
+    return _data ? _data->memoryUsage() : 0;
+  }
+
+  // Returns the depth (nesting level) of the object.
+  // https://arduinojson.org/v6/api/jsonobjectconst/nesting/
+  FORCE_INLINE size_t nesting() const {
+    return variantNesting(collectionToVariant(_data));
+  }
+
+  // Returns the number of members in the object.
+  // https://arduinojson.org/v6/api/jsonobjectconst/size/
+  FORCE_INLINE size_t size() const {
+    return _data ? _data->size() : 0;
+  }
+
+  // Returns an iterator to the first key-value pair of the object.
+  // https://arduinojson.org/v6/api/jsonobjectconst/begin/
+  FORCE_INLINE iterator begin() const {
+    if (!_data)
+      return iterator();
+    return iterator(_data->head());
+  }
+
+  // Returns an iterator following the last key-value pair of the object.
+  // https://arduinojson.org/v6/api/jsonobjectconst/end/
+  FORCE_INLINE iterator end() const {
+    return iterator();
+  }
+
+  // Returns true if the object contains the specified key.
+  // https://arduinojson.org/v6/api/jsonobjectconst/containskey/
+  template <typename TString>
+  FORCE_INLINE bool containsKey(const TString& key) const {
+    return getMember(adaptString(key)) != 0;
+  }
+
+  // Returns true if the object contains the specified key.
+  // https://arduinojson.org/v6/api/jsonobjectconst/containskey/
+  template <typename TChar>
+  FORCE_INLINE bool containsKey(TChar* key) const {
+    return getMember(adaptString(key)) != 0;
+  }
+
+  // Gets the member with specified key.
+  // https://arduinojson.org/v6/api/jsonobjectconst/subscript/
+  template <typename TString>
+  FORCE_INLINE
+      typename enable_if<IsString<TString>::value, JsonVariantConst>::type
+      operator[](const TString& key) const {
+    return JsonVariantConst(getMember(adaptString(key)));
+  }
+
+  // Gets the member with specified key.
+  // https://arduinojson.org/v6/api/jsonobjectconst/subscript/
+  template <typename TChar>
+  FORCE_INLINE
+      typename enable_if<IsString<TChar*>::value, JsonVariantConst>::type
+      operator[](TChar* key) const {
+    return JsonVariantConst(getMember(adaptString(key)));
+  }
+
+  // Compares objects.
+  FORCE_INLINE bool operator==(JsonObjectConst rhs) const {
+    if (_data == rhs._data)
+      return true;
+
+    if (!_data || !rhs._data)
+      return false;
+
+    size_t count = 0;
+    for (iterator it = begin(); it != end(); ++it) {
+      if (it->value() != rhs[it->key()])
+        return false;
+      count++;
+    }
+    return count == rhs.size();
+  }
+
+ private:
+  const VariantData* getData() const {
+    return collectionToVariant(_data);
+  }
+
+  template <typename TAdaptedString>
+  const VariantData* getMember(TAdaptedString key) const {
+    if (!_data)
+      return 0;
+    return _data->getMember(key);
+  }
+
+  const CollectionData* _data;
+};
+
+template <>
+struct Converter<JsonObjectConst> : private VariantAttorney {
+  static void toJson(JsonVariantConst src, JsonVariant dst) {
+    variantCopyFrom(getData(dst), getData(src), getPool(dst));
+  }
+
+  static JsonObjectConst fromJson(JsonVariantConst src) {
+    const VariantData* data = getData(src);
+    return data != 0 ? data->asObject() : 0;
+  }
+
+  static bool checkJson(JsonVariantConst src) {
+    const VariantData* data = getData(src);
+    return data && data->isObject();
+  }
+};
+
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Object/JsonObjectImpl.hpp

@@ -0,0 +1,81 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Array/JsonArray.hpp>
+#include <ArduinoJson/Object/JsonObject.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+template <typename TString>
+inline JsonArray JsonObject::createNestedArray(const TString& key) const {
+  return operator[](key).template to<JsonArray>();
+}
+
+template <typename TChar>
+inline JsonArray JsonObject::createNestedArray(TChar* key) const {
+  return operator[](key).template to<JsonArray>();
+}
+
+template <typename TDerived>
+template <typename TString>
+inline JsonArray VariantRefBase<TDerived>::createNestedArray(
+    const TString& key) const {
+  return operator[](key).template to<JsonArray>();
+}
+
+template <typename TDerived>
+template <typename TChar>
+inline JsonArray VariantRefBase<TDerived>::createNestedArray(TChar* key) const {
+  return operator[](key).template to<JsonArray>();
+}
+
+template <typename TDerived>
+template <typename TString>
+inline JsonObject VariantRefBase<TDerived>::createNestedObject(
+    const TString& key) const {
+  return operator[](key).template to<JsonObject>();
+}
+
+template <typename TDerived>
+template <typename TChar>
+inline JsonObject VariantRefBase<TDerived>::createNestedObject(
+    TChar* key) const {
+  return operator[](key).template to<JsonObject>();
+}
+
+template <typename TDerived>
+template <typename TString>
+inline typename enable_if<IsString<TString>::value, bool>::type
+VariantRefBase<TDerived>::containsKey(const TString& key) const {
+  return variantGetMember(VariantAttorney::getData(derived()),
+                          adaptString(key)) != 0;
+}
+
+template <typename TDerived>
+template <typename TChar>
+inline typename enable_if<IsString<TChar*>::value, bool>::type
+VariantRefBase<TDerived>::containsKey(TChar* key) const {
+  return variantGetMember(VariantAttorney::getData(derived()),
+                          adaptString(key)) != 0;
+}
+
+template <typename TDerived>
+template <typename TString>
+inline typename enable_if<IsString<TString*>::value,
+                          MemberProxy<TDerived, TString*> >::type
+VariantRefBase<TDerived>::operator[](TString* key) const {
+  return MemberProxy<TDerived, TString*>(derived(), key);
+}
+
+template <typename TDerived>
+template <typename TString>
+inline typename enable_if<IsString<TString>::value,
+                          MemberProxy<TDerived, TString> >::type
+VariantRefBase<TDerived>::operator[](const TString& key) const {
+  return MemberProxy<TDerived, TString>(derived(), key);
+}
+
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Object/JsonObjectIterator.hpp

@@ -0,0 +1,119 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Object/JsonPair.hpp>
+#include <ArduinoJson/Variant/SlotFunctions.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+class JsonPairPtr {
+ public:
+  JsonPairPtr(MemoryPool* pool, VariantSlot* slot) : _pair(pool, slot) {}
+
+  const JsonPair* operator->() const {
+    return &_pair;
+  }
+
+  const JsonPair& operator*() const {
+    return _pair;
+  }
+
+ private:
+  JsonPair _pair;
+};
+
+class JsonObjectIterator {
+  friend class JsonObject;
+
+ public:
+  JsonObjectIterator() : _slot(0) {}
+
+  explicit JsonObjectIterator(MemoryPool* pool, VariantSlot* slot)
+      : _pool(pool), _slot(slot) {}
+
+  JsonPair operator*() const {
+    return JsonPair(_pool, _slot);
+  }
+  JsonPairPtr operator->() {
+    return JsonPairPtr(_pool, _slot);
+  }
+
+  bool operator==(const JsonObjectIterator& other) const {
+    return _slot == other._slot;
+  }
+
+  bool operator!=(const JsonObjectIterator& other) const {
+    return _slot != other._slot;
+  }
+
+  JsonObjectIterator& operator++() {
+    _slot = _slot->next();
+    return *this;
+  }
+
+  JsonObjectIterator& operator+=(size_t distance) {
+    _slot = _slot->next(distance);
+    return *this;
+  }
+
+ private:
+  MemoryPool* _pool;
+  VariantSlot* _slot;
+};
+
+class JsonPairConstPtr {
+ public:
+  JsonPairConstPtr(const VariantSlot* slot) : _pair(slot) {}
+
+  const JsonPairConst* operator->() const {
+    return &_pair;
+  }
+
+  const JsonPairConst& operator*() const {
+    return _pair;
+  }
+
+ private:
+  JsonPairConst _pair;
+};
+
+class JsonObjectConstIterator {
+  friend class JsonObject;
+
+ public:
+  JsonObjectConstIterator() : _slot(0) {}
+
+  explicit JsonObjectConstIterator(const VariantSlot* slot) : _slot(slot) {}
+
+  JsonPairConst operator*() const {
+    return JsonPairConst(_slot);
+  }
+  JsonPairConstPtr operator->() {
+    return JsonPairConstPtr(_slot);
+  }
+
+  bool operator==(const JsonObjectConstIterator& other) const {
+    return _slot == other._slot;
+  }
+
+  bool operator!=(const JsonObjectConstIterator& other) const {
+    return _slot != other._slot;
+  }
+
+  JsonObjectConstIterator& operator++() {
+    _slot = _slot->next();
+    return *this;
+  }
+
+  JsonObjectConstIterator& operator+=(size_t distance) {
+    _slot = _slot->next(distance);
+    return *this;
+  }
+
+ private:
+  const VariantSlot* _slot;
+};
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Object/JsonPair.hpp

@@ -0,0 +1,67 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Strings/JsonString.hpp>
+#include <ArduinoJson/Variant/JsonVariant.hpp>
+#include <ArduinoJson/Variant/JsonVariantConst.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+// A key-value pair.
+// https://arduinojson.org/v6/api/jsonobject/begin_end/
+class JsonPair {
+ public:
+  // INTERNAL USE ONLY
+  JsonPair(MemoryPool* pool, VariantSlot* slot) {
+    if (slot) {
+      _key = JsonString(slot->key(), slot->ownsKey() ? JsonString::Copied
+                                                     : JsonString::Linked);
+      _value = JsonVariant(pool, slot->data());
+    }
+  }
+
+  // Returns the key.
+  JsonString key() const {
+    return _key;
+  }
+
+  // Returns the value.
+  JsonVariant value() const {
+    return _value;
+  }
+
+ private:
+  JsonString _key;
+  JsonVariant _value;
+};
+
+// A read-only key-value pair.
+// https://arduinojson.org/v6/api/jsonobjectconst/begin_end/
+class JsonPairConst {
+ public:
+  JsonPairConst(const VariantSlot* slot) {
+    if (slot) {
+      _key = JsonString(slot->key(), slot->ownsKey() ? JsonString::Copied
+                                                     : JsonString::Linked);
+      _value = JsonVariantConst(slot->data());
+    }
+  }
+
+  // Returns the key.
+  JsonString key() const {
+    return _key;
+  }
+
+  // Returns the value.
+  JsonVariantConst value() const {
+    return _value;
+  }
+
+ private:
+  JsonString _key;
+  JsonVariantConst _value;
+};
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Object/MemberProxy.hpp

@@ -0,0 +1,64 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Variant/VariantRefBase.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+// A proxy class to get or set a member of an object.
+// https://arduinojson.org/v6/api/jsonobject/subscript/
+template <typename TUpstream, typename TStringRef>
+class MemberProxy
+    : public VariantRefBase<MemberProxy<TUpstream, TStringRef> >,
+      public VariantOperators<MemberProxy<TUpstream, TStringRef> > {
+  friend class VariantAttorney;
+
+ public:
+  FORCE_INLINE MemberProxy(TUpstream upstream, TStringRef key)
+      : _upstream(upstream), _key(key) {}
+
+  MemberProxy(const MemberProxy& src)
+      : _upstream(src._upstream), _key(src._key) {}
+
+  FORCE_INLINE MemberProxy& operator=(const MemberProxy& src) {
+    this->set(src);
+    return *this;
+  }
+
+  template <typename T>
+  FORCE_INLINE MemberProxy& operator=(const T& src) {
+    this->set(src);
+    return *this;
+  }
+
+  template <typename T>
+  FORCE_INLINE MemberProxy& operator=(T* src) {
+    this->set(src);
+    return *this;
+  }
+
+ private:
+  FORCE_INLINE MemoryPool* getPool() const {
+    return VariantAttorney::getPool(_upstream);
+  }
+
+  FORCE_INLINE VariantData* getData() const {
+    return variantGetMember(VariantAttorney::getData(_upstream),
+                            adaptString(_key));
+  }
+
+  FORCE_INLINE VariantData* getOrCreateData() const {
+    return variantGetOrAddMember(VariantAttorney::getOrCreateData(_upstream),
+                                 adaptString(_key),
+                                 VariantAttorney::getPool(_upstream));
+  }
+
+ private:
+  TUpstream _upstream;
+  TStringRef _key;
+};
+
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Polyfills/alias_cast.hpp

@@ -0,0 +1,29 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <stdint.h>
+#include <stdlib.h>  // for size_t
+
+#include <ArduinoJson/Configuration.hpp>
+#include "math.hpp"
+
+namespace ARDUINOJSON_NAMESPACE {
+
+template <typename T, typename F>
+struct alias_cast_t {
+  union {
+    F raw;
+    T data;
+  };
+};
+
+template <typename T, typename F>
+T alias_cast(F raw_data) {
+  alias_cast_t<T, F> ac;
+  ac.raw = raw_data;
+  return ac.data;
+}
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Polyfills/assert.hpp

@@ -0,0 +1,14 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Configuration.hpp>
+
+#if ARDUINOJSON_DEBUG
+#  include <assert.h>
+#  define ARDUINOJSON_ASSERT(X) assert(X)
+#else
+#  define ARDUINOJSON_ASSERT(X) ((void)0)
+#endif

lib/ArduinoJson/src/ArduinoJson/Polyfills/attributes.hpp

@@ -0,0 +1,38 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#ifdef _MSC_VER  // Visual Studio
+
+#  define FORCE_INLINE  // __forceinline causes C4714 when returning std::string
+#  define NO_INLINE __declspec(noinline)
+
+#elif defined(__GNUC__)  // GCC or Clang
+
+#  define FORCE_INLINE __attribute__((always_inline))
+#  define NO_INLINE __attribute__((noinline))
+
+#else  // Other compilers
+
+#  define FORCE_INLINE
+#  define NO_INLINE
+
+#endif
+
+#if __cplusplus >= 201103L
+#  define NOEXCEPT noexcept
+#else
+#  define NOEXCEPT throw()
+#endif
+
+#if defined(__has_attribute)
+#  if __has_attribute(no_sanitize)
+#    define ARDUINOJSON_NO_SANITIZE(check) __attribute__((no_sanitize(check)))
+#  else
+#    define ARDUINOJSON_NO_SANITIZE(check)
+#  endif
+#else
+#  define ARDUINOJSON_NO_SANITIZE(check)
+#endif

lib/ArduinoJson/src/ArduinoJson/Polyfills/ctype.hpp

@@ -0,0 +1,20 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+#ifndef isdigit
+inline bool isdigit(char c) {
+  return '0' <= c && c <= '9';
+}
+#endif
+
+inline bool issign(char c) {
+  return '-' == c || c == '+';
+}
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Polyfills/integer.hpp

@@ -0,0 +1,30 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <stdint.h>  // int8_t, int16_t
+
+#include <ArduinoJson/Namespace.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+template <int Bits>
+struct int_t;
+
+template <>
+struct int_t<8> {
+  typedef int8_t type;
+};
+
+template <>
+struct int_t<16> {
+  typedef int16_t type;
+};
+
+template <>
+struct int_t<32> {
+  typedef int32_t type;
+};
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Polyfills/limits.hpp

@@ -0,0 +1,45 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include "type_traits.hpp"
+
+#ifdef _MSC_VER
+#  pragma warning(push)
+#  pragma warning(disable : 4310)
+#endif
+
+namespace ARDUINOJSON_NAMESPACE {
+
+// Differs from standard because we can't use the symbols "min" and "max"
+template <typename T, typename Enable = void>
+struct numeric_limits;
+
+template <typename T>
+struct numeric_limits<T, typename enable_if<is_unsigned<T>::value>::type> {
+  static T lowest() {
+    return 0;
+  }
+  static T highest() {
+    return T(-1);
+  }
+};
+
+template <typename T>
+struct numeric_limits<
+    T, typename enable_if<is_integral<T>::value && is_signed<T>::value>::type> {
+  static T lowest() {
+    return T(T(1) << (sizeof(T) * 8 - 1));
+  }
+  static T highest() {
+    return T(~lowest());
+  }
+};
+
+}  // namespace ARDUINOJSON_NAMESPACE
+
+#ifdef _MSC_VER
+#  pragma warning(pop)
+#endif

lib/ArduinoJson/src/ArduinoJson/Polyfills/math.hpp

@@ -0,0 +1,27 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+// Some libraries #define isnan() and isinf() so we need to check before
+// using this name
+
+#ifndef isnan
+template <typename T>
+bool isnan(T x) {
+  return x != x;
+}
+#endif
+
+#ifndef isinf
+template <typename T>
+bool isinf(T x) {
+  return x != 0.0 && x * 2 == x;
+}
+#endif
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Polyfills/mpl/max.hpp

@@ -0,0 +1,26 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+#include <stddef.h>  // for size_t
+
+namespace ARDUINOJSON_NAMESPACE {
+
+// A meta-function that returns the highest value
+template <size_t X, size_t Y, bool MaxIsX = (X > Y)>
+struct Max {};
+
+template <size_t X, size_t Y>
+struct Max<X, Y, true> {
+  static const size_t value = X;
+};
+
+template <size_t X, size_t Y>
+struct Max<X, Y, false> {
+  static const size_t value = Y;
+};
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Polyfills/pgmspace.hpp

@@ -0,0 +1,114 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <Arduino.h>
+
+#include <ArduinoJson/Configuration.hpp>
+#include <ArduinoJson/Namespace.hpp>
+#include <ArduinoJson/Polyfills/assert.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+// Wraps a const char* so that the our functions are picked only if the
+// originals are missing
+struct pgm_p {
+  pgm_p(const void* p) : address(reinterpret_cast<const char*>(p)) {}
+  const char* address;
+};
+}  // namespace ARDUINOJSON_NAMESPACE
+
+#ifndef strlen_P
+inline size_t strlen_P(ARDUINOJSON_NAMESPACE::pgm_p s) {
+  const char* p = s.address;
+  ARDUINOJSON_ASSERT(p != NULL);
+  while (pgm_read_byte(p))
+    p++;
+  return size_t(p - s.address);
+}
+#endif
+
+#ifndef strncmp_P
+inline int strncmp_P(const char* a, ARDUINOJSON_NAMESPACE::pgm_p b, size_t n) {
+  const char* s1 = a;
+  const char* s2 = b.address;
+  ARDUINOJSON_ASSERT(s1 != NULL);
+  ARDUINOJSON_ASSERT(s2 != NULL);
+  while (n-- > 0) {
+    char c1 = *s1++;
+    char c2 = static_cast<char>(pgm_read_byte(s2++));
+    if (c1 < c2)
+      return -1;
+    if (c1 > c2)
+      return 1;
+    if (c1 == 0 /* and c2 as well */)
+      return 0;
+  }
+  return 0;
+}
+#endif
+
+#ifndef strcmp_P
+inline int strcmp_P(const char* a, ARDUINOJSON_NAMESPACE::pgm_p b) {
+  const char* s1 = a;
+  const char* s2 = b.address;
+  ARDUINOJSON_ASSERT(s1 != NULL);
+  ARDUINOJSON_ASSERT(s2 != NULL);
+  for (;;) {
+    char c1 = *s1++;
+    char c2 = static_cast<char>(pgm_read_byte(s2++));
+    if (c1 < c2)
+      return -1;
+    if (c1 > c2)
+      return 1;
+    if (c1 == 0 /* and c2 as well */)
+      return 0;
+  }
+}
+#endif
+
+#ifndef memcmp_P
+inline int memcmp_P(const void* a, ARDUINOJSON_NAMESPACE::pgm_p b, size_t n) {
+  const uint8_t* p1 = reinterpret_cast<const uint8_t*>(a);
+  const char* p2 = b.address;
+  ARDUINOJSON_ASSERT(p1 != NULL);
+  ARDUINOJSON_ASSERT(p2 != NULL);
+  while (n-- > 0) {
+    uint8_t v1 = *p1++;
+    uint8_t v2 = pgm_read_byte(p2++);
+    if (v1 != v2)
+      return v1 - v2;
+  }
+  return 0;
+}
+#endif
+
+#ifndef memcpy_P
+inline void* memcpy_P(void* dst, ARDUINOJSON_NAMESPACE::pgm_p src, size_t n) {
+  uint8_t* d = reinterpret_cast<uint8_t*>(dst);
+  const char* s = src.address;
+  ARDUINOJSON_ASSERT(d != NULL);
+  ARDUINOJSON_ASSERT(s != NULL);
+  while (n-- > 0) {
+    *d++ = pgm_read_byte(s++);
+  }
+  return dst;
+}
+#endif
+
+#ifndef pgm_read_dword
+inline uint32_t pgm_read_dword(ARDUINOJSON_NAMESPACE::pgm_p p) {
+  uint32_t result;
+  memcpy_P(&result, p.address, 4);
+  return result;
+}
+#endif
+
+#ifndef pgm_read_ptr
+inline void* pgm_read_ptr(ARDUINOJSON_NAMESPACE::pgm_p p) {
+  void* result;
+  memcpy_P(&result, p.address, sizeof(result));
+  return result;
+}
+#endif

lib/ArduinoJson/src/ArduinoJson/Polyfills/pgmspace_generic.hpp

@@ -0,0 +1,45 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+#if ARDUINOJSON_ENABLE_PROGMEM
+#  include <ArduinoJson/Polyfills/pgmspace.hpp>
+#  include <ArduinoJson/Polyfills/type_traits.hpp>
+#endif
+
+namespace ARDUINOJSON_NAMESPACE {
+
+#if ARDUINOJSON_ENABLE_PROGMEM
+
+#  ifndef ARDUINOJSON_DEFINE_PROGMEM_ARRAY
+#    define ARDUINOJSON_DEFINE_PROGMEM_ARRAY(type, name, value) \
+      static type const name[] PROGMEM = value;
+#  endif
+
+template <typename T>
+inline const T* pgm_read(const T* const* p) {
+  return reinterpret_cast<const T*>(pgm_read_ptr(p));
+}
+
+inline uint32_t pgm_read(const uint32_t* p) {
+  return pgm_read_dword(p);
+}
+#else
+
+#  ifndef ARDUINOJSON_DEFINE_PROGMEM_ARRAY
+#    define ARDUINOJSON_DEFINE_PROGMEM_ARRAY(type, name, value) \
+      static type const name[] = value;
+#  endif
+
+template <typename T>
+inline T pgm_read(const T* p) {
+  return *p;
+}
+
+#endif
+
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Polyfills/preprocessor.hpp

@@ -0,0 +1,35 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#define ARDUINOJSON_EXPAND6(a, b, c, d, e, f) a, b, c, d, e, f
+#define ARDUINOJSON_EXPAND9(a, b, c, d, e, f, g, h, i) a, b, c, d, e, f, g, h, i
+#define ARDUINOJSON_EXPAND18(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, \
+                             q, r)                                           \
+  a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r
+
+#define ARDUINOJSON_CONCAT_(A, B) A##B
+#define ARDUINOJSON_CONCAT2(A, B) ARDUINOJSON_CONCAT_(A, B)
+#define ARDUINOJSON_CONCAT4(A, B, C, D) \
+  ARDUINOJSON_CONCAT2(ARDUINOJSON_CONCAT2(A, B), ARDUINOJSON_CONCAT2(C, D))
+
+#define ARDUINOJSON_HEX_DIGIT_0000() 0
+#define ARDUINOJSON_HEX_DIGIT_0001() 1
+#define ARDUINOJSON_HEX_DIGIT_0010() 2
+#define ARDUINOJSON_HEX_DIGIT_0011() 3
+#define ARDUINOJSON_HEX_DIGIT_0100() 4
+#define ARDUINOJSON_HEX_DIGIT_0101() 5
+#define ARDUINOJSON_HEX_DIGIT_0110() 6
+#define ARDUINOJSON_HEX_DIGIT_0111() 7
+#define ARDUINOJSON_HEX_DIGIT_1000() 8
+#define ARDUINOJSON_HEX_DIGIT_1001() 9
+#define ARDUINOJSON_HEX_DIGIT_1010() A
+#define ARDUINOJSON_HEX_DIGIT_1011() B
+#define ARDUINOJSON_HEX_DIGIT_1100() C
+#define ARDUINOJSON_HEX_DIGIT_1101() D
+#define ARDUINOJSON_HEX_DIGIT_1110() E
+#define ARDUINOJSON_HEX_DIGIT_1111() F
+#define ARDUINOJSON_HEX_DIGIT_(A, B, C, D) ARDUINOJSON_HEX_DIGIT_##A##B##C##D()
+#define ARDUINOJSON_HEX_DIGIT(A, B, C, D) ARDUINOJSON_HEX_DIGIT_(A, B, C, D)

lib/ArduinoJson/src/ArduinoJson/Polyfills/type_traits.hpp

@@ -0,0 +1,25 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include "type_traits/conditional.hpp"
+#include "type_traits/enable_if.hpp"
+#include "type_traits/integral_constant.hpp"
+#include "type_traits/is_array.hpp"
+#include "type_traits/is_base_of.hpp"
+#include "type_traits/is_class.hpp"
+#include "type_traits/is_const.hpp"
+#include "type_traits/is_convertible.hpp"
+#include "type_traits/is_enum.hpp"
+#include "type_traits/is_floating_point.hpp"
+#include "type_traits/is_integral.hpp"
+#include "type_traits/is_pointer.hpp"
+#include "type_traits/is_same.hpp"
+#include "type_traits/is_signed.hpp"
+#include "type_traits/is_unsigned.hpp"
+#include "type_traits/make_unsigned.hpp"
+#include "type_traits/make_void.hpp"
+#include "type_traits/remove_const.hpp"
+#include "type_traits/remove_reference.hpp"

lib/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/conditional.hpp

@@ -0,0 +1,20 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+template <bool Condition, class TrueType, class FalseType>
+struct conditional {
+  typedef TrueType type;
+};
+
+template <class TrueType, class FalseType>
+struct conditional<false, TrueType, FalseType> {
+  typedef FalseType type;
+};
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/declval.hpp

@@ -0,0 +1,14 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+template <typename T>
+T declval();
+
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/enable_if.hpp

@@ -0,0 +1,19 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+// A meta-function that return the type T if Condition is true.
+template <bool Condition, typename T = void>
+struct enable_if {};
+
+template <typename T>
+struct enable_if<true, T> {
+  typedef T type;
+};
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/integral_constant.hpp

@@ -0,0 +1,19 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+template <typename T, T v>
+struct integral_constant {
+  static const T value = v;
+};
+
+typedef integral_constant<bool, true> true_type;
+typedef integral_constant<bool, false> false_type;
+
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_array.hpp

@@ -0,0 +1,21 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+#include <stddef.h>  // size_t
+
+namespace ARDUINOJSON_NAMESPACE {
+
+template <typename T>
+struct is_array : false_type {};
+
+template <typename T>
+struct is_array<T[]> : true_type {};
+
+template <typename T, size_t N>
+struct is_array<T[N]> : true_type {};
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_base_of.hpp

@@ -0,0 +1,23 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+// A meta-function that returns true if Derived inherits from TBase is an
+// integral type.
+template <typename TBase, typename TDerived>
+class is_base_of {
+ protected:  // <- to avoid GCC's "all member functions in class are private"
+  static int probe(const TBase*);
+  static char probe(...);
+
+ public:
+  static const bool value =
+      sizeof(probe(reinterpret_cast<TDerived*>(0))) == sizeof(int);
+};
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_class.hpp

@@ -0,0 +1,23 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include "declval.hpp"
+
+namespace ARDUINOJSON_NAMESPACE {
+
+template <typename T>
+struct is_class {
+ protected:  // <- to avoid GCC's "all member functions in class are private"
+  template <typename U>
+  static int probe(void (U::*)(void));
+  template <typename>
+  static char probe(...);
+
+ public:
+  static const bool value = sizeof(probe<T>(0)) == sizeof(int);
+};
+
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_const.hpp

@@ -0,0 +1,17 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include "integral_constant.hpp"
+
+namespace ARDUINOJSON_NAMESPACE {
+
+// A meta-function that return the type T without the const modifier
+template <typename T>
+struct is_const : false_type {};
+
+template <typename T>
+struct is_const<const T> : true_type {};
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_convertible.hpp

@@ -0,0 +1,46 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include "declval.hpp"
+
+#ifdef _MSC_VER
+#  pragma warning(push)
+// conversion from 'T' to 'To', possible loss of data
+#  pragma warning(disable : 4244)
+#endif
+
+// clang-format off
+#ifdef __ICCARM__
+// Suppress IAR Compiler Warning[Pa093]: implicit conversion from floating point to integer
+#pragma diag_suppress=Pa093
+#endif
+// clang-format on
+
+namespace ARDUINOJSON_NAMESPACE {
+
+template <typename From, typename To>
+struct is_convertible {
+ protected:  // <- to avoid GCC's "all member functions in class are private"
+  static int probe(To);
+  static char probe(...);
+
+  static From& _from;
+
+ public:
+  static const bool value = sizeof(probe(_from)) == sizeof(int);
+};
+
+}  // namespace ARDUINOJSON_NAMESPACE
+
+#ifdef _MSC_VER
+#  pragma warning(pop)
+#endif
+
+// clang-format off
+#ifdef __ICCARM__
+#pragma diag_default=Pa093
+#endif
+// clang-format on

lib/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_enum.hpp

@@ -0,0 +1,22 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include "is_class.hpp"
+#include "is_convertible.hpp"
+#include "is_floating_point.hpp"
+#include "is_integral.hpp"
+#include "is_same.hpp"
+
+namespace ARDUINOJSON_NAMESPACE {
+
+template <typename T>
+struct is_enum {
+  static const bool value = is_convertible<T, int>::value &&
+                            !is_class<T>::value && !is_integral<T>::value &&
+                            !is_floating_point<T>::value;
+};
+
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_floating_point.hpp

@@ -0,0 +1,20 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include "integral_constant.hpp"
+#include "is_same.hpp"
+#include "remove_cv.hpp"
+
+namespace ARDUINOJSON_NAMESPACE {
+
+template <class T>
+struct is_floating_point
+    : integral_constant<
+          bool,  //
+          is_same<float, typename remove_cv<T>::type>::value ||
+              is_same<double, typename remove_cv<T>::type>::value> {};
+
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_integral.hpp

@@ -0,0 +1,37 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Configuration.hpp>
+
+#include "integral_constant.hpp"
+#include "is_same.hpp"
+#include "remove_cv.hpp"
+
+namespace ARDUINOJSON_NAMESPACE {
+
+// clang-format off
+template <typename T>
+struct is_integral : integral_constant<bool,
+    is_same<typename remove_cv<T>::type, signed char>::value ||
+    is_same<typename remove_cv<T>::type, unsigned char>::value ||
+    is_same<typename remove_cv<T>::type, signed short>::value ||
+    is_same<typename remove_cv<T>::type, unsigned short>::value ||
+    is_same<typename remove_cv<T>::type, signed int>::value ||
+    is_same<typename remove_cv<T>::type, unsigned int>::value ||
+    is_same<typename remove_cv<T>::type, signed long>::value ||
+    is_same<typename remove_cv<T>::type, unsigned long>::value ||
+#if ARDUINOJSON_HAS_LONG_LONG
+    is_same<typename remove_cv<T>::type, signed long long>::value ||
+    is_same<typename remove_cv<T>::type, unsigned long long>::value ||
+#endif
+#if ARDUINOJSON_HAS_INT64
+    is_same<typename remove_cv<T>::type, signed __int64>::value ||
+    is_same<typename remove_cv<T>::type, unsigned __int64>::value ||
+#endif
+    is_same<typename remove_cv<T>::type, char>::value ||
+    is_same<typename remove_cv<T>::type, bool>::value> {};
+// clang-format on
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_pointer.hpp

@@ -0,0 +1,16 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include "integral_constant.hpp"
+
+namespace ARDUINOJSON_NAMESPACE {
+
+template <typename T>
+struct is_pointer : false_type {};
+
+template <typename T>
+struct is_pointer<T*> : true_type {};
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_same.hpp

@@ -0,0 +1,17 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include "integral_constant.hpp"
+
+namespace ARDUINOJSON_NAMESPACE {
+
+// A meta-function that returns true if types T and U are the same.
+template <typename T, typename U>
+struct is_same : false_type {};
+
+template <typename T>
+struct is_same<T, T> : true_type {};
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_signed.hpp

@@ -0,0 +1,30 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include "integral_constant.hpp"
+#include "is_same.hpp"
+#include "remove_cv.hpp"
+
+namespace ARDUINOJSON_NAMESPACE {
+
+// clang-format off
+template <typename T>
+struct is_signed : integral_constant<bool, 
+    is_same<typename remove_cv<T>::type, char>::value ||
+    is_same<typename remove_cv<T>::type, signed char>::value ||
+    is_same<typename remove_cv<T>::type, signed short>::value ||
+    is_same<typename remove_cv<T>::type, signed int>::value ||
+    is_same<typename remove_cv<T>::type, signed long>::value ||
+#if ARDUINOJSON_HAS_LONG_LONG
+    is_same<typename remove_cv<T>::type, signed long long>::value ||
+#endif
+#if ARDUINOJSON_HAS_INT64
+    is_same<typename remove_cv<T>::type, signed __int64>::value ||
+#endif
+    is_same<typename remove_cv<T>::type, float>::value ||
+    is_same<typename remove_cv<T>::type, double>::value> {};
+// clang-format on
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_unsigned.hpp

@@ -0,0 +1,28 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include "integral_constant.hpp"
+#include "is_same.hpp"
+#include "remove_cv.hpp"
+
+namespace ARDUINOJSON_NAMESPACE {
+
+// clang-format off
+template <typename T>
+struct is_unsigned : integral_constant<bool,
+    is_same<typename remove_cv<T>::type, unsigned char>::value ||
+    is_same<typename remove_cv<T>::type, unsigned short>::value ||
+    is_same<typename remove_cv<T>::type, unsigned int>::value ||
+    is_same<typename remove_cv<T>::type, unsigned long>::value ||
+#if ARDUINOJSON_HAS_INT64
+    is_same<typename remove_cv<T>::type, unsigned __int64>::value ||
+#endif
+#if ARDUINOJSON_HAS_LONG_LONG
+    is_same<typename remove_cv<T>::type, unsigned long long>::value ||
+#endif
+    is_same<typename remove_cv<T>::type, bool>::value> {};
+// clang-format on
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/make_unsigned.hpp

@@ -0,0 +1,49 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include "type_identity.hpp"
+namespace ARDUINOJSON_NAMESPACE {
+
+template <typename T>
+struct make_unsigned;
+
+template <>
+struct make_unsigned<char> : type_identity<unsigned char> {};
+
+template <>
+struct make_unsigned<signed char> : type_identity<unsigned char> {};
+template <>
+struct make_unsigned<unsigned char> : type_identity<unsigned char> {};
+
+template <>
+struct make_unsigned<signed short> : type_identity<unsigned short> {};
+template <>
+struct make_unsigned<unsigned short> : type_identity<unsigned short> {};
+
+template <>
+struct make_unsigned<signed int> : type_identity<unsigned int> {};
+template <>
+struct make_unsigned<unsigned int> : type_identity<unsigned int> {};
+
+template <>
+struct make_unsigned<signed long> : type_identity<unsigned long> {};
+template <>
+struct make_unsigned<unsigned long> : type_identity<unsigned long> {};
+
+#if ARDUINOJSON_HAS_LONG_LONG
+template <>
+struct make_unsigned<signed long long> : type_identity<unsigned long long> {};
+template <>
+struct make_unsigned<unsigned long long> : type_identity<unsigned long long> {};
+#endif
+
+#if ARDUINOJSON_HAS_INT64
+template <>
+struct make_unsigned<signed __int64> : type_identity<unsigned __int64> {};
+template <>
+struct make_unsigned<unsigned __int64> : type_identity<unsigned __int64> {};
+#endif
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/make_void.hpp

@@ -0,0 +1,14 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+namespace ARDUINOJSON_NAMESPACE {
+
+template <class = void>
+struct make_void {
+  typedef void type;
+};
+
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/remove_const.hpp

@@ -0,0 +1,20 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+// A meta-function that return the type T without the const modifier
+template <typename T>
+struct remove_const {
+  typedef T type;
+};
+template <typename T>
+struct remove_const<const T> {
+  typedef T type;
+};
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/remove_cv.hpp

@@ -0,0 +1,27 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+template <typename T>
+struct remove_cv {
+  typedef T type;
+};
+template <typename T>
+struct remove_cv<const T> {
+  typedef T type;
+};
+template <typename T>
+struct remove_cv<volatile T> {
+  typedef T type;
+};
+template <typename T>
+struct remove_cv<const volatile T> {
+  typedef T type;
+};
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/remove_reference.hpp

@@ -0,0 +1,20 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+// A meta-function that return the type T without the reference modifier.
+template <typename T>
+struct remove_reference {
+  typedef T type;
+};
+template <typename T>
+struct remove_reference<T&> {
+  typedef T type;
+};
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/type_identity.hpp

@@ -0,0 +1,15 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include "integral_constant.hpp"
+
+namespace ARDUINOJSON_NAMESPACE {
+
+template <typename T>
+struct type_identity {
+  typedef T type;
+};
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Serialization/CountingDecorator.hpp

@@ -0,0 +1,33 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+template <typename TWriter>
+class CountingDecorator {
+ public:
+  explicit CountingDecorator(TWriter& writer) : _writer(writer), _count(0) {}
+
+  void write(uint8_t c) {
+    _count += _writer.write(c);
+  }
+
+  void write(const uint8_t* s, size_t n) {
+    _count += _writer.write(s, n);
+  }
+
+  size_t count() const {
+    return _count;
+  }
+
+ private:
+  TWriter _writer;
+  size_t _count;
+};
+
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Serialization/Writer.hpp

@@ -0,0 +1,47 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+// The default writer is a simple wrapper for Writers that are not copiable
+template <typename TDestination, typename Enable = void>
+class Writer {
+ public:
+  explicit Writer(TDestination& dest) : _dest(&dest) {}
+
+  size_t write(uint8_t c) {
+    return _dest->write(c);
+  }
+
+  size_t write(const uint8_t* s, size_t n) {
+    return _dest->write(s, n);
+  }
+
+ private:
+  TDestination* _dest;
+};
+
+}  // namespace ARDUINOJSON_NAMESPACE
+
+#include <ArduinoJson/Serialization/Writers/StaticStringWriter.hpp>
+
+#if ARDUINOJSON_ENABLE_STD_STRING
+#  include <ArduinoJson/Serialization/Writers/StdStringWriter.hpp>
+#endif
+
+#if ARDUINOJSON_ENABLE_ARDUINO_STRING
+#  include <ArduinoJson/Serialization/Writers/ArduinoStringWriter.hpp>
+#endif
+
+#if ARDUINOJSON_ENABLE_STD_STREAM
+#  include <ArduinoJson/Serialization/Writers/StdStreamWriter.hpp>
+#endif
+
+#if ARDUINOJSON_ENABLE_ARDUINO_PRINT
+#  include <ArduinoJson/Serialization/Writers/PrintWriter.hpp>
+#endif

lib/ArduinoJson/src/ArduinoJson/Serialization/Writers/ArduinoStringWriter.hpp

@@ -0,0 +1,53 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <Arduino.h>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+template <>
+class Writer< ::String, void> {
+  static const size_t bufferCapacity = ARDUINOJSON_STRING_BUFFER_SIZE;
+
+ public:
+  explicit Writer(::String& str) : _destination(&str) {
+    _size = 0;
+  }
+
+  ~Writer() {
+    flush();
+  }
+
+  size_t write(uint8_t c) {
+    if (_size + 1 >= bufferCapacity)
+      if (flush() != 0)
+        return 0;
+    _buffer[_size++] = static_cast<char>(c);
+    return 1;
+  }
+
+  size_t write(const uint8_t* s, size_t n) {
+    for (size_t i = 0; i < n; i++) {
+      write(s[i]);
+    }
+    return n;
+  }
+
+  size_t flush() {
+    ARDUINOJSON_ASSERT(_size < bufferCapacity);
+    _buffer[_size] = 0;
+    if (_destination->concat(_buffer))
+      _size = 0;
+    return _size;
+  }
+
+ private:
+  ::String* _destination;
+  char _buffer[bufferCapacity];
+  size_t _size;
+};
+
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Serialization/Writers/DummyWriter.hpp

@@ -0,0 +1,21 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+class DummyWriter {
+ public:
+  size_t write(uint8_t) {
+    return 1;
+  }
+
+  size_t write(const uint8_t*, size_t n) {
+    return n;
+  }
+};
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Serialization/Writers/PrintWriter.hpp

@@ -0,0 +1,30 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <Arduino.h>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+template <typename TDestination>
+class Writer<
+    TDestination,
+    typename enable_if<is_base_of< ::Print, TDestination>::value>::type> {
+ public:
+  explicit Writer(::Print& print) : _print(&print) {}
+
+  size_t write(uint8_t c) {
+    return _print->write(c);
+  }
+
+  size_t write(const uint8_t* s, size_t n) {
+    return _print->write(s, n);
+  }
+
+ private:
+  ::Print* _print;
+};
+
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Serialization/Writers/StaticStringWriter.hpp

@@ -0,0 +1,35 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+class StaticStringWriter {
+ public:
+  StaticStringWriter(char* buf, size_t size) : end(buf + size), p(buf) {}
+
+  size_t write(uint8_t c) {
+    if (p >= end)
+      return 0;
+    *p++ = static_cast<char>(c);
+    return 1;
+  }
+
+  size_t write(const uint8_t* s, size_t n) {
+    char* begin = p;
+    while (p < end && n > 0) {
+      *p++ = static_cast<char>(*s++);
+      n--;
+    }
+    return size_t(p - begin);
+  }
+
+ private:
+  char* end;
+  char* p;
+};
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Serialization/Writers/StdStreamWriter.hpp

@@ -0,0 +1,32 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ostream>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+template <typename TDestination>
+class Writer<
+    TDestination,
+    typename enable_if<is_base_of<std::ostream, TDestination>::value>::type> {
+ public:
+  explicit Writer(std::ostream& os) : _os(&os) {}
+
+  size_t write(uint8_t c) {
+    _os->put(static_cast<char>(c));
+    return 1;
+  }
+
+  size_t write(const uint8_t* s, size_t n) {
+    _os->write(reinterpret_cast<const char*>(s),
+               static_cast<std::streamsize>(n));
+    return n;
+  }
+
+ private:
+  std::ostream* _os;
+};
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Serialization/Writers/StdStringWriter.hpp

@@ -0,0 +1,40 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+#include <ArduinoJson/Polyfills/type_traits.hpp>
+
+#include <string>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+template <class T>
+struct is_std_string : false_type {};
+
+template <class TCharTraits, class TAllocator>
+struct is_std_string<std::basic_string<char, TCharTraits, TAllocator> >
+    : true_type {};
+
+template <typename TDestination>
+class Writer<TDestination,
+             typename enable_if<is_std_string<TDestination>::value>::type> {
+ public:
+  Writer(TDestination& str) : _str(&str) {}
+
+  size_t write(uint8_t c) {
+    _str->operator+=(static_cast<char>(c));
+    return 1;
+  }
+
+  size_t write(const uint8_t* s, size_t n) {
+    _str->append(reinterpret_cast<const char*>(s), n);
+    return n;
+  }
+
+ private:
+  TDestination* _str;
+};
+}  // namespace ARDUINOJSON_NAMESPACE

lib/ArduinoJson/src/ArduinoJson/Serialization/measure.hpp

@@ -0,0 +1,19 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2022, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Serialization/Writers/DummyWriter.hpp>
+#include <ArduinoJson/Variant/VariantFunctions.hpp>
+
+namespace ARDUINOJSON_NAMESPACE {
+
+template <template <typename> class TSerializer>
+size_t measure(JsonVariantConst source) {
+  DummyWriter dp;
+  TSerializer<DummyWriter> serializer(dp);
+  return variantAccept(VariantAttorney::getData(source), serializer);
+}
+
+}  // namespace ARDUINOJSON_NAMESPACE