diff --git a/src/json/FirebaseJson.cpp b/src/json/FirebaseJson.cpp
index 95e1a49..11d319b 100644
--- a/src/json/FirebaseJson.cpp
+++ b/src/json/FirebaseJson.cpp
@@ -1,9 +1,9 @@
 /*
- * FirebaseJson, version 3.0.8
+ * FirebaseJson, version 3.0.10
  *
  * The Easiest Arduino library to parse, create and edit JSON object using a relative path.
  *
- * Created June 14, 2023
+ * Created March 25, 2024
  *
  * Features
  * - Using path to access node element in search style e.g. json.get(result,"a/b/c")
diff --git a/src/json/FirebaseJson.h b/src/json/FirebaseJson.h
index 8c846dd..5ccd2f0 100644
--- a/src/json/FirebaseJson.h
+++ b/src/json/FirebaseJson.h
@@ -1,9 +1,9 @@
 /*
- * FirebaseJson, version 3.0.9
+ * FirebaseJson, version 3.0.10
  *
  * The Easiest Arduino library to parse, create and edit JSON object using a relative path.
  *
- * Created November 17, 2023
+ * Created March 25, 2024
  *
  * Features
  * - Using path to access node element in search style e.g. json.get(result,"a/b/c")
@@ -385,7 +385,7 @@ class FirebaseJsonData
      * This should call after parse or get function.
      */
     template <typename T>
-    auto to() -> typename MB_ENABLE_IF<is_num_int<T>::value || is_num_float<T>::value || is_bool<T>::value, T>::type
+    auto to() -> typename std::enable_if<is_num_int<T>::value || is_num_float<T>::value || is_bool<T>::value, T>::type
     {
         if (is_bool<T>::value)
             return iVal.uint32 > 0;
@@ -405,28 +405,28 @@ class FirebaseJsonData
             return iVal.int64;
         else if (is_num_uint64<T>::value)
             return iVal.uint64;
-        else if (MB_IS_SAME<T, float>::value)
+        else if (std::is_same<T, float>::value)
             return fVal.f;
-        else if (MB_IS_SAME<T, double>::value)
+        else if (std::is_same<T, double>::value)
             return fVal.d;
         else
             return 0;
     }
 
     template <typename T>
-    auto to() -> typename MB_ENABLE_IF<is_const_chars<T>::value || is_std_string<T>::value || is_arduino_string<T>::value || is_mb_string<T>::value, T>::type
+    auto to() -> typename std::enable_if<is_const_chars<T>::value || is_std_string<T>::value || is_arduino_string<T>::value || is_mb_string<T>::value, T>::type
     {
         return stringValue.c_str();
     }
 
     template <typename T>
-    auto get(T &json) -> typename MB_ENABLE_IF<MB_IS_SAME<T, FirebaseJson>::value>::type
+    auto get(T &json) -> typename std::enable_if<std::is_same<T, FirebaseJson>::value>::type
     {
         getJSON(json);
     }
 
     template <typename T>
-    auto get(T &arr) -> typename MB_ENABLE_IF<MB_IS_SAME<T, FirebaseJsonArray>::value>::type
+    auto get(T &arr) -> typename std::enable_if<std::is_same<T, FirebaseJsonArray>::value>::type
     {
         getArray(arr);
     }
@@ -517,20 +517,20 @@ class FirebaseJsonData
     void *newP(size_t len);
 
     template <typename T>
-    auto getStr(const T &val, uint32_t &addr) -> typename MB_ENABLE_IF<is_std_string<T>::value || is_arduino_string<T>::value || is_mb_string<T>::value || MB_IS_SAME<T, StringSumHelper>::value, const char *>::type
+    auto getStr(const T &val, uint32_t &addr) -> typename std::enable_if<is_std_string<T>::value || is_arduino_string<T>::value || is_mb_string<T>::value || std::is_same<T, StringSumHelper>::value, const char *>::type
     {
         addr = 0;
         return val.c_str();
     }
 
     template <typename T>
-    auto getStr(T val, uint32_t &addr) -> typename MB_ENABLE_IF<is_arduino_flash_string_helper<T>::value, const char *>::type
+    auto getStr(T val, uint32_t &addr) -> typename std::enable_if<is_arduino_flash_string_helper<T>::value, const char *>::type
     {
         return getStr(reinterpret_cast<PGM_P>(val), addr);
     }
 
     template <typename T>
