koffi 2.16.1 → 3.0.0-alpha.2

package/src/koffi/CMakeLists.txt

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: MIT
 # SPDX-FileCopyrightText: 2025 Niels Martignène <niels.martignene@protonmail.com>
 
-cmake_minimum_required(VERSION 3.10)
+cmake_minimum_required(VERSION 3.11)
 cmake_policy(SET CMP0091 NEW)
 
 if(NOT NODE_JS_INCLUDE_DIRS)
@@ -23,7 +23,7 @@ if(MSVC)
         enable_language(ASM_MASM)
     endif()
 else()
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Wno-missing-field-initializers -Wno-unused-parameter -Wno-class-memaccess -Wswitch -Werror=switch")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Wno-missing-field-initializers -Wno-unused-parameter -Wno-class-memaccess -Wno-c99-designator -Wswitch -Werror=switch")
 
     if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unknown-warning-option")
@@ -60,8 +60,8 @@ add_custom_command(OUTPUT trampolines/gnu.inc
                           trampolines/masm64.inc
                    COMMENT "Generate trampoline macros"
                    COMMAND "${NODE_JS_EXECPATH}"
-                   ARGS "${CMAKE_CURRENT_SOURCE_DIR}/tools/write_trampolines.js" "${CMAKE_CURRENT_BINARY_DIR}/trampolines" 8192
-                   DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/tools/write_trampolines.js")
+                   ARGS "${CMAKE_CURRENT_SOURCE_DIR}/src/trampolines.js" "${CMAKE_CURRENT_BINARY_DIR}/trampolines" 8192
+                   DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/src/trampolines.js")
 
 set(KOFFI_SRC
     src/call.cc
@@ -75,8 +75,8 @@ set(KOFFI_SRC
 if(CMAKE_SIZEOF_VOID_P EQUAL 8)
     # CMAKE_SYSTEM_PROCESSOR is wrong on Windows ARM64
 
-    if(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch|arm" OR CMAKE_GENERATOR_PLATFORM STREQUAL "ARM64" OR CMAKE_OSX_ARCHITECTURES MATCHES "arm")
-        if(WIN32)
+    if(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch|arm|ARM|AARCH" OR CMAKE_GENERATOR_PLATFORM STREQUAL "ARM64" OR CMAKE_OSX_ARCHITECTURES MATCHES "arm")
+        if(MSVC)
             get_filename_component(cl_dir "${CMAKE_CXX_COMPILER}" DIRECTORY)
             file(TO_CMAKE_PATH "${cl_dir}/armasm64.exe" asm_compiler)
 
@@ -87,8 +87,8 @@ if(CMAKE_SIZEOF_VOID_P EQUAL 8)
 
             message(STATUS "Using ARMASM64 compiler: ${asm_compiler}")
 
-            file(TO_CMAKE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/src/abi_arm64_asm.asm" asm_source)
-            file(TO_CMAKE_PATH "${CMAKE_CURRENT_BINARY_DIR}/abi_arm64_asm.obj" asm_object)
+            file(TO_CMAKE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/src/abi/arm64_asm.asm" asm_source)
+            file(TO_CMAKE_PATH "${CMAKE_CURRENT_BINARY_DIR}/arm64_asm.obj" asm_object)
 
             add_custom_command(
                 OUTPUT "${asm_object}"
@@ -99,33 +99,33 @@ if(CMAKE_SIZEOF_VOID_P EQUAL 8)
             )
             set_source_files_properties("${asm_object}" PROPERTIES EXTERNAL_OBJECT TRUE)
 
-            list(APPEND KOFFI_SRC src/abi_arm64.cc "${asm_object}")
+            list(APPEND KOFFI_SRC src/abi/arm64.cc "${asm_object}")
         else()
-            list(APPEND KOFFI_SRC src/abi_arm64.cc src/abi_arm64_asm.S)
+            list(APPEND KOFFI_SRC src/abi/arm64.cc src/abi/arm64_asm.S)
         endif()
     elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "riscv")
-        list(APPEND KOFFI_SRC src/abi_riscv64.cc src/abi_riscv64_asm.S)
+        list(APPEND KOFFI_SRC src/abi/riscv64.cc src/abi/riscv64_asm.S)
     elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "loongarch64")
-        list(APPEND KOFFI_SRC src/abi_riscv64.cc src/abi_loong64_asm.S)
+        list(APPEND KOFFI_SRC src/abi/riscv64.cc src/abi/loong64_asm.S)
     else()
         if(WIN32)
             if(MSVC)
-                list(APPEND KOFFI_SRC src/abi_x64_win.cc src/abi_x64_win_asm.asm)
+                list(APPEND KOFFI_SRC src/abi/x64win.cc src/abi/x64win_asm.asm)
             else()
-                list(APPEND KOFFI_SRC src/abi_x64_win.cc src/abi_x64_win_asm.S)
+                list(APPEND KOFFI_SRC src/abi/x64win.cc src/abi/x64win_asm.S)
             endif()
         else()
-            list(APPEND KOFFI_SRC src/abi_x64_sysv.cc src/abi_x64_sysv_asm.S)
+            list(APPEND KOFFI_SRC src/abi/x64sysv.cc src/abi/x64sysv_asm.S)
         endif()
     endif()
 elseif(CMAKE_SIZEOF_VOID_P EQUAL 4)
     if(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch|arm")
-        list(APPEND KOFFI_SRC src/abi_arm32.cc src/abi_arm32_asm.S)
+        list(APPEND KOFFI_SRC src/abi/arm32.cc src/abi/arm32_asm.S)
     else()
-        if(WIN32)
-            list(APPEND KOFFI_SRC src/abi_x86.cc src/abi_x86_asm.asm)
+        if(MSVC)
+            list(APPEND KOFFI_SRC src/abi/x86.cc src/abi/x86_asm.asm)
         else()
-            list(APPEND KOFFI_SRC src/abi_x86.cc src/abi_x86_asm.S)
+            list(APPEND KOFFI_SRC src/abi/x86.cc src/abi/x86_asm.S)
         endif()
     endif()
 endif()
@@ -134,24 +134,13 @@ add_node_addon(NAME koffi SOURCES ${KOFFI_SRC} trampolines/gnu.inc)
 target_include_directories(koffi PRIVATE . ../.. ../../vendor/node-addon-api "${CMAKE_CURRENT_BINARY_DIR}/trampolines")
 
 if(WIN32)
+    create_import_lib(uv.lib src/uv.def)
     set(UV_LINK_LIB "${CMAKE_CURRENT_BINARY_DIR}/uv.lib")
-    if(MSVC)
-        add_custom_command(OUTPUT uv.lib
-                           COMMAND ${CMAKE_AR} ${CMAKE_STATIC_LINKER_FLAGS}
-                                   /def:src/uv.def /out:${UV_LINK_LIB}
-                           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-                           MAIN_DEPENDENCY src/uv.def)
-    else()
-        add_custom_command(OUTPUT uv.lib
-                           COMMAND ${CMAKE_DLLTOOL} -d src/uv.def -l ${UV_LINK_LIB}
-                           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-                           MAIN_DEPENDENCY src/uv.def)
-    endif()
     target_sources(koffi PRIVATE uv.lib)
     target_link_libraries(koffi PRIVATE ${UV_LINK_LIB})
 endif()
 
-target_compile_definitions(koffi PRIVATE FELIX_TARGET=koffi NAPI_DISABLE_CPP_EXCEPTIONS NAPI_VERSION=8 CORE_NO_STATX)
+target_compile_definitions(koffi PRIVATE FELIX_TARGET=koffi NAPI_DISABLE_CPP_EXCEPTIONS NAPI_VERSION=NAPI_VERSION_EXPERIMENTAL CORE_NO_STATX)
 if(WIN32)
     target_compile_definitions(koffi PRIVATE _CRT_SECURE_NO_WARNINGS _CRT_NONSTDC_NO_DEPRECATE)
     target_link_libraries(koffi PRIVATE ws2_32)
@@ -162,11 +151,28 @@ if(UNIX AND NOT APPLE)
     target_link_options(koffi PRIVATE -Wl,--gc-sections)
 endif()
 
+# ---- Optimization ----
+
+option(PGO_GENERATE "Build with PGO profile generation" "")
+option(PGO_USE "Optimize with PGO profile" "")
+
+if(MSVC AND (CMAKE_BUILD_TYPE STREQUAL "Release" OR CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo"))
+    target_compile_options(koffi PRIVATE $<$<COMPILE_LANGUAGE:CXX>:/GS- /Ob2>)
+
+    if(CMAKE_C_COMPILER_ID MATCHES "[Cc]lang")
+        set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /clang:-O3")
+    endif()
+
+    if(CMAKE_BUILD_TYPE STREQUAL "Release")
+        target_compile_options(koffi PRIVATE $<$<COMPILE_LANGUAGE:CXX>:/Oy->)
+    endif()
+endif()
+
 if(NOT MSVC OR CMAKE_C_COMPILER_ID MATCHES "[Cc]lang")
     # Restore C/C++ compiler sanity
 
     if(NOT MSVC)
-        target_compile_options(koffi PRIVATE $<$<COMPILE_LANGUAGE:CXX>:-fno-exceptions -fno-strict-aliasing -fwrapv
+        target_compile_options(koffi PRIVATE $<$<COMPILE_LANGUAGE:CXX>:-fno-strict-aliasing -fwrapv
                                                                        -fno-delete-null-pointer-checks>)
     else()
         target_compile_options(koffi PRIVATE $<$<COMPILE_LANGUAGE:CXX>:-fno-strict-aliasing /clang:-fwrapv
@@ -177,6 +183,63 @@ if(NOT MSVC OR CMAKE_C_COMPILER_ID MATCHES "[Cc]lang")
     if(use_no_finite_loops)
         target_compile_options(koffi PRIVATE $<$<COMPILE_LANGUAGE:CXX>:-fno-finite-loops>)
     endif()
+
+    if(CMAKE_C_COMPILER_ID STREQUAL "GNU")
+        target_compile_options(koffi PRIVATE -fno-reorder-blocks-and-partition -Wno-maybe-musttail-local-addr)
+    endif()
+endif()
+
+if(PGO_GENERATE)
+    set_target_properties(koffi PROPERTIES INTERPROCEDURAL_OPTIMIZATION ON)
+    target_compile_options(koffi PRIVATE "-fprofile-generate=${PGO_GENERATE}")
+    target_link_options(koffi PRIVATE "-fprofile-generate=${PGO_GENERATE}")
+
+    message(STATUS "PGO: Building instrumented binary")
+elseif(PGO_PROFILE)
+    if(NOT EXISTS "${PGO_PROFILE}")
+        message(FATAL_ERROR "Profile data not found at '${PGO_PROFILE}'")
+    endif()
+
+    set_target_properties(koffi PROPERTIES INTERPROCEDURAL_OPTIMIZATION ON)
+    target_compile_options(koffi PRIVATE "-fprofile-use=${PGO_PROFILE}")
+    target_link_options(koffi PRIVATE "-fprofile-use=${PGO_PROFILE}")
+
+    if(CMAKE_C_COMPILER_ID STREQUAL "GNU")
+        target_compile_options(koffi PRIVATE -fprofile-correction)
+    endif()
+
+    message(STATUS "PGO: Building optimized binary with profile data")
+else()
+    enable_unity_build(koffi EXCLUDE src/uv.cc)
 endif()
 
-enable_unity_build(koffi EXCLUDE src/uv.cc)
+if(APPLE)
+    add_custom_command(
+        TARGET koffi POST_BUILD
+        DEPENDS koffi
+        COMMAND $<$<CONFIG:release>:${CMAKE_STRIP}>
+        ARGS -x $<TARGET_FILE:koffi>
+    )
+elseif(UNIX)
+    add_custom_command(
+        TARGET koffi POST_BUILD
+        DEPENDS koffi
+        COMMAND $<$<CONFIG:release>:${CMAKE_STRIP}>
+        ARGS $<TARGET_FILE:koffi>
+    )
+endif()
+
+# ---- Debug ----
+
+option(ASAN "Build with ASan" OFF)
+option(UBSAN "Build with UBSan" OFF)
+
+if(ASAN)
+    target_compile_options(koffi PRIVATE -fsanitize=address)
+    target_link_options(koffi BEFORE PRIVATE -fsanitize=address)
+endif()
+
+if(UBSAN)
+    target_compile_options(koffi PRIVATE -fsanitize=undefined)
+    target_link_options(koffi BEFORE PRIVATE -fsanitize=undefined)
+endif()

package/src/koffi/index.js

@@ -0,0 +1,359 @@
+"use strict";
+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 __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod3) => function __require() {
+  return mod3 || (0, cb[__getOwnPropNames(cb)[0]])((mod3 = { exports: {} }).exports, mod3), mod3.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 = (mod3, isNodeMode, target) => (target = mod3 != null ? __create(__getProtoOf(mod3)) : {}, __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 || !mod3 || !mod3.__esModule ? __defProp(target, "default", { value: mod3, enumerable: true }) : target,
+  mod3
+));
+var __toCommonJS = (mod3) => __copyProps(__defProp({}, "__esModule", { value: true }), mod3);
+
+// ../cnoke/src/abi.js
+var abi_exports = {};
+__export(abi_exports, {
+  determineAbi: () => determineAbi2
+});
+function determineAbi2() {
+  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(filename2, read) {
+  let fd = null;
+  try {
+    let fd2 = import_fs.default.openSync(filename2);
+    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;
+}
+var import_fs;
+var init_abi = __esm({
+  "../cnoke/src/abi.js"() {
+    import_fs = __toESM(require("fs"), 1);
+  }
+});
+
+// package.json
+var require_package = __commonJS({
+  "package.json"(exports2, module2) {
+    module2.exports = {
+      name: "koffi",
+      version: "3.0.0-alpha.2",
+      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.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 require_init = __commonJS({
+  "src/init.js"(exports, module) {
+    "use strict";
+    var fs = require("fs");
+    var path = require("path");
+    var util = require("util");
+    var { determineAbi } = (init_abi(), __toCommonJS(abi_exports));
+    var PACKAGE = require_package();
+    function detect() {
+      if (process.versions.napi == null || process.versions.napi < PACKAGE.cnoke.napi) {
+        let major = parseInt(process.versions.node, 10);
+        throw new Error(`This engine is based on Node ${process.versions.node}, but ${PACKAGE.name} does not support the Node ${major}.x branch (N-API < ${PACKAGE.cnoke.napi})`);
+      }
+      let abi = determineAbi();
+      let pkg3 = `${process.platform}-${process.arch}`;
+      let triplets3 = [`${process.platform}_${abi}`];
+      if (process.platform == "linux")
+        triplets3.push(`musl_${abi}`);
+      return [pkg3, triplets3];
+    }
+    function init(root, pkg, triplets, native) {
+      let err = null;
+      if (native == null) {
+        let roots = [root];
+        if (process.resourcesPath != null)
+          roots.push(process.resourcesPath);
+        let filenames = roots.flatMap((dir) => triplets.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-${pkg}/${triplet}/koffi.node`
+        ]));
+        for (let filename of filenames) {
+          if (!fs.existsSync(filename))
+            continue;
+          try {
+            native = eval("require")(filename);
+            break;
+          } catch (e) {
+            err ??= e;
+          }
+        }
+      }
+      if (native == null) {
+        err ??= new Error("Cannot find the native Koffi module; did you bundle it correctly?");
+        throw err;
+      }
+      if (native.version != PACKAGE.version)
+        throw new Error("Mismatched native Koffi modules");
+      let mod = wrap(native);
+      return mod;
+    }
+    function wrap(native3) {
+      let obj = {
+        ...native3,
+        // Deprecated functions
+        handle: util.deprecate(native3.opaque, "The koffi.handle() function was deprecated in Koffi 2.1, use koffi.opaque() instead", "KOFFI001"),
+        callback: util.deprecate(native3.proto, "The koffi.callback() function was deprecated in Koffi 2.4, use koffi.proto() instead", "KOFFI002")
+      };
+      obj.load = (...args) => {
+        let lib = native3.load(...args);
+        lib.cdecl = util.deprecate((...args2) => lib.func("__cdecl", ...args2), "The koffi.cdecl() function was deprecated in Koffi 2.7, use koffi.func(...) instead", "KOFFI003");
+        lib.stdcall = util.deprecate((...args2) => lib.func("__stdcall", ...args2), 'The koffi.stdcall() function was deprecated in Koffi 2.7, use koffi.func("__stdcall", ...) instead', "KOFFI004");
+        lib.fastcall = util.deprecate((...args2) => lib.func("__fastcall", ...args2), 'The koffi.fastcall() function was deprecated in Koffi 2.7, use koffi.func("__fastcall", ...) instead', "KOFFI005");
+        lib.thiscall = util.deprecate((...args2) => lib.func("__thiscall", ...args2), 'The koffi.thiscall() function was deprecated in Koffi 2.7, use koffi.func("__thiscall", ...) instead', "KOFFI006");
+        return lib;
+      };
+      return obj;
+    }
+    module.exports = {
+      detect,
+      init
+    };
+  }
+});
+
+// src/static.js
+var require_static = __commonJS({
+  "src/static.js"(exports2, module2) {
+    function find2(pkg3) {
+      let native3 = null;
+      if (native3 == null && pkg3 == "linux-arm64") {
+        try {
+          native3 = require("../../build/koffi/linux_arm64/koffi.node");
+        } catch (err2) {
+        }
+      }
+      if (native3 == null && pkg3 == "linux-arm64") {
+        try {
+          native3 = require("../../build/koffi/musl_arm64/koffi.node");
+        } catch (err2) {
+        }
+      }
+      if (native3 == null && pkg3 == "linux-ia32") {
+        try {
+          native3 = require("../../build/koffi/linux_ia32/koffi.node");
+        } catch (err2) {
+        }
+      }
+      if (native3 == null && pkg3 == "linux-x64") {
+        try {
+          native3 = require("../../build/koffi/linux_x64/koffi.node");
+        } catch (err2) {
+        }
+      }
+      if (native3 == null && pkg3 == "linux-x64") {
+        try {
+          native3 = require("../../build/koffi/musl_x64/koffi.node");
+        } catch (err2) {
+        }
+      }
+      if (native3 == null && pkg3 == "freebsd-ia32") {
+        try {
+          native3 = require("../../build/koffi/freebsd_ia32/koffi.node");
+        } catch (err2) {
+        }
+      }
+      if (native3 == null && pkg3 == "freebsd-x64") {
+        try {
+          native3 = require("../../build/koffi/freebsd_x64/koffi.node");
+        } catch (err2) {
+        }
+      }
+      if (native3 == null && pkg3 == "freebsd-arm64") {
+        try {
+          native3 = require("../../build/koffi/freebsd_arm64/koffi.node");
+        } catch (err2) {
+        }
+      }
+      if (native3 == null && pkg3 == "openbsd-ia32") {
+        try {
+          native3 = require("../../build/koffi/openbsd_ia32/koffi.node");
+        } catch (err2) {
+        }
+      }
+      if (native3 == null && pkg3 == "openbsd-x64") {
+        try {
+          native3 = require("../../build/koffi/openbsd_x64/koffi.node");
+        } catch (err2) {
+        }
+      }
+      if (native3 == null && pkg3 == "win32-ia32") {
+        try {
+          native3 = require("../../build/koffi/win32_ia32/koffi.node");
+        } catch (err2) {
+        }
+      }
+      if (native3 == null && pkg3 == "win32-x64") {
+        try {
+          native3 = require("../../build/koffi/win32_x64/koffi.node");
+        } catch (err2) {
+        }
+      }
+      if (native3 == null && pkg3 == "darwin-x64") {
+        try {
+          native3 = require("../../build/koffi/darwin_x64/koffi.node");
+        } catch (err2) {
+        }
+      }
+      if (native3 == null && pkg3 == "darwin-arm64") {
+        try {
+          native3 = require("../../build/koffi/darwin_arm64/koffi.node");
+        } catch (err2) {
+        }
+      }
+      return native3;
+    }
+    module2.exports = { find: find2 };
+  }
+});
+
+// index.js
+var { detect: detect2, init: init2 } = require_init();
+var { find } = require_static();
+var [pkg2, triplets2] = detect2();
+var native2 = find(pkg2);
+var mod2 = init2(__dirname + "/../..", pkg2, triplets2, native2);
+module.exports = mod2;