koffi 3.0.0-alpha.3 → 3.0.0-alpha.4

package/index.cjs

@@ -0,0 +1 @@
+module.exports = require("./src/koffi/index.cjs");

package/index.js

@@ -1 +1 @@
-module.exports = require("./src/koffi/index.js");
+export koffi from "./src/koffi/index.js";

package/indirect.cjs

@@ -0,0 +1 @@
+module.exports = require("./src/koffi/indirect.cjs");

package/indirect.js

@@ -1 +1 @@
-module.exports = require("./src/koffi/indirect.js");
+export koffi from "./src/koffi/indirect.js";

package/lib/native/base/base.cc

@@ -2,7 +2,9 @@
 // SPDX-FileCopyrightText: 2025 Niels Martignène <niels.martignene@protonmail.com>
 
 #include "base.hh"
-#include "crc.inc"
+#if __has_include("crc.inc")
+    #include "crc.inc"
+#endif
 #include "unicode.inc"
 
 #if __has_include("vendor/dragonbox/include/dragonbox/dragonbox.h")
@@ -10696,6 +10698,8 @@ const char *PromptPath(const char *prompt, const char *default_path, Span<const
 // Mime types
 // ------------------------------------------------------------------------
 
+#if __has_include("mimetypes.inc")
+
 const char *GetMimeType(Span<const char> extension, const char *default_type)
 {
     static const HashMap<Span<const char>, const char *> mimetypes = {
@@ -10771,6 +10775,8 @@ bool CanCompressFile(const char *filename)
     return true;
 }
 
+#endif
+
 // ------------------------------------------------------------------------
 // Unicode
 // ------------------------------------------------------------------------
@@ -10792,6 +10798,8 @@ bool IsValidUtf8(Span<const char> str)
     return i == str.len;
 }
 
+#if __has_include("unicode.inc")
+
 static bool TestUnicodeTable(Span<const int32_t> table, int32_t uc)
 {
     K_ASSERT(table.len > 0);
@@ -10862,10 +10870,14 @@ bool IsXidContinue(int32_t uc)
     return false;
 }
 
+#endif
+
 // ------------------------------------------------------------------------
 // CRC
 // ------------------------------------------------------------------------
 
+#if __has_include("crc.inc")
+
 uint32_t CRC32(uint32_t state, Span<const uint8_t> buf)
 {
     state = ~state;
@@ -10990,4 +11002,6 @@ uint64_t CRC64nvme(uint64_t state, Span<const uint8_t> buf)
     return ~state;
 }
 
+#endif
+
 }

package/lib/native/base/base.hh

@@ -107,17 +107,14 @@ extern StreamReader *const StdIn;
 extern StreamWriter *const StdOut;
 extern StreamWriter *const StdErr;
 
-#if defined(__x86_64__) || defined(_M_X64) || defined(__aarch64__) || defined(_M_ARM64) || __riscv_xlen == 64 || defined(__loongarch64)
+#if INTPTR_MAX == INT64_MAX
     typedef int64_t Size;
     #define K_SIZE_MAX INT64_MAX
-#elif defined(_WIN32) || defined(__APPLE__) || defined(__unix__)
-    typedef int32_t Size;
-    #define K_SIZE_MAX INT32_MAX
-#elif defined(__thumb__) || defined(__arm__) || defined(__wasm32__)
+#elif INTPTR_MAX == INT32_MAX
     typedef int32_t Size;
     #define K_SIZE_MAX INT32_MAX
 #else
-    #error Machine architecture not supported
+    #error This code base is not designed to support non-32-or-64-bit platforms
 #endif
 
 #if defined(_MSC_VER) || __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
@@ -135,6 +132,7 @@ extern StreamWriter *const StdErr;
     #error This code base is not designed to support non-64-bits long long types
 #endif
 static_assert(sizeof(double) == 8, "This code base is not designed to support single-precision double floats");
+static_assert(sizeof(intptr_t) == sizeof(size_t), "This code base assumes that intptr_t and size_t are the same size");
 
 #define K_STRINGIFY_(a) #a
 #define K_STRINGIFY(a) K_STRINGIFY_(a)
