@psnext/slingcli 2.4.20260526-1 → 2.4.20260527-2

package/node_modules/koffi/src/koffi/src/util.hh

@@ -1,221 +0,0 @@
-// SPDX-License-Identifier: MIT
-// SPDX-FileCopyrightText: 2025 Niels Martignène <niels.martignene@protonmail.com>
-
-#pragma once
-
-#include "lib/native/base/base.hh"
-#include "ffi.hh"
-
-#include <napi.h>
-
-namespace K {
-
-extern const napi_type_tag TypeInfoMarker;
-extern const napi_type_tag CastMarker;
-extern const napi_type_tag MagicUnionMarker;
-
-class MagicUnion: public Napi::ObjectWrap<MagicUnion> {
-    const TypeInfo *type;
-
-    Napi::Reference<Napi::Symbol> active_symbol;
-    Size active_idx = -1;
-
-    HeapArray<uint8_t> raw;
-
-public:
-    static Napi::Function InitClass(Napi::Env env, const TypeInfo *type);
-
-    MagicUnion(const Napi::CallbackInfo &info);
-
-    const TypeInfo *GetType() { return type; }
-    const RecordMember *GetMember() const { return (active_idx >= 0) ? &type->members[active_idx] : nullptr; }
-
-    void SetRaw(const uint8_t *ptr);
-    const uint8_t *GetRaw() const { return raw.ptr; }
-
-private:
-    Napi::Value Getter(const Napi::CallbackInfo &info);
-    void Setter(const Napi::CallbackInfo &info, const Napi::Value &value);
-};
-
-template <typename T, typename... Args>
-void ThrowError(Napi::Env env, const char *msg, Args... args)
-{
-    char buf[1024];
-    Fmt(buf, msg, args...);
-
-    auto err = T::New(env, buf);
-    err.ThrowAsJavaScriptException();
-}
-
-static inline bool IsInteger(const TypeInfo *type)
-{
-    bool integer = ((int)type->primitive >= (int)PrimitiveKind::Int8 &&
-                    (int)type->primitive <= (int)PrimitiveKind::UInt64);
-    return integer;
-}
-
-static inline bool IsFloat(const TypeInfo *type)
-{
-    bool fp = (type->primitive == PrimitiveKind::Float32 ||
-               type->primitive == PrimitiveKind::Float64);
-    return fp;
-}
-
-static inline bool IsRegularSize(Size size, Size max)
-{
-    bool regular = (size <= max && !(size & (size - 1)));
-    return regular;
-}
-
-int ResolveDirections(Span<const char> str);
-const TypeInfo *ResolveType(Napi::Value value, int *out_directions = nullptr);
-const TypeInfo *ResolveType(Napi::Env env, Span<const char> str);
-
-TypeInfo *MakePointerType(InstanceData *instance, const TypeInfo *ref, int count = 1);
-TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size len);
-TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size len, ArrayHint hint);
-
-Napi::External<TypeInfo> WrapType(Napi::Env env, const TypeInfo *type);
-
-bool CanPassType(const TypeInfo *type, int directions);
-bool CanReturnType(const TypeInfo *type);
-bool CanStoreType(const TypeInfo *type);
-
-// Can be slow, only use for error messages
-const char *GetValueType(const InstanceData *instance, Napi::Value value);
-
-void SetValueTag(Napi::Value value, const void *marker);
-bool CheckValueTag(Napi::Value value, const void *marker);
-
-static inline bool IsNullOrUndefined(Napi::Value value)
-{
-    return value.IsNull() || value.IsUndefined();
-}
-
-static inline bool IsObject(Napi::Value value)
-{
-    return value.IsObject() && !IsNullOrUndefined(value) && !value.IsArray();
-}
-
-static inline bool IsRawBuffer(Napi::Value value)
-{
-    return value.IsTypedArray() || value.IsArrayBuffer();
-}
-
-static inline Span<uint8_t> GetRawBuffer(Napi::Value value)
-{
-    if (value.IsBuffer()) {
-        void *ptr = nullptr;
-        size_t length = 0;
-
-        // Assume it works
-        napi_get_buffer_info(value.Env(), value, &ptr, &length);
-
-        return MakeSpan((uint8_t *)ptr, (Size)length);
-    } else if (value.IsArrayBuffer()) {
-        Napi::ArrayBuffer buffer = value.As<Napi::ArrayBuffer>();
-
-        return MakeSpan((uint8_t *)buffer.Data(), (Size)buffer.ByteLength());
-    }
-
-    K_UNREACHABLE();
-}
-
-int GetTypedArrayType(const TypeInfo *type);
-
-template <typename T>
-T GetNumber(Napi::Value value)
-{
-    K_ASSERT(value.IsNumber() || value.IsBigInt());
-
-    if (value.IsNumber()) [[likely]] {
-        return (T)value.As<Napi::Number>().DoubleValue();
-    } else if (value.IsBigInt()) {
-        Napi::BigInt bigint = value.As<Napi::BigInt>();
-
-        bool lossless;
-        return (T)bigint.Uint64Value(&lossless);
-    }
-
-    K_UNREACHABLE();
-}
-
-template <typename T>
-Size NullTerminatedLength(const T *ptr)
-{
-    Size len = 0;
-    while (ptr[len]) {
-        len++;
-    }
-    return len;
-}
-template <typename T>
-Size NullTerminatedLength(const T *ptr, Size max)
-{
-    Size len = 0;
-    while (len < max && ptr[len]) {
-        len++;
-    }
-    return len;
-}
-
-Napi::String MakeStringFromUTF32(Napi::Env env, const char32_t *ptr, Size len);
-static inline Napi::String MakeStringFromUTF32(Napi::Env env, const char32_t *ptr)
-    { return MakeStringFromUTF32(env, ptr, NullTerminatedLength(ptr)); }
-
-Napi::Object DecodeObject(Napi::Env env, const uint8_t *origin, const TypeInfo *type);
-void DecodeObject(Napi::Object obj, const uint8_t *origin, const TypeInfo *type);
-Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *type, uint32_t len);
-Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *type);
-void DecodeNormalArray(Napi::Array array, const uint8_t *origin, const TypeInfo *ref);
-void DecodeBuffer(Span<uint8_t> buffer, const uint8_t *origin, const TypeInfo *ref);
-
-Napi::Value Decode(Napi::Value value, Size offset, const TypeInfo *type, const Size *len = nullptr);
-Napi::Value Decode(Napi::Env env, const uint8_t *ptr, const TypeInfo *type, const Size *len = nullptr);
-
-bool Encode(Napi::Value ref, Size offset, Napi::Value value, const TypeInfo *type, const Size *len = nullptr);
-bool Encode(Napi::Env env, uint8_t *ptr, Napi::Value value, const TypeInfo *type, const Size *len = nullptr);
-
-static inline Napi::Value NewBigInt(Napi::Env env, int64_t value)
-{
-    if (value <= 9007199254740992ll && value >= -9007199254740992ll) {
-        double d = (double)value;
-        return Napi::Number::New(env, d);
-    } else {
-        return Napi::BigInt::New(env, value);
-    }
-}
-
-static inline Napi::Value NewBigInt(Napi::Env env, uint64_t value)
-{
-    if (value <= 9007199254740992ull) {
-        double d = (double)value;
-        return Napi::Number::New(env, d);
-    } else {
-        return Napi::BigInt::New(env, value);
-    }
-}
-
-static inline Napi::Array GetOwnPropertyNames(Napi::Object obj)
-{
-    Napi::Env env = obj.Env();
-
-    napi_value result;
-    napi_status status = napi_get_all_property_names(env, obj, napi_key_own_only,
-                                                     (napi_key_filter)(napi_key_enumerable | napi_key_skip_symbols),
-                                                     napi_key_numbers_to_strings, &result);
-    K_ASSERT(status == napi_ok);
-
-    return Napi::Array(env, result);
-}
-
-Napi::Function WrapFunction(Napi::Env env, const FunctionInfo *func);
-
-bool DetectCallConvention(Span<const char> name, CallConvention *out_convention);
-
-int AnalyseFlat(const TypeInfo *type, FunctionRef<void(const TypeInfo *type, int offset, int count)> func);
-
-void DumpMemory(const char *type, Span<const uint8_t> bytes);
-
-}

