@entelligentsia/forgecli 0.7.7 → 0.7.9

package/node_modules/koffi/index.js

@@ -0,0 +1,634 @@
+"use strict";
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod3) => function __require() {
+  return mod3 || (0, cb[__getOwnPropNames(cb)[0]])((mod3 = { exports: {} }).exports, mod3), mod3.exports;
+};
+
+// ../../bin/Koffi/package/src/cnoke/src/tools.js
+var require_tools = __commonJS({
+  "../../bin/Koffi/package/src/cnoke/src/tools.js"(exports2, module2) {
+    "use strict";
+    var crypto = require("crypto");
+    var fs2 = require("fs");
+    var http = require("https");
+    var path2 = require("path");
+    var zlib = require("zlib");
+    async function download_http(url, dest) {
+      console.log(">> Downloading " + url);
+      let [tmp_name, file] = open_temporary_stream(dest);
+      try {
+        await new Promise((resolve, reject) => {
+          let request = http.get(url, (response) => {
+            if (response.statusCode != 200) {
+              let err = new Error(`Download failed: ${response.statusMessage} [${response.statusCode}]`);
+              err.code = response.statusCode;
+              reject(err);
+              return;
+            }
+            response.pipe(file);
+            file.on("finish", () => file.close(() => {
+              try {
+                fs2.renameSync(file.path, dest);
+              } catch (err) {
+                if (!fs2.existsSync(dest))
+                  reject(err);
+              }
+              resolve();
+            }));
+          });
+          request.on("error", reject);
+          file.on("error", reject);
+        });
+      } catch (err) {
+        file.close();
+        try {
+          fs2.unlinkSync(tmp_name);
+        } catch (err2) {
+          if (err2.code != "ENOENT")
+            throw err2;
+        }
+        throw err;
+      }
+    }
+    function open_temporary_stream(prefix) {
+      let buf = Buffer.allocUnsafe(4);
+      for (; ; ) {
+        try {
+          crypto.randomFillSync(buf);
+          let suffix = buf.toString("hex").padStart(8, "0");
+          let filename2 = `${prefix}.${suffix}`;
+          let file = fs2.createWriteStream(filename2, { flags: "wx", mode: 420 });
+          return [filename2, file];
+        } catch (err) {
+          if (err.code != "EEXIST")
+            throw err;
+        }
+      }
+    }
+    function extract_targz(filename2, dest_dir, strip = 0) {
+      let reader = fs2.createReadStream(filename2).pipe(zlib.createGunzip());
+      return new Promise((resolve, reject) => {
+        let header = null;
+        let extended = {};
+        reader.on("readable", () => {
+          try {
+            for (; ; ) {
+              if (header == null) {
+                let buf = reader.read(512);
+                if (buf == null)
+                  break;
+                if (!buf[0])
+                  continue;
+                header = {
+                  filename: buf.toString("utf-8", 0, 100).replace(/\0/g, ""),
+                  mode: parseInt(buf.toString("ascii", 100, 109), 8),
+                  size: parseInt(buf.toString("ascii", 124, 137), 8),
+                  type: String.fromCharCode(buf[156])
+                };
+                Object.assign(header, extended);
+                extended = {};
+                header.filename = header.filename.replace(/\\/g, "/");
+                if (!header.filename.length)
+                  throw new Error(`Insecure empty filename inside TAR archive`);
+                if (path_is_absolute(header.filename[0]))
+                  throw new Error(`Insecure filename starting with / inside TAR archive`);
+                if (path_has_dotdot(header.filename))
+                  throw new Error(`Insecure filename containing '..' inside TAR archive`);
+                for (let i = 0; i < strip; i++)
+                  header.filename = header.filename.substr(header.filename.indexOf("/") + 1);
+              }
+              let aligned = Math.floor((header.size + 511) / 512) * 512;
+              let data = header.size ? reader.read(aligned) : null;
+              if (data == null) {
+                if (header.size)
+                  break;
+                data = Buffer.alloc(0);
+              }
+              data = data.subarray(0, header.size);
+              if (header.type == "0" || header.type == "7") {
+                let filename3 = dest_dir + "/" + header.filename;
+                let dirname = path2.dirname(filename3);
+                fs2.mkdirSync(dirname, { recursive: true, mode: 493 });
+                fs2.writeFileSync(filename3, data, { mode: header.mode });
+              } else if (header.type == "5") {
+                let filename3 = dest_dir + "/" + header.filename;
+                fs2.mkdirSync(filename3, { recursive: true, mode: header.mode });
+              } else if (header.type == "L") {
+                extended.filename = data.toString("utf-8").replace(/\0/g, "");
+              } else if (header.type == "x") {
+                let str = data.toString("utf-8");
+                try {
+                  while (str.length) {
+                    let matches = str.match(/^([0-9]+) ([a-zA-Z0-9\._]+)=(.*)\n/);
+                    let skip = parseInt(matches[1], 10);
+                    let key = matches[2];
+                    let value = matches[3];
+                    switch (key) {
+                      case "path":
+                        {
+                          extended.filename = value;
+                        }
+                        break;
+                      case "size":
+                        {
+                          extended.size = parseInt(value, 10);
+                        }
+                        break;
+                    }
+                    str = str.substr(skip).trimStart();
+                  }
+                } catch (err) {
+                  throw new Error("Malformed PAX entry");
+                }
+              }
+              header = null;
+            }
+          } catch (err) {
+            reject(err);
+          }
+        });
+        reader.on("error", reject);
+        reader.on("end", resolve);
+      });
+    }
+    function path_is_absolute(path3) {
+      if (process.platform == "win32" && path3.match(/^[a-zA-Z]:/))
+        path3 = path3.substr(2);
+      return is_path_separator(path3[0]);
+    }
+    function path_has_dotdot(path3) {
+      let start = 0;
+      for (; ; ) {
+        let offset = path3.indexOf("..", start);
+        if (offset < 0)
+          break;
+        start = offset + 2;
+        if (offset && !is_path_separator(path3[offset - 1]))
+          continue;
+        if (offset + 2 < path3.length && !is_path_separator(path3[offset + 2]))
+          continue;
+        return true;
+      }
+      return false;
+    }
+    function is_path_separator(c) {
+      if (c == "/")
+        return true;
+      if (process.platform == "win32" && c == "\\")
+        return true;
+      return false;
+    }
+    function sync_files(src_dir, dest_dir) {
+      let keep = /* @__PURE__ */ new Set();
+      {
+        let entries = fs2.readdirSync(src_dir, { withFileTypes: true });
+        for (let entry of entries) {
+          if (!entry.isFile())
+            continue;
+          keep.add(entry.name);
+          fs2.copyFileSync(src_dir + `/${entry.name}`, dest_dir + `/${entry.name}`);
+        }
+      }
+      {
+        let entries = fs2.readdirSync(dest_dir, { withFileTypes: true });
+        for (let entry of entries) {
+          if (!entry.isFile())
+            continue;
+          if (keep.has(entry.name))
+            continue;
+          fs2.unlinkSync(dest_dir + `/${entry.name}`);
+        }
+      }
+    }
+    function determine_arch2() {
+      let arch = process.arch;
+      if (arch == "riscv32" || arch == "riscv64") {
+        let buf = read_file_header(process.execPath, 512);
+        let header = decode_elf_header(buf);
+        let float_abi = header.e_flags & 6;
+        switch (float_abi) {
+          case 0:
+            {
+            }
+            break;
+          case 2:
+            {
+              arch += "f";
+            }
+            break;
+          case 4:
+            {
+              arch += "d";
+            }
+            break;
+          case 6:
+            {
+              arch += "q";
+            }
+            break;
+        }
+      } else if (arch == "arm") {
+        let buf = read_file_header(process.execPath, 512);
+        let header = decode_elf_header(buf);
+        if (header.e_flags & 1024) {
+          arch += "hf";
+        } else if (header.e_flags & 512) {
+          arch += "sf";
+        } else {
+          throw new Error("Unknown ARM floating-point ABI");
+        }
+      }
+      return arch;
+    }
+    function read_file_header(filename2, read) {
+      let fd = null;
+      try {
+        let fd2 = fs2.openSync(filename2);
+        let buf = Buffer.allocUnsafe(read);
+        let len = fs2.readSync(fd2, buf);
+        return buf.subarray(0, len);
+      } finally {
+        if (fd != null)
+          fs2.closeSync(fd);
+      }
+    }
+    function decode_elf_header(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");
+      let machine = buf.readUInt16LE(18);
+      switch (machine) {
+        case 3:
+          {
+            header.e_machine = "ia32";
+          }
+          break;
+        case 40:
+          {
+            header.e_machine = "arm";
+          }
+          break;
+        case 62:
+          {
+            header.e_machine = "amd64";
+          }
+          break;
+        case 183:
+          {
+            header.e_machine = "arm64";
+          }
+          break;
+        case 243:
+          {
+            switch (buf[4]) {
+              case 1:
+                {
+                  header.e_machine = "riscv32";
+                }
+                break;
+              case 2:
+                {
+                  header.e_machine = "riscv64";
+                }
+                break;
+            }
+          }
+          break;
+        case 248:
+          {
+            switch (buf[4]) {
+              case 1:
+                {
+                  header.e_machine = "loong32";
+                }
+                break;
+              case 2:
+                {
+                  header.e_machine = "loong64";
+                }
+                break;
+            }
+          }
+          break;
+        default:
+          throw new Error("Unknown ELF machine type");
+      }
+      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;
+    }
+    function unlink_recursive(path3) {
+      try {
+        fs2.rmSync(path3, { recursive: true, maxRetries: process.platform == "win32" ? 3 : 0 });
+      } catch (err) {
+        if (err.code !== "ENOENT")
+          throw err;
+      }
+    }
+    function get_napi_version2(napi, major) {
+      if (napi > 8)
+        return null;
+      const support = {
+        6: ["6.14.2", "6.14.2", "6.14.2"],
+        8: ["8.6.0", "8.10.0", "8.11.2"],
+        9: ["9.0.0", "9.3.0", "9.11.0"],
+        10: ["10.0.0", "10.0.0", "10.0.0", "10.16.0", "10.17.0", "10.20.0", "10.23.0"],
+        11: ["11.0.0", "11.0.0", "11.0.0", "11.8.0"],
+        12: ["12.0.0", "12.0.0", "12.0.0", "12.0.0", "12.11.0", "12.17.0", "12.19.0", "12.22.0"],
+        13: ["13.0.0", "13.0.0", "13.0.0", "13.0.0", "13.0.0"],
+        14: ["14.0.0", "14.0.0", "14.0.0", "14.0.0", "14.0.0", "14.0.0", "14.12.0", "14.17.0"],
+        15: ["15.0.0", "15.0.0", "15.0.0", "15.0.0", "15.0.0", "15.0.0", "15.0.0", "15.12.0"]
+      };
+      const max = Math.max(...Object.keys(support).map((k) => parseInt(k, 10)));
+      if (major > max)
+        return major + ".0.0";
+      if (support[major] == null)
+        return null;
+      let required = support[major][napi - 1] || null;
+      return required;
+    }
+    function cmp_version(ver1, ver2) {
+      ver1 = String(ver1).replace(/-.*$/, "").split(".").reduce((acc, v, idx) => acc + parseInt(v, 10) * Math.pow(10, 2 * (5 - idx)), 0);
+      ver2 = String(ver2).replace(/-.*$/, "").split(".").reduce((acc, v, idx) => acc + parseInt(v, 10) * Math.pow(10, 2 * (5 - idx)), 0);
+      let cmp = Math.min(Math.max(ver1 - ver2, -1), 1);
+      return cmp;
+    }
+    module2.exports = {
+      download_http,
+      extract_targz,
+      path_is_absolute,
+      path_has_dotdot,
+      sync_files,
+      determine_arch: determine_arch2,
+      unlink_recursive,
+      get_napi_version: get_napi_version2,
+      cmp_version
+    };
+  }
+});
+
+// ../../bin/Koffi/package/src/koffi/package.json
+var require_package = __commonJS({
+  "../../bin/Koffi/package/src/koffi/package.json"(exports2, module2) {
+    module2.exports = {
+      name: "koffi",
+      version: "2.16.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,
+        require: "./index.js"
+      },
+      funding: "https://liberapay.com/Koromix"
+    };
+  }
+});
+
+// ../../bin/Koffi/package/src/koffi/src/init.js
+var require_init = __commonJS({
+  "../../bin/Koffi/package/src/koffi/src/init.js"(exports, module) {
+    var fs = require("fs");
+    var path = require("path");
+    var util = require("util");
+    var { get_napi_version, determine_arch } = require_tools();
+    var pkg = require_package();
+    function detect() {
+      if (process.versions.napi == null || process.versions.napi < pkg.cnoke.napi) {
+        let major = parseInt(process.versions.node, 10);
+        let required = get_napi_version(pkg.cnoke.napi, major);
+        if (required != null) {
+          throw new Error(`This engine is based on Node ${process.versions.node}, but ${pkg.name} requires Node >= ${required} in the Node ${major}.x branch (N-API >= ${pkg.cnoke.napi})`);
+        } else {
+          throw new Error(`This engine is based on Node ${process.versions.node}, but ${pkg.name} does not support the Node ${major}.x branch (N-API < ${pkg.cnoke.napi})`);
+        }
+      }
+      let arch = determine_arch();
+      let triplet3 = `${process.platform}_${arch}`;
+      return triplet3;
+    }
+    function init(triplet, native) {
+      if (native == null) {
+        let roots = [path.join(__dirname, "..")];
+        let triplets = [triplet];
+        if (process.resourcesPath != null)
+          roots.push(process.resourcesPath);
+        if (triplet.startsWith("linux_")) {
+          let musl = triplet.replace(/^linux_/, "musl_");
+          triplets.push(musl);
+        }
+        let filenames = roots.flatMap((root) => triplets.flatMap((triplet3) => [
+          `${root}/koffi/build/koffi/${triplet3}/koffi.node`,
+          `${root}/build/koffi/${triplet3}/koffi.node`,
+          `${root}/koffi/${triplet3}/koffi.node`,
+          `${root}/node_modules/koffi/build/koffi/${triplet3}/koffi.node`,
+          `${root}/../../bin/Koffi/${triplet3}/koffi.node`
+        ]));
+        let first_err = null;
+        for (let filename of filenames) {
+          if (!fs.existsSync(filename))
+            continue;
+          try {
+            native = eval("require")(filename);
+          } catch (err) {
+            if (first_err == null)
+              first_err = err;
+            continue;
+          }
+          break;
+        }
+        if (first_err != null)
+          throw first_err;
+      }
+      if (native == null)
+        throw new Error("Cannot find the native Koffi module; did you bundle it correctly?");
+      if (native.version != pkg.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
+    };
+  }
+});
+
+// ../../bin/Koffi/package/src/koffi/index.js
+var { detect: detect2, init: init2 } = require_init();
+var triplet2 = detect2();
+var native2 = null;
+try {
+  switch (triplet2) {
+    case "darwin_arm64":
+      {
+        native2 = require("./build/koffi/darwin_arm64/koffi.node");
+      }
+      break;
+    case "darwin_x64":
+      {
+        native2 = require("./build/koffi/darwin_x64/koffi.node");
+      }
+      break;
+    case "freebsd_arm64":
+      {
+        native2 = require("./build/koffi/freebsd_arm64/koffi.node");
+      }
+      break;
+    case "freebsd_ia32":
+      {
+        native2 = require("./build/koffi/freebsd_ia32/koffi.node");
+      }
+      break;
+    case "freebsd_x64":
+      {
+        native2 = require("./build/koffi/freebsd_x64/koffi.node");
+      }
+      break;
+    case "linux_armhf":
+      {
+        native2 = require("./build/koffi/linux_armhf/koffi.node");
+      }
+      break;
+    case "linux_arm64":
+      {
+        native2 = require("./build/koffi/linux_arm64/koffi.node");
+      }
+      break;
+    case "linux_ia32":
+      {
+        native2 = require("./build/koffi/linux_ia32/koffi.node");
+      }
+      break;
+    case "linux_loong64":
+      {
+        native2 = require("./build/koffi/linux_loong64/koffi.node");
+      }
+      break;
+    case "linux_riscv64d":
+      {
+        native2 = require("./build/koffi/linux_riscv64d/koffi.node");
+      }
+      break;
+    case "linux_x64":
+      {
+        native2 = require("./build/koffi/linux_x64/koffi.node");
+      }
+      break;
+    case "openbsd_ia32":
+      {
+        native2 = require("./build/koffi/openbsd_ia32/koffi.node");
+      }
+      break;
+    case "openbsd_x64":
+      {
+        native2 = require("./build/koffi/openbsd_x64/koffi.node");
+      }
+      break;
+    case "win32_arm64":
+      {
+        native2 = require("./build/koffi/win32_arm64/koffi.node");
+      }
+      break;
+    case "win32_ia32":
+      {
+        native2 = require("./build/koffi/win32_ia32/koffi.node");
+      }
+      break;
+    case "win32_x64":
+      {
+        native2 = require("./build/koffi/win32_x64/koffi.node");
+      }
+      break;
+  }
+} catch {
+  try {
+    switch (triplet2) {
+      case "linux_arm64":
+        {
+          native2 = require("./build/koffi/musl_arm64/koffi.node");
+        }
+        break;
+      case "linux_x64":
+        {
+          native2 = require("./build/koffi/musl_x64/koffi.node");
+        }
+        break;
+    }
+  } catch {
+  }
+}
+var mod2 = init2(triplet2, native2);
+module.exports = mod2;