@storm-software/linting-tools 1.111.0 → 1.112.0

package/bin/lint.js

@@ -229,6 +229,139 @@ var require_file_entry_cache = __commonJS({
   }
 });
 
+// ../../node_modules/.pnpm/@manypkg+get-packages@2.2.1/node_modules/@manypkg/get-packages/dist/manypkg-get-packages.cjs.prod.js
+var require_manypkg_get_packages_cjs_prod = __commonJS({
+  "../../node_modules/.pnpm/@manypkg+get-packages@2.2.1/node_modules/@manypkg/get-packages/dist/manypkg-get-packages.cjs.prod.js"(exports) {
+    "use strict";
+    init_esm_shims();
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    var path10 = __require("path");
+    var findRoot = __require("@manypkg/find-root");
+    function _interopDefault(e) {
+      return e && e.__esModule ? e : {
+        "default": e
+      };
+    }
+    __name(_interopDefault, "_interopDefault");
+    var path__default = /* @__PURE__ */ _interopDefault(path10);
+    var PackageJsonMissingNameError = class PackageJsonMissingNameError extends Error {
+      static {
+        __name(this, "PackageJsonMissingNameError");
+      }
+      constructor(directories) {
+        super(`The following package.jsons are missing the "name" field:
+${directories.join("\n")}`);
+        this.directories = directories;
+      }
+    };
+    async function getPackages5(dir, options) {
+      const monorepoRoot = await findRoot.findRoot(dir, options);
+      const packages = await monorepoRoot.tool.getPackages(monorepoRoot.rootDir);
+      validatePackages(packages);
+      return packages;
+    }
+    __name(getPackages5, "getPackages");
+    function getPackagesSync(dir, options) {
+      const monorepoRoot = findRoot.findRootSync(dir, options);
+      const packages = monorepoRoot.tool.getPackagesSync(monorepoRoot.rootDir);
+      validatePackages(packages);
+      return packages;
+    }
+    __name(getPackagesSync, "getPackagesSync");
+    function validatePackages(packages) {
+      const pkgJsonsMissingNameField = [];
+      for (const pkg of packages.packages) {
+        if (!pkg.packageJson.name) {
+          pkgJsonsMissingNameField.push(path__default["default"].join(pkg.relativeDir, "package.json"));
+        }
+      }
+      if (pkgJsonsMissingNameField.length > 0) {
+        pkgJsonsMissingNameField.sort();
+        throw new PackageJsonMissingNameError(pkgJsonsMissingNameField);
+      }
+    }
+    __name(validatePackages, "validatePackages");
+    exports.PackageJsonMissingNameError = PackageJsonMissingNameError;
+    exports.getPackages = getPackages5;
+    exports.getPackagesSync = getPackagesSync;
+  }
+});
+
+// ../../node_modules/.pnpm/@manypkg+get-packages@2.2.1/node_modules/@manypkg/get-packages/dist/manypkg-get-packages.cjs.dev.js
+var require_manypkg_get_packages_cjs_dev = __commonJS({
+  "../../node_modules/.pnpm/@manypkg+get-packages@2.2.1/node_modules/@manypkg/get-packages/dist/manypkg-get-packages.cjs.dev.js"(exports) {
+    "use strict";
+    init_esm_shims();
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    var path10 = __require("path");
+    var findRoot = __require("@manypkg/find-root");
+    function _interopDefault(e) {
+      return e && e.__esModule ? e : {
+        "default": e
+      };
+    }
+    __name(_interopDefault, "_interopDefault");
+    var path__default = /* @__PURE__ */ _interopDefault(path10);
+    var PackageJsonMissingNameError = class PackageJsonMissingNameError extends Error {
+      static {
+        __name(this, "PackageJsonMissingNameError");
+      }
+      constructor(directories) {
+        super(`The following package.jsons are missing the "name" field:
+${directories.join("\n")}`);
+        this.directories = directories;
+      }
+    };
+    async function getPackages5(dir, options) {
+      const monorepoRoot = await findRoot.findRoot(dir, options);
+      const packages = await monorepoRoot.tool.getPackages(monorepoRoot.rootDir);
+      validatePackages(packages);
+      return packages;
+    }
+    __name(getPackages5, "getPackages");
+    function getPackagesSync(dir, options) {
+      const monorepoRoot = findRoot.findRootSync(dir, options);
+      const packages = monorepoRoot.tool.getPackagesSync(monorepoRoot.rootDir);
+      validatePackages(packages);
+      return packages;
+    }
+    __name(getPackagesSync, "getPackagesSync");
+    function validatePackages(packages) {
+      const pkgJsonsMissingNameField = [];
+      for (const pkg of packages.packages) {
+        if (!pkg.packageJson.name) {
+          pkgJsonsMissingNameField.push(path__default["default"].join(pkg.relativeDir, "package.json"));
+        }
+      }
+      if (pkgJsonsMissingNameField.length > 0) {
+        pkgJsonsMissingNameField.sort();
+        throw new PackageJsonMissingNameError(pkgJsonsMissingNameField);
+      }
+    }
+    __name(validatePackages, "validatePackages");
+    exports.PackageJsonMissingNameError = PackageJsonMissingNameError;
+    exports.getPackages = getPackages5;
+    exports.getPackagesSync = getPackagesSync;
+  }
+});
+
+// ../../node_modules/.pnpm/@manypkg+get-packages@2.2.1/node_modules/@manypkg/get-packages/dist/manypkg-get-packages.cjs.js
+var require_manypkg_get_packages_cjs = __commonJS({
+  "../../node_modules/.pnpm/@manypkg+get-packages@2.2.1/node_modules/@manypkg/get-packages/dist/manypkg-get-packages.cjs.js"(exports, module) {
+    "use strict";
+    init_esm_shims();
+    if (process.env.NODE_ENV === "production") {
+      module.exports = require_manypkg_get_packages_cjs_prod();
+    } else {
+      module.exports = require_manypkg_get_packages_cjs_dev();
+    }
+  }
+});
+
 // bin/lint.ts
 init_esm_shims();
 
@@ -467,65 +600,65 @@ __name(normalizeWindowsPath, "normalizeWindowsPath");
 var _UNC_REGEX = /^[/\\]{2}/;
 var _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
 var _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
