koffi 3.0.1 → 3.1.0

package/lib/native/base/base.cc

@@ -1511,7 +1511,7 @@ static inline void ProcessArg(const FmtArg &arg, AppendFunc append)
             append(FormatUnsignedToDecimal((uint64_t)arg.u.date.st.day, buf));
         } break;
 
-        case FmtType::TimeISO: {
+        case FmtType::TimeBasic: {
             const TimeSpec &spec = arg.u.time.spec;
 
             LocalArray<char, 128> buf;
@@ -1548,6 +1548,43 @@ static inline void ProcessArg(const FmtArg &arg, AppendFunc append)
 
             append(buf);
         } break;
+        case FmtType::TimeIso: {
+            const TimeSpec &spec = arg.u.time.spec;
+
+            LocalArray<char, 128> buf;
+
+            if (spec.offset && arg.u.time.ms) {
+                int offset_h = spec.offset / 60;
+                int offset_m = spec.offset % 60;
+
+                buf.len = Fmt(buf.data, "%1-%2-%3T%4:%5:%6.%7%8%9%10",
+                              FmtInt(spec.year, 2), FmtInt(spec.month, 2),
+                              FmtInt(spec.day, 2), FmtInt(spec.hour, 2),
+                              FmtInt(spec.min, 2), FmtInt(spec.sec, 2), FmtInt(spec.msec, 3),
+                              offset_h >= 0 ? "+" : "", FmtInt(offset_h, 2), FmtInt(offset_m, 2)).len;
+            } else if (spec.offset) {
+                int offset_h = spec.offset / 60;
+                int offset_m = spec.offset % 60;
+
+                buf.len = Fmt(buf.data, "%1-%2-%3T%4:%5:%6%7%8%9",
+                              FmtInt(spec.year, 2), FmtInt(spec.month, 2),
+                              FmtInt(spec.day, 2), FmtInt(spec.hour, 2),
+                              FmtInt(spec.min, 2), FmtInt(spec.sec, 2),
+                              offset_h >= 0 ? "+" : "", FmtInt(offset_h, 2), FmtInt(offset_m, 2)).len;
+            } else if (arg.u.time.ms) {
+                buf.len = Fmt(buf.data, "%1-%2-%3T%4:%5:%6.%7Z",
+                              FmtInt(spec.year, 2), FmtInt(spec.month, 2),
+                              FmtInt(spec.day, 2), FmtInt(spec.hour, 2),
+                              FmtInt(spec.min, 2), FmtInt(spec.sec, 2), FmtInt(spec.msec, 3)).len;
+            } else {
+                buf.len = Fmt(buf.data, "%1-%2-%3T%4:%5:%6Z",
+                              FmtInt(spec.year, 2), FmtInt(spec.month, 2),
+                              FmtInt(spec.day, 2), FmtInt(spec.hour, 2),
+                              FmtInt(spec.min, 2), FmtInt(spec.sec, 2)).len;
+            }
+
+            append(buf);
+        } break;
         case FmtType::TimeNice: {
             const TimeSpec &spec = arg.u.time.spec;
 
@@ -1947,7 +1984,7 @@ void FmtUrlSafe::Format(FunctionRef<void(Span<const char>)> append) const
     }
 }
 
