camstack 1.2.14 → 1.2.16

package/dist/main-IM5JIKX5.js

@@ -0,0 +1,2302 @@
+#!/usr/bin/env node
+import {
+  require_semver,
+  require_src
+} from "./chunk-RA674VWL.js";
+import {
+  __commonJS,
+  __esm,
+  __require,
+  __toESM
+} from "./chunk-LMMQX4CK.js";
+
+// ../../node_modules/@electron/rebuild/node_modules/node-abi/getNextTarget.js
+function getNextTarget(runtime, targets) {
+  const latest = targets.filter((t) => {
+    return t.runtime === runtime;
+  }).slice(-1)[0];
+  const increment = runtime === "electron" ? "minor" : "major";
+  let next = import_semver.default.inc(latest.target, increment);
+  if (runtime === "electron" && import_semver.default.parse(latest.target).prerelease.length) {
+    next = import_semver.default.inc(next, "major");
+  }
+  return next;
+}
+var import_semver;
+var init_getNextTarget = __esm({
+  "../../node_modules/@electron/rebuild/node_modules/node-abi/getNextTarget.js"() {
+    "use strict";
+    import_semver = __toESM(require_semver(), 1);
+  }
+});
+
+// ../../node_modules/@electron/rebuild/node_modules/node-abi/index.js
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+function getAbi(target, runtime) {
+  if (target === String(Number(target))) return target;
+  if (target) target = target.replace(/^v/, "");
+  if (!runtime) runtime = "node";
+  if (runtime === "node") {
+    if (!target) return process.versions.modules;
+    if (target === process.versions.node) return process.versions.modules;
+  }
+  let abi;
+  let lastTarget;
+  for (let i = 0; i < allTargets.length; i++) {
+    const t = allTargets[i];
+    if (t.runtime !== runtime) continue;
+    if (import_semver2.default.lte(t.target, target) && (!lastTarget || import_semver2.default.gte(t.target, lastTarget))) {
+      abi = t.abi;
+      lastTarget = t.target;
+    }
+  }
+  if (abi && import_semver2.default.lt(target, getNextTarget(runtime, allTargets))) return abi;
+  throw new Error(
+    "Could not detect abi for version " + target + " and runtime " + runtime + '.  Updating "node-abi" might help solve this issue if it is a new release of ' + runtime
+  );
+}
+function sortByTargetFn(a, b) {
+  const abiComp = Number(a.abi) - Number(b.abi);
+  if (abiComp !== 0) return abiComp;
+  if (a.target < b.target) return -1;
+  if (a.target > b.target) return 1;
+  return 0;
+}
+function loadGeneratedTargets() {
+  const registry = JSON.parse(
+    fs.readFileSync(
+      path.join(path.dirname(fileURLToPath(import.meta.url)), "abi_registry.json"),
+      "utf8"
+    )
+  );
+  const targets = {
+    supported: [],
+    additional: [],
+    future: []
+  };
+  registry.forEach(function(item) {
+    const target = {
+      runtime: item.runtime,
+      target: item.target,
+      abi: item.abi
+    };
+    if (item.lts) {
+      const startDate = new Date(Date.parse(item.lts[0]));
+      const endDate = new Date(Date.parse(item.lts[1]));
+      const currentDate = /* @__PURE__ */ new Date();
+      target.lts = startDate < currentDate && currentDate < endDate;
+    } else {
+      target.lts = false;
+    }
+    if (target.runtime === "node-webkit") {
+      targets.additional.push(target);
+    } else if (item.future) {
+      targets.future.push(target);
+    } else {
+      targets.supported.push(target);
+    }
+  });
+  targets.supported.sort(sortByTargetFn);
+  targets.additional.sort(sortByTargetFn);
+  targets.future.sort(sortByTargetFn);
+  return targets;
+}
+var import_semver2, generatedTargets, supportedTargets, additionalTargets, deprecatedTargets, futureTargets, allTargets;
+var init_node_abi = __esm({
+  "../../node_modules/@electron/rebuild/node_modules/node-abi/index.js"() {
+    "use strict";
+    import_semver2 = __toESM(require_semver(), 1);
+    init_getNextTarget();
+    generatedTargets = loadGeneratedTargets();
+    supportedTargets = [
+      { runtime: "node", target: "5.0.0", abi: "47", lts: false },
+      { runtime: "node", target: "6.0.0", abi: "48", lts: false },
+      { runtime: "node", target: "7.0.0", abi: "51", lts: false },
+      { runtime: "node", target: "8.0.0", abi: "57", lts: false },
+      { runtime: "node", target: "9.0.0", abi: "59", lts: false },
+      {
+        runtime: "node",
+        target: "10.0.0",
+        abi: "64",
+        lts: new Date(2018, 10, 1) < /* @__PURE__ */ new Date() && /* @__PURE__ */ new Date() < new Date(2020, 4, 31)
+      },
+      { runtime: "electron", target: "0.36.0", abi: "47", lts: false },
+      { runtime: "electron", target: "1.1.0", abi: "48", lts: false },
+      { runtime: "electron", target: "1.3.0", abi: "49", lts: false },
+      { runtime: "electron", target: "1.4.0", abi: "50", lts: false },
+      { runtime: "electron", target: "1.5.0", abi: "51", lts: false },
+      { runtime: "electron", target: "1.6.0", abi: "53", lts: false },
+      { runtime: "electron", target: "1.7.0", abi: "54", lts: false },
+      { runtime: "electron", target: "1.8.0", abi: "57", lts: false },
+      { runtime: "electron", target: "2.0.0", abi: "57", lts: false },
+      { runtime: "electron", target: "3.0.0", abi: "64", lts: false },
+      { runtime: "electron", target: "4.0.0", abi: "64", lts: false },
+      { runtime: "electron", target: "4.0.4", abi: "69", lts: false },
+      ...generatedTargets.supported
+    ];
+    additionalTargets = [
+      { runtime: "node-webkit", target: "0.13.0", abi: "47", lts: false },
+      { runtime: "node-webkit", target: "0.15.0", abi: "48", lts: false },
+      { runtime: "node-webkit", target: "0.18.3", abi: "51", lts: false },
+      { runtime: "node-webkit", target: "0.23.0", abi: "57", lts: false },
+      { runtime: "node-webkit", target: "0.26.5", abi: "59", lts: false },
+      ...generatedTargets.additional
+    ];
+    deprecatedTargets = [
+      { runtime: "node", target: "0.2.0", abi: "1", lts: false },
+      { runtime: "node", target: "0.9.1", abi: "0x000A", lts: false },
+      { runtime: "node", target: "0.9.9", abi: "0x000B", lts: false },
+      { runtime: "node", target: "0.10.4", abi: "11", lts: false },
+      { runtime: "node", target: "0.11.0", abi: "0x000C", lts: false },
+      { runtime: "node", target: "0.11.8", abi: "13", lts: false },
+      { runtime: "node", target: "0.11.11", abi: "14", lts: false },
+      { runtime: "node", target: "1.0.0", abi: "42", lts: false },
+      { runtime: "node", target: "1.1.0", abi: "43", lts: false },
+      { runtime: "node", target: "2.0.0", abi: "44", lts: false },
+      { runtime: "node", target: "3.0.0", abi: "45", lts: false },
+      { runtime: "node", target: "4.0.0", abi: "46", lts: false },
+      { runtime: "electron", target: "0.30.0", abi: "44", lts: false },
+      { runtime: "electron", target: "0.31.0", abi: "45", lts: false },
+      { runtime: "electron", target: "0.33.0", abi: "46", lts: false }
+    ];
+    futureTargets = generatedTargets.future;
+    allTargets = deprecatedTargets.concat(supportedTargets).concat(additionalTargets).concat(futureTargets);
+  }
+});
+
+// ../../node_modules/@electron/rebuild/lib/cache.js
+import crypto from "crypto";
+import fs2 from "fs";
+import path2 from "path";
+import zlib from "zlib";
+function dHashTree(tree, hash) {
+  for (const key of Object.keys(tree).sort()) {
+    hash.update(key);
+    if (typeof tree[key] === "string") {
+      hash.update(tree[key]);
+    } else {
+      dHashTree(tree[key], hash);
+    }
+  }
+}
+async function hashDirectory(dir, relativeTo) {
+  relativeTo ??= dir;
+  d("hashing dir", dir);
+  const dirTree = {};
+  await Promise.all((await fs2.promises.readdir(dir)).map(async (child) => {
+    d("found child", child, "in dir", dir);
+    if (dir === relativeTo && (child === "build" || child === "bin"))
+      return;
+    if (child === "node_modules")
+      return;
+    const childPath = path2.resolve(dir, child);
+    const relative = path2.relative(relativeTo, childPath);
+    if ((await fs2.promises.stat(childPath)).isDirectory()) {
+      dirTree[relative] = await hashDirectory(childPath, relativeTo);
+    } else {
+      dirTree[relative] = crypto.createHash("SHA256").update(await fs2.promises.readFile(childPath)).digest("hex");
+    }
+  }));
+  return dirTree;
+}
+async function generateCacheKey(opts) {
+  const tree = await hashDirectory(opts.modulePath);
+  const hasher = crypto.createHash("SHA256").update(`${ELECTRON_REBUILD_CACHE_ID}`).update(path2.basename(opts.modulePath)).update(opts.ABI).update(opts.arch).update(opts.platform).update(opts.debug ? "debug" : "not debug").update(opts.headerURL).update(opts.electronVersion);
+  dHashTree(tree, hasher);
+  const hash = hasher.digest("hex");
+  d("calculated hash of", opts.modulePath, "to be", hash);
+  return hash;
+}
+var import_debug, d, ELECTRON_REBUILD_CACHE_ID, Snap, takeSnapshot, writeSnapshot, serialize, unserialize, cacheModuleState, lookupModuleState;
+var init_cache = __esm({
+  "../../node_modules/@electron/rebuild/lib/cache.js"() {
+    "use strict";
+    import_debug = __toESM(require_src(), 1);
+    d = (0, import_debug.default)("electron-rebuild");
+    ELECTRON_REBUILD_CACHE_ID = 1;
+    Snap = class {
+      hash;
+      data;
+      constructor(hash, data) {
+        this.hash = hash;
+        this.data = data;
+      }
+    };
+    takeSnapshot = async (dir, relativeTo = dir) => {
+      const snap = {};
+      await Promise.all((await fs2.promises.readdir(dir)).map(async (child) => {
+        if (child === "node_modules")
+          return;
+        const childPath = path2.resolve(dir, child);
+        const relative = path2.relative(relativeTo, childPath);
+        if ((await fs2.promises.stat(childPath)).isDirectory()) {
+          snap[relative] = await takeSnapshot(childPath, relativeTo);
+        } else {
+          const data = await fs2.promises.readFile(childPath);
+          snap[relative] = new Snap(crypto.createHash("SHA256").update(data).digest("hex"), data);
+        }
+      }));
+      return snap;
+    };
+    writeSnapshot = async (diff, dir) => {
+      for (const key in diff) {
+        if (diff[key] instanceof Snap) {
+          await fs2.promises.mkdir(path2.dirname(path2.resolve(dir, key)), { recursive: true });
+          await fs2.promises.writeFile(path2.resolve(dir, key), diff[key].data);
+        } else {
+          await fs2.promises.mkdir(path2.resolve(dir, key), { recursive: true });
+          await writeSnapshot(diff[key], dir);
+        }
+      }
+    };
+    serialize = (snap) => {
+      const jsonReady = {};
+      for (const key in snap) {
+        if (snap[key] instanceof Snap) {
+          const s = snap[key];
+          jsonReady[key] = {
+            __isSnap: true,
+            hash: s.hash,
+            data: s.data.toString("base64")
+          };
+        } else {
+          jsonReady[key] = serialize(snap[key]);
+        }
+      }
+      return jsonReady;
+    };
+    unserialize = (jsonReady) => {
+      const snap = {};
+      for (const key in jsonReady) {
+        if (jsonReady[key].__isSnap) {
+          snap[key] = new Snap(jsonReady[key].hash, Buffer.from(jsonReady[key].data, "base64"));
+        } else {
+          snap[key] = unserialize(jsonReady[key]);
+        }
+      }
+      return snap;
+    };
+    cacheModuleState = async (dir, cachePath, key) => {
+      const snap = await takeSnapshot(dir);
+      const moduleBuffer = Buffer.from(JSON.stringify(serialize(snap)));
+      const zipped = await new Promise((resolve) => zlib.gzip(moduleBuffer, (_, result) => resolve(result)));
+      await fs2.promises.mkdir(cachePath, { recursive: true });
+      await fs2.promises.writeFile(path2.resolve(cachePath, key), zipped);
+    };
+    lookupModuleState = async (cachePath, key) => {
+      if (fs2.existsSync(path2.resolve(cachePath, key))) {
+        return async function applyDiff(dir) {
+          const zipped = await fs2.promises.readFile(path2.resolve(cachePath, key));
+          const unzipped = await new Promise((resolve) => {
+            zlib.gunzip(zipped, (_, result) => resolve(result));
+          });
+          const diff = unserialize(JSON.parse(unzipped.toString()));
+          await writeSnapshot(diff, dir);
+        };
+      }
+      return false;
+    };
+  }
+});
+
+// ../../node_modules/@electron/rebuild/lib/types.js
+var BuildType;
+var init_types = __esm({
+  "../../node_modules/@electron/rebuild/lib/types.js"() {
+    "use strict";
+    (function(BuildType2) {
+      BuildType2["Debug"] = "Debug";
+      BuildType2["Release"] = "Release";
+    })(BuildType || (BuildType = {}));
+  }
+});
+
+// ../../node_modules/@electron/rebuild/lib/constants.js
+import os from "os";
+import path3 from "path";
+var ELECTRON_GYP_DIR;
+var init_constants = __esm({
+  "../../node_modules/@electron/rebuild/lib/constants.js"() {
+    "use strict";
+    ELECTRON_GYP_DIR = path3.resolve(os.homedir(), ".electron-gyp");
+  }
+});
+
+// ../../node_modules/@electron/rebuild/lib/fetcher.js
+import { setTimeout as sleep } from "timers/promises";
+async function fetchUrl(url, responseType, retries = 3) {
+  if (retries === 0)
+    throw new Error("Failed to fetch a clang resource, run with DEBUG=electron-rebuild for more information");
+  d2("downloading:", url);
+  try {
+    const response = await globalThis.fetch(url);
+    if (!response.ok) {
+      d2("got bad status code:", response.status);
+      await sleep(2e3);
+      return fetchUrl(url, responseType, retries - 1);
+    }
+    d2("response came back OK");
+    if (responseType === "buffer") {
+      return Buffer.from(await response.arrayBuffer());
+    }
+    return await response.text();
+  } catch (err) {
+    d2("request failed for some reason", err);
+    await sleep(2e3);
+    return fetchUrl(url, responseType, retries - 1);
+  }
+}
+var import_debug2, d2;
+var init_fetcher = __esm({
+  "../../node_modules/@electron/rebuild/lib/fetcher.js"() {
+    "use strict";
+    import_debug2 = __toESM(require_src(), 1);
+    d2 = (0, import_debug2.default)("electron-rebuild");
+  }
+});
+
+// ../../node_modules/isexe/windows.js
+var require_windows = __commonJS({
+  "../../node_modules/isexe/windows.js"(exports, module) {
+    "use strict";
+    module.exports = isexe;
+    isexe.sync = sync;
+    var fs13 = __require("fs");
+    function checkPathExt(path15, options) {
+      var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
+      if (!pathext) {
+        return true;
+      }
+      pathext = pathext.split(";");
+      if (pathext.indexOf("") !== -1) {
+        return true;
+      }
+      for (var i = 0; i < pathext.length; i++) {
+        var p = pathext[i].toLowerCase();
+        if (p && path15.substr(-p.length).toLowerCase() === p) {
+          return true;
+        }
+      }
+      return false;
+    }
+    function checkStat(stat, path15, options) {
+      if (!stat.isSymbolicLink() && !stat.isFile()) {
+        return false;
+      }
+      return checkPathExt(path15, options);
+    }
+    function isexe(path15, options, cb) {
+      fs13.stat(path15, function(er, stat) {
+        cb(er, er ? false : checkStat(stat, path15, options));
+      });
+    }
+    function sync(path15, options) {
+      return checkStat(fs13.statSync(path15), path15, options);
+    }
+  }
+});
+
+// ../../node_modules/isexe/mode.js
+var require_mode = __commonJS({
+  "../../node_modules/isexe/mode.js"(exports, module) {
+    "use strict";
+    module.exports = isexe;
+    isexe.sync = sync;
+    var fs13 = __require("fs");
+    function isexe(path15, options, cb) {
+      fs13.stat(path15, function(er, stat) {
+        cb(er, er ? false : checkStat(stat, options));
+      });
+    }
+    function sync(path15, options) {
+      return checkStat(fs13.statSync(path15), options);
+    }
+    function checkStat(stat, options) {
+      return stat.isFile() && checkMode(stat, options);
+    }
+    function checkMode(stat, options) {
+      var mod = stat.mode;
+      var uid = stat.uid;
+      var gid = stat.gid;
+      var myUid = options.uid !== void 0 ? options.uid : process.getuid && process.getuid();
+      var myGid = options.gid !== void 0 ? options.gid : process.getgid && process.getgid();
+      var u = parseInt("100", 8);
+      var g = parseInt("010", 8);
+      var o = parseInt("001", 8);
+      var ug = u | g;
+      var ret = mod & o || mod & g && gid === myGid || mod & u && uid === myUid || mod & ug && myUid === 0;
+      return ret;
+    }
+  }
+});
+
+// ../../node_modules/isexe/index.js
+var require_isexe = __commonJS({
+  "../../node_modules/isexe/index.js"(exports, module) {
+    "use strict";
+    var fs13 = __require("fs");
+    var core;
+    if (process.platform === "win32" || global.TESTING_WINDOWS) {
+      core = require_windows();
+    } else {
+      core = require_mode();
+    }
+    module.exports = isexe;
+    isexe.sync = sync;
+    function isexe(path15, options, cb) {
+      if (typeof options === "function") {
+        cb = options;
+        options = {};
+      }
+      if (!cb) {
+        if (typeof Promise !== "function") {
+          throw new TypeError("callback not provided");
+        }
+        return new Promise(function(resolve, reject) {
+          isexe(path15, options || {}, function(er, is) {
+            if (er) {
+              reject(er);
+            } else {
+              resolve(is);
+            }
+          });
+        });
+      }
+      core(path15, options || {}, function(er, is) {
+        if (er) {
+          if (er.code === "EACCES" || options && options.ignoreErrors) {
+            er = null;
+            is = false;
+          }
+        }
+        cb(er, is);
+      });
+    }
+    function sync(path15, options) {
+      try {
+        return core.sync(path15, options || {});
+      } catch (er) {
+        if (options && options.ignoreErrors || er.code === "EACCES") {
+          return false;
+        } else {
+          throw er;
+        }
+      }
+    }
+  }
+});
+
+// ../../node_modules/which/which.js
+var require_which = __commonJS({
+  "../../node_modules/which/which.js"(exports, module) {
+    "use strict";
+    var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
+    var path15 = __require("path");
+    var COLON = isWindows ? ";" : ":";
+    var isexe = require_isexe();
+    var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
+    var getPathInfo = (cmd, opt) => {
+      const colon = opt.colon || COLON;
+      const pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? [""] : [
+        // windows always checks the cwd first
+        ...isWindows ? [process.cwd()] : [],
+        ...(opt.path || process.env.PATH || /* istanbul ignore next: very unusual */
+        "").split(colon)
+      ];
+      const pathExtExe = isWindows ? opt.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "";
+      const pathExt = isWindows ? pathExtExe.split(colon) : [""];
+      if (isWindows) {
+        if (cmd.indexOf(".") !== -1 && pathExt[0] !== "")
+          pathExt.unshift("");
+      }
+      return {
+        pathEnv,
+        pathExt,
+        pathExtExe
+      };
+    };
+    var which = (cmd, opt, cb) => {
+      if (typeof opt === "function") {
+        cb = opt;
+        opt = {};
+      }
+      if (!opt)
+        opt = {};
+      const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+      const found = [];
+      const step = (i) => new Promise((resolve, reject) => {
+        if (i === pathEnv.length)
+          return opt.all && found.length ? resolve(found) : reject(getNotFoundError(cmd));
+        const ppRaw = pathEnv[i];
+        const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+        const pCmd = path15.join(pathPart, cmd);
+        const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+        resolve(subStep(p, i, 0));
+      });
+      const subStep = (p, i, ii) => new Promise((resolve, reject) => {
+        if (ii === pathExt.length)
+          return resolve(step(i + 1));
+        const ext = pathExt[ii];
+        isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
+          if (!er && is) {
+            if (opt.all)
+              found.push(p + ext);
+            else
+              return resolve(p + ext);
+          }
+          return resolve(subStep(p, i, ii + 1));
+        });
+      });
+      return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
+    };
+    var whichSync = (cmd, opt) => {
+      opt = opt || {};
+      const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+      const found = [];
+      for (let i = 0; i < pathEnv.length; i++) {
+        const ppRaw = pathEnv[i];
+        const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+        const pCmd = path15.join(pathPart, cmd);
+        const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+        for (let j = 0; j < pathExt.length; j++) {
+          const cur = p + pathExt[j];
+          try {
+            const is = isexe.sync(cur, { pathExt: pathExtExe });
+            if (is) {
+              if (opt.all)
+                found.push(cur);
+              else
+                return cur;
+            }
+          } catch (ex) {
+          }
+        }
+      }
+      if (opt.all && found.length)
+        return found;
+      if (opt.nothrow)
+        return null;
+      throw getNotFoundError(cmd);
+    };
+    module.exports = which;
+    which.sync = whichSync;
+  }
+});
+
+// ../../node_modules/path-key/index.js
+var require_path_key = __commonJS({
+  "../../node_modules/path-key/index.js"(exports, module) {
+    "use strict";
+    var pathKey = (options = {}) => {
+      const environment = options.env || process.env;
+      const platform = options.platform || process.platform;
+      if (platform !== "win32") {
+        return "PATH";
+      }
+      return Object.keys(environment).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
+    };
+    module.exports = pathKey;
+    module.exports.default = pathKey;
+  }
+});
+
+// ../../node_modules/cross-spawn/lib/util/resolveCommand.js
+var require_resolveCommand = __commonJS({
+  "../../node_modules/cross-spawn/lib/util/resolveCommand.js"(exports, module) {
+    "use strict";
+    var path15 = __require("path");
+    var which = require_which();
+    var getPathKey = require_path_key();
+    function resolveCommandAttempt(parsed, withoutPathExt) {
+      const env = parsed.options.env || process.env;
+      const cwd = process.cwd();
+      const hasCustomCwd = parsed.options.cwd != null;
+      const shouldSwitchCwd = hasCustomCwd && process.chdir !== void 0 && !process.chdir.disabled;
+      if (shouldSwitchCwd) {
+        try {
+          process.chdir(parsed.options.cwd);
+        } catch (err) {
+        }
+      }
+      let resolved;
+      try {
+        resolved = which.sync(parsed.command, {
+          path: env[getPathKey({ env })],
+          pathExt: withoutPathExt ? path15.delimiter : void 0
+        });
+      } catch (e) {
+      } finally {
+        if (shouldSwitchCwd) {
+          process.chdir(cwd);
+        }
+      }
+      if (resolved) {
+        resolved = path15.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+      }
+      return resolved;
+    }
+    function resolveCommand(parsed) {
+      return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
+    }
+    module.exports = resolveCommand;
+  }
+});
+
+// ../../node_modules/cross-spawn/lib/util/escape.js
+var require_escape = __commonJS({
+  "../../node_modules/cross-spawn/lib/util/escape.js"(exports, module) {
+    "use strict";
+    var metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
+    function escapeCommand(arg) {
+      arg = arg.replace(metaCharsRegExp, "^$1");
+      return arg;
+    }
+    function escapeArgument(arg, doubleEscapeMetaChars) {
+      arg = `${arg}`;
+      arg = arg.replace(/(?=(\\+?)?)\1"/g, '$1$1\\"');
+      arg = arg.replace(/(?=(\\+?)?)\1$/, "$1$1");
+      arg = `"${arg}"`;
+      arg = arg.replace(metaCharsRegExp, "^$1");
+      if (doubleEscapeMetaChars) {
+        arg = arg.replace(metaCharsRegExp, "^$1");
+      }
+      return arg;
+    }
+    module.exports.command = escapeCommand;
+    module.exports.argument = escapeArgument;
+  }
+});
+
+// ../../node_modules/shebang-regex/index.js
+var require_shebang_regex = __commonJS({
+  "../../node_modules/shebang-regex/index.js"(exports, module) {
+    "use strict";
+    module.exports = /^#!(.*)/;
+  }
+});
+
+// ../../node_modules/shebang-command/index.js
+var require_shebang_command = __commonJS({
+  "../../node_modules/shebang-command/index.js"(exports, module) {
+    "use strict";
+    var shebangRegex = require_shebang_regex();
+    module.exports = (string = "") => {
+      const match = string.match(shebangRegex);
+      if (!match) {
+        return null;
+      }
+      const [path15, argument] = match[0].replace(/#! ?/, "").split(" ");
+      const binary = path15.split("/").pop();
+      if (binary === "env") {
+        return argument;
+      }
+      return argument ? `${binary} ${argument}` : binary;
+    };
+  }
+});
+
+// ../../node_modules/cross-spawn/lib/util/readShebang.js
+var require_readShebang = __commonJS({
+  "../../node_modules/cross-spawn/lib/util/readShebang.js"(exports, module) {
+    "use strict";
+    var fs13 = __require("fs");
+    var shebangCommand = require_shebang_command();
+    function readShebang(command) {
+      const size = 150;
+      const buffer = Buffer.alloc(size);
+      let fd;
+      try {
+        fd = fs13.openSync(command, "r");
+        fs13.readSync(fd, buffer, 0, size, 0);
+        fs13.closeSync(fd);
+      } catch (e) {
+      }
+      return shebangCommand(buffer.toString());
+    }
+    module.exports = readShebang;
+  }
+});
+
+// ../../node_modules/cross-spawn/lib/parse.js
+var require_parse = __commonJS({
+  "../../node_modules/cross-spawn/lib/parse.js"(exports, module) {
+    "use strict";
+    var path15 = __require("path");
+    var resolveCommand = require_resolveCommand();
+    var escape = require_escape();
+    var readShebang = require_readShebang();
+    var isWin = process.platform === "win32";
+    var isExecutableRegExp = /\.(?:com|exe)$/i;
+    var isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+    function detectShebang(parsed) {
+      parsed.file = resolveCommand(parsed);
+      const shebang = parsed.file && readShebang(parsed.file);
+      if (shebang) {
+        parsed.args.unshift(parsed.file);
+        parsed.command = shebang;
+        return resolveCommand(parsed);
+      }
+      return parsed.file;
+    }
+    function parseNonShell(parsed) {
+      if (!isWin) {
+        return parsed;
+      }
+      const commandFile = detectShebang(parsed);
+      const needsShell = !isExecutableRegExp.test(commandFile);
+      if (parsed.options.forceShell || needsShell) {
+        const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
+        parsed.command = path15.normalize(parsed.command);
+        parsed.command = escape.command(parsed.command);
+        parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
+        const shellCommand = [parsed.command].concat(parsed.args).join(" ");
+        parsed.args = ["/d", "/s", "/c", `"${shellCommand}"`];
+        parsed.command = process.env.comspec || "cmd.exe";
+        parsed.options.windowsVerbatimArguments = true;
+      }
+      return parsed;
+    }
+    function parse(command, args, options) {
+      if (args && !Array.isArray(args)) {
+        options = args;
+        args = null;
+      }
+      args = args ? args.slice(0) : [];
+      options = Object.assign({}, options);
+      const parsed = {
+        command,
+        args,
+        options,
+        file: void 0,
+        original: {
+          command,
+          args
+        }
+      };
+      return options.shell ? parsed : parseNonShell(parsed);
+    }
+    module.exports = parse;
+  }
+});
+
+// ../../node_modules/cross-spawn/lib/enoent.js
+var require_enoent = __commonJS({
+  "../../node_modules/cross-spawn/lib/enoent.js"(exports, module) {
+    "use strict";
+    var isWin = process.platform === "win32";
+    function notFoundError(original, syscall) {
+      return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
+        code: "ENOENT",
+        errno: "ENOENT",
+        syscall: `${syscall} ${original.command}`,
+        path: original.command,
+        spawnargs: original.args
+      });
+    }
+    function hookChildProcess(cp2, parsed) {
+      if (!isWin) {
+        return;
+      }
+      const originalEmit = cp2.emit;
+      cp2.emit = function(name, arg1) {
+        if (name === "exit") {
+          const err = verifyENOENT(arg1, parsed);
+          if (err) {
+            return originalEmit.call(cp2, "error", err);
+          }
+        }
+        return originalEmit.apply(cp2, arguments);
+      };
+    }
+    function verifyENOENT(status, parsed) {
+      if (isWin && status === 1 && !parsed.file) {
+        return notFoundError(parsed.original, "spawn");
+      }
+      return null;
+    }
+    function verifyENOENTSync(status, parsed) {
+      if (isWin && status === 1 && !parsed.file) {
+        return notFoundError(parsed.original, "spawnSync");
+      }
+      return null;
+    }
+    module.exports = {
+      hookChildProcess,
+      verifyENOENT,
+      verifyENOENTSync,
+      notFoundError
+    };
+  }
+});
+
+// ../../node_modules/cross-spawn/index.js
+var require_cross_spawn = __commonJS({
+  "../../node_modules/cross-spawn/index.js"(exports, module) {
+    "use strict";
+    var cp2 = __require("child_process");
+    var parse = require_parse();
+    var enoent = require_enoent();
+    function spawn5(command, args, options) {
+      const parsed = parse(command, args, options);
+      const spawned = cp2.spawn(parsed.command, parsed.args, parsed.options);
+      enoent.hookChildProcess(spawned, parsed);
+      return spawned;
+    }
+    function spawnSync(command, args, options) {
+      const parsed = parse(command, args, options);
+      const result = cp2.spawnSync(parsed.command, parsed.args, parsed.options);
+      result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
+      return result;
+    }
+    module.exports = spawn5;
+    module.exports.spawn = spawn5;
+    module.exports.sync = spawnSync;
+    module.exports._parse = parse;
+    module.exports._enoent = enoent;
+  }
+});
+
+// ../../node_modules/@malept/cross-spawn-promise/dist/src/index.js
+var require_src2 = __commonJS({
+  "../../node_modules/@malept/cross-spawn-promise/dist/src/index.js"(exports) {
+    "use strict";
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.spawn = exports.ExitSignalError = exports.ExitCodeError = exports.ExitError = exports.CrossSpawnError = void 0;
+    var cross_spawn_1 = __importDefault(require_cross_spawn());
+    function stringifyCommand(cmd, args) {
+      if (args && Array.isArray(args) && args.length > 0) {
+        return `${cmd} ${args.join(" ")}`;
+      } else {
+        return cmd;
+      }
+    }
+    var CrossSpawnError = class extends Error {
+      constructor(cmd, args, originalError, stderr) {
+        const fullCommand = stringifyCommand(cmd, args);
+        const errorMessage = originalError.message || originalError;
+        super(`Error executing command (${fullCommand}):
+${errorMessage}
+${stderr}`.trim());
+        this.originalError = originalError;
+      }
+    };
+    exports.CrossSpawnError = CrossSpawnError;
+    var ExitError = class extends Error {
+      constructor(cmd, args, message, stdout, stderr) {
+        super(message);
+        this.cmd = cmd;
+        this.args = args;
+        this.stdout = stdout;
+        this.stderr = stderr;
+      }
+    };
+    exports.ExitError = ExitError;
+    var ExitCodeError = class extends ExitError {
+      constructor(cmd, args, code, stdout, stderr) {
+        const fullCommand = stringifyCommand(cmd, args);
+        super(cmd, args, `Command failed with a non-zero return code (${code}):
+${fullCommand}
+${stdout}
+${stderr}`.trim(), stdout, stderr);
+        this.code = code;
+      }
+    };
+    exports.ExitCodeError = ExitCodeError;
+    var ExitSignalError = class extends ExitError {
+      constructor(cmd, args, signal, stdout, stderr) {
+        const fullCommand = stringifyCommand(cmd, args);
+        super(cmd, args, `Command terminated via a signal (${signal}):
+${fullCommand}
+${stdout}
+${stderr}`.trim(), stdout, stderr);
+        this.signal = signal;
+      }
+    };
+    exports.ExitSignalError = ExitSignalError;
+    async function spawn5(cmd, args, options) {
+      if (!options) {
+        options = {};
+      }
+      const { logger, updateErrorCallback, ...spawnOptions } = options;
+      if (logger)
+        logger(`Executing command ${stringifyCommand(cmd, args)}`);
+      return new Promise((resolve, reject) => {
+        let stdout = "";
+        let stderr = "";
+        const process2 = cross_spawn_1.default(cmd, args, spawnOptions);
+        if (process2.stdout) {
+          process2.stdout.on("data", (data) => {
+            stdout += data.toString();
+          });
+        }
+        if (process2.stderr) {
+          process2.stderr.on(
+            "data",
+            /* istanbul ignore next */
+            (data) => {
+              stderr += data.toString();
+            }
+          );
+        }
+        process2.on("close", (code, signal) => {
+          if (code === 0) {
+            resolve(stdout);
+          } else if (code === null) {
+            reject(new ExitSignalError(cmd, args, signal, stdout, stderr));
+          } else {
+            reject(new ExitCodeError(cmd, args, code, stdout, stderr));
+          }
+        });
+        process2.on("error", (err) => {
+          if (updateErrorCallback) {
+            updateErrorCallback(err, !!logger);
+          }
+          reject(new CrossSpawnError(cmd, args, err, stderr));
+        });
+      });
+    }
+    exports.spawn = spawn5;
+  }
+});
+
+// ../../node_modules/@electron/rebuild/lib/sysroot-fetcher.js
+import crypto2 from "crypto";
+import fs3 from "fs";
+import path4 from "path";
+async function downloadLinuxSysroot(electronVersion, targetArch) {
+  d3("fetching sysroot for Electron:", electronVersion);
+  const sysrootDir = path4.resolve(ELECTRON_GYP_DIR, `${electronVersion}-sysroot`);
+  if (fs3.existsSync(path4.resolve(sysrootDir, "lib")))
+    return sysrootDir;
+  await fs3.promises.mkdir(sysrootDir, { recursive: true });
+  const linuxArch = sysrootArchAliases[targetArch] || targetArch;
+  const electronSysroots = JSON.parse(await fetchUrl(`https://raw.githubusercontent.com/electron/electron/v${electronVersion}/script/sysroots.json`, "text"));
+  const { Sha1Sum: sha, Tarball: fileName } = electronSysroots[`sid_${linuxArch}`] || electronSysroots[`bullseye_${linuxArch}`];
+  const sysrootURL = `${SYSROOT_BASE_URL}/${sha}/${fileName}`;
+  const sysrootBuffer = await fetchUrl(sysrootURL, "buffer");
+  const actualSha = crypto2.createHash("SHA1").update(sysrootBuffer).digest("hex");
+  d3("expected sha:", sha);
+  d3("actual sha:", actualSha);
+  if (sha !== actualSha)
+    throw new Error(`Attempted to download the linux sysroot for ${electronVersion} but the SHA checksum did not match`);
+  d3("writing sysroot to disk");
+  const tmpTarFile = path4.resolve(ELECTRON_GYP_DIR, `${electronVersion}-${fileName}`);
+  if (fs3.existsSync(tmpTarFile))
+    await fs3.promises.rm(tmpTarFile, { recursive: true, force: true });
+  await fs3.promises.writeFile(tmpTarFile, sysrootBuffer);
+  d3("decompressing sysroot");
+  await (0, import_cross_spawn_promise.spawn)("tar", ["-xf", tmpTarFile, "-C", sysrootDir], { stdio: "ignore" });
+  return sysrootDir;
+}
+var import_debug3, import_cross_spawn_promise, d3, sysrootArchAliases, SYSROOT_BASE_URL;
+var init_sysroot_fetcher = __esm({
+  "../../node_modules/@electron/rebuild/lib/sysroot-fetcher.js"() {
+    "use strict";
+    import_debug3 = __toESM(require_src(), 1);
+    init_constants();
+    init_fetcher();
+    import_cross_spawn_promise = __toESM(require_src2(), 1);
+    d3 = (0, import_debug3.default)("electron-rebuild");
+    sysrootArchAliases = {
+      x64: "amd64",
+      ia32: "i386"
+    };
+    SYSROOT_BASE_URL = "https://dev-cdn.electronjs.org/linux-sysroots";
+  }
+});
+
+// ../../node_modules/@electron/rebuild/lib/clang-fetcher.js
+import cp from "child_process";
+import fs4 from "fs";
+import path5 from "path";
+function getPlatformUrlPrefix(hostOS, hostArch) {
+  const prefixMap = {
+    linux: "Linux_x64",
+    darwin: "Mac",
+    win32: "Win"
+  };
+  let prefix = prefixMap[hostOS];
+  if (prefix === "Mac" && hostArch === "arm64") {
+    prefix = "Mac_arm64";
+  }
+  return CDS_URL + "/" + prefix + "/";
+}
+function getClangDownloadURL(packageFile, packageVersion, hostOS, hostArch) {
+  const cdsFile = `${packageFile}-${packageVersion}.tgz`;
+  return getPlatformUrlPrefix(hostOS, hostArch) + cdsFile;
+}
+function getSDKRoot() {
+  if (process.env.SDKROOT)
+    return process.env.SDKROOT;
+  const output = cp.execFileSync("xcrun", ["--sdk", "macosx", "--show-sdk-path"]);
+  return output.toString().trim();
+}
+async function getClangEnvironmentVars(electronVersion, targetArch) {
+  const clangDownloadDir = await downloadClangVersion(electronVersion);
+  const clangDir = path5.resolve(clangDownloadDir, "bin");
+  const clangArgs = [];
+  if (process.platform === "darwin") {
+    clangArgs.push("-isysroot", getSDKRoot());
+  }
+  const gypArgs = [];
+  if (process.platform === "win32") {
+    console.log(await fs4.promises.readdir(clangDir));
+    gypArgs.push(`/p:CLToolExe=clang-cl.exe`, `/p:CLToolPath=${clangDir}`);
+  }
+  if (process.platform === "linux") {
+    const sysrootPath = await downloadLinuxSysroot(electronVersion, targetArch);
+    clangArgs.push("--sysroot", sysrootPath);
+  }
+  return {
+    env: {
+      CC: `"${path5.resolve(clangDir, "clang")}" ${clangArgs.join(" ")}`,
+      CXX: `"${path5.resolve(clangDir, "clang++")}" ${clangArgs.join(" ")}`
+    },
+    args: gypArgs
+  };
+}
+function clangVersionFromRevision(update) {
+  const regex = /CLANG_REVISION = '([^']+)'\nCLANG_SUB_REVISION = (\d+)\n/g;
+  const clangVersionMatch = regex.exec(update);
+  if (!clangVersionMatch)
+    return null;
+  const [, clangVersion, clangSubRevision] = clangVersionMatch;
+  return `${clangVersion}-${clangSubRevision}`;
+}
+function clangVersionFromSVN(update) {
+  const regex = /CLANG_REVISION = '([^']+)'\nCLANG_SVN_REVISION = '([^']+)'\nCLANG_SUB_REVISION = (\d+)\n/g;
+  const clangVersionMatch = regex.exec(update);
+  if (!clangVersionMatch)
+    return null;
+  const [, clangVersion, clangSvn, clangSubRevision] = clangVersionMatch;
+  return `${clangSvn}-${clangVersion.substr(0, 8)}-${clangSubRevision}`;
+}
+async function downloadClangVersion(electronVersion) {
+  d4("fetching clang for Electron:", electronVersion);
+  const clangDirPath = path5.resolve(ELECTRON_GYP_DIR, `${electronVersion}-clang`);
+  if (fs4.existsSync(path5.resolve(clangDirPath, "bin", "clang")))
+    return clangDirPath;
+  await fs4.promises.mkdir(ELECTRON_GYP_DIR, { recursive: true });
+  const electronDeps = await fetchUrl(`https://raw.githubusercontent.com/electron/electron/v${electronVersion}/DEPS`, "text");
+  const chromiumRevisionExtractor = /'chromium_version':\n\s+'([^']+)/g;
+  const chromiumRevisionMatch = chromiumRevisionExtractor.exec(electronDeps);
+  if (!chromiumRevisionMatch)
+    throw new Error("Failed to determine Chromium revision for given Electron version");
+  const chromiumRevision = chromiumRevisionMatch[1];
+  d4("fetching clang for Chromium:", chromiumRevision);
+  const base64ClangUpdate = await fetchUrl(`https://chromium.googlesource.com/chromium/src.git/+/${chromiumRevision}/tools/clang/scripts/update.py?format=TEXT`, "text");
+  const clangUpdate = Buffer.from(base64ClangUpdate, "base64").toString("utf8");
+  const clangVersionString = clangVersionFromRevision(clangUpdate) || clangVersionFromSVN(clangUpdate);
+  if (!clangVersionString)
+    throw new Error("Failed to determine Clang revision from Electron version");
+  d4("fetching clang:", clangVersionString);
+  const clangDownloadURL = getClangDownloadURL("clang", clangVersionString, process.platform, process.arch);
+  const contents = await fetchUrl(clangDownloadURL, "buffer");
+  const tarPath = path5.resolve(ELECTRON_GYP_DIR, `${electronVersion}-clang.tgz`);
+  if (fs4.existsSync(tarPath))
+    await fs4.promises.rm(tarPath, { recursive: true, force: true });
+  await fs4.promises.writeFile(tarPath, contents);
+  await fs4.promises.mkdir(clangDirPath, { recursive: true });
+  d4("extracting clang");
+  await (0, import_cross_spawn_promise2.spawn)("tar", ["-xf", tarPath, "-C", clangDirPath], { stdio: "ignore" });
+  await fs4.promises.rm(tarPath, { recursive: true, force: true });
+  d4("cleaning up clang tar file");
+  return clangDirPath;
+}
+var import_debug4, import_cross_spawn_promise2, d4, CDS_URL;
+var init_clang_fetcher = __esm({
+  "../../node_modules/@electron/rebuild/lib/clang-fetcher.js"() {
+    "use strict";
+    import_debug4 = __toESM(require_src(), 1);
+    init_constants();
+    init_fetcher();
+    init_sysroot_fetcher();
+    import_cross_spawn_promise2 = __toESM(require_src2(), 1);
+    d4 = (0, import_debug4.default)("electron-rebuild");
+    CDS_URL = "https://commondatastorage.googleapis.com/chromium-browser-clang";
+  }
+});
+
+// ../../node_modules/node-api-version/index.js
+var require_node_api_version = __commonJS({
+  "../../node_modules/node-api-version/index.js"(exports) {
+    "use strict";
+    var semver3 = require_semver();
+    var nodeApiVersionRanges = [
+      [">=24 || ^22.14 || ^23.6", 10],
+      [">=21 || ^18.17 || ^20.3", 9],
+      [">=16 || ^15.12 || ^12.22", 8],
+      [">=15 || ^14.12 || ^12.19 || ^10.23", 7],
+      [">=14 || ^12.17 || ^10.20", 6],
+      [">=13 || ^12.11 || ^10.17", 5],
+      [">=12 || ^11.8 || ^10.16", 4],
+      [">=10", 3]
+    ];
+    function fromNodeVersion(nodeVersion) {
+      for (const [range, version] of nodeApiVersionRanges) {
+        if (semver3.satisfies(nodeVersion, range)) {
+          return version;
+        }
+      }
+      return void 0;
+    }
+    exports.fromNodeVersion = fromNodeVersion;
+    var electronNapiVersions = (
+      // replace-start
+      [
+        ["35.0.0-beta.8", 10],
+        ["35.0.0-alpha.1", 8],
+        ["27.0.0-alpha.1", 9],
+        ["15.0.0-alpha.1", 8],
+        ["12.0.0-beta.1", 7],
+        ["11.0.0-beta.1", 6],
+        ["8.0.0-beta.1", 5],
+        ["5.0.0-beta.1", 4],
+        ["3.0.0-beta.1", 3]
+      ]
+    );
+    function fromElectronVersion(electronVersion) {
+      for (const [change, version] of electronNapiVersions) {
+        if (semver3.gte(electronVersion, change)) {
+          return version;
+        }
+      }
+      return void 0;
+    }
+    exports.fromElectronVersion = fromElectronVersion;
+  }
+});
+
+// ../../node_modules/@electron/rebuild/lib/node-api.js
+var import_node_api_version, NodeAPI;
+var init_node_api = __esm({
+  "../../node_modules/@electron/rebuild/lib/node-api.js"() {
+    "use strict";
+    import_node_api_version = __toESM(require_node_api_version(), 1);
+    NodeAPI = class {
+      moduleName;
+      electronVersion;
+      constructor(moduleName, electronVersion) {
+        this.moduleName = moduleName;
+        this.electronVersion = electronVersion;
+      }
+      ensureElectronSupport() {
+        this.getVersionForElectron();
+      }
+      getVersionForElectron() {
+        const electronNapiVersion = (0, import_node_api_version.fromElectronVersion)(this.electronVersion);
+        if (!electronNapiVersion) {
+          throw new Error(`Native module '${this.moduleName}' requires Node-API but Electron v${this.electronVersion} does not support Node-API`);
+        }
+        return electronNapiVersion;
+      }
+      getNapiVersion(moduleNapiVersions) {
+        const electronNapiVersion = this.getVersionForElectron();
+        const filteredVersions = moduleNapiVersions.filter((v) => v <= electronNapiVersion);
+        if (filteredVersions.length === 0) {
+          throw new Error(`Native module '${this.moduleName}' supports Node-API versions ${moduleNapiVersions.join(", ")} but Electron v${this.electronVersion} only supports Node-API v${electronNapiVersion}`);
+        }
+        return Math.max(...filteredVersions);
+      }
+    };
+  }
+});
+
+// ../../node_modules/@electron/rebuild/lib/read-package-json.js
+import fs5 from "fs/promises";
+import path6 from "path";
+async function readPackageJson(dir, safe = false) {
+  try {
+    return JSON.parse(await fs5.readFile(path6.resolve(dir, "package.json"), {
+      encoding: "utf-8"
+    }));
+  } catch (err) {
+    if (safe) {
+      return {};
+    } else {
+      throw err;
+    }
+  }
+}
+var init_read_package_json = __esm({
+  "../../node_modules/@electron/rebuild/lib/read-package-json.js"() {
+    "use strict";
+  }
+});
+
+// ../../node_modules/@electron/rebuild/lib/module-type/index.js
+import fs6 from "fs";
+import path7 from "path";
+async function locateBinary(basePath, suffix) {
+  let parentPath = basePath;
+  let testPath;
+  while (testPath !== parentPath) {
+    testPath = parentPath;
+    const checkPath = path7.resolve(testPath, suffix);
+    if (fs6.existsSync(checkPath)) {
+      return checkPath;
+    }
+    parentPath = path7.resolve(testPath, "..");
+  }
+  return null;
+}
+var NativeModule;
+var init_module_type = __esm({
+  "../../node_modules/@electron/rebuild/lib/module-type/index.js"() {
+    "use strict";
+    init_node_api();
+    init_read_package_json();
+    NativeModule = class {
+      rebuilder;
+      _moduleName;
+      modulePath;
+      nodeAPI;
+      packageJSON;
+      constructor(rebuilder, modulePath) {
+        this.rebuilder = rebuilder;
+        this.modulePath = modulePath;
+        this.nodeAPI = new NodeAPI(this.moduleName, this.rebuilder.electronVersion);
+      }
+      get moduleName() {
+        if (!this._moduleName) {
+          const basename = path7.basename(this.modulePath);
+          const parentDir = path7.basename(path7.dirname(this.modulePath));
+          if (parentDir.startsWith("@")) {
+            this._moduleName = `${parentDir}/${basename}`;
+          }
+          this._moduleName = basename;
+        }
+        return this._moduleName;
+      }
+      async packageJSONFieldWithDefault(key, defaultValue) {
+        const result = await this.packageJSONField(key);
+        return result === void 0 ? defaultValue : result;
+      }
+      async packageJSONField(key) {
+        this.packageJSON ||= await readPackageJson(this.modulePath);
+        return this.packageJSON[key];
+      }
+      async getSupportedNapiVersions() {
+        const binary = await this.packageJSONFieldWithDefault("binary", {});
+        return binary?.napi_versions;
+      }
+      /**
+       * Search dependencies for package using either `packageName` or
+       * `@namespace/packageName` in the case of forks.
+       */
+      async findPackageInDependencies(packageName, packageProperty = "dependencies") {
+        const dependencies = await this.packageJSONFieldWithDefault(packageProperty, {});
+        if (typeof dependencies !== "object")
+          return null;
+        if (dependencies.hasOwnProperty(packageName))
+          return packageName;
+        const forkedPackage = Object.keys(dependencies).find((dependency) => dependency.startsWith("@") && dependency.endsWith(`/${packageName}`));
+        return forkedPackage || null;
+      }
+    };
+  }
+});
+
+// ../../node_modules/@electron/rebuild/lib/detect-libc.js
+function detectLibcFamily() {
+  if (cached !== void 0)
+    return cached;
+  if (process.platform !== "linux")
+    return cached = null;
+  const report = process.report?.getReport();
+  if (report?.header?.glibcVersionRuntime)
+    return cached = "glibc";
+  if (Array.isArray(report?.sharedObjects) && report.sharedObjects.some((s) => s.includes("libc.musl") || s.includes("ld-musl"))) {
+    return cached = "musl";
+  }
+  return cached = null;
+}
+var cached;
+var init_detect_libc = __esm({
+  "../../node_modules/@electron/rebuild/lib/detect-libc.js"() {
+    "use strict";
+  }
+});
+
+// ../../node_modules/@electron/rebuild/lib/module-type/node-gyp/node-gyp.js
+import { fork } from "child_process";
+import path8 from "path";
+var import_debug5, d5, NodeGyp;
+var init_node_gyp = __esm({
+  "../../node_modules/@electron/rebuild/lib/module-type/node-gyp/node-gyp.js"() {
+    "use strict";
+    import_debug5 = __toESM(require_src(), 1);
+    init_constants();
+    init_clang_fetcher();
+    init_module_type();
+    init_detect_libc();
+    d5 = (0, import_debug5.default)("electron-rebuild");
+    NodeGyp = class extends NativeModule {
+      async buildArgs(prefixedArgs) {
+        const args = [
+          "node",
+          "node-gyp",
+          "rebuild",
+          ...prefixedArgs,
+          `--runtime=electron`,
+          `--target=${this.rebuilder.electronVersion}`,
+          `--arch=${this.rebuilder.arch}`,
+          `--dist-url=${this.rebuilder.headerURL}`,
+          "--build-from-source"
+        ];
+        args.push(d5.enabled ? "--verbose" : "--silent");
+        if (this.rebuilder.debug) {
+          args.push("--debug");
+        }
+        args.push(...await this.buildArgsFromBinaryField());
+        if (this.rebuilder.msvsVersion) {
+          args.push(`--msvs_version=${this.rebuilder.msvsVersion}`);
+        }
+        if (this.rebuilder.jobs) {
+          args.push(`--jobs=${this.rebuilder.jobs}`);
+        }
+        const [maj, min] = this.rebuilder.electronVersion.split(".").map(Number);
+        if (maj < 14 || maj === 14 && min < 2 || maj === 15 && min < 3) {
+          args.push("--force-process-config");
+        }
+        return args;
+      }
+      async buildArgsFromBinaryField() {
+        const binary = await this.packageJSONFieldWithDefault("binary", {});
+        let napiBuildVersion = void 0;
+        if (Array.isArray(binary.napi_versions)) {
+          napiBuildVersion = this.nodeAPI.getNapiVersion(binary.napi_versions.map((str) => Number(str)));
+        }
+        const flags = await Promise.all(Object.entries(binary).map(async ([binaryKey, binaryValue]) => {
+          if (binaryKey === "napi_versions") {
+            return;
+          }
+          let value = binaryValue;
+          if (binaryKey === "module_path") {
+            value = path8.resolve(this.modulePath, value);
+          }
+          value = value.replace("{configuration}", this.rebuilder.buildType).replace("{node_abi}", `electron-v${this.rebuilder.electronVersion.split(".").slice(0, 2).join(".")}`).replace("{platform}", this.rebuilder.platform).replace("{arch}", this.rebuilder.arch).replace("{version}", await this.packageJSONField("version")).replace("{libc}", detectLibcFamily() || "unknown");
+          if (napiBuildVersion !== void 0) {
+            value = value.replace("{napi_build_version}", napiBuildVersion.toString());
+          }
+          for (const [replaceKey, replaceValue] of Object.entries(binary)) {
+            value = value.replace(`{${replaceKey}}`, replaceValue);
+          }
+          return `--${binaryKey}=${value}`;
+        }));
+        return flags.filter((value) => value);
+      }
+      async rebuildModule() {
+        if (this.rebuilder.platform !== process.platform) {
+          throw new Error("node-gyp does not support cross-compiling native modules from source.");
+        }
+        if (this.modulePath.includes(" ")) {
+          console.error("Attempting to build a module with a space in the path");
+          console.error("See https://github.com/nodejs/node-gyp/issues/65#issuecomment-368820565 for reasons why this may not work");
+        }
+        const env = {
+          ...process.env
+        };
+        const extraNodeGypArgs = [];
+        if (this.rebuilder.useElectronClang) {
+          const { env: clangEnv, args: clangArgs } = await getClangEnvironmentVars(this.rebuilder.electronVersion, this.rebuilder.arch);
+          Object.assign(env, clangEnv);
+          extraNodeGypArgs.push(...clangArgs);
+        }
+        const nodeGypArgs = await this.buildArgs(extraNodeGypArgs);
+        d5("rebuilding", this.moduleName, "with args", nodeGypArgs);
+        const forkedChild = fork(path8.resolve(import.meta.dirname, "worker.js"), {
+          env,
+          cwd: this.modulePath,
+          stdio: "pipe"
+        });
+        const outputBuffers = [];
+        forkedChild.stdout?.on("data", (chunk) => {
+          outputBuffers.push(chunk);
+        });
+        forkedChild.stderr?.on("data", (chunk) => {
+          outputBuffers.push(chunk);
+        });
+        forkedChild.send({
+          moduleName: this.moduleName,
+          nodeGypArgs,
+          extraNodeGypArgs,
+          devDir: this.rebuilder.mode === "sequential" ? ELECTRON_GYP_DIR : path8.resolve(ELECTRON_GYP_DIR, "_p", this.moduleName)
+        });
+        await new Promise((resolve, reject) => {
+          forkedChild.on("exit", (code) => {
+            if (code === 0)
+              return resolve();
+            console.error(Buffer.concat(outputBuffers).toString());
+            reject(new Error(`node-gyp failed to rebuild '${this.modulePath}'`));
+          });
+        });
+      }
+    };
+  }
+});
+
+// ../../node_modules/@electron/rebuild/lib/arch.js
+import { execSync } from "child_process";
+function uname() {
+  return execSync("uname -m").toString().trim();
+}
+function getNodeArch(arch, configVariables) {
+  if (arch === "arm") {
+    switch (configVariables.arm_version) {
+      case "6":
+        return uname();
+      case "7":
+      default:
+        return "armv7l";
+    }
+  }
+  return arch;
+}
+var init_arch = __esm({
+  "../../node_modules/@electron/rebuild/lib/arch.js"() {
+    "use strict";
+  }
+});
+
+// ../../node_modules/@electron/rebuild/lib/module-type/prebuildify.js
+import fs7 from "fs";
+import path9 from "path";
+function determineNativePrebuildArch(arch) {
+  if (arch === "armv7l") {
+    return "arm";
+  }
+  return arch;
+}
+function determineNativePrebuildExtension(arch) {
+  switch (arch) {
+    case "arm64":
+      return "armv8.node";
+    case "armv7l":
+      return "armv7.node";
+  }
+  return "node";
+}
+var import_debug6, d6, Prebuildify;
+var init_prebuildify = __esm({
+  "../../node_modules/@electron/rebuild/lib/module-type/prebuildify.js"() {
+    "use strict";
+    import_debug6 = __toESM(require_src(), 1);
+    init_arch();
+    init_module_type();
+    d6 = (0, import_debug6.default)("electron-rebuild");
+    Prebuildify = class extends NativeModule {
+      async usesTool() {
+        const packageName = await this.findPackageInDependencies("prebuildify", "devDependencies");
+        return !!packageName;
+      }
+      async findPrebuiltModule() {
+        d6(`Checking for prebuilds for "${this.moduleName}"`);
+        const prebuildsDir = path9.join(this.modulePath, "prebuilds");
+        if (!fs7.existsSync(prebuildsDir)) {
+          d6(`Could not find the prebuilds directory at "${prebuildsDir}"`);
+          return false;
+        }
+        const nodeArch = getNodeArch(this.rebuilder.arch, process.config.variables);
+        const prebuiltModuleDir = path9.join(prebuildsDir, `${this.rebuilder.platform}-${determineNativePrebuildArch(nodeArch)}`);
+        const nativeExt = determineNativePrebuildExtension(nodeArch);
+        const electronNapiModuleFilename = path9.join(prebuiltModuleDir, `electron.napi.${nativeExt}`);
+        const nodejsNapiModuleFilename = path9.join(prebuiltModuleDir, `node.napi.${nativeExt}`);
+        const abiModuleFilename = path9.join(prebuiltModuleDir, `electron.abi${this.rebuilder.ABI}.${nativeExt}`);
+        if (fs7.existsSync(electronNapiModuleFilename) || fs7.existsSync(nodejsNapiModuleFilename)) {
+          this.nodeAPI.ensureElectronSupport();
+          d6(`Found prebuilt Node-API module in ${prebuiltModuleDir}"`);
+        } else if (fs7.existsSync(abiModuleFilename)) {
+          d6(`Found prebuilt module: "${abiModuleFilename}"`);
+        } else {
+          d6(`Could not locate "${electronNapiModuleFilename}", "${nodejsNapiModuleFilename}", or "${abiModuleFilename}"`);
+          return false;
+        }
+        return true;
+      }
+    };
+  }
+});
+
+// ../../node_modules/@electron/rebuild/lib/module-type/prebuild-install.js
+import fs8 from "fs";
+import path10 from "path";
+var import_debug7, import_cross_spawn_promise3, d7, PrebuildInstall;
+var init_prebuild_install = __esm({
+  "../../node_modules/@electron/rebuild/lib/module-type/prebuild-install.js"() {
+    "use strict";
+    import_debug7 = __toESM(require_src(), 1);
+    init_module_type();
+    import_cross_spawn_promise3 = __toESM(require_src2(), 1);
+    d7 = (0, import_debug7.default)("electron-rebuild");
+    PrebuildInstall = class extends NativeModule {
+      async usesTool() {
+        const packageName = await this.findPackageInDependencies("prebuild-install");
+        return !!packageName;
+      }
+      async locateBinary() {
+        const packageName = await this.findPackageInDependencies("prebuild-install");
+        if (!packageName)
+          return null;
+        return locateBinary(this.modulePath, `node_modules/${packageName}/bin.js`);
+      }
+      async run(prebuildInstallPath) {
+        await (0, import_cross_spawn_promise3.spawn)(process.execPath, [
+          path10.resolve(import.meta.dirname, "..", `prebuild-shim.js`),
+          prebuildInstallPath,
+          `--arch=${this.rebuilder.arch}`,
+          `--platform=${this.rebuilder.platform}`,
+          `--tag-prefix=${this.rebuilder.prebuildTagPrefix}`,
+          ...await this.getPrebuildInstallRuntimeArgs()
+        ], {
+          cwd: this.modulePath
+        });
+      }
+      async findPrebuiltModule() {
+        const prebuildInstallPath = await this.locateBinary();
+        if (prebuildInstallPath) {
+          d7(`triggering prebuild download step: ${this.moduleName}`);
+          try {
+            await this.run(prebuildInstallPath);
+            return true;
+          } catch (err) {
+            d7("failed to use prebuild-install:", err);
+            if (err?.message?.includes("requires Node-API but Electron")) {
+              throw err;
+            }
+          }
+        } else {
+          d7(`could not find prebuild-install relative to: ${this.modulePath}`);
+        }
+        return false;
+      }
+      /**
+       * Whether a prebuild-install-based native module exists.
+       */
+      async prebuiltModuleExists() {
+        return fs8.existsSync(path10.resolve(this.modulePath, "prebuilds", `${this.rebuilder.platform}-${this.rebuilder.arch}`, `electron-${this.rebuilder.ABI}.node`));
+      }
+      async getPrebuildInstallRuntimeArgs() {
+        const moduleNapiVersions = await this.getSupportedNapiVersions();
+        if (moduleNapiVersions) {
+          const napiVersion = this.nodeAPI.getNapiVersion(moduleNapiVersions);
+          return ["--runtime=napi", `--target=${napiVersion}`];
+        } else {
+          return ["--runtime=electron", `--target=${this.rebuilder.electronVersion}`];
+        }
+      }
+    };
+  }
+});
+
+// ../../node_modules/read-binary-file-arch/index.js
+var require_read_binary_file_arch = __commonJS({
+  "../../node_modules/read-binary-file-arch/index.js"(exports, module) {
+    "use strict";
+    var { promisify } = __require("util");
+    var { exec } = __require("child_process");
+    var { promises: fs13 } = __require("fs");
+    var execAsync = promisify(exec);
+    var debug12 = require_src()("read-binary-file-arch");
+    var SUPPORTED_ARCH = [
+      "arm",
+      "arm64",
+      "ia32",
+      "loong64",
+      "mips",
+      "mipsel",
+      "ppc",
+      "ppc64",
+      "riscv64",
+      "s390",
+      "s390x",
+      "x64"
+    ];
+    async function readPEArch(filePath) {
+      const DOS_HEADER_PE_OFFSET = 60;
+      const COFF_HEADER_MACHINE_OFFSET = 4;
+      const BUFFER_SIZE = 1024;
+      const buffer = Buffer.alloc(BUFFER_SIZE);
+      const fileHandle = await fs13.open(filePath, "r");
+      await fileHandle.read(buffer, 0, BUFFER_SIZE, 0);
+      const peOffset = buffer.readUInt32LE(DOS_HEADER_PE_OFFSET);
+      let machineType;
+      try {
+        machineType = buffer.readUInt16LE(
+          peOffset + COFF_HEADER_MACHINE_OFFSET
+        );
+      } catch (error) {
+        debug12("read error:", error.message);
+        throw new Error("Invalid PE file");
+      }
+      const MACHINE_TYPES = {
+        332: "ia32",
+        34404: "x64",
+        448: "arm",
+        452: "arm",
+        // ARMv7 Thumb-2 LE
+        43620: "arm64"
+      };
+      const arch = MACHINE_TYPES[machineType];
+      debug12("win32 arch:", arch);
+      await fileHandle.close();
+      return arch;
+    }
+    async function getArchUsingFileCommand(filePath) {
+      const { stdout } = await execAsync(`file "${filePath}"`);
+      const output = stdout.trim();
+      debug12("file command output:", output);
+      const resultStart = filePath.length + 1;
+      const result = output.substring(resultStart).trim();
+      debug12("result:", result);
+      const FILE_ARCH = {
+        x64: "x64",
+        "x86-64": "x64",
+        x86_64: "x64",
+        x86: "ia32",
+        i386: "ia32",
+        arm64: "arm64",
+        arm: "arm",
+        aarch64: "arm64",
+        ARMv7: "arm",
+        ppc_7400: "ppc",
+        // PE32 executable (console) Intel 80386, for MS Windows
+        "Intel 80386": "ia32",
+        // ELF 64-bit LSB executable, IA-64, version 1 (SYSV), dynamically linked, interpreter /lib/ld-linux-ia64.so.2, for GNU/Linux 2.6.16
+        "IA-64": "x64",
+        // ELF 32-bit MSB executable, PowerPC or cisco 4500, version 1 (SYSV), dynamically linked, interpreter /lib/ld.so.1, for GNU/Linux 2.6.32
+        PowerPC: "ppc",
+        // ELF 32-bit MSB executable, MIPS, MIPS-IV version 1 (SYSV), dynamically linked, interpreter /lib/ld.so.1, for GNU/Linux 2.4.1
+        MIPS: "mips"
+      };
+      const fileArchRegexStr = Object.keys(FILE_ARCH).map((arch2) => `(?:${arch2})`).join("|");
+      const fileArchRegex = new RegExp(fileArchRegexStr);
+      const fileArchMatch = result.match(fileArchRegex);
+      debug12("archMatch:", fileArchMatch && fileArchMatch[0]);
+      const fileArch = fileArchMatch ? fileArchMatch[0] : null;
+      const arch = FILE_ARCH[fileArch];
+      return arch;
+    }
+    async function readBinaryFileArch2(filePath) {
+      const stat = await fs13.stat(filePath);
+      if (!stat.isFile()) {
+        throw new Error(`${filePath} is not a file.`);
+      }
+      let arch;
+      if (process.platform === "win32") {
+        arch = await readPEArch(filePath);
+      } else {
+        arch = await getArchUsingFileCommand(filePath);
+      }
+      return SUPPORTED_ARCH.includes(arch) ? arch : null;
+    }
+    module.exports = { readBinaryFileArch: readBinaryFileArch2 };
+  }
+});
+
+// ../../node_modules/@electron/rebuild/lib/module-type/node-pre-gyp.js
+var import_debug8, import_read_binary_file_arch, import_cross_spawn_promise4, d8, NodePreGyp;
+var init_node_pre_gyp = __esm({
+  "../../node_modules/@electron/rebuild/lib/module-type/node-pre-gyp.js"() {
+    "use strict";
+    import_debug8 = __toESM(require_src(), 1);
+    import_read_binary_file_arch = __toESM(require_read_binary_file_arch(), 1);
+    init_module_type();
+    import_cross_spawn_promise4 = __toESM(require_src2(), 1);
+    d8 = (0, import_debug8.default)("electron-rebuild");
+    NodePreGyp = class extends NativeModule {
+      async usesTool() {
+        const packageName = await this.findPackageInDependencies("node-pre-gyp");
+        return !!packageName;
+      }
+      async locateBinary() {
+        const packageName = await this.findPackageInDependencies("node-pre-gyp");
+        if (!packageName)
+          return null;
+        return locateBinary(this.modulePath, `node_modules/${packageName}/bin/node-pre-gyp`);
+      }
+      async run(nodePreGypPath) {
+        const redownloadBinary = await this.shouldUpdateBinary(nodePreGypPath);
+        await (0, import_cross_spawn_promise4.spawn)(process.execPath, [
+          nodePreGypPath,
+          "reinstall",
+          "--fallback-to-build",
+          ...redownloadBinary ? ["--update-binary"] : [],
+          `--arch=${this.rebuilder.arch}`,
+          // fallback build arch
+          `--target_arch=${this.rebuilder.arch}`,
+          // prebuild arch
+          `--target_platform=${this.rebuilder.platform}`,
+          ...await this.getNodePreGypRuntimeArgs()
+        ], {
+          cwd: this.modulePath
+        });
+      }
+      async findPrebuiltModule() {
+        const nodePreGypPath = await this.locateBinary();
+        if (nodePreGypPath) {
+          d8(`triggering prebuild download step: ${this.moduleName}`);
+          try {
+            await this.run(nodePreGypPath);
+            return true;
+          } catch (err) {
+            d8("failed to use node-pre-gyp:", err);
+            if (err?.message?.includes("requires Node-API but Electron")) {
+              throw err;
+            }
+          }
+        } else {
+          d8(`could not find node-pre-gyp relative to: ${this.modulePath}`);
+        }
+        return false;
+      }
+      async getNodePreGypRuntimeArgs() {
+        const moduleNapiVersions = await this.getSupportedNapiVersions();
+        if (moduleNapiVersions) {
+          return [];
+        } else {
+          return [
+            "--runtime=electron",
+            `--target=${this.rebuilder.electronVersion}`,
+            `--dist-url=${this.rebuilder.headerURL}`
+          ];
+        }
+      }
+      async shouldUpdateBinary(nodePreGypPath) {
+        let shouldUpdate = false;
+        try {
+          const modulePaths = await this.getModulePaths(nodePreGypPath);
+          d8("module paths:", modulePaths);
+          for (const modulePath of modulePaths) {
+            let moduleArch;
+            try {
+              moduleArch = await (0, import_read_binary_file_arch.readBinaryFileArch)(modulePath);
+              d8("module arch:", moduleArch);
+            } catch (error) {
+              d8("failed to read module arch:", error.message);
+              continue;
+            }
+            if (moduleArch && moduleArch !== this.rebuilder.arch) {
+              shouldUpdate = true;
+              d8("module architecture differs:", `${moduleArch} !== ${this.rebuilder.arch}`);
+              break;
+            }
+          }
+        } catch (error) {
+          d8("failed to get existing binary arch:", error.message);
+          shouldUpdate = true;
+        }
+        return shouldUpdate;
+      }
+      async getModulePaths(nodePreGypPath) {
+        const results = await (0, import_cross_spawn_promise4.spawn)(process.execPath, [
+          nodePreGypPath,
+          "reveal",
+          "module",
+          // pick property with module path
+          `--target_arch=${this.rebuilder.arch}`,
+          `--target_platform=${this.rebuilder.platform}`
+        ], {
+          cwd: this.modulePath
+        });
+        return results.split("\n").filter(Boolean);
+      }
+    };
+  }
+});
+
+// ../../node_modules/@electron/rebuild/lib/module-rebuilder.js
+import fs9 from "fs";
+import path11 from "path";
+var import_debug9, d9, ModuleRebuilder;
+var init_module_rebuilder = __esm({
+  "../../node_modules/@electron/rebuild/lib/module-rebuilder.js"() {
+    "use strict";
+    import_debug9 = __toESM(require_src(), 1);
+    init_cache();
+    init_node_gyp();
+    init_prebuildify();
+    init_prebuild_install();
+    init_node_pre_gyp();
+    d9 = (0, import_debug9.default)("electron-rebuild");
+    ModuleRebuilder = class {
+      modulePath;
+      nodeGyp;
+      rebuilder;
+      prebuildify;
+      prebuildInstall;
+      nodePreGyp;
+      constructor(rebuilder, modulePath) {
+        this.modulePath = modulePath;
+        this.rebuilder = rebuilder;
+        this.nodeGyp = new NodeGyp(rebuilder, modulePath);
+        this.prebuildify = new Prebuildify(rebuilder, modulePath);
+        this.prebuildInstall = new PrebuildInstall(rebuilder, modulePath);
+        this.nodePreGyp = new NodePreGyp(rebuilder, modulePath);
+      }
+      get metaPath() {
+        return path11.resolve(this.modulePath, "build", this.rebuilder.buildType, ".forge-meta");
+      }
+      get metaData() {
+        return `${this.rebuilder.arch}--${this.rebuilder.ABI}`;
+      }
+      async alreadyBuiltByRebuild() {
+        if (fs9.existsSync(this.metaPath)) {
+          const meta = await fs9.promises.readFile(this.metaPath, "utf8");
+          return meta === this.metaData;
+        }
+        return false;
+      }
+      async cacheModuleState(cacheKey) {
+        if (this.rebuilder.useCache) {
+          await cacheModuleState(this.modulePath, this.rebuilder.cachePath, cacheKey);
+        }
+      }
+      /**
+       * Whether a prebuild-install-generated native module exists.
+       */
+      async prebuildInstallNativeModuleExists() {
+        return this.prebuildInstall.prebuiltModuleExists();
+      }
+      /**
+       * If the native module uses prebuildify, check to see if it comes with a prebuilt module for
+       * the given platform and arch.
+       */
+      async findPrebuildifyModule(cacheKey) {
+        if (await this.prebuildify.usesTool()) {
+          d9(`assuming is prebuildify powered: ${this.prebuildify.moduleName}`);
+          if (await this.prebuildify.findPrebuiltModule()) {
+            await this.writeMetadata();
+            await this.cacheModuleState(cacheKey);
+            return true;
+          }
+        }
+        return false;
+      }
+      async findPrebuildInstallModule(cacheKey) {
+        if (await this.prebuildInstall.usesTool()) {
+          d9(`assuming is prebuild-install powered: ${this.prebuildInstall.moduleName}`);
+          if (await this.prebuildInstall.findPrebuiltModule()) {
+            d9("installed prebuilt module:", this.prebuildInstall.moduleName);
+            await this.writeMetadata();
+            await this.cacheModuleState(cacheKey);
+            return true;
+          }
+        }
+        return false;
+      }
+      async findNodePreGypInstallModule(cacheKey) {
+        if (await this.nodePreGyp.usesTool()) {
+          d9(`assuming is node-pre-gyp powered: ${this.nodePreGyp.moduleName}`);
+          if (await this.nodePreGyp.findPrebuiltModule()) {
+            d9("installed prebuilt module:", this.nodePreGyp.moduleName);
+            await this.writeMetadata();
+            await this.cacheModuleState(cacheKey);
+            return true;
+          }
+        }
+        return false;
+      }
+      async rebuildNodeGypModule(cacheKey) {
+        await this.nodeGyp.rebuildModule();
+        d9("built via node-gyp:", this.nodeGyp.moduleName);
+        await this.writeMetadata();
+        await this.replaceExistingNativeModule();
+        await this.cacheModuleState(cacheKey);
+        return true;
+      }
+      async replaceExistingNativeModule() {
+        const buildLocation = path11.resolve(this.modulePath, "build", this.rebuilder.buildType);
+        d9("searching for .node file", buildLocation);
+        const buildLocationFiles = await fs9.promises.readdir(buildLocation);
+        d9("testing files", buildLocationFiles);
+        const nodeFile = buildLocationFiles.find((file) => file !== ".node" && file.endsWith(".node"));
+        const nodePath = nodeFile ? path11.resolve(buildLocation, nodeFile) : void 0;
+        if (nodePath && fs9.existsSync(nodePath)) {
+          d9("found .node file", nodePath);
+          if (!this.rebuilder.disablePreGypCopy) {
+            const abiPath = path11.resolve(this.modulePath, `bin/${this.rebuilder.platform}-${this.rebuilder.arch}-${this.rebuilder.ABI}`);
+            d9("copying to prebuilt place:", abiPath);
+            await fs9.promises.mkdir(abiPath, { recursive: true });
+            await fs9.promises.copyFile(nodePath, path11.join(abiPath, `${this.nodeGyp.moduleName}.node`));
+          }
+        }
+      }
+      async writeMetadata() {
+        await fs9.promises.mkdir(path11.dirname(this.metaPath), { recursive: true });
+        await fs9.promises.writeFile(this.metaPath, this.metaData);
+      }
+      async rebuild(cacheKey) {
+        if (!this.rebuilder.buildFromSource && (await this.findPrebuildifyModule(cacheKey) || await this.findPrebuildInstallModule(cacheKey) || await this.findNodePreGypInstallModule(cacheKey))) {
+          return true;
+        }
+        return await this.rebuildNodeGypModule(cacheKey);
+      }
+    };
+  }
+});
+
+// ../../node_modules/@electron/rebuild/lib/search-module.js
+import fs10 from "fs";
+import path12 from "path";
+async function shouldContinueSearch(traversedPath, rootPath, stopAtPackageJSON) {
+  if (rootPath) {
+    return Promise.resolve(traversedPath !== path12.dirname(rootPath));
+  } else if (stopAtPackageJSON) {
+    return fs10.existsSync(path12.join(traversedPath, "package.json"));
+  } else {
+    return true;
+  }
+}
+async function traverseAncestorDirectories(cwd, pathGenerator, rootPath, maxItems, stopAtPackageJSON) {
+  const paths = [];
+  let traversedPath = path12.resolve(cwd);
+  while (await shouldContinueSearch(traversedPath, rootPath, stopAtPackageJSON)) {
+    const generatedPath = pathGenerator(traversedPath);
+    if (fs10.existsSync(generatedPath)) {
+      paths.push(generatedPath);
+    }
+    const parentPath = path12.dirname(traversedPath);
+    if (parentPath === traversedPath || maxItems && paths.length >= maxItems) {
+      break;
+    }
+    traversedPath = parentPath;
+  }
+  return paths;
+}
+async function searchForModule(cwd, moduleName, rootPath) {
+  const pathGenerator = (traversedPath) => path12.join(traversedPath, "node_modules", moduleName);
+  return traverseAncestorDirectories(cwd, pathGenerator, rootPath, void 0, true);
+}
+async function searchForNodeModules(cwd, rootPath) {
+  const pathGenerator = (traversedPath) => path12.join(traversedPath, "node_modules");
+  return traverseAncestorDirectories(cwd, pathGenerator, rootPath, void 0, true);
+}
+var init_search_module = __esm({
+  "../../node_modules/@electron/rebuild/lib/search-module.js"() {
+    "use strict";
+  }
+});
+
+// ../../node_modules/@electron/rebuild/lib/module-walker.js
+import fs11 from "fs";
+import path13 from "path";
+var import_debug10, d10, ModuleWalker;
+var init_module_walker = __esm({
+  "../../node_modules/@electron/rebuild/lib/module-walker.js"() {
+    "use strict";
+    import_debug10 = __toESM(require_src(), 1);
+    init_read_package_json();
+    init_search_module();
+    d10 = (0, import_debug10.default)("electron-rebuild");
+    ModuleWalker = class {
+      buildPath;
+      modulesToRebuild;
+      onlyModules;
+      prodDeps;
+      projectRootPath;
+      realModulePaths;
+      realNodeModulesPaths;
+      types;
+      constructor(buildPath, projectRootPath, types, prodDeps, onlyModules) {
+        this.buildPath = buildPath;
+        this.modulesToRebuild = [];
+        this.projectRootPath = projectRootPath;
+        this.types = types;
+        this.prodDeps = prodDeps;
+        this.onlyModules = onlyModules;
+        this.realModulePaths = /* @__PURE__ */ new Set();
+        this.realNodeModulesPaths = /* @__PURE__ */ new Set();
+      }
+      get nodeModulesPaths() {
+        return searchForNodeModules(this.buildPath, this.projectRootPath);
+      }
+      async walkModules() {
+        const rootPackageJson = await readPackageJson(this.buildPath);
+        const markWaiters = [];
+        const depKeys = [];
+        if (this.types.includes("prod") || this.onlyModules) {
+          depKeys.push(...Object.keys(rootPackageJson.dependencies || {}));
+        }
+        if (this.types.includes("optional") || this.onlyModules) {
+          depKeys.push(...Object.keys(rootPackageJson.optionalDependencies || {}));
+        }
+        if (this.types.includes("dev") || this.onlyModules) {
+          depKeys.push(...Object.keys(rootPackageJson.devDependencies || {}));
+        }
+        for (const key of depKeys) {
+          this.prodDeps.add(key);
+          const modulePaths = await searchForModule(this.buildPath, key, this.projectRootPath);
+          for (const modulePath of modulePaths) {
+            markWaiters.push(this.markChildrenAsProdDeps(modulePath));
+          }
+        }
+        await Promise.all(markWaiters);
+        d10("identified prod deps:", this.prodDeps);
+      }
+      async findModule(moduleName, fromDir, foundFn) {
+        const testPaths = await searchForModule(fromDir, moduleName, this.projectRootPath);
+        const foundFns = testPaths.map((testPath) => foundFn(testPath));
+        return Promise.all(foundFns);
+      }
+      async markChildrenAsProdDeps(modulePath) {
+        if (!fs11.existsSync(modulePath)) {
+          return;
+        }
+        d10("exploring", modulePath);
+        let childPackageJson;
+        try {
+          childPackageJson = await readPackageJson(modulePath, true);
+        } catch {
+          return;
+        }
+        const moduleWait = [];
+        const callback = this.markChildrenAsProdDeps.bind(this);
+        for (const key of Object.keys(childPackageJson.dependencies || {}).concat(Object.keys(childPackageJson.optionalDependencies || {}))) {
+          if (this.prodDeps.has(key)) {
+            continue;
+          }
+          this.prodDeps.add(key);
+          moduleWait.push(this.findModule(key, modulePath, callback));
+        }
+        await Promise.all(moduleWait);
+      }
+      async findAllModulesIn(nodeModulesPath, prefix = "") {
+        const realNodeModulesPath = await fs11.promises.realpath(nodeModulesPath);
+        if (this.realNodeModulesPaths.has(realNodeModulesPath)) {
+          return;
+        }
+        this.realNodeModulesPaths.add(realNodeModulesPath);
+        d10("scanning:", realNodeModulesPath);
+        for (const modulePath of await fs11.promises.readdir(realNodeModulesPath)) {
+          if (modulePath === ".bin")
+            continue;
+          const subPath = path13.resolve(nodeModulesPath, modulePath);
+          let realPath;
+          try {
+            realPath = await fs11.promises.realpath(subPath);
+          } catch (error) {
+            if (error.code === "ENOENT") {
+              const stat = await fs11.promises.lstat(subPath);
+              if (stat.isSymbolicLink()) {
+                continue;
+              }
+            }
+            throw error;
+          }
+          if (this.realModulePaths.has(realPath)) {
+            continue;
+          }
+          this.realModulePaths.add(realPath);
+          const moduleName = `${prefix}${modulePath}`;
+          if (this.prodDeps.has(moduleName) && (!this.onlyModules || this.onlyModules.includes(moduleName))) {
+            this.modulesToRebuild.push(realPath);
+          }
+          if (modulePath.startsWith("@")) {
+            await this.findAllModulesIn(realPath, `${modulePath}/`);
+          }
+          if (fs11.existsSync(path13.resolve(nodeModulesPath, modulePath, "node_modules"))) {
+            await this.findAllModulesIn(path13.resolve(realPath, "node_modules"));
+          }
+        }
+      }
+    };
+  }
+});
+
+// ../../node_modules/@electron/rebuild/lib/rebuild.js
+import { EventEmitter } from "events";
+import fs12 from "fs";
+import os2 from "os";
+import path14 from "path";
+function rebuild(options) {
+  d11("rebuilding with args:", arguments);
+  const lifecycle = new EventEmitter();
+  const rebuilderOptions = { ...options, lifecycle };
+  const rebuilder = new Rebuilder(rebuilderOptions);
+  const ret = rebuilder.rebuild();
+  ret.lifecycle = lifecycle;
+  return ret;
+}
+var import_debug11, d11, defaultMode, defaultTypes, Rebuilder;
+var init_rebuild = __esm({
+  "../../node_modules/@electron/rebuild/lib/rebuild.js"() {
+    "use strict";
+    import_debug11 = __toESM(require_src(), 1);
+    init_node_abi();
+    init_cache();
+    init_types();
+    init_module_rebuilder();
+    init_module_walker();
+    d11 = (0, import_debug11.default)("electron-rebuild");
+    defaultMode = "sequential";
+    defaultTypes = ["prod", "optional"];
+    Rebuilder = class {
+      ABIVersion;
+      moduleWalker;
+      rebuilds;
+      lifecycle;
+      buildPath;
+      electronVersion;
+      platform;
+      arch;
+      force;
+      headerURL;
+      mode;
+      debug;
+      useCache;
+      cachePath;
+      prebuildTagPrefix;
+      msvsVersion;
+      useElectronClang;
+      disablePreGypCopy;
+      buildFromSource;
+      ignoreModules;
+      jobs;
+      constructor(options) {
+        this.lifecycle = options.lifecycle;
+        this.buildPath = options.buildPath;
+        this.electronVersion = options.electronVersion;
+        this.platform = options.platform || process.platform;
+        this.arch = options.arch || process.arch;
+        this.force = options.force || false;
+        this.headerURL = options.headerURL || "https://www.electronjs.org/headers";
+        this.mode = options.mode || defaultMode;
+        this.debug = options.debug || false;
+        this.useCache = options.useCache || false;
+        this.useElectronClang = options.useElectronClang || false;
+        this.cachePath = options.cachePath || path14.resolve(os2.homedir(), ".electron-rebuild-cache");
+        this.prebuildTagPrefix = options.prebuildTagPrefix ?? "v";
+        this.msvsVersion = process.env.GYP_MSVS_VERSION;
+        this.disablePreGypCopy = options.disablePreGypCopy || false;
+        this.buildFromSource = options.buildFromSource || false;
+        this.ignoreModules = options.ignoreModules || [];
+        this.jobs = options.jobs;
+        d11("ignoreModules", this.ignoreModules);
+        if (this.useCache && this.force) {
+          console.warn("[WARNING]: Electron Rebuild has force enabled and cache enabled, force take precedence and the cache will not be used.");
+          this.useCache = false;
+        }
+        if (typeof this.electronVersion === "number") {
+          if (`${this.electronVersion}`.split(".").length === 1) {
+            this.electronVersion = `${this.electronVersion}.0.0`;
+          } else {
+            this.electronVersion = `${this.electronVersion}.0`;
+          }
+        }
+        if (typeof this.electronVersion !== "string") {
+          throw new Error(`Expected a string version for electron version, got a "${typeof this.electronVersion}"`);
+        }
+        this.ABIVersion = options.forceABI?.toString();
+        const onlyModules = options.onlyModules || null;
+        const extraModules = new Set(options.extraModules);
+        const types = options.types || defaultTypes;
+        this.moduleWalker = new ModuleWalker(this.buildPath, options.projectRootPath, types, extraModules, onlyModules);
+        this.rebuilds = [];
+        d11("rebuilding with args:", this.buildPath, this.electronVersion, this.platform, this.arch, extraModules, this.force, this.headerURL, types, this.debug);
+      }
+      get ABI() {
+        if (this.ABIVersion === void 0) {
+          this.ABIVersion = getAbi(this.electronVersion, "electron");
+        }
+        return this.ABIVersion;
+      }
+      get buildType() {
+        return this.debug ? BuildType.Debug : BuildType.Release;
+      }
+      async rebuild() {
+        if (!path14.isAbsolute(this.buildPath)) {
+          throw new Error("Expected buildPath to be an absolute path");
+        }
+        this.lifecycle.emit("start");
+        const candidatePaths = [...await this.modulesToRebuild(), this.buildPath];
+        const nativeModulePaths = candidatePaths.filter((p) => fs12.existsSync(path14.resolve(p, "binding.gyp")));
+        this.lifecycle.emit("modules-found", nativeModulePaths.map((p) => {
+          const name = path14.basename(p);
+          const parent = path14.basename(path14.dirname(p));
+          return parent !== "node_modules" ? `${parent}/${name}` : name;
+        }));
+        for (const modulePath of nativeModulePaths) {
+          this.rebuilds.push(() => this.rebuildModuleAt(modulePath));
+        }
+        if (this.mode !== "sequential") {
+          await Promise.all(this.rebuilds.map((fn) => fn()));
+        } else {
+          for (const rebuildFn of this.rebuilds) {
+            await rebuildFn();
+          }
+        }
+      }
+      async modulesToRebuild() {
+        await this.moduleWalker.walkModules();
+        for (const nodeModulesPath of await this.moduleWalker.nodeModulesPaths) {
+          await this.moduleWalker.findAllModulesIn(nodeModulesPath);
+        }
+        return this.moduleWalker.modulesToRebuild;
+      }
+      async rebuildModuleAt(modulePath) {
+        const moduleRebuilder = new ModuleRebuilder(this, modulePath);
+        let moduleName = path14.basename(modulePath);
+        const parentName = path14.basename(path14.dirname(modulePath));
+        if (parentName !== "node_modules") {
+          moduleName = `${parentName}/${moduleName}`;
+        }
+        this.lifecycle.emit("module-found", moduleName);
+        if (!this.force && await moduleRebuilder.alreadyBuiltByRebuild()) {
+          d11(`skipping: ${moduleName} as it is already built`);
+          this.lifecycle.emit("module-done", moduleName);
+          this.lifecycle.emit("module-skip", moduleName);
+          return;
+        }
+        d11("checking", moduleName, "against", this.ignoreModules);
+        if (this.ignoreModules.includes(moduleName)) {
+          d11(`skipping: ${moduleName} as it is in the ignoreModules array`);
+          this.lifecycle.emit("module-done", moduleName);
+          this.lifecycle.emit("module-skip", moduleName);
+          return;
+        }
+        if (await moduleRebuilder.prebuildInstallNativeModuleExists()) {
+          d11(`skipping: ${moduleName} as it was prebuilt`);
+          return;
+        }
+        let cacheKey;
+        if (this.useCache) {
+          cacheKey = await generateCacheKey({
+            ABI: this.ABI,
+            arch: this.arch,
+            platform: this.platform,
+            debug: this.debug,
+            electronVersion: this.electronVersion,
+            headerURL: this.headerURL,
+            modulePath
+          });
+          const applyDiffFn = await lookupModuleState(this.cachePath, cacheKey);
+          if (typeof applyDiffFn === "function") {
+            await applyDiffFn(modulePath);
+            this.lifecycle.emit("module-done", moduleName);
+            return;
+          }
+        }
+        if (await moduleRebuilder.rebuild(cacheKey)) {
+          this.lifecycle.emit("module-done", moduleName);
+        }
+      }
+    };
+  }
+});
+
+// ../../node_modules/@electron/rebuild/lib/main.js
+var init_main = __esm({
+  "../../node_modules/@electron/rebuild/lib/main.js"() {
+    init_rebuild();
+  }
+});
+init_main();
+export {
+  rebuild
+};