-var correctPaths = /* @__PURE__ */ __name(function(path9) {
-  if (!path9 || path9.length === 0) {
+var correctPaths = /* @__PURE__ */ __name(function(path10) {
+  if (!path10 || path10.length === 0) {
     return ".";
   }
-  path9 = normalizeWindowsPath(path9);
-  const isUNCPath = path9.match(_UNC_REGEX);
-  const isPathAbsolute = isAbsolute(path9);
-  const trailingSeparator = path9[path9.length - 1] === "/";
-  path9 = normalizeString(path9, !isPathAbsolute);
-  if (path9.length === 0) {
+  path10 = normalizeWindowsPath(path10);
+  const isUNCPath = path10.match(_UNC_REGEX);
+  const isPathAbsolute = isAbsolute(path10);
+  const trailingSeparator = path10[path10.length - 1] === "/";
+  path10 = normalizeString(path10, !isPathAbsolute);
+  if (path10.length === 0) {
     if (isPathAbsolute) {
       return "/";
     }
     return trailingSeparator ? "./" : ".";
   }
   if (trailingSeparator) {
-    path9 += "/";
+    path10 += "/";
   }
-  if (_DRIVE_LETTER_RE.test(path9)) {
-    path9 += "/";
+  if (_DRIVE_LETTER_RE.test(path10)) {
+    path10 += "/";
   }
   if (isUNCPath) {
     if (!isPathAbsolute) {
-      return `//./${path9}`;
+      return `//./${path10}`;
     }
-    return `//${path9}`;
+    return `//${path10}`;
   }
-  return isPathAbsolute && !isAbsolute(path9) ? `/${path9}` : path9;
+  return isPathAbsolute && !isAbsolute(path10) ? `/${path10}` : path10;
 }, "correctPaths");
 var joinPaths = /* @__PURE__ */ __name(function(...segments) {
-  let path9 = "";
+  let path10 = "";
   for (const seg of segments) {
     if (!seg) {
       continue;
     }
-    if (path9.length > 0) {
-      const pathTrailing = path9[path9.length - 1] === "/";
+    if (path10.length > 0) {
+      const pathTrailing = path10[path10.length - 1] === "/";
       const segLeading = seg[0] === "/";
       const both = pathTrailing && segLeading;
       if (both) {
-        path9 += seg.slice(1);
+        path10 += seg.slice(1);
       } else {
-        path9 += pathTrailing || segLeading ? seg : `/${seg}`;
+        path10 += pathTrailing || segLeading ? seg : `/${seg}`;
       }
     } else {
-      path9 += seg;
+      path10 += seg;
     }
   }
-  return correctPaths(path9);
+  return correctPaths(path10);
 }, "joinPaths");
-function normalizeString(path9, allowAboveRoot) {
+function normalizeString(path10, allowAboveRoot) {
   let res = "";
   let lastSegmentLength = 0;
   let lastSlash = -1;
   let dots = 0;
   let char = null;
-  for (let index = 0; index <= path9.length; ++index) {
-    if (index < path9.length) {
-      char = path9[index];
+  for (let index = 0; index <= path10.length; ++index) {
+    if (index < path10.length) {
+      char = path10[index];
     } else if (char === "/") {
       break;
     } else {
@@ -561,9 +694,9 @@ function normalizeString(path9, allowAboveRoot) {
         }
       } else {
         if (res.length > 0) {
-          res += `/${path9.slice(lastSlash + 1, index)}`;
+          res += `/${path10.slice(lastSlash + 1, index)}`;
         } else {
-          res = path9.slice(lastSlash + 1, index);
+          res = path10.slice(lastSlash + 1, index);
         }
         lastSegmentLength = index - lastSlash - 1;
       }
@@ -968,13 +1101,13 @@ var exitWithSuccess = /* @__PURE__ */ __name((config) => {
 }, "exitWithSuccess");
 var handleProcess = /* @__PURE__ */ __name((config) => {
   writeTrace(`Using the following arguments to process the script: ${process.argv.join(", ")}`, config);
-  process.on("unhandledRejection", (error) => {
-    writeError(`An Unhandled Rejection occurred while running the program: ${error}`, config);
+  process.on("unhandledRejection", (error2) => {
+    writeError(`An Unhandled Rejection occurred while running the program: ${error2}`, config);
     exitWithError(config);
   });
-  process.on("uncaughtException", (error) => {
-    writeError(`An Uncaught Exception occurred while running the program: ${error.message} 
-Stacktrace: ${error.stack}`, config);
+  process.on("uncaughtException", (error2) => {
+    writeError(`An Uncaught Exception occurred while running the program: ${error2.message} 
+Stacktrace: ${error2.stack}`, config);
     exitWithError(config);
   });
   process.on("SIGTERM", (signal) => {
@@ -1695,11 +1828,11 @@ function getReporter(options, config) {
   __name(relativeIssue, "relativeIssue");
   const issuesCollection = showProgress ? [] : void 0;
   const errorCollection = [];
-  function errorEmitter(message, error) {
-    if (isSpellingDictionaryLoadError(error)) {
-      error = error.cause;
+  function errorEmitter(message, error2) {
+    if (isSpellingDictionaryLoadError(error2)) {
+      error2 = error2.cause;
     }
-    const errorText = format(chalk2.red(message), error.toString());
+    const errorText = format(chalk2.red(message), error2.toString());
     errorCollection?.push(errorText);
     console.error(errorText);
   }
@@ -1725,7 +1858,7 @@ function getReporter(options, config) {
     if (errorCollection?.length && issues2 > 5) {
       console.error("-------------------------------------------");
       console.error("Errors:");
-      errorCollection.forEach((error) => console.error(error));
+      errorCollection.forEach((error2) => console.error(error2));
     }
     if (options.showPerfSummary) {
       console.error("-------------------------------------------");
@@ -2217,8 +2350,8 @@ function readFileInfo(filename, encoding = UTF8, handleNotFound = false) {
   filename = resolveFilename(filename);
   const pText = filename.startsWith(STDINProtocol) ? getStdin() : cioReadFile(filename, encoding);
   return pText.then((text) => ({ text, filename }), (e) => {
-    const error = toError(e);
-    return handleNotFound && error.code === "EISDIR" ? Promise.resolve({ text: "", filename, errorCode: error.code }) : handleNotFound && error.code === "ENOENT" ? Promise.resolve({ text: "", filename, errorCode: error.code }) : Promise.reject(new IOError(`Error reading file: "${filename}"`, error));
+    const error2 = toError(e);
+    return handleNotFound && error2.code === "EISDIR" ? Promise.resolve({ text: "", filename, errorCode: error2.code }) : handleNotFound && error2.code === "ENOENT" ? Promise.resolve({ text: "", filename, errorCode: error2.code }) : Promise.reject(new IOError(`Error reading file: "${filename}"`, error2));
   });
 }
 __name(readFileInfo, "readFileInfo");
@@ -2988,13 +3121,13 @@ async function runLint(cfg) {
     dictCollection.dictionaries.forEach((dict) => {
       const dictErrors = dict.getErrors?.() || [];
       const msg = `Dictionary Error with (${dict.name})`;
-      dictErrors.forEach((error) => {
-        const key = msg + error.toString();
+      dictErrors.forEach((error2) => {
+        const key = msg + error2.toString();
         if (configErrors.has(key))
           return;
         configErrors.add(key);
         count += 1;
-        reporter.error(msg, error);
+        reporter.error(msg, error2);
       });
     });
     return count;
@@ -3190,7 +3323,7 @@ function getLoggerFromReporter(reporter) {
     const msg = format3(...params);
     reporter.info(msg, "Info");
   }, "log");
-  const error = /* @__PURE__ */ __name((...params) => {
+  const error2 = /* @__PURE__ */ __name((...params) => {
     const msg = format3(...params);
     const err = { message: "", name: "error", toString: /* @__PURE__ */ __name(() => "", "toString") };
     reporter.error(msg, err);
@@ -3202,7 +3335,7 @@ function getLoggerFromReporter(reporter) {
   return {
     log,
     warn,
-    error
+    error: error2
   };
 }
 __name(getLoggerFromReporter, "getLoggerFromReporter");
@@ -3496,9 +3629,9 @@ var runAlex = /* @__PURE__ */ __name((rcName = "@storm-software/linting-tools/al
     silentlyIgnore: true,
     frail: true,
     defaultConfig: transform({})
-  }, (error, code) => {
-    if (error) {
-      console.error(error.message);
+  }, (error2, code) => {
+    if (error2) {
+      console.error(error2.message);
       return reject(code);
     }
     return resolve7(code);
@@ -3638,15 +3771,765 @@ __name(validateUser, "validateUser");
 
 // src/manypkg/index.ts
 init_esm_shims();
-import { checks } from "@manypkg/cli/src/checks";
-import { ExitError } from "@manypkg/cli/src/errors";
-import { npmTagAll } from "@manypkg/cli/src/npm-tag";
-import { runCmd } from "@manypkg/cli/src/run";
-import { upgradeDependency } from "@manypkg/cli/src/upgrade";
-import { install, writePackage } from "@manypkg/cli/src/utils";
-import { getPackages } from "@manypkg/get-packages";
-import pLimit from "p-limit";
+
+// ../../node_modules/.pnpm/@manypkg+cli@0.21.4/node_modules/@manypkg/cli/src/checks/index.ts
+init_esm_shims();
+
+// ../../node_modules/.pnpm/@manypkg+cli@0.21.4/node_modules/@manypkg/cli/src/checks/EXTERNAL_MISMATCH.ts
+init_esm_shims();
+
+// ../../node_modules/.pnpm/@manypkg+cli@0.21.4/node_modules/@manypkg/cli/src/checks/utils.ts
+init_esm_shims();
+import * as semver from "semver";
+import { highest } from "sembear";
+var NORMAL_DEPENDENCY_TYPES = [
+  "dependencies",
+  "devDependencies",
+  "optionalDependencies"
+];
+var DEPENDENCY_TYPES = [
+  "dependencies",
+  "devDependencies",
+  "optionalDependencies",
+  "peerDependencies"
+];
+function sortObject(prevObj) {
+  let newObj = {};
+  for (let key of Object.keys(prevObj).sort()) {
+    newObj[key] = prevObj[key];
+  }
+  return newObj;
+}
+__name(sortObject, "sortObject");
+function sortDeps(pkg) {
+  for (let depType of DEPENDENCY_TYPES) {
+    let prevDeps = pkg.packageJson[depType];
+    if (prevDeps) {
+      pkg.packageJson[depType] = sortObject(prevDeps);
+    }
+  }
+}
+__name(sortDeps, "sortDeps");
+function weakMemoize(func) {
+  let cache = /* @__PURE__ */ new WeakMap();
+  return (arg) => {
+    if (cache.has(arg)) {
+      return cache.get(arg);
+    }
+    let ret = func(arg);
+    cache.set(arg, ret);
+    return ret;
+  };
+}
+__name(weakMemoize, "weakMemoize");
+var getMostCommonRangeMap = weakMemoize(/* @__PURE__ */ __name(function getMostCommonRanges(allPackages) {
+  let dependencyRangesMapping = /* @__PURE__ */ new Map();
+  for (let [pkgName, pkg] of allPackages) {
+    for (let depType of NORMAL_DEPENDENCY_TYPES) {
+      let deps = pkg.packageJson[depType];
+      if (deps) {
+        for (let depName in deps) {
+          const depSpecifier = deps[depName];
+          if (!allPackages.has(depName)) {
+            if (!semver.validRange(deps[depName])) {
+              continue;
+            }
+            let dependencyRanges = dependencyRangesMapping.get(depName) || {};
+            const specifierCount = dependencyRanges[depSpecifier] || 0;
+            dependencyRanges[depSpecifier] = specifierCount + 1;
+            dependencyRangesMapping.set(depName, dependencyRanges);
+          }
+        }
+      }
+    }
+  }
+  let mostCommonRangeMap = /* @__PURE__ */ new Map();
+  for (let [depName, specifierMap] of dependencyRangesMapping) {
+    const specifierMapEntryArray = Object.entries(specifierMap);
+    const [first] = specifierMapEntryArray;
+    const maxValue = specifierMapEntryArray.reduce((acc, value) => {
+      if (acc[1] === value[1]) {
+        const highestRange = highest([
+          acc[0],
+          value[0]
+        ]);
+        return [
+          highestRange,
+          acc[1]
+        ];
+      }
+      if (acc[1] > value[1]) {
+        return acc;
+      }
+      return value;
+    }, first);
+    mostCommonRangeMap.set(depName, maxValue[0]);
+  }
+  return mostCommonRangeMap;
+}, "getMostCommonRanges"));
+function versionRangeToRangeType(versionRange) {
+  if (versionRange.charAt(0) === "^") return "^";
+  if (versionRange.charAt(0) === "~") return "~";
+  return "";
+}
+__name(versionRangeToRangeType, "versionRangeToRangeType");
+function isArrayEqual(arrA, arrB) {
+  for (var i = 0; i < arrA.length; i++) {
+    if (arrA[i] !== arrB[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+__name(isArrayEqual, "isArrayEqual");
+function makeCheck(check) {
+  return check;
+}
+__name(makeCheck, "makeCheck");
+
+// ../../node_modules/.pnpm/@manypkg+cli@0.21.4/node_modules/@manypkg/cli/src/checks/EXTERNAL_MISMATCH.ts
+import { validRange as validRange2 } from "semver";
+var EXTERNAL_MISMATCH_default = makeCheck({
+  validate: /* @__PURE__ */ __name((workspace, allWorkspace) => {
+    let errors = [];
+    let mostCommonRangeMap = getMostCommonRangeMap(allWorkspace);
+    for (let depType of NORMAL_DEPENDENCY_TYPES) {
+      let deps = workspace.packageJson[depType];
+      if (deps) {
+        for (let depName in deps) {
+          let range = deps[depName];
+          let mostCommonRange = mostCommonRangeMap.get(depName);
+          if (mostCommonRange !== void 0 && mostCommonRange !== range && validRange2(range)) {
+            errors.push({
+              type: "EXTERNAL_MISMATCH",
+              workspace,
+              dependencyName: depName,
+              dependencyRange: range,
+              mostCommonDependencyRange: mostCommonRange
+            });
+          }
+        }
+      }
+    }
+    return errors;
+  }, "validate"),
+  fix: /* @__PURE__ */ __name((error2) => {
+    for (let depType of NORMAL_DEPENDENCY_TYPES) {
+      let deps = error2.workspace.packageJson[depType];
+      if (deps && deps[error2.dependencyName]) {
+        deps[error2.dependencyName] = error2.mostCommonDependencyRange;
+      }
+    }
+    return {
+      requiresInstall: true
+    };
+  }, "fix"),
+  print: /* @__PURE__ */ __name((error2) => `${error2.workspace.packageJson.name} has a dependency on ${error2.dependencyName}@${error2.dependencyRange} but the most common range in the repo is ${error2.mostCommonDependencyRange}, the range should be set to ${error2.mostCommonDependencyRange}`, "print"),
+  type: "all"
+});
+
+// ../../node_modules/.pnpm/@manypkg+cli@0.21.4/node_modules/@manypkg/cli/src/checks/INTERNAL_MISMATCH.ts
+init_esm_shims();
+import semver2 from "semver";
+var INTERNAL_MISMATCH_default = makeCheck({
+  validate: /* @__PURE__ */ __name((workspace, allWorkspaces) => {
+    let errors = [];
+    for (let depType of NORMAL_DEPENDENCY_TYPES) {
+      let deps = workspace.packageJson[depType];
+      if (deps) {
+        for (let depName in deps) {
+          let range = deps[depName];
+          let dependencyWorkspace = allWorkspaces.get(depName);
+          if (dependencyWorkspace !== void 0 && !range.startsWith("npm:") && !range.startsWith("workspace:") && !semver2.satisfies(dependencyWorkspace.packageJson.version, range)) {
+            errors.push({
+              type: "INTERNAL_MISMATCH",
+              workspace,
+              dependencyWorkspace,
+              dependencyRange: range
+            });
+          }
+        }
+      }
+    }
+    return errors;
+  }, "validate"),
+  fix: /* @__PURE__ */ __name((error2) => {
+    for (let depType of NORMAL_DEPENDENCY_TYPES) {
+      let deps = error2.workspace.packageJson[depType];
+      if (deps && deps[error2.dependencyWorkspace.packageJson.name]) {
+        deps[error2.dependencyWorkspace.packageJson.name] = versionRangeToRangeType(deps[error2.dependencyWorkspace.packageJson.name]) + error2.dependencyWorkspace.packageJson.version;
+      }
+    }
+    return {
+      requiresInstall: true
+    };
+  }, "fix"),
+  print: /* @__PURE__ */ __name((error2) => `${error2.workspace.packageJson.name} has a dependency on ${error2.dependencyWorkspace.packageJson.name}@${error2.dependencyRange} but the version of ${error2.dependencyWorkspace.packageJson.name} in the repo is ${error2.dependencyWorkspace.packageJson.version} which is not within range of the depended on version, please update the dependency version`, "print"),
+  type: "all"
+});
+
+// ../../node_modules/.pnpm/@manypkg+cli@0.21.4/node_modules/@manypkg/cli/src/checks/INVALID_DEV_AND_PEER_DEPENDENCY_RELATIONSHIP.ts
+init_esm_shims();
+import { upperBoundOfRangeAWithinBoundsOfB } from "sembear";
+import semver3 from "semver";
+var INVALID_DEV_AND_PEER_DEPENDENCY_RELATIONSHIP_default = makeCheck({
+  type: "all",
+  validate: /* @__PURE__ */ __name((workspace, allWorkspaces) => {
+    let errors = [];
+    let peerDeps = workspace.packageJson.peerDependencies;
+    let devDeps = workspace.packageJson.devDependencies || {};
+    if (peerDeps) {
+      for (let depName in peerDeps) {
+        if (!devDeps[depName]) {
+          let highestRanges = getMostCommonRangeMap(allWorkspaces);
+          let idealDevVersion = highestRanges.get(depName);
+          let isInternalDependency = allWorkspaces.has(depName);
+          if (isInternalDependency) {
+            idealDevVersion = "*";
+          } else if (idealDevVersion === void 0) {
+            idealDevVersion = peerDeps[depName];
+          }
+          errors.push({
+            type: "INVALID_DEV_AND_PEER_DEPENDENCY_RELATIONSHIP",
+            workspace,
+            peerVersion: peerDeps[depName],
+            dependencyName: depName,
+            devVersion: null,
+            idealDevVersion
+          });
+        } else if (semver3.validRange(devDeps[depName]) && // TODO: we should probably error when a peer dep has an invalid range (in a seperate rule)
+        // (also would be good to do a bit more validation instead of just ignoring invalid ranges for normal dep types)
+        semver3.validRange(peerDeps[depName]) && !upperBoundOfRangeAWithinBoundsOfB(devDeps[depName], peerDeps[depName])) {
+          let highestRanges = getMostCommonRangeMap(allWorkspaces);
+          let idealDevVersion = highestRanges.get(depName);
+          if (idealDevVersion === void 0) {
+            idealDevVersion = peerDeps[depName];
+          }
+          errors.push({
+            type: "INVALID_DEV_AND_PEER_DEPENDENCY_RELATIONSHIP",
+            workspace,
+            dependencyName: depName,
+            peerVersion: peerDeps[depName],
+            devVersion: devDeps[depName],
+            idealDevVersion
+          });
+        }
+      }
+    }
+    return errors;
+  }, "validate"),
+  fix: /* @__PURE__ */ __name((error2) => {
+    if (!error2.workspace.packageJson.devDependencies) {
+      error2.workspace.packageJson.devDependencies = {};
+    }
+    error2.workspace.packageJson.devDependencies[error2.dependencyName] = error2.idealDevVersion;
+    return {
+      requiresInstall: true
+    };
+  }, "fix"),
+  print: /* @__PURE__ */ __name((error2) => {
+    if (error2.devVersion === null) {
+      return `${error2.workspace.packageJson.name} has a peerDependency on ${error2.dependencyName} but it is not also specified in devDependencies, please add it there.`;
+    }
+    return `${error2.workspace.packageJson.name} has a peerDependency on ${error2.dependencyName} but the range specified in devDependency is not greater than or equal to the range specified in peerDependencies`;
+  }, "print")
+});
+
+// ../../node_modules/.pnpm/@manypkg+cli@0.21.4/node_modules/@manypkg/cli/src/checks/INVALID_PACKAGE_NAME.ts
+init_esm_shims();
+import validateNpmPackageName from "validate-npm-package-name";
+var INVALID_PACKAGE_NAME_default = makeCheck({
+  type: "all",
+  validate: /* @__PURE__ */ __name((workspace) => {
+    if (!workspace.packageJson.name) {
+      return [
+        {
+          type: "INVALID_PACKAGE_NAME",
+          workspace,
+          errors: [
+            "name cannot be undefined"
+          ]
+        }
+      ];
+    }
+    let validationErrors = validateNpmPackageName(workspace.packageJson.name);
+    let errors = [
+      ...validationErrors.errors || [],
+      ...validationErrors.warnings || []
+    ];
+    if (errors.length) {
+      return [
+        {
+          type: "INVALID_PACKAGE_NAME",
+          workspace,
+          errors
+        }
+      ];
+    }
+    return [];
+  }, "validate"),
+  print: /* @__PURE__ */ __name((error2) => {
+    if (!error2.workspace.packageJson.name) {
+      return `The package at ${JSON.stringify(error2.workspace.relativeDir)} does not have a name`;
+    }
+    return `${error2.workspace.packageJson.name} is an invalid package name for the following reasons:
+${error2.errors.join("\n")}`;
+  }, "print")
+});
+
+// ../../node_modules/.pnpm/@manypkg+cli@0.21.4/node_modules/@manypkg/cli/src/checks/MULTIPLE_DEPENDENCY_TYPES.ts
+init_esm_shims();
+var MULTIPLE_DEPENDENCY_TYPES_default = makeCheck({
+  validate: /* @__PURE__ */ __name((workspace, allWorkspaces) => {
+    let dependencies = /* @__PURE__ */ new Set();
+    let errors = [];
+    if (workspace.packageJson.dependencies) {
+      for (let depName in workspace.packageJson.dependencies) {
+        dependencies.add(depName);
+      }
+    }
+    for (let depType of [
+      "devDependencies",
+      "optionalDependencies"
+    ]) {
+      let deps = workspace.packageJson[depType];
+      if (deps) {
+        for (let depName in deps) {
+          if (dependencies.has(depName)) {
+            errors.push({
+              type: "MULTIPLE_DEPENDENCY_TYPES",
+              dependencyType: depType,
+              dependencyName: depName,
+              workspace
+            });
+          }
+        }
+      }
+    }
+    return errors;
+  }, "validate"),
+  type: "all",
+  fix: /* @__PURE__ */ __name((error2) => {
+    let deps = error2.workspace.packageJson[error2.dependencyType];
+    if (deps) {
+      delete deps[error2.dependencyName];
+      if (Object.keys(deps).length === 0) {
+        delete error2.workspace.packageJson[error2.dependencyType];
+      }
+    }
+    return {
+      requiresInstall: true
+    };
+  }, "fix"),
+  print: /* @__PURE__ */ __name((error2) => `${error2.workspace.packageJson.name} has a dependency and a ${error2.dependencyType === "devDependencies" ? "devDependency" : "optionalDependency"} on ${error2.dependencyName}, this is unnecessary, it should be removed from ${error2.dependencyType}`, "print")
+});
+
+// ../../node_modules/.pnpm/@manypkg+cli@0.21.4/node_modules/@manypkg/cli/src/checks/ROOT_HAS_DEV_DEPENDENCIES.ts
+init_esm_shims();
+import chalk4 from "chalk";
+var ROOT_HAS_DEV_DEPENDENCIES_default = makeCheck({
+  type: "root",
+  validate: /* @__PURE__ */ __name((rootWorkspace) => {
+    if (rootWorkspace.packageJson.devDependencies) {
+      return [
+        {
+          type: "ROOT_HAS_DEV_DEPENDENCIES",
+          workspace: rootWorkspace
+        }
+      ];
+    }
+    return [];
+  }, "validate"),
+  fix: /* @__PURE__ */ __name((error2) => {
+    error2.workspace.packageJson.dependencies = sortObject({
+      ...error2.workspace.packageJson.devDependencies,
+      ...error2.workspace.packageJson.dependencies
+    });
+    delete error2.workspace.packageJson.devDependencies;
+  }, "fix"),
+  print: /* @__PURE__ */ __name(() => {
+    return `the root package.json contains ${chalk4.yellow("devDependencies")}, this is disallowed as ${chalk4.yellow("devDependencies")} vs ${chalk4.green("dependencies")} in a private package does not affect anything and creates confusion.`;
+  }, "print")
+});
+
+// ../../node_modules/.pnpm/@manypkg+cli@0.21.4/node_modules/@manypkg/cli/src/checks/UNSORTED_DEPENDENCIES.ts
+init_esm_shims();
+var UNSORTED_DEPENDENCIES_default = makeCheck({
+  type: "all",
+  validate: /* @__PURE__ */ __name((workspace) => {
+    for (let depType of DEPENDENCY_TYPES) {
+      let deps = workspace.packageJson[depType];
+      if (deps && !isArrayEqual(Object.keys(deps), Object.keys(deps).sort())) {
+        return [
+          {
+            type: "UNSORTED_DEPENDENCIES",
+            workspace
+          }
+        ];
+      }
+    }
+    return [];
+  }, "validate"),
+  fix: /* @__PURE__ */ __name((error2) => {
+    sortDeps(error2.workspace);
+  }, "fix"),
+  print: /* @__PURE__ */ __name((error2) => `${error2.workspace.packageJson.name}'s dependencies are unsorted, this can cause large diffs when packages are added, resulting in dependencies being sorted`, "print")
+});
+
+// ../../node_modules/.pnpm/@manypkg+cli@0.21.4/node_modules/@manypkg/cli/src/checks/INCORRECT_REPOSITORY_FIELD.ts
+init_esm_shims();
+import parseGithubUrl from "parse-github-url";
+import normalizePath2 from "normalize-path";
+var INCORRECT_REPOSITORY_FIELD_default = makeCheck({
+  type: "all",
+  validate: /* @__PURE__ */ __name((workspace, allWorkspaces, rootWorkspace, options) => {
+    let rootRepositoryField = rootWorkspace?.packageJson?.repository;
+    if (typeof rootRepositoryField === "string") {
+      let result = parseGithubUrl(rootRepositoryField);
+      if (result !== null && (result.host === "github.com" || result.host === "dev.azure.com")) {
+        let baseRepositoryUrl = "";
+        if (result.host === "github.com") {
+          baseRepositoryUrl = `${result.protocol}//${result.host}/${result.owner}/${result.name}`;
+        } else if (result.host === "dev.azure.com") {
+          baseRepositoryUrl = `${result.protocol}//${result.host}/${result.owner}/${result.name}/_git/${result.filepath}`;
+        }
+        if (workspace === rootWorkspace) {
+          let correctRepositoryField = baseRepositoryUrl;
+          if (rootRepositoryField !== correctRepositoryField) {
+            return [
+              {
+                type: "INCORRECT_REPOSITORY_FIELD",
+                workspace,
+                currentRepositoryField: rootRepositoryField,
+                correctRepositoryField
+              }
+            ];
+          }
+        } else {
+          let correctRepositoryField = "";
+          if (result.host === "github.com") {
+            correctRepositoryField = `${baseRepositoryUrl}/tree/${options.defaultBranch}/${normalizePath2(workspace.relativeDir)}`;
+          } else if (result.host === "dev.azure.com") {
+            correctRepositoryField = `${baseRepositoryUrl}?path=${normalizePath2(workspace.relativeDir)}&version=GB${options.defaultBranch}&_a=contents`;
+          }
+          let currentRepositoryField = workspace.packageJson.repository;
+          if (correctRepositoryField !== currentRepositoryField) {
+            return [
+              {
+                type: "INCORRECT_REPOSITORY_FIELD",
+                workspace,
+                currentRepositoryField,
+                correctRepositoryField
+              }
+            ];
+          }
+        }
+      }
+    }
+    return [];
+  }, "validate"),
+  fix: /* @__PURE__ */ __name((error2) => {
+    error2.workspace.packageJson.repository = error2.correctRepositoryField;
+  }, "fix"),
+  print: /* @__PURE__ */ __name((error2) => {
+    if (error2.currentRepositoryField === void 0) {
+      return `${error2.workspace.packageJson.name} does not have a repository field when it should be ${JSON.stringify(error2.correctRepositoryField)}`;
+    }
+    return `${error2.workspace.packageJson.name} has a repository field of ${JSON.stringify(error2.currentRepositoryField)} when it should be ${JSON.stringify(error2.correctRepositoryField)}`;
+  }, "print")
+});
+
+// ../../node_modules/.pnpm/@manypkg+cli@0.21.4/node_modules/@manypkg/cli/src/checks/WORKSPACE_REQUIRED.ts
+init_esm_shims();
+var WORKSPACE_REQUIRED_default = makeCheck({
+  validate: /* @__PURE__ */ __name((workspace, allWorkspaces, root, opts) => {
+    if (opts.workspaceProtocol !== "require") return [];
+    let errors = [];
+    for (let depType of NORMAL_DEPENDENCY_TYPES) {
+      let deps = workspace.packageJson[depType];
+      if (deps) {
+        for (let depName in deps) {
+          if (allWorkspaces.has(depName) && !deps[depName].startsWith("workspace:")) {
+            errors.push({
+              type: "WORKSPACE_REQUIRED",
+              workspace,
+              depName,
+              depType
+            });
+          }
+        }
+      }
+    }
+    return errors;
+  }, "validate"),
+  fix: /* @__PURE__ */ __name((error2) => {
+    let deps = error2.workspace.packageJson[error2.depType];
+    if (deps && deps[error2.depName]) {
+      deps[error2.depName] = "workspace:^";
+    }
+    return {
+      requiresInstall: true
+    };
+  }, "fix"),
+  print: /* @__PURE__ */ __name((error2) => `${error2.workspace.packageJson.name} has a dependency on ${error2.depName} without using the workspace: protocol but this project requires using the workspace: protocol, please change it to workspace:^ or etc.`, "print"),
+  type: "all"
+});
+
+// ../../node_modules/.pnpm/@manypkg+cli@0.21.4/node_modules/@manypkg/cli/src/checks/index.ts
+var checks = {
+  EXTERNAL_MISMATCH: EXTERNAL_MISMATCH_default,
+  INTERNAL_MISMATCH: INTERNAL_MISMATCH_default,
+  INVALID_DEV_AND_PEER_DEPENDENCY_RELATIONSHIP: INVALID_DEV_AND_PEER_DEPENDENCY_RELATIONSHIP_default,
+  INVALID_PACKAGE_NAME: INVALID_PACKAGE_NAME_default,
+  MULTIPLE_DEPENDENCY_TYPES: MULTIPLE_DEPENDENCY_TYPES_default,
+  ROOT_HAS_DEV_DEPENDENCIES: ROOT_HAS_DEV_DEPENDENCIES_default,
+  UNSORTED_DEPENDENCIES: UNSORTED_DEPENDENCIES_default,
+  INCORRECT_REPOSITORY_FIELD: INCORRECT_REPOSITORY_FIELD_default,
+  WORKSPACE_REQUIRED: WORKSPACE_REQUIRED_default
+};
+
+// ../../node_modules/.pnpm/@manypkg+cli@0.21.4/node_modules/@manypkg/cli/src/errors.ts
+init_esm_shims();
+var ExitError = class extends Error {
+  static {
+    __name(this, "ExitError");
+  }
+  code;
+  constructor(code) {
+    super(`The process should exit with code ${code}`);
+    this.code = code;
+  }
+};
+
+// ../../node_modules/.pnpm/@manypkg+cli@0.21.4/node_modules/@manypkg/cli/src/npm-tag.ts
+init_esm_shims();
+var import_get_packages = __toESM(require_manypkg_get_packages_cjs());
 import spawn from "spawndamnit";
+import pLimit from "p-limit";
+var npmLimit = pLimit(40);
+function getCorrectRegistry() {
+  let registry = process.env.npm_config_registry === "https://registry.yarnpkg.com" ? void 0 : process.env.npm_config_registry;
+  return registry;
+}
+__name(getCorrectRegistry, "getCorrectRegistry");
+async function tagApackage(packageJson, tag, otpCode) {
+  const envOverride = {
+    npm_config_registry: getCorrectRegistry()
+  };
+  let flags = [];
+  if (otpCode) {
+    flags.push("--otp", otpCode);
+  }
+  return await spawn("npm", [
+    "dist-tag",
+    "add",
+    `${packageJson.name}@${packageJson.version}`,
+    tag,
+    ...flags
+  ], {
+    stdio: "inherit",
+    env: Object.assign({}, process.env, envOverride)
+  });
+}
+__name(tagApackage, "tagApackage");
+async function npmTagAll([tag, _, otp]) {
+  let { packages } = await (0, import_get_packages.getPackages)(process.cwd());
+  await Promise.all(packages.filter(({ packageJson }) => packageJson.private !== true).map(({ packageJson }) => npmLimit(() => tagApackage(packageJson, tag, otp))));
+}
+__name(npmTagAll, "npmTagAll");
+
+// ../../node_modules/.pnpm/@manypkg+cli@0.21.4/node_modules/@manypkg/cli/src/run.ts
+init_esm_shims();
+var import_get_packages2 = __toESM(require_manypkg_get_packages_cjs());
+import spawn2 from "spawndamnit";
+
+// ../../node_modules/.pnpm/@manypkg+cli@0.21.4/node_modules/@manypkg/cli/src/logger.ts
+init_esm_shims();
+import chalk5 from "chalk";
+import util from "util";
+function format4(args, messageType, scope) {
+  let prefix = {
+    error: chalk5.red("error"),
+    success: chalk5.green("success"),
+    info: chalk5.cyan("info")
+  }[messageType];
+  let fullPrefix = "\u2614\uFE0F " + prefix + (scope === void 0 ? "" : " " + scope);
+  return fullPrefix + util.format("", ...args).split("\n").join("\n" + fullPrefix + " ");
+}
+__name(format4, "format");
+function error(message, scope) {
+  console.error(format4([
+    message
+  ], "error", scope));
+}
+__name(error, "error");
+
+// ../../node_modules/.pnpm/@manypkg+cli@0.21.4/node_modules/@manypkg/cli/src/run.ts
+async function runCmd(args, cwd) {
+  let { packages, rootDir } = await (0, import_get_packages2.getPackages)(cwd);
+  const exactMatchingPackage = packages.find((pkg) => {
+    return pkg.packageJson.name === args[0] || pkg.relativeDir === args[0];
+  });
+  if (exactMatchingPackage) {
+    const { code } = await spawn2("yarn", args.slice(1), {
+      cwd: exactMatchingPackage.dir,
+      stdio: "inherit"
+    });
+    throw new ExitError(code);
+  }
+  const matchingPackages = packages.filter((pkg) => {
+    return pkg.packageJson.name.includes(args[0]) || pkg.relativeDir.includes(args[0]);
+  });
+  if (matchingPackages.length > 1) {
+    error(`an identifier must only match a single package but "${args[0]}" matches the following packages: 
+${matchingPackages.map((x) => x.packageJson.name).join("\n")}`);
+    throw new ExitError(1);
+  } else if (matchingPackages.length === 0) {
+    error("No matching packages found");
+    throw new ExitError(1);
+  } else {
+    const { code } = await spawn2("yarn", args.slice(1), {
+      cwd: matchingPackages[0].dir,
+      stdio: "inherit"
+    });
+    throw new ExitError(code);
+  }
+}
+__name(runCmd, "runCmd");
+
+// ../../node_modules/.pnpm/@manypkg+cli@0.21.4/node_modules/@manypkg/cli/src/upgrade.ts
+init_esm_shims();
+var import_get_packages3 = __toESM(require_manypkg_get_packages_cjs());
+import semver4 from "semver";
+import pLimit2 from "p-limit";
+
+// ../../node_modules/.pnpm/@manypkg+cli@0.21.4/node_modules/@manypkg/cli/src/utils.ts
+init_esm_shims();
+import * as fs4 from "fs-extra";
+import path9 from "path";
+import spawn3 from "spawndamnit";
+import detectIndent from "detect-indent";
+async function writePackage(pkg) {
+  let pkgRaw = await fs4.readFile(path9.join(pkg.dir, "package.json"), "utf-8");
+  let indent = detectIndent(pkgRaw).indent || "  ";
+  return fs4.writeFile(path9.join(pkg.dir, "package.json"), JSON.stringify(pkg.packageJson, null, indent) + (pkgRaw.endsWith("\n") ? "\n" : ""));
+}
+__name(writePackage, "writePackage");
+async function install(toolType, cwd) {
+  const cliRunners = {
+    bolt: "bolt",
+    lerna: "lerna",
+    pnpm: "pnpm",
+    root: "yarn",
+    rush: "rushx",
+    yarn: "yarn"
+  };
+  await spawn3(cliRunners[toolType], toolType === "pnpm" ? [
+    "install"
+  ] : toolType === "lerna" ? [
+    "bootstrap",
+    "--since",
+    "HEAD"
+  ] : [], {
+    cwd,
+    stdio: "inherit"
+  });
+}
+__name(install, "install");
+
+// ../../node_modules/.pnpm/@manypkg+cli@0.21.4/node_modules/@manypkg/cli/src/upgrade.ts
+async function upgradeDependency([name, tag = "latest"]) {
+  let { packages, tool, rootPackage, rootDir } = await (0, import_get_packages3.getPackages)(process.cwd());
+  let isScope = name.startsWith("@") && !name.includes("/");
+  let newVersion = semver4.validRange(tag) ? tag : null;
+  let packagesToUpdate = /* @__PURE__ */ new Set();
+  let filteredPackages = packages.filter(({ packageJson }) => {
+    let requiresUpdate = false;
+    DEPENDENCY_TYPES.forEach((t) => {
+      let deps = packageJson[t];
+      if (!deps) return;
+      let packageNames = Object.keys(deps);
+      packageNames.forEach((pkgName) => {
+        if (isScope && pkgName.startsWith(`${name}/`) || pkgName === name) {
+          requiresUpdate = true;
+          packagesToUpdate.add(pkgName);
+        }
+      });
+    });
+    return requiresUpdate;
+  });
+  if (rootPackage) {
+    let rootRequiresUpdate = false;
+    DEPENDENCY_TYPES.forEach((t) => {
+      let deps = rootPackage.packageJson[t];
+      if (!deps) return;
+      let packageNames = Object.keys(deps);
+      packageNames.forEach((pkgName) => {
+        if (isScope && pkgName.startsWith(`${name}/`) || pkgName === name) {
+          rootRequiresUpdate = true;
+          packagesToUpdate.add(pkgName);
+        }
+      });
+      if (rootRequiresUpdate) {
+        filteredPackages.push(rootPackage);
+      }
+    });
+  }
+  let newVersions = await Promise.all([
+    ...packagesToUpdate
+  ].map(async (pkgName) => {
+    if (!newVersion) {
+      let info = await getPackageInfo(pkgName);
+      let distTags = info["dist-tags"];
+      let version2 = distTags[tag];
+      return {
+        pkgName,
+        version: version2
+      };
+    } else {
+      return {
+        pkgName,
+        version: newVersion
+      };
+    }
+  }));
+  filteredPackages.forEach(({ packageJson }) => {
+    DEPENDENCY_TYPES.forEach((t) => {
+      let deps = packageJson[t];
+      if (deps) {
+        newVersions.forEach(({ pkgName, version: version2 }) => {
+          if (deps[pkgName] && version2) {
+            if (!newVersion) {
+              deps[pkgName] = `${versionRangeToRangeType(deps[pkgName])}${version2}`;
+            } else {
+              deps[pkgName] = version2;
+            }
+          }
+        });
+      }
+    });
+  });
+  await Promise.all([
+    ...filteredPackages
+  ].map(writePackage));
+  await install(tool.type, rootDir);
+}
+__name(upgradeDependency, "upgradeDependency");
+var npmRequestLimit = pLimit2(40);
+function getPackageInfo(pkgName) {
+  return npmRequestLimit(async () => {
+    const getPackageJson = (await import("package-json")).default;
+    return getPackageJson(pkgName, {
+      allVersions: true
+    });
+  });
+}
+__name(getPackageInfo, "getPackageInfo");
+
+// src/manypkg/index.ts
+var import_get_packages4 = __toESM(require_manypkg_get_packages_cjs(), 1);
+import pLimit3 from "p-limit";
+import spawn4 from "spawndamnit";
 var defaultOptions = {
   defaultBranch: "main"
 };
@@ -3662,8 +4545,8 @@ var runChecks = /* @__PURE__ */ __name((allWorkspaces, rootWorkspace, shouldFix,
       for (const [, workspace] of allWorkspaces) {
         const errors = check.validate(workspace, allWorkspaces, rootWorkspace, options);
         if (shouldFix && check.fix !== void 0) {
-          for (const error of errors) {
-            const output = check.fix(error, options) || {
+          for (const error2 of errors) {
+            const output = check.fix(error2, options) || {
               requiresInstall: false
             };
             if (output.requiresInstall) {
@@ -3671,9 +4554,9 @@ var runChecks = /* @__PURE__ */ __name((allWorkspaces, rootWorkspace, shouldFix,
             }
           }
         } else {
-          for (const error of errors) {
+          for (const error2 of errors) {
             hasErrored = true;
-            console.error(check.print(error, options));
+            console.error(check.print(error2, options));
           }
         }
       }
@@ -3681,8 +4564,8 @@ var runChecks = /* @__PURE__ */ __name((allWorkspaces, rootWorkspace, shouldFix,
     if (check.type === "root" && rootWorkspace) {
       const errors = check.validate(rootWorkspace, allWorkspaces, options);
       if (shouldFix && check.fix !== void 0) {
-        for (const error of errors) {
-          const output = check.fix(error, options) || {
+        for (const error2 of errors) {
+          const output = check.fix(error2, options) || {
             requiresInstall: false
           };
           if (output.requiresInstall) {
@@ -3690,9 +4573,9 @@ var runChecks = /* @__PURE__ */ __name((allWorkspaces, rootWorkspace, shouldFix,
           }
         }
       } else {
-        for (const error of errors) {
+        for (const error2 of errors) {
           hasErrored = true;
-          console.error(check.print(error, options));
+          console.error(check.print(error2, options));
         }
       }
     }
@@ -3702,13 +4585,13 @@ var runChecks = /* @__PURE__ */ __name((allWorkspaces, rootWorkspace, shouldFix,
     hasErrored
   };
 }, "runChecks");
-var execLimit = pLimit(4);
+var execLimit = pLimit3(4);
 async function execCmd(args) {
-  const { packages } = await getPackages(process.cwd());
+  const { packages } = await (0, import_get_packages4.getPackages)(process.cwd());
   let highestExitCode = 0;
   await Promise.all(packages.map((pkg) => {
     return execLimit(async () => {
-      const { code } = await spawn(args[0], args.slice(1), {
+      const { code } = await spawn4(args[0], args.slice(1), {
         cwd: pkg.dir,
         stdio: "inherit"
       });
@@ -3743,7 +4626,7 @@ async function runManypkg(manypkgType = "fix", manypkgArgs) {
     console.error(`command ${manypkgType} not found, only check, exec, run, upgrade, npm-tag and fix exist`);
     process.exit(1);
   }
-  const { packages, rootPackage, rootDir } = await getPackages(process.env.STORM_WORKSPACE_ROOT ? process.env.STORM_WORKSPACE_ROOT : process.cwd());
+  const { packages, rootPackage, rootDir } = await (0, import_get_packages4.getPackages)(process.env.STORM_WORKSPACE_ROOT ? process.env.STORM_WORKSPACE_ROOT : process.cwd());
   const options = {
     ...defaultOptions,
     ...rootPackage?.packageJson.manypkg
@@ -4002,10 +4885,10 @@ void (async () => {
     await program.parseAsync(process.argv);
     writeSuccess("\u{1F389}  Code linting and fixing completed successfully!", config);
     exitWithSuccess(config);
-  } catch (error) {
+  } catch (error2) {
     writeFatal(`A fatal error occurred while running the Storm Lint tool:
-${error?.message ? error.message : JSON.stringify(error)}${error?.stack ? `
-Stack Trace: ${error.stack}` : ""}`, config);
+${error2?.message ? error2.message : JSON.stringify(error2)}${error2?.stack ? `
+Stack Trace: ${error2.stack}` : ""}`, config);
     exitWithError(config);
     process.exit(1);
   }