-    auto getStr(T val, uint32_t &addr) -> typename MB_ENABLE_IF<is_const_chars<T>::value, const char *>::type
+    auto getStr(T val, uint32_t &addr) -> typename std::enable_if<is_const_chars<T>::value, const char *>::type
     {
         int len = strlen_P((PGM_P)val) + 1;
         char *out = (char *)newP(len);
@@ -705,7 +705,7 @@ class FirebaseJsonBase
     MB_String buf;
 
     template <typename T>
-    auto getStr(T val, uint32_t &addr) -> typename MB_ENABLE_IF<is_bool<T>::value || is_num_int<T>::value || MB_IS_SAME<T, float>::value || MB_IS_SAME<T, double>::value || MB_IS_SAME<T, long double>::value, const char *>::type
+    auto getStr(T val, uint32_t &addr) -> typename std::enable_if<is_bool<T>::value || is_num_int<T>::value || std::is_same<T, float>::value || std::is_same<T, double>::value || std::is_same<T, long double>::value, const char *>::type
     {
         MB_String t;
 
@@ -713,9 +713,9 @@ class FirebaseJsonBase
             t.appendNum(val, 0);
         else if (is_num_int<T>::value)
             t.appendNum(val, -1);
-        else if (MB_IS_SAME<T, float>::value)
+        else if (std::is_same<T, float>::value)
             t.appendNum(val, floatDigits);
-        else if (MB_IS_SAME<T, double>::value || MB_IS_SAME<T, long double>::value)
+        else if (std::is_same<T, double>::value || std::is_same<T, long double>::value)
             t.appendNum(val, doubleDigits);
 
         char *out = (char *)newP(t.length() + 1);
@@ -726,20 +726,20 @@ class FirebaseJsonBase
     }
 
     template <typename T>
-    auto getStr(const T &val, uint32_t &addr) -> typename MB_ENABLE_IF<is_std_string<T>::value || is_arduino_string<T>::value || is_mb_string<T>::value || MB_IS_SAME<T, StringSumHelper>::value, const char *>::type
+    auto getStr(const T &val, uint32_t &addr) -> typename std::enable_if<is_std_string<T>::value || is_arduino_string<T>::value || is_mb_string<T>::value || std::is_same<T, StringSumHelper>::value, const char *>::type
     {
         addr = 0;
         return val.c_str();
     }
 
     template <typename T>
-    auto getStr(T val, uint32_t &addr) -> typename MB_ENABLE_IF<is_arduino_flash_string_helper<T>::value, const char *>::type
+    auto getStr(T val, uint32_t &addr) -> typename std::enable_if<is_arduino_flash_string_helper<T>::value, const char *>::type
     {
         return getStr(reinterpret_cast<PGM_P>(val), addr);
     }
 
     template <typename T>
-    auto getStr(T val, uint32_t &addr) -> typename MB_ENABLE_IF<is_const_chars<T>::value, const char *>::type
+    auto getStr(T val, uint32_t &addr) -> typename std::enable_if<is_const_chars<T>::value, const char *>::type
     {
         int len = strlen_P((PGM_P)val) + 1;
         char *out = (char *)newP(len);
@@ -756,7 +756,7 @@ class FirebaseJsonBase
         if (!root || !ptr)
             return false;
 
-        if (MB_IS_SAME<T, char>::value)
+        if (std::is_same<T, char>::value)
         {
             char *p = prettify ? MB_JSON_Print(root) : MB_JSON_PrintUnformatted(root);
             if (p)
@@ -770,7 +770,7 @@ class FirebaseJsonBase
     }
 
     template <typename T>
-    auto toStringHandler(T &out, bool prettify) -> typename MB_ENABLE_IF<is_string<T>::value, bool>::type
+    auto toStringHandler(T &out, bool prettify) -> typename std::enable_if<is_string<T>::value, bool>::type
     {
         if (!root)
             return false;
@@ -786,7 +786,7 @@ class FirebaseJsonBase
     }
 
     template <typename T>
-    auto toStringHandler(T &out, bool prettify) -> typename MB_ENABLE_IF<MB_IS_SAME<T, MB_SERIAL_CLASS>::value, bool>::type
+    auto toStringHandler(T &out, bool prettify) -> typename std::enable_if<std::is_same<T, MB_SERIAL_CLASS>::value, bool>::type
     {
         char *p = prettify ? MB_JSON_Print(root) : MB_JSON_PrintUnformatted(root);
         if (p)
@@ -799,7 +799,7 @@ class FirebaseJsonBase
     }
 
     template <typename T>
-    auto toStringHandler(T &out, bool prettify) -> typename MB_ENABLE_IF<MB_IS_SAME<T, Stream>::value, bool>::type
+    auto toStringHandler(T &out, bool prettify) -> typename std::enable_if<std::is_same<T, Stream>::value, bool>::type
     {
         return writeStream(out, prettify);
     }
@@ -807,13 +807,13 @@ class FirebaseJsonBase
 #if defined(MB_JSON_FS_H)
 #if defined(MB_ARDUINO_PICO)
     template <typename T>
-    auto toStringHandler(T &out, bool prettify) -> typename MB_ENABLE_IF<MB_IS_SAME<T, fs::File>::value, bool>::type
+    auto toStringHandler(T &out, bool prettify) -> typename std::enable_if<std::is_same<T, fs::File>::value, bool>::type
     {
         return writeStream(out, prettify);
     }
 #else
     template <typename T>
-    auto toStringHandler(T &out, bool prettify) -> typename MB_ENABLE_IF<MB_IS_SAME<T, File>::value, bool>::type
+    auto toStringHandler(T &out, bool prettify) -> typename std::enable_if<std::is_same<T, File>::value, bool>::type
     {
         return writeStream(out, prettify);
     }
@@ -2014,7 +2014,7 @@ class FirebaseJsonArray : public FirebaseJsonBase
     bool mRemoveIdx(int index);
 
     template <typename T>
-    auto dataGetHandler(T arg, FirebaseJsonData &result, bool prettify) -> typename MB_ENABLE_IF<is_string<T>::value, bool>::type
+    auto dataGetHandler(T arg, FirebaseJsonData &result, bool prettify) -> typename std::enable_if<is_string<T>::value, bool>::type
     {
         uint32_t addr = 0;
         bool ret = mGet(root, &result, getStr(arg, addr), prettify);
@@ -2023,13 +2023,13 @@ class FirebaseJsonArray : public FirebaseJsonBase
     }
 
     template <typename T>
-    auto dataGetHandler(T arg, FirebaseJsonData &result, bool prettify) -> typename MB_ENABLE_IF<is_num_int<T>::value, bool>::type
+    auto dataGetHandler(T arg, FirebaseJsonData &result, bool prettify) -> typename std::enable_if<is_num_int<T>::value, bool>::type
     {
         return mGetIdx(&result, arg, prettify);
     }
 
     template <typename T>
-    auto dataRemoveHandler(T arg) -> typename MB_ENABLE_IF<is_string<T>::value, bool>::type
+    auto dataRemoveHandler(T arg) -> typename std::enable_if<is_string<T>::value, bool>::type
     {
         uint32_t addr = 0;
         bool ret = mRemove(getStr(arg, addr));
@@ -2038,13 +2038,13 @@ class FirebaseJsonArray : public FirebaseJsonBase
     }
 
     template <typename T>
-    auto dataRemoveHandler(T arg) -> typename MB_ENABLE_IF<is_num_int<T>::value, bool>::type
+    auto dataRemoveHandler(T arg) -> typename std::enable_if<is_num_int<T>::value, bool>::type
     {
         return mRemoveIdx(arg);
     }
 
     template <typename T>
-    auto dataAddHandler(T arg) -> typename MB_ENABLE_IF<is_bool<T>::value, FirebaseJsonArray &>::type
+    auto dataAddHandler(T arg) -> typename std::enable_if<is_bool<T>::value, FirebaseJsonArray &>::type
     {
         if (root_type != Root_Type_JSONArray)
             mClear();
@@ -2056,7 +2056,7 @@ class FirebaseJsonArray : public FirebaseJsonBase
     }
 
     template <typename T>
-    auto dataAddHandler(T arg) -> typename MB_ENABLE_IF<is_num_int<T>::value, FirebaseJsonArray &>::type
+    auto dataAddHandler(T arg) -> typename std::enable_if<is_num_int<T>::value, FirebaseJsonArray &>::type
     {
         if (root_type != Root_Type_JSONArray)
             mClear();
@@ -2068,7 +2068,7 @@ class FirebaseJsonArray : public FirebaseJsonBase
     }
 
     template <typename T>
-    auto dataAddHandler(T arg) -> typename MB_ENABLE_IF<MB_IS_SAME<T, float>::value, FirebaseJsonArray &>::type
+    auto dataAddHandler(T arg) -> typename std::enable_if<std::is_same<T, float>::value, FirebaseJsonArray &>::type
     {
         if (root_type != Root_Type_JSONArray)
             mClear();
@@ -2080,7 +2080,7 @@ class FirebaseJsonArray : public FirebaseJsonBase
     }
 
     template <typename T>
-    auto dataAddHandler(T arg) -> typename MB_ENABLE_IF<MB_IS_SAME<T, double>::value || MB_IS_SAME<T, long double>::value, FirebaseJsonArray &>::type
+    auto dataAddHandler(T arg) -> typename std::enable_if<std::is_same<T, double>::value || std::is_same<T, long double>::value, FirebaseJsonArray &>::type
     {
         if (root_type != Root_Type_JSONArray)
             mClear();
@@ -2092,7 +2092,7 @@ class FirebaseJsonArray : public FirebaseJsonBase
     }
 
     template <typename T>
-    auto dataAddHandler(T arg) -> typename MB_ENABLE_IF<is_string<T>::value, FirebaseJsonArray &>::type
+    auto dataAddHandler(T arg) -> typename std::enable_if<is_string<T>::value, FirebaseJsonArray &>::type
     {
         if (root_type != Root_Type_JSONArray)
             mClear();
@@ -2107,7 +2107,7 @@ class FirebaseJsonArray : public FirebaseJsonBase
 
 #if !defined(__AVR__)
     template <typename T1, typename T2>
-    auto dataSetHandler(T1 arg1, T2 arg2) -> typename MB_ENABLE_IF<is_string<T1>::value && MB_IS_SAME<T2, std::nullptr_t>::value>::type
+    auto dataSetHandler(T1 arg1, T2 arg2) -> typename std::enable_if<is_string<T1>::value && std::is_same<T2, std::nullptr_t>::value>::type
     {
         if (root_type != Root_Type_JSONArray)
             mClear();
@@ -2120,14 +2120,14 @@ class FirebaseJsonArray : public FirebaseJsonBase
     }
 
     template <typename T1, typename T2>
-    auto dataSetHandler(T1 arg1, T2 arg2) -> typename MB_ENABLE_IF<(is_num_int<T1>::value || is_num_float<T1>::value || is_bool<T1>::value) && MB_IS_SAME<T2, std::nullptr_t>::value>::type
+    auto dataSetHandler(T1 arg1, T2 arg2) -> typename std::enable_if<(is_num_int<T1>::value || is_num_float<T1>::value || is_bool<T1>::value) && std::is_same<T2, std::nullptr_t>::value>::type
     {
         mSetIdx(arg1, MB_JSON_CreateNull);
     }
 #endif
 
     template <typename T1, typename T2>
-    auto dataSetHandler(T1 arg1, T2 arg2) -> typename MB_ENABLE_IF<is_string<T1>::value && is_bool<T2>::value>::type
+    auto dataSetHandler(T1 arg1, T2 arg2) -> typename std::enable_if<is_string<T1>::value && is_bool<T2>::value>::type
     {
         if (root_type != Root_Type_JSONArray)
             mClear();
@@ -2140,13 +2140,13 @@ class FirebaseJsonArray : public FirebaseJsonBase
     }
 
     template <typename T1, typename T2>
-    auto dataSetHandler(T1 arg1, T2 arg2) -> typename MB_ENABLE_IF<(is_num_int<T1>::value || is_num_float<T1>::value || is_bool<T1>::value) && is_bool<T2>::value>::type
+    auto dataSetHandler(T1 arg1, T2 arg2) -> typename std::enable_if<(is_num_int<T1>::value || is_num_float<T1>::value || is_bool<T1>::value) && is_bool<T2>::value>::type
     {
         mSetIdx(arg1, MB_JSON_CreateBool(arg2));
     }
 
     template <typename T1, typename T2>
-    auto dataSetHandler(T1 arg1, T2 arg2) -> typename MB_ENABLE_IF<is_string<T1>::value && is_num_int<T2>::value>::type
+    auto dataSetHandler(T1 arg1, T2 arg2) -> typename std::enable_if<is_string<T1>::value && is_num_int<T2>::value>::type
     {
         if (root_type != Root_Type_JSONArray)
             mClear();
@@ -2159,13 +2159,13 @@ class FirebaseJsonArray : public FirebaseJsonBase
     }
 
     template <typename T1, typename T2>
-    auto dataSetHandler(T1 arg1, T2 arg2) -> typename MB_ENABLE_IF<(is_num_int<T1>::value || is_num_float<T1>::value || is_bool<T1>::value) && is_num_int<T2>::value>::type
+    auto dataSetHandler(T1 arg1, T2 arg2) -> typename std::enable_if<(is_num_int<T1>::value || is_num_float<T1>::value || is_bool<T1>::value) && is_num_int<T2>::value>::type
     {
         mSetIdx(arg1, MB_JSON_CreateRaw(num2Str(arg2, -1)));
     }
 
     template <typename T1, typename T2>
-    auto dataSetHandler(T1 arg1, T2 arg2) -> typename MB_ENABLE_IF<is_string<T1>::value && MB_IS_SAME<T2, float>::value>::type
+    auto dataSetHandler(T1 arg1, T2 arg2) -> typename std::enable_if<is_string<T1>::value && std::is_same<T2, float>::value>::type
     {
         if (root_type != Root_Type_JSONArray)
             mClear();
@@ -2178,13 +2178,13 @@ class FirebaseJsonArray : public FirebaseJsonBase
     }
 
     template <typename T1, typename T2>
-    auto dataSetHandler(T1 arg1, T2 arg2) -> typename MB_ENABLE_IF<(is_num_int<T1>::value || is_num_float<T1>::value || is_bool<T1>::value) && MB_IS_SAME<T2, float>::value>::type
+    auto dataSetHandler(T1 arg1, T2 arg2) -> typename std::enable_if<(is_num_int<T1>::value || is_num_float<T1>::value || is_bool<T1>::value) && std::is_same<T2, float>::value>::type
     {
         mSetIdx(arg1, MB_JSON_CreateRaw(num2Str(arg2, floatDigits)));
     }
 
     template <typename T1, typename T2>
-    auto dataSetHandler(T1 arg1, T2 arg2) -> typename MB_ENABLE_IF<is_string<T1>::value && (MB_IS_SAME<T2, double>::value || MB_IS_SAME<T2, long double>::value)>::type
+    auto dataSetHandler(T1 arg1, T2 arg2) -> typename std::enable_if<is_string<T1>::value && (std::is_same<T2, double>::value || std::is_same<T2, long double>::value)>::type
     {
         if (root_type != Root_Type_JSONArray)
             mClear();
@@ -2197,13 +2197,13 @@ class FirebaseJsonArray : public FirebaseJsonBase
     }
 
     template <typename T1, typename T2>
-    auto dataSetHandler(T1 arg1, T2 arg2) -> typename MB_ENABLE_IF<(is_num_int<T1>::value || is_num_float<T1>::value || is_bool<T1>::value) && (MB_IS_SAME<T2, double>::value || MB_IS_SAME<T2, long double>::value)>::type
+    auto dataSetHandler(T1 arg1, T2 arg2) -> typename std::enable_if<(is_num_int<T1>::value || is_num_float<T1>::value || is_bool<T1>::value) && (std::is_same<T2, double>::value || std::is_same<T2, long double>::value)>::type
     {
         mSetIdx(arg1, MB_JSON_CreateRaw(num2Str(arg2, doubleDigits)));
     }
 
     template <typename T1, typename T2>
-    auto dataSetHandler(T1 arg1, T2 arg2) -> typename MB_ENABLE_IF<is_string<T1>::value && is_string<T2>::value>::type
+    auto dataSetHandler(T1 arg1, T2 arg2) -> typename std::enable_if<is_string<T1>::value && is_string<T2>::value>::type
     {
         if (root_type != Root_Type_JSONArray)
             mClear();
@@ -2218,7 +2218,7 @@ class FirebaseJsonArray : public FirebaseJsonBase
     }
 
     template <typename T1, typename T2>
-    auto dataSetHandler(T1 arg1, T2 arg2) -> typename MB_ENABLE_IF<(is_num_int<T1>::value || is_num_float<T1>::value || is_bool<T1>::value) && is_string<T2>::value>::type
+    auto dataSetHandler(T1 arg1, T2 arg2) -> typename std::enable_if<(is_num_int<T1>::value || is_num_float<T1>::value || is_bool<T1>::value) && is_string<T2>::value>::type
     {
         uint32_t addr = 0;
         mSetIdx(arg1, MB_JSON_CreateString(getStr(arg2, addr)));
@@ -2226,7 +2226,7 @@ class FirebaseJsonArray : public FirebaseJsonBase
     }
 
     template <typename T1, typename T2>
-    auto dataSetHandler(T1 arg1, T2 &arg2) -> typename MB_ENABLE_IF<is_string<T1>::value && MB_IS_SAME<T2, FirebaseJson>::value>::type
+    auto dataSetHandler(T1 arg1, T2 &arg2) -> typename std::enable_if<is_string<T1>::value && std::is_same<T2, FirebaseJson>::value>::type
     {
         if (root_type != Root_Type_JSONArray)
             mClear();
@@ -2240,14 +2240,14 @@ class FirebaseJsonArray : public FirebaseJsonBase
     }
 
     template <typename T1, typename T2>
-    auto dataSetHandler(T1 arg1, T2 &arg2) -> typename MB_ENABLE_IF<(is_num_int<T1>::value || is_num_float<T1>::value || is_bool<T1>::value) && MB_IS_SAME<T2, FirebaseJson>::value>::type
+    auto dataSetHandler(T1 arg1, T2 &arg2) -> typename std::enable_if<(is_num_int<T1>::value || is_num_float<T1>::value || is_bool<T1>::value) && std::is_same<T2, FirebaseJson>::value>::type
     {
         MB_JSON *e = MB_JSON_Duplicate(arg2.root, true);
         mSetIdx(arg1, e);
     }
 
     template <typename T1, typename T2>
-    auto dataSetHandler(T1 arg1, T2 &arg2) -> typename MB_ENABLE_IF<is_string<T1>::value && MB_IS_SAME<T2, FirebaseJsonArray>::value>::type
+    auto dataSetHandler(T1 arg1, T2 &arg2) -> typename std::enable_if<is_string<T1>::value && std::is_same<T2, FirebaseJsonArray>::value>::type
     {
         if (root_type != Root_Type_JSONArray)
             mClear();
@@ -2261,7 +2261,7 @@ class FirebaseJsonArray : public FirebaseJsonBase
     }
 
     template <typename T1, typename T2>
-    auto dataSetHandler(T1 arg1, T2 &arg2) -> typename MB_ENABLE_IF<(is_num_int<T1>::value || is_num_float<T1>::value || is_bool<T1>::value) && MB_IS_SAME<T2, FirebaseJsonArray>::value>::type
+    auto dataSetHandler(T1 arg1, T2 &arg2) -> typename std::enable_if<(is_num_int<T1>::value || is_num_float<T1>::value || is_bool<T1>::value) && std::is_same<T2, FirebaseJsonArray>::value>::type
     {
         MB_JSON *e = MB_JSON_Duplicate(arg2.root, true);
         mSetIdx(arg1, e);
@@ -2636,7 +2636,7 @@ class FirebaseJson : public FirebaseJsonBase
     FirebaseJson &nAdd(const char *key, MB_JSON *value);
 
     template <typename T1, typename T2>
-    auto dataHandler(T1 arg1, T2 arg2, fb_json_func_type_t type) -> typename MB_ENABLE_IF<is_string<T1>::value && is_bool<T2>::value, FirebaseJson &>::type
+    auto dataHandler(T1 arg1, T2 arg2, fb_json_func_type_t type) -> typename std::enable_if<is_string<T1>::value && is_bool<T2>::value, FirebaseJson &>::type
     {
         if (root_type != Root_Type_JSON)
             mClear();
@@ -2653,7 +2653,7 @@ class FirebaseJson : public FirebaseJsonBase
     }
 
     template <typename T1, typename T2>
-    auto dataHandler(T1 arg1, T2 arg2, fb_json_func_type_t type) -> typename MB_ENABLE_IF<is_string<T1>::value && is_num_int<T2>::value, FirebaseJson &>::type
+    auto dataHandler(T1 arg1, T2 arg2, fb_json_func_type_t type) -> typename std::enable_if<is_string<T1>::value && is_num_int<T2>::value, FirebaseJson &>::type
     {
         if (root_type != Root_Type_JSON)
             mClear();
@@ -2670,7 +2670,7 @@ class FirebaseJson : public FirebaseJsonBase
     }
 
     template <typename T1, typename T2>
-    auto dataHandler(T1 arg1, T2 arg2, fb_json_func_type_t type) -> typename MB_ENABLE_IF<is_string<T1>::value && MB_IS_SAME<T2, float>::value, FirebaseJson &>::type
+    auto dataHandler(T1 arg1, T2 arg2, fb_json_func_type_t type) -> typename std::enable_if<is_string<T1>::value && std::is_same<T2, float>::value, FirebaseJson &>::type
     {
         if (root_type != Root_Type_JSON)
             mClear();
@@ -2687,7 +2687,7 @@ class FirebaseJson : public FirebaseJsonBase
     }
 
     template <typename T1, typename T2>
-    auto dataHandler(T1 arg1, T2 arg2, fb_json_func_type_t type) -> typename MB_ENABLE_IF<is_string<T1>::value && (MB_IS_SAME<T2, double>::value || MB_IS_SAME<T2, long double>::value), FirebaseJson &>::type
+    auto dataHandler(T1 arg1, T2 arg2, fb_json_func_type_t type) -> typename std::enable_if<is_string<T1>::value && (std::is_same<T2, double>::value || std::is_same<T2, long double>::value), FirebaseJson &>::type
     {
         if (root_type != Root_Type_JSON)
             mClear();
@@ -2704,7 +2704,7 @@ class FirebaseJson : public FirebaseJsonBase
     }
 
     template <typename T1, typename T2>
-    auto dataHandler(T1 arg1, T2 arg2, fb_json_func_type_t type) -> typename MB_ENABLE_IF<is_string<T1>::value && is_string<T2>::value, FirebaseJson &>::type
+    auto dataHandler(T1 arg1, T2 arg2, fb_json_func_type_t type) -> typename std::enable_if<is_string<T1>::value && is_string<T2>::value, FirebaseJson &>::type
     {
         if (root_type != Root_Type_JSON)
             mClear();
@@ -2723,7 +2723,7 @@ class FirebaseJson : public FirebaseJsonBase
     }
 
     template <typename T>
-    auto dataHandler(T arg, FirebaseJson &json, fb_json_func_type_t type) -> typename MB_ENABLE_IF<is_string<T>::value, FirebaseJson &>::type
+    auto dataHandler(T arg, FirebaseJson &json, fb_json_func_type_t type) -> typename std::enable_if<is_string<T>::value, FirebaseJson &>::type
     {
         if (root_type != Root_Type_JSON)
             mClear();
@@ -2741,7 +2741,7 @@ class FirebaseJson : public FirebaseJsonBase
     }
 
     template <typename T>
-    auto dataHandler(T arg, FirebaseJsonArray &arr, fb_json_func_type_t type) -> typename MB_ENABLE_IF<is_string<T>::value, FirebaseJson &>::type
+    auto dataHandler(T arg, FirebaseJsonArray &arr, fb_json_func_type_t type) -> typename std::enable_if<is_string<T>::value, FirebaseJson &>::type
     {
         if (root_type != Root_Type_JSON)
             mClear();
diff --git a/src/json/MB_String.h b/src/json/MB_String.h
index 0ac5b00..53a1fec 100644
--- a/src/json/MB_String.h
+++ b/src/json/MB_String.h
@@ -1,11 +1,14 @@
 
 /**
- * Mobizt's SRAM/PSRAM supported String, version 1.2.11
+ * Mobizt's SRAM/PSRAM supported String, version 1.2.12
  *
- * Created March 23, 2024
+ * Created March 25, 2024
  *
  * Changes Log
  *
+ * v1.2.12
+ * - using std namespace
+ * 
  * v1.2.11
  * - fix float to string conversion
  * 
@@ -113,13 +116,6 @@ class MB_String;
 #define pgm2Str(p) (MB_String().appendP(p).c_str())
 #define num2Str(v, p) (MB_String().appendNum(v, p).c_str())
 
-#if defined(ARDUINO_ARCH_STM32) || defined(ARDUINO_ARCH_STM32F1) || defined(ARDUINO_ARCH_STM32F4)
-#define MB_IS_SAME std::is_same
-#define MB_ENABLE_IF std::enable_if
-#else
-#define MB_IS_SAME is_same
-#define MB_ENABLE_IF enable_if
-#endif
 
 namespace mb_string
 {
@@ -194,52 +190,52 @@ namespace mb_string
     template <typename T>
     struct is_num_int8
     {
-        static bool const value = MB_IS_SAME<T, int8_t>::value || MB_IS_SAME<T, signed char>::value;
+        static bool const value = std::is_same<T, int8_t>::value || std::is_same<T, signed char>::value;
     };
 
     template <typename T>
     struct is_num_uint8
     {
-        static bool const value = MB_IS_SAME<T, uint8_t>::value || MB_IS_SAME<T, unsigned char>::value;
+        static bool const value = std::is_same<T, uint8_t>::value || std::is_same<T, unsigned char>::value;
     };
 
     template <typename T>
     struct is_num_int16
     {
-        static bool const value = MB_IS_SAME<T, int16_t>::value || MB_IS_SAME<T, signed short>::value;
+        static bool const value = std::is_same<T, int16_t>::value || std::is_same<T, signed short>::value;
     };
 
     template <typename T>
     struct is_num_uint16
     {
-        static bool const value = MB_IS_SAME<T, uint16_t>::value || MB_IS_SAME<T, unsigned short>::value;
+        static bool const value = std::is_same<T, uint16_t>::value || std::is_same<T, unsigned short>::value;
     };
 
     template <typename T>
     struct is_num_int32
     {
-        static bool const value = MB_IS_SAME<T, signed int>::value || MB_IS_SAME<T, int>::value ||
-                                  MB_IS_SAME<T, int32_t>::value || MB_IS_SAME<T, long>::value ||
-                                  MB_IS_SAME<T, signed long>::value;
+        static bool const value = std::is_same<T, signed int>::value || std::is_same<T, int>::value ||
+                                  std::is_same<T, int32_t>::value || std::is_same<T, long>::value ||
+                                  std::is_same<T, signed long>::value;
     };
 
     template <typename T>
     struct is_num_uint32
     {
-        static bool const value = MB_IS_SAME<T, unsigned int>::value || MB_IS_SAME<T, uint32_t>::value ||
-                                  MB_IS_SAME<T, unsigned long>::value;
+        static bool const value = std::is_same<T, unsigned int>::value || std::is_same<T, uint32_t>::value ||
+                                  std::is_same<T, unsigned long>::value;
     };
 
     template <typename T>
     struct is_num_int64
     {
-        static bool const value = MB_IS_SAME<T, int64_t>::value || MB_IS_SAME<T, signed long long>::value;
+        static bool const value = std::is_same<T, int64_t>::value || std::is_same<T, signed long long>::value;
     };
 
     template <typename T>
     struct is_num_uint64
     {
-        static bool const value = MB_IS_SAME<T, uint64_t>::value || MB_IS_SAME<T, unsigned long long>::value;
+        static bool const value = std::is_same<T, uint64_t>::value || std::is_same<T, unsigned long long>::value;
     };
 
     template <typename T>
@@ -265,44 +261,44 @@ namespace mb_string
     template <typename T>
     struct is_num_float
     {
-        static bool const value = MB_IS_SAME<T, float>::value || MB_IS_SAME<T, double>::value || MB_IS_SAME<T, long double>::value;
+        static bool const value = std::is_same<T, float>::value || std::is_same<T, double>::value || std::is_same<T, long double>::value;
     };
 
     template <typename T>
     struct is_bool
     {
-        static bool const value = MB_IS_SAME<T, bool>::value;
+        static bool const value = std::is_same<T, bool>::value;
     };
 
     template <typename T>
     struct cs_t
     {
-        static bool const value = MB_IS_SAME<T, char *>::value;
+        static bool const value = std::is_same<T, char *>::value;
     };
 
     template <typename T>
     struct ccs_t
     {
-        static bool const value = MB_IS_SAME<T, const char *>::value;
+        static bool const value = std::is_same<T, const char *>::value;
     };
 
     template <typename T>
     struct as_t
     {
-        static bool const value = MB_IS_SAME<T, String>::value;
+        static bool const value = std::is_same<T, String>::value;
     };
 
     template <typename T>
     struct cas_t
     {
-        static bool const value = MB_IS_SAME<T, const String>::value;
+        static bool const value = std::is_same<T, const String>::value;
     };
 
     template <typename T>
     struct ss_t
     {
 #if !defined(__AVR__)
-        static bool const value = MB_IS_SAME<T, std::string>::value;
+        static bool const value = std::is_same<T, std::string>::value;
 #else
         static bool const value = false;
 #endif
@@ -312,7 +308,7 @@ namespace mb_string
     struct css_t
     {
 #if !defined(__AVR__)
-        static bool const value = MB_IS_SAME<T, const std::string>::value;
+        static bool const value = std::is_same<T, const std::string>::value;
 #else
         static bool const value = false;
 #endif
@@ -321,31 +317,31 @@ namespace mb_string
     template <typename T>
     struct ssh_t
     {
-        static bool const value = MB_IS_SAME<T, StringSumHelper>::value;
+        static bool const value = std::is_same<T, StringSumHelper>::value;
     };
 
     template <typename T>
     struct fs_t
     {
-        static bool const value = MB_IS_SAME<T, const __FlashStringHelper *>::value;
+        static bool const value = std::is_same<T, const __FlashStringHelper *>::value;
     };
 
     template <typename T>
     struct mbs_t
     {
-        static bool const value = MB_IS_SAME<T, MB_String>::value;
+        static bool const value = std::is_same<T, MB_String>::value;
     };
 
     template <typename T>
     struct cmbs_t
     {
-        static bool const value = MB_IS_SAME<T, const MB_String>::value;
+        static bool const value = std::is_same<T, const MB_String>::value;
     };
 
     template <typename T>
     struct pgm_t
     {
-        static bool const value = MB_IS_SAME<T, PGM_P>::value;
+        static bool const value = std::is_same<T, PGM_P>::value;
     };
 
     template <typename T>
@@ -403,14 +399,14 @@ namespace mb_string
     }
 #else
     template <typename T>
-    auto addrTo(int address) -> typename MB_ENABLE_IF<!MB_IS_SAME<T, nullptr_t>::value, T>::type
+    auto addrTo(int address) -> typename std::enable_if<!std::is_same<T, nullptr_t>::value, T>::type
     {
         return reinterpret_cast<T>(address);
     }
 #endif
 
     template <typename T>
-    auto getSubType(T val) -> typename MB_ENABLE_IF<is_num_int<T>::value || is_num_float<T>::value || MB_IS_SAME<T, bool>::value || is_const_chars<T>::value || is_arduino_flash_string_helper<T>::value || is_arduino_string<T>::value || is_std_string<T>::value || is_mb_string<T>::value || MB_IS_SAME<T, StringSumHelper>::value, mb_string_sub_type>::type
+    auto getSubType(T val) -> typename std::enable_if<is_num_int<T>::value || is_num_float<T>::value || std::is_same<T, bool>::value || is_const_chars<T>::value || is_arduino_flash_string_helper<T>::value || is_arduino_string<T>::value || is_std_string<T>::value || is_mb_string<T>::value || std::is_same<T, StringSumHelper>::value, mb_string_sub_type>::type
     {
         if (is_num_uint64<T>::value)
             return mb_string_sub_type_uint64;
@@ -428,11 +424,11 @@ namespace mb_string
             return mb_string_sub_type_uint8;
         else if (is_num_int8<T>::value)
             return mb_string_sub_type_int8;
-        else if (MB_IS_SAME<T, bool>::value)
+        else if (std::is_same<T, bool>::value)
             return mb_string_sub_type_bool;
-        else if (MB_IS_SAME<T, float>::value)
+        else if (std::is_same<T, float>::value)
             return mb_string_sub_type_float;
-        else if (MB_IS_SAME<T, double>::value)
+        else if (std::is_same<T, double>::value)
             return mb_string_sub_type_double;
         else if (is_arduino_string<T>::value)
             return mb_string_sub_type_arduino_string;
@@ -442,7 +438,7 @@ namespace mb_string
             return mb_string_sub_type_mb_string;
         else if (is_arduino_flash_string_helper<T>::value)
             return mb_string_sub_type_fptr;
-        else if (MB_IS_SAME<T, StringSumHelper>::value)
+        else if (std::is_same<T, StringSumHelper>::value)
             return mb_string_sub_type_string_sum_helper;
         else if (ccs_t<T>::value)
             return mb_string_sub_type_cstring;
@@ -453,19 +449,19 @@ namespace mb_string
     }
 
     template <typename T>
-    auto getSubType(T *val) -> typename MB_ENABLE_IF<is_num_int<T>::value || is_num_float<T>::value || MB_IS_SAME<T, bool>::value || is_const_chars<T>::value || is_arduino_flash_string_helper<T>::value || is_arduino_string<T>::value || is_std_string<T>::value || is_mb_string<T>::value || MB_IS_SAME<T, StringSumHelper>::value, mb_string_sub_type>::type
+    auto getSubType(T *val) -> typename std::enable_if<is_num_int<T>::value || is_num_float<T>::value || std::is_same<T, bool>::value || is_const_chars<T>::value || is_arduino_flash_string_helper<T>::value || is_arduino_string<T>::value || is_std_string<T>::value || is_mb_string<T>::value || std::is_same<T, StringSumHelper>::value, mb_string_sub_type>::type
     {
         return getSubType(*val);
     }
 
     template <typename T>
-    auto toStringPtr(const T &val) -> typename MB_ENABLE_IF<is_std_string<T>::value || is_arduino_string<T>::value || is_mb_string<T>::value, MB_StringPtr>::type
+    auto toStringPtr(const T &val) -> typename std::enable_if<is_std_string<T>::value || is_arduino_string<T>::value || is_mb_string<T>::value, MB_StringPtr>::type
     {
         return MB_StringPtr(reinterpret_cast<uint32_t>(&val), getSubType(val));
     }
 
     template <typename T>
-    auto toStringPtr(const T &val) -> typename MB_ENABLE_IF<MB_IS_SAME<T, StringSumHelper>::value, MB_StringPtr>::type
+    auto toStringPtr(const T &val) -> typename std::enable_if<std::is_same<T, StringSumHelper>::value, MB_StringPtr>::type
     {
 #if defined(ESP8266)
         return MB_StringPtr(reinterpret_cast<uint32_t>(&val), getSubType(val), -1);
@@ -476,27 +472,27 @@ namespace mb_string
     }
 
     template <typename T>
-    auto toStringPtr(T val) -> typename MB_ENABLE_IF<is_const_chars<T>::value, MB_StringPtr>::type { return MB_StringPtr(reinterpret_cast<uint32_t>(val), getSubType(val)); }
+    auto toStringPtr(T val) -> typename std::enable_if<is_const_chars<T>::value, MB_StringPtr>::type { return MB_StringPtr(reinterpret_cast<uint32_t>(val), getSubType(val)); }
 
     template <typename T>
-    auto toStringPtr(T &val) -> typename MB_ENABLE_IF<is_arduino_flash_string_helper<T>::value, MB_StringPtr>::type { return MB_StringPtr(reinterpret_cast<uint32_t>(val), getSubType(val)); }
+    auto toStringPtr(T &val) -> typename std::enable_if<is_arduino_flash_string_helper<T>::value, MB_StringPtr>::type { return MB_StringPtr(reinterpret_cast<uint32_t>(val), getSubType(val)); }
 
 #if !defined(__AVR__)
     template <typename T>
-    auto toStringPtr(T val) -> typename MB_ENABLE_IF<MB_IS_SAME<T, std::nullptr_t>::value, MB_StringPtr>::type
+    auto toStringPtr(T val) -> typename std::enable_if<std::is_same<T, std::nullptr_t>::value, MB_StringPtr>::type
     {
         return MB_StringPtr();
     }
 #endif
 
     template <typename T>
-    auto toStringPtr(T val) -> typename MB_ENABLE_IF<MB_IS_SAME<T, MB_StringPtr>::value, MB_StringPtr>::type
+    auto toStringPtr(T val) -> typename std::enable_if<std::is_same<T, MB_StringPtr>::value, MB_StringPtr>::type
     {
         return val;
     }
 
     template <typename T>
-    auto toStringPtr(T &val, int precision = -1) -> typename MB_ENABLE_IF<is_num_int<T>::value || is_num_float<T>::value || MB_IS_SAME<T, bool>::value, MB_StringPtr>::type { return MB_StringPtr(reinterpret_cast<uint32_t>(&val), getSubType(val), precision); }
+    auto toStringPtr(T &val, int precision = -1) -> typename std::enable_if<is_num_int<T>::value || is_num_float<T>::value || std::is_same<T, bool>::value, MB_StringPtr>::type { return MB_StringPtr(reinterpret_cast<uint32_t>(&val), getSubType(val), precision); }
 }
 
 using namespace mb_string;
@@ -797,7 +793,7 @@ class MB_String
     }
 
     template <typename T = int>
-    auto operator=(T value) -> typename MB_ENABLE_IF<is_num_int<T>::value || is_num_float<T>::value || is_bool<T>::value, MB_String &>::type
+    auto operator=(T value) -> typename std::enable_if<is_num_int<T>::value || is_num_float<T>::value || is_bool<T>::value, MB_String &>::type
     {
         clear();
         appendNum(value);
@@ -805,7 +801,7 @@ class MB_String
     }
 
     template <typename T = int>
-    auto operator+=(T value) -> typename MB_ENABLE_IF<is_num_int<T>::value || is_num_float<T>::value || is_bool<T>::value, MB_String &>::type
+    auto operator+=(T value) -> typename std::enable_if<is_num_int<T>::value || is_num_float<T>::value || is_bool<T>::value, MB_String &>::type
     {
         appendNum(value);
         return (*this);
@@ -898,7 +894,7 @@ class MB_String
     };
 
     template <typename T = int>
-    auto appendNum(T value, int precision = 0) -> typename MB_ENABLE_IF<is_num_int<T>::value || is_bool<T>::value, MB_String &>::type
+    auto appendNum(T value, int precision = 0) -> typename std::enable_if<is_num_int<T>::value || is_bool<T>::value, MB_String &>::type
     {
         char *s = NULL;