creatium 0.1.17 → 0.2.2

package/dist/{main.mjs → index.mjs}

@@ -1,830 +1,13 @@
-import { deepmergeCustom, deepmerge } from 'deepmerge-ts';
-import process$1 from 'node:process';
-import { spawn } from 'node:child_process';
-import yargs from 'yargs';
-import { hideBin as hideBin$1 } from 'yargs/helpers';
-import * as p from '@clack/prompts';
-import { TextPrompt } from '@clack/core';
-import gradientString from 'gradient-string';
-import { styleText } from 'node:util';
-import stringWidth from 'string-width';
-import { boxen } from '@visulima/boxen';
-import Table from 'cli-table3';
-import columnify from 'columnify';
-import { writeFile as writeFile$1, readFile as readFile$1, readdir, rm, unlink, stat, mkdir, access, constants, copyFile as copyFile$1, lstat, symlink } from 'node:fs/promises';
-import { resolve, relative, extname, dirname, basename, isAbsolute, normalize, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import glob from 'tiny-glob';
-import { homedir as homedir$1, tmpdir as tmpdir$1, platform, arch } from 'node:os';
+import { formatter } from '@clippium/preset-colored';
+import { hiddenBin, Clippium } from 'clippium';
+import { W as Wn, q as qn, U as Un, z as zn, S as Sn, P as Pn, a2 as Si, x as xi, T as Tn, ae as Hi, O as On, V as Vn, a as ai, ab as Wi, ag as Vi, ac as Li, L as Ln, a4 as Ti } from './shared/creatium.v0AbQ44Q.mjs';
+import 'module';
 
-const isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined";
-const isNode = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
-const isWebWorker = typeof self === "object" && self.constructor && self.constructor.name === "DedicatedWorkerGlobalScope";
-const isJsDom = typeof window !== "undefined" && window.name === "nodejs" || typeof navigator !== "undefined" && "userAgent" in navigator && typeof navigator.userAgent === "string" && (navigator.userAgent.includes("Node.js") || navigator.userAgent.includes("jsdom"));
-const isDeno = typeof Deno !== "undefined" && typeof Deno.version !== "undefined" && typeof Deno.version.deno !== "undefined";
-const isBun = typeof process !== "undefined" && process.versions != null && process.versions.bun != null;
-const env$2 = {
-  isBrowser,
-  isWebWorker,
-  isNode,
-  isJsDom,
-  isDeno,
-  isBun
-};
-
-const execChild = async (cmd) => {
-  return new Promise((resolve, reject) => {
-    const options = {
-      shell: true,
-      stdio: "pipe"
-    };
-    const childProcess = spawn(cmd, options);
-    let stdout = "", stderr = "";
-    childProcess.stdout?.on("data", (data) => {
-      stdout += data.toString();
-    });
-    childProcess.stderr?.on("data", (data) => {
-      stderr += data.toString();
-    });
-    childProcess.on("close", (code) => {
-      if (code === 0) {
-        resolve({
-          stdout,
-          stderr
-        });
-      } else {
-        const data = {
-          code,
-          stdout,
-          stderr
-        };
-        reject(data);
-      }
-    });
-    childProcess.on("error", (err) => {
-      reject(err);
-    });
-  });
-};
-const existsLocalBin = async (binName) => {
-  const command = process$1.platform === "win32" ? `where ${binName}` : `which ${binName}`;
-  try {
-    await execChild(command);
-    return true;
-  } catch (_e) {
-    return false;
-  }
-};
-
-const hideBin = hideBin$1;
-const createCli = async (options) => {
-  const {
-    args = process.argv,
-    fn
-  } = options;
-  const bin = yargs(args);
-  await fn(bin);
-  bin.help();
-  bin.parse();
-  return bin;
-};
-
-const cTypes = [
-  // ForegroundColors
-  "black",
-  "blackBright",
-  "blue",
-  "blueBright",
-  "cyan",
-  "cyanBright",
-  "gray",
-  "green",
-  "greenBright",
-  "grey",
-  "magenta",
-  "magentaBright",
-  "red",
-  "redBright",
-  "white",
-  "whiteBright",
-  "yellow",
-  "yellowBright",
-  // BackgroundColors
-  "bgBlack",
-  "bgBlackBright",
-  "bgBlue",
-  "bgBlueBright",
-  "bgCyan",
-  "bgCyanBright",
-  "bgGray",
-  "bgGreen",
-  "bgGreenBright",
-  "bgGrey",
-  "bgMagenta",
-  "bgMagentaBright",
-  "bgRed",
-  "bgRedBright",
-  "bgWhite",
-  "bgWhiteBright",
-  "bgYellow",
-  "bgYellowBright",
-  // Modifiers
-  "blink",
-  "bold",
-  "dim",
-  "doubleunderline",
-  "framed",
-  "hidden",
-  "inverse",
-  "italic",
-  "overlined",
-  "reset",
-  "strikethrough",
-  "underline"
-];
-const _color = (t, v) => styleText(t, v);
-const _colorObj = cTypes.reduce((acc, t) => {
-  acc[t] = (v) => _color(t, v);
-  return acc;
-}, {});
-const color = _colorObj;
-const gradient = (txt, colors, opts) => {
-  return gradientString(colors, opts).multiline(txt);
-};
-
-const line = ({
-  title,
-  lineChar = "\u23AF",
-  align = "center"
-}) => {
-  const lineCharLength = stringWidth(lineChar);
-  const totalWidth = process.stdout.columns;
-  const textLength = title ? stringWidth(title) : 0;
-  const width = Math.floor((totalWidth - textLength) / (2 * lineCharLength));
-  const line2 = lineChar.repeat(width);
-  if (align === "left") return title + line2 + line2;
-  else if (align === "right") return line2 + line2 + title;
-  return line2 + title + line2;
-};
-
-const table = (data, options) => {
-  const _table = new Table(options);
-  _table.push(...data);
-  return _table.toString();
-};
-const box = (text, options) => boxen(text, options);
-const columns = (data, options) => columnify(data, options);
-
-const style$1 = {
-  color,
-  gradient,
-  box,
-  columns,
-  table,
-  line
-};
-
-const isUnicodeSupported = () => {
-  if (process$1.platform !== "win32") return process$1.env.TERM !== "linux";
-  return Boolean(process$1.env.WT_SESSION) || Boolean(process$1.env.TERMINUS_SUBLIME) || process$1.env.ConEmuTask === "{cmd::Cmder}" || process$1.env.TERM_PROGRAM === "Terminus-Sublime" || process$1.env.TERM_PROGRAM === "vscode" || process$1.env.TERM === "xterm-256color" || process$1.env.TERM === "alacritty" || process$1.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
-};
-const unicode = isUnicodeSupported();
-const s = (c, fallback) => unicode ? c : fallback;
-const symbols = {
-  STEP_ACTIVE: s("\u25C6", "*"),
-  STEP_CANCEL: s("\u25A0", "x"),
-  STEP_ERROR: s("\u25B2", "x"),
-  STEP_SUBMIT: s("\u25C7", "o"),
-  BAR: s("\u2502", "|"),
-  BAR_END: s("\u2514", "\u2014")
-};
-const symbol = (state) => {
-  if (state === "initial" || state === "active")
-    return color.cyan(symbols.STEP_ACTIVE);
-  else if (state === "cancel")
-    return color.red(symbols.STEP_CANCEL);
-  else if (state === "error")
-    return color.yellow(symbols.STEP_ERROR);
-  else if (state === "submit")
-    return color.green(symbols.STEP_SUBMIT);
-};
-
-async function number(opts) {
-  return new TextPrompt({
-    validate: (value) => {
-      const errorDefault = "Value must be a number without";
-      const spaces = /\s/.test(value);
-      const isNum = typeof Number(value) === "number" && !isNaN(Number(value));
-      if (!value || !isNum) return opts.errorText ? opts.errorText : errorDefault;
-      if (spaces) return opts.errorText ? opts.errorText : errorDefault;
-      if (opts.validate) return opts.validate(value);
-    },
-    placeholder: opts.placeholder,
-    defaultValue: opts.defaultValue,
-    initialValue: opts.initialValue,
-    render() {
-      const title = `${color.gray(symbols.BAR)}
-${symbol(this.state)}  ${opts.message}
-`;
-      const placeholder = opts.placeholder ? color.inverse(opts.placeholder[0]) + color.dim(opts.placeholder.slice(1)) : color.inverse(color.hidden("_"));
-      const value = !this.value ? placeholder : this.valueWithCursor;
-      switch (this.state) {
-        case "error":
-          return `${title.trim()}
-${color.yellow(symbols.BAR)}  ${value}
-${color.yellow(
-            symbols.BAR_END
-          )}  ${color.yellow(this.error)}
-`;
-        case "submit":
-          return `${title}${color.gray(symbols.BAR)}  ${color.dim(this.value || opts.placeholder)}`;
-        case "cancel":
-          return `${title}${color.gray(symbols.BAR)}  ${color.strikethrough(
-            color.dim(this.value ?? "")
-          )}${this.value?.trim() ? "\n" + color.gray(symbols.BAR) : ""}`;
-        default:
-          return `${title}${color.cyan(symbols.BAR)}  ${value}
-${color.cyan(symbols.BAR_END)}
-`;
-      }
-    }
-  }).prompt();
-}
-
-const promptLineMethods = {
-  message: "message"};
-
-const clackPrompts = p;
-const printOptions = {
-  /**
-   * Logs a table in the prompt line.
-   */
-  table: ({
-    value,
-    opts,
-    type = promptLineMethods.message
-  }) => p.log[type](table(value, opts)),
-  /**
-   * Logs data formatted into aligned columns in the prompt line.
-   */
-  columns: ({
-    value,
-    opts,
-    type = promptLineMethods.message
-  }) => p.log[type](columns(value, opts)),
-  /**
-   * Logs a styled box in the prompt line.
-   */
-  box: ({
-    value,
-    opts,
-    type = promptLineMethods.message
-  }) => p.log[type](box(value, opts))
-};
-const corePromptLine = {
-  ...clackPrompts,
-  number,
-  ...printOptions
-};
-
-const replacePlaceholders = async (props) => {
-  const { content, params, transform, opts } = props;
-  const { prefix, suffix } = opts?.mark || {
-    prefix: "{{",
-    suffix: "}}"
-  };
-  const escapeRegExp = (v) => v.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const regex = new RegExp(
-    `${escapeRegExp(prefix)}\\s*([^}]+?)\\s*${escapeRegExp(suffix)}`,
-    "g"
-  );
-  const getValue = (obj, path) => {
-    const parts = path.split(".");
-    let result2 = obj;
-    for (const part of parts) {
-      if (result2 === void 0) return void 0;
-      if (part.includes("[") && part.includes("]")) {
-        const [arrayName, indexStr] = part.split("[");
-        const index = parseInt(indexStr.replace("]", ""), 10);
-        result2 = result2[arrayName]?.[index];
-      } else {
-        result2 = result2[part];
-      }
-    }
-    return result2;
-  };
-  const replaceAsync = async (match, key) => {
-    if (transform) {
-      const transformed = await transform(key);
-      if (transformed !== key) return transformed;
-    }
-    const value = getValue(params, key);
-    if (value === void 0) {
-      if (opts?.throw) throw new Error(`Placeholder ${key} not found`);
-      return match;
-    }
-    return String(value);
-  };
-  let result = content;
-  const matches = [...content.matchAll(regex)];
-  for (const match of matches) {
-    const [fullMatch, key] = match;
-    const replacement = await replaceAsync(fullMatch, key);
-    result = result.replace(fullMatch, replacement);
-  }
-  return result;
-};
-
-const getHomeDir = homedir$1;
-const getTempDir = () => tmpdir$1();
-const getPlatform = async () => {
-  const p = platform();
-  switch (p) {
-    case "win32":
-      return "windows";
-    case "darwin":
-      return "macos";
-    case "linux":
-      return "linux";
-    default:
-      return "unknown";
-  }
-};
-function getArch() {
-  const architecture = arch();
-  switch (architecture) {
-    case "arm64":
-      return "arm64";
-    case "arm":
-      return "arm64";
-    // As 'arm' is also treated as 'arm64'.
-    case "x64":
-      return "x64";
-    default:
-      return "unknown";
-  }
-}
-
-const resolvePath = resolve;
-const relativePath = relative;
-const getExtName = extname;
-const getDirName = dirname;
-const getBaseName = basename;
-const isAbsolutePath = isAbsolute;
-const normalizePath = normalize;
-const writeFile = writeFile$1;
-const getPaths = glob;
-const arePathsEqual = (path1, path2) => {
-  const normalizedPath1 = resolvePath(path1);
-  const normalizedPath2 = resolvePath(path2);
-  return normalizedPath1 === normalizedPath2;
-};
-const isPath = (str) => {
-  if (isAbsolute(str) || /^(\.\/|\.\.\/|[A-Za-z]:\\|\/)/.test(str)) {
-    if (isAbsolute(str) || /^(\.\/|\.\.\/|[A-Za-z]:\\|\/)/.test(str)) {
-      if (/\s(?!\\)/.test(str) && !/\\\s/.test(str))
-        return false;
-      try {
-        const normalizedPath = join(str);
-        return normalizedPath !== "";
-      } catch {
-        return false;
-      }
-    }
-  }
-  return false;
-};
-const ensureDir = async (path) => {
-  const exist = await existsDir(path);
-  if (!exist) await createDir(path);
-};
-const readDir = async (path) => {
-  path = validateHomeDir(path);
-  return await readdir(path, { withFileTypes: true });
-};
-async function getFilteredFileNames({
-  path,
-  extensions = []
-}) {
-  const files = await readDir(path);
-  const filteredFileNames = files.filter((file) => {
-    const ext = getExtName(file.name);
-    return extensions.includes(ext);
-  }).map((file) => getBaseName(file.name, getExtName(file.name)));
-  return filteredFileNames;
-}
-const getCurrentDir = (path = import.meta.url) => getDirName(fileURLToPath(path));
-function joinPath(...paths) {
-  return join(...paths);
-}
-const getAbsolutePath = resolve;
-function validateHomeDir(path) {
-  let resolvedPath = path;
-  if (path.startsWith("~/")) {
-    resolvedPath = path.replace(/^~(?=$|\/|\\)/, getHomeDir());
-  }
-  return getAbsolutePath(resolvedPath);
-}
-const readFile = readFile$1;
-async function removeDir(path) {
-  try {
-    path = validateHomeDir(path);
-    await rm(path, {
-      recursive: true,
-      force: true
-    });
-  } catch (error) {
-    throw new Error(`Error removing ${path}: ${error.message}`);
-  }
-}
-async function removeDirIfExist(path) {
-  path = validateHomeDir(path);
-  const exists = await existsDir(path);
-  if (exists) await removeDir(path);
-}
-async function removePathIfExist(path) {
-  path = validateHomeDir(path);
-  const isDir = await isDirectory(path);
-  if (isDir) await removeDirIfExist(path);
-  else await removeFileIfExist(path);
-}
-async function removeFileIfExist(path) {
-  path = validateHomeDir(path);
-  const exists = await existsFile(path);
-  if (exists) await unlink(path);
-}
-async function removeFile(path) {
-  await unlink(path);
-}
-async function isDirectory(path) {
-  path = validateHomeDir(path);
-  const stats = await stat(path);
-  return stats.isDirectory();
-}
-async function createDir(path) {
-  try {
-    path = validateHomeDir(path);
-    await mkdir(path, { recursive: true });
-  } catch (error) {
-    throw Error(`Error creating the directory: ${error}`);
-  }
-}
-async function existsDir(path) {
-  try {
-    path = validateHomeDir(path);
-    await access(path, constants.F_OK);
-    const stats = await stat(path);
-    return stats.isDirectory();
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return false;
-    } else {
-      throw error;
-    }
-  }
-}
-async function existsFile(path) {
-  try {
-    path = validateHomeDir(path);
-    await access(path);
-    const stats = await stat(path);
-    return stats.isFile();
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return false;
-    } else {
-      throw error;
-    }
-  }
-}
-async function writeFileContent(path, content) {
-  path = validateHomeDir(path);
-  await writeFile$1(path, content);
-}
-async function existsPath(path) {
-  const isFile = await existsFile(path);
-  if (isFile) return true;
-  const isDir = await existsDir(path);
-  return isDir;
-}
-const copyFile = async ({
-  input,
-  output
-}) => {
-  try {
-    await copyFile$1(input, output);
-  } catch (error) {
-    console.error(error);
-  }
-};
-const copyDir = async ({
-  input,
-  output
-}) => {
-  const _copyDir = async ({
-    input: input2,
-    output: output2
-  }) => {
-    if (!await existsDir(input2)) throw new Error(`Input directory does not exist`);
-    const entries = await readDir(input2);
-    const exist = await existsDir(output2);
-    if (!exist) await createDir(output2);
-    for (const entry of entries) {
-      const srcPath = join(input2, entry.name);
-      const destPath = join(output2, entry.name);
-      if (entry.isDirectory()) {
-        await _copyDir({
-          input: srcPath,
-          output: destPath
-        });
-      } else {
-        await copyFile({
-          input: srcPath,
-          output: destPath
-        });
-      }
-    }
-  };
-  try {
-    await _copyDir({
-      input,
-      output
-    });
-  } catch (error) {
-    if (error instanceof Error)
-      throw new Error(`Error copying directory "${input}" to "${output}": ${error.message}`);
-    throw new Error(`Error copying directory: ${error}`);
-  }
-};
-const createSymlink = async ({
-  input,
-  output
-}) => {
-  try {
-    await access(output);
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      await mkdir(output, { recursive: true });
-    } else {
-      throw `\u274C\u{1F517} ${error}`;
-    }
-  }
-  const sourceStat = await lstat(input);
-  const isWin = process$1.platform === "win32";
-  if (sourceStat.isDirectory()) {
-    if (isWin) {
-      await symlink(input, join(output, basename(input)), "junction");
-    } else {
-      await symlink(input, join(output, basename(input)), "dir");
-    }
-  } else if (sourceStat.isFile()) {
-    await symlink(input, join(output, basename(input)));
-  }
-  console.log(`\u{1F517} symlink: "${input}" to "${output}".`);
-};
-
-const homedir = getHomeDir();
-const tmpdir = getTempDir();
-const { env: env$1 } = process$1;
-const macos = (name) => {
-  const library = joinPath(homedir, "Library");
-  return {
-    data: joinPath(library, "Application Support", name),
-    config: joinPath(library, "Preferences", name),
-    cache: joinPath(library, "Caches", name),
-    log: joinPath(library, "Logs", name),
-    temp: joinPath(tmpdir, name)
-  };
-};
-const windows = (name) => {
-  const appData = env$1.APPDATA || joinPath(homedir, "AppData", "Roaming");
-  const localAppData = env$1.LOCALAPPDATA || joinPath(homedir, "AppData", "Local");
-  return {
-    // Data/config/cache/log are invented by me as Windows isn't opinionated about this
-    data: joinPath(localAppData, name, "Data"),
-    config: joinPath(appData, name, "Config"),
-    cache: joinPath(localAppData, name, "Cache"),
-    log: joinPath(localAppData, name, "Log"),
-    temp: joinPath(tmpdir, name)
-  };
-};
-const linux = (name) => {
-  const username = getBaseName(homedir);
-  return {
-    data: joinPath(env$1.XDG_DATA_HOME || joinPath(homedir, ".local", "share"), name),
-    config: joinPath(env$1.XDG_CONFIG_HOME || joinPath(homedir, ".config"), name),
-    cache: joinPath(env$1.XDG_CACHE_HOME || joinPath(homedir, ".cache"), name),
-    // https://wiki.debian.org/XDGBaseDirectorySpecification#state
-    log: joinPath(env$1.XDG_STATE_HOME || joinPath(homedir, ".local", "state"), name),
-    temp: joinPath(tmpdir, username, name)
-  };
-};
-const getSystemEnvPaths = ({
-  name,
-  suffix = "nodejs"
-}) => {
-  if (typeof name !== "string")
-    throw new TypeError(`Expected a string, got ${typeof name}`);
-  if (suffix) name += `-${suffix}`;
-  if (process$1.platform === "darwin") return macos(name);
-  if (process$1.platform === "win32") return windows(name);
-  return linux(name);
-};
-
-const getFileContent = async (path) => {
-  path = validateHomeDir(path);
-  const fileContentBuffer = await readFile(path);
-  const fileContent = fileContentBuffer.toString("utf8");
-  return fileContent;
-};
-const getObjectFromJSONContent = async (content) => {
-  const r = JSON.parse(content);
-  return r;
-};
-const getObjectFromJSONFile = async (path) => {
-  try {
-    const fileContent = await getFileContent(path);
-    return await getObjectFromJSONContent(fileContent);
-  } catch (error) {
-    throw new Error(`Error reading JSON file ${path}: ${error.message}`);
-  }
-};
-
-const cache = async (opts) => {
-  const {
-    id,
-    values,
-    projectName,
-    cwd,
-    suffix
-  } = opts;
-  const dir = cwd || getSystemEnvPaths({
-    name: projectName,
-    suffix
-  }).config;
-  const path = joinPath(dir, `config.json`);
-  const exists = await existsFile(path);
-  const defaultValues = { [id]: values };
-  const merge = deepmergeCustom({ mergeArrays: false });
-  const getCachedDataFromFile = async () => {
-    try {
-      const data = await getObjectFromJSONFile(path);
-      return data;
-    } catch {
-      return defaultValues;
-    }
-  };
-  let cachedData = exists ? await getCachedDataFromFile() : defaultValues;
-  const set = async (obj) => {
-    const exists2 = await existsFile(path);
-    if (!exists2) await ensureDir(dir);
-    const updatedData = merge(cachedData, { [id]: obj });
-    await writeFile(path, JSON.stringify(updatedData, null, 2));
-    cachedData = updatedData;
-  };
-  const get = async (v) => {
-    if (typeof v === "string") {
-      if (!cachedData[id] || typeof cachedData[id][v] === "undefined") return void 0;
-      return cachedData[id][v];
-    }
-    return cachedData[id];
-  };
-  const reset = async () => await set(values);
-  if (!exists) await set(values);
-  else {
-    const updatedData = merge({ [id]: values }, cachedData);
-    await set(updatedData[id]);
-  }
-  return {
-    /**
-     * The default values for the cache.
-     */
-    defaultValues: values,
-    /**
-     * Retrieve a value from the cache.
-     *
-     * @example
-     * const theme = get('theme');
-     * console.log(theme); // Output: 'light'
-     */
-    get,
-    /**
-     * Updates the cache with the provided values.
-     *
-     * Merges the existing cached values with the new partial values and updates the cache.
-     */
-    set,
-    /**
-     * Resets the cache to its default values.
-     *
-     * @example
-     * reset();
-     */
-    reset,
-    /**
-     * The path to the cache file.
-     */
-    path
-  };
-};
-
-const getClosestPackageJson = async (startDir = process$1.cwd()) => {
-  let currentDir = resolvePath(startDir);
-  while (true) {
-    const pkgPath = joinPath(currentDir, "package.json");
-    if (await existsFile(pkgPath)) return pkgPath;
-    const parentDir = getDirName(currentDir);
-    if (parentDir === currentDir)
-      throw new Error("No package.json found in any parent directory.");
-    currentDir = parentDir;
-  }
-};
-const getClosestPackageDir = async (startDir = process$1.cwd()) => {
-  const pkgPath = await getClosestPackageJson(startDir);
-  return getDirName(pkgPath);
-};
-
-const _sys = {
-	__proto__: null,
-	arePathsEqual: arePathsEqual,
-	cache: cache,
-	copyDir: copyDir,
-	copyFile: copyFile,
-	createDir: createDir,
-	createSymlink: createSymlink,
-	ensureDir: ensureDir,
-	existsDir: existsDir,
-	existsFile: existsFile,
-	existsPath: existsPath,
-	fileURLToPath: fileURLToPath,
-	getAbsolutePath: getAbsolutePath,
-	getArch: getArch,
-	getBaseName: getBaseName,
-	getClosestPackageDir: getClosestPackageDir,
-	getClosestPackageJson: getClosestPackageJson,
-	getCurrentDir: getCurrentDir,
-	getDirName: getDirName,
-	getExtName: getExtName,
-	getFilteredFileNames: getFilteredFileNames,
-	getHomeDir: getHomeDir,
-	getObjectFromJSONFile: getObjectFromJSONFile,
-	getPaths: getPaths,
-	getPlatform: getPlatform,
-	getSystemEnvPaths: getSystemEnvPaths,
-	getTempDir: getTempDir,
-	isAbsolutePath: isAbsolutePath,
-	isDirectory: isDirectory,
-	isPath: isPath,
-	joinPath: joinPath,
-	normalizePath: normalizePath,
-	readDir: readDir,
-	readFile: readFile,
-	relativePath: relativePath,
-	removeDir: removeDir,
-	removeDirIfExist: removeDirIfExist,
-	removeFile: removeFile,
-	removeFileIfExist: removeFileIfExist,
-	removePathIfExist: removePathIfExist,
-	resolvePath: resolvePath,
-	validateHomeDir: validateHomeDir,
-	writeFile: writeFile,
-	writeFileContent: writeFileContent
-};
-
-const SELECT_BASE_OPTS = { NONE: "none" };
-const mergeSelectBaseOptions = (config, defaultOptions) => {
-  const options = deepmerge(defaultOptions || {}, config.options || {});
-  const filteredOptions = config.onlyOptions && config.onlyOptions.length > 1 ? Object.entries(options).reduce((acc, [key, value]) => {
-    if (key === SELECT_BASE_OPTS.NONE || config.onlyOptions.includes(key))
-      acc[key] = value;
-    return acc;
-  }, {}) : options;
-  return {
-    ...config,
-    options: Object.keys(filteredOptions).length > 1 ? filteredOptions : options
-  };
-};
-
-const sys = _sys;
-const prompt = corePromptLine;
-const env = env$2;
-const style = style$1;
-
-const utils = {
-	__proto__: null,
-	env: env,
-	prompt: prompt,
-	style: style,
-	sys: sys
-};
-
-const coreUtils = utils;
-let Core$1 = class Core {
-  constructor(config) {
+class Core {
+  constructor(config, _utils) {
     this.config = config;
+    this._utils = _utils;
   }
-  // for use outside
-  _utils = utils;
   /** On cancel callback */
   _onCancel = async () => {
   };
@@ -843,12 +26,13 @@ let Core$1 = class Core {
     string: "string",
     number: "number",
     boolean: "boolean",
-    array: "array"
+    array: "array",
+    choices: "choices"
   };
   _text = {
     initialValueSuccess: (t, v) => `${t}
-${this._utils.style.color.dim(this._utils.style.color.gray(v))}`,
-    initialValueError: (v) => `Initial value ${this._utils.style.color.yellow(v || "")} is not valid`
+${this._utils.color.dim(this._utils.color.gray(v))}`,
+    initialValueError: (v) => `Initial value ${this._utils.color.yellow(v || "")} is not valid`
   };
   async getPromptHooked() {
     if (!("prompt" in this && typeof this.prompt === "function")) return;
@@ -862,171 +46,13 @@ ${this._utils.style.color.dim(this._utils.style.color.gray(v))}`,
       return res;
     } catch (error) {
       if (error instanceof Error)
-        this._utils.prompt.log.error("Unexpected error:" + error?.message);
+        this._utils.prompt.log.error("Unexpected error: " + error?.message);
       return await this.prompt();
     }
   }
-};
-
-class Select extends Core$1 {
-  async cmd() {
-    return {
-      desc: this.config.desc,
-      type: this._type.string,
-      alias: this.config.alias,
-      choices: Object.keys(this.config.options)
-    };
-  }
-  async validateInitialValue(data) {
-    const message = this.config.promptMsg || this.config.desc;
-    if (typeof this.initialValue === "number" || typeof this.initialValue === "string") {
-      if (data?.showSuccess !== false)
-        this._utils.prompt.log.success(this._text.initialValueSuccess(message, this.initialValue.toString()));
-      return this.initialValue;
-    }
-    if (data?.showError !== false)
-      this._utils.prompt.log.warn(this._text.initialValueError(this.initialValue));
-    return void 0;
-  }
-  async prompt() {
-    const value = await this._utils.prompt.select({
-      message: this.config.promptMsg || this.config.desc,
-      options: Object.entries(this.config.options).map(([key, value2]) => ({
-        value: key,
-        label: value2?.name || key,
-        hint: value2?.desc
-      })),
-      initialValue: this.config.placeholderValue?.toString()
-    });
-    if (this._utils.prompt.isCancel(value)) {
-      await this._onCancel();
-      throw "";
-    }
-    return value;
-  }
-}
-
-const TEXT_EDITOR = {
-  ...SELECT_BASE_OPTS,
-  VSCODE: "code",
-  SUBLIME: "subl",
-  WEBSTORM: "webstorm"
-};
-class Editor extends Select {
-  constructor(config) {
-    const defaultOptions = {
-      [TEXT_EDITOR.SUBLIME]: { name: "Sublime Text" },
-      [TEXT_EDITOR.VSCODE]: { name: "Visual Studio Code" },
-      [TEXT_EDITOR.WEBSTORM]: { name: "WebStorm" },
-      [TEXT_EDITOR.NONE]: {
-        name: "None",
-        desc: "Do not open the project with any text editor"
-      }
-    };
-    if (!config.desc) config.desc = "Select the text editor to open the project";
-    const finalConfig = mergeSelectBaseOptions(config, defaultOptions);
-    super(finalConfig);
-    this.config = finalConfig;
-  }
-  async validateInitialValue(data) {
-    const validateValue = await super.validateInitialValue({ showSuccess: false });
-    if (!validateValue) return void 0;
-    if (validateValue && await existsLocalBin(validateValue)) {
-      if (data?.showSuccess !== false)
-        this._utils.prompt.log.success(this._text.initialValueSuccess(this.config.promptMsg || this.config.desc, validateValue));
-      return validateValue;
-    }
-    if (data?.showError !== false)
-      this._utils.prompt.log.warn(this._text.initialValueError(this.initialValue));
-    return void 0;
-  }
-  async prompt() {
-    let value = await super.prompt();
-    if (value === TEXT_EDITOR.NONE) return value;
-    const exists = await existsLocalBin(value);
-    if (!exists) {
-      this.config.options = Object.fromEntries(
-        Object.entries(this.config.options).filter(([key]) => key !== value)
-      );
-      const badge = (txt) => this._utils.style.color.red(this._utils.style.color.inverse(" " + txt + " "));
-      this._utils.prompt.log.error(`Binary ${badge(value)} not found in system`);
-      value = await this.prompt();
-    }
-    return value;
-  }
-}
-
-const INSTALLER = {
-  DENO: "deno",
-  BUN: "bun",
-  NPM: "npm",
-  PNPM: "pnpm",
-  YARN: "yarn",
-  ...SELECT_BASE_OPTS
-};
-class Install extends Select {
-  constructor(config) {
-    const defaultOptions = {
-      [INSTALLER.NPM]: { name: "npm" },
-      [INSTALLER.PNPM]: { name: "pnpm" },
-      [INSTALLER.YARN]: { name: "yarn" },
-      [INSTALLER.DENO]: { name: "deno" },
-      [INSTALLER.NONE]: {
-        name: "None",
-        desc: "Do not install project dependencies"
-      }
-    };
-    if (!config.desc) config.desc = "Select the package manager to install the dependencies.";
-    const finalConfig = mergeSelectBaseOptions(config, defaultOptions);
-    super(finalConfig);
-    this.config = finalConfig;
-  }
-  async validateInitialValue(data) {
-    const validateValue = await super.validateInitialValue({ showSuccess: false });
-    if (!validateValue) return void 0;
-    if (validateValue && await existsLocalBin(validateValue)) {
-      if (data?.showSuccess !== false)
-        this._utils.prompt.log.success(this._text.initialValueSuccess(this.config.promptMsg || this.config.desc, validateValue));
-      return validateValue;
-    }
-    if (data?.showError !== false)
-      this._utils.prompt.log.warn(this._text.initialValueError(this.initialValue));
-    return void 0;
-  }
-  async prompt() {
-    let value = await super.prompt();
-    if (value === INSTALLER.NONE) return value;
-    const exists = await existsLocalBin(value);
-    if (!exists) {
-      this.config.options = Object.fromEntries(
-        Object.entries(this.config.options).filter(([key]) => key !== value)
-      );
-      const badge = (txt) => this._utils.style.color.red(this._utils.style.color.inverse(" " + txt + " "));
-      this._utils.prompt.log.error(`Binary ${badge(value)} not found in system`);
-      value = await this.prompt();
-    }
-    return value;
-  }
 }
 
-const OPTION = {
-  array: "array",
-  select: "select",
-  multiselect: "multiselect",
-  boolean: "boolean",
-  number: "number",
-  text: "text",
-  void: "void",
-  // customs
-  output: "output",
-  name: "name",
-  template: "template",
-  install: "install",
-  openEditor: "openEditor",
-  path: "path"
-};
-
-let Array$1 = class Array extends Core$1 {
+let Array$1 = class Array extends Core {
   #defaultSeparator = ",";
   async cmd() {
     return {
@@ -1072,7 +98,7 @@ let Array$1 = class Array extends Core$1 {
   }
 };
 
-let Boolean$1 = class Boolean extends Core$1 {
+class Boolean extends Core {
   async cmd() {
     return {
       desc: this.config.desc,
@@ -1103,13 +129,13 @@ let Boolean$1 = class Boolean extends Core$1 {
     }
     return value;
   }
-};
+}
 
-class Multiselect extends Core$1 {
+class Multiselect extends Core {
   async cmd() {
     return {
       desc: this.config.desc,
-      type: this._type.array,
+      type: this._type.choices,
       alias: this.config.alias,
       choices: Object.keys(this.config.options)
     };
@@ -1145,7 +171,7 @@ class Multiselect extends Core$1 {
   }
 }
 
-let Number$1 = class Number extends Core$1 {
+class Number extends Core {
   async cmd() {
     return {
       desc: this.config.desc,
@@ -1186,9 +212,50 @@ let Number$1 = class Number extends Core$1 {
     }
     return value;
   }
-};
+}
 
-class Text extends Core$1 {
+class Select extends Core {
+  async cmd() {
+    return {
+      desc: this.config.desc,
+      type: this._type.choices,
+      alias: this.config.alias,
+      choices: Object.keys(this.config.options)
+    };
+  }
+  async validateInitialValue(data) {
+    const message = this.config.promptMsg || this.config.desc;
+    if (typeof this.initialValue === "number" || typeof this.initialValue === "string") {
+      if (data?.showSuccess !== false)
+        this._utils.prompt.log.success(this._text.initialValueSuccess(message, this.initialValue.toString()));
+      return this.initialValue;
+    }
+    if (data?.showError !== false)
+      this._utils.prompt.log.warn(this._text.initialValueError(this.initialValue));
+    return void 0;
+  }
+  async prompt() {
+    const value = await this._utils.prompt.select({
+      message: this.config.promptMsg || this.config.desc,
+      options: Object.entries(this.config.options).map(([key, v]) => ({
+        value: key,
+        label: v?.name || key,
+        hint: v?.desc
+      })),
+      initialValue: this.config.placeholderValue?.toString()
+    });
+    console.debug({ selectData: {
+      value
+    } });
+    if (this._utils.prompt.isCancel(value)) {
+      await this._onCancel();
+      throw "";
+    }
+    return value;
+  }
+}
+
+class Text extends Core {
   async cmd() {
     return {
       desc: this.config.desc,
@@ -1225,7 +292,7 @@ class Text extends Core$1 {
   }
 }
 
-class Void extends Core$1 {
+class Void extends Core {
   async cmd() {
     return void 0;
   }
@@ -1238,13 +305,136 @@ class Void extends Core$1 {
   }
 }
 
+const name = "creatium";
+
+const SELECT_BASE_OPTS = { NONE: "none" };
+const mergeSelectBaseOptions = (config, defaultOptions) => {
+  const options = Wn(defaultOptions || {}, config.options || {});
+  const filteredOptions = config.onlyOptions && config.onlyOptions.length > 1 ? Object.entries(options).reduce((acc, [key, value]) => {
+    if (key === SELECT_BASE_OPTS.NONE || config.onlyOptions.includes(key))
+      acc[key] = value;
+    return acc;
+  }, {}) : options;
+  return {
+    ...config,
+    options: Object.keys(filteredOptions).length > 1 ? filteredOptions : options
+  };
+};
+
+const TEXT_EDITOR = {
+  ...SELECT_BASE_OPTS,
+  VSCODE: "code",
+  SUBLIME: "subl",
+  WEBSTORM: "webstorm"
+};
+class Editor extends Select {
+  constructor(config, _utils) {
+    const defaultOptions = {
+      [TEXT_EDITOR.SUBLIME]: { name: "Sublime Text" },
+      [TEXT_EDITOR.VSCODE]: { name: "Visual Studio Code" },
+      [TEXT_EDITOR.WEBSTORM]: { name: "WebStorm" },
+      [TEXT_EDITOR.NONE]: {
+        name: "None",
+        desc: "Do not open the project with any text editor"
+      }
+    };
+    if (!config.desc) config.desc = "Select the text editor to open the project";
+    const finalConfig = mergeSelectBaseOptions(config, defaultOptions);
+    super(finalConfig, _utils);
+    this._utils = _utils;
+    this.config = finalConfig;
+  }
+  async validateInitialValue(data) {
+    const validateValue = await super.validateInitialValue({ showSuccess: false });
+    if (!validateValue) return void 0;
+    if (validateValue && await qn(validateValue)) {
+      if (data?.showSuccess !== false)
+        this._utils.prompt.log.success(this._text.initialValueSuccess(this.config.promptMsg || this.config.desc, validateValue));
+      return validateValue;
+    }
+    if (data?.showError !== false)
+      this._utils.prompt.log.warn(this._text.initialValueError(this.initialValue));
+    return void 0;
+  }
+  async prompt() {
+    let value = await super.prompt();
+    if (value === TEXT_EDITOR.NONE) return value;
+    const exists = await qn(value);
+    if (!exists) {
+      this.config.options = Object.fromEntries(
+        Object.entries(this.config.options).filter(([key]) => key !== value)
+      );
+      const badge = (txt) => this._utils.color.red(this._utils.color.inverse(" " + txt + " "));
+      this._utils.prompt.log.error(`Binary ${badge(value)} not found in system`);
+      value = await this.prompt();
+    }
+    return value;
+  }
+}
+
+const INSTALLER = {
+  DENO: "deno",
+  BUN: "bun",
+  NPM: "npm",
+  PNPM: "pnpm",
+  YARN: "yarn",
+  ...SELECT_BASE_OPTS
+};
+class Install extends Select {
+  constructor(config, _utils) {
+    const defaultOptions = {
+      [INSTALLER.NPM]: { name: "npm" },
+      [INSTALLER.PNPM]: { name: "pnpm" },
+      [INSTALLER.YARN]: { name: "yarn" },
+      [INSTALLER.DENO]: { name: "deno" },
+      [INSTALLER.NONE]: {
+        name: "None",
+        desc: "Do not install project dependencies"
+      }
+    };
+    if (!config.desc) config.desc = "Select the package manager to install the dependencies.";
+    const finalConfig = mergeSelectBaseOptions(config, defaultOptions);
+    super(finalConfig, _utils);
+    this._utils = _utils;
+    this.config = finalConfig;
+  }
+  async validateInitialValue(data) {
+    const validateValue = await super.validateInitialValue({ showSuccess: false });
+    if (!validateValue) return void 0;
+    const exists = await qn(validateValue);
+    if (validateValue && exists) {
+      if (data?.showSuccess !== false)
+        this._utils.prompt.log.success(this._text.initialValueSuccess(this.config.promptMsg || this.config.desc, validateValue));
+      return validateValue;
+    }
+    if (data?.showError !== false)
+      this._utils.prompt.log.warn(this._text.initialValueError(this.initialValue));
+    return void 0;
+  }
+  async prompt() {
+    let value = await super.prompt();
+    if (value === INSTALLER.NONE) return value;
+    const exists = await qn(value);
+    if (!exists) {
+      this.config.options = Object.fromEntries(
+        Object.entries(this.config.options).filter(([key]) => key !== value)
+      );
+      const badge = (txt) => this._utils.color.red(this._utils.color.inverse(" " + txt + " "));
+      this._utils.prompt.log.error(`Binary ${badge(value)} not found in system`);
+      value = await this.prompt();
+    }
+    return value;
+  }
+}
+
 class Name extends Text {
-  constructor(config) {
+  constructor(config, _utils) {
     const finalConfig = {
       desc: config.desc ?? "Set the name of the project",
       ...config
     };
-    super(finalConfig);
+    super(finalConfig, _utils);
+    this._utils = _utils;
     this.config = finalConfig;
   }
   async validateInitialValue(data) {
@@ -1284,24 +474,25 @@ const PATH_TYPE = {
   file: "file"
 };
 class Path extends Text {
-  #existsPath;
-  #pathType;
-  constructor(config) {
+  constructor(config, _utils) {
     if (!config.pathType) config.pathType = PATH_TYPE.file;
     if (!config.exists) config.exists = false;
     const finalConfig = {
       desc: config.desc ?? `Set input ${config.exists ? "existing" : "new"} ${config.pathType}`,
       ...config
     };
-    super(finalConfig);
+    super(finalConfig, _utils);
+    this._utils = _utils;
     this.config = finalConfig;
     this.#existsPath = config.exists;
     this.#pathType = config.pathType;
   }
+  #existsPath;
+  #pathType;
   async #validatePath(path) {
     const mustExists = this.#existsPath;
     const type = this.#pathType;
-    const existsPath = type === PATH_TYPE.file ? await existsFile(path) : await existsDir(path);
+    const existsPath = type === PATH_TYPE.file ? await Un(path) : await zn(path);
     const validation = mustExists === existsPath;
     console.debug({ pathValueData: {
       validatePath: path,
@@ -1347,7 +538,7 @@ class Path extends Text {
 }
 
 class Output extends Path {
-  constructor(config) {
+  constructor(config, _utils) {
     const finalConfig = {
       desc: config.desc ?? "Set the path where you want to create your project",
       promptMsg: config.promptMsg ?? "Where do you want to create your project?",
@@ -1357,13 +548,14 @@ class Output extends Path {
       ...finalConfig,
       pathType: PATH_TYPE.folder,
       exists: false
-    });
+    }, _utils);
+    this._utils = _utils;
     this.config = finalConfig;
   }
 }
 
 class Template extends Select {
-  constructor(config) {
+  constructor(config, _utils) {
     const {
       options: _options,
       ...rest
@@ -1383,21 +575,19 @@ class Template extends Select {
       ...rest
       // Propiedades opcionales adicionales
     };
-    super(finalConfig);
+    super(finalConfig, _utils);
+    this._utils = _utils;
     this.config = finalConfig;
   }
 }
 
-const name = "creatium";
-
-class Core {
-  constructor(config) {
+class Options {
+  constructor(config, utils) {
     this.config = config;
-    this.utils = coreUtils;
+    this.utils = utils;
     this.onCancel = async () => {
     };
   }
-  utils;
   onCancel;
   /** Enable cache */
   cache = false;
@@ -1409,15 +599,15 @@ class Core {
   /** Debug mode */
   set debugMode(value) {
     if (value === true) {
-      const dim = (txt) => this.utils.style.color.gray(this.utils.style.color.dim(txt));
+      const dim = (txt) => this.utils.color.gray(this.utils.color.dim(txt));
       console.debug = (...args) => {
         console.log();
-        const TITLE = dim(this.utils.style.line({
+        const TITLE = dim(this.utils.line({
           title: "DEBUG",
           lineChar: " ",
           align: "left"
         }));
-        const LINE = dim(this.utils.style.line({ title: "" }));
+        const LINE = dim(this.utils.line({ title: "" }));
         console.log(TITLE);
         console.log(LINE);
         console.log(...args);
@@ -1435,7 +625,7 @@ class Core {
       }, {});
     };
     if (!this.cache) return;
-    return await cache({
+    return await Sn({
       projectName: this.projectName,
       id: "create-prompts",
       values: resetObjectValues(this.config)
@@ -1444,8 +634,8 @@ class Core {
   #getClass() {
     return {
       array: Array$1,
-      number: Number$1,
-      boolean: Boolean$1,
+      number: Number,
+      boolean: Boolean,
       multiselect: Multiselect,
       select: Select,
       text: Text,
@@ -1506,21 +696,42 @@ class Core {
   }
 }
 
+const OPTION = {
+  array: "array",
+  select: "select",
+  multiselect: "multiselect",
+  boolean: "boolean",
+  number: "number",
+  text: "text",
+  void: "void",
+  // customs
+  output: "output",
+  name: "name",
+  template: "template",
+  install: "install",
+  openEditor: "openEditor",
+  path: "path"
+};
+
 class CreatiumCore {
   #core;
   #data;
   utils;
   config;
   #style;
-  #cwd = process$1.cwd();
+  #cwd = Pn.cwd();
   constructor(config) {
-    this.#core = new Core(config.prompt);
+    this.#core = new Options(config.prompt, {
+      color: Tn,
+      line: xi,
+      prompt: Si
+    });
     this.config = config;
     this.utils = this.#core.utils;
     this.#core.cache = this.config.cache === void 0 ? true : this.config.cache;
     this.#core.projectName = this.config.name;
     this.debugMode = false;
-    this.#style = { tick: this.utils.style.color.green(this.utils.style.color.dim("\u2713")) };
+    this.#style = { tick: this.utils.color.green(this.utils.color.dim("\u2713")) };
   }
   #_spinnerFN;
   /** Force debug mode */
@@ -1540,52 +751,80 @@ class CreatiumCore {
     }
   }
   async #exec(values) {
-    this.#data = { values };
-    console.debug({ initData: this.#data });
-    this.#core.onCancel = async () => await this.cancel();
-    if (this.config.hooks?.beforePrompt)
-      await this.config.hooks.beforePrompt(this.#data);
-    console.debug({ beforePromptData: this.#data });
-    await this.intro();
-    const prompts = await this.#core.getPrompts(this.#data.values);
-    const answers = await this.utils.prompt.group(prompts, { onCancel: this.#core.onCancel });
-    this.#data.values = answers;
-    console.debug({ promptData: this.#data });
-    if (this.config.hooks?.afterPrompt)
-      await this.config.hooks.afterPrompt(this.#data);
-    console.debug({ afterPromptData: this.#data });
-    return answers;
+    try {
+      this.#data = { values };
+      console.debug({ initData: this.#data });
+      this.#core.onCancel = async () => await this.cancel();
+      await this.config.hooks?.beforePrompt?.(this.#data);
+      console.debug({ beforePromptData: this.#data });
+      await this.intro();
+      const prompts = await this.#core.getPrompts(this.#data.values);
+      const answers = await this.utils.prompt.group(prompts, { onCancel: this.#core.onCancel });
+      this.#data.values = answers;
+      console.debug({ promptData: this.#data });
+      await this.config.hooks?.afterPrompt?.(this.#data);
+      console.debug({ afterPromptData: this.#data });
+      return answers;
+    } catch (err) {
+      if (err instanceof Error) throw new Error(Hi(err.message, 200, "..."));
+      throw new Error("Unexpected error in execution");
+    }
   }
   #getCliArgs(props) {
-    return props?.args && props.hideBin ? hideBin(props.args) ? props.args : props?.args : hideBin(process$1.argv);
+    return props?.args && props.hideBin ? hiddenBin(props.args) ? props.args : props?.args : hiddenBin(Pn.argv);
   }
   async #initCli(props) {
     if (this.config.updater) await this.updateNotify();
     const args = this.#getCliArgs(props);
-    const instance = await createCli({
-      args,
-      fn: async (cli) => {
-        cli.scriptName(this.config.name).version(this.config.version).usage("Usage: $0 [options]").locale("en").help(false).showHelpOnFail(false).alias("h", "help").alias("v", "version");
-        if (this.config.prompt) {
-          const props2 = await this.#core.getCmds();
-          cli.options(props2);
+    const cli = new Clippium({
+      name: this.config.name.replaceAll(" ", "-").toLowerCase(),
+      version: this.config.version,
+      flags: {
+        ...this.config.prompt ? await this.#core.getCmds() : {},
+        help: {
+          type: "boolean",
+          alias: ["h"],
+          group: "Global flags:",
+          desc: "Show help"
+        },
+        version: {
+          type: "boolean",
+          alias: ["v"],
+          group: "Global flags:",
+          desc: "Show version"
+        },
+        debug: {
+          type: "boolean",
+          group: "Global flags:",
+          desc: "Debug mode"
         }
-        cli.option("debug", {
-          desc: "Set Debug mode",
-          type: "boolean"
-        });
-        return cli;
       }
-    });
-    const argv = await instance.argv;
-    if (!argv.debug) this.debugMode = false;
+    }, { help: { formatter: formatter({
+      title: (v) => Tn.cyan(Tn.inverse(Tn.bold(v))),
+      bin: Tn.cyan,
+      version: (v) => Tn.cyan(Tn.dim(Tn.italic(v))),
+      name: Tn.bold,
+      positionals: (v) => Tn.green(Tn.dim(v)),
+      commands: Tn.green,
+      flags: Tn.yellow,
+      desc: (v) => Tn.white(Tn.dim(v)),
+      examples: Tn.cyan,
+      sectionTitle: (v) => Tn.white(Tn.bold(Tn.underline(v))),
+      //color.white.bold.underline,
+      sectionDesc: (v) => Tn.white(Tn.dim(v)),
+      sectionsProps: (v) => Tn.white(Tn.dim(Tn.italic(v)))
+    }) } });
+    const { flags } = await cli.parse(args);
+    if (flags.help) {
+      console.log(cli.getHelp(args));
+      Pn.exit(0);
+    } else if (flags.version) {
+      console.log(cli.getVersion());
+      Pn.exit(0);
+    }
+    if (!flags.debug) this.debugMode = false;
     else this.debugMode = true;
-    const {
-      _,
-      $0,
-      ...values
-    } = argv;
-    return values;
+    return flags;
   }
   /**
    * Shows a notification if the current package is outdated.
@@ -1616,13 +855,13 @@ class CreatiumCore {
     if (message) {
       this.utils.prompt.log.step("");
       this.utils.prompt.cancel(message);
-      process$1.exit(0);
+      Pn.exit(0);
     } else if (this.config.onCancel && this.#data)
       await this.config.onCancel(this.#data);
     else if (this.config.onCancel === void 0) {
       this.utils.prompt.log.step("");
       this.utils.prompt.cancel("Canceled \u{1F494}");
-      process$1.exit(0);
+      Pn.exit(0);
     }
   }
   /**
@@ -1641,7 +880,7 @@ class CreatiumCore {
       await this.config.intro(this.#data || {});
     else if (this.config.intro === void 0) {
       console.log();
-      const badge = (txt) => this.utils.style.color.blue(this.utils.style.color.inverse(" " + this.utils.style.color.bold(txt) + " "));
+      const badge = (txt) => this.utils.color.blue(this.utils.color.inverse(" " + this.utils.color.bold(txt) + " "));
       this.utils.prompt.intro(badge(this.config.name));
       this.utils.prompt.log.step("");
     }
@@ -1662,26 +901,37 @@ class CreatiumCore {
     else if (typeof this.config.outro === "function" && this.#data)
       await this.config.outro(this.#data);
     else if (this.config.outro === void 0) {
-      this.utils.prompt.outro(this.utils.style.color.greenBright("Successfully completed \u{1F308}"));
+      this.utils.prompt.outro(this.utils.color.greenBright("Successfully completed \u{1F308}"));
     }
   }
   /**
    * Copy a directory from input path to output path.
    *
-   * @param   {object}        data        - Options object with input and output paths.
-   * @param   {string}        data.input  - The path to the directory to copy.
-   * @param   {string}        data.output - The path to the destination directory.
-   * @returns {Promise<void>}             - Resolves when the directory has been copied.
+   * @param   {object}        data - Options object with input and output paths.
+   * @returns {Promise<void>}      - Resolves when the directory has been copied.
    * @example
    *
    * const copyResult = await core.copyDir({
    *   input : '/path/to/sourceDir',
    *   output: '/path/to/destinationDir',
    * })
+   * const copyResult = await copyDir({
+   * input : [
+   *   {
+   *     name: 'file1.txt',
+   *     content: 'Hello, world!',
+   *   },
+   *   {
+   *     name: 'file2.txt',
+   *     content: 'Goodbye, world!',
+   *   },
+   * ],
+   * output: '/path/to/destinationDir',
+   * })
    */
   async copyDir(data) {
     console.debug({ copyDirData: data });
-    return await copyDir(data);
+    return await On(data);
   }
   /**
    * Installs the project with the given package manager.
@@ -1715,7 +965,7 @@ class CreatiumCore {
     };
     try {
       s.start(`Installing with ${installer}`);
-      await execChild(command[installer]);
+      await Vn(command[installer]);
       s.stop(`${this.#style.tick} Package installed with [${installer}] successfully`);
     } catch (_e) {
       if (this.debugMode)
@@ -1750,7 +1000,7 @@ class CreatiumCore {
     const s = this.utils.prompt.spinner();
     try {
       s.start(`Opening in ${editor}`);
-      await execChild(`${editor} ${input}`);
+      await Vn(`${editor} ${input}`);
       s.stop(`${this.#style.tick} Text editor [${editor}] opened successfully`);
     } catch (_e) {
       if (this.debugMode)
@@ -1789,13 +1039,13 @@ class CreatiumCore {
     if (!params) return;
     const getContent = async (filePath) => {
       try {
-        const content = await readFile(filePath, "utf-8");
+        const content = await Ti(filePath, "utf-8");
         return typeof content === "string" && content.trim().length > 0 ? content : void 0;
       } catch (_e) {
         return void 0;
       }
     };
-    const paths = await getPaths("**", {
+    const paths = await ai("**", {
       filesOnly: true,
       cwd: input,
       absolute: true,
@@ -1809,11 +1059,11 @@ class CreatiumCore {
     await Promise.all(paths.map(async (path) => {
       const content = await getContent(path);
       if (!content) return;
-      const res = await replacePlaceholders({
+      const res = await Wi({
         content,
         params
       });
-      await writeFile(path, res, "utf-8");
+      await Vi(path, res, "utf-8");
     }));
   }
   /**
@@ -1840,7 +1090,7 @@ class CreatiumCore {
       templates
     } });
     if (input && templates[input].input) return templates[input].input;
-    if (input && await existsDir(input)) return input;
+    if (input && await zn(input)) return input;
     this.utils.prompt.log.error(`Error creating Template: template input "${input}" not found`);
     return;
   }
@@ -1873,11 +1123,11 @@ class CreatiumCore {
         output,
         install,
         consts,
-        ...prompt
+        ...prompt2
       } = values;
       const data = {
         input: await this.getTemplateInput({ input }),
-        output: output ? resolvePath(output) : void 0
+        output: output ? Li(output) : void 0
       };
       console.debug({ createTemplate: {
         values,
@@ -1896,7 +1146,7 @@ class CreatiumCore {
           name: this.config.name,
           version: this.config.version,
           consts,
-          prompt
+          prompt: prompt2
         }
       });
       await this.install({
@@ -1911,7 +1161,7 @@ class CreatiumCore {
     } catch (e) {
       const error = e instanceof Error ? e.message : e?.toString();
       this.utils.prompt.log.error(`Unexpected error creating template:
-${error}
+${Hi(error || "", 100, "...")}
 
 `);
       await this.#core.onCancel();
@@ -1926,7 +1176,7 @@ ${error}
    */
   async build(values, opts) {
     const cliValues = opts?.activeCli !== false ? await this.#initCli(opts) : {};
-    const config = values ? deepmergeCustom({})(values, cliValues) : cliValues;
+    const config = values ? Ln({})(values, cliValues) : cliValues;
     return await this.#exec(config);
   }
   /**
@@ -2024,4 +1274,4 @@ class Creatium {
   }
 }
 
-export { Creatium, CreatiumCore, INSTALLER, OPTION, TEXT_EDITOR, env, prompt, style, sys };
+export { Creatium, CreatiumCore, INSTALLER, OPTION, TEXT_EDITOR };