@reliverse/relico 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright (c) 2024 Nazarii Korniienko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,121 @@
+# @reliverse/relico
+
+[**Docs**](.github/DOCS.md) | [**NPM**](https://npmjs.com/package/@reliverse/relico) | [**GitHub**](https://github.com/reliverse/relico)
+
+<p align="left">
+  <a href="https://npmjs.org/package/@reliverse/relico">
+    <img src="https://img.shields.io/npm/v/@reliverse/relico.svg" alt="version" />
+  </a>
+  <a href="https://npmjs.org/package/@reliverse/relico">
+    <img src="https://img.shields.io/npm/dm/@reliverse/relico.svg" alt="downloads" />
+  </a>
+</p>
+
+**@reliverse/relico is a modern terminal color formatting library** that provides a type-safe and flexible way to add colors and styles to your command-line output. Built with TypeScript and TypeBox for enhanced reliability and developer experience.
+
+## Installation
+
+```sh
+bun add @reliverse/relico # Replace "bun" with npm, pnpm, or yarn if desired
+```
+
+## Key Features
+
+- **Smart Terminal Detection**: Automatically detects terminal type and color support level
+- **Type Safety**: Built with TypeScript and TypeBox for reliable type checking
+- **Multiple Color Levels**: Supports different color levels (none, basic, 256-color, truecolor)
+- **Flexible API**: Multiple ways to apply colors (object syntax, functions, RGB)
+- **Windows Support**: Special color handling for Windows Terminal
+- **Environment Aware**: Respects NO_COLOR and FORCE_COLOR environment variables
+
+## Usage Examples
+
+```typescript
+import { re, colorize, rgb } from "@reliverse/relico";
+
+// Using the "re" object for basic colors
+console.log(re.red("This is red text"));
+console.log(re.blue("This is blue text"));
+
+// Combining styles
+console.log(re.bold(re.green("Bold green text")));
+
+// Using the colorize function
+console.log(colorize("magenta", "This is magenta text"));
+
+// Using RGB colors (requires truecolor support)
+const salmon = rgb(250, 128, 114);
+console.log(salmon("This is salmon colored text"));
+```
+
+## Color Support
+
+The library automatically detects the terminal's color support level:
+
+- Level 0: No color support
+- Level 1: Basic color support
+- Level 2: 256 color support
+- Level 3: Truecolor (16 million colors) support
+
+You can check color support information:
+
+```typescript
+import { colorSupport } from "@reliverse/relico";
+
+console.log("Terminal:", colorSupport.terminalName);
+console.log("Colors Supported:", colorSupport.isColorSupported);
+console.log("Colors Forced:", colorSupport.isForced);
+console.log("Colors Disabled:", colorSupport.isDisabled);
+```
+
+## Available Styles
+
+- **Basic Colors**: `red`, `green`, `blue`, `yellow`, `magenta`, `cyan`, `white`, `black`, `gray`
+- **Bright Colors**: `redBright`, `greenBright`, `blueBright`, etc.
+- **Background Colors**: `bgRed`, `bgGreen`, `bgBlue`, etc.
+- **Text Styles**: `bold`, `dim`, `italic`, `underline`, `inverse`, `hidden`, `strikethrough`
+
+## Configuration
+
+You can customize the library's behavior:
+
+```typescript
+import { configure } from "@reliverse/relico";
+
+configure({
+  colorLevel: 3, // Force truecolor support
+  customColors: {
+    // Add custom color definitions
+    success: ["\x1b[38;2;0;255;0m", "\x1b[0m"]
+  }
+});
+```
+
+## Example Project
+
+Check out [examples/example.ts](./examples/example.ts) for a comprehensive demonstration of all features, including:
+
+- Basic color usage
+- Text styling
+- Background colors
+- RGB colors
+- Color level switching
+- Terminal detection
+
+## Contributing
+
+@reliverse/relico is open to contributions. To get started:
+
+```sh
+git clone https://github.com/reliverse/relico.git
+cd relico
+bun i
+```
+
+## Learn More
+
+- [ANSI Color Codes](https://gist.github.com/fnky/458719343aabd01cfb17a3a4f7296797)
+
+## License
+
+[MIT](./LICENSE.md) © [Nazarii Korniienko](https://github.com/blefnk)

package/dist-npm/main.d.ts

@@ -0,0 +1,80 @@
+import type { Static } from "@sinclair/typebox";
+export declare function getCurrentTerminalName(): string;
+export declare const ColorDefinitionSchema: import("@sinclair/typebox").TTuple<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TString, import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>]>;
+export declare const ColorMapSchema: import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TTuple<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TString, import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>]>>;
+export declare const RelicoConfigSchema: import("@sinclair/typebox").TObject<{
+    colorLevel: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<0>, import("@sinclair/typebox").TLiteral<1>, import("@sinclair/typebox").TLiteral<2>, import("@sinclair/typebox").TLiteral<3>]>>;
+    customColors: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TTuple<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TString, import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>]>>>;
+}>;
+export type RelicoConfig = Static<typeof RelicoConfigSchema>;
+/**
+ * Configures the library with a partial or complete `RelicoConfig`.
+ * For any invalid fields, a warning is shown and they are ignored.
+ */
+export declare function configure(userInput: unknown): void;
+/** Returns a read-only copy of the current configuration. */
+export declare function getConfig(): RelicoConfig;
+/** Returns a color function by name (or `reset` or identity if not found). */
+export declare function getColor(name: string): (text: string | number) => string;
+/** Colorize text with a color function. */
+export declare function colorize(name: string, text: string | number): string;
+/** Set the color level (0=none,1=basic,2=256,3=truecolor). */
+export declare function setColorLevel(level: 0 | 1 | 2 | 3): void;
+/** Returns a custom "rgb" color function if level=3, otherwise identity. */
+export declare function rgb(r: number, g: number, b: number): (text: string | number) => string;
+export type IRelicoColors = {
+    reset(text: string | number): string;
+    bold(text: string | number): string;
+    dim(text: string | number): string;
+    italic(text: string | number): string;
+    underline(text: string | number): string;
+    inverse(text: string | number): string;
+    hidden(text: string | number): string;
+    strikethrough(text: string | number): string;
+    black(text: string | number): string;
+    red(text: string | number): string;
+    green(text: string | number): string;
+    yellow(text: string | number): string;
+    blue(text: string | number): string;
+    magenta(text: string | number): string;
+    cyan(text: string | number): string;
+    white(text: string | number): string;
+    gray(text: string | number): string;
+    bgBlack(text: string | number): string;
+    bgRed(text: string | number): string;
+    bgGreen(text: string | number): string;
+    bgYellow(text: string | number): string;
+    bgBlue(text: string | number): string;
+    bgMagenta(text: string | number): string;
+    bgCyan(text: string | number): string;
+    bgWhite(text: string | number): string;
+    blackBright(text: string | number): string;
+    redBright(text: string | number): string;
+    greenBright(text: string | number): string;
+    yellowBright(text: string | number): string;
+    blueBright(text: string | number): string;
+    magentaBright(text: string | number): string;
+    cyanBright(text: string | number): string;
+    whiteBright(text: string | number): string;
+    bgBlackBright(text: string | number): string;
+    bgRedBright(text: string | number): string;
+    bgGreenBright(text: string | number): string;
+    bgYellowBright(text: string | number): string;
+    bgBlueBright(text: string | number): string;
+    bgMagentaBright(text: string | number): string;
+    bgCyanBright(text: string | number): string;
+    bgWhiteBright(text: string | number): string;
+    [k: string]: (text: string | number) => string;
+};
+/**
+ * The typed `re` object with all known color methods
+ * plus user-defined ones (index signature).
+ */
+export declare const re: IRelicoColors;
+export type ColorSupport = {
+    isColorSupported: boolean;
+    isForced: boolean;
+    isDisabled: boolean;
+    terminalName: string;
+};
+export declare const colorSupport: ColorSupport;