package/node_modules/koffi/src/koffi/src/uv.cc

@@ -1,193 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-#include "uv.hh"
-#include "util.hh"
-
-#include <uv.h>
-
-namespace K {
-
-Napi::Function PollHandle::Define(Napi::Env env)
-{
-    return DefineClass(env, "PollHandle", {
-        InstanceMethod("start", &PollHandle::Start),
-        InstanceMethod("stop", &PollHandle::Stop),
-        InstanceMethod("close", &PollHandle::Close),
-        InstanceMethod("unref", &PollHandle::Unref),
-        InstanceMethod("ref", &PollHandle::Ref)
-    });
-}
-
-PollHandle::PollHandle(const Napi::CallbackInfo &info)
-    : Napi::ObjectWrap<PollHandle>(info), env(info.Env())
-{
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
-
-    if (info.Length() < 1 || !info[0].IsNumber()) {
-        ThrowError<Napi::Error>(env, "Expected 1 argument, got %1", info.Length());
-        return;
-    }
-    if (!info[0].IsNumber()) {
-        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for descriptor, expected number", GetValueType(instance, info[0]));
-        return;
-    }
-
-    int fd = info[0].As<Napi::Number>().Int32Value();
-
-    uv_loop_t *loop = nullptr;
-    if (napi_get_uv_event_loop(env, &loop) != napi_ok || !loop) {
-        ThrowError<Napi::Error>(env, "napi_get_uv_event_loop() failed");
-        return;
-    }
-
-    // We would store it inside the class, but the definition of uv_poll_t involves windows.h...
-    // and we won't want that on Windows. Heap allocation it is!
-    // Also, it may have to outlive the object, because uv_close() is asynchronous.
-    handle = new uv_poll_t();
-
-    if (int ret = uv_poll_init_socket(loop, handle, (uv_os_sock_t)fd); ret != 0) {
-        ThrowError<Napi::Error>(env, "Failed to init UV poll: %1", uv_strerror(ret));
-        return;
-    }
-
-    handle->data = this;
-}
-
-void PollHandle::Start(const Napi::CallbackInfo &info)
-{
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
-
-    bool has_opts = (info.Length() >= 2 && info[0].IsObject());
-
-    if (info.Length() < 1u + has_opts) {
-        ThrowError<Napi::TypeError>(env, "Expected 1 to 2 arguments, got %1", info.Length());
-        return;
-    }
-    if (!info[0u + has_opts].IsFunction()) {
-        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for callback, expected function", GetValueType(instance, info[0u + has_opts]));
-        return;
-    }
-
-    int events = 0;
-    Napi::Function cb = info[0 + has_opts].As<Napi::Function>();
-
-    if (has_opts) {
-        Napi::Object opts = has_opts ? info[0].As<Napi::Object>() : Napi::Object::New(env);
-
-        events |= opts.Get("readable").ToBoolean() ? UV_READABLE : 0;
-        events |= opts.Get("writable").ToBoolean() ? UV_WRITABLE : 0;
-        events |= opts.Get("disconnect").ToBoolean() ? UV_DISCONNECT : 0;
-    } else {
-        events = UV_READABLE;
-    }
-
-    callback.Reset(cb, 1);
-
-    if (int ret = uv_poll_start(handle, events, &PollHandle::OnPoll); ret != 0) {
-        callback.Reset();
-        ThrowError<Napi::Error>(env, "Failed to start UV poll: %1", uv_strerror(ret));
-    }
-}
-
-void PollHandle::Stop(const Napi::CallbackInfo &)
-{
-    uv_poll_stop(handle);
-    callback.Reset();
-}
-
-void PollHandle::Close(const Napi::CallbackInfo &)
-{
-    Close();
-    callback.Reset();
-}
-
-void PollHandle::Ref(const Napi::CallbackInfo &)
-{
-    uv_ref((uv_handle_t *)handle);
-}
-
-void PollHandle::Unref(const Napi::CallbackInfo &)
-{
-    uv_unref((uv_handle_t *)handle);
-}
-
-void PollHandle::Close()
-{
-    if (!handle)
-        return;
-
-    const auto release = [](uv_handle_t *ptr) {
-        uv_poll_t *handle = (uv_poll_t *)ptr;
-        delete handle;
-    };
-
-    uv_poll_stop(handle);
-    uv_close((uv_handle_t *)handle, release);
-
-    handle = nullptr;
-}
-
-void PollHandle::OnPoll(uv_poll_t *h, int status, int events)
-{
-    PollHandle *poll = (PollHandle *)h->data;
-
-    if (poll->callback.IsEmpty()) [[unlikely]]
-        return;
-
-    Napi::Env env = poll->env;
-    Napi::HandleScope scope(env);
-
-    Napi::Object obj = Napi::Object::New(env);
-
-    obj.Set("readable", !!(events & UV_READABLE));
-    obj.Set("writable", !!(events & UV_WRITABLE));
-    obj.Set("disconnect", !!(events & UV_DISCONNECT));
-
-    napi_value args[] = { Napi::Number::New(env, status), obj };
-    poll->callback.Call(poll->Value(), K_LEN(args), args);
-}
-
-Napi::Value Poll(const Napi::CallbackInfo &info)
-{
-    Napi::Env env = info.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
-
-    bool has_opts = (info.Length() >= 3 && info[1].IsObject());
-
-    if (info.Length() < 2u + has_opts) {
-        ThrowError<Napi::TypeError>(env, "Expected 2 to 3 arguments, got %1", info.Length());
-        return env.Null();
-    }
-
-    if (!info[0].IsNumber()) {
-        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for descriptor, expected number", GetValueType(instance, info[0]));
-        return env.Null();
-    }
-    if (!info[1 + has_opts].IsFunction()) {
-        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for callback, expected function", GetValueType(instance, info[1 + has_opts]));
-        return env.Null();
-    }
-
-    int fd = info[0].As<Napi::Number>().Int32Value();
-
-    Napi::Function ctor = PollHandle::Define(env);
-    Napi::Object inst = ctor.New({ Napi::Number::New(env, fd) });
-    Napi::Function start = inst.Get("start").As<Napi::Function>();
-
-    if (env.IsExceptionPending()) [[unlikely]]
-        return env.Null();
-
-    if (has_opts) {
-        Napi::Value opts = info[1];
-        Napi::Function cb = info[2].As<Napi::Function>();
-
-        start.Call(inst, { opts, cb });
-    } else {
-        Napi::Function cb = info[1].As<Napi::Function>();
-        start.Call(inst, { cb });
-    }
-
-    return inst;
-}
-
-}

