koffi 2.5.10 → 2.5.12

package/src/core/libcc/libcc.hh

@@ -272,6 +272,7 @@ constexpr Size Kilobytes(Size len) { return len * 1000; }
 #define RG_SIZE(Type) ((RG::Size)sizeof(Type))
 template <typename T, unsigned N>
 char (&ComputeArraySize(T const (&)[N]))[N];
+#define RG_BITS(Type) (8 * RG_SIZE(Type))
 #define RG_LEN(Array) RG_SIZE(RG::ComputeArraySize(Array))
 #define RG_OFFSET_OF(Type, Member) ((Size)__builtin_offsetof(Type, Member))
 
@@ -1856,7 +1857,7 @@ public:
     typedef Iterator<Bitset> iterator_type;
 
     static constexpr Size Bits = N;
-    size_t data[(N + RG_SIZE(size_t) - 1) / RG_SIZE(size_t)] = {};
+    size_t data[(N + RG_BITS(size_t) - 1) / RG_BITS(size_t)] = {};
 
     void Clear()
     {
@@ -3315,41 +3316,38 @@ static inline int CmpStr(const char *str1, Span<const char> str2)
 static inline int CmpStr(const char *str1, const char *str2)
     { return strcmp(str1, str2); }
 
-static inline Size StartsWith(Span<const char> str, Span<const char> prefix)
+static inline bool StartsWith(Span<const char> str, Span<const char> prefix)
 {
     Size i = 0;
     while (i < str.len && i < prefix.len) {
         if (str[i] != prefix[i])
-            return 0;
-
+            return false;
         i++;
     }
 
-    return (i == prefix.len) ? i : 0;
+    return (i == prefix.len);
 }
-static inline Size StartsWith(Span<const char> str, const char *prefix)
+static inline bool StartsWith(Span<const char> str, const char *prefix)
 {
     Size i = 0;
     while (i < str.len && prefix[i]) {
         if (str[i] != prefix[i])
-            return 0;
-
+            return false;
         i++;
     }
 
-    return !prefix[i] ? i : 0;
+    return !prefix[i];
 }
-static inline Size StartsWith(const char *str, const char *prefix)
+static inline bool StartsWith(const char *str, const char *prefix)
 {
     Size i = 0;
     while (str[i] && prefix[i]) {
         if (str[i] != prefix[i])
-            return 0;
-
+            return false;
         i++;
     }
 
-    return !prefix[i] ? i : 0;
+    return !prefix[i];
 }
 
 static inline bool EndsWith(Span<const char> str, const char *suffix)
@@ -3703,6 +3701,31 @@ overflow:
 bool ParseBool(Span<const char> str, bool *out_value, unsigned int flags = RG_DEFAULT_PARSE_FLAGS,
                Span<const char> *out_remaining = nullptr);
 
+bool ParseSize(Span<const char> str, int64_t *out_size, unsigned int flags = RG_DEFAULT_PARSE_FLAGS,
+               Span<const char> *out_remaining = nullptr);
+#if RG_SIZE_MAX < INT64_MAX
+static inline bool ParseSize(Span<const char> str, Size *out_size,
+                             unsigned int flags = RG_DEFAULT_PARSE_FLAGS, Span<const char> *out_remaining = nullptr)
+{
+    int64_t size = 0;
+    if (!ParseSize(str, &size, flags, out_remaining))
+        return false;
+
+    if (size > RG_SIZE_MAX) [[unlikely]] {
+        if (flags & (int)ParseFlag::Log) {
+            LogError("Size value is too high");
+        }
+        return false;
+    }
+
+    *out_size = (Size)size;
+    return true;
+}
+#endif
+
+bool ParseDuration(Span<const char> str, int64_t *out_duration, unsigned int flags = RG_DEFAULT_PARSE_FLAGS,
+                   Span<const char> *out_remaining = nullptr);
+
 static inline Size EncodeUtf8(int32_t c, char out_buf[4])
 {
     if (c < 0x80) {
@@ -3806,10 +3829,12 @@ static inline Size DecodeUtf8(Span<const char> str, Size offset, int32_t *out_c)
 #ifdef _WIN32
     #define RG_PATH_SEPARATORS "\\/"
     #define RG_PATH_DELIMITER ';'
+    #define RG_EXECUTABLE_EXTENSION ".exe"
     #define RG_SHARED_LIBRARY_EXTENSION ".dll"
 #else
     #define RG_PATH_SEPARATORS "/"
     #define RG_PATH_DELIMITER ':'
+    #define RG_EXECUTABLE_EXTENSION ""
     #define RG_SHARED_LIBRARY_EXTENSION ".so"
 #endif
 
@@ -4096,11 +4121,11 @@ bool NotifySystemd();
         })()
 #endif
 
+void InitRG();
+int Main(int argc, char **argv);
+
 static inline int RunApp(int argc, char **argv)
 {
-    void InitRG();
-    int Main(int argc, char **argv);
-
     InitRG();
     return Main(argc, argv);
 }
@@ -4658,6 +4683,9 @@ public:
 
 bool SpliceStream(StreamReader *reader, int64_t max_len, StreamWriter *writer);
 
+bool IsCompressorAvailable(CompressionType compression_type);
+bool IsDecompressorAvailable(CompressionType compression_type);
+
 // For convenience, don't close them
 extern StreamReader stdin_st;
 extern StreamWriter stdout_st;

package/src/index.js

@@ -47,13 +47,13 @@ try {
     switch (triplet) {
         case 'darwin_arm64': { native = require('../build/koffi/darwin_arm64/koffi.node'); } break;
         case 'darwin_x64': { native = require('../build/koffi/darwin_x64/koffi.node'); } break;
-        case 'freebsd_arm46': { native = require('../build/koffi/freebsd_arm46/koffi.node'); } break;
+        case 'freebsd_arm64': { native = require('../build/koffi/freebsd_arm64/koffi.node'); } break;
         case 'freebsd_ia32': { native = require('../build/koffi/freebsd_ia32/koffi.node'); } break;
         case 'freebsd_x64': { native = require('../build/koffi/freebsd_x64/koffi.node'); } break;
         case 'linux_arm32hf': { native = require('../build/koffi/linux_arm32hf/koffi.node'); } break;
         case 'linux_arm64': { native = require('../build/koffi/linux_arm64/koffi.node'); } break;
         case 'linux_ia32': { native = require('../build/koffi/linux_ia32/koffi.node'); } break;
-        case 'linux_risc64hf64': { native = require('../build/koffi/linux_risc64hf64/koffi.node'); } break;
+        case 'linux_riscv64hf64': { native = require('../build/koffi/linux_riscv64hf64/koffi.node'); } break;
         case 'linux_x64': { native = require('../build/koffi/linux_x64/koffi.node'); } break;
         case 'openbsd_ia32': { native = require('../build/koffi/openbsd_ia32/koffi.node'); } break;
         case 'openbsd_x64': { native = require('../build/koffi/openbsd_x64/koffi.node'); } break;

package/src/koffi/CMakeLists.txt

@@ -28,7 +28,7 @@ include(CheckCXXCompilerFlag)
 
 find_package(CNoke)
 
-set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD 20)
 if(MSVC)
     set(CMAKE_MSVC_RUNTIME_LIBRARY MultiThreaded)
 

package/src/koffi/src/call.cc

@@ -1043,12 +1043,6 @@ bool CallData::PushPointer(Napi::Value value, const TypeInfo *type, int directio
                 out_kind = OutArgument::Kind::Buffer;
             } else if (type->ref.type->primitive == PrimitiveKind::Record ||
                        type->ref.type->primitive == PrimitiveKind::Union) [[likely]] {
-                if (!type->ref.type->size) [[unlikely]] {
-                    ThrowError<Napi::TypeError>(env, "Cannot pass %1 value to %2, use koffi.as()",
-                                                type->ref.type != instance->void_type ? "opaque" : "ambiguous", type->name);
-                    return false;
-                }
-
                 Napi::Object obj = value.As<Napi::Object>();
                 RG_ASSERT(IsObject(value));
 
@@ -1108,6 +1102,22 @@ bool CallData::PushPointer(Napi::Value value, const TypeInfo *type, int directio
             }
         } break;
 
+        case napi_function: {
+            if (type->primitive != PrimitiveKind::Callback) [[unlikely]] {
+                ThrowError<Napi::TypeError>(env, "Cannot pass function to type %1", type->name);
+                return false;
+            }
+
+            Napi::Function func = value.As<Napi::Function>();
+
+            void *ptr = ReserveTrampoline(type->ref.proto, func);
+            if (!ptr) [[unlikely]]
+                return false;
+
+            *out_ptr = (void *)ptr;
+            return true;
+        } break;
+
         case napi_number: {
             Napi::Number number = value.As<Napi::Number>();
             intptr_t ptr = (intptr_t)number.Int32Value();

package/src/koffi/src/call.hh

@@ -81,7 +81,7 @@ class alignas(8) CallData {
     uint8_t *return_ptr = nullptr;
 
     LocalArray<int16_t, 16> used_trampolines;
-    LocalArray<OutArgument, MaxParameters> out_arguments;
+    HeapArray<OutArgument> out_arguments;
 
     BlockAllocator call_alloc;
 

package/src/koffi/src/ffi.cc

@@ -233,7 +233,7 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
     Napi::Array keys = obj.GetPropertyNames();
 
     type->name = named ? DuplicateString(name.Utf8Value().c_str(), &instance->str_alloc).ptr
-                       : Fmt(&instance->str_alloc, "<type_%1>", instance->types.len).ptr;
+                       : Fmt(&instance->str_alloc, "<anonymous_%1>", instance->types.len).ptr;
 
     type->primitive = PrimitiveKind::Record;
     type->align = 1;
@@ -362,7 +362,7 @@ static Napi::Value CreateUnionType(const Napi::CallbackInfo &info)
     Napi::Array keys = obj.GetPropertyNames();
 
     type->name = named ? DuplicateString(name.Utf8Value().c_str(), &instance->str_alloc).ptr
-                       : Fmt(&instance->str_alloc, "<type_%1>", instance->types.len).ptr;
+                       : Fmt(&instance->str_alloc, "<anonymous_%1>", instance->types.len).ptr;
 
     type->primitive = PrimitiveKind::Union;
     type->align = 1;
@@ -493,7 +493,7 @@ static Napi::Value CreateOpaqueType(const Napi::CallbackInfo &info)
     RG_DEFER_N(err_guard) { instance->types.RemoveLast(1); };
 
     type->name = named ? DuplicateString(name.Utf8Value().c_str(), &instance->str_alloc).ptr
-                       : Fmt(&instance->str_alloc, "<type_%1>", instance->types.len).ptr;
+                       : Fmt(&instance->str_alloc, "<anonymous_%1>", instance->types.len).ptr;
 
     type->primitive = PrimitiveKind::Void;
     type->size = 0;
@@ -699,7 +699,7 @@ static Napi::Value CreateDisposableType(const Napi::CallbackInfo &info)
     type->members.allocator = GetNullAllocator();
 
     type->name = named ? DuplicateString(name.Utf8Value().c_str(), &instance->str_alloc).ptr
-                       : Fmt(&instance->str_alloc, "<type_%1>", instance->types.len).ptr;
+                       : Fmt(&instance->str_alloc, "<anonymous_%1>", instance->types.len).ptr;
 
     type->dispose = dispose;
     type->dispose_ref = Napi::Persistent(dispose_func);
@@ -1775,8 +1775,9 @@ static Napi::Value CastValue(const Napi::CallbackInfo &info)
     if (!type) [[unlikely]]
         return env.Null();
     if (type->primitive != PrimitiveKind::Pointer &&
+            type->primitive != PrimitiveKind::Callback &&
             type->primitive != PrimitiveKind::String &&
-            type->primitive != PrimitiveKind::String16) {
+            type->primitive != PrimitiveKind::String16) [[unlikely]] {
         ThrowError<Napi::TypeError>(env, "Only pointer or string types can be used for casting");
         return env.Null();
     }

package/src/koffi/src/ffi.hh

@@ -36,7 +36,7 @@ static const int DefaultMaxAsyncCalls = 64;
 static const Size DefaultMaxTypeSize = Mebibytes(64);
 
 static const int MaxAsyncCalls = 256;
-static const Size MaxParameters = 32;
+static const Size MaxParameters = 64;
 static const Size MaxTrampolines = 8192;
 
 enum class PrimitiveKind {

package/src/koffi/src/util.cc

@@ -243,7 +243,7 @@ const TypeInfo *ResolveType(Napi::Env env, Span<const char> str, int *out_direct
             TypeInfo *copy = instance->types.AppendDefault();
 
             memcpy((void *)copy, (const void *)type, RG_SIZE(*type));
-            copy->name = Fmt(&instance->str_alloc, "<type_%1>", instance->types.len).ptr;
+            copy->name = Fmt(&instance->str_alloc, "<anonymous_%1>", instance->types.len).ptr;
             copy->members.allocator = GetNullAllocator();
 
             copy->dispose = [](Napi::Env env, const TypeInfo *, const void *ptr) {

package/doc/parameters.md

@@ -1,336 +0,0 @@
-# Special parameters
-
-## Direction
-
-By default, Koffi will only forward arguments from Javascript to C. However, many C functions use pointer arguments for output values, or input/output values.
-
-## Output parameters
-
-For simplicity, and because Javascript only has value semantics for primitive types, Koffi can marshal out (or in/out) two types of parameters:
-
-- [Structs](types.md#struct-types) (to/from JS objects)
-- [Unions](unions.md)
-- [Opaque types](types.md#opaque-types)
-- String buffers
-
-In order to change an argument from input-only to output or input/output, use the following functions:
-
-- `koffi.out()` on a pointer, e.g. `koffi.out(koffi.pointer(timeval))` (where timeval is a struct type)
-- `koffi.inout()` for dual input/output parameters
-
-The same can be done when declaring a function with a C-like prototype string, with the MSDN-like type qualifiers:
-
-- `_Out_` for output parameters
-- `_Inout_` for dual input/output parameters
-
-### Primitive value
-
-This Windows example enumerate all Chrome windows along with their PID and their title. The `GetWindowThreadProcessId()` function illustrates how to get a primitive value from an output argument.
-
-```js
-// ES6 syntax: import koffi from 'koffi';
-const koffi = require('koffi');
-
-const user32 = koffi.load('user32.dll');
-
-const DWORD = koffi.alias('DWORD', 'uint32_t');
-const HANDLE = koffi.pointer(koffi.opaque('HANDLE'));
-const HWND = koffi.alias('HWND', HANDLE);
-
-const FindWindowEx = user32.func('HWND __stdcall FindWindowExW(HWND hWndParent, HWND hWndChildAfter, const char16_t *lpszClass, const char16_t *lpszWindow)');
-const GetWindowThreadProcessId = user32.func('DWORD __stdcall GetWindowThreadProcessId(HWND hWnd, _Out_ DWORD *lpdwProcessId)');
-const GetWindowText = user32.func('int __stdcall GetWindowTextA(HWND hWnd, _Out_ uint8_t *lpString, int nMaxCount)');
-
-for (let hwnd = null;;) {
-    hwnd = FindWindowEx(0, hwnd, 'Chrome_WidgetWin_1', null);
-
-    if (!hwnd)
-        break;
-
-    // Get PID
-    let pid;
-    {
-        let ptr = [null];
-        let tid = GetWindowThreadProcessId(hwnd, ptr);
-
-        if (!tid) {
-            // Maybe the process ended in-between?
-            continue;
-        }
-
-        pid = ptr[0];
-    }
-
-    // Get window title
-    let title;
-    {
-        let buf = Buffer.allocUnsafe(1024);
-        let length = GetWindowText(hwnd, buf, buf.length);
-
-        if (!length) {
-            // Maybe the process ended in-between?
-            continue;
-        }
-
-        title = koffi.decode(buf, 'char', length);
-    }
-
-    console.log({ PID: pid, Title: title });
-}
-```
-
-### Struct example
-
-This example calls the POSIX function `gettimeofday()`, and uses the prototype-like syntax.
-
-```js
-// ES6 syntax: import koffi from 'koffi';
-const koffi = require('koffi');
-
-const lib = koffi.load('libc.so.6');
-
-const timeval = koffi.struct('timeval', {
-    tv_sec: 'unsigned int',
-    tv_usec: 'unsigned int'
-});
-const timezone = koffi.struct('timezone', {
-    tz_minuteswest: 'int',
-    tz_dsttime: 'int'
-});
-
-// The _Out_ qualifiers instruct Koffi to marshal out the values
-const gettimeofday = lib.func('int gettimeofday(_Out_ timeval *tv, _Out_ timezone *tz)');
-
-let tv = {};
-gettimeofday(tv, null);
-
-console.log(tv);
-```
-
-### Opaque type example
-
-This example opens an in-memory SQLite database, and uses the node-ffi-style function declaration syntax.
-
-```js
-// ES6 syntax: import koffi from 'koffi';
-const koffi = require('koffi');
-
-const lib = koffi.load('sqlite3.so');
-
-const sqlite3 = koffi.opaque('sqlite3');
-
-// Use koffi.out() on a double pointer to copy out (from C to JS) after the call
-const sqlite3_open_v2 = lib.func('sqlite3_open_v2', 'int', ['str', koffi.out(koffi.pointer(sqlite3, 2)), 'int', 'str']);
-const sqlite3_close_v2 = lib.func('sqlite3_close_v2', 'int', [koffi.pointer(sqlite3)]);
-
-const SQLITE_OPEN_READWRITE = 0x2;
-const SQLITE_OPEN_CREATE = 0x4;
-
-let out = [null];
-if (sqlite3_open_v2(':memory:', out, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, null) != 0)
-    throw new Error('Failed to open database');
-let db = out[0];
-
-sqlite3_close_v2(db);
-```
-
-### String buffer example
-
-*New in Koffi 2.2*
-
-This example calls a C function to concatenate two strings to a pre-allocated string buffer. Since JS strings are immutable, you must pass an array with a single string instead.
-
-```c
-void ConcatToBuffer(const char *str1, const char *str2, char *out)
-{
-    size_t len = 0;
-
-    for (size_t i = 0; str1[i]; i++) {
-        out[len++] = str1[i];
-    }
-    for (size_t i = 0; str2[i]; i++) {
-        out[len++] = str2[i];
-    }
-
-    out[len] = 0;
-}
-```
-
-```js
-const ConcatToBuffer = lib.func('void ConcatToBuffer(const char *str1, const char *str2, _Out_ char *out)');
-
-let str1 = 'Hello ';
-let str2 = 'Friends!';
-
-// We need to reserve space for the output buffer! Including the NUL terminator
-// because ConcatToBuffer() expects so, but Koffi can convert back to a JS string
-// without it (if we reserve the right size).
-let out = ['\0'.repeat(str1.length + str2.length + 1)];
-
-ConcatToBuffer(str1, str2, out);
-
-console.log(out[0]);
-```
-
-## Polymorphic parameters
-
-### Input polymorphism
-
-*New in Koffi 2.1*
-
-Many C functions use `void *` parameters in order to pass polymorphic objects and arrays, meaning that the data format changes can change depending on one other argument, or on some kind of struct tag member.
-
-Koffi provides two features to deal with this:
-
-- Buffers and typed JS arrays can be used as values in place everywhere a pointer is expected. See [dynamic arrays](pointers.md#array-pointers-dynamic-arrays) for more information, for input or output.
-- You can use `koffi.as(value, type)` to tell Koffi what kind of type is actually expected.
-
-The example below shows the use of `koffi.as()` to read the header of a PNG file with `fread()`.
-
-```js
-// ES6 syntax: import koffi from 'koffi';
-const koffi = require('koffi');
-
-const lib = koffi.load('libc.so.6');
-
-const FILE = koffi.opaque('FILE');
-
-const PngHeader = koffi.pack('PngHeader', {
-    signature: koffi.array('uint8_t', 8),
-    ihdr: koffi.pack({
-        length: 'uint32_be_t',
-        chunk: koffi.array('char', 4),
-        width: 'uint32_be_t',
-        height: 'uint32_be_t',
-        depth: 'uint8_t',
-        color: 'uint8_t',
-        compression: 'uint8_t',
-        filter: 'uint8_t',
-        interlace: 'uint8_t',
-        crc: 'uint32_be_t'
-    })
-});
-
-const fopen = lib.func('FILE *fopen(const char *path, const char *mode)');
-const fclose = lib.func('int fclose(FILE *fp)');
-const fread = lib.func('size_t fread(_Out_ void *ptr, size_t size, size_t nmemb, FILE *fp)');
-
-let filename = process.argv[2];
-if (filename == null)
-    throw new Error('Usage: node png.js <image.png>');
-
-let hdr = {};
-{
-    let fp = fopen(filename, 'rb');
-    if (!fp)
-        throw new Error(`Failed to open '${filename}'`);
-
-    try {
-        let len = fread(koffi.as(hdr, 'PngHeader *'), 1, koffi.sizeof(PngHeader), fp);
-        if (len < koffi.sizeof(PngHeader))
-            throw new Error('Failed to read PNG header');
-    } finally {
-        fclose(fp);
-    }
-}
-
-console.log('PNG header:', hdr);
-```
-
-### Output buffers
-
-*New in Koffi 2.3*
-
-You can use buffers and typed arrays for output (and input/output) pointer parameters. Simply pass the buffer as an argument and the native function will receive a pointer to its contents.
-
-Once the native function returns, you can decode the content with `koffi.decode(value, type)` as in the following example:
-
-```js
-// ES6 syntax: import koffi from 'koffi';
-const koffi = require('koffi');
-
-const lib = koffi.load('libc.so.6');
-
-const Vec3 = koffi.struct('Vec3', {
-    x: 'float32',
-    y: 'float32',
-    z: 'float32'
-})
-
-const memcpy = lib.func('void *memcpy(_Out_ void *dest, const void *src, size_t size)');
-
-let vec1 = { x: 1, y: 2, z: 3 };
-let vec2 = null;
-
-// Copy the vector in a convoluted way through memcpy
-{
-    let src = koffi.as(vec1, 'Vec3 *');
-    let dest = Buffer.allocUnsafe(koffi.sizeof(Vec3));
-
-    memcpy(dest, src, koffi.sizeof(Vec3));
-
-    vec2 = koffi.decode(dest, Vec3);
-}
-
-// CHange vector1, leaving copy alone
-[vec1.x, vec1.y, vec1.z] = [vec1.z, vec1.y, vec1.x];
-
-console.log(vec1); // { x: 3, y: 2, z: 1 }
-console.log(vec2); // { x: 1, y: 2, z: 3 }
-```
-
-See [pointer arguments](callbacks.md#decoding-pointer-arguments) for more information about the decode function.
-
-## Heap-allocated values
-
-*New in Koffi 2.0*
-
-Some C functions return heap-allocated values directly or through output parameters. While Koffi automatically converts values from C to JS (to a string or an object), it does not know when something needs to be freed, or how.
-
-For opaque types, such as FILE, this does not matter because you will explicitly call `fclose()` on them. But some values (such as strings) get implicitly converted by Koffi, and you lose access to the original pointer. This creates a leak if the string is heap-allocated.
-
-To avoid this, you can instruct Koffi to call a function on the original pointer once the conversion is done, by creating a **disposable type** with `koffi.dispose(name, type, func)`. This creates a type derived from another type, the only difference being that *func* gets called with the original pointer once the value has been converted and is not needed anymore.
-
-The *name* can be omitted to create an anonymous disposable type. If *func* is omitted or is null, Koffi will use `koffi.free(ptr)` (which calls the standard C library *free* function under the hood).
-
-```js
-const AnonHeapStr = koffi.disposable('str'); // Anonymous type (cannot be used in function prototypes)
-const NamedHeapStr = koffi.disposable('HeapStr', 'str'); // Same thing, but named so usable in function prototypes
-const ExplicitFree = koffi.disposable('HeapStr16', 'str16', koffi.free); // You can specify any other JS function
-```
-
-The following example illustrates the use of a disposable type derived from *str*.
-
-```js
-// ES6 syntax: import koffi from 'koffi';
-const koffi = require('koffi');
-
-const lib = koffi.load('libc.so.6');
-
-const HeapStr = koffi.disposable('str');
-const strdup = lib.cdecl('strdup', HeapStr, ['str']);
-
-let copy = strdup('Hello!');
-console.log(copy); // Prints Hello!
-```
-
-When you declare functions with the [prototype-like syntax](functions.md#definition-syntax), you can either use named disposable types or use the '!' shortcut qualifier with compatibles types, as shown in the example below. This qualifier creates an anonymous disposable type that calls `koffi.free(ptr)`.
-
-```js
-// ES6 syntax: import koffi from 'koffi';
-const koffi = require('koffi');
-
-const lib = koffi.load('libc.so.6');
-
-// You can also use: const strdup = lib.func('const char *! strdup(const char *str)')
-const strdup = lib.func('str! strdup(const char *str)');
-
-let copy = strdup('World!');
-console.log(copy); // Prints World!
-```
-
-Disposable types can only be created from pointer or string types.
-
-```{warning}
-Be careful on Windows: if your shared library uses a different CRT (such as msvcrt), the memory could have been allocated by a different malloc/free implementation or heap, resulting in undefined behavior if you use `koffi.free()`.
-```