Expose DPP message embeds.

Fix team kill and normal kill swapped

CMakeLists.txt

@@ -1,14 +1,23 @@
 cmake_minimum_required(VERSION 3.7)
 project(SqMod)
 
+# This plug-in only works on 64-bit
+if(CMAKE_SIZEOF_VOID_P EQUAL 4)
+    message(FATAL_ERROR "SqMod does not support 32-but platforms anymore.")
+endif()
+
 # Tell CMake where to find our scripts
 set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake)
 set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/vendor/POCO/cmake)
 
 # Several plugin options
 option(ENABLE_API21 "Build for 2.1 API." OFF)
+option(ENABLE_DISCORD "Enable built-in Discord support" OFF)
+option(ENABLE_DISCORD_VOICE "Enable voice support in Discord library" OFF)
 option(ENABLE_OFFICIAL "Enable compatibility with official legacy plug-in" ON)
-option(FORCE_32BIT_BIN "Create a 32-bit executable binary if the compiler defaults to 64-bit." OFF)
+# As a fall-back for certain situations (mainly some docker ubuntu containers)
+option(ENABLE_BUILTIN_MYSQL_C "Enable built-in MySQL connector library" OFF)
+#option(FORCE_32BIT_BIN "Create a 32-bit executable binary if the compiler defaults to 64-bit." OFF)
 # This option should only be available in certain conditions
 if(WIN32 AND MINGW)
     option(COPY_DEPENDENCIES "Copy deppendent DLLs into the deps folder." OFF)
@@ -93,10 +102,9 @@ else()
     endif()
 endif()
 
-# Determine if build mode
-if(${CMAKE_BUILD_TYPE} MATCHES "(Debug)+")
-    add_compile_options(-g)
-endif()
+# Strip binary
+set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -s -g")
+set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -s -g")
 
 # Enable position independent code
 if (${CMAKE_SYSTEM_NAME} MATCHES "Linux")

module/CMakeLists.txt

@@ -76,8 +76,8 @@ add_library(SqModule MODULE SqBase.hpp Main.cpp
     Library/IO/Stream.cpp Library/IO/Stream.hpp
     Library/JSON.cpp Library/JSON.hpp
     Library/MMDB.cpp Library/MMDB.hpp
+    Library/Net.cpp Library/Net.hpp
     Library/Numeric.cpp Library/Numeric.hpp
-    Library/Numeric/Long.cpp Library/Numeric/Long.hpp
     Library/Numeric/Math.cpp Library/Numeric/Math.hpp
     Library/Numeric/Random.cpp Library/Numeric/Random.hpp
     Library/String.cpp Library/String.hpp
@@ -85,6 +85,7 @@ add_library(SqModule MODULE SqBase.hpp Main.cpp
     Library/System/Dir.cpp Library/System/Dir.hpp
     Library/System/Env.cpp Library/System/Env.hpp
     Library/System/Path.cpp Library/System/Path.hpp
+    Library/UTF8.cpp Library/UTF8.hpp
     Library/Utils.cpp Library/Utils.hpp
     Library/Utils/Announce.cpp Library/Utils/Announce.hpp
     Library/Utils/String.cpp Library/Utils/String.hpp
@@ -104,13 +105,11 @@ add_library(SqModule MODULE SqBase.hpp Main.cpp
     # POCO
     PocoLib/Crypto.cpp PocoLib/Crypto.hpp
     PocoLib/Data.cpp PocoLib/Data.hpp
-    PocoLib/JSON.cpp PocoLib/JSON.hpp
     PocoLib/Net.cpp PocoLib/Net.hpp
     PocoLib/RegEx.cpp PocoLib/RegEx.hpp
     PocoLib/Register.cpp PocoLib/Register.hpp
     PocoLib/Time.cpp PocoLib/Time.hpp
     PocoLib/Util.cpp PocoLib/Util.hpp
-    PocoLib/XML.cpp PocoLib/XML.hpp
     # 
     Core.cpp Core.hpp
     Logger.cpp Logger.hpp
@@ -133,9 +132,30 @@ if(WIN32 OR MINGW)
     target_link_libraries(SqModule wsock32 ws2_32 shlwapi)
 endif()
 # Link to base libraries
-target_link_libraries(SqModule Squirrel fmt::fmt SimpleINI TinyDir xxHash ConcurrentQueue SAJSON CPR PUGIXML maxminddb libzmq-static)
+target_link_libraries(SqModule Squirrel fmt::fmt SimpleINI TinyDir xxHash ConcurrentQueue SAJSON CPR UTF8Lib PUGIXML CivetWeb maxminddb libzmq-static)
+# Enable built-in Discord support
+if(ENABLE_DISCORD)
+    target_link_libraries(SqModule DPP)
+    target_compile_definitions(SqModule PRIVATE VCMP_ENABLE_DISCORD=1)
+    target_sources(SqModule PRIVATE
+        Library/DPP.cpp Library/DPP.hpp
+        Library/DPP/Channel.cpp Library/DPP/Channel.hpp
+        Library/DPP/Client.cpp Library/DPP/Client.hpp
+        Library/DPP/Cluster.cpp Library/DPP/Cluster.hpp
+        Library/DPP/Command.cpp Library/DPP/Command.hpp
+        Library/DPP/Constants.cpp Library/DPP/Constants.hpp
+        Library/DPP/Events.cpp Library/DPP/Events.hpp
+        Library/DPP/Guild.cpp Library/DPP/Guild.hpp
+        Library/DPP/Integration.cpp Library/DPP/Integration.hpp
+        Library/DPP/Message.cpp Library/DPP/Message.hpp
+        Library/DPP/Other.cpp Library/DPP/Other.hpp
+        Library/DPP/Role.cpp Library/DPP/Role.hpp
+        Library/DPP/User.cpp Library/DPP/User.hpp
+        Library/DPP/Utilities.cpp Library/DPP/Utilities.hpp
+    )
+endif()
 # Link to POCO libraries
-target_link_libraries(SqModule Poco::Foundation Poco::Crypto Poco::Data Poco::Net Poco::JSON Poco::XML)
+target_link_libraries(SqModule Poco::Foundation Poco::Crypto Poco::Data Poco::Net)
 # Does POCO have SQLite support?
 if(ENABLE_DATA_SQLITE)
     if(NOT POCO_UNBUNDLED)
@@ -150,9 +170,12 @@ if(ENABLE_DATA_SQLITE)
     # Include legacy implementation sources
     target_sources(SqModule PRIVATE Library/SQLite.hpp Library/SQLite.cpp)
 endif()
+# Do we have built-in MYSQL enabled?
+if (NOT ENABLE_BUILTIN_MYSQL_C)
+    find_package(MySQL)
+endif()
 # Does POCO have MySLQ support?
-find_package(MySQL)
-if(MYSQL_FOUND)
+if(ENABLE_BUILTIN_MYSQL_C OR MYSQL_FOUND)
     message(STATUS "MySQL was enabled")
     # Link the libraries
     target_link_libraries(SqModule Poco::DataMySQL)
@@ -175,6 +198,8 @@ if(${CMAKE_BUILD_TYPE} MATCHES "(Release)+")
 else()
     target_compile_definitions(SqModule PRIVATE _DEBUG=1 SQMOD_EXCEPTLOC=1)
 endif()
+# Strip binary
+set_target_properties(SqModule PROPERTIES LINK_FLAGS_RELEASE -s)
 # Force 32-bit binaries when necessary
 if(FORCE_32BIT_BIN)
     set_target_properties(SqModule PROPERTIES COMPILE_FLAGS "-m32" LINK_FLAGS "-m32")

module/Core.cpp

@@ -48,6 +48,11 @@ extern void TerminatePrivileges();
 extern void TerminateRoutines();
 extern void TerminateCommands();
 extern void TerminateSignals();
+extern void TerminateNet();
+#ifdef VCMP_ENABLE_DISCORD
+    extern void TerminateDPP();
+#endif
+extern void TerminatePocoNet();
 extern void TerminatePocoData();
 
 // ------------------------------------------------------------------------------------------------
@@ -547,7 +552,16 @@ void Core::Terminate(bool shutdown)
     // Release announcers
     AnnounceTerminate();
     cLogDbg(m_Verbosity >= 1, "Announcer terminated");
+    // Release DPP
+#ifdef VCMP_ENABLE_DISCORD
+    TerminateDPP();
+    cLogDbg(m_Verbosity >= 1, "Discord terminated");
+#endif
+    // Release network
+    TerminateNet();
+    cLogDbg(m_Verbosity >= 1, "Network terminated");
     // Release Poco statement results
+    TerminatePocoNet();
     TerminatePocoData();
     cLogDbg(m_Verbosity >= 1, "Poco terminated");
     // Release ZMQ sockets

module/Core/Buffer.hpp

@@ -148,6 +148,7 @@ public:
         : m_Ptr(o.m_Ptr), m_Cap(o.m_Cap), m_Cur(o.m_Cur)
     {
         o.m_Ptr = nullptr;
+        o.m_Cap = o.m_Cur = 0;
     }
 
     /* --------------------------------------------------------------------------------------------
@@ -175,6 +176,7 @@ public:
             m_Cap = o.m_Cap;
             m_Cur = o.m_Cur;
             o.m_Ptr = nullptr;
+            o.m_Cap = o.m_Cur = 0;
         }
         return *this;
     }
@@ -856,6 +858,17 @@ public:
         m_Cur += Write(m_Cur, str, size);
     }
 
+    /* --------------------------------------------------------------------------------------------
+     * Steal ownership of the internal memory buffer. Whoever gets hold of the buffer must invoke delete [] on it.
+    */
+    SQMOD_NODISCARD Pointer Steal()
+    {
+        Pointer ptr = m_Ptr;
+        m_Ptr = nullptr;
+        m_Cap = m_Cur = 0; // Save this before calling this method
+        return ptr;
+    }
+
 protected:
 
     /* --------------------------------------------------------------------------------------------

module/Core/Common.cpp

@@ -2,7 +2,6 @@
 #include "Core/Common.hpp"
 #include "Core/Buffer.hpp"
 #include "Core/Utility.hpp"
-#include "Library/Numeric/Long.hpp"
 
 // ------------------------------------------------------------------------------------------------
 #include <cerrno>
@@ -313,46 +312,10 @@ SQInteger PopStackInteger(HSQUIRRELVM vm, SQInteger idx)
         case OT_TABLE:
         case OT_CLASS:
         case OT_USERDATA:
-        {
-            return sq_getsize(vm, idx);
-        }
         case OT_INSTANCE:
         {
-            SQUserPointer tag;
-            // Attempt to retrieve the type tag
-            if (SQ_FAILED(sq_gettypetag(vm, -1, &tag)))
-            {
-                break;
-            }
-            // Is the instance SLongInt? (signed long)
-            else if (static_cast< AbstractStaticClassData * >(tag) == StaticClassTypeTag< SLongInt >::Get())
-            {
-                try
-                {
-                    return ConvTo< SQInteger >::From(Var< const SLongInt & >(vm, idx).value.GetNum());
-                }
-                catch (...)
-                {
-                    // Just ignore it...
-                }
-            }
-            // Is the instance ULongInt? (unsigned long)
-            else if (static_cast< AbstractStaticClassData * >(tag) == StaticClassTypeTag< ULongInt >::Get())
-            {
-                try
-                {
-                    return ConvTo< SQInteger >::From(Var< const ULongInt & >(vm, idx).value.GetNum());
-                }
-                catch (...)
-                {
-                    // Just ignore it...
-                }
-            }
-            else
-            {
-                // Attempt to get the size of the instance as a fall back
-                return sq_getsize(vm, idx);
-            }
+            // Attempt to get the size of the instance as a fall back
+            return sq_getsize(vm, idx);
         }
         default: break;
     }
@@ -406,41 +369,8 @@ SQFloat PopStackFloat(HSQUIRRELVM vm, SQInteger idx)
         }
         case OT_INSTANCE:
         {
-            SQUserPointer tag;
-            // Attempt to retrieve the type tag
-            if (SQ_FAILED(sq_gettypetag(vm, -1, &tag)))
-            {
-                break;
-            }
-            // Is the instance SLongInt? (signed long)
-            else if (static_cast< AbstractStaticClassData * >(tag) == StaticClassTypeTag< SLongInt >::Get())
-            {
-                try
-                {
-                    return ConvTo< SQFloat >::From(Var< const SLongInt & >(vm, idx).value.GetNum());
-                }
-                catch (...)
-                {
-                    // Just ignore it...
-                }
-            }
-            // Is the instance ULongInt? (unsigned long)
-            else if (static_cast< AbstractStaticClassData * >(tag) == StaticClassTypeTag< ULongInt >::Get())
-            {
-                try
-                {
-                    return ConvTo< SQFloat >::From(Var< const ULongInt & >(vm, idx).value.GetNum());
-                }
-                catch (...)
-                {
-                    // Just ignore it...
-                }
-            }
-            else
-            {
-                // Attempt to get the size of the instance as a fall back
-                return ConvTo< SQFloat >::From(sq_getsize(vm, idx));
-            }
+            // Attempt to get the size of the instance as a fall back
+            return ConvTo< SQFloat >::From(sq_getsize(vm, idx));
         }
         default: break;
     }

module/Core/Events.inc

@@ -444,7 +444,7 @@ void Core::EmitPlayerKilled(int32_t player_id, int32_t killer_id, int32_t reason
 #ifdef VCMP_ENABLE_OFFICIAL
     if (IsOfficial())
     {
-        if (!team_kill)
+        if (team_kill)
         {
             ExecuteLegacyEvent(m_VM, _SC("onPlayerTeamKill"), _killer.mLgObj, _player.mLgObj, reason, static_cast< int32_t >(body_part));
         }

module/Entity/Checkpoint.cpp

@@ -157,16 +157,16 @@ void CCheckpoint::SetWorld(int32_t world)
     {
         return;
     }
-    // Avoid property unwind from a recursive call
-    _Func->SetCheckPointWorld(m_ID, world);
     // Avoid infinite recursive event loops
-    if (!(m_CircularLocks & CHECKPOINTCL_EMIT_CHECKPOINT_WORLD))
+    else if (!(m_CircularLocks & CHECKPOINTCL_EMIT_CHECKPOINT_WORLD))
     {
         // Prevent this event from triggering while executed
         BitGuardU32 bg(m_CircularLocks, CHECKPOINTCL_EMIT_CHECKPOINT_WORLD);
         // Now forward the event call
         Core::Get().EmitCheckpointWorld(m_ID, current, world);
     }
+    // Avoid property unwind from a recursive call
+    _Func->SetCheckPointWorld(m_ID, world);
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -257,8 +257,6 @@ void CCheckpoint::SetRadius(float radius)
     Validate();
     // Grab the current value for this property
     const float current = _Func->GetCheckPointRadius(m_ID);
-    // Avoid property unwind from a recursive call
-    _Func->SetCheckPointRadius(m_ID, radius);
     // Avoid infinite recursive event loops
     if (!(m_CircularLocks & CHECKPOINTCL_EMIT_CHECKPOINT_RADIUS))
     {
@@ -267,6 +265,8 @@ void CCheckpoint::SetRadius(float radius)
         // Now forward the event call
         Core::Get().EmitCheckpointRadius(m_ID, current, radius);
     }
+    // Avoid property unwind from a recursive call
+    _Func->SetCheckPointRadius(m_ID, radius);
 }
 
 // ------------------------------------------------------------------------------------------------

module/Entity/Object.cpp

@@ -163,16 +163,16 @@ void CObject::SetWorld(int32_t world)
     {
         return;
     }
-    // Avoid property unwind from a recursive call
-    _Func->SetObjectWorld(m_ID, world);
     // Avoid infinite recursive event loops
-    if (!(m_CircularLocks & OBJECTCL_EMIT_OBJECT_WORLD))
+    else if (!(m_CircularLocks & OBJECTCL_EMIT_OBJECT_WORLD))
     {
         // Prevent this event from triggering while executed
         BitGuardU32 bg(m_CircularLocks, OBJECTCL_EMIT_OBJECT_WORLD);
         // Now forward the event call
         Core::Get().EmitObjectWorld(m_ID, current, world);
     }
+    // Avoid property unwind from a recursive call
+    _Func->SetObjectWorld(m_ID, world);
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -202,16 +202,16 @@ void CObject::SetAlphaEx(int32_t alpha, uint32_t time)
     {
         return;
     }
-    // Avoid property unwind from a recursive call
-    _Func->SetObjectAlpha(m_ID, alpha, time);
     // Avoid infinite recursive event loops
-    if (!(m_CircularLocks & OBJECTCL_EMIT_OBJECT_ALPHA))
+    else if (!(m_CircularLocks & OBJECTCL_EMIT_OBJECT_ALPHA))
     {
         // Prevent this event from triggering while executed
         BitGuardU32 bg(m_CircularLocks, OBJECTCL_EMIT_OBJECT_ALPHA);
         // Now forward the event call
         Core::Get().EmitObjectAlpha(m_ID, current, alpha, time);
     }
+    // Avoid property unwind from a recursive call
+    _Func->SetObjectAlpha(m_ID, alpha, time);
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -400,16 +400,16 @@ void CObject::SetShotReport(bool toggle)
     {
         return;
     }
-    // Avoid property unwind from a recursive call
-    _Func->SetObjectShotReportEnabled(m_ID, static_cast< uint8_t >(toggle));
     // Avoid infinite recursive event loops
-    if (!(m_CircularLocks & OBJECTCL_EMIT_OBJECT_REPORT))
+    else if (!(m_CircularLocks & OBJECTCL_EMIT_OBJECT_REPORT))
     {
         // Prevent this event from triggering while executed
         BitGuardU32 bg(m_CircularLocks, OBJECTCL_EMIT_OBJECT_REPORT);
         // Now forward the event call
         Core::Get().EmitObjectReport(m_ID, current, toggle, false);
     }
+    // Avoid property unwind from a recursive call
+    _Func->SetObjectShotReportEnabled(m_ID, static_cast< uint8_t >(toggle));
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -433,16 +433,16 @@ void CObject::SetTouchedReport(bool toggle)
     {
         return;
     }
-    // Avoid property unwind from a recursive call
-    _Func->SetObjectTouchedReportEnabled(m_ID, static_cast< uint8_t >(toggle));
     // Avoid infinite recursive event loops
-    if (!(m_CircularLocks & OBJECTCL_EMIT_OBJECT_REPORT))
+    else if (!(m_CircularLocks & OBJECTCL_EMIT_OBJECT_REPORT))
     {
         // Prevent this event from triggering while executed
         BitGuardU32 bg(m_CircularLocks, OBJECTCL_EMIT_OBJECT_REPORT);
         // Now forward the event call
         Core::Get().EmitObjectReport(m_ID, current, toggle, true);
     }
+    // Avoid property unwind from a recursive call
+    _Func->SetObjectTouchedReportEnabled(m_ID, static_cast< uint8_t >(toggle));
 }
 
 // ------------------------------------------------------------------------------------------------

module/Entity/Pickup.cpp

@@ -145,19 +145,20 @@ void CPickup::SetOption(int32_t option_id, bool toggle)
 {
     // Attempt to obtain the current value of the specified option
     const bool value = _Func->GetPickupOption(m_ID, static_cast< vcmpPickupOption >(option_id));
-    // Attempt to modify the current value of the specified option
-    if (_Func->SetPickupOption(m_ID, static_cast< vcmpPickupOption >(option_id),
-                               static_cast< uint8_t >(toggle)) == vcmpErrorArgumentOutOfBounds)
-    {
-        STHROWF("Invalid option identifier: {}", option_id);
-    }
-    else if (!(m_CircularLocks & PICKUPCL_EMIT_PICKUP_OPTION))
+    // Avoid infinite recursive event loops
+    if (!(m_CircularLocks & PICKUPCL_EMIT_PICKUP_OPTION))
     {
         // Prevent this event from triggering while executed
         BitGuardU32 bg(m_CircularLocks, PICKUPCL_EMIT_PICKUP_OPTION);
         // Now forward the event call
         Core::Get().EmitPickupOption(m_ID, option_id, value, 0, NullLightObj());
     }
+    // Attempt to modify the current value of the specified option
+    if (_Func->SetPickupOption(m_ID, static_cast< vcmpPickupOption >(option_id),
+                               static_cast< uint8_t >(toggle)) == vcmpErrorArgumentOutOfBounds)
+    {
+        STHROWF("Invalid option identifier: {}", option_id);
+    }
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -165,19 +166,20 @@ void CPickup::SetOptionEx(int32_t option_id, bool toggle, int32_t header, LightO
 {
     // Attempt to obtain the current value of the specified option
     const bool value = _Func->GetPickupOption(m_ID, static_cast< vcmpPickupOption >(option_id));
-    // Attempt to modify the current value of the specified option
-    if (_Func->SetPickupOption(m_ID, static_cast< vcmpPickupOption >(option_id),
-                               static_cast< uint8_t >(toggle)) == vcmpErrorArgumentOutOfBounds)
-    {
-        STHROWF("Invalid option identifier: {}", option_id);
-    }
-    else if (!(m_CircularLocks & PICKUPCL_EMIT_PICKUP_OPTION))
+    // Avoid infinite recursive event loops
+    if (!(m_CircularLocks & PICKUPCL_EMIT_PICKUP_OPTION))
     {
         // Prevent this event from triggering while executed
         BitGuardU32 bg(m_CircularLocks, PICKUPCL_EMIT_PICKUP_OPTION);
         // Now forward the event call
         Core::Get().EmitPickupOption(m_ID, option_id, value, header, payload);
     }
+    // Attempt to modify the current value of the specified option
+    if (_Func->SetPickupOption(m_ID, static_cast< vcmpPickupOption >(option_id),
+                               static_cast< uint8_t >(toggle)) == vcmpErrorArgumentOutOfBounds)
+    {
+        STHROWF("Invalid option identifier: {}", option_id);
+    }
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -201,16 +203,16 @@ void CPickup::SetWorld(int32_t world)
     {
         return;
     }
-    // Avoid property unwind from a recursive call
-    _Func->SetPickupWorld(m_ID, world);
     // Avoid infinite recursive event loops
-    if (!(m_CircularLocks & PICKUPCL_EMIT_PICKUP_WORLD))
+    else if (!(m_CircularLocks & PICKUPCL_EMIT_PICKUP_WORLD))
     {
         // Prevent this event from triggering while executed
         BitGuardU32 bg(m_CircularLocks, PICKUPCL_EMIT_PICKUP_WORLD);
         // Now forward the event call
         Core::Get().EmitPickupWorld(m_ID, current, world);
     }
+    // Avoid property unwind from a recursive call
+    _Func->SetPickupWorld(m_ID, world);
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -234,16 +236,16 @@ void CPickup::SetAlpha(int32_t alpha)
     {
         return;
     }
-    // Avoid property unwind from a recursive call
-    _Func->SetPickupAlpha(m_ID, alpha);
     // Avoid infinite recursive event loops
-    if (!(m_CircularLocks & PICKUPCL_EMIT_PICKUP_ALPHA))
+    else if (!(m_CircularLocks & PICKUPCL_EMIT_PICKUP_ALPHA))
     {
         // Prevent this event from triggering while executed
         BitGuardU32 bg(m_CircularLocks, PICKUPCL_EMIT_PICKUP_ALPHA);
         // Now forward the event call
         Core::Get().EmitPickupAlpha(m_ID, current, alpha);
     }
+    // Avoid property unwind from a recursive call
+    _Func->SetPickupAlpha(m_ID, alpha);
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -267,16 +269,16 @@ void CPickup::SetAutomatic(bool toggle)
     {
         return;
     }
-    // Avoid property unwind from a recursive call
-    _Func->SetPickupIsAutomatic(m_ID, static_cast< uint8_t >(toggle));
     // Avoid infinite recursive event loops
-    if (!(m_CircularLocks & PICKUPCL_EMIT_PICKUP_AUTOMATIC))
+    else if (!(m_CircularLocks & PICKUPCL_EMIT_PICKUP_AUTOMATIC))
     {
         // Prevent this event from triggering while executed
         BitGuardU32 bg(m_CircularLocks, PICKUPCL_EMIT_PICKUP_AUTOMATIC);
         // Now forward the event call
         Core::Get().EmitPickupAutomatic(m_ID, current, toggle);
     }
+    // Avoid property unwind from a recursive call
+    _Func->SetPickupIsAutomatic(m_ID, static_cast< uint8_t >(toggle));
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -300,16 +302,16 @@ void CPickup::SetAutoTimer(int32_t timer)
     {
         return;
     }
-    // Avoid property unwind from a recursive call
-    _Func->SetPickupAutoTimer(m_ID, static_cast< uint32_t >(timer));
     // Avoid infinite recursive event loops
-    if (!(m_CircularLocks & PICKUPCL_EMIT_PICKUP_AUTOTIMER))
+    else if (!(m_CircularLocks & PICKUPCL_EMIT_PICKUP_AUTOTIMER))
     {
         // Prevent this event from triggering while executed
         BitGuardU32 bg(m_CircularLocks, PICKUPCL_EMIT_PICKUP_AUTOTIMER);
         // Now forward the event call
         Core::Get().EmitPickupAutoTimer(m_ID, current, timer);
     }
+    // Avoid property unwind from a recursive call
+    _Func->SetPickupAutoTimer(m_ID, static_cast< uint32_t >(timer));
 }
 
 // ------------------------------------------------------------------------------------------------

module/Entity/Player.cpp

@@ -168,16 +168,16 @@ void CPlayer::SetAdmin(bool toggle)
     {
         return;
     }
-    // Avoid property unwind from a recursive call
-    _Func->SetPlayerAdmin(m_ID, static_cast< uint8_t >(toggle));
     // Avoid infinite recursive event loops
-    if (!(m_CircularLocks & PLAYERCL_EMIT_PLAYER_ADMIN))
+    else if (!(m_CircularLocks & PLAYERCL_EMIT_PLAYER_ADMIN))
     {
         // Prevent this event from triggering while executed
         BitGuardU32 bg(m_CircularLocks, PLAYERCL_EMIT_PLAYER_ADMIN);
         // Now forward the event call
         Core::Get().EmitPlayerAdmin(m_ID, current, toggle);
     }
+    // Avoid property unwind from a recursive call
+    _Func->SetPlayerAdmin(m_ID, static_cast< uint8_t >(toggle));
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -373,13 +373,6 @@ void CPlayer::SetOptionEx(int32_t option_id, bool toggle, int32_t header, LightO
     {
         return;
     }
-    // Avoid property unwind from a recursive call
-    else if (_Func->SetPlayerOption(m_ID,
-        static_cast< vcmpPlayerOption >(option_id),
-        static_cast< uint8_t >(toggle)) == vcmpErrorArgumentOutOfBounds)
-    {
-        STHROWF("Invalid option identifier: {}", option_id);
-    }
     // Avoid infinite recursive event loops
     else if (!(m_CircularLocks & PLAYERCL_EMIT_PLAYER_OPTION))
     {
@@ -388,6 +381,13 @@ void CPlayer::SetOptionEx(int32_t option_id, bool toggle, int32_t header, LightO
         // Now forward the event call
         Core::Get().EmitPlayerOption(m_ID, option_id, current, header, payload);
     }
+    // Avoid property unwind from a recursive call
+    if (_Func->SetPlayerOption(m_ID,
+        static_cast< vcmpPlayerOption >(option_id),
+        static_cast< uint8_t >(toggle)) == vcmpErrorArgumentOutOfBounds)
+    {
+        STHROWF("Invalid option identifier: {}", option_id);
+    }
 }
 #if SQMOD_SDK_LEAST(2, 1)
 // ------------------------------------------------------------------------------------------------
@@ -433,16 +433,16 @@ void CPlayer::SetWorld(int32_t world)
     {
         return;
     }
-    // Avoid property unwind from a recursive call
-    _Func->SetPlayerWorld(m_ID, world);
     // Avoid infinite recursive event loops
-    if (!(m_CircularLocks & PLAYERCL_EMIT_PLAYER_WORLD))
+    else if (!(m_CircularLocks & PLAYERCL_EMIT_PLAYER_WORLD))
     {
         // Prevent this event from triggering while executed
         BitGuardU32 bg(m_CircularLocks, PLAYERCL_EMIT_PLAYER_WORLD);
         // Now forward the event call
         Core::Get().EmitPlayerWorld(m_ID, current, world, false);
     }
+    // Avoid property unwind from a recursive call
+    _Func->SetPlayerWorld(m_ID, world);
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -466,16 +466,16 @@ void CPlayer::SetSecondaryWorld(int32_t world)
     {
         return;
     }
-    // Avoid property unwind from a recursive call
-    _Func->SetPlayerSecondaryWorld(m_ID, world);
     // Avoid infinite recursive event loops
-    if (!(m_CircularLocks & PLAYERCL_EMIT_PLAYER_WORLD))
+    else if (!(m_CircularLocks & PLAYERCL_EMIT_PLAYER_WORLD))
     {
         // Prevent this event from triggering while executed
         BitGuardU32 bg(m_CircularLocks, PLAYERCL_EMIT_PLAYER_WORLD);
         // Now forward the event call
         Core::Get().EmitPlayerWorld(m_ID, current, world, true);
     }
+    // Avoid property unwind from a recursive call
+    _Func->SetPlayerSecondaryWorld(m_ID, world);
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -526,11 +526,6 @@ void CPlayer::SetTeam(int32_t team)
     {
         return;
     }
-    // Avoid property unwind from a recursive call
-    else if (_Func->SetPlayerTeam(m_ID, team) == vcmpErrorArgumentOutOfBounds)
-    {
-        STHROWF("Invalid team identifier: {}", team);
-    }
     // Avoid infinite recursive event loops
     else if (!(m_CircularLocks & PLAYERCL_EMIT_PLAYER_TEAM))
     {
@@ -539,6 +534,11 @@ void CPlayer::SetTeam(int32_t team)
         // Now forward the event call
         Core::Get().EmitPlayerTeam(m_ID, current, team);
     }
+    // Avoid property unwind from a recursive call
+    if (_Func->SetPlayerTeam(m_ID, team) == vcmpErrorArgumentOutOfBounds)
+    {
+        STHROWF("Invalid team identifier: {}", team);
+    }
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -562,11 +562,6 @@ void CPlayer::SetSkin(int32_t skin)
     {
         return;
     }
-    // Avoid property unwind from a recursive call
-    else if (_Func->SetPlayerSkin(m_ID, skin) == vcmpErrorArgumentOutOfBounds)
-    {
-        STHROWF("Invalid skin identifier: {}", skin);
-    }
     // Avoid infinite recursive event loops
     else if (!(m_CircularLocks & PLAYERCL_EMIT_PLAYER_SKIN))
     {
@@ -575,6 +570,11 @@ void CPlayer::SetSkin(int32_t skin)
         // Now forward the event call
         Core::Get().EmitPlayerSkin(m_ID, current, skin);
     }
+    // Avoid property unwind from a recursive call
+    if (_Func->SetPlayerSkin(m_ID, skin) == vcmpErrorArgumentOutOfBounds)
+    {
+        STHROWF("Invalid skin identifier: {}", skin);
+    }
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -665,16 +665,16 @@ void CPlayer::SetMoney(int32_t amount)
     {
         return;
     }
-    // Avoid property unwind from a recursive call
-    _Func->SetPlayerMoney(m_ID, amount);
     // Avoid infinite recursive event loops
-    if (!(m_CircularLocks & PLAYERCL_EMIT_PLAYER_MONEY))
+    else if (!(m_CircularLocks & PLAYERCL_EMIT_PLAYER_MONEY))
     {
         // Prevent this event from triggering while executed
         BitGuardU32 bg(m_CircularLocks, PLAYERCL_EMIT_PLAYER_MONEY);
         // Now forward the event call
         Core::Get().EmitPlayerMoney(m_ID, current, amount);
     }
+    // Avoid property unwind from a recursive call
+    _Func->SetPlayerMoney(m_ID, amount);
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -684,8 +684,6 @@ void CPlayer::GiveMoney(int32_t amount)
     Validate();
     // Grab the current value for this property
     const int32_t current = _Func->GetPlayerMoney(m_ID);
-    // Avoid property unwind from a recursive call
-    _Func->GivePlayerMoney(m_ID, amount);
     // Avoid infinite recursive event loops
     if (!(m_CircularLocks & PLAYERCL_EMIT_PLAYER_MONEY))
     {
@@ -694,6 +692,8 @@ void CPlayer::GiveMoney(int32_t amount)
         // Now forward the event call
         Core::Get().EmitPlayerMoney(m_ID, current, current + amount);
     }
+    // Avoid property unwind from a recursive call
+    _Func->GivePlayerMoney(m_ID, amount);
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -717,16 +717,16 @@ void CPlayer::SetScore(int32_t score)
     {
         return;
     }
-    // Avoid property unwind from a recursive call
-    _Func->SetPlayerScore(m_ID, score);
     // Avoid infinite recursive event loops
-    if (!(m_CircularLocks & PLAYERCL_EMIT_PLAYER_SCORE))
+    else if (!(m_CircularLocks & PLAYERCL_EMIT_PLAYER_SCORE))
     {
         // Prevent this event from triggering while executed
         BitGuardU32 bg(m_CircularLocks, PLAYERCL_EMIT_PLAYER_SCORE);
         // Now forward the event call
         Core::Get().EmitPlayerScore(m_ID, current, score);
     }
+    // Avoid property unwind from a recursive call
+    _Func->SetPlayerScore(m_ID, score);
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -750,16 +750,16 @@ void CPlayer::SetWantedLevel(int32_t level)
     {
         return;
     }
-    // Avoid property unwind from a recursive call
-    _Func->SetPlayerWantedLevel(m_ID, level);
     // Avoid infinite recursive event loops
-    if (!(m_CircularLocks & PLAYERCL_EMIT_PLAYER_WANTED_LEVEL))
+    else if (!(m_CircularLocks & PLAYERCL_EMIT_PLAYER_WANTED_LEVEL))
     {
         // Prevent this event from triggering while executed
         BitGuardU32 bg(m_CircularLocks, PLAYERCL_EMIT_PLAYER_WANTED_LEVEL);
         // Now forward the event call
         Core::Get().EmitPlayerWantedLevel(m_ID, current, level);
     }
+    // Avoid property unwind from a recursive call
+    _Func->SetPlayerWantedLevel(m_ID, level);
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -832,8 +832,6 @@ void CPlayer::SetImmunity(uint32_t flags)
     Validate();
     // Grab the current value for this property
     const uint32_t current = _Func->GetPlayerImmunityFlags(m_ID);
-    // Avoid property unwind from a recursive call
-    _Func->SetPlayerImmunityFlags(m_ID, static_cast< uint32_t >(flags));
     // Avoid infinite recursive event loops
     if (!(m_CircularLocks & PLAYERCL_EMIT_PLAYER_IMMUNITY))
     {
@@ -842,6 +840,8 @@ void CPlayer::SetImmunity(uint32_t flags)
         // Now forward the event call
         Core::Get().EmitPlayerImmunity(m_ID, static_cast< int32_t >(current), static_cast< int32_t >(flags));
     }
+    // Avoid property unwind from a recursive call
+    _Func->SetPlayerImmunityFlags(m_ID, static_cast< uint32_t >(flags));
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -969,16 +969,16 @@ void CPlayer::SetAlphaEx(int32_t alpha, int32_t fade)
     {
         return;
     }
-    // Avoid property unwind from a recursive call
-    _Func->SetPlayerAlpha(m_ID, alpha, static_cast< uint32_t >(fade));
     // Avoid infinite recursive event loops
-    if (!(m_CircularLocks & PLAYERCL_EMIT_PLAYER_ALPHA))
+    else if (!(m_CircularLocks & PLAYERCL_EMIT_PLAYER_ALPHA))
     {
         // Prevent this event from triggering while executed
         BitGuardU32 bg(m_CircularLocks, PLAYERCL_EMIT_PLAYER_ALPHA);
         // Now forward the event call
         Core::Get().EmitPlayerAlpha(m_ID, current, alpha, fade);
     }
+    // Avoid property unwind from a recursive call
+    _Func->SetPlayerAlpha(m_ID, alpha, static_cast< uint32_t >(fade));
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -1044,7 +1044,7 @@ uint32_t CPlayer::GetGameKeys() const
 }
 
 // ------------------------------------------------------------------------------------------------
-bool CPlayer::Embark(CVehicle & vehicle) const
+bool CPlayer::Embark(CVehicle & vehicle)
 {
     // Is the specified vehicle even valid?
     if (!vehicle.IsActive())
@@ -1053,13 +1053,26 @@ bool CPlayer::Embark(CVehicle & vehicle) const
     }
     // Validate the managed identifier
     Validate();
+    // If the player embarks in the same vehicle then ignore
+    if (_Func->GetPlayerVehicleId(m_ID) == vehicle.GetID())
+    {
+        return true; // I guess this is somewhat successful
+    }
+    // Avoid infinite recursive event loops
+    else if (!(m_CircularLocks & PLAYERCL_EMIT_PLAYER_EMBARK))
+    {
+        // Prevent this event from triggering while executed
+        BitGuardU32 bg(m_CircularLocks, PLAYERCL_EMIT_PLAYER_EMBARK);
+        // Now forward the event call
+        Core::Get().EmitPlayerEmbarking(m_ID, vehicle.GetID(), 0);
+    }
     // Perform the requested operation
     return (_Func->PutPlayerInVehicle(m_ID, vehicle.GetID(), 0,
         static_cast< uint8_t >(true), static_cast< uint8_t >(true)) != vcmpErrorRequestDenied);
 }
 
 // ------------------------------------------------------------------------------------------------
-bool CPlayer::EmbarkEx(CVehicle & vehicle, int32_t slot, bool allocate, bool warp) const
+bool CPlayer::EmbarkEx(CVehicle & vehicle, int32_t slot, bool allocate, bool warp)
 {
     // Is the specified vehicle even valid?
     if (!vehicle.IsActive())
@@ -1068,6 +1081,19 @@ bool CPlayer::EmbarkEx(CVehicle & vehicle, int32_t slot, bool allocate, bool war
     }
     // Validate the managed identifier
     Validate();
+    // If the player embarks in the same vehicle then ignore
+    if (_Func->GetPlayerVehicleId(m_ID) == vehicle.GetID())
+    {
+        return true; // I guess this is somewhat successful
+    }
+    // Avoid infinite recursive event loops
+    else if (!(m_CircularLocks & PLAYERCL_EMIT_PLAYER_EMBARK))
+    {
+        // Prevent this event from triggering while executed
+        BitGuardU32 bg(m_CircularLocks, PLAYERCL_EMIT_PLAYER_EMBARK);
+        // Now forward the event call
+        Core::Get().EmitPlayerEmbarking(m_ID, vehicle.GetID(), slot);
+    }
     // Perform the requested operation
     return (_Func->PutPlayerInVehicle(m_ID, vehicle.GetID(), slot,
         static_cast< uint8_t >(allocate), static_cast< uint8_t >(warp)) != vcmpErrorRequestDenied);

module/Entity/Player.hpp

@@ -21,7 +21,8 @@ enum PlayerCircularLocks
     PLAYERCL_EMIT_PLAYER_SCORE           = (1u << 6u),
     PLAYERCL_EMIT_PLAYER_WANTED_LEVEL    = (1u << 7u),
     PLAYERCL_EMIT_PLAYER_IMMUNITY        = (1u << 8u),
-    PLAYERCL_EMIT_PLAYER_ALPHA           = (1u << 9u)
+    PLAYERCL_EMIT_PLAYER_ALPHA           = (1u << 9u),
+    PLAYERCL_EMIT_PLAYER_EMBARK          = (1u << 10u)
 };
 
 /* ------------------------------------------------------------------------------------------------
@@ -593,12 +594,12 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Embark the managed player entity into the specified vehicle entity.
     */
-    bool Embark(CVehicle & vehicle) const;
+    bool Embark(CVehicle & vehicle);
 
     /* --------------------------------------------------------------------------------------------
      * Embark the managed player entity into the specified vehicle entity.
     */
-    bool EmbarkEx(CVehicle & vehicle, int32_t slot, bool allocate, bool warp) const;
+    bool EmbarkEx(CVehicle & vehicle, int32_t slot, bool allocate, bool warp);
 
     /* --------------------------------------------------------------------------------------------
      * Disembark the managed player entity from the currently embarked vehicle entity.

module/Entity/Vehicle.cpp

@@ -148,19 +148,20 @@ void CVehicle::SetOption(int32_t option_id, bool toggle)
 {
     // Attempt to obtain the current value of the specified option
     const bool value = _Func->GetVehicleOption(m_ID, static_cast< vcmpVehicleOption >(option_id));
-    // Attempt to modify the current value of the specified option
-    if (_Func->SetVehicleOption(m_ID, static_cast< vcmpVehicleOption >(option_id),
-                                static_cast< uint8_t >(toggle)) == vcmpErrorArgumentOutOfBounds)
-    {
-        STHROWF("Invalid option identifier: {}", option_id);
-    }
-    else if (!(m_CircularLocks & VEHICLECL_EMIT_VEHICLE_OPTION))
+    // Avoid infinite recursive event loops
+    if (!(m_CircularLocks & VEHICLECL_EMIT_VEHICLE_OPTION))
     {
         // Prevent this event from triggering while executed
         BitGuardU32 bg(m_CircularLocks, VEHICLECL_EMIT_VEHICLE_OPTION);
         // Now forward the event call
         Core::Get().EmitVehicleOption(m_ID, option_id, value, 0, NullLightObj());
     }
+    // Attempt to modify the current value of the specified option
+    if (_Func->SetVehicleOption(m_ID, static_cast< vcmpVehicleOption >(option_id),
+                                static_cast< uint8_t >(toggle)) == vcmpErrorArgumentOutOfBounds)
+    {
+        STHROWF("Invalid option identifier: {}", option_id);
+    }
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -168,19 +169,20 @@ void CVehicle::SetOptionEx(int32_t option_id, bool toggle, int32_t header, Light
 {
     // Attempt to obtain the current value of the specified option
     const bool value = _Func->GetVehicleOption(m_ID, static_cast< vcmpVehicleOption >(option_id));
-    // Attempt to modify the current value of the specified option
-    if (_Func->SetVehicleOption(m_ID, static_cast< vcmpVehicleOption >(option_id),
-                                static_cast< uint8_t >(toggle)) == vcmpErrorArgumentOutOfBounds)
-    {
-        STHROWF("Invalid option identifier: {}", option_id);
-    }
-    else if (!(m_CircularLocks & VEHICLECL_EMIT_VEHICLE_OPTION))
+    // Avoid infinite recursive event loops
+    if (!(m_CircularLocks & VEHICLECL_EMIT_VEHICLE_OPTION))
     {
         // Prevent this event from triggering while executed
         BitGuardU32 bg(m_CircularLocks, VEHICLECL_EMIT_VEHICLE_OPTION);
         // Now forward the event call
         Core::Get().EmitVehicleOption(m_ID, option_id, value, header, payload);
     }
+    // Attempt to modify the current value of the specified option
+    if (_Func->SetVehicleOption(m_ID, static_cast< vcmpVehicleOption >(option_id),
+                                static_cast< uint8_t >(toggle)) == vcmpErrorArgumentOutOfBounds)
+    {
+        STHROWF("Invalid option identifier: {}", option_id);
+    }
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -222,16 +224,16 @@ void CVehicle::SetWorld(int32_t world)
     {
         return;
     }
-    // Avoid property unwind from a recursive call
-    _Func->SetVehicleWorld(m_ID, world);
     // Avoid infinite recursive event loops
-    if (!(m_CircularLocks & VEHICLECL_EMIT_VEHICLE_WORLD))
+    else if (!(m_CircularLocks & VEHICLECL_EMIT_VEHICLE_WORLD))
     {
         // Prevent this event from triggering while executed
         BitGuardU32 bg(m_CircularLocks, VEHICLECL_EMIT_VEHICLE_WORLD);
         // Now forward the event call
         Core::Get().EmitVehicleWorld(m_ID, current, world);
     }
+    // Avoid property unwind from a recursive call
+    _Func->SetVehicleWorld(m_ID, world);
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -321,8 +323,6 @@ void CVehicle::SetImmunity(uint32_t flags)
     Validate();
     // Grab the current value for this property
     const uint32_t current = _Func->GetVehicleImmunityFlags(m_ID);
-    // Avoid property unwind from a recursive call
-    _Func->SetVehicleImmunityFlags(m_ID, static_cast< uint32_t >(flags));
     // Avoid infinite recursive event loops
     if (!(m_CircularLocks & VEHICLECL_EMIT_VEHICLE_IMMUNITY))
     {
@@ -331,6 +331,8 @@ void CVehicle::SetImmunity(uint32_t flags)
         // Now forward the event call
         Core::Get().EmitVehicleImmunity(m_ID, static_cast< int32_t >(current), static_cast< int32_t >(flags));
     }
+    // Avoid property unwind from a recursive call
+    _Func->SetVehicleImmunityFlags(m_ID, static_cast< uint32_t >(flags));
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -914,16 +916,16 @@ void CVehicle::SetPartStatus(int32_t part, int32_t status)
     {
         return;
     }
-    // Avoid property unwind from a recursive call
-    _Func->SetVehiclePartStatus(m_ID, part, status);
     // Avoid infinite recursive event loops
-    if (!(m_CircularLocks & VEHICLECL_EMIT_VEHICLE_PARTSTATUS))
+    else if (!(m_CircularLocks & VEHICLECL_EMIT_VEHICLE_PARTSTATUS))
     {
         // Prevent this event from triggering while executed
         BitGuardU32 bg(m_CircularLocks, VEHICLECL_EMIT_VEHICLE_PARTSTATUS);
         // Now forward the event call
         Core::Get().EmitVehiclePartStatus(m_ID, part, current, status);
     }
+    // Avoid property unwind from a recursive call
+    _Func->SetVehiclePartStatus(m_ID, part, status);
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -947,16 +949,16 @@ void CVehicle::SetTyreStatus(int32_t tyre, int32_t status)
     {
         return;
     }
-    // Avoid property unwind from a recursive call
-    _Func->SetVehicleTyreStatus(m_ID, tyre, status);
     // Avoid infinite recursive event loops
-    if (!(m_CircularLocks & VEHICLECL_EMIT_VEHICLE_TYRESTATUS))
+    else if (!(m_CircularLocks & VEHICLECL_EMIT_VEHICLE_TYRESTATUS))
     {
         // Prevent this event from triggering while executed
         BitGuardU32 bg(m_CircularLocks, VEHICLECL_EMIT_VEHICLE_TYRESTATUS);
         // Now forward the event call
         Core::Get().EmitVehicleTyreStatus(m_ID, tyre, current, status);
     }
+    // Avoid property unwind from a recursive call
+    _Func->SetVehicleTyreStatus(m_ID, tyre, status);
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -980,16 +982,16 @@ void CVehicle::SetDamageData(uint32_t data)
     {
         return;
     }
-    // Avoid property unwind from a recursive call
-    _Func->SetVehicleDamageData(m_ID, data);
     // Avoid infinite recursive event loops
-    if (!(m_CircularLocks & VEHICLECL_EMIT_VEHICLE_DAMAGEDATA))
+    else if (!(m_CircularLocks & VEHICLECL_EMIT_VEHICLE_DAMAGEDATA))
     {
         // Prevent this event from triggering while executed
         BitGuardU32 bg(m_CircularLocks, VEHICLECL_EMIT_VEHICLE_DAMAGEDATA);
         // Now forward the event call
         Core::Get().EmitVehicleDamageData(m_ID, current, data);
     }
+    // Avoid property unwind from a recursive call
+    _Func->SetVehicleDamageData(m_ID, data);
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -1013,16 +1015,16 @@ void CVehicle::SetRadio(int32_t radio)
     {
         return;
     }
-    // Avoid property unwind from a recursive call
-    _Func->SetVehicleRadio(m_ID, radio);
     // Avoid infinite recursive event loops
-    if (!(m_CircularLocks & VEHICLECL_EMIT_VEHICLE_RADIO))
+    else if (!(m_CircularLocks & VEHICLECL_EMIT_VEHICLE_RADIO))
     {
         // Prevent this event from triggering while executed
         BitGuardU32 bg(m_CircularLocks, VEHICLECL_EMIT_VEHICLE_RADIO);
         // Now forward the event call
         Core::Get().EmitVehicleRadio(m_ID, current, radio);
     }
+    // Avoid property unwind from a recursive call
+    _Func->SetVehicleRadio(m_ID, radio);
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -1089,8 +1091,6 @@ void CVehicle::SetHandlingRule(int32_t rule, float data)
     Validate();
     // Grab the current value for this property
     const auto current = static_cast< SQFloat >(_Func->GetInstHandlingRule(m_ID, rule));
-    // Avoid property unwind from a recursive call
-    _Func->SetInstHandlingRule(m_ID, rule, data);
     // Avoid infinite recursive event loops
     if (!(m_CircularLocks & VEHICLECL_EMIT_VEHICLE_HANDLINGRULE))
     {
@@ -1099,6 +1099,8 @@ void CVehicle::SetHandlingRule(int32_t rule, float data)
         // Now forward the event call
         Core::Get().EmitVehicleHandlingRule(m_ID, rule, current, data);
     }
+    // Avoid property unwind from a recursive call
+    _Func->SetInstHandlingRule(m_ID, rule, data);
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -1108,8 +1110,6 @@ void CVehicle::ResetHandlingRule(int32_t rule)
     Validate();
     // Grab the current value for this property
     const auto current = static_cast< SQFloat >(_Func->GetInstHandlingRule(m_ID, rule));
-    // Avoid property unwind from a recursive call
-    _Func->ResetInstHandlingRule(m_ID, rule);
     // Avoid infinite recursive event loops
     if (!(m_CircularLocks & VEHICLECL_EMIT_VEHICLE_HANDLINGRULE))
     {
@@ -1118,6 +1118,8 @@ void CVehicle::ResetHandlingRule(int32_t rule)
         // Now forward the event call
         Core::Get().EmitVehicleHandlingRule(m_ID, rule, current, static_cast< SQFloat >(_Func->GetInstHandlingRule(m_ID, rule)));
     }
+    // Avoid property unwind from a recursive call
+    _Func->ResetInstHandlingRule(m_ID, rule);
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -1148,7 +1150,7 @@ void CVehicle::SetLightsData(int32_t data) const
 }
 
 // ------------------------------------------------------------------------------------------------
-bool CVehicle::Embark(CPlayer & player) const
+bool CVehicle::Embark(CPlayer & player)
 {
     // Is the specified player even valid?
     if (!player.IsActive())
@@ -1157,6 +1159,19 @@ bool CVehicle::Embark(CPlayer & player) const
     }
     // Validate the managed identifier
     Validate();
+    // If the player embarks in the same vehicle then ignore
+    if (_Func->GetPlayerVehicleId(player.GetID()) == m_ID)
+    {
+        return true; // I guess this is somewhat successful
+    }
+    // Avoid infinite recursive event loops
+    else if (!(m_CircularLocks & VEHICLECL_EMIT_VEHICLE_EMBARK))
+    {
+        // Prevent this event from triggering while executed
+        BitGuardU32 bg(m_CircularLocks, VEHICLECL_EMIT_VEHICLE_EMBARK);
+        // Now forward the event call
+        Core::Get().EmitPlayerEmbarking(player.GetID(), m_ID, 0);
+    }
     // Perform the requested operation
     return (_Func->PutPlayerInVehicle(player.GetID(), m_ID, 0,
         static_cast< uint8_t >(true), static_cast< uint8_t >(true))
@@ -1164,7 +1179,7 @@ bool CVehicle::Embark(CPlayer & player) const
 }
 
 // ------------------------------------------------------------------------------------------------
-bool CVehicle::EmbarkEx(CPlayer & player, int32_t slot, bool allocate, bool warp) const
+bool CVehicle::EmbarkEx(CPlayer & player, int32_t slot, bool allocate, bool warp)
 {
     // Is the specified player even valid?
     if (!player.IsActive())
@@ -1173,6 +1188,19 @@ bool CVehicle::EmbarkEx(CPlayer & player, int32_t slot, bool allocate, bool warp
     }
     // Validate the managed identifier
     Validate();
+    // If the player embarks in the same vehicle then ignore
+    if (_Func->GetPlayerVehicleId(player.GetID()) == m_ID)
+    {
+        return true; // I guess this is somewhat successful
+    }
+    // Avoid infinite recursive event loops
+    else if (!(m_CircularLocks & VEHICLECL_EMIT_VEHICLE_EMBARK))
+    {
+        // Prevent this event from triggering while executed
+        BitGuardU32 bg(m_CircularLocks, VEHICLECL_EMIT_VEHICLE_EMBARK);
+        // Now forward the event call
+        Core::Get().EmitPlayerEmbarking(player.GetID(), m_ID, 0);
+    }
     // Perform the requested operation
     return (_Func->PutPlayerInVehicle(player.GetID(), m_ID, slot,
         static_cast< uint8_t >(allocate), static_cast< uint8_t >(warp)) != vcmpErrorRequestDenied);

module/Entity/Vehicle.hpp

@@ -18,7 +18,8 @@ enum VehicleCircularLocks
     VEHICLECL_EMIT_VEHICLE_TYRESTATUS   = (1u << 4u),
     VEHICLECL_EMIT_VEHICLE_DAMAGEDATA   = (1u << 5u),
     VEHICLECL_EMIT_VEHICLE_RADIO        = (1u << 6u),
-    VEHICLECL_EMIT_VEHICLE_HANDLINGRULE = (1u << 7u)
+    VEHICLECL_EMIT_VEHICLE_HANDLINGRULE = (1u << 7u),
+    VEHICLECL_EMIT_VEHICLE_EMBARK       = (1u << 8u) // This should probably be shared with CPlayer
 };
 
 /* ------------------------------------------------------------------------------------------------
@@ -615,12 +616,12 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Embark the specified player entity into the managed vehicle entity.
     */
-    bool Embark(CPlayer & player) const;
+    bool Embark(CPlayer & player);
 
     /* --------------------------------------------------------------------------------------------
      * Embark the specified player entity into the managed vehicle entity.
     */
-    bool EmbarkEx(CPlayer & player, int32_t slot, bool allocate, bool warp) const;
+    bool EmbarkEx(CPlayer & player, int32_t slot, bool allocate, bool warp);
 #if SQMOD_SDK_LEAST(2, 1)
     /* --------------------------------------------------------------------------------------------
      * Set whether the target player will see an objective arrow over a vehicle.

module/Library/Chrono.cpp

@@ -3,7 +3,6 @@
 #include "Library/Chrono/Date.hpp"
 #include "Library/Chrono/Timer.hpp"
 #include "Library/Chrono/Timestamp.hpp"
-#include "Library/Numeric/Long.hpp"
 #include "Core/Utility.hpp"
 
 // ------------------------------------------------------------------------------------------------
@@ -243,33 +242,38 @@ int64_t Chrono::DateRangeToSeconds(uint16_t _year, uint8_t _month, uint8_t _day,
 }
 
 // ------------------------------------------------------------------------------------------------
-static SLongInt SqGetEpochTimeMicro()
+static SQRESULT SqGetEpochTimeMicro(HSQUIRRELVM vm)
 {
-    return SLongInt(Chrono::GetEpochTimeMicro());
+    sq_pushinteger(vm, Chrono::GetEpochTimeMicro());
+    return 1;
 }
 
 // ------------------------------------------------------------------------------------------------
-static SLongInt SqGetEpochTimeMilli()
+static SQRESULT SqGetEpochTimeMilli(HSQUIRRELVM vm)
 {
-    return SLongInt(Chrono::GetEpochTimeMilli());
+    sq_pushinteger(vm, Chrono::GetEpochTimeMilli());
+    return 1;
 }
 
 // ------------------------------------------------------------------------------------------------
-static SLongInt SqGetCurrentSysTime()
+static SQRESULT SqGetCurrentSysTime(HSQUIRRELVM vm)
 {
-    return SLongInt(Chrono::GetCurrentSysTime());
+    sq_pushinteger(vm, Chrono::GetCurrentSysTime());
+    return 1;
 }
 
 // ------------------------------------------------------------------------------------------------
-static SQInteger SqGetTickCount()
+static SQRESULT SqGetTickCount(HSQUIRRELVM vm)
 {
-    return ConvTo< SQInteger >::From(GetTickCount());
+    sq_pushinteger(vm, ConvTo< SQInteger >::From(GetTickCount()));
+    return 1;
 }
 
 // ------------------------------------------------------------------------------------------------
-static SLongInt SqGetTickCount64()
+static SQRESULT SqGetTickCount64(HSQUIRRELVM vm)
 {
-    return SLongInt(GetTickCount64());
+    sq_pushinteger(vm, ConvTo< SQInteger >::From(GetTickCount64()));
+    return 1;
 }
 
 // ================================================================================================
@@ -284,11 +288,11 @@ void Register_Chrono(HSQUIRRELVM vm)
     Register_ChronoTimestamp(vm, cns);
 
     cns
-    .Func(_SC("EpochMicro"), &SqGetEpochTimeMicro)
-    .Func(_SC("EpochMilli"), &SqGetEpochTimeMilli)
-    .Func(_SC("Current"), &SqGetCurrentSysTime)
-    .Func(_SC("TickCount"), &SqGetTickCount)
-    .Func(_SC("TickCount64"), &SqGetTickCount64)
+    .SquirrelFunc(_SC("EpochMicro"), &SqGetEpochTimeMicro)
+    .SquirrelFunc(_SC("EpochMilli"), &SqGetEpochTimeMilli)
+    .SquirrelFunc(_SC("Current"), &SqGetCurrentSysTime)
+    .SquirrelFunc(_SC("TickCount"), &SqGetTickCount)
+    .SquirrelFunc(_SC("TickCount64"), &SqGetTickCount64)
     .Func(_SC("IsLeapYear"), &Chrono::IsLeapYear)
     .Func(_SC("IsDateValid"), &Chrono::ValidDate)
     .Func(_SC("DaysInYear"), &Chrono::DaysInYear)

module/Library/Chrono/Timestamp.cpp

@@ -4,7 +4,6 @@
 #include "Library/Chrono/Time.hpp"
 #include "Library/Chrono/Date.hpp"
 #include "Library/Chrono/Datetime.hpp"
-#include "Library/Numeric/Long.hpp"
 
 // ------------------------------------------------------------------------------------------------
 #include <chrono>
@@ -15,13 +14,6 @@ namespace SqMod {
 // ------------------------------------------------------------------------------------------------
 SQMOD_DECL_TYPENAME(Typename, _SC("SqTimestamp"))
 
-// ------------------------------------------------------------------------------------------------
-Timestamp::Timestamp(const SLongInt & t)
-    : m_Timestamp(t.GetNum())
-{
-    /* ... */
-}
-
 // ------------------------------------------------------------------------------------------------
 int32_t Timestamp::Cmp(const Timestamp & o) const
 {
@@ -52,36 +44,36 @@ void Timestamp::SetNow()
 }
 
 // ------------------------------------------------------------------------------------------------
-SLongInt Timestamp::GetMicroseconds() const
+SQInteger Timestamp::GetMicroseconds() const
 {
-    return SLongInt(m_Timestamp);
+    return m_Timestamp;
 }
 
 // ------------------------------------------------------------------------------------------------
-void Timestamp::SetMicroseconds(const SLongInt & amount)
+void Timestamp::SetMicroseconds(SQInteger amount)
 {
-    m_Timestamp = amount.GetNum();
+    m_Timestamp = amount;
 }
 
 // ------------------------------------------------------------------------------------------------
-Timestamp & Timestamp::AddMicroseconds(const SLongInt & amount) { m_Timestamp += amount.GetNum(); return *this; }
-Timestamp & Timestamp::SubMicroseconds(const SLongInt & amount) { m_Timestamp -= amount.GetNum(); return *this; }
+Timestamp & Timestamp::AddMicroseconds(SQInteger amount) { m_Timestamp += amount; return *this; }
+Timestamp & Timestamp::SubMicroseconds(SQInteger amount) { m_Timestamp -= amount; return *this; }
 
 // ------------------------------------------------------------------------------------------------
-SLongInt Timestamp::GetMilliseconds() const
+    SQInteger Timestamp::GetMilliseconds() const
 {
-    return SLongInt(m_Timestamp / 1000L);
+    return m_Timestamp / 1000L;
 }
 
 // ------------------------------------------------------------------------------------------------
-void Timestamp::SetMilliseconds(const SLongInt & amount)
+void Timestamp::SetMilliseconds(SQInteger amount)
 {
-    m_Timestamp = (amount.GetNum() * 1000L);
+    m_Timestamp = (amount * 1000L);
 }
 
 // ------------------------------------------------------------------------------------------------
-Timestamp & Timestamp::AddMilliseconds(const SLongInt & amount) { m_Timestamp += (amount.GetNum() * 1000L); return *this; }
-Timestamp & Timestamp::SubMilliseconds(const SLongInt & amount) { m_Timestamp -= (amount.GetNum() * 1000L); return *this; }
+Timestamp & Timestamp::AddMilliseconds(SQInteger amount) { m_Timestamp += (amount * 1000L); return *this; }
+Timestamp & Timestamp::SubMilliseconds(SQInteger amount) { m_Timestamp -= (amount * 1000L); return *this; }
 
 // ------------------------------------------------------------------------------------------------
 Time Timestamp::GetTime() const
@@ -213,7 +205,7 @@ static Timestamp SqGetMicrosecondsRaw(int64_t amount)
 }
 
 // ------------------------------------------------------------------------------------------------
-static Timestamp SqGetMicroseconds(const SLongInt & amount)
+static Timestamp SqGetMicroseconds(SQInteger amount)
 {
     return Timestamp(amount);
 }

module/Library/Chrono/Timestamp.hpp

@@ -40,11 +40,6 @@ public:
         /* ... */
     }
 
-    /* --------------------------------------------------------------------------------------------
-     *
-    */
-    explicit Timestamp(const SLongInt & t);
-
     /* --------------------------------------------------------------------------------------------
      *
     */
@@ -122,18 +117,18 @@ public:
     /* --------------------------------------------------------------------------------------------
      *
     */
-    SQMOD_NODISCARD SLongInt GetMicroseconds() const;
+    SQMOD_NODISCARD SQInteger GetMicroseconds() const;
 
     /* --------------------------------------------------------------------------------------------
      *
     */
-    void SetMicroseconds(const SLongInt & amount);
+    void SetMicroseconds(SQInteger amount);
 
     /* --------------------------------------------------------------------------------------------
      *
     */
-    Timestamp & AddMicroseconds(const SLongInt & amount);
-    Timestamp & SubMicroseconds(const SLongInt & amount);
+    Timestamp & AddMicroseconds(SQInteger amount);
+    Timestamp & SubMicroseconds(SQInteger amount);
 
     /* --------------------------------------------------------------------------------------------
      *
@@ -160,18 +155,18 @@ public:
     /* --------------------------------------------------------------------------------------------
      *
     */
-    SQMOD_NODISCARD SLongInt GetMilliseconds() const;
+    SQMOD_NODISCARD SQInteger GetMilliseconds() const;
 
     /* --------------------------------------------------------------------------------------------
      *
     */
-    void SetMilliseconds(const SLongInt & amount);
+    void SetMilliseconds(SQInteger amount);
 
     /* --------------------------------------------------------------------------------------------
      *
     */
-    Timestamp & AddMilliseconds(const SLongInt & amount);
-    Timestamp & SubMilliseconds(const SLongInt & amount);
+    Timestamp & AddMilliseconds(SQInteger amount);
+    Timestamp & SubMilliseconds(SQInteger amount);
 
     /* --------------------------------------------------------------------------------------------
      *
@@ -244,7 +239,7 @@ public:
     */
     SQMOD_NODISCARD SQFloat GetMinutesF() const
     {
-        return SQFloat(m_Timestamp / 60000000.0);
+        return SQFloat(m_Timestamp) / 60000000.0;
     }
 
     /* --------------------------------------------------------------------------------------------
@@ -288,7 +283,7 @@ public:
     */
     SQMOD_NODISCARD SQFloat GetHoursF() const
     {
-        return SQFloat(m_Timestamp / 3600000000.0);
+        return SQFloat(m_Timestamp) / 3600000000.0;
     }
 
     /* --------------------------------------------------------------------------------------------
@@ -332,7 +327,7 @@ public:
     */
     SQMOD_NODISCARD SQFloat GetDaysF() const
     {
-        return SQFloat(m_Timestamp / 86400000000.0);
+        return SQFloat(m_Timestamp) / 86400000000.0;
     }
 
     /* --------------------------------------------------------------------------------------------
@@ -376,7 +371,7 @@ public:
     */
     SQMOD_NODISCARD SQFloat GetYearsF() const
     {
-        return SQFloat(m_Timestamp / 31557600000000.0);
+        return SQFloat(m_Timestamp) / 31557600000000.0;
     }
 
     /* --------------------------------------------------------------------------------------------
@@ -466,7 +461,7 @@ public:
     /* --------------------------------------------------------------------------------------------
      *
     */
-    std::time_t ToTimeT() const;
+    SQMOD_NODISCARD std::time_t ToTimeT() const;
 
 private:
 

module/Library/DPP.cpp

@@ -0,0 +1,72 @@
+// ------------------------------------------------------------------------------------------------
+#include "Library/DPP.hpp"
+#include "Library/DPP/Cluster.hpp"
+
+// ------------------------------------------------------------------------------------------------
+#include <sqratConst.h>
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+// ------------------------------------------------------------------------------------------------
+void TerminateDPP()
+{
+    // Go over all clusters and try to terminate them
+    for (DpCluster * inst = DpCluster::sHead; inst && inst->mNext != DpCluster::sHead; inst = inst->mNext)
+    {
+        inst->Terminate(); // Terminate() the cluster
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void ProcessDPP()
+{
+    // Go over all clusters and allow them to process data
+    for (DpCluster * inst = DpCluster::sHead; inst && inst->mNext != DpCluster::sHead; inst = inst->mNext)
+    {
+        inst->Process();
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+extern void Register_DPP_Channel(HSQUIRRELVM vm, Table & ns);
+extern void Register_DPP_Client(HSQUIRRELVM vm, Table & ns);
+extern void Register_DPP_Cluster(HSQUIRRELVM vm, Table & ns);
+extern void Register_DPP_Command(HSQUIRRELVM vm, Table & ns);
+extern void Register_DPP_Constants(HSQUIRRELVM vm, Table & ns);
+extern void Register_DPP_Events(HSQUIRRELVM vm, Table & ns);
+extern void Register_DPP_Guild(HSQUIRRELVM vm, Table & ns);
+extern void Register_DPP_Integration(HSQUIRRELVM vm, Table & ns);
+extern void Register_DPP_Message(HSQUIRRELVM vm, Table & ns);
+extern void Register_DPP_Other(HSQUIRRELVM vm, Table & ns);
+extern void Register_DPP_Role(HSQUIRRELVM vm, Table & ns);
+extern void Register_DPP_User(HSQUIRRELVM vm, Table & ns);
+
+// ================================================================================================
+void Register_DPP(HSQUIRRELVM vm)
+{
+    Table ns(vm);
+    // --------------------------------------------------------------------------------------------
+    Register_DPP_Constants(vm, ns);
+    Register_DPP_Client(vm, ns);
+    Register_DPP_Integration(vm, ns);
+    Register_DPP_Command(vm, ns);
+    Register_DPP_Message(vm, ns);
+    Register_DPP_Channel(vm, ns);
+    Register_DPP_Other(vm, ns);
+    Register_DPP_Role(vm, ns);
+    Register_DPP_User(vm, ns);
+    Register_DPP_Guild(vm, ns);
+    {
+        Table ens(vm);
+        Register_DPP_Events(vm, ens);
+        ns.Bind(_SC("Events"), ens);
+    }
+    Register_DPP_Cluster(vm, ns);
+    // --------------------------------------------------------------------------------------------
+    ns.Func(_SC("HasVoice"), dpp::utility::has_voice);
+    // --------------------------------------------------------------------------------------------
+    RootTable(vm).Bind(_SC("SqDiscord"), ns);
+}
+
+} // Namespace:: SqMod

module/Library/DPP.hpp

@@ -1,11 +1,12 @@
 #pragma once
 
 // ------------------------------------------------------------------------------------------------
-#include "Core/Common.hpp"
+#include "Core/Utility.hpp"
+
+// ------------------------------------------------------------------------------------------------
+
 
 // ------------------------------------------------------------------------------------------------
 namespace SqMod {
 
-
-
 } // Namespace:: SqMod

module/Library/DPP/Channel.cpp

@@ -1,5 +1,5 @@
 // ------------------------------------------------------------------------------------------------
-#include "PocoLib/XML.hpp"
+#include "Library/DPP/Channel.hpp"
 
 // ------------------------------------------------------------------------------------------------
 namespace SqMod {
@@ -7,12 +7,10 @@ namespace SqMod {
 // ------------------------------------------------------------------------------------------------
 
 
-// ================================================================================================
-void Register_POCO_XML(HSQUIRRELVM vm, Table &)
+// ------------------------------------------------------------------------------------------------
+void Register_DPP_Channel(HSQUIRRELVM vm, Table & ns)
 {
-    //Table ns(vm);
 
-    //RootTable(vm).Bind(_SC("SqXML"), ns);
 }
 
 } // Namespace:: SqMod

module/Library/DPP/Channel.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+// ------------------------------------------------------------------------------------------------
+#include "Core/Utility.hpp"
+
+// ------------------------------------------------------------------------------------------------
+#include <chrono>
+
+// ------------------------------------------------------------------------------------------------
+#include <dpp/dpp.h>
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+/* ------------------------------------------------------------------------------------------------
+ * 
+*/
+
+} // Namespace:: SqMod

module/Library/DPP/Client.cpp

@@ -1,5 +1,5 @@
 // ------------------------------------------------------------------------------------------------
-#include "PocoLib/JSON.hpp"
+#include "Library/DPP/Client.hpp"
 
 // ------------------------------------------------------------------------------------------------
 namespace SqMod {
@@ -7,12 +7,10 @@ namespace SqMod {
 // ------------------------------------------------------------------------------------------------
 
 
-// ================================================================================================
-void Register_POCO_JSON(HSQUIRRELVM vm, Table &)
+// ------------------------------------------------------------------------------------------------
+void Register_DPP_Client(HSQUIRRELVM vm, Table & ns)
 {
-    //Table ns(vm);
 
-    //RootTable(vm).Bind(_SC("SqJSON"), ns);
 }
 
 } // Namespace:: SqMod

module/Library/DPP/Client.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+// ------------------------------------------------------------------------------------------------
+#include "Core/Utility.hpp"
+
+// ------------------------------------------------------------------------------------------------
+#include <chrono>
+
+// ------------------------------------------------------------------------------------------------
+#include <dpp/dpp.h>
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+/* ------------------------------------------------------------------------------------------------
+ * 
+*/
+
+} // Namespace:: SqMod

module/Library/DPP/Cluster.cpp

@@ -0,0 +1,757 @@
+// ------------------------------------------------------------------------------------------------
+#include "Library/DPP/Cluster.hpp"
+#include "Library/DPP/Events.hpp"
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+// ------------------------------------------------------------------------------------------------
+SQMOD_DECL_TYPENAME(SqDppCluster, _SC("SqDppCluster"))
+
+// ------------------------------------------------------------------------------------------------
+void Register_DPP_Cluster(HSQUIRRELVM vm, Table & ns)
+{
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("Cluster"),
+        Class< DpCluster, NoCopy< DpCluster > >(vm, SqDppCluster::Str)
+        // Constructors
+        .Ctor< StackStrF & >()
+        .Ctor< StackStrF &, SQInteger >()
+        .Ctor< StackStrF &, SQInteger, SQInteger >()
+        .Ctor< StackStrF &, SQInteger, SQInteger, SQInteger >()
+        .Ctor< StackStrF &, SQInteger, SQInteger, SQInteger, SQInteger >()
+        .Ctor< StackStrF &, SQInteger, SQInteger, SQInteger, SQInteger, bool >()
+        .Ctor< StackStrF &, SQInteger, SQInteger, SQInteger, SQInteger, bool, const DpCachePolicy & >()
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppCluster::Fn)
+        // Member Properties
+        .Prop(_SC("On"), &DpCluster::GetEvents)
+        .Prop(_SC("UpTime"), &DpCluster::UpTime)
+        // Member Methods
+        .Func(_SC("Start"), &DpCluster::Start)
+        .Func(_SC("Log"), &DpCluster::Log)
+        .Func(_SC("GetDmChannel"), &DpCluster::GetDmChannel)
+        .Func(_SC("SetDmChannel"), &DpCluster::SetDmChannel)
+        .Func(_SC("SetPresence"), &DpCluster::SetPresence)
+        .Func(_SC("EnableEvent"), &DpCluster::EnableEvent)
+        .Func(_SC("DisableEvent"), &DpCluster::DisableEvent)
+    );
+}
+
+// ------------------------------------------------------------------------------------------------
+SQMOD_NODISCARD LightObj EventToScriptObject(uint8_t type, uintptr_t data);
+void EventInvokeCleanup(uint8_t type, uintptr_t data);
+
+// ------------------------------------------------------------------------------------------------
+void DpCluster::Process(bool force)
+{
+    // Is there a valid connection?
+    if (!mC && !force)
+    {
+        return; // No point in going forward
+    }
+    DpInternalEvent event;
+    // Retrieve each event individually and process it
+    for (size_t count = mQueue.size_approx(), n = 0; n <= count; ++n)
+    {
+        // Try to get an event from the queue
+        if (mQueue.try_dequeue(event))
+        {
+            // Fetch the type of event
+            const auto type = event.GetType();
+            // Fetch the event itself
+            const auto data = event.GetData();
+            // Is this a valid event and is anyone listening to it?
+            if (event.mData == 0 || mEvents[type].first == nullptr || mEvents[type].first->IsEmpty())
+            {
+                continue; // Move on
+            }
+            // Transform the event instance into a script object
+            LightObj obj = EventToScriptObject(type, data);
+            // Allow the script to take ownership of the event instance now
+            event.Reset();
+            // Forward the call to the associated signal
+            (*mEvents[type].first)(obj);
+            // Allow the event instance to clean itself
+            EventInvokeCleanup(type, data);
+        }
+    }
+}
+
+/* ================================================================================================
+ * Event handlers.
+*/
+void DpCluster::OnVoiceStateUpdate(const dpp::voice_state_update_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::VoiceStateUpdate, new DpVoiceStateUpdateEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnLog(const dpp::log_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::Log, new DpLogEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnGuildJoinRequestDelete(const dpp::guild_join_request_delete_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::GuildJoinRequestDelete, new DpGuildJoinRequestDeleteEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnInteractionCreate(const dpp::interaction_create_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::InteractionCreate, new DpInteractionCreateEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnButtonClick(const dpp::button_click_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::ButtonClick, new DpButtonClickEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnSelectClick(const dpp::select_click_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::SelectClick, new DpSelectClickEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnGuildDelete(const dpp::guild_delete_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::GuildDelete, new DpGuildDeleteEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnChannelDelete(const dpp::channel_delete_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::ChannelDelete, new DpChannelDeleteEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnChannelUpdate(const dpp::channel_update_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::ChannelUpdate, new DpChannelUpdateEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnReady(const dpp::ready_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::Ready, new DpReadyEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnMessageDelete(const dpp::message_delete_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::MessageDelete, new DpMessageDeleteEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnApplicationCommandDelete(const dpp::application_command_delete_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::ApplicationCommandDelete, new DpApplicationCommandDeleteEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnGuildMemberRemove(const dpp::guild_member_remove_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::GuildMemberRemove, new DpGuildMemberRemoveEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnApplicationCommandCreate(const dpp::application_command_create_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::ApplicationCommandCreate, new DpApplicationCommandCreateEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnResumed(const dpp::resumed_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::Resumed, new DpResumedEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnGuildRoleCreate(const dpp::guild_role_create_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::GuildRoleCreate, new DpGuildRoleCreateEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnTypingStart(const dpp::typing_start_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::TypingStart, new DpTypingStartEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnMessageReactionAdd(const dpp::message_reaction_add_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::MessageReactionAdd, new DpMessageReactionAddEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnGuildMembersChunk(const dpp::guild_members_chunk_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::GuildMembersChunk, new DpGuildMembersChunkEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnMessageReactionRemove(const dpp::message_reaction_remove_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::MessageReactionRemove, new DpMessageReactionRemoveEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnGuildCreate(const dpp::guild_create_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::GuildCreate, new DpGuildCreateEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnChannelCreate(const dpp::channel_create_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::ChannelCreate, new DpChannelCreateEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnMessageReactionRemoveEmoji(const dpp::message_reaction_remove_emoji_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::MessageReactionRemoveEmoji, new DpMessageReactionRemoveEmojiEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnMessageDeleteBulk(const dpp::message_delete_bulk_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::MessageDeleteBulk, new DpMessageDeleteBulkEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnGuildRoleUpdate(const dpp::guild_role_update_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::GuildRoleUpdate, new DpGuildRoleUpdateEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnGuildRoleDelete(const dpp::guild_role_delete_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::GuildRoleDelete, new DpGuildRoleDeleteEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnChannelPinsUpdate(const dpp::channel_pins_update_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::ChannelPinsUpdate, new DpChannelPinsUpdateEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnMessageReactionRemoveAll(const dpp::message_reaction_remove_all_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::MessageReactionRemoveAll, new DpMessageReactionRemoveAllEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnVoiceServerUpdate(const dpp::voice_server_update_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::VoiceServerUpdate, new DpVoiceServerUpdateEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnGuildEmojisUpdate(const dpp::guild_emojis_update_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::GuildEmojisUpdate, new DpGuildEmojisUpdateEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnGuildStickersUpdate(const dpp::guild_stickers_update_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::GuildStickersUpdate, new DpGuildStickersUpdateEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnPresenceUpdate(const dpp::presence_update_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::PresenceUpdate, new DpPresenceUpdateEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnWebhooksUpdate(const dpp::webhooks_update_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::WebhooksUpdate, new DpWebhooksUpdateEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnGuildMemberAdd(const dpp::guild_member_add_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::GuildMemberAdd, new DpGuildMemberAddEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnInviteDelete(const dpp::invite_delete_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::InviteDelete, new DpInviteDeleteEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnGuildUpdate(const dpp::guild_update_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::GuildUpdate, new DpGuildUpdateEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnGuildIntegrationsUpdate(const dpp::guild_integrations_update_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::GuildIntegrationsUpdate, new DpGuildIntegrationsUpdateEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnGuildMemberUpdate(const dpp::guild_member_update_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::GuildMemberUpdate, new DpGuildMemberUpdateEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnApplicationCommandUpdate(const dpp::application_command_update_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::ApplicationCommandUpdate, new DpApplicationCommandUpdateEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnInviteCreate(const dpp::invite_create_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::InviteCreate, new DpInviteCreateEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnMessageUpdate(const dpp::message_update_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::MessageUpdate, new DpMessageUpdateEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnUserUpdate(const dpp::user_update_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::UserUpdate, new DpUserUpdateEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnMessageCreate(const dpp::message_create_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::MessageCreate, new DpMessageCreateEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnGuildBanAdd(const dpp::guild_ban_add_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::GuildBanAdd, new DpGuildBanAddEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnGuildBanRemove(const dpp::guild_ban_remove_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::GuildBanRemove, new DpGuildBanRemoveEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnIntegrationCreate(const dpp::integration_create_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::IntegrationCreate, new DpIntegrationCreateEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnIntegrationUpdate(const dpp::integration_update_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::IntegrationUpdate, new DpIntegrationUpdateEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnIntegrationDelete(const dpp::integration_delete_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::IntegrationDelete, new DpIntegrationDeleteEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnThreadCreate(const dpp::thread_create_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::ThreadCreate, new DpThreadCreateEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnThreadUpdate(const dpp::thread_update_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::ThreadUpdate, new DpThreadUpdateEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnThreadDelete(const dpp::thread_delete_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::ThreadDelete, new DpThreadDeleteEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnThreadListSync(const dpp::thread_list_sync_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::ThreadListSync, new DpThreadListSyncEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnThreadMemberUpdate(const dpp::thread_member_update_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::ThreadMemberUpdate, new DpThreadMemberUpdateEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnThreadMembersUpdate(const dpp::thread_members_update_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::ThreadMembersUpdate, new DpThreadMembersUpdateEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnVoiceBufferSend(const dpp::voice_buffer_send_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::VoiceBufferSend, new DpVoiceBufferSendEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnVoiceUserTalking(const dpp::voice_user_talking_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::VoiceUserTalking, new DpVoiceUserTalkingEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnVoiceReady(const dpp::voice_ready_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::VoiceReady, new DpVoiceReadyEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnVoiceReceive(const dpp::voice_receive_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::VoiceReceive, new DpVoiceReceiveEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnVoiceTrackMarker(const dpp::voice_track_marker_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::VoiceTrackMarker, new DpVoiceTrackMarkerEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnStageInstanceCreate(const dpp::stage_instance_create_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::StageInstanceCreate, new DpStageInstanceCreateEvent(ev)));
+}
+// ------------------------------------------------------------------------------------------------
+void DpCluster::OnStageInstanceDelete(const dpp::stage_instance_delete_t & ev)
+{
+    mQueue.enqueue(DpInternalEvent(DpEventID::StageInstanceDelete, new DpStageInstanceDeleteEvent(ev)));
+}
+
+// ------------------------------------------------------------------------------------------------
+DpCluster & DpCluster::EnableEvent(SQInteger id)
+{
+    switch (id)
+    {
+        case DpEventID::VoiceStateUpdate:           mC->on_voice_state_update([this](auto && e) { OnVoiceStateUpdate(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::Log:                        mC->on_log([this](auto && e) { OnLog(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::GuildJoinRequestDelete:     mC->on_guild_join_request_delete([this](auto && e) { OnGuildJoinRequestDelete(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::InteractionCreate:          mC->on_interaction_create([this](auto && e) { OnInteractionCreate(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::ButtonClick:                mC->on_button_click([this](auto && e) { OnButtonClick(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::SelectClick:                mC->on_select_click([this](auto && e) { OnSelectClick(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::GuildDelete:                mC->on_guild_delete([this](auto && e) { OnGuildDelete(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::ChannelDelete:              mC->on_channel_delete([this](auto && e) { OnChannelDelete(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::ChannelUpdate:              mC->on_channel_update([this](auto && e) { OnChannelUpdate(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::Ready:                      mC->on_ready([this](auto && e) { OnReady(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::MessageDelete:              mC->on_message_delete([this](auto && e) { OnMessageDelete(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::ApplicationCommandDelete:   mC->on_application_command_delete([this](auto && e) { OnApplicationCommandDelete(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::GuildMemberRemove:          mC->on_guild_member_remove([this](auto && e) { OnGuildMemberRemove(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::ApplicationCommandCreate:   mC->on_application_command_create([this](auto && e) { OnApplicationCommandCreate(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::Resumed:                    mC->on_resumed([this](auto && e) { OnResumed(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::GuildRoleCreate:            mC->on_guild_role_create([this](auto && e) { OnGuildRoleCreate(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::TypingStart:                mC->on_typing_start([this](auto && e) { OnTypingStart(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::MessageReactionAdd:         mC->on_message_reaction_add([this](auto && e) { OnMessageReactionAdd(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::GuildMembersChunk:          mC->on_guild_members_chunk([this](auto && e) { OnGuildMembersChunk(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::MessageReactionRemove:      mC->on_message_reaction_remove([this](auto && e) { OnMessageReactionRemove(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::GuildCreate:                mC->on_guild_create([this](auto && e) { OnGuildCreate(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::ChannelCreate:              mC->on_channel_create([this](auto && e) { OnChannelCreate(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::MessageReactionRemoveEmoji: mC->on_message_reaction_remove_emoji([this](auto && e) { OnMessageReactionRemoveEmoji(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::MessageDeleteBulk:          mC->on_message_delete_bulk([this](auto && e) { OnMessageDeleteBulk(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::GuildRoleUpdate:            mC->on_guild_role_update([this](auto && e) { OnGuildRoleUpdate(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::GuildRoleDelete:            mC->on_guild_role_delete([this](auto && e) { OnGuildRoleDelete(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::ChannelPinsUpdate:          mC->on_channel_pins_update([this](auto && e) { OnChannelPinsUpdate(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::MessageReactionRemoveAll:   mC->on_message_reaction_remove_all([this](auto && e) { OnMessageReactionRemoveAll(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::VoiceServerUpdate:          mC->on_voice_server_update([this](auto && e) { OnVoiceServerUpdate(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::GuildEmojisUpdate:          mC->on_guild_emojis_update([this](auto && e) { OnGuildEmojisUpdate(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::GuildStickersUpdate:        mC->on_guild_stickers_update([this](auto && e) { OnGuildStickersUpdate(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::PresenceUpdate:             mC->on_presence_update([this](auto && e) { OnPresenceUpdate(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::WebhooksUpdate:             mC->on_webhooks_update([this](auto && e) { OnWebhooksUpdate(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::GuildMemberAdd:             mC->on_guild_member_add([this](auto && e) { OnGuildMemberAdd(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::InviteDelete:               mC->on_invite_delete([this](auto && e) { OnInviteDelete(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::GuildUpdate:                mC->on_guild_update([this](auto && e) { OnGuildUpdate(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::GuildIntegrationsUpdate:    mC->on_guild_integrations_update([this](auto && e) { OnGuildIntegrationsUpdate(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::GuildMemberUpdate:          mC->on_guild_member_update([this](auto && e) { OnGuildMemberUpdate(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::ApplicationCommandUpdate:   mC->on_application_command_update([this](auto && e) { OnApplicationCommandUpdate(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::InviteCreate:               mC->on_invite_create([this](auto && e) { OnInviteCreate(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::MessageUpdate:              mC->on_message_update([this](auto && e) { OnMessageUpdate(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::UserUpdate:                 mC->on_user_update([this](auto && e) { OnUserUpdate(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::MessageCreate:              mC->on_message_create([this](auto && e) { OnMessageCreate(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::GuildBanAdd:                mC->on_guild_ban_add([this](auto && e) { OnGuildBanAdd(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::GuildBanRemove:             mC->on_guild_ban_remove([this](auto && e) { OnGuildBanRemove(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::IntegrationCreate:          mC->on_integration_create([this](auto && e) { OnIntegrationCreate(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::IntegrationUpdate:          mC->on_integration_update([this](auto && e) { OnIntegrationUpdate(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::IntegrationDelete:          mC->on_integration_delete([this](auto && e) { OnIntegrationDelete(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::ThreadCreate:               mC->on_thread_create([this](auto && e) { OnThreadCreate(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::ThreadUpdate:               mC->on_thread_update([this](auto && e) { OnThreadUpdate(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::ThreadDelete:               mC->on_thread_delete([this](auto && e) { OnThreadDelete(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::ThreadListSync:             mC->on_thread_list_sync([this](auto && e) { OnThreadListSync(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::ThreadMemberUpdate:         mC->on_thread_member_update([this](auto && e) { OnThreadMemberUpdate(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::ThreadMembersUpdate:        mC->on_thread_members_update([this](auto && e) { OnThreadMembersUpdate(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::VoiceBufferSend:            mC->on_voice_buffer_send([this](auto && e) { OnVoiceBufferSend(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::VoiceUserTalking:           mC->on_voice_user_talking([this](auto && e) { OnVoiceUserTalking(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::VoiceReady:                 mC->on_voice_ready([this](auto && e) { OnVoiceReady(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::VoiceReceive:               mC->on_voice_receive([this](auto && e) { OnVoiceReceive(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::VoiceTrackMarker:           mC->on_voice_track_marker([this](auto && e) { OnVoiceTrackMarker(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::StageInstanceCreate:        mC->on_stage_instance_create([this](auto && e) { OnStageInstanceCreate(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::StageInstanceDelete:        mC->on_stage_instance_delete([this](auto && e) { OnStageInstanceDelete(std::forward< decltype(e) >(e)); }); break;
+        case DpEventID::Max: // Fall through
+        default: STHROWF("Invalid discord event identifier {}", id);
+    }
+    // Allow chaining
+    return *this;
+}
+
+// ------------------------------------------------------------------------------------------------
+DpCluster & DpCluster::DisableEvent(SQInteger id)
+{
+    switch (id)
+    {
+        case DpEventID::VoiceStateUpdate:           mC->on_voice_state_update(std::function<void(const dpp::voice_state_update_t&)>{}); break;
+        case DpEventID::Log:                        mC->on_log(std::function<void(const dpp::log_t&)>{}); break;
+        case DpEventID::GuildJoinRequestDelete:     mC->on_guild_join_request_delete(std::function<void(const dpp::guild_join_request_delete_t&)>{}); break;
+        case DpEventID::InteractionCreate:          mC->on_interaction_create(std::function<void(const dpp::interaction_create_t&)>{}); break;
+        case DpEventID::ButtonClick:                mC->on_button_click(std::function<void(const dpp::button_click_t&)>{}); break;
+        case DpEventID::SelectClick:                mC->on_select_click(std::function<void(const dpp::select_click_t&)>{}); break;
+        case DpEventID::GuildDelete:                mC->on_guild_delete(std::function<void(const dpp::guild_delete_t&)>{}); break;
+        case DpEventID::ChannelDelete:              mC->on_channel_delete(std::function<void(const dpp::channel_delete_t&)>{}); break;
+        case DpEventID::ChannelUpdate:              mC->on_channel_update(std::function<void(const dpp::channel_update_t&)>{}); break;
+        case DpEventID::Ready:                      mC->on_ready(std::function<void(const dpp::ready_t&)>{}); break;
+        case DpEventID::MessageDelete:              mC->on_message_delete(std::function<void(const dpp::message_delete_t&)>{}); break;
+        case DpEventID::ApplicationCommandDelete:   mC->on_application_command_delete(std::function<void(const dpp::application_command_delete_t&)>{}); break;
+        case DpEventID::GuildMemberRemove:          mC->on_guild_member_remove(std::function<void(const dpp::guild_member_remove_t&)>{}); break;
+        case DpEventID::ApplicationCommandCreate:   mC->on_application_command_create(std::function<void(const dpp::application_command_create_t&)>{}); break;
+        case DpEventID::Resumed:                    mC->on_resumed(std::function<void(const dpp::resumed_t&)>{}); break;
+        case DpEventID::GuildRoleCreate:            mC->on_guild_role_create(std::function<void(const dpp::guild_role_create_t&)>{}); break;
+        case DpEventID::TypingStart:                mC->on_typing_start(std::function<void(const dpp::typing_start_t&)>{}); break;
+        case DpEventID::MessageReactionAdd:         mC->on_message_reaction_add(std::function<void(const dpp::message_reaction_add_t&)>{}); break;
+        case DpEventID::GuildMembersChunk:          mC->on_guild_members_chunk(std::function<void(const dpp::guild_members_chunk_t&)>{}); break;
+        case DpEventID::MessageReactionRemove:      mC->on_message_reaction_remove(std::function<void(const dpp::message_reaction_remove_t&)>{}); break;
+        case DpEventID::GuildCreate:                mC->on_guild_create(std::function<void(const dpp::guild_create_t&)>{}); break;
+        case DpEventID::ChannelCreate:              mC->on_channel_create(std::function<void(const dpp::channel_create_t&)>{}); break;
+        case DpEventID::MessageReactionRemoveEmoji: mC->on_message_reaction_remove_emoji(std::function<void(const dpp::message_reaction_remove_emoji_t&)>{}); break;
+        case DpEventID::MessageDeleteBulk:          mC->on_message_delete_bulk(std::function<void(const dpp::message_delete_bulk_t&)>{}); break;
+        case DpEventID::GuildRoleUpdate:            mC->on_guild_role_update(std::function<void(const dpp::guild_role_update_t&)>{}); break;
+        case DpEventID::GuildRoleDelete:            mC->on_guild_role_delete(std::function<void(const dpp::guild_role_delete_t&)>{}); break;
+        case DpEventID::ChannelPinsUpdate:          mC->on_channel_pins_update(std::function<void(const dpp::channel_pins_update_t&)>{}); break;
+        case DpEventID::MessageReactionRemoveAll:   mC->on_message_reaction_remove_all(std::function<void(const dpp::message_reaction_remove_all_t&)>{}); break;
+        case DpEventID::VoiceServerUpdate:          mC->on_voice_server_update(std::function<void(const dpp::voice_server_update_t&)>{}); break;
+        case DpEventID::GuildEmojisUpdate:          mC->on_guild_emojis_update(std::function<void(const dpp::guild_emojis_update_t&)>{}); break;
+        case DpEventID::GuildStickersUpdate:        mC->on_guild_stickers_update(std::function<void(const dpp::guild_stickers_update_t&)>{}); break;
+        case DpEventID::PresenceUpdate:             mC->on_presence_update(std::function<void(const dpp::presence_update_t&)>{}); break;
+        case DpEventID::WebhooksUpdate:             mC->on_webhooks_update(std::function<void(const dpp::webhooks_update_t&)>{}); break;
+        case DpEventID::GuildMemberAdd:             mC->on_guild_member_add(std::function<void(const dpp::guild_member_add_t&)>{}); break;
+        case DpEventID::InviteDelete:               mC->on_invite_delete(std::function<void(const dpp::invite_delete_t&)>{}); break;
+        case DpEventID::GuildUpdate:                mC->on_guild_update(std::function<void(const dpp::guild_update_t&)>{}); break;
+        case DpEventID::GuildIntegrationsUpdate:    mC->on_guild_integrations_update(std::function<void(const dpp::guild_integrations_update_t&)>{}); break;
+        case DpEventID::GuildMemberUpdate:          mC->on_guild_member_update(std::function<void(const dpp::guild_member_update_t&)>{}); break;
+        case DpEventID::ApplicationCommandUpdate:   mC->on_application_command_update(std::function<void(const dpp::application_command_update_t&)>{}); break;
+        case DpEventID::InviteCreate:               mC->on_invite_create(std::function<void(const dpp::invite_create_t&)>{}); break;
+        case DpEventID::MessageUpdate:              mC->on_message_update(std::function<void(const dpp::message_update_t&)>{}); break;
+        case DpEventID::UserUpdate:                 mC->on_user_update(std::function<void(const dpp::user_update_t&)>{}); break;
+        case DpEventID::MessageCreate:              mC->on_message_create(std::function<void(const dpp::message_create_t&)>{}); break;
+        case DpEventID::GuildBanAdd:                mC->on_guild_ban_add(std::function<void(const dpp::guild_ban_add_t&)>{}); break;
+        case DpEventID::GuildBanRemove:             mC->on_guild_ban_remove(std::function<void(const dpp::guild_ban_remove_t&)>{}); break;
+        case DpEventID::IntegrationCreate:          mC->on_integration_create(std::function<void(const dpp::integration_create_t&)>{}); break;
+        case DpEventID::IntegrationUpdate:          mC->on_integration_update(std::function<void(const dpp::integration_update_t&)>{}); break;
+        case DpEventID::IntegrationDelete:          mC->on_integration_delete(std::function<void(const dpp::integration_delete_t&)>{}); break;
+        case DpEventID::ThreadCreate:               mC->on_thread_create(std::function<void(const dpp::thread_create_t&)>{}); break;
+        case DpEventID::ThreadUpdate:               mC->on_thread_update(std::function<void(const dpp::thread_update_t&)>{}); break;
+        case DpEventID::ThreadDelete:               mC->on_thread_delete(std::function<void(const dpp::thread_delete_t&)>{}); break;
+        case DpEventID::ThreadListSync:             mC->on_thread_list_sync(std::function<void(const dpp::thread_list_sync_t&)>{}); break;
+        case DpEventID::ThreadMemberUpdate:         mC->on_thread_member_update(std::function<void(const dpp::thread_member_update_t&)>{}); break;
+        case DpEventID::ThreadMembersUpdate:        mC->on_thread_members_update(std::function<void(const dpp::thread_members_update_t&)>{}); break;
+        case DpEventID::VoiceBufferSend:            mC->on_voice_buffer_send(std::function<void(const dpp::voice_buffer_send_t&)>{}); break;
+        case DpEventID::VoiceUserTalking:           mC->on_voice_user_talking(std::function<void(const dpp::voice_user_talking_t&)>{}); break;
+        case DpEventID::VoiceReady:                 mC->on_voice_ready(std::function<void(const dpp::voice_ready_t&)>{}); break;
+        case DpEventID::VoiceReceive:               mC->on_voice_receive(std::function<void(const dpp::voice_receive_t&)>{}); break;
+        case DpEventID::VoiceTrackMarker:           mC->on_voice_track_marker(std::function<void(const dpp::voice_track_marker_t&)>{}); break;
+        case DpEventID::StageInstanceCreate:        mC->on_stage_instance_create(std::function<void(const dpp::stage_instance_create_t&)>{}); break;
+        case DpEventID::StageInstanceDelete:        mC->on_stage_instance_delete(std::function<void(const dpp::stage_instance_delete_t&)>{}); break;
+        case DpEventID::Max: // Fall through
+        default: STHROWF("Invalid discord event identifier {}", id);
+    }
+    // Allow chaining
+    return *this;
+}
+
+// ------------------------------------------------------------------------------------------------
+void DpInternalEvent::Release()
+{
+    // Make sure we actually manage something
+    if (mData == 0) return;
+    // Fetch the type of data
+    const auto type = GetType();
+    // Fetch the data itself
+    const auto data = GetData();
+    // Identify data type
+    switch (type)
+    {
+        case DpEventID::VoiceStateUpdate:           delete reinterpret_cast< DpVoiceStateUpdateEvent * >(data); break;
+        case DpEventID::Log:                        delete reinterpret_cast< DpLogEvent * >(data); break;
+        case DpEventID::GuildJoinRequestDelete:     delete reinterpret_cast< DpGuildJoinRequestDeleteEvent * >(data); break;
+        case DpEventID::InteractionCreate:          delete reinterpret_cast< DpInteractionCreateEvent * >(data); break;
+        case DpEventID::ButtonClick:                delete reinterpret_cast< DpButtonClickEvent * >(data); break;
+        case DpEventID::SelectClick:                delete reinterpret_cast< DpSelectClickEvent * >(data); break;
+        case DpEventID::GuildDelete:                delete reinterpret_cast< DpGuildDeleteEvent * >(data); break;
+        case DpEventID::ChannelDelete:              delete reinterpret_cast< DpChannelDeleteEvent * >(data); break;
+        case DpEventID::ChannelUpdate:              delete reinterpret_cast< DpChannelUpdateEvent * >(data); break;
+        case DpEventID::Ready:                      delete reinterpret_cast< DpReadyEvent * >(data); break;
+        case DpEventID::MessageDelete:              delete reinterpret_cast< DpMessageDeleteEvent * >(data); break;
+        case DpEventID::ApplicationCommandDelete:   delete reinterpret_cast< DpApplicationCommandDeleteEvent * >(data); break;
+        case DpEventID::GuildMemberRemove:          delete reinterpret_cast< DpGuildMemberRemoveEvent * >(data); break;
+        case DpEventID::ApplicationCommandCreate:   delete reinterpret_cast< DpApplicationCommandCreateEvent * >(data); break;
+        case DpEventID::Resumed:                    delete reinterpret_cast< DpResumedEvent * >(data); break;
+        case DpEventID::GuildRoleCreate:            delete reinterpret_cast< DpGuildRoleCreateEvent * >(data); break;
+        case DpEventID::TypingStart:                delete reinterpret_cast< DpTypingStartEvent * >(data); break;
+        case DpEventID::MessageReactionAdd:         delete reinterpret_cast< DpMessageReactionAddEvent * >(data); break;
+        case DpEventID::GuildMembersChunk:          delete reinterpret_cast< DpGuildMembersChunkEvent * >(data); break;
+        case DpEventID::MessageReactionRemove:      delete reinterpret_cast< DpMessageReactionRemoveEvent * >(data); break;
+        case DpEventID::GuildCreate:                delete reinterpret_cast< DpGuildCreateEvent * >(data); break;
+        case DpEventID::ChannelCreate:              delete reinterpret_cast< DpChannelCreateEvent * >(data); break;
+        case DpEventID::MessageReactionRemoveEmoji: delete reinterpret_cast< DpMessageReactionRemoveEmojiEvent * >(data); break;
+        case DpEventID::MessageDeleteBulk:          delete reinterpret_cast< DpMessageDeleteBulkEvent * >(data); break;
+        case DpEventID::GuildRoleUpdate:            delete reinterpret_cast< DpGuildRoleUpdateEvent * >(data); break;
+        case DpEventID::GuildRoleDelete:            delete reinterpret_cast< DpGuildRoleDeleteEvent * >(data); break;
+        case DpEventID::ChannelPinsUpdate:          delete reinterpret_cast< DpChannelPinsUpdateEvent * >(data); break;
+        case DpEventID::MessageReactionRemoveAll:   delete reinterpret_cast< DpMessageReactionRemoveAllEvent * >(data); break;
+        case DpEventID::VoiceServerUpdate:          delete reinterpret_cast< DpVoiceServerUpdateEvent * >(data); break;
+        case DpEventID::GuildEmojisUpdate:          delete reinterpret_cast< DpGuildEmojisUpdateEvent * >(data); break;
+        case DpEventID::GuildStickersUpdate:        delete reinterpret_cast< DpGuildStickersUpdateEvent * >(data); break;
+        case DpEventID::PresenceUpdate:             delete reinterpret_cast< DpPresenceUpdateEvent * >(data); break;
+        case DpEventID::WebhooksUpdate:             delete reinterpret_cast< DpWebhooksUpdateEvent * >(data); break;
+        case DpEventID::GuildMemberAdd:             delete reinterpret_cast< DpGuildMemberAddEvent * >(data); break;
+        case DpEventID::InviteDelete:               delete reinterpret_cast< DpInviteDeleteEvent * >(data); break;
+        case DpEventID::GuildUpdate:                delete reinterpret_cast< DpGuildUpdateEvent * >(data); break;
+        case DpEventID::GuildIntegrationsUpdate:    delete reinterpret_cast< DpGuildIntegrationsUpdateEvent * >(data); break;
+        case DpEventID::GuildMemberUpdate:          delete reinterpret_cast< DpGuildMemberUpdateEvent * >(data); break;
+        case DpEventID::ApplicationCommandUpdate:   delete reinterpret_cast< DpApplicationCommandUpdateEvent * >(data); break;
+        case DpEventID::InviteCreate:               delete reinterpret_cast< DpInviteCreateEvent * >(data); break;
+        case DpEventID::MessageUpdate:              delete reinterpret_cast< DpMessageUpdateEvent * >(data); break;
+        case DpEventID::UserUpdate:                 delete reinterpret_cast< DpUserUpdateEvent * >(data); break;
+        case DpEventID::MessageCreate:              delete reinterpret_cast< DpMessageCreateEvent * >(data); break;
+        case DpEventID::GuildBanAdd:                delete reinterpret_cast< DpGuildBanAddEvent * >(data); break;
+        case DpEventID::GuildBanRemove:             delete reinterpret_cast< DpGuildBanRemoveEvent * >(data); break;
+        case DpEventID::IntegrationCreate:          delete reinterpret_cast< DpIntegrationCreateEvent * >(data); break;
+        case DpEventID::IntegrationUpdate:          delete reinterpret_cast< DpIntegrationUpdateEvent * >(data); break;
+        case DpEventID::IntegrationDelete:          delete reinterpret_cast< DpIntegrationDeleteEvent * >(data); break;
+        case DpEventID::ThreadCreate:               delete reinterpret_cast< DpThreadCreateEvent * >(data); break;
+        case DpEventID::ThreadUpdate:               delete reinterpret_cast< DpThreadUpdateEvent * >(data); break;
+        case DpEventID::ThreadDelete:               delete reinterpret_cast< DpThreadDeleteEvent * >(data); break;
+        case DpEventID::ThreadListSync:             delete reinterpret_cast< DpThreadListSyncEvent * >(data); break;
+        case DpEventID::ThreadMemberUpdate:         delete reinterpret_cast< DpThreadMemberUpdateEvent * >(data); break;
+        case DpEventID::ThreadMembersUpdate:        delete reinterpret_cast< DpThreadMembersUpdateEvent * >(data); break;
+        case DpEventID::VoiceBufferSend:            delete reinterpret_cast< DpVoiceBufferSendEvent * >(data); break;
+        case DpEventID::VoiceUserTalking:           delete reinterpret_cast< DpVoiceUserTalkingEvent * >(data); break;
+        case DpEventID::VoiceReady:                 delete reinterpret_cast< DpVoiceReadyEvent * >(data); break;
+        case DpEventID::VoiceReceive:               delete reinterpret_cast< DpVoiceReceiveEvent * >(data); break;
+        case DpEventID::VoiceTrackMarker:           delete reinterpret_cast< DpVoiceTrackMarkerEvent * >(data); break;
+        case DpEventID::StageInstanceCreate:        delete reinterpret_cast< DpStageInstanceCreateEvent * >(data); break;
+        case DpEventID::StageInstanceDelete:        delete reinterpret_cast< DpStageInstanceDeleteEvent * >(data); break;
+        case DpEventID::Max: // Fall through
+        default: LogFtl("Unrecognized discord event instance type"); assert(0); break;
+    }
+    // Forget about it
+    Reset();
+}
+
+// ------------------------------------------------------------------------------------------------
+SQMOD_NODISCARD LightObj EventToScriptObject(uint8_t type, uintptr_t data)
+{
+    switch (type)
+    {
+        case DpEventID::VoiceStateUpdate:           return LightObj(reinterpret_cast< DpVoiceStateUpdateEvent * >(data));
+        case DpEventID::Log:                        return LightObj(reinterpret_cast< DpLogEvent * >(data));
+        case DpEventID::GuildJoinRequestDelete:     return LightObj(reinterpret_cast< DpGuildJoinRequestDeleteEvent * >(data));
+        case DpEventID::InteractionCreate:          return LightObj(reinterpret_cast< DpInteractionCreateEvent * >(data));
+        case DpEventID::ButtonClick:                return LightObj(reinterpret_cast< DpButtonClickEvent * >(data));
+        case DpEventID::SelectClick:                return LightObj(reinterpret_cast< DpSelectClickEvent * >(data));
+        case DpEventID::GuildDelete:                return LightObj(reinterpret_cast< DpGuildDeleteEvent * >(data));
+        case DpEventID::ChannelDelete:              return LightObj(reinterpret_cast< DpChannelDeleteEvent * >(data));
+        case DpEventID::ChannelUpdate:              return LightObj(reinterpret_cast< DpChannelUpdateEvent * >(data));
+        case DpEventID::Ready:                      return LightObj(reinterpret_cast< DpReadyEvent * >(data));
+        case DpEventID::MessageDelete:              return LightObj(reinterpret_cast< DpMessageDeleteEvent * >(data));
+        case DpEventID::ApplicationCommandDelete:   return LightObj(reinterpret_cast< DpApplicationCommandDeleteEvent * >(data));
+        case DpEventID::GuildMemberRemove:          return LightObj(reinterpret_cast< DpGuildMemberRemoveEvent * >(data));
+        case DpEventID::ApplicationCommandCreate:   return LightObj(reinterpret_cast< DpApplicationCommandCreateEvent * >(data));
+        case DpEventID::Resumed:                    return LightObj(reinterpret_cast< DpResumedEvent * >(data));
+        case DpEventID::GuildRoleCreate:            return LightObj(reinterpret_cast< DpGuildRoleCreateEvent * >(data));
+        case DpEventID::TypingStart:                return LightObj(reinterpret_cast< DpTypingStartEvent * >(data));
+        case DpEventID::MessageReactionAdd:         return LightObj(reinterpret_cast< DpMessageReactionAddEvent * >(data));
+        case DpEventID::GuildMembersChunk:          return LightObj(reinterpret_cast< DpGuildMembersChunkEvent * >(data));
+        case DpEventID::MessageReactionRemove:      return LightObj(reinterpret_cast< DpMessageReactionRemoveEvent * >(data));
+        case DpEventID::GuildCreate:                return LightObj(reinterpret_cast< DpGuildCreateEvent * >(data));
+        case DpEventID::ChannelCreate:              return LightObj(reinterpret_cast< DpChannelCreateEvent * >(data));
+        case DpEventID::MessageReactionRemoveEmoji: return LightObj(reinterpret_cast< DpMessageReactionRemoveEmojiEvent * >(data));
+        case DpEventID::MessageDeleteBulk:          return LightObj(reinterpret_cast< DpMessageDeleteBulkEvent * >(data));
+        case DpEventID::GuildRoleUpdate:            return LightObj(reinterpret_cast< DpGuildRoleUpdateEvent * >(data));
+        case DpEventID::GuildRoleDelete:            return LightObj(reinterpret_cast< DpGuildRoleDeleteEvent * >(data));
+        case DpEventID::ChannelPinsUpdate:          return LightObj(reinterpret_cast< DpChannelPinsUpdateEvent * >(data));
+        case DpEventID::MessageReactionRemoveAll:   return LightObj(reinterpret_cast< DpMessageReactionRemoveAllEvent * >(data));
+        case DpEventID::VoiceServerUpdate:          return LightObj(reinterpret_cast< DpVoiceServerUpdateEvent * >(data));
+        case DpEventID::GuildEmojisUpdate:          return LightObj(reinterpret_cast< DpGuildEmojisUpdateEvent * >(data));
+        case DpEventID::GuildStickersUpdate:        return LightObj(reinterpret_cast< DpGuildStickersUpdateEvent * >(data));
+        case DpEventID::PresenceUpdate:             return LightObj(reinterpret_cast< DpPresenceUpdateEvent * >(data));
+        case DpEventID::WebhooksUpdate:             return LightObj(reinterpret_cast< DpWebhooksUpdateEvent * >(data));
+        case DpEventID::GuildMemberAdd:             return LightObj(reinterpret_cast< DpGuildMemberAddEvent * >(data));
+        case DpEventID::InviteDelete:               return LightObj(reinterpret_cast< DpInviteDeleteEvent * >(data));
+        case DpEventID::GuildUpdate:                return LightObj(reinterpret_cast< DpGuildUpdateEvent * >(data));
+        case DpEventID::GuildIntegrationsUpdate:    return LightObj(reinterpret_cast< DpGuildIntegrationsUpdateEvent * >(data));
+        case DpEventID::GuildMemberUpdate:          return LightObj(reinterpret_cast< DpGuildMemberUpdateEvent * >(data));
+        case DpEventID::ApplicationCommandUpdate:   return LightObj(reinterpret_cast< DpApplicationCommandUpdateEvent * >(data));
+        case DpEventID::InviteCreate:               return LightObj(reinterpret_cast< DpInviteCreateEvent * >(data));
+        case DpEventID::MessageUpdate:              return LightObj(reinterpret_cast< DpMessageUpdateEvent * >(data));
+        case DpEventID::UserUpdate:                 return LightObj(reinterpret_cast< DpUserUpdateEvent * >(data));
+        case DpEventID::MessageCreate:              return LightObj(reinterpret_cast< DpMessageCreateEvent * >(data));
+        case DpEventID::GuildBanAdd:                return LightObj(reinterpret_cast< DpGuildBanAddEvent * >(data));
+        case DpEventID::GuildBanRemove:             return LightObj(reinterpret_cast< DpGuildBanRemoveEvent * >(data));
+        case DpEventID::IntegrationCreate:          return LightObj(reinterpret_cast< DpIntegrationCreateEvent * >(data));
+        case DpEventID::IntegrationUpdate:          return LightObj(reinterpret_cast< DpIntegrationUpdateEvent * >(data));
+        case DpEventID::IntegrationDelete:          return LightObj(reinterpret_cast< DpIntegrationDeleteEvent * >(data));
+        case DpEventID::ThreadCreate:               return LightObj(reinterpret_cast< DpThreadCreateEvent * >(data));
+        case DpEventID::ThreadUpdate:               return LightObj(reinterpret_cast< DpThreadUpdateEvent * >(data));
+        case DpEventID::ThreadDelete:               return LightObj(reinterpret_cast< DpThreadDeleteEvent * >(data));
+        case DpEventID::ThreadListSync:             return LightObj(reinterpret_cast< DpThreadListSyncEvent * >(data));
+        case DpEventID::ThreadMemberUpdate:         return LightObj(reinterpret_cast< DpThreadMemberUpdateEvent * >(data));
+        case DpEventID::ThreadMembersUpdate:        return LightObj(reinterpret_cast< DpThreadMembersUpdateEvent * >(data));
+        case DpEventID::VoiceBufferSend:            return LightObj(reinterpret_cast< DpVoiceBufferSendEvent * >(data));
+        case DpEventID::VoiceUserTalking:           return LightObj(reinterpret_cast< DpVoiceUserTalkingEvent * >(data));
+        case DpEventID::VoiceReady:                 return LightObj(reinterpret_cast< DpVoiceReadyEvent * >(data));
+        case DpEventID::VoiceReceive:               return LightObj(reinterpret_cast< DpVoiceReceiveEvent * >(data));
+        case DpEventID::VoiceTrackMarker:           return LightObj(reinterpret_cast< DpVoiceTrackMarkerEvent * >(data));
+        case DpEventID::StageInstanceCreate:        return LightObj(reinterpret_cast< DpStageInstanceCreateEvent * >(data));
+        case DpEventID::StageInstanceDelete:        return LightObj(reinterpret_cast< DpStageInstanceDeleteEvent * >(data));
+        case DpEventID::Max: // Fall through
+        default: assert(0); return LightObj{};
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void EventInvokeCleanup(uint8_t type, uintptr_t data)
+{
+    switch (type)
+    {
+        case DpEventID::VoiceStateUpdate:           reinterpret_cast< DpVoiceStateUpdateEvent * >(data)->Cleanup(); break;
+        case DpEventID::Log:                        reinterpret_cast< DpLogEvent * >(data)->Cleanup(); break;
+        case DpEventID::GuildJoinRequestDelete:     reinterpret_cast< DpGuildJoinRequestDeleteEvent * >(data)->Cleanup(); break;
+        case DpEventID::InteractionCreate:          reinterpret_cast< DpInteractionCreateEvent * >(data)->Cleanup(); break;
+        case DpEventID::ButtonClick:                reinterpret_cast< DpButtonClickEvent * >(data)->Cleanup(); break;
+        case DpEventID::SelectClick:                reinterpret_cast< DpSelectClickEvent * >(data)->Cleanup(); break;
+        case DpEventID::GuildDelete:                reinterpret_cast< DpGuildDeleteEvent * >(data)->Cleanup(); break;
+        case DpEventID::ChannelDelete:              reinterpret_cast< DpChannelDeleteEvent * >(data)->Cleanup(); break;
+        case DpEventID::ChannelUpdate:              reinterpret_cast< DpChannelUpdateEvent * >(data)->Cleanup(); break;
+        case DpEventID::Ready:                      reinterpret_cast< DpReadyEvent * >(data)->Cleanup(); break;
+        case DpEventID::MessageDelete:              reinterpret_cast< DpMessageDeleteEvent * >(data)->Cleanup(); break;
+        case DpEventID::ApplicationCommandDelete:   reinterpret_cast< DpApplicationCommandDeleteEvent * >(data)->Cleanup(); break;
+        case DpEventID::GuildMemberRemove:          reinterpret_cast< DpGuildMemberRemoveEvent * >(data)->Cleanup(); break;
+        case DpEventID::ApplicationCommandCreate:   reinterpret_cast< DpApplicationCommandCreateEvent * >(data)->Cleanup(); break;
+        case DpEventID::Resumed:                    reinterpret_cast< DpResumedEvent * >(data)->Cleanup(); break;
+        case DpEventID::GuildRoleCreate:            reinterpret_cast< DpGuildRoleCreateEvent * >(data)->Cleanup(); break;
+        case DpEventID::TypingStart:                reinterpret_cast< DpTypingStartEvent * >(data)->Cleanup(); break;
+        case DpEventID::MessageReactionAdd:         reinterpret_cast< DpMessageReactionAddEvent * >(data)->Cleanup(); break;
+        case DpEventID::GuildMembersChunk:          reinterpret_cast< DpGuildMembersChunkEvent * >(data)->Cleanup(); break;
+        case DpEventID::MessageReactionRemove:      reinterpret_cast< DpMessageReactionRemoveEvent * >(data)->Cleanup(); break;
+        case DpEventID::GuildCreate:                reinterpret_cast< DpGuildCreateEvent * >(data)->Cleanup(); break;
+        case DpEventID::ChannelCreate:              reinterpret_cast< DpChannelCreateEvent * >(data)->Cleanup(); break;
+        case DpEventID::MessageReactionRemoveEmoji: reinterpret_cast< DpMessageReactionRemoveEmojiEvent * >(data)->Cleanup(); break;
+        case DpEventID::MessageDeleteBulk:          reinterpret_cast< DpMessageDeleteBulkEvent * >(data)->Cleanup(); break;
+        case DpEventID::GuildRoleUpdate:            reinterpret_cast< DpGuildRoleUpdateEvent * >(data)->Cleanup(); break;
+        case DpEventID::GuildRoleDelete:            reinterpret_cast< DpGuildRoleDeleteEvent * >(data)->Cleanup(); break;
+        case DpEventID::ChannelPinsUpdate:          reinterpret_cast< DpChannelPinsUpdateEvent * >(data)->Cleanup(); break;
+        case DpEventID::MessageReactionRemoveAll:   reinterpret_cast< DpMessageReactionRemoveAllEvent * >(data)->Cleanup(); break;
+        case DpEventID::VoiceServerUpdate:          reinterpret_cast< DpVoiceServerUpdateEvent * >(data)->Cleanup(); break;
+        case DpEventID::GuildEmojisUpdate:          reinterpret_cast< DpGuildEmojisUpdateEvent * >(data)->Cleanup(); break;
+        case DpEventID::GuildStickersUpdate:        reinterpret_cast< DpGuildStickersUpdateEvent * >(data)->Cleanup(); break;
+        case DpEventID::PresenceUpdate:             reinterpret_cast< DpPresenceUpdateEvent * >(data)->Cleanup(); break;
+        case DpEventID::WebhooksUpdate:             reinterpret_cast< DpWebhooksUpdateEvent * >(data)->Cleanup(); break;
+        case DpEventID::GuildMemberAdd:             reinterpret_cast< DpGuildMemberAddEvent * >(data)->Cleanup(); break;
+        case DpEventID::InviteDelete:               reinterpret_cast< DpInviteDeleteEvent * >(data)->Cleanup(); break;
+        case DpEventID::GuildUpdate:                reinterpret_cast< DpGuildUpdateEvent * >(data)->Cleanup(); break;
+        case DpEventID::GuildIntegrationsUpdate:    reinterpret_cast< DpGuildIntegrationsUpdateEvent * >(data)->Cleanup(); break;
+        case DpEventID::GuildMemberUpdate:          reinterpret_cast< DpGuildMemberUpdateEvent * >(data)->Cleanup(); break;
+        case DpEventID::ApplicationCommandUpdate:   reinterpret_cast< DpApplicationCommandUpdateEvent * >(data)->Cleanup(); break;
+        case DpEventID::InviteCreate:               reinterpret_cast< DpInviteCreateEvent * >(data)->Cleanup(); break;
+        case DpEventID::MessageUpdate:              reinterpret_cast< DpMessageUpdateEvent * >(data)->Cleanup(); break;
+        case DpEventID::UserUpdate:                 reinterpret_cast< DpUserUpdateEvent * >(data)->Cleanup(); break;
+        case DpEventID::MessageCreate:              reinterpret_cast< DpMessageCreateEvent * >(data)->Cleanup(); break;
+        case DpEventID::GuildBanAdd:                reinterpret_cast< DpGuildBanAddEvent * >(data)->Cleanup(); break;
+        case DpEventID::GuildBanRemove:             reinterpret_cast< DpGuildBanRemoveEvent * >(data)->Cleanup(); break;
+        case DpEventID::IntegrationCreate:          reinterpret_cast< DpIntegrationCreateEvent * >(data)->Cleanup(); break;
+        case DpEventID::IntegrationUpdate:          reinterpret_cast< DpIntegrationUpdateEvent * >(data)->Cleanup(); break;
+        case DpEventID::IntegrationDelete:          reinterpret_cast< DpIntegrationDeleteEvent * >(data)->Cleanup(); break;
+        case DpEventID::ThreadCreate:               reinterpret_cast< DpThreadCreateEvent * >(data)->Cleanup(); break;
+        case DpEventID::ThreadUpdate:               reinterpret_cast< DpThreadUpdateEvent * >(data)->Cleanup(); break;
+        case DpEventID::ThreadDelete:               reinterpret_cast< DpThreadDeleteEvent * >(data)->Cleanup(); break;
+        case DpEventID::ThreadListSync:             reinterpret_cast< DpThreadListSyncEvent * >(data)->Cleanup(); break;
+        case DpEventID::ThreadMemberUpdate:         reinterpret_cast< DpThreadMemberUpdateEvent * >(data)->Cleanup(); break;
+        case DpEventID::ThreadMembersUpdate:        reinterpret_cast< DpThreadMembersUpdateEvent * >(data)->Cleanup(); break;
+        case DpEventID::VoiceBufferSend:            reinterpret_cast< DpVoiceBufferSendEvent * >(data)->Cleanup(); break;
+        case DpEventID::VoiceUserTalking:           reinterpret_cast< DpVoiceUserTalkingEvent * >(data)->Cleanup(); break;
+        case DpEventID::VoiceReady:                 reinterpret_cast< DpVoiceReadyEvent * >(data)->Cleanup(); break;
+        case DpEventID::VoiceReceive:               reinterpret_cast< DpVoiceReceiveEvent * >(data)->Cleanup(); break;
+        case DpEventID::VoiceTrackMarker:           reinterpret_cast< DpVoiceTrackMarkerEvent * >(data)->Cleanup(); break;
+        case DpEventID::StageInstanceCreate:        reinterpret_cast< DpStageInstanceCreateEvent * >(data)->Cleanup(); break;
+        case DpEventID::StageInstanceDelete:        reinterpret_cast< DpStageInstanceDeleteEvent * >(data)->Cleanup(); break;
+        case DpEventID::Max: // Fall through
+        default: assert(0); return;
+    }
+}
+
+} // Namespace:: SqMod

module/Library/DPP/Cluster.hpp

@@ -0,0 +1,431 @@
+#pragma once
+
+// ------------------------------------------------------------------------------------------------
+#include "Core/Utility.hpp"
+#include "Core/Signal.hpp"
+
+// ------------------------------------------------------------------------------------------------
+#include "Library/DPP/Other.hpp"
+#include "Library/DPP/Constants.hpp"
+
+// ------------------------------------------------------------------------------------------------
+#include <chrono>
+#include <memory>
+#include <functional>
+
+// ------------------------------------------------------------------------------------------------
+#include <concurrentqueue.h>
+#include <dpp/dpp.h>
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+/* ------------------------------------------------------------------------------------------------
+ * Internal event proxy.
+*/
+struct DpInternalEvent
+{
+    /* --------------------------------------------------------------------------------------------
+     * Event data.
+    */
+    uint64_t mData{0llu};
+
+    /* --------------------------------------------------------------------------------------------
+     * Default constructor.
+    */
+    DpInternalEvent() noexcept = default;
+
+    /* --------------------------------------------------------------------------------------------
+     * Explicit constructor.
+    */
+    DpInternalEvent(uint64_t type, void * data) noexcept
+        : mData((type << 56u) | reinterpret_cast< uint64_t >(data))
+    {
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Copy constructor (disabled).
+    */
+    DpInternalEvent(const DpInternalEvent & o) = delete;
+
+    /* --------------------------------------------------------------------------------------------
+     * Move constructor.
+    */
+    DpInternalEvent(DpInternalEvent && o) noexcept
+        : mData(o.mData)
+    {
+        o.mData = 0llu; // Take ownership
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Destructor.
+    */
+    ~DpInternalEvent()
+    {
+        Release();
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Copy assignment operator (disabled).
+    */
+    DpInternalEvent & operator = (const DpInternalEvent & o) = delete;
+
+    /* --------------------------------------------------------------------------------------------
+     * Move assignment operator.
+    */
+    DpInternalEvent & operator = (DpInternalEvent && o) noexcept
+    {
+        if (mData != o.mData)
+        {
+            // Release current information
+            Release();
+            // Replicate members
+            mData = o.mData;
+            // Take ownership
+            o.mData = 0llu;
+        }
+        return *this;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Forget about the managed event data.
+    */
+    void Reset() noexcept
+    {
+        mData = 0llu;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the event type.
+    */
+    SQMOD_NODISCARD uint8_t GetType() const noexcept
+    {
+        return static_cast< uint8_t >((mData >> 56u) & 0xFFllu);
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the event data.
+    */
+    SQMOD_NODISCARD uintptr_t GetData() const noexcept
+    {
+        return static_cast< uintptr_t >((~(0xFFllu << 56u)) & mData);
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Release associated event data, if any.
+    */
+    void Release();
+};
+
+/* ------------------------------------------------------------------------------------------------
+ * The cluster class represents a group of shards and a command queue for sending and receiving
+ * commands from discord via HTTP.
+*/
+struct DpCluster : public SqChainedInstances< DpCluster >
+{
+    /* --------------------------------------------------------------------------------------------
+     * Queue of events generated from other threads.
+    */
+    using EventQueue = moodycamel::ConcurrentQueue< DpInternalEvent >;
+
+    /* --------------------------------------------------------------------------------------------
+     * Managed cluster instance.
+    */
+    std::unique_ptr< dpp::cluster > mC{nullptr};
+
+    /* --------------------------------------------------------------------------------------------
+     * Event queue.
+    */
+    EventQueue mQueue{4096};
+
+    /* --------------------------------------------------------------------------------------------
+     * Explicit constructor.
+    */
+    explicit DpCluster(StackStrF & token)
+        : mC(std::make_unique< dpp::cluster >(token.ToStr()))
+        , mQueue(4096)
+    {
+        Initialize();
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Explicit constructor.
+    */
+    DpCluster(StackStrF & token, SQInteger intents)
+        : mC(std::make_unique< dpp::cluster >(token.ToStr(), static_cast< uint32_t >(intents)))
+        , mQueue(4096)
+    {
+        Initialize();
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Explicit constructor.
+    */
+    DpCluster(StackStrF & token, SQInteger intents, SQInteger shards)
+        : mC(std::make_unique< dpp::cluster >(token.ToStr(), static_cast< uint32_t >(intents), static_cast< uint32_t >(shards)))
+        , mQueue(4096)
+    {
+        Initialize();
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Explicit constructor.
+    */
+    DpCluster(StackStrF & token, SQInteger intents, SQInteger shards, SQInteger cluster_id)
+        : mC(std::make_unique< dpp::cluster >(token.ToStr(), static_cast< uint32_t >(intents), static_cast< uint32_t >(shards), static_cast< uint32_t >(cluster_id)))
+        , mQueue(4096)
+    {
+        Initialize();
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Explicit constructor.
+    */
+    DpCluster(StackStrF & token, SQInteger intents, SQInteger shards, SQInteger cluster_id, SQInteger max_clusters)
+        : mC(std::make_unique< dpp::cluster >(token.ToStr(), static_cast< uint32_t >(intents), static_cast< uint32_t >(shards), static_cast< uint32_t >(cluster_id), static_cast< uint32_t >(max_clusters)))
+        , mQueue(4096)
+    {
+        Initialize();
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Explicit constructor.
+    */
+    DpCluster(StackStrF & token, SQInteger intents, SQInteger shards, SQInteger cluster_id, SQInteger max_clusters, bool compressed)
+        : mC(std::make_unique< dpp::cluster >(token.ToStr(), static_cast< uint32_t >(intents), static_cast< uint32_t >(shards), static_cast< uint32_t >(cluster_id), static_cast< uint32_t >(max_clusters), compressed))
+        , mQueue(4096)
+    {
+        Initialize();
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Explicit constructor.
+    */
+    DpCluster(StackStrF & token, SQInteger intents, SQInteger shards, SQInteger cluster_id, SQInteger max_clusters, bool compressed, const DpCachePolicy & cp)
+        : mC(std::make_unique< dpp::cluster >(token.ToStr(), static_cast< uint32_t >(intents), static_cast< uint32_t >(shards), static_cast< uint32_t >(cluster_id), static_cast< uint32_t >(max_clusters), compressed, cp.ToNative()))
+        , mQueue(4096)
+    {
+        Initialize();
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Destructor.
+    */
+    ~DpCluster()
+    {
+        DropEvents();
+        // Forget about this instance
+        UnchainInstance();
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Start the cluster, connecting all its shards. Returns once all shards are connected.
+    */
+    DpCluster & Start()
+    {
+        LogInf("Before start...");
+        mC->start(true);
+        LogInf("After start...");
+        return *this;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Log a message to whatever log the user is using.
+    */
+    DpCluster & Log(SQInteger severity, StackStrF & message)
+    {
+        mC->log(static_cast< dpp::loglevel >(severity), message.ToStr());
+        return *this;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Get the dm channel for a user id.
+    */
+    SQMOD_NODISCARD dpp::snowflake GetDmChannel(dpp::snowflake user_id) const
+    {
+        return mC->get_dm_channel(static_cast< dpp::snowflake >(user_id));
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Set the dm channel id for a user id.
+    */
+    DpCluster & SetDmChannel(dpp::snowflake user_id, dpp::snowflake channel_id)
+    {
+        mC->set_dm_channel(user_id, channel_id);
+        return *this;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Returns the uptime of the cluster.
+    */
+    SQMOD_NODISCARD dpp::utility::uptime UpTime() const
+    {
+        return mC->uptime();
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Returns the uptime of the cluster.
+    */
+    DpCluster & SetPresence(const DpPresence & p)
+    {
+        mC->set_presence(p.Valid());
+        return *this;
+    }
+
+    // --------------------------------------------------------------------------------------------
+    LightObj mSqEvents{}; // Table containing the emitted cluster events.
+
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the events table of this cluster.
+    */
+    SQMOD_NODISCARD LightObj & GetEvents()
+    {
+        return mSqEvents;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Cluster signals.
+    */
+    std::array< SignalPair, static_cast< size_t >(DpEventID::Max) > mEvents{};
+
+    /* --------------------------------------------------------------------------------------------
+     * Process the cluster.
+    */
+    void Process(bool force = false);
+
+    /* --------------------------------------------------------------------------------------------
+     * Terminate the cluster.
+    */
+    void Terminate()
+    {
+        // Delete the cluster instance
+        mC.reset();
+        // Release associated script objects
+        mSqEvents.Release();
+        // Release event signal objects
+        DropEvents();
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Enable a certain event for the cluster.
+    */
+    DpCluster & EnableEvent(SQInteger id);
+
+    /* --------------------------------------------------------------------------------------------
+     * Disable a certain event for the cluster.
+    */
+    DpCluster & DisableEvent(SQInteger id);
+
+private:
+
+    /* --------------------------------------------------------------------------------------------
+     * Initialize the cluster.
+    */
+    void Initialize()
+    {
+        InitEvents();
+        // Remember this instance
+        ChainInstance();
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Signal initialization.
+    */
+    void InitEvents()
+    {
+        // Ignore the call if already initialized
+        if (!mSqEvents.IsNull())
+        {
+            return;
+        }
+        // Create a new table on the stack
+        sq_newtableex(SqVM(), 64);
+        // Grab the table object from the stack
+        mSqEvents = LightObj(-1, SqVM());
+        // Pop the table object from the stack
+        sq_pop(SqVM(), 1);
+        // Proceed to initializing the events
+        for (size_t i = 0; i < mEvents.size(); ++i)
+        {
+            InitSignalPair(mEvents[i], mSqEvents, DpEventID::NAME[i]);
+        }
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Signal termination.
+    */
+    void DropEvents()
+    {
+        for (auto & e : mEvents)
+        {
+            ResetSignalPair(e);
+        }
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Event handlers.
+    */
+    void OnVoiceStateUpdate(const dpp::voice_state_update_t & ev);
+    void OnLog(const dpp::log_t & ev);
+    void OnGuildJoinRequestDelete(const dpp::guild_join_request_delete_t & ev);
+    void OnInteractionCreate(const dpp::interaction_create_t & ev);
+    void OnButtonClick(const dpp::button_click_t & ev);
+    void OnSelectClick(const dpp::select_click_t & ev);
+    void OnGuildDelete(const dpp::guild_delete_t & ev);
+    void OnChannelDelete(const dpp::channel_delete_t & ev);
+    void OnChannelUpdate(const dpp::channel_update_t & ev);
+    void OnReady(const dpp::ready_t & ev);
+    void OnMessageDelete(const dpp::message_delete_t & ev);
+    void OnApplicationCommandDelete(const dpp::application_command_delete_t & ev);
+    void OnGuildMemberRemove(const dpp::guild_member_remove_t & ev);
+    void OnApplicationCommandCreate(const dpp::application_command_create_t & ev);
+    void OnResumed(const dpp::resumed_t & ev);
+    void OnGuildRoleCreate(const dpp::guild_role_create_t & ev);
+    void OnTypingStart(const dpp::typing_start_t & ev);
+    void OnMessageReactionAdd(const dpp::message_reaction_add_t & ev);
+    void OnGuildMembersChunk(const dpp::guild_members_chunk_t & ev);
+    void OnMessageReactionRemove(const dpp::message_reaction_remove_t & ev);
+    void OnGuildCreate(const dpp::guild_create_t & ev);
+    void OnChannelCreate(const dpp::channel_create_t & ev);
+    void OnMessageReactionRemoveEmoji(const dpp::message_reaction_remove_emoji_t & ev);
+    void OnMessageDeleteBulk(const dpp::message_delete_bulk_t & ev);
+    void OnGuildRoleUpdate(const dpp::guild_role_update_t & ev);
+    void OnGuildRoleDelete(const dpp::guild_role_delete_t & ev);
+    void OnChannelPinsUpdate(const dpp::channel_pins_update_t & ev);
+    void OnMessageReactionRemoveAll(const dpp::message_reaction_remove_all_t & ev);
+    void OnVoiceServerUpdate(const dpp::voice_server_update_t & ev);
+    void OnGuildEmojisUpdate(const dpp::guild_emojis_update_t & ev);
+    void OnGuildStickersUpdate(const dpp::guild_stickers_update_t & ev);
+    void OnPresenceUpdate(const dpp::presence_update_t & ev);
+    void OnWebhooksUpdate(const dpp::webhooks_update_t & ev);
+    void OnGuildMemberAdd(const dpp::guild_member_add_t & ev);
+    void OnInviteDelete(const dpp::invite_delete_t & ev);
+    void OnGuildUpdate(const dpp::guild_update_t & ev);
+    void OnGuildIntegrationsUpdate(const dpp::guild_integrations_update_t & ev);
+    void OnGuildMemberUpdate(const dpp::guild_member_update_t & ev);
+    void OnApplicationCommandUpdate(const dpp::application_command_update_t & ev);
+    void OnInviteCreate(const dpp::invite_create_t & ev);
+    void OnMessageUpdate(const dpp::message_update_t & ev);
+    void OnUserUpdate(const dpp::user_update_t & ev);
+    void OnMessageCreate(const dpp::message_create_t & ev);
+    void OnGuildBanAdd(const dpp::guild_ban_add_t & ev);
+    void OnGuildBanRemove(const dpp::guild_ban_remove_t & ev);
+    void OnIntegrationCreate(const dpp::integration_create_t & ev);
+    void OnIntegrationUpdate(const dpp::integration_update_t & ev);
+    void OnIntegrationDelete(const dpp::integration_delete_t & ev);
+    void OnThreadCreate(const dpp::thread_create_t & ev);
+    void OnThreadUpdate(const dpp::thread_update_t & ev);
+    void OnThreadDelete(const dpp::thread_delete_t & ev);
+    void OnThreadListSync(const dpp::thread_list_sync_t & ev);
+    void OnThreadMemberUpdate(const dpp::thread_member_update_t & ev);
+    void OnThreadMembersUpdate(const dpp::thread_members_update_t & ev);
+    void OnVoiceBufferSend(const dpp::voice_buffer_send_t & ev);
+    void OnVoiceUserTalking(const dpp::voice_user_talking_t & ev);
+    void OnVoiceReady(const dpp::voice_ready_t & ev);
+    void OnVoiceReceive(const dpp::voice_receive_t & ev);
+    void OnVoiceTrackMarker(const dpp::voice_track_marker_t & ev);
+    void OnStageInstanceCreate(const dpp::stage_instance_create_t & ev);
+    void OnStageInstanceDelete(const dpp::stage_instance_delete_t & ev);
+};
+
+} // Namespace:: SqMod

module/Library/DPP/Command.cpp

@@ -0,0 +1,16 @@
+// ------------------------------------------------------------------------------------------------
+#include "Library/DPP/Command.hpp"
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+// ------------------------------------------------------------------------------------------------
+
+
+// ------------------------------------------------------------------------------------------------
+void Register_DPP_Command(HSQUIRRELVM vm, Table & ns)
+{
+
+}
+
+} // Namespace:: SqMod

module/Library/DPP/Command.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+// ------------------------------------------------------------------------------------------------
+#include "Core/Utility.hpp"
+
+// ------------------------------------------------------------------------------------------------
+#include <chrono>
+
+// ------------------------------------------------------------------------------------------------
+#include <dpp/dpp.h>
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+/* ------------------------------------------------------------------------------------------------
+ * 
+*/
+
+} // Namespace:: SqMod

module/Library/DPP/Constants.cpp

@@ -0,0 +1,427 @@
+// ------------------------------------------------------------------------------------------------
+#include "Library/DPP/Constants.hpp"
+
+// ------------------------------------------------------------------------------------------------
+#include <sqratConst.h>
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+// ------------------------------------------------------------------------------------------------
+const std::array< const char *, static_cast< size_t >(DpEventID::Max) > DpEventID::NAME{
+    "VoiceStateUpdate",
+    "Log",
+    "GuildJoinRequestDelete",
+    "InteractionCreate",
+    "ButtonClick",
+    "SelectClick",
+    "GuildDelete",
+    "ChannelDelete",
+    "ChannelUpdate",
+    "Ready",
+    "MessageDelete",
+    "ApplicationCommandDelete",
+    "GuildMemberRemove",
+    "ApplicationCommandCreate",
+    "Resumed",
+    "GuildRoleCreate",
+    "TypingStart",
+    "MessageReactionAdd",
+    "GuildMembersChunk",
+    "MessageReactionRemove",
+    "GuildCreate",
+    "ChannelCreate",
+    "MessageReactionRemoveEmoji",
+    "MessageDeleteBulk",
+    "GuildRoleUpdate",
+    "GuildRoleDelete",
+    "ChannelPinsUpdate",
+    "MessageReactionRemoveAll",
+    "VoiceServerUpdate",
+    "GuildEmojisUpdate",
+    "GuildStickersUpdate",
+    "PresenceUpdate",
+    "WebhooksUpdate",
+    "GuildMemberAdd",
+    "InviteDelete",
+    "GuildUpdate",
+    "GuildIntegrationsUpdate",
+    "GuildMemberUpdate",
+    "ApplicationCommandUpdate",
+    "InviteCreate",
+    "MessageUpdate",
+    "UserUpdate",
+    "MessageCreate",
+    "GuildBanAdd",
+    "GuildBanRemove",
+    "IntegrationCreate",
+    "IntegrationUpdate",
+    "IntegrationDelete",
+    "ThreadCreate",
+    "ThreadUpdate",
+    "ThreadDelete",
+    "ThreadListSync",
+    "ThreadMemberUpdate",
+    "ThreadMembersUpdate",
+    "VoiceBufferSend",
+    "VoiceUserTalking",
+    "VoiceReady",
+    "VoiceReceive",
+    "VoiceTrackMarker",
+    "StageInstanceCreate",
+    "StageInstanceDelete"
+};
+
+// ------------------------------------------------------------------------------------------------
+static const EnumElement g_DpLogLevelEnum[] = {
+    {_SC("Trace"),      static_cast< SQInteger >(dpp::ll_trace)},
+    {_SC("Debug"),      static_cast< SQInteger >(dpp::ll_debug)},
+    {_SC("Info"),       static_cast< SQInteger >(dpp::ll_info)},
+    {_SC("Warning"),    static_cast< SQInteger >(dpp::ll_warning)},
+    {_SC("Error"),      static_cast< SQInteger >(dpp::ll_error)},
+    {_SC("Critical"),   static_cast< SQInteger >(dpp::ll_critical)}
+};
+
+// ------------------------------------------------------------------------------------------------
+static const EnumElement g_DpImageTypeEnum[] = {
+    {_SC("PNG"),    static_cast< SQInteger >(dpp::i_png)},
+    {_SC("JPG"),    static_cast< SQInteger >(dpp::i_jpg)},
+    {_SC("GIF"),    static_cast< SQInteger >(dpp::i_gif)}
+};
+
+// ------------------------------------------------------------------------------------------------
+static const EnumElement g_DpCachePolicyEnum[] = {
+    {_SC("Aggressive"),   static_cast< SQInteger >(dpp::cp_aggressive)},
+    {_SC("Lazy"),         static_cast< SQInteger >(dpp::cp_lazy)},
+    {_SC("None"),         static_cast< SQInteger >(dpp::cp_none)}
+};
+
+// ------------------------------------------------------------------------------------------------
+static const EnumElement g_DpClusterIntentsEnum[] = {
+    {_SC("Guilds"),                   static_cast< SQInteger >(dpp::i_guilds)},
+    {_SC("GuildMembers"),             static_cast< SQInteger >(dpp::i_guild_members)},
+    {_SC("GuildBans"),                static_cast< SQInteger >(dpp::i_guild_bans)},
+    {_SC("GuildEmojis"),              static_cast< SQInteger >(dpp::i_guild_emojis)},
+    {_SC("GuildIntegrations"),        static_cast< SQInteger >(dpp::i_guild_integrations)},
+    {_SC("GuildWebhooks"),            static_cast< SQInteger >(dpp::i_guild_webhooks)},
+    {_SC("GuildInvites"),             static_cast< SQInteger >(dpp::i_guild_invites)},
+    {_SC("GuildVoiceStates"),         static_cast< SQInteger >(dpp::i_guild_voice_states)},
+    {_SC("GuildPresences"),           static_cast< SQInteger >(dpp::i_guild_presences)},
+    {_SC("GuildMessages"),            static_cast< SQInteger >(dpp::i_guild_messages)},
+    {_SC("GuildMessageReactions"),    static_cast< SQInteger >(dpp::i_guild_message_reactions)},
+    {_SC("GuildMessageTyping"),       static_cast< SQInteger >(dpp::i_guild_message_typing)},
+    {_SC("DirectMessages"),           static_cast< SQInteger >(dpp::i_direct_messages)},
+    {_SC("DirectMessageReactions"),   static_cast< SQInteger >(dpp::i_direct_message_reactions)},
+    {_SC("DirectMessageTyping"),      static_cast< SQInteger >(dpp::i_direct_message_typing)},
+    {_SC("Default"),                  static_cast< SQInteger >(dpp::i_default_intents)},
+    {_SC("Privileged"),               static_cast< SQInteger >(dpp::i_privileged_intents)},
+    {_SC("All"),                      static_cast< SQInteger >(dpp::i_all_intents)}
+};
+
+// ------------------------------------------------------------------------------------------------
+static const EnumElement g_DpPresenceFlagsEnum[] = {
+    {_SC("DesktopOnline"),  static_cast< SQInteger >(dpp::p_desktop_online)},
+    {_SC("DesktopDND"),     static_cast< SQInteger >(dpp::p_desktop_dnd)},
+    {_SC("DesktopIdle"),    static_cast< SQInteger >(dpp::p_desktop_idle)},
+    {_SC("WebWnline"),      static_cast< SQInteger >(dpp::p_web_online)},
+    {_SC("WebDND"),         static_cast< SQInteger >(dpp::p_web_dnd)},
+    {_SC("WebIdle"),        static_cast< SQInteger >(dpp::p_web_idle)},
+    {_SC("MobileOnline"),   static_cast< SQInteger >(dpp::p_mobile_online)},
+    {_SC("MobileDND"),      static_cast< SQInteger >(dpp::p_mobile_dnd)},
+    {_SC("MobileIdle"),     static_cast< SQInteger >(dpp::p_mobile_idle)},
+    {_SC("StatusOnline"),   static_cast< SQInteger >(dpp::p_status_online)},
+    {_SC("StatusDND"),      static_cast< SQInteger >(dpp::p_status_dnd)},
+    {_SC("StatusIdle"),     static_cast< SQInteger >(dpp::p_status_idle)},
+    // Helper bit-shift flags
+    {_SC("BitShiftDesktop"),    static_cast< SQInteger >(PF_SHIFT_DESKTOP)},
+    {_SC("BitShiftWeb"),        static_cast< SQInteger >(PF_SHIFT_WEB)},
+    {_SC("BitShiftMobile"),     static_cast< SQInteger >(PF_SHIFT_MOBILE)},
+    {_SC("BitShiftMain"),       static_cast< SQInteger >(PF_SHIFT_MAIN)},
+    {_SC("BitStatusMask"),      static_cast< SQInteger >(PF_STATUS_MASK)},
+    {_SC("BitClearDesktop"),    static_cast< SQInteger >(PF_CLEAR_DESKTOP)},
+    {_SC("BitClearWeb"),        static_cast< SQInteger >(PF_CLEAR_WEB)},
+    {_SC("BitClearMobile"),     static_cast< SQInteger >(PF_CLEAR_MOBILE)},
+    {_SC("BitClearStatus"),     static_cast< SQInteger >(PF_CLEAR_STATUS)},
+};
+
+// ------------------------------------------------------------------------------------------------
+static const EnumElement g_DpPresenceStatusEnum[] = {
+    {_SC("Offline"),    static_cast< SQInteger >(dpp::ps_offline)},
+    {_SC("Online"),     static_cast< SQInteger >(dpp::ps_online)},
+    {_SC("DND"),        static_cast< SQInteger >(dpp::ps_dnd)},
+    {_SC("Idle"),       static_cast< SQInteger >(dpp::ps_idle)}
+};
+
+// ------------------------------------------------------------------------------------------------
+static const EnumElement g_DpDesktopStatusBitsEnum[] = {
+    {_SC("ShiftDesktop"),   static_cast< SQInteger >(PF_SHIFT_DESKTOP)},
+    {_SC("ShiftWeb"),       static_cast< SQInteger >(PF_SHIFT_WEB)},
+    {_SC("ShiftMobile"),    static_cast< SQInteger >(PF_SHIFT_MOBILE)},
+    {_SC("ShiftMain"),      static_cast< SQInteger >(PF_SHIFT_MAIN)},
+    {_SC("StatusMask"),     static_cast< SQInteger >(PF_STATUS_MASK)},
+    {_SC("ClearDesktop"),   static_cast< SQInteger >(PF_CLEAR_DESKTOP)},
+    {_SC("ClearWeb"),       static_cast< SQInteger >(PF_CLEAR_WEB)},
+    {_SC("ClearMobile"),    static_cast< SQInteger >(PF_CLEAR_MOBILE)},
+    {_SC("ClearStatus"),    static_cast< SQInteger >(PF_CLEAR_STATUS)}
+};
+
+// ------------------------------------------------------------------------------------------------
+static const EnumElement g_DpActivityTypeEnum[] = {
+    {_SC("Game"),       static_cast< SQInteger >(dpp::at_game)},
+    {_SC("Streaming"),  static_cast< SQInteger >(dpp::at_streaming)},
+    {_SC("Listening"),  static_cast< SQInteger >(dpp::at_listening)},
+    {_SC("Custom"),     static_cast< SQInteger >(dpp::at_custom)},
+    {_SC("Competing"),  static_cast< SQInteger >(dpp::at_competing)}
+};
+
+// ------------------------------------------------------------------------------------------------
+static const EnumElement g_DpActivityFlagsEnum[] = {
+    {_SC("Instance"),       static_cast< SQInteger >(dpp::af_instance)},
+    {_SC("Join"),           static_cast< SQInteger >(dpp::af_join)},
+    {_SC("Spectate"),       static_cast< SQInteger >(dpp::af_spectate)},
+    {_SC("JoinRequest"),    static_cast< SQInteger >(dpp::af_join_request)},
+    {_SC("Sync"),           static_cast< SQInteger >(dpp::af_sync)},
+    {_SC("Play"),           static_cast< SQInteger >(dpp::af_play)}
+};
+
+// ------------------------------------------------------------------------------------------------
+static const EnumElement g_DpVoiceStateFlagsEnum[] = {
+    {_SC("Deaf"),       static_cast< SQInteger >(dpp::vs_deaf)},
+    {_SC("Mute"),       static_cast< SQInteger >(dpp::vs_mute)},
+    {_SC("SelfMute"),   static_cast< SQInteger >(dpp::vs_self_mute)},
+    {_SC("SelfDeaf"),   static_cast< SQInteger >(dpp::vs_self_deaf)},
+    {_SC("SelfStream"), static_cast< SQInteger >(dpp::vs_self_stream)},
+    {_SC("SelfVideo"),  static_cast< SQInteger >(dpp::vs_self_video)},
+    {_SC("Suppress"),   static_cast< SQInteger >(dpp::vs_suppress)},
+};
+
+// ------------------------------------------------------------------------------------------------
+static const EnumElement g_DpRoleFlagsEnum[] = {
+    {_SC("Hoist"),              static_cast< SQInteger >(dpp::r_hoist)},
+    {_SC("Managed"),            static_cast< SQInteger >(dpp::r_managed)},
+    {_SC("Mentionable"),        static_cast< SQInteger >(dpp::r_mentionable)},
+    {_SC("PremiumSubscriber"),  static_cast< SQInteger >(dpp::r_premium_subscriber)}
+};
+
+// ------------------------------------------------------------------------------------------------
+static const EnumElement g_DpRolePermissionsEnum[] = {
+    {_SC("CreateInstantInvite"),  static_cast< SQInteger >(dpp::p_create_instant_invite)},
+    {_SC("KickMembers"),           static_cast< SQInteger >(dpp::p_kick_members)},
+    {_SC("BanMembers"),            static_cast< SQInteger >(dpp::p_ban_members)},
+    {_SC("Administrator"),          static_cast< SQInteger >(dpp::p_administrator)},
+    {_SC("ManageChannels"),        static_cast< SQInteger >(dpp::p_manage_channels)},
+    {_SC("ManageGuild"),           static_cast< SQInteger >(dpp::p_manage_guild)},
+    {_SC("AddReactions"),          static_cast< SQInteger >(dpp::p_add_reactions)},
+    {_SC("ViewAuditLog"),         static_cast< SQInteger >(dpp::p_view_audit_log)},
+    {_SC("PrioritySpeaker"),       static_cast< SQInteger >(dpp::p_priority_speaker)},
+    {_SC("Stream"),                 static_cast< SQInteger >(dpp::p_stream)},
+    {_SC("ViewChannel"),           static_cast< SQInteger >(dpp::p_view_channel)},
+    {_SC("SendMessages"),          static_cast< SQInteger >(dpp::p_send_messages)},
+    {_SC("SendTtsMessages"),      static_cast< SQInteger >(dpp::p_send_tts_messages)},
+    {_SC("ManageMessages"),        static_cast< SQInteger >(dpp::p_manage_messages)},
+    {_SC("EmbedLinks"),            static_cast< SQInteger >(dpp::p_embed_links)},
+    {_SC("AttachFiles"),           static_cast< SQInteger >(dpp::p_attach_files)},
+    {_SC("ReadMessageHistory"),   static_cast< SQInteger >(dpp::p_read_message_history)},
+    {_SC("MentionEveryone"),       static_cast< SQInteger >(dpp::p_mention_everyone)},
+    {_SC("UseExternalEmojis"),    static_cast< SQInteger >(dpp::p_use_external_emojis)},
+    {_SC("ViewGuildInsights"),    static_cast< SQInteger >(dpp::p_view_guild_insights)},
+    {_SC("Connect"),                static_cast< SQInteger >(dpp::p_connect)},
+    {_SC("Speak"),                  static_cast< SQInteger >(dpp::p_speak)},
+    {_SC("MuteMembers"),           static_cast< SQInteger >(dpp::p_mute_members)},
+    {_SC("DeafenMembers"),         static_cast< SQInteger >(dpp::p_deafen_members)},
+    {_SC("MoveMembers"),           static_cast< SQInteger >(dpp::p_move_members)},
+    {_SC("UseVAD"),                static_cast< SQInteger >(dpp::p_use_vad)},
+    {_SC("ChangeNickname"),        static_cast< SQInteger >(dpp::p_change_nickname)},
+    {_SC("ManageNicknames"),       static_cast< SQInteger >(dpp::p_manage_nicknames)},
+    {_SC("ManageRoles"),           static_cast< SQInteger >(dpp::p_manage_roles)},
+    {_SC("ManageWebHooks"),        static_cast< SQInteger >(dpp::p_manage_webhooks)},
+    {_SC("ManageEmojis"),          static_cast< SQInteger >(dpp::p_manage_emojis)},
+    {_SC("UseSlashCommands"),     static_cast< SQInteger >(dpp::p_use_slash_commands)},
+    {_SC("RequestToSpeak"),       static_cast< SQInteger >(dpp::p_request_to_speak)},
+    {_SC("ManageThreads"),         static_cast< SQInteger >(dpp::p_manage_threads)},
+    {_SC("UsePublicThreads"),     static_cast< SQInteger >(dpp::p_use_public_threads)},
+    {_SC("UsePrivateThreads"),    static_cast< SQInteger >(dpp::p_use_private_threads)}
+};
+
+// ------------------------------------------------------------------------------------------------
+static const EnumElement g_DpUserFlagsEnum[] = {
+    {_SC("Bot"),                static_cast< SQInteger >(dpp::u_bot)},
+    {_SC("System"),             static_cast< SQInteger >(dpp::u_system)},
+    {_SC("MfaEnabled"),         static_cast< SQInteger >(dpp::u_mfa_enabled)},
+    {_SC("Verified"),           static_cast< SQInteger >(dpp::u_verified)},
+    {_SC("NitroFull"),          static_cast< SQInteger >(dpp::u_nitro_full)},
+    {_SC("NitroClassic"),       static_cast< SQInteger >(dpp::u_nitro_classic)},
+    {_SC("DiscordEmployee"),    static_cast< SQInteger >(dpp::u_discord_employee)},
+    {_SC("PartneredOwner"),     static_cast< SQInteger >(dpp::u_partnered_owner)},
+    {_SC("HypesquadEvents"),    static_cast< SQInteger >(dpp::u_hypesquad_events)},
+    {_SC("Bughunter1"),         static_cast< SQInteger >(dpp::u_bughunter_1)},
+    {_SC("HouseBravery"),       static_cast< SQInteger >(dpp::u_house_bravery)},
+    {_SC("HouseBrilliance"),    static_cast< SQInteger >(dpp::u_house_brilliance)},
+    {_SC("HouseBalanace"),      static_cast< SQInteger >(dpp::u_house_balanace)},
+    {_SC("EarlySupporter"),     static_cast< SQInteger >(dpp::u_early_supporter)},
+    {_SC("TeamUser"),           static_cast< SQInteger >(dpp::u_team_user)},
+    {_SC("Bughunter2"),         static_cast< SQInteger >(dpp::u_bughunter_2)},
+    {_SC("VerifiedBot"),        static_cast< SQInteger >(dpp::u_verified_bot)},
+    {_SC("VerifiedBotDev"),     static_cast< SQInteger >(dpp::u_verified_bot_dev)},
+    {_SC("AnimatedIcon"),       static_cast< SQInteger >(dpp::u_animated_icon)},
+    {_SC("CertifiedModerator"), static_cast< SQInteger >(dpp::u_certified_moderator)}
+};
+
+// ------------------------------------------------------------------------------------------------
+static const EnumElement g_DpRegionEnum[] = {
+    {_SC("Brazil"),         static_cast< SQInteger >(dpp::r_brazil)},
+    {_SC("CentralEurope"),  static_cast< SQInteger >(dpp::r_central_europe)},
+    {_SC("HongKong"),       static_cast< SQInteger >(dpp::r_hong_kong)},
+    {_SC("India"),          static_cast< SQInteger >(dpp::r_india)},
+    {_SC("Japan"),          static_cast< SQInteger >(dpp::r_japan)},
+    {_SC("Russia"),         static_cast< SQInteger >(dpp::r_russia)},
+    {_SC("Singapore"),      static_cast< SQInteger >(dpp::r_singapore)},
+    {_SC("SouthAfrica"),    static_cast< SQInteger >(dpp::r_south_africa)},
+    {_SC("Sydney"),         static_cast< SQInteger >(dpp::r_sydney)},
+    {_SC("UsCentral"),      static_cast< SQInteger >(dpp::r_us_central)},
+    {_SC("UsEast"),         static_cast< SQInteger >(dpp::r_us_east)},
+    {_SC("UsSouth"),        static_cast< SQInteger >(dpp::r_us_south)},
+    {_SC("UsWest"),         static_cast< SQInteger >(dpp::r_us_west)},
+    {_SC("WesternEurope"),  static_cast< SQInteger >(dpp::r_western_europe)}
+};
+
+// ------------------------------------------------------------------------------------------------
+static const EnumElement g_DpGuildFlagsEnum[] = {
+    {_SC("Large"),                  static_cast< SQInteger >(dpp::g_large)},
+    {_SC("Unavailable"),            static_cast< SQInteger >(dpp::g_unavailable)},
+    {_SC("WidgetEnabled"),          static_cast< SQInteger >(dpp::g_widget_enabled)},
+    {_SC("InviteSplash"),           static_cast< SQInteger >(dpp::g_invite_splash)},
+    {_SC("VipRegions"),             static_cast< SQInteger >(dpp::g_vip_regions)},
+    {_SC("VanityURL"),              static_cast< SQInteger >(dpp::g_vanity_url)},
+    {_SC("Verified"),               static_cast< SQInteger >(dpp::g_verified)},
+    {_SC("Partnered"),              static_cast< SQInteger >(dpp::g_partnered)},
+    {_SC("Community"),              static_cast< SQInteger >(dpp::g_community)},
+    {_SC("Commerce"),               static_cast< SQInteger >(dpp::g_commerce)},
+    {_SC("News"),                   static_cast< SQInteger >(dpp::g_news)},
+    {_SC("Discoverable"),           static_cast< SQInteger >(dpp::g_discoverable)},
+    {_SC("Featureable"),            static_cast< SQInteger >(dpp::g_featureable)},
+    {_SC("AnimatedIcon"),           static_cast< SQInteger >(dpp::g_animated_icon)},
+    {_SC("Banner"),                 static_cast< SQInteger >(dpp::g_banner)},
+    {_SC("WelcomeScreenEnabled"),   static_cast< SQInteger >(dpp::g_welcome_screen_enabled)},
+    {_SC("MemberVerificationGate"), static_cast< SQInteger >(dpp::g_member_verification_gate)},
+    {_SC("PreviewEnabled"),         static_cast< SQInteger >(dpp::g_preview_enabled)},
+    {_SC("NoJoinNotifications"),    static_cast< SQInteger >(dpp::g_no_join_notifications)},
+    {_SC("NoBoostNotifications"),   static_cast< SQInteger >(dpp::g_no_boost_notifications)},
+    {_SC("HasAnimatedIcon"),        static_cast< SQInteger >(dpp::g_has_animated_icon)}
+};
+
+// ------------------------------------------------------------------------------------------------
+static const EnumElement g_DpGuildMemberFlagsEnum[] = {
+    {_SC("Deaf"),       static_cast< SQInteger >(dpp::gm_deaf)},
+    {_SC("Mute"),       static_cast< SQInteger >(dpp::gm_mute)},
+    {_SC("Pending"),    static_cast< SQInteger >(dpp::gm_pending)}
+};
+
+// ------------------------------------------------------------------------------------------------
+static const EnumElement g_DpComponentTypeEnum[] = {
+    {_SC("ActionRow"),      static_cast< SQInteger >(dpp::cot_action_row)},
+    {_SC("Button"),         static_cast< SQInteger >(dpp::cot_button)},
+    {_SC("SelectMenu"),     static_cast< SQInteger >(dpp::cot_selectmenu)}
+};
+
+// ------------------------------------------------------------------------------------------------
+static const EnumElement g_DpComponentStyleEnum[] = {
+    {_SC("Primary"),        static_cast< SQInteger >(dpp::cos_primary)},
+    {_SC("Secondary"),      static_cast< SQInteger >(dpp::cos_secondary)},
+    {_SC("Success"),        static_cast< SQInteger >(dpp::cos_success)},
+    {_SC("Danger"),         static_cast< SQInteger >(dpp::cos_danger)},
+    {_SC("Link"),           static_cast< SQInteger >(dpp::cos_link)}
+};
+
+// ------------------------------------------------------------------------------------------------
+static const EnumElement g_DpStickerTypeEnum[] = {
+    {_SC("Standard"),      static_cast< SQInteger >(dpp::st_standard)},
+    {_SC("Guild"),         static_cast< SQInteger >(dpp::st_guild)}
+};
+
+// ------------------------------------------------------------------------------------------------
+static const EnumElement g_DpStickerFormatEnum[] = {
+    {_SC("PNG"),        static_cast< SQInteger >(dpp::sf_png)},
+    {_SC("APNG"),       static_cast< SQInteger >(dpp::sf_apng)},
+    {_SC("Lottie"),     static_cast< SQInteger >(dpp::sf_lottie)}
+};
+
+// ------------------------------------------------------------------------------------------------
+static const EnumElement g_DpMessageFlagsEnum[] = {
+    {_SC("Crossposted"),            static_cast< SQInteger >(dpp::m_crossposted)},
+    {_SC("IsCrosspost"),            static_cast< SQInteger >(dpp::m_is_crosspost)},
+    {_SC("SuppressEmbeds"),         static_cast< SQInteger >(dpp::m_suppress_embeds)},
+    {_SC("SourceMessageDeleted"),   static_cast< SQInteger >(dpp::m_source_message_deleted)},
+    {_SC("Urgent"),                 static_cast< SQInteger >(dpp::m_urgent)},
+    {_SC("Ephemeral"),              static_cast< SQInteger >(dpp::m_ephemeral)},
+    {_SC("Loading"),                static_cast< SQInteger >(dpp::m_loading)}
+};
+
+// ------------------------------------------------------------------------------------------------
+static const EnumElement g_DpMessageTypeEnum[] = {
+    {_SC("Default"),                                    static_cast< SQInteger >(dpp::mt_default)},
+    {_SC("RecipientAdd"),                               static_cast< SQInteger >(dpp::mt_recipient_add)},
+    {_SC("RecipientRemove"),                            static_cast< SQInteger >(dpp::mt_recipient_remove)},
+    {_SC("Call"),                                       static_cast< SQInteger >(dpp::mt_call)},
+    {_SC("ChannelNameChange"),                          static_cast< SQInteger >(dpp::mt_channel_name_change)},
+    {_SC("ChannelIconChange"),                          static_cast< SQInteger >(dpp::mt_channel_icon_change)},
+    {_SC("ChannelPinnedMessage"),                       static_cast< SQInteger >(dpp::mt_channel_pinned_message)},
+    {_SC("GuildMemberJoin"),                            static_cast< SQInteger >(dpp::mt_guild_member_join)},
+    {_SC("UserPremiumGuildSubscription"),               static_cast< SQInteger >(dpp::mt_user_premium_guild_subscription)},
+    {_SC("UserPremiumGuildSubscriptionTier1"),          static_cast< SQInteger >(dpp::mt_user_premium_guild_subscription_tier_1)},
+    {_SC("UserPremiumGuildSubscriptionTier2"),          static_cast< SQInteger >(dpp::mt_user_premium_guild_subscription_tier_2)},
+    {_SC("UserPremiumGuildSubscriptionTier3"),          static_cast< SQInteger >(dpp::mt_user_premium_guild_subscription_tier_3)},
+    {_SC("ChannelFollowAdd"),                           static_cast< SQInteger >(dpp::mt_channel_follow_add)},
+    {_SC("GuildDiscoveryDisqualified"),                 static_cast< SQInteger >(dpp::mt_guild_discovery_disqualified)},
+    {_SC("GuildDiscoveryRequalified"),                  static_cast< SQInteger >(dpp::mt_guild_discovery_requalified)},
+    {_SC("GuildDiscoveryGracePeriodInitialWarning"),    static_cast< SQInteger >(dpp::mt_guild_discovery_grace_period_initial_warning)},
+    {_SC("GuildDiscoveryGracePeriodFinalWarning"),      static_cast< SQInteger >(dpp::mt_guild_discovery_grace_period_final_warning)},
+    {_SC("ThreadCreated"),                              static_cast< SQInteger >(dpp::mt_thread_created)},
+    {_SC("Reply"),                                      static_cast< SQInteger >(dpp::mt_reply)},
+    {_SC("ApplicationCommand"),                         static_cast< SQInteger >(dpp::mt_application_command)},
+    {_SC("ThreadStarterMessage"),                       static_cast< SQInteger >(dpp::mt_thread_starter_message)},
+    {_SC("GuildInviteReminder"),                        static_cast< SQInteger >(dpp::mt_guild_invite_reminder)}
+};
+
+// ------------------------------------------------------------------------------------------------
+static const EnumElements g_EnumList[] = {
+    {_SC("SqDiscordLogLevel"),              g_DpLogLevelEnum},
+    {_SC("SqDiscordImageType"),             g_DpImageTypeEnum},
+    {_SC("SqDiscordCachePolicy"),           g_DpCachePolicyEnum},
+    {_SC("SqDiscordClusterIntents"),        g_DpClusterIntentsEnum},
+    {_SC("SqDiscordPresenceFlags"),         g_DpPresenceFlagsEnum},
+    {_SC("SqDiscordPresenceStatus"),        g_DpPresenceStatusEnum},
+    {_SC("SqDiscordDesktopStatusBits"),     g_DpDesktopStatusBitsEnum},
+    {_SC("SqDiscordActivityType"),          g_DpActivityTypeEnum},
+    {_SC("SqDiscordActivityFlags"),         g_DpActivityFlagsEnum},
+    {_SC("SqDiscordVoiceStateFlags"),       g_DpVoiceStateFlagsEnum},
+    {_SC("SqDiscordRoleFlags"),             g_DpRoleFlagsEnum},
+    {_SC("SqDiscordRolePermissions"),       g_DpRolePermissionsEnum},
+    {_SC("SqDiscordUserFlags"),             g_DpUserFlagsEnum},
+    {_SC("SqDiscordRegion"),                g_DpRegionEnum},
+    {_SC("SqDiscordGuildFlags"),            g_DpGuildFlagsEnum},
+    {_SC("SqDiscordGuildMemberFlags"),      g_DpGuildMemberFlagsEnum},
+    {_SC("SqDiscordComponentType"),         g_DpComponentTypeEnum},
+    {_SC("SqDiscordComponentStyle"),        g_DpComponentStyleEnum},
+    {_SC("SqDiscordStickerType"),           g_DpStickerTypeEnum},
+    {_SC("SqDiscordStickerFormat"),         g_DpStickerFormatEnum},
+    {_SC("SqDiscordMessageFlags"),          g_DpMessageFlagsEnum},
+    {_SC("SqDiscordMessageType"),           g_DpMessageTypeEnum}
+};
+
+// ------------------------------------------------------------------------------------------------
+void Register_DPP_Constants(HSQUIRRELVM vm, Table & ns)
+{
+    RegisterEnumerations(vm, g_EnumList);
+    // --------------------------------------------------------------------------------------------
+    Enumeration e(vm);
+    // Bind all events using their associated name
+    for (SQInteger i = 0; i < static_cast< SQInteger >(DpEventID::Max); ++i)
+    {
+        e.Const(DpEventID::NAME[i], i);
+    }
+    // Expose the constants
+    ConstTable(vm).Enum(_SC("SqDiscordEvent"), e);
+}
+
+} // Namespace:: SqMod

module/Library/DPP/Constants.hpp

@@ -0,0 +1,91 @@
+#pragma once
+
+// ------------------------------------------------------------------------------------------------
+#include "Core/Utility.hpp"
+
+// ------------------------------------------------------------------------------------------------
+#include <dpp/dpp.h>
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+/* ------------------------------------------------------------------------------------------------
+ * Unique ID for each event.
+*/
+struct DpEventID
+{
+    /* --------------------------------------------------------------------------------------------
+     * ID enumeration.
+    */
+    enum Type
+    {
+        VoiceStateUpdate=0,
+        Log,
+        GuildJoinRequestDelete,
+        InteractionCreate,
+        ButtonClick,
+        SelectClick,
+        GuildDelete,
+        ChannelDelete,
+        ChannelUpdate,
+        Ready,
+        MessageDelete,
+        ApplicationCommandDelete,
+        GuildMemberRemove,
+        ApplicationCommandCreate,
+        Resumed,
+        GuildRoleCreate,
+        TypingStart,
+        MessageReactionAdd,
+        GuildMembersChunk,
+        MessageReactionRemove,
+        GuildCreate,
+        ChannelCreate,
+        MessageReactionRemoveEmoji,
+        MessageDeleteBulk,
+        GuildRoleUpdate,
+        GuildRoleDelete,
+        ChannelPinsUpdate,
+        MessageReactionRemoveAll,
+        VoiceServerUpdate,
+        GuildEmojisUpdate,
+        GuildStickersUpdate,
+        PresenceUpdate,
+        WebhooksUpdate,
+        GuildMemberAdd,
+        InviteDelete,
+        GuildUpdate,
+        GuildIntegrationsUpdate,
+        GuildMemberUpdate,
+        ApplicationCommandUpdate,
+        InviteCreate,
+        MessageUpdate,
+        UserUpdate,
+        MessageCreate,
+        GuildBanAdd,
+        GuildBanRemove,
+        IntegrationCreate,
+        IntegrationUpdate,
+        IntegrationDelete,
+        ThreadCreate,
+        ThreadUpdate,
+        ThreadDelete,
+        ThreadListSync,
+        ThreadMemberUpdate,
+        ThreadMembersUpdate,
+        VoiceBufferSend,
+        VoiceUserTalking,
+        VoiceReady,
+        VoiceReceive,
+        VoiceTrackMarker,
+        StageInstanceCreate,
+        StageInstanceDelete,
+        Max
+    };
+    /* --------------------------------------------------------------------------------------------
+     * String identification for each event ID.
+    */
+    static const std::array< const char *, static_cast< size_t >(Max) > NAME;
+};
+
+} // Namespace:: SqMod

module/Library/DPP/Events.cpp

@@ -0,0 +1,630 @@
+// ------------------------------------------------------------------------------------------------
+#include "Library/DPP/Events.hpp"
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+// ------------------------------------------------------------------------------------------------
+SQMOD_DECL_TYPENAME(SqDppVoiceStateUpdateEvent, _SC("SqDppVoiceStateUpdateEvent"))
+SQMOD_DECL_TYPENAME(SqDppLogEvent, _SC("SqDppLogEvent"))
+SQMOD_DECL_TYPENAME(SqDppGuildJoinRequestDeleteEvent, _SC("SqDppGuildJoinRequestDeleteEvent"))
+SQMOD_DECL_TYPENAME(SqDppInteractionCreateEvent, _SC("SqDppInteractionCreateEvent"))
+SQMOD_DECL_TYPENAME(SqDppButtonClickEvent, _SC("SqDppButtonClickEvent"))
+SQMOD_DECL_TYPENAME(SqDppSelectClickEvent, _SC("SqDppSelectClickEvent"))
+SQMOD_DECL_TYPENAME(SqDppGuildDeleteEvent, _SC("SqDppGuildDeleteEvent"))
+SQMOD_DECL_TYPENAME(SqDppChannelDeleteEvent, _SC("SqDppChannelDeleteEvent"))
+SQMOD_DECL_TYPENAME(SqDppChannelUpdateEvent, _SC("SqDppChannelUpdateEvent"))
+SQMOD_DECL_TYPENAME(SqDppReadyEvent, _SC("SqDppReadyEvent"))
+SQMOD_DECL_TYPENAME(SqDppMessageDeleteEvent, _SC("SqDppMessageDeleteEvent"))
+SQMOD_DECL_TYPENAME(SqDppApplicationCommandDeleteEvent, _SC("SqDppApplicationCommandDeleteEvent"))
+SQMOD_DECL_TYPENAME(SqDppGuildMemberRemoveEvent, _SC("SqDppGuildMemberRemoveEvent"))
+SQMOD_DECL_TYPENAME(SqDppApplicationCommandCreateEvent, _SC("SqDppApplicationCommandCreateEvent"))
+SQMOD_DECL_TYPENAME(SqDppResumedEvent, _SC("SqDppResumedEvent"))
+SQMOD_DECL_TYPENAME(SqDppGuildRoleCreateEvent, _SC("SqDppGuildRoleCreateEvent"))
+SQMOD_DECL_TYPENAME(SqDppTypingStartEvent, _SC("SqDppTypingStartEvent"))
+SQMOD_DECL_TYPENAME(SqDppMessageReactionAddEvent, _SC("SqDppMessageReactionAddEvent"))
+SQMOD_DECL_TYPENAME(SqDppGuildMembersChunkEvent, _SC("SqDppGuildMembersChunkEvent"))
+SQMOD_DECL_TYPENAME(SqDppMessageReactionRemoveEvent, _SC("SqDppMessageReactionRemoveEvent"))
+SQMOD_DECL_TYPENAME(SqDppGuildCreateEvent, _SC("SqDppGuildCreateEvent"))
+SQMOD_DECL_TYPENAME(SqDppChannelCreateEvent, _SC("SqDppChannelCreateEvent"))
+SQMOD_DECL_TYPENAME(SqDppMessageReactionRemoveEmojiEvent, _SC("SqDppMessageReactionRemoveEmojiEvent"))
+SQMOD_DECL_TYPENAME(SqDppMessageDeleteBulkEvent, _SC("SqDppMessageDeleteBulkEvent"))
+SQMOD_DECL_TYPENAME(SqDppGuildRoleUpdateEvent, _SC("SqDppGuildRoleUpdateEvent"))
+SQMOD_DECL_TYPENAME(SqDppGuildRoleDeleteEvent, _SC("SqDppGuildRoleDeleteEvent"))
+SQMOD_DECL_TYPENAME(SqDppChannelPinsUpdateEvent, _SC("SqDppChannelPinsUpdateEvent"))
+SQMOD_DECL_TYPENAME(SqDppMessageReactionRemoveAllEvent, _SC("SqDppMessageReactionRemoveAllEvent"))
+SQMOD_DECL_TYPENAME(SqDppVoiceServerUpdateEvent, _SC("SqDppVoiceServerUpdateEvent"))
+SQMOD_DECL_TYPENAME(SqDppGuildEmojisUpdateEvent, _SC("SqDppGuildEmojisUpdateEvent"))
+SQMOD_DECL_TYPENAME(SqDppGuildStickersUpdateEvent, _SC("SqDppGuildStickersUpdateEvent"))
+SQMOD_DECL_TYPENAME(SqDppPresenceUpdateEvent, _SC("SqDppPresenceUpdateEvent"))
+SQMOD_DECL_TYPENAME(SqDppWebhooksUpdateEvent, _SC("SqDppWebhooksUpdateEvent"))
+SQMOD_DECL_TYPENAME(SqDppGuildMemberAddEvent, _SC("SqDppGuildMemberAddEvent"))
+SQMOD_DECL_TYPENAME(SqDppInviteDeleteEvent, _SC("SqDppInviteDeleteEvent"))
+SQMOD_DECL_TYPENAME(SqDppGuildUpdateEvent, _SC("SqDppGuildUpdateEvent"))
+SQMOD_DECL_TYPENAME(SqDppGuildIntegrationsUpdateEvent, _SC("SqDppGuildIntegrationsUpdateEvent"))
+SQMOD_DECL_TYPENAME(SqDppGuildMemberUpdateEvent, _SC("SqDppGuildMemberUpdateEvent"))
+SQMOD_DECL_TYPENAME(SqDppApplicationCommandUpdateEvent, _SC("SqDppApplicationCommandUpdateEvent"))
+SQMOD_DECL_TYPENAME(SqDppInviteCreateEvent, _SC("SqDppInviteCreateEvent"))
+SQMOD_DECL_TYPENAME(SqDppMessageUpdateEvent, _SC("SqDppMessageUpdateEvent"))
+SQMOD_DECL_TYPENAME(SqDppUserUpdateEvent, _SC("SqDppUserUpdateEvent"))
+SQMOD_DECL_TYPENAME(SqDppMessageCreateEvent, _SC("SqDppMessageCreateEvent"))
+SQMOD_DECL_TYPENAME(SqDppGuildBanAddEvent, _SC("SqDppGuildBanAddEvent"))
+SQMOD_DECL_TYPENAME(SqDppGuildBanRemoveEvent, _SC("SqDppGuildBanRemoveEvent"))
+SQMOD_DECL_TYPENAME(SqDppIntegrationCreateEvent, _SC("SqDppIntegrationCreateEvent"))
+SQMOD_DECL_TYPENAME(SqDppIntegrationUpdateEvent, _SC("SqDppIntegrationUpdateEvent"))
+SQMOD_DECL_TYPENAME(SqDppIntegrationDeleteEvent, _SC("SqDppIntegrationDeleteEvent"))
+SQMOD_DECL_TYPENAME(SqDppThreadCreateEvent, _SC("SqDppThreadCreateEvent"))
+SQMOD_DECL_TYPENAME(SqDppThreadUpdateEvent, _SC("SqDppThreadUpdateEvent"))
+SQMOD_DECL_TYPENAME(SqDppThreadDeleteEvent, _SC("SqDppThreadDeleteEvent"))
+SQMOD_DECL_TYPENAME(SqDppThreadListSyncEvent, _SC("SqDppThreadListSyncEvent"))
+SQMOD_DECL_TYPENAME(SqDppThreadMemberUpdateEvent, _SC("SqDppThreadMemberUpdateEvent"))
+SQMOD_DECL_TYPENAME(SqDppThreadMembersUpdateEvent, _SC("SqDppThreadMembersUpdateEvent"))
+SQMOD_DECL_TYPENAME(SqDppVoiceBufferSendEvent, _SC("SqDppVoiceBufferSendEvent"))
+SQMOD_DECL_TYPENAME(SqDppVoiceUserTalkingEvent, _SC("SqDppVoiceUserTalkingEvent"))
+SQMOD_DECL_TYPENAME(SqDppVoiceReadyEvent, _SC("SqDppVoiceReadyEvent"))
+SQMOD_DECL_TYPENAME(SqDppVoiceReceiveEvent, _SC("SqDppVoiceReceiveEvent"))
+SQMOD_DECL_TYPENAME(SqDppVoiceTrackMarkerEvent, _SC("SqDppVoiceTrackMarkerEvent"))
+SQMOD_DECL_TYPENAME(SqDppStageInstanceCreateEvent, _SC("SqDppStageInstanceCreateEvent"))
+SQMOD_DECL_TYPENAME(SqDppStageInstanceDeleteEvent, _SC("SqDppStageInstanceDeleteEvent"))
+
+// ------------------------------------------------------------------------------------------------
+void Register_DPP_Events(HSQUIRRELVM vm, Table & ns)
+{
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("VoiceStateUpdate"),
+        Class< DpVoiceStateUpdateEvent, NoConstructor< DpVoiceStateUpdateEvent > >(vm, SqDppVoiceStateUpdateEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppVoiceStateUpdateEvent::Fn)
+        .Func(_SC("_tostring"), &DpVoiceStateUpdateEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("State"), &DpVoiceStateUpdateEvent::GetState)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("Log"),
+        Class< DpLogEvent, NoConstructor< DpLogEvent > >(vm, SqDppLogEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppLogEvent::Fn)
+        .Func(_SC("_tostring"), &DpLogEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpLogEvent::GetRawEvent)
+        .Prop(_SC("Severity"), &DpLogEvent::GetSeverity)
+        .Prop(_SC("Message"), &DpLogEvent::GetMessage)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("GuildJoinRequestDelete"),
+        Class< DpGuildJoinRequestDeleteEvent, NoConstructor< DpGuildJoinRequestDeleteEvent > >(vm, SqDppGuildJoinRequestDeleteEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppGuildJoinRequestDeleteEvent::Fn)
+        .Func(_SC("_tostring"), &DpGuildJoinRequestDeleteEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpGuildJoinRequestDeleteEvent::GetRawEvent)
+        .Prop(_SC("GuildID"), &DpGuildJoinRequestDeleteEvent::GetGuildID)
+        .Prop(_SC("UserID"), &DpGuildJoinRequestDeleteEvent::GetUserID)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("InteractionCreate"),
+        Class< DpInteractionCreateEvent, NoConstructor< DpInteractionCreateEvent > >(vm, SqDppInteractionCreateEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppInteractionCreateEvent::Fn)
+        .Func(_SC("_tostring"), &DpInteractionCreateEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpInteractionCreateEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("ButtonClick"),
+        Class< DpButtonClickEvent, NoConstructor< DpButtonClickEvent > >(vm, SqDppButtonClickEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppButtonClickEvent::Fn)
+        .Func(_SC("_tostring"), &DpButtonClickEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpButtonClickEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("SelectClick"),
+        Class< DpSelectClickEvent, NoConstructor< DpSelectClickEvent > >(vm, SqDppSelectClickEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppSelectClickEvent::Fn)
+        .Func(_SC("_tostring"), &DpSelectClickEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpSelectClickEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("GuildDelete"),
+        Class< DpGuildDeleteEvent, NoConstructor< DpGuildDeleteEvent > >(vm, SqDppGuildDeleteEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppGuildDeleteEvent::Fn)
+        .Func(_SC("_tostring"), &DpGuildDeleteEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpGuildDeleteEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("ChannelDelete"),
+        Class< DpChannelDeleteEvent, NoConstructor< DpChannelDeleteEvent > >(vm, SqDppChannelDeleteEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppChannelDeleteEvent::Fn)
+        .Func(_SC("_tostring"), &DpChannelDeleteEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpChannelDeleteEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("ChannelUpdate"),
+        Class< DpChannelUpdateEvent, NoConstructor< DpChannelUpdateEvent > >(vm, SqDppChannelUpdateEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppChannelUpdateEvent::Fn)
+        .Func(_SC("_tostring"), &DpChannelUpdateEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpChannelUpdateEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("Ready"),
+        Class< DpReadyEvent, NoConstructor< DpReadyEvent > >(vm, SqDppReadyEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppReadyEvent::Fn)
+        .Func(_SC("_tostring"), &DpReadyEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpReadyEvent::GetRawEvent)
+        .Prop(_SC("SessionID"), &DpReadyEvent::GetSessionID)
+        .Prop(_SC("ShardID"), &DpReadyEvent::GetShardID)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("MessageDelete"),
+        Class< DpMessageDeleteEvent, NoConstructor< DpMessageDeleteEvent > >(vm, SqDppMessageDeleteEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppMessageDeleteEvent::Fn)
+        .Func(_SC("_tostring"), &DpMessageDeleteEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpMessageDeleteEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("ApplicationCommandDelete"),
+        Class< DpApplicationCommandDeleteEvent, NoConstructor< DpApplicationCommandDeleteEvent > >(vm, SqDppApplicationCommandDeleteEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppApplicationCommandDeleteEvent::Fn)
+        .Func(_SC("_tostring"), &DpApplicationCommandDeleteEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpApplicationCommandDeleteEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("GuildMemberRemove"),
+        Class< DpGuildMemberRemoveEvent, NoConstructor< DpGuildMemberRemoveEvent > >(vm, SqDppGuildMemberRemoveEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppGuildMemberRemoveEvent::Fn)
+        .Func(_SC("_tostring"), &DpGuildMemberRemoveEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpGuildMemberRemoveEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("ApplicationCommandCreate"),
+        Class< DpApplicationCommandCreateEvent, NoConstructor< DpApplicationCommandCreateEvent > >(vm, SqDppApplicationCommandCreateEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppApplicationCommandCreateEvent::Fn)
+        .Func(_SC("_tostring"), &DpApplicationCommandCreateEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpApplicationCommandCreateEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("Resumed"),
+        Class< DpResumedEvent, NoConstructor< DpResumedEvent > >(vm, SqDppResumedEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppResumedEvent::Fn)
+        .Func(_SC("_tostring"), &DpResumedEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpResumedEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("GuildRoleCreate"),
+        Class< DpGuildRoleCreateEvent, NoConstructor< DpGuildRoleCreateEvent > >(vm, SqDppGuildRoleCreateEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppGuildRoleCreateEvent::Fn)
+        .Func(_SC("_tostring"), &DpGuildRoleCreateEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpGuildRoleCreateEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("TypingStart"),
+        Class< DpTypingStartEvent, NoConstructor< DpTypingStartEvent > >(vm, SqDppTypingStartEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppTypingStartEvent::Fn)
+        .Func(_SC("_tostring"), &DpTypingStartEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpTypingStartEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("MessageReactionAdd"),
+        Class< DpMessageReactionAddEvent, NoConstructor< DpMessageReactionAddEvent > >(vm, SqDppMessageReactionAddEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppMessageReactionAddEvent::Fn)
+        .Func(_SC("_tostring"), &DpMessageReactionAddEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpMessageReactionAddEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("GuildMembersChunk"),
+        Class< DpGuildMembersChunkEvent, NoConstructor< DpGuildMembersChunkEvent > >(vm, SqDppGuildMembersChunkEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppGuildMembersChunkEvent::Fn)
+        .Func(_SC("_tostring"), &DpGuildMembersChunkEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpGuildMembersChunkEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("MessageReactionRemove"),
+        Class< DpMessageReactionRemoveEvent, NoConstructor< DpMessageReactionRemoveEvent > >(vm, SqDppMessageReactionRemoveEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppMessageReactionRemoveEvent::Fn)
+        .Func(_SC("_tostring"), &DpMessageReactionRemoveEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpMessageReactionRemoveEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("GuildCreate"),
+        Class< DpGuildCreateEvent, NoConstructor< DpGuildCreateEvent > >(vm, SqDppGuildCreateEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppGuildCreateEvent::Fn)
+        .Func(_SC("_tostring"), &DpGuildCreateEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpGuildCreateEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("ChannelCreate"),
+        Class< DpChannelCreateEvent, NoConstructor< DpChannelCreateEvent > >(vm, SqDppChannelCreateEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppChannelCreateEvent::Fn)
+        .Func(_SC("_tostring"), &DpChannelCreateEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpChannelCreateEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("MessageReactionRemoveEmoji"),
+        Class< DpMessageReactionRemoveEmojiEvent, NoConstructor< DpMessageReactionRemoveEmojiEvent > >(vm, SqDppMessageReactionRemoveEmojiEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppMessageReactionRemoveEmojiEvent::Fn)
+        .Func(_SC("_tostring"), &DpMessageReactionRemoveEmojiEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpMessageReactionRemoveEmojiEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("MessageDeleteBulk"),
+        Class< DpMessageDeleteBulkEvent, NoConstructor< DpMessageDeleteBulkEvent > >(vm, SqDppMessageDeleteBulkEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppMessageDeleteBulkEvent::Fn)
+        .Func(_SC("_tostring"), &DpMessageDeleteBulkEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpMessageDeleteBulkEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("GuildRoleUpdate"),
+        Class< DpGuildRoleUpdateEvent, NoConstructor< DpGuildRoleUpdateEvent > >(vm, SqDppGuildRoleUpdateEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppGuildRoleUpdateEvent::Fn)
+        .Func(_SC("_tostring"), &DpGuildRoleUpdateEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpGuildRoleUpdateEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("GuildRoleDelete"),
+        Class< DpGuildRoleDeleteEvent, NoConstructor< DpGuildRoleDeleteEvent > >(vm, SqDppGuildRoleDeleteEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppGuildRoleDeleteEvent::Fn)
+        .Func(_SC("_tostring"), &DpGuildRoleDeleteEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpGuildRoleDeleteEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("ChannelPinsUpdate"),
+        Class< DpChannelPinsUpdateEvent, NoConstructor< DpChannelPinsUpdateEvent > >(vm, SqDppChannelPinsUpdateEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppChannelPinsUpdateEvent::Fn)
+        .Func(_SC("_tostring"), &DpChannelPinsUpdateEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpChannelPinsUpdateEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("MessageReactionRemoveAll"),
+        Class< DpMessageReactionRemoveAllEvent, NoConstructor< DpMessageReactionRemoveAllEvent > >(vm, SqDppMessageReactionRemoveAllEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppMessageReactionRemoveAllEvent::Fn)
+        .Func(_SC("_tostring"), &DpMessageReactionRemoveAllEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpMessageReactionRemoveAllEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("VoiceServerUpdate"),
+        Class< DpVoiceServerUpdateEvent, NoConstructor< DpVoiceServerUpdateEvent > >(vm, SqDppVoiceServerUpdateEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppVoiceServerUpdateEvent::Fn)
+        .Func(_SC("_tostring"), &DpVoiceServerUpdateEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpVoiceServerUpdateEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("GuildEmojisUpdate"),
+        Class< DpGuildEmojisUpdateEvent, NoConstructor< DpGuildEmojisUpdateEvent > >(vm, SqDppGuildEmojisUpdateEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppGuildEmojisUpdateEvent::Fn)
+        .Func(_SC("_tostring"), &DpGuildEmojisUpdateEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpGuildEmojisUpdateEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("GuildStickersUpdate"),
+        Class< DpGuildStickersUpdateEvent, NoConstructor< DpGuildStickersUpdateEvent > >(vm, SqDppGuildStickersUpdateEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppGuildStickersUpdateEvent::Fn)
+        .Func(_SC("_tostring"), &DpGuildStickersUpdateEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpGuildStickersUpdateEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("PresenceUpdate"),
+        Class< DpPresenceUpdateEvent, NoConstructor< DpPresenceUpdateEvent > >(vm, SqDppPresenceUpdateEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppPresenceUpdateEvent::Fn)
+        .Func(_SC("_tostring"), &DpPresenceUpdateEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpPresenceUpdateEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("WebhooksUpdate"),
+        Class< DpWebhooksUpdateEvent, NoConstructor< DpWebhooksUpdateEvent > >(vm, SqDppWebhooksUpdateEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppWebhooksUpdateEvent::Fn)
+        .Func(_SC("_tostring"), &DpWebhooksUpdateEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpWebhooksUpdateEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("GuildMemberAdd"),
+        Class< DpGuildMemberAddEvent, NoConstructor< DpGuildMemberAddEvent > >(vm, SqDppGuildMemberAddEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppGuildMemberAddEvent::Fn)
+        .Func(_SC("_tostring"), &DpGuildMemberAddEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpGuildMemberAddEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("InviteDelete"),
+        Class< DpInviteDeleteEvent, NoConstructor< DpInviteDeleteEvent > >(vm, SqDppInviteDeleteEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppInviteDeleteEvent::Fn)
+        .Func(_SC("_tostring"), &DpInviteDeleteEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpInviteDeleteEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("GuildUpdate"),
+        Class< DpGuildUpdateEvent, NoConstructor< DpGuildUpdateEvent > >(vm, SqDppGuildUpdateEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppGuildUpdateEvent::Fn)
+        .Func(_SC("_tostring"), &DpGuildUpdateEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpGuildUpdateEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("GuildIntegrationsUpdate"),
+        Class< DpGuildIntegrationsUpdateEvent, NoConstructor< DpGuildIntegrationsUpdateEvent > >(vm, SqDppGuildIntegrationsUpdateEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppGuildIntegrationsUpdateEvent::Fn)
+        .Func(_SC("_tostring"), &DpGuildIntegrationsUpdateEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpGuildIntegrationsUpdateEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("GuildMemberUpdate"),
+        Class< DpGuildMemberUpdateEvent, NoConstructor< DpGuildMemberUpdateEvent > >(vm, SqDppGuildMemberUpdateEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppGuildMemberUpdateEvent::Fn)
+        .Func(_SC("_tostring"), &DpGuildMemberUpdateEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpGuildMemberUpdateEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("ApplicationCommandUpdate"),
+        Class< DpApplicationCommandUpdateEvent, NoConstructor< DpApplicationCommandUpdateEvent > >(vm, SqDppApplicationCommandUpdateEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppApplicationCommandUpdateEvent::Fn)
+        .Func(_SC("_tostring"), &DpApplicationCommandUpdateEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpApplicationCommandUpdateEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("InviteCreate"),
+        Class< DpInviteCreateEvent, NoConstructor< DpInviteCreateEvent > >(vm, SqDppInviteCreateEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppInviteCreateEvent::Fn)
+        .Func(_SC("_tostring"), &DpInviteCreateEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpInviteCreateEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("MessageUpdate"),
+        Class< DpMessageUpdateEvent, NoConstructor< DpMessageUpdateEvent > >(vm, SqDppMessageUpdateEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppMessageUpdateEvent::Fn)
+        .Func(_SC("_tostring"), &DpMessageUpdateEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpMessageUpdateEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("UserUpdate"),
+        Class< DpUserUpdateEvent, NoConstructor< DpUserUpdateEvent > >(vm, SqDppUserUpdateEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppUserUpdateEvent::Fn)
+        .Func(_SC("_tostring"), &DpUserUpdateEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpUserUpdateEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("MessageCreate"),
+        Class< DpMessageCreateEvent, NoConstructor< DpMessageCreateEvent > >(vm, SqDppMessageCreateEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppMessageCreateEvent::Fn)
+        .Func(_SC("_tostring"), &DpMessageCreateEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpMessageCreateEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("GuildBanAdd"),
+        Class< DpGuildBanAddEvent, NoConstructor< DpGuildBanAddEvent > >(vm, SqDppGuildBanAddEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppGuildBanAddEvent::Fn)
+        .Func(_SC("_tostring"), &DpGuildBanAddEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpGuildBanAddEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("GuildBanRemove"),
+        Class< DpGuildBanRemoveEvent, NoConstructor< DpGuildBanRemoveEvent > >(vm, SqDppGuildBanRemoveEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppGuildBanRemoveEvent::Fn)
+        .Func(_SC("_tostring"), &DpGuildBanRemoveEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpGuildBanRemoveEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("IntegrationCreate"),
+        Class< DpIntegrationCreateEvent, NoConstructor< DpIntegrationCreateEvent > >(vm, SqDppIntegrationCreateEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppIntegrationCreateEvent::Fn)
+        .Func(_SC("_tostring"), &DpIntegrationCreateEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpIntegrationCreateEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("IntegrationUpdate"),
+        Class< DpIntegrationUpdateEvent, NoConstructor< DpIntegrationUpdateEvent > >(vm, SqDppIntegrationUpdateEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppIntegrationUpdateEvent::Fn)
+        .Func(_SC("_tostring"), &DpIntegrationUpdateEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpIntegrationUpdateEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("IntegrationDelete"),
+        Class< DpIntegrationDeleteEvent, NoConstructor< DpIntegrationDeleteEvent > >(vm, SqDppIntegrationDeleteEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppIntegrationDeleteEvent::Fn)
+        .Func(_SC("_tostring"), &DpIntegrationDeleteEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpIntegrationDeleteEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("ThreadCreate"),
+        Class< DpThreadCreateEvent, NoConstructor< DpThreadCreateEvent > >(vm, SqDppThreadCreateEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppThreadCreateEvent::Fn)
+        .Func(_SC("_tostring"), &DpThreadCreateEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpThreadCreateEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("ThreadUpdate"),
+        Class< DpThreadUpdateEvent, NoConstructor< DpThreadUpdateEvent > >(vm, SqDppThreadUpdateEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppThreadUpdateEvent::Fn)
+        .Func(_SC("_tostring"), &DpThreadUpdateEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpThreadUpdateEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("ThreadDelete"),
+        Class< DpThreadDeleteEvent, NoConstructor< DpThreadDeleteEvent > >(vm, SqDppThreadDeleteEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppThreadDeleteEvent::Fn)
+        .Func(_SC("_tostring"), &DpThreadDeleteEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpThreadDeleteEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("ThreadListSync"),
+        Class< DpThreadListSyncEvent, NoConstructor< DpThreadListSyncEvent > >(vm, SqDppThreadListSyncEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppThreadListSyncEvent::Fn)
+        .Func(_SC("_tostring"), &DpThreadListSyncEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpThreadListSyncEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("ThreadMemberUpdate"),
+        Class< DpThreadMemberUpdateEvent, NoConstructor< DpThreadMemberUpdateEvent > >(vm, SqDppThreadMemberUpdateEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppThreadMemberUpdateEvent::Fn)
+        .Func(_SC("_tostring"), &DpThreadMemberUpdateEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpThreadMemberUpdateEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("ThreadMembersUpdate"),
+        Class< DpThreadMembersUpdateEvent, NoConstructor< DpThreadMembersUpdateEvent > >(vm, SqDppThreadMembersUpdateEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppThreadMembersUpdateEvent::Fn)
+        .Func(_SC("_tostring"), &DpThreadMembersUpdateEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpThreadMembersUpdateEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("VoiceBufferSend"),
+        Class< DpVoiceBufferSendEvent, NoConstructor< DpVoiceBufferSendEvent > >(vm, SqDppVoiceBufferSendEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppVoiceBufferSendEvent::Fn)
+        .Func(_SC("_tostring"), &DpVoiceBufferSendEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpVoiceBufferSendEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("VoiceUserTalking"),
+        Class< DpVoiceUserTalkingEvent, NoConstructor< DpVoiceUserTalkingEvent > >(vm, SqDppVoiceUserTalkingEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppVoiceUserTalkingEvent::Fn)
+        .Func(_SC("_tostring"), &DpVoiceUserTalkingEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpVoiceUserTalkingEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("VoiceReady"),
+        Class< DpVoiceReadyEvent, NoConstructor< DpVoiceReadyEvent > >(vm, SqDppVoiceReadyEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppVoiceReadyEvent::Fn)
+        .Func(_SC("_tostring"), &DpVoiceReadyEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpVoiceReadyEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("VoiceReceive"),
+        Class< DpVoiceReceiveEvent, NoConstructor< DpVoiceReceiveEvent > >(vm, SqDppVoiceReceiveEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppVoiceReceiveEvent::Fn)
+        .Func(_SC("_tostring"), &DpVoiceReceiveEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpVoiceReceiveEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("VoiceTrackMarker"),
+        Class< DpVoiceTrackMarkerEvent, NoConstructor< DpVoiceTrackMarkerEvent > >(vm, SqDppVoiceTrackMarkerEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppVoiceTrackMarkerEvent::Fn)
+        .Func(_SC("_tostring"), &DpVoiceTrackMarkerEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpVoiceTrackMarkerEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("StageInstanceCreate"),
+        Class< DpStageInstanceCreateEvent, NoConstructor< DpStageInstanceCreateEvent > >(vm, SqDppStageInstanceCreateEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppStageInstanceCreateEvent::Fn)
+        .Func(_SC("_tostring"), &DpStageInstanceCreateEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpStageInstanceCreateEvent::GetRawEvent)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("StageInstanceDelete"),
+        Class< DpStageInstanceDeleteEvent, NoConstructor< DpStageInstanceDeleteEvent > >(vm, SqDppStageInstanceDeleteEvent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppStageInstanceDeleteEvent::Fn)
+        .Func(_SC("_tostring"), &DpStageInstanceDeleteEvent::GetRawEvent)
+        // Member Properties
+        .Prop(_SC("RawEvent"), &DpStageInstanceDeleteEvent::GetRawEvent)
+    );
+}
+
+} // Namespace:: SqMod

module/Library/DPP/Guild.cpp

@@ -0,0 +1,146 @@
+// ------------------------------------------------------------------------------------------------
+#include "Library/DPP/Guild.hpp"
+#include "Library/DPP/Other.hpp"
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+// ------------------------------------------------------------------------------------------------
+SQMOD_DECL_TYPENAME(SqDppGuildMember, _SC("SqDppGuildMember"))
+SQMOD_DECL_TYPENAME(SqDppGuild, _SC("SqDppGuild"))
+
+// ------------------------------------------------------------------------------------------------
+Table DpGuild::GetMembers() const
+{
+    Table t(SqVM(), static_cast< SQInteger >(Valid().members.size()));
+    // Attempt to convert the [members] associative container into a script table
+    const auto r = t.InsertFromMapWith(mPtr->members, [](HSQUIRRELVM vm, auto id, auto & m) -> SQRESULT {
+        // The [id] is a dpp::snowflake which is basically a uint64_t so let's leave that as is
+        sq_pushinteger(vm, static_cast< SQInteger >(id));
+        // Wrap the dpp::guild_member type into a DpGuildMember instance
+        ClassType< DpGuildMember >::PushInstance(vm, new DpGuildMember(m));
+        // The elements are now on the stack and can be inserted in the table
+        return SQ_OK;
+    });
+    // Did anything fail?
+    if (SQ_FAILED(r))
+    {
+        STHROWF("Unable to convert [members] container");
+    }
+    // Return the resulted table
+    return t;
+}
+
+// ------------------------------------------------------------------------------------------------
+Table DpGuild::GetVoiceMembers() const
+{
+    Table t(SqVM(), static_cast< SQInteger >(Valid().voice_members.size()));
+    // Attempt to convert the [voice_members] associative container into a script table
+    const auto r = t.InsertFromMapWith(mPtr->voice_members, [](HSQUIRRELVM vm, auto id, auto & m) -> SQRESULT {
+        // The [id] is a dpp::snowflake which is basically a uint64_t so let's leave that as is
+        sq_pushinteger(vm, static_cast< SQInteger >(id));
+        // Wrap the dpp::guild_member type into a DpGuildMember instance
+        ClassType< DpVoiceState >::PushInstance(vm, new DpVoiceState(m));
+        // The elements are now on the stack and can be inserted in the table
+        return SQ_OK;
+    });
+    // Did anything fail?
+    if (SQ_FAILED(r))
+    {
+        STHROWF("Unable to convert [voice_members] container");
+    }
+    // Return the resulted table
+    return t;
+}
+
+// ------------------------------------------------------------------------------------------------
+void Register_DPP_Guild(HSQUIRRELVM vm, Table & ns)
+{
+    ns.Bind(_SC("GuildMember"),
+        Class< DpGuildMember, NoConstructor< DpGuildMember > >(vm, SqDppGuildMember::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppGuildMember::Fn)
+        .Func(_SC("_tojson"), &DpGuildMember::BuildJSON)
+        // Member Properties
+        .Prop(_SC("Valid"), &DpGuildMember::IsValid)
+        .Prop(_SC("JSON"), &DpGuildMember::BuildJSON)
+        .Prop(_SC("Nickname"), &DpGuildMember::GetNickname)
+        .Prop(_SC("GuildID"), &DpGuildMember::GetGuildID)
+        .Prop(_SC("UserID"), &DpGuildMember::GetUserID)
+        .Prop(_SC("JoinedAt"), &DpGuildMember::GetJoinedAt)
+        .Prop(_SC("PremiumSince"), &DpGuildMember::GetPremiumSince)
+        .Prop(_SC("Flags"), &DpGuildMember::GetFlags)
+        .Prop(_SC("IsDeaf"), &DpGuildMember::IsDeaf)
+        .Prop(_SC("IsMuted"), &DpGuildMember::IsMuted)
+        .Prop(_SC("IsPending"), &DpGuildMember::IsPending)
+        // Member Methods
+        .Func(_SC("GetRoles"), &DpGuildMember::GetRoles)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("Guild"),
+        Class< DpGuild, NoConstructor< DpGuild > >(vm, SqDppGuild::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppGuild::Fn)
+        .Func(_SC("_tojson"), &DpGuild::BuildJSON)
+        // Member Properties
+        .Prop(_SC("Valid"), &DpGuild::IsValid)
+        .Prop(_SC("JSON"), &DpGuild::BuildJSON)
+        .Prop(_SC("ShardID"), &DpGuild::GetShardID)
+        .Prop(_SC("Flags"), &DpGuild::GetFlags)
+        .Prop(_SC("Name"), &DpGuild::GetName)
+        .Prop(_SC("Description"), &DpGuild::GetDescription)
+        .Prop(_SC("VanityUrlCode"), &DpGuild::GetVanityUrlCode)
+        .Prop(_SC("Icon"), &DpGuild::GetIcon)
+        .Prop(_SC("Splash"), &DpGuild::GetSplash)
+        .Prop(_SC("DiscoverySplash"), &DpGuild::GetDiscoverySplash)
+        .Prop(_SC("OwnerID"), &DpGuild::GetOwnerID)
+        .Prop(_SC("VoiceRegion"), &DpGuild::GetVoiceRegion)
+        .Prop(_SC("AfkChannelID"), &DpGuild::GetAfkChannelID)
+        .Prop(_SC("AfkTimeout"), &DpGuild::GetAfkTimeout)
+        .Prop(_SC("WidgetChannelID"), &DpGuild::GetWidgetChannelID)
+        .Prop(_SC("VerificationLevel"), &DpGuild::GetVerificationLevel)
+        .Prop(_SC("DefaultMessageNotifications"), &DpGuild::GetDefaultMessageNotifications)
+        .Prop(_SC("ExplicitContentFilter"), &DpGuild::GetExplicitContentFilter)
+        .Prop(_SC("MfaLevel"), &DpGuild::GetMfaLevel)
+        .Prop(_SC("ApplicationID"), &DpGuild::GetApplicationID)
+        .Prop(_SC("SystemChannelID"), &DpGuild::GetSystemChannelID)
+        .Prop(_SC("RulesChannelID"), &DpGuild::GetRulesChannelID)
+        .Prop(_SC("MemberCount"), &DpGuild::GetMemberCount)
+        .Prop(_SC("Banner"), &DpGuild::GetBanner)
+        .Prop(_SC("PremiumTier"), &DpGuild::GetPremiumTier)
+        .Prop(_SC("PremiumSubscriptionCount"), &DpGuild::GetPremiumSubscriptionCount)
+        .Prop(_SC("PublicUpdatesChannelID"), &DpGuild::GetPublicUpdatesChannelID)
+        .Prop(_SC("MaxVideoChannelUsers"), &DpGuild::GetMaxVideoChannelUsers)
+        .Prop(_SC("IsLarge"), &DpGuild::IsLarge)
+        .Prop(_SC("IsUnavailable"), &DpGuild::IsUnavailable)
+        .Prop(_SC("WidgetEnabled"), &DpGuild::WidgetEnabled)
+        .Prop(_SC("HasInviteSplash"), &DpGuild::HasInviteSplash)
+        .Prop(_SC("HasVipRegions"), &DpGuild::HasVipRegions)
+        .Prop(_SC("HasVanityURL"), &DpGuild::HasVanityURL)
+        .Prop(_SC("IsVerified"), &DpGuild::IsVerified)
+        .Prop(_SC("IsPartnered"), &DpGuild::IsPartnered)
+        .Prop(_SC("IsCommunity"), &DpGuild::IsCommunity)
+        .Prop(_SC("HasCommerce"), &DpGuild::HasCommerce)
+        .Prop(_SC("HasNews"), &DpGuild::HasNews)
+        .Prop(_SC("IsDiscoverable"), &DpGuild::IsDiscoverable)
+        .Prop(_SC("IsFeatureable"), &DpGuild::IsFeatureable)
+        .Prop(_SC("HasAnimatedIcon"), &DpGuild::HasAnimatedIcon)
+        .Prop(_SC("BasBanner"), &DpGuild::BasBanner)
+        .Prop(_SC("WelcomeScreenEnabled"), &DpGuild::WelcomeScreenEnabled)
+        .Prop(_SC("HasMemberVerificationGate"), &DpGuild::HasMemberVerificationGate)
+        .Prop(_SC("IsPreviewEnabled"), &DpGuild::IsPreviewEnabled)
+        .Prop(_SC("HasAnimatedIconHash"), &DpGuild::HasAnimatedIconHash)
+        // Member Methods
+        .Func(_SC("BuildJSON"), &DpGuild::BuildJSON_)
+        .Func(_SC("GetRoles"), &DpGuild::GetRoles)
+        .Func(_SC("GetChannels"), &DpGuild::GetChannels)
+        .Func(_SC("GetThreads"), &DpGuild::GetThreads)
+        .Func(_SC("GetMembers"), &DpGuild::GetMembers)
+        .Func(_SC("GetVoiceMembers"), &DpGuild::GetVoiceMembers)
+        .Func(_SC("GetEmojis"), &DpGuild::GetEmojis)
+        .Func(_SC("RehashMembers"), &DpGuild::RehashMembers)
+        .Func(_SC("ConnectMemberVoice"), &DpGuild::ConnectMemberVoice)
+    );
+}
+
+} // Namespace:: SqMod

module/Library/DPP/Guild.hpp

@@ -0,0 +1,478 @@
+#pragma once
+
+// ------------------------------------------------------------------------------------------------
+#include "Core/Utility.hpp"
+
+// ------------------------------------------------------------------------------------------------
+#include <chrono>
+
+// ------------------------------------------------------------------------------------------------
+#include <dpp/dpp.h>
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+/* ------------------------------------------------------------------------------------------------
+ * Represents a guild on Discord (AKA a server).
+*/
+struct DpGuildMember
+{
+    using Ptr = std::unique_ptr< dpp::guild_member >;
+    /* --------------------------------------------------------------------------------------------
+     * Referenced guild member instance.
+    */
+    Ptr mPtr{nullptr};
+    /* --------------------------------------------------------------------------------------------
+     * Whether the referenced pointer is owned.
+    */
+    bool mOwned{false};
+    /* --------------------------------------------------------------------------------------------
+     * Default constructor.
+    */
+    DpGuildMember() noexcept = default;
+    /* --------------------------------------------------------------------------------------------
+     * Explicit constructor.
+    */
+    explicit DpGuildMember(Ptr::pointer ptr, bool owned = false) noexcept
+        : mPtr(ptr), mOwned(owned)
+    { }
+    /* --------------------------------------------------------------------------------------------
+     * Copy constructor.
+    */
+    explicit DpGuildMember(const Ptr::element_type & o) noexcept
+        : DpGuildMember(new Ptr::element_type(o), true)
+    { }
+    /* --------------------------------------------------------------------------------------------
+     * Move constructor.
+    */
+    explicit DpGuildMember(Ptr::element_type && o) noexcept
+        : DpGuildMember(new Ptr::element_type(std::forward< Ptr::element_type >(o)), true)
+    { }
+    /* --------------------------------------------------------------------------------------------
+     * Copy constructor (disabled).
+    */
+    DpGuildMember(const DpGuildMember & o) = delete;
+    /* --------------------------------------------------------------------------------------------
+     * Move constructor.
+    */
+    DpGuildMember(DpGuildMember && o) noexcept = default;
+    /* --------------------------------------------------------------------------------------------
+     * Destructor.
+    */
+    ~DpGuildMember() noexcept { Cleanup(); }
+    /* --------------------------------------------------------------------------------------------
+     * Copy assignment operator (disabled).
+    */
+    DpGuildMember & operator = (const DpGuildMember & o) = delete;
+    /* --------------------------------------------------------------------------------------------
+     * Move assignment operator.
+    */
+    DpGuildMember & operator = (DpGuildMember && o) noexcept
+    {
+        if (this != &o) {
+            // Do we own this to try delete it?
+            Cleanup();
+            // Transfer members values
+            mPtr = std::move(o.mPtr);
+            mOwned = o.mOwned;
+        }
+        return *this;
+    }
+    /* --------------------------------------------------------------------------------------------
+     * Release any referenced resources and default to an empty/invalid state.
+    */
+    void Cleanup()
+    {
+        // Do we own this to try delete it?
+        if (!mOwned && mPtr) {
+            // Not our job, simply forget about it
+            [[maybe_unused]] auto p = mPtr.release();
+        } else mPtr.reset(); // We own this so delete the instance
+    }
+    /* --------------------------------------------------------------------------------------------
+     * Validate the managed handle.
+    */
+    void Validate() const { if (!mPtr) STHROWF("Invalid discord voice state handle"); }
+    /* --------------------------------------------------------------------------------------------
+     * Validate the managed handle and retrieve a const reference to it.
+    */
+    SQMOD_NODISCARD Ptr::element_type & Valid() const { Validate(); return *mPtr; }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether a valid instance is managed.
+    */
+    SQMOD_NODISCARD bool IsValid() const { return static_cast< bool >(mPtr); }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the gickname, or empty string if they don't have a nickname on this guild.
+    */
+    SQMOD_NODISCARD const std::string & GetNickname() const { return Valid().nickname; }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the guild id.
+    */
+    SQMOD_NODISCARD dpp::snowflake GetGuildID() const { return Valid().guild_id; }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the user id.
+    */
+    SQMOD_NODISCARD dpp::snowflake GetUserID() const { return Valid().user_id; }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the list of roles this user has on this guild.
+    */
+    SQMOD_NODISCARD Array GetRoles() const
+    {
+        return Array(SqVM()).Reserve(static_cast< SQInteger >(Valid().roles.size()))
+                            .AppendFromVector(Valid().roles);
+    }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the date and time since the user joined the guild.
+    */
+    SQMOD_NODISCARD SQInteger GetJoinedAt() const
+    {
+        return std::chrono::time_point_cast< std::chrono::seconds >(
+                std::chrono::system_clock::from_time_t(Valid().joined_at)
+            ).time_since_epoch().count();
+    }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the date and time since the user has boosted the guild guild.
+    */
+    SQMOD_NODISCARD SQInteger GetPremiumSince() const
+    {
+        return std::chrono::time_point_cast< std::chrono::seconds >(
+                std::chrono::system_clock::from_time_t(Valid().premium_since)
+            ).time_since_epoch().count();
+    }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the set of flags built from the bitmask defined by dpp::guild_member_flags.
+    */
+    SQMOD_NODISCARD SQInteger GetFlags() const { return static_cast< SQInteger >(Valid().flags); }
+    /* --------------------------------------------------------------------------------------------
+     * Build JSON string for the member object.
+    */
+    SQMOD_NODISCARD std::string BuildJSON() const { return Valid().build_json(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the user is deafened.
+    */
+    SQMOD_NODISCARD bool IsDeaf() const { return Valid().is_deaf(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the user is muted.
+    */
+    SQMOD_NODISCARD bool IsMuted() const { return Valid().is_muted(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the user is pending verification by membership screening.
+    */
+    SQMOD_NODISCARD bool IsPending() const { return Valid().is_pending(); }
+};
+
+/* ------------------------------------------------------------------------------------------------
+ * Represents a guild on Discord (AKA a server)
+*/
+struct DpGuild
+{
+    using Ptr = std::unique_ptr< dpp::guild >;
+    /* --------------------------------------------------------------------------------------------
+     * Referenced guild instance.
+    */
+    Ptr mPtr{nullptr};
+    /* --------------------------------------------------------------------------------------------
+     * Whether the referenced pointer is owned.
+    */
+    bool mOwned{false};
+    /* --------------------------------------------------------------------------------------------
+     * Default constructor.
+    */
+    DpGuild() noexcept = default;
+    /* --------------------------------------------------------------------------------------------
+     * Explicit constructor.
+    */
+    explicit DpGuild(Ptr::pointer ptr, bool owned = false) noexcept
+        : mPtr(ptr), mOwned(owned)
+    { }
+    /* --------------------------------------------------------------------------------------------
+     * Copy constructor.
+    */
+    explicit DpGuild(const Ptr::element_type & o) noexcept
+        : DpGuild(new Ptr::element_type(o), true)
+    { }
+    /* --------------------------------------------------------------------------------------------
+     * Move constructor.
+    */
+    explicit DpGuild(Ptr::element_type && o) noexcept
+        : DpGuild(new Ptr::element_type(std::forward< Ptr::element_type >(o)), true)
+    { }
+    /* --------------------------------------------------------------------------------------------
+     * Copy constructor (disabled).
+    */
+    DpGuild(const DpGuild & o) = delete;
+    /* --------------------------------------------------------------------------------------------
+     * Move constructor.
+    */
+    DpGuild(DpGuild && o) noexcept = default;
+    /* --------------------------------------------------------------------------------------------
+     * Destructor.
+    */
+    ~DpGuild() noexcept { Cleanup(); }
+    /* --------------------------------------------------------------------------------------------
+     * Copy assignment operator (disabled).
+    */
+    DpGuild & operator = (const DpGuild & o) = delete;
+    /* --------------------------------------------------------------------------------------------
+     * Move assignment operator.
+    */
+    DpGuild & operator = (DpGuild && o) noexcept
+    {
+        if (this != &o) {
+            // Do we own this to try delete it?
+            Cleanup();
+            // Transfer members values
+            mPtr = std::move(o.mPtr);
+            mOwned = o.mOwned;
+        }
+        return *this;
+    }
+    /* --------------------------------------------------------------------------------------------
+     * Release any referenced resources and default to an empty/invalid state.
+    */
+    void Cleanup()
+    {
+        // Do we own this to try delete it?
+        if (!mOwned && mPtr) {
+            // Not our job, simply forget about it
+            [[maybe_unused]] auto p = mPtr.release();
+        } else mPtr.reset(); // We own this so delete the instance
+    }
+    /* --------------------------------------------------------------------------------------------
+     * Validate the managed handle.
+    */
+    void Validate() const { if (!mPtr) STHROWF("Invalid discord guild handle"); }
+    /* --------------------------------------------------------------------------------------------
+     * Validate the managed handle and retrieve a const reference to it.
+    */
+    SQMOD_NODISCARD Ptr::element_type & Valid() const { Validate(); return *mPtr; }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether a valid instance is managed.
+    */
+    SQMOD_NODISCARD bool IsValid() const { return static_cast< bool >(mPtr); }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the shard ID of the guild.
+    */
+    SQMOD_NODISCARD SQInteger GetShardID() const { return static_cast< SQInteger >(Valid().shard_id); }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the flags bitmask as defined by values within dpp::guild_flags.
+    */
+    SQMOD_NODISCARD SQInteger GetFlags() const { return static_cast< SQInteger >(Valid().flags); }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the guild name.
+    */
+    SQMOD_NODISCARD const std::string & GetName() const { return Valid().name; }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the server description for communities.
+    */
+    SQMOD_NODISCARD const std::string & GetDescription() const { return Valid().description; }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the vanity url code for verified or partnered servers and boost level 3.
+    */
+    SQMOD_NODISCARD const std::string & GetVanityUrlCode() const { return Valid().vanity_url_code; }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the guild icon hash.
+    */
+    SQMOD_NODISCARD const dpp::utility::iconhash & GetIcon() const { return Valid().icon; }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the guild splash hash.
+    */
+    SQMOD_NODISCARD const dpp::utility::iconhash & GetSplash() const { return Valid().splash; }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the guild discovery splash hash.
+    */
+    SQMOD_NODISCARD const dpp::utility::iconhash & GetDiscoverySplash() const { return Valid().discovery_splash; }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the snowflake id of guild owner.
+    */
+    SQMOD_NODISCARD dpp::snowflake GetOwnerID() const { return Valid().owner_id; }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the guild voice region.
+    */
+    SQMOD_NODISCARD SQInteger GetVoiceRegion() const { return static_cast< SQInteger >(Valid().voice_region); }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the snowflake ID of AFK voice channel or 0.
+    */
+    SQMOD_NODISCARD dpp::snowflake GetAfkChannelID() const { return Valid().afk_channel_id; }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the voice AFK timeout before moving users to AFK channel.
+    */
+    SQMOD_NODISCARD SQInteger GetAfkTimeout() const { return static_cast< SQInteger >(Valid().afk_timeout); }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the snowflake ID of widget channel, or 0.
+    */
+    SQMOD_NODISCARD dpp::snowflake GetWidgetChannelID() const { return Valid().widget_channel_id; }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the verification level of server.
+    */
+    SQMOD_NODISCARD SQInteger GetVerificationLevel() const { return static_cast< SQInteger >(Valid().verification_level); }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the setting for how notifications are to be delivered to users.
+    */
+    SQMOD_NODISCARD SQInteger GetDefaultMessageNotifications() const { return static_cast< SQInteger >(Valid().default_message_notifications); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether or not explicit content filtering is enable and what setting it is.
+    */
+    SQMOD_NODISCARD SQInteger GetExplicitContentFilter() const { return static_cast< SQInteger >(Valid().explicit_content_filter); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether multi factor authentication is required for moderators or not.
+    */
+    SQMOD_NODISCARD SQInteger GetMfaLevel() const { return static_cast< SQInteger >(Valid().mfa_level); }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the ID of creating application, if any, or 0.
+    */
+    SQMOD_NODISCARD dpp::snowflake GetApplicationID() const { return Valid().application_id; }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the ID of system channel where discord update messages are sent.
+    */
+    SQMOD_NODISCARD dpp::snowflake GetSystemChannelID() const { return Valid().system_channel_id; }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the ID of rules channel for communities.
+    */
+    SQMOD_NODISCARD dpp::snowflake GetRulesChannelID() const { return Valid().rules_channel_id; }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the approximate member count. May be sent as zero.
+    */
+    SQMOD_NODISCARD SQInteger GetMemberCount() const { return static_cast< SQInteger >(Valid().member_count); }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the server banner hash.
+    */
+    SQMOD_NODISCARD const dpp::utility::iconhash & GetBanner() const { return Valid().banner; }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the boost level.
+    */
+    SQMOD_NODISCARD SQInteger GetPremiumTier() const { return static_cast< SQInteger >(Valid().premium_tier); }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the number of boosters.
+    */
+    SQMOD_NODISCARD SQInteger GetPremiumSubscriptionCount() const { return static_cast< SQInteger >(Valid().premium_subscription_count); }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve public updates channel ID or 0.
+    */
+    SQMOD_NODISCARD dpp::snowflake GetPublicUpdatesChannelID() const { return Valid().public_updates_channel_id; }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the maximum users in a video channel, or 0.
+    */
+    SQMOD_NODISCARD SQInteger GetMaxVideoChannelUsers() const { return static_cast< SQInteger >(Valid().max_video_channel_users); }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve a roles defined on this server.
+    */
+    SQMOD_NODISCARD Array GetRoles() const { return Array(SqVM()).Reserve(static_cast< SQInteger >(Valid().roles.size())).AppendFromVector(Valid().roles); }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve a list of channels on this server.
+    */
+    SQMOD_NODISCARD Array GetChannels() const { return Array(SqVM()).Reserve(static_cast< SQInteger >(Valid().channels.size())).AppendFromVector(Valid().channels); }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve a list of threads on this server.
+    */
+    SQMOD_NODISCARD Array GetThreads() const { return Array(SqVM()).Reserve(static_cast< SQInteger >(Valid().threads.size())).AppendFromVector(Valid().threads); }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve a list of guild members. Note that when you first receive the guild create event,
+     * this may be empty or near empty. This depends upon your dpp::intents and the size of your bot.
+     * It will be filled by guild member chunk requests.
+    */
+    SQMOD_NODISCARD Table GetMembers() const;
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve a list of members in voice channels in the guild.
+    */
+    SQMOD_NODISCARD Table GetVoiceMembers() const;
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve a list of emojis.
+    */
+    SQMOD_NODISCARD Array GetEmojis() const { return Array(SqVM()).Reserve(static_cast< SQInteger >(Valid().emojis.size())).AppendFromVector(Valid().emojis); }
+    /* --------------------------------------------------------------------------------------------
+     * Build a JSON string from this object.
+    */
+    SQMOD_NODISCARD std::string BuildJSON() const { return Valid().build_json(); }
+    /* --------------------------------------------------------------------------------------------
+     * Build a JSON string from this object. If [with_id] is True then ID is to be included in the JSON.
+    */
+    SQMOD_NODISCARD std::string BuildJSON_(bool with_id) const { return Valid().build_json(with_id); }
+    /* --------------------------------------------------------------------------------------------
+     * Rehash members map.
+    */
+    SQMOD_NODISCARD DpGuild & RehashMembers() { Valid().rehash_members(); return *this; }
+    /* --------------------------------------------------------------------------------------------
+     * Connect to a voice channel another guild member is in.
+     * Returns true if the user specified is in a voice channel, false if they aren't.
+    */
+    SQMOD_NODISCARD bool ConnectMemberVoice(SQInteger user_id) const { return Valid().connect_member_voice(user_id); }
+    /* --------------------------------------------------------------------------------------------
+     * Is a large server (>250 users).
+    */
+    SQMOD_NODISCARD bool IsLarge() const { return Valid().is_large(); }
+    /* --------------------------------------------------------------------------------------------
+     * Is unavailable due to outage (most other fields will be blank or outdated).
+    */
+    SQMOD_NODISCARD bool IsUnavailable() const { return Valid().is_unavailable(); }
+    /* --------------------------------------------------------------------------------------------
+     * Widget is enabled for this server.
+    */
+    SQMOD_NODISCARD bool WidgetEnabled() const { return Valid().widget_enabled(); }
+    /* --------------------------------------------------------------------------------------------
+     * Guild has an invite splash.
+    */
+    SQMOD_NODISCARD bool HasInviteSplash() const { return Valid().has_invite_splash(); }
+    /* --------------------------------------------------------------------------------------------
+     * Guild has VIP regions.
+    */
+    SQMOD_NODISCARD bool HasVipRegions() const { return Valid().has_vip_regions(); }
+    /* --------------------------------------------------------------------------------------------
+     * Guild can have a vanity URL.
+    */
+    SQMOD_NODISCARD bool HasVanityURL() const { return Valid().has_vanity_url(); }
+    /* --------------------------------------------------------------------------------------------
+     * Guild is a verified server.
+    */
+    SQMOD_NODISCARD bool IsVerified() const { return Valid().is_verified(); }
+    /* --------------------------------------------------------------------------------------------
+     * Guild is a discord partner server.
+    */
+    SQMOD_NODISCARD bool IsPartnered() const { return Valid().is_partnered(); }
+    /* --------------------------------------------------------------------------------------------
+     * Guild has enabled community.
+    */
+    SQMOD_NODISCARD bool IsCommunity() const { return Valid().is_community(); }
+    /* --------------------------------------------------------------------------------------------
+     * Guild has enabled commerce channels.
+    */
+    SQMOD_NODISCARD bool HasCommerce() const { return Valid().has_commerce(); }
+    /* --------------------------------------------------------------------------------------------
+     * Guild has news channel.
+    */
+    SQMOD_NODISCARD bool HasNews() const { return Valid().has_news(); }
+    /* --------------------------------------------------------------------------------------------
+     * Guild is discoverable.
+    */
+    SQMOD_NODISCARD bool IsDiscoverable() const { return Valid().is_discoverable(); }
+    /* --------------------------------------------------------------------------------------------
+     * Guild is featureable.
+    */
+    SQMOD_NODISCARD bool IsFeatureable() const { return Valid().is_featureable(); }
+    /* --------------------------------------------------------------------------------------------
+     * Guild is allowed an animated icon.
+    */
+    SQMOD_NODISCARD bool HasAnimatedIcon() const { return Valid().has_animated_icon(); }
+    /* --------------------------------------------------------------------------------------------
+     * Guild has a banner image.
+    */
+    SQMOD_NODISCARD bool BasBanner() const { return Valid().has_banner(); }
+    /* --------------------------------------------------------------------------------------------
+     * Guild has enabled welcome screen.
+    */
+    SQMOD_NODISCARD bool WelcomeScreenEnabled() const { return Valid().is_welcome_screen_enabled(); }
+    /* --------------------------------------------------------------------------------------------
+     * Guild has enabled membership screening.
+    */
+    SQMOD_NODISCARD bool HasMemberVerificationGate() const { return Valid().has_member_verification_gate(); }
+    /* --------------------------------------------------------------------------------------------
+     * Guild has preview enabled.
+    */
+    SQMOD_NODISCARD bool IsPreviewEnabled() const { return Valid().is_preview_enabled(); }
+    /* --------------------------------------------------------------------------------------------
+     * Server icon is actually an animated gif.
+    */
+    SQMOD_NODISCARD bool HasAnimatedIconHash() const { return Valid().has_animated_icon_hash(); }
+};
+
+} // Namespace:: SqMod

module/Library/DPP/Integration.cpp

@@ -0,0 +1,16 @@
+// ------------------------------------------------------------------------------------------------
+#include "Library/DPP/Integration.hpp"
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+// ------------------------------------------------------------------------------------------------
+
+
+// ------------------------------------------------------------------------------------------------
+void Register_DPP_Integration(HSQUIRRELVM vm, Table & ns)
+{
+
+}
+
+} // Namespace:: SqMod

module/Library/DPP/Integration.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+// ------------------------------------------------------------------------------------------------
+#include "Core/Utility.hpp"
+
+// ------------------------------------------------------------------------------------------------
+#include <chrono>
+
+// ------------------------------------------------------------------------------------------------
+#include <dpp/dpp.h>
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+/* ------------------------------------------------------------------------------------------------
+ * 
+*/
+
+} // Namespace:: SqMod

module/Library/DPP/Message.cpp

@@ -0,0 +1,242 @@
+// ------------------------------------------------------------------------------------------------
+#include "Library/DPP/Message.hpp"
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+// ------------------------------------------------------------------------------------------------
+SQMOD_DECL_TYPENAME(SqDppSelectOption, _SC("SqDppSelectOption"))
+SQMOD_DECL_TYPENAME(SqDppSelectOptions, _SC("SqDppSelectOptions"))
+SQMOD_DECL_TYPENAME(SqDppComponent, _SC("SqDppComponent"))
+SQMOD_DECL_TYPENAME(SqDppComponents, _SC("SqDppComponents"))
+SQMOD_DECL_TYPENAME(SqDppEmbedFooter, _SC("SqDppEmbedFooter"))
+SQMOD_DECL_TYPENAME(SqDppEmbedImage, _SC("SqDppEmbedImage"))
+SQMOD_DECL_TYPENAME(SqDppEmbedProvider, _SC("SqDppEmbedProvider"))
+SQMOD_DECL_TYPENAME(SqDppEmbedAuthor, _SC("SqDppEmbedAuthor"))
+SQMOD_DECL_TYPENAME(SqDppEmbedField, _SC("SqDppEmbedField"))
+SQMOD_DECL_TYPENAME(SqDppEmbed, _SC("SqDppEmbed"))
+SQMOD_DECL_TYPENAME(SqDppReaction, _SC("SqDppReaction"))
+SQMOD_DECL_TYPENAME(SqDppAttachment, _SC("SqDppAttachment"))
+SQMOD_DECL_TYPENAME(SqDppSticker, _SC("SqDppSticker"))
+SQMOD_DECL_TYPENAME(SqDppStickerPack, _SC("SqDppStickerPack"))
+SQMOD_DECL_TYPENAME(SqDppMessage, _SC("SqDppMessage"))
+
+// ------------------------------------------------------------------------------------------------
+void Register_DPP_Message(HSQUIRRELVM vm, Table & ns)
+{
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("SelectOption"),
+        Class< DpSelectOption, NoCopy< DpSelectOption > >(vm, SqDppSelectOption::Str)
+        .Ctor()
+        .Ctor< StackStrF &, StackStrF &, StackStrF & >()
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppSelectOption::Fn)
+        // Member Properties
+        .Prop(_SC("Valid"), &DpSelectOption::IsValid)
+        .Prop(_SC("Label"), &DpSelectOption::GetLabel, &DpSelectOption::SetLabel)
+        .Prop(_SC("Value"), &DpSelectOption::GetValue, &DpSelectOption::SetValue)
+        .Prop(_SC("Description"), &DpSelectOption::GetDescription, &DpSelectOption::SetDescription)
+        .Prop(_SC("IsDefault"), &DpSelectOption::IsDefault, &DpSelectOption::SetDefault)
+        .Prop(_SC("IsAnimated"), &DpSelectOption::IsAnimated, &DpSelectOption::SetAnimated)
+        .Prop(_SC("EmojiName"), &DpSelectOption::GetEmojiName, &DpSelectOption::SetEmojiName)
+        .Prop(_SC("EmojiID"), &DpSelectOption::GetEmojiID, &DpSelectOption::SetEmojiID)
+        // Member Methods
+        .FmtFunc(_SC("SetLabel"), &DpSelectOption::ApplyLabel)
+        .FmtFunc(_SC("SetValue"), &DpSelectOption::ApplyValue)
+        .FmtFunc(_SC("SetDescription"), &DpSelectOption::ApplyDescription)
+        .FmtFunc(_SC("SetEmoji"), &DpSelectOption::SetEmoji)
+        .FmtFunc(_SC("SetDefault"), &DpSelectOption::SetDefault)
+        .FmtFunc(_SC("SetAnimated"), &DpSelectOption::SetAnimated)
+        .FmtFunc(_SC("SetEmojiName"), &DpSelectOption::ApplyEmojiName)
+    );
+    // --------------------------------------------------------------------------------------------
+    Register_DPP_VectorProxy< dpp::select_option, DpSelectOption, SqDppSelectOptions >(vm, ns, _SC("SelectOptions"));
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("Component"),
+        Class< DpComponent, NoConstructor< DpComponent > >(vm, SqDppComponent::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppComponent::Fn)
+        // Member Properties
+        .Prop(_SC("Valid"), &DpComponent::IsValid)
+        .Prop(_SC("JSON"), &DpComponent::BuildJSON)
+        .Prop(_SC("Type"), &DpComponent::GetType, &DpComponent::SetType)
+        .Prop(_SC("Label"), &DpComponent::GetLabel, &DpComponent::SetLabel)
+        .Prop(_SC("Style"), &DpComponent::GetStyle, &DpComponent::SetStyle)
+        .Prop(_SC("CustomID"), &DpComponent::GetCustomID, &DpComponent::SetCustomID)
+        .Prop(_SC("URL"), &DpComponent::GetURL, &DpComponent::SetURL)
+        .Prop(_SC("Placeholder"), &DpComponent::GetPlaceholder, &DpComponent::SetPlaceholder)
+        .Prop(_SC("MinValues"), &DpComponent::GetMinValues, &DpComponent::SetMinValues)
+        .Prop(_SC("MaxValues"), &DpComponent::GetMaxValues, &DpComponent::SetMaxValues)
+        .Prop(_SC("Disabled"), &DpComponent::IsDisabled, &DpComponent::SetDisabled)
+        .Prop(_SC("IsAnimated"), &DpComponent::IsAnimated, &DpComponent::SetAnimated)
+        .Prop(_SC("EmojiName"), &DpComponent::GetEmojiName, &DpComponent::SetEmojiName)
+        .Prop(_SC("EmojiID"), &DpComponent::GetEmojiID, &DpComponent::SetEmojiID)
+        // Member Methods
+        .FmtFunc(_SC("SetLabel"), &DpComponent::ApplyLabel)
+        .FmtFunc(_SC("SetCustomID"), &DpComponent::ApplyCustomID)
+        .FmtFunc(_SC("SetURL"), &DpComponent::ApplyURL)
+        .FmtFunc(_SC("SetPlaceholder"), &DpComponent::ApplyPlaceholder)
+        .FmtFunc(_SC("SetDisabled"), &DpComponent::SetDisabled)
+        .FmtFunc(_SC("SetAnimated"), &DpComponent::SetAnimated)
+        .FmtFunc(_SC("SetEmojiName"), &DpComponent::ApplyEmojiName)
+        .FmtFunc(_SC("GetComponents"), &DpComponent::GetComponents)
+        .FmtFunc(_SC("GetOptions"), &DpComponent::GetOptions)
+        .FmtFunc(_SC("AddComponent"), &DpComponent::AddComponent)
+        .FmtFunc(_SC("AddOption"), &DpComponent::AddSelectOption)
+    );
+    // --------------------------------------------------------------------------------------------
+    Register_DPP_VectorProxy< dpp::component, DpComponent, SqDppComponent >(vm, ns, _SC("Components"));
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("EmbedFooter"),
+        Class< DpEmbedFooter, NoConstructor< DpEmbedFooter > >(vm, SqDppEmbedFooter::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppEmbedFooter::Fn)
+        // Member Properties
+        .Prop(_SC("Valid"), &DpEmbedFooter::IsValid)
+        .Prop(_SC("Text"), &DpEmbedFooter::GetText, &DpEmbedFooter::SetText)
+        .Prop(_SC("Icon"), &DpEmbedFooter::GetIconURL, &DpEmbedFooter::SetIconURL)
+        .Prop(_SC("Proxy"), &DpEmbedFooter::GetProxyURL, &DpEmbedFooter::SetProxyURL)
+        // Member Methods
+        .FmtFunc(_SC("SetText"), &DpEmbedFooter::ApplyText)
+        .FmtFunc(_SC("SetIcon"), &DpEmbedFooter::ApplyIconURL)
+        .FmtFunc(_SC("SetProxy"), &DpEmbedFooter::ApplyProxyURL)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("EmbedImage"),
+        Class< DpEmbedImage, NoConstructor< DpEmbedImage > >(vm, SqDppEmbedImage::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppEmbedImage::Fn)
+        // Member Properties
+        .Prop(_SC("Valid"), &DpEmbedImage::IsValid)
+        .Prop(_SC("URL"), &DpEmbedImage::GetURL, &DpEmbedImage::SetURL)
+        .Prop(_SC("Proxy"), &DpEmbedImage::GetProxyURL, &DpEmbedImage::SetProxyURL)
+        .Prop(_SC("Height"), &DpEmbedImage::GetHeight, &DpEmbedImage::SetHeight)
+        .Prop(_SC("Width"), &DpEmbedImage::GetWidth, &DpEmbedImage::SetWidth)
+        // Member Methods
+        .FmtFunc(_SC("SetURL"), &DpEmbedImage::ApplyURL)
+        .FmtFunc(_SC("SetProxy"), &DpEmbedImage::ApplyProxyURL)
+        .FmtFunc(_SC("SetHeight"), &DpEmbedImage::ApplyHeight)
+        .FmtFunc(_SC("SetWidth"), &DpEmbedImage::ApplyWidth)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("EmbedProvider"),
+        Class< DpEmbedProvider, NoConstructor< DpEmbedProvider > >(vm, SqDppEmbedProvider::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppEmbedProvider::Fn)
+        // Member Properties
+        .Prop(_SC("Valid"), &DpEmbedProvider::IsValid)
+        .Prop(_SC("Name"), &DpEmbedProvider::GetName, &DpEmbedProvider::SetName)
+        .Prop(_SC("URL"), &DpEmbedProvider::GetURL, &DpEmbedProvider::SetURL)
+        // Member Methods
+        .FmtFunc(_SC("SetName"), &DpEmbedProvider::ApplyName)
+        .FmtFunc(_SC("SetURL"), &DpEmbedProvider::ApplyURL)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("EmbedAuthor"),
+        Class< DpEmbedAuthor, NoConstructor< DpEmbedAuthor > >(vm, SqDppEmbedAuthor::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppEmbedAuthor::Fn)
+        // Member Properties
+        .Prop(_SC("Valid"), &DpEmbedAuthor::IsValid)
+        .Prop(_SC("Name"), &DpEmbedAuthor::GetName, &DpEmbedAuthor::SetName)
+        .Prop(_SC("URL"), &DpEmbedAuthor::GetURL, &DpEmbedAuthor::SetURL)
+        .Prop(_SC("Icon"), &DpEmbedAuthor::GetIconURL, &DpEmbedAuthor::SetIconURL)
+        .Prop(_SC("ProxyIcon"), &DpEmbedAuthor::GetProxyIconURL, &DpEmbedAuthor::SetProxyIconURL)
+        // Member Methods
+        .FmtFunc(_SC("SetName"), &DpEmbedAuthor::ApplyName)
+        .FmtFunc(_SC("SetURL"), &DpEmbedAuthor::ApplyURL)
+        .FmtFunc(_SC("SetIcon"), &DpEmbedAuthor::ApplyIconURL)
+        .FmtFunc(_SC("SetProxyIcon"), &DpEmbedAuthor::ApplyProxyIconURL)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("EmbedField"),
+        Class< DpEmbedField, NoConstructor< DpEmbedField > >(vm, SqDppEmbedField::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppEmbedField::Fn)
+        // Member Properties
+        .Prop(_SC("Valid"), &DpEmbedField::IsValid)
+        .Prop(_SC("Name"), &DpEmbedField::GetName, &DpEmbedField::SetName)
+        .Prop(_SC("Value"), &DpEmbedField::GetValue, &DpEmbedField::SetValue)
+        .Prop(_SC("Inline"), &DpEmbedField::IsInline, &DpEmbedField::SetInline)
+        // Member Methods
+        .FmtFunc(_SC("SetName"), &DpEmbedField::ApplyName)
+        .FmtFunc(_SC("SetValue"), &DpEmbedField::ApplyValue)
+        .FmtFunc(_SC("SetInline"), &DpEmbedField::SetInline)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("Embed"),
+        Class< DpEmbed, NoConstructor< DpEmbed > >(vm, SqDppEmbed::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppEmbed::Fn)
+        // Member Properties
+        .Prop(_SC("Valid"), &DpEmbed::IsValid)
+        .Prop(_SC("Title"), &DpEmbed::GetTitle, &DpEmbed::SetTitle)
+        .Prop(_SC("Type"), &DpEmbed::GetType, &DpEmbed::SetType)
+        .Prop(_SC("Description"), &DpEmbed::GetDescription, &DpEmbed::SetDescription)
+        .Prop(_SC("URL"), &DpEmbed::GetURL, &DpEmbed::SetURL)
+        .Prop(_SC("TimeStamp"), &DpEmbed::GetTimeStamp, &DpEmbed::SetTimeStamp)
+        .Prop(_SC("Color"), &DpEmbed::GetColor, &DpEmbed::SetColor)
+        .Prop(_SC("Footer"), &DpEmbed::GetFooter, &DpEmbed::SetFooter)
+        .Prop(_SC("Image"), &DpEmbed::GetImage, &DpEmbed::SetImage)
+        .Prop(_SC("Thumbnail"), &DpEmbed::GetThumbnail, &DpEmbed::SetThumbnail)
+        .Prop(_SC("Video"), &DpEmbed::GetVideo, &DpEmbed::SetVideo)
+        .Prop(_SC("Provider"), &DpEmbed::GetProvider, &DpEmbed::SetProvider)
+        .Prop(_SC("Author"), &DpEmbed::GetAuthor, &DpEmbed::SetAuthor)
+        .Prop(_SC("Fields"), &DpEmbed::GetFields)
+        // Member Methods
+        .FmtFunc(_SC("SetTitle"), &DpEmbed::ApplyTitle)
+        .FmtFunc(_SC("SetType"), &DpEmbed::ApplyType)
+        .FmtFunc(_SC("SetDescription"), &DpEmbed::ApplyDescription)
+        .FmtFunc(_SC("SetURL"), &DpEmbed::ApplyURL)
+        .FmtFunc(_SC("SetTimeStamp"), &DpEmbed::ApplyTimeStamp)
+        .FmtFunc(_SC("SetFooter"), &DpEmbed::ApplyFooter)
+        .FmtFunc(_SC("SetImage"), &DpEmbed::ApplyImage)
+        .FmtFunc(_SC("SetThumbnail"), &DpEmbed::ApplyThumbnail)
+        .FmtFunc(_SC("SetVideo"), &DpEmbed::ApplyVideo)
+        .FmtFunc(_SC("SetProvider"), &DpEmbed::ApplyProvider)
+        .FmtFunc(_SC("SetAuthor"), &DpEmbed::ApplyAuthor)
+        .FmtFunc(_SC("AddField"), &DpEmbed::AddField)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("Reaction"),
+        Class< DpReaction, NoConstructor< DpReaction > >(vm, SqDppReaction::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppReaction::Fn)
+        // Member Properties
+        .Prop(_SC("Valid"), &DpReaction::IsValid)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("Attachment"),
+        Class< DpAttachment, NoConstructor< DpAttachment > >(vm, SqDppAttachment::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppAttachment::Fn)
+        // Member Properties
+        .Prop(_SC("Valid"), &DpAttachment::IsValid)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("Sticker"),
+        Class< DpSticker, NoConstructor< DpSticker > >(vm, SqDppSticker::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppSticker::Fn)
+        // Member Properties
+        .Prop(_SC("Valid"), &DpSticker::IsValid)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("StickerPack"),
+        Class< DpStickerPack, NoConstructor< DpStickerPack > >(vm, SqDppStickerPack::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppStickerPack::Fn)
+        // Member Properties
+        .Prop(_SC("Valid"), &DpStickerPack::IsValid)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("Message"),
+        Class< DpMessage, NoConstructor< DpMessage > >(vm, SqDppMessage::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppMessage::Fn)
+        // Member Properties
+        .Prop(_SC("Valid"), &DpMessage::IsValid)
+    );
+}
+
+} // Namespace:: SqMod

module/Library/DPP/Other.cpp

@@ -0,0 +1,141 @@
+// ------------------------------------------------------------------------------------------------
+#include "Library/DPP/Other.hpp"
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+// ------------------------------------------------------------------------------------------------
+SQMOD_DECL_TYPENAME(SqDppCachePolicy, _SC("SqDppCachePolicy"))
+SQMOD_DECL_TYPENAME(SqDppIconHash, _SC("SqDppIconHash"))
+SQMOD_DECL_TYPENAME(SqDppUptime, _SC("SqDppUptime"))
+SQMOD_DECL_TYPENAME(SqDppActivity, _SC("SqDppActivity"))
+SQMOD_DECL_TYPENAME(SqDppPresence, _SC("SqDppPresence"))
+SQMOD_DECL_TYPENAME(SqDppVoiceState, _SC("SqDppVoiceState"))
+
+// ------------------------------------------------------------------------------------------------
+void Register_DPP_Other(HSQUIRRELVM vm, Table & ns)
+{
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("Uptime"),
+        Class< dpp::utility::uptime >(vm, SqDppUptime::Str)
+        // Constructors
+        .Ctor()
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppUptime::Fn)
+        .Func(_SC("_tostring"), &dpp::utility::uptime::to_string)
+        // Member Variables
+        .Var(_SC("Days"), &dpp::utility::uptime::days)
+        .Var(_SC("Hours"), &dpp::utility::uptime::hours)
+        .Var(_SC("Minutes"), &dpp::utility::uptime::mins)
+        .Var(_SC("Seconds"), &dpp::utility::uptime::secs)
+        // Member Methods
+        .Func(_SC("ToSeconds"), &dpp::utility::uptime::to_secs)
+        .Func(_SC("ToMilliseconds"), &dpp::utility::uptime::to_msecs)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("IconHash"),
+        Class< dpp::utility::iconhash >(vm, SqDppIconHash::Str)
+        // Constructors
+        .Ctor()
+        .Ctor< const std::string & >()
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppIconHash::Fn)
+        .Func(_SC("_tostring"), &dpp::utility::iconhash::to_string)
+        // Member Variables
+        .Var(_SC("High"), &dpp::utility::iconhash::first)
+        .Var(_SC("Low"), &dpp::utility::iconhash::second)
+        // Member Methods
+        .Func(_SC("Set"), &dpp::utility::iconhash::set)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("CachePolicy"),
+        Class< DpCachePolicy >(vm, SqDppCachePolicy::Str)
+        // Constructors
+        .Ctor()
+        .Ctor< SQInteger >()
+        .Ctor< SQInteger, SQInteger >()
+        .Ctor< SQInteger, SQInteger, SQInteger >()
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppCachePolicy::Fn)
+        // Member Variables
+        .Var(_SC("UserPolicy"), &DpCachePolicy::mUserPolicy)
+        .Var(_SC("EmojiPolicy"), &DpCachePolicy::mEmojiPolicy)
+        .Var(_SC("RolePolicy"), &DpCachePolicy::mRolePolicy)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("Activity"),
+        Class< DpActivity, NoCopy< DpActivity > >(vm, SqDppActivity::Str)
+        // Constructors
+        .Ctor()
+        .Ctor< SQInteger, StackStrF &, StackStrF &, StackStrF & >()
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppActivity::Fn)
+        // Member Properties
+        .Prop(_SC("Name"), &DpActivity::GetName, &DpActivity::SetName)
+        .Prop(_SC("State"), &DpActivity::GetState, &DpActivity::SetState)
+        .Prop(_SC("URL"), &DpActivity::GetURL, &DpActivity::SetURL)
+        .Prop(_SC("Type"), &DpActivity::GetType, &DpActivity::SetType)
+        .Prop(_SC("CreatedAt"), &DpActivity::GetCreatedAt, &DpActivity::SetCreatedAt)
+        .Prop(_SC("Start"), &DpActivity::GetStart, &DpActivity::SetStart)
+        .Prop(_SC("End"), &DpActivity::GetEnd, &DpActivity::SetEnd)
+        // Member Methods
+        .Func(_SC("SetName"), &DpActivity::ApplyName)
+        .Func(_SC("SetState"), &DpActivity::ApplyState)
+        .Func(_SC("SetURL"), &DpActivity::ApplyURL)
+        .Func(_SC("SetType"), &DpActivity::ApplyType)
+        .Func(_SC("SetCreatedAt"), &DpActivity::ApplyCreatedAt)
+        .Func(_SC("SetStart"), &DpActivity::ApplyStart)
+        .Func(_SC("SetEnd"), &DpActivity::ApplyEnd)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("Presence"),
+        Class< DpPresence, NoCopy< DpPresence > >(vm, SqDppPresence::Str)
+        // Constructors
+        .Ctor()
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppPresence::Fn)
+        // Member Properties
+        .Prop(_SC("Valid"), &DpPresence::IsValid)
+        .Prop(_SC("UserID"), &DpPresence::GetUserID, &DpPresence::SetUserID)
+        .Prop(_SC("GuildID"), &DpPresence::GetGuildID, &DpPresence::SetGuildID)
+        .Prop(_SC("Flags"), &DpPresence::GetFlags, &DpPresence::SetFlags)
+        .Prop(_SC("ActivityCount"), &DpPresence::ActivityCount)
+        .Prop(_SC("DesktopStatus"), &DpPresence::GetDesktopStatus)
+        .Prop(_SC("WebStatus"), &DpPresence::GetWebStatus)
+        .Prop(_SC("MobileStatus"), &DpPresence::GetMobileStatus)
+        .Prop(_SC("Status"), &DpPresence::GetStatus)
+        // Member Methods
+        .Func(_SC("SetUserID"), &DpPresence::ApplyUserID)
+        .Func(_SC("SetGuildID"), &DpPresence::ApplyGuildID)
+        .Func(_SC("SetFlags"), &DpPresence::ApplyFlags)
+        .Func(_SC("AddActivity"), &DpPresence::AddActivity)
+        .Func(_SC("EachActivity"), &DpPresence::EachActivity)
+        .Func(_SC("ClearActivities"), &DpPresence::ClearActivities)
+        .Func(_SC("FilterActivities"), &DpPresence::FilterActivities)
+        .Func(_SC("BuildJSON"), &DpPresence::BuildJSON)
+    );
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("VoiceState"),
+        Class< DpVoiceState, NoConstructor< DpVoiceState > >(vm, SqDppVoiceState::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppVoiceState::Fn)
+        .Func(_SC("_tojson"), &DpVoiceState::BuildJSON)
+        // Member Properties
+        .Prop(_SC("Valid"), &DpVoiceState::IsValid)
+        .Prop(_SC("JSON"), &DpVoiceState::BuildJSON)
+        .Prop(_SC("GuildID"), &DpVoiceState::GetGuildID)
+        .Prop(_SC("ChannelID"), &DpVoiceState::GetChannelID)
+        .Prop(_SC("UserID"), &DpVoiceState::GetUserID)
+        .Prop(_SC("SessionID"), &DpVoiceState::GetSessionID)
+        .Prop(_SC("Flags"), &DpVoiceState::GetFlags, &DpVoiceState::SetFlags)
+        .Prop(_SC("IsDeaf"), &DpVoiceState::IsDeaf)
+        .Prop(_SC("IsMute"), &DpVoiceState::IsMute)
+        .Prop(_SC("IsSelfMute"), &DpVoiceState::IsSelfMute)
+        .Prop(_SC("IsSelfDeaf"), &DpVoiceState::IsSelfDeaf)
+        .Prop(_SC("SelfStream"), &DpVoiceState::SelfStream)
+        .Prop(_SC("SelfVideo"), &DpVoiceState::SelfVideo)
+        .Prop(_SC("IsSuppressed"), &DpVoiceState::IsSuppressed)
+    );
+}
+
+} // Namespace:: SqMod

module/Library/DPP/Other.hpp

@@ -0,0 +1,607 @@
+#pragma once
+
+// ------------------------------------------------------------------------------------------------
+#include "Core/Utility.hpp"
+
+// ------------------------------------------------------------------------------------------------
+#include <chrono>
+
+// ------------------------------------------------------------------------------------------------
+#include <dpp/dpp.h>
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+/* ------------------------------------------------------------------------------------------------
+ * Represents the caching policy of the cluster.
+*/
+struct DpCachePolicy
+{
+    SQInteger mUserPolicy{dpp::cp_aggressive};
+    SQInteger mEmojiPolicy{dpp::cp_aggressive};
+    SQInteger mRolePolicy{dpp::cp_aggressive};
+    /* --------------------------------------------------------------------------------------------
+     * Default constructor.
+    */
+    DpCachePolicy() noexcept = default;
+    /* --------------------------------------------------------------------------------------------
+     * Explicit constructor.
+    */
+    explicit DpCachePolicy(SQInteger user) noexcept
+        : mUserPolicy(user), mEmojiPolicy(dpp::cp_aggressive), mRolePolicy(dpp::cp_aggressive)
+    { }
+    /* --------------------------------------------------------------------------------------------
+     * Explicit constructor.
+    */
+    DpCachePolicy(SQInteger user, SQInteger emoji) noexcept
+        : mUserPolicy(user), mEmojiPolicy(emoji), mRolePolicy(dpp::cp_aggressive)
+    { }
+    /* --------------------------------------------------------------------------------------------
+     * Explicit constructor.
+    */
+    DpCachePolicy(SQInteger user, SQInteger emoji, SQInteger role) noexcept
+        : mUserPolicy(user), mEmojiPolicy(emoji), mRolePolicy(role)
+    { }
+    /* --------------------------------------------------------------------------------------------
+     * Copy constructor.
+    */
+    DpCachePolicy(const DpCachePolicy &) noexcept = default;
+    /* --------------------------------------------------------------------------------------------
+     * Convert to native cache policy type.
+    */
+    SQMOD_NODISCARD dpp::cache_policy_t ToNative() const noexcept
+    {
+        return dpp::cache_policy_t{
+            static_cast< dpp::cache_policy_setting_t >(mUserPolicy),
+            static_cast< dpp::cache_policy_setting_t >(mEmojiPolicy),
+            static_cast< dpp::cache_policy_setting_t >(mRolePolicy)
+        };
+    }
+};
+
+/* ------------------------------------------------------------------------------------------------
+ * An activity is a representation of what a user is doing. It might be a game, or a website, or a movie. Whatever.
+*/
+struct DpActivity
+{
+    using Ptr = std::unique_ptr< dpp::activity >;
+    /* --------------------------------------------------------------------------------------------
+     * Referenced activity instance.
+    */
+    Ptr mPtr{nullptr};
+    /* --------------------------------------------------------------------------------------------
+     * Whether the referenced pointer is owned.
+    */
+    bool mOwned{false};
+    /* --------------------------------------------------------------------------------------------
+     * Default constructor.
+    */
+    DpActivity() noexcept
+        : DpActivity(new Ptr::element_type(), true)
+    { }
+    /* --------------------------------------------------------------------------------------------
+     * Explicit constructor.
+    */
+    explicit DpActivity(Ptr::pointer ptr, bool owned = false) noexcept
+        : mPtr(ptr), mOwned(owned)
+    { }
+    /* --------------------------------------------------------------------------------------------
+     * Copy constructor.
+    */
+    explicit DpActivity(const Ptr::element_type & o) noexcept
+        : DpActivity(new Ptr::element_type(o), true)
+    { }
+    /* --------------------------------------------------------------------------------------------
+     * Move constructor.
+    */
+    explicit DpActivity(Ptr::element_type && o) noexcept
+        : DpActivity(new Ptr::element_type(std::forward< Ptr::element_type >(o)), true)
+    { }
+    /* --------------------------------------------------------------------------------------------
+     * Explicit constructor.
+    */
+    DpActivity(SQInteger type, StackStrF & name, StackStrF & state, StackStrF & url)
+        : DpActivity(new Ptr::element_type(static_cast< dpp::activity_type >(type), name.ToStr(), state.ToStr(), url.ToStr()), true)
+    { }
+    /* --------------------------------------------------------------------------------------------
+     * Copy constructor (disabled).
+    */
+    DpActivity(const DpActivity & o) = delete;
+    /* --------------------------------------------------------------------------------------------
+     * Move constructor.
+    */
+    DpActivity(DpActivity && o) noexcept = default;
+    /* --------------------------------------------------------------------------------------------
+     * Destructor.
+    */
+    ~DpActivity() noexcept { Cleanup(); }
+    /* --------------------------------------------------------------------------------------------
+     * Copy assignment operator (disabled).
+    */
+    DpActivity & operator = (const DpActivity & o) = delete;
+    /* --------------------------------------------------------------------------------------------
+     * Move assignment operator.
+    */
+    DpActivity & operator = (DpActivity && o) noexcept
+    {
+        if (this != &o) {
+            Cleanup();
+            // Transfer members values
+            mPtr = std::move(o.mPtr);
+            mOwned = o.mOwned;
+        }
+        return *this;
+    }
+    /* --------------------------------------------------------------------------------------------
+     * Release any referenced resources and default to an empty/invalid state.
+    */
+    void Cleanup()
+    {
+        // Do we own this to try delete it?
+        if (!mOwned && mPtr) {
+            // Not our job, simply forget about it
+            [[maybe_unused]] auto p = mPtr.release();
+        } else mPtr.reset(); // We own this so delete the instance
+    }
+    /* --------------------------------------------------------------------------------------------
+     * Validate the managed handle.
+    */
+    void Validate() const { if (!mPtr) STHROWF("Invalid discord activity handle"); }
+    /* --------------------------------------------------------------------------------------------
+     * Validate the managed handle and retrieve a const reference to it.
+    */
+    SQMOD_NODISCARD Ptr::element_type & Valid() const { Validate(); return *mPtr; }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether a valid instance is managed.
+    */
+    SQMOD_NODISCARD bool IsValid() const { return static_cast< bool >(mPtr); }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the name of the activity.
+    */
+    SQMOD_NODISCARD const std::string & GetName() const { return Valid().name; }
+    /* --------------------------------------------------------------------------------------------
+     * Modify the name of the activity.
+    */
+    void SetName(StackStrF & name) const { Valid().name = name.ToStr(); }
+    /* --------------------------------------------------------------------------------------------
+     * Modify the name of the activity.
+    */
+    DpActivity & ApplyName(StackStrF & name) { SetName(name); return *this; }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the state of the activity.
+    */
+    SQMOD_NODISCARD const std::string & GetState() const { return Valid().state; }
+    /* --------------------------------------------------------------------------------------------
+     * Modify the state of the activity.
+    */
+    void SetState(StackStrF & state) const { Valid().state = state.ToStr(); }
+    /* --------------------------------------------------------------------------------------------
+     * Modify the state of the activity.
+    */
+    DpActivity & ApplyState(StackStrF & state) { SetState(state); return *this; }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the url of the activity.
+    */
+    SQMOD_NODISCARD const std::string & GetURL() const { return Valid().url; }
+    /* --------------------------------------------------------------------------------------------
+     * Modify the url of the activity.
+    */
+    void SetURL(StackStrF & url) const { Valid().url = url.ToStr(); }
+    /* --------------------------------------------------------------------------------------------
+     * Modify the url of the activity.
+    */
+    DpActivity & ApplyURL(StackStrF & url) { SetURL(url); return *this; }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the type of the activity.
+    */
+    SQMOD_NODISCARD SQInteger GetType() const { return static_cast< SQInteger >(Valid().type); }
+    /* --------------------------------------------------------------------------------------------
+     * Modify the type of the activity.
+    */
+    void SetType(SQInteger s) const { Valid().type = static_cast< dpp::activity_type >(s); }
+    /* --------------------------------------------------------------------------------------------
+     * Modify the type of the activity.
+    */
+    DpActivity & ApplyType(SQInteger s) { SetType(s); return *this; }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve when the activity was created.
+    */
+    SQMOD_NODISCARD SQInteger GetCreatedAt() const
+    {
+        return static_cast< SQInteger >(std::chrono::duration_cast< std::chrono::seconds >(std::chrono::system_clock::from_time_t(Valid().created_at).time_since_epoch()).count());
+    }
+    /* --------------------------------------------------------------------------------------------
+     * Modify when the activity was created.
+    */
+    void SetCreatedAt(SQInteger s) const
+    {
+        Valid().created_at = std::chrono::system_clock::to_time_t(std::chrono::time_point< std::chrono::system_clock >{std::chrono::seconds{s}});
+    }
+    /* --------------------------------------------------------------------------------------------
+     * Modify when the activity was created.
+    */
+    DpActivity & ApplyCreatedAt(SQInteger s) { SetCreatedAt(s); return *this; }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve when the activity was started.
+    */
+    SQMOD_NODISCARD SQInteger GetStart() const
+    {
+        return static_cast< SQInteger >(std::chrono::duration_cast< std::chrono::seconds >(std::chrono::system_clock::from_time_t(Valid().start).time_since_epoch()).count());
+    }
+    /* --------------------------------------------------------------------------------------------
+     * Modify when the activity was started.
+    */
+    void SetStart(SQInteger s) const
+    {
+        Valid().start = std::chrono::system_clock::to_time_t(std::chrono::time_point< std::chrono::system_clock >{std::chrono::seconds{s}});
+    }
+    /* --------------------------------------------------------------------------------------------
+     * Modify when the activity was started.
+    */
+    DpActivity & ApplyStart(SQInteger s) { SetStart(s); return *this; }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve when the activity was stopped.
+    */
+    SQMOD_NODISCARD SQInteger GetEnd() const
+    {
+        return static_cast< SQInteger >(std::chrono::duration_cast< std::chrono::seconds >(std::chrono::system_clock::from_time_t(Valid().end).time_since_epoch()).count());
+    }
+    /* --------------------------------------------------------------------------------------------
+     * Modify when the activity was stopped.
+    */
+    void SetEnd(SQInteger s) const
+    {
+        Valid().end = std::chrono::system_clock::to_time_t(std::chrono::time_point< std::chrono::system_clock >{std::chrono::seconds{s}});
+    }
+    /* --------------------------------------------------------------------------------------------
+     * Modify when the activity was stopped.
+    */
+    DpActivity & ApplyEnd(SQInteger s) { SetEnd(s); return *this; }
+};
+
+/* ------------------------------------------------------------------------------------------------
+ * Represents user presence, e.g. what game they are playing and if they are online.
+*/
+struct DpPresence
+{
+    using Ptr = std::unique_ptr< dpp::presence >;
+    /* --------------------------------------------------------------------------------------------
+     * Referenced presence instance.
+    */
+    Ptr mPtr{nullptr};
+    /* --------------------------------------------------------------------------------------------
+     * Whether the referenced pointer is owned.
+    */
+    bool mOwned{false};
+    /* --------------------------------------------------------------------------------------------
+     * Default constructor.
+    */
+    DpPresence() noexcept
+        : DpPresence(new Ptr::element_type(), true)
+    { }
+    /* --------------------------------------------------------------------------------------------
+     * Explicit constructor.
+    */
+    explicit DpPresence(Ptr::pointer ptr, bool owned = false) noexcept
+        : mPtr(ptr), mOwned(owned)
+    { }
+    /* --------------------------------------------------------------------------------------------
+     * Copy constructor.
+    */
+    explicit DpPresence(const Ptr::element_type & o) noexcept
+        : DpPresence(new Ptr::element_type(o), true)
+    { }
+    /* --------------------------------------------------------------------------------------------
+     * Move constructor.
+    */
+    explicit DpPresence(Ptr::element_type && o) noexcept
+        : DpPresence(new Ptr::element_type(std::forward< Ptr::element_type >(o)), true)
+    { }
+    /* --------------------------------------------------------------------------------------------
+     * Copy constructor (disabled).
+    */
+    DpPresence(const DpPresence & o) = delete;
+    /* --------------------------------------------------------------------------------------------
+     * Move constructor.
+    */
+    DpPresence(DpPresence && o) noexcept = default;
+    /* --------------------------------------------------------------------------------------------
+     * Destructor.
+    */
+    ~DpPresence() noexcept { Cleanup(); }
+    /* --------------------------------------------------------------------------------------------
+     * Copy assignment operator (disabled).
+    */
+    DpPresence & operator = (const DpPresence & o) = delete;
+    /* --------------------------------------------------------------------------------------------
+     * Move assignment operator.
+    */
+    DpPresence & operator = (DpPresence && o) noexcept
+    {
+        if (this != &o) {
+            Cleanup();
+            // Transfer members values
+            mPtr = std::move(o.mPtr);
+            mOwned = o.mOwned;
+        }
+        return *this;
+    }
+    /* --------------------------------------------------------------------------------------------
+     * Release any referenced resources and default to an empty/invalid state.
+    */
+    void Cleanup()
+    {
+        // Do we own this to try delete it?
+        if (!mOwned && mPtr) {
+            // Not our job, simply forget about it
+            [[maybe_unused]] auto p = mPtr.release();
+        } else mPtr.reset(); // We own this so delete the instance
+    }
+    /* --------------------------------------------------------------------------------------------
+     * Validate the managed handle.
+    */
+    void Validate() const { if (!mPtr) STHROWF("Invalid discord presence handle"); }
+    /* --------------------------------------------------------------------------------------------
+     * Validate the managed handle and retrieve a const reference to it.
+    */
+    SQMOD_NODISCARD Ptr::element_type & Valid() const { Validate(); return *mPtr; }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether a valid instance is managed.
+    */
+    SQMOD_NODISCARD bool IsValid() const { return static_cast< bool >(mPtr); }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the user that the presence applies to.
+    */
+    SQMOD_NODISCARD dpp::snowflake GetUserID() const { return Valid().user_id; }
+    /* --------------------------------------------------------------------------------------------
+     * Modify the user that the presence applies to.
+    */
+    void SetUserID(dpp::snowflake id) const { Valid().user_id = id; }
+    /* --------------------------------------------------------------------------------------------
+     * Modify the user that the presence applies to.
+    */
+    DpPresence & ApplyUserID(dpp::snowflake id) { SetUserID(id); return *this; }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the guild that the presence applies to.
+    */
+    SQMOD_NODISCARD dpp::snowflake GetGuildID() const { return Valid().guild_id; }
+    /* --------------------------------------------------------------------------------------------
+     * Modify the guild that the presence applies to.
+    */
+    void SetGuildID(dpp::snowflake id) const { Valid().guild_id = id; }
+    /* --------------------------------------------------------------------------------------------
+     * Modify the guild that the presence applies to.
+    */
+    DpPresence & ApplyGuildID(dpp::snowflake id) { SetGuildID(id); return *this; }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the presence bit-mask.
+    */
+    SQMOD_NODISCARD SQInteger GetFlags() const { return static_cast< SQInteger >(Valid().flags); }
+    /* --------------------------------------------------------------------------------------------
+     * Modify the presence bit-mask.
+    */
+    void SetFlags(SQInteger f) const { Valid().flags = static_cast< uint8_t >(f); }
+    /* --------------------------------------------------------------------------------------------
+     * Modify the presence bit-mask.
+    */
+    DpPresence & ApplyFlags(SQInteger f) { SetFlags(f); return *this; }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the number of activities.
+    */
+    SQMOD_NODISCARD SQInteger ActivityCount() const { return static_cast< SQInteger >(Valid().activities.size()); }
+    /* --------------------------------------------------------------------------------------------
+     * Add a new activity.
+    */
+    DpPresence & AddActivity(const DpActivity & a) { Valid().activities.push_back(a.Valid()); return *this; }
+    /* --------------------------------------------------------------------------------------------
+     * Iterate all activities.
+    */
+    DpPresence & EachActivity(Function & fn)
+    {
+        for (const auto & a : Valid().activities)
+        {
+            fn.Execute(a);
+        }
+        return *this;
+    }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the number of activities.
+    */
+    DpPresence & ClearActivities(const DpActivity & a) { Valid().activities.clear(); return *this; }
+    /* --------------------------------------------------------------------------------------------
+     * Filter activities.
+    */
+    DpPresence & FilterActivities(Function & fn)
+    {
+        std::vector< dpp::activity > list;
+        // Reserve memory in advance
+        list.reserve(Valid().activities.size());
+        // Process each activity individually
+        for (const auto & a : Valid().activities)
+        {
+            auto ret = fn.Eval(a);
+            // (null || true) == keep & false == skip
+            if (!ret.IsNull() || !ret.template Cast< bool >())
+            {
+                list.push_back(a); // Keep this activity
+            }
+        }
+        // Use filtered activities
+        Valid().activities.swap(list);
+        // Allow chaining
+        return *this;
+    }
+    /* --------------------------------------------------------------------------------------------
+     * Build JSON string from this object.
+    */
+    SQMOD_NODISCARD std::string BuildJSON() const { return Valid().build_json(); }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the users status on desktop.
+    */
+    SQMOD_NODISCARD SQInteger GetDesktopStatus() const { return static_cast< SQInteger >(Valid().desktop_status()); }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the user's status on web.
+    */
+    SQMOD_NODISCARD SQInteger GetWebStatus() const { return static_cast< SQInteger >(Valid().web_status()); }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the user's status on mobile.
+    */
+    SQMOD_NODISCARD SQInteger GetMobileStatus() const { return static_cast< SQInteger >(Valid().mobile_status()); }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the user's status as shown to other users.
+    */
+    SQMOD_NODISCARD SQInteger GetStatus() const { return static_cast< SQInteger >(Valid().status()); }
+};
+
+/* ------------------------------------------------------------------------------------------------
+ * Represents the voice state of a user on a guild.
+ * These are stored in the DpGuild object, and accessible there, or via DpChannel::GetVoiceMembers.
+*/
+struct DpVoiceState
+{
+    using Ptr = std::unique_ptr< dpp::voicestate >;
+    /* --------------------------------------------------------------------------------------------
+     * Referenced voice state instance.
+    */
+    Ptr mPtr{nullptr};
+    /* --------------------------------------------------------------------------------------------
+     * Whether the referenced pointer is owned.
+    */
+    bool mOwned{false};
+    /* --------------------------------------------------------------------------------------------
+     * Default constructor.
+    */
+    DpVoiceState() noexcept = default;
+    /* --------------------------------------------------------------------------------------------
+     * Explicit constructor.
+    */
+    explicit DpVoiceState(Ptr::pointer ptr, bool owned = false) noexcept
+        : mPtr(ptr), mOwned(owned)
+    { }
+    /* --------------------------------------------------------------------------------------------
+     * Explicit constructor.
+    */
+    explicit DpVoiceState(const Ptr::element_type & o) noexcept
+        : DpVoiceState(new Ptr::element_type(o), true)
+    { }
+    /* --------------------------------------------------------------------------------------------
+     * Move constructor.
+    */
+    explicit DpVoiceState(Ptr::element_type && o) noexcept
+        : DpVoiceState(new Ptr::element_type(std::forward< Ptr::element_type >(o)), true)
+    { }
+    /* --------------------------------------------------------------------------------------------
+     * Copy constructor (disabled).
+    */
+    DpVoiceState(const DpVoiceState & o) = delete;
+    /* --------------------------------------------------------------------------------------------
+     * Move constructor.
+    */
+    DpVoiceState(DpVoiceState && o) noexcept = default;
+    /* --------------------------------------------------------------------------------------------
+     * Destructor.
+    */
+    ~DpVoiceState() noexcept { Cleanup(); }
+    /* --------------------------------------------------------------------------------------------
+     * Copy assignment operator (disabled).
+    */
+    DpVoiceState & operator = (const DpVoiceState & o) = delete;
+    /* --------------------------------------------------------------------------------------------
+     * Move assignment operator.
+    */
+    DpVoiceState & operator = (DpVoiceState && o) noexcept
+    {
+        if (this != &o) {
+            Cleanup();
+            // Transfer members values
+            mPtr = std::move(o.mPtr);
+            mOwned = o.mOwned;
+        }
+        return *this;
+    }
+    /* --------------------------------------------------------------------------------------------
+     * Release any referenced resources and default to an empty/invalid state.
+    */
+    void Cleanup()
+    {
+        // Do we own this to try delete it?
+        if (!mOwned && mPtr) {
+            // Not our job, simply forget about it
+            [[maybe_unused]] auto p = mPtr.release();
+        } else mPtr.reset(); // We own this so delete the instance
+    }
+    /* --------------------------------------------------------------------------------------------
+     * Validate the managed handle.
+    */
+    void Validate() const { if (!mPtr) STHROWF("Invalid discord voice state handle"); }
+    /* --------------------------------------------------------------------------------------------
+     * Validate the managed handle and retrieve a const reference to it.
+    */
+    SQMOD_NODISCARD Ptr::element_type & Valid() const { Validate(); return *mPtr; }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether a valid instance is managed.
+    */
+    SQMOD_NODISCARD bool IsValid() const { return static_cast< bool >(mPtr); }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the guild id this voice state is for (optional).
+    */
+    SQMOD_NODISCARD dpp::snowflake GetGuildID() const { return Valid().guild_id; }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the guild id this voice state is for (optional).
+    */
+    SQMOD_NODISCARD dpp::snowflake GetChannelID() const { return Valid().channel_id; }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the guild id this voice state is for (optional).
+    */
+    SQMOD_NODISCARD dpp::snowflake GetUserID() const { return Valid().user_id; }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the guild id this voice state is for (optional).
+    */
+    SQMOD_NODISCARD const std::string & GetSessionID() const { return Valid().session_id; }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the guild id this voice state is for (optional).
+    */
+    SQMOD_NODISCARD SQInteger GetFlags() const { return Valid().flags; }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the guild id this voice state is for (optional).
+    */
+    void SetFlags(SQInteger flags) const { Valid().flags = flags; }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the guild id this voice state is for (optional).
+    */
+    SQMOD_NODISCARD std::string BuildJSON() const { return Valid().build_json(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check if user is deafened.
+    */
+    SQMOD_NODISCARD bool IsDeaf() const { return Valid().is_deaf(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check if user is muted.
+    */
+    SQMOD_NODISCARD bool IsMute() const { return Valid().is_mute(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check if user muted themselves.
+    */
+    SQMOD_NODISCARD bool IsSelfMute() const { return Valid().is_self_mute(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check if user deafened themselves.
+    */
+    SQMOD_NODISCARD bool IsSelfDeaf() const { return Valid().is_self_deaf(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check if user is streamig.
+    */
+    SQMOD_NODISCARD bool SelfStream() const { return Valid().self_stream(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check if user is in video.
+    */
+    SQMOD_NODISCARD bool SelfVideo() const { return Valid().self_video(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check if user is surpressed.
+    */
+    SQMOD_NODISCARD bool IsSuppressed() const { return Valid().is_suppressed(); }
+};
+
+/* ------------------------------------------------------------------------------------------------
+ * 
+*/
+
+} // Namespace:: SqMod

module/Library/DPP/Role.cpp

@@ -0,0 +1,74 @@
+// ------------------------------------------------------------------------------------------------
+#include "Library/DPP/Role.hpp"
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+// ------------------------------------------------------------------------------------------------
+SQMOD_DECL_TYPENAME(SqDppRole, _SC("SqDppRole"))
+
+// ------------------------------------------------------------------------------------------------
+void Register_DPP_Role(HSQUIRRELVM vm, Table & ns)
+{
+    ns.Bind(_SC("Role"),
+        Class< DpRole, NoConstructor< DpRole > >(vm, SqDppRole::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppRole::Fn)
+        .Func(_SC("_tojson"), &DpRole::BuildJSON)
+        // Member Properties
+        .Prop(_SC("Valid"), &DpRole::IsValid)
+        .Prop(_SC("JSON"), &DpRole::BuildJSON)
+        .Prop(_SC("Name"), &DpRole::GetName)
+        .Prop(_SC("GuildID"), &DpRole::GetGuildID)
+        .Prop(_SC("Color"), &DpRole::GetColour)
+        .Prop(_SC("Colour"), &DpRole::GetColour)
+        .Prop(_SC("Position"), &DpRole::GetPosition)
+        .Prop(_SC("Permissions"), &DpRole::GetPermissions)
+        .Prop(_SC("Flags"), &DpRole::GetFlags)
+        .Prop(_SC("IntegrationID"), &DpRole::GetIntegrationID)
+        .Prop(_SC("BotID"), &DpRole::GetBotID)
+        .Prop(_SC("IsHoisted"), &DpRole::IsHoisted)
+        .Prop(_SC("IsMentionable"), &DpRole::IsMentionable)
+        .Prop(_SC("IsManaged"), &DpRole::IsManaged)
+        .Prop(_SC("CanCreateInstantInvite"), &DpRole::CanCreateInstantInvite)
+        .Prop(_SC("CanKickMembers"), &DpRole::CanKickMembers)
+        .Prop(_SC("CanBanMembers"), &DpRole::CanBanMembers)
+        .Prop(_SC("IsAdministrator"), &DpRole::IsAdministrator)
+        .Prop(_SC("CanManageChannels"), &DpRole::CanManageChannels)
+        .Prop(_SC("CanManageGuild"), &DpRole::CanManageGuild)
+        .Prop(_SC("CanAddReactions"), &DpRole::CanAddReactions)
+        .Prop(_SC("CanViewAuditLog"), &DpRole::CanViewAuditLog)
+        .Prop(_SC("IsPrioritySpeaker"), &DpRole::IsPrioritySpeaker)
+        .Prop(_SC("CanStream"), &DpRole::CanStream)
+        .Prop(_SC("CanViewChannel"), &DpRole::CanViewChannel)
+        .Prop(_SC("CanSendMessages"), &DpRole::CanSendMessages)
+        .Prop(_SC("CanSendTtsMessages"), &DpRole::CanSendTtsMessages)
+        .Prop(_SC("CanManageMessages"), &DpRole::CanManageMessages)
+        .Prop(_SC("CanEmbedLinks"), &DpRole::CanEmbedLinks)
+        .Prop(_SC("CanAttachFiles"), &DpRole::CanAttachFiles)
+        .Prop(_SC("CanReadMessageHistory"), &DpRole::CanReadMessageHistory)
+        .Prop(_SC("CanMentionEveryone"), &DpRole::CanMentionEveryone)
+        .Prop(_SC("CanUseExternalEmojis"), &DpRole::CanUseExternalEmojis)
+        .Prop(_SC("CanViewGuildInsights"), &DpRole::CanViewGuildInsights)
+        .Prop(_SC("CanConnect"), &DpRole::CanConnect)
+        .Prop(_SC("CanSpeak"), &DpRole::CanSpeak)
+        .Prop(_SC("CanMuteMembers"), &DpRole::CanMuteMembers)
+        .Prop(_SC("CanDeafenMembers"), &DpRole::CanDeafenMembers)
+        .Prop(_SC("CanMoveMembers"), &DpRole::CanMoveMembers)
+        .Prop(_SC("CanUseVAT"), &DpRole::CanUseVAT)
+        .Prop(_SC("CanChangeNickname"), &DpRole::CanChangeNickname)
+        .Prop(_SC("CanManageNicknames"), &DpRole::CanManageNicknames)
+        .Prop(_SC("CanManageRoles"), &DpRole::CanManageRoles)
+        .Prop(_SC("CanManageWebhooks"), &DpRole::CanManageWebhooks)
+        .Prop(_SC("CanManageEmojis"), &DpRole::CanManageEmojis)
+        .Prop(_SC("CanUseSlashCommands"), &DpRole::CanUseSlashCommands)
+        .Prop(_SC("HasRequestToSpeak"), &DpRole::HasRequestToSpeak)
+        .Prop(_SC("CanManageThreads"), &DpRole::CanManageThreads)
+        .Prop(_SC("HasUsePublicThreads"), &DpRole::HasUsePublicThreads)
+        .Prop(_SC("HasUsePrivateThreads"), &DpRole::HasUsePrivateThreads)
+        // Member Methods
+        .Func(_SC("BuildJSON"), &DpRole::BuildJSON_)
+    );
+}
+
+} // Namespace:: SqMod

module/Library/DPP/Role.hpp

@@ -0,0 +1,301 @@
+#pragma once
+
+// ------------------------------------------------------------------------------------------------
+#include "Core/Utility.hpp"
+
+// ------------------------------------------------------------------------------------------------
+#include <chrono>
+
+// ------------------------------------------------------------------------------------------------
+#include <dpp/dpp.h>
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+/* ------------------------------------------------------------------------------------------------
+ * Represents a role within a DpGuild.
+*/
+struct DpRole
+{
+    using Ptr = std::unique_ptr< dpp::role >;
+    /* --------------------------------------------------------------------------------------------
+     * Referenced role instance.
+    */
+    Ptr mPtr{nullptr};
+    /* --------------------------------------------------------------------------------------------
+     * Whether the referenced pointer is owned.
+    */
+    bool mOwned{false};
+    /* --------------------------------------------------------------------------------------------
+     * Default constructor.
+    */
+    DpRole() noexcept = default;
+    /* --------------------------------------------------------------------------------------------
+     * Explicit constructor.
+    */
+    explicit DpRole(Ptr::pointer ptr, bool owned = false) noexcept
+        : mPtr(ptr), mOwned(owned)
+    { }
+    /* --------------------------------------------------------------------------------------------
+     * Explicit constructor.
+    */
+    explicit DpRole(const Ptr::element_type & o) noexcept
+        : DpRole(new Ptr::element_type(o), true)
+    { }
+    /* --------------------------------------------------------------------------------------------
+     * Move constructor.
+    */
+    explicit DpRole(Ptr::element_type && o) noexcept
+        : DpRole(new Ptr::element_type(std::forward< Ptr::element_type >(o)), true)
+    { }
+    /* --------------------------------------------------------------------------------------------
+     * Copy constructor (disabled).
+    */
+    DpRole(const DpRole & o) = delete;
+    /* --------------------------------------------------------------------------------------------
+     * Move constructor.
+    */
+    DpRole(DpRole && o) noexcept = default;
+    /* --------------------------------------------------------------------------------------------
+     * Destructor.
+    */
+    ~DpRole() noexcept { Cleanup(); }
+    /* --------------------------------------------------------------------------------------------
+     * Copy assignment operator (disabled).
+    */
+    DpRole & operator = (const DpRole & o) = delete;
+    /* --------------------------------------------------------------------------------------------
+     * Move assignment operator.
+    */
+    DpRole & operator = (DpRole && o) noexcept
+    {
+        if (this != &o) {
+            Cleanup();
+            // Transfer members values
+            mPtr = std::move(o.mPtr);
+            mOwned = o.mOwned;
+        }
+        return *this;
+    }
+    /* --------------------------------------------------------------------------------------------
+     * Release any referenced resources and default to an empty/invalid state.
+    */
+    void Cleanup()
+    {
+        // Do we own this to try delete it?
+        if (!mOwned && mPtr) {
+            // Not our job, simply forget about it
+            [[maybe_unused]] auto p = mPtr.release();
+        } else mPtr.reset(); // We own this so delete the instance
+    }
+    /* --------------------------------------------------------------------------------------------
+     * Validate the managed handle.
+    */
+    void Validate() const { if (!mPtr) STHROWF("Invalid discord role handle"); }
+    /* --------------------------------------------------------------------------------------------
+     * Validate the managed handle and retrieve a const reference to it.
+    */
+    SQMOD_NODISCARD Ptr::element_type & Valid() const { Validate(); return *mPtr; }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether a valid instance is managed.
+    */
+    SQMOD_NODISCARD bool IsValid() const { return static_cast< bool >(mPtr); }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve role name.
+    */
+    SQMOD_NODISCARD const std::string & GetName() const { return Valid().name; }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the role guild id.
+    */
+    SQMOD_NODISCARD dpp::snowflake GetGuildID() const { return Valid().guild_id; }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the role colour.
+    */
+    SQMOD_NODISCARD SQInteger GetColour() const { return static_cast< SQInteger >(Valid().colour); }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the role position.
+    */
+    SQMOD_NODISCARD SQInteger GetPosition() const { return static_cast< SQInteger >(Valid().position); }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the role permissions bitmask values from SqDiscordRolePermissions.
+    */
+    SQMOD_NODISCARD SQInteger GetPermissions() const { return static_cast< SQInteger >(Valid().permissions); }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the role flags from SqDiscordRoleFlags.
+    */
+    SQMOD_NODISCARD SQInteger GetFlags() const { return static_cast< SQInteger >(Valid().flags); }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the role integration id if any (e.g. role is a bot's role created when it was invited).
+    */
+    SQMOD_NODISCARD dpp::snowflake GetIntegrationID() const { return Valid().integration_id; }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the role bot id if any (e.g. role is a bot's role created when it was invited).
+    */
+    SQMOD_NODISCARD dpp::snowflake GetBotID() const { return Valid().bot_id; }
+    /* --------------------------------------------------------------------------------------------
+     * Build a JSON string from this object.
+    */
+    SQMOD_NODISCARD std::string BuildJSON() const { return Valid().build_json(); }
+    /* --------------------------------------------------------------------------------------------
+     * Build a JSON string from this object. If [with_id] is True then ID is to be included in the JSON.
+    */
+    SQMOD_NODISCARD std::string BuildJSON_(bool with_id) const { return Valid().build_json(with_id); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the role is hoisted.
+    */
+    SQMOD_NODISCARD bool IsHoisted() const { return Valid().is_hoisted(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the role is mentionable.
+    */
+    SQMOD_NODISCARD bool IsMentionable() const { return Valid().is_mentionable(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the role is managed (belongs to a bot or application).
+    */
+    SQMOD_NODISCARD bool IsManaged() const { return Valid().is_managed(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the role has create instant invite permission.
+    */
+    SQMOD_NODISCARD bool CanCreateInstantInvite() const { return Valid().has_create_instant_invite(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the role has the kick members permission.
+    */
+    SQMOD_NODISCARD bool CanKickMembers() const { return Valid().has_kick_members(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the role has the ban members permission.
+    */
+    SQMOD_NODISCARD bool CanBanMembers() const { return Valid().has_ban_members(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the role has the administrator permission.
+    */
+    SQMOD_NODISCARD bool IsAdministrator() const { return Valid().has_administrator(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the role has the manage channels permission.
+    */
+    SQMOD_NODISCARD bool CanManageChannels() const { return Valid().has_manage_channels(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the role has the manage guild permission.
+    */
+    SQMOD_NODISCARD bool CanManageGuild() const { return Valid().has_manage_guild(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the role has the add reactions permission.
+    */
+    SQMOD_NODISCARD bool CanAddReactions() const { return Valid().has_add_reactions(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the role has the view audit log permission.
+    */
+    SQMOD_NODISCARD bool CanViewAuditLog() const { return Valid().has_view_audit_log(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the role has the priority speaker permission.
+    */
+    SQMOD_NODISCARD bool IsPrioritySpeaker() const { return Valid().has_priority_speaker(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the role has the stream permission.
+    */
+    SQMOD_NODISCARD bool CanStream() const { return Valid().has_stream(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the role has the view channel permission.
+    */
+    SQMOD_NODISCARD bool CanViewChannel() const { return Valid().has_view_channel(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the role has the send messages permission.
+    */
+    SQMOD_NODISCARD bool CanSendMessages() const { return Valid().has_send_messages(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the role has the send TTS messages permission.
+    */
+    SQMOD_NODISCARD bool CanSendTtsMessages() const { return Valid().has_send_tts_messages(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the role has the manage messages permission.
+    */
+    SQMOD_NODISCARD bool CanManageMessages() const { return Valid().has_manage_messages(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the role has the embed links permission.
+    */
+    SQMOD_NODISCARD bool CanEmbedLinks() const { return Valid().has_embed_links(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the role has the attach files permission.
+    */
+    SQMOD_NODISCARD bool CanAttachFiles() const { return Valid().has_attach_files(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the role has the read message history permission.
+    */
+    SQMOD_NODISCARD bool CanReadMessageHistory() const { return Valid().has_read_message_history(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the role has the mention \@everyone and \@here permission.
+    */
+    SQMOD_NODISCARD bool CanMentionEveryone() const { return Valid().has_mention_everyone(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the role has the use external emojis permission.
+    */
+    SQMOD_NODISCARD bool CanUseExternalEmojis() const { return Valid().has_use_external_emojis(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the role has the view guild insights permission.
+    */
+    SQMOD_NODISCARD bool CanViewGuildInsights() const { return Valid().has_view_guild_insights(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the role has the connect voice permission.
+    */
+    SQMOD_NODISCARD bool CanConnect() const { return Valid().has_connect(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the role has the speak permission.
+    */
+    SQMOD_NODISCARD bool CanSpeak() const { return Valid().has_speak(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the role has the mute members permission.
+    */
+    SQMOD_NODISCARD bool CanMuteMembers() const { return Valid().has_mute_members(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the role has the deafen members permission.
+    */
+    SQMOD_NODISCARD bool CanDeafenMembers() const { return Valid().has_deafen_members(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the role has the move members permission.
+    */
+    SQMOD_NODISCARD bool CanMoveMembers() const { return Valid().has_move_members(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the role has use voice activity detection permission.
+    */
+    SQMOD_NODISCARD bool CanUseVAT() const { return Valid().has_use_vad(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the role has the change nickname permission.
+    */
+    SQMOD_NODISCARD bool CanChangeNickname() const { return Valid().has_change_nickname(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the role has the manage nicknames permission.
+    */
+    SQMOD_NODISCARD bool CanManageNicknames() const { return Valid().has_manage_nicknames(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the role has the manage roles permission.
+    */
+    SQMOD_NODISCARD bool CanManageRoles() const { return Valid().has_manage_roles(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the role has the manage webhooks permission.
+    */
+    SQMOD_NODISCARD bool CanManageWebhooks() const { return Valid().has_manage_webhooks(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the role has the manage emojis permission.
+    */
+    SQMOD_NODISCARD bool CanManageEmojis() const { return Valid().has_manage_emojis(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the role has the use slash commands permission.
+    */
+    SQMOD_NODISCARD bool CanUseSlashCommands() const { return Valid().has_use_slash_commands(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the role has the request to speak permission.
+    */
+    SQMOD_NODISCARD bool HasRequestToSpeak() const { return Valid().has_request_to_speak(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the role has the manage threads permission.
+    */
+    SQMOD_NODISCARD bool CanManageThreads() const { return Valid().has_manage_threads(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the role has the use public threads permission.
+    */
+    SQMOD_NODISCARD bool HasUsePublicThreads() const { return Valid().has_use_public_threads(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the role has the use private threads permission.
+    */
+    SQMOD_NODISCARD bool HasUsePrivateThreads() const { return Valid().has_use_private_threads(); }
+};
+
+} // Namespace:: SqMod

module/Library/DPP/User.cpp

@@ -0,0 +1,48 @@
+// ------------------------------------------------------------------------------------------------
+#include "Library/DPP/User.hpp"
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+// ------------------------------------------------------------------------------------------------
+SQMOD_DECL_TYPENAME(SqDppUser, _SC("SqDppUser"))
+
+// ------------------------------------------------------------------------------------------------
+void Register_DPP_User(HSQUIRRELVM vm, Table & ns)
+{
+    ns.Bind(_SC("User"),
+        Class< DpUser, NoConstructor< DpUser > >(vm, SqDppUser::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqDppUser::Fn)
+        // Member Properties
+        .Prop(_SC("Valid"), &DpUser::IsValid)
+        .Prop(_SC("Username"), &DpUser::GetUsername)
+        .Prop(_SC("Discriminator"), &DpUser::GetDiscriminator)
+        .Prop(_SC("Avatar"), &DpUser::GetAvatar)
+        .Prop(_SC("Flags"), &DpUser::GetFlags)
+        .Prop(_SC("RefCount"), &DpUser::GetRefCount)
+        .Prop(_SC("AvatarURL"), &DpUser::GetAvatarURL)
+        .Prop(_SC("IsBot"), &DpUser::IsBot)
+        .Prop(_SC("IsSystem"), &DpUser::IsSystem)
+        .Prop(_SC("IsMfaEnabled"), &DpUser::IsMfaEnabled)
+        .Prop(_SC("IsVerified"), &DpUser::IsVerified)
+        .Prop(_SC("HasNitroFull"), &DpUser::HasNitroFull)
+        .Prop(_SC("HasNitroClassic"), &DpUser::HasNitroClassic)
+        .Prop(_SC("IsDiscordEmployee"), &DpUser::IsDiscordEmployee)
+        .Prop(_SC("IsPartneredOwner"), &DpUser::IsPartneredOwner)
+        .Prop(_SC("HasHypesquadEvents"), &DpUser::HasHypesquadEvents)
+        .Prop(_SC("IsBughunter1"), &DpUser::IsBughunter1)
+        .Prop(_SC("IsHouseBravery"), &DpUser::IsHouseBravery)
+        .Prop(_SC("IsHouseBrilliance"), &DpUser::IsHouseBrilliance)
+        .Prop(_SC("IsHouseBalanace"), &DpUser::IsHouseBalanace)
+        .Prop(_SC("IsEarlySupporter"), &DpUser::IsEarlySupporter)
+        .Prop(_SC("IsTeamUser"), &DpUser::IsTeamUser)
+        .Prop(_SC("IsBughunter2"), &DpUser::IsBughunter2)
+        .Prop(_SC("IsVerifiedBot"), &DpUser::IsVerifiedBot)
+        .Prop(_SC("IsVerifiedBotDev"), &DpUser::IsVerifiedBotDev)
+        .Prop(_SC("IsCertifiedDoderator"), &DpUser::IsCertifiedDoderator)
+        .Prop(_SC("HasAnimatedIcon"), &DpUser::HasAnimatedIcon)
+    );
+}
+
+} // Namespace:: SqMod

module/Library/DPP/User.hpp

@@ -0,0 +1,206 @@
+#pragma once
+
+// ------------------------------------------------------------------------------------------------
+#include "Core/Utility.hpp"
+
+// ------------------------------------------------------------------------------------------------
+#include <dpp/dpp.h>
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+/* ------------------------------------------------------------------------------------------------
+ * Represents a user on discord. May or may not be a member of a DpGuild.
+*/
+struct DpUser
+{
+    using Ptr = std::unique_ptr< dpp::user >;
+    /* --------------------------------------------------------------------------------------------
+     * Referenced user instance.
+    */
+    Ptr mPtr{nullptr};
+    /* --------------------------------------------------------------------------------------------
+     * Whether the referenced pointer is owned.
+    */
+    bool mOwned{false};
+    /* --------------------------------------------------------------------------------------------
+     * Default constructor.
+    */
+    DpUser() noexcept = default;
+    /* --------------------------------------------------------------------------------------------
+     * Explicit constructor.
+    */
+    explicit DpUser(Ptr::pointer ptr, bool owned = false) noexcept
+        : mPtr(ptr), mOwned(owned)
+    { }
+    /* --------------------------------------------------------------------------------------------
+     * Copy constructor.
+    */
+    explicit DpUser(const Ptr::element_type & o) noexcept
+        : DpUser(new Ptr::element_type(o), true)
+    { }
+    /* --------------------------------------------------------------------------------------------
+     * Move constructor.
+    */
+    explicit DpUser(Ptr::element_type && o) noexcept
+        : DpUser(new Ptr::element_type(std::forward< Ptr::element_type >(o)), true)
+    { }
+    /* --------------------------------------------------------------------------------------------
+     * Copy constructor (disabled).
+    */
+    DpUser(const DpUser & o) = delete;
+    /* --------------------------------------------------------------------------------------------
+     * Move constructor.
+    */
+    DpUser(DpUser && o) noexcept = default;
+    /* --------------------------------------------------------------------------------------------
+     * Destructor.
+    */
+    ~DpUser() noexcept { Cleanup(); }
+    /* --------------------------------------------------------------------------------------------
+     * Copy assignment operator (disabled).
+    */
+    DpUser & operator = (const DpUser & o) = delete;
+    /* --------------------------------------------------------------------------------------------
+     * Move assignment operator.
+    */
+    DpUser & operator = (DpUser && o) noexcept
+    {
+        if (this != &o) {
+            Cleanup();
+            // Transfer members values
+            mPtr = std::move(o.mPtr);
+            mOwned = o.mOwned;
+        }
+        return *this;
+    }
+    /* --------------------------------------------------------------------------------------------
+     * Release any referenced resources and default to an empty/invalid state.
+    */
+    void Cleanup()
+    {
+        // Do we own this to try delete it?
+        if (!mOwned && mPtr) {
+            // Not our job, simply forget about it
+            [[maybe_unused]] auto p = mPtr.release();
+        } else mPtr.reset(); // We own this so delete the instance
+    }
+    /* --------------------------------------------------------------------------------------------
+     * Validate the managed handle.
+    */
+    void Validate() const { if (!mPtr) STHROWF("Invalid discord user handle"); }
+    /* --------------------------------------------------------------------------------------------
+     * Validate the managed handle and retrieve a const reference to it.
+    */
+    SQMOD_NODISCARD Ptr::element_type & Valid() const { Validate(); return *mPtr; }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether a valid instance is managed.
+    */
+    SQMOD_NODISCARD bool IsValid() const { return static_cast< bool >(mPtr); }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve user discord username.
+    */
+    SQMOD_NODISCARD const std::string & GetUsername() const { return Valid().username; }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve user discriminator (aka tag), 4 digits usually displayed with leading zeroes.
+    */
+    SQMOD_NODISCARD SQInteger GetDiscriminator() const { return static_cast< SQInteger >(Valid().discriminator); }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve user avatar hash.
+    */
+    SQMOD_NODISCARD const dpp::utility::iconhash & GetAvatar() const { return Valid().avatar; }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve user flags built from a bitmask of values in dpp::user_flags.
+    */
+    SQMOD_NODISCARD SQInteger GetFlags() const { return static_cast< SQInteger >(Valid().flags); }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve user feference count of how many guilds this user is in.
+    */
+    SQMOD_NODISCARD SQInteger GetRefCount() const { return static_cast< SQInteger >(Valid().refcount); }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the avatar url of the user object.
+    */
+    SQMOD_NODISCARD std::string GetAvatarURL() const { return Valid().get_avatar_url(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the user is a bot.
+    */
+    SQMOD_NODISCARD bool IsBot() const { return Valid().is_bot(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the user is a system user (Clyde).
+    */
+    SQMOD_NODISCARD bool IsSystem() const { return Valid().is_system(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the user has multi-factor authentication enabled.
+    */
+    SQMOD_NODISCARD bool IsMfaEnabled() const { return Valid().is_mfa_enabled(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the user has verified account.
+    */
+    SQMOD_NODISCARD bool IsVerified() const { return Valid().is_verified(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the user has full nitro.
+    */
+    SQMOD_NODISCARD bool HasNitroFull() const { return Valid().has_nitro_full(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the user has nitro classic.
+    */
+    SQMOD_NODISCARD bool HasNitroClassic() const { return Valid().has_nitro_classic(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the user is a discord employee.
+    */
+    SQMOD_NODISCARD bool IsDiscordEmployee() const { return Valid().is_discord_employee(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the user owns a partnered server.
+    */
+    SQMOD_NODISCARD bool IsPartneredOwner() const { return Valid().is_partnered_owner(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the user has hype-squad events.
+    */
+    SQMOD_NODISCARD bool HasHypesquadEvents() const { return Valid().has_hypesquad_events(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the user has the bug-hunter level 1 badge.
+    */
+    SQMOD_NODISCARD bool IsBughunter1() const { return Valid().is_bughunter_1(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the user is in house bravery.
+    */
+    SQMOD_NODISCARD bool IsHouseBravery() const { return Valid().is_house_bravery(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the user is in house brilliance.
+    */
+    SQMOD_NODISCARD bool IsHouseBrilliance() const { return Valid().is_house_brilliance(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the user is in house balance.
+    */
+    SQMOD_NODISCARD bool IsHouseBalanace() const { return Valid().is_house_balanace(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the user is an early supporter.
+    */
+    SQMOD_NODISCARD bool IsEarlySupporter() const { return Valid().is_early_supporter(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the user is a team user.
+    */
+    SQMOD_NODISCARD bool IsTeamUser() const { return Valid().is_team_user(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the user has the bug-hunter level 2 badge.
+    */
+    SQMOD_NODISCARD bool IsBughunter2() const { return Valid().is_bughunter_2(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the user has the verified bot badge.
+    */
+    SQMOD_NODISCARD bool IsVerifiedBot() const { return Valid().is_verified_bot(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the user is an early verified bot developer.
+    */
+    SQMOD_NODISCARD bool IsVerifiedBotDev() const { return Valid().is_verified_bot_dev(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the user is a certified moderator.
+    */
+    SQMOD_NODISCARD bool IsCertifiedDoderator() const { return Valid().is_certified_moderator(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether the user has an animated icon.
+    */
+    SQMOD_NODISCARD bool HasAnimatedIcon() const { return Valid().has_animated_icon(); }
+};
+
+} // Namespace:: SqMod

module/Library/DPP/Utilities.cpp

@@ -0,0 +1,12 @@
+// ------------------------------------------------------------------------------------------------
+#include "Library/DPP/Utilities.hpp"
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+// ------------------------------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------------------------------
+
+
+} // Namespace:: SqMod

module/Library/DPP/Utilities.hpp

@@ -0,0 +1,429 @@
+#pragma once
+
+// ------------------------------------------------------------------------------------------------
+#include "Core/Utility.hpp"
+
+// ------------------------------------------------------------------------------------------------
+#include <dpp/dpp.h>
+
+// ------------------------------------------------------------------------------------------------
+#include <memory>
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+/* ------------------------------------------------------------------------------------------------
+ * Wrapper around a std::vector of DPP values.
+*/
+template < class T, class W > struct DpVectorProxy
+{
+    using Ptr = std::unique_ptr< std::vector< T > >;
+    using Vec = std::vector< std::pair< LightObj, W * > >;
+    /* --------------------------------------------------------------------------------------------
+     * Referenced vector instance.
+    */
+    Ptr mPtr{nullptr};
+    /* --------------------------------------------------------------------------------------------
+     * Cached script objects vector.
+    */
+    Vec mVec{};
+    /* --------------------------------------------------------------------------------------------
+     * Whether the referenced pointer is owned.
+    */
+    bool mOwned{false};
+    /* --------------------------------------------------------------------------------------------
+     * Default constructor.
+    */
+    DpVectorProxy() noexcept = default;
+    /* --------------------------------------------------------------------------------------------
+     * Explicit constructor.
+    */
+    explicit DpVectorProxy(typename Ptr::pointer ptr, bool owned = false)
+        : mPtr(ptr), mVec(), mOwned(owned)
+    { if (mPtr) mVec.resize(mPtr->size()); }
+    /* --------------------------------------------------------------------------------------------
+     * Explicit constructor.
+    */
+    explicit DpVectorProxy(const typename Ptr::element_type & o) noexcept
+        : DpVectorProxy(new typename Ptr::element_type(o), true)
+    { }
+    /* --------------------------------------------------------------------------------------------
+     * Move constructor.
+    */
+    explicit DpVectorProxy(typename Ptr::element_type && o) noexcept
+        : DpVectorProxy(new typename Ptr::element_type(std::forward< Ptr::element_type >(o)), true)
+    { }
+    /* --------------------------------------------------------------------------------------------
+     * Copy constructor (disabled).
+    */
+    DpVectorProxy(const DpVectorProxy & o) = delete;
+    /* --------------------------------------------------------------------------------------------
+     * Move constructor.
+    */
+    DpVectorProxy(DpVectorProxy && o) noexcept = default;
+    /* --------------------------------------------------------------------------------------------
+     * Destructor.
+    */
+    ~DpVectorProxy() noexcept { Cleanup(); }
+    /* --------------------------------------------------------------------------------------------
+     * Copy assignment operator (disabled).
+    */
+    DpVectorProxy & operator = (const DpVectorProxy & o) = delete;
+    /* --------------------------------------------------------------------------------------------
+     * Move assignment operator.
+    */
+    DpVectorProxy & operator = (DpVectorProxy && o) noexcept
+    {
+        if (this != &o) {
+            Cleanup();
+            // Transfer members values
+            mPtr = std::move(o.mPtr);
+            mVec = std::move(o.mVec);
+            mOwned = o.mOwned;
+        }
+        return *this;
+    }
+    /* --------------------------------------------------------------------------------------------
+     * Release any referenced resources and default to an empty/invalid state.
+    */
+    void Cleanup()
+    {
+        // Invalidate cached instances
+        ClearCache();
+        // Do we own this to try delete it?
+        if (!mOwned && mPtr) {
+            // Not our job, simply forget about it
+            [[maybe_unused]] auto p = mPtr.release();
+        } else mPtr.reset(); // We own this so delete the instance
+    }
+    /* --------------------------------------------------------------------------------------------
+     * Validate the managed handle.
+    */
+    void Validate() const { if (!mPtr) STHROWF("Invalid discord vector handle"); }
+    /* --------------------------------------------------------------------------------------------
+     * Validate the managed handle and retrieve a const reference to it.
+    */
+    SQMOD_NODISCARD typename Ptr::element_type & Valid() const { Validate(); return *mPtr; }
+    /* --------------------------------------------------------------------------------------------
+     * Check whether a valid instance is managed.
+    */
+    SQMOD_NODISCARD bool IsValid() const { return static_cast< bool >(mPtr); }
+    /* --------------------------------------------------------------------------------------------
+     * Make sure an index is within range and return the container. Container must exist.
+    */
+    void ValidIdx_(SQInteger i)
+    {
+        if (static_cast< size_t >(i) >= Valid().size())
+        {
+            STHROWF("Invalid vector container index({})", i);
+        }
+    }
+    typename Ptr::element_type & ValidIdx(SQInteger i) { ValidIdx_(i); return *mPtr; }
+    /* --------------------------------------------------------------------------------------------
+     * Make sure an index is within range and return the container. Container must exist.
+    */
+    void ValidIdx_(SQInteger i) const
+    {
+        if (static_cast< size_t >(i) >= Valid().size())
+        {
+            STHROWF("Invalid vector container index({})", i);
+        }
+    }
+    const typename Ptr::element_type & ValidIdx(SQInteger i) const { ValidIdx_(i); return *mPtr; }
+    /* --------------------------------------------------------------------------------------------
+     * Make sure a container instance is referenced and is populated, then return it.
+    */
+    void ValidPop_()
+    {
+        if (Valid().empty())
+        {
+            STHROWF("Vector container is empty");
+        }
+    }
+    typename Ptr::element_type & ValidPop() { ValidPop_(); return *mPtr; }
+    /* --------------------------------------------------------------------------------------------
+     * Make sure a container instance is referenced and is populated, then return it.
+    */
+    void ValidPop_() const
+    {
+        if (Valid().empty())
+        {
+            STHROWF("Vector container is empty");
+        }
+    }
+    const typename Ptr::element_type & ValidPop() const { ValidPop_(); return *mPtr; }
+    /* --------------------------------------------------------------------------------------------
+     * Check if a container instance is referenced.
+    */
+    SQMOD_NODISCARD bool IsNull() const { return !mPtr; }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve a value from the container.
+    */
+    SQMOD_NODISCARD LightObj & Get_(SQInteger i)
+    {
+        // Is the element cached?
+        if (mVec[static_cast< size_t >(i)].first.IsNull())
+        {
+            mVec[static_cast< size_t >(i)] = Obj(&mPtr->at(static_cast< size_t >(i)));
+        }
+        // Return the object from the cache
+        return mVec[static_cast< size_t >(i)].first;
+    }
+    SQMOD_NODISCARD LightObj & Get(SQInteger i)
+    {
+        // Was the referenced vector modified?
+        if (mVec.size() < Valid().size())
+        {
+            // Synchronize the size
+            mVec.resize(mPtr->size());
+            // Synchronize the cache
+            CacheSync();
+        }
+        // Validate index
+        ValidIdx_(i);
+        // Perform the request
+        return Get_(i);
+    }
+    /* --------------------------------------------------------------------------------------------
+     * Modify a value from the container.
+    */
+    void Set(SQInteger i, const W & v) { ValidIdx(i)[static_cast< size_t >(i)] = v.Valid(); }
+    /* --------------------------------------------------------------------------------------------
+     * Check if the container has no elements.
+    */
+    SQMOD_NODISCARD bool Empty() const { return Valid().empty(); }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the number of elements in the container.
+    */
+    SQMOD_NODISCARD SQInteger Size() const { return static_cast< SQInteger >(Valid().size()); }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the number of elements that the container has currently allocated space for.
+    */
+    SQMOD_NODISCARD SQInteger Capacity() const { return static_cast< SQInteger >(Valid().capacity()); }
+    /* --------------------------------------------------------------------------------------------
+     * Synchronize cache container instances.
+    */
+    void CacheSync()
+    {
+        // Invalidate cached instances, if any
+        for (size_t i = 0; i < mVec.size(); ++i)
+        {
+            // Is this element cached?
+            if (mVec[i].second != nullptr)
+            {
+                // Discard previous instance, if any
+                [[maybe_unused]] auto _ = mVec[i].second->mPtr.release();
+                // Sync to new instance
+                mVec[i].second->mPtr.reset(&mPtr->at(i));
+            }
+        }
+    }
+    /* --------------------------------------------------------------------------------------------
+     * Increase the capacity of the container to a value that's greater or equal to the one specified.
+    */
+    DpVectorProxy & Reserve(SQInteger n)
+    {
+        Valid().reserve(ClampL< SQInteger, size_t >(n));
+        mVec.reserve(mPtr->size());
+        CacheSync();
+        return *this;
+    }
+    /* --------------------------------------------------------------------------------------------
+     * Request the removal of unused capacity.
+    */
+    void Compact() { Valid().shrink_to_fit(); CacheSync(); mVec.shrink_to_fit(); }
+    /* --------------------------------------------------------------------------------------------
+     * Erase all elements from the cache container.
+    */
+    void ClearCache()
+    {
+        // Invalidate cached instances, if any
+        for (auto & e : mVec)
+        {
+            // Is this element cached?
+            if (e.second != nullptr)
+            {
+                // Invalidate the instance
+                e.second->Cleanup();
+                // Forget about it
+                e.second = nullptr;
+                // Release script object
+                e.first.Release();
+            }
+        }
+        // Clear the cache vector
+        mVec.clear();
+    }
+    /* --------------------------------------------------------------------------------------------
+     * Erase all elements from the container.
+    */
+    void Clear() { Validate(); ClearCache(); mPtr->clear(); }
+    /* --------------------------------------------------------------------------------------------
+     * Push a value at the back of the container.
+    */
+    void Push(const W & v)
+    {
+        Valid().push_back(v.Valid());
+        mVec.emplace_back();
+        CacheSync();
+    }
+    /* --------------------------------------------------------------------------------------------
+     * Extends the Container by appending all the items in the given container.
+    */
+    void Extend(DpVectorProxy & v)
+    {
+        Valid().insert(Valid().end(), v.Valid().begin(), v.Valid().end());
+        mVec.resize(mPtr->size());
+        CacheSync();
+    }
+    /* --------------------------------------------------------------------------------------------
+     * Pop the last element in the container.
+    */
+    void Pop()
+    {
+        Validate();
+        // Is this element cached?
+        if (mVec.back().second != nullptr)
+        {
+            // Invalidate the instance
+            mVec.back().second->Cleanup();
+            mVec.back().first.Release();
+        }
+        // Safe to remove
+        mPtr->pop_back();
+        mVec.pop_back();
+    }
+    /* --------------------------------------------------------------------------------------------
+     * Erase the element at a certain position.
+    */
+    void EraseAt(SQInteger i)
+    {
+        ValidIdx_(i);
+        // Is this element cached?
+        if (mVec[static_cast< size_t >(i)].second != nullptr)
+        {
+            // Invalidate the instance
+            mVec[static_cast< size_t >(i)].second->Cleanup();
+            mVec[static_cast< size_t >(i)].first.Release();
+        }
+        // Safe to remove
+        mPtr->erase(mPtr->begin() + static_cast< size_t >(i));
+        mVec.erase(mVec.begin() + static_cast< size_t >(i));
+        // Synchronize cache
+        CacheSync();
+    }
+    /* --------------------------------------------------------------------------------------------
+     * Iterate all values through a functor.
+    */
+    void Each(Function & fn)
+    {
+        Validate();
+        // Iterate referenced vector elements
+        for (size_t i = 0; i < mVec.size(); ++i)
+        {
+            fn.Execute(Get(static_cast< SQInteger >(i)));
+        }
+    }
+    /* --------------------------------------------------------------------------------------------
+     * Iterate values in range through a functor.
+    */
+    void EachRange(SQInteger p, SQInteger n, Function & fn)
+    {
+        ValidIdx_(p);
+        ValidIdx_(p + n);
+        // Iterate specified range
+        for (n += p; p < n; ++p)
+        {
+            fn.Execute(Get(static_cast< SQInteger >(p)));
+        }
+    }
+    /* --------------------------------------------------------------------------------------------
+     * Iterate all values through a functor until stopped (i.e false is returned).
+    */
+    void While(Function & fn)
+    {
+        Validate();
+        // Iterate referenced vector elements
+        for (size_t i = 0; i < mVec.size(); ++i)
+        {
+            auto ret = fn.Eval(Get(static_cast< SQInteger >(i)));
+            // (null || true) == continue & false == break
+            if (!ret.IsNull() || !ret.template Cast< bool >())
+            {
+                break;
+            }
+        }
+    }
+    /* --------------------------------------------------------------------------------------------
+     * Iterate values in range through a functor until stopped (i.e false is returned).
+    */
+    void WhileRange(SQInteger p, SQInteger n, Function & fn)
+    {
+        ValidIdx_(p);
+        ValidIdx_(p + n);
+        // Iterate specified range
+        for (n += p; p < n; ++p)
+        {
+            auto ret = fn.Eval(Get(static_cast< SQInteger >(p)));
+            // (null || true) == continue & false == break
+            if (!ret.IsNull() || !ret.template Cast< bool >())
+            {
+                break;
+            }
+        }
+    }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve a wrapped instance as a script object.
+    */
+    SQMOD_NODISCARD static std::pair< LightObj, W * > Obj(T * ptr, bool owned = false)
+    {
+        // Create the wrapper instance for given pointer
+        auto wp = std::make_unique< W >(ptr, false);
+        // Create script object for wrapper instance
+        std::pair< LightObj, W * > p{LightObj{wp.get()}, wp.get()};
+        // Release ownership of the wrapper instance
+        [[maybe_unused]] auto _ = wp.release();
+        // Return the script object and wrapper instance
+        return p;
+    }
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve a wrapped instance as a script object.
+    */
+    SQMOD_NODISCARD static std::pair< LightObj, W * > Obj(const T * ptr, bool owned = false)
+    {
+        return Obj(const_cast< T * >(ptr), owned);
+    }
+};
+
+template < class T, class W, class U > inline void Register_DPP_VectorProxy(HSQUIRRELVM vm, Table & ns, const SQChar * name)
+{
+    using Container = DpVectorProxy< T, W >;
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(name,
+        Class< Container, NoConstructor< Container > >(vm, U::Str)
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &U::Fn)
+        // Properties
+        .Prop(_SC("Null"), &Container::IsNull)
+        .Prop(_SC("Empty"), &Container::Empty)
+        .Prop(_SC("Size"), &Container::Size)
+        .Prop(_SC("Capacity"), &Container::Capacity, &Container::Reserve)
+        // Member Methods
+        .Func(_SC("Get"), &Container::Get)
+        .Func(_SC("Set"), &Container::Set)
+        .Func(_SC("Reserve"), &Container::Reserve)
+        .Func(_SC("Compact"), &Container::Compact)
+        .Func(_SC("Clear"), &Container::Clear)
+        .Func(_SC("Push"), &Container::Push)
+        .Func(_SC("Append"), &Container::Push)
+        .Func(_SC("Extend"), &Container::Extend)
+        .Func(_SC("Pop"), &Container::Pop)
+        .Func(_SC("EraseAt"), &Container::EraseAt)
+        .Func(_SC("Each"), &Container::Each)
+        .Func(_SC("EachRange"), &Container::EachRange)
+        .Func(_SC("While"), &Container::While)
+        .Func(_SC("WhileRange"), &Container::WhileRange)
+    );
+}
+
+} // Namespace:: SqMod

module/Library/IO/Buffer.cpp

@@ -1,6 +1,5 @@
 // ------------------------------------------------------------------------------------------------
 #include "Library/IO/Buffer.hpp"
-#include "Library/Numeric/Long.hpp"
 #include "Base/AABB.hpp"
 #include "Base/Circle.hpp"
 #include "Base/Color3.hpp"
@@ -20,19 +19,7 @@ namespace SqMod {
 SQMOD_DECL_TYPENAME(Typename, _SC("SqBuffer"))
 
 // ------------------------------------------------------------------------------------------------
-void SqBuffer::WriteInt64(const SLongInt & val)
-{
-    Valid().Push< int64_t >(val.GetNum());
-}
-
-// ------------------------------------------------------------------------------------------------
-void SqBuffer::WriteUint64(const ULongInt & val)
-{
-    Valid().Push< uint64_t >(val.GetNum());
-}
-
-// ------------------------------------------------------------------------------------------------
-SQInteger SqBuffer::WriteRawString(StackStrF & val)
+SQInteger SqBuffer::WriteRawString(StackStrF & val) const
 {
     // Validate the managed buffer reference
     Validate();
@@ -50,7 +37,7 @@ SQInteger SqBuffer::WriteRawString(StackStrF & val)
 }
 
 // ------------------------------------------------------------------------------------------------
-SQInteger SqBuffer::WriteClientString(StackStrF & val)
+SQInteger SqBuffer::WriteClientString(StackStrF & val) const
 {
     // Validate the managed buffer reference
     Validate();
@@ -75,67 +62,67 @@ SQInteger SqBuffer::WriteClientString(StackStrF & val)
 }
 
 // ------------------------------------------------------------------------------------------------
-void SqBuffer::WriteAABB(const AABB & val)
+void SqBuffer::WriteAABB(const AABB & val) const
 {
     Valid().Push< AABB >(val);
 }
 
 // ------------------------------------------------------------------------------------------------
-void SqBuffer::WriteCircle(const Circle & val)
+void SqBuffer::WriteCircle(const Circle & val) const
 {
     Valid().Push< Circle >(val);
 }
 
 // ------------------------------------------------------------------------------------------------
-void SqBuffer::WriteColor3(const Color3 & val)
+void SqBuffer::WriteColor3(const Color3 & val) const
 {
     Valid().Push< Color3 >(val);
 }
 
 // ------------------------------------------------------------------------------------------------
-void SqBuffer::WriteColor4(const Color4 & val)
+void SqBuffer::WriteColor4(const Color4 & val) const
 {
     Valid().Push< Color4 >(val);
 }
 
 // ------------------------------------------------------------------------------------------------
-void SqBuffer::WriteQuaternion(const Quaternion & val)
+void SqBuffer::WriteQuaternion(const Quaternion & val) const
 {
     Valid().Push< Quaternion >(val);
 }
 
 // ------------------------------------------------------------------------------------------------
-void SqBuffer::WriteSphere(const Sphere &val)
+void SqBuffer::WriteSphere(const Sphere &val) const
 {
     Valid().Push< Sphere >(val);
 }
 
 // ------------------------------------------------------------------------------------------------
-void SqBuffer::WriteVector2(const Vector2 & val)
+void SqBuffer::WriteVector2(const Vector2 & val) const
 {
     Valid().Push< Vector2 >(val);
 }
 
 // ------------------------------------------------------------------------------------------------
-void SqBuffer::WriteVector2i(const Vector2i & val)
+void SqBuffer::WriteVector2i(const Vector2i & val) const
 {
     Valid().Push< Vector2i >(val);
 }
 
 // ------------------------------------------------------------------------------------------------
-void SqBuffer::WriteVector3(const Vector3 & val)
+void SqBuffer::WriteVector3(const Vector3 & val) const
 {
     Valid().Push< Vector3 >(val);
 }
 
 // ------------------------------------------------------------------------------------------------
-void SqBuffer::WriteVector4(const Vector4 & val)
+void SqBuffer::WriteVector4(const Vector4 & val) const
 {
     Valid().Push< Vector4 >(val);
 }
 
 // ------------------------------------------------------------------------------------------------
-SLongInt SqBuffer::ReadInt64()
+SQInteger SqBuffer::ReadInt64() const
 {
     // Validate the managed buffer reference
     ValidateDeeper();
@@ -144,11 +131,11 @@ SLongInt SqBuffer::ReadInt64()
     // Advance the buffer cursor
     m_Buffer->Advance< int64_t >(1);
     // Return the requested information
-    return SLongInt(value);
+    return static_cast< SQInteger >(value);
 }
 
 // ------------------------------------------------------------------------------------------------
-ULongInt SqBuffer::ReadUint64()
+SQInteger SqBuffer::ReadUint64() const
 {
     // Validate the managed buffer reference
     ValidateDeeper();
@@ -157,11 +144,11 @@ ULongInt SqBuffer::ReadUint64()
     // Advance the buffer cursor
     m_Buffer->Advance< uint64_t >(1);
     // Return the requested information
-    return ULongInt(value);
+    return static_cast< SQInteger >(value);
 }
 
 // ------------------------------------------------------------------------------------------------
-LightObj SqBuffer::ReadRawString(SQInteger length)
+LightObj SqBuffer::ReadRawString(SQInteger length) const
 {
     // Validate the managed buffer reference
     ValidateDeeper();
@@ -201,7 +188,7 @@ LightObj SqBuffer::ReadRawString(SQInteger length)
 }
 
 // ------------------------------------------------------------------------------------------------
-LightObj SqBuffer::ReadClientString()
+LightObj SqBuffer::ReadClientString() const
 {
     // Validate the managed buffer reference
     ValidateDeeper();
@@ -228,7 +215,7 @@ LightObj SqBuffer::ReadClientString()
 }
 
 // ------------------------------------------------------------------------------------------------
-AABB SqBuffer::ReadAABB()
+AABB SqBuffer::ReadAABB() const
 {
     // Validate the managed buffer reference
     ValidateDeeper();
@@ -241,7 +228,7 @@ AABB SqBuffer::ReadAABB()
 }
 
 // ------------------------------------------------------------------------------------------------
-Circle SqBuffer::ReadCircle()
+Circle SqBuffer::ReadCircle() const
 {
     // Validate the managed buffer reference
     ValidateDeeper();
@@ -254,7 +241,7 @@ Circle SqBuffer::ReadCircle()
 }
 
 // ------------------------------------------------------------------------------------------------
-Color3 SqBuffer::ReadColor3()
+Color3 SqBuffer::ReadColor3() const
 {
     // Validate the managed buffer reference
     ValidateDeeper();
@@ -267,7 +254,7 @@ Color3 SqBuffer::ReadColor3()
 }
 
 // ------------------------------------------------------------------------------------------------
-Color4 SqBuffer::ReadColor4()
+Color4 SqBuffer::ReadColor4() const
 {
     // Validate the managed buffer reference
     ValidateDeeper();
@@ -280,7 +267,7 @@ Color4 SqBuffer::ReadColor4()
 }
 
 // ------------------------------------------------------------------------------------------------
-Quaternion SqBuffer::ReadQuaternion()
+Quaternion SqBuffer::ReadQuaternion() const
 {
     // Validate the managed buffer reference
     ValidateDeeper();
@@ -293,7 +280,7 @@ Quaternion SqBuffer::ReadQuaternion()
 }
 
 // ------------------------------------------------------------------------------------------------
-Sphere SqBuffer::ReadSphere()
+Sphere SqBuffer::ReadSphere() const
 {
     // Validate the managed buffer reference
     ValidateDeeper();
@@ -306,7 +293,7 @@ Sphere SqBuffer::ReadSphere()
 }
 
 // ------------------------------------------------------------------------------------------------
-Vector2 SqBuffer::ReadVector2()
+Vector2 SqBuffer::ReadVector2() const
 {
     // Validate the managed buffer reference
     ValidateDeeper();
@@ -319,7 +306,7 @@ Vector2 SqBuffer::ReadVector2()
 }
 
 // ------------------------------------------------------------------------------------------------
-Vector2i SqBuffer::ReadVector2i()
+Vector2i SqBuffer::ReadVector2i() const
 {
     // Validate the managed buffer reference
     ValidateDeeper();
@@ -332,7 +319,7 @@ Vector2i SqBuffer::ReadVector2i()
 }
 
 // ------------------------------------------------------------------------------------------------
-Vector3 SqBuffer::ReadVector3()
+Vector3 SqBuffer::ReadVector3() const
 {
     // Validate the managed buffer reference
     ValidateDeeper();
@@ -345,7 +332,7 @@ Vector3 SqBuffer::ReadVector3()
 }
 
 // ------------------------------------------------------------------------------------------------
-Vector4 SqBuffer::ReadVector4()
+Vector4 SqBuffer::ReadVector4() const
 {
     // Validate the managed buffer reference
     ValidateDeeper();
@@ -358,7 +345,7 @@ Vector4 SqBuffer::ReadVector4()
 }
 
 // ------------------------------------------------------------------------------------------------
-SQInteger SqBuffer::GetCRC32(SQInteger n)
+SQInteger SqBuffer::GetCRC32(SQInteger n) const
 {
     // Validate the managed buffer reference
     ValidateDeeper();
@@ -371,7 +358,7 @@ SQInteger SqBuffer::GetCRC32(SQInteger n)
 }
 
 // ------------------------------------------------------------------------------------------------
-SQInteger SqBuffer::GetADLER32(SQInteger n)
+SQInteger SqBuffer::GetADLER32(SQInteger n) const
 {
     // Validate the managed buffer reference
     ValidateDeeper();

module/Library/IO/Buffer.hpp

@@ -176,9 +176,9 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Validate the managed memory buffer reference.
     */
-    Buffer & Valid() const
+    SQMOD_NODISCARD Buffer & Valid() const
     {
-        Valid();
+        Validate();
         // Return the buffer
         return *m_Buffer;
     }
@@ -186,7 +186,7 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Validate the managed memory buffer reference and the buffer itself.
     */
-    Buffer & ValidDeeper() const
+    SQMOD_NODISCARD Buffer & ValidDeeper() const
     {
         ValidateDeeper();
         // Return the buffer
@@ -204,7 +204,7 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Modify a certain element type at the specified position.
     */
-    void Set(SQInteger n, SQInteger v)
+    void Set(SQInteger n, SQInteger v) const
     {
         Valid().At(ConvTo< SzType >::From(n)) = ConvTo< Value >::From(v);
     }
@@ -220,7 +220,7 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Modify the element at the front of the buffer.
     */
-    void SetFront(SQInteger v)
+    void SetFront(SQInteger v) const
     {
         Valid().Front() = ConvTo< Value >::From(v);
     }
@@ -236,7 +236,7 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Modify the element after the first element in the buffer.
     */
-    void SetNext(SQInteger v)
+    void SetNext(SQInteger v) const
     {
         Valid().Next() = ConvTo< Value >::From(v);
     }
@@ -252,7 +252,7 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Modify the element at the back of the buffer.
     */
-    void SetBack(SQInteger v)
+    void SetBack(SQInteger v) const
     {
         Valid().Back() = ConvTo< Value >::From(v);
     }
@@ -268,7 +268,7 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Modify the element before the last element in the buffer.
     */
-    void SetPrev(SQInteger v)
+    void SetPrev(SQInteger v) const
     {
         Valid().Prev() = ConvTo< Value >::From(v);
     }
@@ -276,7 +276,7 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Reposition the edit cursor to the specified number of elements ahead.
     */
-    void Advance(SQInteger n)
+    void Advance(SQInteger n) const
     {
         Valid().Advance(ConvTo< SzType >::From(n));
     }
@@ -284,7 +284,7 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Reposition the edit cursor to the specified number of elements behind.
     */
-    void Retreat(SQInteger n)
+    void Retreat(SQInteger n) const
     {
         Valid().Retreat(ConvTo< SzType >::From(n));
     }
@@ -292,7 +292,7 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Reposition the edit cursor to a fixed position within the buffer.
     */
-    void Move(SQInteger n)
+    void Move(SQInteger n) const
     {
         Valid().Move(ConvTo< SzType >::From(n));
     }
@@ -300,7 +300,7 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Append a value to the current cursor location and advance the cursor.
     */
-    void Push(SQInteger v)
+    void Push(SQInteger v) const
     {
         Valid().Push(ConvTo< Value >::From(v));
     }
@@ -316,7 +316,7 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Modify the element at the cursor position.
     */
-    void SetCursor(SQInteger v)
+    void SetCursor(SQInteger v) const
     {
         Valid().Cursor() = ConvTo< Value >::From(v);
     }
@@ -332,7 +332,7 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Modify the element before the cursor position.
     */
-    void SetBefore(SQInteger v)
+    void SetBefore(SQInteger v) const
     {
         Valid().Before() = ConvTo< Value >::From(v);
     }
@@ -348,7 +348,7 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Modify the element after the cursor position.
     */
-    void SetAfter(SQInteger v)
+    void SetAfter(SQInteger v) const
     {
         Valid().After() = ConvTo< Value >::From(v);
     }
@@ -396,7 +396,7 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Grow the size of the internal buffer by the specified amount of bytes.
     */
-    void Grow(SQInteger n)
+    void Grow(SQInteger n) const
     {
         return Valid().Grow(ConvTo< SzType >::From(n) * sizeof(Value));
     }
@@ -425,65 +425,71 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Write a signed 8 bit integer to the buffer.
     */
-    void WriteInt8(SQInteger val)
+    void WriteInt8(SQInteger val) const
     {
-        Valid().Push< int8_t >(ConvTo< int8_t >::From(val));
+        Valid().Push< int8_t >(static_cast< int8_t >(val));
     }
 
     /* --------------------------------------------------------------------------------------------
      * Write an unsigned 8 bit integer to the buffer.
     */
-    void WriteUint8(SQInteger val)
+    void WriteUint8(SQInteger val) const
     {
-        Valid().Push< uint8_t >(ConvTo< uint8_t >::From(val));
+        Valid().Push< uint8_t >(static_cast< uint8_t >(val));
     }
 
     /* --------------------------------------------------------------------------------------------
      * Write a signed 16 bit integer to the buffer.
     */
-    void WriteInt16(SQInteger val)
+    void WriteInt16(SQInteger val) const
     {
-        Valid().Push< int16_t >(ConvTo< int16_t >::From(val));
+        Valid().Push< int16_t >(static_cast< int16_t >(val));
     }
 
     /* --------------------------------------------------------------------------------------------
      * Write an unsigned 16 bit integer to the buffer.
     */
-    void WriteUint16(SQInteger val)
+    void WriteUint16(SQInteger val) const
     {
-        Valid().Push< uint16_t >(ConvTo< uint16_t >::From(val));
+        Valid().Push< uint16_t >(static_cast< uint16_t >(val));
     }
 
     /* --------------------------------------------------------------------------------------------
      * Write a signed 32 bit integer to the buffer.
     */
-    void WriteInt32(SQInteger val)
+    void WriteInt32(SQInteger val) const
     {
-        Valid().Push< int32_t >(ConvTo< int32_t >::From(val));
+        Valid().Push< int32_t >(static_cast< int32_t >(val));
     }
 
     /* --------------------------------------------------------------------------------------------
      * Write an unsigned 32 bit integer to the buffer.
     */
-    void WriteUint32(SQInteger val)
+    void WriteUint32(SQInteger val) const
     {
-        Valid().Push< uint32_t >(ConvTo< uint32_t >::From(val));
+        Valid().Push< uint32_t >(static_cast< uint32_t >(val));
     }
 
     /* --------------------------------------------------------------------------------------------
      * Write a signed 64 bit integer to the buffer.
     */
-    void WriteInt64(const SLongInt & val);
+    void WriteInt64(SQInteger val) const
+    {
+        Valid().Push< int64_t >(static_cast< int64_t >(val));
+    }
 
     /* --------------------------------------------------------------------------------------------
      * Write an unsigned 64 bit integer to the buffer.
     */
-    void WriteUint64(const ULongInt & val);
+    void WriteUint64(SQInteger val) const
+    {
+        Valid().Push< uint64_t >(static_cast< uint64_t >(val));
+    }
 
     /* --------------------------------------------------------------------------------------------
      * Write a 32 bit float to the buffer.
     */
-    void WriteFloat32(SQFloat val)
+    void WriteFloat32(SQFloat val) const
     {
         Valid().Push< float >(ConvTo< float >::From(val));
     }
@@ -491,7 +497,7 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Write a 64 bit float to the buffer.
     */
-    void WriteFloat64(SQFloat val)
+    void WriteFloat64(SQFloat val) const
     {
         Valid().Push< double >(ConvTo< double >::From(val));
     }
@@ -499,67 +505,67 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Write a raw string to the buffer.
     */
-    SQInteger WriteRawString(StackStrF & val);
+    SQInteger WriteRawString(StackStrF & val) const;
 
     /* --------------------------------------------------------------------------------------------
      * Write a client encoded string to the buffer.
     */
-    SQInteger WriteClientString(StackStrF & val);
+    SQInteger WriteClientString(StackStrF & val) const;
 
     /* --------------------------------------------------------------------------------------------
      * Write a AABB to the buffer.
     */
-    void WriteAABB(const AABB & val);
+    void WriteAABB(const AABB & val) const;
 
     /* --------------------------------------------------------------------------------------------
      * Write a Circle to the buffer.
     */
-    void WriteCircle(const Circle & val);
+    void WriteCircle(const Circle & val) const;
 
     /* --------------------------------------------------------------------------------------------
      * Write a Color3 to the buffer.
     */
-    void WriteColor3(const Color3 & val);
+    void WriteColor3(const Color3 & val) const;
 
     /* --------------------------------------------------------------------------------------------
      * Write a Color4 to the buffer.
     */
-    void WriteColor4(const Color4 & val);
+    void WriteColor4(const Color4 & val) const;
 
     /* --------------------------------------------------------------------------------------------
      * Write a Quaternion to the buffer.
     */
-    void WriteQuaternion(const Quaternion & val);
+    void WriteQuaternion(const Quaternion & val) const;
 
     /* --------------------------------------------------------------------------------------------
      * Write a Sphere to the buffer.
     */
-    void WriteSphere(const Sphere &val);
+    void WriteSphere(const Sphere &val) const;
 
     /* --------------------------------------------------------------------------------------------
      * Write a Vector2 to the buffer.
     */
-    void WriteVector2(const Vector2 & val);
+    void WriteVector2(const Vector2 & val) const;
 
     /* --------------------------------------------------------------------------------------------
      * Write a Vector2i to the buffer.
     */
-    void WriteVector2i(const Vector2i & val);
+    void WriteVector2i(const Vector2i & val) const;
 
     /* --------------------------------------------------------------------------------------------
      * Write a Vector3 to the buffer.
     */
-    void WriteVector3(const Vector3 & val);
+    void WriteVector3(const Vector3 & val) const;
 
     /* --------------------------------------------------------------------------------------------
      * Write a Vector4 to the buffer.
     */
-    void WriteVector4(const Vector4 & val);
+    void WriteVector4(const Vector4 & val) const;
 
     /* --------------------------------------------------------------------------------------------
      * Write a signed 8 bit integer from the buffer.
     */
-    SQInteger ReadInt8()
+    SQMOD_NODISCARD SQInteger ReadInt8() const
     {
         // Validate the managed buffer reference
         ValidateDeeper();
@@ -574,7 +580,7 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Read an unsigned 8 bit integer from the buffer.
     */
-    SQInteger ReadUint8()
+    SQMOD_NODISCARD SQInteger ReadUint8() const
     {
         // Validate the managed buffer reference
         ValidateDeeper();
@@ -589,7 +595,7 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Read a signed 16 bit integer from the buffer.
     */
-    SQInteger ReadInt16()
+    SQMOD_NODISCARD SQInteger ReadInt16() const
     {
         // Validate the managed buffer reference
         ValidateDeeper();
@@ -604,7 +610,7 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Read an unsigned 16 bit integer from the buffer.
     */
-    SQInteger ReadUint16()
+    SQMOD_NODISCARD SQInteger ReadUint16() const
     {
         // Validate the managed buffer reference
         ValidateDeeper();
@@ -619,7 +625,7 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Read a signed 32 bit integer from the buffer.
     */
-    SQInteger ReadInt32()
+    SQMOD_NODISCARD SQInteger ReadInt32() const
     {
         // Validate the managed buffer reference
         ValidateDeeper();
@@ -634,7 +640,7 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Read an unsigned 32 bit integer from the buffer.
     */
-    SQInteger ReadUint32()
+    SQMOD_NODISCARD SQInteger ReadUint32() const
     {
         // Validate the managed buffer reference
         ValidateDeeper();
@@ -649,17 +655,17 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Read a signed 64 bit integer from the buffer.
     */
-    SLongInt ReadInt64();
+    SQMOD_NODISCARD SQInteger ReadInt64() const;
 
     /* --------------------------------------------------------------------------------------------
      * Read an unsigned 64 bit integer from the buffer.
     */
-    ULongInt ReadUint64();
+    SQMOD_NODISCARD SQInteger ReadUint64() const;
 
     /* --------------------------------------------------------------------------------------------
      * Read a 32 bit float from the buffer.
     */
-    SQFloat ReadFloat32()
+    SQMOD_NODISCARD SQFloat ReadFloat32() const
     {
         // Validate the managed buffer reference
         ValidateDeeper();
@@ -674,7 +680,7 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Read a 64 bit float from the buffer.
     */
-    SQFloat ReadFloat64()
+    SQMOD_NODISCARD SQFloat ReadFloat64() const
     {
         // Validate the managed buffer reference
         ValidateDeeper();
@@ -689,72 +695,72 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Read a raw string from the buffer.
     */
-    LightObj ReadRawString(SQInteger length);
+    SQMOD_NODISCARD LightObj ReadRawString(SQInteger length) const;
 
     /* --------------------------------------------------------------------------------------------
      * Read a string from the buffer.
     */
-    LightObj ReadClientString();
+    SQMOD_NODISCARD LightObj ReadClientString() const;
 
     /* --------------------------------------------------------------------------------------------
      * Read a AABB from the buffer.
     */
-    AABB ReadAABB();
+    SQMOD_NODISCARD AABB ReadAABB() const;
 
     /* --------------------------------------------------------------------------------------------
      * Read a Circle from the buffer.
     */
-    Circle ReadCircle();
+    SQMOD_NODISCARD Circle ReadCircle() const;
 
     /* --------------------------------------------------------------------------------------------
      * Read a Color3 from the buffer.
     */
-    Color3 ReadColor3();
+    SQMOD_NODISCARD Color3 ReadColor3() const;
 
     /* --------------------------------------------------------------------------------------------
      * Read a Color4 from the buffer.
     */
-    Color4 ReadColor4();
+    SQMOD_NODISCARD Color4 ReadColor4() const;
 
     /* --------------------------------------------------------------------------------------------
      * Read a Quaternion from the buffer.
     */
-    Quaternion ReadQuaternion();
+    SQMOD_NODISCARD Quaternion ReadQuaternion() const;
 
     /* --------------------------------------------------------------------------------------------
      * Read a Sphere from the buffer.
     */
-    Sphere ReadSphere();
+    SQMOD_NODISCARD Sphere ReadSphere() const;
 
     /* --------------------------------------------------------------------------------------------
      * Read a Vector2 from the buffer.
     */
-    Vector2 ReadVector2();
+    SQMOD_NODISCARD Vector2 ReadVector2() const;
 
     /* --------------------------------------------------------------------------------------------
      * Read a Vector2i from the buffer.
     */
-    Vector2i ReadVector2i();
+    SQMOD_NODISCARD Vector2i ReadVector2i() const;
 
     /* --------------------------------------------------------------------------------------------
      * Read a Vector3 from the buffer.
     */
-    Vector3 ReadVector3();
+    SQMOD_NODISCARD Vector3 ReadVector3() const;
 
     /* --------------------------------------------------------------------------------------------
      * Read a Vector4 from the buffer.
     */
-    Vector4 ReadVector4();
+    SQMOD_NODISCARD Vector4 ReadVector4() const;
 
     /* --------------------------------------------------------------------------------------------
      * Compute the CRC-32 checksums on the data in the buffer.
     */
-    SQInteger GetCRC32(SQInteger n);
+    SQMOD_NODISCARD SQInteger GetCRC32(SQInteger n) const;
 
     /* --------------------------------------------------------------------------------------------
      * Compute the Adler-32 checksums on the data in the buffer.
     */
-    SQInteger GetADLER32(SQInteger n);
+    SQMOD_NODISCARD SQInteger GetADLER32(SQInteger n) const;
 };
 
 } // Namespace:: SqMod

module/Library/MMDB.cpp

@@ -36,7 +36,7 @@ static SQChar * Bin128ToDec(const uint32_t N[4])
         // Add s[] to itself in decimal, doubling it
         for (j = sizeof(s) - 2; j >= 0; j--)
         {
-            s[j] += s[j] - '0' + carry;
+            s[j] += s[j] - '0' + carry; // NOLINT(cppcoreguidelines-narrowing-conversions)
 
             carry = (s[j] > '9');
 
@@ -265,7 +265,7 @@ SQFloat GetEntryAsFloat(const MMDB_entry_data_s & ed)
 }
 
 // ------------------------------------------------------------------------------------------------
-LightObj GetEntryAsLong(const MMDB_entry_data_s & ed)
+SQInteger GetEntryAsLong(const MMDB_entry_data_s & ed)
 {
     uint64_t value = 0;
     // Identify the type of entry data
@@ -315,7 +315,7 @@ LightObj GetEntryAsLong(const MMDB_entry_data_s & ed)
             STHROWF("Unsupported conversion from ({}) to (long)", AsTypeStr(ed.type));
     }
     // Return a long integer instance with the requested value
-    return LightObj(SqTypeIdentity< ULongInt >{}, SqVM(), value);
+    return static_cast< SQInteger >(value);
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -338,7 +338,7 @@ LightObj GetEntryAsString(const MMDB_entry_data_s & ed)
             sq_pushstring(vm, fmt::format("{}", ed.double_value).c_str(), -1);
         } break;
         case MMDB_DATA_TYPE_BYTES: {
-            sq_pushstring(vm, reinterpret_cast< const SQChar * >(ed.bytes), ed.data_size / sizeof(SQChar));
+            sq_pushstring(vm, reinterpret_cast< const SQChar * >(ed.bytes), static_cast< SQInteger >(ed.data_size) / sizeof(SQChar));
         } break;
         case MMDB_DATA_TYPE_UINT16: {
             sq_pushstring(vm, fmt::format("{}", ed.uint16).c_str(), -1);
@@ -1051,7 +1051,7 @@ Object LookupResult::GetEntryDataList()
 // ------------------------------------------------------------------------------------------------
 SQInteger LookupResult::GetValue(HSQUIRRELVM vm)
 {
-    const int32_t top = sq_gettop(vm);
+    const auto top = sq_gettop(vm);
     // The lookup result instance
     LookupResult * lookup;
     // Attempt to extract the lookup result instance
@@ -1294,7 +1294,7 @@ Object SearchNode::GetRightRecordEntryDataList()
 // ------------------------------------------------------------------------------------------------
 SQInteger SearchNode::GetRecordEntryData(HSQUIRRELVM vm, bool right)
 {
-    const int32_t top = sq_gettop(vm);
+    const auto top = sq_gettop(vm);
     // The search node result instance
     SearchNode * node;
     // Attempt to extract the search node result instance

module/Library/MMDB.hpp

@@ -5,7 +5,6 @@
 
 // ------------------------------------------------------------------------------------------------
 #include "Library/IO/Buffer.hpp"
-#include "Library/Numeric/Long.hpp"
 
 // ------------------------------------------------------------------------------------------------
 #include <vector>
@@ -76,7 +75,7 @@ SQFloat GetEntryAsFloat(const MMDB_entry_data_s & ed);
 /* ------------------------------------------------------------------------------------------------
  * Retrieve the value from the specified entry data as a long integer.
 */
-LightObj GetEntryAsLong(const MMDB_entry_data_s & ed);
+SQInteger GetEntryAsLong(const MMDB_entry_data_s & ed);
 
 /* ------------------------------------------------------------------------------------------------
  * Retrieve the value from the specified entry data as a string.
@@ -811,7 +810,7 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Retrieve the value from the current element as a long integer.
     */
-    SQMOD_NODISCARD LightObj GetLong() const
+    SQMOD_NODISCARD SQInteger GetLong() const
     {
         return GetEntryAsLong(SQMOD_GET_VALID(*this));
     }
@@ -1105,7 +1104,7 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Retrieve the value from the current element as a long integer.
     */
-    SQMOD_NODISCARD LightObj GetLong() const
+    SQMOD_NODISCARD SQInteger GetLong() const
     {
         return GetEntryAsLong(SQMOD_GET_VALID_ELEM(*this)->entry_data);
     }
@@ -1492,9 +1491,9 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Retrieve the build epoch.
     */
-    SQMOD_NODISCARD Object GetBuildEpoch() const
+    SQMOD_NODISCARD SQInteger GetBuildEpoch() const
     {
-        return Object(SqTypeIdentity< ULongInt >{}, SqVM(), ConvTo< uint64_t >::From(SQMOD_GET_VALID(*this)->build_epoch));
+        return ConvTo< SQInteger >::From(SQMOD_GET_VALID(*this)->build_epoch);
     }
 
     /* --------------------------------------------------------------------------------------------
@@ -1662,17 +1661,17 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Retrieve the left record value.
     */
-    Object GetLeftRecord()
+    SQInteger GetLeftRecord()
     {
-        return Object(SqTypeIdentity< ULongInt >{}, SqVM(), ConvTo< uint64_t >::From(SQMOD_GET_VALID(*this).left_record));
+        return ConvTo< SQInteger >::From(SQMOD_GET_VALID(*this).left_record);
     }
 
     /* --------------------------------------------------------------------------------------------
      * Retrieve the right record value.
     */
-    Object GetRightRecord()
+    SQInteger GetRightRecord()
     {
-      return Object(SqTypeIdentity< ULongInt >{}, SqVM(), ConvTo< uint64_t >::From(SQMOD_GET_VALID(*this).right_record));
+      return ConvTo< SQInteger >::From(SQMOD_GET_VALID(*this).right_record);
     }
 
     /* --------------------------------------------------------------------------------------------

module/Library/MySQL.cpp

@@ -534,7 +534,7 @@ bool DbConvTo< bool >::From(const SQChar * value, unsigned long length, enum_fie
 }
 
 // ------------------------------------------------------------------------------------------------
-bool DbConvTo< char >::From(const SQChar * value, unsigned long length, enum_field_types type, const SQChar * tn)
+char DbConvTo< char >::From(const SQChar * value, unsigned long length, enum_field_types type, const SQChar * tn)
 {
     return ConvertToSInt< char >(value, length, type, tn);
 }
@@ -636,7 +636,7 @@ void ConnHnd::Create(const Account & acc)
         SQMOD_THROW_CURRENT(*this, "Cannot connect to database");
     }
     // Attempt configure the auto-commit option
-    else if (mysql_autocommit(mPtr, mAutoCommit) != 0)
+    else if (mysql_autocommit(mPtr, static_cast< StmtBind::BoolType >(mAutoCommit)) != 0)
     {
         SQMOD_THROW_CURRENT(*this, "Cannot configure auto-commit");
     }
@@ -1555,7 +1555,7 @@ void Account::SetSSL(const SQChar * key, const SQChar * cert, const SQChar * ca,
 Table Account::GetOptionsTable() const
 {
     // Allocate an empty table
-    Table tbl(SqVM(), m_Options.size());
+    Table tbl(SqVM(), static_cast< SQInteger >(m_Options.size()));
     // Insert every option into the table
     for (const auto & opt : m_Options)
     {
@@ -1694,7 +1694,7 @@ const ConnRef & Connection::GetCreated() const
 #endif // _DEBUG
 
 // ------------------------------------------------------------------------------------------------
-Object Connection::Insert(const SQChar * query)
+SQInteger Connection::Insert(const SQChar * query)
 {
     // Make sure the specified query is valid
     if (!query || *query == '\0')
@@ -1707,7 +1707,7 @@ Object Connection::Insert(const SQChar * query)
         SQMOD_THROW_CURRENT(*m_Handle, "Unable to execute MySQL query");
     }
     // Return the identifier of the inserted row
-    return Object(SqTypeIdentity< ULongInt >{}, SqVM(), mysql_insert_id(m_Handle->mPtr));
+    return static_cast< SQInteger >(mysql_insert_id(m_Handle->mPtr));
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -1784,12 +1784,11 @@ SQInteger Connection::ExecuteF(HSQUIRRELVM vm)
     // Attempt to execute the specified query
     try
     {
-        Var< ULongInt >::push(vm, ULongInt(conn->m_Handle->Execute(val.mPtr, static_cast<unsigned long>(val.mLen))));
+        sq_pushinteger(vm, static_cast< SQInteger >(conn->m_Handle->Execute(val.mPtr, static_cast< unsigned long >(val.mLen))));
     }
-    catch (const Sqrat::Exception & e)
+    catch (const std::exception & e)
     {
-        // Propagate the error
-        return sq_throwerror(vm, e.what());
+        return sq_throwerror(vm, e.what()); // Propagate the error
     }
     // This function returned a value
     return 1;
@@ -1851,12 +1850,11 @@ SQInteger Connection::InsertF(HSQUIRRELVM vm)
             SQMOD_THROW_CURRENT(*(conn->m_Handle), "Unable to execute MySQL query");
         }
         // Return the identifier of the inserted row
-        Var< ULongInt >::push(vm, ULongInt(mysql_insert_id(conn->m_Handle->mPtr)));
+        sq_pushinteger(vm, static_cast< SQInteger >(mysql_insert_id(conn->m_Handle->mPtr)));
     }
-    catch (const Sqrat::Exception & e)
+    catch (const std::exception & e)
     {
-        // Propagate the error
-        return sq_throwerror(vm, e.what());
+        return sq_throwerror(vm, e.what()); // Propagate the error
     }
     // This function returned a value
     return 1;
@@ -2361,7 +2359,7 @@ SQInteger Field::GetUint32() const
 }
 
 // ------------------------------------------------------------------------------------------------
-Object Field::GetInt64() const
+SQInteger Field::GetInt64() const
 {
     SQMOD_VALIDATE_STEPPED(*this);
     // Obtain the initial stack size
@@ -2369,18 +2367,16 @@ Object Field::GetInt64() const
     // Should we retrieve the value from the bind wrapper?
     if (m_Handle->mStatement)
     {
-        return Object(SqTypeIdentity< SLongInt >{}, SqVM(),
-                ConvTo< int64_t >::From(m_Handle->mBinds[m_Index].mInt64));
+        return ConvTo< SQInteger >::From(m_Handle->mBinds[m_Index].mInt64);
     }
     // Retrieve the value directly from the row
-    return Object(SqTypeIdentity< SLongInt >{}, SqVM(),
-            DbConvTo< int64_t >::From(m_Handle->mRow[m_Index],
+    return DbConvTo< SQInteger >::From(m_Handle->mRow[m_Index],
                                     m_Handle->mLengths[m_Index],
-                                    m_Handle->mFields[m_Index].type));
+                                    m_Handle->mFields[m_Index].type);
 }
 
 // ------------------------------------------------------------------------------------------------
-Object Field::GetUint64() const
+SQInteger Field::GetUint64() const
 {
     SQMOD_VALIDATE_STEPPED(*this);
     // Obtain the initial stack size
@@ -2388,14 +2384,12 @@ Object Field::GetUint64() const
     // Should we retrieve the value from the bind wrapper?
     if (m_Handle->mStatement)
     {
-      return Object(SqTypeIdentity< ULongInt >{}, SqVM(),
-                ConvTo< uint64_t >::From(m_Handle->mBinds[m_Index].mUint64));
+      return ConvTo< SQInteger >::From(m_Handle->mBinds[m_Index].mUint64);
     }
     // Retrieve the value directly from the row
-    return Object(SqTypeIdentity< ULongInt >{}, SqVM(),
-            DbConvTo< uint64_t >::From(m_Handle->mRow[m_Index],
+    return DbConvTo< SQInteger >::From(m_Handle->mRow[m_Index],
                                     m_Handle->mLengths[m_Index],
-                                    m_Handle->mFields[m_Index].type));
+                                    m_Handle->mFields[m_Index].type);
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -2997,23 +2991,23 @@ void Statement::SetUint64(uint32_t idx, SQInteger val) const
 }
 
 // ------------------------------------------------------------------------------------------------
-void Statement::SetSLongInt(uint32_t idx, const SLongInt & val) const
+void Statement::SetSLongInt(uint32_t idx, SQInteger val) const
 {
     SQMOD_VALIDATE_PARAM(*this, idx);
     // Attempt to set the input value
     m_Handle->mBinds[idx].SetInput(MYSQL_TYPE_LONGLONG, &(m_Handle->mMyBinds[idx]));
     // Attempt to assign the numeric value inside the specified object
-    m_Handle->mBinds[idx].mInt64 = val.GetNum();
+    m_Handle->mBinds[idx].mInt64 = val;
 }
 
 // ------------------------------------------------------------------------------------------------
-void Statement::SetULongInt(uint32_t idx, const ULongInt & val) const
+void Statement::SetULongInt(uint32_t idx, SQInteger val) const
 {
     SQMOD_VALIDATE_PARAM(*this, idx);
     // Attempt to set the input value
     m_Handle->mBinds[idx].SetInput(MYSQL_TYPE_LONGLONG, &(m_Handle->mMyBinds[idx]));
     // Attempt to assign the numeric value inside the specified object
-    m_Handle->mBinds[idx].mUint64 = val.GetNum();
+    m_Handle->mBinds[idx].mUint64 = static_cast< uint64_t >(val);
     // Specify that this value is unsigned
     m_Handle->mMyBinds[idx].is_unsigned = true;
 }

module/Library/MySQL.hpp

@@ -5,7 +5,6 @@
 
 // ------------------------------------------------------------------------------------------------
 #include "Library/IO/Buffer.hpp"
-#include "Library/Numeric/Long.hpp"
 #include "Library/Chrono.hpp"
 #include "Library/Chrono/Date.hpp"
 #include "Library/Chrono/Datetime.hpp"
@@ -196,7 +195,7 @@ template < > struct DbConvTo< bool >
 */
 template < > struct DbConvTo< char >
 {
-    SQMOD_NODISCARD static bool From(const SQChar * value, unsigned long length, enum_field_types type, const SQChar * tn = _SC("char"));
+    SQMOD_NODISCARD static char From(const SQChar * value, unsigned long length, enum_field_types type, const SQChar * tn = _SC("char"));
 };
 
 /* ------------------------------------------------------------------------------------------------
@@ -560,7 +559,7 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Retrieve the used buffer.
     */
-    char * GetBuffer()
+    SQMOD_NODISCARD char * GetBuffer()
     {
         return mData ? mData.Data() : reinterpret_cast< char * >(&mUint64);
     }
@@ -1457,7 +1456,7 @@ public:
     {
         // Attempt to toggle auto-commit if necessary
         if (SQMOD_GET_CREATED(*this)->mAutoCommit != toggle &&
-            mysql_autocommit(m_Handle->mPtr, toggle) != 0)
+            mysql_autocommit(m_Handle->mPtr, static_cast< StmtBind::BoolType >(toggle)) != 0)
         {
             SQMOD_THROW_CURRENT(*m_Handle, "Cannot toggle auto-commit");
         }
@@ -1486,15 +1485,15 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Execute a query on the server.
     */
-    Object Execute(const SQChar * query)
+    SQInteger Execute(const SQChar * query)
     {
-        return Object(SqTypeIdentity< ULongInt >{}, SqVM(), SQMOD_GET_CREATED(*this)->Execute(query));
+        return static_cast< SQInteger >(SQMOD_GET_CREATED(*this)->Execute(query));
     }
 
     /* --------------------------------------------------------------------------------------------
      * Execute a query on the server.
     */
-    Object Insert(const SQChar * query);
+    SQInteger Insert(const SQChar * query);
 
     /* --------------------------------------------------------------------------------------------
      * Execute a query on the server.
@@ -1866,12 +1865,12 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Retrieve the value inside the referenced field as a signed 64 bit integer value.
     */
-    SQMOD_NODISCARD Object GetInt64() const;
+    SQMOD_NODISCARD SQInteger GetInt64() const;
 
     /* --------------------------------------------------------------------------------------------
      * Retrieve the value inside the referenced field as an unsigned 64 bit integer value.
     */
-    SQMOD_NODISCARD Object GetUint64() const;
+    SQMOD_NODISCARD SQInteger GetUint64() const;
 
     /* --------------------------------------------------------------------------------------------
      * Retrieve the value inside the referenced field as a 32 bit floating point value.
@@ -2111,17 +2110,17 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Returns the current position of the row cursor for the last Next().
     */
-    SQMOD_NODISCARD Object RowIndex() const
+    SQMOD_NODISCARD SQInteger RowIndex() const
     {
-        return Object(SqTypeIdentity< ULongInt >{}, SqVM(), SQMOD_GET_CREATED(*this)->RowIndex());
+        return static_cast< SQInteger >(SQMOD_GET_CREATED(*this)->RowIndex());
     }
 
     /* --------------------------------------------------------------------------------------------
      * Returns the number of rows in the result set.
     */
-    SQMOD_NODISCARD Object RowCount() const
+    SQMOD_NODISCARD SQInteger RowCount() const
     {
-        return Object(SqTypeIdentity< ULongInt >{}, SqVM(), SQMOD_GET_CREATED(*this)->RowCount());
+        return static_cast< SQInteger >(SQMOD_GET_CREATED(*this)->RowCount());
     }
 
     /* --------------------------------------------------------------------------------------------
@@ -2143,9 +2142,9 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Seeks to an arbitrary row in a query result set.
     */
-    SQMOD_NODISCARD bool SetLongRowIndex(const ULongInt & index) const
+    SQMOD_NODISCARD bool SetLongRowIndex(SQInteger index) const
     {
-        return SQMOD_GET_CREATED(*this)->SetRowIndex(index.GetNum());
+        return SQMOD_GET_CREATED(*this)->SetRowIndex(static_cast< uint64_t >(index));
     }
 
     /* --------------------------------------------------------------------------------------------
@@ -2422,7 +2421,7 @@ public:
         // Do we have a valid handle?
         if (m_Handle)
         {
-            m_Handle->mQuery;
+            return m_Handle->mQuery;
         }
         // Default to an empty string
         return NullString();
@@ -2517,12 +2516,12 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Assign a signed long integer to a parameter.
     */
-    void SetSLongInt(uint32_t idx, const SLongInt & val) const;
+    void SetSLongInt(uint32_t idx, SQInteger val) const;
 
     /* --------------------------------------------------------------------------------------------
      * Assign an unsigned long integer to a parameter.
     */
-    void SetULongInt(uint32_t idx, const ULongInt & val) const;
+    void SetULongInt(uint32_t idx, SQInteger val) const;
 
     /* --------------------------------------------------------------------------------------------
      * Assign a native integer to a parameter.

module/Library/Net.cpp

@@ -0,0 +1,203 @@
+// ------------------------------------------------------------------------------------------------
+#include "Library/Net.hpp"
+
+// ------------------------------------------------------------------------------------------------
+#include <sqratConst.h>
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+// ------------------------------------------------------------------------------------------------
+SQMOD_DECL_TYPENAME(SqWebSocketClient, _SC("SqWebSocketClient"))
+
+// ------------------------------------------------------------------------------------------------
+static std::thread::id sMainThreadID{}; // Main thread ID
+
+// ------------------------------------------------------------------------------------------------
+void InitializeNet()
+{
+    int f = MG_FEATURES_DEFAULT;
+#ifndef NO_FILES
+    f |= MG_FEATURES_FILES;
+#endif
+#ifndef NO_SSL
+    f |= MG_FEATURES_SSL;
+#endif
+#ifndef NO_CGI
+    f |= MG_FEATURES_CGI;
+#endif
+#ifndef NO_CACHING
+    f |= MG_FEATURES_CACHE;
+#endif
+#ifdef USE_IPV6
+    f |= MG_FEATURES_CGI;
+#endif
+#ifdef USE_WEBSOCKET
+    f |= MG_FEATURES_WEBSOCKET;
+#endif
+#ifdef USE_SERVER_STATS
+    f |= MG_FEATURES_STATS;
+#endif
+#ifdef USE_ZLIB
+    f |= MG_FEATURES_COMPRESSION;
+#endif
+#ifdef USE_HTTP2
+    f |= MG_FEATURES_HTTP2;
+#endif
+#ifdef USE_X_DOM_SOCKET
+    f |= MG_FEATURES_X_DOMAIN_SOCKET;
+#endif
+    mg_init_library(f);
+}
+
+// ------------------------------------------------------------------------------------------------
+void TerminateNet()
+{
+    // Go over all connections and try to terminate them
+    for (WebSocketClient * inst = WebSocketClient::sHead; inst && inst->mNext != WebSocketClient::sHead; inst = inst->mNext)
+    {
+        inst->Terminate(); // Terminate() the connection
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void ProcessNet()
+{
+    // Go over all connections and allow them to process data
+    for (WebSocketClient * inst = WebSocketClient::sHead; inst && inst->mNext != WebSocketClient::sHead; inst = inst->mNext)
+    {
+        inst->Process();
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+WebSocketClient & WebSocketClient::Connect()
+{
+    // Make sure another connection does not exist
+    Invalid();
+    // Error buffer
+    char err_buf[128] = {0};
+    // Connect to the given WS or WSS (WS secure) server
+    mHandle = mg_connect_websocket_client(mHost.c_str(), mPort, mSecure?1:0,
+                                        err_buf, sizeof(err_buf), mPath.c_str(),
+                                        mOrigin.empty() ? nullptr : mOrigin.c_str(),
+                                        &WebSocketClient::DataHandler_,
+                                        &WebSocketClient::CloseHandler_,
+                                        this);
+    // Check if connection was possible
+    if (!mHandle)
+    {
+        STHROWF("Connection failed: {}", err_buf);
+    }
+    // Allow chaining
+    return *this;
+}
+
+// ------------------------------------------------------------------------------------------------
+WebSocketClient & WebSocketClient::ConnectExt()
+{
+    // Make sure another connection does not exist
+    Invalid();
+    // Error buffer
+    char err_buf[128] = {0};
+    // Connect to the given WS or WSS (WS secure) server
+    mHandle = mg_connect_websocket_client_extensions(mHost.c_str(), mPort, mSecure?1:0,
+                                                    err_buf, sizeof(err_buf), mPath.c_str(),
+                                                    mOrigin.empty() ? nullptr : mOrigin.c_str(),
+                                                    mExtensions.empty() ? nullptr : mExtensions.c_str(),
+                                                    &WebSocketClient::DataHandler_,
+                                                    &WebSocketClient::CloseHandler_,
+                                                    this);
+    // Check if connection was possible
+    if (!mHandle)
+    {
+        STHROWF("Connection failed: {}", err_buf);
+    }
+    // Allow chaining
+    return *this;
+}
+
+// ------------------------------------------------------------------------------------------------
+int WebSocketClient::DataHandler(int flags, char * data, size_t data_len) noexcept
+{
+    // Create a frame instance to store information and queue it
+    try
+    {
+        mQueue.enqueue(std::make_unique< Frame >(data, data_len, flags));
+    }
+    catch(...)
+    {
+        LogFtl("Failed to queue web-socket data");
+    }
+    // Return 1 to keep the connection open
+    return 1;
+}
+
+// ------------------------------------------------------------------------------------------------
+void WebSocketClient::CloseHandler() noexcept
+{
+    mClosing.store(true);
+}
+
+// ================================================================================================
+void Register_Net(HSQUIRRELVM vm)
+{
+    Table ns(vm);
+    // --------------------------------------------------------------------------------------------
+    ns.Bind(_SC("WebSocketClient"),
+        Class< WebSocketClient, NoCopy< WebSocketClient > >(ns.GetVM(), SqWebSocketClient::Str)
+        // Constructors
+        .Ctor()
+        .Ctor< StackStrF &, uint16_t, StackStrF & >()
+        .Ctor< StackStrF &, uint16_t, StackStrF &, bool >()
+        .Ctor< StackStrF &, uint16_t, StackStrF &, bool, StackStrF & >()
+        .Ctor< StackStrF &, uint16_t, StackStrF &, bool, StackStrF &, StackStrF & >()
+        // Meta-methods
+        .SquirrelFunc(_SC("_typename"), &SqWebSocketClient::Fn)
+        // Properties
+        .Prop(_SC("Tag"), &WebSocketClient::GetTag, &WebSocketClient::SetTag)
+        .Prop(_SC("Data"), &WebSocketClient::GetData, &WebSocketClient::SetData)
+        .Prop(_SC("Host"), &WebSocketClient::GetHost, &WebSocketClient::SetHost)
+        .Prop(_SC("Port"), &WebSocketClient::GetPort, &WebSocketClient::SetPort)
+        .Prop(_SC("Path"), &WebSocketClient::GetPath, &WebSocketClient::SetPath)
+        .Prop(_SC("Secure"), &WebSocketClient::GetSecure, &WebSocketClient::SetSecure)
+        .Prop(_SC("Origin"), &WebSocketClient::GetOrigin, &WebSocketClient::SetOrigin)
+        .Prop(_SC("Extensions"), &WebSocketClient::GetExtensions, &WebSocketClient::SetExtensions)
+        .Prop(_SC("OnData"), &WebSocketClient::GetOnData, &WebSocketClient::SetOnData)
+        .Prop(_SC("OnClose"), &WebSocketClient::GetOnClose, &WebSocketClient::SetOnClose)
+        .Prop(_SC("Valid"), &WebSocketClient::IsValid)
+        .Prop(_SC("Closing"), &WebSocketClient::IsClosing)
+        // Member Methods
+        .FmtFunc(_SC("SetTag"), &WebSocketClient::ApplyTag)
+        .FmtFunc(_SC("SetData"), &WebSocketClient::ApplyData)
+        .FmtFunc(_SC("SetHost"), &WebSocketClient::ApplyHost)
+        .Func(_SC("SetPort"), &WebSocketClient::ApplyPort)
+        .FmtFunc(_SC("SetPath"), &WebSocketClient::ApplyPath)
+        .Func(_SC("SetSecure"), &WebSocketClient::ApplySecure)
+        .FmtFunc(_SC("SetOrigin"), &WebSocketClient::ApplyOrigin)
+        .FmtFunc(_SC("SetExtensions"), &WebSocketClient::ApplyExtensions)
+        .CbFunc(_SC("BindOnData"), &WebSocketClient::BindOnData)
+        .CbFunc(_SC("BindOnClose"), &WebSocketClient::BindOnClose)
+        .Func(_SC("Connect"), &WebSocketClient::Connect)
+        .Func(_SC("ConnectExt"), &WebSocketClient::ConnectExt)
+        .Func(_SC("SendOpCode"), &WebSocketClient::SendOpCode)
+        .Func(_SC("SendBuffer"), &WebSocketClient::SendBuffer)
+        .FmtFunc(_SC("SendString"), &WebSocketClient::SendString)
+        .Func(_SC("Close"), &WebSocketClient::Close)
+    );
+    // --------------------------------------------------------------------------------------------
+    RootTable(vm).Bind(_SC("SqNet"), ns);
+    // --------------------------------------------------------------------------------------------
+    ConstTable(vm).Enum(_SC("SqWsOpCode"), Enumeration(vm)
+        .Const(_SC("Continuation"),     static_cast< SQInteger >(MG_WEBSOCKET_OPCODE_CONTINUATION))
+        .Const(_SC("Text"),             static_cast< SQInteger >(MG_WEBSOCKET_OPCODE_TEXT))
+        .Const(_SC("Binary"),           static_cast< SQInteger >(MG_WEBSOCKET_OPCODE_BINARY))
+        .Const(_SC("ConnectionClose"),  static_cast< SQInteger >(MG_WEBSOCKET_OPCODE_CONNECTION_CLOSE))
+        .Const(_SC("Ping"),             static_cast< SQInteger >(MG_WEBSOCKET_OPCODE_PING))
+        .Const(_SC("Pong"),             static_cast< SQInteger >(MG_WEBSOCKET_OPCODE_PONG))
+    );
+    // Main thread ID
+    sMainThreadID = std::this_thread::get_id();
+}
+
+} // Namespace:: SqMod

module/Library/Net.hpp

@@ -0,0 +1,760 @@
+#pragma once
+
+// ------------------------------------------------------------------------------------------------
+#include "Library/IO/Buffer.hpp"
+
+// ------------------------------------------------------------------------------------------------
+#include <atomic>
+
+// ------------------------------------------------------------------------------------------------
+#include <sqratFunction.h>
+#include <concurrentqueue.h>
+#include <civetweb.h>
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+/* ------------------------------------------------------------------------------------------------
+ * WebSocket client implementation.
+*/
+struct WebSocketClient : public SqChainedInstances< WebSocketClient >
+{
+    using Base = SqChainedInstances< WebSocketClient >;
+    /* --------------------------------------------------------------------------------------------
+     * WebSocket frame.
+    */
+    struct Frame
+    {
+        /* ----------------------------------------------------------------------------------------
+         * Frame data.
+        */
+        char * mData{nullptr};
+
+        /* ----------------------------------------------------------------------------------------
+         * Frame data capacity.
+        */
+        uint32_t mSize{0};
+
+        /* ----------------------------------------------------------------------------------------
+         * Frame flags.
+        */
+        int mFlags{0};
+
+        /* ----------------------------------------------------------------------------------------
+         * Default constructor.
+        */
+        Frame() = default;
+
+        /* ----------------------------------------------------------------------------------------
+         * Explicit constructor.
+        */
+        Frame(char * data, size_t size, int flags)
+            : mData(nullptr), mSize(static_cast< uint32_t >(size)), mFlags(flags)
+        {
+            // Do we need to allocate a buffer?
+            if (mSize != 0)
+            {
+                // Allocate the memory buffer.
+                mData = new char[mSize];
+                // Copy the data into the buffer we own
+                std::memcpy(mData, data, mSize);
+            }
+        }
+
+        /* ----------------------------------------------------------------------------------------
+         * Copy constructor (disabled).
+        */
+        Frame(const Frame & o) = delete;
+
+        /* ----------------------------------------------------------------------------------------
+         * Move constructor (disabled).
+        */
+        Frame(Frame && o) noexcept = delete;
+
+        /* ----------------------------------------------------------------------------------------
+         * Destructor.
+        */
+        ~Frame()
+        {
+            delete[] mData;
+        }
+
+        /* ----------------------------------------------------------------------------------------
+         * Copy assignment operator (disabled).
+        */
+        Frame & operator = (const Frame & o) = delete;
+
+        /* ----------------------------------------------------------------------------------------
+         * Move assignment operator (disabled).
+        */
+        Frame & operator = (Frame && o) noexcept = delete;
+
+        /* ----------------------------------------------------------------------------------------
+         * Forget about the associated memory buffer.
+        */
+        void ForgetBuffer() noexcept
+        {
+            mData = nullptr;
+            mSize = 0;
+        }
+    };
+
+    /* --------------------------------------------------------------------------------------------
+     * Smart frame pointer.
+    */
+    using FramePtr = std::unique_ptr< Frame >;
+
+    /* --------------------------------------------------------------------------------------------
+     * Queue of frames written from other threads.
+    */
+    using FrameQueue = moodycamel::ConcurrentQueue< FramePtr >;
+
+    /* --------------------------------------------------------------------------------------------
+     * Connection handle.
+    */
+    struct mg_connection * mHandle{nullptr};
+
+    /* --------------------------------------------------------------------------------------------
+     * Queue of frames that must be processed.
+    */
+    FrameQueue mQueue{1024};
+
+    /* --------------------------------------------------------------------------------------------
+     * Callback to invoke when receiving data.
+    */
+    Function mOnData{};
+
+    /* --------------------------------------------------------------------------------------------
+     * Callback to invoke when the socket is shutting down.
+    */
+    Function mOnClose{};
+
+    /* --------------------------------------------------------------------------------------------
+     * User tag associated with this instance.
+    */
+    String mTag{};
+
+    /* --------------------------------------------------------------------------------------------
+     * User data associated with this instance.
+    */
+    LightObj mData{};
+
+    /* --------------------------------------------------------------------------------------------
+     * Server port.
+    */
+    int mPort{0};
+
+    /* --------------------------------------------------------------------------------------------
+     * Make a secure connection to server.
+    */
+    bool mSecure{false};
+
+    /* --------------------------------------------------------------------------------------------
+     * Whether the connection is currently closing.
+    */
+    std::atomic< bool > mClosing{false};
+
+    /* --------------------------------------------------------------------------------------------
+     * Server host to connect to, i.e. "echo.websocket.org" or "192.168.1.1" or "localhost".
+    */
+    String mHost{};
+
+    /* --------------------------------------------------------------------------------------------
+     * Server path you are trying to connect to, i.e. if connection to localhost/app, path should be "/app".
+    */
+    String mPath{};
+
+    /* --------------------------------------------------------------------------------------------
+     * Value of the Origin HTTP header.
+    */
+    String mOrigin{};
+
+    /* --------------------------------------------------------------------------------------------
+     * Extensions to include in the connection.
+    */
+    String mExtensions{};
+
+    /* --------------------------------------------------------------------------------------------
+     * Default constructor.
+    */
+    WebSocketClient()
+        : Base(), mHandle(nullptr), mQueue(1024), mOnData(), mOnClose(), mTag(), mData()
+        , mPort(0), mSecure(false), mClosing(false), mHost(), mPath(), mOrigin(), mExtensions()
+    {
+        ChainInstance(); // Remember this instance
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Explicit constructor.
+    */
+    WebSocketClient(StackStrF & host, uint16_t port, StackStrF & path)
+        : Base(), mHandle(nullptr), mQueue(1024), mOnData(), mOnClose(), mTag(), mData()
+        , mPort(port), mSecure(false), mClosing(false)
+        , mHost(host.mPtr, host.GetSize())
+        , mPath(path.mPtr, path.GetSize())
+        , mOrigin(), mExtensions()
+    {
+        ChainInstance(); // Remember this instance
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Explicit constructor.
+    */
+    WebSocketClient(StackStrF & host, uint16_t port, StackStrF & path, bool secure)
+        : Base(), mHandle(nullptr), mQueue(1024), mOnData(), mOnClose(), mTag(), mData()
+        , mPort(port), mSecure(secure), mClosing(false)
+        , mHost(host.mPtr, host.GetSize())
+        , mPath(path.mPtr, path.GetSize())
+        , mOrigin(), mExtensions()
+    {
+        ChainInstance(); // Remember this instance
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Explicit constructor.
+    */
+    WebSocketClient(StackStrF & host, uint16_t port, StackStrF & path, bool secure, StackStrF & origin)
+        : Base(), mHandle(nullptr), mQueue(1024), mOnData(), mOnClose(), mTag(), mData()
+        , mPort(port), mSecure(secure), mClosing(false)
+        , mHost(host.mPtr, host.GetSize())
+        , mPath(path.mPtr, path.GetSize())
+        , mOrigin(origin.mPtr, origin.GetSize())
+        , mExtensions()
+    {
+        ChainInstance(); // Remember this instance
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Explicit constructor.
+    */
+    WebSocketClient(StackStrF & host, uint16_t port, StackStrF & path, bool secure, StackStrF & origin, StackStrF & ext)
+        : Base(), mHandle(nullptr), mQueue(1024), mOnData(), mOnClose(), mTag(), mData()
+        , mPort(port), mSecure(secure), mClosing(false)
+        , mHost(host.mPtr, host.GetSize())
+        , mPath(path.mPtr, path.GetSize())
+        , mOrigin(origin.mPtr, origin.GetSize())
+        , mExtensions(ext.mPtr, ext.GetSize())
+    {
+        ChainInstance(); // Remember this instance
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Copy constructor.
+    */
+    WebSocketClient(const WebSocketClient &) = delete;
+
+    /* --------------------------------------------------------------------------------------------
+     * Move constructor.
+    */
+    WebSocketClient(WebSocketClient &&) = delete;
+
+    /* --------------------------------------------------------------------------------------------
+     * Destructor. Closes the connection.
+    */
+    ~WebSocketClient()
+    {
+        // Is there a connection left to close?
+        if (mHandle != nullptr)
+        {
+            Close();
+        }
+        // Forget about this instance
+        UnchainInstance();
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Copy assignment operator.
+    */
+    WebSocketClient & operator = (const WebSocketClient &) = delete;
+
+    /* --------------------------------------------------------------------------------------------
+     * Move assignment operator.
+    */
+    WebSocketClient & operator = (WebSocketClient &&) = delete;
+
+    /* --------------------------------------------------------------------------------------------
+     * Return whether the associated connection handle is valid.
+    */
+    SQMOD_NODISCARD bool IsValid() const
+    {
+        return mHandle != nullptr;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Return whether the associated connection is closing.
+     * This is only valid inside the OnClose callback.
+    */
+    SQMOD_NODISCARD bool IsClosing() const
+    {
+        return mClosing.load();
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the associated user tag.
+    */
+    SQMOD_NODISCARD const String & GetTag() const
+    {
+        return mTag;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Modify the associated user tag.
+    */
+    void SetTag(StackStrF & tag)
+    {
+        if (tag.mLen > 0)
+        {
+            mTag.assign(tag.mPtr, static_cast< size_t >(tag.mLen));
+        }
+        else
+        {
+            mTag.clear();
+        }
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Modify the associated user tag.
+    */
+    WebSocketClient & ApplyTag(StackStrF & tag)
+    {
+        SetTag(tag);
+        return *this;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the associated user data.
+    */
+    SQMOD_NODISCARD LightObj & GetData()
+    {
+        return mData;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Modify the associated user data.
+    */
+    void SetData(LightObj & data)
+    {
+        mData = data;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Modify the associated user data.
+    */
+    WebSocketClient & ApplyData(LightObj & data)
+    {
+        mData = data;
+        return *this;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Make sure a connection exists.
+    */
+    void Validate() const
+    {
+        if (mHandle == nullptr)
+        {
+            STHROWF("No connection was made to server ({}:{}{})", mHost, mPort, mPath);
+        }
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Return a valid connection.
+    */
+    SQMOD_NODISCARD struct mg_connection * Valid() const
+    {
+        Validate();
+        return mHandle;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Make sure a connection does not exist.
+    */
+    void Invalid() const
+    {
+        if (mHandle != nullptr)
+        {
+            STHROWF("Connection already made to server ({}:{}{})", mHost, mPort, mPath);
+        }
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the associated server host.
+    */
+    SQMOD_NODISCARD const String & GetHost() const
+    {
+        return mHost;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Modify the associated server host.
+    */
+    void SetHost(StackStrF & host)
+    {
+        Invalid();
+        // Is there a valid host?
+        if (host.mLen > 0)
+        {
+            mHost.assign(host.mPtr, static_cast< size_t >(host.mLen));
+        }
+        else
+        {
+            mHost.clear();
+        }
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Modify the associated server host.
+    */
+    WebSocketClient & ApplyHost(StackStrF & host)
+    {
+        SetHost(host);
+        return *this;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the associated server path.
+    */
+    SQMOD_NODISCARD const String & GetPath() const
+    {
+        return mPath;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Modify the associated server path.
+    */
+    void SetPath(StackStrF & path)
+    {
+        Invalid();
+        // Is there a valid path?
+        if (path.mLen > 0)
+        {
+            mPath.assign(path.mPtr, static_cast< size_t >(path.mLen));
+        }
+        else
+        {
+            mPath.clear();
+        }
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Modify the associated server path.
+    */
+    WebSocketClient & ApplyPath(StackStrF & path)
+    {
+        SetPath(path);
+        return *this;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the associated origin value.
+    */
+    SQMOD_NODISCARD const String & GetOrigin() const
+    {
+        return mOrigin;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Modify the associated origin value.
+    */
+    void SetOrigin(StackStrF & origin)
+    {
+        Invalid();
+        // Is there a valid origin?
+        if (origin.mLen > 0)
+        {
+            mOrigin.assign(origin.mPtr, static_cast< size_t >(origin.mLen));
+        }
+        else
+        {
+            mOrigin.clear();
+        }
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Modify the associated origin value.
+    */
+    WebSocketClient & ApplyOrigin(StackStrF & origin)
+    {
+        SetOrigin(origin);
+        return *this;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the associated connection extensions.
+    */
+    SQMOD_NODISCARD const String & GetExtensions() const
+    {
+        return mExtensions;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Modify the associated connection extensions.
+    */
+    void SetExtensions(StackStrF & ext)
+    {
+        Invalid();
+        // Is there a valid extension?
+        if (ext.mLen > 0)
+        {
+            mExtensions.assign(ext.mPtr, static_cast< size_t >(ext.mLen));
+        }
+        else
+        {
+            mExtensions.clear();
+        }
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Modify the associated connection extensions.
+    */
+    WebSocketClient & ApplyExtensions(StackStrF & ext)
+    {
+        SetExtensions(ext);
+        return *this;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the associated server port number.
+    */
+    SQMOD_NODISCARD int GetPort() const
+    {
+        return mPort;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Modify the associated server port number.
+    */
+    void SetPort(int port)
+    {
+        Invalid();
+        // Is there a valid port?
+        if (port < 0 || port > 65535)
+        {
+            STHROWF("Invalid port number: {0} < 0 || {0} > 65535", port);
+        }
+        else
+        {
+            mPort = port;
+        }
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Modify the associated server port number.
+    */
+    WebSocketClient & ApplyPort(int port)
+    {
+        SetPort(port);
+        return *this;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the associated SSL status.
+    */
+    SQMOD_NODISCARD bool GetSecure() const
+    {
+        return mSecure;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Modify the associated SSL status.
+    */
+    void SetSecure(bool secure)
+    {
+        Invalid();
+        mSecure = secure;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Modify the associated SSL status.
+    */
+    WebSocketClient & ApplySecure(bool secure)
+    {
+        SetSecure(secure);
+        return *this;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the associated data callback.
+    */
+    SQMOD_NODISCARD Function & GetOnData()
+    {
+        return mOnData;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Modify the associated data callback.
+    */
+    void SetOnData(Function & cb)
+    {
+        mOnData = cb;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Modify the associated data callback.
+    */
+    WebSocketClient & BindOnData(Function & cb)
+    {
+        mOnData = cb;
+        return *this;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the associated close callback.
+    */
+    SQMOD_NODISCARD Function & GetOnClose()
+    {
+        return mOnClose;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Modify the associated close callback.
+    */
+    void SetOnClose(Function & cb)
+    {
+        mOnClose = cb;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Modify the associated close callback.
+    */
+    WebSocketClient & BindOnClose(Function & cb)
+    {
+        mOnClose = cb;
+        return *this;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Connect to a web-socket as a client.
+    */
+    WebSocketClient & Connect();
+
+    /* --------------------------------------------------------------------------------------------
+     * Connect to a web-socket as a client with specific extensions.
+    */
+    WebSocketClient & ConnectExt();
+
+    /* --------------------------------------------------------------------------------------------
+     * Close client connection.
+    */
+    void Close()
+    {
+        mg_close_connection(Valid());
+        // Prevent further use
+        mHandle = nullptr;
+        // Process pending events
+        Process(true);
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Sends the contents of the given buffer through the socket as a single frame.
+    */
+    SQMOD_NODISCARD SQInteger SendOpCode(SqBuffer & buf, SQInteger opcode)
+    {
+        return mg_websocket_client_write(Valid(), static_cast< int >(opcode), nullptr, 0);
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Sends the contents of the given buffer through the socket as a single frame.
+    */
+    SQMOD_NODISCARD SQInteger SendBuffer(SqBuffer & buf, SQInteger opcode)
+    {
+        return mg_websocket_client_write(Valid(), static_cast< int >(opcode), buf.Valid().Data(), buf.Valid().Position());
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Sends the contents of the given string through the socket as a single frame.
+    */
+    SQMOD_NODISCARD SQInteger SendString(SQInteger opcode, StackStrF & str)
+    {
+        return mg_websocket_client_write(Valid(), static_cast< int >(opcode), str.mPtr, static_cast< size_t >(str.mLen));
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Process received data.
+    */
+    void Process(bool force = false)
+    {
+        // Is there a valid connection?
+        if (mHandle == nullptr && !force)
+        {
+            return; // No point in going forward
+        }
+        FramePtr frame;
+        // See if connection is closing
+        const bool closing = mClosing.load();
+        // Is the connection closing?
+        if (closing)
+        {
+            mHandle = nullptr; // Prevent further use
+        }
+        // Retrieve each frame individually and process it
+        for (size_t count = mQueue.size_approx(), n = 0; n <= count; ++n)
+        {
+            // Try to get a frame from the queue
+            if (mQueue.try_dequeue(frame) && !mOnData.IsNull())
+            {
+                // Obtain a buffer from the frame
+                Buffer b(frame->mData, frame->mSize, frame->mSize, Buffer::OwnIt{});
+                // Backup the frame size before forgetting about it
+                const SQInteger size = static_cast< SQInteger >(frame->mSize);
+                // Take ownership of the memory
+                frame->ForgetBuffer();
+                // Transform the buffer into a script object
+                LightObj obj(SqTypeIdentity< SqBuffer >{}, SqVM(), std::move(b));
+                // Forward the event to the callback
+                mOnData.Execute(obj, size, frame->mFlags);
+            }
+        }
+        // Is the server closing the connection?
+        if (closing && !mOnClose.IsNull())
+        {
+            mOnClose.Execute(); // Let the user know
+        }
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Used internally to release script resources, if any. The VM is about to be closed.
+     * If you don't close the connection yourself don't care about what is received after this.
+    */
+    void Terminate()
+    {
+        // Process pending data
+        Process(true);
+        // Release callbacks
+        mOnData.Release();
+        mOnClose.Release();
+        // Release user data
+        mData.Release();
+    }
+
+protected:
+
+    /* --------------------------------------------------------------------------------------------
+     * Callback for handling data received from the server
+    */
+    int DataHandler(int flags, char * data, size_t data_len) noexcept;
+
+    /* --------------------------------------------------------------------------------------------
+     * Callback for handling a close message received from the server.
+    */
+    void CloseHandler() noexcept;
+
+    /* --------------------------------------------------------------------------------------------
+     * Proxy for DataHandler()
+    */
+    static int DataHandler_(struct mg_connection * SQ_UNUSED_ARG(c), int f, char * d, size_t n, void * u) noexcept
+    {
+        return reinterpret_cast< WebSocketClient * >(u)->DataHandler(f, d, n);
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Proxy for CloseHandler();
+    */
+    static void CloseHandler_(const struct mg_connection * SQ_UNUSED_ARG(c), void * u) noexcept
+    {
+        reinterpret_cast< WebSocketClient * >(u)->CloseHandler();
+    }
+};
+
+
+} // Namespace:: SqMod

module/Library/Numeric.cpp

@@ -5,14 +5,12 @@
 namespace SqMod {
 
 // ------------------------------------------------------------------------------------------------
-extern void Register_LongInt(HSQUIRRELVM vm);
 extern void Register_Math(HSQUIRRELVM vm);
 extern void Register_Random(HSQUIRRELVM vm);
 
 // ================================================================================================
 void Register_Numeric(HSQUIRRELVM vm)
 {
-    Register_LongInt(vm);
     Register_Math(vm);
     Register_Random(vm);
 }

module/Library/Numeric/Long.cpp

@@ -1,376 +0,0 @@
-// ------------------------------------------------------------------------------------------------
-#include "Library/Numeric/Long.hpp"
-#include "Library/Numeric/Random.hpp"
-#include "Base/DynArg.hpp"
-
-// ------------------------------------------------------------------------------------------------
-#include <cstdio>
-#include <cstdlib>
-
-// ------------------------------------------------------------------------------------------------
-namespace SqMod {
-
-// ------------------------------------------------------------------------------------------------
-SQMOD_DECL_TYPENAME(TypenameS, _SC("SLongInt"))
-SQMOD_DECL_TYPENAME(TypenameU, _SC("ULongInt"))
-
-// ------------------------------------------------------------------------------------------------
-LongInt< signed long long >::LongInt(const SQChar * text)
-    : m_Data(0), m_Text()
-{
-    m_Data = std::strtoll(text, nullptr, 10);
-}
-
-// ------------------------------------------------------------------------------------------------
-LongInt< signed long long >::LongInt(const SQChar * text, uint32_t base)
-    : m_Data(0), m_Text()
-{
-    m_Data = std::strtoll(text, nullptr, base);
-}
-
-// ------------------------------------------------------------------------------------------------
-LongInt< signed long long > & LongInt< signed long long >::operator = (const SQChar * text)
-{
-    m_Data = std::strtoll(text, nullptr, 10);
-    return *this;
-}
-
-// ------------------------------------------------------------------------------------------------
-const SQChar * LongInt< signed long long >::ToString()
-{
-    if (std::snprintf(m_Text, sizeof(m_Text), "%llu", m_Data) < 0)
-    {
-        m_Text[0] = 0;
-    }
-
-    return m_Text;
-}
-
-// ------------------------------------------------------------------------------------------------
-void LongInt< signed long long >::Random()
-{
-    m_Data = GetRandomInt64();
-}
-
-// ------------------------------------------------------------------------------------------------
-void LongInt< signed long long >::Random(Type n)
-{
-    m_Data = GetRandomInt64(n);
-}
-
-// ------------------------------------------------------------------------------------------------
-void LongInt< signed long long >::Random(Type m, Type n)
-{
-    m_Data = GetRandomInt64(m, n);
-}
-
-// ------------------------------------------------------------------------------------------------
-LongInt< unsigned long long >::LongInt(const SQChar * text)
-    : m_Data(0), m_Text()
-{
-    m_Data = std::strtoull(text, nullptr, 10);
-}
-
-// ------------------------------------------------------------------------------------------------
-LongInt< unsigned long long >::LongInt(const SQChar * text, uint32_t base)
-    : m_Data(0), m_Text()
-{
-    m_Data = std::strtoull(text, nullptr, base);
-}
-
-// ------------------------------------------------------------------------------------------------
-LongInt< unsigned long long > & LongInt< unsigned long long >::operator = (const SQChar * text)
-{
-    m_Data = std::strtoull(text, nullptr, 10);
-    return *this;
-}
-
-// ------------------------------------------------------------------------------------------------
-const SQChar * LongInt< unsigned long long >::ToString()
-{
-    if (std::snprintf(m_Text, sizeof(m_Text), "%llu", m_Data) < 0)
-    {
-        m_Text[0] = 0;
-    }
-
-    return m_Text;
-}
-
-// ------------------------------------------------------------------------------------------------
-void LongInt< unsigned long long >::Random()
-{
-    m_Data = GetRandomUint64();
-}
-
-// ------------------------------------------------------------------------------------------------
-void LongInt< unsigned long long >::Random(Type n)
-{
-    m_Data = GetRandomUint64(n);
-}
-
-// ------------------------------------------------------------------------------------------------
-void LongInt< unsigned long long >::Random(Type m, Type n)
-{
-    m_Data = GetRandomUint64(m, n);
-}
-
-// ------------------------------------------------------------------------------------------------
-signed long long PopStackSLong(HSQUIRRELVM vm, SQInteger idx)
-{
-    // Identify which type must be extracted
-    switch (sq_gettype(vm, idx))
-    {
-        case OT_INTEGER:
-        {
-            SQInteger val;
-            sq_getinteger(vm, idx, &val);
-            return static_cast< signed long long >(val);
-        }
-        case OT_FLOAT:
-        {
-            SQFloat val;
-            sq_getfloat(vm, idx, &val);
-            return ConvTo< signed long long >::From(val);
-        }
-        case OT_BOOL:
-        {
-            SQBool val;
-            sq_getbool(vm, idx, &val);
-            return static_cast< signed long long >(val);
-        }
-        case OT_STRING:
-        {
-            const SQChar * val = nullptr;
-            // Attempt to retrieve and convert the string
-            if (SQ_SUCCEEDED(sq_getstring(vm, idx, &val)) && val != nullptr && *val != '\0')
-            {
-                return std::strtoll(val, nullptr, 10);
-            }
-        } break;
-        case OT_ARRAY:
-        case OT_TABLE:
-        case OT_CLASS:
-        case OT_USERDATA:
-        {
-            return static_cast< signed long long >(sq_getsize(vm, idx));
-        }
-        case OT_INSTANCE:
-        {
-            // Attempt to treat the value as a signed long instance
-            try
-            {
-                return Var< const SLongInt & >(vm, idx).value.GetNum();
-            }
-            catch (...)
-            {
-                // Just ignore it...
-            }
-            // Attempt to treat the value as a unsigned long instance
-            try
-            {
-                return ConvTo< signed long long >::From(Var< const ULongInt & >(vm, idx).value.GetNum());
-            }
-            catch (...)
-            {
-                // Just ignore it...
-            }
-            // Attempt to get the size of the instance as a fall back
-            return static_cast< signed long long >(sq_getsize(vm, idx));
-        }
-        default: break;
-    }
-    // Default to 0
-    return 0;
-}
-
-// ------------------------------------------------------------------------------------------------
-unsigned long long PopStackULong(HSQUIRRELVM vm, SQInteger idx)
-{
-    // Identify which type must be extracted
-    switch (sq_gettype(vm, idx))
-    {
-        case OT_INTEGER:
-        {
-            SQInteger val;
-            sq_getinteger(vm, idx, &val);
-            return ConvTo< unsigned long long >::From(val);
-        }
-        case OT_FLOAT:
-        {
-            SQFloat val;
-            sq_getfloat(vm, idx, &val);
-            return ConvTo< unsigned long long >::From(val);
-        }
-        case OT_BOOL:
-        {
-            SQBool val;
-            sq_getbool(vm, idx, &val);
-            return ConvTo< unsigned long long >::From(val);
-        }
-        case OT_STRING:
-        {
-            const SQChar * val = nullptr;
-            // Attempt to retrieve and convert the string
-            if (SQ_SUCCEEDED(sq_getstring(vm, idx, &val)) && val != nullptr && *val != '\0')
-            {
-                return std::strtoull(val, nullptr, 10);
-            }
-        } break;
-        case OT_ARRAY:
-        case OT_TABLE:
-        case OT_CLASS:
-        case OT_USERDATA:
-        {
-            return ConvTo< unsigned long long >::From(sq_getsize(vm, idx));
-        }
-        case OT_INSTANCE:
-        {
-            // Attempt to treat the value as a signed long instance
-            try
-            {
-                return ConvTo< unsigned long long >::From(Var< const SLongInt & >(vm, idx).value.GetNum());
-            }
-            catch (...)
-            {
-                // Just ignore it...
-            }
-            // Attempt to treat the value as a unsigned long instance
-            try
-            {
-                return Var< const ULongInt & >(vm, idx).value.GetNum();
-            }
-            catch (...)
-            {
-                // Just ignore it...
-            }
-            // Attempt to get the size of the instance as a fall back
-            return ConvTo< unsigned long long >::From(sq_getsize(vm, idx));
-        }
-        default: break;
-    }
-    // Default to 0
-    return 0;
-}
-
-// ------------------------------------------------------------------------------------------------
-const SLongInt & GetSLongInt()
-{
-    static SLongInt l;
-    l.SetNum(0);
-    return l;
-}
-
-const SLongInt & GetSLongInt(signed long long n)
-{
-    static SLongInt l;
-    l.SetNum(n);
-    return l;
-}
-
-const SLongInt & GetSLongInt(const SQChar * s)
-{
-    static SLongInt l;
-    l = s;
-    return l;
-}
-
-const ULongInt & GetULongInt()
-{
-    static ULongInt l;
-    l.SetNum(0);
-    return l;
-}
-
-const ULongInt & GetULongInt(unsigned long long n)
-{
-    static ULongInt l;
-    l.SetNum(n);
-    return l;
-}
-
-const ULongInt & GetULongInt(const SQChar * s)
-{
-    static ULongInt l;
-    l = s;
-    return l;
-}
-
-// ================================================================================================
-void Register_LongInt(HSQUIRRELVM vm)
-{
-    RootTable(vm).Bind(TypenameS::Str,
-        Class< SLongInt >(vm, TypenameS::Str)
-        // Constructors
-        .Ctor()
-        .Ctor< SLongInt::Type >()
-        .template Ctor< const char *, SQInteger >()
-        // Properties
-        .Prop(_SC("Str"), &SLongInt::GetCStr, &SLongInt::SetStr)
-        .Prop(_SC("Num"), &SLongInt::GetSNum, &SLongInt::SetNum)
-        // Core Meta-methods
-        .SquirrelFunc(_SC("cmp"), &SqDynArgFwd< SqDynArgCmpFn< SLongInt >, SQInteger, SQFloat, bool, std::nullptr_t, const SQChar *, SLongInt, ULongInt >)
-        .SquirrelFunc(_SC("_typename"), &TypenameS::Fn)
-        .Func(_SC("_tostring"), &SLongInt::ToString)
-        // Core Functions
-        .Func(_SC("tointeger"), &SLongInt::ToSqInteger)
-        .Func(_SC("tofloat"), &SLongInt::ToSqFloat)
-        .Func(_SC("tostring"), &SLongInt::ToSqString)
-        .Func(_SC("tobool"), &SLongInt::ToSqBool)
-        .Func(_SC("tochar"), &SLongInt::ToSqChar)
-        // Meta-methods
-        .SquirrelFunc(_SC("_add"), &SqDynArgFwd< SqDynArgAddFn< SLongInt >, SQInteger, SQFloat, bool, std::nullptr_t, const SQChar *, SLongInt, ULongInt >)
-        .SquirrelFunc(_SC("_sub"), &SqDynArgFwd< SqDynArgSubFn< SLongInt >, SQInteger, SQFloat, bool, std::nullptr_t, const SQChar *, SLongInt, ULongInt >)
-        .SquirrelFunc(_SC("_mul"), &SqDynArgFwd< SqDynArgMulFn< SLongInt >, SQInteger, SQFloat, bool, std::nullptr_t, const SQChar *, SLongInt, ULongInt >)
-        .SquirrelFunc(_SC("_div"), &SqDynArgFwd< SqDynArgDivFn< SLongInt >, SQInteger, SQFloat, bool, std::nullptr_t, const SQChar *, SLongInt, ULongInt >)
-        .SquirrelFunc(_SC("_modulo"), &SqDynArgFwd< SqDynArgModFn< SLongInt >, SQInteger, SQFloat, bool, std::nullptr_t, const SQChar *, SLongInt, ULongInt >)
-        .Func< SLongInt (SLongInt::*)(void) const >(_SC("_unm"), &SLongInt::operator -)
-        // Functions
-        .Func(_SC("GetStr"), &SLongInt::GetCStr)
-        .Func(_SC("SetStr"), &SLongInt::SetStr)
-        .Func(_SC("GetNum"), &SLongInt::GetSNum)
-        .Func(_SC("SetNum"), &SLongInt::SetNum)
-        // Overloads
-        .Overload< void (SLongInt::*)(void) >(_SC("Random"), &SLongInt::Random)
-        .Overload< void (SLongInt::*)(SLongInt::Type) >(_SC("Random"), &SLongInt::Random)
-        .Overload< void (SLongInt::*)(SLongInt::Type, SLongInt::Type) >(_SC("Random"), &SLongInt::Random)
-    );
-
-    RootTable(vm).Bind(TypenameU::Str,
-        Class< ULongInt >(vm, TypenameU::Str)
-        // Constructors
-        .Ctor()
-        .Ctor< ULongInt::Type >()
-        .Ctor< const char *, SQInteger >()
-        // Properties
-        .Prop(_SC("Str"), &ULongInt::GetCStr, &ULongInt::SetStr)
-        .Prop(_SC("Num"), &ULongInt::GetSNum, &ULongInt::SetNum)
-        // Core Meta-methods
-        .SquirrelFunc(_SC("cmp"), &SqDynArgFwd< SqDynArgCmpFn< ULongInt >, SQInteger, SQFloat, bool, std::nullptr_t, const SQChar *, ULongInt, SLongInt >)
-        .SquirrelFunc(_SC("_typename"), &TypenameU::Fn)
-        .Func(_SC("_tostring"), &ULongInt::ToString)
-        // Core Functions
-        .Func(_SC("tointeger"), &ULongInt::ToSqInteger)
-        .Func(_SC("tofloat"), &ULongInt::ToSqFloat)
-        .Func(_SC("tostring"), &ULongInt::ToSqString)
-        .Func(_SC("tobool"), &ULongInt::ToSqBool)
-        .Func(_SC("tochar"), &ULongInt::ToSqChar)
-        // Meta-methods
-        .SquirrelFunc(_SC("_add"), &SqDynArgFwd< SqDynArgAddFn< ULongInt >, SQInteger, SQFloat, bool, std::nullptr_t, const SQChar *, ULongInt, SLongInt >)
-        .SquirrelFunc(_SC("_sub"), &SqDynArgFwd< SqDynArgSubFn< ULongInt >, SQInteger, SQFloat, bool, std::nullptr_t, const SQChar *, ULongInt, SLongInt >)
-        .SquirrelFunc(_SC("_mul"), &SqDynArgFwd< SqDynArgMulFn< ULongInt >, SQInteger, SQFloat, bool, std::nullptr_t, const SQChar *, ULongInt, SLongInt >)
-        .SquirrelFunc(_SC("_div"), &SqDynArgFwd< SqDynArgDivFn< ULongInt >, SQInteger, SQFloat, bool, std::nullptr_t, const SQChar *, ULongInt, SLongInt >)
-        .SquirrelFunc(_SC("_modulo"), &SqDynArgFwd< SqDynArgModFn< ULongInt >, SQInteger, SQFloat, bool, std::nullptr_t, const SQChar *, ULongInt, SLongInt >)
-        .Func< ULongInt (ULongInt::*)(void) const >(_SC("_unm"), &ULongInt::operator -)
-        // Functions
-        .Func(_SC("GetStr"), &ULongInt::GetCStr)
-        .Func(_SC("SetStr"), &ULongInt::SetStr)
-        .Func(_SC("GetNum"), &ULongInt::GetSNum)
-        .Func(_SC("SetNum"), &ULongInt::SetNum)
-        // Overloads
-        .Overload< void (ULongInt::*)(void) >(_SC("Random"), &ULongInt::Random)
-        .Overload< void (ULongInt::*)(ULongInt::Type) >(_SC("Random"), &ULongInt::Random)
-        .Overload< void (ULongInt::*)(ULongInt::Type, ULongInt::Type) >(_SC("Random"), &ULongInt::Random)
-    );
-}
-
-} // Namespace:: SqMod

module/Library/Numeric/Math.cpp

@@ -1,6 +1,5 @@
 // ------------------------------------------------------------------------------------------------
 #include "Library/Numeric/Math.hpp"
-#include "Library/Numeric/Long.hpp"
 
 // ------------------------------------------------------------------------------------------------
 #include <cmath>
@@ -66,7 +65,7 @@ static SQInteger SqRemainder(HSQUIRRELVM vm)
     // Are we both arguments integers?
     else if ((sq_gettype(vm, 2) == OT_INTEGER) && sq_gettype(vm, 3) == OT_INTEGER)
     { // NOLINT(bugprone-branch-clone)
-        sq_pushinteger(vm, std::remainder(PopStackInteger(vm, 2), PopStackInteger(vm, 3)));
+        sq_pushinteger(vm, static_cast< SQInteger >(std::remainder(PopStackInteger(vm, 2), PopStackInteger(vm, 3))));
     }
     // Is the first argument float?
     else if ((sq_gettype(vm, 2) == OT_FLOAT))
@@ -76,7 +75,7 @@ static SQInteger SqRemainder(HSQUIRRELVM vm)
     // Is the first argument integer?
     else if ((sq_gettype(vm, 2) == OT_INTEGER))
     {
-        sq_pushinteger(vm, std::remainder(PopStackInteger(vm, 2), PopStackInteger(vm, 3)));
+        sq_pushinteger(vm, static_cast< SQInteger >(std::remainder(PopStackInteger(vm, 2), PopStackInteger(vm, 3))));
     }
     // Default to both arguments as float so we don't loos precision from the float one
     else
@@ -184,18 +183,7 @@ static SQInteger SqNanL(HSQUIRRELVM vm)
         return val.mRes; // Propagate the error!
     }
     // Fetch the arguments from the stack and perform the requested operation
-    try
-    {
-        Var< SLongInt * >::push(vm, new SLongInt(std::nanl(val.mPtr)));
-    }
-    catch (const std::exception & e)
-    {
-        return sq_throwerror(vm, e.what());
-    }
-    catch (...)
-    {
-        return sq_throwerror(vm, _SC("Failed to create a long integer instance"));
-    }
+    sq_pushinteger(vm, static_cast< SQInteger >(std::nanl(val.mPtr)));
     // Specify that we have a value on the stack
     return 1;
 }
@@ -659,11 +647,11 @@ static SQInteger SqRoundI(HSQUIRRELVM vm)
     // Fetch the arguments from the stack and perform the requested operation
     if (sq_gettype(vm, 2) == OT_FLOAT)
     {
-        sq_pushinteger(vm, ConvTo< SQInteger >::From(std::llround(PopStackFloat(vm, 2))));
+        sq_pushinteger(vm, static_cast< SQInteger >(std::llround(PopStackFloat(vm, 2))));
     }
     else
     {
-        sq_pushinteger(vm, ConvTo< SQInteger >::From(std::llround(PopStackInteger(vm, 2))));
+        sq_pushinteger(vm, static_cast< SQInteger >(std::llround(PopStackInteger(vm, 2))));
     }
     // Specify that we have a value on the stack
     return 1;
@@ -678,24 +666,13 @@ static SQInteger SqRoundL(HSQUIRRELVM vm)
         return sq_throwerror(vm, "Wrong number of arguments");
     }
     // Fetch the arguments from the stack and perform the requested operation
-    try
+    if (sq_gettype(vm, 2) == OT_FLOAT)
     {
-        if (sq_gettype(vm, 2) == OT_FLOAT)
-        {
-            Var< SLongInt * >::push(vm, new SLongInt(std::llround(PopStackFloat(vm, 2))));
-        }
-        else
-        {
-            Var< SLongInt * >::push(vm, new SLongInt(std::llround(PopStackInteger(vm, 2))));
-        }
+        sq_pushinteger(vm, static_cast< SQInteger >(std::llround(PopStackFloat(vm, 2))));
     }
-    catch (const std::exception & e)
+    else
     {
-        return sq_throwerror(vm, e.what());
-    }
-    catch (...)
-    {
-        return sq_throwerror(vm, _SC("Failed to create a long integer instance"));
+        sq_pushinteger(vm, static_cast< SQInteger >(std::llround(PopStackInteger(vm, 2))));
     }
     // Specify that we have a value on the stack
     return 1;
@@ -760,7 +737,7 @@ static SQInteger SqLdexp(HSQUIRRELVM vm)
         return sq_throwerror(vm, "Wrong number of arguments");
     }
     // Fetch the arguments from the stack and perform the requested operation
-    sq_pushfloat(vm, std::ldexp(PopStackFloat(vm, 2), PopStackInteger(vm, 3)));
+    sq_pushfloat(vm, std::ldexp(PopStackFloat(vm, 2), static_cast< int >(PopStackInteger(vm, 3))));
     // Specify that we have a value on the stack
     return 1;
 }
@@ -811,9 +788,9 @@ static SQInteger SqScalbn(HSQUIRRELVM vm)
     }
     // Fetch the arguments from the stack and perform the requested operation
 #ifdef _SQ64
-    sq_pushfloat(vm, std::scalbln(PopStackFloat(vm, 2), PopStackInteger(vm, 3)));
+    sq_pushfloat(vm, std::scalbln(PopStackFloat(vm, 2), static_cast< int >(PopStackInteger(vm, 3))));
 #else
-    sq_pushfloat(vm, std::scalbn(PopStackFloat(vm, 2), PopStackInteger(vm, 3)));
+    sq_pushfloat(vm, std::scalbn(PopStackFloat(vm, 2), static_cast< int >(PopStackInteger(vm, 3))));
 #endif // _SQ64
     // Specify that we have a value on the stack
     return 1;
@@ -1066,7 +1043,7 @@ static SQInteger SqDigits1(HSQUIRRELVM vm)
         return sq_throwerror(vm, "Wrong number of arguments");
     }
     // Fetch the integer value from the stack
-    int64_t n = std::llabs(PopStackSLong(vm, 2));
+    int64_t n = std::llabs(PopStackInteger(vm, 2));
     // Start with 0 digits
     uint8_t d = 0;
     // Identify the number of digits
@@ -1090,7 +1067,7 @@ static SQInteger SqDigits0(HSQUIRRELVM vm)
         return sq_throwerror(vm, "Wrong number of arguments");
     }
     // Fetch the integer value from the stack
-    int64_t n = std::llabs(PopStackSLong(vm, 2));
+    int64_t n = std::llabs(PopStackInteger(vm, 2));
     // Start with 0 digits
     uint8_t d = 0;
     // Identify the number of digits

module/Library/Numeric/Math.hpp

@@ -1,7 +1,7 @@
 #pragma once
 
 // ------------------------------------------------------------------------------------------------
-#include "Core/Common.hpp"
+#include "Core/Utility.hpp"
 
 // ------------------------------------------------------------------------------------------------
 namespace SqMod {

module/Library/SQLite.cpp

@@ -424,21 +424,21 @@ int32_t ReleaseMemory(int32_t bytes)
 }
 
 // ------------------------------------------------------------------------------------------------
-Object GetMemoryUsage()
+SQInteger GetMemoryUsage()
 {
     // Obtain the initial stack size
     const StackGuard sg;
     // Push a long integer instance with the requested value on the stack
-    return Object(new SLongInt(sqlite3_memory_used()));
+    return sqlite3_memory_used();
 }
 
 // ------------------------------------------------------------------------------------------------
-Object GetMemoryHighwaterMark(bool reset)
+SQInteger GetMemoryHighwaterMark(bool reset)
 {
     // Obtain the initial stack size
     const StackGuard sg;
     // Push a long integer instance with the requested value on the stack
-    return Object(new SLongInt(sqlite3_memory_highwater(reset)));
+    return sqlite3_memory_highwater(reset);
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -451,11 +451,15 @@ LightObj EscapeString(StackStrF & str)
     }
     // Allocate a memory buffer
     std::vector< SQChar > b;
-    b.reserve(static_cast< size_t >(str.mLen));
+    // Allocate extra space to make sure there's room for a null terminator since we need it
+    // This is a f* up from SQLite devs not returning the number of written characters from snprintf
+    // So we can figure out if we actually had room for the null terminator or not
+    b.reserve(static_cast< size_t >(str.mLen * 2 + 1));
     // Attempt to escape the specified string
     sqlite3_snprintf(static_cast<int>(b.capacity()), b.data(), "%q", str.mPtr);
     // Return the resulted string
-    return LightObj(b.data());
+    LightObj o(b.data(), -1);
+    return o;
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -477,7 +481,8 @@ LightObj EscapeStringEx(SQChar spec, StackStrF & str)
     fs[1] = spec;
     // Allocate a memory buffer
     std::vector< SQChar > b;
-    b.reserve(static_cast< size_t >(str.mLen));
+    // Allocate extra space to make sure there's room for a null terminator since we need it (see above)
+    b.reserve(static_cast< size_t >(str.mLen * 2 + 1));
     // Attempt to escape the specified string
     sqlite3_snprintf(static_cast<int>(b.capacity()), b.data(), fs, str.mPtr);
     // Return the resulted string
@@ -1585,11 +1590,11 @@ void SQLiteParameter::SetUint32(SQInteger value)
 }
 
 // ------------------------------------------------------------------------------------------------
-void SQLiteParameter::SetInt64(const Object & value)
+void SQLiteParameter::SetInt64(SQInteger value)
 {
     SQMOD_VALIDATE_CREATED(*this);
     // Attempt to bind the specified value
-    m_Handle->mStatus = sqlite3_bind_int64(m_Handle->mPtr, m_Index, value.Cast< const SLongInt & >().GetNum());
+    m_Handle->mStatus = sqlite3_bind_int64(m_Handle->mPtr, m_Index, value);
     // Validate the result
     if (m_Handle->mStatus != SQLITE_OK)
     {
@@ -1598,11 +1603,11 @@ void SQLiteParameter::SetInt64(const Object & value)
 }
 
 // ------------------------------------------------------------------------------------------------
-void SQLiteParameter::SetUint64(const Object & value)
+void SQLiteParameter::SetUint64(SQInteger value)
 {
     SQMOD_VALIDATE_CREATED(*this);
     // Attempt to bind the specified value
-    m_Handle->mStatus = sqlite3_bind_int64(m_Handle->mPtr, m_Index, value.Cast< const ULongInt & >().GetNum());
+    m_Handle->mStatus = sqlite3_bind_int64(m_Handle->mPtr, m_Index, value);
     // Validate the result
     if (m_Handle->mStatus != SQLITE_OK)
     {
@@ -2315,11 +2320,11 @@ SQFloat SQLiteColumn::GetFloat() const
 }
 
 // ------------------------------------------------------------------------------------------------
-Object SQLiteColumn::GetLong() const
+SQInteger SQLiteColumn::GetLong() const
 {
     SQMOD_VALIDATE_ROW(*this);
     // Return the requested information
-    return Object(new SLongInt(sqlite3_column_int64(m_Handle->mPtr, m_Index)));
+    return sqlite3_column_int64(m_Handle->mPtr, m_Index);
 }
 
 // ------------------------------------------------------------------------------------------------

module/Library/SQLite.hpp

@@ -5,7 +5,6 @@
 
 // ------------------------------------------------------------------------------------------------
 #include "Library/IO/Buffer.hpp"
-#include "Library/Numeric/Long.hpp"
 #include "Library/Chrono/Date.hpp"
 #include "Library/Chrono/Datetime.hpp"
 #include "Library/Chrono/Time.hpp"
@@ -95,12 +94,12 @@ Object GetStatementObj(const StmtRef & stmt);
 /* ------------------------------------------------------------------------------------------------
  * Tests if a certain query string is empty.
 */
-bool IsQueryEmpty(const SQChar * str);
+SQMOD_NODISCARD bool IsQueryEmpty(const SQChar * str);
 
 /* ------------------------------------------------------------------------------------------------
  * Retrieve the string representation of a certain status code.
 */
-const SQChar * GetErrStr(int32_t status);
+SQMOD_NODISCARD const SQChar * GetErrStr(int32_t status);
 
 /* ------------------------------------------------------------------------------------------------
  * Set a specific heap limit.
@@ -115,32 +114,32 @@ int32_t ReleaseMemory(int32_t bytes);
 /* ------------------------------------------------------------------------------------------------
  * Retrieve the current memory usage.
 */
-Object GetMemoryUsage();
+SQMOD_NODISCARD SQInteger GetMemoryUsage();
 
 /* ------------------------------------------------------------------------------------------------
  * Retrieve the memory high watermark.
 */
-Object GetMemoryHighwaterMark(bool reset);
+SQMOD_NODISCARD SQInteger GetMemoryHighwaterMark(bool reset);
 
 /* ------------------------------------------------------------------------------------------------
  * Retrieve the escaped version of the specified string.
 */
-LightObj EscapeString(StackStrF & str);
+SQMOD_NODISCARD LightObj EscapeString(StackStrF & str);
 
 /* ------------------------------------------------------------------------------------------------
  * Retrieve the escaped version of the specified string using the supplied format specifier.
 */
-LightObj EscapeStringEx(SQChar spec, StackStrF & str);
+SQMOD_NODISCARD LightObj EscapeStringEx(SQChar spec, StackStrF & str);
 
 /* ------------------------------------------------------------------------------------------------
  * Convert the values from the specified array to a list of column names string.
 */
-LightObj ArrayToQueryColumns(Array & arr);
+SQMOD_NODISCARD LightObj ArrayToQueryColumns(Array & arr);
 
 /* ------------------------------------------------------------------------------------------------
  * Convert the keys from the specified array to a list of column names string.
 */
-LightObj TableToQueryColumns(Table & tbl);
+SQMOD_NODISCARD LightObj TableToQueryColumns(Table & tbl);
 
 /* ------------------------------------------------------------------------------------------------
  * The structure that holds the data associated with a certain connection.
@@ -701,9 +700,9 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Get the row-id of the most recent successful INSERT into the database from the current connection.
     */
-    SQMOD_NODISCARD Object GetLastInsertRowID() const
+    SQMOD_NODISCARD SQInteger GetLastInsertRowID() const
     {
-        return Object(new SLongInt(sqlite3_last_insert_rowid(SQMOD_GET_CREATED(*this)->mPtr)));
+        return sqlite3_last_insert_rowid(SQMOD_GET_CREATED(*this)->mPtr);
     }
 
     /* --------------------------------------------------------------------------------------------
@@ -1148,12 +1147,12 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Attempt to bind a signed 64 bit integer value at the referenced parameter index.
     */
-    void SetInt64(const Object & value);
+    void SetInt64(SQInteger value);
 
     /* --------------------------------------------------------------------------------------------
      * Attempt to bind an unsigned 64 bit integer value at the referenced parameter index.
     */
-    void SetUint64(const Object & value);
+    void SetUint64(SQInteger value);
 
     /* --------------------------------------------------------------------------------------------
      * Attempt to bind a native floating point value at the referenced parameter index.
@@ -1538,7 +1537,7 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Retrieve the value inside the referenced column as a long integer.
     */
-    SQMOD_NODISCARD Object GetLong() const;
+    SQMOD_NODISCARD SQInteger GetLong() const;
 
     /* --------------------------------------------------------------------------------------------
      * Retrieve the value inside the referenced column as a string.
@@ -2101,7 +2100,7 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Attempt to bind a signed 64 bit integer value at the specified parameter index.
     */
-    SQLiteStatement & SetInt64(const Object & param, const Object & value)
+    SQLiteStatement & SetInt64(const Object & param, SQInteger value)
     {
         SQLiteParameter(SQMOD_GET_CREATED(*this), param).SetInt64(value);
         // Allow chaining of operations
@@ -2111,7 +2110,7 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Attempt to bind an unsigned 64 bit integer value at the specified parameter index.
     */
-    SQLiteStatement & SetUint64(const Object & param, const Object & value)
+    SQLiteStatement & SetUint64(const Object & param, SQInteger value)
     {
         SQLiteParameter(SQMOD_GET_CREATED(*this), param).SetUint64(value);
         // Allow chaining of operations

module/Library/String.cpp

@@ -961,17 +961,17 @@ static SQInteger SqLevenshtein(StackStrF & a, StackStrF & b)
 }
 
 // ------------------------------------------------------------------------------------------------
-static SQInteger SqStrToI(SQInteger base, StackStrF & s)
+static SQInteger SqStringToInt(SQInteger base, StackStrF & s)
 {
 #ifdef _SQ64
-	return std::stoll(s.mPtr, nullptr, ConvTo< int >::From((base)));
+	return std::stoll(s.ToStr(), nullptr, ConvTo< int >::From((base)));
 #else
-	return std::stoi(s.mPtr, nullptr, ConvTo< int >::From((base)));
+	return std::stoi(s.ToStr(), nullptr, ConvTo< int >::From((base)));
 #endif
 }
 
 // ------------------------------------------------------------------------------------------------
-static SQFloat SqStrToF(StackStrF & s)
+static SQFloat SqStringToFloat(StackStrF & s)
 {
 #ifdef SQUSEDOUBLE
 	return std::strtod(s.mPtr, nullptr);
@@ -980,6 +980,102 @@ static SQFloat SqStrToF(StackStrF & s)
 #endif
 }
 
+// ------------------------------------------------------------------------------------------------
+SQMOD_NODISCARD static Table SqStringToL(SQInteger base, StackStrF & s)
+{
+    SQChar * end = nullptr;
+    // Attempt to process the specified string
+    const auto r = std::strtol(s.mPtr, &end, ConvTo< int >::From((base)));
+    // Allocate a table for the result
+    Table t(SqVM(), 2);
+    // Insert the resulted value
+    t.SetValue(_SC("value"), r);
+    // Insert the end of the value
+    t.SetValue(_SC("end"), static_cast< intptr_t >(end - s.mPtr));
+    // Return the table containing the results
+    return t;
+}
+
+// ------------------------------------------------------------------------------------------------
+SQMOD_NODISCARD static Table SqStringToLL(SQInteger base, StackStrF & s)
+{
+    SQChar * end = nullptr;
+    // Attempt to process the specified string
+    const auto r = std::strtoll(s.mPtr, &end, ConvTo< int >::From((base)));
+    // Allocate a table for the result
+    Table t(SqVM(), 2);
+    // Insert the resulted value
+    t.SetValue(_SC("value"), r);
+    // Insert the end of the value
+    t.SetValue(_SC("end"), static_cast< intptr_t >(end - s.mPtr));
+    // Return the table containing the results
+    return t;
+}
+
+// ------------------------------------------------------------------------------------------------
+SQMOD_NODISCARD static Table SqStringToUL(SQInteger base, StackStrF & s)
+{
+    SQChar * end = nullptr;
+    // Attempt to process the specified string
+    const auto r = std::strtoul(s.mPtr, &end, ConvTo< int >::From((base)));
+    // Allocate a table for the result
+    Table t(SqVM(), 2);
+    // Insert the resulted value
+    t.SetValue(_SC("value"), r);
+    // Insert the end of the value
+    t.SetValue(_SC("end"), static_cast< intptr_t >(end - s.mPtr));
+    // Return the table containing the results
+    return t;
+}
+
+// ------------------------------------------------------------------------------------------------
+SQMOD_NODISCARD static Table SqStringToULL(SQInteger base, StackStrF & s)
+{
+    SQChar * end = nullptr;
+    // Attempt to process the specified string
+    const auto r = std::strtoull(s.mPtr, &end, ConvTo< int >::From((base)));
+    // Allocate a table for the result
+    Table t(SqVM(), 2);
+    // Insert the resulted value
+    t.SetValue(_SC("value"), r);
+    // Insert the end of the value
+    t.SetValue(_SC("end"), static_cast< intptr_t >(end - s.mPtr));
+    // Return the table containing the results
+    return t;
+}
+
+// ------------------------------------------------------------------------------------------------
+SQMOD_NODISCARD static Table SqStringToF(StackStrF & s)
+{
+    SQChar * end = nullptr;
+    // Attempt to process the specified string
+    const auto r = std::strtof(s.mPtr, &end);
+    // Allocate a table for the result
+    Table t(SqVM(), 2);
+    // Insert the resulted value
+    t.SetValue(_SC("value"), r);
+    // Insert the end of the value
+    t.SetValue(_SC("end"), static_cast< intptr_t >(end - s.mPtr));
+    // Return the table containing the results
+    return t;
+}
+
+// ------------------------------------------------------------------------------------------------
+SQMOD_NODISCARD static Table SqStringToD(StackStrF & s)
+{
+    SQChar * end = nullptr;
+    // Attempt to process the specified string
+    const auto r = std::strtod(s.mPtr, &end);
+    // Allocate a table for the result
+    Table t(SqVM(), 2);
+    // Insert the resulted value
+    t.SetValue(_SC("value"), r);
+    // Insert the end of the value
+    t.SetValue(_SC("end"), static_cast< intptr_t >(end - s.mPtr));
+    // Return the table containing the results
+    return t;
+}
+
 // ================================================================================================
 void Register_String(HSQUIRRELVM vm)
 {
@@ -1000,8 +1096,14 @@ void Register_String(HSQUIRRELVM vm)
     .FmtFunc(_SC("Lowercase"), &SqToLowercase)
     .FmtFunc(_SC("Uppercase"), &SqToUppercase)
     .FmtFunc(_SC("JustAlnum"), &SqJustAlphaNum)
-    .FmtFunc(_SC("ToInt"), &SqStrToI)
-    .FmtFunc(_SC("ToFloat"), &SqStrToF)
+    .FmtFunc(_SC("ToInt"), &SqStringToInt)
+    .FmtFunc(_SC("ToFloat"), &SqStringToFloat)
+    .FmtFunc(_SC("ToL"), &SqStringToL)
+    .FmtFunc(_SC("ToLL"), &SqStringToLL)
+    .FmtFunc(_SC("ToUL"), &SqStringToUL)
+    .FmtFunc(_SC("ToULL"), &SqStringToULL)
+    .FmtFunc(_SC("ToF"), &SqStringToF)
+    .FmtFunc(_SC("ToD"), &SqStringToD)
     .FmtFunc(_SC("Levenshtein"), &SqLevenshtein)
     .FmtFunc(_SC("AreAllSpace"), &SqAllChars< std::isspace >)
     .FmtFunc(_SC("AreAllPrint"), &SqAllChars< std::isprint >)

module/Library/UTF8.cpp

@@ -0,0 +1,135 @@
+// ------------------------------------------------------------------------------------------------
+#include "Library/UTF8.hpp"
+#include "Core/Buffer.hpp"
+
+// ------------------------------------------------------------------------------------------------
+namespace SqMod {
+
+// ------------------------------------------------------------------------------------------------
+SQMOD_NODISCARD static SQInteger SqStrLenUTF8(StackStrF & str)
+{
+    // Is the string empty or invalid?
+    if (str.mLen <= 0)
+    {
+        return str.mLen; // Return same value
+    }
+    // Perform the request and return the result
+    return static_cast< SQInteger >(utf8len(str.mPtr));
+} 
+
+// ------------------------------------------------------------------------------------------------
+SQMOD_NODISCARD static SQInteger SqStrNLenUTF8(SQInteger len, StackStrF & str)
+{
+    // Is the string empty or invalid?
+    if (str.mLen <= 0)
+    {
+        return str.mLen; // Return same value
+    }
+    // Is the specified length within bounds?
+    else if (std::abs(len) > str.mLen)
+    {
+        STHROWF("Specified range {} is out of bounds {}", len, str.mLen);
+    }
+    // Should we compute the length backwards?
+    else if (len < 0)
+    {
+        len = str.mLen - std::abs(len); // Subtract from actual length
+    }
+    // Did we trim all of it?
+    else if (len == 0)
+    {
+        return 0; // Nothing to search for
+    }
+    // Perform the request and return the result
+    return static_cast< SQInteger >(utf8nlen(str.mPtr, static_cast< size_t >(len)));
+}
+
+// ------------------------------------------------------------------------------------------------
+SQMOD_NODISCARD static SQInteger SqStrChrUTF8(SQInteger chr, StackStrF & str)
+{
+    // Is the string empty or invalid?
+    if (str.mLen <= 0)
+    {
+        return -1; // Let the user know that we could not search for this
+    }
+    // Look for the specified character in the string
+    auto * p = reinterpret_cast< const SQChar * >(utf8chr(str.mPtr, static_cast< utf8_int32_t >(chr)));
+    // Return the distance in bytes where the character was found
+    return static_cast< SQInteger >(p - str.mPtr);
+}
+
+// ------------------------------------------------------------------------------------------------
+SQMOD_NODISCARD static SQInteger SqCaseCmpUTF8(StackStrF & a, StackStrF & b)
+{
+    // Is the left string invalid?
+    if (a.mLen < 0)
+    {
+        STHROWF("Invalid string on the left {}", a.mLen);
+    }
+    // Is the right string invalid?
+    else if (b.mLen < 0)
+    {
+        STHROWF("Invalid string on the right {}", b.mLen);
+    }
+    // Perform the request and return the result
+    return utf8casecmp(a.mPtr, b.mPtr);
+}
+
+// ------------------------------------------------------------------------------------------------
+SQMOD_NODISCARD static SQInteger SqNCaseCmpUTF8(StackStrF & a, StackStrF & b)
+{
+    // Is the left string invalid?
+    if (a.mLen < 0)
+    {
+        STHROWF("Invalid string on the left {}", a.mLen);
+    }
+    // Is the right string invalid?
+    else if (b.mLen < 0)
+    {
+        STHROWF("Invalid string on the right {}", b.mLen);
+    }
+    // See if we can decide this based on length differences
+    else if (a.mLen < b.mLen)
+    {
+        return -1;
+    }
+    else if (a.mLen > b.mLen)
+    {
+        return 1;
+    }
+    // Perform the request and return the result
+    return utf8ncasecmp(a.mPtr, b.mPtr, static_cast< size_t >(a.mLen));
+}
+
+// ------------------------------------------------------------------------------------------------
+SQMOD_NODISCARD static SQInteger SqCaseStrUTF8(StackStrF & hs, StackStrF & nd)
+{
+    // Is the haystack or needle string empty or invalid?
+    if (hs.mLen <= 0 || nd.mLen <= 0)
+    {
+        return -1; // Let the user know that we could not search for this
+    }
+    // Look for the specified needle string in the haystack string
+    auto * p = reinterpret_cast< const SQChar * >(utf8casestr(hs.mPtr, nd.mPtr));
+    // Return the distance in bytes where the string was found
+    return static_cast< SQInteger >(p - hs.mPtr);
+}
+
+// ================================================================================================
+void Register_UTF8(HSQUIRRELVM vm)
+{
+    Table ns(vm);
+
+    ns
+    .FmtFunc(_SC("StrLen"), &SqStrLenUTF8)
+    .FmtFunc(_SC("StrNLen"), &SqStrNLenUTF8)
+    .FmtFunc(_SC("StrChr"), &SqStrChrUTF8)
+    .FmtFunc(_SC("CaseCmp"), &SqCaseCmpUTF8)
+    .FmtFunc(_SC("NCaseCmp"), &SqNCaseCmpUTF8)
+    .FmtFunc(_SC("CaseStr"), &SqCaseStrUTF8)
+    ;
+
+    RootTable(vm).Bind(_SC("SqUTF8"), ns);
+}
+
+} // Namespace:: SqMod

module/Library/UTF8.hpp

@@ -1,7 +1,10 @@
 #pragma once
 
 // ------------------------------------------------------------------------------------------------
-#include "Core/Common.hpp"
+#include "Core/Utility.hpp"
+
+// ------------------------------------------------------------------------------------------------
+#include <utf8.h>
 
 // ------------------------------------------------------------------------------------------------
 namespace SqMod {

module/Library/Utils/Announce.hpp

@@ -40,8 +40,9 @@ using Poco::StreamCopier;
 /* ------------------------------------------------------------------------------------------------
  * Helper utility that can be used to announce the server to a master-list.
 */
-struct SqAnnouncer : SqChainedInstances< SqAnnouncer >
+struct SqAnnouncer : public SqChainedInstances< SqAnnouncer >
 {
+    using Base = SqChainedInstances< SqAnnouncer >;
     /* --------------------------------------------------------------------------------------------
      * Announcer status.
     */
@@ -114,7 +115,7 @@ struct SqAnnouncer : SqChainedInstances< SqAnnouncer >
      * Explicit constructor.
     */
     SqAnnouncer(SQInteger interval, StackStrF & uri)
-        : mRun(false), mLog(true)
+        : Base(), mRun(false), mLog(true)
         , mCount(0)
         , mSuccess(0)
         , mFailures(0)
@@ -125,8 +126,7 @@ struct SqAnnouncer : SqChainedInstances< SqAnnouncer >
         , mURI(uri.mPtr)
         , mMtx(), mThread()
     {
-        // Remember this instance
-        ChainInstance();
+        ChainInstance(); // Remember this instance
     }
 
     /* --------------------------------------------------------------------------------------------

module/Library/XML.cpp

@@ -108,99 +108,99 @@ bool XmlNode::RemoveAttrInst(const XmlAttribute & attr)
 }
 
 // ------------------------------------------------------------------------------------------------
-LightObj XmlAttribute::AsLong(const SLongInt & def) const
+SQInteger XmlAttribute::AsLong(SQInteger def) const
 {
-    return LightObj(SqTypeIdentity< SLongInt >{}, SqVM(), m_Attr.as_llong(def.GetNum()));
+    return m_Attr.as_llong(def);
 }
 
 // ------------------------------------------------------------------------------------------------
-LightObj XmlAttribute::AsUlong(const ULongInt & def) const
+SQInteger XmlAttribute::AsUlong(SQInteger def) const
 {
-    return LightObj(SqTypeIdentity< ULongInt >{}, SqVM(), m_Attr.as_ullong(def.GetNum()));
+    return static_cast< SQInteger >(m_Attr.as_ullong(static_cast< uint64_t >(def)));
 }
 
 // ------------------------------------------------------------------------------------------------
-bool XmlAttribute::ApplyLong(const SLongInt & value)
+bool XmlAttribute::ApplyLong(SQInteger value)
 {
-    return m_Attr.set_value(value.GetNum());
+    return m_Attr.set_value(value);
 }
 
 // ------------------------------------------------------------------------------------------------
-bool XmlAttribute::ApplyUlong(const ULongInt & value)
+bool XmlAttribute::ApplyUlong(SQInteger value)
 {
-    return m_Attr.set_value(value.GetNum());
+    return m_Attr.set_value(value);
 }
 
 // ------------------------------------------------------------------------------------------------
-LightObj XmlAttribute::GetLong() const
+SQInteger XmlAttribute::GetLong() const
 {
-    return LightObj(SqTypeIdentity< SLongInt >{}, SqVM(), m_Attr.as_llong());
+    return m_Attr.as_llong();
 }
 
 // ------------------------------------------------------------------------------------------------
-void XmlAttribute::SetLong(const SLongInt & value)
+void XmlAttribute::SetLong(SQInteger value)
 {
-    m_Attr = value.GetNum();
+    m_Attr = value;
 }
 
 // ------------------------------------------------------------------------------------------------
-LightObj XmlAttribute::GetUlong() const
+SQInteger XmlAttribute::GetUlong() const
 {
-    return LightObj(SqTypeIdentity< ULongInt >{}, SqVM(), m_Attr.as_ullong());
+    return static_cast< SQInteger >(m_Attr.as_ullong());
 }
 
 // ------------------------------------------------------------------------------------------------
-void XmlAttribute::SetUlong(const ULongInt & value)
+void XmlAttribute::SetUlong(SQInteger value)
 {
-    m_Attr = value.GetNum();
+    m_Attr = static_cast< uint64_t >(value);
 }
 
 // ------------------------------------------------------------------------------------------------
-LightObj XmlText::AsLong(const SLongInt & def) const
+SQInteger XmlText::AsLong(SQInteger def) const
 {
-    return LightObj(SqTypeIdentity< SLongInt >{}, SqVM(), m_Text.as_llong(def.GetNum()));
+    return m_Text.as_llong(def);
 }
 
 // ------------------------------------------------------------------------------------------------
-LightObj XmlText::AsUlong(const ULongInt & def) const
+SQInteger XmlText::AsUlong(SQInteger def) const
 {
-    return LightObj(SqTypeIdentity< ULongInt >{}, SqVM(), m_Text.as_ullong(def.GetNum()));
+    return static_cast< SQInteger >(m_Text.as_ullong(static_cast< uint64_t >(def)));
 }
 
 // ------------------------------------------------------------------------------------------------
-bool XmlText::ApplyLong(const SLongInt & value)
+bool XmlText::ApplyLong(SQInteger value)
 {
-    return m_Text.set(value.GetNum());
+    return m_Text.set(value);
 }
 
 // ------------------------------------------------------------------------------------------------
-bool XmlText::ApplyUlong(const ULongInt & value)
+bool XmlText::ApplyUlong(SQInteger value)
 {
-    return m_Text.set(value.GetNum());
+    return m_Text.set(static_cast< uint64_t >(value));
 }
 
 // ------------------------------------------------------------------------------------------------
-LightObj XmlText::GetLong() const
+SQInteger XmlText::GetLong() const
 {
-    return LightObj(SqTypeIdentity< SLongInt >{}, SqVM(), m_Text.as_llong());
+    return m_Text.as_llong();
 }
 
 // ------------------------------------------------------------------------------------------------
-void XmlText::SetLong(const SLongInt & value)
+void XmlText::SetLong(SQInteger value)
 {
-    m_Text = value.GetNum();
+    m_Text = value;
 }
 
 // ------------------------------------------------------------------------------------------------
-LightObj XmlText::GetUlong() const
+SQInteger XmlText::GetUlong() const
 {
-    return LightObj(SqTypeIdentity< SLongInt >{}, SqVM(), m_Text.as_ullong());
+    return static_cast< SQInteger >(m_Text.as_ullong());
 }
 
 // ------------------------------------------------------------------------------------------------
-void XmlText::SetUlong(const ULongInt & value)
+void XmlText::SetUlong(SQInteger value)
 {
-    m_Text = value.GetNum();
+    m_Text = static_cast< uint64_t >(value);
 }
 
 // ------------------------------------------------------------------------------------------------

module/Library/XML.hpp

@@ -3,9 +3,6 @@
 // ------------------------------------------------------------------------------------------------
 #include "Core/Utility.hpp"
 
-// ------------------------------------------------------------------------------------------------
-#include "Library/Numeric/Long.hpp"
-
 // ------------------------------------------------------------------------------------------------
 #include <pugixml.hpp>
 #include <utility>
@@ -1420,12 +1417,12 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Retrieve the value as a long integer or the specified default value if empty.
     */
-    SQMOD_NODISCARD LightObj AsLong(const SLongInt & def) const;
+    SQMOD_NODISCARD SQInteger AsLong(SQInteger def) const;
 
     /* --------------------------------------------------------------------------------------------
      * Retrieve the value as a unsigned long integer or the specified default value if empty.
     */
-    SQMOD_NODISCARD LightObj AsUlong(const ULongInt & def) const;
+    SQMOD_NODISCARD SQInteger AsUlong(SQInteger def) const;
 
     /* --------------------------------------------------------------------------------------------
      * Retrieve the value as a boolean or the specified default value if empty.
@@ -1478,12 +1475,12 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Modify the value as a long integer.
     */
-    bool ApplyLong(const SLongInt & value);
+    bool ApplyLong(SQInteger value);
 
     /* --------------------------------------------------------------------------------------------
      * Modify the value as a unsigned long integer.
     */
-    bool ApplyUlong(const ULongInt & value);
+    bool ApplyUlong(SQInteger value);
 
     /* --------------------------------------------------------------------------------------------
      * Modify the value as a boolean.
@@ -1576,22 +1573,22 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Retrieve the value as a long integer.
     */
-    SQMOD_NODISCARD LightObj GetLong() const;
+    SQMOD_NODISCARD SQInteger GetLong() const;
 
     /* --------------------------------------------------------------------------------------------
      * Modify the value as a long integer.
     */
-    void SetLong(const SLongInt & value);
+    void SetLong(SQInteger value);
 
     /* --------------------------------------------------------------------------------------------
      * Retrieve the value as a unsigned long integer.
     */
-    SQMOD_NODISCARD LightObj GetUlong() const;
+    SQMOD_NODISCARD SQInteger GetUlong() const;
 
     /* --------------------------------------------------------------------------------------------
      * Modify the value as a unsigned long integer.
     */
-    void SetUlong(const ULongInt & value);
+    void SetUlong(SQInteger value);
 
     /* --------------------------------------------------------------------------------------------
      * Retrieve the value as a boolean.
@@ -1772,12 +1769,12 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Retrieve the value as a long integer or the specified default value if empty.
     */
-    SQMOD_NODISCARD LightObj AsLong(const SLongInt & def) const;
+    SQMOD_NODISCARD SQInteger AsLong(SQInteger def) const;
 
     /* --------------------------------------------------------------------------------------------
      * Retrieve the value as a unsigned long integer or the specified default value if empty.
     */
-    SQMOD_NODISCARD LightObj AsUlong(const ULongInt & def) const;
+    SQMOD_NODISCARD SQInteger AsUlong(SQInteger def) const;
 
     /* --------------------------------------------------------------------------------------------
      * Retrieve the value as a boolean or the specified default value if empty.
@@ -1830,12 +1827,12 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Modify the value as a long integer.
     */
-    bool ApplyLong(const SLongInt & value);
+    bool ApplyLong(SQInteger value);
 
     /* --------------------------------------------------------------------------------------------
      * Modify the value as a unsigned long integer.
     */
-    bool ApplyUlong(const ULongInt & value);
+    bool ApplyUlong(SQInteger value);
 
     /* --------------------------------------------------------------------------------------------
      * Modify the value as a boolean.
@@ -1928,22 +1925,22 @@ public:
     /* --------------------------------------------------------------------------------------------
      * Retrieve the value as a long integer.
     */
-    SQMOD_NODISCARD LightObj GetLong() const;
+    SQMOD_NODISCARD SQInteger GetLong() const;
 
     /* --------------------------------------------------------------------------------------------
      * Modify the value as a long integer.
     */
-    void SetLong(const SLongInt & value);
+    void SetLong(SQInteger value);
 
     /* --------------------------------------------------------------------------------------------
      * Retrieve the value as a unsigned long integer.
     */
-    SQMOD_NODISCARD LightObj GetUlong() const;
+    SQMOD_NODISCARD SQInteger GetUlong() const;
 
     /* --------------------------------------------------------------------------------------------
      * Modify the value as a unsigned long integer.
     */
-    void SetUlong(const ULongInt & value);
+    void SetUlong(SQInteger value);
 
     /* --------------------------------------------------------------------------------------------
      * Retrieve the value as a boolean.

module/Main.cpp

@@ -18,10 +18,15 @@ static bool g_Reload = false;
 
 // ------------------------------------------------------------------------------------------------
 //extern void InitExports();
+extern void InitializeNet();
 extern void InitializePocoDataConnectors();
 extern void ProcessRoutines();
 extern void ProcessTasks();
 extern void ProcessThreads();
+extern void ProcessNet();
+#ifdef VCMP_ENABLE_DISCORD
+    extern void ProcessDPP();
+#endif
 
 /* ------------------------------------------------------------------------------------------------
  * Will the scripts be reloaded at the end of the current event?
@@ -168,6 +173,12 @@ static void OnServerFrame(float elapsed_time)
     ProcessTasks();
     // Process threads
     ProcessThreads();
+    // Process network
+    ProcessNet();
+    // Process DPP
+#ifdef VCMP_ENABLE_DISCORD
+    ProcessDPP();
+#endif
     // Process log messages from other threads
     Logger::Get().ProcessQueue();
     // See if a reload was requested
@@ -991,6 +1002,7 @@ SQMOD_API_EXPORT unsigned int VcmpPluginInit(PluginFuncs * funcs, PluginCallback
     try
     {
         // External plugs that need to happen (once) before initialization
+        InitializeNet();
         InitializePocoDataConnectors();
         // Proceed with plug-in initialization
         if (!Core::Get().Initialize())

module/Misc/Functions.cpp

@@ -4,7 +4,6 @@
 #include "Base/Color3.hpp"
 #include "Base/Vector2.hpp"
 #include "Entity/Player.hpp"
-#include "Library/Numeric/Long.hpp"
 
 // ------------------------------------------------------------------------------------------------
 namespace SqMod {
@@ -173,9 +172,9 @@ void SendPluginCommand(uint32_t identifier, StackStrF & payload)
 }
 
 // ------------------------------------------------------------------------------------------------
-const ULongInt & GetTime()
+SQInteger GetTime()
 {
-    return GetULongInt(_Func->GetTime());
+    return static_cast< SQInteger >(_Func->GetTime());
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -218,7 +217,7 @@ const SQChar * GetPluginAuthor()
 }
 
 // ------------------------------------------------------------------------------------------------
-int32_t GetPluginID()
+uint32_t GetPluginID()
 {
     return _Info->pluginId;
 }
@@ -242,7 +241,7 @@ uint32_t GetServerFlags()
 }
 
 // ------------------------------------------------------------------------------------------------
-int32_t GetMaxPlayers()
+uint32_t GetMaxPlayers()
 {
     return _Func->GetMaxPlayers();
 }
@@ -468,7 +467,7 @@ int32_t GetTimeRate()
 }
 
 // ------------------------------------------------------------------------------------------------
-void SetTimeRate(uint32_t rate)
+void SetTimeRate(int32_t rate)
 {
     _Func->SetTimeRate(rate);
 }
@@ -763,7 +762,7 @@ void SetSpawnCameraPositionEx(float x, float y, float z)
 // ------------------------------------------------------------------------------------------------
 void SetSpawnCameraLookAtEx(float x, float y, float z)
 {
-    _Func->SetSpawnPlayerPosition(x, y, z);
+    _Func->SetSpawnCameraLookAt(x, y, z);
 }
 
 // ------------------------------------------------------------------------------------------------

module/Misc/Functions.hpp

@@ -49,7 +49,7 @@ void SendPluginCommand(uint32_t identifier, StackStrF & payload);
 /* ------------------------------------------------------------------------------------------------
  * Retrieve the server time.
 */
-const ULongInt & GetTime();
+SQInteger GetTime();
 
 /* ------------------------------------------------------------------------------------------------
  * Send a log message to the server.
@@ -84,7 +84,7 @@ SQMOD_NODISCARD const SQChar * GetPluginAuthor();
 /* ------------------------------------------------------------------------------------------------
  * Retrieve the id of the host Squirrel plug-in.
 */
-SQMOD_NODISCARD int32_t GetPluginID();
+SQMOD_NODISCARD uint32_t GetPluginID();
 
 /* ------------------------------------------------------------------------------------------------
  * Retrieve the port onto which the server was binded.
@@ -99,7 +99,7 @@ SQMOD_NODISCARD uint32_t GetServerFlags();
 /* ------------------------------------------------------------------------------------------------
  * Retrieve the maximum number of clients allowed on the server.
 */
-SQMOD_NODISCARD int32_t GetMaxPlayers();
+SQMOD_NODISCARD uint32_t GetMaxPlayers();
 
 /* ------------------------------------------------------------------------------------------------
  * Modify the maximum number of clients allowed on the server.
@@ -205,7 +205,7 @@ SQMOD_NODISCARD int32_t GetTimeRate();
 /* ------------------------------------------------------------------------------------------------
  * Modify the current time-rate.
 */
-void SetTimeRate(uint32_t rate);
+void SetTimeRate(int32_t rate);
 
 /* ------------------------------------------------------------------------------------------------
  * Retrieve the game hour.

module/Misc/Official.cpp

@@ -673,7 +673,7 @@ struct LgPlayer
     void SetCanAttack(bool toggle) const { _Func->SetPlayerOption(GetIdentifier(), vcmpPlayerOptionCanAttack, static_cast< uint8_t >(toggle)); }
     void SetWeaponSlot(int slot) const { Get().SetWeaponSlot(slot); }
     void ShowMarkers(bool toggle) const { _Func->SetPlayerOption(GetIdentifier(), vcmpPlayerOptionShowMarkers, static_cast< uint8_t >(toggle)); }
-    void SetSpectateTarget(LgPlayer & player) const { Get().SetSpectator(player.Get()); }
+    void SetSpectateTarget(LightObj & player) const { player.IsNull() ? Get().SetSpectatorID(-1) : Get().SetSpectator(player.CastI< LgPlayer >()->Get()); }
     void SetMarkerVisible(bool toggle) const { _Func->SetPlayerOption(GetIdentifier(), vcmpPlayerOptionHasMarker, static_cast< uint8_t >(toggle)); }
     void SetCanUseColors(bool toggle) const { _Func->SetPlayerOption(GetIdentifier(), vcmpPlayerOptionChatTagsEnabled, static_cast< uint8_t >(toggle)); }
     void SetDrunkStatus(bool toggle) const { _Func->SetPlayerOption(GetIdentifier(), vcmpPlayerOptionDrunkEffects, static_cast< uint8_t >(toggle)); }

module/Misc/Register.cpp

@@ -3,7 +3,6 @@
 #include "Base/Color3.hpp"
 #include "Base/Vector2.hpp"
 #include "Entity/Player.hpp"
-#include "Library/Numeric/Long.hpp"
 
 // ------------------------------------------------------------------------------------------------
 #include "Misc/Functions.hpp"

module/PocoLib/Net.cpp

@@ -10,10 +10,15 @@ namespace SqMod {
 // ------------------------------------------------------------------------------------------------
 SQMOD_DECL_TYPENAME(SqWsClient, _SC("SqWsClient"))
 
-// ================================================================================================
-void Register_POCO_Net(HSQUIRRELVM vm, Table &)
+// ------------------------------------------------------------------------------------------------
+void TerminatePocoNet()
+{
+
+}
+
+// ================================================================================================
+void Register_POCO_Net(HSQUIRRELVM vm, Table & ns)
 {
-    Table ns(vm);
     // --------------------------------------------------------------------------------------------
     ns.Bind(_SC("WsClient"),
         Class< WsClient, NoCopy< WsClient > >(ns.GetVM(), SqWsClient::Str)
@@ -25,18 +30,22 @@ void Register_POCO_Net(HSQUIRRELVM vm, Table &)
         .Var(_SC("Flags"), &WsClient::mFlags)
         .Var(_SC("State"), &WsClient::mState)
         // Properties
+        .Prop(_SC("Tag"), &WsClient::GetTag, &WsClient::SetTag)
+        .Prop(_SC("Data"), &WsClient::GetData, &WsClient::SetData)
         .Prop(_SC("MaxPayloadSize"), &WsClient::GetMaxPayloadSize, &WsClient::SetMaxPayloadSize)
         // Member Methods
+        .FmtFunc(_SC("SetTag"), &WsClient::ApplyTag)
+        .FmtFunc(_SC("SetData"), &WsClient::ApplyData)
         .Func(_SC("Shutdown"), &WsClient::Shutdown)
         .FmtFunc(_SC("ShutdownWith"), &WsClient::ShutdownWith)
         .Func(_SC("SendFrame"), &WsClient::SendFrame)
         .FmtFunc(_SC("SendStringFrame"), &WsClient::SendStringFrame)
         .Func(_SC("RecvFrame"), &WsClient::RecvFrame)
         .Func(_SC("RecvStringFrame"), &WsClient::RecvStringFrame)
+        .CbFunc(_SC("RecvFrameIn"), &WsClient::RecvFrameIn)
+        .CbFunc(_SC("RecvStringFrameIn"), &WsClient::RecvStringFrameIn)
     );
     // --------------------------------------------------------------------------------------------
-    RootTable(vm).Bind(_SC("SqNet"), ns);
-    // --------------------------------------------------------------------------------------------
     ConstTable(vm).Enum(_SC("SqWsFrameFlags"), Enumeration(vm)
         .Const(_SC("FIN"),      static_cast< SQInteger >(Poco::Net::WebSocket::FRAME_FLAG_FIN))
         .Const(_SC("RSV1"),     static_cast< SQInteger >(Poco::Net::WebSocket::FRAME_FLAG_RSV1))

module/PocoLib/Net.hpp

@@ -6,12 +6,21 @@
 
 // ------------------------------------------------------------------------------------------------
 #include <vector>
+#include <utility>
+#include <algorithm>
 
 // ------------------------------------------------------------------------------------------------
+#include <Poco/Thread.h>
+#include <Poco/AutoPtr.h>
+#include <Poco/Runnable.h>
+#include <Poco/Observer.h>
+#include <Poco/NObserver.h>
 #include <Poco/Net/HTTPRequest.h>
 #include <Poco/Net/HTTPResponse.h>
 #include <Poco/Net/HTTPMessage.h>
 #include <Poco/Net/HTTPClientSession.h>
+#include <Poco/Net/SocketAcceptor.h>
+#include <Poco/Net/SocketReactor.h>
 #include <Poco/Net/WebSocket.h>
 
 // ------------------------------------------------------------------------------------------------
@@ -22,6 +31,33 @@ namespace SqMod {
 */
 struct WsClient
 {
+    /* --------------------------------------------------------------------------------------------
+     * Flags received in the last call to Recv[String]Frame() (will be overwritten on next call).
+    */
+    int mFlags{0};
+
+    /* --------------------------------------------------------------------------------------------
+     * Return value from the last call to Recv[String]Frame() (will be overwritten on next call).
+     * A return value of 0, with flags also 0, means that the peer has shut down or closed the connection.
+     * A return value of 0, with non-zero flags, indicates an reception of an empty frame (e.g., in case of a PING).
+    */
+    int mState{0};
+
+    /* --------------------------------------------------------------------------------------------
+     * Receiving buffer instance.
+    */
+    Poco::Buffer< char > mBuffer{0};
+
+    /* --------------------------------------------------------------------------------------------
+     * User tag associated with this instance.
+    */
+    String mTag{};
+
+    /* --------------------------------------------------------------------------------------------
+     * User data associated with this instance.
+    */
+    LightObj mData{};
+
     /* --------------------------------------------------------------------------------------------
      * HTTP client session instance.
     */
@@ -40,63 +76,110 @@ struct WsClient
     /* --------------------------------------------------------------------------------------------
      * WebSocket instance.
     */
-    Poco::Net::WebSocket mWebSocket;
-
-    /* --------------------------------------------------------------------------------------------
-     * Receiving buffer instance.
-    */
-    Poco::Buffer< char > mBuffer;
-
-    /* --------------------------------------------------------------------------------------------
-     * Flags received in the last call to Recv[String]Frame() (will be overwritten on next call).
-    */
-    int mFlags{0};
-
-    /* --------------------------------------------------------------------------------------------
-     * Return value from the last call to Recv[String]Frame() (will be overwritten on next call).
-     * A return value of 0, with flags also 0, means that the peer has shut down or closed the connection.
-     * A return value of 0, with non-zero flags, indicates an reception of an empty frame (e.g., in case of a PING).
-    */
-    int mState{0};
+    Poco::Net::WebSocket mSocket;
 
     /* --------------------------------------------------------------------------------------------
      * Base constructor.
     */
     WsClient(StackStrF & host, uint16_t port, StackStrF & uri)
-            : mClient(host.ToStr(), port),
-              mRequest(Poco::Net::HTTPRequest::HTTP_GET, uri.ToStr(), Poco::Net::HTTPRequest::HTTP_1_1), mResponse(),
-              mWebSocket(mClient, mRequest, mResponse), mBuffer(0), mFlags(0), mState(0)
+        : mFlags(0), mState(0), mBuffer(0), mTag(), mData()
+        , mClient(host.ToStr(), port)
+        , mRequest(Poco::Net::HTTPRequest::HTTP_GET, uri.ToStr(), Poco::Net::HTTPRequest::HTTP_1_1)
+        , mResponse()
+        , mSocket(mClient, mRequest, mResponse)
     {
+        mSocket.setBlocking(false); // Disable blocking
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the associated user tag.
+    */
+    SQMOD_NODISCARD const String & GetTag() const
+    {
+        return mTag;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Modify the associated user tag.
+    */
+    void SetTag(StackStrF & tag)
+    {
+        if (tag.mLen > 0)
+        {
+            mTag.assign(tag.mPtr, static_cast< size_t >(tag.mLen));
+        }
+        else
+        {
+            mTag.clear();
+        }
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Modify the associated user tag.
+    */
+    WsClient & ApplyTag(StackStrF & tag)
+    {
+        SetTag(tag);
+        return *this;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Retrieve the associated user data.
+    */
+    SQMOD_NODISCARD LightObj & GetData()
+    {
+        return mData;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Modify the associated user data.
+    */
+    void SetData(LightObj & data)
+    {
+        mData = data;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Modify the associated user data.
+    */
+    WsClient & ApplyData(LightObj & data)
+    {
+        mData = data;
+        return *this;
     }
 
     /* --------------------------------------------------------------------------------------------
      * Sends a Close control frame to the server end of the connection to initiate an orderly shutdown of the connection.
     */
-    void Shutdown() {
-        mWebSocket.shutdown();
+    void Shutdown()
+    {
+        mSocket.shutdown();
     }
 
     /* --------------------------------------------------------------------------------------------
      * Sends a Close control frame to the server end of the connection to initiate an orderly shutdown of the connection.
     */
-    void ShutdownWith(SQInteger code, StackStrF & msg) {
-        mWebSocket.shutdown(static_cast< uint16_t >(code), msg.ToStr());
+    void ShutdownWith(SQInteger code, StackStrF & msg)
+    {
+        mSocket.shutdown(static_cast< uint16_t >(code), msg.ToStr());
     }
 
     /* --------------------------------------------------------------------------------------------
      * Sends the contents of the given buffer through the socket as a single frame.
      * Returns the number of bytes sent, which may be less than the number of bytes specified.
     */
-    SQInteger SendFrame(SqBuffer & buf, SQInteger flags) {
-        return mWebSocket.sendFrame(buf.Valid().Data(), static_cast< int >(buf.Valid().Position()), static_cast< int >(flags));
+    SQInteger SendFrame(SqBuffer & buf, SQInteger flags)
+    {
+        return mSocket.sendFrame(buf.Valid().Data(), static_cast< int >(buf.Valid().Position()), static_cast< int >(flags));
     }
 
     /* --------------------------------------------------------------------------------------------
      * Sends the contents of the given string through the socket as a single frame.
      * Returns the number of bytes sent, which may be less than the number of bytes specified.
     */
-    SQInteger SendStringFrame(SQInteger flags, StackStrF & str) {
-        return mWebSocket.sendFrame(str.mPtr, static_cast< int >(str.mLen), static_cast< int >(flags));
+    SQInteger SendStringFrame(SQInteger flags, StackStrF & str)
+    {
+        return mSocket.sendFrame(str.mPtr, static_cast< int >(str.mLen), static_cast< int >(flags));
     }
 
     /* --------------------------------------------------------------------------------------------
@@ -106,7 +189,12 @@ struct WsClient
     LightObj RecvFrame()
     {
         // Attempt to receive data
-        mState = mWebSocket.receiveFrame(mBuffer, mFlags);
+        try {
+            mState = mSocket.receiveFrame(mBuffer, mFlags);
+        } catch (const Poco::TimeoutException &) {
+            mState = mFlags = 0; // Make sure these don't indicate otherwise
+            return LightObj{}; // We handle timeout so we can be non blocking
+        }
         // If something was returned
         if (mState != 0)
         {
@@ -131,7 +219,12 @@ struct WsClient
     LightObj RecvStringFrame()
     {
         // Attempt to receive data
-        mState = mWebSocket.receiveFrame(mBuffer, mFlags);
+        try {
+            mState = mSocket.receiveFrame(mBuffer, mFlags);
+        } catch (const Poco::TimeoutException &) {
+            mState = mFlags = 0; // Make sure these don't indicate otherwise
+            return LightObj{}; // We handle timeout so we can be non blocking
+        }
         // If something was returned
         if (mState != 0)
         {
@@ -146,12 +239,44 @@ struct WsClient
         return LightObj{};
     }
 
+    /* --------------------------------------------------------------------------------------------
+     * Receives a frame from the socket and return it as a buffer. Only invokes callback if response is valid.
+     * The frame's payload size must not exceed the maximum payload size set with SetMaxPayloadSize().
+    */
+    SQInteger RecvFrameIn(Function & cb)
+    {
+        auto obj = RecvFrame();
+        // Only invoke the callback if we have a valid response
+        if (mState != 0 || mFlags != 0)
+        {
+            cb(obj, mState, mFlags);
+        }
+        // Return result
+        return mState;
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Receives a frame from the socket and return it as a string. Only invokes callback if response is valid.
+     * The frame's payload size must not exceed the maximum payload size set with SetMaxPayloadSize().
+    */
+    SQInteger RecvStringFrameIn(Function & cb)
+    {
+        auto obj = RecvStringFrame();
+        // Only invoke the callback if we have data response
+        if (mState != 0 || mFlags != 0)
+        {
+            cb(obj, mState, mFlags);
+        }
+        // Return result
+        return mState;
+    }
+
     /* --------------------------------------------------------------------------------------------
      * Sets the maximum payload size for RecvFrame(). The default is std::numeric_limits<int>::max().
     */
     WsClient & SetMaxPayloadSize(SQInteger size)
     {
-        mWebSocket.setMaxPayloadSize(static_cast< int >(size));
+        mSocket.setMaxPayloadSize(static_cast< int >(size));
         return *this;
     }
 
@@ -160,7 +285,7 @@ struct WsClient
     */
     SQMOD_NODISCARD SQInteger GetMaxPayloadSize() const
     {
-        return mWebSocket.getMaxPayloadSize();
+        return mSocket.getMaxPayloadSize();
     }
 };
 

module/PocoLib/Register.cpp

@@ -7,12 +7,10 @@ namespace SqMod {
 // ------------------------------------------------------------------------------------------------
 extern void Register_POCO_Crypto(HSQUIRRELVM vm, Table & ns);
 extern void Register_POCO_Data(HSQUIRRELVM vm, Table & ns);
-extern void Register_POCO_JSON(HSQUIRRELVM vm, Table & ns);
 extern void Register_POCO_Net(HSQUIRRELVM vm, Table & ns);
 extern void Register_POCO_RegEx(HSQUIRRELVM vm, Table & ns);
 extern void Register_POCO_Time(HSQUIRRELVM vm, Table & ns);
 extern void Register_POCO_Util(HSQUIRRELVM vm, Table & ns);
-extern void Register_POCO_XML(HSQUIRRELVM vm, Table & ns);
 
 // ================================================================================================
 void Register_POCO(HSQUIRRELVM vm)
@@ -21,12 +19,10 @@ void Register_POCO(HSQUIRRELVM vm)
 
 	Register_POCO_Crypto(vm, ns);
 	Register_POCO_Data(vm, ns);
-	Register_POCO_JSON(vm, ns);
 	Register_POCO_Net(vm, ns);
 	Register_POCO_RegEx(vm, ns);
 	Register_POCO_Time(vm, ns);
 	Register_POCO_Util(vm, ns);
-	Register_POCO_XML(vm, ns);
 
     RootTable(vm).Bind(_SC("Sq"), ns);
 }

module/Register.cpp

@@ -37,12 +37,17 @@ extern void Register_Format(HSQUIRRELVM vm);
 extern void Register_IO(HSQUIRRELVM vm);
 extern void Register_JSON(HSQUIRRELVM vm);
 extern void Register_MMDB(HSQUIRRELVM vm);
+extern void Register_Net(HSQUIRRELVM vm);
 extern void Register_Numeric(HSQUIRRELVM vm);
 extern void Register_String(HSQUIRRELVM vm);
 extern void Register_System(HSQUIRRELVM vm);
+extern void Register_UTF8(HSQUIRRELVM vm);
 extern void Register_Utils(HSQUIRRELVM vm);
 extern void Register_XML(HSQUIRRELVM vm);
 extern void Register_ZMQ(HSQUIRRELVM vm);
+#ifdef VCMP_ENABLE_DISCORD
+    extern void Register_DPP(HSQUIRRELVM vm);
+#endif
 #ifdef SQMOD_POCO_HAS_SQLITE
     extern void Register_SQLite(HSQUIRRELVM vm);
 #endif
@@ -102,12 +107,17 @@ bool RegisterAPI(HSQUIRRELVM vm)
     Register_IO(vm);
     Register_JSON(vm);
     Register_MMDB(vm);
+    Register_Net(vm);
     Register_Numeric(vm);
     Register_String(vm);
     Register_System(vm);
+    Register_UTF8(vm);
     Register_Utils(vm);
     Register_XML(vm);
     Register_ZMQ(vm);
+#ifdef VCMP_ENABLE_DISCORD
+    Register_DPP(vm);
+#endif
 #ifdef SQMOD_POCO_HAS_SQLITE
     Register_SQLite(vm);
 #endif

module/SqBase.hpp

@@ -32,20 +32,21 @@
  * OS IDENTIFICATION
 */
 
-#if defined(_WIN32) || defined(__WIN32__) || defined(_WIN) || defined(__WIN__)
-    // Windows x32
-    #define SQMOD_OS_WINDOWS
-    #define SQMOD_OS_32
-    #define SQMOD_OS_WINDOWS32
-    #define SQMOD_ARCHITECTURE 1
-    #define SQMOD_PLATFORM 1
-#elif defined(_WIN64) || defined(__WIN64__)
+#if defined(_WIN64) || defined(__WIN64__)
     // Windows x64
     #define SQMOD_OS_WINDOWS
     #define SQMOD_OS_64
     #define SQMOD_OS_WINDOWS64
     #define SQMOD_ARCHITECTURE 2
     #define SQMOD_PLATFORM 1
+#elif defined(_WIN32) || defined(__WIN32__) || defined(_WIN) || defined(__WIN__)
+    #error Squirrel Module does not support 32-bit Windows anymore
+    // Windows x32
+    //#define SQMOD_OS_WINDOWS
+    //#define SQMOD_OS_32
+    //#define SQMOD_OS_WINDOWS32
+    //#define SQMOD_ARCHITECTURE 1
+    //#define SQMOD_PLATFORM 1
 #elif defined(linux) || defined(__linux) || defined(__linux__)
     // Linux
     #define SQMOD_OS_LINUX
@@ -53,13 +54,14 @@
         #if __x86_64__ || __ppc64__
             #define SQMOD_OS_64
             #define SQMOD_OS_LINUX64
-             #define SQMOD_ARCHITECTURE 2
+            #define SQMOD_ARCHITECTURE 2
             #define SQMOD_PLATFORM 2
         #else
-            #define SQMOD_OS_32
-            #define SQMOD_OS_LINUX32
-            #define SQMOD_ARCHITECTURE 1
-            #define SQMOD_PLATFORM 2
+            #error Squirrel Module does not support 32-bit Linux anymore
+            //#define SQMOD_OS_32
+            //#define SQMOD_OS_LINUX32
+            //#define SQMOD_ARCHITECTURE 1
+            //#define SQMOD_PLATFORM 2
         #endif
     #endif
 #else
@@ -106,7 +108,7 @@
 /* ------------------------------------------------------------------------------------------------
  * API EXPORT.
 */
-#if defined(_MSC_VER)
+#if defined(SQMOD_OS_WINDOWS)
     #define SQMOD_API_EXPORT    extern "C" __declspec(dllexport)
 #elif defined(__GNUC__)
     #define SQMOD_API_EXPORT    extern "C"
@@ -423,7 +425,7 @@ enum EntityType
 #define SQMOD_CONCAT(a,b) SQMOD_CONCAT_(a,b)
 
 // ------------------------------------------------------------------------------------------------
-#ifdef _WIN32
+#ifdef SQMOD_OS_WINDOWS
    #define sqmod_stricmp(a,b) stricmp(a,b)
    #define sqmod_strnicmp(a,b,n) strnicmp(a,b,n)
 #else

module/Sqrat/sqratArray.h

@@ -612,6 +612,30 @@ public:
         //sq_pop(vm,1); // pop array
         return *this;
     }
+
+    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    /// Appends values to the end of the Array
+    ///
+    /// \param vec Vector to be appended to the array
+    ///
+    /// \tparam T Type of value (usually doesnt need to be defined explicitly)
+    ///
+    /// \return The Array itself so the call can be chained
+    ///
+    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    template<class T>
+    ArrayBase& AppendFromVector(const std::vector< T > & vec) {
+        HSQUIRRELVM vm = SqVM();
+        const StackGuard sg(vm);
+        sq_pushobject(vm, GetObj());
+        for (const auto & v : vec)
+        {
+            Var< const T & >::push(vm, v);
+            sq_arrayappend(vm, -2);
+        }
+        //sq_pop(vm,1); // pop array
+        return *this;
+    }
 };
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

module/Sqrat/sqratObject.h

@@ -31,6 +31,9 @@
 
 #include <cstring>
 
+#include <map>
+#include <unordered_map>
+
 #include "sqratAllocator.h"
 #include "sqratTypes.h"
 #include "sqratOverloadMethods.h"
@@ -669,6 +672,128 @@ public:
         return res;
     }
 
+    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    /// Inserts associative container values into the managed object.
+    ///
+    /// \param map Associative container to be inserted to the table
+    ///
+    /// \tparam K Type of key (usually doesnt need to be defined explicitly)
+    ///
+    /// \tparam V Type of value (usually doesnt need to be defined explicitly)
+    ///
+    /// \return Result value returned by squirrel.
+    ///
+    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    template<class K, class V>
+    SQRESULT InsertFromMap(const std::unordered_map< K, V > & map, bool staticVar = false) {
+        HSQUIRRELVM vm = SqVM();
+        const StackGuard sg(vm);
+        sq_pushobject(vm, GetObj());
+        for (const auto & p : map)
+        {
+            Var< const K & >::push(vm, p.first);
+            Var< const V & >::push(vm, p.second);
+            const auto r = sq_newslot(vm, -3, staticVar);
+            if (SQ_FAILED(r)) return r;
+        }
+        //sq_pop(vm, 1); // pop object
+        return SQ_OK;
+    }
+
+    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    /// Inserts associative container values into the managed object.
+    ///
+    /// \param map Associative container to be inserted to the table
+    ///
+    /// \tparam K Type of key (usually doesnt need to be defined explicitly)
+    ///
+    /// \tparam V Type of value (usually doesnt need to be defined explicitly)
+    ///
+    /// \return Result value returned by squirrel.
+    ///
+    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    template<class K, class V>
+    SQRESULT InsertFromMap(const std::map< K, V > & map, bool staticVar = false) {
+        HSQUIRRELVM vm = SqVM();
+        const StackGuard sg(vm);
+        sq_pushobject(vm, GetObj());
+        for (const auto & p : map)
+        {
+            Var< const K & >::push(vm, p.first);
+            Var< const V & >::push(vm, p.second);
+            const auto r = sq_newslot(vm, -3, staticVar);
+            if (SQ_FAILED(r)) return r;
+        }
+        //sq_pop(vm, 1); // pop object
+        return SQ_OK;
+    }
+
+    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    /// Inserts associative container values into the managed object.
+    ///
+    /// \param map Associative container to be inserted to the table
+    ///
+    /// \param func Functor that is continuously called to push values on the stack
+    ///
+    /// \tparam K Type of key (usually doesnt need to be defined explicitly)
+    ///
+    /// \tparam V Type of value (usually doesnt need to be defined explicitly)
+    ///
+    /// \tparam F Type of functor (usually doesnt need to be defined explicitly)
+    ///
+    /// \return Result value returned by squirrel.
+    ///
+    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    template<class K, class V, class F>
+    SQRESULT InsertFromMapWith(const std::unordered_map< K, V > & map, F func, bool staticVar = false) {
+        HSQUIRRELVM vm = SqVM();
+        const StackGuard sg(vm);
+        sq_pushobject(vm, GetObj());
+        SQRESULT r = SQ_OK;
+        for (const auto & p : map)
+        {
+            r = func(vm, p.first, p.second);
+            if (SQ_FAILED(r)) break;
+            r = sq_newslot(vm, -3, staticVar);
+            if (SQ_FAILED(r)) return r;
+        }
+        //sq_pop(vm, 1); // pop object
+        return r;
+    }
+
+    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    /// Inserts associative container values into the managed object.
+    ///
+    /// \param map Associative container to be inserted to the table
+    ///
+    /// \param func Functor that is continuously called to push values on the stack
+    ///
+    /// \tparam K Type of key (usually doesnt need to be defined explicitly)
+    ///
+    /// \tparam V Type of value (usually doesnt need to be defined explicitly)
+    ///
+    /// \tparam F Type of functor (usually doesnt need to be defined explicitly)
+    ///
+    /// \return Result value returned by squirrel.
+    ///
+    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    template<class K, class V, class F>
+    SQRESULT InsertFromMapWith(const std::map< K, V > & map, F func, bool staticVar = false) {
+        HSQUIRRELVM vm = SqVM();
+        const StackGuard sg(vm);
+        sq_pushobject(vm, GetObj());
+        SQRESULT r = SQ_OK;
+        for (const auto & p : map)
+        {
+            r = func(vm, p.first, p.second);
+            if (SQ_FAILED(r)) break;
+            r = sq_newslot(vm, -3, staticVar);
+            if (SQ_FAILED(r)) return r;
+        }
+        //sq_pop(vm, 1); // pop object
+        return r;
+    }
+
 protected:
 /// @cond DEV
 

module/Sqrat/sqratTypes.h

@@ -181,7 +181,7 @@ private:
 
     template <class T2, bool b>
     struct pushAsInt {
-        void push(HSQUIRRELVM vm, const T2& /*value*/) {
+        inline void push(HSQUIRRELVM vm, const T2& /*value*/) noexcept {
             assert(false); // fails because called before a Sqrat::Class for T exists and T is not convertible to SQInteger
             sq_pushnull(vm);
         }
@@ -189,8 +189,8 @@ private:
 
     template <class T2>
     struct pushAsInt<T2, true> {
-        void push(HSQUIRRELVM vm, const T2& value) {
-            sq_pushinteger(vm, static_cast<SQInteger>(value));
+        inline void push(HSQUIRRELVM vm, const T2& val) noexcept {
+            sq_pushinteger(vm, static_cast<SQInteger>(val));
         }
     };
 };
@@ -237,7 +237,7 @@ private:
 
     template <class T2, bool b>
     struct pushAsInt {
-        void push(HSQUIRRELVM vm, const T2& /*value*/) {
+        inline void push(HSQUIRRELVM vm, const T2& /*value*/) noexcept {
             assert(false); // fails because called before a Sqrat::Class for T exists and T is not convertible to SQInteger
             sq_pushnull(vm);
         }
@@ -245,8 +245,8 @@ private:
 
     template <class T2>
     struct pushAsInt<T2, true> {
-        void push(HSQUIRRELVM vm, const T2& value) {
-            sq_pushinteger(vm, static_cast<SQInteger>(value));
+        inline void push(HSQUIRRELVM vm, const T2& val) noexcept {
+            sq_pushinteger(vm, static_cast<SQInteger>(val));
         }
     };
 };
@@ -483,7 +483,7 @@ struct Var<SharedPtr<T> > {
      Var(HSQUIRRELVM vm, SQInteger idx) { \
          value = popAsInt<type, true>(vm, idx).value; \
      } \
-     static void push(HSQUIRRELVM vm, const type& value) { \
+     inline static void push(HSQUIRRELVM vm, const type& value) noexcept { \
          sq_pushinteger(vm, static_cast<SQInteger>(value)); \
      } \
  };\
@@ -494,7 +494,7 @@ struct Var<SharedPtr<T> > {
      Var(HSQUIRRELVM vm, SQInteger idx) { \
          value = popAsInt<type, true>(vm, idx).value; \
      } \
-     static void push(HSQUIRRELVM vm, const type& value) { \
+     inline static void push(HSQUIRRELVM vm, const type& value) noexcept { \
          sq_pushinteger(vm, static_cast<SQInteger>(value)); \
      } \
  };
@@ -525,7 +525,7 @@ SCRAT_INTEGER(signed __int64)
      Var(HSQUIRRELVM vm, SQInteger idx) { \
          value = popAsFloat<type>(vm, idx).value; \
      } \
-     static void push(HSQUIRRELVM vm, const type& value) { \
+     inline static void push(HSQUIRRELVM vm, const type& value) noexcept { \
          sq_pushfloat(vm, static_cast<SQFloat>(value)); \
      } \
  }; \
@@ -536,7 +536,7 @@ SCRAT_INTEGER(signed __int64)
      Var(HSQUIRRELVM vm, SQInteger idx) { \
          value = popAsFloat<type>(vm, idx).value; \
      } \
-     static void push(HSQUIRRELVM vm, const type& value) { \
+     inline static void push(HSQUIRRELVM vm, const type& value) noexcept { \
          sq_pushfloat(vm, static_cast<SQFloat>(value)); \
      } \
  };
@@ -572,7 +572,7 @@ struct Var<bool> {
     /// \param value Value to push on to the VM's stack
     ///
     /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    static void push(HSQUIRRELVM vm, const bool& value) {
+    inline static void push(HSQUIRRELVM vm, const bool& value) noexcept {
         sq_pushbool(vm, static_cast<SQBool>(value));
     }
 };
@@ -605,7 +605,7 @@ struct Var<const bool&> {
     /// \param value Value to push on to the VM's stack
     ///
     /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    static void push(HSQUIRRELVM vm, const bool& value) {
+    inline static void push(HSQUIRRELVM vm, const bool& value) noexcept {
         sq_pushbool(vm, static_cast<SQBool>(value));
     }
 };
@@ -615,7 +615,7 @@ struct Var<const bool&> {
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 template<>
 struct Var<std::nullptr_t> {
-    std::nullptr_t value; ///< The actual value of get operations
+    std::nullptr_t value{}; ///< The actual value of get operations
 
     /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     /// Attempts to get the value off the stack at idx as a nullptr_t
@@ -632,7 +632,7 @@ struct Var<std::nullptr_t> {
     /// \param vm    Target VM
     ///
     /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    static void push(HSQUIRRELVM vm) {
+    inline static void push(HSQUIRRELVM vm) noexcept {
         sq_pushnull(vm);
     }
 
@@ -643,7 +643,7 @@ struct Var<std::nullptr_t> {
     /// \param value Value to push on to the VM's stack
     ///
     /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    static void push(HSQUIRRELVM vm, std::nullptr_t SQ_UNUSED_ARG(value)) {
+    inline static void push(HSQUIRRELVM vm, std::nullptr_t SQ_UNUSED_ARG(value)) noexcept {
         sq_pushnull(vm);
     }
 };
@@ -655,13 +655,13 @@ template<>
 struct Var<SQChar*> {
 private:
 
-    HSQOBJECT obj; /* hold a reference to the object holding value during the Var struct lifetime*/
-    HSQUIRRELVM v;
+    HSQOBJECT obj{}; /* hold a reference to the object holding value during the Var struct lifetime*/
+    HSQUIRRELVM v{nullptr};
 
 public:
 
-    SQChar* value; ///< The actual value of get operations
-    SQInteger size; ///< The size of the obtained string
+    SQChar* value{nullptr}; ///< The actual value of get operations
+    SQInteger size{0}; ///< The size of the obtained string
 
     /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     /// Attempts to get the value off the stack at idx as a character array
@@ -698,7 +698,7 @@ public:
     /// \param len   Length of the string (defaults to finding the length by searching for a terminating null-character)
     ///
     /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    static void push(HSQUIRRELVM vm, const SQChar* value, SQInteger len = -1) {
+    inline static void push(HSQUIRRELVM vm, const SQChar* value, SQInteger len = -1) noexcept {
         sq_pushstring(vm, value, len);
     }
 };
@@ -710,13 +710,13 @@ template<>
 struct Var<const SQChar*> {
 private:
 
-    HSQOBJECT obj; /* hold a reference to the object holding value during the Var struct lifetime*/
-    HSQUIRRELVM v;
+    HSQOBJECT obj{}; /* hold a reference to the object holding value during the Var struct lifetime*/
+    HSQUIRRELVM v{nullptr};
 
 public:
 
-    const SQChar* value; ///< The actual value of get operations
-    SQInteger size; ///< The size of the obtained string
+    const SQChar* value{nullptr}; ///< The actual value of get operations
+    SQInteger size{0}; ///< The size of the obtained string
 
     /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     /// Attempts to get the value off the stack at idx as a character array
@@ -753,7 +753,7 @@ public:
     /// \param len   Length of the string (defaults to finding the length by searching for a terminating null-character)
     ///
     /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    static void push(HSQUIRRELVM vm, const SQChar* value, SQInteger len = -1) {
+    inline static void push(HSQUIRRELVM vm, const SQChar* value, SQInteger len = -1) noexcept {
         sq_pushstring(vm, value, len);
     }
 };
@@ -789,8 +789,8 @@ struct Var<string> {
     /// \param value Value to push on to the VM's stack
     ///
     /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    static void push(HSQUIRRELVM vm, const string& value) {
-        sq_pushstring(vm, value.c_str(), value.size());
+    inline static void push(HSQUIRRELVM vm, const string& value) noexcept {
+        sq_pushstring(vm, value.c_str(), static_cast< SQInteger >(value.size()));
     }
 };
 
@@ -825,8 +825,8 @@ struct Var<const string&> {
     /// \param value Value to push on to the VM's stack
     ///
     /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    static void push(HSQUIRRELVM vm, const string& value) {
-        sq_pushstring(vm, value.c_str(), value.size());
+    inline static void push(HSQUIRRELVM vm, const string& value) noexcept {
+        sq_pushstring(vm, value.c_str(), static_cast< SQInteger >(value.size()));
     }
 };
 
@@ -863,7 +863,7 @@ struct Var<std::wstring> {
     /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     static void push(HSQUIRRELVM vm, const std::wstring& value) {
         std::string s(value.begin(), value.end());
-        sq_pushstring(vm, s.c_str(), s.size());
+        sq_pushstring(vm, s.c_str(), static_cast< SQInteger >(s.size()));
     }
 };
 
@@ -900,7 +900,7 @@ struct Var<const std::wstring&> {
     /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     static void push(HSQUIRRELVM vm, const std::wstring& value) {
         std::string s(value.begin(), value.end());
-        sq_pushstring(vm, s.c_str(), s.size());
+        sq_pushstring(vm, s.c_str(), static_cast< SQInteger >(s.size()));
     }
 };
 
@@ -1173,7 +1173,7 @@ struct Var<StackStrF> {
     /// \param value Value to push on to the VM's stack
     ///
     /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    static void push(HSQUIRRELVM vm, const StackStrF& value) {
+    static void push(HSQUIRRELVM vm, const StackStrF& value) noexcept {
         if (sq_isstring(value.mObj)) {
             sq_pushobject(vm, value.mObj);
         } else {
@@ -1284,7 +1284,7 @@ inline void PushVars(HSQUIRRELVM /*vm*/) { }
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 template<class T>
 inline void PushVars(HSQUIRRELVM vm, T value) {
-    PushVar(vm, value);
+    PushVar(vm, std::forward< T >(value));
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -1292,15 +1292,15 @@ inline void PushVars(HSQUIRRELVM vm, T value) {
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 template<class T, class... Ts>
 inline void PushVars(HSQUIRRELVM vm, T value, Ts &&... tail) {
-    PushVar(vm, value);
-    PushVars(vm, std::forward<Ts>(tail)...);
+    PushVar(vm, std::forward< T >(value));
+    PushVars(vm, std::forward< Ts >(tail)...);
 }
 
 /// @cond DEV
 template<class T, bool b>
 struct PushVarR_helper {
     inline static void push(HSQUIRRELVM vm, T value) {
-        PushVar<T>(vm, value);
+        PushVar<T>(vm, std::forward< T >(value));
     }
 };
 template<class T>

vendor/CMakeLists.txt

@@ -6,7 +6,17 @@ add_subdirectory(SimpleIni)
 add_subdirectory(TinyDir)
 add_subdirectory(SAJSON)
 add_subdirectory(CPR)
+add_subdirectory(UTF8)
 add_subdirectory(PUGIXML)
+add_subdirectory(CivetWeb)
+if (ENABLE_BUILTIN_MYSQL_C)
+    set(WITH_MSI OFF CACHE INTERNAL "" FORCE)
+    set(WITH_UNIT_TESTS OFF CACHE INTERNAL "" FORCE)
+    set(WITH_EXTERNAL_ZLIB ON CACHE INTERNAL "" FORCE)
+    set(WITH_CURL ON CACHE INTERNAL "" FORCE)
+    set(WITH_SSL ON CACHE INTERNAL "" FORCE)
+    add_subdirectory(MDBC)
+endif()
 set(BUILD_TESTING OFF CACHE INTERNAL "" FORCE)
 set(BUILD_SHARED_LIBS OFF CACHE INTERNAL "" FORCE)
 add_subdirectory(MaxmindDB)
@@ -32,7 +42,18 @@ set(ENABLE_POCODOC OFF CACHE INTERNAL "" FORCE)
 set(ENABLE_PAGECOMPILER OFF CACHE INTERNAL "" FORCE)
 set(ENABLE_PAGECOMPILER_FILE2PAGE OFF CACHE INTERNAL "" FORCE)
 set(ENABLE_TESTS OFF CACHE INTERNAL "" FORCE)
+set(ENABLE_ACTIVERECORD OFF CACHE INTERNAL "" FORCE)
+set(ENABLE_ACTIVERECORD_COMPILER OFF CACHE INTERNAL "" FORCE)
 set(POCO_UNBUNDLED OFF CACHE INTERNAL "" FORCE)
+# Manualy enable some options if available
+find_package(MySQL)
+if(MYSQL_FOUND)
+    set(ENABLE_DATA_MYSQL ON CACHE INTERNAL "" FORCE)
+endif()
+find_package(PostgreSQL)
+if(PostgreSQL_FOUND)
+    set(ENABLE_DATA_POSTGRESQL ON CACHE INTERNAL "" FORCE)
+endif()
 add_subdirectory(POCO)
 # Windows gets stupid sometimes
 if (WIN32 AND MINGW)
@@ -49,3 +70,7 @@ if (WIN32 OR MINGW)
     set(ZMQ_HAVE_IPC OFF CACHE INTERNAL "" FORCE)
 endif()
 add_subdirectory(ZMQ)
+# Should we include DPP?
+if (ENABLE_DISCORD)
+    add_subdirectory(DPP)
+endif()

vendor/CivetWeb/CMakeLists.txt

@@ -0,0 +1,47 @@
+# Create the CivetWeb library
+add_library(CivetWeb STATIC
+    include/civetweb.h civetweb.c
+    mod_mbedtls.inl
+    mod_zlib.inl
+    openssl_dl.inl
+    response.inl
+    sha1.inl
+    timer.inl
+    wolfssl_extras.inl
+    handle_form.inl
+    md5.inl
+    mod_http2.inl
+)
+# Configure include folders
+target_include_directories(CivetWeb PRIVATE ${CMAKE_CURRENT_LIST_DIR})
+target_include_directories(CivetWeb PUBLIC ${CMAKE_CURRENT_LIST_DIR}/include)
+# Configure macro options
+if(WIN32 OR MINGW)
+    target_compile_definitions(CivetWeb PRIVATE _WIN32_WINNT=0x0601)
+endif()
+# Generic macro options
+target_compile_definitions(CivetWeb PUBLIC USE_TIMERS=1 USE_WEBSOCKET=1 USE_IPV6=1 USE_HTTP2=1)
+# Look for SSL
+find_package(OpenSSL)
+# Check SSL status
+if (OPENSSL_FOUND)
+    message(STATUS "CivetWeb: OpenSSL was found")
+    target_link_libraries(CivetWeb PUBLIC OpenSSL::Crypto OpenSSL::SSL)
+    string(REPLACE "." ";" OPENSSL_VERSION_LIST ${OPENSSL_VERSION})
+    list(GET OPENSSL_VERSION_LIST 0 OPENSSL_VERSION_MAJOR)
+    list(GET OPENSSL_VERSION_LIST 1 OPENSSL_VERSION_MINOR)
+    list(GET OPENSSL_VERSION_LIST 2 OPENSSL_VERSION_PATCH)
+    # Tell the library what SSL version to expect
+    target_compile_definitions(CivetWeb PUBLIC "OPENSSL_API_${OPENSSL_VERSION_MAJOR}_${OPENSSL_VERSION_MINOR}")
+    message(STATUS "CivetWeb: OPENSSL_API_${OPENSSL_VERSION_MAJOR}_${OPENSSL_VERSION_MINOR}")
+else()
+    target_compile_definitions(CivetWeb PUBLIC NO_SSL=1)
+endif()
+# Look for ZLib
+find_package(ZLIB)
+# Check ZLib status
+if (ZLIB_FOUND)
+    message(STATUS "CivetWeb: ZLib was found")
+    target_link_libraries(CivetWeb PUBLIC ZLIB::ZLIB)
+    target_compile_definitions(CivetWeb PUBLIC USE_ZLIB=1)
+endif()

vendor/CivetWeb/LICENSE.md

@@ -0,0 +1,248 @@
+ALL LICENSES
+=====
+
+This document includes several copyright licenses for different
+aspects of the software.  Not all licenses may apply depending
+on the features chosen.
+
+
+Civetweb License
+-----
+
+### Included with all features.
+
+> Copyright (c) 2013-2021 The CivetWeb developers ([CREDITS.md](https://github.com/civetweb/civetweb/blob/master/CREDITS.md))
+>
+> Copyright (c) 2004-2013 Sergey Lyubka
+>
+> Copyright (c) 2013 No Face Press, LLC (Thomas Davis)
+>
+> Copyright (c) 2013 F-Secure Corporation
+>
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+>
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+>
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+
+Lua License
+------
+
+### Included only if built with Lua support.
+
+http://www.lua.org/license.html
+
+> Copyright (C) 1994-2020 Lua.org, PUC-Rio.
+>
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+>
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+>
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+
+SQLite3 License
+------
+
+### Included only if built with Lua and SQLite support.
+
+http://www.sqlite.org/copyright.html
+
+> 2001-09-15
+>
+> The author disclaims copyright to this source code.  In place of
+> a legal notice, here is a blessing:
+>
+>    May you do good and not evil.
+>    May you find forgiveness for yourself and forgive others.
+>    May you share freely, never taking more than you give.
+
+
+lsqlite3 License
+------
+
+### Included only if built with Lua and SQLite support.
+
+> Copyright (C) 2002-2016 Tiago Dionizio, Doug Currie
+> All rights reserved.
+> Author    : Tiago Dionizio <tiago.dionizio@ist.utl.pt>
+> Author    : Doug Currie <doug.currie@alum.mit.edu>
+> Library   : lsqlite3 - an SQLite 3 database binding for Lua 5
+>
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+>
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+>
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+
+Lua File System License
+------
+
+### Included only if built with Lua support.
+
+https://github.com/keplerproject/luafilesystem/blob/master/LICENSE
+
+> Copyright © 2003-2020 Kepler Project.
+>
+> Permission is hereby granted, free of charge, to any person
+> obtaining a copy of this software and associated documentation
+> files (the "Software"), to deal in the Software without
+> restriction, including without limitation the rights to use, copy,
+> modify, merge, publish, distribute, sublicense, and/or sell copies
+> of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+>
+> The above copyright notice and this permission notice shall be
+> included in all copies or substantial portions of the Software.
+>
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+> NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+> BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+> ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+> CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+> SOFTWARE.
+
+
+LuaXML License
+------
+
+### Included only if built with Lua and LuaXML support.
+
+Version 1.8.0 (Lua 5.2), 2013-06-10 by Gerald Franz, eludi.net
+
+Modified and extended 2015 by Bernhard Nortmann, https://github.com/n1tehawk/LuaXML – version 2.0.x, compatible with Lua 5.1 to 5.3 and LuaJIT.
+
+
+> LuaXML License
+>
+> LuaXml is licensed under the terms of the MIT license reproduced below,
+> the same as Lua itself. This means that LuaXml is free software and can be
+> used for both academic and commercial purposes at absolutely no cost.
+>
+> Copyright (C) 2007-2013 Gerald Franz, eludi.net
+>
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+>
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+>
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+
+Duktape License
+------
+
+### Included only if built with Duktape support.
+
+https://github.com/svaarala/duktape/blob/master/LICENSE.txt
+
+> ===============
+> Duktape license
+> ===============
+>
+> (http://opensource.org/licenses/MIT)
+>
+> Copyright (c) 2013-2017 by Duktape authors (see AUTHORS.rst)
+>
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+>
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+>
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+
+
+zlib License
+------
+
+### Included only if built with zlib support.
+
+https://www.zlib.net/zlib_license.html
+
+> zlib.h -- interface of the 'zlib' general purpose compression library
+> version 1.2.11, January 15th, 2017
+>
+> Copyright (C) 1995-2017 Jean-loup Gailly and Mark Adler
+>
+> This software is provided 'as-is', without any express or implied
+> warranty.  In no event will the authors be held liable for any damages
+> arising from the use of this software.
+>
+> Permission is granted to anyone to use this software for any purpose,
+> including commercial applications, and to alter it and redistribute it
+> freely, subject to the following restrictions:
+>
+> 1. The origin of this software must not be misrepresented; you must not
+>    claim that you wrote the original software. If you use this software
+>    in a product, an acknowledgment in the product documentation would be
+>    appreciated but is not required.
+> 2. Altered source versions must be plainly marked as such, and must not be
+>    misrepresented as being the original software.
+> 3. This notice may not be removed or altered from any source distribution.
+>
+> Jean-loup Gailly        Mark Adler
+> jloup@gzip.org          madler@alumni.caltech.edu
+

vendor/CivetWeb/md5.inl

@@ -0,0 +1,471 @@
+/*
+ * This an amalgamation of md5.c and md5.h into a single file
+ * with all static declaration to reduce linker conflicts
+ * in Civetweb.
+ *
+ * The MD5_STATIC declaration was added to facilitate static
+ * inclusion.
+ * No Face Press, LLC
+ */
+
+/* $Id: md5.h,v 1.4 2002/04/13 19:20:28 lpd Exp $ */
+/*
+  Independent implementation of MD5 (RFC 1321).
+
+  This code implements the MD5 Algorithm defined in RFC 1321, whose
+  text is available at
+    http://www.ietf.org/rfc/rfc1321.txt
+  The code is derived from the text of the RFC, including the test suite
+  (section A.5) but excluding the rest of Appendix A.  It does not include
+  any code or documentation that is identified in the RFC as being
+  copyrighted.
+
+  The original and principal author of md5.h is L. Peter Deutsch
+  <ghost@aladdin.com>.  Other authors are noted in the change history
+  that follows (in reverse chronological order):
+
+  2002-04-13 lpd Removed support for non-ANSI compilers; removed
+    references to Ghostscript; clarified derivation from RFC 1321;
+    now handles byte order either statically or dynamically.
+  1999-11-04 lpd Edited comments slightly for automatic TOC extraction.
+  1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5);
+    added conditionalization for C++ compilation from Martin
+    Purschke <purschke@bnl.gov>.
+  1999-05-03 lpd Original version.
+ */
+
+#if !defined(md5_INCLUDED)
+#define md5_INCLUDED
+
+/*
+ * This package supports both compile-time and run-time determination of CPU
+ * byte order.  If ARCH_IS_BIG_ENDIAN is defined as 0, the code will be
+ * compiled to run only on little-endian CPUs; if ARCH_IS_BIG_ENDIAN is
+ * defined as non-zero, the code will be compiled to run only on big-endian
+ * CPUs; if ARCH_IS_BIG_ENDIAN is not defined, the code will be compiled to
+ * run on either big- or little-endian CPUs, but will run slightly less
+ * efficiently on either one than if ARCH_IS_BIG_ENDIAN is defined.
+ */
+
+typedef unsigned char md5_byte_t; /* 8-bit byte */
+typedef unsigned int md5_word_t;  /* 32-bit word */
+
+/* Define the state of the MD5 Algorithm. */
+typedef struct md5_state_s {
+	md5_word_t count[2]; /* message length in bits, lsw first */
+	md5_word_t abcd[4];  /* digest buffer */
+	md5_byte_t buf[64];  /* accumulate block */
+} md5_state_t;
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+/* Initialize the algorithm. */
+MD5_STATIC void md5_init(md5_state_t *pms);
+
+/* Append a string to the message. */
+MD5_STATIC void
+md5_append(md5_state_t *pms, const md5_byte_t *data, size_t nbytes);
+
+/* Finish the message and return the digest. */
+MD5_STATIC void md5_finish(md5_state_t *pms, md5_byte_t digest[16]);
+
+#if defined(__cplusplus)
+} /* end extern "C" */
+#endif
+
+#endif /* md5_INCLUDED */
+
+/*
+  Copyright (C) 1999, 2000, 2002 Aladdin Enterprises.  All rights reserved.
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  L. Peter Deutsch
+  ghost@aladdin.com
+
+ */
+/* $Id: md5.c,v 1.6 2002/04/13 19:20:28 lpd Exp $ */
+/*
+  Independent implementation of MD5 (RFC 1321).
+
+  This code implements the MD5 Algorithm defined in RFC 1321, whose
+  text is available at
+    http://www.ietf.org/rfc/rfc1321.txt
+  The code is derived from the text of the RFC, including the test suite
+  (section A.5) but excluding the rest of Appendix A.  It does not include
+  any code or documentation that is identified in the RFC as being
+  copyrighted.
+
+  The original and principal author of md5.c is L. Peter Deutsch
+  <ghost@aladdin.com>.  Other authors are noted in the change history
+  that follows (in reverse chronological order):
+
+  2002-04-13 lpd Clarified derivation from RFC 1321; now handles byte order
+    either statically or dynamically; added missing #include <string.h>
+    in library.
+  2002-03-11 lpd Corrected argument list for main(), and added int return
+    type, in test program and T value program.
+  2002-02-21 lpd Added missing #include <stdio.h> in test program.
+  2000-07-03 lpd Patched to eliminate warnings about "constant is
+    unsigned in ANSI C, signed in traditional"; made test program
+    self-checking.
+  1999-11-04 lpd Edited comments slightly for automatic TOC extraction.
+  1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5).
+  1999-05-03 lpd Original version.
+ */
+
+#if !defined(MD5_STATIC)
+#include <string.h>
+#endif
+
+#undef BYTE_ORDER /* 1 = big-endian, -1 = little-endian, 0 = unknown */
+#if defined(ARCH_IS_BIG_ENDIAN)
+#define BYTE_ORDER (ARCH_IS_BIG_ENDIAN ? 1 : -1)
+#else
+#define BYTE_ORDER (0)
+#endif
+
+#define T_MASK ((md5_word_t)~0)
+#define T1 /* 0xd76aa478 */ (T_MASK ^ 0x28955b87)
+#define T2 /* 0xe8c7b756 */ (T_MASK ^ 0x173848a9)
+#define T3 (0x242070db)
+#define T4 /* 0xc1bdceee */ (T_MASK ^ 0x3e423111)
+#define T5 /* 0xf57c0faf */ (T_MASK ^ 0x0a83f050)
+#define T6 (0x4787c62a)
+#define T7 /* 0xa8304613 */ (T_MASK ^ 0x57cfb9ec)
+#define T8 /* 0xfd469501 */ (T_MASK ^ 0x02b96afe)
+#define T9 (0x698098d8)
+#define T10 /* 0x8b44f7af */ (T_MASK ^ 0x74bb0850)
+#define T11 /* 0xffff5bb1 */ (T_MASK ^ 0x0000a44e)
+#define T12 /* 0x895cd7be */ (T_MASK ^ 0x76a32841)
+#define T13 (0x6b901122)
+#define T14 /* 0xfd987193 */ (T_MASK ^ 0x02678e6c)
+#define T15 /* 0xa679438e */ (T_MASK ^ 0x5986bc71)
+#define T16 (0x49b40821)
+#define T17 /* 0xf61e2562 */ (T_MASK ^ 0x09e1da9d)
+#define T18 /* 0xc040b340 */ (T_MASK ^ 0x3fbf4cbf)
+#define T19 (0x265e5a51)
+#define T20 /* 0xe9b6c7aa */ (T_MASK ^ 0x16493855)
+#define T21 /* 0xd62f105d */ (T_MASK ^ 0x29d0efa2)
+#define T22 (0x02441453)
+#define T23 /* 0xd8a1e681 */ (T_MASK ^ 0x275e197e)
+#define T24 /* 0xe7d3fbc8 */ (T_MASK ^ 0x182c0437)
+#define T25 (0x21e1cde6)
+#define T26 /* 0xc33707d6 */ (T_MASK ^ 0x3cc8f829)
+#define T27 /* 0xf4d50d87 */ (T_MASK ^ 0x0b2af278)
+#define T28 (0x455a14ed)
+#define T29 /* 0xa9e3e905 */ (T_MASK ^ 0x561c16fa)
+#define T30 /* 0xfcefa3f8 */ (T_MASK ^ 0x03105c07)
+#define T31 (0x676f02d9)
+#define T32 /* 0x8d2a4c8a */ (T_MASK ^ 0x72d5b375)
+#define T33 /* 0xfffa3942 */ (T_MASK ^ 0x0005c6bd)
+#define T34 /* 0x8771f681 */ (T_MASK ^ 0x788e097e)
+#define T35 (0x6d9d6122)
+#define T36 /* 0xfde5380c */ (T_MASK ^ 0x021ac7f3)
+#define T37 /* 0xa4beea44 */ (T_MASK ^ 0x5b4115bb)
+#define T38 (0x4bdecfa9)
+#define T39 /* 0xf6bb4b60 */ (T_MASK ^ 0x0944b49f)
+#define T40 /* 0xbebfbc70 */ (T_MASK ^ 0x4140438f)
+#define T41 (0x289b7ec6)
+#define T42 /* 0xeaa127fa */ (T_MASK ^ 0x155ed805)
+#define T43 /* 0xd4ef3085 */ (T_MASK ^ 0x2b10cf7a)
+#define T44 (0x04881d05)
+#define T45 /* 0xd9d4d039 */ (T_MASK ^ 0x262b2fc6)
+#define T46 /* 0xe6db99e5 */ (T_MASK ^ 0x1924661a)
+#define T47 (0x1fa27cf8)
+#define T48 /* 0xc4ac5665 */ (T_MASK ^ 0x3b53a99a)
+#define T49 /* 0xf4292244 */ (T_MASK ^ 0x0bd6ddbb)
+#define T50 (0x432aff97)
+#define T51 /* 0xab9423a7 */ (T_MASK ^ 0x546bdc58)
+#define T52 /* 0xfc93a039 */ (T_MASK ^ 0x036c5fc6)
+#define T53 (0x655b59c3)
+#define T54 /* 0x8f0ccc92 */ (T_MASK ^ 0x70f3336d)
+#define T55 /* 0xffeff47d */ (T_MASK ^ 0x00100b82)
+#define T56 /* 0x85845dd1 */ (T_MASK ^ 0x7a7ba22e)
+#define T57 (0x6fa87e4f)
+#define T58 /* 0xfe2ce6e0 */ (T_MASK ^ 0x01d3191f)
+#define T59 /* 0xa3014314 */ (T_MASK ^ 0x5cfebceb)
+#define T60 (0x4e0811a1)
+#define T61 /* 0xf7537e82 */ (T_MASK ^ 0x08ac817d)
+#define T62 /* 0xbd3af235 */ (T_MASK ^ 0x42c50dca)
+#define T63 (0x2ad7d2bb)
+#define T64 /* 0xeb86d391 */ (T_MASK ^ 0x14792c6e)
+
+static void
+md5_process(md5_state_t *pms, const md5_byte_t *data /*[64]*/)
+{
+	md5_word_t a = pms->abcd[0], b = pms->abcd[1], c = pms->abcd[2],
+	           d = pms->abcd[3];
+	md5_word_t t;
+#if BYTE_ORDER > 0
+	/* Define storage only for big-endian CPUs. */
+	md5_word_t X[16];
+#else
+	/* Define storage for little-endian or both types of CPUs. */
+	md5_word_t xbuf[16];
+	const md5_word_t *X;
+#endif
+
+	{
+#if BYTE_ORDER == 0
+		/*
+		 * Determine dynamically whether this is a big-endian or
+		 * little-endian machine, since we can use a more efficient
+		 * algorithm on the latter.
+		 */
+		static const int w = 1;
+
+		if (*((const md5_byte_t *)&w)) /* dynamic little-endian */
+#endif
+#if BYTE_ORDER <= 0 /* little-endian */
+		{
+			/*
+			 * On little-endian machines, we can process properly aligned
+			 * data without copying it.
+			 */
+			if (!((data - (const md5_byte_t *)0) & 3)) {
+				/* data are properly aligned, a direct assignment is possible */
+				/* cast through a (void *) should avoid a compiler warning,
+				   see
+				   https://github.com/bel2125/civetweb/issues/94#issuecomment-98112861
+				   */
+				X = (const md5_word_t *)(const void *)data;
+			} else {
+				/* not aligned */
+				memcpy(xbuf, data, 64);
+				X = xbuf;
+			}
+		}
+#endif
+#if BYTE_ORDER == 0
+		else /* dynamic big-endian */
+#endif
+#if BYTE_ORDER >= 0 /* big-endian */
+		{
+			/*
+			 * On big-endian machines, we must arrange the bytes in the
+			 * right order.
+			 */
+			const md5_byte_t *xp = data;
+			int i;
+
+#if BYTE_ORDER == 0
+			X = xbuf; /* (dynamic only) */
+#else
+#define xbuf X /* (static only) */
+#endif
+			for (i = 0; i < 16; ++i, xp += 4)
+				xbuf[i] = (md5_word_t)(xp[0]) + (md5_word_t)(xp[1] << 8)
+				          + (md5_word_t)(xp[2] << 16)
+				          + (md5_word_t)(xp[3] << 24);
+		}
+#endif
+	}
+
+#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
+
+/* Round 1. */
+/* Let [abcd k s i] denote the operation
+   a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */
+#define F(x, y, z) (((x) & (y)) | (~(x) & (z)))
+#define SET(a, b, c, d, k, s, Ti)                                              \
+	t = (a) + F(b, c, d) + X[k] + (Ti);                                        \
+	(a) = ROTATE_LEFT(t, s) + (b)
+
+	/* Do the following 16 operations. */
+	SET(a, b, c, d, 0, 7, T1);
+	SET(d, a, b, c, 1, 12, T2);
+	SET(c, d, a, b, 2, 17, T3);
+	SET(b, c, d, a, 3, 22, T4);
+	SET(a, b, c, d, 4, 7, T5);
+	SET(d, a, b, c, 5, 12, T6);
+	SET(c, d, a, b, 6, 17, T7);
+	SET(b, c, d, a, 7, 22, T8);
+	SET(a, b, c, d, 8, 7, T9);
+	SET(d, a, b, c, 9, 12, T10);
+	SET(c, d, a, b, 10, 17, T11);
+	SET(b, c, d, a, 11, 22, T12);
+	SET(a, b, c, d, 12, 7, T13);
+	SET(d, a, b, c, 13, 12, T14);
+	SET(c, d, a, b, 14, 17, T15);
+	SET(b, c, d, a, 15, 22, T16);
+#undef SET
+
+/* Round 2. */
+/* Let [abcd k s i] denote the operation
+	 a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */
+#define G(x, y, z) (((x) & (z)) | ((y) & ~(z)))
+#define SET(a, b, c, d, k, s, Ti)                                              \
+	t = (a) + G(b, c, d) + X[k] + (Ti);                                        \
+	(a) = ROTATE_LEFT(t, s) + (b)
+
+	/* Do the following 16 operations. */
+	SET(a, b, c, d, 1, 5, T17);
+	SET(d, a, b, c, 6, 9, T18);
+	SET(c, d, a, b, 11, 14, T19);
+	SET(b, c, d, a, 0, 20, T20);
+	SET(a, b, c, d, 5, 5, T21);
+	SET(d, a, b, c, 10, 9, T22);
+	SET(c, d, a, b, 15, 14, T23);
+	SET(b, c, d, a, 4, 20, T24);
+	SET(a, b, c, d, 9, 5, T25);
+	SET(d, a, b, c, 14, 9, T26);
+	SET(c, d, a, b, 3, 14, T27);
+	SET(b, c, d, a, 8, 20, T28);
+	SET(a, b, c, d, 13, 5, T29);
+	SET(d, a, b, c, 2, 9, T30);
+	SET(c, d, a, b, 7, 14, T31);
+	SET(b, c, d, a, 12, 20, T32);
+#undef SET
+
+/* Round 3. */
+/* Let [abcd k s t] denote the operation
+	 a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */
+#define H(x, y, z) ((x) ^ (y) ^ (z))
+#define SET(a, b, c, d, k, s, Ti)                                              \
+	t = (a) + H(b, c, d) + X[k] + (Ti);                                        \
+	(a) = ROTATE_LEFT(t, s) + b
+
+	/* Do the following 16 operations. */
+	SET(a, b, c, d, 5, 4, T33);
+	SET(d, a, b, c, 8, 11, T34);
+	SET(c, d, a, b, 11, 16, T35);
+	SET(b, c, d, a, 14, 23, T36);
+	SET(a, b, c, d, 1, 4, T37);
+	SET(d, a, b, c, 4, 11, T38);
+	SET(c, d, a, b, 7, 16, T39);
+	SET(b, c, d, a, 10, 23, T40);
+	SET(a, b, c, d, 13, 4, T41);
+	SET(d, a, b, c, 0, 11, T42);
+	SET(c, d, a, b, 3, 16, T43);
+	SET(b, c, d, a, 6, 23, T44);
+	SET(a, b, c, d, 9, 4, T45);
+	SET(d, a, b, c, 12, 11, T46);
+	SET(c, d, a, b, 15, 16, T47);
+	SET(b, c, d, a, 2, 23, T48);
+#undef SET
+
+/* Round 4. */
+/* Let [abcd k s t] denote the operation
+	 a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */
+#define I(x, y, z) ((y) ^ ((x) | ~(z)))
+#define SET(a, b, c, d, k, s, Ti)                                              \
+	t = (a) + I(b, c, d) + X[k] + (Ti);                                        \
+	(a) = ROTATE_LEFT(t, s) + (b)
+
+	/* Do the following 16 operations. */
+	SET(a, b, c, d, 0, 6, T49);
+	SET(d, a, b, c, 7, 10, T50);
+	SET(c, d, a, b, 14, 15, T51);
+	SET(b, c, d, a, 5, 21, T52);
+	SET(a, b, c, d, 12, 6, T53);
+	SET(d, a, b, c, 3, 10, T54);
+	SET(c, d, a, b, 10, 15, T55);
+	SET(b, c, d, a, 1, 21, T56);
+	SET(a, b, c, d, 8, 6, T57);
+	SET(d, a, b, c, 15, 10, T58);
+	SET(c, d, a, b, 6, 15, T59);
+	SET(b, c, d, a, 13, 21, T60);
+	SET(a, b, c, d, 4, 6, T61);
+	SET(d, a, b, c, 11, 10, T62);
+	SET(c, d, a, b, 2, 15, T63);
+	SET(b, c, d, a, 9, 21, T64);
+#undef SET
+
+	/* Then perform the following additions. (That is increment each
+	   of the four registers by the value it had before this block
+	   was started.) */
+	pms->abcd[0] += a;
+	pms->abcd[1] += b;
+	pms->abcd[2] += c;
+	pms->abcd[3] += d;
+}
+
+MD5_STATIC void
+md5_init(md5_state_t *pms)
+{
+	pms->count[0] = pms->count[1] = 0;
+	pms->abcd[0] = 0x67452301;
+	pms->abcd[1] = /*0xefcdab89*/ T_MASK ^ 0x10325476;
+	pms->abcd[2] = /*0x98badcfe*/ T_MASK ^ 0x67452301;
+	pms->abcd[3] = 0x10325476;
+}
+
+MD5_STATIC void
+md5_append(md5_state_t *pms, const md5_byte_t *data, size_t nbytes)
+{
+	const md5_byte_t *p = data;
+	size_t left = nbytes;
+	size_t offset = (pms->count[0] >> 3) & 63;
+	md5_word_t nbits = (md5_word_t)(nbytes << 3);
+
+	if (nbytes <= 0)
+		return;
+
+	/* Update the message length. */
+	pms->count[1] += (md5_word_t)(nbytes >> 29);
+	pms->count[0] += nbits;
+	if (pms->count[0] < nbits)
+		pms->count[1]++;
+
+	/* Process an initial partial block. */
+	if (offset) {
+		size_t copy = (offset + nbytes > 64 ? 64 - offset : nbytes);
+
+		memcpy(pms->buf + offset, p, copy);
+		if (offset + copy < 64)
+			return;
+		p += copy;
+		left -= copy;
+		md5_process(pms, pms->buf);
+	}
+
+	/* Process full blocks. */
+	for (; left >= 64; p += 64, left -= 64)
+		md5_process(pms, p);
+
+	/* Process a final partial block. */
+	if (left)
+		memcpy(pms->buf, p, left);
+}
+
+MD5_STATIC void
+md5_finish(md5_state_t *pms, md5_byte_t digest[16])
+{
+	static const md5_byte_t pad[64] = {0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	                                   0,    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	                                   0,    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	                                   0,    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	                                   0,    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+	md5_byte_t data[8];
+	int i;
+
+	/* Save the length before padding. */
+	for (i = 0; i < 8; ++i)
+		data[i] = (md5_byte_t)(pms->count[i >> 2] >> ((i & 3) << 3));
+	/* Pad to 56 bytes mod 64. */
+	md5_append(pms, pad, ((55 - (pms->count[0] >> 3)) & 63) + 1);
+	/* Append the length. */
+	md5_append(pms, data, 8);
+	for (i = 0; i < 16; ++i)
+		digest[i] = (md5_byte_t)(pms->abcd[i >> 2] >> ((i & 3) << 3));
+}
+
+
+/* End of md5.inl */

vendor/CivetWeb/mod_mbedtls.inl

@@ -0,0 +1,239 @@
+#if defined(USE_MBEDTLS) // USE_MBEDTLS used with NO_SSL
+
+#include "mbedtls/certs.h"
+#include "mbedtls/ctr_drbg.h"
+#include "mbedtls/debug.h"
+#include "mbedtls/entropy.h"
+#include "mbedtls/error.h"
+#include "mbedtls/net.h"
+#include "mbedtls/pk.h"
+#include "mbedtls/platform.h"
+#include "mbedtls/ssl.h"
+#include "mbedtls/x509.h"
+#include "mbedtls/x509_crt.h"
+#include <string.h>
+
+typedef mbedtls_ssl_context SSL;
+
+typedef struct {
+	mbedtls_ssl_config conf;         /* SSL configuration */
+	mbedtls_x509_crt cert;           /* Certificate */
+	mbedtls_ctr_drbg_context ctr;    /* Counter random generator state */
+	mbedtls_entropy_context entropy; /* Entropy context */
+	mbedtls_pk_context pkey;         /* Private key */
+} SSL_CTX;
+
+
+/* public api */
+int mbed_sslctx_init(SSL_CTX *ctx, const char *crt);
+void mbed_sslctx_uninit(SSL_CTX *ctx);
+void mbed_ssl_close(mbedtls_ssl_context *ssl);
+int mbed_ssl_accept(mbedtls_ssl_context **ssl,
+                    SSL_CTX *ssl_ctx,
+                    int *sock,
+                    struct mg_context *phys_ctx);
+int mbed_ssl_read(mbedtls_ssl_context *ssl, unsigned char *buf, int len);
+int mbed_ssl_write(mbedtls_ssl_context *ssl, const unsigned char *buf, int len);
+
+static void mbed_debug(void *context,
+                       int level,
+                       const char *file,
+                       int line,
+                       const char *str);
+static int mbed_ssl_handshake(mbedtls_ssl_context *ssl);
+
+
+int
+mbed_sslctx_init(SSL_CTX *ctx, const char *crt)
+{
+	mbedtls_ssl_config *conf;
+	int rc;
+
+	if (ctx == NULL || crt == NULL) {
+		return -1;
+	}
+
+	DEBUG_TRACE("%s", "Initializing MbedTLS SSL");
+	mbedtls_entropy_init(&ctx->entropy);
+
+	conf = &ctx->conf;
+	mbedtls_ssl_config_init(conf);
+
+	/* Set mbedTLS debug level by defining MG_CONFIG_MBEDTLS_DEBUG:
+	 *   0 No debug = mbedTLS DEFAULT
+	 *   1 Error (default if "DEBUG" is set for CivetWeb)
+	 *	 2 State change
+	 *	 3 Informational
+	 *	 4 Verbose
+	 */
+#if defined(DEBUG) || defined(MG_CONFIG_MBEDTLS_DEBUG)
+#if defined(MG_CONFIG_MBEDTLS_DEBUG)
+	mbedtls_debug_set_threshold(MG_CONFIG_MBEDTLS_DEBUG);
+#else
+	mbedtls_debug_set_threshold(1);
+#endif
+	mbedtls_ssl_conf_dbg(conf, mbed_debug, (void *)ctx);
+#endif
+
+	/* Initialize TLS key and cert */
+	mbedtls_pk_init(&ctx->pkey);
+	mbedtls_ctr_drbg_init(&ctx->ctr);
+	mbedtls_x509_crt_init(&ctx->cert);
+
+	rc = mbedtls_ctr_drbg_seed(&ctx->ctr,
+	                           mbedtls_entropy_func,
+	                           &ctx->entropy,
+	                           (unsigned char *)"CivetWeb",
+	                           strlen("CivetWeb"));
+	if (rc != 0) {
+		DEBUG_TRACE("TLS random seed failed (%i)", rc);
+		return -1;
+	}
+
+	rc = mbedtls_pk_parse_keyfile(&ctx->pkey, crt, NULL);
+	if (rc != 0) {
+		DEBUG_TRACE("TLS parse key file failed (%i)", rc);
+		return -1;
+	}
+
+	rc = mbedtls_x509_crt_parse_file(&ctx->cert, crt);
+	if (rc != 0) {
+		DEBUG_TRACE("TLS parse crt file failed (%i)", rc);
+		return -1;
+	}
+
+	rc = mbedtls_ssl_config_defaults(conf,
+	                                 MBEDTLS_SSL_IS_SERVER,
+	                                 MBEDTLS_SSL_TRANSPORT_STREAM,
+	                                 MBEDTLS_SSL_PRESET_DEFAULT);
+	if (rc != 0) {
+		DEBUG_TRACE("TLS set defaults failed (%i)", rc);
+		return -1;
+	}
+
+	mbedtls_ssl_conf_rng(conf, mbedtls_ctr_drbg_random, &ctx->ctr);
+
+	/* Set auth mode if peer cert should be verified */
+	mbedtls_ssl_conf_authmode(conf, MBEDTLS_SSL_VERIFY_NONE);
+	mbedtls_ssl_conf_ca_chain(conf, NULL, NULL);
+
+	/* Configure server cert and key */
+	rc = mbedtls_ssl_conf_own_cert(conf, &ctx->cert, &ctx->pkey);
+	if (rc != 0) {
+		DEBUG_TRACE("TLS cannot set certificate and private key (%i)", rc);
+		return -1;
+	}
+	return 0;
+}
+
+
+void
+mbed_sslctx_uninit(SSL_CTX *ctx)
+{
+	mbedtls_ctr_drbg_free(&ctx->ctr);
+	mbedtls_pk_free(&ctx->pkey);
+	mbedtls_x509_crt_free(&ctx->cert);
+	mbedtls_entropy_free(&ctx->entropy);
+	mbedtls_ssl_config_free(&ctx->conf);
+}
+
+
+int
+mbed_ssl_accept(mbedtls_ssl_context **ssl,
+                SSL_CTX *ssl_ctx,
+                int *sock,
+                struct mg_context *phys_ctx)
+{
+	int rc;
+	(void)phys_ctx; /* unused, if server statistics is not turned on */
+
+	DEBUG_TRACE("TLS accept processing %p", ssl);
+
+	*ssl = (mbedtls_ssl_context *)mg_calloc_ctx(1,
+	                                            sizeof(mbedtls_ssl_context),
+	                                            phys_ctx);
+	if (*ssl == NULL) {
+		DEBUG_TRACE("TLS accept: malloc ssl failed (%i)",
+		            (int)sizeof(mbedtls_ssl_context));
+		return -1;
+	}
+
+	mbedtls_ssl_init(*ssl);
+	mbedtls_ssl_setup(*ssl, &ssl_ctx->conf);
+	mbedtls_ssl_set_bio(*ssl, sock, mbedtls_net_send, mbedtls_net_recv, NULL);
+	rc = mbed_ssl_handshake(*ssl);
+	if (rc != 0) {
+		DEBUG_TRACE("TLS handshake failed (%i)", rc);
+		mbedtls_ssl_free(*ssl);
+		mg_free(*ssl);
+		*ssl = NULL;
+		return -1;
+	}
+
+	DEBUG_TRACE("TLS connection %p accepted, state: %d", ssl, (*ssl)->state);
+	return 0;
+}
+
+
+void
+mbed_ssl_close(mbedtls_ssl_context *ssl)
+{
+	DEBUG_TRACE("TLS connection %p closed", ssl);
+	mbedtls_ssl_close_notify(ssl);
+	mbedtls_ssl_free(ssl);
+	mg_free(ssl); /* mg_free for mg_calloc in mbed_ssl_accept */
+}
+
+
+static int
+mbed_ssl_handshake(mbedtls_ssl_context *ssl)
+{
+	int rc;
+	while ((rc = mbedtls_ssl_handshake(ssl)) != 0) {
+		if (rc != MBEDTLS_ERR_SSL_WANT_READ && rc != MBEDTLS_ERR_SSL_WANT_WRITE
+		    && rc != MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS) {
+			break;
+		}
+	}
+
+	DEBUG_TRACE("TLS handshake rc: %d, state: %d", rc, ssl->state);
+	return rc;
+}
+
+
+int
+mbed_ssl_read(mbedtls_ssl_context *ssl, unsigned char *buf, int len)
+{
+	int rc = mbedtls_ssl_read(ssl, buf, len);
+	/* DEBUG_TRACE("mbedtls_ssl_read: %d", rc); */
+	return rc;
+}
+
+
+int
+mbed_ssl_write(mbedtls_ssl_context *ssl, const unsigned char *buf, int len)
+{
+	int rc = mbedtls_ssl_write(ssl, buf, len);
+	/* DEBUG_TRACE("mbedtls_ssl_write: %d", rc); */
+	return rc;
+}
+
+
+static void
+mbed_debug(void *user_param,
+           int level,
+           const char *file,
+           int line,
+           const char *str)
+{
+	(void)level; /* Ignored. Limit is set using mbedtls_debug_set_threshold */
+	(void)user_param; /* Ignored. User parameter (context) is set using
+	                  mbedtls_ssl_conf_dbg */
+
+	DEBUG_TRACE("mbedTLS DEBUG: file: [%s] line: [%d] str: [%s]",
+	            file,
+	            line,
+	            str);
+}
+
+#endif /* USE_MBEDTLS */

vendor/CivetWeb/mod_zlib.inl

@@ -0,0 +1,281 @@
+/* Experimental implementation for on-the-fly compression */
+#if !defined(USE_ZLIB)
+#error "This file must only be included, if USE_ZLIB is set"
+#endif
+
+#if !defined(MEM_LEVEL)
+#define MEM_LEVEL (8)
+#endif
+
+static void *
+zalloc(void *opaque, uInt items, uInt size)
+{
+	struct mg_connection *conn = (struct mg_connection *)opaque;
+	void *ret = mg_calloc_ctx(items, size, conn->phys_ctx);
+	(void)conn; /* mg_calloc_ctx makro might not need it */
+
+	return ret;
+}
+
+
+static void
+zfree(void *opaque, void *address)
+{
+	struct mg_connection *conn = (struct mg_connection *)opaque;
+	(void)conn; /* not required */
+
+	mg_free(address);
+}
+
+
+static void
+send_compressed_data(struct mg_connection *conn, struct mg_file *filep)
+{
+
+	int zret;
+	z_stream zstream;
+	int do_flush;
+	unsigned bytes_avail;
+	unsigned char in_buf[MG_BUF_LEN];
+	unsigned char out_buf[MG_BUF_LEN];
+	FILE *in_file = filep->access.fp;
+
+	/* Prepare state buffer. User server context memory allocation. */
+	memset(&zstream, 0, sizeof(zstream));
+	zstream.zalloc = zalloc;
+	zstream.zfree = zfree;
+	zstream.opaque = (void *)conn;
+
+	/* Initialize for GZIP compression (MAX_WBITS | 16) */
+	zret = deflateInit2(&zstream,
+	                    Z_BEST_COMPRESSION,
+	                    Z_DEFLATED,
+	                    MAX_WBITS | 16,
+	                    MEM_LEVEL,
+	                    Z_DEFAULT_STRATEGY);
+
+	if (zret != Z_OK) {
+		mg_cry_internal(conn,
+		                "GZIP init failed (%i): %s",
+		                zret,
+		                (zstream.msg ? zstream.msg : "<no error message>"));
+		deflateEnd(&zstream);
+		return;
+	}
+
+	/* Read until end of file */
+	do {
+		zstream.avail_in = fread(in_buf, 1, MG_BUF_LEN, in_file);
+		if (ferror(in_file)) {
+			mg_cry_internal(conn, "fread failed: %s", strerror(ERRNO));
+			(void)deflateEnd(&zstream);
+			return;
+		}
+
+		do_flush = (feof(in_file) ? Z_FINISH : Z_NO_FLUSH);
+		zstream.next_in = in_buf;
+
+		/* run deflate() on input until output buffer not full, finish
+		 * compression if all of source has been read in */
+		do {
+			zstream.avail_out = MG_BUF_LEN;
+			zstream.next_out = out_buf;
+			zret = deflate(&zstream, do_flush);
+
+			if (zret == Z_STREAM_ERROR) {
+				/* deflate error */
+				zret = -97;
+				break;
+			}
+
+			bytes_avail = MG_BUF_LEN - zstream.avail_out;
+			if (bytes_avail) {
+				if (mg_send_chunk(conn, (char *)out_buf, bytes_avail) < 0) {
+					zret = -98;
+					break;
+				}
+			}
+
+		} while (zstream.avail_out == 0);
+
+		if (zret < -90) {
+			/* Forward write error */
+			break;
+		}
+
+		if (zstream.avail_in != 0) {
+			/* all input will be used, otherwise GZIP is incomplete */
+			zret = -99;
+			break;
+		}
+
+		/* done when last data in file processed */
+	} while (do_flush != Z_FINISH);
+
+	if (zret != Z_STREAM_END) {
+		/* Error: We did not compress everything. */
+		mg_cry_internal(conn,
+		                "GZIP incomplete (%i): %s",
+		                zret,
+		                (zstream.msg ? zstream.msg : "<no error message>"));
+	}
+
+	deflateEnd(&zstream);
+
+	/* Send "end of chunked data" marker */
+	mg_write(conn, "0\r\n\r\n", 5);
+}
+
+
+#if defined(USE_WEBSOCKET) && defined(MG_EXPERIMENTAL_INTERFACES)
+static int
+websocket_deflate_initialize(struct mg_connection *conn, int server)
+{
+	int zret =
+	    deflateInit2(&conn->websocket_deflate_state,
+	                 Z_BEST_COMPRESSION,
+	                 Z_DEFLATED,
+	                 server
+	                     ? -1 * conn->websocket_deflate_server_max_windows_bits
+	                     : -1 * conn->websocket_deflate_client_max_windows_bits,
+	                 MEM_LEVEL,
+	                 Z_DEFAULT_STRATEGY);
+	if (zret != Z_OK) {
+		mg_cry_internal(conn,
+		                "Websocket deflate init failed (%i): %s",
+		                zret,
+		                (conn->websocket_deflate_state.msg
+		                     ? conn->websocket_deflate_state.msg
+		                     : "<no error message>"));
+		deflateEnd(&conn->websocket_deflate_state);
+		return zret;
+	}
+
+	zret = inflateInit2(
+	    &conn->websocket_inflate_state,
+	    server ? -1 * conn->websocket_deflate_client_max_windows_bits
+	           : -1 * conn->websocket_deflate_server_max_windows_bits);
+	if (zret != Z_OK) {
+		mg_cry_internal(conn,
+		                "Websocket inflate init failed (%i): %s",
+		                zret,
+		                (conn->websocket_inflate_state.msg
+		                     ? conn->websocket_inflate_state.msg
+		                     : "<no error message>"));
+		inflateEnd(&conn->websocket_inflate_state);
+		return zret;
+	}
+	if ((conn->websocket_deflate_server_no_context_takeover && server)
+	    || (conn->websocket_deflate_client_no_context_takeover && !server))
+		conn->websocket_deflate_flush = Z_FULL_FLUSH;
+	else
+		conn->websocket_deflate_flush = Z_SYNC_FLUSH;
+
+	conn->websocket_deflate_initialized = 1;
+	return Z_OK;
+}
+
+
+static void
+websocket_deflate_negotiate(struct mg_connection *conn)
+{
+	const char *extensions = mg_get_header(conn, "Sec-WebSocket-Extensions");
+	int val;
+	if (extensions && !strncmp(extensions, "permessage-deflate", 18)) {
+		conn->accept_gzip = 1;
+		conn->websocket_deflate_client_max_windows_bits = 15;
+		conn->websocket_deflate_server_max_windows_bits = 15;
+		conn->websocket_deflate_server_no_context_takeover = 0;
+		conn->websocket_deflate_client_no_context_takeover = 0;
+		extensions += 18;
+		while (*extensions != '\0') {
+			if (*extensions == ';' || *extensions == ' ')
+				++extensions;
+			else if (!strncmp(extensions, "server_no_context_takeover", 26)) {
+				extensions += 26;
+				conn->websocket_deflate_server_no_context_takeover = 1;
+			} else if (!strncmp(extensions, "client_no_context_takeover", 26)) {
+				extensions += 26;
+				conn->websocket_deflate_client_no_context_takeover = 1;
+			} else if (!strncmp(extensions, "server_max_window_bits", 22)) {
+				extensions += 22;
+				if (*extensions == '=') {
+					++extensions;
+					if (*extensions == '"')
+						++extensions;
+					val = 0;
+					while (*extensions >= '0' && *extensions <= '9') {
+						val = val * 10 + (*extensions - '0');
+						++extensions;
+					}
+					if (val < 9 || val > 15) {
+						// The permessage-deflate spec specifies that a
+						// value of 8 is also allowed, but zlib doesn't accept
+						// that.
+						mg_cry_internal(conn,
+						                "server-max-window-bits must be "
+						                "between 9 and 15. Got %i",
+						                val);
+					} else
+						conn->websocket_deflate_server_max_windows_bits = val;
+					if (*extensions == '"')
+						++extensions;
+				}
+			} else if (!strncmp(extensions, "client_max_window_bits", 22)) {
+				extensions += 22;
+				if (*extensions == '=') {
+					++extensions;
+					if (*extensions == '"')
+						++extensions;
+					val = 0;
+					while (*extensions >= '0' && *extensions <= '9') {
+						val = val * 10 + (*extensions - '0');
+						++extensions;
+					}
+					if (val < 9 || val > 15)
+						// The permessage-deflate spec specifies that a
+						// value of 8 is also allowed, but zlib doesn't
+						// accept that.
+						mg_cry_internal(conn,
+						                "client-max-window-bits must be "
+						                "between 9 and 15. Got %i",
+						                val);
+					else
+						conn->websocket_deflate_client_max_windows_bits = val;
+					if (*extensions == '"')
+						++extensions;
+				}
+			} else {
+				mg_cry_internal(conn,
+				                "Unknown parameter %s for permessage-deflate",
+				                extensions);
+				break;
+			}
+		}
+	} else {
+		conn->accept_gzip = 0;
+	}
+	conn->websocket_deflate_initialized = 0;
+}
+
+
+static void
+websocket_deflate_response(struct mg_connection *conn)
+{
+	if (conn->accept_gzip) {
+		mg_printf(conn,
+		          "Sec-WebSocket-Extensions: permessage-deflate; "
+		          "server_max_window_bits=%i; "
+		          "client_max_window_bits=%i"
+		          "%s%s\r\n",
+		          conn->websocket_deflate_server_max_windows_bits,
+		          conn->websocket_deflate_client_max_windows_bits,
+		          conn->websocket_deflate_client_no_context_takeover
+		              ? "; client_no_context_takeover"
+		              : "",
+		          conn->websocket_deflate_server_no_context_takeover
+		              ? "; server_no_context_takeover"
+		              : "");
+	};
+}
+#endif

vendor/CivetWeb/openssl_dl.inl

@@ -0,0 +1,545 @@
+/* Copyright (c) 2013-2021 the Civetweb developers
+ * Copyright (c) 2004-2013 Sergey Lyubka
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+
+typedef struct ssl_st SSL;
+typedef struct ssl_method_st SSL_METHOD;
+typedef struct ssl_ctx_st SSL_CTX;
+typedef struct x509_store_ctx_st X509_STORE_CTX;
+typedef struct x509_name X509_NAME;
+typedef struct asn1_integer ASN1_INTEGER;
+typedef struct bignum BIGNUM;
+typedef struct ossl_init_settings_st OPENSSL_INIT_SETTINGS;
+typedef struct evp_md EVP_MD;
+typedef struct x509 X509;
+
+
+#define SSL_CTRL_OPTIONS (32)
+#define SSL_CTRL_CLEAR_OPTIONS (77)
+#define SSL_CTRL_SET_ECDH_AUTO (94)
+
+#define OPENSSL_INIT_NO_LOAD_SSL_STRINGS 0x00100000L
+#define OPENSSL_INIT_LOAD_SSL_STRINGS 0x00200000L
+#define OPENSSL_INIT_LOAD_CRYPTO_STRINGS 0x00000002L
+
+#define SSL_VERIFY_NONE (0)
+#define SSL_VERIFY_PEER (1)
+#define SSL_VERIFY_FAIL_IF_NO_PEER_CERT (2)
+#define SSL_VERIFY_CLIENT_ONCE (4)
+
+#define SSL_OP_ALL (0x80000BFFul)
+
+#define SSL_OP_NO_SSLv2 (0x01000000ul)
+#define SSL_OP_NO_SSLv3 (0x02000000ul)
+#define SSL_OP_NO_TLSv1 (0x04000000ul)
+#define SSL_OP_NO_TLSv1_2 (0x08000000ul)
+#define SSL_OP_NO_TLSv1_1 (0x10000000ul)
+#define SSL_OP_NO_TLSv1_3 (0x20000000ul)
+#define SSL_OP_SINGLE_DH_USE (0x00100000ul)
+#define SSL_OP_CIPHER_SERVER_PREFERENCE (0x00400000ul)
+#define SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION (0x00010000ul)
+#define SSL_OP_NO_COMPRESSION (0x00020000ul)
+#define SSL_OP_NO_RENEGOTIATION (0x40000000ul)
+
+#define SSL_CB_HANDSHAKE_START (0x10)
+#define SSL_CB_HANDSHAKE_DONE (0x20)
+
+#define SSL_ERROR_NONE (0)
+#define SSL_ERROR_SSL (1)
+#define SSL_ERROR_WANT_READ (2)
+#define SSL_ERROR_WANT_WRITE (3)
+#define SSL_ERROR_WANT_X509_LOOKUP (4)
+#define SSL_ERROR_SYSCALL (5) /* see errno */
+#define SSL_ERROR_ZERO_RETURN (6)
+#define SSL_ERROR_WANT_CONNECT (7)
+#define SSL_ERROR_WANT_ACCEPT (8)
+
+#define TLSEXT_TYPE_server_name (0)
+#define TLSEXT_NAMETYPE_host_name (0)
+#define SSL_TLSEXT_ERR_OK (0)
+#define SSL_TLSEXT_ERR_ALERT_WARNING (1)
+#define SSL_TLSEXT_ERR_ALERT_FATAL (2)
+#define SSL_TLSEXT_ERR_NOACK (3)
+
+#define SSL_SESS_CACHE_BOTH (3)
+
+enum ssl_func_category {
+	TLS_Mandatory, /* required for HTTPS */
+	TLS_ALPN,      /* required for Application Layer Protocol Negotiation */
+	TLS_END_OF_LIST
+};
+
+/* Check if all TLS functions/features are available */
+static int tls_feature_missing[TLS_END_OF_LIST] = {0};
+
+struct ssl_func {
+	const char *name;                /* SSL function name */
+	enum ssl_func_category required; /* Mandatory or optional */
+	void (*ptr)(void);               /* Function pointer */
+};
+
+
+#if (defined(OPENSSL_API_1_1) || defined(OPENSSL_API_3_0))                     \
+    && !defined(NO_SSL_DL)
+
+#define SSL_free (*(void (*)(SSL *))ssl_sw[0].ptr)
+#define SSL_accept (*(int (*)(SSL *))ssl_sw[1].ptr)
+#define SSL_connect (*(int (*)(SSL *))ssl_sw[2].ptr)
+#define SSL_read (*(int (*)(SSL *, void *, int))ssl_sw[3].ptr)
+#define SSL_write (*(int (*)(SSL *, const void *, int))ssl_sw[4].ptr)
+#define SSL_get_error (*(int (*)(SSL *, int))ssl_sw[5].ptr)
+#define SSL_set_fd (*(int (*)(SSL *, SOCKET))ssl_sw[6].ptr)
+#define SSL_new (*(SSL * (*)(SSL_CTX *)) ssl_sw[7].ptr)
+#define SSL_CTX_new (*(SSL_CTX * (*)(SSL_METHOD *)) ssl_sw[8].ptr)
+#define TLS_server_method (*(SSL_METHOD * (*)(void)) ssl_sw[9].ptr)
+#define OPENSSL_init_ssl                                                       \
+	(*(int (*)(uint64_t opts,                                                  \
+	           const OPENSSL_INIT_SETTINGS *settings))ssl_sw[10]               \
+	      .ptr)
+#define SSL_CTX_use_PrivateKey_file                                            \
+	(*(int (*)(SSL_CTX *, const char *, int))ssl_sw[11].ptr)
+#define SSL_CTX_use_certificate_file                                           \
+	(*(int (*)(SSL_CTX *, const char *, int))ssl_sw[12].ptr)
+#define SSL_CTX_set_default_passwd_cb                                          \
+	(*(void (*)(SSL_CTX *, mg_callback_t))ssl_sw[13].ptr)
+#define SSL_CTX_free (*(void (*)(SSL_CTX *))ssl_sw[14].ptr)
+#define SSL_CTX_use_certificate_chain_file                                     \
+	(*(int (*)(SSL_CTX *, const char *))ssl_sw[15].ptr)
+#define TLS_client_method (*(SSL_METHOD * (*)(void)) ssl_sw[16].ptr)
+#define SSL_pending (*(int (*)(SSL *))ssl_sw[17].ptr)
+#define SSL_CTX_set_verify                                                     \
+	(*(void (*)(SSL_CTX *,                                                     \
+	            int,                                                           \
+	            int (*verify_callback)(int, X509_STORE_CTX *)))ssl_sw[18]      \
+	      .ptr)
+#define SSL_shutdown (*(int (*)(SSL *))ssl_sw[19].ptr)
+#define SSL_CTX_load_verify_locations                                          \
+	(*(int (*)(SSL_CTX *, const char *, const char *))ssl_sw[20].ptr)
+#define SSL_CTX_set_default_verify_paths (*(int (*)(SSL_CTX *))ssl_sw[21].ptr)
+#define SSL_CTX_set_verify_depth (*(void (*)(SSL_CTX *, int))ssl_sw[22].ptr)
+#define SSL_get_peer_certificate (*(X509 * (*)(SSL *)) ssl_sw[23].ptr)
+#define SSL_get_version (*(const char *(*)(SSL *))ssl_sw[24].ptr)
+#define SSL_get_current_cipher (*(SSL_CIPHER * (*)(SSL *)) ssl_sw[25].ptr)
+#define SSL_CIPHER_get_name                                                    \
+	(*(const char *(*)(const SSL_CIPHER *))ssl_sw[26].ptr)
+#define SSL_CTX_check_private_key (*(int (*)(SSL_CTX *))ssl_sw[27].ptr)
+#define SSL_CTX_set_session_id_context                                         \
+	(*(int (*)(SSL_CTX *, const unsigned char *, unsigned int))ssl_sw[28].ptr)
+#define SSL_CTX_ctrl (*(long (*)(SSL_CTX *, int, long, void *))ssl_sw[29].ptr)
+#define SSL_CTX_set_cipher_list                                                \
+	(*(int (*)(SSL_CTX *, const char *))ssl_sw[30].ptr)
+#define SSL_CTX_set_options                                                    \
+	(*(unsigned long (*)(SSL_CTX *, unsigned long))ssl_sw[31].ptr)
+#define SSL_CTX_set_info_callback                                              \
+	(*(void (*)(SSL_CTX * ctx, void (*callback)(const SSL *, int, int)))       \
+	      ssl_sw[32]                                                           \
+	          .ptr)
+#define SSL_get_ex_data (*(char *(*)(const SSL *, int))ssl_sw[33].ptr)
+#define SSL_set_ex_data (*(void (*)(SSL *, int, char *))ssl_sw[34].ptr)
+#define SSL_CTX_callback_ctrl                                                  \
+	(*(long (*)(SSL_CTX *, int, void (*)(void)))ssl_sw[35].ptr)
+#define SSL_get_servername                                                     \
+	(*(const char *(*)(const SSL *, int type))ssl_sw[36].ptr)
+#define SSL_set_SSL_CTX (*(SSL_CTX * (*)(SSL *, SSL_CTX *)) ssl_sw[37].ptr)
+#define SSL_ctrl (*(long (*)(SSL *, int, long, void *))ssl_sw[38].ptr)
+#define SSL_CTX_set_alpn_protos                                                \
+	(*(int (*)(SSL_CTX *, const unsigned char *, unsigned))ssl_sw[39].ptr)
+typedef int (*tSSL_alpn_select_cb)(SSL *ssl,
+                                   const unsigned char **out,
+                                   unsigned char *outlen,
+                                   const unsigned char *in,
+                                   unsigned int inlen,
+                                   void *arg);
+#define SSL_CTX_set_alpn_select_cb                                             \
+	(*(void (*)(SSL_CTX *, tSSL_alpn_select_cb, void *))ssl_sw[40].ptr)
+typedef int (*tSSL_next_protos_advertised_cb)(SSL *ssl,
+                                              const unsigned char **out,
+                                              unsigned int *outlen,
+                                              void *arg);
+#define SSL_CTX_set_next_protos_advertised_cb                                  \
+	(*(void (*)(SSL_CTX *, tSSL_next_protos_advertised_cb, void *))ssl_sw[41]  \
+	      .ptr)
+
+#define SSL_CTX_set_timeout (*(long (*)(SSL_CTX *, long))ssl_sw[42].ptr)
+
+#define SSL_CTX_clear_options(ctx, op)                                         \
+	SSL_CTX_ctrl((ctx), SSL_CTRL_CLEAR_OPTIONS, (op), NULL)
+#define SSL_CTX_set_ecdh_auto(ctx, onoff)                                      \
+	SSL_CTX_ctrl(ctx, SSL_CTRL_SET_ECDH_AUTO, onoff, NULL)
+
+#define SSL_CTRL_SET_TLSEXT_SERVERNAME_CB 53
+#define SSL_CTRL_SET_TLSEXT_SERVERNAME_ARG 54
+#define SSL_CTRL_SET_TLSEXT_HOSTNAME 55
+#define SSL_CTX_set_tlsext_servername_callback(ctx, cb)                        \
+	SSL_CTX_callback_ctrl(ctx,                                                 \
+	                      SSL_CTRL_SET_TLSEXT_SERVERNAME_CB,                   \
+	                      (void (*)(void))cb)
+#define SSL_set_tlsext_host_name(ctx, arg)                                     \
+	SSL_ctrl(ctx, SSL_CTRL_SET_TLSEXT_HOSTNAME, 0, (void *)arg)
+
+#define X509_get_notBefore(x) ((x)->cert_info->validity->notBefore)
+#define X509_get_notAfter(x) ((x)->cert_info->validity->notAfter)
+
+#define SSL_set_app_data(s, arg) (SSL_set_ex_data(s, 0, (char *)arg))
+#define SSL_get_app_data(s) (SSL_get_ex_data(s, 0))
+
+#define SSL_CTX_sess_set_cache_size(ctx, size) SSL_CTX_ctrl(ctx, 42, size, NULL)
+#define SSL_CTX_set_session_cache_mode(ctx, mode)                              \
+	SSL_CTX_ctrl(ctx, 44, mode, NULL)
+
+
+#define ERR_get_error (*(unsigned long (*)(void))crypto_sw[0].ptr)
+#define ERR_error_string (*(char *(*)(unsigned long, char *))crypto_sw[1].ptr)
+#define CONF_modules_unload (*(void (*)(int))crypto_sw[2].ptr)
+#define X509_free (*(void (*)(X509 *))crypto_sw[3].ptr)
+#define X509_get_subject_name (*(X509_NAME * (*)(X509 *)) crypto_sw[4].ptr)
+#define X509_get_issuer_name (*(X509_NAME * (*)(X509 *)) crypto_sw[5].ptr)
+#define X509_NAME_oneline                                                      \
+	(*(char *(*)(X509_NAME *, char *, int))crypto_sw[6].ptr)
+#define X509_get_serialNumber (*(ASN1_INTEGER * (*)(X509 *)) crypto_sw[7].ptr)
+#define EVP_get_digestbyname                                                   \
+	(*(const EVP_MD *(*)(const char *))crypto_sw[8].ptr)
+#define EVP_Digest                                                             \
+	(*(int (*)(                                                                \
+	    const void *, size_t, void *, unsigned int *, const EVP_MD *, void *)) \
+	      crypto_sw[9]                                                         \
+	          .ptr)
+#define i2d_X509 (*(int (*)(X509 *, unsigned char **))crypto_sw[10].ptr)
+#define BN_bn2hex (*(char *(*)(const BIGNUM *a))crypto_sw[11].ptr)
+#define ASN1_INTEGER_to_BN                                                     \
+	(*(BIGNUM * (*)(const ASN1_INTEGER *ai, BIGNUM *bn)) crypto_sw[12].ptr)
+#define BN_free (*(void (*)(const BIGNUM *a))crypto_sw[13].ptr)
+#define CRYPTO_free (*(void (*)(void *addr))crypto_sw[14].ptr)
+#define ERR_clear_error (*(void (*)(void))crypto_sw[15].ptr)
+
+#define OPENSSL_free(a) CRYPTO_free(a)
+
+#define OPENSSL_REMOVE_THREAD_STATE()
+
+/* init_ssl_ctx() function updates this array.
+ * It loads SSL library dynamically and changes NULLs to the actual addresses
+ * of respective functions. The macros above (like SSL_connect()) are really
+ * just calling these functions indirectly via the pointer. */
+static struct ssl_func ssl_sw[] = {
+    {"SSL_free", TLS_Mandatory, NULL},
+    {"SSL_accept", TLS_Mandatory, NULL},
+    {"SSL_connect", TLS_Mandatory, NULL},
+    {"SSL_read", TLS_Mandatory, NULL},
+    {"SSL_write", TLS_Mandatory, NULL},
+    {"SSL_get_error", TLS_Mandatory, NULL},
+    {"SSL_set_fd", TLS_Mandatory, NULL},
+    {"SSL_new", TLS_Mandatory, NULL},
+    {"SSL_CTX_new", TLS_Mandatory, NULL},
+    {"TLS_server_method", TLS_Mandatory, NULL},
+    {"OPENSSL_init_ssl", TLS_Mandatory, NULL},
+    {"SSL_CTX_use_PrivateKey_file", TLS_Mandatory, NULL},
+    {"SSL_CTX_use_certificate_file", TLS_Mandatory, NULL},
+    {"SSL_CTX_set_default_passwd_cb", TLS_Mandatory, NULL},
+    {"SSL_CTX_free", TLS_Mandatory, NULL},
+    {"SSL_CTX_use_certificate_chain_file", TLS_Mandatory, NULL},
+    {"TLS_client_method", TLS_Mandatory, NULL},
+    {"SSL_pending", TLS_Mandatory, NULL},
+    {"SSL_CTX_set_verify", TLS_Mandatory, NULL},
+    {"SSL_shutdown", TLS_Mandatory, NULL},
+    {"SSL_CTX_load_verify_locations", TLS_Mandatory, NULL},
+    {"SSL_CTX_set_default_verify_paths", TLS_Mandatory, NULL},
+    {"SSL_CTX_set_verify_depth", TLS_Mandatory, NULL},
+#if defined(OPENSSL_API_3_0)
+    {"SSL_get1_peer_certificate", TLS_Mandatory, NULL},
+#else
+    {"SSL_get_peer_certificate", TLS_Mandatory, NULL},
+#endif
+    {"SSL_get_version", TLS_Mandatory, NULL},
+    {"SSL_get_current_cipher", TLS_Mandatory, NULL},
+    {"SSL_CIPHER_get_name", TLS_Mandatory, NULL},
+    {"SSL_CTX_check_private_key", TLS_Mandatory, NULL},
+    {"SSL_CTX_set_session_id_context", TLS_Mandatory, NULL},
+    {"SSL_CTX_ctrl", TLS_Mandatory, NULL},
+    {"SSL_CTX_set_cipher_list", TLS_Mandatory, NULL},
+    {"SSL_CTX_set_options", TLS_Mandatory, NULL},
+    {"SSL_CTX_set_info_callback", TLS_Mandatory, NULL},
+    {"SSL_get_ex_data", TLS_Mandatory, NULL},
+    {"SSL_set_ex_data", TLS_Mandatory, NULL},
+    {"SSL_CTX_callback_ctrl", TLS_Mandatory, NULL},
+    {"SSL_get_servername", TLS_Mandatory, NULL},
+    {"SSL_set_SSL_CTX", TLS_Mandatory, NULL},
+    {"SSL_ctrl", TLS_Mandatory, NULL},
+    {"SSL_CTX_set_alpn_protos", TLS_ALPN, NULL},
+    {"SSL_CTX_set_alpn_select_cb", TLS_ALPN, NULL},
+    {"SSL_CTX_set_next_protos_advertised_cb", TLS_ALPN, NULL},
+    {"SSL_CTX_set_timeout", TLS_Mandatory, NULL},
+    {NULL, TLS_END_OF_LIST, NULL}};
+
+
+/* Similar array as ssl_sw. These functions could be located in different
+ * lib. */
+static struct ssl_func crypto_sw[] = {
+    {"ERR_get_error", TLS_Mandatory, NULL},
+    {"ERR_error_string", TLS_Mandatory, NULL},
+    {"CONF_modules_unload", TLS_Mandatory, NULL},
+    {"X509_free", TLS_Mandatory, NULL},
+    {"X509_get_subject_name", TLS_Mandatory, NULL},
+    {"X509_get_issuer_name", TLS_Mandatory, NULL},
+    {"X509_NAME_oneline", TLS_Mandatory, NULL},
+    {"X509_get_serialNumber", TLS_Mandatory, NULL},
+    {"EVP_get_digestbyname", TLS_Mandatory, NULL},
+    {"EVP_Digest", TLS_Mandatory, NULL},
+    {"i2d_X509", TLS_Mandatory, NULL},
+    {"BN_bn2hex", TLS_Mandatory, NULL},
+    {"ASN1_INTEGER_to_BN", TLS_Mandatory, NULL},
+    {"BN_free", TLS_Mandatory, NULL},
+    {"CRYPTO_free", TLS_Mandatory, NULL},
+    {"ERR_clear_error", TLS_Mandatory, NULL},
+    {NULL, TLS_END_OF_LIST, NULL}};
+#endif
+
+
+#if defined(OPENSSL_API_1_0)
+
+#define SSL_free (*(void (*)(SSL *))ssl_sw[0].ptr)
+#define SSL_accept (*(int (*)(SSL *))ssl_sw[1].ptr)
+#define SSL_connect (*(int (*)(SSL *))ssl_sw[2].ptr)
+#define SSL_read (*(int (*)(SSL *, void *, int))ssl_sw[3].ptr)
+#define SSL_write (*(int (*)(SSL *, const void *, int))ssl_sw[4].ptr)
+#define SSL_get_error (*(int (*)(SSL *, int))ssl_sw[5].ptr)
+#define SSL_set_fd (*(int (*)(SSL *, SOCKET))ssl_sw[6].ptr)
+#define SSL_new (*(SSL * (*)(SSL_CTX *)) ssl_sw[7].ptr)
+#define SSL_CTX_new (*(SSL_CTX * (*)(SSL_METHOD *)) ssl_sw[8].ptr)
+#define SSLv23_server_method (*(SSL_METHOD * (*)(void)) ssl_sw[9].ptr)
+#define SSL_library_init (*(int (*)(void))ssl_sw[10].ptr)
+#define SSL_CTX_use_PrivateKey_file                                            \
+	(*(int (*)(SSL_CTX *, const char *, int))ssl_sw[11].ptr)
+#define SSL_CTX_use_certificate_file                                           \
+	(*(int (*)(SSL_CTX *, const char *, int))ssl_sw[12].ptr)
+#define SSL_CTX_set_default_passwd_cb                                          \
+	(*(void (*)(SSL_CTX *, mg_callback_t))ssl_sw[13].ptr)
+#define SSL_CTX_free (*(void (*)(SSL_CTX *))ssl_sw[14].ptr)
+#define SSL_load_error_strings (*(void (*)(void))ssl_sw[15].ptr)
+#define SSL_CTX_use_certificate_chain_file                                     \
+	(*(int (*)(SSL_CTX *, const char *))ssl_sw[16].ptr)
+#define SSLv23_client_method (*(SSL_METHOD * (*)(void)) ssl_sw[17].ptr)
+#define SSL_pending (*(int (*)(SSL *))ssl_sw[18].ptr)
+#define SSL_CTX_set_verify                                                     \
+	(*(void (*)(SSL_CTX *,                                                     \
+	            int,                                                           \
+	            int (*verify_callback)(int, X509_STORE_CTX *)))ssl_sw[19]      \
+	      .ptr)
+#define SSL_shutdown (*(int (*)(SSL *))ssl_sw[20].ptr)
+#define SSL_CTX_load_verify_locations                                          \
+	(*(int (*)(SSL_CTX *, const char *, const char *))ssl_sw[21].ptr)
+#define SSL_CTX_set_default_verify_paths (*(int (*)(SSL_CTX *))ssl_sw[22].ptr)
+#define SSL_CTX_set_verify_depth (*(void (*)(SSL_CTX *, int))ssl_sw[23].ptr)
+#define SSL_get_peer_certificate (*(X509 * (*)(SSL *)) ssl_sw[24].ptr)
+#define SSL_get_version (*(const char *(*)(SSL *))ssl_sw[25].ptr)
+#define SSL_get_current_cipher (*(SSL_CIPHER * (*)(SSL *)) ssl_sw[26].ptr)
+#define SSL_CIPHER_get_name                                                    \
+	(*(const char *(*)(const SSL_CIPHER *))ssl_sw[27].ptr)
+#define SSL_CTX_check_private_key (*(int (*)(SSL_CTX *))ssl_sw[28].ptr)
+#define SSL_CTX_set_session_id_context                                         \
+	(*(int (*)(SSL_CTX *, const unsigned char *, unsigned int))ssl_sw[29].ptr)
+#define SSL_CTX_ctrl (*(long (*)(SSL_CTX *, int, long, void *))ssl_sw[30].ptr)
+#define SSL_CTX_set_cipher_list                                                \
+	(*(int (*)(SSL_CTX *, const char *))ssl_sw[31].ptr)
+#define SSL_CTX_set_info_callback                                              \
+	(*(void (*)(SSL_CTX *, void (*callback)(const SSL *, int, int)))ssl_sw[32] \
+	      .ptr)
+#define SSL_get_ex_data (*(char *(*)(const SSL *, int))ssl_sw[33].ptr)
+#define SSL_set_ex_data (*(void (*)(SSL *, int, char *))ssl_sw[34].ptr)
+#define SSL_CTX_callback_ctrl                                                  \
+	(*(long (*)(SSL_CTX *, int, void (*)(void)))ssl_sw[35].ptr)
+#define SSL_get_servername                                                     \
+	(*(const char *(*)(const SSL *, int type))ssl_sw[36].ptr)
+#define SSL_set_SSL_CTX (*(SSL_CTX * (*)(SSL *, SSL_CTX *)) ssl_sw[37].ptr)
+#define SSL_ctrl (*(long (*)(SSL *, int, long, void *))ssl_sw[38].ptr)
+#define SSL_CTX_set_alpn_protos                                                \
+	(*(int (*)(SSL_CTX *, const unsigned char *, unsigned))ssl_sw[39].ptr)
+typedef int (*tSSL_alpn_select_cb)(SSL *ssl,
+                                   const unsigned char **out,
+                                   unsigned char *outlen,
+                                   const unsigned char *in,
+                                   unsigned int inlen,
+                                   void *arg);
+#define SSL_CTX_set_alpn_select_cb                                             \
+	(*(void (*)(SSL_CTX *, tSSL_alpn_select_cb, void *))ssl_sw[40].ptr)
+typedef int (*tSSL_next_protos_advertised_cb)(SSL *ssl,
+                                              const unsigned char **out,
+                                              unsigned int *outlen,
+                                              void *arg);
+#define SSL_CTX_set_next_protos_advertised_cb                                  \
+	(*(void (*)(SSL_CTX *, tSSL_next_protos_advertised_cb, void *))ssl_sw[41]  \
+	      .ptr)
+
+#define SSL_CTX_set_timeout (*(long (*)(SSL_CTX *, long))ssl_sw[42].ptr)
+
+
+#define SSL_CTX_set_options(ctx, op)                                           \
+	SSL_CTX_ctrl((ctx), SSL_CTRL_OPTIONS, (op), NULL)
+#define SSL_CTX_clear_options(ctx, op)                                         \
+	SSL_CTX_ctrl((ctx), SSL_CTRL_CLEAR_OPTIONS, (op), NULL)
+#define SSL_CTX_set_ecdh_auto(ctx, onoff)                                      \
+	SSL_CTX_ctrl(ctx, SSL_CTRL_SET_ECDH_AUTO, onoff, NULL)
+
+#define SSL_CTRL_SET_TLSEXT_SERVERNAME_CB 53
+#define SSL_CTRL_SET_TLSEXT_SERVERNAME_ARG 54
+#define SSL_CTRL_SET_TLSEXT_HOSTNAME 55
+#define SSL_CTX_set_tlsext_servername_callback(ctx, cb)                        \
+	SSL_CTX_callback_ctrl(ctx,                                                 \
+	                      SSL_CTRL_SET_TLSEXT_SERVERNAME_CB,                   \
+	                      (void (*)(void))cb)
+#define SSL_set_tlsext_host_name(ctx, arg)                                     \
+	SSL_ctrl(ctx, SSL_CTRL_SET_TLSEXT_HOSTNAME, 0, (void *)arg)
+
+#define X509_get_notBefore(x) ((x)->cert_info->validity->notBefore)
+#define X509_get_notAfter(x) ((x)->cert_info->validity->notAfter)
+
+#define SSL_set_app_data(s, arg) (SSL_set_ex_data(s, 0, (char *)arg))
+#define SSL_get_app_data(s) (SSL_get_ex_data(s, 0))
+
+#define SSL_CTX_sess_set_cache_size(ctx, size) SSL_CTX_ctrl(ctx, 42, size, NULL)
+#define SSL_CTX_set_session_cache_mode(ctx, mode)                              \
+	SSL_CTX_ctrl(ctx, 44, mode, NULL)
+
+
+#define CRYPTO_num_locks (*(int (*)(void))crypto_sw[0].ptr)
+#define CRYPTO_set_locking_callback                                            \
+	(*(void (*)(void (*)(int, int, const char *, int)))crypto_sw[1].ptr)
+#define CRYPTO_set_id_callback                                                 \
+	(*(void (*)(unsigned long (*)(void)))crypto_sw[2].ptr)
+#define ERR_get_error (*(unsigned long (*)(void))crypto_sw[3].ptr)
+#define ERR_error_string (*(char *(*)(unsigned long, char *))crypto_sw[4].ptr)
+#define ERR_remove_state (*(void (*)(unsigned long))crypto_sw[5].ptr)
+#define ERR_free_strings (*(void (*)(void))crypto_sw[6].ptr)
+#define ENGINE_cleanup (*(void (*)(void))crypto_sw[7].ptr)
+#define CONF_modules_unload (*(void (*)(int))crypto_sw[8].ptr)
+#define CRYPTO_cleanup_all_ex_data (*(void (*)(void))crypto_sw[9].ptr)
+#define EVP_cleanup (*(void (*)(void))crypto_sw[10].ptr)
+#define X509_free (*(void (*)(X509 *))crypto_sw[11].ptr)
+#define X509_get_subject_name (*(X509_NAME * (*)(X509 *)) crypto_sw[12].ptr)
+#define X509_get_issuer_name (*(X509_NAME * (*)(X509 *)) crypto_sw[13].ptr)
+#define X509_NAME_oneline                                                      \
+	(*(char *(*)(X509_NAME *, char *, int))crypto_sw[14].ptr)
+#define X509_get_serialNumber (*(ASN1_INTEGER * (*)(X509 *)) crypto_sw[15].ptr)
+#define i2c_ASN1_INTEGER                                                       \
+	(*(int (*)(ASN1_INTEGER *, unsigned char **))crypto_sw[16].ptr)
+#define EVP_get_digestbyname                                                   \
+	(*(const EVP_MD *(*)(const char *))crypto_sw[17].ptr)
+#define EVP_Digest                                                             \
+	(*(int (*)(                                                                \
+	    const void *, size_t, void *, unsigned int *, const EVP_MD *, void *)) \
+	      crypto_sw[18]                                                        \
+	          .ptr)
+#define i2d_X509 (*(int (*)(X509 *, unsigned char **))crypto_sw[19].ptr)
+#define BN_bn2hex (*(char *(*)(const BIGNUM *a))crypto_sw[20].ptr)
+#define ASN1_INTEGER_to_BN                                                     \
+	(*(BIGNUM * (*)(const ASN1_INTEGER *ai, BIGNUM *bn)) crypto_sw[21].ptr)
+#define BN_free (*(void (*)(const BIGNUM *a))crypto_sw[22].ptr)
+#define CRYPTO_free (*(void (*)(void *addr))crypto_sw[23].ptr)
+#define ERR_clear_error (*(void (*)(void))crypto_sw[24].ptr)
+
+#define OPENSSL_free(a) CRYPTO_free(a)
+
+/* use here ERR_remove_state,
+ * while on some platforms function is not included into library due to
+ * deprication */
+#define OPENSSL_REMOVE_THREAD_STATE() ERR_remove_state(0)
+
+/* init_ssl_ctx() function updates this array.
+ * It loads SSL library dynamically and changes NULLs to the actual addresses
+ * of respective functions. The macros above (like SSL_connect()) are really
+ * just calling these functions indirectly via the pointer. */
+static struct ssl_func ssl_sw[] = {
+    {"SSL_free", TLS_Mandatory, NULL},
+    {"SSL_accept", TLS_Mandatory, NULL},
+    {"SSL_connect", TLS_Mandatory, NULL},
+    {"SSL_read", TLS_Mandatory, NULL},
+    {"SSL_write", TLS_Mandatory, NULL},
+    {"SSL_get_error", TLS_Mandatory, NULL},
+    {"SSL_set_fd", TLS_Mandatory, NULL},
+    {"SSL_new", TLS_Mandatory, NULL},
+    {"SSL_CTX_new", TLS_Mandatory, NULL},
+    {"SSLv23_server_method", TLS_Mandatory, NULL},
+    {"SSL_library_init", TLS_Mandatory, NULL},
+    {"SSL_CTX_use_PrivateKey_file", TLS_Mandatory, NULL},
+    {"SSL_CTX_use_certificate_file", TLS_Mandatory, NULL},
+    {"SSL_CTX_set_default_passwd_cb", TLS_Mandatory, NULL},
+    {"SSL_CTX_free", TLS_Mandatory, NULL},
+    {"SSL_load_error_strings", TLS_Mandatory, NULL},
+    {"SSL_CTX_use_certificate_chain_file", TLS_Mandatory, NULL},
+    {"SSLv23_client_method", TLS_Mandatory, NULL},
+    {"SSL_pending", TLS_Mandatory, NULL},
+    {"SSL_CTX_set_verify", TLS_Mandatory, NULL},
+    {"SSL_shutdown", TLS_Mandatory, NULL},
+    {"SSL_CTX_load_verify_locations", TLS_Mandatory, NULL},
+    {"SSL_CTX_set_default_verify_paths", TLS_Mandatory, NULL},
+    {"SSL_CTX_set_verify_depth", TLS_Mandatory, NULL},
+    {"SSL_get_peer_certificate", TLS_Mandatory, NULL},
+    {"SSL_get_version", TLS_Mandatory, NULL},
+    {"SSL_get_current_cipher", TLS_Mandatory, NULL},
+    {"SSL_CIPHER_get_name", TLS_Mandatory, NULL},
+    {"SSL_CTX_check_private_key", TLS_Mandatory, NULL},
+    {"SSL_CTX_set_session_id_context", TLS_Mandatory, NULL},
+    {"SSL_CTX_ctrl", TLS_Mandatory, NULL},
+    {"SSL_CTX_set_cipher_list", TLS_Mandatory, NULL},
+    {"SSL_CTX_set_info_callback", TLS_Mandatory, NULL},
+    {"SSL_get_ex_data", TLS_Mandatory, NULL},
+    {"SSL_set_ex_data", TLS_Mandatory, NULL},
+    {"SSL_CTX_callback_ctrl", TLS_Mandatory, NULL},
+    {"SSL_get_servername", TLS_Mandatory, NULL},
+    {"SSL_set_SSL_CTX", TLS_Mandatory, NULL},
+    {"SSL_ctrl", TLS_Mandatory, NULL},
+    {"SSL_CTX_set_alpn_protos", TLS_ALPN, NULL},
+    {"SSL_CTX_set_alpn_select_cb", TLS_ALPN, NULL},
+    {"SSL_CTX_set_next_protos_advertised_cb", TLS_ALPN, NULL},
+    {"SSL_CTX_set_timeout", TLS_Mandatory, NULL},
+    {NULL, TLS_END_OF_LIST, NULL}};
+
+
+/* Similar array as ssl_sw. These functions could be located in different
+ * lib. */
+static struct ssl_func crypto_sw[] = {
+    {"CRYPTO_num_locks", TLS_Mandatory, NULL},
+    {"CRYPTO_set_locking_callback", TLS_Mandatory, NULL},
+    {"CRYPTO_set_id_callback", TLS_Mandatory, NULL},
+    {"ERR_get_error", TLS_Mandatory, NULL},
+    {"ERR_error_string", TLS_Mandatory, NULL},
+    {"ERR_remove_state", TLS_Mandatory, NULL},
+    {"ERR_free_strings", TLS_Mandatory, NULL},
+    {"ENGINE_cleanup", TLS_Mandatory, NULL},
+    {"CONF_modules_unload", TLS_Mandatory, NULL},
+    {"CRYPTO_cleanup_all_ex_data", TLS_Mandatory, NULL},
+    {"EVP_cleanup", TLS_Mandatory, NULL},
+    {"X509_free", TLS_Mandatory, NULL},
+    {"X509_get_subject_name", TLS_Mandatory, NULL},
+    {"X509_get_issuer_name", TLS_Mandatory, NULL},
+    {"X509_NAME_oneline", TLS_Mandatory, NULL},
+    {"X509_get_serialNumber", TLS_Mandatory, NULL},
+    {"i2c_ASN1_INTEGER", TLS_Mandatory, NULL},
+    {"EVP_get_digestbyname", TLS_Mandatory, NULL},
+    {"EVP_Digest", TLS_Mandatory, NULL},
+    {"i2d_X509", TLS_Mandatory, NULL},
+    {"BN_bn2hex", TLS_Mandatory, NULL},
+    {"ASN1_INTEGER_to_BN", TLS_Mandatory, NULL},
+    {"BN_free", TLS_Mandatory, NULL},
+    {"CRYPTO_free", TLS_Mandatory, NULL},
+    {"ERR_clear_error", TLS_Mandatory, NULL},
+    {NULL, TLS_END_OF_LIST, NULL}};
+#endif /* OPENSSL_API_1_0 */

vendor/CivetWeb/response.inl

@@ -0,0 +1,326 @@
+/* response.inl
+ *
+ * Bufferring for HTTP headers for HTTP response.
+ * This function are only intended to be used at the server side.
+ * Optional for HTTP/1.0 and HTTP/1.1, mandatory for HTTP/2.
+ *
+ * This file is part of the CivetWeb project.
+ */
+
+#if defined(NO_RESPONSE_BUFFERING) && defined(USE_HTTP2)
+#error "HTTP2 works only if NO_RESPONSE_BUFFERING is not set"
+#endif
+
+
+/* Internal function to free header list */
+static void
+free_buffered_response_header_list(struct mg_connection *conn)
+{
+#if !defined(NO_RESPONSE_BUFFERING)
+	while (conn->response_info.num_headers > 0) {
+		conn->response_info.num_headers--;
+		mg_free((void *)conn->response_info
+		            .http_headers[conn->response_info.num_headers]
+		            .name);
+		conn->response_info.http_headers[conn->response_info.num_headers].name =
+		    0;
+		mg_free((void *)conn->response_info
+		            .http_headers[conn->response_info.num_headers]
+		            .value);
+		conn->response_info.http_headers[conn->response_info.num_headers]
+		    .value = 0;
+	}
+#else
+	(void)conn; /* Nothing to do */
+#endif
+}
+
+
+/* Send first line of HTTP/1.x response */
+static void
+send_http1_response_status_line(struct mg_connection *conn)
+{
+	const char *status_txt;
+	const char *http_version = conn->request_info.http_version;
+	int status_code = conn->status_code;
+
+	if ((status_code < 100) || (status_code > 999)) {
+		/* Set invalid status code to "500 Internal Server Error" */
+		status_code = 500;
+	}
+	if (!http_version) {
+		http_version = "1.0";
+	}
+
+	/* mg_get_response_code_text will never return NULL */
+	status_txt = mg_get_response_code_text(conn, conn->status_code);
+
+	mg_printf(conn, "HTTP/%s %i %s\r\n", http_version, status_code, status_txt);
+}
+
+
+/* Initialize a new HTTP response
+ * Parameters:
+ *   conn: Current connection handle.
+ *   status: HTTP status code (e.g., 200 for "OK").
+ * Return:
+ *   0:    ok
+ *  -1:    parameter error
+ *  -2:    invalid connection type
+ *  -3:    invalid connection status
+ */
+int
+mg_response_header_start(struct mg_connection *conn, int status)
+{
+	if ((conn == NULL) || (status < 100) || (status > 999)) {
+		/* Parameter error */
+		return -1;
+	}
+	if ((conn->connection_type != CONNECTION_TYPE_REQUEST)
+	    || (conn->protocol_type == PROTOCOL_TYPE_WEBSOCKET)) {
+		/* Only allowed in server context */
+		return -2;
+	}
+	if (conn->request_state != 0) {
+		/* only allowed if nothing was sent up to now */
+		return -3;
+	}
+	conn->status_code = status;
+	conn->request_state = 1;
+
+	/* Buffered response is stored, unbuffered response will be sent directly,
+	 * but we can only send HTTP/1.x response here */
+#if !defined(NO_RESPONSE_BUFFERING)
+	free_buffered_response_header_list(conn);
+#else
+	send_http1_response_status_line(conn);
+	conn->request_state = 1; /* Reset from 10 to 1 */
+#endif
+
+	return 0;
+}
+
+
+/* Add a new HTTP response header line
+ * Parameters:
+ *   conn: Current connection handle.
+ *   header: Header name.
+ *   value: Header value.
+ *   value_len: Length of header value, excluding the terminating zero.
+ *              Use -1 for "strlen(value)".
+ * Return:
+ *    0:    ok
+ *   -1:    parameter error
+ *   -2:    invalid connection type
+ *   -3:    invalid connection status
+ *   -4:    too many headers
+ *   -5:    out of memory
+ */
+int
+mg_response_header_add(struct mg_connection *conn,
+                       const char *header,
+                       const char *value,
+                       int value_len)
+{
+#if !defined(NO_RESPONSE_BUFFERING)
+	int hidx;
+#endif
+
+	if ((conn == NULL) || (header == NULL) || (value == NULL)) {
+		/* Parameter error */
+		return -1;
+	}
+	if ((conn->connection_type != CONNECTION_TYPE_REQUEST)
+	    || (conn->protocol_type == PROTOCOL_TYPE_WEBSOCKET)) {
+		/* Only allowed in server context */
+		return -2;
+	}
+	if (conn->request_state != 1) {
+		/* only allowed if mg_response_header_start has been called before */
+		return -3;
+	}
+
+#if !defined(NO_RESPONSE_BUFFERING)
+	hidx = conn->response_info.num_headers;
+	if (hidx >= MG_MAX_HEADERS) {
+		/* Too many headers */
+		return -4;
+	}
+
+	/* Alloc new element */
+	conn->response_info.http_headers[hidx].name =
+	    mg_strdup_ctx(header, conn->phys_ctx);
+	if (value_len >= 0) {
+		char *hbuf =
+		    (char *)mg_malloc_ctx((unsigned)value_len + 1, conn->phys_ctx);
+		if (hbuf) {
+			memcpy(hbuf, value, (unsigned)value_len);
+			hbuf[value_len] = 0;
+		}
+		conn->response_info.http_headers[hidx].value = hbuf;
+	} else {
+		conn->response_info.http_headers[hidx].value =
+		    mg_strdup_ctx(value, conn->phys_ctx);
+	}
+
+	if ((conn->response_info.http_headers[hidx].name == 0)
+	    || (conn->response_info.http_headers[hidx].value == 0)) {
+		/* Out of memory */
+		mg_free((void *)conn->response_info.http_headers[hidx].name);
+		conn->response_info.http_headers[hidx].name = 0;
+		mg_free((void *)conn->response_info.http_headers[hidx].value);
+		conn->response_info.http_headers[hidx].value = 0;
+		return -5;
+	}
+
+	/* OK, header stored */
+	conn->response_info.num_headers++;
+
+#else
+	if (value_len >= 0) {
+		mg_printf(conn, "%s: %.*s\r\n", header, (int)value_len, value);
+	} else {
+		mg_printf(conn, "%s: %s\r\n", header, value);
+	}
+	conn->request_state = 1; /* Reset from 10 to 1 */
+#endif
+
+	return 0;
+}
+
+
+/* forward */
+static int parse_http_headers(char **buf, struct mg_header hdr[MG_MAX_HEADERS]);
+
+
+/* Add a complete header string (key + value).
+ * Parameters:
+ *   conn: Current connection handle.
+ *   http1_headers: Header line(s) in the form "name: value".
+ * Return:
+ *  >=0:   no error, number of header lines added
+ *  -1:    parameter error
+ *  -2:    invalid connection type
+ *  -3:    invalid connection status
+ *  -4:    too many headers
+ *  -5:    out of memory
+ */
+int
+mg_response_header_add_lines(struct mg_connection *conn,
+                             const char *http1_headers)
+{
+	struct mg_header add_hdr[MG_MAX_HEADERS];
+	int num_hdr, i, ret;
+	char *workbuffer, *parse;
+
+	/* We need to work on a copy of the work buffer, sice parse_http_headers
+	 * will modify */
+	workbuffer = mg_strdup_ctx(http1_headers, conn->phys_ctx);
+	if (!workbuffer) {
+		/* Out of memory */
+		return -5;
+	}
+
+	/* Call existing method to split header buffer */
+	parse = workbuffer;
+	num_hdr = parse_http_headers(&parse, add_hdr);
+	ret = num_hdr;
+
+	for (i = 0; i < num_hdr; i++) {
+		int lret =
+		    mg_response_header_add(conn, add_hdr[i].name, add_hdr[i].value, -1);
+		if ((ret > 0) && (lret < 0)) {
+			/* Store error return value */
+			ret = lret;
+		}
+	}
+
+	/* mg_response_header_add created a copy, so we can free the original */
+	mg_free(workbuffer);
+	return ret;
+}
+
+
+#if defined(USE_HTTP2)
+static int http2_send_response_headers(struct mg_connection *conn);
+#endif
+
+
+/* Send http response
+ * Parameters:
+ *   conn: Current connection handle.
+ * Return:
+ *   0:    ok
+ *  -1:    parameter error
+ *  -2:    invalid connection type
+ *  -3:    invalid connection status
+ */
+int
+mg_response_header_send(struct mg_connection *conn)
+{
+#if !defined(NO_RESPONSE_BUFFERING)
+	int i;
+	int has_date = 0;
+	int has_connection = 0;
+#endif
+
+	if (conn == NULL) {
+		/* Parameter error */
+		return -1;
+	}
+	if ((conn->connection_type != CONNECTION_TYPE_REQUEST)
+	    || (conn->protocol_type == PROTOCOL_TYPE_WEBSOCKET)) {
+		/* Only allowed in server context */
+		return -2;
+	}
+	if (conn->request_state != 1) {
+		/* only allowed if mg_response_header_start has been called before */
+		return -3;
+	}
+
+	/* State: 2 */
+	conn->request_state = 2;
+
+#if !defined(NO_RESPONSE_BUFFERING)
+#if defined(USE_HTTP2)
+	if (conn->protocol_type == PROTOCOL_TYPE_HTTP2) {
+		int ret = http2_send_response_headers(conn);
+		return ret ? 0 : 0; /* todo */
+	}
+#endif
+
+	/* Send */
+	send_http1_response_status_line(conn);
+	for (i = 0; i < conn->response_info.num_headers; i++) {
+		mg_printf(conn,
+		          "%s: %s\r\n",
+		          conn->response_info.http_headers[i].name,
+		          conn->response_info.http_headers[i].value);
+
+		/* Check for some special headers */
+		if (!mg_strcasecmp("Date", conn->response_info.http_headers[i].name)) {
+			has_date = 1;
+		}
+		if (!mg_strcasecmp("Connection",
+		                   conn->response_info.http_headers[i].name)) {
+			has_connection = 1;
+		}
+	}
+
+	if (!has_date) {
+		time_t curtime = time(NULL);
+		char date[64];
+		gmt_time_string(date, sizeof(date), &curtime);
+		mg_printf(conn, "Date: %s\r\n", date);
+	}
+	if (!has_connection) {
+		mg_printf(conn, "Connection: %s\r\n", suggest_connection_header(conn));
+	}
+#endif
+
+	mg_write(conn, "\r\n", 2);
+	conn->request_state = 3;
+
+	/* ok */
+	return 0;
+}

vendor/CivetWeb/sha1.inl

@@ -0,0 +1,323 @@
+/*
+SHA-1 in C
+By Steve Reid <sreid@sea-to-sky.net>
+100% Public Domain
+
+-----------------
+Modified 7/98
+By James H. Brown <jbrown@burgoyne.com>
+Still 100% Public Domain
+
+Corrected a problem which generated improper hash values on 16 bit machines
+Routine SHA1Update changed from
+    void SHA1Update(SHA_CTX* context, unsigned char* data, unsigned int
+len)
+to
+    void SHA1Update(SHA_CTX* context, unsigned char* data, unsigned
+long len)
+
+The 'len' parameter was declared an int which works fine on 32 bit machines.
+However, on 16 bit machines an int is too small for the shifts being done
+against
+it.  This caused the hash function to generate incorrect values if len was
+greater than 8191 (8K - 1) due to the 'len << 3' on line 3 of SHA1Update().
+
+Since the file IO in main() reads 16K at a time, any file 8K or larger would
+be guaranteed to generate the wrong hash (e.g. Test Vector #3, a million
+"a"s).
+
+I also changed the declaration of variables i & j in SHA1Update to
+unsigned long from unsigned int for the same reason.
+
+These changes should make no difference to any 32 bit implementations since
+an
+int and a long are the same size in those environments.
+
+--
+I also corrected a few compiler warnings generated by Borland C.
+1. Added #include <process.h> for exit() prototype
+2. Removed unused variable 'j' in SHA1Final
+3. Changed exit(0) to return(0) at end of main.
+
+ALL changes I made can be located by searching for comments containing 'JHB'
+-----------------
+Modified 8/98
+By Steve Reid <sreid@sea-to-sky.net>
+Still 100% public domain
+
+1- Removed #include <process.h> and used return() instead of exit()
+2- Fixed overwriting of finalcount in SHA1Final() (discovered by Chris Hall)
+3- Changed email address from steve@edmweb.com to sreid@sea-to-sky.net
+
+-----------------
+Modified 4/01
+By Saul Kravitz <Saul.Kravitz@celera.com>
+Still 100% PD
+Modified to run on Compaq Alpha hardware.
+
+-----------------
+Modified 07/2002
+By Ralph Giles <giles@ghostscript.com>
+Still 100% public domain
+modified for use with stdint types, autoconf
+code cleanup, removed attribution comments
+switched SHA1Final() argument order for consistency
+use SHA1_ prefix for public api
+move public api to sha1.h
+*/
+
+/*
+11/2016 adapted for CivetWeb:
+  include sha1.h in sha1.c,
+  rename to sha1.inl
+  remove unused #ifdef sections
+  make endian independent
+  align buffer to 4 bytes
+  remove unused variable assignments
+*/
+
+/*
+Test Vectors (from FIPS PUB 180-1)
+"abc"
+  A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D
+"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
+  84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1
+A million repetitions of "a"
+  34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F
+*/
+
+#include <stdint.h>
+#include <string.h>
+
+typedef struct {
+	uint32_t state[5];
+	uint32_t count[2];
+	uint8_t buffer[64];
+} SHA_CTX;
+
+#define SHA1_DIGEST_SIZE 20
+
+#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
+
+/* blk0() and blk() perform the initial expand. */
+/* I got the idea of expanding during the round function from SSLeay */
+
+
+typedef union {
+	uint8_t c[64];
+	uint32_t l[16];
+} CHAR64LONG16;
+
+
+static uint32_t
+blk0(CHAR64LONG16 *block, int i)
+{
+	static const uint32_t n = 1u;
+	if ((*((uint8_t *)(&n))) == 1) {
+		/* little endian / intel byte order */
+		block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00)
+		              | (rol(block->l[i], 8) & 0x00FF00FF);
+	}
+	return block->l[i];
+}
+
+#define blk(block, i)                                                          \
+	((block)->l[(i)&15] =                                                      \
+	     rol((block)->l[((i) + 13) & 15] ^ (block)->l[((i) + 8) & 15]          \
+	             ^ (block)->l[((i) + 2) & 15] ^ (block)->l[(i)&15],            \
+	         1))
+
+/* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
+#define R0(v, w, x, y, z, i)                                                   \
+	z += ((w & (x ^ y)) ^ y) + blk0(block, i) + 0x5A827999 + rol(v, 5);        \
+	w = rol(w, 30);
+#define R1(v, w, x, y, z, i)                                                   \
+	z += ((w & (x ^ y)) ^ y) + blk(block, i) + 0x5A827999 + rol(v, 5);         \
+	w = rol(w, 30);
+#define R2(v, w, x, y, z, i)                                                   \
+	z += (w ^ x ^ y) + blk(block, i) + 0x6ED9EBA1 + rol(v, 5);                 \
+	w = rol(w, 30);
+#define R3(v, w, x, y, z, i)                                                   \
+	z += (((w | x) & y) | (w & x)) + blk(block, i) + 0x8F1BBCDC + rol(v, 5);   \
+	w = rol(w, 30);
+#define R4(v, w, x, y, z, i)                                                   \
+	z += (w ^ x ^ y) + blk(block, i) + 0xCA62C1D6 + rol(v, 5);                 \
+	w = rol(w, 30);
+
+
+/* Hash a single 512-bit block. This is the core of the algorithm. */
+static void
+SHA1_Transform(uint32_t state[5], const uint8_t buffer[64])
+{
+	uint32_t a, b, c, d, e;
+
+	/* Must use an aligned, read/write buffer */
+	CHAR64LONG16 block[1];
+	memcpy(block, buffer, sizeof(block));
+
+	/* Copy context->state[] to working vars */
+	a = state[0];
+	b = state[1];
+	c = state[2];
+	d = state[3];
+	e = state[4];
+
+	/* 4 rounds of 20 operations each. Loop unrolled. */
+	R0(a, b, c, d, e, 0);
+	R0(e, a, b, c, d, 1);
+	R0(d, e, a, b, c, 2);
+	R0(c, d, e, a, b, 3);
+	R0(b, c, d, e, a, 4);
+	R0(a, b, c, d, e, 5);
+	R0(e, a, b, c, d, 6);
+	R0(d, e, a, b, c, 7);
+	R0(c, d, e, a, b, 8);
+	R0(b, c, d, e, a, 9);
+	R0(a, b, c, d, e, 10);
+	R0(e, a, b, c, d, 11);
+	R0(d, e, a, b, c, 12);
+	R0(c, d, e, a, b, 13);
+	R0(b, c, d, e, a, 14);
+	R0(a, b, c, d, e, 15);
+	R1(e, a, b, c, d, 16);
+	R1(d, e, a, b, c, 17);
+	R1(c, d, e, a, b, 18);
+	R1(b, c, d, e, a, 19);
+	R2(a, b, c, d, e, 20);
+	R2(e, a, b, c, d, 21);
+	R2(d, e, a, b, c, 22);
+	R2(c, d, e, a, b, 23);
+	R2(b, c, d, e, a, 24);
+	R2(a, b, c, d, e, 25);
+	R2(e, a, b, c, d, 26);
+	R2(d, e, a, b, c, 27);
+	R2(c, d, e, a, b, 28);
+	R2(b, c, d, e, a, 29);
+	R2(a, b, c, d, e, 30);
+	R2(e, a, b, c, d, 31);
+	R2(d, e, a, b, c, 32);
+	R2(c, d, e, a, b, 33);
+	R2(b, c, d, e, a, 34);
+	R2(a, b, c, d, e, 35);
+	R2(e, a, b, c, d, 36);
+	R2(d, e, a, b, c, 37);
+	R2(c, d, e, a, b, 38);
+	R2(b, c, d, e, a, 39);
+	R3(a, b, c, d, e, 40);
+	R3(e, a, b, c, d, 41);
+	R3(d, e, a, b, c, 42);
+	R3(c, d, e, a, b, 43);
+	R3(b, c, d, e, a, 44);
+	R3(a, b, c, d, e, 45);
+	R3(e, a, b, c, d, 46);
+	R3(d, e, a, b, c, 47);
+	R3(c, d, e, a, b, 48);
+	R3(b, c, d, e, a, 49);
+	R3(a, b, c, d, e, 50);
+	R3(e, a, b, c, d, 51);
+	R3(d, e, a, b, c, 52);
+	R3(c, d, e, a, b, 53);
+	R3(b, c, d, e, a, 54);
+	R3(a, b, c, d, e, 55);
+	R3(e, a, b, c, d, 56);
+	R3(d, e, a, b, c, 57);
+	R3(c, d, e, a, b, 58);
+	R3(b, c, d, e, a, 59);
+	R4(a, b, c, d, e, 60);
+	R4(e, a, b, c, d, 61);
+	R4(d, e, a, b, c, 62);
+	R4(c, d, e, a, b, 63);
+	R4(b, c, d, e, a, 64);
+	R4(a, b, c, d, e, 65);
+	R4(e, a, b, c, d, 66);
+	R4(d, e, a, b, c, 67);
+	R4(c, d, e, a, b, 68);
+	R4(b, c, d, e, a, 69);
+	R4(a, b, c, d, e, 70);
+	R4(e, a, b, c, d, 71);
+	R4(d, e, a, b, c, 72);
+	R4(c, d, e, a, b, 73);
+	R4(b, c, d, e, a, 74);
+	R4(a, b, c, d, e, 75);
+	R4(e, a, b, c, d, 76);
+	R4(d, e, a, b, c, 77);
+	R4(c, d, e, a, b, 78);
+	R4(b, c, d, e, a, 79);
+
+	/* Add the working vars back into context.state[] */
+	state[0] += a;
+	state[1] += b;
+	state[2] += c;
+	state[3] += d;
+	state[4] += e;
+}
+
+
+/* SHA1Init - Initialize new context */
+SHA_API void
+SHA1_Init(SHA_CTX *context)
+{
+	/* SHA1 initialization constants */
+	context->state[0] = 0x67452301;
+	context->state[1] = 0xEFCDAB89;
+	context->state[2] = 0x98BADCFE;
+	context->state[3] = 0x10325476;
+	context->state[4] = 0xC3D2E1F0;
+	context->count[0] = context->count[1] = 0;
+}
+
+
+SHA_API void
+SHA1_Update(SHA_CTX *context, const uint8_t *data, const uint32_t len)
+{
+	uint32_t i, j;
+
+	j = context->count[0];
+	if ((context->count[0] += (len << 3)) < j) {
+		context->count[1]++;
+	}
+	context->count[1] += (len >> 29);
+	j = (j >> 3) & 63;
+	if ((j + len) > 63) {
+		i = 64 - j;
+		memcpy(&context->buffer[j], data, i);
+		SHA1_Transform(context->state, context->buffer);
+		for (; i + 63 < len; i += 64) {
+			SHA1_Transform(context->state, &data[i]);
+		}
+		j = 0;
+	} else {
+		i = 0;
+	}
+	memcpy(&context->buffer[j], &data[i], len - i);
+}
+
+
+/* Add padding and return the message digest. */
+SHA_API void
+SHA1_Final(unsigned char *digest, SHA_CTX *context)
+{
+	uint32_t i;
+	uint8_t finalcount[8];
+
+	for (i = 0; i < 8; i++) {
+		finalcount[i] =
+		    (uint8_t)((context->count[(i >= 4 ? 0 : 1)] >> ((3 - (i & 3)) * 8))
+		              & 255); /* Endian independent */
+	}
+	SHA1_Update(context, (uint8_t *)"\x80", 1);
+	while ((context->count[0] & 504) != 448) {
+		SHA1_Update(context, (uint8_t *)"\x00", 1);
+	}
+	SHA1_Update(context, finalcount, 8); /* Should cause a SHA1_Transform() */
+	for (i = 0; i < SHA1_DIGEST_SIZE; i++) {
+		digest[i] =
+		    (uint8_t)((context->state[i >> 2] >> ((3 - (i & 3)) * 8)) & 255);
+	}
+
+	/* Wipe variables */
+	memset(context, '\0', sizeof(*context));
+}
+
+
+/* End of sha1.inl */

vendor/CivetWeb/timer.inl

@@ -0,0 +1,294 @@
+/* This file is part of the CivetWeb web server.
+ * See https://github.com/civetweb/civetweb/
+ * (C) 2014-2021 by the CivetWeb authors, MIT license.
+ */
+
+#if !defined(MAX_TIMERS)
+#define MAX_TIMERS MAX_WORKER_THREADS
+#endif
+#if !defined(TIMER_RESOLUTION)
+/* Timer resolution in ms */
+#define TIMER_RESOLUTION (10)
+#endif
+
+typedef int (*taction)(void *arg);
+typedef void (*tcancelaction)(void *arg);
+
+struct ttimer {
+	double time;
+	double period;
+	taction action;
+	void *arg;
+	tcancelaction cancel;
+};
+
+struct ttimers {
+	pthread_t threadid;      /* Timer thread ID */
+	pthread_mutex_t mutex;   /* Protects timer lists */
+	struct ttimer *timers;   /* List of timers */
+	unsigned timer_count;    /* Current size of timer list */
+	unsigned timer_capacity; /* Capacity of timer list */
+#if defined(_WIN32)
+	DWORD last_tick;
+	uint64_t now_tick64;
+#endif
+};
+
+
+TIMER_API double
+timer_getcurrenttime(struct mg_context *ctx)
+{
+#if defined(_WIN32)
+	/* GetTickCount returns milliseconds since system start as
+	 * unsigned 32 bit value. It will wrap around every 49.7 days.
+	 * We need to use a 64 bit counter (will wrap in 500 mio. years),
+	 * by adding the 32 bit difference since the last call to a
+	 * 64 bit counter. This algorithm will only work, if this
+	 * function is called at least once every 7 weeks. */
+	uint64_t now_tick64 = 0;
+	DWORD now_tick = GetTickCount();
+
+	if (ctx->timers) {
+		pthread_mutex_lock(&ctx->timers->mutex);
+		ctx->timers->now_tick64 += now_tick - ctx->timers->last_tick;
+		now_tick64 = ctx->timers->now_tick64;
+		ctx->timers->last_tick = now_tick;
+		pthread_mutex_unlock(&ctx->timers->mutex);
+	}
+	return (double)now_tick64 * 1.0E-3;
+#else
+	struct timespec now_ts;
+
+	(void)ctx;
+	clock_gettime(CLOCK_MONOTONIC, &now_ts);
+	return (double)now_ts.tv_sec + (double)now_ts.tv_nsec * 1.0E-9;
+#endif
+}
+
+
+TIMER_API int
+timer_add(struct mg_context *ctx,
+          double next_time,
+          double period,
+          int is_relative,
+          taction action,
+          void *arg,
+          tcancelaction cancel)
+{
+	int error = 0;
+	double now;
+
+	if (!ctx->timers) {
+		return 1;
+	}
+
+	now = timer_getcurrenttime(ctx);
+
+	/* HCP24: if is_relative = 0 and next_time < now
+	 *        action will be called so fast as possible
+	 *        if additional period > 0
+	 *        action will be called so fast as possible
+	 *        n times until (next_time + (n * period)) > now
+	 *        then the period is working
+	 * Solution:
+	 *        if next_time < now then we set next_time = now.
+	 *        The first callback will be so fast as possible (now)
+	 *        but the next callback on period
+	 */
+	if (is_relative) {
+		next_time += now;
+	}
+
+	/* You can not set timers into the past */
+	if (next_time < now) {
+		next_time = now;
+	}
+
+	pthread_mutex_lock(&ctx->timers->mutex);
+	if (ctx->timers->timer_count == MAX_TIMERS) {
+		error = 1;
+	} else if (ctx->timers->timer_count == ctx->timers->timer_capacity) {
+		unsigned capacity = (ctx->timers->timer_capacity * 2) + 1;
+		struct ttimer *timers =
+		    (struct ttimer *)mg_realloc_ctx(ctx->timers->timers,
+		                                    capacity * sizeof(struct ttimer),
+		                                    ctx);
+		if (timers) {
+			ctx->timers->timers = timers;
+			ctx->timers->timer_capacity = capacity;
+		} else {
+			error = 1;
+		}
+	}
+	if (!error) {
+		/* Insert new timer into a sorted list. */
+		/* The linear list is still most efficient for short lists (small
+		 * number of timers) - if there are many timers, different
+		 * algorithms will work better. */
+		unsigned u = ctx->timers->timer_count;
+		for (; (u > 0) && (ctx->timers->timers[u - 1].time > next_time); u--) {
+			ctx->timers->timers[u] = ctx->timers->timers[u - 1];
+		}
+		ctx->timers->timers[u].time = next_time;
+		ctx->timers->timers[u].period = period;
+		ctx->timers->timers[u].action = action;
+		ctx->timers->timers[u].arg = arg;
+		ctx->timers->timers[u].cancel = cancel;
+		ctx->timers->timer_count++;
+	}
+	pthread_mutex_unlock(&ctx->timers->mutex);
+	return error;
+}
+
+
+static void
+timer_thread_run(void *thread_func_param)
+{
+	struct mg_context *ctx = (struct mg_context *)thread_func_param;
+	double d;
+	unsigned u;
+	int action_res;
+	struct ttimer t;
+
+	mg_set_thread_name("timer");
+
+	if (ctx->callbacks.init_thread) {
+		/* Timer thread */
+		ctx->callbacks.init_thread(ctx, 2);
+	}
+
+	/* Timer main loop */
+	d = timer_getcurrenttime(ctx);
+	while (STOP_FLAG_IS_ZERO(&ctx->stop_flag)) {
+		pthread_mutex_lock(&ctx->timers->mutex);
+		if ((ctx->timers->timer_count > 0)
+		    && (d >= ctx->timers->timers[0].time)) {
+			/* Timer list is sorted. First action should run now. */
+			/* Store active timer in "t" */
+			t = ctx->timers->timers[0];
+
+			/* Shift all other timers */
+			for (u = 1; u < ctx->timers->timer_count; u++) {
+				ctx->timers->timers[u - 1] = ctx->timers->timers[u];
+			}
+			ctx->timers->timer_count--;
+
+			pthread_mutex_unlock(&ctx->timers->mutex);
+
+			/* Call timer action */
+			action_res = t.action(t.arg);
+
+			/* action_res == 1: reschedule */
+			/* action_res == 0: do not reschedule, free(arg) */
+			if ((action_res > 0) && (t.period > 0)) {
+				/* Should schedule timer again */
+				timer_add(ctx,
+				          t.time + t.period,
+				          t.period,
+				          0,
+				          t.action,
+				          t.arg,
+				          t.cancel);
+			} else {
+				/* Allow user to free timer argument */
+				if (t.cancel != NULL) {
+					t.cancel(t.arg);
+				}
+			}
+			continue;
+		} else {
+			pthread_mutex_unlock(&ctx->timers->mutex);
+		}
+
+		/* TIMER_RESOLUTION = 10 ms seems reasonable.
+		 * A faster loop (smaller sleep value) increases CPU load,
+		 * a slower loop (higher sleep value) decreases timer accuracy.
+		 */
+		mg_sleep(TIMER_RESOLUTION);
+
+		d = timer_getcurrenttime(ctx);
+	}
+
+	/* Remove remaining timers */
+	for (u = 0; u < ctx->timers->timer_count; u++) {
+		t = ctx->timers->timers[u];
+		if (t.cancel != NULL) {
+			t.cancel(t.arg);
+		}
+	}
+}
+
+
+#if defined(_WIN32)
+static unsigned __stdcall timer_thread(void *thread_func_param)
+{
+	timer_thread_run(thread_func_param);
+	return 0;
+}
+#else
+static void *
+timer_thread(void *thread_func_param)
+{
+	struct sigaction sa;
+
+	/* Ignore SIGPIPE */
+	memset(&sa, 0, sizeof(sa));
+	sa.sa_handler = SIG_IGN;
+	sigaction(SIGPIPE, &sa, NULL);
+
+	timer_thread_run(thread_func_param);
+	return NULL;
+}
+#endif /* _WIN32 */
+
+
+TIMER_API int
+timers_init(struct mg_context *ctx)
+{
+	/* Initialize timers data structure */
+	ctx->timers =
+	    (struct ttimers *)mg_calloc_ctx(sizeof(struct ttimers), 1, ctx);
+
+	if (!ctx->timers) {
+		return -1;
+	}
+	ctx->timers->timers = NULL;
+
+	/* Initialize mutex */
+	if (0 != pthread_mutex_init(&ctx->timers->mutex, NULL)) {
+		mg_free(ctx->timers);
+		ctx->timers = NULL;
+		return -1;
+	}
+
+	/* For some systems timer_getcurrenttime does some initialization
+	 * during the first call. Call it once now, ignore the result. */
+	(void)timer_getcurrenttime(ctx);
+
+	/* Start timer thread */
+	if (mg_start_thread_with_id(timer_thread, ctx, &ctx->timers->threadid)
+	    != 0) {
+		(void)pthread_mutex_destroy(&ctx->timers->mutex);
+		mg_free(ctx->timers);
+		ctx->timers = NULL;
+		return -1;
+	}
+
+	return 0;
+}
+
+
+TIMER_API void
+timers_exit(struct mg_context *ctx)
+{
+	if (ctx->timers) {
+		mg_join_thread(ctx->timers->threadid);
+		(void)pthread_mutex_destroy(&ctx->timers->mutex);
+		mg_free(ctx->timers->timers);
+		mg_free(ctx->timers);
+		ctx->timers = NULL;
+	}
+}
+
+
+/* End of timer.inl */

vendor/CivetWeb/wolfssl_extras.inl

@@ -0,0 +1,77 @@
+/* Additional defines for WolfSSL, see
+ * https://github.com/civetweb/civetweb/issues/583 */
+
+
+/* Required for WOLFSSL_X509 */
+#include <openssl/../internal.h>
+
+
+#define i2d_X509 cw_i2d_X509
+#define EVP_Digest cw_EVP_Digest
+
+
+/* i2d_X509 has no valid implementation in wolfssl
+ *
+ * The letters i and d in for example i2d_X509 stand for "internal" (that is an
+ *internal C structure)
+ * and " DER ". So that i2d_X509 converts from internal to DER.
+ *
+ * For OpenSSL 0.9.7 and later if *out is NULL memory will be allocated for a
+ *buffer and the encoded
+ * data written to it. In this case *out is not incremented and it points to the
+ *start of the data
+ * just written.
+ */
+int
+cw_i2d_X509(struct WOLFSSL_X509 *x, unsigned char **out)
+{
+	if (!x || !x->derCert) {
+		return -1;
+	}
+
+	const int ret = (int)x->derCert->length;
+
+	if (out && (ret > 0)) {
+		if (*out == NULL) {
+			*out = mg_malloc(ret);
+		}
+		if (*out != NULL) {
+			memcpy(*out, x->derCert->buffer, ret);
+		}
+	}
+
+	return ret;
+}
+
+
+/* EVP_Digest not in wolfssl */
+int
+cw_EVP_Digest(const void *data,
+              size_t count,
+              unsigned char *md,
+              unsigned int *size,
+              const EVP_MD *type,
+              ENGINE *impl)
+{
+	EVP_MD_CTX *ctx = EVP_MD_CTX_new();
+	int ret;
+
+	if (ctx == NULL)
+		return 0;
+
+	/* EVP_MD_CTX_set_flags(ctx, EVP_MD_CTX_FLAG_ONESHOT); */
+	ret = EVP_DigestInit_ex(ctx, type, impl)
+	      && EVP_DigestUpdate(ctx, data, count)
+	      && EVP_DigestFinal_ex(ctx, md, size);
+	EVP_MD_CTX_free(ctx);
+
+	return ret;
+}
+
+
+/*
+ * the variable SSL_OP_NO_TLSv1_1 is not defined within the context of
+ * wolfssl but since the methods using the value are all stubs, we can
+ * define it arbitrarily and it will not have any consequences
+ */
+#define SSL_OP_NO_TLSv1_1 (0x10000000L)

vendor/DPP/CMakeLists.txt

@@ -0,0 +1,174 @@
+# Create the DPP library
+add_library(DPP STATIC
+    include/dpp/nlohmann/json.hpp
+    include/dpp/nlohmann/json_fwd.hpp
+    include/dpp/auditlog.h
+    include/dpp/ban.h
+    include/dpp/cache.h
+    include/dpp/channel.h
+    include/dpp/cluster.h
+    include/dpp/commandhandler.h
+    include/dpp/discord.h
+    include/dpp/discordclient.h
+    include/dpp/discordevents.h
+    include/dpp/discordvoiceclient.h
+    include/dpp/dispatcher.h
+    include/dpp/dpp.h
+    include/dpp/dtemplate.h
+    include/dpp/emoji.h
+    include/dpp/event.h
+    include/dpp/export.h
+    include/dpp/guild.h
+    include/dpp/httplib.h
+    include/dpp/integration.h
+    include/dpp/intents.h
+    include/dpp/invite.h
+    include/dpp/json_fwd.hpp
+    include/dpp/message.h
+    include/dpp/presence.h
+    include/dpp/prune.h
+    include/dpp/queues.h
+    include/dpp/role.h
+    include/dpp/slashcommand.h
+    include/dpp/sslclient.h
+    include/dpp/stringops.h
+    include/dpp/user.h
+    include/dpp/version.h
+    include/dpp/voiceregion.h
+    include/dpp/voicestate.h
+    include/dpp/webhook.h
+    include/dpp/wsclient.h
+    src/dpp/ban.cpp
+    src/dpp/cache.cpp
+    src/dpp/channel.cpp
+    src/dpp/cluster.cpp
+    src/dpp/commandhandler.cpp
+    src/dpp/discordclient.cpp
+    src/dpp/discordevents.cpp
+    src/dpp/discordvoiceclient.cpp
+    src/dpp/dispatcher.cpp
+    src/dpp/dtemplate.cpp
+    src/dpp/emoji.cpp
+    src/dpp/guild.cpp
+    src/dpp/httplib.cpp
+    src/dpp/integration.cpp
+    src/dpp/invite.cpp
+    src/dpp/managed.cpp
+    src/dpp/message.cpp
+    src/dpp/presence.cpp
+    src/dpp/prune.cpp
+    src/dpp/queues.cpp
+    src/dpp/role.cpp
+    src/dpp/slashcommand.cpp
+    src/dpp/sslclient.cpp
+    src/dpp/user.cpp
+    src/dpp/utility.cpp
+    src/dpp/voiceregion.cpp
+    src/dpp/voicestate.cpp
+    src/dpp/webhook.cpp
+    src/dpp/wsclient.cpp
+    src/dpp/auditlog.cpp
+    src/dpp/events/application_command_update.cpp
+    src/dpp/events/channel_create.cpp
+    src/dpp/events/channel_delete.cpp
+    src/dpp/events/channel_pins_update.cpp
+    src/dpp/events/channel_update.cpp
+    src/dpp/events/guild_ban_add.cpp
+    src/dpp/events/guild_ban_remove.cpp
+    src/dpp/events/guild_create.cpp
+    src/dpp/events/guild_delete.cpp
+    src/dpp/events/guild_emojis_update.cpp
+    src/dpp/events/guild_integrations_update.cpp
+    src/dpp/events/guild_join_request_delete.cpp
+    src/dpp/events/guild_member_add.cpp
+    src/dpp/events/guild_member_remove.cpp
+    src/dpp/events/guild_member_update.cpp
+    src/dpp/events/guild_members_chunk.cpp
+    src/dpp/events/guild_role_create.cpp
+    src/dpp/events/guild_role_delete.cpp
+    src/dpp/events/guild_role_update.cpp
+    src/dpp/events/guild_stickers_update.cpp
+    src/dpp/events/guild_update.cpp
+    src/dpp/events/integration_create.cpp
+    src/dpp/events/integration_delete.cpp
+    src/dpp/events/integration_update.cpp
+    src/dpp/events/interaction_create.cpp
+    src/dpp/events/invite_create.cpp
+    src/dpp/events/invite_delete.cpp
+    src/dpp/events/logger.cpp
+    src/dpp/events/message_create.cpp
+    src/dpp/events/message_delete.cpp
+    src/dpp/events/message_delete_bulk.cpp
+    src/dpp/events/message_reaction_add.cpp
+    src/dpp/events/message_reaction_remove.cpp
+    src/dpp/events/message_reaction_remove_all.cpp
+    src/dpp/events/message_reaction_remove_emoji.cpp
+    src/dpp/events/message_update.cpp
+    src/dpp/events/presence_update.cpp
+    src/dpp/events/ready.cpp
+    src/dpp/events/resumed.cpp
+    src/dpp/events/stage_instance_create.cpp
+    src/dpp/events/stage_instance_delete.cpp
+    src/dpp/events/thread_create.cpp
+    src/dpp/events/thread_delete.cpp
+    src/dpp/events/thread_list_sync.cpp
+    src/dpp/events/thread_member_update.cpp
+    src/dpp/events/thread_members_update.cpp
+    src/dpp/events/thread_update.cpp
+    src/dpp/events/typing_start.cpp
+    src/dpp/events/user_update.cpp
+    src/dpp/events/voice_server_update.cpp
+    src/dpp/events/voice_state_update.cpp
+    src/dpp/events/webhooks_update.cpp
+    src/dpp/events/application_command_create.cpp
+    src/dpp/events/application_command_delete.cpp
+)
+# Configure include folders
+target_include_directories(DPP PRIVATE ${CMAKE_CURRENT_LIST_DIR}/src)
+target_include_directories(DPP PRIVATE ${CMAKE_CURRENT_LIST_DIR}/src/dpp)
+target_include_directories(DPP PUBLIC ${CMAKE_CURRENT_LIST_DIR}/include)
+# Link to built-in third-party libraries
+target_link_libraries(DPP PUBLIC fmt::fmt)
+# Project defines
+target_compile_definitions(DPP PUBLIC DPP_BUILD=1)
+# Platform defines
+if(WIN32)
+    target_compile_definitions(DPP PRIVATE _WIN32_WINNT=0x0601 OPENSSL_SYS_WIN32=1 _WINSOCK_DEPRECATED_NO_WARNINGS=1 WIN32_LEAN_AND_MEAN=1 _CRT_SECURE_NO_WARNINGS=1 _CRT_NONSTDC_NO_DEPRECATE=1)
+    if (MINGW)
+        target_compile_definitions(DPP PUBLIC WIN32=1)
+    endif()
+    target_link_libraries(DPP PRIVATE Crypt32)
+endif()
+# Third-party library preferences
+set(THREADS_PREFER_PTHREAD_FLAG ON)
+# Find required third-party libraries
+find_package(Threads REQUIRED)
+find_package(ZLIB REQUIRED)
+find_package(OpenSSL REQUIRED)
+# Link to required third-party libraries
+target_link_libraries(DPP PUBLIC Threads::Threads ZLIB::ZLIB OpenSSL::Crypto OpenSSL::SSL)
+# Include the custom module folder
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_LIST_DIR}/cmake/")
+# Enable voice support in discord library
+if (ENABLE_DISCORD_VOICE)
+    # Look for sodium and opus libraries
+    include("cmake/FindSodium.cmake")
+    include("cmake/FindOpus.cmake")
+    # Was the opus library found?
+    if(DEFINED OPUS_FOUND)
+        message(STATUS "Opus library was found")
+        # Link to opus library
+        target_include_directories(DPP PUBLIC ${OPUS_INCLUDE_DIRS})
+        target_link_libraries(DPP PUBLIC ${OPUS_LIBRARIES})
+        # Was the sodium library found?
+        if(DEFINED sodium_VERSION_STRING)
+            message(STATUS "Sodium library was found")
+            message(STATUS "DPP voice support enabled")
+            # Let the code know about this
+            target_compile_definitions(DPP PRIVATE HAVE_VOICE=1)
+            # Link to sodium library
+            target_include_directories(DPP PUBLIC ${sodium_INCLUDE_DIR})
+            target_link_libraries(DPP PUBLIC ${sodium_LIBRARY_RELEASE})
+        endif()
+    endif()
+endif()

vendor/DPP/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

vendor/DPP/cmake/FindOpus.cmake

@@ -0,0 +1,36 @@
+#  OPUS_FOUND - system has opus
+#  OPUS_INCLUDE_DIRS - the opus include directory
+#  OPUS_LIBRARIES - The libraries needed to use opus
+
+find_path(OPUS_INCLUDE_DIRS
+	NAMES opus/opus.h
+	PATH_SUFFIXES include
+)
+if(OPUS_INCLUDE_DIRS)
+	set(HAVE_OPUS_OPUS_H 1)
+endif()
+
+if(OPUS_USE_STATIC_LIBS)
+	find_library(OPUS_LIBRARIES NAMES "libopus.a")
+else()
+	find_library(OPUS_LIBRARIES NAMES opus)
+endif()
+
+if(OPUS_LIBRARIES)
+	if(OPUS_USE_STATIC_LIBS)
+		find_library(LIBM NAMES "libm.a" "libm.tbd")
+	else()
+		find_library(LIBM NAMES m)
+	endif()
+	if(LIBM)
+		list(APPEND OPUS_LIBRARIES ${LIBM})
+	endif()
+endif()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(Opus
+	DEFAULT_MSG
+	OPUS_INCLUDE_DIRS OPUS_LIBRARIES HAVE_OPUS_OPUS_H
+)
+
+mark_as_advanced(OPUS_INCLUDE_DIRS OPUS_LIBRARIES HAVE_OPUS_OPUS_H)

vendor/DPP/cmake/FindSodium.cmake

@@ -0,0 +1,293 @@
+# Written in 2016 by Henrik Steffen Gaßmann <henrik@gassmann.onl>
+#
+# To the extent possible under law, the author(s) have dedicated all copyright
+# and related and neighboring rights to this software to the public domain
+# worldwide. This software is distributed without any warranty.
+#
+# You should have received a copy of the CC0 Public Domain Dedication along with
+# this software. If not, see
+#
+# http://creativecommons.org/publicdomain/zero/1.0/
+#
+# ##############################################################################
+# Tries to find the local libsodium installation.
+#
+# On Windows the sodium_DIR environment variable is used as a default hint which
+# can be overridden by setting the corresponding cmake variable.
+#
+# Once done the following variables will be defined:
+#
+# sodium_FOUND sodium_INCLUDE_DIR sodium_LIBRARY_DEBUG sodium_LIBRARY_RELEASE
+# sodium_VERSION_STRING
+#
+# Furthermore an imported "sodium" target is created.
+#
+
+if(CMAKE_C_COMPILER_ID STREQUAL "GNU" OR CMAKE_C_COMPILER_ID STREQUAL "Clang")
+  set(_GCC_COMPATIBLE 1)
+endif()
+
+# static library option
+if(NOT DEFINED sodium_USE_STATIC_LIBS)
+  option(sodium_USE_STATIC_LIBS "enable to statically link against sodium" OFF)
+endif()
+if(NOT (sodium_USE_STATIC_LIBS EQUAL sodium_USE_STATIC_LIBS_LAST))
+  unset(sodium_LIBRARY CACHE)
+  unset(sodium_LIBRARY_DEBUG CACHE)
+  unset(sodium_LIBRARY_RELEASE CACHE)
+  unset(sodium_DLL_DEBUG CACHE)
+  unset(sodium_DLL_RELEASE CACHE)
+  set(sodium_USE_STATIC_LIBS_LAST
+      ${sodium_USE_STATIC_LIBS}
+      CACHE INTERNAL "internal change tracking variable")
+endif()
+
+# ##############################################################################
+# UNIX
+if(UNIX)
+  # import pkg-config
+  find_package(PkgConfig QUIET)
+  if(PKG_CONFIG_FOUND)
+    pkg_check_modules(sodium_PKG QUIET libsodium)
+  endif()
+
+  if(sodium_USE_STATIC_LIBS)
+    if(sodium_PKG_STATIC_LIBRARIES)
+      foreach(_libname ${sodium_PKG_STATIC_LIBRARIES})
+        if(NOT _libname MATCHES "^lib.*\\.a$") # ignore strings already ending
+                                               # with .a
+          list(INSERT sodium_PKG_STATIC_LIBRARIES 0 "lib${_libname}.a")
+        endif()
+      endforeach()
+      list(REMOVE_DUPLICATES sodium_PKG_STATIC_LIBRARIES)
+    else()
+      # if pkgconfig for libsodium doesn't provide static lib info, then
+      # override PKG_STATIC here..
+      set(sodium_PKG_STATIC_LIBRARIES libsodium.a)
+    endif()
+
+    set(XPREFIX sodium_PKG_STATIC)
+  else()
+    if(sodium_PKG_LIBRARIES STREQUAL "")
+      set(sodium_PKG_LIBRARIES sodium)
+    endif()
+
+    set(XPREFIX sodium_PKG)
+  endif()
+
+  find_path(sodium_INCLUDE_DIR sodium.h HINTS ${${XPREFIX}_INCLUDE_DIRS})
+  find_library(sodium_LIBRARY_DEBUG
+               NAMES ${${XPREFIX}_LIBRARIES}
+               HINTS ${${XPREFIX}_LIBRARY_DIRS})
+  find_library(sodium_LIBRARY_RELEASE
+               NAMES ${${XPREFIX}_LIBRARIES}
+               HINTS ${${XPREFIX}_LIBRARY_DIRS})
+
+  # ############################################################################
+  # Windows
+elseif(WIN32)
+  set(sodium_DIR "$ENV{sodium_DIR}" CACHE FILEPATH "sodium install directory")
+  mark_as_advanced(sodium_DIR)
+
+  find_path(sodium_INCLUDE_DIR sodium.h
+            HINTS ${sodium_DIR}
+            PATH_SUFFIXES include)
+
+  if(MSVC)
+    # detect target architecture
+    file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/arch.cpp" [=[
+            #if defined _M_IX86
+            #error ARCH_VALUE x86_32
+            #elif defined _M_X64
+            #error ARCH_VALUE x86_64
+            #endif
+            #error ARCH_VALUE unknown
+        ]=])
+    try_compile(_UNUSED_VAR "${CMAKE_CURRENT_BINARY_DIR}"
+                "${CMAKE_CURRENT_BINARY_DIR}/arch.cpp"
+                OUTPUT_VARIABLE _COMPILATION_LOG)
+    string(REGEX
+           REPLACE ".*ARCH_VALUE ([a-zA-Z0-9_]+).*"
+                   "\\1"
+                   _TARGET_ARCH
+                   "${_COMPILATION_LOG}")
+
+    # construct library path
+    if(_TARGET_ARCH STREQUAL "x86_32")
+      string(APPEND _PLATFORM_PATH "Win32")
+    elseif(_TARGET_ARCH STREQUAL "x86_64")
+      string(APPEND _PLATFORM_PATH "x64")
+    else()
+      message(
+        FATAL_ERROR
+          "the ${_TARGET_ARCH} architecture is not supported by Findsodium.cmake."
+        )
+    endif()
+    string(APPEND _PLATFORM_PATH "/$$CONFIG$$")
+
+    if(MSVC_VERSION LESS 1900)
+      math(EXPR _VS_VERSION "${MSVC_VERSION} / 10 - 60")
+    else()
+      math(EXPR _VS_VERSION "${MSVC_VERSION} / 10 - 50")
+    endif()
+    string(APPEND _PLATFORM_PATH "/v${_VS_VERSION}")
+
+    if(sodium_USE_STATIC_LIBS)
+      string(APPEND _PLATFORM_PATH "/static")
+    else()
+      string(APPEND _PLATFORM_PATH "/dynamic")
+    endif()
+
+    string(REPLACE "$$CONFIG$$"
+                   "Debug"
+                   _DEBUG_PATH_SUFFIX
+                   "${_PLATFORM_PATH}")
+    string(REPLACE "$$CONFIG$$"
+                   "Release"
+                   _RELEASE_PATH_SUFFIX
+                   "${_PLATFORM_PATH}")
+
+    find_library(sodium_LIBRARY_DEBUG libsodium.lib
+                 HINTS ${sodium_DIR}
+                 PATH_SUFFIXES ${_DEBUG_PATH_SUFFIX})
+    find_library(sodium_LIBRARY_RELEASE libsodium.lib
+                 HINTS ${sodium_DIR}
+                 PATH_SUFFIXES ${_RELEASE_PATH_SUFFIX})
+    if(NOT sodium_USE_STATIC_LIBS)
+      set(CMAKE_FIND_LIBRARY_SUFFIXES_BCK ${CMAKE_FIND_LIBRARY_SUFFIXES})
+      set(CMAKE_FIND_LIBRARY_SUFFIXES ".dll")
+      find_library(sodium_DLL_DEBUG libsodium
+                   HINTS ${sodium_DIR}
+                   PATH_SUFFIXES ${_DEBUG_PATH_SUFFIX})
+      find_library(sodium_DLL_RELEASE libsodium
+                   HINTS ${sodium_DIR}
+                   PATH_SUFFIXES ${_RELEASE_PATH_SUFFIX})
+      set(CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES_BCK})
+    endif()
+
+  elseif(_GCC_COMPATIBLE)
+    if(sodium_USE_STATIC_LIBS)
+      find_library(sodium_LIBRARY_DEBUG libsodium.a
+                   HINTS ${sodium_DIR}
+                   PATH_SUFFIXES lib)
+      find_library(sodium_LIBRARY_RELEASE libsodium.a
+                   HINTS ${sodium_DIR}
+                   PATH_SUFFIXES lib)
+    else()
+      find_library(sodium_LIBRARY_DEBUG libsodium.dll.a
+                   HINTS ${sodium_DIR}
+                   PATH_SUFFIXES lib)
+      find_library(sodium_LIBRARY_RELEASE libsodium.dll.a
+                   HINTS ${sodium_DIR}
+                   PATH_SUFFIXES lib)
+
+      file(GLOB _DLL
+           LIST_DIRECTORIES false
+           RELATIVE "${sodium_DIR}/bin"
+           "${sodium_DIR}/bin/libsodium*.dll")
+      find_library(sodium_DLL_DEBUG ${_DLL} libsodium
+                   HINTS ${sodium_DIR}
+                   PATH_SUFFIXES bin)
+      find_library(sodium_DLL_RELEASE ${_DLL} libsodium
+                   HINTS ${sodium_DIR}
+                   PATH_SUFFIXES bin)
+    endif()
+  else()
+    message(FATAL_ERROR "this platform is not supported by FindSodium.cmake")
+  endif()
+
+  # ############################################################################
+  # unsupported
+else()
+  message(FATAL_ERROR "this platform is not supported by FindSodium.cmake")
+endif()
+
+# ##############################################################################
+# common stuff
+
+# extract sodium version
+if(sodium_INCLUDE_DIR)
+  set(_VERSION_HEADER "${sodium_INCLUDE_DIR}/sodium/version.h")
+  if(EXISTS "${_VERSION_HEADER}")
+    file(READ "${_VERSION_HEADER}" _VERSION_HEADER_CONTENT)
+    string(
+      REGEX
+      REPLACE
+      ".*#define[ \t]*SODIUM_VERSION_STRING[ \t]*\"([^\n]*)\".*"
+        "\\1"
+        sodium_VERSION_STRING
+        "${_VERSION_HEADER_CONTENT}")
+    set(sodium_VERSION_STRING "${sodium_VERSION_STRING}")
+  endif()
+endif()
+
+# communicate results
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(sodium
+                                  REQUIRED_VARS
+                                  sodium_LIBRARY_RELEASE
+                                  sodium_LIBRARY_DEBUG
+                                  sodium_INCLUDE_DIR
+                                  VERSION_VAR
+                                  sodium_VERSION_STRING)
+
+# mark file paths as advanced
+mark_as_advanced(sodium_INCLUDE_DIR)
+mark_as_advanced(sodium_LIBRARY_DEBUG)
+mark_as_advanced(sodium_LIBRARY_RELEASE)
+if(WIN32)
+  mark_as_advanced(sodium_DLL_DEBUG)
+  mark_as_advanced(sodium_DLL_RELEASE)
+endif()
+
+# create imported target
+if(sodium_USE_STATIC_LIBS)
+  set(_LIB_TYPE STATIC)
+else()
+  set(_LIB_TYPE SHARED)
+endif()
+add_library(sodium ${_LIB_TYPE} IMPORTED)
+
+set_target_properties(sodium
+                      PROPERTIES INTERFACE_INCLUDE_DIRECTORIES
+                                 "${sodium_INCLUDE_DIR}"
+                                 IMPORTED_LINK_INTERFACE_LANGUAGES
+                                 "C")
+
+if(sodium_USE_STATIC_LIBS)
+  set_target_properties(sodium
+                        PROPERTIES INTERFACE_COMPILE_DEFINITIONS
+                                   "SODIUM_STATIC"
+                                   IMPORTED_LOCATION
+                                   "${sodium_LIBRARY_RELEASE}"
+                                   IMPORTED_LOCATION_DEBUG
+                                   "${sodium_LIBRARY_DEBUG}")
+else()
+  if(UNIX)
+    set_target_properties(sodium
+                          PROPERTIES IMPORTED_LOCATION
+                                     "${sodium_LIBRARY_RELEASE}"
+                                     IMPORTED_LOCATION_DEBUG
+                                     "${sodium_LIBRARY_DEBUG}")
+  elseif(WIN32)
+    set_target_properties(sodium
+                          PROPERTIES IMPORTED_IMPLIB
+                                     "${sodium_LIBRARY_RELEASE}"
+                                     IMPORTED_IMPLIB_DEBUG
+                                     "${sodium_LIBRARY_DEBUG}")
+    if(NOT (sodium_DLL_DEBUG MATCHES ".*-NOTFOUND"))
+      set_target_properties(sodium
+                            PROPERTIES IMPORTED_LOCATION_DEBUG
+                                       "${sodium_DLL_DEBUG}")
+    endif()
+    if(NOT (sodium_DLL_RELEASE MATCHES ".*-NOTFOUND"))
+      set_target_properties(sodium
+                            PROPERTIES IMPORTED_LOCATION_RELWITHDEBINFO
+                                       "${sodium_DLL_RELEASE}"
+                                       IMPORTED_LOCATION_MINSIZEREL
+                                       "${sodium_DLL_RELEASE}"
+                                       IMPORTED_LOCATION_RELEASE
+                                       "${sodium_DLL_RELEASE}")
+    endif()
+  endif()
+endif()

vendor/DPP/include/dpp/auditlog.h

@@ -0,0 +1,165 @@
+/************************************************************************************
+ *
+ * D++, A Lightweight C++ library for Discord
+ *
+ * Copyright 2021 Craig Edwards and D++ contributors 
+ * (https://github.com/brainboxdotcc/DPP/graphs/contributors)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ ************************************************************************************/
+
+#pragma once
+#include <dpp/export.h>
+#include <dpp/discord.h>
+#include <dpp/json_fwd.hpp>
+#include <optional>
+
+namespace dpp {
+
+/**
+ * @brief Defines types of audit log entry
+ */
+enum audit_type {
+	/// Guild update
+	ae_guild_update			=	1,
+	/// Channel create
+	ae_channel_create		=	10,
+	/// Channel update
+	ae_channel_update		=	11,
+	/// Channel delete
+	ae_channel_delete		=	12,
+	/// Channel overwrite create
+	ae_channel_overwrite_create	=	13,
+	/// Channel overwrite update
+	ae_channel_overwrite_update	=	14,
+	/// Channel overwrite delete
+	ae_channel_overwrite_delete	=	15,
+	/// Channel member kick
+	ae_member_kick			=	20,
+	/// Channel member prune
+	ae_member_prune			=	21,
+	/// Channel member ban add
+	ae_member_ban_add		=	22,
+	/// Channel member ban remove
+	ae_member_ban_remove		=	23,
+	/// Guild member update
+	ae_member_update		=	24,
+	/// Guild member role update
+	ae_member_role_update		=	25,
+	/// Guild member move
+	ae_member_move			=	26,
+	/// Guild member voice disconnect
+	ae_member_disconnect		=	27,
+	/// Guild bot add
+	ae_bot_add			=	28,
+	/// Guild role create
+	ae_role_create			=	30,
+	/// Guild role update
+	ae_role_update			=	31,
+	/// Guild role delete
+	ae_role_delete			=	32,
+	/// Guild invite create
+	ae_invite_create		=	40,
+	/// Guild invite update
+	ae_invite_update		=	41,
+	/// Guild invite delete
+	ae_invite_delete		=	42,
+	/// Guild webhook create
+	ae_webhook_create		=	50,
+	/// Guild webhook update
+	ae_webhook_update		=	51,
+	/// Guild webhook delete
+	ae_webhook_delete		=	52,
+	/// Guild emoji create
+	ae_emoji_create			=	60,
+	/// Guild emoji update
+	ae_emoji_update			=	61,
+	/// Guild emoji delete
+	ae_emoji_delete			=	62,
+	/// Guild message delete
+	ae_message_delete		=	72,
+	/// Guild message bulk delete
+	ae_message_bulk_delete		=	73,
+	/// Guild message pin
+	ae_message_pin			=	74,
+	/// Guild message unpin
+	ae_message_unpin		=	75,
+	/// Guild integration create
+	ae_integration_create		=	80,
+	/// Guild integration update
+	ae_integration_update		=	81,
+	/// Guild integration delete
+	ae_integration_delete		=	82
+};
+
+/**
+ * @brief Defines audit log changes
+ */
+struct CoreExport audit_change {
+	/// Optional: Serialised new value of the key
+	std::string	new_value;
+	/// Optional: Serialised old value of the key
+	std::string	old_value;
+	/// name of audit log change key
+	std::string	key;
+};
+
+/**
+ * @brief Extra information for an audit log entry
+ */
+struct CoreExport audit_extra {
+	std::string 	delete_member_days;	//!< number of days after which inactive members were kicked
+	std::string	members_removed;	//!< number of members removed by the prune
+	snowflake	channel_id;		//!< channel in which the entities were targeted
+	snowflake	message_id;		//!< id of the message that was targeted
+	std::string	count;			//!< number of entities that were targeted
+	snowflake	id;			//!< id of the overwritten entity
+	std::string	type;			//!< type of overwritten entity - "0" for "role" or "1" for "member"
+	std::string 	role_name;		//!< name of the role if type is "0" (not present if type is "1")
+};
+
+/**
+ * @brief An individual audit log entry
+ */
+struct CoreExport audit_entry {
+	snowflake			id;		//!< id of the entry
+	snowflake			target_id;	//!< id of the affected entity (webhook, user, role, etc.) (may be empty)
+	std::vector<audit_change>	changes;	//!< Optional: changes made to the target_id
+	snowflake			user_id;	//!< the user who made the changes (may be empty)
+	audit_type			event;		//!< type of action that occurred
+	std::optional<audit_extra>	options;	//!< Optional: additional info for certain action types
+	std::string			reason;		//!< Optional: the reason for the change (0-512 characters)	
+};
+
+/**
+ * @brief The auditlog class represents the audit log entry of a guild.
+ */
+class CoreExport auditlog {
+public:
+	std::vector<audit_entry> entries;	//!< Audit log entries
+	
+	/** Constructor */
+	auditlog();
+
+	/** Destructor */
+	~auditlog();
+
+	/** Read class values from json object
+	 * @param j A json object to read from
+	 * @return A reference to self
+	 */
+	auditlog& fill_from_json(nlohmann::json* j);
+};
+
+};

vendor/DPP/include/dpp/ban.h

@@ -0,0 +1,64 @@
+/************************************************************************************
+ *
+ * D++, A Lightweight C++ library for Discord
+ *
+ * Copyright 2021 Craig Edwards and D++ contributors 
+ * (https://github.com/brainboxdotcc/DPP/graphs/contributors)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ ************************************************************************************/
+
+#pragma once
+#include <dpp/export.h>
+#include <dpp/discord.h>
+#include <dpp/json_fwd.hpp>
+
+namespace dpp {
+
+/**
+ * @brief The ban class represents a ban on a guild.
+ * 
+ */
+class CoreExport ban {
+public:
+	/** The ban reason */
+	std::string reason;
+	/** User ID the ban applies to */
+	snowflake user_id;
+	
+	/** Constructor */
+	ban();
+
+	/** Destructor */
+	~ban();
+
+	/** Read class values from json object
+	 * @param j A json object to read from
+	 * @return A reference to self
+	 */
+	ban& fill_from_json(nlohmann::json* j);
+
+	/**
+	 * @brief Build json representation of a ban
+	 * 
+	 * @return std::string stringified json
+	 */
+	std::string build_json() const;
+};
+
+/** A group of bans
+ */
+typedef std::unordered_map<snowflake, ban> ban_map;
+
+};

vendor/DPP/include/dpp/cache.h

@@ -0,0 +1,127 @@
+/************************************************************************************
+ *
+ * D++, A Lightweight C++ library for Discord
+ *
+ * Copyright 2021 Craig Edwards and D++ contributors 
+ * (https://github.com/brainboxdotcc/DPP/graphs/contributors)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ ************************************************************************************/
+
+#pragma once
+#include <dpp/export.h>
+#include <dpp/discord.h>
+#include <map>
+#include <mutex>
+
+namespace dpp {
+
+	/**
+	 * @brief A set of cached managed objects
+	 */
+	typedef std::unordered_map<uint64_t, managed*> cache_container;
+
+	/**
+	 * @brief A cache object maintains a cache of dpp::managed objects.
+	 * This is for example users, channels or guilds.
+	 */
+	class CoreExport cache {
+	private:
+
+		/** Mutex to protect the cache */
+		std::mutex cache_mutex;
+
+		/** Cached items */
+		cache_container* cache_map;
+
+	public:
+
+		/**
+		 * @brief Construct a new cache object
+		 */
+		cache();
+
+		/**
+		 * @brief Destroy the cache object
+		 */
+		~cache();
+
+		/** Store an object in the cache.
+		 * @param object object to store
+		 */
+		void store(managed* object);
+
+		/** Remove an object from the cache.
+		 * @param object object to remove
+		 */
+		void remove(managed* object);
+
+		/** Find an object in the cache by id.
+		 * @param id Object id to find
+		 */
+		managed* find(snowflake id);
+
+		/** Return a count of the number of items in the cache.
+		 */
+		uint64_t count();
+
+		/** 
+		 * @brief Return the cache's locking mutex. Use this whenever
+		 * you manipulate or iterate raw elements in the cache!
+		 * 
+		 * @return The mutex used to protect the container
+		 */
+		std::mutex& get_mutex();
+
+		/**
+		 * @brief Get the container map
+		 * @warning Be sure to use cache::get_mutex() correctly if you
+		 * manipulate or iterate the map returned by this method! If you do
+		 * not, this is not thread safe and will cause crashes!
+		 * @see cache::get_mutex
+		 * 
+		 * @return cache_container& A reference to the cache's container map
+		 */
+		cache_container& get_container();
+
+		/**
+		 * @brief "Rehash" a cache by cleaning out used RAM
+		 * @warning May be time consuming!
+		 */
+		void rehash();
+
+		/**
+		 * @brief Get "real" size in RAM of the cache
+		 * 
+		 * @return size_t 
+		 */
+		size_t bytes();
+
+	};
+
+	/** Run garbage collection across all caches removing deleted items
+	 * that have been deleted over 60 seconds ago.
+	 */
+	void CoreExport garbage_collection();
+
+	#define cache_decl(type, setter, getter, counter) CoreExport type * setter (snowflake id); CoreExport cache * getter ();  CoreExport uint64_t counter ();
+
+	/* Declare major caches */
+	cache_decl(user, find_user, get_user_cache, get_user_count);
+	cache_decl(guild, find_guild, get_guild_cache, get_guild_count);
+	cache_decl(role, find_role, get_role_cache, get_role_count);
+	cache_decl(channel, find_channel, get_channel_cache, get_channel_count);
+	cache_decl(emoji, find_emoji, get_emoji_cache, get_emoji_count);
+};
+