@xylabs/ts-scripts-yarn3 7.3.2 → 7.4.1

package/dist/actions/index.mjs

@@ -315,8 +315,8 @@ var loadConfig = async (params) => {
 
 // src/lib/parsedPackageJSON.ts
 import { readFileSync as readFileSync2 } from "fs";
-var parsedPackageJSON = (path11) => {
-  const pathToPackageJSON = path11 ?? process.env.npm_package_json ?? "";
+var parsedPackageJSON = (path13) => {
+  const pathToPackageJSON = path13 ?? process.env.npm_package_json ?? "";
   const packageJSON = readFileSync2(pathToPackageJSON).toString();
   return JSON.parse(packageJSON);
 };
@@ -598,7 +598,7 @@ var cycleAll = async ({ verbose = false }) => {
     combinedDependencies: true,
     outputType: verbose ? "text" : "err"
   };
-  const target = "**/src";
+  const target = "**/packages/*/src";
   console.log(`Checking for circular dependencies in ${target}...`);
   const result = await cruise([target], cruiseOptions);
   if (result.output) {
@@ -618,7 +618,7 @@ var dead = () => {
 };
 
 // src/actions/deplint/deplint.ts
-import chalk16 from "chalk";
+import chalk17 from "chalk";
 
 // src/actions/deplint/findFilesByGlob.ts
 import { globSync } from "glob";
@@ -627,12 +627,18 @@ function findFilesByGlob(cwd5, pattern) {
 }
 
 // src/actions/deplint/findFiles.ts
-function findFiles(path11) {
-  const allSourceInclude = ["./src/**/*.{ts,tsx}"];
+function findFiles(path13) {
+  const allSourceInclude = ["./src/**/*.{ts,tsx,mts,cts,js,mjs,cjs}"];
   const allDistInclude = ["./dist/**/*.d.ts", "./dist/**/*.{mjs,js,cjs}"];
-  const srcFiles = allSourceInclude.flatMap((pattern) => findFilesByGlob(path11, pattern));
-  const distFiles = allDistInclude.flatMap((pattern) => findFilesByGlob(path11, pattern));
-  return { srcFiles, distFiles };
+  const allConfigInclude = ["./*.config.{ts,mts,mjs,js}"];
+  const srcFiles = allSourceInclude.flatMap((pattern) => findFilesByGlob(path13, pattern));
+  const distFiles = allDistInclude.flatMap((pattern) => findFilesByGlob(path13, pattern));
+  const configFiles = allConfigInclude.flatMap((pattern) => findFilesByGlob(path13, pattern));
+  return {
+    srcFiles,
+    distFiles,
+    configFiles
+  };
 }
 
 // src/actions/deplint/getDependenciesFromPackageJson.ts
@@ -652,10 +658,9 @@ function getDependenciesFromPackageJson(packageJsonPath) {
   };
 }
 
-// src/actions/deplint/getImportsFromFile.ts
+// src/actions/deplint/getExtendsFromTsconfigs.ts
 import fs3 from "fs";
-import path4 from "path";
-import ts from "typescript";
+import { globSync as globSync2 } from "glob";
 
 // src/actions/deplint/getBasePackageName.ts
 function getBasePackageName(importName) {
@@ -667,7 +672,37 @@ function getBasePackageName(importName) {
   return importNameScrubbed.split("/")[0];
 }
 
+// src/actions/deplint/getExtendsFromTsconfigs.ts
+var isExternalReference = (ref) => !ref.startsWith(".") && !ref.startsWith("/");
+function parseExtendsField(value) {
+  if (typeof value === "string") return [value];
+  if (Array.isArray(value)) return value.filter((v) => typeof v === "string");
+  return [];
+}
+function getExtendsFromTsconfigs(location) {
+  const tsconfigFiles = globSync2("./tsconfig*.json", { cwd: location, absolute: true });
+  const packages = /* @__PURE__ */ new Set();
+  for (const file of tsconfigFiles) {
+    try {
+      const content = fs3.readFileSync(file, "utf8");
+      const cleaned = content.replaceAll(/\/\/.*/g, "").replaceAll(/,\s*([}\]])/g, "$1");
+      const parsed = JSON.parse(cleaned);
+      const refs = parseExtendsField(parsed.extends);
+      for (const ref of refs) {
+        if (isExternalReference(ref)) {
+          packages.add(getBasePackageName(ref));
+        }
+      }
+    } catch {
+    }
+  }
+  return [...packages];
+}
+
 // src/actions/deplint/getImportsFromFile.ts
+import fs4 from "fs";
+import path4 from "path";
+import ts from "typescript";
 function isTypeOnlyImportClause(clause) {
   if (clause === void 0) {
     return false;
@@ -680,7 +715,7 @@ function isTypeOnlyImportClause(clause) {
   return clause.isTypeOnly;
 }
 function getImportsFromFile(filePath, importPaths, typeImportPaths) {
-  const sourceCode = fs3.readFileSync(filePath, "utf8");
+  const sourceCode = fs4.readFileSync(filePath, "utf8");
   const isMjsFile = filePath.endsWith(".mjs");
   const sourceFile = ts.createSourceFile(
     path4.basename(filePath),
@@ -733,24 +768,38 @@ var internalImportPrefixes = [".", "#", "node:"];
 var removeInternalImports = (imports) => {
   return imports.filter((imp) => !internalImportPrefixes.some((prefix) => imp.startsWith(prefix)));
 };
-function getExternalImportsFromFiles({ srcFiles, distFiles }) {
+function getExternalImportsFromFiles({
+  srcFiles,
+  distFiles,
+  configFiles = [],
+  tsconfigExtends = []
+}) {
   const srcImportPaths = {};
   const distImportPaths = {};
   const distTypeImportPaths = {};
-  for (const path11 of srcFiles) getImportsFromFile(path11, srcImportPaths, srcImportPaths).flat();
+  const configImportPaths = {};
+  for (const path13 of srcFiles) getImportsFromFile(path13, srcImportPaths, srcImportPaths).flat();
+  for (const path13 of configFiles) getImportsFromFile(path13, configImportPaths, configImportPaths).flat();
   const distTypeFiles = distFiles.filter((file) => file.endsWith(".d.ts") || file.endsWith(".d.cts") || file.endsWith(".d.mts"));
   const distCodeFiles = distFiles.filter((file) => !(file.endsWith(".d.ts") || file.endsWith(".d.cts") || file.endsWith(".d.mts")));
-  for (const path11 of distCodeFiles) getImportsFromFile(path11, distImportPaths, distImportPaths).flat();
-  for (const path11 of distTypeFiles) getImportsFromFile(path11, distTypeImportPaths, distTypeImportPaths).flat();
+  for (const path13 of distCodeFiles) getImportsFromFile(path13, distImportPaths, distImportPaths).flat();
+  for (const path13 of distTypeFiles) getImportsFromFile(path13, distTypeImportPaths, distTypeImportPaths).flat();
   const srcImports = Object.keys(srcImportPaths);
   const distImports = Object.keys(distImportPaths);
   const distTypeImports = Object.keys(distTypeImportPaths);
   const externalSrcImports = removeInternalImports(srcImports);
   const externalDistImports = removeInternalImports(distImports);
   const externalDistTypeImports = removeInternalImports(distTypeImports);
+  const externalConfigImports = removeInternalImports(Object.keys(configImportPaths));
+  for (const ext of tsconfigExtends) {
+    if (!externalSrcImports.includes(ext)) externalSrcImports.push(ext);
+    if (!externalConfigImports.includes(ext)) externalConfigImports.push(ext);
+  }
   return {
+    configImportPaths,
     srcImports,
     srcImportPaths,
+    externalConfigImports,
     externalSrcImports,
     distImports,
     distImportPaths,
@@ -762,6 +811,15 @@ function getExternalImportsFromFiles({ srcFiles, distFiles }) {
 // src/actions/deplint/checkPackage/getUnlistedDependencies.ts
 import { builtinModules } from "module";
 import chalk12 from "chalk";
+function isListedOrBuiltin(imp, name, dependencies, peerDependencies) {
+  return dependencies.includes(imp) || imp === name || dependencies.includes(`@types/${imp}`) || peerDependencies.includes(imp) || peerDependencies.includes(`@types/${imp}`) || builtinModules.includes(imp) || builtinModules.includes(`@types/${imp}`);
+}
+function logMissing(name, imp, importPaths) {
+  console.log(`[${chalk12.blue(name)}] Missing dependency in package.json: ${chalk12.red(imp)}`);
+  if (importPaths[imp]) {
+    console.log(`  ${importPaths[imp].join("\n ")}`);
+  }
+}
 function getUnlistedDependencies({ name, location }, { dependencies, peerDependencies }, {
   externalDistImports,
   externalDistTypeImports,
@@ -769,17 +827,15 @@ function getUnlistedDependencies({ name, location }, { dependencies, peerDepende
 }) {
   let unlistedDependencies = 0;
   for (const imp of externalDistImports) {
-    if (!dependencies.includes(imp) && imp !== name && !dependencies.includes(`@types/${imp}`) && !peerDependencies.includes(imp) && !peerDependencies.includes(`@types/${imp}`) && !builtinModules.includes(imp) && !builtinModules.includes(`@types/${imp}`)) {
+    if (!isListedOrBuiltin(imp, name, dependencies, peerDependencies)) {
       unlistedDependencies++;
-      console.log(`[${chalk12.blue(name)}] Missing dependency in package.json: ${chalk12.red(imp)}`);
-      console.log(`  ${distImportPaths[imp].join("\n ")}`);
+      logMissing(name, imp, distImportPaths);
     }
   }
   for (const imp of externalDistTypeImports) {
-    if (!dependencies.includes(imp) && imp !== name && dependencies.includes(`@types/${imp}`) && !peerDependencies.includes(imp) && peerDependencies.includes(`@types/${imp}`) && !builtinModules.includes(imp) && builtinModules.includes(`@types/${imp}`)) {
+    if (!isListedOrBuiltin(imp, name, dependencies, peerDependencies)) {
       unlistedDependencies++;
-      console.log(`[${chalk12.blue(name)}] Missing dependency in package.json: ${chalk12.red(imp)}`);
-      console.log(`  ${distImportPaths[imp].join("\n ")}`);
+      logMissing(name, imp, distImportPaths);
     }
   }
   if (unlistedDependencies > 0) {
@@ -807,7 +863,9 @@ function getUnlistedDevDependencies({ name, location }, {
     if (!distImports.includes(imp) && imp !== name && !dependencies.includes(imp) && !dependencies.includes(`@types/${imp}`) && !peerDependencies.includes(imp) && !peerDependencies.includes(`@types/${imp}`) && !devDependencies.includes(imp) && !devDependencies.includes(`@types/${imp}`) && !builtinModules2.includes(imp)) {
       unlistedDevDependencies++;
       console.log(`[${chalk13.blue(name)}] Missing devDependency in package.json: ${chalk13.red(imp)}`);
-      console.log(`  ${srcImportPaths[imp].join("\n ")}`);
+      if (srcImportPaths[imp]) {
+        console.log(`  ${srcImportPaths[imp].join("\n ")}`);
+      }
     }
   }
   if (unlistedDevDependencies > 0) {
@@ -844,29 +902,243 @@ function getUnusedDependencies({ name, location }, { dependencies }, {
   return unusedDependencies;
 }
 
-// src/actions/deplint/checkPackage/getUnusedPeerDependencies.ts
+// src/actions/deplint/checkPackage/getUnusedDevDependencies.ts
 import chalk15 from "chalk";
+
+// src/actions/deplint/getRequiredPeerDependencies.ts
+import fs5 from "fs";
+import path5 from "path";
+function findDepPackageJson(location, dep) {
+  let dir = location;
+  while (true) {
+    const candidate = path5.join(dir, "node_modules", dep, "package.json");
+    if (fs5.existsSync(candidate)) return candidate;
+    const parent = path5.dirname(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+function getRequiredPeerDependencies(location, allDeps) {
+  const required = /* @__PURE__ */ new Set();
+  for (const dep of allDeps) {
+    const depPkgPath = findDepPackageJson(location, dep);
+    if (!depPkgPath) continue;
+    try {
+      const raw = fs5.readFileSync(depPkgPath, "utf8");
+      const pkg = JSON.parse(raw);
+      if (pkg.peerDependencies) {
+        for (const peer of Object.keys(pkg.peerDependencies)) {
+          required.add(peer);
+        }
+      }
+    } catch {
+    }
+  }
+  return required;
+}
+
+// src/actions/deplint/getScriptReferencedPackages.ts
+import fs6 from "fs";
+import path6 from "path";
+function getBinNames(location, dep) {
+  const depPkgPath = findDepPackageJson(location, dep);
+  if (!depPkgPath) return [];
+  try {
+    const raw = fs6.readFileSync(depPkgPath, "utf8");
+    const pkg = JSON.parse(raw);
+    if (!pkg.bin) return [];
+    if (typeof pkg.bin === "string") return [pkg.name?.split("/").pop() ?? dep];
+    return Object.keys(pkg.bin);
+  } catch {
+    return [];
+  }
+}
+function tokenizeScript(script) {
+  return script.split(/[&|;$()"`\s]+/).map((t) => t.trim()).filter(Boolean);
+}
+function getScriptReferencedPackages(location, allDeps) {
+  const pkgPath = path6.join(location, "package.json");
+  let scripts = {};
+  try {
+    const raw = fs6.readFileSync(pkgPath, "utf8");
+    const pkg = JSON.parse(raw);
+    scripts = pkg.scripts ?? {};
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+  const scriptText = Object.values(scripts).join(" ");
+  const tokens = new Set(tokenizeScript(scriptText));
+  const binToPackage = /* @__PURE__ */ new Map();
+  for (const dep of allDeps) {
+    const bins = getBinNames(location, dep);
+    for (const bin of bins) {
+      binToPackage.set(bin, dep);
+    }
+  }
+  const referenced = /* @__PURE__ */ new Set();
+  for (const token of tokens) {
+    const baseName = getBasePackageName(token);
+    if (allDeps.includes(baseName)) {
+      referenced.add(baseName);
+    }
+    const pkg = binToPackage.get(token);
+    if (pkg) {
+      referenced.add(pkg);
+    }
+  }
+  return referenced;
+}
+
+// src/actions/deplint/implicitDevDependencies.ts
+import fs7 from "fs";
+var hasFileWithExtension = (files, extensions) => files.some((f) => extensions.some((ext) => f.endsWith(ext)));
+var tsExtensions = [".ts", ".tsx", ".mts", ".cts"];
+var hasTypescriptFiles = ({ srcFiles, configFiles }) => hasFileWithExtension([...srcFiles, ...configFiles], tsExtensions);
+var decoratorPattern = /^\s*@[A-Z]\w*/m;
+var hasDecorators = ({ srcFiles }) => srcFiles.filter((f) => tsExtensions.some((ext) => f.endsWith(ext))).some((file) => {
+  try {
+    const content = fs7.readFileSync(file, "utf8");
+    return decoratorPattern.test(content);
+  } catch {
+    return false;
+  }
+});
+var importPlugins = /* @__PURE__ */ new Set(["eslint-plugin-import-x", "eslint-plugin-import"]);
+function hasImportPlugin({ location, allDependencies }) {
+  if (allDependencies.some((d) => importPlugins.has(d))) return true;
+  for (const dep of allDependencies) {
+    const pkgPath = findDepPackageJson(location, dep);
+    if (!pkgPath) continue;
+    try {
+      const pkg = JSON.parse(fs7.readFileSync(pkgPath, "utf8"));
+      const transitiveDeps = [
+        ...Object.keys(pkg.dependencies ?? {}),
+        ...Object.keys(pkg.peerDependencies ?? {})
+      ];
+      if (transitiveDeps.some((d) => importPlugins.has(d))) return true;
+    } catch {
+    }
+  }
+  return false;
+}
+var rules = [
+  {
+    package: "typescript",
+    isNeeded: hasTypescriptFiles
+  },
+  {
+    package: "eslint-import-resolver-typescript",
+    isNeeded: (context) => hasTypescriptFiles(context) && context.allDependencies.includes("eslint") && hasImportPlugin(context)
+  },
+  {
+    package: "tslib",
+    isNeeded: hasDecorators
+  }
+];
+function getImplicitDevDependencies(context) {
+  const implicit = /* @__PURE__ */ new Set();
+  for (const rule of rules) {
+    if (rule.isNeeded(context)) {
+      implicit.add(rule.package);
+    }
+  }
+  return implicit;
+}
+
+// src/actions/deplint/checkPackage/getUnusedDevDependencies.ts
+var allExternalImports = ({
+  externalSrcImports,
+  externalDistImports,
+  externalDistTypeImports,
+  externalConfigImports
+}) => {
+  const all = /* @__PURE__ */ new Set([
+    ...externalSrcImports,
+    ...externalDistImports,
+    ...externalDistTypeImports,
+    ...externalConfigImports
+  ]);
+  return all;
+};
+function isDevDepUsed(dep, allImports, implicitDeps, requiredPeers, scriptRefs) {
+  if (implicitDeps.has(dep)) return true;
+  if (requiredPeers.has(dep)) return true;
+  if (scriptRefs.has(dep)) return true;
+  if (dep.startsWith("@types/")) {
+    const baseName = dep.replace(/^@types\//, "");
+    return allImports.has(baseName) || allImports.has(dep) || implicitDeps.has(baseName);
+  }
+  return allImports.has(dep);
+}
+function getUnusedDevDependencies({ name, location }, {
+  devDependencies,
+  dependencies,
+  peerDependencies
+}, sourceParams, fileContext) {
+  const allImports = allExternalImports(sourceParams);
+  const allDeps = [...dependencies, ...devDependencies, ...peerDependencies];
+  const implicitDeps = getImplicitDevDependencies({
+    ...fileContext,
+    allDependencies: allDeps,
+    location
+  });
+  const requiredPeers = getRequiredPeerDependencies(location, allDeps);
+  const scriptRefs = getScriptReferencedPackages(location, allDeps);
+  let unusedDevDependencies = 0;
+  for (const dep of devDependencies) {
+    if (dependencies.includes(dep) || peerDependencies.includes(dep)) continue;
+    if (!isDevDepUsed(dep, allImports, implicitDeps, requiredPeers, scriptRefs)) {
+      unusedDevDependencies++;
+      console.log(`[${chalk15.blue(name)}] Unused devDependency in package.json: ${chalk15.red(dep)}`);
+    }
+  }
+  if (unusedDevDependencies > 0) {
+    const packageLocation = `${location}/package.json`;
+    console.log(`  ${chalk15.yellow(packageLocation)}
+`);
+  }
+  return unusedDevDependencies;
+}
+
+// src/actions/deplint/checkPackage/getUnusedPeerDependencies.ts
+import chalk16 from "chalk";
 function getUnusedPeerDependencies({ name, location }, { peerDependencies, dependencies }, { externalDistImports, externalDistTypeImports }) {
   let unusedDependencies = 0;
   for (const dep of peerDependencies) {
     if (!externalDistImports.includes(dep) && !externalDistImports.includes(dep.replace(/^@types\//, "")) && !externalDistTypeImports.includes(dep) && !externalDistTypeImports.includes(dep.replace(/^@types\//, ""))) {
       unusedDependencies++;
       if (dependencies.includes(dep)) {
-        console.log(`[${chalk15.blue(name)}] Unused peerDependency [already a dependency] in package.json: ${chalk15.red(dep)}`);
+        console.log(`[${chalk16.blue(name)}] Unused peerDependency [already a dependency] in package.json: ${chalk16.red(dep)}`);
       } else {
-        console.log(`[${chalk15.blue(name)}] Unused peerDependency in package.json: ${chalk15.red(dep)}`);
+        console.log(`[${chalk16.blue(name)}] Unused peerDependency in package.json: ${chalk16.red(dep)}`);
       }
     }
   }
   if (unusedDependencies > 0) {
     const packageLocation = `${location}/package.json`;
-    console.log(`  ${chalk15.yellow(packageLocation)}
+    console.log(`  ${chalk16.yellow(packageLocation)}
 `);
   }
   return unusedDependencies;
 }
 
 // src/actions/deplint/checkPackage/checkPackage.ts
+function logVerbose(name, location, srcFiles, distFiles, configFiles, tsconfigExtends) {
+  console.info(`Checking package: ${name} at ${location}`);
+  console.info(`Source files: ${srcFiles.length}, Distribution files: ${distFiles.length}, Config files: ${configFiles.length}`);
+  for (const file of srcFiles) {
+    console.info(`Source file: ${file}`);
+  }
+  for (const file of distFiles) {
+    console.info(`Distribution file: ${file}`);
+  }
+  for (const file of configFiles) {
+    console.info(`Config file: ${file}`);
+  }
+  for (const ext of tsconfigExtends) {
+    console.info(`Tsconfig extends: ${ext}`);
+  }
+}
 function checkPackage({
   name,
   location,
@@ -875,27 +1147,36 @@ function checkPackage({
   peerDeps = false,
   verbose = false
 }) {
-  const { srcFiles, distFiles } = findFiles(location);
+  const {
+    srcFiles,
+    distFiles,
+    configFiles
+  } = findFiles(location);
+  const tsconfigExtends = getExtendsFromTsconfigs(location);
   if (verbose) {
-    console.info(`Checking package: ${name} at ${location}`);
-    console.info(`Source files: ${srcFiles.length}, Distribution files: ${distFiles.length}`);
-    for (const file of srcFiles) {
-      console.info(`Source file: ${file}`);
-    }
-    for (const file of distFiles) {
-      console.info(`Distribution file: ${file}`);
-    }
+    logVerbose(name, location, srcFiles, distFiles, configFiles, tsconfigExtends);
   }
   const checkDeps = deps || !(deps || devDeps || peerDeps);
   const checkDevDeps = devDeps || !(deps || devDeps || peerDeps);
   const checkPeerDeps = peerDeps;
-  const sourceParams = getExternalImportsFromFiles({ srcFiles, distFiles });
+  const sourceParams = getExternalImportsFromFiles({
+    srcFiles,
+    distFiles,
+    configFiles,
+    tsconfigExtends
+  });
   const packageParams = getDependenciesFromPackageJson(`${location}/package.json`);
   const unlistedDependencies = checkDeps ? getUnlistedDependencies({ name, location }, packageParams, sourceParams) : 0;
   const unusedDependencies = checkDeps ? getUnusedDependencies({ name, location }, packageParams, sourceParams) : 0;
   const unlistedDevDependencies = checkDevDeps ? getUnlistedDevDependencies({ name, location }, packageParams, sourceParams) : 0;
+  const fileContext = {
+    configFiles,
+    distFiles,
+    srcFiles
+  };
+  const unusedDevDependencies = checkDevDeps ? getUnusedDevDependencies({ name, location }, packageParams, sourceParams, fileContext) : 0;
   const unusedPeerDependencies = checkPeerDeps ? getUnusedPeerDependencies({ name, location }, packageParams, sourceParams) : 0;
-  const totalErrors = unlistedDependencies + unlistedDevDependencies + unusedDependencies + unusedPeerDependencies;
+  const totalErrors = unlistedDependencies + unlistedDevDependencies + unusedDependencies + unusedDevDependencies + unusedPeerDependencies;
   return totalErrors;
 }
 
@@ -933,9 +1214,9 @@ var deplint = ({
     });
   }
   if (totalErrors > 0) {
-    console.warn(`Deplint: Found ${chalk16.red(totalErrors)} dependency problems. ${chalk16.red("\u2716")}`);
+    console.warn(`Deplint: Found ${chalk17.red(totalErrors)} dependency problems. ${chalk17.red("\u2716")}`);
   } else {
-    console.info(`Deplint: Found no dependency problems. ${chalk16.green("\u2714")}`);
+    console.info(`Deplint: Found no dependency problems. ${chalk17.green("\u2714")}`);
   }
   return 0;
 };
@@ -1037,22 +1318,22 @@ var deployNext = () => {
 };
 
 // src/actions/dupdeps.ts
-import chalk17 from "chalk";
+import chalk18 from "chalk";
 var dupdeps = () => {
-  console.log(chalk17.green("Checking all Dependencies for Duplicates"));
+  console.log(chalk18.green("Checking all Dependencies for Duplicates"));
   const allDependencies = parsedPackageJSON()?.dependencies;
   const dependencies = Object.entries(allDependencies).map(([k]) => k);
   return detectDuplicateDependencies(dependencies);
 };
 
 // src/actions/lint.ts
-import chalk18 from "chalk";
+import chalk19 from "chalk";
 var lintPackage = ({
   pkg,
   fix: fix2,
   verbose
 }) => {
-  console.log(chalk18.gray(`${fix2 ? "Fix" : "Lint"} [${pkg}]`));
+  console.log(chalk19.gray(`${fix2 ? "Fix" : "Lint"} [${pkg}]`));
   const start = Date.now();
   const result = runSteps(`${fix2 ? "Fix" : "Lint"}  [${pkg}]`, [
     ["yarn", [
@@ -1062,7 +1343,7 @@ var lintPackage = ({
       fix2 ? "package-fix" : verbose ? "package-lint-verbose" : "package-lint"
     ]]
   ]);
-  console.log(chalk18.gray(`${fix2 ? "Fixed in" : "Linted in"} [${chalk18.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk18.gray("seconds")}`));
+  console.log(chalk19.gray(`${fix2 ? "Fixed in" : "Linted in"} [${chalk19.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk19.gray("seconds")}`));
   return result;
 };
 var lint = ({
@@ -1082,13 +1363,13 @@ var lint = ({
   });
 };
 var lintAllPackages = ({ fix: fix2 = false } = {}) => {
-  console.log(chalk18.gray(`${fix2 ? "Fix" : "Lint"} [All-Packages]`));
+  console.log(chalk19.gray(`${fix2 ? "Fix" : "Lint"} [All-Packages]`));
   const start = Date.now();
   const fixOptions = fix2 ? ["--fix"] : [];
   const result = runSteps(`${fix2 ? "Fix" : "Lint"}  [All-Packages]`, [
     ["yarn", ["eslint", "--cache", "--cache-location", ".eslintcache", "--cache-strategy", "content", ...fixOptions]]
   ]);
-  console.log(chalk18.gray(`${fix2 ? "Fixed in" : "Linted in"} [${chalk18.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk18.gray("seconds")}`));
+  console.log(chalk19.gray(`${fix2 ? "Fixed in" : "Linted in"} [${chalk19.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk19.gray("seconds")}`));
   return result;
 };
 
@@ -1116,7 +1397,7 @@ var filename = ".gitignore";
 var gitignoreGen = (pkg) => generateIgnoreFiles(filename, pkg);
 
 // src/actions/gitlint.ts
-import chalk19 from "chalk";
+import chalk20 from "chalk";
 import ParseGitConfig from "parse-git-config";
 var gitlint = () => {
   console.log(`
@@ -1127,7 +1408,7 @@ Gitlint Start [${process.cwd()}]
   const errors = 0;
   const gitConfig = ParseGitConfig.sync();
   const warn = (message) => {
-    console.warn(chalk19.yellow(`Warning: ${message}`));
+    console.warn(chalk20.yellow(`Warning: ${message}`));
     warnings++;
   };
   if (gitConfig.core.ignorecase) {
@@ -1147,13 +1428,13 @@ Gitlint Start [${process.cwd()}]
   }
   const resultMessages = [];
   if (valid > 0) {
-    resultMessages.push(chalk19.green(`Passed: ${valid}`));
+    resultMessages.push(chalk20.green(`Passed: ${valid}`));
   }
   if (warnings > 0) {
-    resultMessages.push(chalk19.yellow(`Warnings: ${warnings}`));
+    resultMessages.push(chalk20.yellow(`Warnings: ${warnings}`));
   }
   if (errors > 0) {
-    resultMessages.push(chalk19.red(` Errors: ${errors}`));
+    resultMessages.push(chalk20.red(` Errors: ${errors}`));
   }
   console.warn(`Gitlint Finish [ ${resultMessages.join(" | ")} ]
 `);
@@ -1162,7 +1443,7 @@ Gitlint Start [${process.cwd()}]
 
 // src/actions/gitlint-fix.ts
 import { execSync as execSync2 } from "child_process";
-import chalk20 from "chalk";
+import chalk21 from "chalk";
 import ParseGitConfig2 from "parse-git-config";
 var gitlintFix = () => {
   console.log(`
@@ -1171,15 +1452,15 @@ Gitlint Fix Start [${process.cwd()}]
   const gitConfig = ParseGitConfig2.sync();
   if (gitConfig.core.ignorecase) {
     execSync2("git config core.ignorecase false", { stdio: "inherit" });
-    console.warn(chalk20.yellow("\nGitlint Fix: Updated core.ignorecase to be false\n"));
+    console.warn(chalk21.yellow("\nGitlint Fix: Updated core.ignorecase to be false\n"));
   }
   if (gitConfig.core.autocrlf !== false) {
     execSync2("git config core.autocrlf false", { stdio: "inherit" });
-    console.warn(chalk20.yellow("\nGitlint Fix: Updated core.autocrlf to be false\n"));
+    console.warn(chalk21.yellow("\nGitlint Fix: Updated core.autocrlf to be false\n"));
   }
   if (gitConfig.core.eol !== "lf") {
     execSync2("git config core.eol lf", { stdio: "inherit" });
-    console.warn(chalk20.yellow('\nGitlint Fix: Updated core.eol to be "lf"\n'));
+    console.warn(chalk21.yellow('\nGitlint Fix: Updated core.eol to be "lf"\n'));
   }
   return 1;
 };
@@ -1190,7 +1471,7 @@ var knip = () => {
 };
 
 // src/actions/license.ts
-import chalk21 from "chalk";
+import chalk22 from "chalk";
 import { init } from "license-checker";
 var license = async (pkg) => {
   const workspaces = yarnWorkspaces();
@@ -1215,18 +1496,18 @@ var license = async (pkg) => {
     "LGPL-3.0-or-later",
     "Python-2.0"
   ]);
-  console.log(chalk21.green("License Checker"));
+  console.log(chalk22.green("License Checker"));
   return (await Promise.all(
     workspaceList.map(({ location, name }) => {
       return new Promise((resolve) => {
         init({ production: true, start: location }, (error, packages) => {
           if (error) {
-            console.error(chalk21.red(`License Checker [${name}] Error`));
-            console.error(chalk21.gray(error));
+            console.error(chalk22.red(`License Checker [${name}] Error`));
+            console.error(chalk22.gray(error));
             console.log("\n");
             resolve(1);
           } else {
-            console.log(chalk21.green(`License Checker [${name}]`));
+            console.log(chalk22.green(`License Checker [${name}]`));
             let count = 0;
             for (const [name2, info] of Object.entries(packages)) {
               const licenses = Array.isArray(info.licenses) ? info.licenses : [info.licenses];
@@ -1242,7 +1523,7 @@ var license = async (pkg) => {
                   }
                   if (!orLicenseFound) {
                     count++;
-                    console.warn(chalk21.yellow(`${name2}: Package License not allowed [${license2}]`));
+                    console.warn(chalk22.yellow(`${name2}: Package License not allowed [${license2}]`));
                   }
                 }
               }
@@ -1261,13 +1542,13 @@ var filename2 = ".npmignore";
 var npmignoreGen = (pkg) => generateIgnoreFiles(filename2, pkg);
 
 // src/actions/package/clean-outputs.ts
-import path5 from "path";
-import chalk22 from "chalk";
+import path7 from "path";
+import chalk23 from "chalk";
 var packageCleanOutputs = () => {
   const pkg = process.env.INIT_CWD ?? ".";
   const pkgName = process.env.npm_package_name;
-  const folders = [path5.join(pkg, "dist"), path5.join(pkg, "build"), path5.join(pkg, "docs")];
-  console.log(chalk22.green(`Cleaning Outputs [${pkgName}]`));
+  const folders = [path7.join(pkg, "dist"), path7.join(pkg, "build"), path7.join(pkg, "docs")];
+  console.log(chalk23.green(`Cleaning Outputs [${pkgName}]`));
   for (let folder of folders) {
     deleteGlob(folder);
   }
@@ -1275,13 +1556,13 @@ var packageCleanOutputs = () => {
 };
 
 // src/actions/package/clean-typescript.ts
-import path6 from "path";
-import chalk23 from "chalk";
+import path8 from "path";
+import chalk24 from "chalk";
 var packageCleanTypescript = () => {
   const pkg = process.env.INIT_CWD ?? ".";
   const pkgName = process.env.npm_package_name;
-  console.log(chalk23.green(`Cleaning Typescript [${pkgName}]`));
-  const files = [path6.join(pkg, "*.tsbuildinfo"), path6.join(pkg, ".tsconfig.*"), path6.join(pkg, ".eslintcache")];
+  console.log(chalk24.green(`Cleaning Typescript [${pkgName}]`));
+  const files = [path8.join(pkg, "*.tsbuildinfo"), path8.join(pkg, ".tsconfig.*"), path8.join(pkg, ".eslintcache")];
   for (let file of files) {
     deleteGlob(file);
   }
@@ -1294,26 +1575,26 @@ var packageClean = async () => {
 };
 
 // src/actions/package/compile/compile.ts
-import chalk28 from "chalk";
+import chalk29 from "chalk";
 
 // src/actions/package/compile/packageCompileTsup.ts
-import chalk27 from "chalk";
+import chalk28 from "chalk";
 import { build as build2, defineConfig } from "tsup";
 
 // src/actions/package/compile/inputs.ts
-import chalk24 from "chalk";
+import chalk25 from "chalk";
 import { glob as glob2 } from "glob";
 var getAllInputs = (srcDir, verbose = false) => {
   return [...glob2.sync(`${srcDir}/**/*.ts`, { posix: true }).map((file) => {
     const result = file.slice(Math.max(0, srcDir.length + 1));
     if (verbose) {
-      console.log(chalk24.gray(`getAllInputs: ${JSON.stringify(result, null, 2)}`));
+      console.log(chalk25.gray(`getAllInputs: ${JSON.stringify(result, null, 2)}`));
     }
     return result;
   }), ...glob2.sync(`${srcDir}/**/*.tsx`, { posix: true }).map((file) => {
     const result = file.slice(Math.max(0, srcDir.length + 1));
     if (verbose) {
-      console.log(chalk24.gray(`getAllInputs: ${JSON.stringify(result, null, 2)}`));
+      console.log(chalk25.gray(`getAllInputs: ${JSON.stringify(result, null, 2)}`));
     }
     return result;
   })];
@@ -1372,7 +1653,7 @@ function deepMergeObjects(objects) {
 
 // src/actions/package/compile/packageCompileTsc.ts
 import { cwd as cwd2 } from "process";
-import chalk25 from "chalk";
+import chalk26 from "chalk";
 import { createProgramFromConfig } from "tsc-prog";
 import ts2, {
   DiagnosticCategory,
@@ -1394,7 +1675,7 @@ var getCompilerOptions = (options = {}, fileName = "tsconfig.json") => {
 var packageCompileTsc = (platform, entries, srcDir = "src", outDir = "dist", compilerOptionsParam, verbose = false) => {
   const pkg = process.env.INIT_CWD ?? cwd2();
   if (verbose) {
-    console.log(chalk25.cyan(`Validating code START: ${entries.length} files to ${outDir} from ${srcDir}`));
+    console.log(chalk26.cyan(`Validating code START: ${entries.length} files to ${outDir} from ${srcDir}`));
   }
   const configFilePath = ts2.findConfigFile(
     "./",
@@ -1417,10 +1698,10 @@ var packageCompileTsc = (platform, entries, srcDir = "src", outDir = "dist", com
     emitDeclarationOnly: true,
     noEmit: false
   };
-  console.log(chalk25.cyan(`Validating Files: ${entries.length}`));
+  console.log(chalk26.cyan(`Validating Files: ${entries.length}`));
   if (verbose) {
     for (const entry of entries) {
-      console.log(chalk25.grey(`Validating: ${entry}`));
+      console.log(chalk26.grey(`Validating: ${entry}`));
     }
   }
   try {
@@ -1450,22 +1731,22 @@ var packageCompileTsc = (platform, entries, srcDir = "src", outDir = "dist", com
     return 0;
   } finally {
     if (verbose) {
-      console.log(chalk25.cyan(`Validating code FINISH: ${entries.length} files to ${outDir} from ${srcDir}`));
+      console.log(chalk26.cyan(`Validating code FINISH: ${entries.length} files to ${outDir} from ${srcDir}`));
     }
   }
 };
 
 // src/actions/package/compile/packageCompileTscTypes.ts
-import path7 from "path";
+import path9 from "path";
 import { cwd as cwd3 } from "process";
-import chalk26 from "chalk";
+import chalk27 from "chalk";
 import { rollup } from "rollup";
 import dts from "rollup-plugin-dts";
 import nodeExternals from "rollup-plugin-node-externals";
 var ignoredWarningCodes = /* @__PURE__ */ new Set(["EMPTY_BUNDLE", "UNRESOLVED_IMPORT"]);
 async function bundleDts(inputPath, outputPath, platform, options, verbose = false) {
   const pkg = process.env.INIT_CWD ?? cwd3();
-  const tsconfigPath = path7.resolve(pkg, "tsconfig.json");
+  const tsconfigPath = path9.resolve(pkg, "tsconfig.json");
   const nodePlugIns = platform === "node" ? [nodeExternals()] : [];
   try {
     const bundle = await rollup({
@@ -1483,8 +1764,8 @@ async function bundleDts(inputPath, outputPath, platform, options, verbose = fal
         if (ignoredWarningCodes.has(warning.code ?? "")) {
           return;
         }
-        console.warn(chalk26.yellow(`[${warning.code}] ${warning.message}`));
-        console.warn(chalk26.gray(inputPath));
+        console.warn(chalk27.yellow(`[${warning.code}] ${warning.message}`));
+        console.warn(chalk27.gray(inputPath));
         warn(warning);
       }
     });
@@ -1494,8 +1775,8 @@ async function bundleDts(inputPath, outputPath, platform, options, verbose = fal
     });
   } catch (ex) {
     const error = ex;
-    console.warn(chalk26.red(error));
-    console.warn(chalk26.gray(inputPath));
+    console.warn(chalk27.red(error));
+    console.warn(chalk27.gray(inputPath));
   }
   if (verbose) {
     console.log(`Bundled declarations written to ${outputPath}`);
@@ -1503,7 +1784,7 @@ async function bundleDts(inputPath, outputPath, platform, options, verbose = fal
 }
 var packageCompileTscTypes = async (entries, outDir, platform, srcDir = "build", verbose = false) => {
   if (verbose) {
-    console.log(chalk26.cyan(`Compiling Types START [${platform}]: ${entries.length} files to ${outDir} from ${srcDir}`));
+    console.log(chalk27.cyan(`Compiling Types START [${platform}]: ${entries.length} files to ${outDir} from ${srcDir}`));
     console.log(`Entries: ${entries.join(", ")}`);
   }
   const pkg = process.env.INIT_CWD ?? cwd3();
@@ -1527,7 +1808,7 @@ var packageCompileTscTypes = async (entries, outDir, platform, srcDir = "build",
     await bundleDts(`${srcRoot}/${entryTypeName}`, `${outDir}/${entryTypeName}`, platform, { compilerOptions }, verbose);
   }));
   if (verbose) {
-    console.log(chalk26.cyan(`Compiling Types FINISH: ${entries.length} files to ${outDir} from ${srcDir}`));
+    console.log(chalk27.cyan(`Compiling Types FINISH: ${entries.length} files to ${outDir} from ${srcDir}`));
   }
   return 0;
 };
@@ -1539,15 +1820,15 @@ var compileFolder = async (srcDir, entries, buildDir, options, bundleTypes = fal
     console.log(`compileFolder [${srcDir}, ${options?.outDir}]`);
   }
   if (entries.length === 0) {
-    console.warn(chalk27.yellow(`No entries found in ${srcDir} to compile`));
+    console.warn(chalk28.yellow(`No entries found in ${srcDir} to compile`));
     return 0;
   }
   if (verbose) {
-    console.log(chalk27.gray(`buildDir [${buildDir}]`));
+    console.log(chalk28.gray(`buildDir [${buildDir}]`));
   }
   const validationResult = packageCompileTsc(options?.platform ?? "neutral", entries, srcDir, buildDir, void 0, verbose);
   if (validationResult !== 0) {
-    console.error(chalk27.red(`Compile:Validation had ${validationResult} errors`));
+    console.error(chalk28.red(`Compile:Validation had ${validationResult} errors`));
     return validationResult;
   }
   const optionsParams = tsupOptions([{
@@ -1572,12 +1853,12 @@ var compileFolder = async (srcDir, entries, buildDir, options, bundleTypes = fal
     })
   )).flat();
   if (verbose) {
-    console.log(chalk27.cyan(`TSUP:build:start [${srcDir}]`));
-    console.log(chalk27.gray(`TSUP:build:options [${JSON.stringify(optionsList, null, 2)}]`));
+    console.log(chalk28.cyan(`TSUP:build:start [${srcDir}]`));
+    console.log(chalk28.gray(`TSUP:build:options [${JSON.stringify(optionsList, null, 2)}]`));
   }
   await Promise.all(optionsList.map((options2) => build2(options2)));
   if (verbose) {
-    console.log(chalk27.cyan(`TSUP:build:stop [${srcDir}]`));
+    console.log(chalk28.cyan(`TSUP:build:stop [${srcDir}]`));
   }
   if (bundleTypes) {
     await packageCompileTscTypes(entries, outDir, options?.platform ?? "neutral", buildDir, verbose);
@@ -1688,14 +1969,14 @@ var packageCompileTsup = async (config2) => {
 // src/actions/package/compile/compile.ts
 var packageCompile = async (inConfig = {}) => {
   const pkg = process.env.INIT_CWD;
-  console.log(chalk28.green(`Compiling ${pkg}`));
+  console.log(chalk29.green(`Compiling ${pkg}`));
   const config2 = await loadConfig(inConfig);
   return await packageCompileTsup(config2);
 };
 
 // src/actions/package/copy-assets.ts
-import path8 from "path/posix";
-import chalk29 from "chalk";
+import path10 from "path/posix";
+import chalk30 from "chalk";
 import cpy2 from "cpy";
 var copyTargetAssets2 = async (target, name, location) => {
   try {
@@ -1703,12 +1984,12 @@ var copyTargetAssets2 = async (target, name, location) => {
       ["**/*.jpg", "**/*.png", "**/*.gif", "**/*.svg", "**/*.webp", "**/*.sass", "**/*.scss", "**/*.gif", "**/*.css"],
       `../dist/${target}`,
       {
-        cwd: path8.join(location, "src"),
+        cwd: path10.join(location, "src"),
         flat: false
       }
     );
     if (values.length > 0) {
-      console.log(chalk29.green(`Copying Assets [${target.toUpperCase()}] - ${name} - ${location}`));
+      console.log(chalk30.green(`Copying Assets [${target.toUpperCase()}] - ${name} - ${location}`));
     }
     for (const value of values) {
       console.log(`${value.split("/").pop()} => ./dist/${target}`);
@@ -1774,8 +2055,8 @@ var packageCycle = async () => {
 
 // src/actions/package/gen-docs.ts
 import { existsSync as existsSync4 } from "fs";
-import path9 from "path";
-import chalk30 from "chalk";
+import path11 from "path";
+import chalk31 from "chalk";
 import {
   Application,
   ArgumentsReader,
@@ -1793,7 +2074,7 @@ var ExitCodes = {
 };
 var packageGenDocs = async () => {
   const pkg = process.env.INIT_CWD;
-  if (pkg !== void 0 && !existsSync4(path9.join(pkg, "typedoc.json"))) {
+  if (pkg !== void 0 && !existsSync4(path11.join(pkg, "typedoc.json"))) {
     return;
   }
   const app = await Application.bootstrap({
@@ -1879,16 +2160,16 @@ var runTypeDoc = async (app) => {
       return ExitCodes.OutputError;
     }
   }
-  console.log(chalk30.green(`${pkgName} - Ok`));
+  console.log(chalk31.green(`${pkgName} - Ok`));
   return ExitCodes.Ok;
 };
 
 // src/actions/package/lint.ts
 import { readdirSync } from "fs";
-import path10 from "path";
+import path12 from "path";
 import { cwd as cwd4 } from "process";
 import { pathToFileURL } from "url";
-import chalk31 from "chalk";
+import chalk32 from "chalk";
 import { ESLint } from "eslint";
 import { findUp } from "find-up";
 import picomatch from "picomatch";
@@ -1897,14 +2178,14 @@ var dumpMessages = (lintResults) => {
   const severity = ["none", "warning", "error"];
   for (const lintResult of lintResults) {
     if (lintResult.messages.length > 0) {
-      console.log(chalk31.gray(`
+      console.log(chalk32.gray(`
 ${lintResult.filePath}`));
       for (const message of lintResult.messages) {
         console.log(
-          chalk31.gray(`	${message.line}:${message.column}`),
-          chalk31[colors[message.severity]](`	${severity[message.severity]}`),
-          chalk31.white(`	${message.message}`),
-          chalk31.gray(`	${message.ruleId}`)
+          chalk32.gray(`	${message.line}:${message.column}`),
+          chalk32[colors[message.severity]](`	${severity[message.severity]}`),
+          chalk32.white(`	${message.message}`),
+          chalk32.gray(`	${message.ruleId}`)
         );
       }
     }
@@ -1922,7 +2203,7 @@ function getFiles(dir, ignoreFolders) {
   const subDirectory = dir.split(currentDirectory)[1]?.split("/")[1];
   if (ignoreFolders.includes(subDirectory)) return [];
   return readdirSync(dir, { withFileTypes: true }).flatMap((dirent) => {
-    const res = path10.resolve(dir, dirent.name);
+    const res = path12.resolve(dir, dirent.name);
     const relativePath = subDirectory === void 0 ? dirent.name : `${subDirectory}/${dirent.name}`;
     const ignoreMatchers = ignoreFolders.map((pattern) => picomatch(pattern));
     if (ignoreMatchers.some((isMatch) => isMatch(relativePath))) return [];
@@ -1942,10 +2223,10 @@ var packageLint = async (fix2 = false, verbose = false, cache = true) => {
     cache
   });
   const files = getFiles(cwd4(), ignoreFolders);
-  console.log(chalk31.green(`Linting ${pkg} [files = ${files.length}]`));
+  console.log(chalk32.green(`Linting ${pkg} [files = ${files.length}]`));
   if (verbose) {
     for (const file of files) {
-      console.log(chalk31.gray(`	${file}`));
+      console.log(chalk32.gray(`	${file}`));
     }
   }
   const lintResults = await engine.lintFiles(files);
@@ -1956,43 +2237,43 @@ var packageLint = async (fix2 = false, verbose = false, cache = true) => {
   const filesCountColor = files.length < 100 ? "green" : files.length < 1e3 ? "yellow" : "red";
   const lintTime = Date.now() - start;
   const lintTimeColor = lintTime < 1e3 ? "green" : lintTime < 3e3 ? "yellow" : "red";
-  console.log(chalk31.white(`Linted ${chalk31[filesCountColor](files.length)} files in ${chalk31[lintTimeColor](lintTime)}ms`));
+  console.log(chalk32.white(`Linted ${chalk32[filesCountColor](files.length)} files in ${chalk32[lintTimeColor](lintTime)}ms`));
   return lintResults.reduce((prev, lintResult) => prev + lintResult.errorCount, 0);
 };
 
 // src/actions/package/publint.ts
-import { promises as fs4 } from "fs";
-import chalk32 from "chalk";
+import { promises as fs8 } from "fs";
+import chalk33 from "chalk";
 import sortPackageJson from "sort-package-json";
 var customPubLint = (pkg) => {
   let errorCount = 0;
   let warningCount = 0;
   if (pkg.files === void 0) {
-    console.warn(chalk32.yellow('Publint [custom]: "files" field is missing'));
+    console.warn(chalk33.yellow('Publint [custom]: "files" field is missing'));
     warningCount++;
   }
   if (pkg.main !== void 0) {
-    console.warn(chalk32.yellow('Publint [custom]: "main" field is deprecated, use "exports" instead'));
+    console.warn(chalk33.yellow('Publint [custom]: "main" field is deprecated, use "exports" instead'));
     warningCount++;
   }
   if (pkg.sideEffects !== false) {
-    console.warn(chalk32.yellow('Publint [custom]: "sideEffects" field should be set to false'));
+    console.warn(chalk33.yellow('Publint [custom]: "sideEffects" field should be set to false'));
     warningCount++;
   }
   if (pkg.resolutions !== void 0) {
-    console.warn(chalk32.yellow('Publint [custom]: "resolutions" in use'));
-    console.warn(chalk32.gray(JSON.stringify(pkg.resolutions, null, 2)));
+    console.warn(chalk33.yellow('Publint [custom]: "resolutions" in use'));
+    console.warn(chalk33.gray(JSON.stringify(pkg.resolutions, null, 2)));
     warningCount++;
   }
   return [errorCount, warningCount];
 };
 var packagePublint = async ({ strict = true, verbose = false } = {}) => {
   const pkgDir = process.env.INIT_CWD;
-  const sortedPkg = sortPackageJson(await fs4.readFile(`${pkgDir}/package.json`, "utf8"));
-  await fs4.writeFile(`${pkgDir}/package.json`, sortedPkg);
-  const pkg = JSON.parse(await fs4.readFile(`${pkgDir}/package.json`, "utf8"));
-  console.log(chalk32.green(`Publint: ${pkg.name}`));
-  console.log(chalk32.gray(pkgDir));
+  const sortedPkg = sortPackageJson(await fs8.readFile(`${pkgDir}/package.json`, "utf8"));
+  await fs8.writeFile(`${pkgDir}/package.json`, sortedPkg);
+  const pkg = JSON.parse(await fs8.readFile(`${pkgDir}/package.json`, "utf8"));
+  console.log(chalk33.green(`Publint: ${pkg.name}`));
+  console.log(chalk33.gray(pkgDir));
   const { publint: publint2 } = await import("publint");
   const { messages } = await publint2({
     level: "suggestion",
@@ -2003,22 +2284,22 @@ var packagePublint = async ({ strict = true, verbose = false } = {}) => {
   for (const message of messages) {
     switch (message.type) {
       case "error": {
-        console.error(chalk32.red(`[${message.code}] ${formatMessage(message, pkg)}`));
+        console.error(chalk33.red(`[${message.code}] ${formatMessage(message, pkg)}`));
         break;
       }
       case "warning": {
-        console.warn(chalk32.yellow(`[${message.code}] ${formatMessage(message, pkg)}`));
+        console.warn(chalk33.yellow(`[${message.code}] ${formatMessage(message, pkg)}`));
         break;
       }
       default: {
-        console.log(chalk32.white(`[${message.code}] ${formatMessage(message, pkg)}`));
+        console.log(chalk33.white(`[${message.code}] ${formatMessage(message, pkg)}`));
         break;
       }
     }
   }
   const [errorCount, warningCount] = customPubLint(pkg);
   if (verbose) {
-    console.log(chalk32.gray(`Publint [Finish]: ${pkgDir} [${messages.length + errorCount + warningCount} messages]`));
+    console.log(chalk33.gray(`Publint [Finish]: ${pkgDir} [${messages.length + errorCount + warningCount} messages]`));
   }
   return messages.filter((message) => message.type === "error").length + errorCount;
 };
@@ -2054,7 +2335,7 @@ var rebuild = ({ target }) => {
 };
 
 // src/actions/recompile.ts
-import chalk33 from "chalk";
+import chalk34 from "chalk";
 var recompile = async ({
   verbose,
   target,
@@ -2090,7 +2371,7 @@ var recompileAll = async ({
   const incrementalOptions = incremental ? ["--since", "-Apt", "--topological-dev"] : ["--parallel", "-Apt", "--topological-dev"];
   const jobsOptions = jobs ? ["-j", `${jobs}`] : [];
   if (jobs) {
-    console.log(chalk33.blue(`Jobs set to [${jobs}]`));
+    console.log(chalk34.blue(`Jobs set to [${jobs}]`));
   }
   const result = await runStepsAsync(`Recompile${incremental ? "-Incremental" : ""} [All]`, [
     [
@@ -2121,7 +2402,7 @@ var recompileAll = async ({
     ]
   ]);
   console.log(
-    `${chalk33.gray("Recompiled in")} [${chalk33.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk33.gray("seconds")}`
+    `${chalk34.gray("Recompiled in")} [${chalk34.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk34.gray("seconds")}`
   );
   return result;
 };
@@ -2152,13 +2433,13 @@ var reinstall = () => {
 };
 
 // src/actions/relint.ts
-import chalk34 from "chalk";
+import chalk35 from "chalk";
 var relintPackage = ({
   pkg,
   fix: fix2,
   verbose
 }) => {
-  console.log(chalk34.gray(`${fix2 ? "Fix" : "Lint"} [${pkg}]`));
+  console.log(chalk35.gray(`${fix2 ? "Fix" : "Lint"} [${pkg}]`));
   const start = Date.now();
   const result = runSteps(`${fix2 ? "Fix" : "Lint"}  [${pkg}]`, [
     ["yarn", [
@@ -2168,7 +2449,7 @@ var relintPackage = ({
       fix2 ? "package-fix" : verbose ? "package-lint-verbose" : "package-lint"
     ]]
   ]);
-  console.log(chalk34.gray(`${fix2 ? "Fixed in" : "Linted in"} [${chalk34.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk34.gray("seconds")}`));
+  console.log(chalk35.gray(`${fix2 ? "Fixed in" : "Linted in"} [${chalk35.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk35.gray("seconds")}`));
   return result;
 };
 var relint = ({
@@ -2188,13 +2469,13 @@ var relint = ({
   });
 };
 var relintAllPackages = ({ fix: fix2 = false } = {}) => {
-  console.log(chalk34.gray(`${fix2 ? "Fix" : "Lint"} [All-Packages]`));
+  console.log(chalk35.gray(`${fix2 ? "Fix" : "Lint"} [All-Packages]`));
   const start = Date.now();
   const fixOptions = fix2 ? ["--fix"] : [];
   const result = runSteps(`${fix2 ? "Fix" : "Lint"}  [All-Packages]`, [
     ["yarn", ["eslint", ...fixOptions]]
   ]);
-  console.log(chalk34.gray(`${fix2 ? "Fixed in" : "Linted in"} [${chalk34.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk34.gray("seconds")}`));
+  console.log(chalk35.gray(`${fix2 ? "Fixed in" : "Linted in"} [${chalk35.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk35.gray("seconds")}`));
   return result;
 };
 
@@ -2212,10 +2493,10 @@ var sonar = () => {
 };
 
 // src/actions/statics.ts
-import chalk35 from "chalk";
+import chalk36 from "chalk";
 var DefaultDependencies = ["axios", "@xylabs/pixel", "react", "graphql", "react-router", "@mui/material", "@mui/system"];
 var statics = () => {
-  console.log(chalk35.green("Check Required Static Dependencies"));
+  console.log(chalk36.green("Check Required Static Dependencies"));
   const statics2 = parsedPackageJSON()?.xy?.deps?.statics;
   return detectDuplicateDependencies(statics2, DefaultDependencies);
 };