koffi 3.0.2 → 3.1.1

package/lib/native/base/base.hh

@@ -467,21 +467,30 @@ constexpr T BigEndian(T v) { return ReverseBytes(v); }
 
 static inline Size AlignLen(Size len, Size align)
 {
-    Size aligned = (len + align - 1) / align * align;
+    K_ASSERT(align >= 1 && !((align - 1) & align));
+
+    // Compilers can optimize x / align * align... for unsigned types.
+    // It's pessimized for signed types, to handle len < 0.
+
+    Size aligned = (len + align - 1) & ~(align - 1);
     return aligned;
 }
 
 template <typename T>
 static inline T *AlignUp(T *ptr, Size align)
 {
-    uint8_t *aligned = (uint8_t *)(((uintptr_t)ptr + align - 1) / align * align);
+    K_ASSERT(align >= 1 && !((align - 1) & align));
+
+    uint8_t *aligned = (uint8_t *)(((uintptr_t)ptr + align - 1) & ~(align - 1));
     return (T *)aligned;
 }
 
 template <typename T>
 static inline T *AlignDown(T *ptr, Size align)
 {
-    uint8_t *aligned = (uint8_t *)((uintptr_t)ptr / align * align);
+    K_ASSERT(align >= 1 && !((align - 1) & align));
+
+    uint8_t *aligned = (uint8_t *)((uintptr_t)ptr & ~(align - 1));
     return (T *)aligned;
 }
 
@@ -1157,15 +1166,11 @@ private:
 };
 
 class BlockAllocator final: public Allocator {
-    struct Bucket {
-        Size used;
-        uint8_t data[];
-    };
-
     LinkedAllocator allocator;
     Size block_size;
 
-    Bucket *current_bucket = nullptr;
+    uint8_t *bucket_ptr = nullptr;
+    uint8_t *bucket_end = nullptr;
     uint8_t *last_alloc = nullptr;
 
 public:
@@ -1191,9 +1196,6 @@ public:
 
     void GiveTo(LinkedAllocator *alloc);
     void GiveTo(BlockAllocator *alloc) { GiveTo(&alloc->allocator); }
-
-private:
-    bool AllocateSeparately(Size aligned_size) const { return aligned_size > block_size / 2; }
 };
 
 static inline void *AllocateRaw(Allocator *alloc, Size size)
@@ -3074,8 +3076,8 @@ private:
 template <typename T>
 class HashTraits {
 public:
-    static constexpr uint64_t Hash(const T &key) { return key.Hash(); }
-    static constexpr bool Test(const T &key1, const T &key2) { return key1 == key2; }
+    static uint64_t Hash(const T &key) { return key.Hash(); }
+    static bool Test(const T &key1, const T &key2) { return key1 == key2; }
 };
 
 // Stole the Hash function from Thomas Wang (see here: https://gist.github.com/badboy/6267743)
@@ -3146,44 +3148,17 @@ DEFINE_INTEGER_HASH_TRAITS_64(unsigned long long, constexpr);
 #undef DEFINE_INTEGER_HASH_TRAITS_64
 
 // MurmurHash2