@@ -5893,10 +5891,14 @@ static inline const char *PromptPath(const char *prompt, Allocator *alloc)
 // Mime types
 // ------------------------------------------------------------------------
 
+#if __has_include("mimetypes.inc")
+
 const char *GetMimeType(Span<const char> extension, const char *default_type = "application/octet-stream");
 
 bool CanCompressFile(const char *filename);
 
+#endif
+
 // ------------------------------------------------------------------------
 // Unicode
 // ------------------------------------------------------------------------
@@ -6012,19 +6014,27 @@ static inline Size EncodeUtf8(int32_t c, char out_buf[4])
 
 bool IsValidUtf8(Span<const char> str);
 
+#if __has_include("unicode.inc")
+
 int ComputeUnicodeWidth(Span<const char> str);
 
 bool IsXidStart(int32_t uc);
 bool IsXidContinue(int32_t uc);
 
+#endif
+
 // ------------------------------------------------------------------------
 // CRC
 // ------------------------------------------------------------------------
 
+#if __has_include("crc.inc")
+
 uint32_t CRC32(uint32_t state, Span<const uint8_t> buf);
 uint32_t CRC32C(uint32_t state, Span<const uint8_t> buf);
 
 uint64_t CRC64xz(uint64_t state, Span<const uint8_t> buf);
 uint64_t CRC64nvme(uint64_t state, Span<const uint8_t> buf);
 
+#endif
+
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "koffi",
-    "version": "3.0.0-alpha.3",
+    "version": "3.0.0-alpha.4",
     "description": "Fast and simple C FFI (foreign function interface) for Node.js",
     "keywords": [
         "foreign",
@@ -21,8 +21,7 @@
         "email": "niels.martignene@protonmail.com",
         "url": "https://koromix.dev/"
     },
-    "main": "./index.js",
-    "types": "./index.d.ts",
+    "module": "./index.js",
     "scripts": {
         "install": "node src/build.js -P . -D src/koffi --prebuild --release"
     },
@@ -33,5 +32,7 @@
         "node": 16,
         "napi": 8
     },
-    "funding": "https://liberapay.com/Koromix"
+    "funding": "https://liberapay.com/Koromix",
+    "main": "./index.cjs",
+    "types": "./index.d.ts"
 }

package/src/koffi/index.cjs

