koffi 2.16.1 → 3.0.0-alpha.2

package/src/koffi/indirect.js

@@ -0,0 +1,216 @@
+"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);
+  }
+});
+
+// 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.json");
+    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(native2) {
+      let obj = {
+        ...native2,
+        // Deprecated functions
+        handle: util.deprecate(native2.opaque, "The koffi.handle() function was deprecated in Koffi 2.1, use koffi.opaque() instead", "KOFFI001"),
+        callback: util.deprecate(native2.proto, "The koffi.callback() function was deprecated in Koffi 2.4, use koffi.proto() instead", "KOFFI002")
+      };
+      obj.load = (...args) => {
+        let lib = native2.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
+    };
+  }
+});
+
+// indirect.js
+var { detect: detect2, init: init2 } = require_init();
+var [pkg2, triplets2] = detect2();
+var mod2 = init2(__dirname + "/../..", pkg2, triplets2, null);
+module.exports = mod2;