-void FmtHtmlSafe::Format(FunctionRef<void(Span<const char>)> append) const
+void FmtXmlSafe::Format(FunctionRef<void(Span<const char>)> append) const
 {
     for (char c: str) {
         switch (c) {
@@ -5171,7 +5208,7 @@ bool ExecuteCommandLine(const char *cmd_line, const ExecuteInfo &info,
 
     // Read and write standard process streams
     {
-        bool running = true;
+        bool running = in_func.IsValid() || out_func.IsValid();
 
         PendingIO proc_in;
         Span<const uint8_t> write_buf = {};
@@ -5201,6 +5238,7 @@ bool ExecuteCommandLine(const char *cmd_line, const ExecuteInfo &info,
                         }
                     } else {
                         CloseHandleSafe(&in_pipe[1]);
+                        running &= out_func.IsValid();
                     }
                 }
 
@@ -5632,7 +5670,7 @@ bool ExecuteCommandLine(const char *cmd_line, const ExecuteInfo &info,
     return true;
 }
 
-Size ReadCommandOutput(const char *cmd_line, Span<char> out_output)
+Size ReadCommandOutput(const char *cmd_line, Span<uint8_t> out_output)
 {
     static ExecuteInfo::KeyValue variables[] = {
         { "LANG", "C" },
@@ -5654,14 +5692,14 @@ Size ReadCommandOutput(const char *cmd_line, Span<char> out_output)
     if (!ExecuteCommandLine(cmd_line, info, MakeSpan((const uint8_t *)nullptr, 0), write, &exit_code))
         return -1;
     if (exit_code) {
-        LogDebug("Command '%1 failed (exit code: %2)", cmd_line, exit_code);
+        LogDebug("Command '%1' failed (exit code: %2)", cmd_line, exit_code);
         return -1;
     }
 
     return total_len;
 }
 
-bool ReadCommandOutput(const char *cmd_line, HeapArray<char> *out_output)
+bool ReadCommandOutput(const char *cmd_line, HeapArray<uint8_t> *out_output)
 {
     static ExecuteInfo::KeyValue variables[] = {
         { "LANG", "C" },
@@ -5675,7 +5713,7 @@ bool ReadCommandOutput(const char *cmd_line, HeapArray<char> *out_output)
     if (!ExecuteCommandLine(cmd_line, info, {}, Mebibytes(1), out_output, &exit_code))
         return false;
     if (exit_code) {
-        LogDebug("Command '%1 failed (exit code: %2)", cmd_line, exit_code);
+        LogDebug("Command '%1' failed (exit code: %2)", cmd_line, exit_code);
         return false;
     }
 
@@ -7405,7 +7443,7 @@ public:
     void AddTask(Async *async, int worker_idx, const std::function<bool()> &func);
 
     void RunWorker(int worker_idx);
-    void SyncOn(Async *async, bool soon);
+    void SyncOn(Async *async, Async *only);
     bool WaitOn(Async *async, int timeout);
 
     void RunTasks(int worker_idx, Async *only);
@@ -7419,7 +7457,7 @@ static thread_local AsyncPool *async_running_pool = nullptr;
 static thread_local int async_running_worker_idx;
 static thread_local bool async_running_task = false;
 
-Async::Async(int threads)
+Async::Async(int threads, unsigned int flags)
 {
     K_ASSERT(threads);
 
@@ -7441,14 +7479,22 @@ Async::Async(int threads)
     }
 
     pool->RegisterAsync();
+
+    if (flags & (int)AsyncFlag::Selfish) {
+        only = this;
+    }
 }
 
-Async::Async(Async *parent)
+Async::Async(Async *parent, unsigned int flags)
 {
     K_ASSERT(parent);
 
     pool = parent->pool;
     pool->RegisterAsync();
+
+    if (flags & (int)AsyncFlag::Selfish) {
+        only = this;
+    }
 }
 
 Async::~Async()
@@ -7471,13 +7517,7 @@ void Async::Run(int worker, const std::function<bool()> &func)
 
 bool Async::Sync()
 {
-    pool->SyncOn(this, false);
-    return success;
-}
-
-bool Async::SyncSoon()
-{
-    pool->SyncOn(this, true);
+    pool->SyncOn(this, only);
     return success;
 }
 
@@ -7613,7 +7653,7 @@ void AsyncPool::AddTask(Async *async, int worker_idx, const std::function<bool()
         int worker_idx = async_running_worker_idx;
 
         do {
-            RunTasks(worker_idx, nullptr);
+            RunTasks(worker_idx, async->only);
         } while (pending_tasks >= K_ASYNC_MAX_PENDING_TASKS);
     } else if (!prev_pending) {
         std::lock_guard<std::mutex> lock_pool(pool_mutex);
@@ -7647,7 +7687,7 @@ void AsyncPool::RunWorker(int worker_idx)
     }
 }
 
-void AsyncPool::SyncOn(Async *async, bool soon)
+void AsyncPool::SyncOn(Async *async, Async *only)
 {
     K_DEFER_C(pool = async_running_pool,
                worker_idx = async_running_worker_idx) {
@@ -7659,7 +7699,7 @@ void AsyncPool::SyncOn(Async *async, bool soon)
     async_running_worker_idx = 0;
 
     while (async->remaining_tasks) {
-        RunTasks(0, soon ? async : nullptr);
+        RunTasks(0, only);
 
         std::unique_lock<std::mutex> lock_sync(pool_mutex);
         sync_cv.wait(lock_sync, [&]() { return pending_tasks || !async->remaining_tasks; });
@@ -7739,12 +7779,12 @@ void AsyncPool::RunTask(Task *task)
 #else
 
 
-Async::Async(int threads)
+Async::Async(int threads, unsigned int)
 {
     K_ASSERT(threads);
 }
 
-Async::Async(Async *parent)
+Async::Async(Async *parent, unsigned int)
 {
     K_ASSERT(parent);
 }
@@ -10728,7 +10768,7 @@ const char *GetMimeType(Span<const char> extension, const char *default_type)
     const char *mimetype = mimetypes.FindValue(lower, nullptr);
 
     if (!mimetype) {
-        LogError("Unknown MIME type for extension '%1'", extension);
+        LogDebug("Unknown MIME type for extension '%1'", extension);
         mimetype = default_type;
     }
 
@@ -10768,8 +10808,10 @@ bool CanCompressFile(const char *filename)
     if (TestStrI(extension, ".db") || TestStrI(extension, ".sqlite3"))
         return false;
 
-    const char *mimetype = GetMimeType(extension);
+    const char *mimetype = GetMimeType(extension, nullptr);
 
+    if (!mimetype)
+        return false;
     if (StartsWith(mimetype, "video/"))
         return false;
     if (StartsWith(mimetype, "audio/"))

package/lib/native/base/base.hh

@@ -3074,8 +3074,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 +3146,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 +3189,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 +3198,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 +3328,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 +3376,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 +3561,8 @@ enum class FmtType {
     MemorySize,
     DiskSize,
     Date,
-    TimeISO,
+    TimeBasic,
+    TimeIso,
     TimeNice,
     List,
     FlagNames,
@@ -3938,10 +3817,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 +3948,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 +4563,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 +4931,10 @@ void CloseSocket(int fd);
 // Tasks
 // ------------------------------------------------------------------------
 
+enum class AsyncFlag {
+    Selfish = 1 << 0
+};
+
 class Async {
     K_DELETE_COPY(Async)
 
@@ -5042,20 +4943,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.1",
+    "version": "3.1.0",
     "description": "Fast and easy-to-use dynamic C FFI (foreign function interface) for Node.js",
     "keywords": [
         "foreign",
@@ -33,20 +33,20 @@
     },
     "funding": "https://liberapay.com/Koromix",
     "optionalDependencies": {
-        "@koromix/koffi-linux-arm64": "3.0.1",
-        "@koromix/koffi-linux-ia32": "3.0.1",
-        "@koromix/koffi-linux-x64": "3.0.1",
-        "@koromix/koffi-linux-riscv64": "3.0.1",
-        "@koromix/koffi-freebsd-ia32": "3.0.1",
-        "@koromix/koffi-freebsd-x64": "3.0.1",
-        "@koromix/koffi-freebsd-arm64": "3.0.1",
-        "@koromix/koffi-openbsd-ia32": "3.0.1",
-        "@koromix/koffi-openbsd-x64": "3.0.1",
-        "@koromix/koffi-win32-ia32": "3.0.1",
-        "@koromix/koffi-win32-x64": "3.0.1",
-        "@koromix/koffi-darwin-x64": "3.0.1",
-        "@koromix/koffi-darwin-arm64": "3.0.1",
-        "@koromix/koffi-linux-loong64": "3.0.1"
+        "@koromix/koffi-linux-arm64": "3.1.0",
+        "@koromix/koffi-linux-ia32": "3.1.0",
+        "@koromix/koffi-linux-x64": "3.1.0",
+        "@koromix/koffi-linux-riscv64": "3.1.0",
+        "@koromix/koffi-freebsd-ia32": "3.1.0",
+        "@koromix/koffi-freebsd-x64": "3.1.0",
+        "@koromix/koffi-freebsd-arm64": "3.1.0",
+        "@koromix/koffi-openbsd-ia32": "3.1.0",
+        "@koromix/koffi-openbsd-x64": "3.1.0",
+        "@koromix/koffi-win32-ia32": "3.1.0",
+        "@koromix/koffi-win32-x64": "3.1.0",
+        "@koromix/koffi-darwin-x64": "3.1.0",
+        "@koromix/koffi-darwin-arm64": "3.1.0",
+        "@koromix/koffi-linux-loong64": "3.1.0"
     },
     "type": "module",
     "main": "./index.cjs",
@@ -60,7 +60,7 @@
         "./indirect": {
             "import": "./indirect.js",
             "require": "./indirect.cjs",
-            "types": "./indirect.d.ts"
+            "types": "./index.d.ts"
         }
     },
     "types": "./index.d.ts"

package/src/koffi/CMakeLists.txt

@@ -67,6 +67,7 @@ set(KOFFI_SRC
     src/call.cc
     src/ffi.cc
     src/parser.cc
+    src/type.cc
     src/util.cc
     src/uv.cc
     src/win32.cc
@@ -136,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)
@@ -174,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)
@@ -216,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 ----