@@ -0,0 +1,453 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/static.js
+var require_static = __commonJS({
+  "src/static.js"(exports2, module2) {
+    var { createRequire: createRequire2 } = require("node:module");
+    var requireNative2 = createRequire2(__dirname);
+    function loadStatic2(pkg2) {
+      let native2 = null;
+      if (native2 == null && pkg2 == "linux-arm64") {
+        try {
+          native2 = requireNative2("../../build/koffi/linux_arm64/koffi.node");
+        } catch (err) {
+        }
+      }
+      if (native2 == null && pkg2 == "linux-arm64") {
+        try {
+          native2 = requireNative2("../../build/koffi/musl_arm64/koffi.node");
+        } catch (err) {
+        }
+      }
+      if (native2 == null && pkg2 == "linux-ia32") {
+        try {
+          native2 = requireNative2("../../build/koffi/linux_ia32/koffi.node");
+        } catch (err) {
+        }
+      }
+      if (native2 == null && pkg2 == "linux-x64") {
+        try {
+          native2 = requireNative2("../../build/koffi/linux_x64/koffi.node");
+        } catch (err) {
+        }
+      }
+      if (native2 == null && pkg2 == "linux-x64") {
+        try {
+          native2 = requireNative2("../../build/koffi/musl_x64/koffi.node");
+        } catch (err) {
+        }
+      }
+      if (native2 == null && pkg2 == "freebsd-ia32") {
+        try {
+          native2 = requireNative2("../../build/koffi/freebsd_ia32/koffi.node");
+        } catch (err) {
+        }
+      }
+      if (native2 == null && pkg2 == "freebsd-x64") {
+        try {
+          native2 = requireNative2("../../build/koffi/freebsd_x64/koffi.node");
+        } catch (err) {
+        }
+      }
+      if (native2 == null && pkg2 == "freebsd-arm64") {
+        try {
+          native2 = requireNative2("../../build/koffi/freebsd_arm64/koffi.node");
+        } catch (err) {
+        }
+      }
+      if (native2 == null && pkg2 == "openbsd-ia32") {
+        try {
+          native2 = requireNative2("../../build/koffi/openbsd_ia32/koffi.node");
+        } catch (err) {
+        }
+      }
+      if (native2 == null && pkg2 == "openbsd-x64") {
+        try {
+          native2 = requireNative2("../../build/koffi/openbsd_x64/koffi.node");
+        } catch (err) {
+        }
+      }
+      if (native2 == null && pkg2 == "win32-ia32") {
+        try {
+          native2 = requireNative2("../../build/koffi/win32_ia32/koffi.node");
+        } catch (err) {
+        }
+      }
+      if (native2 == null && pkg2 == "win32-x64") {
+        try {
+          native2 = requireNative2("../../build/koffi/win32_x64/koffi.node");
+        } catch (err) {
+        }
+      }
+      if (native2 == null && pkg2 == "darwin-x64") {
+        try {
+          native2 = requireNative2("../../build/koffi/darwin_x64/koffi.node");
+        } catch (err) {
+        }
+      }
+      if (native2 == null && pkg2 == "darwin-arm64") {
+        try {
+          native2 = requireNative2("../../build/koffi/darwin_arm64/koffi.node");
+        } catch (err) {
+        }
+      }
+      return native2;
+    }
+    module2.exports = { loadStatic: loadStatic2 };
+  }
+});
+
+// index.js
+var index_exports = {};
+__export(index_exports, {
+  Union: () => _Union,
+  address: () => _address,
+  alias: () => _alias,
+  alignof: () => _alignof,
+  alloc: () => _alloc,
+  array: () => _array,
+  as: () => _as,
+  call: () => _call,
+  config: () => _config,
+  decode: () => _decode,
+  disposable: () => _disposable,
+  encode: () => _encode,
+  errno: () => _errno,
+  extension: () => _extension,
+  free: () => _free,
+  in: () => _in,
+  inout: () => _inout,
+  introspect: () => _introspect,
+  load: () => _load,
+  node: () => _node,
+  offsetof: () => _offsetof,
+  opaque: () => _opaque,
+  os: () => _os,
+  out: () => _out,
+  pack: () => _pack,
+  pointer: () => _pointer,
+  proto: () => _proto,
+  register: () => _register,
+  reset: () => _reset,
+  resolve: () => _resolve,
+  sizeof: () => _sizeof,
+  stats: () => _stats,
+  struct: () => _struct,
+  types: () => _types,
+  union: () => _union,
+  unregister: () => _unregister,
+  version: () => _version,
+  view: () => _view
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/init.js
+var import_util = __toESM(require("util"));
+var import_fs2 = __toESM(require("fs"));
+var import_node_module = require("node:module");
+
+// ../cnoke/src/abi.js
+var import_fs = __toESM(require("fs"), 1);
+function determineAbi() {
+  let abi = process.arch;
+  if (abi == "riscv32" || abi == "riscv64") {
+    let buf = readFileHeader(process.execPath, 512);
+    let header = decodeElfHeader(buf);
+    let float_abi = header.e_flags & 6;
+    switch (float_abi) {
+      case 0:
+        {
+        }
+        break;
+      case 2:
+        {
+          abi += "f";
+        }
+        break;
+      case 4:
+        {
+          abi += "d";
+        }
+        break;
+      case 6:
+        {
+          abi += "q";
+        }
+        break;
+    }
+  } else if (abi == "arm") {
+    let buf = readFileHeader(process.execPath, 512);
+    let header = decodeElfHeader(buf);
+    if (header.e_flags & 1024) {
+      abi += "hf";
+    } else if (header.e_flags & 512) {
+      abi += "sf";
+    } else {
+      throw new Error("Unknown ARM floating-point ABI");
+    }
+  }
+  return abi;
+}
+function readFileHeader(filename, read) {
+  let fd = null;
+  try {
+    let fd2 = import_fs.default.openSync(filename);
+    let buf = Buffer.allocUnsafe(read);
+    let len = import_fs.default.readSync(fd2, buf);
+    return buf.subarray(0, len);
+  } finally {
+    if (fd != null)
+      import_fs.default.closeSync(fd);
+  }
+}
+function decodeElfHeader(buf) {
+  let header = {};
+  if (buf.length < 16)
+    throw new Error("Truncated header");
+  if (buf[0] != 127 || buf[1] != 69 || buf[2] != 76 || buf[3] != 70)
+    throw new Error("Invalid magic number");
+  if (buf[6] != 1)
+    throw new Error("Invalid ELF version");
+  if (buf[5] != 1)
+    throw new Error("Big-endian architectures are not supported");
+  header.e_machine = buf.readUInt16LE(18);
+  switch (buf[4]) {
+    case 1:
+      {
+        buf = buf.subarray(0, 68);
+        if (buf.length < 68)
+          throw new Error("Truncated ELF header");
+        header.ei_class = 32;
+        header.e_flags = buf.readUInt32LE(36);
+      }
+      break;
+    case 2:
+      {
+        buf = buf.subarray(0, 120);
+        if (buf.length < 120)
+          throw new Error("Truncated ELF header");
+        header.ei_class = 64;
+        header.e_flags = buf.readUInt32LE(48);
+      }
+      break;
+    default:
+      throw new Error("Invalid ELF class");
+  }
+  return header;
+}
+
+// package.json
+var package_default = {
+  name: "koffi",
+  version: "3.0.0-alpha.4",
+  description: "Fast and simple C FFI (foreign function interface) for Node.js",
+  keywords: [
+    "foreign",
+    "function",
+    "interface",
+    "ffi",
+    "binding",
+    "c",
+    "napi"
+  ],
+  repository: {
+    type: "git",
+    url: "https://github.com/Koromix/koffi"
+  },
+  homepage: "https://koffi.dev/",
+  author: {
+    name: "Niels Martign\xE8ne",
+    email: "niels.martignene@protonmail.com",
+    url: "https://koromix.dev/"
+  },
+  main: "./index.cjs",
+  module: "./index.js",
+  types: "./index.d.ts",
+  scripts: {
+    test: "node tools/brew.js test",
+    prepack: `echo 'Use "npm run package" instead' && false`,
+    prepublishOnly: `echo 'Use "npm run package" instead' && false`,
+    package: "node tools/brew.js build"
+  },
+  license: "MIT",
+  cnoke: {
+    api: "../../vendor/node-api-headers",
+    output: "../../bin/Koffi/{{ toolchain }}",
+    node: 16,
+    napi: 8
+  },
+  funding: "https://liberapay.com/Koromix"
+};
+
+// src/init.js
+var requireNative = (0, import_node_module.createRequire)(__dirname);
+function detectPlatform() {
+  if (process.versions.napi == null || process.versions.napi < package_default.cnoke.napi) {
+    let major = parseInt(process.versions.node, 10);
+    throw new Error(`This engine is based on Node ${process.versions.node}, but ${package_default.name} does not support the Node ${major}.x branch (N-API < ${package_default.cnoke.napi})`);
+  }
+  let abi = determineAbi();
+  let pkg2 = `${process.platform}-${process.arch}`;
+  let triplets2 = [`${process.platform}_${abi}`];
+  if (process.platform == "linux")
+    triplets2.push(`musl_${abi}`);
+  return [package_default.version, pkg2, triplets2];
+}
+function loadDynamic(root, pkg2, triplets2) {
+  let roots = [root];
+  let native2 = null;
+  let err = null;
+  if (process.resourcesPath != null)
+    roots.push(process.resourcesPath);
+  let filenames = roots.flatMap((dir) => triplets2.flatMap((triplet) => [
+    `${dir}/build/koffi/${triplet}/koffi.node`,
+    `${dir}/bin/Koffi/${triplet}/koffi.node`,
+    `${dir}/node_modules/koffi/build/koffi/${triplet}/koffi.node`,
+    `${dir}/../@koromix/koffi-${pkg2}/${triplet}/koffi.node`
+  ]));
+  for (let filename of filenames) {
+    if (!import_fs2.default.existsSync(filename))
+      continue;
+    try {
+      native2 = requireNative(filename);
+      break;
+    } catch (e) {
+      err ??= e;
+    }
+  }
+  if (native2 == null) {
+    err ??= new Error("Cannot find the native Koffi module; did you bundle it correctly?");
+    throw err;
+  }
+  return native2;
+}
+function wrapNative(native2) {
+  let load = native2.load;
+  native2.load = (...args) => {
+    let lib = load(...args);
+    lib.cdecl = import_util.default.deprecate((...args2) => lib.func("__cdecl", ...args2), "The koffi.cdecl() function was deprecated in Koffi 2.7, use koffi.func(...) instead", "KOFFI003");
+    lib.stdcall = import_util.default.deprecate((...args2) => lib.func("__stdcall", ...args2), 'The koffi.stdcall() function was deprecated in Koffi 2.7, use koffi.func("__stdcall", ...) instead', "KOFFI004");
+    lib.fastcall = import_util.default.deprecate((...args2) => lib.func("__fastcall", ...args2), 'The koffi.fastcall() function was deprecated in Koffi 2.7, use koffi.func("__fastcall", ...) instead', "KOFFI005");
+    lib.thiscall = import_util.default.deprecate((...args2) => lib.func("__thiscall", ...args2), 'The koffi.thiscall() function was deprecated in Koffi 2.7, use koffi.func("__thiscall", ...) instead', "KOFFI006");
+    return lib;
+  };
+}
+
+// index.js
+var import_static = __toESM(require_static());
+var [version, pkg, triplets] = detectPlatform();
+var native = null;
+STATIC: native = (0, import_static.loadStatic)(pkg);
+if (native == null)
+  native = loadDynamic(__dirname + "/../..", pkg, triplets);
+if (native.version != version)
+  throw new Error("Mismatched native Koffi modules");
+wrapNative(native);
+var _config = native.config;
+var _stats = native.stats;
+var _struct = native.struct;
+var _pack = native.pack;
+var _union = native.union;
+var _Union = native.Union;
+var _opaque = native.opaque;
+var _pointer = native.pointer;
+var _array = native.array;
+var _proto = native.proto;
+var _alias = native.alias;
+var _sizeof = native.sizeof;
+var _alignof = native.alignof;
+var _offsetof = native.offsetof;
+var _resolve = native.resolve;
+var _introspect = native.introspect;
+var _load = native.load;
+var _in = native.in;
+var _out = native.out;
+var _inout = native.inout;
+var _disposable = native.disposable;
+var _alloc = native.alloc;
+var _free = native.free;
+var _register = native.register;
+var _unregister = native.unregister;
+var _as = native.as;
+var _decode = native.decode;
+var _address = native.address;
+var _call = native.call;
+var _encode = native.encode;
+var _view = native.view;
+var _reset = native.reset;
+var _errno = native.errno;
+var _os = native.os;
+var _extension = native.extension;
+var _types = native.types;
+var _node = native.node;
+var _version = native.version;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Union,
+  address,
+  alias,
+  alignof,
+  alloc,
+  array,
+  as,
+  call,
+  config,
+  decode,
+  disposable,
+  encode,
+  errno,
+  extension,
+  free,
+  in: null,
+  inout,
+  introspect,
+  load,
+  node,
+  offsetof,
+  opaque,
+  os,
+  out,
+  pack,
+  pointer,
+  proto,
+  register,
+  reset,
+  resolve,
+  sizeof,
+  stats,
+  struct,
+  types,
+  union,
+  unregister,
+  version,
+  view
+});