package/dist-npm/main.js

@@ -0,0 +1,329 @@
+import { Type } from "@sinclair/typebox";
+import { Value } from "@sinclair/typebox/value";
+import { env, isWindows, isLinux, isMacOS } from "std-env";
+export function getCurrentTerminalName() {
+  const termProgram = env["TERM_PROGRAM"];
+  const term = env["TERM"];
+  const terminalEmulator = env["TERMINAL_EMULATOR"];
+  if (termProgram) {
+    switch (termProgram.toLowerCase()) {
+      case "vscode":
+        return "VSCode Terminal";
+      case "terminus-sublime":
+        return "Terminus Sublime";
+      case "hyper":
+        return "Hyper";
+      case "iterm.app":
+      case "iterm":
+        return "iTerm2";
+      case "alacritty":
+        return "Alacritty";
+      case "wezterm":
+        return "WezTerm";
+      case "terminus":
+        return "Terminus";
+      default:
+        return `TERM_PROGRAM: ${termProgram}`;
+    }
+  }
+  if (terminalEmulator) {
+    switch (terminalEmulator.toLowerCase()) {
+      case "jetbrains-jediterm":
+        return "JetBrains JediTerm";
+      case "cmder":
+        return "Cmder";
+      case "conemu":
+        return "ConEmu";
+      default:
+        return `TERMINAL_EMULATOR: ${terminalEmulator}`;
+    }
+  }
+  if (term) {
+    const lowered = term.toLowerCase();
+    switch (lowered) {
+      case "xterm-256color":
+        return "Xterm 256 Color";
+      case "alacritty":
+        return "Alacritty";
+      case "xterm":
+        return "Xterm";
+      case "linux":
+        return "Linux Console Kernel";
+      default:
+        return `TERM: ${term}`;
+    }
+  }
+  if (isWindows) {
+    return "Windows Terminal";
+  } else if (isMacOS) {
+    return "macOS Terminal";
+  } else if (isLinux) {
+    return "Linux Terminal";
+  }
+  return "Unknown Terminal";
+}
+export const ColorDefinitionSchema = Type.Tuple([
+  Type.String(),
+  Type.String(),
+  Type.Optional(Type.String())
+]);
+export const ColorMapSchema = Type.Record(Type.String(), ColorDefinitionSchema);
+export const RelicoConfigSchema = Type.Object(
+  {
+    colorLevel: Type.Optional(
+      Type.Union([
+        Type.Literal(0),
+        Type.Literal(1),
+        Type.Literal(2),
+        Type.Literal(3)
+      ])
+    ),
+    customColors: Type.Optional(ColorMapSchema)
+  },
+  { additionalProperties: false }
+);
+const argv = typeof process === "undefined" ? [] : process.argv;
+const isDisabled = "NO_COLOR" in env || argv.includes("--no-color");
+const isForced = "FORCE_COLOR" in env || argv.includes("--color");
+const isCI = "CI" in env && ("GITHUB_ACTIONS" in env || "GITLAB_CI" in env || "CIRCLECI" in env);
+const isCompatibleTerminal = typeof process !== "undefined" && Boolean(process.stdout) && Boolean(process.stdout.isTTY) && env["TERM"] !== "dumb";
+const colorterm = (env["COLORTERM"] ?? "").toLowerCase();
+const supportsTrueColor = colorterm === "truecolor" || colorterm === "24bit";
+function detectColorLevel() {
+  if (isDisabled) return 0;
+  if (isForced) return 3;
+  if (supportsTrueColor) return 3;
+  if (isWindows) return 2;
+  if (isCI) return 2;
+  if (isCompatibleTerminal) {
+    return 2;
+  }
+  return 0;
+}
+const baseColors = {
+  reset: ["\x1B[0m", "\x1B[0m"],
+  bold: ["\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"],
+  dim: ["\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"],
+  italic: ["\x1B[3m", "\x1B[23m"],
+  underline: ["\x1B[4m", "\x1B[24m"],
+  inverse: ["\x1B[7m", "\x1B[27m"],
+  hidden: ["\x1B[8m", "\x1B[28m"],
+  strikethrough: ["\x1B[9m", "\x1B[29m"],
+  black: ["\x1B[30m", "\x1B[39m"],
+  red: ["\x1B[31m", "\x1B[39m"],
+  green: ["\x1B[32m", "\x1B[39m"],
+  yellow: ["\x1B[33m", "\x1B[39m"],
+  blue: ["\x1B[34m", "\x1B[39m"],
+  magenta: ["\x1B[35m", "\x1B[39m"],
+  cyan: ["\x1B[36m", "\x1B[39m"],
+  white: ["\x1B[37m", "\x1B[39m"],
+  gray: ["\x1B[90m", "\x1B[39m"],
+  bgBlack: ["\x1B[40m", "\x1B[49m"],
+  bgRed: ["\x1B[41m", "\x1B[49m"],
+  bgGreen: ["\x1B[42m", "\x1B[49m"],
+  bgYellow: ["\x1B[43m", "\x1B[49m"],
+  bgBlue: ["\x1B[44m", "\x1B[49m"],
+  bgMagenta: ["\x1B[45m", "\x1B[49m"],
+  bgCyan: ["\x1B[46m", "\x1B[49m"],
+  bgWhite: ["\x1B[47m", "\x1B[49m"],
+  blackBright: ["\x1B[90m", "\x1B[39m"],
+  redBright: ["\x1B[91m", "\x1B[39m"],
+  greenBright: ["\x1B[92m", "\x1B[39m"],
+  yellowBright: ["\x1B[93m", "\x1B[39m"],
+  blueBright: ["\x1B[94m", "\x1B[39m"],
+  magentaBright: ["\x1B[95m", "\x1B[39m"],
+  cyanBright: ["\x1B[96m", "\x1B[39m"],
+  whiteBright: ["\x1B[97m", "\x1B[39m"],
+  bgBlackBright: ["\x1B[100m", "\x1B[49m"],
+  bgRedBright: ["\x1B[101m", "\x1B[49m"],
+  bgGreenBright: ["\x1B[102m", "\x1B[49m"],
+  bgYellowBright: ["\x1B[103m", "\x1B[49m"],
+  bgBlueBright: ["\x1B[104m", "\x1B[49m"],
+  bgMagentaBright: ["\x1B[105m", "\x1B[49m"],
+  bgCyanBright: ["\x1B[106m", "\x1B[49m"],
+  bgWhiteBright: ["\x1B[107m", "\x1B[49m"]
+};
+const windowsTerminalColors = {
+  ...baseColors,
+  red: ["\x1B[38;2;255;85;85m", "\x1B[39m"],
+  green: ["\x1B[38;2;80;250;123m", "\x1B[39m"],
+  yellow: ["\x1B[38;2;241;250;140m", "\x1B[39m"],
+  blue: ["\x1B[38;2;98;114;164m", "\x1B[39m"],
+  magenta: ["\x1B[38;2;255;121;198m", "\x1B[39m"],
+  cyan: ["\x1B[38;2;139;233;253m", "\x1B[39m"]
+};
+let config = {
+  colorLevel: detectColorLevel()
+};
+let colorMap = {};
+let colorFunctions = {};
+function replaceClose(str, close, replace, index) {
+  let result = "";
+  let cursor = 0;
+  let i = index;
+  while (i !== -1) {
+    result += str.substring(cursor, i) + replace;
+    cursor = i + close.length;
+    i = str.indexOf(close, cursor);
+  }
+  return result + str.substring(cursor);
+}
+function createFormatter(open, close, replace = open) {
+  return (input) => {
+    const stringed = String(input);
+    const idx = stringed.indexOf(close, open.length);
+    if (idx !== -1) {
+      return open + replaceClose(stringed, close, replace, idx) + close;
+    }
+    return open + stringed + close;
+  };
+}
+function buildColorMap(cfg) {
+  const terminalName = getCurrentTerminalName();
+  const isWinTerm = terminalName === "Windows Terminal";
+  if (cfg.colorLevel === 0) {
+    const map = {};
+    for (const k of Object.keys(baseColors)) {
+      map[k] = ["", "", ""];
+    }
+    return map;
+  }
+  let builtIn;
+  if (isWinTerm && cfg.colorLevel === 3) {
+    builtIn = { ...windowsTerminalColors };
+  } else {
+    builtIn = { ...baseColors };
+  }
+  if (cfg.customColors) {
+    for (const [k, v] of Object.entries(cfg.customColors)) {
+      builtIn[k] = v;
+    }
+  }
+  return builtIn;
+}
+function initColorFunctions() {
+  colorFunctions = {};
+  if (config.colorLevel === 0) {
+    for (const k of Object.keys(baseColors)) {
+      colorFunctions[k] = identityColor;
+    }
+    return;
+  }
+  for (const [key, [open, close, replace]] of Object.entries(colorMap)) {
+    colorFunctions[key] = createFormatter(open, close, replace ?? open);
+  }
+}
+function rebuild() {
+  colorMap = buildColorMap(config);
+  initColorFunctions();
+}
+function identityColor(text) {
+  return String(text);
+}
+rebuild();
+export function configure(userInput) {
+  let newObj = null;
+  if (typeof userInput === "object" && userInput !== null) {
+    newObj = { ...config, ...userInput };
+  } else {
+    newObj = { ...config };
+  }
+  try {
+    const parsed = Value.Cast(RelicoConfigSchema, newObj);
+    config = parsed;
+  } catch (err) {
+    console.warn("Invalid relico config:", err);
+    return;
+  }
+  rebuild();
+}
+export function getConfig() {
+  return { ...config };
+}
+export function getColor(name) {
+  const maybeFn = colorFunctions[name];
+  if (maybeFn) return maybeFn;
+  const resetFn = colorFunctions["reset"];
+  if (resetFn) return resetFn;
+  return identityColor;
+}
+export function colorize(name, text) {
+  const fn = getColor(name);
+  return fn(text);
+}
+export function setColorLevel(level) {
+  configure({ colorLevel: level });
+}
+export function rgb(r, g, b) {
+  if (config.colorLevel === 3) {
+    const open = `\x1B[38;2;${String(r)};${String(g)};${String(b)}m`;
+    const close = "\x1B[39m";
+    return createFormatter(open, close);
+  }
+  return identityColor;
+}
+const typedRe = {
+  reset: identityColor,
+  bold: identityColor,
+  dim: identityColor,
+  italic: identityColor,
+  underline: identityColor,
+  inverse: identityColor,
+  hidden: identityColor,
+  strikethrough: identityColor,
+  black: identityColor,
+  red: identityColor,
+  green: identityColor,
+  yellow: identityColor,
+  blue: identityColor,
+  magenta: identityColor,
+  cyan: identityColor,
+  white: identityColor,
+  gray: identityColor,
+  bgBlack: identityColor,
+  bgRed: identityColor,
+  bgGreen: identityColor,
+  bgYellow: identityColor,
+  bgBlue: identityColor,
+  bgMagenta: identityColor,
+  bgCyan: identityColor,
+  bgWhite: identityColor,
+  blackBright: identityColor,
+  redBright: identityColor,
+  greenBright: identityColor,
+  yellowBright: identityColor,
+  blueBright: identityColor,
+  magentaBright: identityColor,
+  cyanBright: identityColor,
+  whiteBright: identityColor,
+  bgBlackBright: identityColor,
+  bgRedBright: identityColor,
+  bgGreenBright: identityColor,
+  bgYellowBright: identityColor,
+  bgBlueBright: identityColor,
+  bgMagentaBright: identityColor,
+  bgCyanBright: identityColor,
+  bgWhiteBright: identityColor
+};
+function refreshTypedRe() {
+  for (const colorName of Object.keys(typedRe)) {
+    typedRe[colorName] = identityColor;
+  }
+  for (const [k, fn] of Object.entries(colorFunctions)) {
+    typedRe[k] = fn;
+  }
+}
+const originalRebuild = rebuild;
+function newRebuild() {
+  originalRebuild();
+  refreshTypedRe();
+}
+rebuild = newRebuild;
+newRebuild();
+export const re = typedRe;
+export const colorSupport = {
+  isColorSupported: getConfig().colorLevel !== 0,
+  isForced,
+  isDisabled,
+  terminalName: getCurrentTerminalName()
+};

