hyouji 0.0.16 → 0.1.0

package/README.md

@@ -1,5 +1,8 @@
 # Hyouji(表示) GitHub Label Manager
 
+<img width="2816" height="1536" alt="hyouji_generated_image" src="https://github.com/user-attachments/assets/636382d1-a718-4289-81d7-2943f1962ce8" />
+
+
 ### article
 
 https://levelup.gitconnected.com/create-github-labels-from-terminal-158d4868fab  

package/dist/index.js

@@ -7,7 +7,9 @@ import { homedir } from "os";
 import * as path from "path";
 import { join, dirname } from "path";
 import { createHash, randomBytes, createCipheriv, createDecipheriv } from "crypto";
-import prompts from "prompts";
+import { stdout, stdin } from "node:process";
+import { emitKeypressEvents } from "node:readline";
+import { createInterface } from "node:readline/promises";
 import YAML from "yaml";
 import { Octokit } from "@octokit/core";
 import { exec } from "child_process";
@@ -47,26 +49,16 @@ const newLabel = [
   }
 ];
 const deleteLabel$1 = {
-  type: "text",
-  name: "name",
   message: "Please type label name you want to delete"
 };
 const labelFilePath = {
-  type: "text",
-  name: "filePath",
   message: "Please type the path to your JSON or YAML file"
 };
 const dryRunToggle = {
-  type: "toggle",
-  name: "dryRun",
   message: "Run in dry-run mode? (no API calls will be made)",
-  active: "yes",
-  inactive: "no",
   initial: false
 };
 const actionSelector = {
-  type: "multiselect",
-  name: "action",
   message: "Please select an action",
   choices: [
     { title: "create a label", value: 0 },
@@ -81,8 +73,6 @@ const actionSelector = {
   ]
 };
 const holdToken = {
-  type: "confirm",
-  name: "value",
   message: "Do you have a personal token?",
   initial: true
 };
@@ -428,7 +418,13 @@ const deleteLabels = async (configs2) => {
   log$4(chalk.bgBlueBright(extraGuideText));
   return { deleted, failed };
 };
-const _CryptoUtils = class _CryptoUtils {
+class CryptoUtils {
+  static {
+    this.ALGORITHM = "aes-256-cbc";
+  }
+  static {
+    this.ENCODING = "hex";
+  }
   /**
    * Generate a machine-specific key based on system information
    * This provides basic obfuscation without requiring user passwords
@@ -507,10 +503,7 @@ const _CryptoUtils = class _CryptoUtils {
     const middle = "*".repeat(Math.min(token.length - 8, 20));
     return `${start}${middle}${end}`;
   }
-};
-_CryptoUtils.ALGORITHM = "aes-256-cbc";
-_CryptoUtils.ENCODING = "hex";
-let CryptoUtils = _CryptoUtils;
+}
 class ConfigError extends Error {
   constructor(type, message, originalError) {
     super(message);
@@ -1016,13 +1009,374 @@ class ConfigManager {
     ].includes(error.type);
   }
 }
+const OPEN_TUI_INPUT_TIMEOUT_MS = 3e4;
+const ESCAPE_SELECTION_VALUE = 99;
+let opentuiLoadAttempted = false;
+let opentuiModule = null;
+const loadOpenTui = async () => {
+  if (opentuiLoadAttempted) {
+    return opentuiModule;
+  }
+  opentuiLoadAttempted = true;
+  try {
+    const loaded = await import("@opentui/core");
+    opentuiModule = loaded;
+    return loaded;
+  } catch {
+    opentuiModule = null;
+    return null;
+  }
+};
+const question = async (message) => {
+  const rl = createInterface({ input: stdin, output: stdout });
+  try {
+    const answer = await rl.question(`${message}: `);
+    return answer.trim();
+  } finally {
+    rl.close();
+  }
+};
+const askText = async (message, options = {}) => {
+  const core = await loadOpenTui();
+  if (core) {
+    const result = await askTextWithOpenTui(core, message, options);
+    if (result !== null) {
+      return result;
+    }
+  }
+  const answer = await question(message);
+  if (answer.length === 0 && options.initial !== void 0) {
+    return options.initial;
+  }
+  return answer;
+};
+const askPassword = async (message) => {
+  const masked = await askPasswordWithRawInput(message);
+  if (masked !== null) {
+    return masked;
+  }
+  return askText(message);
+};
+const askConfirm = async (message, initial = true) => {
+  const value = await askSelect(message, [
+    { title: initial ? "yes (default)" : "yes", value: 1 },
+    { title: initial ? "no" : "no (default)", value: 0 }
+  ]);
+  if (value === 1) {
+    return true;
+  }
+  if (value === 0) {
+    return false;
+  }
+  if (value === ESCAPE_SELECTION_VALUE) {
+    return false;
+  }
+  return initial;
+};
+const askSelect = async (message, choices) => {
+  const core = await loadOpenTui();
+  if (core) {
+    const selected = await askSelectWithOpenTui(core, message, choices);
+    if (selected !== null) {
+      return selected;
+    }
+  }
+  stdout.write(`${message}
+`);
+  choices.forEach((choice, index) => {
+    stdout.write(`  ${index + 1}. ${choice.title}
+`);
+  });
+  const rawSelected = await askSelectWithRawInput(choices);
+  if (rawSelected !== null) {
+    return rawSelected;
+  }
+  while (true) {
+    const answer = await question("Select number");
+    const normalized = answer.toLowerCase();
+    if (normalized === "esc" || normalized === "escape") {
+      return choices.find((choice2) => choice2.title.toLowerCase() === "exit")?.value ?? 99;
+    }
+    const parsed = Number.parseInt(answer, 10);
+    if (Number.isNaN(parsed)) {
+      stdout.write("Please enter a valid number.\n");
+      continue;
+    }
+    const choice = choices[parsed - 1];
+    if (!choice) {
+      stdout.write("Out of range. Try again.\n");
+      continue;
+    }
+    return choice.value;
+  }
+};
+const askSelectWithOpenTui = async (core, message, choices) => {
+  const renderer = await core.createCliRenderer({ exitOnCtrlC: true });
+  let destroyed = false;
+  const destroyRenderer = async () => {
+    if (destroyed) {
+      return;
+    }
+    destroyed = true;
+    await renderer.destroy();
+  };
+  try {
+    const root = new core.BoxRenderable(renderer, {
+      id: "prompt-root",
+      flexDirection: "column",
+      border: true,
+      padding: 1
+    });
+    const title = new core.TextRenderable(renderer, {
+      id: "prompt-title",
+      content: message
+    });
+    const select = new core.SelectRenderable(renderer, {
+      id: "prompt-select",
+      options: choices.map((choice) => ({
+        name: choice.title,
+        value: choice.value
+      }))
+    });
+    root.add(title);
+    root.add(select);
+    renderer.root.add(root);
+    select.focus?.();
+    if (!select.on) {
+      await destroyRenderer();
+      return null;
+    }
+    const escapeValue = choices.find((choice) => choice.title.toLowerCase() === "exit")?.value ?? 99;
+    return await new Promise((resolve) => {
+      let resolved = false;
+      const resolveOnce = async (value) => {
+        if (resolved) {
+          return;
+        }
+        resolved = true;
+        await destroyRenderer();
+        resolve(value);
+      };
+      select.on(
+        core.SelectRenderableEvents.ITEM_SELECTED,
+        async (_index, option) => {
+          if (typeof option === "object" && option !== null && "value" in option && typeof option.value === "number") {
+            await resolveOnce(option.value);
+            return;
+          }
+          await resolveOnce(99);
+        }
+      );
+      renderer.keyInput?.on?.("keypress", async (key) => {
+        if (typeof key === "object" && key !== null && "name" in key && (key.name === "escape" || key.name === "esc")) {
+          await resolveOnce(escapeValue);
+        }
+      });
+    });
+  } catch {
+    await destroyRenderer();
+    return null;
+  }
+};
+const askSelectWithRawInput = async (choices) => {
+  if (!stdin.isTTY || typeof stdin.setRawMode !== "function") {
+    return null;
+  }
+  const escapeValue = choices.find((choice) => choice.title.toLowerCase() === "exit")?.value ?? 99;
+  stdout.write("Select number (or Esc to exit): ");
+  return await new Promise((resolve) => {
+    let digits = "";
+    const wasRaw = stdin.isRaw;
+    const wasPaused = stdin.isPaused();
+    const cleanup = () => {
+      stdin.removeListener("keypress", onKeypress);
+      if (!wasRaw) {
+        stdin.setRawMode(false);
+      }
+      if (wasPaused) {
+        stdin.pause();
+      }
+      stdout.write("\n");
+    };
+    const resolveValue = (value) => {
+      cleanup();
+      resolve(value);
+    };
+    const onKeypress = (str, key) => {
+      if (!key) {
+        return;
+      }
+      if (key.name === "escape" || key.name === "esc") {
+        resolveValue(escapeValue);
+        return;
+      }
+      if (key.name === "return" || key.name === "enter") {
+        const parsed = Number.parseInt(digits, 10);
+        if (Number.isNaN(parsed)) {
+          stdout.write("\nPlease enter a valid number.\nSelect number: ");
+          digits = "";
+          return;
+        }
+        const choice = choices[parsed - 1];
+        if (!choice) {
+          stdout.write("\nOut of range. Try again.\nSelect number: ");
+          digits = "";
+          return;
+        }
+        resolveValue(choice.value);
+        return;
+      }
+      if (key.name === "backspace") {
+        if (digits.length > 0) {
+          digits = digits.slice(0, -1);
+          stdout.write("\b \b");
+        }
+        return;
+      }
+      if (/^[0-9]$/.test(str)) {
+        digits += str;
+        stdout.write(str);
+      }
+    };
+    emitKeypressEvents(stdin);
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.on("keypress", onKeypress);
+  });
+};
+const askPasswordWithRawInput = async (message) => {
+  if (!stdin.isTTY || typeof stdin.setRawMode !== "function") {
+    return null;
+  }
+  stdout.write(`${message}: `);
+  return await new Promise((resolve) => {
+    let value = "";
+    const wasRaw = stdin.isRaw;
+    const wasPaused = stdin.isPaused();
+    const cleanup = () => {
+      stdin.removeListener("keypress", onKeypress);
+      if (!wasRaw) {
+        stdin.setRawMode(false);
+      }
+      if (wasPaused) {
+        stdin.pause();
+      }
+      stdout.write("\n");
+    };
+    const resolveValue = (password) => {
+      cleanup();
+      resolve(password);
+    };
+    const onKeypress = (str, key) => {
+      if (!key) {
+        return;
+      }
+      if (key.name === "return" || key.name === "enter") {
+        resolveValue(value);
+        return;
+      }
+      if (key.name === "backspace") {
+        if (value.length > 0) {
+          value = value.slice(0, -1);
+          stdout.write("\b \b");
+        }
+        return;
+      }
+      if (key.name === "escape" || key.name === "esc") {
+        resolveValue(null);
+        return;
+      }
+      if (str.length === 1 && str >= " ") {
+        value += str;
+        stdout.write("*");
+      }
+    };
+    emitKeypressEvents(stdin);
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.on("keypress", onKeypress);
+  });
+};
+const askTextWithOpenTui = async (core, message, options) => {
+  const renderer = await core.createCliRenderer({ exitOnCtrlC: true });
+  let destroyed = false;
+  let currentValue = options.initial ?? "";
+  const destroyRenderer = async () => {
+    if (destroyed) {
+      return;
+    }
+    destroyed = true;
+    await renderer.destroy();
+  };
+  try {
+    const root = new core.BoxRenderable(renderer, {
+      id: "prompt-root",
+      flexDirection: "column",
+      border: true,
+      padding: 1
+    });
+    const title = new core.TextRenderable(renderer, {
+      id: "prompt-title",
+      content: message
+    });
+    const inputField = new core.InputRenderable(renderer, {
+      id: "prompt-input",
+      placeholder: options.initial ?? ""
+    });
+    inputField.setValue?.(currentValue);
+    if (!inputField.on) {
+      await destroyRenderer();
+      return null;
+    }
+    inputField.on(core.InputRenderableEvents.CHANGE, (nextValue) => {
+      if (typeof nextValue === "string") {
+        currentValue = nextValue;
+      }
+    });
+    root.add(title);
+    root.add(inputField);
+    renderer.root.add(root);
+    inputField.focus?.();
+    if (!renderer.keyInput?.on) {
+      await destroyRenderer();
+      return null;
+    }
+    return await new Promise((resolve) => {
+      let settled = false;
+      const timer = setTimeout(async () => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        await destroyRenderer();
+        resolve(null);
+      }, OPEN_TUI_INPUT_TIMEOUT_MS);
+      renderer.keyInput?.on?.("keypress", async (key) => {
+        if (settled) {
+          return;
+        }
+        if (typeof key === "object" && key !== null && "name" in key && (key.name === "enter" || key.name === "return")) {
+          settled = true;
+          clearTimeout(timer);
+          await destroyRenderer();
+          if (currentValue === "" && options.initial !== void 0) {
+            resolve(options.initial);
+            return;
+          }
+          resolve(currentValue);
+        }
+      });
+    });
+  } catch {
+    await destroyRenderer();
+    return null;
+  }
+};
 const getConfirmation = async () => {
-  const response = await prompts(holdToken);
-  return response.value;
+  return askConfirm(holdToken.message, holdToken.initial);
 };
 const getDryRunChoice = async () => {
-  const response = await prompts(dryRunToggle);
-  return Boolean(response.dryRun);
+  return askConfirm(dryRunToggle.message, dryRunToggle.initial);
 };
 const log$3 = console.log;
 const generateSampleJson = async () => {
@@ -1344,11 +1698,19 @@ const importLabelsFromFile = async (configs2, filePath, dryRun = false) => {
   return summary;
 };
 const getTargetLabel = async () => {
-  const response = await prompts(deleteLabel$1);
-  return [response.name];
+  while (true) {
+    const name = (await askText(deleteLabel$1.message)).trim();
+    if (name.length > 0) {
+      return [name];
+    }
+    console.log(chalk.yellow("Label name cannot be empty. Please try again."));
+  }
 };
 const GIT_COMMAND_TIMEOUT_MS = 5e3;
-const _GitRepositoryDetector = class _GitRepositoryDetector {
+class GitRepositoryDetector {
+  static {
+    this.execAsyncInternal = promisify(exec);
+  }
   /**
    * Overrides the internal execAsync function for testing purposes.
    * @param mock - The mock function to use for execAsync.
@@ -1449,14 +1811,14 @@ const _GitRepositoryDetector = class _GitRepositoryDetector {
    */
   static async getRemoteUrl(gitRoot, remoteName) {
     try {
-      const { stdout } = await this.execAsyncInternal(
+      const { stdout: stdout2 } = await this.execAsyncInternal(
         `git remote get-url ${remoteName}`,
         {
           cwd: gitRoot,
           timeout: GIT_COMMAND_TIMEOUT_MS
         }
       );
-      return stdout.trim() || null;
+      return stdout2.trim() || null;
     } catch {
       return null;
     }
@@ -1526,12 +1888,12 @@ const _GitRepositoryDetector = class _GitRepositoryDetector {
    */
   static async getAllRemotes(gitRoot) {
     try {
-      const { stdout } = await this.execAsyncInternal("git remote", {
+      const { stdout: stdout2 } = await this.execAsyncInternal("git remote", {
         cwd: gitRoot,
         timeout: GIT_COMMAND_TIMEOUT_MS
       });
       return {
-        remotes: stdout.trim().split("\n").filter((remote) => remote.length > 0)
+        remotes: stdout2.trim().split("\n").filter((remote) => remote.length > 0)
       };
     } catch (err) {
       const error = err;
@@ -1544,11 +1906,23 @@ const _GitRepositoryDetector = class _GitRepositoryDetector {
       return { remotes: [] };
     }
   }
+}
+const askRequiredValue = async (ask, fieldName) => {
+  while (true) {
+    const rawValue = await ask();
+    if (rawValue === null) {
+      throw new Error(`${fieldName} input was canceled by user.`);
+    }
+    const value = rawValue.trim();
+    if (value.length > 0) {
+      return value;
+    }
+    console.log(
+      chalk.yellow(`⚠️  ${fieldName} cannot be empty. Please try again.`)
+    );
+  }
 };
-_GitRepositoryDetector.execAsyncInternal = promisify(exec);
-let GitRepositoryDetector = _GitRepositoryDetector;
 const getGitHubConfigs = async () => {
-  var _a, _b;
   const configManager2 = new ConfigManager();
   let validationResult = {
     config: null,
@@ -1612,91 +1986,108 @@ const getGitHubConfigs = async () => {
         console.log(chalk.gray(`  Error: ${error.message}`));
       }
     }
-    const repoResponse = await prompts([
-      {
-        type: "text",
-        name: "repo",
-        message: "Please type your target repo name"
-      }
-    ]);
+    const repoPrompt2 = githubConfigs.find((prompt) => prompt.name === "repo");
+    const repo2 = await askRequiredValue(
+      () => askText(repoPrompt2?.message ?? "Please type your target repo name"),
+      "Repository name"
+    );
     const octokit2 = new Octokit({
       auth: validationResult.config.token
     });
     return {
       octokit: octokit2,
       owner: validationResult.config.owner,
-      repo: repoResponse.repo,
+      repo: repo2,
       fromSavedConfig: true,
       autoDetected: false,
       detectionMethod: "manual"
     };
   }
-  const promptConfig = [...githubConfigs];
-  if ((_a = validationResult.preservedData) == null ? void 0 : _a.owner) {
-    const ownerPromptIndex = promptConfig.findIndex(
-      (prompt) => prompt.name === "owner"
-    );
-    if (ownerPromptIndex !== -1) {
-      promptConfig[ownerPromptIndex] = {
-        ...promptConfig[ownerPromptIndex],
-        initial: validationResult.preservedData.owner
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      };
+  const tokenPrompt = githubConfigs.find((prompt) => prompt.name === "octokit");
+  const ownerPrompt = githubConfigs.find((prompt) => prompt.name === "owner");
+  const repoPrompt = githubConfigs.find((prompt) => prompt.name === "repo");
+  const octokitToken = await askRequiredValue(
+    () => askPassword(tokenPrompt?.message ?? "Please type your personal token"),
+    "Personal token"
+  );
+  const owner = await askRequiredValue(
+    () => askText(ownerPrompt?.message ?? "Please type your GitHub account", {
+      initial: validationResult.preservedData?.owner
+    }),
+    "GitHub account"
+  );
+  const repo = await askRequiredValue(
+    () => askText(repoPrompt?.message ?? "Please type your target repo name"),
+    "Repository name"
+  );
+  try {
+    await configManager2.saveConfig({
+      token: octokitToken,
+      owner,
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    if (validationResult.preservedData?.owner && validationResult.preservedData.owner !== owner) {
+      console.log("✓ Configuration updated with new credentials");
+    } else {
+      console.log("✓ Configuration saved successfully");
     }
-  }
-  const response = await prompts(promptConfig);
-  if (response.octokit && response.owner) {
-    try {
-      await configManager2.saveConfig({
-        token: response.octokit,
-        owner: response.owner,
-        lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      if (((_b = validationResult.preservedData) == null ? void 0 : _b.owner) && validationResult.preservedData.owner !== response.owner) {
-        console.log("✓ Configuration updated with new credentials");
-      } else {
-        console.log("✓ Configuration saved successfully");
-      }
-    } catch (error) {
-      if (error instanceof ConfigError) {
-        console.error(`❌ ${ConfigManager.getErrorMessage(error)}`);
-        if (!ConfigManager.isRecoverableError(error)) {
-          console.error(
-            "   This may affect future sessions. Please resolve the issue or contact support."
-          );
-        }
-      } else {
-        console.warn(
-          "⚠️  Failed to save configuration:",
-          error instanceof Error ? error.message : "Unknown error"
+  } catch (error) {
+    if (error instanceof ConfigError) {
+      console.error(`❌ ${ConfigManager.getErrorMessage(error)}`);
+      if (!ConfigManager.isRecoverableError(error)) {
+        console.error(
+          "   This may affect future sessions. Please resolve the issue or contact support."
         );
       }
+    } else {
+      console.warn(
+        "⚠️  Failed to save configuration:",
+        error instanceof Error ? error.message : "Unknown error"
+      );
     }
   }
   const octokit = new Octokit({
-    auth: response.octokit
+    auth: octokitToken
   });
   return {
     octokit,
-    owner: response.owner,
-    repo: response.repo,
+    owner,
+    repo,
     fromSavedConfig: false,
     autoDetected: false,
     detectionMethod: "manual"
   };
 };
 const getLabelFilePath = async () => {
-  const response = await prompts(labelFilePath);
-  return response.filePath;
+  while (true) {
+    const filePath = (await askText(labelFilePath.message)).trim();
+    if (filePath.length > 0) {
+      return filePath;
+    }
+    console.log("File path cannot be empty. Please try again.");
+  }
+};
+const getPromptMessage = (field, fallback) => {
+  return newLabel.find((prompt) => prompt.name === field)?.message ?? fallback;
 };
 const getNewLabel = async () => {
-  const response = await prompts(newLabel);
-  return response;
+  const name = await askText(
+    getPromptMessage("name", "Please type new label name")
+  );
+  const color = await askText(
+    getPromptMessage("color", 'Please type label color without "#" ')
+  );
+  const description = await askText(
+    getPromptMessage("description", "Please type label description")
+  );
+  return {
+    name,
+    color,
+    description
+  };
 };
 const selectAction = async () => {
-  const response = await prompts(actionSelector);
-  const { action } = response;
-  return action[0] !== void 0 ? action[0] : 99;
+  return askSelect(actionSelector.message, actionSelector.choices);
 };
 const log = console.log;
 let firstStart = true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hyouji",
-  "version": "0.0.16",
+  "version": "0.1.0",
   "description": "Hyouji (表示) — A command-line tool for organizing and displaying GitHub labels with clarity and harmony.",
   "main": "dist/index.js",
   "author": "koji <baxin1919@gmail.com>",
@@ -24,8 +24,7 @@
     "表示",
     "Hyouji(表示)",
     "JSON",
-    "yaml",
-    "yml"
+    "yaml"
   ],
   "scripts": {
     "start": "node dist/index.js",
@@ -43,34 +42,32 @@
     "test:auto-detection": "node tests/integration/auto-detection/integration-flow.cjs",
     "test:verification": "node tests/scripts/verification/run-all.cjs",
     "test:all-custom": "npm run test:error-handling && npm run test:config && npm run test:integration && npm run test:verification",
-    "check-cli": "run-s test diff-integration-tests check-integration-tests",
-    "check-integration-tests": "run-s check-integration-test:*",
     "diff-integration-tests": "mkdir -p diff && rm -rf diff/test && cp -r test diff/test && rm -rf diff/test/test-*/.git && cd diff && git init --quiet && git add -A && git commit --quiet --no-verify --allow-empty -m 'WIP' && echo '\\n\\nCommitted most recent integration test output in the \"diff\" directory. Review the changes with \"cd diff && git diff HEAD\" or your preferred git diff viewer.'",
     "watch:build": "tsc -p tsconfig.json -w",
-    "cov:send": "run-s cov:lcov && codecov",
     "version": "standard-version",
-    "reset-hard": "git clean -dfx && git reset --hard && yarn",
-    "prepare-release": "run-s reset-hard test cov:check doc:html version doc:publish"
+    "reset-hard": "git clean -dfx && git reset --hard && bun install"
   },
   "engines": {
-    "node": ">=10"
+    "node": ">=22.22.0"
   },
   "dependencies": {
     "@octokit/core": "^7.0.6",
+    "@opentui/core": "0.1.80",
     "chalk": "^5.6.2",
     "oh-my-logo": "^0.3.2",
-    "prompts": "^2.4.2",
     "yaml": "^2.8.1"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.3.4",
+    "@biomejs/biome": "2.3.11",
     "@types/node": "^24.10.0",
-    "@vitest/coverage-v8": "^4.0.8",
-    "@vitest/ui": "^4.0.8",
+    "@vitest/coverage-v8": "^4.0.17",
+    "@vitest/ui": "^4.0.17",
+    "knip": "^5.85.0",
+    "lefthook": "^2.1.1",
     "standard-version": "^9.5.0",
     "typescript": "^5.9.3",
-    "vite": "^7.2.2",
-    "vitest": "^4.0.8"
+    "vite": "^7.3.1",
+    "vitest": "^4.0.17"
   },
   "files": [
     "dist/**/*",