-static constexpr inline uint64_t HashStr(Span<const char> str)
+static inline uint64_t HashStr(Span<const char> str)
 {
     const uint64_t Seed = 0;
     const uint64_t Mult = (((uint64_t)0xc6a4a793ull) << 32ull) + (uint64_t)0x5bd1e995ull;
 
     const auto unaligned_load =
-#if __cplusplus >= 202002L && (__GNUC__ >= 12 || __clang_major__ >= 16)
-        !std::is_constant_evaluated() ?
         [](const char *p) {
             uint64_t result;
-            __builtin_memcpy(&result, p, sizeof(result));
-            return result;
-        } :
-#endif
-        [](const char *p) {
-#if defined(K_BIG_ENDIAN)
-            uint64_t result = ((uint64_t)p[0] << 56) |
-                              ((uint64_t)p[1] << 48) |
-                              ((uint64_t)p[2] << 40) |
-                              ((uint64_t)p[3] << 32) |
-                              ((uint64_t)p[4] << 24) |
-                              ((uint64_t)p[5] << 16) |
-                              ((uint64_t)p[6] << 8) |
-                              ((uint64_t)p[7] << 0);
-#else
-            uint64_t result = ((uint64_t)p[0] << 0) |
-                              ((uint64_t)p[1] << 8) |
-                              ((uint64_t)p[2] << 16) |
-                              ((uint64_t)p[3] << 24) |
-                              ((uint64_t)p[4] << 32) |
-                              ((uint64_t)p[5] << 40) |
-                              ((uint64_t)p[6] << 48) |
-                              ((uint64_t)p[7] << 56);
-#endif
-
+            memcpy(&result, p, sizeof(result));
             return result;
         };
-
     const auto load_bytes = [](const char *p, int n) {
         uint64_t result = 0;
 
@@ -3216,7 +3191,7 @@ static constexpr inline uint64_t HashStr(Span<const char> str)
     return hash;
 }
 
-static constexpr inline uint64_t HashStr(const char *str)
+static inline uint64_t HashStr(const char *str)
 {
     Span<const char> span = str;
     return HashStr(span);
@@ -3225,35 +3200,35 @@ static constexpr inline uint64_t HashStr(const char *str)
 template <>
 class HashTraits<const char *> {
 public:
-    static constexpr uint64_t Hash(Span<const char> key) { return HashStr(key); }
-    static constexpr uint64_t Hash(const char *key) { return HashStr(key); }
+    static uint64_t Hash(Span<const char> key) { return HashStr(key); }
+    static uint64_t Hash(const char *key) { return HashStr(key); }
 
-    static constexpr bool Test(const char *key1, const char *key2) { return TestStr(key1, key2); }
-    static constexpr bool Test(const char *key1, Span<const char> key2) { return key2 == key1; }
+    static bool Test(const char *key1, const char *key2) { return TestStr(key1, key2); }
+    static bool Test(const char *key1, Span<const char> key2) { return key2 == key1; }
 };
 
 template <>
 class HashTraits<Span<const char>> {
 public:
-    static constexpr uint64_t Hash(Span<const char> key) { return HashStr(key); }
-    static constexpr uint64_t Hash(const char *key) { return HashStr(key); }
+    static uint64_t Hash(Span<const char> key) { return HashStr(key); }
+    static uint64_t Hash(const char *key) { return HashStr(key); }
 
-    static constexpr bool Test(Span<const char> key1, Span<const char> key2) { return key1 == key2; }
-    static constexpr bool Test(Span<const char> key1, const char * key2) { return key1 == key2; }
+    static bool Test(Span<const char> key1, Span<const char> key2) { return key1 == key2; }
+    static bool Test(Span<const char> key1, const char * key2) { return key1 == key2; }
 };
 
 #define K_HASHTABLE_HANDLER_EX_N(Name, ValueType, KeyType, KeyMember, HashFunc, TestFunc) \
     class Name { \
     public: \
-        static constexpr KeyType GetKey(const ValueType &value) \
+        static KeyType GetKey(const ValueType &value) \
             { return (KeyType)(value.KeyMember); } \
-        static constexpr KeyType GetKey(const ValueType *value) \
+        static KeyType GetKey(const ValueType *value) \
             { return (KeyType)(value->KeyMember); } \
         template <typename TestKey> \
-        static constexpr uint64_t HashKey(TestKey key) \
+        static uint64_t HashKey(TestKey key) \
             { return HashFunc(key); } \
         template <typename TestKey> \
-        static constexpr bool TestKeys(KeyType key1, TestKey key2) \
+        static bool TestKeys(KeyType key1, TestKey key2) \
             { return TestFunc((key1), (key2)); } \
     }
 #define K_HASHTABLE_HANDLER_EX(ValueType, KeyType, KeyMember, HashFunc, TestFunc) \
@@ -3355,11 +3330,11 @@ template <typename ValueType>
 class HashSet {
     class Handler {
     public:
-        static constexpr ValueType GetKey(const ValueType &value) { return value; }
-        static constexpr ValueType GetKey(const ValueType *value) { return *value; }
-        static constexpr uint64_t HashKey(const ValueType &value)
+        static ValueType GetKey(const ValueType &value) { return value; }
+        static ValueType GetKey(const ValueType *value) { return *value; }
+        static uint64_t HashKey(const ValueType &value)
             { return HashTraits<ValueType>::Hash(value); }
-        static constexpr bool TestKeys(const ValueType &value1, const ValueType &value2)
+        static bool TestKeys(const ValueType &value1, const ValueType &value2)
             { return HashTraits<ValueType>::Test(value1, value2); }
     };
 
@@ -3403,101 +3378,6 @@ public:
 private:
 };
 
-// XXX: Switch to perfect hashing later on
-template <Size N, typename KeyType, typename ValueType>
-class ConstMap {
-public:
-    struct Bucket {
-        KeyType key;
-        ValueType value;
-    };
-
-    size_t used[(N + (K_SIZE(size_t) * 8) - 1) / K_SIZE(size_t)] = {};
-    Bucket data[N] = {};
-    Size count = 0;
-
-    constexpr ConstMap(std::initializer_list<Bucket> l)
-    {
-        K_CRITICAL(l.size() <= N, "ConstMap<%1> cannot store %2 values", N, l.size());
-
-        for (const Bucket &it: l) {
-            Bucket *bucket = Insert(it.key);
-
-            bucket->key = it.key;
-            bucket->value = it.value;
-        }
-    }
-
-    template <typename T = KeyType>
-    ValueType *Find(const T &key)
-        { return (ValueType *)((const ConstMap *)this)->Find(key); }
-    template <typename T = KeyType>
-    const ValueType *Find(const T &key) const
-    {
-        uint64_t hash = HashTraits<KeyType>::Hash(key);
-        Size idx = HashToIndex(hash);
-
-        const Bucket *bucket = Find(&idx, key);
-        return bucket ? &bucket->value : nullptr;
-    }
-
-    template <typename T = KeyType>
-    ValueType FindValue(const T &key, const ValueType &default_value)
-        { return (ValueType)((const ConstMap *)this)->FindValue(key, default_value); }
-    template <typename T = KeyType>
-    const ValueType FindValue(const T &key, const ValueType &default_value) const
-    {
-        const ValueType *it = Find(key);
-        return it ? *it : default_value;
-    }
-
-private:
-    template <typename T = KeyType>
-    constexpr Bucket *Find(Size *idx, const T &key)
-        { return (Bucket *)((const ConstMap *)this)->Find(idx, key); }
-    template <typename T = KeyType>
-    constexpr const Bucket *Find(Size *idx, const T &key) const
-    {
-        while (!IsEmpty(*idx)) {
-            if (HashTraits<KeyType>::Test(data[*idx].key, key))
-                return &data[*idx];
-            *idx = (*idx + 1) & (N - 1);
-        }
-        return nullptr;
-    }
-
-    constexpr Bucket *Insert(const KeyType &key)
-    {
-        uint64_t hash = HashTraits<KeyType>::Hash(key);
-        Size idx = HashToIndex(hash);
-        Bucket *it = Find(&idx, key);
-
-        if (!it) {
-            count++;
-            MarkUsed(idx);
-
-            return &data[idx];
-        } else {
-            return it;
-        }
-    }
-
-    constexpr void MarkUsed(Size idx)
-    {
-        used[idx / (K_SIZE(size_t) * 8)] |= (1ull << (idx % (K_SIZE(size_t) * 8)));
-    }
-    constexpr bool IsEmpty(Size idx) const
-    {
-        bool empty = !(used[idx / (K_SIZE(size_t) * 8)] & (1ull << (idx % (K_SIZE(size_t) * 8))));
-        return empty;
-    }
-
-    constexpr Size HashToIndex(uint64_t hash) const
-    {
-        return (Size)(hash & (uint64_t)(N - 1));
-    }
-};
-
 // ------------------------------------------------------------------------
 // Date
 // ------------------------------------------------------------------------
@@ -3683,7 +3563,8 @@ enum class FmtType {
     MemorySize,
     DiskSize,
     Date,
-    TimeISO,
+    TimeBasic,
+    TimeIso,
     TimeNice,
     List,
     FlagNames,
@@ -3938,10 +3819,19 @@ static inline FmtArg FmtDiskSize(int64_t size)
     return arg;
 }
 
-static inline FmtArg FmtTimeISO(TimeSpec spec, bool ms = false)
+static inline FmtArg FmtTimeBasic(TimeSpec spec, bool ms = false)
 {
     FmtArg arg;
-    arg.type = FmtType::TimeISO;
+    arg.type = FmtType::TimeBasic;
+    arg.u.time.spec = spec;
+    arg.u.time.ms = ms;
+    return arg;
+}
+
+static inline FmtArg FmtTimeIso(TimeSpec spec, bool ms = false)
+{
+    FmtArg arg;
+    arg.type = FmtType::TimeIso;
     arg.u.time.spec = spec;
     arg.u.time.ms = ms;
     return arg;
@@ -4060,11 +3950,11 @@ public:
     operator FmtArg() const { return FmtCustom(*this); }
 };
 
-class FmtHtmlSafe {
+class FmtXmlSafe {
     Span<const char> str;
 
 public:
-    FmtHtmlSafe(Span<const char> str) : str(str) {}
+    FmtXmlSafe(Span<const char> str) : str(str) {}
 
     void Format(FunctionRef<void(Span<const char>)> append) const;
     operator FmtArg() const { return FmtCustom(*this); }
@@ -4675,8 +4565,17 @@ static inline bool ExecuteCommandLine(const char *cmd_line, const ExecuteInfo &i
                               (HeapArray<uint8_t> *)out_buf, out_code);
 }
 
-Size ReadCommandOutput(const char *cmd_line, Span<char> out_output);
-bool ReadCommandOutput(const char *cmd_line, HeapArray<char> *out_output);
+Size ReadCommandOutput(const char *cmd_line, Span<uint8_t> out_output);
+bool ReadCommandOutput(const char *cmd_line, HeapArray<uint8_t> *out_output);
+
+// Char variants
+static inline Size ReadCommandOutput(const char *cmd_line, Span<char> out_output)
+    { return ReadCommandOutput(cmd_line, out_output.As<uint8_t>()); }
+static inline bool ReadCommandOutput(const char *cmd_line, HeapArray<char> *out_output)
+{
+    HeapArray<uint8_t> *out = (HeapArray<uint8_t> *)out_output;
+    return ReadCommandOutput(cmd_line, out);
+}
 
 #endif
 
@@ -5034,6 +4933,10 @@ void CloseSocket(int fd);
 // Tasks
 // ------------------------------------------------------------------------
 
+enum class AsyncFlag {
+    Selfish = 1 << 0
+};
+
 class Async {
     K_DELETE_COPY(Async)
 
@@ -5042,20 +4945,21 @@ class Async {
     std::atomic_int remaining_tasks { 0 };
 
     class AsyncPool *pool;
+
+    Async *only = nullptr;
 #else
     bool success = true;
 #endif
 
 public:
-    Async(int threads = -1);
-    Async(Async *parent);
+    Async(int threads = -1, unsigned int flags = 0);
+    Async(Async *parent, unsigned int flags = 0);
     ~Async();
 
     void Run(const std::function<bool()> &f);
     void Run(int worker, const std::function<bool()> &f);
 
     bool Sync();
-    bool SyncSoon();
     bool Wait(int timeout);
     bool IsSuccess() const { return success; }
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "koffi",
-    "version": "3.0.2",
+    "version": "3.1.1",
     "description": "Fast and easy-to-use dynamic C FFI (foreign function interface) for Node.js",
     "keywords": [
         "foreign",
@@ -33,20 +33,21 @@
     },
     "funding": "https://liberapay.com/Koromix",
     "optionalDependencies": {
-        "@koromix/koffi-linux-arm64": "3.0.2",
-        "@koromix/koffi-linux-ia32": "3.0.2",
-        "@koromix/koffi-linux-x64": "3.0.2",
-        "@koromix/koffi-linux-riscv64": "3.0.2",
-        "@koromix/koffi-freebsd-ia32": "3.0.2",
-        "@koromix/koffi-freebsd-x64": "3.0.2",
-        "@koromix/koffi-freebsd-arm64": "3.0.2",
-        "@koromix/koffi-openbsd-ia32": "3.0.2",
-        "@koromix/koffi-openbsd-x64": "3.0.2",
-        "@koromix/koffi-win32-ia32": "3.0.2",
-        "@koromix/koffi-win32-x64": "3.0.2",
-        "@koromix/koffi-darwin-x64": "3.0.2",
-        "@koromix/koffi-darwin-arm64": "3.0.2",
-        "@koromix/koffi-linux-loong64": "3.0.2"
+        "@koromix/koffi-linux-arm64": "3.1.1",
+        "@koromix/koffi-linux-ia32": "3.1.1",
+        "@koromix/koffi-linux-x64": "3.1.1",
+        "@koromix/koffi-linux-riscv64": "3.1.1",
+        "@koromix/koffi-freebsd-ia32": "3.1.1",
+        "@koromix/koffi-freebsd-x64": "3.1.1",
+        "@koromix/koffi-freebsd-arm64": "3.1.1",
+        "@koromix/koffi-openbsd-ia32": "3.1.1",
+        "@koromix/koffi-openbsd-x64": "3.1.1",
+        "@koromix/koffi-win32-ia32": "3.1.1",
+        "@koromix/koffi-win32-x64": "3.1.1",
+        "@koromix/koffi-win32-arm64": "3.1.1",
+        "@koromix/koffi-darwin-x64": "3.1.1",
+        "@koromix/koffi-darwin-arm64": "3.1.1",
+        "@koromix/koffi-linux-loong64": "3.1.1"
     },
     "type": "module",
     "main": "./index.cjs",

package/src/koffi/CMakeLists.txt

@@ -137,7 +137,8 @@ if(WIN32)
     target_link_libraries(koffi PRIVATE ${UV_LINK_LIB})
 endif()
 
-target_compile_definitions(koffi PRIVATE FELIX_TARGET=koffi NAPI_DISABLE_CPP_EXCEPTIONS NAPI_VERSION=NAPI_VERSION_EXPERIMENTAL)
+target_compile_definitions(koffi PRIVATE FELIX_TARGET=koffi NAPI_VERSION=NAPI_VERSION_EXPERIMENTAL
+                                         NODE_ADDON_API_DISABLE_CPP_EXCEPTIONS NODE_ADDON_API_REQUIRE_BASIC_FINALIZERS)
 
 if(WIN32)
     target_compile_definitions(koffi PRIVATE _CRT_SECURE_NO_WARNINGS _CRT_NONSTDC_NO_DEPRECATE)
@@ -175,12 +176,11 @@ endif()
 if(NOT MSVC OR CMAKE_C_COMPILER_ID MATCHES "[Cc]lang")
     # Restore C/C++ compiler sanity
 
-    target_compile_options(koffi PRIVATE $<$<COMPILE_LANGUAGE:CXX>:-fno-exceptions -fno-rtti -fno-strict-aliasing
-                                                                   -fno-delete-null-pointer-checks>)
+    target_compile_options(koffi PRIVATE $<$<COMPILE_LANGUAGE:CXX>:-fno-strict-aliasing -fno-delete-null-pointer-checks>)
     if(MSVC)
-        target_compile_options(koffi PRIVATE $<$<COMPILE_LANGUAGE:CXX>:/clang:-fwrapv>)
+        target_compile_options(koffi PRIVATE $<$<COMPILE_LANGUAGE:CXX>:/clang:-fwrapv /clang:-fno-exceptions /clang:-fno-rtti>)
     else()
-        target_compile_options(koffi PRIVATE $<$<COMPILE_LANGUAGE:CXX>:-fwrapv>)
+        target_compile_options(koffi PRIVATE $<$<COMPILE_LANGUAGE:CXX>:-fwrapv -fno-exceptions -fno-rtti>)
     endif()
 
     check_cxx_compiler_flag(-fno-finite-loops use_no_finite_loops)
@@ -217,18 +217,20 @@ else()
     enable_unity_build(koffi)
 endif()
 
-if(APPLE)
-    add_custom_command(
-        TARGET koffi POST_BUILD
-        COMMAND $<$<CONFIG:release>:${CMAKE_STRIP}>
-        ARGS -x $<TARGET_FILE:koffi>
-    )
-elseif(UNIX)
-    add_custom_command(
-        TARGET koffi POST_BUILD
-        COMMAND $<$<CONFIG:release>:${CMAKE_STRIP}>
-        ARGS $<TARGET_FILE:koffi>
-    )
+if(CMAKE_BUILD_TYPE STREQUAL "Release")
+    if(APPLE)
+        add_custom_command(
+            TARGET koffi POST_BUILD
+            COMMAND ${CMAKE_STRIP}
+            ARGS -x $<TARGET_FILE:koffi>
+        )
+    elseif(UNIX)
+        add_custom_command(
+            TARGET koffi POST_BUILD
+            COMMAND ${CMAKE_STRIP}
+            ARGS $<TARGET_FILE:koffi>
+        )
+    endif()
 endif()
 
 # ---- Debug ----

package/src/koffi/index.cjs

@@ -4,8 +4,13 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
 };
 var __export = (target, all) => {
   for (var name in all)
@@ -128,7 +133,7 @@ var init_abi = __esm({
 var package_default;
 var init_package = __esm({
   "src/koffi/package.json"() {
-    package_default = { name: "koffi", version: "3.0.2", cnoke: { api: "../../vendor/node-api-headers", output: "../../bin/Koffi/{{ toolchain }}", node: 16, napi: 8 } };
+    package_default = { name: "koffi", version: "3.1.1", cnoke: { api: "../../vendor/node-api-headers", output: "../../bin/Koffi/{{ toolchain }}", node: 16, napi: 8 } };
   }
 });
 

package/src/koffi/index.js

@@ -94,7 +94,7 @@ function decodeElfHeader(buf) {
 }
 
 // src/koffi/package.json
-var package_default = { name: "koffi", version: "3.0.2", cnoke: { api: "../../vendor/node-api-headers", output: "../../bin/Koffi/{{ toolchain }}", node: 16, napi: 8 } };
+var package_default = { name: "koffi", version: "3.1.1", cnoke: { api: "../../vendor/node-api-headers", output: "../../bin/Koffi/{{ toolchain }}", node: 16, napi: 8 } };
 
 // src/koffi/src/init.js
 var require2 = createRequire(import.meta.url);

package/src/koffi/indirect.cjs

@@ -4,8 +4,13 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
 };
 var __export = (target, all) => {
   for (var name in all)
@@ -128,7 +133,7 @@ var init_abi = __esm({
 var package_default;
 var init_package = __esm({
   "src/koffi/package.json"() {
-    package_default = { name: "koffi", version: "3.0.2", cnoke: { api: "../../vendor/node-api-headers", output: "../../bin/Koffi/{{ toolchain }}", node: 16, napi: 8 } };
+    package_default = { name: "koffi", version: "3.1.1", cnoke: { api: "../../vendor/node-api-headers", output: "../../bin/Koffi/{{ toolchain }}", node: 16, napi: 8 } };
   }
 });
 

package/src/koffi/indirect.js

@@ -94,7 +94,7 @@ function decodeElfHeader(buf) {
 }
 
 // src/koffi/package.json
-var package_default = { name: "koffi", version: "3.0.2", cnoke: { api: "../../vendor/node-api-headers", output: "../../bin/Koffi/{{ toolchain }}", node: 16, napi: 8 } };
+var package_default = { name: "koffi", version: "3.1.1", cnoke: { api: "../../vendor/node-api-headers", output: "../../bin/Koffi/{{ toolchain }}", node: 16, napi: 8 } };
 
 // src/koffi/src/init.js
 var require2 = createRequire(import.meta.url);