@xylabs/ts-scripts-yarn3 3.14.2 → 3.15.0

package/dist/index.mjs

@@ -1,5 +1,2988 @@
-export * from "./actions";
-export * from "./lib";
-export * from "./loadPackageConfig";
-export * from "./xy";
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/actions/build.ts
+import chalk9 from "chalk";
+
+// src/lib/checkResult.ts
+import chalk from "chalk";
+var checkResult = /* @__PURE__ */ __name((name, result, level = "error", exitOnFail = false) => {
+  if (result) {
+    const exiting = exitOnFail ? "[Exiting Process]" : "[Continuing]";
+    const chalkFunc = level === "error" ? chalk.red : chalk.yellow;
+    console[level](chalkFunc(`${name} had ${result} failures ${exiting}`));
+    if (exitOnFail) {
+      process.exit(result);
+    }
+  }
+}, "checkResult");
+
+// src/lib/createBuildConfig.ts
+import { readFileSync } from "node:fs";
+
+// src/lib/defaultBuildConfig.ts
+var defaultBuildConfig = {
+  compilerOptions: {
+    rootDir: "src",
+    rootDirs: [
+      "package.json"
+    ]
+  },
+  exclude: [
+    "**/build",
+    "**/dist",
+    "**/node_modules",
+    "**/*.spec.*",
+    "**/*.spec",
+    "**/*.stories.*",
+    "**/*.example.*",
+    "**/spec/*",
+    "**/stories/*"
+  ],
+  include: [
+    "src"
+  ]
+};
+
+// src/lib/createBuildConfig.ts
+var getGeneralTypescriptConfig = /* @__PURE__ */ __name((location) => {
+  let generalConfig;
+  try {
+    generalConfig = readFileSync(`${location}/tsconfig.json`, {
+      encoding: "utf8"
+    });
+  } catch {
+    return false;
+  }
+  return JSON.parse(generalConfig);
+}, "getGeneralTypescriptConfig");
+var createBuildConfig = /* @__PURE__ */ __name((location, module, target, outDirSuffix) => {
+  const generalConfigObject = getGeneralTypescriptConfig(location);
+  if (generalConfigObject === false) {
+    return void 0;
+  }
+  return {
+    ...generalConfigObject,
+    compilerOptions: {
+      ...defaultBuildConfig.compilerOptions,
+      ...generalConfigObject.compilerOptions,
+      module,
+      outDir: `./${generalConfigObject.compilerOptions?.outDir ?? "dist"}/${outDirSuffix}`,
+      target
+    },
+    exclude: [
+      ...generalConfigObject.exclude ?? [],
+      ...defaultBuildConfig.exclude
+    ],
+    include: [
+      ...generalConfigObject.include ?? [],
+      ...defaultBuildConfig.include
+    ]
+  };
+}, "createBuildConfig");
+
+// src/lib/dependencies/detectDuplicateDependencies.ts
+import { execSync } from "node:child_process";
+
+// src/lib/processEx.ts
+import chalk2 from "chalk";
+
+// src/lib/withError.ts
+var withError = /* @__PURE__ */ __name((ex, closure, predicate = (ex2) => ex2.name !== void 0 && ex2.message !== void 0) => {
+  return predicate(ex) ? closure(ex) : void 0;
+}, "withError");
+
+// src/lib/withErrnoException.ts
+var withErrnoException = /* @__PURE__ */ __name((ex, closure) => {
+  return withError(ex, closure, (ex2) => ex2.errno !== void 0);
+}, "withErrnoException");
+
+// src/lib/processEx.ts
+var processEx = /* @__PURE__ */ __name((ex) => {
+  const error = typeof ex === "string" ? new Error(ex) : ex;
+  const exitCode = withErrnoException(error, (error2) => {
+    if (error2.code === "ENOENT") {
+      console.error(chalk2.red(`'${error2.path}' not found.`));
+    } else {
+      console.error(chalk2.red(`Errno: ${error2.code}`));
+    }
+    return error2.errno ?? -1;
+  }) ?? withError(error, (error2) => {
+    console.error(chalk2.red(`${error2.name}: ${error2.message}`));
+    return -1;
+  }) ?? (() => {
+    console.error(chalk2.red(`Unexpected Error: ${JSON.stringify(ex, null, 2)}`));
+    return -1;
+  })();
+  process.exit(process.exitCode ?? exitCode);
+}, "processEx");
+
+// src/lib/safeExit.ts
+var safeExit = /* @__PURE__ */ __name((func, exitOnFail = true) => {
+  try {
+    const result = func();
+    if (result && exitOnFail) {
+      process.exit(result);
+    }
+    return result;
+  } catch (ex) {
+    return processEx(ex);
+  }
+}, "safeExit");
+var safeExitAsync = /* @__PURE__ */ __name(async (func, exitOnFail = true) => {
+  try {
+    const result = await func();
+    if (result && exitOnFail) {
+      process.exit(result);
+    }
+    return result;
+  } catch (ex) {
+    return processEx(ex);
+  }
+}, "safeExitAsync");
+
+// src/lib/dependencies/DuplicateDetector.ts
+import { EOL } from "node:os";
+import chalk3 from "chalk";
+import { uniq } from "lodash-es";
+
+// src/lib/jsonFormatters.ts
+var multiLineToJSONArray = /* @__PURE__ */ __name((output) => {
+  const withCommas = output.replaceAll("\r\n", "").replaceAll("\n", ",");
+  const cleanCollection = withCommas.slice(0, Math.max(0, withCommas.length - 1));
+  const collection = `[${cleanCollection}]`;
+  return JSON.parse(collection);
+}, "multiLineToJSONArray");
+
+// src/lib/dependencies/DuplicateDetector.ts
+var trimVirtualMeta = /* @__PURE__ */ __name((value) => {
+  const virtualParts = value.split("virtual:");
+  if (virtualParts.length > 1) {
+    const hashParts = virtualParts[1].split("#");
+    return virtualParts[0] + hashParts[1];
+  } else {
+    return value;
+  }
+}, "trimVirtualMeta");
+var trimObjectDependencyVirtualMeta = /* @__PURE__ */ __name((obj) => {
+  const resultObj = {};
+  for (const [key, value] of Object.entries(obj)) {
+    resultObj[trimVirtualMeta(key)] = {
+      descriptor: trimVirtualMeta(value.descriptor),
+      locator: trimVirtualMeta(value.locator)
+    };
+  }
+  return resultObj;
+}, "trimObjectDependencyVirtualMeta");
+var trimDependencyVirtualMeta = /* @__PURE__ */ __name((dependencies) => {
+  return dependencies.map((dependency) => {
+    return {
+      children: trimObjectDependencyVirtualMeta(dependency.children),
+      value: trimVirtualMeta(dependency.value)
+    };
+  });
+}, "trimDependencyVirtualMeta");
+var DuplicateDetector = class {
+  static {
+    __name(this, "DuplicateDetector");
+  }
+  dependency;
+  dependencyEntries;
+  constructor(output, dependency) {
+    this.dependency = dependency;
+    this.dependencyEntries = trimDependencyVirtualMeta(multiLineToJSONArray(output));
+  }
+  detect() {
+    const result = this.dependencyEntries.reduce(this.detectReducer, this.resultsFactory(this.dependency));
+    if (result.duplicateVersions.length > 0) {
+      console.log(chalk3.yellow(`${EOL}Duplicates found for: ${this.dependency}`));
+      const duplicateVersions = result.duplicateVersions.toString().replaceAll(",", `${EOL}  `);
+      console.log(chalk3.grey(`  ${duplicateVersions}`, EOL));
+      return 1;
+    } else {
+      console.log(`${this.dependency} - OK`);
+      return 0;
+    }
+  }
+  detectReducer(acc, entry) {
+    const version = Object.entries(entry.children).map(([k]) => k)[0];
+    if (!acc.currentVersion) {
+      acc.currentVersion = version;
+      return acc;
+    }
+    if (acc.currentVersion && acc.currentVersion !== version && !version.includes("@virtual:")) {
+      if (acc.duplicateVersions.length === 0) {
+        acc.duplicateVersions.push(acc.currentVersion);
+      }
+      acc.duplicateVersions.push(version);
+      acc.duplicateVersions = uniq(acc.duplicateVersions);
+    }
+    return acc;
+  }
+  resultsFactory = /* @__PURE__ */ __name((dependency) => ({
+    currentVersion: void 0,
+    dependency,
+    duplicateVersions: []
+  }), "resultsFactory");
+};
+
+// src/lib/dependencies/detectDuplicateDependencies.ts
+var detectDuplicateDependencies = /* @__PURE__ */ __name((depsFromPackageJSON, DefaultDependencies2) => {
+  let exitCode = 0;
+  const dependencies = depsFromPackageJSON?.length ? depsFromPackageJSON : DefaultDependencies2;
+  return safeExit(() => {
+    if (dependencies) {
+      for (const dependency of dependencies) {
+        let output;
+        try {
+          const cmd = `yarn why ${dependency} --json`;
+          output = execSync(cmd).toString();
+        } catch (e) {
+          console.error(`Error running yarn why: ${e}`);
+          exitCode = 1;
+          exitCode;
+          continue;
+        }
+        if (output) {
+          exitCode = new DuplicateDetector(output, dependency).detect();
+          exitCode;
+        } else {
+          console.log(`${dependency} - N/A`);
+          if (depsFromPackageJSON) {
+            exitCode = 1;
+            console.log(`\u{1F6A8} Library ${dependency} was requested in package.json but not found`);
+          }
+          exitCode;
+        }
+      }
+      return exitCode;
+    } else {
+      console.log("\u{1F6A8} No dependencies where passed");
+      return exitCode;
+    }
+  });
+}, "detectDuplicateDependencies");
+
+// src/lib/file/constants.ts
+var WINDOWS_NEWLINE_REGEX = /\r\n/g;
+var CROSS_PLATFORM_NEWLINE = "\n";
+
+// src/lib/file/fileLines.ts
+import { existsSync, readFileSync as readFileSync2, writeFileSync } from "node:fs";
+
+// src/lib/string/empty.ts
+var empty = /* @__PURE__ */ __name((value) => value?.trim().length === 0, "empty");
+var notEmpty = /* @__PURE__ */ __name((value) => !empty(value), "notEmpty");
+
+// src/lib/string/union.ts
+var union = /* @__PURE__ */ __name((a, b) => /* @__PURE__ */ new Set([
+  ...new Set(a),
+  ...new Set(b)
+]), "union");
+
+// src/lib/file/ReadFileSyncOptions.ts
+var defaultReadFileSyncOptions = {
+  encoding: "utf8"
+};
+
+// src/lib/file/fileLines.ts
+var readLines = /* @__PURE__ */ __name((uri, options = defaultReadFileSyncOptions) => existsSync(uri) ? readFileSync2(uri, options).replace(WINDOWS_NEWLINE_REGEX, CROSS_PLATFORM_NEWLINE).split(CROSS_PLATFORM_NEWLINE) : [], "readLines");
+var readNonEmptyLines = /* @__PURE__ */ __name((uri, options = defaultReadFileSyncOptions) => readLines(uri, options).filter(notEmpty), "readNonEmptyLines");
+var writeLines = /* @__PURE__ */ __name((uri, lines, options = defaultReadFileSyncOptions) => {
+  const existing = existsSync(uri) ? readFileSync2(uri, options) : void 0;
+  const desired = lines.join(CROSS_PLATFORM_NEWLINE);
+  if (existing !== desired) writeFileSync(uri, desired, options);
+}, "writeLines");
+
+// src/lib/file/tryReadFileSync.ts
+import { existsSync as existsSync2, readFileSync as readFileSync3 } from "node:fs";
+var tryReadFileSync = /* @__PURE__ */ __name((uri, options = defaultReadFileSyncOptions) => {
+  return existsSync2(uri) ? readFileSync3(uri, options) : void 0;
+}, "tryReadFileSync");
+
+// src/lib/generateIgnoreFiles.ts
+import chalk4 from "chalk";
+
+// src/lib/yarn/isYarnVersionOrGreater.ts
+import { spawnSync } from "node:child_process";
+var isYarnVersionOrGreater = /* @__PURE__ */ __name((major, minor, patch) => {
+  const result = spawnSync("yarn", [
+    "-v"
+  ], {
+    encoding: "utf8",
+    shell: true
+  });
+  const version = result.stdout.toString().replaceAll("\n", "");
+  const versionNumbers = version.split(".").map((ver) => Number.parseInt(ver));
+  const majorDelta = versionNumbers[0] - major;
+  const minorDelta = versionNumbers[1] - (minor ?? versionNumbers[1]);
+  const patchDelta = versionNumbers[2] - (patch ?? versionNumbers[2]);
+  const majorOk = majorDelta >= 0;
+  const minorOk = majorDelta > 0 || minorDelta >= 0;
+  const patchOk = majorDelta > 0 || minorDelta > 0 || patchDelta >= 0;
+  return [
+    majorOk && minorOk && patchOk,
+    version
+  ];
+}, "isYarnVersionOrGreater");
+
+// src/lib/yarn/workspace/yarnWorkspaces.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+var yarnWorkspaces = /* @__PURE__ */ __name(() => {
+  const result = spawnSync2("yarn", [
+    "workspaces",
+    "list",
+    "--json",
+    "--recursive"
+  ], {
+    encoding: "utf8",
+    shell: true
+  });
+  if (result.error) {
+    throw result.error;
+  }
+  return result.stdout.toString().split("\n").slice(0, -1).map((item) => {
+    return JSON.parse(item);
+  });
+}, "yarnWorkspaces");
+
+// src/lib/yarn/workspace/yarnWorkspace.ts
+var yarnWorkspace = /* @__PURE__ */ __name((pkg) => {
+  const workspace = yarnWorkspaces().find(({ name }) => name === pkg);
+  if (!workspace) throw new Error(`Workspace ${pkg} not found`);
+  return workspace;
+}, "yarnWorkspace");
+
+// src/lib/yarn/yarnInitCwd.ts
+var INIT_CWD = /* @__PURE__ */ __name(() => {
+  if (!process.env.INIT_CWD) console.error("Missing INIT_CWD");
+  return process.env.INIT_CWD;
+}, "INIT_CWD");
+
+// src/lib/generateIgnoreFiles.ts
+var mergeEntries = /* @__PURE__ */ __name((a, b) => [
+  ...union(a, b)
+].sort(), "mergeEntries");
+var generateIgnoreFiles = /* @__PURE__ */ __name((filename3, pkg) => {
+  console.log(chalk4.green(`Generate ${filename3} Files`));
+  const cwd4 = INIT_CWD() ?? ".";
+  const workspaces = pkg ? [
+    yarnWorkspace(pkg)
+  ] : yarnWorkspaces();
+  const readEntries = /* @__PURE__ */ __name((location) => readNonEmptyLines(`${location}/${filename3}`), "readEntries");
+  const writeEntries = /* @__PURE__ */ __name((location, entries) => writeLines(`${location}/${filename3}`, entries), "writeEntries");
+  const results = workspaces.map(({ location, name }) => {
+    try {
+      writeEntries(location, mergeEntries(readEntries(cwd4), readEntries(location)));
+      return 0;
+    } catch (ex) {
+      const error = ex;
+      console.error(`Generate ${filename3} Files [${name}] [${error.message}]`);
+      return 1;
+    }
+  });
+  const succeeded = results.every((result) => result === 0);
+  return succeeded ? 0 : 1;
+}, "generateIgnoreFiles");
+
+// src/lib/loadConfig.ts
+import chalk5 from "chalk";
+import { cosmiconfig } from "cosmiconfig";
+import { merge } from "lodash-es";
+var config;
+var loadConfig = /* @__PURE__ */ __name(async (params) => {
+  if (config) {
+    return merge({}, config, params);
+  }
+  const cosmicConfigResult = await cosmiconfig("xy", {
+    cache: true
+  }).search();
+  config = cosmicConfigResult?.config;
+  const configFilePath = cosmicConfigResult?.filepath;
+  if (configFilePath) {
+    console.log(chalk5.gray(`Loading config from ${configFilePath}`));
+  }
+  return merge({}, config, params);
+}, "loadConfig");
+
+// src/lib/parsedPackageJSON.ts
+import { readFileSync as readFileSync4 } from "node:fs";
+var parsedPackageJSON = /* @__PURE__ */ __name((path7) => {
+  const pathToPackageJSON = path7 ?? process.env.npm_package_json ?? "";
+  const packageJSON = readFileSync4(pathToPackageJSON).toString();
+  return JSON.parse(packageJSON);
+}, "parsedPackageJSON");
+
+// src/lib/runSteps.ts
+import { spawnSync as spawnSync3 } from "node:child_process";
+import { existsSync as existsSync3 } from "node:fs";
+import chalk6 from "chalk";
+var runSteps = /* @__PURE__ */ __name((name, steps, exitOnFail = true, messages) => {
+  return safeExit(() => {
+    const pkgName = process.env.npm_package_name;
+    console.log(chalk6.green(`${name} [${pkgName}]`));
+    let totalStatus = 0;
+    for (const [i, [command, args, config2]] of steps.entries()) {
+      if (messages?.[i]) {
+        console.log(chalk6.gray(messages?.[i]));
+      }
+      const argList = Array.isArray(args) ? args : args.split(" ");
+      if (command === "node" && !existsSync3(argList[0])) {
+        throw new Error(`File not found [${argList[0]}]`);
+      }
+      const status = spawnSync3(command, Array.isArray(args) ? args : args.split(" "), {
+        ...config2,
+        encoding: "utf8",
+        env: {
+          FORCE_COLOR: "3",
+          ...process.env
+        },
+        shell: true,
+        stdio: "inherit"
+      }).status ?? 0;
+      checkResult(name, status, "error", exitOnFail);
+      totalStatus += status ?? 0;
+    }
+    return totalStatus;
+  }, !!exitOnFail);
+}, "runSteps");
+
+// src/lib/runStepsAsync.ts
+import { spawn } from "node:child_process";
+import { existsSync as existsSync4 } from "node:fs";
+import chalk7 from "chalk";
+var runStepAsync = /* @__PURE__ */ __name((name, step, exitOnFail = true, message) => {
+  return new Promise((resolve) => {
+    const [command, args, config2] = step;
+    if (message) {
+      console.log(chalk7.gray(message));
+    }
+    const argList = Array.isArray(args) ? args : args.split(" ");
+    if (command === "node" && !existsSync4(argList[0])) {
+      throw new Error(`File not found [${argList[0]}]`);
+    }
+    spawn(command, Array.isArray(args) ? args : args.split(" "), {
+      ...config2,
+      env: {
+        FORCE_COLOR: "3",
+        ...process.env
+      },
+      shell: true,
+      stdio: "inherit"
+    }).on("close", (code) => {
+      if (code) {
+        console.error(chalk7.red(`Command Exited With Non-Zero Result [${chalk7.gray(code)}] | ${chalk7.yellow(command)} ${chalk7.white(Array.isArray(args) ? args.join(" ") : args)}`));
+        checkResult(name, code, "error", exitOnFail);
+        resolve(code);
+      } else {
+        resolve(0);
+      }
+    });
+  });
+}, "runStepAsync");
+var runStepsAsync = /* @__PURE__ */ __name(async (name, steps, exitOnFail = true, messages) => {
+  return await safeExitAsync(async () => {
+    const pkgName = process.env.npm_package_name;
+    console.log(chalk7.green(`${name} [${pkgName}]`));
+    let result = 0;
+    for (const [i, step] of steps.entries()) {
+      result += await runStepAsync(name, step, exitOnFail, messages?.[i]);
+    }
+    return result;
+  });
+}, "runStepsAsync");
+
+// src/lib/runXy.ts
+var runXy = /* @__PURE__ */ __name((command) => {
+  return runSteps(`XY [${command}]`, [
+    [
+      "yarn",
+      [
+        "xy",
+        command,
+        ...process.argv.filter((value, index) => index > 1 ? value : void 0)
+      ]
+    ]
+  ]);
+}, "runXy");
+
+// src/lib/runXyWithWarning.ts
+import chalk8 from "chalk";
+var runXyWithWarning = /* @__PURE__ */ __name((command) => {
+  const commandString = `yarn ${command}`;
+  const commandXyString = `yarn xy ${command}`;
+  console.warn(chalk8.yellow(`WARNING: [${chalk8.white(commandString)}] is deprecated for XY Labs Scripts.`));
+  console.warn(chalk8.gray(`Did you mean [${chalk8.magenta(commandXyString)}]?`));
+  return 1;
+}, "runXyWithWarning");
+
+// src/actions/build.ts
+var build = /* @__PURE__ */ __name(async ({ incremental, jobs, target, verbose, pkg }) => {
+  const start = Date.now();
+  const pkgOptions = pkg ? [
+    pkg
+  ] : [];
+  const incrementalOptions = incremental ? [
+    "-i"
+  ] : [];
+  const verboseOptions = verbose ? [
+    "-v"
+  ] : [];
+  const targetOptions = target ? [
+    "-t",
+    target
+  ] : [];
+  const jobsOptions = jobs ? [
+    "-j",
+    `${jobs}`
+  ] : [];
+  if (jobs) {
+    console.log(chalk9.blue(`Jobs set to [${jobs}]`));
+  }
+  const result = await runStepsAsync(`Build${incremental ? "-Incremental" : ""} [${pkg ?? "All"}]`, [
+    [
+      "yarn",
+      [
+        "xy",
+        "compile",
+        ...pkgOptions,
+        ...targetOptions,
+        ...verboseOptions,
+        ...jobsOptions,
+        ...incrementalOptions
+      ]
+    ],
+    [
+      "yarn",
+      [
+        "xy",
+        "lint",
+        ...pkgOptions,
+        ...verboseOptions,
+        ...incrementalOptions
+      ]
+    ],
+    [
+      "yarn",
+      [
+        "xy",
+        "deps",
+        ...pkgOptions,
+        ...verboseOptions,
+        ...jobsOptions,
+        ...incrementalOptions
+      ]
+    ]
+  ]);
+  console.log(`${chalk9.gray("Built in")} [${chalk9.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk9.gray("seconds")}`);
+  return result;
+}, "build");
+
+// src/actions/clean.ts
+var clean = /* @__PURE__ */ __name(async ({ verbose, pkg }) => {
+  return pkg ? await cleanPackage({
+    pkg,
+    verbose
+  }) : cleanAll({
+    verbose
+  });
+}, "clean");
+var cleanPackage = /* @__PURE__ */ __name(({ pkg }) => {
+  return runStepsAsync(`Clean [${pkg}]`, [
+    [
+      "yarn",
+      [
+        "workspace",
+        pkg,
+        "run",
+        "package-clean"
+      ]
+    ]
+  ]);
+}, "cleanPackage");
+var cleanAll = /* @__PURE__ */ __name(({ verbose }) => {
+  const verboseOptions = verbose ? [
+    "--verbose"
+  ] : [
+    "--no-verbose"
+  ];
+  return runStepsAsync("Clean", [
+    [
+      "yarn",
+      [
+        "workspaces foreach",
+        "-pA",
+        "--jobs 64",
+        ...verboseOptions,
+        "run",
+        "package-clean"
+      ]
+    ]
+  ]);
+}, "cleanAll");
+
+// src/actions/clean-docs.ts
+import path from "node:path";
+import chalk10 from "chalk";
+import { rimrafSync } from "rimraf";
+var cleanDocs = /* @__PURE__ */ __name(() => {
+  const pkgName = process.env.npm_package_name;
+  console.log(chalk10.green(`Cleaning Docs [${pkgName}]`));
+  for (const { location } of yarnWorkspaces()) rimrafSync(path.join(location, "docs"), {
+    glob: true
+  });
+  return 0;
+}, "cleanDocs");
+
+// src/actions/compile.ts
+import chalk11 from "chalk";
+var compile = /* @__PURE__ */ __name(({ verbose, target, pkg, incremental, publint: publint2 }) => {
+  return pkg ? compilePackage({
+    pkg,
+    publint: publint2,
+    target,
+    verbose
+  }) : compileAll({
+    incremental,
+    publint: publint2,
+    target,
+    verbose
+  });
+}, "compile");
+var compilePackage = /* @__PURE__ */ __name(({ target, pkg }) => {
+  const targetOptions = target ? [
+    "-t",
+    target
+  ] : [];
+  return runSteps(`Compile [${pkg}]`, [
+    [
+      "yarn",
+      [
+        "workspace",
+        pkg,
+        "run",
+        "package-compile",
+        ...targetOptions
+      ]
+    ]
+  ]);
+}, "compilePackage");
+var compileAll = /* @__PURE__ */ __name(({ jobs, verbose, target, incremental }) => {
+  const start = Date.now();
+  const verboseOptions = verbose ? [
+    "--verbose"
+  ] : [
+    "--no-verbose"
+  ];
+  const targetOptions = target ? [
+    "-t",
+    target
+  ] : [];
+  const incrementalOptions = incremental ? [
+    "--since",
+    "-Apt",
+    "--topological-dev"
+  ] : [
+    "--parallel",
+    "-Apt",
+    "--topological-dev"
+  ];
+  const jobsOptions = jobs ? [
+    "-j",
+    `${jobs}`
+  ] : [];
+  if (jobs) {
+    console.log(chalk11.blue(`Jobs set to [${jobs}]`));
+  }
+  const result = runSteps(`Compile${incremental ? "-Incremental" : ""} [All]`, [
+    [
+      "yarn",
+      [
+        "workspaces",
+        "foreach",
+        ...incrementalOptions,
+        ...jobsOptions,
+        ...verboseOptions,
+        "run",
+        "package-compile",
+        ...targetOptions
+      ]
+    ]
+  ]);
+  console.log(`${chalk11.gray("Compiled in")} [${chalk11.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk11.gray("seconds")}`);
+  return result;
+}, "compileAll");
+
+// src/actions/copy-assets.ts
+import path2 from "node:path/posix";
+import chalk12 from "chalk";
+import cpy from "cpy";
+var copyPackageTargetAssets = /* @__PURE__ */ __name(async (target, name, location) => {
+  try {
+    const values = await cpy([
+      "**/*.jpg",
+      "**/*.png",
+      "**/*.gif",
+      "**/*.svg",
+      "**/*.webp",
+      "**/*.sass",
+      "**/*.scss",
+      "**/*.gif",
+      "**/*.css"
+    ], `../dist/${target}`, {
+      cwd: path2.join(process.cwd(), location, "src"),
+      parents: true
+    });
+    for (const value of values) {
+      console.log(`${value.split("/").pop()} => ./dist/${target}`);
+    }
+    return 0;
+  } catch (reason) {
+    console.log(`Copy Failed: ${name}: ${reason}`);
+    return 1;
+  }
+}, "copyPackageTargetAssets");
+var copyTargetAssets = /* @__PURE__ */ __name(async (target, pkg) => {
+  const workspaces = yarnWorkspaces();
+  console.log(chalk12.green(`Copying Assets [${target.toUpperCase()}]`));
+  const workspaceList = workspaces.filter(({ name }) => {
+    return pkg === void 0 || name === pkg;
+  });
+  if (workspaceList.length === 0) {
+    console.error(`Package not found [${pkg}]`);
+  } else {
+    const results = await Promise.all(workspaceList.map(async (workspace) => {
+      const { location, name } = workspace;
+      return await copyPackageTargetAssets(target, name, location);
+    }));
+    return results.reduce((prev, result) => prev || result, 0);
+  }
+  return 0;
+}, "copyTargetAssets");
+var copyAssets = /* @__PURE__ */ __name(async ({ target, pkg }) => {
+  switch (target) {
+    case "esm": {
+      return await copyTargetAssets("esm", pkg);
+    }
+    case "cjs": {
+      return await copyTargetAssets("cjs", pkg);
+    }
+    default: {
+      return await copyTargetAssets("esm", pkg) || await copyTargetAssets("cjs", pkg);
+    }
+  }
+}, "copyAssets");
+
+// src/actions/cycle.ts
+var cycle = /* @__PURE__ */ __name(() => {
+  const rules = [
+    `"'import/no-cycle': [1, { maxDepth: 6 }]"`,
+    `"'import/no-internal-modules': ['off']"`
+  ];
+  return runSteps("Cycle", [
+    [
+      "yarn",
+      [
+        "eslint",
+        ...rules.flatMap((rule) => [
+          "--rule",
+          rule
+        ]),
+        "--cache",
+        "."
+      ]
+    ]
+  ]);
+}, "cycle");
+
+// src/actions/dead.ts
+var dead = /* @__PURE__ */ __name(() => {
+  return runSteps("Dead", [
+    [
+      "yarn",
+      [
+        "ts-prune",
+        "-p",
+        "tsconfig.json"
+      ]
+    ]
+  ]);
+}, "dead");
+
+// src/actions/deploy.ts
+var deploy = /* @__PURE__ */ __name(() => {
+  return runSteps("Deploy [Patch]", [
+    [
+      "yarn",
+      "workspaces foreach --all version patch --deferred"
+    ],
+    [
+      "yarn",
+      "xy clean"
+    ],
+    [
+      "yarn",
+      "xy build"
+    ],
+    [
+      "yarn",
+      "version apply --all"
+    ],
+    [
+      "yarn",
+      "workspaces foreach --all --parallel npm publish"
+    ]
+  ]);
+}, "deploy");
+
+// src/actions/deploy-major.ts
+var deployMajor = /* @__PURE__ */ __name(() => {
+  return runSteps("Deploy [Major]", [
+    [
+      "yarn",
+      "workspaces foreach --all version major --deferred"
+    ],
+    [
+      "yarn",
+      "xy clean"
+    ],
+    [
+      "yarn",
+      "xy build"
+    ],
+    [
+      "yarn",
+      "version apply --all"
+    ],
+    [
+      "yarn",
+      "workspaces foreach --all --parallel npm publish"
+    ]
+  ]);
+}, "deployMajor");
+
+// src/actions/deploy-minor.ts
+var deployMinor = /* @__PURE__ */ __name(() => {
+  return runSteps("Deploy [Minor]", [
+    [
+      "yarn",
+      "workspaces foreach --all version minor --deferred"
+    ],
+    [
+      "yarn",
+      "xy clean"
+    ],
+    [
+      "yarn",
+      "xy build"
+    ],
+    [
+      "yarn",
+      "version apply --all"
+    ],
+    [
+      "yarn",
+      "workspaces foreach --all --parallel npm publish"
+    ]
+  ]);
+}, "deployMinor");
+
+// src/actions/deploy-next.ts
+var deployNext = /* @__PURE__ */ __name(() => {
+  return runSteps("Deploy [Next]", [
+    [
+      "yarn",
+      "workspaces foreach --all version minor --deferred"
+    ],
+    [
+      "yarn",
+      "xy clean"
+    ],
+    [
+      "yarn",
+      "xy build"
+    ],
+    [
+      "yarn",
+      "version apply --all --prerelease"
+    ],
+    [
+      "yarn",
+      "workspaces foreach --all --parallel npm publish --tag next"
+    ]
+  ]);
+}, "deployNext");
+
+// src/actions/deps.ts
+import chalk13 from "chalk";
+var deps = /* @__PURE__ */ __name(({ pkg, incremental }) => {
+  pkg ? depsPackage({
+    pkg
+  }) : depsAll({
+    incremental
+  });
+  return 0;
+}, "deps");
+var depsPackage = /* @__PURE__ */ __name(({ pkg }) => {
+  const steps = [
+    [
+      "yarn",
+      [
+        "workspace",
+        pkg,
+        "run",
+        "package-deps"
+      ]
+    ]
+  ];
+  return runSteps(`Deps [${pkg}]`, [
+    ...steps
+  ]);
+}, "depsPackage");
+var depsAll = /* @__PURE__ */ __name(({ incremental, jobs, verbose }) => {
+  const start = Date.now();
+  const jobsOptions = jobs ? [
+    "-j",
+    `${jobs}`
+  ] : [];
+  const verboseOptions = verbose ? [
+    "--verbose"
+  ] : [
+    "--no-verbose"
+  ];
+  if (jobs) {
+    console.log(chalk13.blue(`Jobs set to [${jobs}]`));
+  }
+  const incrementalOptions = incremental ? [
+    "--since",
+    "-pA"
+  ] : [
+    "-pA"
+  ];
+  const steps = [
+    [
+      "yarn",
+      [
+        "workspaces",
+        "foreach",
+        ...jobsOptions,
+        ...incrementalOptions,
+        ...verboseOptions,
+        "run",
+        "package-deps"
+      ]
+    ]
+  ];
+  const result = runSteps(`Deps${incremental ? "-Incremental" : ""} [All]`, [
+    ...steps
+  ]);
+  console.log(`${chalk13.gray("Dep checked in")} [${chalk13.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk13.gray("seconds")}`);
+  return result;
+}, "depsAll");
+
+// src/actions/dupdeps.ts
+import chalk14 from "chalk";
+var dupdeps = /* @__PURE__ */ __name(() => {
+  console.log(chalk14.green("Checking all Dependencies for Duplicates"));
+  const allDependencies = parsedPackageJSON()?.dependencies;
+  const dependencies = Object.entries(allDependencies).map(([k]) => k);
+  return detectDuplicateDependencies(dependencies);
+}, "dupdeps");
+
+// src/actions/fix.ts
+var fix = /* @__PURE__ */ __name(() => {
+  return runSteps("Fix", [
+    [
+      "yarn",
+      [
+        "eslint",
+        ".",
+        "--fix",
+        "--cache"
+      ]
+    ]
+  ]);
+}, "fix");
+
+// src/actions/gen-docs.ts
+var genDocs = /* @__PURE__ */ __name(({ pkg, incremental }) => {
+  return pkg ? genDocsPackage({
+    pkg
+  }) : genDocsAll({
+    incremental
+  });
+}, "genDocs");
+var genDocsPackage = /* @__PURE__ */ __name(({ pkg }) => {
+  const steps = [
+    [
+      "yarn",
+      [
+        "workspace",
+        pkg,
+        "run",
+        "package-gen-docs"
+      ]
+    ]
+  ];
+  return runSteps(`GenDocs [${pkg}]`, [
+    ...steps
+  ]);
+}, "genDocsPackage");
+var genDocsAll = /* @__PURE__ */ __name(({ incremental }) => {
+  const incrementalOptions = incremental ? [
+    "--since",
+    "-pA"
+  ] : [
+    "-pA"
+  ];
+  const steps = [
+    [
+      "yarn",
+      [
+        "workspaces",
+        "foreach",
+        ...incrementalOptions,
+        "run",
+        "package-gen-docs"
+      ]
+    ]
+  ];
+  return runSteps(`GenDocs [All${incremental ? "-Incremental" : ""}]`, [
+    ...steps
+  ]);
+}, "genDocsAll");
+
+// src/actions/gitignore-gen.ts
+var filename = ".gitignore";
+var gitignoreGen = /* @__PURE__ */ __name((pkg) => generateIgnoreFiles(filename, pkg), "gitignoreGen");
+
+// src/actions/gitlint.ts
+import chalk15 from "chalk";
+import ParseGitConfig from "parse-git-config";
+var gitlint = /* @__PURE__ */ __name(() => {
+  console.log(`
+Gitlint Start [${process.cwd()}]
+`);
+  let valid = 0;
+  let warnings = 0;
+  const errors = 0;
+  const gitConfig = ParseGitConfig.sync();
+  const warn = /* @__PURE__ */ __name((message) => {
+    console.warn(chalk15.yellow(`Warning: ${message}`));
+    warnings++;
+  }, "warn");
+  if (gitConfig.core.ignorecase) {
+    warn("Please set core.ignorecase to FALSE in .git/config file [run yarn gitlint-fix]");
+  } else {
+    valid++;
+  }
+  if (gitConfig.core.autocrlf === false) {
+    valid++;
+  } else {
+    warn("Please set core.autocrlf to FALSE in .git/config file [run yarn gitlint-fix]");
+  }
+  if (gitConfig.core.eol === "lf") {
+    valid++;
+  } else {
+    warn('Please set core.eol to "lf" in .git/config file [run yarn gitlint-fix]');
+  }
+  const resultMessages = [];
+  if (valid > 0) {
+    resultMessages.push(chalk15.green(`Passed: ${valid}`));
+  }
+  if (warnings > 0) {
+    resultMessages.push(chalk15.yellow(`Warnings: ${warnings}`));
+  }
+  if (errors > 0) {
+    resultMessages.push(chalk15.red(` Errors: ${errors}`));
+  }
+  console.warn(`Gitlint Finish [ ${resultMessages.join(" | ")} ]
+`);
+  return warnings + errors === 0 ? 1 : 0;
+}, "gitlint");
+
+// src/actions/gitlint-fix.ts
+import { execSync as execSync2 } from "node:child_process";
+import chalk16 from "chalk";
+import ParseGitConfig2 from "parse-git-config";
+var gitlintFix = /* @__PURE__ */ __name(() => {
+  console.log(`
+Gitlint Fix Start [${process.cwd()}]
+`);
+  const gitConfig = ParseGitConfig2.sync();
+  if (gitConfig.core.ignorecase) {
+    execSync2("git config core.ignorecase false", {
+      stdio: "inherit"
+    });
+    console.warn(chalk16.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(chalk16.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(chalk16.yellow('\nGitlint Fix: Updated core.eol to be "lf"\n'));
+  }
+  return 1;
+}, "gitlintFix");
+
+// src/actions/license.ts
+import chalk17 from "chalk";
+import { init } from "license-checker";
+var license = /* @__PURE__ */ __name(async (pkg) => {
+  const workspaces = yarnWorkspaces();
+  const workspaceList = workspaces.filter(({ name }) => {
+    return pkg === void 0 || name === pkg;
+  });
+  const exclude = /* @__PURE__ */ new Set([
+    "MIT",
+    "MIT*",
+    "ISC",
+    "Apache-2.0",
+    "BSD",
+    "BSD*",
+    "BSD-2-Clause",
+    "BSD-3-Clause",
+    "CC-BY-4.0",
+    "Unlicense",
+    "CC-BY-3.0",
+    "CC0-1.0",
+    "LGPL-3.0-only",
+    "LGPL-3.0",
+    "LGPL-3.0-or-later",
+    "Python-2.0"
+  ]);
+  console.log(chalk17.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(chalk17.red(`License Checker [${name}] Error`));
+          console.error(chalk17.gray(error));
+          console.log("\n");
+          resolve(1);
+        } else {
+          console.log(chalk17.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
+            ];
+            for (let license2 of licenses) {
+              if (license2) {
+                if (license2[0] === "(" && license2.at(-1) === ")") {
+                  license2 = license2.slice(1, -2);
+                }
+                const orLicenses = license2.split(" OR ");
+                let orLicenseFound = false;
+                for (const orLicense of orLicenses) {
+                  if (exclude.has(orLicense)) {
+                    orLicenseFound = true;
+                  }
+                }
+                if (!orLicenseFound) {
+                  count++;
+                  console.warn(chalk17.yellow(`${name2}: Package License not allowed [${license2}]`));
+                }
+              }
+            }
+          }
+          console.log("\n");
+          resolve(count);
+        }
+      });
+    });
+  }))).reduce((prev, value) => prev || value, 0);
+}, "license");
+
+// src/actions/lint.ts
+import chalk18 from "chalk";
+import { ESLint } from "eslint";
+var dumpMessages = /* @__PURE__ */ __name((lintResults) => {
+  const colors = [
+    "white",
+    "yellow",
+    "red"
+  ];
+  const severity = [
+    "none",
+    "warning",
+    "error"
+  ];
+  for (const lintResult of lintResults) {
+    if (lintResult.messages.length > 0) {
+      console.log(chalk18.gray(`${lintResult.filePath}`));
+      for (const message of lintResult.messages) {
+        console.log(chalk18.gray(`	${message.line}:${message.column}`), chalk18[colors[message.severity]](`	${severity[message.severity]}`), chalk18.white(`	${message.message}`), chalk18.gray(`	${message.ruleId}`));
+      }
+    }
+  }
+}, "dumpMessages");
+var lintPackage = /* @__PURE__ */ __name(async ({ pkg }) => {
+  const workspace = yarnWorkspaces().find((workspace2) => workspace2.name === pkg);
+  if (!workspace) {
+    console.error(chalk18.red(`Unable to locate package [${chalk18.magenta(pkg)}]`));
+    process.exit(1);
+  }
+  const engine = new ESLint({
+    cache: true
+  });
+  const lintResults = await engine.lintFiles(workspace.location);
+  dumpMessages(lintResults);
+  return lintResults.reduce((prev, lintResult) => prev + lintResult.errorCount, 0);
+}, "lintPackage");
+var lintAll = /* @__PURE__ */ __name(async () => {
+  const engine = new ESLint({
+    cache: true
+  });
+  const lintResults = await engine.lintFiles("./**/*.*");
+  dumpMessages(lintResults);
+  return lintResults.reduce((prev, lintResult) => prev + lintResult.errorCount, 0);
+}, "lintAll");
+var lint = /* @__PURE__ */ __name(async ({ pkg } = {}) => {
+  return pkg ? await lintPackage({
+    pkg
+  }) : runSteps("Lint-Caching [All]", [
+    [
+      "yarn",
+      [
+        "eslint",
+        ".",
+        "--cache"
+      ]
+    ]
+  ]);
+}, "lint");
+
+// src/actions/lint-clean.ts
+import { rmSync } from "node:fs";
+var lintClean = /* @__PURE__ */ __name(() => {
+  console.log("Lint Clean [.eslintcache]");
+  const workspaces = yarnWorkspaces();
+  const result = workspaces.map(({ location, name }) => {
+    const dist = `${location}/.eslintcache`;
+    try {
+      rmSync(dist, {
+        force: true,
+        recursive: true
+      });
+      return 0;
+    } catch (ex) {
+      const error = ex;
+      console.error(`Lint Clean [.eslintcache] Failed [${name}, ${error.message}]`);
+      return 1;
+    }
+  }).reduce((prev, result2) => prev || result2, 0);
+  return result || lint();
+}, "lintClean");
+
+// src/actions/lint-profile.ts
+var lintProfile = /* @__PURE__ */ __name(() => {
+  return runSteps("Lint Profile", [
+    [
+      "yarn",
+      [
+        "xy",
+        "lint"
+      ],
+      {
+        env: {
+          ...process.env,
+          TIMING: "1"
+        }
+      }
+    ]
+  ]);
+}, "lintProfile");
+
+// src/actions/npmignore-gen.ts
+var filename2 = ".npmignore";
+var npmignoreGen = /* @__PURE__ */ __name((pkg) => generateIgnoreFiles(filename2, pkg), "npmignoreGen");
+
+// src/actions/package/clean-outputs.ts
+import path3 from "node:path";
+import chalk19 from "chalk";
+import { rimraf } from "rimraf";
+var packageCleanOutputs = /* @__PURE__ */ __name(async () => {
+  const pkg = process.env.INIT_CWD ?? ".";
+  const pkgName = process.env.npm_package_name;
+  const folders = [
+    path3.join(pkg, "dist"),
+    path3.join(pkg, "build"),
+    path3.join(pkg, "docs")
+  ];
+  console.log(chalk19.green(`Cleaning Outputs [${pkgName}]`));
+  await Promise.all(folders.map((folder) => rimraf(folder)));
+  return 0;
+}, "packageCleanOutputs");
+
+// src/actions/package/clean-typescript.ts
+import path4 from "node:path";
+import chalk20 from "chalk";
+import { rimraf as rimraf2 } from "rimraf";
+var packageCleanTypescript = /* @__PURE__ */ __name(async () => {
+  const pkg = process.env.INIT_CWD ?? ".";
+  const pkgName = process.env.npm_package_name;
+  console.log(chalk20.green(`Cleaning Typescript [${pkgName}]`));
+  const files = [
+    path4.join(pkg, "*.tsbuildinfo"),
+    path4.join(pkg, ".tsconfig.*"),
+    path4.join(pkg, ".eslintcache")
+  ];
+  await Promise.all(files.map((file) => rimraf2(file)));
+  return 0;
+}, "packageCleanTypescript");
+
+// src/actions/package/clean.ts
+var packageClean = /* @__PURE__ */ __name(async () => {
+  return (await Promise.all([
+    packageCleanOutputs(),
+    packageCleanTypescript()
+  ])).reduce((prev, value) => prev + value, 0);
+}, "packageClean");
+
+// src/actions/package/compile/compile.ts
+import chalk24 from "chalk";
+
+// src/actions/package/publint.ts
+import { promises as fs } from "node:fs";
+import chalk21 from "chalk";
+var packagePublint = /* @__PURE__ */ __name(async (params) => {
+  const pkgDir = process.env.INIT_CWD;
+  const pkg = JSON.parse(await fs.readFile(`${pkgDir}/package.json`, "utf8"));
+  console.log(chalk21.green(`Publint: ${pkg.name}`));
+  console.log(chalk21.gray(pkgDir));
+  const { publint: publint2 } = await import("publint");
+  const { messages } = await publint2({
+    level: "suggestion",
+    pkgDir,
+    strict: true
+  });
+  const { formatMessage } = await import("publint/utils");
+  const validMessage = /* @__PURE__ */ __name((_message) => {
+    return true;
+  }, "validMessage");
+  const validMessages = messages.filter(validMessage);
+  for (const message of validMessages) {
+    switch (message.type) {
+      case "error": {
+        console.error(chalk21.red(`[${message.code}] ${formatMessage(message, pkg)}`));
+        break;
+      }
+      case "warning": {
+        console.warn(chalk21.yellow(`[${message.code}] ${formatMessage(message, pkg)}`));
+        break;
+      }
+      default: {
+        console.log(chalk21.white(`[${message.code}] ${formatMessage(message, pkg)}`));
+        break;
+      }
+    }
+  }
+  if (params?.verbose) {
+    console.log(chalk21.gray(`Publint [Finish]: ${pkgDir} [${validMessages.length}]`));
+  }
+  return validMessages.filter((message) => message.type === "error").length;
+}, "packagePublint");
+
+// src/actions/package/compile/packageCompileTsc.ts
+import { cwd } from "node:process";
+import chalk22 from "chalk";
+import { createProgramFromConfig } from "tsc-prog";
+import { DiagnosticCategory, formatDiagnosticsWithColorAndContext, getLineAndCharacterOfPosition, getPreEmitDiagnostics } from "typescript";
+
+// src/actions/package/compile/getCompilerOptions.ts
+import { createRequire } from "node:module";
+import { merge as merge2 } from "lodash-es";
+import { findConfigFile, readConfigFile, sys } from "typescript";
+var getCompilerOptionsJSONFollowExtends = /* @__PURE__ */ __name((filename3) => {
+  let opts = {};
+  const config2 = readConfigFile(filename3, sys.readFile).config;
+  if (config2.extends) {
+    const require2 = createRequire(import.meta.url);
+    opts = require2(config2.extends);
+  }
+  if (config2?.error) {
+    throw new Error(`getCompilerOptionsJSONFollowExtends failed ${JSON.stringify(config2?.error?.messageText, null, 2)}`);
+  }
+  return {
+    ...opts.compilerOptions,
+    ...config2.compilerOptions
+  };
+}, "getCompilerOptionsJSONFollowExtends");
+var getCompilerOptions = /* @__PURE__ */ __name(async (options, tsconfig = "tsconfig.json") => {
+  const configFileName = findConfigFile("./", sys.fileExists, tsconfig);
+  const configFileCompilerOptions = configFileName ? await getCompilerOptionsJSONFollowExtends(configFileName) : void 0;
+  return merge2({}, configFileCompilerOptions, options);
+}, "getCompilerOptions");
+
+// src/actions/package/compile/packageCompileTsc.ts
+var packageCompileTsc = /* @__PURE__ */ __name(async (noEmit, config2, compilerOptionsParam) => {
+  const pkg = process.env.INIT_CWD ?? cwd();
+  const publint2 = config2?.publint ?? true;
+  const verbose = config2?.verbose ?? false;
+  const formatHost = {
+    getCanonicalFileName: /* @__PURE__ */ __name((fileName) => fileName, "getCanonicalFileName"),
+    getCurrentDirectory: /* @__PURE__ */ __name(() => pkg, "getCurrentDirectory"),
+    getNewLine: /* @__PURE__ */ __name(() => "\n", "getNewLine")
+  };
+  if (verbose) {
+    console.log(`Compiling with NoEmit TSC [${pkg}]`);
+  }
+  const compilerOptions = {
+    ...await getCompilerOptions({
+      outDir: "dist",
+      removeComments: true,
+      rootDir: "src"
+    }),
+    ...compilerOptionsParam,
+    ...noEmit === void 0 ? {} : {
+      noEmit
+    }
+  };
+  const program = createProgramFromConfig({
+    basePath: pkg ?? cwd(),
+    compilerOptions,
+    exclude: [
+      "dist",
+      "docs",
+      "**/*.spec.*",
+      "**/*.stories.*",
+      "src/**/spec/**/*"
+    ],
+    include: [
+      "src"
+    ]
+  });
+  const results = getPreEmitDiagnostics(program);
+  for (const diag of results) {
+    const lineAndChar = diag.file ? getLineAndCharacterOfPosition(diag.file, diag.start ?? 0) : {
+      character: 0,
+      line: 0
+    };
+    console.log(chalk22.cyan(`${diag.file?.fileName}:${lineAndChar.line + 1}:${lineAndChar.character + 1}`));
+    console.log(formatDiagnosticsWithColorAndContext([
+      diag
+    ], formatHost));
+  }
+  return results.reduce((prev, diag) => prev + diag.category === DiagnosticCategory.Error ? 1 : 0, 0) || (publint2 ? await packagePublint() : 0);
+}, "packageCompileTsc");
+
+// src/actions/package/compile/packageCompileTsup.ts
+import { merge as merge3 } from "lodash-es";
+import { build as build2, defineConfig } from "tsup";
+
+// src/actions/package/compile/inputs.ts
+import { glob } from "glob";
+var getAllInputs2 = /* @__PURE__ */ __name((folder) => {
+  return glob.sync(`${folder}/**/*.*`, {
+    ignore: [
+      "**/*.spec.*",
+      "**/*.stories.*",
+      "**/spec/**/*"
+    ],
+    posix: true
+  });
+}, "getAllInputs2");
+
+// src/actions/package/compile/buildEntries.ts
+var buildEntries = /* @__PURE__ */ __name((folder, entryMode, verbose = false) => {
+  switch (entryMode) {
+    case "platform": {
+      if (verbose) console.log("buildEntries [platform]");
+      return [
+        `${folder}/index-node.ts`,
+        `${folder}/index-browser.ts`
+      ];
+    }
+    case "all": {
+      if (verbose) console.log("buildEntries [all]");
+      return getAllInputs2(folder).filter((entry) => !entry.includes(".spec.") && !entry.includes(".story."));
+    }
+    default: {
+      if (verbose) console.log("buildEntries [single]");
+      return [
+        `${folder}/index.ts`
+      ];
+    }
+  }
+}, "buildEntries");
+
+// src/actions/package/compile/packageCompileTscTypes.ts
+import { cwd as cwd2 } from "node:process";
+import chalk23 from "chalk";
+import { createProgramFromConfig as createProgramFromConfig2 } from "tsc-prog";
+import { DiagnosticCategory as DiagnosticCategory2 } from "typescript";
+
+// src/actions/package/compile/copyTypeFiles.ts
+import { copyFile, readdir } from "node:fs/promises";
+import { Mutex } from "async-mutex";
+var copyFileMutex = new Mutex();
+var getDistTypeFiles = /* @__PURE__ */ __name(async (compilerOptions) => {
+  const outDir = compilerOptions.outDir ?? "dist";
+  return (await readdir(outDir, {
+    recursive: true
+  })).filter((file) => file.endsWith("d.ts")).map((file) => `${outDir}/${file}`);
+}, "getDistTypeFiles");
+var getDistTypeMapFiles = /* @__PURE__ */ __name(async (compilerOptions) => {
+  const outDir = compilerOptions.outDir ?? "dist";
+  return (await readdir(outDir, {
+    recursive: true
+  })).filter((file) => file.endsWith("d.ts.map")).map((file) => `${outDir}/${file}`);
+}, "getDistTypeMapFiles");
+var copyTypeFiles = /* @__PURE__ */ __name(async (compilerOptions) => {
+  await copyFileMutex.runExclusive(async () => {
+    const distTypeFiles = await getDistTypeFiles(compilerOptions);
+    await Promise.all(distTypeFiles.map(async (file) => {
+      await copyFile(file, file.replace("d.ts", "d.mts"));
+      await copyFile(file, file.replace("d.ts", "d.cts"));
+    }));
+    const distTypeMapFiles = await getDistTypeMapFiles(compilerOptions);
+    await Promise.all(distTypeMapFiles.map(async (file) => {
+      await copyFile(file, file.replace("d.ts.map", "d.mts.map"));
+      await copyFile(file, file.replace("d.ts.map", "d.cts.map"));
+    }));
+  });
+}, "copyTypeFiles");
+
+// src/actions/package/compile/packageCompileTscTypes.ts
+var packageCompileTscTypes = /* @__PURE__ */ __name(async (folder = "src", { verbose } = {}, compilerOptionsParam, generateMts = true) => {
+  const pkg = process.env.INIT_CWD ?? cwd2();
+  if (verbose) {
+    console.log(`Compiling types with TSC [${pkg}]`);
+  }
+  const compilerOptions = {
+    ...await getCompilerOptions({
+      declaration: true,
+      emitDeclarationOnly: true,
+      outDir: "dist",
+      removeComments: true,
+      skipDefaultLibCheck: true,
+      skipLibCheck: true,
+      sourceMap: true
+    }),
+    ...compilerOptionsParam
+  };
+  const files = buildEntries(folder, "all");
+  const result = createProgramFromConfig2({
+    basePath: pkg ?? cwd2(),
+    compilerOptions,
+    exclude: [
+      "dist",
+      "docs",
+      "**/*.spec.*",
+      "**/*.stories.*",
+      "src/**/spec/**/*"
+    ],
+    files
+  }).emit();
+  const diagResults = result.diagnostics.length;
+  for (const diag of result.diagnostics) {
+    switch (diag.category) {
+      case DiagnosticCategory2.Error: {
+        console.error(chalk23.red(diag.messageText));
+        console.error(chalk23.grey(pkg));
+        console.error(chalk23.blue(diag.file?.fileName));
+        break;
+      }
+      case DiagnosticCategory2.Warning: {
+        console.error(chalk23.yellow(diag.messageText));
+        console.error(chalk23.grey(pkg));
+        console.error(chalk23.blue(diag.file?.fileName));
+        break;
+      }
+      case DiagnosticCategory2.Suggestion: {
+        console.error(chalk23.white(diag.messageText));
+        console.error(chalk23.grey(pkg));
+        console.error(chalk23.blue(diag.file?.fileName));
+        break;
+      }
+    }
+  }
+  if (generateMts) {
+    await copyTypeFiles(compilerOptions);
+  }
+  return diagResults;
+}, "packageCompileTscTypes");
+
+// src/actions/package/compile/packageCompileTsup.ts
+var compileFolder = /* @__PURE__ */ __name(async (folder, entryMode = "single", options, verbose) => {
+  const outDir = options?.outDir ?? "dist";
+  const entry = buildEntries(folder, entryMode);
+  const optionsResult = defineConfig({
+    bundle: true,
+    cjsInterop: true,
+    clean: true,
+    dts: false,
+    entry,
+    format: [
+      "cjs",
+      "esm"
+    ],
+    // minify: true,
+    outDir,
+    silent: true,
+    sourcemap: true,
+    splitting: false,
+    // terserOptions: { format: { comments: false } },
+    tsconfig: "tsconfig.json",
+    ...options
+  });
+  const optionsList = (await Promise.all((Array.isArray(optionsResult) ? optionsResult : [
+    optionsResult
+  ]).flatMap(async (options2) => {
+    const result = typeof options2 === "function" ? await options2({}) : [
+      options2
+    ];
+    return Array.isArray(result) ? result : [
+      result
+    ];
+  }))).flat();
+  await Promise.all(optionsList.map((options2) => build2(options2)));
+  await packageCompileTscTypes(folder, {
+    verbose
+  }, {
+    outDir
+  });
+  return 0;
+}, "compileFolder");
+var packageCompileTsup = /* @__PURE__ */ __name(async (config2) => {
+  const compile2 = config2?.compile;
+  const publint2 = config2?.publint ?? true;
+  const verbose = config2?.verbose ?? false;
+  if (verbose) {
+    console.log(`Compiling with TSUP [Depth: ${compile2?.depth}]`);
+  }
+  const compileForNode = compile2?.node ?? {
+    src: {}
+  };
+  const compileForBrowser = compile2?.browser ?? {
+    src: {}
+  };
+  const compileForNeutral = compile2?.neutral ?? {
+    src: {}
+  };
+  return await packageCompileTsc(true, {
+    publint: false,
+    verbose
+  }) || (await Promise.all(Object.entries(compileForNode).map(async ([folder, options]) => {
+    const inEsBuildOptions = typeof compile2?.node?.esbuildOptions === "object" ? compile2?.node?.esbuildOptions : {};
+    return folder ? await compileFolder(folder, compile2?.entryMode, {
+      bundle: true,
+      format: [
+        "cjs",
+        "esm"
+      ],
+      loader: merge3({}, {
+        ".gif": "copy",
+        ".html": "copy",
+        ".jpg": "copy",
+        ".json": "json",
+        ".png": "copy",
+        ".svg": "copy",
+        ".webp": "copy"
+      }, inEsBuildOptions?.loader),
+      // minify: true,
+      outDir: "dist/node",
+      platform: "node",
+      skipNodeModulesBundle: true,
+      sourcemap: true,
+      target: "node16",
+      // terserOptions: { format: { comments: false } },
+      ...compile2?.tsup?.options,
+      ...typeof options === "object" ? options : {}
+    }, verbose) : 0;
+  }))).reduce((prev, value) => prev + value, 0) || (await Promise.all(Object.entries(compileForBrowser).map(async ([folder, options]) => {
+    const inEsBuildOptions = typeof compile2?.browser?.esbuildOptions === "object" ? compile2?.browser?.esbuildOptions : {};
+    return folder ? (await Promise.all([
+      compileFolder(folder, compile2?.entryMode, {
+        bundle: true,
+        format: [
+          "cjs"
+        ],
+        loader: merge3({}, {
+          ".gif": "copy",
+          ".html": "copy",
+          ".jpg": "copy",
+          ".json": "json",
+          ".png": "copy",
+          ".svg": "copy",
+          ".webp": "copy"
+        }, inEsBuildOptions?.loader),
+        // minify: true,
+        outDir: "dist/browser",
+        outExtension: /* @__PURE__ */ __name(({ format }) => format === "esm" ? {
+          js: ".ts"
+        } : {
+          js: ".cjs"
+        }, "outExtension"),
+        platform: "browser",
+        skipNodeModulesBundle: true,
+        sourcemap: true,
+        target: "esnext",
+        // terserOptions: { format: { comments: false } },
+        ...compile2?.tsup?.options,
+        ...typeof options === "object" ? options : {}
+      }, verbose),
+      compileFolder(folder, compile2?.entryMode, {
+        bundle: true,
+        format: [
+          "esm"
+        ],
+        loader: merge3({}, {
+          ".gif": "copy",
+          ".html": "copy",
+          ".jpg": "copy",
+          ".json": "json",
+          ".png": "copy",
+          ".svg": "copy",
+          ".webp": "copy"
+        }, inEsBuildOptions?.loader),
+        // minify: true,
+        outDir: "dist/browser",
+        outExtension: /* @__PURE__ */ __name(({ format }) => format === "esm" ? {
+          js: ".ts"
+        } : {
+          js: ".cjs"
+        }, "outExtension"),
+        platform: "browser",
+        skipNodeModulesBundle: true,
+        sourcemap: true,
+        target: "esnext",
+        // terserOptions: { format: { comments: false } },
+        ...compile2?.tsup?.options,
+        ...typeof options === "object" ? options : {}
+      }, verbose)
+    ])).reduce((prev, value) => prev + value, 0) : 0;
+  }))).reduce((prev, value) => prev + value, 0) || (await Promise.all(Object.entries(compileForNeutral).map(async ([folder, options]) => {
+    const inEsBuildOptions = typeof compile2?.neutral?.esbuildOptions === "object" ? compile2?.neutral?.esbuildOptions : {};
+    return folder ? (await Promise.all([
+      compileFolder(folder, compile2?.entryMode, {
+        bundle: true,
+        format: [
+          "cjs"
+        ],
+        loader: merge3({}, {
+          ".gif": "copy",
+          ".html": "copy",
+          ".jpg": "copy",
+          ".json": "json",
+          ".png": "copy",
+          ".svg": "copy",
+          ".webp": "copy"
+        }, inEsBuildOptions?.loader),
+        // minify: true,
+        outDir: "dist/neutral",
+        outExtension: /* @__PURE__ */ __name(({ format }) => format === "esm" ? {
+          js: ".ts"
+        } : {
+          js: ".cjs"
+        }, "outExtension"),
+        platform: "neutral",
+        skipNodeModulesBundle: true,
+        sourcemap: true,
+        target: "esnext",
+        // terserOptions: { format: { comments: false } },
+        ...compile2?.tsup?.options,
+        ...typeof options === "object" ? options : {}
+      }, verbose),
+      compileFolder(folder, compile2?.entryMode, {
+        bundle: true,
+        format: [
+          "esm"
+        ],
+        loader: merge3({}, {
+          ".gif": "copy",
+          ".html": "copy",
+          ".jpg": "copy",
+          ".json": "json",
+          ".png": "copy",
+          ".svg": "copy",
+          ".webp": "copy"
+        }, inEsBuildOptions?.loader),
+        // minify: true,
+        outDir: "dist/neutral",
+        outExtension: /* @__PURE__ */ __name(({ format }) => format === "esm" ? {
+          js: ".ts"
+        } : {
+          js: ".cjs"
+        }, "outExtension"),
+        platform: "neutral",
+        skipNodeModulesBundle: true,
+        sourcemap: true,
+        target: "esnext",
+        // terserOptions: { format: { comments: false } },
+        ...compile2?.tsup?.options,
+        ...typeof options === "object" ? options : {}
+      }, verbose)
+    ])).reduce((prev, value) => prev + value, 0) : 0;
+  }))).reduce((prev, value) => prev + value, 0) || (publint2 ? await packagePublint() : 0);
+}, "packageCompileTsup");
+
+// src/actions/package/compile/compile.ts
+var packageCompile = /* @__PURE__ */ __name(async (inConfig = {}) => {
+  const pkg = process.env.INIT_CWD;
+  console.log(chalk24.green(`Compiling ${pkg}`));
+  const config2 = await loadConfig(inConfig);
+  const publint2 = config2.publint;
+  const mode = config2.compile?.mode ?? "tsup";
+  let result = 0;
+  switch (mode) {
+    case "tsc": {
+      result += await packageCompileTsc(void 0, config2);
+      break;
+    }
+    case "tsup": {
+      result += await packageCompileTsup(config2);
+      break;
+    }
+  }
+  return result + (publint2 ? await packagePublint(config2) : 0);
+}, "packageCompile");
+
+// src/actions/package/copy-assets.ts
+import path5 from "node:path/posix";
+import chalk25 from "chalk";
+import cpy2 from "cpy";
+var copyTargetAssets2 = /* @__PURE__ */ __name(async (target, name, location) => {
+  try {
+    const values = await cpy2([
+      "**/*.jpg",
+      "**/*.png",
+      "**/*.gif",
+      "**/*.svg",
+      "**/*.webp",
+      "**/*.sass",
+      "**/*.scss",
+      "**/*.gif",
+      "**/*.css"
+    ], `../dist/${target}`, {
+      cwd: path5.join(location, "src"),
+      parents: true
+    });
+    if (values.length > 0) {
+      console.log(chalk25.green(`Copying Assets [${target.toUpperCase()}] - ${name} - ${location}`));
+    }
+    for (const value of values) {
+      console.log(`${value.split("/").pop()} => ./dist/${target}`);
+    }
+    return 0;
+  } catch (ex) {
+    const error = ex;
+    console.log(`Copy Assets Failed: ${name}: ${error.message}`);
+    return 1;
+  }
+}, "copyTargetAssets");
+var packageCopyAssets = /* @__PURE__ */ __name(async ({ target }) => {
+  const pkg = process.env.INIT_CWD ?? "./";
+  const pkgName = process.env.npm_package_name ?? "Unknown";
+  switch (target) {
+    case "esm": {
+      return await copyTargetAssets2("esm", pkgName, pkg);
+    }
+    case "cjs": {
+      return await copyTargetAssets2("cjs", pkgName, pkg);
+    }
+    default: {
+      return await copyTargetAssets2("esm", pkgName, pkg) || await copyTargetAssets2("cjs", pkgName, pkg);
+    }
+  }
+}, "packageCopyAssets");
+
+// src/actions/package/deps.ts
+import { existsSync as existsSync5, readFileSync as readFileSync5 } from "node:fs";
+import { cwd as cwd3 } from "node:process";
+import chalk26 from "chalk";
+import depcheck from "depcheck";
+var special = depcheck.special;
+var defaultIgnorePatterns = [
+  "*.d.ts",
+  "dist",
+  ".*",
+  "node_modules"
+];
+var defaultIgnoreDevDeps = [
+  "@xylabs/ts-scripts-yarn3",
+  "@xylabs/tsconfig",
+  "@xylabs/tsconfig-dom",
+  "@xylabs/tsconfig-react",
+  "@xylabs/tsconfig-jest",
+  "typescript"
+];
+var defaultIgnoreDevPatterns = [
+  "*.stories.*",
+  "*.spec.*",
+  "spec",
+  "stories",
+  "tsconfig.json"
+];
+var reportUnused = /* @__PURE__ */ __name((name, unused) => {
+  if (unused.length > 0) {
+    const message = [
+      chalk26.yellow(`${unused.length} Unused ${name}`)
+    ];
+    for (const value of unused) message.push(chalk26.gray(`  ${value}`));
+    console.log(message.join("\n"));
+  }
+}, "reportUnused");
+var reportMissing = /* @__PURE__ */ __name((name, missing) => {
+  if (Object.keys(missing).length > 0) {
+    const message = [
+      chalk26.yellow(`${Object.entries(missing).length} Missing ${name}`)
+    ];
+    for (const [key, value] of Object.entries(missing)) {
+      message.push(`${key}`, chalk26.gray(`  ${value.at(0)}`));
+    }
+    console.log(chalk26.yellow(message.join("\n")));
+  }
+}, "reportMissing");
+var analyzeDeps = /* @__PURE__ */ __name(async (pkg, ignoreMatches) => {
+  const packageContent = existsSync5(`${pkg}/package.json`) ? JSON.parse(readFileSync5(`${pkg}/package.json`, {
+    encoding: "utf8"
+  })) : void 0;
+  const [srcUnused, allUnused] = await Promise.all([
+    depcheck(`${pkg}/src`, {
+      ignoreMatches,
+      ignorePatterns: [
+        ...defaultIgnoreDevPatterns,
+        ...defaultIgnorePatterns
+      ],
+      package: packageContent
+    }),
+    depcheck(`${pkg}/.`, {
+      ignoreMatches: [
+        ...ignoreMatches,
+        ...defaultIgnoreDevDeps
+      ],
+      ignorePatterns: [
+        ...defaultIgnorePatterns
+      ],
+      package: packageContent,
+      specials: [
+        special.eslint,
+        special.babel,
+        special.bin,
+        special.prettier,
+        special.jest,
+        special.mocha
+      ]
+    })
+  ]);
+  const unusedDeps = srcUnused.dependencies;
+  const unusedDevDeps = allUnused.devDependencies;
+  const usedDeps = srcUnused.using;
+  const usedDevDeps = allUnused.using;
+  const missing = {
+    ...srcUnused.missing,
+    ...allUnused.missing
+  };
+  const { invalidDirs, invalidFiles } = allUnused;
+  return {
+    invalidDirs,
+    invalidFiles,
+    missing,
+    unusedDeps,
+    unusedDevDeps,
+    usedDeps,
+    usedDevDeps
+  };
+}, "analyzeDeps");
+var packageDeps = /* @__PURE__ */ __name(async () => {
+  const pkg = process.env.INIT_CWD ?? cwd3();
+  const pkgName = process.env.npm_package_name;
+  const packageContent = existsSync5(`${pkg}/package.json`) ? JSON.parse(readFileSync5(`${pkg}/package.json`, {
+    encoding: "utf8"
+  })) : void 0;
+  const rawIgnore = existsSync5(`${pkg}/.depcheckrc`) ? readFileSync5(`${pkg}/.depcheckrc`, {
+    encoding: "utf8"
+  }).replace("ignores:", '"ignores":') : void 0;
+  let ignoreMatches = [];
+  try {
+    ignoreMatches = rawIgnore ? JSON.parse(`{${rawIgnore}}`).ignores : [];
+  } catch (ex) {
+    const error = ex;
+    console.log(`${pkgName} [${error.message}] Failed to parse .depcheckrc [${rawIgnore}]`);
+  }
+  const { invalidDirs, invalidFiles, unusedDeps, unusedDevDeps, usedDeps, usedDevDeps, missing } = await analyzeDeps(pkg, ignoreMatches);
+  const declaredDeps = Object.keys(packageContent.dependencies ?? {});
+  const declaredPeerDeps = Object.keys(packageContent.peerDependencies ?? {});
+  const declaredDevDeps = Object.keys(packageContent.devDependencies ?? {});
+  const missingDeps = Object.keys(usedDeps).filter((key) => !declaredDeps.includes(key) && !declaredPeerDeps.includes(key) && !key.startsWith("@types/"));
+  const missingDevDeps = Object.keys(usedDevDeps).filter((key) => !declaredDevDeps.includes(key) && !declaredDeps.includes(key));
+  const missingDepsObject = {};
+  for (const key of missingDeps) {
+    missingDepsObject[key] = missing[key] ?? [
+      `devDep should be dep [${key}]`
+    ];
+  }
+  const missingDevDepsObject = {};
+  for (const key of missingDevDeps) {
+    if (missing[key]) {
+      missingDevDepsObject[key] = missing[key];
+    }
+  }
+  const errorCounts = [
+    unusedDeps.length,
+    unusedDevDeps.length,
+    Object.entries(invalidDirs).length,
+    Object.entries(invalidFiles).length,
+    Object.entries(missingDepsObject).length,
+    Object.entries(missingDevDepsObject).length
+  ];
+  const errorCount = errorCounts.reduce((prev, count) => prev + count, 0);
+  if (errorCount > 0) {
+    console.log(`Deps [${pkgName}] = (${JSON.stringify(errorCounts)})`);
+  } else {
+    console.log(`Deps [${pkgName}] - Ok`);
+  }
+  reportUnused("dependencies", unusedDeps);
+  reportUnused("devDependencies", unusedDevDeps);
+  if (Object.entries(invalidDirs).length > 0) {
+    for (const [key, value] of Object.entries(invalidDirs)) console.warn(chalk26.gray(`Invalid Dir: ${key}: ${value}`));
+  }
+  if (Object.entries(invalidFiles).length > 0) {
+    for (const [key, value] of Object.entries(invalidFiles)) console.warn(chalk26.gray(`Invalid File: ${key}: ${value}`));
+  }
+  reportMissing("dependencies", missingDepsObject);
+  reportMissing("devDependencies", missingDevDepsObject);
+  checkResult(`Deps [${pkgName}]`, errorCount, "warn", false);
+  return 0;
+}, "packageDeps");
+
+// src/actions/package/gen-docs.ts
+import { existsSync as existsSync6 } from "node:fs";
+import path6 from "node:path";
+import chalk27 from "chalk";
+import { Application, ArgumentsReader, TSConfigReader, TypeDocReader } from "typedoc";
+var ExitCodes = {
+  CompileError: 3,
+  ExceptionThrown: 6,
+  NoEntryPoints: 2,
+  Ok: 0,
+  OptionError: 1,
+  OutputError: 5,
+  ValidationError: 4
+};
+var packageGenDocs = /* @__PURE__ */ __name(async () => {
+  const pkg = process.env.INIT_CWD;
+  if (pkg && !existsSync6(path6.join(pkg, "typedoc.json"))) {
+    return;
+  }
+  const app = await Application.bootstrap({
+    entryPointStrategy: "merge",
+    entryPoints: [
+      `${pkg}/src/**/*.ts`,
+      `${pkg}/packages/*/dist/docs.json`
+    ],
+    excludeExternals: true,
+    json: `${pkg}/dist/docs.json`,
+    logLevel: "Error",
+    tsconfig: `${pkg}/tsconfig.json`
+  });
+  app.options.addReader(new ArgumentsReader(0));
+  app.options.addReader(new TypeDocReader());
+  app.options.addReader(new TSConfigReader());
+  app.options.addReader(new ArgumentsReader(300));
+  return await runTypeDoc(app);
+}, "packageGenDocs");
+var runTypeDoc = /* @__PURE__ */ __name(async (app) => {
+  const pkgName = process.env.npm_package_name;
+  if (app.options.getValue("version")) {
+    console.log(app.toString());
+    return ExitCodes.Ok;
+  }
+  if (app.options.getValue("showConfig")) {
+    console.log(app.options.getRawValues());
+    return ExitCodes.Ok;
+  }
+  if (app.logger.hasErrors()) {
+    return ExitCodes.OptionError;
+  }
+  if (app.options.getValue("treatWarningsAsErrors") && app.logger.hasWarnings()) {
+    return ExitCodes.OptionError;
+  }
+  if (app.options.getValue("entryPoints").length === 0) {
+    app.logger.error("No entry points provided");
+    return ExitCodes.NoEntryPoints;
+  }
+  if (app.options.getValue("watch")) {
+    app.convertAndWatch(async (project2) => {
+      const out = app.options.getValue("out");
+      if (out) {
+        await app.generateDocs(project2, out);
+      }
+      const json = app.options.getValue("json");
+      if (json) {
+        await app.generateJson(project2, json);
+      }
+      if (!out && !json) {
+        await app.generateDocs(project2, "./docs");
+      }
+    });
+    return ExitCodes.Ok;
+  }
+  const project = await app.convert();
+  if (!project) {
+    return ExitCodes.CompileError;
+  }
+  if (app.options.getValue("treatWarningsAsErrors") && app.logger.hasWarnings()) {
+    return ExitCodes.CompileError;
+  }
+  app.validate(project);
+  if (app.logger.hasErrors()) {
+    return ExitCodes.ValidationError;
+  }
+  if (app.options.getValue("treatWarningsAsErrors") && app.logger.hasWarnings()) {
+    return ExitCodes.ValidationError;
+  }
+  if (app.options.getValue("emit") !== "none") {
+    const out = app.options.getValue("out");
+    if (out) {
+      await app.generateDocs(project, out);
+    }
+    const json = app.options.getValue("json");
+    if (json) {
+      await app.generateJson(project, json);
+    }
+    if (!out && !json) {
+      await app.generateDocs(project, "./docs");
+    }
+    if (app.logger.hasErrors()) {
+      return ExitCodes.OutputError;
+    }
+    if (app.options.getValue("treatWarningsAsErrors") && app.logger.hasWarnings()) {
+      return ExitCodes.OutputError;
+    }
+  }
+  console.log(chalk27.green(`${pkgName} - Ok`));
+  return ExitCodes.Ok;
+}, "runTypeDoc");
+
+// src/actions/package/recompile.ts
+var packageRecompile = /* @__PURE__ */ __name(async () => {
+  return (await Promise.all([
+    packageClean(),
+    packageCompile()
+  ])).reduce((prev, value) => prev + value, 0);
+}, "packageRecompile");
+
+// src/actions/publint.ts
+var publint = /* @__PURE__ */ __name(async ({ verbose, pkg }) => {
+  return pkg ? await publintPackage({
+    pkg,
+    verbose
+  }) : publintAll({
+    verbose
+  });
+}, "publint");
+var publintPackage = /* @__PURE__ */ __name(({ pkg }) => {
+  return runStepsAsync(`Publint [${pkg}]`, [
+    [
+      "yarn",
+      [
+        "workspace",
+        pkg,
+        "run",
+        "package-publint"
+      ]
+    ]
+  ]);
+}, "publintPackage");
+var publintAll = /* @__PURE__ */ __name(({ verbose }) => {
+  const verboseOptions = verbose ? [
+    "--verbose"
+  ] : [
+    "--no-verbose"
+  ];
+  return runSteps("Publint", [
+    [
+      "yarn",
+      [
+        "workspaces",
+        "foreach",
+        "-pA",
+        ...verboseOptions,
+        "run",
+        "package-publint"
+      ]
+    ]
+  ]);
+}, "publintAll");
+
+// src/actions/rebuild.ts
+var rebuild = /* @__PURE__ */ __name(({ target }) => {
+  return runSteps("Rebuild", [
+    [
+      "yarn",
+      "xy clean"
+    ],
+    [
+      "yarn",
+      target ? `xy build -t ${target}` : "xy build"
+    ]
+  ]);
+}, "rebuild");
+
+// src/actions/recompile.ts
+import chalk28 from "chalk";
+var recompile = /* @__PURE__ */ __name(async ({ verbose, target, pkg, incremental }) => {
+  return pkg ? await recompilePackage({
+    pkg,
+    target,
+    verbose
+  }) : await recompileAll({
+    incremental,
+    target,
+    verbose
+  });
+}, "recompile");
+var recompilePackage = /* @__PURE__ */ __name(({ verbose, target, pkg }) => {
+  const targetOptions = target ? [
+    "-t",
+    target
+  ] : [];
+  const verboseOptions = verbose ? [
+    "--verbose"
+  ] : [
+    "--no-verbose"
+  ];
+  return runStepsAsync(`Recompile [${pkg}]`, [
+    [
+      "yarn",
+      [
+        "workspace",
+        pkg,
+        ...verboseOptions,
+        "run",
+        "package-recompile",
+        ...targetOptions
+      ]
+    ]
+  ]);
+}, "recompilePackage");
+var recompileAll = /* @__PURE__ */ __name(async ({ jobs, verbose, target, incremental }) => {
+  const start = Date.now();
+  const verboseOptions = verbose ? [
+    "--verbose"
+  ] : [
+    "--no-verbose"
+  ];
+  const targetOptions = target ? [
+    "-t",
+    target
+  ] : [];
+  const incrementalOptions = incremental ? [
+    "--since",
+    "-Apt",
+    "--topological-dev"
+  ] : [
+    "--parallel",
+    "-Apt",
+    "--topological-dev"
+  ];
+  const jobsOptions = jobs ? [
+    "-j",
+    `${jobs}`
+  ] : [];
+  if (jobs) {
+    console.log(chalk28.blue(`Jobs set to [${jobs}]`));
+  }
+  const result = await runStepsAsync(`Recompile${incremental ? "-Incremental" : ""} [All]`, [
+    [
+      "yarn",
+      [
+        "workspaces",
+        "foreach",
+        ...incrementalOptions,
+        ...jobsOptions,
+        ...verboseOptions,
+        "run",
+        "package-recompile",
+        ...targetOptions
+      ]
+    ]
+  ]);
+  console.log(`${chalk28.gray("Recompiled in")} [${chalk28.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk28.gray("seconds")}`);
+  return result;
+}, "recompileAll");
+
+// src/actions/reinstall.ts
+import { closeSync, openSync, rmSync as rmSync2 } from "node:fs";
+var reinstall = /* @__PURE__ */ __name(() => {
+  console.log("Reinstall [Clear Lock File]");
+  closeSync(openSync("./yarn.lock", "w"));
+  console.log("Reinstall [Clear Node Modules]");
+  const workspaces = yarnWorkspaces();
+  const result = workspaces.map(({ location, name }) => {
+    const dist = `${location}/node_modules`;
+    try {
+      rmSync2(dist, {
+        force: true,
+        recursive: true
+      });
+      return 0;
+    } catch (ex) {
+      const error = ex;
+      console.error(`Reinstall [Clear Node Modules] Failed [${name}, ${error.message}]`);
+      return 1;
+    }
+  }).reduce((prev, result2) => prev || result2, 0);
+  return result || runSteps("Reinstall", [
+    [
+      "yarn",
+      "install --network-timeout 10000"
+    ]
+  ]);
+}, "reinstall");
+
+// src/actions/relint.ts
+import { rmSync as rmSync3 } from "node:fs";
+var relint = /* @__PURE__ */ __name(() => {
+  console.log("Relint - Cleaning [.eslintcache]");
+  const workspaces = yarnWorkspaces();
+  const result = workspaces.map(({ location, name }) => {
+    const dist = `${location}/.eslintcache`;
+    try {
+      rmSync3(dist, {
+        force: true,
+        recursive: true
+      });
+      return 0;
+    } catch (ex) {
+      const error = ex;
+      console.error(`Relint - Cleaning [.eslintcache] Failed [${name}, ${error.message}]`);
+      return 1;
+    }
+  }).reduce((prev, result2) => prev || result2, 0);
+  return result || runSteps("Relint", [
+    [
+      "yarn",
+      [
+        "eslint",
+        ".",
+        "--cache"
+      ]
+    ]
+  ]);
+}, "relint");
+
+// src/actions/retest.ts
+var retest = /* @__PURE__ */ __name(() => {
+  return runSteps("Test", [
+    [
+      "yarn",
+      [
+        "jest",
+        "--clearCache"
+      ]
+    ],
+    [
+      "yarn",
+      [
+        "jest",
+        "."
+      ]
+    ]
+  ]);
+}, "retest");
+
+// src/actions/sonar.ts
+var sonar = /* @__PURE__ */ __name(() => {
+  return runSteps("Sonar", [
+    [
+      "yarn",
+      [
+        "eslint",
+        "-c",
+        "sonar.eslintrc",
+        "."
+      ]
+    ]
+  ]);
+}, "sonar");
+
+// src/actions/statics.ts
+import chalk29 from "chalk";
+var DefaultDependencies = [
+  "axios",
+  "@xylabs/pixel",
+  "react",
+  "graphql",
+  "react-router",
+  "@mui/material",
+  "@mui/system"
+];
+var statics = /* @__PURE__ */ __name(() => {
+  console.log(chalk29.green("Check Required Static Dependencies"));
+  const statics2 = parsedPackageJSON()?.xy?.deps?.statics;
+  return detectDuplicateDependencies(statics2, DefaultDependencies);
+}, "statics");
+
+// src/actions/test.ts
+var test = /* @__PURE__ */ __name(() => {
+  return runSteps("Test", [
+    [
+      "yarn",
+      [
+        "jest",
+        "."
+      ]
+    ]
+  ]);
+}, "test");
+
+// src/actions/up.ts
+var up = /* @__PURE__ */ __name(() => {
+  return runSteps("Up", [
+    [
+      "yarn",
+      "outdated"
+    ]
+  ]);
+}, "up");
+
+// src/actions/updo.ts
+var updo = /* @__PURE__ */ __name(() => {
+  return runSteps("Updo", [
+    [
+      "yarn",
+      "install"
+    ],
+    [
+      "yarn",
+      "upgrade-interactive"
+    ],
+    [
+      "yarn",
+      "dedupe"
+    ]
+  ]);
+}, "updo");
+
+// src/actions/upplug.ts
+var updateYarnPlugins = /* @__PURE__ */ __name(() => {
+  return runSteps("Update Yarn Plugins", [
+    [
+      "yarn",
+      [
+        "plugin",
+        "import",
+        "https://mskelton.dev/yarn-outdated/v3"
+      ]
+    ],
+    [
+      "yarn",
+      [
+        "plugin",
+        "import",
+        "version"
+      ]
+    ],
+    [
+      "yarn",
+      [
+        "plugin",
+        "import",
+        "interactive-tools"
+      ]
+    ],
+    [
+      "yarn",
+      [
+        "plugin",
+        "import",
+        "workspace-tools"
+      ]
+    ]
+  ]);
+}, "updateYarnPlugins");
+
+// src/actions/upyarn.ts
+var updateYarnVersion = /* @__PURE__ */ __name(() => {
+  return runSteps("Update Yarn Version", [
+    [
+      "yarn",
+      [
+        "set",
+        "version",
+        "latest"
+      ]
+    ]
+  ]);
+}, "updateYarnVersion");
+
+// src/actions/yarn3only.ts
+var yarn3Only = /* @__PURE__ */ __name(() => {
+  const [valid, version] = isYarnVersionOrGreater(3);
+  if (!valid) {
+    processEx(`Invalid Yarn version [${version}]`);
+  }
+  return 0;
+}, "yarn3Only");
+
+// src/loadPackageConfig.ts
+import { readFile } from "node:fs/promises";
+var loadPackageConfig = /* @__PURE__ */ __name(async () => {
+  const pkg = process.env.INIT_CWD;
+  const pkgConfig = await readFile(`${pkg}/package.json`, {
+    encoding: "utf8"
+  });
+  return JSON.parse(pkgConfig);
+}, "loadPackageConfig");
+
+// src/xy/xy.ts
+import chalk31 from "chalk";
+
+// src/xy/xyBuildCommands.ts
+var xyBuildCommands = /* @__PURE__ */ __name((args) => {
+  return args.command("build [package]", "Build - Compile & Lint", (yargs2) => {
+    return yargs2.positional("package", {
+      describe: "Specific package to build"
+    });
+  }, async (argv) => {
+    if (argv.verbose) {
+      console.log(`Building: ${argv.package ?? "all"}`);
+    }
+    process.exitCode = await build({
+      incremental: !!argv.incremental,
+      jobs: argv.jobs,
+      pkg: argv.package,
+      target: argv.target,
+      verbose: !!argv.verbose
+    });
+  }).command("compile [package]", "Compile with Typescript & Copy Images", (yargs2) => {
+    return yargs2.positional("package", {
+      describe: "Specific package to compile"
+    });
+  }, async (argv) => {
+    if (argv.verbose) {
+      console.log(`Compiling: ${argv.package ?? "all"}`);
+    }
+    process.exitCode = await compile({
+      incremental: !!argv.incremental,
+      jobs: argv.jobs,
+      pkg: argv.package,
+      target: argv.target,
+      verbose: !!argv.verbose
+    });
+  }).command("compile-only [package]", "Compile with Typescript & Copy Images (No Publint)", (yargs2) => {
+    return yargs2.positional("package", {
+      describe: "Specific package to compile"
+    });
+  }, async (argv) => {
+    if (argv.verbose) {
+      console.log(`Compiling: ${argv.package ?? "all"}`);
+    }
+    process.exitCode = await compile({
+      incremental: !!argv.incremental,
+      jobs: argv.jobs,
+      pkg: argv.package,
+      publint: false,
+      target: argv.target,
+      verbose: !!argv.verbose
+    });
+  }).command("recompile [package]", "Re-compile with Typescript & Copy Images", (yargs2) => {
+    return yargs2.positional("package", {
+      describe: "Specific package to re-compile"
+    });
+  }, async (argv) => {
+    if (argv.verbose) {
+      console.log(`Re-compiling: ${argv.package ?? "all"}`);
+    }
+    process.exitCode = await recompile({
+      incremental: !!argv.incremental,
+      jobs: argv.jobs,
+      pkg: argv.package,
+      target: argv.target,
+      verbose: !!argv.verbose
+    });
+  }).command("rebuild [package]", "Rebuild - Clean, Compile & Lint", (yargs2) => {
+    return yargs2.positional("package", {
+      describe: "Specific package to rebuild"
+    });
+  }, (argv) => {
+    if (argv.verbose) console.log(`Rebuilding: ${argv.package ?? "all"}`);
+    process.exitCode = rebuild({
+      target: argv.target
+    });
+  }).command("copy-assets [package]", "Copy Assets - Copy the assets from src to dist", (yargs2) => {
+    return yargs2.positional("package", {
+      describe: "Specific package to copy assets"
+    });
+  }, async (argv) => {
+    if (argv.verbose) console.log(`Copying Assets: ${argv.package ?? "all"}`);
+    process.exitCode = await copyAssets({
+      target: argv.target
+    });
+  });
+}, "xyBuildCommands");
+
+// src/xy/param.ts
+var packagePositionalParam = /* @__PURE__ */ __name((yargs2) => {
+  return yargs2.positional("package", {
+    describe: "Specific package to target"
+  });
+}, "packagePositionalParam");
+
+// src/xy/xyCommonCommands.ts
+var xyCommonCommands = /* @__PURE__ */ __name((args) => {
+  return args.command("license [package]", "License - Check licenses of dependencies", (yargs2) => {
+    return packagePositionalParam(yargs2);
+  }, async (argv) => {
+    if (argv.verbose) console.log(`License: ${argv.package ?? "all"}`);
+    process.exitCode = await license();
+  }).command("dead [package]", "Dead - Check for dead code", (yargs2) => {
+    return packagePositionalParam(yargs2);
+  }, (argv) => {
+    if (argv.verbose) console.log("Dead");
+    process.exitCode = dead();
+  }).command("deps [package]", "Deps - Check for unused or missing dependencies", (yargs2) => {
+    return packagePositionalParam(yargs2);
+  }, (argv) => {
+    if (argv.verbose) console.log(`Checking Dependencies: ${argv.package ?? "all"}`);
+    process.exitCode = deps({
+      incremental: !!argv.incremental,
+      jobs: argv.jobs,
+      pkg: argv.package
+    });
+  }).command("gen-docs [package]", "GenDocs - Generate TypeDocs", (yargs2) => {
+    return packagePositionalParam(yargs2);
+  }, (argv) => {
+    if (argv.verbose) console.log(`Generating TypeDocs: ${argv.package ?? "all"}`);
+    process.exitCode = genDocs({
+      incremental: !!argv.incremental,
+      pkg: argv.package
+    });
+  }).command("clean-docs", "CleanDocs - Clean TypeDocs", (yargs2) => yargs2, (argv) => {
+    if (argv.verbose) console.log("Cleaning TypeDocs: all");
+    process.exitCode = cleanDocs();
+  }).command("gitlint [package]", "Gitlint - Lint your git config", (yargs2) => {
+    return yargs2;
+  }, (argv) => {
+    if (argv.verbose) console.log("Gitlint");
+    process.exitCode = argv.fix ? gitlintFix() : gitlint();
+  }).command("gitignore-gen", "GitIgnore Gen - Generate .gitignore files", (yargs2) => {
+    return yargs2;
+  }, (argv) => {
+    if (argv.verbose) console.log("GitIgnore Gen");
+    process.exitCode = gitignoreGen();
+  }).command("npmignore-gen", "NpmIgnore Gen - Generate .npmignore files", (yargs2) => {
+    return yargs2;
+  }, (argv) => {
+    if (argv.verbose) console.log("NpmIgnore Gen");
+    process.exitCode = npmignoreGen();
+  }).command("retest", "Re-Test - Run Jest Tests with cleaned cache", (yargs2) => {
+    return yargs2;
+  }, (argv) => {
+    if (argv.verbose) console.log("Re-Testing");
+    process.exitCode = retest();
+  }).command("test", "Test - Run Jest Tests", (yargs2) => {
+    return yargs2;
+  }, (argv) => {
+    if (argv.verbose) console.log("Testing");
+    process.exitCode = test();
+  }).command("upplug", "UpPlug - Update Yarn Plugins", (yargs2) => {
+    return yargs2;
+  }, (argv) => {
+    if (argv.verbose) console.log("UpPlug");
+    process.exitCode = updateYarnPlugins();
+  }).command("upyarn", "UpYarn - Update Yarn Version", (yargs2) => {
+    return yargs2;
+  }, (argv) => {
+    if (argv.verbose) console.log("UpYarn");
+    process.exitCode = updateYarnVersion();
+  }).command("yarn3only", "Yarn3Only - Check if using Yarn v3", (yargs2) => {
+    return yargs2;
+  }, (argv) => {
+    if (argv.verbose) console.log("Yarn 3 Check");
+    process.exitCode = yarn3Only();
+  });
+}, "xyCommonCommands");
+
+// src/xy/xyDeployCommands.ts
+var xyDeployCommands = /* @__PURE__ */ __name((args) => {
+  return args.command("deploy", "Deploy - Deploy patch", (yargs2) => {
+    return yargs2;
+  }, (argv) => {
+    if (argv.verbose) console.log("Deploy patch");
+    process.exitCode = deploy();
+  }).command("deploy-minor", "Deploy - Deploy minor", (yargs2) => {
+    return yargs2;
+  }, (argv) => {
+    if (argv.verbose) console.log("Deploy minor");
+    process.exitCode = deployMinor();
+  }).command("deploy-major", "Deploy - Deploy major", (yargs2) => {
+    return yargs2;
+  }, (argv) => {
+    if (argv.verbose) console.log("Deploy major");
+    process.exitCode = deployMajor();
+  }).command("deploy-next", "Deploy - Deploy next", (yargs2) => {
+    return yargs2;
+  }, (argv) => {
+    if (argv.verbose) console.log("Deploy next");
+    process.exitCode = deployNext();
+  });
+}, "xyDeployCommands");
+
+// src/xy/xyInstallCommands.ts
+var xyInstallCommands = /* @__PURE__ */ __name((args) => {
+  return args.command("clean [package]", "Clean", (yargs2) => {
+    return yargs2.positional("package", {
+      describe: "Specific package to clean"
+    });
+  }, async (argv) => {
+    if (argv.verbose) {
+      console.log(`Cleaning: ${argv.package ?? "all"}`);
+    }
+    process.exitCode = await clean({
+      pkg: argv.package,
+      verbose: !!argv.verbose
+    });
+  }).command("reinstall", "Reinstall - Clean & Install", (yargs2) => {
+    return yargs2;
+  }, (argv) => {
+    if (argv.verbose) console.log("Reinstalling");
+    process.exitCode = reinstall();
+  }).command("up", "Up - Update dependencies", (yargs2) => {
+    return yargs2;
+  }, (argv) => {
+    if (argv.verbose) console.log("Up");
+    process.exitCode = up();
+  }).command("updo", "Updo - Update dependencies [Interactive]", (yargs2) => {
+    return yargs2;
+  }, (argv) => {
+    if (argv.verbose) console.log("Updo");
+    process.exitCode = updo();
+  }).command("statics", "Statics - Confirming Static Packages", (yargs2) => {
+    return yargs2;
+  }, (argv) => {
+    if (argv.verbose) console.log("Statics");
+    process.exitCode = statics();
+  }).command("dupdeps", "Dupdeps - Duplicate Dependencies in package.json", (yargs2) => {
+    return yargs2;
+  }, (argv) => {
+    if (argv.verbose) console.log("Dupdeps");
+    process.exitCode = dupdeps();
+  });
+}, "xyInstallCommands");
+
+// src/xy/xyLintCommands.ts
+import chalk30 from "chalk";
+var xyLintCommands = /* @__PURE__ */ __name((args) => {
+  return args.command("cycle [package]", "Cycle - Check for dependency cycles", (yargs2) => {
+    return packagePositionalParam(yargs2);
+  }, (argv) => {
+    const start = Date.now();
+    if (argv.verbose) console.log("Cycle");
+    process.exitCode = cycle();
+    console.log(chalk30.blue(`Finished in ${Date.now() - start}ms`));
+  }).command("lint [package]", "Lint - Run Eslint", (yargs2) => {
+    return packagePositionalParam(yargs2);
+  }, async (argv) => {
+    if (argv.verbose) console.log("Lint");
+    const start = Date.now();
+    process.exitCode = argv.fix ? fix() : argv.profile ? lintProfile() : await lint({
+      pkg: argv.package
+    });
+    console.log(chalk30.blue(`Finished in ${Date.now() - start}ms`));
+  }).command("fix [package]", "Fix - Run Eslint w/fix", (yargs2) => {
+    return packagePositionalParam(yargs2);
+  }, (argv) => {
+    const start = Date.now();
+    if (argv.verbose) console.log("Fix");
+    process.exitCode = fix();
+    console.log(chalk30.blue(`Finished in ${Date.now() - start}ms`));
+  }).command("relint [package]", "Relint - Clean & Lint", (yargs2) => {
+    return packagePositionalParam(yargs2);
+  }, (argv) => {
+    if (argv.verbose) console.log("Relinting");
+    const start = Date.now();
+    process.exitCode = relint();
+    console.log(chalk30.blue(`Finished in ${Date.now() - start}ms`));
+  }).command("publint [package]", "Publint - Run Publint", (yargs2) => {
+    return packagePositionalParam(yargs2);
+  }, async (argv) => {
+    if (argv.verbose) console.log("Publint");
+    const start = Date.now();
+    process.exitCode = await publint({
+      pkg: argv.package,
+      verbose: !!argv.verbose
+    });
+    console.log(chalk30.blue(`Finished in ${Date.now() - start}ms`));
+  }).command("sonar", "Sonar - Run Sonar Check", (yargs2) => {
+    return packagePositionalParam(yargs2);
+  }, (argv) => {
+    const start = Date.now();
+    if (argv.verbose) console.log("Sonar Check");
+    process.exitCode = sonar();
+    console.log(chalk30.blue(`Finished in ${Date.now() - start}ms`));
+  });
+}, "xyLintCommands");
+
+// src/xy/xyParseOptions.ts
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+var xyParseOptions = /* @__PURE__ */ __name(() => {
+  return yargs(hideBin(process.argv)).scriptName("yarn xy").option("jobs", {
+    alias: "j",
+    default: void 0,
+    description: "Max parallel jobs",
+    type: "number"
+  }).option("verbose", {
+    alias: "v",
+    default: false,
+    description: "Run with verbose logging",
+    type: "boolean"
+  }).option("target", {
+    alias: "t",
+    choices: [
+      "esm",
+      "cjs"
+    ],
+    description: "Limit output to specific target",
+    type: "string"
+  }).option("incremental", {
+    alias: "i",
+    default: false,
+    description: "Attempt to perform the action only on changed packages",
+    type: "boolean"
+  }).option("fix", {
+    alias: "f",
+    default: false,
+    description: "Try to fix errors",
+    type: "boolean"
+  }).option("cache", {
+    alias: "c",
+    default: false,
+    description: "Use caching for performance",
+    type: "boolean"
+  }).option("profile", {
+    alias: "p",
+    default: false,
+    description: "Profile action",
+    type: "boolean"
+  });
+}, "xyParseOptions");
+
+// src/xy/xy.ts
+var xy = /* @__PURE__ */ __name(async () => {
+  const options = xyParseOptions();
+  return await xyBuildCommands(xyCommonCommands(xyInstallCommands(xyDeployCommands(xyLintCommands(options))))).demandCommand(1).command("*", "", () => {
+    console.error(chalk31.yellow(`Command not found [${chalk31.magenta(process.argv[2])}]`));
+    console.log(chalk31.gray("Try 'yarn xy --help' for list of commands"));
+  }).version().help().argv;
+}, "xy");
+export {
+  CROSS_PLATFORM_NEWLINE,
+  DuplicateDetector,
+  INIT_CWD,
+  WINDOWS_NEWLINE_REGEX,
+  build,
+  checkResult,
+  clean,
+  cleanAll,
+  cleanDocs,
+  cleanPackage,
+  compile,
+  compileAll,
+  compilePackage,
+  copyAssets,
+  createBuildConfig,
+  cycle,
+  dead,
+  defaultBuildConfig,
+  defaultReadFileSyncOptions,
+  deploy,
+  deployMajor,
+  deployMinor,
+  deployNext,
+  deps,
+  depsAll,
+  depsPackage,
+  detectDuplicateDependencies,
+  dupdeps,
+  empty,
+  fix,
+  genDocs,
+  genDocsAll,
+  genDocsPackage,
+  generateIgnoreFiles,
+  gitignoreGen,
+  gitlint,
+  gitlintFix,
+  isYarnVersionOrGreater,
+  license,
+  lint,
+  lintAll,
+  lintClean,
+  lintPackage,
+  lintProfile,
+  loadConfig,
+  loadPackageConfig,
+  multiLineToJSONArray,
+  notEmpty,
+  npmignoreGen,
+  packageClean,
+  packageCleanOutputs,
+  packageCleanTypescript,
+  packageCompile,
+  packageCompileTsc,
+  packageCompileTsup,
+  packageCopyAssets,
+  packageDeps,
+  packageGenDocs,
+  packagePublint,
+  packageRecompile,
+  parsedPackageJSON,
+  processEx,
+  publint,
+  publintAll,
+  publintPackage,
+  readLines,
+  readNonEmptyLines,
+  rebuild,
+  recompile,
+  recompileAll,
+  recompilePackage,
+  reinstall,
+  relint,
+  retest,
+  runStepAsync,
+  runSteps,
+  runStepsAsync,
+  runXy,
+  runXyWithWarning,
+  safeExit,
+  safeExitAsync,
+  sonar,
+  statics,
+  test,
+  tryReadFileSync,
+  union,
+  up,
+  updateYarnPlugins,
+  updateYarnVersion,
+  updo,
+  withErrnoException,
+  withError,
+  writeLines,
+  xy,
+  xyBuildCommands,
+  xyCommonCommands,
+  xyDeployCommands,
+  xyInstallCommands,
+  xyLintCommands,
+  xyParseOptions,
+  yarn3Only,
+  yarnWorkspace,
+  yarnWorkspaces
+};
 //# sourceMappingURL=index.mjs.map