binary-collections 2.0.9 → 2.0.11

package/lib/del-node-modules.mjs

@@ -1,26 +1,157 @@
 import { createRequire } from 'module'; const require = createRequire(import.meta.url);
-import {
-  require_utils
-} from "./chunk-APBWENF6.mjs";
 import {
   __require,
   init_esm_shims
-} from "./chunk-AASHBCRW.mjs";
+} from "./chunk-QQ4A6DLD.mjs";
 
 // src/del-node-modules.js
 init_esm_shims();
-var glob = __require("glob");
-var { delStream } = require_utils();
-var globalIgnore = [
-  // ignore .git .github folder
-  "**/.git*",
-  // ignore composer folder
-  "**/vendor/**"
-];
-console.log("cleaning node_modules in", process.cwd());
-var g3 = new glob.Glob("**/node_modules", {
-  withFileTypes: false,
-  cwd: process.cwd(),
-  ignore: globalIgnore
+var fs = __require("fs");
+var fsp = fs.promises;
+var path = __require("path");
+var os = __require("os");
+var minimist = __require("minimist");
+var argv = minimist(process.argv.slice(2), {
+  boolean: ["force", "help"],
+  alias: { h: "help", f: "force", c: "concurrent" },
+  default: { force: false, concurrent: 2 }
 });
-delStream(g3);
+if (argv.help) {
+  console.log(`Usage: clean-node [--force] [-c|--concurrent N]
+By default runs in dry-run mode. Use --force to actually delete.
+Use -c/--concurrent to set concurrent removals (default 2).`);
+  process.exit(0);
+}
+var DRY_RUN = !argv.force;
+var defaultConcurrency = Math.max(2, os.cpus().length || 2);
+var CONCURRENCY = Math.max(1, Number(argv.concurrent || argv.c || defaultConcurrency));
+var customChars = "@.";
+var vowels = "aeiouAEIOU";
+var alnum = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+var combined = alnum + vowels + customChars;
+var ROOT = process.cwd();
+async function isSymlinkAsync(p) {
+  try {
+    return (await fsp.lstat(p)).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+async function removeAsync(target) {
+  if (await isSymlinkAsync(target)) {
+    console.log("Skipping symlink", target);
+    return;
+  }
+  if (DRY_RUN) {
+    console.log("Would remove", target);
+    return;
+  }
+  try {
+    await fsp.rm(target, { recursive: true, force: true });
+    console.log("Deleting", target);
+  } catch (e) {
+    console.error("Failed:", target, e.message);
+  }
+}
+function runWithConcurrency(tasks, concurrency) {
+  return new Promise((resolve, reject) => {
+    let i = 0;
+    let active = 0;
+    let done = 0;
+    const total = tasks.length;
+    if (total === 0) return resolve();
+    function next() {
+      if (done === total) return resolve();
+      while (active < concurrency && i < total) {
+        const idx = i++;
+        active++;
+        Promise.resolve().then(() => tasks[idx]()).then(() => {
+          active--;
+          done++;
+          next();
+        }).catch((err) => reject(err));
+      }
+    }
+    next();
+  });
+}
+function walk(dir, callback, { skipNodeModulesChildren = false } = {}) {
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isSymbolicLink()) continue;
+    if (skipNodeModulesChildren && dir.includes("node_modules")) continue;
+    callback(fullPath, entry);
+    if (entry.isDirectory()) {
+      if (skipNodeModulesChildren && entry.name === "node_modules") {
+        continue;
+      }
+      walk(fullPath, callback, { skipNodeModulesChildren });
+    }
+  }
+}
+async function processNodeModules(dir) {
+  console.log("Found:", dir);
+  let items;
+  try {
+    items = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  const targets = items.filter((entry) => entry.name.length && combined.includes(entry.name[0]));
+  const tasks = targets.map((entry) => async () => {
+    const name = entry.name;
+    const target = path.join(dir, name);
+    if (entry.isSymbolicLink && entry.isSymbolicLink()) {
+      console.log("Skipping symlink", target);
+      return;
+    }
+    await removeAsync(target);
+  });
+  await runWithConcurrency(tasks, CONCURRENCY);
+  await removeAsync(dir);
+}
+async function main() {
+  const nodeModulesDirs = [];
+  walk(ROOT, (fullPath, entry) => {
+    if (entry.isDirectory() && entry.name === "node_modules") {
+      nodeModulesDirs.push(fullPath);
+    }
+  });
+  for (const dir of nodeModulesDirs) {
+    await processNodeModules(dir);
+  }
+  const packageLocks = [];
+  const yarnLocks = [];
+  const yarnCaches = [];
+  walk(
+    ROOT,
+    (fullPath, entry) => {
+      const base = path.basename(fullPath);
+      if (base === "package-lock.json") packageLocks.push(fullPath);
+      if (base === "yarn.lock") yarnLocks.push(fullPath);
+      if (entry.isDirectory() && fullPath.endsWith(path.join(".yarn", "cache"))) yarnCaches.push(fullPath);
+    },
+    { skipNodeModulesChildren: true }
+  );
+  if (DRY_RUN) {
+    console.log("Would remove package-lock.json files:");
+    for (const p of packageLocks) console.log(p);
+    console.log("Would remove yarn.lock files:");
+    for (const p of yarnLocks) console.log(p);
+    console.log("Would remove .yarn/cache directories:");
+    for (const p of yarnCaches) console.log(p);
+  } else {
+    const allTasks = [];
+    allTasks.push(...packageLocks.map((p) => async () => removeAsync(p)));
+    allTasks.push(...yarnLocks.map((p) => async () => removeAsync(p)));
+    allTasks.push(...yarnCaches.map((p) => async () => removeAsync(p)));
+    await runWithConcurrency(allTasks, CONCURRENCY);
+  }
+}
+main();

package/lib/del-ps.cjs

@@ -1,10 +1,27 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // node_modules/tsup/assets/cjs_shims.js
 var init_cjs_shims = __esm({
@@ -13,17 +30,22 @@ var init_cjs_shims = __esm({
 });
 
 // src/ps/isWin.js
-var require_isWin = __commonJS({
-  "src/ps/isWin.js"(exports2, module2) {
+var isWin_exports = {};
+__export(isWin_exports, {
+  default: () => isWin_default
+});
+var isWin, isWin_default;
+var init_isWin = __esm({
+  "src/ps/isWin.js"() {
     init_cjs_shims();
-    var isWin2 = process.platform === "win32";
-    module2.exports = isWin2;
+    isWin = process.platform === "win32";
+    isWin_default = isWin;
   }
 });
 
-// src/utils.js
+// src/utils/index.cjs
 var require_utils = __commonJS({
-  "src/utils.js"(exports2, module2) {
+  "src/utils/index.cjs"(exports2, module2) {
     init_cjs_shims();
     var fs = require("fs");
     var path = require("upath");
@@ -76,31 +98,78 @@ var require_utils = __commonJS({
     }
     module2.exports.getArgs = getArgs2;
     function del(fullPath) {
-      if (fs.statSync(fullPath).isDirectory()) {
-        const subdir = fs.readdirSync(fullPath).map((dirPath) => path.resolve(fullPath, dirPath));
-        for (let i = 0; i < subdir.length; i++) {
-          del(subdir[i]);
+      try {
+        if (!fs.existsSync(fullPath)) return;
+        const stat = fs.lstatSync(fullPath);
+        if (stat.isSymbolicLink()) {
+          try {
+            fs.unlinkSync(fullPath);
+            console.log("deleted symlink", fullPath);
+          } catch (e) {
+            console.log("failed delete symlink", fullPath, e && e.message);
+          }
+          return;
+        }
+        if (stat.isDirectory()) {
+          const subdir = fs.readdirSync(fullPath).map((dirPath) => path.resolve(fullPath, dirPath));
+          for (let i = 0; i < subdir.length; i++) {
+            del(subdir[i]);
+          }
+          try {
+            fs.rmdirSync(fullPath);
+            console.log("deleted", fullPath);
+          } catch (e) {
+            try {
+              fs.rmSync(fullPath, { recursive: true, force: true, retryDelay: 7e3 });
+              console.log("deleted", fullPath);
+            } catch (ee) {
+              console.log("failed delete", fullPath, ee && ee.message);
+            }
+          }
+          return;
         }
-      } else {
         try {
-          fs.rmSync(fullPath, { recursive: true, force: true, retryDelay: 7e3 });
+          fs.unlinkSync(fullPath);
           console.log("deleted", fullPath);
-        } catch (_) {
-          console.log("failed delete", fullPath);
+        } catch (e) {
+          try {
+            fs.rmSync(fullPath, { recursive: true, force: true, retryDelay: 7e3 });
+            console.log("deleted", fullPath);
+          } catch (ee) {
+            console.log("failed delete", fullPath, ee && ee.message);
+          }
         }
+      } catch (err) {
+        console.log("failed delete", fullPath, err && err.message);
       }
     }
     module2.exports.del = del;
     function delStream(globStream) {
       globStream.stream().on("data", (result) => {
         const fullPath = path.resolve(process.cwd(), result);
-        if (fs.statSync(fullPath).isDirectory()) {
-          const subdir = fs.readdirSync(fullPath).map((dirPath) => path.resolve(fullPath, dirPath));
-          for (let i = 0; i < subdir.length; i++) {
-            del(subdir[i]);
+        try {
+          if (fs.existsSync(fullPath)) {
+            const stat = fs.lstatSync(fullPath);
+            if (stat.isSymbolicLink()) {
+              try {
+                fs.unlinkSync(fullPath);
+                console.log("deleted symlink", fullPath);
+              } catch (e) {
+                console.log("failed delete symlink", fullPath, e && e.message);
+              }
+              return;
+            }
+            if (stat.isDirectory()) {
+              const subdir = fs.readdirSync(fullPath).map((dirPath) => path.resolve(fullPath, dirPath));
+              for (let i = 0; i < subdir.length; i++) {
+                del(subdir[i]);
+              }
+            }
           }
+          del(fullPath);
+        } catch (err) {
+          console.log("failed processing", fullPath, err && err.message);
         }
-        del(fullPath);
       });
     }
     module2.exports.delStream = delStream;
@@ -150,7 +219,7 @@ var require_utils = __commonJS({
 init_cjs_shims();
 var crossSpawn = require("cross-spawn");
 var ps = require("ps-node");
-var isWin = require_isWin();
+var isWin2 = (init_isWin(), __toCommonJS(isWin_exports)).default;
 var { getArgs } = require_utils();
 getArgs()._.forEach((command) => {
   ps.lookup(
@@ -164,7 +233,7 @@ getArgs()._.forEach((command) => {
       }
       resultList.forEach(function(process2) {
         if (process2) {
-          if (!isWin) {
+          if (!isWin2) {
             crossSpawn.spawnAsync("kill", ["-9", process2.pid]).catch((e) => console.log(`kill failed ${e.message}`));
             crossSpawn.spawnAsync("killall", ["-9", process2.pid]).catch((e) => console.log(`killall failed ${e.message}`));
           } else {

package/lib/del-ps.js

@@ -1,7 +1,8 @@
+"use strict";
 const crossSpawn = require("cross-spawn");
 const ps = require("ps-node");
-const isWin = require("./ps/isWin");
-const { getArgs } = require("./utils.js");
+const isWin = require("./ps/isWin.js").default;
+const { getArgs } = require("./utils/index.cjs");
 getArgs()._.forEach((command) => {
     ps.lookup({
         command,

package/lib/del-ps.mjs

@@ -1,20 +1,22 @@
 import { createRequire } from 'module'; const require = createRequire(import.meta.url);
 import {
-  require_isWin
-} from "./chunk-W3ENOM53.mjs";
+  init_isWin,
+  isWin_exports
+} from "./chunk-6S4NXESK.mjs";
 import {
   require_utils
-} from "./chunk-APBWENF6.mjs";
+} from "./chunk-Z6JLYU2J.mjs";
 import {
   __require,
+  __toCommonJS,
   init_esm_shims
-} from "./chunk-AASHBCRW.mjs";
+} from "./chunk-QQ4A6DLD.mjs";
 
 // src/del-ps.js
 init_esm_shims();
 var crossSpawn = __require("cross-spawn");
 var ps = __require("ps-node");
-var isWin = require_isWin();
+var isWin = (init_isWin(), __toCommonJS(isWin_exports)).default;
 var { getArgs } = require_utils();
 getArgs()._.forEach((command) => {
   ps.lookup(

package/lib/del-yarn-caches.cjs

@@ -1,10 +1,32 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 
 // node_modules/tsup/assets/cjs_shims.js
 var init_cjs_shims = __esm({
@@ -12,9 +34,9 @@ var init_cjs_shims = __esm({
   }
 });
 
-// src/utils.js
+// src/utils/index.cjs
 var require_utils = __commonJS({
-  "src/utils.js"(exports2, module2) {
+  "src/utils/index.cjs"(exports2, module2) {
     init_cjs_shims();
     var fs = require("fs");
     var path = require("upath");
@@ -67,31 +89,78 @@ var require_utils = __commonJS({
     }
     module2.exports.getArgs = getArgs;
     function del(fullPath) {
-      if (fs.statSync(fullPath).isDirectory()) {
-        const subdir = fs.readdirSync(fullPath).map((dirPath) => path.resolve(fullPath, dirPath));
-        for (let i = 0; i < subdir.length; i++) {
-          del(subdir[i]);
+      try {
+        if (!fs.existsSync(fullPath)) return;
+        const stat = fs.lstatSync(fullPath);
+        if (stat.isSymbolicLink()) {
+          try {
+            fs.unlinkSync(fullPath);
+            console.log("deleted symlink", fullPath);
+          } catch (e) {
+            console.log("failed delete symlink", fullPath, e && e.message);
+          }
+          return;
+        }
+        if (stat.isDirectory()) {
+          const subdir = fs.readdirSync(fullPath).map((dirPath) => path.resolve(fullPath, dirPath));
+          for (let i = 0; i < subdir.length; i++) {
+            del(subdir[i]);
+          }
+          try {
+            fs.rmdirSync(fullPath);
+            console.log("deleted", fullPath);
+          } catch (e) {
+            try {
+              fs.rmSync(fullPath, { recursive: true, force: true, retryDelay: 7e3 });
+              console.log("deleted", fullPath);
+            } catch (ee) {
+              console.log("failed delete", fullPath, ee && ee.message);
+            }
+          }
+          return;
         }
-      } else {
         try {
-          fs.rmSync(fullPath, { recursive: true, force: true, retryDelay: 7e3 });
+          fs.unlinkSync(fullPath);
           console.log("deleted", fullPath);
-        } catch (_) {
-          console.log("failed delete", fullPath);
+        } catch (e) {
+          try {
+            fs.rmSync(fullPath, { recursive: true, force: true, retryDelay: 7e3 });
+            console.log("deleted", fullPath);
+          } catch (ee) {
+            console.log("failed delete", fullPath, ee && ee.message);
+          }
         }
+      } catch (err) {
+        console.log("failed delete", fullPath, err && err.message);
       }
     }
     module2.exports.del = del;
     function delStream2(globStream) {
       globStream.stream().on("data", (result) => {
         const fullPath = path.resolve(process.cwd(), result);
-        if (fs.statSync(fullPath).isDirectory()) {
-          const subdir = fs.readdirSync(fullPath).map((dirPath) => path.resolve(fullPath, dirPath));
-          for (let i = 0; i < subdir.length; i++) {
-            del(subdir[i]);
+        try {
+          if (fs.existsSync(fullPath)) {
+            const stat = fs.lstatSync(fullPath);
+            if (stat.isSymbolicLink()) {
+              try {
+                fs.unlinkSync(fullPath);
+                console.log("deleted symlink", fullPath);
+              } catch (e) {
+                console.log("failed delete symlink", fullPath, e && e.message);
+              }
+              return;
+            }
+            if (stat.isDirectory()) {
+              const subdir = fs.readdirSync(fullPath).map((dirPath) => path.resolve(fullPath, dirPath));
+              for (let i = 0; i < subdir.length; i++) {
+                del(subdir[i]);
+              }
+            }
           }
+          del(fullPath);
+        } catch (err) {
+          console.log("failed processing", fullPath, err && err.message);
         }
-        del(fullPath);
       });
     }
     module2.exports.delStream = delStream2;
@@ -139,11 +208,11 @@ var require_utils = __commonJS({
 
 // src/del-yarn-caches.js
 init_cjs_shims();
-var glob = require("glob");
-var { delStream } = require_utils();
+var glob = __toESM(require("glob"), 1);
+var import_utils = __toESM(require_utils(), 1);
 var g3 = new glob.Glob(["**/.yarn/cache*", "**/.yarn/*.gz"], {
   withFileTypes: false,
   cwd: process.cwd(),
   ignore: ["**/.git*", "**/vendor/**"]
 });
-delStream(g3);
+(0, import_utils.delStream)(g3);

package/lib/del-yarn-caches.js

@@ -1,8 +1,43 @@
-const glob = require("glob");
-const { delStream } = require("./utils");
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const glob = __importStar(require("glob"));
+const index_cjs_1 = require("./utils/index.cjs");
 const g3 = new glob.Glob(["**/.yarn/cache*", "**/.yarn/*.gz"], {
     withFileTypes: false,
     cwd: process.cwd(),
     ignore: ["**/.git*", "**/vendor/**"]
 });
-delStream(g3);
+(0, index_cjs_1.delStream)(g3);

package/lib/del-yarn-caches.mjs

@@ -1,19 +1,19 @@
 import { createRequire } from 'module'; const require = createRequire(import.meta.url);
 import {
   require_utils
-} from "./chunk-APBWENF6.mjs";
+} from "./chunk-Z6JLYU2J.mjs";
 import {
-  __require,
+  __toESM,
   init_esm_shims
-} from "./chunk-AASHBCRW.mjs";
+} from "./chunk-QQ4A6DLD.mjs";
 
 // src/del-yarn-caches.js
 init_esm_shims();
-var glob = __require("glob");
-var { delStream } = require_utils();
+var import_utils = __toESM(require_utils(), 1);
+import * as glob from "glob";
 var g3 = new glob.Glob(["**/.yarn/cache*", "**/.yarn/*.gz"], {
   withFileTypes: false,
   cwd: process.cwd(),
   ignore: ["**/.git*", "**/vendor/**"]
 });
-delStream(g3);
+(0, import_utils.delStream)(g3);

package/lib/find-node-modules-cli.cjs

@@ -13,9 +13,9 @@ var init_cjs_shims = __esm({
   }
 });
 
-// src/find-node-modules.js
+// src/find-node-modules.cjs
 var require_find_node_modules = __commonJS({
-  "src/find-node-modules.js"(exports2, module2) {
+  "src/find-node-modules.cjs"(exports2, module2) {
     init_cjs_shims();
     var glob = require("glob");
     var path = require("path");
@@ -49,6 +49,9 @@ var require_find_node_modules = __commonJS({
         });
       });
     }
+    module2.exports = findNodeModules2;
+    module2.exports.default = findNodeModules2;
+    module2.exports.findNodeModules = findNodeModules2;
     if (typeof module2 !== "undefined" && require.main === module2) {
       findNodeModules2(null, console.log).then((dirs) => {
         console.log(`Found ${dirs.length} node_modules directories.`);
@@ -56,8 +59,6 @@ var require_find_node_modules = __commonJS({
         console.error("Error finding node_modules directories:", err);
       });
     }
-    module2.exports = findNodeModules2;
-    module2.exports.default = findNodeModules2;
   }
 });
 

package/lib/find-node-modules-cli.js

@@ -1,3 +1,4 @@
 #!/usr/bin/env node
-const findNodeModules = require("./find-node-modules");
+"use strict";
+const findNodeModules = require("./find-node-modules.cjs");
 findNodeModules(null, console.log);

package/lib/find-node-modules-cli.mjs

@@ -2,10 +2,10 @@
 import { createRequire } from 'module'; const require = createRequire(import.meta.url);
 import {
   require_find_node_modules
-} from "./chunk-YX5U7XDR.mjs";
+} from "./chunk-M3YIYRHT.mjs";
 import {
   init_esm_shims
-} from "./chunk-AASHBCRW.mjs";
+} from "./chunk-QQ4A6DLD.mjs";
 
 // src/find-node-modules-cli.js
 init_esm_shims();