package/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "@reliverse/relico",
+  "version": "1.0.0",
+  "author": "blefnk",
+  "type": "module",
+  "description": "@reliverse/relico is doing its best to improve your terminal colorization experience by leveraging TypeScript and TypeBox for enhanced reliability and type safety.",
+  "scripts": {
+    "dev": "bun examples/example.ts",
+    "check": "bun typecheck && bun test && bun knip && bun lint && bun format",
+    "build:npm": "unbuild && bun build.optim.ts",
+    "build:jsr": "bun build.optim.ts --jsr",
+    "build": "bun build:npm && bun build:jsr",
+    "pub:npm": "bun build.publish.ts",
+    "pub:jsr": "bun build.publish.ts --jsr",
+    "pub:dry": "bun build.publish.ts --dry-run",
+    "pub": "bun check && bun publish.ts",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint --cache --fix .",
+    "lint:i": "eslint --inspect-config",
+    "format": "biome check --write .",
+    "attw": "bunx @arethetypeswrong/cli",
+    "unpub": "npm unpublish",
+    "test": "vitest",
+    "knip": "knip",
+    "latest": "bun update --latest"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/reliverse/relico.git"
+  },
+  "types": "./dist-npm/main.d.ts",
+  "module": "./dist-npm/main.js",
+  "main": "./dist-npm/main.js",
+  "exports": {
+    "import": "./dist-npm/main.js",
+    "types": "./dist-npm/main.d.ts"
+  },
+  "bugs": {
+    "url": "https://github.com/reliverse/relico/issues",
+    "email": "blefnk@gmail.com"
+  },
+  "files": ["package.json", "README.md", "LICENSE.md", "dist-npm"],
+  "homepage": "https://github.com/reliverse/relico",
+  "keywords": ["cli", "reliverse"],
+  "license": "MIT",
+  "dependencies": {
+    "@sinclair/typebox": "^0.34.14",
+    "confbox": "^0.1.8",
+    "destr": "^2.0.3",
+    "fs-extra": "^11.3.0",
+    "globby": "^14.0.2",
+    "mri": "^1.2.0",
+    "pathe": "^2.0.2",
+    "std-env": "^3.8.0"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.17.3",
+    "@biomejs/biome": "1.9.4",
+    "@eslint/js": "^9.18.0",
+    "@eslint/json": "^0.9.1",
+    "@eslint/markdown": "^6.2.1",
+    "@stylistic/eslint-plugin": "^2.13.0",
+    "@types/bun": "^1.1.18",
+    "@types/eslint__js": "^8.42.3",
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^22.10.7",
+    "citty": "^0.1.6",
+    "eslint": "^9.18.0",
+    "eslint-plugin-perfectionist": "^4.7.0",
+    "execa": "^9.5.2",
+    "jiti": "^2.4.2",
+    "knip": "^5.42.3",
+    "typescript": "^5.7.3",
+    "typescript-eslint": "^8.21.0",
+    "unbuild": "^3.3.1",
+    "vitest": "^3.0.3"
+  }
+}