package/node_modules/koffi/src/koffi/src/uv.def

@@ -1,10 +0,0 @@
-NAME NODE.EXE
-EXPORTS
-uv_close
-uv_ref
-uv_unref
-uv_strerror
-uv_poll_init
-uv_poll_init_socket
-uv_poll_start
-uv_poll_stop

package/node_modules/koffi/src/koffi/src/uv.hh

@@ -1,40 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include "lib/native/base/base.hh"
-
-#include <napi.h>
-
-struct uv_poll_s;
-typedef struct uv_poll_s uv_poll_t;
-
-namespace K {
-
-class PollHandle: public Napi::ObjectWrap<PollHandle> {
-    Napi::Env env = nullptr;
-
-    uv_poll_t *handle = nullptr;
-    Napi::FunctionReference callback;
-
-public:
-    static Napi::Function Define(Napi::Env env);
-
-    PollHandle(const Napi::CallbackInfo &info);
-    ~PollHandle() { Close(); }
-
-    void Start(const Napi::CallbackInfo &info);
-    void Stop(const Napi::CallbackInfo &info);
-    void Close(const Napi::CallbackInfo &info);
-    void Ref(const Napi::CallbackInfo &info);
-    void Unref(const Napi::CallbackInfo &info);
-
-private:
-    void Close();
-
-    static void OnPoll(uv_poll_t *handle, int status, int events);
-};
-
-Napi::Value Poll(const Napi::CallbackInfo &info);
-
-}

