@ugo-studio/jspp 0.2.9 → 0.3.0

package/src/prelude/library/array.hpp

@@ -1,186 +1,186 @@
-#pragma once
-
-#include "types.hpp"
-#include "any_value.hpp"
-#include "utils/operators.hpp"
-#include "utils/access.hpp"
-
-inline auto Array = jspp::AnyValue::make_class([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
-                                               {
-    if (args.size() == 1 && args[0].is_number()) {
-        double len = args[0].as_double();
-        if (len < 0 || len > 4294967295.0) { // Max uint32
-             throw jspp::Exception::make_exception("Invalid array length", "RangeError");
-        }
-        auto arr = jspp::AnyValue::make_array(std::vector<jspp::AnyValue>());
-        auto arr_ptr = arr.as_array();
-        arr_ptr->length = static_cast<uint64_t>(len);
-        arr_ptr->dense.resize(static_cast<size_t>(len), jspp::Constants::UNINITIALIZED);
-        return arr;
-    }
-    std::vector<jspp::AnyValue> elements;
-    for(const auto& arg : args) {
-        elements.push_back(arg);
-    }
-    return jspp::AnyValue::make_array(std::move(elements)); }, "Array");
-
-struct ArrayInit
-{
-    ArrayInit()
-    {
-        // Array.isArray(value)
-        Array.define_data_property("isArray", jspp::AnyValue::make_function([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
-                                                                            {
-            if (args.empty()) return jspp::Constants::FALSE;
-            return jspp::AnyValue::make_boolean(args[0].is_array()); }, "isArray"));
-
-        // Array.of(...elements)
-        Array.define_data_property("of", jspp::AnyValue::make_function([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
-                                                                       {
-            std::vector<jspp::AnyValue> elements;
-            for(const auto& arg : args) {
-                elements.push_back(arg);
-            }
-            return jspp::AnyValue::make_array(std::move(elements)); }, "of"));
-
-        // Array.from(arrayLike, mapFn?, thisArg?)
-        Array.define_data_property("from", jspp::AnyValue::make_function([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
-                                                                         {
-            if (args.empty() || args[0].is_null() || args[0].is_undefined()) {
-                throw jspp::Exception::make_exception("Array.from requires an array-like object", "TypeError");
-            }
-
-            const auto& items = args[0];
-            const auto& mapFn = (args.size() > 1 && args[1].is_function()) ? args[1] : jspp::Constants::UNDEFINED;
-            const auto& thisArg = (args.size() > 2) ? args[2] : jspp::Constants::UNDEFINED;
-
-            std::vector<jspp::AnyValue> result;
-
-            auto iteratorSym = jspp::WellKnownSymbols::iterator;
-            if (items.has_property(iteratorSym->key)) {
-                auto iter = jspp::Access::get_object_iterator(items, "Array.from source");
-                auto nextFn = iter.get_own_property("next");
-                
-                size_t k = 0;
-                while (true) {
-                    auto nextRes = nextFn.call(iter, std::span<const jspp::AnyValue>{}, "next");
-                    if (jspp::is_truthy(nextRes.get_own_property("done"))) break;
-                    
-                    auto val = nextRes.get_own_property("value");
-                    if (mapFn.is_function()) {
-                        jspp::AnyValue kVal = jspp::AnyValue::make_number(k);
-                        const jspp::AnyValue mapArgs[] = {val, kVal};
-                        val = mapFn.call(thisArg, std::span<const jspp::AnyValue>(mapArgs, 2));
-                    }
-                    result.push_back(val);
-                    k++;
-                }
-            } else {
-                // Array-like (length property)
-                auto lenVal = items.get_property_with_receiver("length", items);
-                size_t len = static_cast<size_t>(jspp::Operators_Private::ToUint32(lenVal));
-                
-                for (size_t k = 0; k < len; ++k) {
-                    auto kVal = items.get_property_with_receiver(std::to_string(k), items);
-                    if (mapFn.is_function()) {
-                        jspp::AnyValue kNum = jspp::AnyValue::make_number(k);
-                        const jspp::AnyValue mapArgs[] = {kVal, kNum};
-                        kVal = mapFn.call(thisArg, std::span<const jspp::AnyValue>(mapArgs, 2));
-                    }
-                    result.push_back(kVal);
-                }
-            }
-            
-            return jspp::AnyValue::make_array(std::move(result)); }, "from"));
-
-        // Array.fromAsync(iterableOrArrayLike, mapFn?, thisArg?)
-        Array.define_data_property("fromAsync", jspp::AnyValue::make_async_function([](jspp::AnyValue, std::vector<jspp::AnyValue> args) -> jspp::JsPromise
-                                                                                    {
-            if (args.empty() || args[0].is_null() || args[0].is_undefined()) {
-                throw jspp::Exception::make_exception("Array.fromAsync requires an iterable or array-like object", "TypeError");
-            }
-
-            const auto& items = args[0];
-            const auto& mapFn = (args.size() > 1 && args[1].is_function()) ? args[1] : jspp::Constants::UNDEFINED;
-            const auto& thisArg = (args.size() > 2) ? args[2] : jspp::Constants::UNDEFINED;
-
-            std::vector<jspp::AnyValue> result;
-            
-            bool isAsync = false;
-            jspp::AnyValue iter = jspp::Constants::UNDEFINED;
-            jspp::AnyValue nextFn = jspp::Constants::UNDEFINED;
-
-            if (items.has_property(jspp::WellKnownSymbols::asyncIterator->key)) {
-                auto method = items.get_property_with_receiver(jspp::WellKnownSymbols::asyncIterator->key, items);
-                if (method.is_function()) {
-                    iter = method.call(items, {});
-                    nextFn = iter.get_own_property("next");
-                    isAsync = true;
-                }
-            } 
-            
-            if (!isAsync && items.has_property(jspp::WellKnownSymbols::iterator->key)) {
-                auto method = items.get_property_with_receiver(jspp::WellKnownSymbols::iterator->key, items);
-                if (method.is_function()) {
-                    iter = method.call(items, {});
-                    nextFn = iter.get_own_property("next");
-                }
-            }
-
-            if (!iter.is_undefined()) {
-                size_t k = 0;
-                while (true) {
-                    auto nextRes = nextFn.call(iter, {});
-                    
-                    if (nextRes.is_promise()) {
-                        nextRes = co_await nextRes;
-                    }
-                    
-                    if (jspp::is_truthy(nextRes.get_own_property("done"))) break;
-                    
-                    auto val = nextRes.get_own_property("value");
-                    
-                    if (mapFn.is_function()) {
-                        jspp::AnyValue kVal = jspp::AnyValue::make_number(k);
-                        const jspp::AnyValue mapArgs[] = {val, kVal};
-                        auto mapRes = mapFn.call(thisArg, std::span<const jspp::AnyValue>(mapArgs, 2));
-                        if (mapRes.is_promise()) {
-                            val = co_await mapRes;
-                        } else {
-                            val = mapRes;
-                        }
-                    }
-                    result.push_back(val);
-                    k++;
-                }
-            } else {
-                auto lenVal = items.get_property_with_receiver("length", items);
-                size_t len = static_cast<size_t>(jspp::Operators_Private::ToUint32(lenVal));
-                
-                for (size_t k = 0; k < len; ++k) {
-                    auto kVal = items.get_property_with_receiver(std::to_string(k), items);
-                    if (kVal.is_promise()) {
-                        kVal = co_await kVal;
-                    }
-
-                    if (mapFn.is_function()) {
-                        jspp::AnyValue kNum = jspp::AnyValue::make_number(k);
-                        const jspp::AnyValue mapArgs[] = {kVal, kNum};
-                        auto mapRes = mapFn.call(thisArg, std::span<const jspp::AnyValue>(mapArgs, 2));
-                        if (mapRes.is_promise()) {
-                            kVal = co_await mapRes;
-                        } else {
-                            kVal = mapRes;
-                        }
-                    }
-                    result.push_back(kVal);
-                }
-            }
-
-            co_return jspp::AnyValue::make_array(std::move(result)); }, "fromAsync"));
-
-        // Array[Symbol.species]
-        Array.define_getter(jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::species), jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
-                                                                                                                        { return thisVal; }, "get [Symbol.species]"));
-    }
+#pragma once
+
+#include "types.hpp"
+#include "any_value.hpp"
+#include "utils/operators.hpp"
+#include "utils/access.hpp"
+
+inline auto Array = jspp::AnyValue::make_class([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                               {
+    if (args.size() == 1 && args[0].is_number()) {
+        double len = args[0].as_double();
+        if (len < 0 || len > 4294967295.0) { // Max uint32
+             throw jspp::Exception::make_exception("Invalid array length", "RangeError");
+        }
+        auto arr = jspp::AnyValue::make_array(std::vector<jspp::AnyValue>());
+        auto arr_ptr = arr.as_array();
+        arr_ptr->length = static_cast<uint64_t>(len);
+        arr_ptr->dense.resize(static_cast<size_t>(len), jspp::Constants::UNINITIALIZED);
+        return arr;
+    }
+    std::vector<jspp::AnyValue> elements;
+    for(const auto& arg : args) {
+        elements.push_back(arg);
+    }
+    return jspp::AnyValue::make_array(std::move(elements)); }, "Array");
+
+struct ArrayInit
+{
+    ArrayInit()
+    {
+        // Array.isArray(value)
+        Array.define_data_property("isArray", jspp::AnyValue::make_function([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                            {
+            if (args.empty()) return jspp::Constants::FALSE;
+            return jspp::AnyValue::make_boolean(args[0].is_array()); }, "isArray"));
+
+        // Array.of(...elements)
+        Array.define_data_property("of", jspp::AnyValue::make_function([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                       {
+            std::vector<jspp::AnyValue> elements;
+            for(const auto& arg : args) {
+                elements.push_back(arg);
+            }
+            return jspp::AnyValue::make_array(std::move(elements)); }, "of"));
+
+        // Array.from(arrayLike, mapFn?, thisArg?)
+        Array.define_data_property("from", jspp::AnyValue::make_function([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                         {
+            if (args.empty() || args[0].is_null() || args[0].is_undefined()) {
+                throw jspp::Exception::make_exception("Array.from requires an array-like object", "TypeError");
+            }
+
+            const auto& items = args[0];
+            const auto& mapFn = (args.size() > 1 && args[1].is_function()) ? args[1] : jspp::Constants::UNDEFINED;
+            const auto& thisArg = (args.size() > 2) ? args[2] : jspp::Constants::UNDEFINED;
+
+            std::vector<jspp::AnyValue> result;
+
+            auto iteratorSym = jspp::WellKnownSymbols::iterator;
+            if (items.has_property(iteratorSym->key)) {
+                auto iter = jspp::Access::get_object_iterator(items, "Array.from source");
+                auto nextFn = iter.get_own_property("next");
+                
+                size_t k = 0;
+                while (true) {
+                    auto nextRes = nextFn.call(iter, std::span<const jspp::AnyValue>{}, "next");
+                    if (jspp::is_truthy(nextRes.get_own_property("done"))) break;
+                    
+                    auto val = nextRes.get_own_property("value");
+                    if (mapFn.is_function()) {
+                        jspp::AnyValue kVal = jspp::AnyValue::make_number(k);
+                        const jspp::AnyValue mapArgs[] = {val, kVal};
+                        val = mapFn.call(thisArg, std::span<const jspp::AnyValue>(mapArgs, 2));
+                    }
+                    result.push_back(val);
+                    k++;
+                }
+            } else {
+                // Array-like (length property)
+                auto lenVal = items.get_property_with_receiver("length", items);
+                size_t len = static_cast<size_t>(jspp::Operators_Private::ToUint32(lenVal));
+                
+                for (size_t k = 0; k < len; ++k) {
+                    auto kVal = items.get_property_with_receiver(std::to_string(k), items);
+                    if (mapFn.is_function()) {
+                        jspp::AnyValue kNum = jspp::AnyValue::make_number(k);
+                        const jspp::AnyValue mapArgs[] = {kVal, kNum};
+                        kVal = mapFn.call(thisArg, std::span<const jspp::AnyValue>(mapArgs, 2));
+                    }
+                    result.push_back(kVal);
+                }
+            }
+            
+            return jspp::AnyValue::make_array(std::move(result)); }, "from"));
+
+        // Array.fromAsync(iterableOrArrayLike, mapFn?, thisArg?)
+        Array.define_data_property("fromAsync", jspp::AnyValue::make_async_function([](jspp::AnyValue, std::vector<jspp::AnyValue> args) -> jspp::JsPromise
+                                                                                    {
+            if (args.empty() || args[0].is_null() || args[0].is_undefined()) {
+                throw jspp::Exception::make_exception("Array.fromAsync requires an iterable or array-like object", "TypeError");
+            }
+
+            const auto& items = args[0];
+            const auto& mapFn = (args.size() > 1 && args[1].is_function()) ? args[1] : jspp::Constants::UNDEFINED;
+            const auto& thisArg = (args.size() > 2) ? args[2] : jspp::Constants::UNDEFINED;
+
+            std::vector<jspp::AnyValue> result;
+            
+            bool isAsync = false;
+            jspp::AnyValue iter = jspp::Constants::UNDEFINED;
+            jspp::AnyValue nextFn = jspp::Constants::UNDEFINED;
+
+            if (items.has_property(jspp::WellKnownSymbols::asyncIterator->key)) {
+                auto method = items.get_property_with_receiver(jspp::WellKnownSymbols::asyncIterator->key, items);
+                if (method.is_function()) {
+                    iter = method.call(items, {});
+                    nextFn = iter.get_own_property("next");
+                    isAsync = true;
+                }
+            } 
+            
+            if (!isAsync && items.has_property(jspp::WellKnownSymbols::iterator->key)) {
+                auto method = items.get_property_with_receiver(jspp::WellKnownSymbols::iterator->key, items);
+                if (method.is_function()) {
+                    iter = method.call(items, {});
+                    nextFn = iter.get_own_property("next");
+                }
+            }
+
+            if (!iter.is_undefined()) {
+                size_t k = 0;
+                while (true) {
+                    auto nextRes = nextFn.call(iter, {});
+                    
+                    if (nextRes.is_promise()) {
+                        nextRes = co_await nextRes;
+                    }
+                    
+                    if (jspp::is_truthy(nextRes.get_own_property("done"))) break;
+                    
+                    auto val = nextRes.get_own_property("value");
+                    
+                    if (mapFn.is_function()) {
+                        jspp::AnyValue kVal = jspp::AnyValue::make_number(k);
+                        const jspp::AnyValue mapArgs[] = {val, kVal};
+                        auto mapRes = mapFn.call(thisArg, std::span<const jspp::AnyValue>(mapArgs, 2));
+                        if (mapRes.is_promise()) {
+                            val = co_await mapRes;
+                        } else {
+                            val = mapRes;
+                        }
+                    }
+                    result.push_back(val);
+                    k++;
+                }
+            } else {
+                auto lenVal = items.get_property_with_receiver("length", items);
+                size_t len = static_cast<size_t>(jspp::Operators_Private::ToUint32(lenVal));
+                
+                for (size_t k = 0; k < len; ++k) {
+                    auto kVal = items.get_property_with_receiver(std::to_string(k), items);
+                    if (kVal.is_promise()) {
+                        kVal = co_await kVal;
+                    }
+
+                    if (mapFn.is_function()) {
+                        jspp::AnyValue kNum = jspp::AnyValue::make_number(k);
+                        const jspp::AnyValue mapArgs[] = {kVal, kNum};
+                        auto mapRes = mapFn.call(thisArg, std::span<const jspp::AnyValue>(mapArgs, 2));
+                        if (mapRes.is_promise()) {
+                            kVal = co_await mapRes;
+                        } else {
+                            kVal = mapRes;
+                        }
+                    }
+                    result.push_back(kVal);
+                }
+            }
+
+            co_return jspp::AnyValue::make_array(std::move(result)); }, "fromAsync"));
+
+        // Array[Symbol.species]
+        Array.define_getter(jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::species), jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                                                                        { return thisVal; }, "get [Symbol.species]"));
+    }
 } arrayInit;

package/src/prelude/library/console.hpp

@@ -1,112 +1,112 @@
-#pragma once
-
-#include <chrono>
-#include "types.hpp"
-#include "values/non_values.hpp"
-#include "values/object.hpp"
-#include "values/function.hpp"
-#include "utils/operators.hpp"
-#include "exception.hpp"
-#include "utils/log_any_value/log_any_value.hpp"
-
-#include <cmath>
-#include <sstream>
-#include <iomanip>
-
-static std::map<std::string, std::chrono::steady_clock::time_point> timers = {};
-
-auto logFn = jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args)
-                                           {
-                                               for (size_t i = 0; i < args.size(); ++i)
-                                               {
-                                                   std::cout << jspp::LogAnyValue::to_log_string(args[i]);
-                                                   if (i < args.size() - 1)
-                                                       std::cout << " ";
-                                               }
-                                               std::cout << "\n" << std::flush;
-                                               return jspp::Constants::UNDEFINED; }, "log");
-auto warnFn = jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args)
-                                            {
-                                                std::cerr << "\033[33m";
-                                                for (size_t i = 0; i < args.size(); ++i)
-                                                {
-                                                    std::cout << jspp::LogAnyValue::to_log_string(args[i]);
-                                                    if (i < args.size() - 1)
-                                                        std::cout << " ";
-                                                }
-                                                std::cerr << "\033[0m" << "\n" << std::flush; // reset
-                                                return jspp::Constants::UNDEFINED; }, "warn");
-auto errorFn = jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args)
-                                             {
-                                                 std::cerr << "\033[31m";
-                                                 for (size_t i = 0; i < args.size(); ++i)
-                                                 {
-                                                     std::cout << jspp::LogAnyValue::to_log_string(args[i]);
-                                                     if (i < args.size() - 1)
-                                                         std::cout << " ";
-                                                 }
-                                                 std::cerr << "\033[0m" << "\n" << std::flush; // reset
-                                                 return jspp::Constants::UNDEFINED; }, "error");
-auto timeFn = jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args)
-                                            {
-                                                auto start = std::chrono::steady_clock::now(); // capture immediately
-                                                auto key_str = args.size() > 0 ? args[0].to_std_string() : "default";
-                                                timers[key_str] = start;
-                                                return jspp::Constants::UNDEFINED; }, "time");
-
-// helper to format duration in ms -> ms/s/m/h with nice precision
-static auto format_duration = [](double ms) -> std::string
-{
-    std::ostringstream ss;
-    if (ms < 1000.0)
-    {
-        ss << std::fixed << std::setprecision(4) << ms << "ms";
-        return ss.str();
-    }
-    double total_s = ms / 1000.0;
-    if (ms < 60000.0)
-    { // less than a minute -> show seconds
-        ss << std::fixed << std::setprecision(4) << total_s << "s";
-        return ss.str();
-    }
-    if (ms < 3600000.0)
-    { // less than an hour -> show minutes + seconds
-        int minutes = static_cast<int>(ms / 60000.0);
-        double seconds = (ms - minutes * 60000.0) / 1000.0;
-        ss << minutes << "m " << std::fixed << std::setprecision(4) << seconds << "s";
-        return ss.str();
-    }
-    // hours, minutes, seconds
-    int hours = static_cast<int>(ms / 3600000.0);
-    int minutes = static_cast<int>((ms - hours * 3600000.0) / 60000.0);
-    double seconds = (ms - hours * 3600000.0 - minutes * 60000.0) / 1000.0;
-    ss << hours << "h " << minutes << "m " << std::fixed << std::setprecision(4) << seconds << "s";
-    return ss.str();
-};
-
-auto timeEndFn = jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args)
-                                               {
-                                                   auto end = std::chrono::steady_clock::now(); // capture immediately
-                                                   auto key_str = args.size() > 0 ? args[0].to_std_string() : "default";
-                                                   auto it = timers.find(key_str);
-                                                   if (it != timers.end())
-                                                   {
-                                                       std::chrono::duration<double, std::milli> duration = end - it->second;
-                                                       double ms = duration.count();
-                                                       std::string formatted = format_duration(ms);
-                                                       std::cout << "\033[90m" << "[" << format_duration(ms) << "] " << "\033[0m" << key_str << "\n";
-                                                       timers.erase(it); // remove the timer after ending it
-                                                   }
-                                                   else
-                                                   {
-                                                       std::cout << "Timer '" << key_str << "' does not exist." << "\n";
-                                                   }
-                                                   return jspp::Constants::UNDEFINED; }, "timeEnd");
-
-inline auto console = jspp::AnyValue::make_object({
-    {"log", logFn},
-    {"warn", warnFn},
-    {"error", errorFn},
-    {"time", timeFn},
-    {"timeEnd", timeEndFn},
+#pragma once
+
+#include <chrono>
+#include "types.hpp"
+#include "values/non_values.hpp"
+#include "values/object.hpp"
+#include "values/function.hpp"
+#include "utils/operators.hpp"
+#include "exception.hpp"
+#include "utils/log_any_value/log_any_value.hpp"
+
+#include <cmath>
+#include <sstream>
+#include <iomanip>
+
+static std::map<std::string, std::chrono::steady_clock::time_point> timers = {};
+
+auto logFn = jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args)
+                                           {
+                                               for (size_t i = 0; i < args.size(); ++i)
+                                               {
+                                                   std::cout << jspp::LogAnyValue::to_log_string(args[i]);
+                                                   if (i < args.size() - 1)
+                                                       std::cout << " ";
+                                               }
+                                               std::cout << "\n" << std::flush;
+                                               return jspp::Constants::UNDEFINED; }, "log");
+auto warnFn = jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args)
+                                            {
+                                                std::cerr << "\033[33m";
+                                                for (size_t i = 0; i < args.size(); ++i)
+                                                {
+                                                    std::cout << jspp::LogAnyValue::to_log_string(args[i]);
+                                                    if (i < args.size() - 1)
+                                                        std::cout << " ";
+                                                }
+                                                std::cerr << "\033[0m" << "\n" << std::flush; // reset
+                                                return jspp::Constants::UNDEFINED; }, "warn");
+auto errorFn = jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args)
+                                             {
+                                                 std::cerr << "\033[31m";
+                                                 for (size_t i = 0; i < args.size(); ++i)
+                                                 {
+                                                     std::cout << jspp::LogAnyValue::to_log_string(args[i]);
+                                                     if (i < args.size() - 1)
+                                                         std::cout << " ";
+                                                 }
+                                                 std::cerr << "\033[0m" << "\n" << std::flush; // reset
+                                                 return jspp::Constants::UNDEFINED; }, "error");
+auto timeFn = jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args)
+                                            {
+                                                auto start = std::chrono::steady_clock::now(); // capture immediately
+                                                auto key_str = args.size() > 0 ? args[0].to_std_string() : "default";
+                                                timers[key_str] = start;
+                                                return jspp::Constants::UNDEFINED; }, "time");
+
+// helper to format duration in ms -> ms/s/m/h with nice precision
+static auto format_duration = [](double ms) -> std::string
+{
+    std::ostringstream ss;
+    if (ms < 1000.0)
+    {
+        ss << std::fixed << std::setprecision(4) << ms << "ms";
+        return ss.str();
+    }
+    double total_s = ms / 1000.0;
+    if (ms < 60000.0)
+    { // less than a minute -> show seconds
+        ss << std::fixed << std::setprecision(4) << total_s << "s";
+        return ss.str();
+    }
+    if (ms < 3600000.0)
+    { // less than an hour -> show minutes + seconds
+        int minutes = static_cast<int>(ms / 60000.0);
+        double seconds = (ms - minutes * 60000.0) / 1000.0;
+        ss << minutes << "m " << std::fixed << std::setprecision(4) << seconds << "s";
+        return ss.str();
+    }
+    // hours, minutes, seconds
+    int hours = static_cast<int>(ms / 3600000.0);
+    int minutes = static_cast<int>((ms - hours * 3600000.0) / 60000.0);
+    double seconds = (ms - hours * 3600000.0 - minutes * 60000.0) / 1000.0;
+    ss << hours << "h " << minutes << "m " << std::fixed << std::setprecision(4) << seconds << "s";
+    return ss.str();
+};
+
+auto timeEndFn = jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args)
+                                               {
+                                                   auto end = std::chrono::steady_clock::now(); // capture immediately
+                                                   auto key_str = args.size() > 0 ? args[0].to_std_string() : "default";
+                                                   auto it = timers.find(key_str);
+                                                   if (it != timers.end())
+                                                   {
+                                                       std::chrono::duration<double, std::milli> duration = end - it->second;
+                                                       double ms = duration.count();
+                                                       std::string formatted = format_duration(ms);
+                                                       std::cout << "\033[90m" << "[" << format_duration(ms) << "] " << "\033[0m" << key_str << "\n";
+                                                       timers.erase(it); // remove the timer after ending it
+                                                   }
+                                                   else
+                                                   {
+                                                       std::cout << "Timer '" << key_str << "' does not exist." << "\n";
+                                                   }
+                                                   return jspp::Constants::UNDEFINED; }, "timeEnd");
+
+inline auto console = jspp::AnyValue::make_object({
+    {"log", logFn},
+    {"warn", warnFn},
+    {"error", errorFn},
+    {"time", timeFn},
+    {"timeEnd", timeEndFn},
 });