package/node_modules/koffi/src/koffi/src/win32.cc

@@ -1,198 +0,0 @@
-// SPDX-License-Identifier: MIT
-// SPDX-FileCopyrightText: 2025 Niels Martignène <niels.martignene@protonmail.com>
-
-#if defined(_WIN32)
-
-#include "util.hh"
-#include "win32.hh"
-
-#if !defined(NOMINMAX)
-    #define NOMINMAX
-#endif
-#if !defined(WIN32_LEAN_AND_MEAN)
-    #define WIN32_LEAN_AND_MEAN
-#endif
-#include <windows.h>
-#include <ntsecapi.h>
-#include <processthreadsapi.h>
-
-namespace K {
-
-const HashMap<int, const char *> WindowsMachineNames = {
-    { 0x184, "Alpha AXP, 32-bit" },
-    { 0x284, "Alpha 64" },
-    { 0x1d3, "Matsushita AM33" },
-    { 0x8664, "AMD x64" },
-    { 0x1c0, "ARM little endian" },
-    { 0xaa64, "ARM64 little endian" },
-    { 0x1c4, "ARM Thumb-2 little endian" },
-    { 0x284, "AXP 64" },
-    { 0xebc, "EFI byte code" },
-    { 0x14c, "Intel 386+" },
-    { 0x200, "Intel Itanium" },
-    { 0x6232, "LoongArch 32-bit" },
-    { 0x6264, "LoongArch 64-bit" },
-    { 0x9041, "Mitsubishi M32R little endian" },
-    { 0x266, "MIPS16" },
-    { 0x366, "MIPS with FPU" },
-    { 0x466, "MIPS16 with FPU" },
-    { 0x1f0, "Power PC little endian" },
-    { 0x1f1, "Power PC with FP support" },
-    { 0x166, "MIPS little endian" },
-    { 0x5032, "RISC-V 32-bit" },
-    { 0x5064, "RISC-V 64-bit" },
-    { 0x5128, "RISC-V 128-bit" },
-    { 0x1a2, "Hitachi SH3" },
-    { 0x1a3, "Hitachi SH3 DSP" },
-    { 0x1a6, "Hitachi SH4" },
-    { 0x1a8, "Hitachi SH5" },
-    { 0x1c2, "Thumb" },
-    { 0x169, "MIPS little-endian WCE v2" }
-};
-
-HANDLE LoadWindowsLibrary(Napi::Env env, Span<const char> path)
-{
-    BlockAllocator temp_alloc;
-
-    Span<wchar_t> filename_w = AllocateSpan<wchar_t>(&temp_alloc, path.len + 1);
-
-    if (ConvertUtf8ToWin32Wide(path, filename_w) < 0) {
-        ThrowError<Napi::Error>(env, "Invalid path string");
-        return nullptr;
-    }
-
-    HMODULE module = LoadLibraryW(filename_w.ptr);
-
-    if (!module) {
-        DWORD flags = LOAD_LIBRARY_SEARCH_DEFAULT_DIRS | LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR;
-
-        Span<const char> filename = NormalizePath(path, GetWorkingDirectory(), &temp_alloc);
-        Span<wchar_t> filename_w = AllocateSpan<wchar_t>(&temp_alloc, filename.len + 1);
-
-        if (ConvertUtf8ToWin32Wide(filename, filename_w) < 0) {
-            ThrowError<Napi::Error>(env, "Invalid path string");
-            return nullptr;
-        }
-
-        module = LoadLibraryExW(filename_w.ptr, nullptr, flags);
-    }
-
-    if (!module) {
-        if (GetLastError() == ERROR_BAD_EXE_FORMAT) {
-            int process = GetSelfMachine();
-            int dll = GetDllMachine(filename_w.ptr);
-
-            if (process >= 0 && dll >= 0 && dll != process) {
-                ThrowError<Napi::Error>(env, "Cannot load '%1' DLL in '%2' process",
-                                        WindowsMachineNames.FindValue(dll, "Unknown"),
-                                        WindowsMachineNames.FindValue(process, "Unknown"));
-                return nullptr;
-            }
-        }
-
-        ThrowError<Napi::Error>(env, "Failed to load shared library: %1", GetWin32ErrorString());
-        return nullptr;
-    }
-
-    return module;
-}
-
-// Fails silently on purpose
-static bool ReadAt(HANDLE h, int32_t offset, void *buf, int len)
-{
-    OVERLAPPED ov = {};
-    DWORD read;
-
-    ov.Offset = offset & 0x7FFFFFFFu;
-
-    if (offset < 0)
-        return false;
-    if (!ReadFile(h, buf, (DWORD)len, &read, &ov))
-        return false;
-    if (read != (DWORD)len)
-        return false;
-
-    return true;
-}
-
-static int GetFileMachine(HANDLE h, bool check_dll)
-{
-    PE_DOS_HEADER dos = {};
-    PE_NT_HEADERS nt = {};
-
-    if (!ReadAt(h, 0, &dos, K_SIZE(dos)))
-        goto generic;
-    if (!ReadAt(h, dos.e_lfanew, &nt, K_SIZE(nt)))
-        goto generic;
-
-    if (dos.e_magic != 0x5A4D) // MZ
-        goto generic;
-    if (nt.Signature != 0x00004550) // PE\0\0
-        goto generic;
-    if (check_dll && !(nt.FileHeader.Characteristics & IMAGE_FILE_DLL))
-        goto generic;
-
-    return (int)nt.FileHeader.Machine;
-
-generic:
-    LogError("Invalid or forbidden %1 file: %2", check_dll ? "DLL" : "executable", GetWin32ErrorString());
-    return -1;
-}
-
-int GetSelfMachine()
-{
-    const char *filename = GetApplicationExecutable();
-
-    HANDLE h;
-    if (IsWin32Utf8()) {
-        h = CreateFileA(filename, GENERIC_READ,
-                        FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
-                        nullptr, OPEN_EXISTING, 0, nullptr);
-    } else {
-        wchar_t filename_w[4096];
-        if (ConvertUtf8ToWin32Wide(filename, filename_w) < 0)
-            return -1;
-
-        h = CreateFileW(filename_w, GENERIC_READ,
-                        FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
-                        nullptr, OPEN_EXISTING, 0, nullptr);
-    }
-    if (h == INVALID_HANDLE_VALUE) {
-        LogError("Cannot open '%1': %2", filename, GetWin32ErrorString());
-        return -1;
-    }
-    K_DEFER { CloseHandle(h); };
-
-    return GetFileMachine(h, false);
-}
-
-int GetDllMachine(const wchar_t *filename)
-{
-    HANDLE h = CreateFileW((LPCWSTR)filename, GENERIC_READ,
-                           FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
-                           nullptr, OPEN_EXISTING, 0, nullptr);
-    if (h == INVALID_HANDLE_VALUE) {
-        LogError("Cannot open '%1': %2", filename, GetWin32ErrorString());
-        return -1;
-    }
-    K_DEFER { CloseHandle(h); };
-
-    return GetFileMachine(h, true);
-}
-
-extern "C" int __cdecl SehHandler(void *ptr, void *, void *ctx, void *)
-{
-    EXCEPTION_RECORD *rec = (EXCEPTION_RECORD *)ptr;
-
-    if (!(rec->ExceptionFlags & (EXCEPTION_UNWINDING | EXCEPTION_EXIT_UNWIND))) {
-        EXCEPTION_POINTERS ep = { rec, (CONTEXT *)ctx };
-        UnhandledExceptionFilter(&ep);
-        ExitProcess(rec->ExceptionCode);
-    }
-
-    return ExceptionContinueSearch;
-}
-
-}
-
-#endif