@lang-tag/cli 0.9.4 → 0.10.1

package/cli/index.js

@@ -1,1474 +0,0 @@
-#!/usr/bin/env node
-import { program } from "commander";
-import fs, { readFileSync, existsSync } from "fs";
-import { writeFile, mkdir, readFile, rm } from "fs/promises";
-import JSON5 from "json5";
-import * as path from "path";
-import path__default, { sep, dirname, resolve as resolve$1, join } from "path";
-import { globby } from "globby";
-import path$1, { resolve, dirname as dirname$1 } from "pathe";
-import { pathToFileURL, fileURLToPath } from "url";
-import * as process$1 from "node:process";
-import process__default from "node:process";
-import * as acorn from "acorn";
-import micromatch from "micromatch";
-import chokidar from "chokidar";
-import mustache from "mustache";
-class $LT_TagProcessor {
-  constructor(config) {
-    this.config = config;
-  }
-  extractTags(fileContent) {
-    const tagName = this.config.tagName;
-    const optionalVariableAssignment = `(?:\\s*(\\w+)\\s*=\\s*)?`;
-    const matches = [];
-    let currentIndex = 0;
-    const startPattern = new RegExp(`${optionalVariableAssignment}${tagName}\\(\\s*\\{`, "g");
-    while (true) {
-      startPattern.lastIndex = currentIndex;
-      const startMatch = startPattern.exec(fileContent);
-      if (!startMatch) break;
-      const matchStartIndex = startMatch.index;
-      const variableName = startMatch[1] || void 0;
-      let braceCount = 1;
-      let i = matchStartIndex + startMatch[0].length;
-      while (i < fileContent.length && braceCount > 0) {
-        if (fileContent[i] === "{") braceCount++;
-        if (fileContent[i] === "}") braceCount--;
-        i++;
-      }
-      if (braceCount !== 0) {
-        currentIndex = matchStartIndex + 1;
-        continue;
-      }
-      let parameter1Text = fileContent.substring(matchStartIndex + startMatch[0].length - 1, i);
-      let parameter2Text;
-      while (i < fileContent.length && (fileContent[i] === " " || fileContent[i] === "\n" || fileContent[i] === "	")) {
-        i++;
-      }
-      if (i >= fileContent.length) {
-        currentIndex = matchStartIndex + 1;
-        continue;
-      }
-      if (fileContent[i] === ",") {
-        i++;
-        while (i < fileContent.length && (fileContent[i] === " " || fileContent[i] === "\n" || fileContent[i] === "	")) {
-          i++;
-        }
-        if (i >= fileContent.length || fileContent[i] !== "{") {
-          currentIndex = matchStartIndex + 1;
-          continue;
-        }
-        braceCount = 1;
-        const secondParamStart = i;
-        i++;
-        while (i < fileContent.length && braceCount > 0) {
-          if (fileContent[i] === "{") braceCount++;
-          if (fileContent[i] === "}") braceCount--;
-          i++;
-        }
-        if (braceCount !== 0) {
-          currentIndex = matchStartIndex + 1;
-          continue;
-        }
-        parameter2Text = fileContent.substring(secondParamStart, i);
-        while (i < fileContent.length && (fileContent[i] === " " || fileContent[i] === "\n" || fileContent[i] === "	")) {
-          i++;
-        }
-        if (i < fileContent.length && fileContent[i] === ",") {
-          i++;
-          while (i < fileContent.length && (fileContent[i] === " " || fileContent[i] === "\n" || fileContent[i] === "	")) {
-            i++;
-          }
-        }
-      } else if (fileContent[i] !== ")") {
-        currentIndex = matchStartIndex + 1;
-        continue;
-      }
-      if (i >= fileContent.length || fileContent[i] !== ")") {
-        currentIndex = matchStartIndex + 1;
-        continue;
-      }
-      i++;
-      const fullMatch = fileContent.substring(matchStartIndex, i);
-      const { line, column } = getLineAndColumn(fileContent, matchStartIndex);
-      let validity = "ok";
-      let parameter1 = void 0;
-      let parameter2 = void 0;
-      try {
-        parameter1 = JSON5.parse(parameter1Text);
-        if (parameter2Text) {
-          try {
-            parameter2 = JSON5.parse(parameter2Text);
-          } catch (error) {
-            validity = "invalid-param-2";
-          }
-        }
-      } catch (error) {
-        validity = "invalid-param-1";
-      }
-      let parameterTranslations = this.config.translationArgPosition === 1 ? parameter1 : parameter2;
-      let parameterConfig = this.config.translationArgPosition === 1 ? parameter2 : parameter1;
-      if (validity === "ok") {
-        if (!parameterTranslations) validity = "translations-not-found";
-      }
-      matches.push({
-        fullMatch,
-        variableName,
-        parameter1Text,
-        parameter2Text,
-        parameterTranslations,
-        parameterConfig,
-        index: matchStartIndex,
-        line,
-        column,
-        validity
-      });
-      currentIndex = i;
-    }
-    return matches;
-  }
-  replaceTags(fileContent, replacements) {
-    const replaceMap = /* @__PURE__ */ new Map();
-    replacements.forEach((R) => {
-      if (!R.translations && !R.config) {
-        throw new Error("Replacement data is required!");
-      }
-      const tag = R.tag;
-      let newTranslationsString = R.translations;
-      if (!newTranslationsString) newTranslationsString = this.config.translationArgPosition === 1 ? tag.parameter1Text : tag.parameter2Text;
-      else if (typeof newTranslationsString !== "string") newTranslationsString = JSON5.stringify(newTranslationsString);
-      if (!newTranslationsString) throw new Error("Tag must have translations provided!");
-      try {
-        JSON5.parse(newTranslationsString);
-      } catch (error) {
-        throw new Error(`Tag translations are invalid object! Translations: ${newTranslationsString}`);
-      }
-      let newConfigString = R.config;
-      if (!newConfigString) newConfigString = tag.parameterConfig;
-      if (newConfigString) {
-        try {
-          if (typeof newConfigString === "string") JSON5.parse(newConfigString);
-          else newConfigString = JSON5.stringify(newConfigString);
-        } catch (error) {
-          throw new Error(`Tag config is invalid object! Config: ${newConfigString}`);
-        }
-      }
-      const arg1 = this.config.translationArgPosition === 1 ? newTranslationsString : newConfigString;
-      const arg2 = this.config.translationArgPosition === 1 ? newConfigString : newTranslationsString;
-      let tagFunction = `${this.config.tagName}(${arg1}`;
-      if (arg2) tagFunction += `, ${arg2}`;
-      tagFunction += ")";
-      if (tag.variableName) replaceMap.set(tag, ` ${tag.variableName} = ${tagFunction}`);
-      else replaceMap.set(tag, tagFunction);
-    });
-    let offset = 0;
-    replaceMap.forEach((replacement, match) => {
-      const startIdx = match.index + offset;
-      const endIdx = startIdx + match.fullMatch.length;
-      fileContent = fileContent.slice(0, startIdx) + replacement + fileContent.slice(endIdx);
-      offset += replacement.length - match.fullMatch.length;
-    });
-    return fileContent;
-  }
-}
-function getLineAndColumn(text, matchIndex) {
-  const lines = text.slice(0, matchIndex).split("\n");
-  const line = lines.length;
-  const column = lines[lines.length - 1].length + 1;
-  return { line, column };
-}
-function $LT_FilterInvalidTags(tags, config, logger) {
-  return tags.filter((tag) => {
-    if (tag.validity === "invalid-param-1")
-      logger.debug('Skipping tag "{fullMatch}". Invalid JSON: "{invalid}"', {
-        fullMatch: tag.fullMatch.trim(),
-        invalid: tag.parameter1Text
-      });
-    if (tag.validity === "invalid-param-2")
-      logger.debug('Skipping tag "{fullMatch}". Invalid JSON: "{invalid}"', {
-        fullMatch: tag.fullMatch.trim(),
-        invalid: tag.parameter2Text
-      });
-    if (tag.validity === "translations-not-found")
-      logger.debug('Skipping tag "{fullMatch}". Translations not found at parameter position: {pos}', {
-        fullMatch: tag.fullMatch.trim(),
-        pos: config.translationArgPosition
-      });
-    return tag.validity === "ok";
-  });
-}
-function $LT_FilterEmptyNamespaceTags(tags, logger) {
-  return tags.filter((tag) => {
-    if (!tag.parameterConfig) {
-      logger.warn('Skipping tag "{fullMatch}". Tag configuration not defined. (Check lang-tag config at collect.onCollectConfigFix)', {
-        fullMatch: tag.fullMatch.trim()
-      });
-      return false;
-    }
-    if (!tag.parameterConfig.namespace) {
-      logger.warn('Skipping tag "{fullMatch}". Tag configuration namespace not defined. (Check lang-tag config at collect.onCollectConfigFix)', {
-        fullMatch: tag.fullMatch.trim()
-      });
-      return false;
-    }
-    return true;
-  });
-}
-async function checkAndRegenerateFileLangTags(config, logger, file, path2) {
-  let libraryImportsDir = config.import.dir;
-  if (!libraryImportsDir.endsWith(sep)) libraryImportsDir += sep;
-  const fileContent = readFileSync(file, "utf-8");
-  const processor = new $LT_TagProcessor(config);
-  let tags = processor.extractTags(fileContent);
-  tags = $LT_FilterInvalidTags(tags, config, logger);
-  if (!tags.length) {
-    return false;
-  }
-  const replacements = [];
-  for (let tag of tags) {
-    const newConfig = config.onConfigGeneration({
-      config: tag.parameterConfig,
-      fullPath: file,
-      path: path2,
-      isImportedLibrary: path2.startsWith(libraryImportsDir)
-    });
-    if (newConfig === void 0) {
-      continue;
-    }
-    if (JSON5.stringify(tag.parameterConfig) !== JSON5.stringify(newConfig)) {
-      replacements.push({ tag, config: newConfig });
-    }
-  }
-  if (replacements.length) {
-    const newContent = processor.replaceTags(fileContent, replacements);
-    await writeFile(file, newContent, "utf-8");
-    return true;
-  }
-  return false;
-}
-const CONFIG_FILE_NAME = ".lang-tag.config.js";
-const EXPORTS_FILE_NAME = ".lang-tag.exports.json";
-const LANG_TAG_DEFAULT_CONFIG = {
-  tagName: "lang",
-  includes: ["src/**/*.{js,ts,jsx,tsx}"],
-  excludes: ["node_modules", "dist", "build"],
-  outputDir: "locales/en",
-  collect: {
-    defaultNamespace: "common",
-    ignoreConflictsWithMatchingValues: true,
-    onCollectConfigFix: ({ config, langTagConfig }) => {
-      if (langTagConfig.isLibrary) return config;
-      if (!config) return { path: "", namespace: langTagConfig.collect.defaultNamespace };
-      if (!config.path) config.path = "";
-      if (!config.namespace) config.namespace = langTagConfig.collect.defaultNamespace;
-      return config;
-    },
-    onConflictResolution: async (event) => {
-      await event.logger.conflict(event.conflict, true);
-    },
-    onCollectFinish: (event) => {
-      event.exit();
-    }
-  },
-  import: {
-    dir: "src/lang-libraries",
-    tagImportPath: 'import { lang } from "@/my-lang-tag-path"',
-    onImport: ({ importedRelativePath, fileGenerationData }, actions) => {
-      const exportIndex = (fileGenerationData.index || 0) + 1;
-      fileGenerationData.index = exportIndex;
-      actions.setFile(path$1.basename(importedRelativePath));
-      actions.setExportName(`translations${exportIndex}`);
-    }
-  },
-  isLibrary: false,
-  language: "en",
-  translationArgPosition: 1,
-  onConfigGeneration: (params) => void 0
-};
-async function $LT_ReadConfig(projectPath) {
-  const configPath = resolve(projectPath, CONFIG_FILE_NAME);
-  if (!existsSync(configPath)) {
-    throw new Error(`No "${CONFIG_FILE_NAME}" detected`);
-  }
-  try {
-    const configModule = await import(pathToFileURL(configPath).href);
-    if (!configModule.default || Object.keys(configModule.default).length === 0) {
-      throw new Error(`Config found, but default export is undefined`);
-    }
-    const userConfig = configModule.default || {};
-    const tn = (userConfig.tagName || "").toLowerCase().replace(/[-_\s]/g, "");
-    if (tn.includes("langtag")) {
-      throw new Error('Custom tagName cannot include "langtag"! (It is not recommended for use with libraries)\n');
-    }
-    return {
-      ...LANG_TAG_DEFAULT_CONFIG,
-      ...userConfig,
-      import: {
-        ...LANG_TAG_DEFAULT_CONFIG.import,
-        ...userConfig.import
-      },
-      collect: {
-        ...LANG_TAG_DEFAULT_CONFIG.collect,
-        ...userConfig.collect
-      }
-    };
-  } catch (error) {
-    throw error;
-  }
-}
-async function $LT_EnsureDirectoryExists(filePath) {
-  await mkdir(filePath, { recursive: true });
-}
-async function $LT_RemoveDirectory(dirPath) {
-  try {
-    await rm(dirPath, { recursive: true, force: true });
-  } catch (error) {
-  }
-}
-async function $LT_WriteJSON(filePath, data) {
-  await writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
-}
-async function $LT_ReadJSON(filePath) {
-  const content = await readFile(filePath, "utf-8");
-  return JSON.parse(content);
-}
-async function $LT_WriteFileWithDirs(filePath, content) {
-  const dir = dirname(filePath);
-  try {
-    await mkdir(dir, { recursive: true });
-  } catch (error) {
-  }
-  await writeFile(filePath, content, "utf-8");
-}
-async function $LT_ReadFileContent(relativeFilePath) {
-  const cwd = process.cwd();
-  const absolutePath = resolve$1(cwd, relativeFilePath);
-  return await readFile(absolutePath, "utf-8");
-}
-function parseObjectAST(code) {
-  const nodes = [];
-  try {
-    let walk = function(node, path2 = []) {
-      if (node.type === "Property" && node.key) {
-        const keyName = node.key.type === "Identifier" ? node.key.name : node.key.type === "Literal" ? node.key.value : null;
-        if (keyName) {
-          const currentPath = [...path2, keyName];
-          nodes.push({
-            type: "key",
-            start: node.key.start - 1,
-            // -1 for wrapper '('
-            end: node.key.end - 1,
-            value: keyName,
-            line: node.key.loc.start.line,
-            column: node.key.loc.start.column,
-            path: currentPath
-          });
-          if (node.value && node.value.type === "Literal") {
-            nodes.push({
-              type: "value",
-              start: node.value.start - 1,
-              // -1 for wrapper '('
-              end: node.value.end - 1,
-              value: node.value.value,
-              line: node.value.loc.start.line,
-              column: node.value.loc.start.column
-            });
-          }
-          if (node.value && node.value.type === "ObjectExpression") {
-            walk(node.value, currentPath);
-            return;
-          }
-        }
-      }
-      for (const key in node) {
-        if (node[key] && typeof node[key] === "object") {
-          if (Array.isArray(node[key])) {
-            node[key].forEach((child) => walk(child, path2));
-          } else {
-            walk(node[key], path2);
-          }
-        }
-      }
-    };
-    const ast = acorn.parse(`(${code})`, {
-      ecmaVersion: "latest",
-      locations: true
-    });
-    walk(ast);
-    for (let i = 0; i < code.length; i++) {
-      const char = code[i];
-      if (/[{}[\](),:]/.test(char)) {
-        const isCovered = nodes.some((n) => i >= n.start && i < n.end);
-        if (!isCovered) {
-          const nodeType = char === ":" ? "colon" : "bracket";
-          nodes.push({
-            type: nodeType,
-            start: i,
-            end: i + 1,
-            value: char,
-            line: 1,
-            // Will be calculated properly
-            column: i + 1
-          });
-        }
-      }
-    }
-    nodes.sort((a, b) => a.start - b.start);
-  } catch (error) {
-    nodes.push({
-      type: "error",
-      start: 0,
-      end: code.length,
-      value: code,
-      line: 1,
-      column: 1
-    });
-  }
-  return nodes;
-}
-function markConflictNodes(nodes, conflictPath) {
-  const conflictKeys = conflictPath.split(".");
-  return nodes.map((node) => {
-    if (node.type === "key" && node.path) {
-      const isConflict = conflictKeys.length > 0 && node.path.length <= conflictKeys.length && node.path.every((key, idx) => key === conflictKeys[idx]);
-      if (isConflict) {
-        return { ...node, type: "error" };
-      }
-    }
-    return node;
-  });
-}
-const ANSI$1 = {
-  reset: "\x1B[0m",
-  white: "\x1B[97m",
-  brightCyan: "\x1B[96m",
-  green: "\x1B[92m",
-  gray: "\x1B[90m",
-  redBg: "\x1B[41m\x1B[97m",
-  bold: "\x1B[1m"
-};
-function colorizeFromAST(code, nodes) {
-  const ranges = [];
-  for (const node of nodes) {
-    const color = getColorForNodeType(node.type);
-    const priority = getPriorityForNodeType(node.type);
-    ranges.push({
-      start: node.start,
-      end: node.end,
-      color,
-      priority
-    });
-  }
-  ranges.sort((a, b) => {
-    if (b.start !== a.start) return b.start - a.start;
-    return b.priority - a.priority;
-  });
-  let colorized = code;
-  for (const range of ranges) {
-    const before = colorized.substring(0, range.start);
-    const text = colorized.substring(range.start, range.end);
-    const after = colorized.substring(range.end);
-    colorized = before + range.color + text + ANSI$1.reset + after;
-  }
-  return colorized;
-}
-function getColorForNodeType(type) {
-  switch (type) {
-    case "key":
-      return ANSI$1.brightCyan;
-    case "bracket":
-    case "colon":
-      return ANSI$1.gray;
-    case "value":
-      return ANSI$1.green;
-    case "comment":
-      return ANSI$1.gray;
-    case "error":
-      return ANSI$1.bold + ANSI$1.redBg;
-    default:
-      return ANSI$1.white;
-  }
-}
-function getPriorityForNodeType(type) {
-  switch (type) {
-    case "error":
-      return 3;
-    // Highest priority
-    case "key":
-      return 2;
-    case "value":
-      return 1;
-    case "bracket":
-    case "colon":
-    case "comment":
-      return 0;
-    // Lowest priority
-    default:
-      return 0;
-  }
-}
-const ANSI = {
-  reset: "\x1B[0m",
-  white: "\x1B[97m",
-  cyan: "\x1B[96m",
-  gray: "\x1B[37m",
-  darkGray: "\x1B[90m",
-  bold: "\x1B[1m"
-};
-function getVisibleLines(totalLines, errorLines, threshold = 10) {
-  if (totalLines <= threshold) {
-    return null;
-  }
-  const visible = /* @__PURE__ */ new Set();
-  const contextLines = 2;
-  visible.add(0);
-  visible.add(1);
-  visible.add(totalLines - 2);
-  visible.add(totalLines - 1);
-  for (const errorLine of errorLines) {
-    for (let i = Math.max(0, errorLine - contextLines); i <= Math.min(totalLines - 1, errorLine + contextLines); i++) {
-      visible.add(i);
-    }
-  }
-  return visible;
-}
-function printLines(lines, startLineNumber, errorLines = /* @__PURE__ */ new Set(), condense = false) {
-  const visibleLines = condense ? getVisibleLines(lines.length, errorLines) : null;
-  if (visibleLines === null) {
-    lines.forEach((line, i) => {
-      const lineNumber = startLineNumber + i;
-      const lineNumStr = String(lineNumber).padStart(3, " ");
-      console.log(`${ANSI.gray}${lineNumStr}${ANSI.reset} ${ANSI.darkGray}│${ANSI.reset} ${line}`);
-    });
-  } else {
-    let lastPrinted = -2;
-    lines.forEach((line, i) => {
-      if (visibleLines.has(i)) {
-        if (i > lastPrinted + 1 && lastPrinted >= 0) {
-          console.log(`${ANSI.gray}  -${ANSI.reset} ${ANSI.darkGray}│${ANSI.reset} ${ANSI.gray}...${ANSI.reset}`);
-        }
-        const lineNumber = startLineNumber + i;
-        const lineNumStr = String(lineNumber).padStart(3, " ");
-        console.log(`${ANSI.gray}${lineNumStr}${ANSI.reset} ${ANSI.darkGray}│${ANSI.reset} ${line}`);
-        lastPrinted = i;
-      }
-    });
-  }
-}
-async function getLangTagCodeSection(tagInfo) {
-  const { tag, relativeFilePath } = tagInfo;
-  const fileContent = await $LT_ReadFileContent(relativeFilePath);
-  const fileLines = fileContent.split("\n");
-  const startLine = tag.line;
-  const endLine = tag.line + tag.fullMatch.split("\n").length - 1;
-  return fileLines.slice(startLine - 1, endLine).join("\n");
-}
-function stripPrefix(str, prefix) {
-  if (!prefix) return str;
-  if (str.startsWith(prefix)) {
-    if (!prefix.endsWith(".")) {
-      prefix += ".";
-    }
-    return str.slice(prefix.length);
-  }
-  return str;
-}
-function getErrorLineNumbers(code, nodes) {
-  const errorLines = /* @__PURE__ */ new Set();
-  const lines = code.split("\n");
-  const errorNodes = nodes.filter((n) => n.type === "error");
-  for (const errorNode of errorNodes) {
-    let currentPos = 0;
-    for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
-      const lineLength = lines[lineIndex].length;
-      const lineEnd = currentPos + lineLength;
-      if (errorNode.start < lineEnd && errorNode.end > currentPos) {
-        errorLines.add(lineIndex);
-      }
-      currentPos = lineEnd + 1;
-    }
-  }
-  return errorLines;
-}
-async function logTagConflictInfo(tagInfo, prefix, conflictPath, translationArgPosition, condense) {
-  const { tag } = tagInfo;
-  const filePath = path.join(process.cwd(), tagInfo.relativeFilePath);
-  let lineNum = tagInfo.tag.line;
-  try {
-    const startLine = tag.line;
-    const wholeTagCode = await getLangTagCodeSection(tagInfo);
-    const translationTagCode = translationArgPosition === 1 ? tag.parameter1Text : tag.parameter2Text;
-    const configTagCode = translationArgPosition === 1 ? tag.parameter2Text : tag.parameter1Text;
-    const translationErrorPath = stripPrefix(conflictPath, tag.parameterConfig?.path);
-    let colorizedWhole = wholeTagCode;
-    let errorLines = /* @__PURE__ */ new Set();
-    if (translationTagCode) {
-      try {
-        const translationNodes = parseObjectAST(translationTagCode);
-        const markedTranslationNodes = translationErrorPath ? markConflictNodes(translationNodes, translationErrorPath) : translationNodes;
-        const translationErrorLines = getErrorLineNumbers(translationTagCode, markedTranslationNodes);
-        const translationStartInWhole = wholeTagCode.indexOf(translationTagCode);
-        if (translationStartInWhole >= 0) {
-          const linesBeforeTranslation = wholeTagCode.substring(0, translationStartInWhole).split("\n").length - 1;
-          translationErrorLines.forEach((lineNum2) => {
-            errorLines.add(linesBeforeTranslation + lineNum2);
-          });
-          if (translationErrorLines.size > 0) {
-            const lastTranslationErrorLine = Math.max(...Array.from(translationErrorLines));
-            lineNum = startLine + linesBeforeTranslation + lastTranslationErrorLine;
-          }
-        }
-        const colorizedTranslation = colorizeFromAST(translationTagCode, markedTranslationNodes);
-        colorizedWhole = colorizedWhole.replace(translationTagCode, colorizedTranslation);
-      } catch (error) {
-        console.error("Failed to colorize translation:", error);
-      }
-    }
-    if (configTagCode) {
-      try {
-        const configNodes = parseObjectAST(configTagCode);
-        let pathKeyFound = false;
-        const markedConfigNodes = configNodes.map((node, index) => {
-          if (node.type === "key" && node.value === "path") {
-            pathKeyFound = true;
-            return node;
-          }
-          if (pathKeyFound && node.type === "value") {
-            if (conflictPath.startsWith(node.value + ".")) {
-              pathKeyFound = false;
-              return { ...node, type: "error" };
-            }
-          }
-          return node;
-        });
-        const configErrorLines = getErrorLineNumbers(configTagCode, markedConfigNodes);
-        const configStartInWhole = wholeTagCode.indexOf(configTagCode);
-        if (configStartInWhole >= 0) {
-          const linesBeforeConfig = wholeTagCode.substring(0, configStartInWhole).split("\n").length - 1;
-          configErrorLines.forEach((lineNum2) => {
-            errorLines.add(linesBeforeConfig + lineNum2);
-          });
-        }
-        const colorizedConfig = colorizeFromAST(configTagCode, markedConfigNodes);
-        colorizedWhole = colorizedWhole.replace(configTagCode, colorizedConfig);
-      } catch (error) {
-        console.error("Failed to colorize config:", error);
-      }
-    }
-    console.log(`${ANSI.gray}${prefix}${ANSI.reset} ${ANSI.cyan}file://${filePath}${ANSI.reset}${ANSI.gray}:${lineNum}${ANSI.reset}`);
-    printLines(colorizedWhole.split("\n"), startLine, errorLines, condense);
-  } catch (error) {
-    console.error("Error displaying conflict:", error);
-  }
-}
-async function $LT_LogConflict(conflict, translationArgPosition, condense) {
-  const { path: conflictPath, tagA, tagB } = conflict;
-  await logTagConflictInfo(tagA, "between", conflictPath, translationArgPosition, condense);
-  await logTagConflictInfo(tagB, "and", conflictPath, translationArgPosition, condense);
-}
-const ANSI_COLORS = {
-  reset: "\x1B[0m",
-  white: "\x1B[37m",
-  blue: "\x1B[34m",
-  green: "\x1B[32m",
-  yellow: "\x1B[33m",
-  red: "\x1B[31m",
-  gray: "\x1B[90m",
-  bold: "\x1B[1m",
-  cyan: "\x1B[36m"
-};
-function validateAndInterpolate(message, params) {
-  const placeholders = Array.from(message.matchAll(/\{(\w+)\}/g)).map((m) => m[1]);
-  const missing = placeholders.filter((p) => !(p in (params || {})));
-  if (missing.length) {
-    throw new Error(`Missing variables in message: ${missing.join(", ")}`);
-  }
-  const extra = params ? Object.keys(params).filter((k) => !placeholders.includes(k)) : [];
-  if (extra.length) {
-    throw new Error(`Extra variables provided not used in message: ${extra.join(", ")}`);
-  }
-  const parts = [];
-  let lastIndex = 0;
-  for (const match of message.matchAll(/\{(\w+)\}/g)) {
-    const [fullMatch, key] = match;
-    const index = match.index;
-    if (index > lastIndex) {
-      parts.push({ text: message.slice(lastIndex, index), isVar: false });
-    }
-    parts.push({ text: String(params[key]), isVar: true });
-    lastIndex = index + fullMatch.length;
-  }
-  if (lastIndex < message.length) {
-    parts.push({ text: message.slice(lastIndex), isVar: false });
-  }
-  return parts;
-}
-function log(baseColor, message, params) {
-  const parts = validateAndInterpolate(message, params);
-  const coloredMessage = parts.map(
-    (p) => p.isVar ? `${ANSI_COLORS.bold}${ANSI_COLORS.white}${p.text}${ANSI_COLORS.reset}${baseColor}` : p.text
-  ).join("");
-  const now = /* @__PURE__ */ new Date();
-  const time = `${now.getHours().toString().padStart(2, "0")}:${now.getMinutes().toString().padStart(2, "0")}:${now.getSeconds().toString().padStart(2, "0")}`;
-  const prefix = (
-    // Static colored "LangTag" prefix
-    //`${ANSI_COLORS.bold}${ANSI_COLORS.cyan}LangTag${ANSI_COLORS.reset} ` +
-    // Time
-    `${ANSI_COLORS.gray}[${time}]${ANSI_COLORS.reset} `
-  );
-  console.log(`${prefix}${baseColor}${coloredMessage}${ANSI_COLORS.reset}`);
-}
-function $LT_CreateDefaultLogger(debugMode, translationArgPosition = 1) {
-  return {
-    info: (msg, params) => log(ANSI_COLORS.blue, msg, params),
-    success: (msg, params) => log(ANSI_COLORS.green, msg, params),
-    warn: (msg, params) => log(ANSI_COLORS.yellow, msg, params),
-    error: (msg, params) => log(ANSI_COLORS.red, msg || "empty error message", params),
-    debug: (msg, params) => {
-      if (!debugMode) return;
-      log(ANSI_COLORS.gray, msg, params);
-    },
-    conflict: async (conflict, condense) => {
-      const { path: path2, conflictType, tagA } = conflict;
-      console.log();
-      console.log(`${ANSI_COLORS.bold}${ANSI_COLORS.red}⚠ Translation Conflict Detected${ANSI_COLORS.reset}`);
-      console.log(`${ANSI_COLORS.gray}${"─".repeat(60)}${ANSI_COLORS.reset}`);
-      console.log(`  ${ANSI_COLORS.cyan}Conflict Type:${ANSI_COLORS.reset} ${ANSI_COLORS.white}${conflictType}${ANSI_COLORS.reset}`);
-      console.log(`  ${ANSI_COLORS.cyan}Translation Key:${ANSI_COLORS.reset} ${ANSI_COLORS.white}${path2}${ANSI_COLORS.reset}`);
-      console.log(`  ${ANSI_COLORS.cyan}Namespace:${ANSI_COLORS.reset} ${ANSI_COLORS.white}${tagA.tag.parameterConfig.namespace}${ANSI_COLORS.reset}`);
-      console.log(`${ANSI_COLORS.gray}${"─".repeat(60)}${ANSI_COLORS.reset}`);
-      await $LT_LogConflict(conflict, translationArgPosition, condense);
-      console.log();
-    }
-  };
-}
-async function $LT_GetCommandEssentials() {
-  const config = await $LT_ReadConfig(process__default.cwd());
-  const logger = $LT_CreateDefaultLogger(config.debug, config.translationArgPosition);
-  return {
-    config,
-    logger
-  };
-}
-async function $LT_CMD_RegenerateTags() {
-  const { config, logger } = await $LT_GetCommandEssentials();
-  const files = await globby(config.includes, {
-    cwd: process.cwd(),
-    ignore: config.excludes,
-    absolute: true
-  });
-  const charactersToSkip = process.cwd().length + 1;
-  let dirty = false;
-  for (const file of files) {
-    const path2 = file.substring(charactersToSkip);
-    const localDirty = await checkAndRegenerateFileLangTags(config, logger, file, path2);
-    if (localDirty) {
-      logger.info('Lang tag configurations written for file "{path}"', { path: path2 });
-      dirty = true;
-    }
-  }
-  if (!dirty) {
-    logger.info("No changes were made based on the current configuration and files");
-  }
-}
-function deepMergeTranslations(target, source) {
-  if (typeof target !== "object") {
-    throw new Error("Target must be an object");
-  }
-  if (typeof source !== "object") {
-    throw new Error("Source must be an object");
-  }
-  let changed = false;
-  for (const key in source) {
-    if (!source.hasOwnProperty(key)) {
-      continue;
-    }
-    let targetValue = target[key];
-    const sourceValue = source[key];
-    if (typeof targetValue === "string" && typeof sourceValue === "object") {
-      throw new Error(`Trying to write object into target key "${key}" which is translation already`);
-    }
-    if (Array.isArray(sourceValue)) {
-      throw new Error(`Trying to write array into target key "${key}", we do not allow arrays inside translations`);
-    }
-    if (typeof sourceValue === "object") {
-      if (!targetValue) {
-        targetValue = {};
-        target[key] = targetValue;
-      }
-      if (deepMergeTranslations(targetValue, sourceValue)) {
-        changed = true;
-      }
-    } else {
-      if (target[key] !== sourceValue) {
-        changed = true;
-      }
-      target[key] = sourceValue;
-    }
-  }
-  return changed;
-}
-async function $LT_WriteToNamespaces({ config, namespaces, logger, clean }) {
-  const changedNamespaces = [];
-  if (clean) {
-    logger.info("Cleaning output directory...");
-    await $LT_RemoveDirectory(config.outputDir);
-  }
-  await $LT_EnsureDirectoryExists(config.outputDir);
-  for (let namespace of Object.keys(namespaces)) {
-    if (!namespace) {
-      continue;
-    }
-    const filePath = resolve(
-      process__default.cwd(),
-      config.outputDir,
-      namespace + ".json"
-    );
-    let originalJSON = {};
-    try {
-      originalJSON = await $LT_ReadJSON(filePath);
-    } catch (e) {
-      if (!clean) {
-        logger.warn(`Original namespace file "{namespace}.json" not found. A new one will be created.`, { namespace });
-      }
-    }
-    if (deepMergeTranslations(originalJSON, namespaces[namespace])) {
-      changedNamespaces.push(namespace);
-      await $LT_WriteJSON(filePath, originalJSON);
-    }
-  }
-  return changedNamespaces;
-}
-async function $LT_CollectCandidateFilesWithTags(props) {
-  const { config, logger } = props;
-  const processor = new $LT_TagProcessor(config);
-  const cwd = process__default.cwd();
-  let filesToScan = props.filesToScan;
-  if (!filesToScan) {
-    filesToScan = await globby(config.includes, { cwd, ignore: config.excludes, absolute: true });
-  }
-  const candidates = [];
-  for (const filePath of filesToScan) {
-    const fileContent = readFileSync(filePath, "utf-8");
-    let tags = processor.extractTags(fileContent);
-    if (!tags.length) {
-      continue;
-    }
-    tags = $LT_FilterInvalidTags(tags, config, logger);
-    if (!tags.length) {
-      continue;
-    }
-    for (let tag of tags) {
-      tag.parameterConfig = config.collect.onCollectConfigFix({ config: tag.parameterConfig, langTagConfig: config });
-    }
-    tags = $LT_FilterEmptyNamespaceTags(tags, logger);
-    const relativeFilePath = path__default.relative(cwd, filePath);
-    candidates.push({ relativeFilePath, tags });
-  }
-  return candidates;
-}
-async function $LT_WriteAsExportFile({ config, logger, files }) {
-  const packageJson = await $LT_ReadJSON(path__default.resolve(process.cwd(), "package.json"));
-  if (!packageJson) {
-    throw new Error("package.json not found");
-  }
-  const langTagFiles = {};
-  for (const file of files) {
-    langTagFiles[file.relativeFilePath] = {
-      matches: file.tags.map((tag) => {
-        let T = config.translationArgPosition === 1 ? tag.parameter1Text : tag.parameter2Text;
-        let C = config.translationArgPosition === 1 ? tag.parameter2Text : tag.parameter1Text;
-        if (!T) T = "{}";
-        if (!C) C = "{}";
-        return {
-          translations: T,
-          config: C,
-          variableName: tag.variableName
-        };
-      })
-    };
-  }
-  const data = {
-    language: config.language,
-    packageName: packageJson.name || "",
-    files: langTagFiles
-  };
-  await $LT_WriteJSON(EXPORTS_FILE_NAME, data);
-  logger.success(`Written {file}`, { file: EXPORTS_FILE_NAME });
-}
-async function $LT_GroupTagsToNamespaces({ logger, files, config }) {
-  let totalTags = 0;
-  const namespaces = {};
-  function getTranslations(namespace) {
-    const namespaceTranslations = namespaces[namespace] || {};
-    if (!(namespace in namespaces)) {
-      namespaces[namespace] = namespaceTranslations;
-    }
-    return namespaceTranslations;
-  }
-  const allConflicts = [];
-  const existingValuesByNamespace = /* @__PURE__ */ new Map();
-  for (const file of files) {
-    totalTags += file.tags.length;
-    for (const tag of file.tags) {
-      const tagConfig = tag.parameterConfig;
-      const namespaceTranslations = getTranslations(tagConfig.namespace);
-      let existingValues = existingValuesByNamespace.get(tagConfig.namespace);
-      if (!existingValues) {
-        existingValues = /* @__PURE__ */ new Map();
-        existingValuesByNamespace.set(tagConfig.namespace, existingValues);
-      }
-      const valueTracker = {
-        get: (path2) => existingValues.get(path2),
-        trackValue: (path2, value) => {
-          existingValues.set(path2, { tag, relativeFilePath: file.relativeFilePath, value });
-        }
-      };
-      const addConflict = async (path2, tagA, tagBValue, conflictType) => {
-        if (conflictType === "path_overwrite" && config.collect?.ignoreConflictsWithMatchingValues !== false && tagA.value === tagBValue) {
-          return;
-        }
-        const conflict = {
-          path: path2,
-          tagA,
-          tagB: {
-            tag,
-            relativeFilePath: file.relativeFilePath,
-            value: tagBValue
-          },
-          conflictType
-        };
-        if (config.collect?.onConflictResolution) {
-          let shouldContinue = true;
-          await config.collect.onConflictResolution({
-            conflict,
-            logger,
-            exit() {
-              shouldContinue = false;
-            }
-          });
-          if (!shouldContinue) {
-            throw new Error(`LangTagConflictResolution:Processing stopped due to conflict resolution: ${conflict.tagA.tag.parameterConfig.namespace}|${conflict.path}`);
-          }
-        }
-        allConflicts.push(conflict);
-      };
-      const target = await ensureNestedObject(
-        tagConfig.path,
-        namespaceTranslations,
-        valueTracker,
-        addConflict
-      );
-      await mergeWithConflictDetection(
-        target,
-        tag.parameterTranslations,
-        tagConfig.path || "",
-        valueTracker,
-        addConflict
-      );
-    }
-  }
-  if (allConflicts.length > 0) {
-    logger.warn(`Found ${allConflicts.length} conflicts.`);
-    if (config.collect?.onCollectFinish) {
-      let shouldContinue = true;
-      config.collect.onCollectFinish({
-        conflicts: allConflicts,
-        logger,
-        exit() {
-          shouldContinue = false;
-        }
-      });
-      if (!shouldContinue) {
-        throw new Error(`LangTagConflictResolution:Processing stopped due to collect finish handler`);
-      }
-    }
-  }
-  return namespaces;
-}
-async function ensureNestedObject(path2, root, valueTracker, addConflict) {
-  if (!path2 || !path2.trim()) return root;
-  let current = root;
-  let currentPath = "";
-  for (const key of path2.split(".")) {
-    currentPath = currentPath ? `${currentPath}.${key}` : key;
-    if (current[key] !== void 0 && typeof current[key] !== "object") {
-      const existingInfo = valueTracker.get(currentPath);
-      if (existingInfo) {
-        await addConflict(currentPath, existingInfo, {}, "type_mismatch");
-      }
-      return current;
-    }
-    current[key] = current[key] || {};
-    current = current[key];
-  }
-  return current;
-}
-async function mergeWithConflictDetection(target, source, basePath = "", valueTracker, addConflict) {
-  if (typeof target !== "object" || typeof source !== "object") {
-    return;
-  }
-  for (const key in source) {
-    if (!source.hasOwnProperty(key)) {
-      continue;
-    }
-    const currentPath = basePath ? `${basePath}.${key}` : key;
-    let targetValue = target[key];
-    const sourceValue = source[key];
-    if (Array.isArray(sourceValue)) {
-      continue;
-    }
-    if (targetValue !== void 0) {
-      const targetType = typeof targetValue;
-      const sourceType = typeof sourceValue;
-      let existingInfo = valueTracker.get(currentPath);
-      if (!existingInfo && targetType === "object" && targetValue !== null && !Array.isArray(targetValue)) {
-        const findNestedInfo = (obj, prefix) => {
-          for (const key2 in obj) {
-            const path2 = prefix ? `${prefix}.${key2}` : key2;
-            const info = valueTracker.get(path2);
-            if (info) {
-              return info;
-            }
-            if (typeof obj[key2] === "object" && obj[key2] !== null && !Array.isArray(obj[key2])) {
-              const nestedInfo = findNestedInfo(obj[key2], path2);
-              if (nestedInfo) {
-                return nestedInfo;
-              }
-            }
-          }
-          return void 0;
-        };
-        existingInfo = findNestedInfo(targetValue, currentPath);
-      }
-      if (targetType !== sourceType) {
-        if (existingInfo) {
-          await addConflict(currentPath, existingInfo, sourceValue, "type_mismatch");
-        }
-        continue;
-      }
-      if (targetType !== "object") {
-        if (existingInfo) {
-          await addConflict(currentPath, existingInfo, sourceValue, "path_overwrite");
-        }
-        if (targetValue !== sourceValue) {
-          continue;
-        }
-      }
-    }
-    if (typeof sourceValue === "object" && sourceValue !== null && !Array.isArray(sourceValue)) {
-      if (!targetValue) {
-        targetValue = {};
-        target[key] = targetValue;
-      }
-      await mergeWithConflictDetection(
-        targetValue,
-        sourceValue,
-        currentPath,
-        valueTracker,
-        addConflict
-      );
-    } else {
-      target[key] = sourceValue;
-      valueTracker.trackValue(currentPath, sourceValue);
-    }
-  }
-}
-async function $LT_CMD_Collect(options) {
-  const { config, logger } = await $LT_GetCommandEssentials();
-  logger.info("Collecting translations from source files...");
-  const files = await $LT_CollectCandidateFilesWithTags({ config, logger });
-  if (config.isLibrary) {
-    await $LT_WriteAsExportFile({ config, logger, files });
-    return;
-  }
-  try {
-    const namespaces = await $LT_GroupTagsToNamespaces({ logger, files, config });
-    const totalTags = files.reduce((sum, file) => sum + file.tags.length, 0);
-    logger.debug("Found {totalTags} translation tags", { totalTags });
-    const changedNamespaces = await $LT_WriteToNamespaces({ config, namespaces, logger, clean: options?.clean });
-    if (!changedNamespaces?.length) {
-      logger.info("No changes were made based on the current configuration and files");
-      return;
-    }
-    const n = changedNamespaces.map((n2) => `"${n2}.json"`).join(", ");
-    logger.success("Updated namespaces {outputDir} ({namespaces})", {
-      outputDir: config.outputDir,
-      namespaces: n
-    });
-  } catch (e) {
-    const prefix = "LangTagConflictResolution:";
-    if (e.message.startsWith(prefix)) {
-      logger.error(e.message.substring(prefix.length));
-      return;
-    }
-    throw e;
-  }
-}
-function getBasePath(pattern) {
-  const globStartIndex = pattern.indexOf("*");
-  const braceStartIndex = pattern.indexOf("{");
-  let endIndex = -1;
-  if (globStartIndex !== -1 && braceStartIndex !== -1) {
-    endIndex = Math.min(globStartIndex, braceStartIndex);
-  } else if (globStartIndex !== -1) {
-    endIndex = globStartIndex;
-  } else if (braceStartIndex !== -1) {
-    endIndex = braceStartIndex;
-  }
-  if (endIndex === -1) {
-    const lastSlashIndex = pattern.lastIndexOf("/");
-    return lastSlashIndex !== -1 ? pattern.substring(0, lastSlashIndex) : ".";
-  }
-  const lastSeparatorIndex = pattern.lastIndexOf("/", endIndex);
-  return lastSeparatorIndex === -1 ? "." : pattern.substring(0, lastSeparatorIndex);
-}
-function $LT_CreateChokidarWatcher(config) {
-  const cwd = process.cwd();
-  const baseDirsToWatch = [
-    ...new Set(config.includes.map((pattern) => getBasePath(pattern)))
-  ];
-  const finalDirsToWatch = baseDirsToWatch.map((dir) => dir === "." ? cwd : dir);
-  const ignored = [...config.excludes, "**/.git/**"];
-  return chokidar.watch(finalDirsToWatch, {
-    // Watch base directories
-    cwd,
-    ignored,
-    persistent: true,
-    ignoreInitial: true,
-    awaitWriteFinish: {
-      stabilityThreshold: 300,
-      pollInterval: 100
-    }
-  });
-}
-async function $LT_WatchTranslations() {
-  const { config, logger } = await $LT_GetCommandEssentials();
-  await $LT_CMD_Collect();
-  const watcher = $LT_CreateChokidarWatcher(config);
-  logger.info("Starting watch mode for translations...");
-  logger.info("Watching for changes...");
-  logger.info("Press Ctrl+C to stop watching");
-  watcher.on("change", async (filePath) => await handleFile(config, logger, filePath)).on("add", async (filePath) => await handleFile(config, logger, filePath)).on("error", (error) => {
-    logger.error("Error in file watcher: {error}", { error });
-  });
-}
-async function handleFile(config, logger, cwdRelativeFilePath, event) {
-  if (!micromatch.isMatch(cwdRelativeFilePath, config.includes)) {
-    return;
-  }
-  const cwd = process.cwd();
-  const absoluteFilePath = path__default.join(cwd, cwdRelativeFilePath);
-  const dirty = await checkAndRegenerateFileLangTags(config, logger, absoluteFilePath, cwdRelativeFilePath);
-  if (dirty) {
-    logger.info(`Lang tag configurations written for file "{filePath}"`, { filePath: cwdRelativeFilePath });
-  }
-  const files = await $LT_CollectCandidateFilesWithTags({ filesToScan: [cwdRelativeFilePath], config, logger });
-  const namespaces = await $LT_GroupTagsToNamespaces({ logger, files, config });
-  const changedNamespaces = await $LT_WriteToNamespaces({ config, namespaces, logger });
-  if (changedNamespaces.length > 0) {
-    const n = changedNamespaces.map((n2) => `"${n2}.json"`).join(", ");
-    logger.success("Updated namespaces {outputDir} ({namespaces})", {
-      outputDir: config.outputDir,
-      namespaces: n
-    });
-  }
-}
-async function detectModuleSystem() {
-  const packageJsonPath = join(process.cwd(), "package.json");
-  if (!existsSync(packageJsonPath)) {
-    return "cjs";
-  }
-  try {
-    const content = await readFile(packageJsonPath, "utf-8");
-    const packageJson = JSON.parse(content);
-    if (packageJson.type === "module") {
-      return "esm";
-    }
-    return "cjs";
-  } catch (error) {
-    return "cjs";
-  }
-}
-function getExportStatement(moduleSystem) {
-  return moduleSystem === "esm" ? "export default config;" : "module.exports = config;";
-}
-async function generateDefaultConfig() {
-  const moduleSystem = await detectModuleSystem();
-  const exportStatement = getExportStatement(moduleSystem);
-  return `/** @type {import('lang-tag/cli/config').LangTagCLIConfig} */
-const config = {
-    tagName: 'lang',
-    isLibrary: false,
-    includes: ['src/**/*.{js,ts,jsx,tsx}'],
-    excludes: ['node_modules', 'dist', 'build', '**/*.test.ts'],
-    outputDir: 'public/locales/en',
-    onConfigGeneration: (params) => {
-        // We do not modify imported configurations
-        if (params.isImportedLibrary) return undefined;
-
-        //if (!params.config.path) {
-        //    params.config.path = 'test';
-        //    params.config.namespace = 'testNamespace';
-        //}
-
-        return undefined
-    },
-    collect: {
-        defaultNamespace: 'common',
-        onConflictResolution: async event => {
-            await event.logger.conflict(event.conflict, true);
-            // By default, continue processing even if conflicts occur
-            // Call event.exit(); to terminate the process upon the first conflict
-        },
-        onCollectFinish: event => {
-            event.exit(); // Stop the process to avoid merging on conflict
-        }
-    },
-    translationArgPosition: 1,
-    debug: false,
-};
-
-${exportStatement}`;
-}
-async function $LT_CMD_InitConfig() {
-  const logger = $LT_CreateDefaultLogger();
-  if (existsSync(CONFIG_FILE_NAME)) {
-    logger.success("Configuration file already exists. Please remove the existing configuration file before creating a new default one");
-    return;
-  }
-  try {
-    const configContent = await generateDefaultConfig();
-    await writeFile(CONFIG_FILE_NAME, configContent, "utf-8");
-    logger.success("Configuration file created successfully");
-  } catch (error) {
-    logger.error(error?.message);
-  }
-}
-function $LT_CollectNodeModulesExportFilePaths(logger) {
-  const nodeModulesPath = path$1.join(process__default.cwd(), "node_modules");
-  if (!fs.existsSync(nodeModulesPath)) {
-    logger.error('"node_modules" directory not found');
-    return [];
-  }
-  function findExportJson(dir, depth = 0, maxDepth = 3) {
-    if (depth > maxDepth) return [];
-    let results = [];
-    try {
-      const files = fs.readdirSync(dir);
-      for (const file of files) {
-        const fullPath = path$1.join(dir, file);
-        const stat = fs.statSync(fullPath);
-        if (stat.isDirectory()) {
-          results = results.concat(findExportJson(fullPath, depth + 1, maxDepth));
-        } else if (file === EXPORTS_FILE_NAME) {
-          results.push(fullPath);
-        }
-      }
-    } catch (error) {
-      logger.error('Error reading directory "{dir}": {error}', {
-        dir,
-        error: String(error)
-      });
-    }
-    return results;
-  }
-  return findExportJson(nodeModulesPath);
-}
-async function $LT_ImportLibraries(config, logger) {
-  const files = $LT_CollectNodeModulesExportFilePaths(logger);
-  const generationFiles = {};
-  for (const filePath of files) {
-    const exportData = await $LT_ReadJSON(filePath);
-    for (let langTagFilePath in exportData.files) {
-      const fileGenerationData = {};
-      const matches = exportData.files[langTagFilePath].matches;
-      for (let match of matches) {
-        let parsedTranslations = typeof match.translations === "string" ? JSON5.parse(match.translations) : match.translations;
-        let parsedConfig = typeof match.config === "string" ? JSON5.parse(match.config) : match.config === void 0 ? {} : match.config;
-        let file = langTagFilePath;
-        let exportName = match.variableName || "";
-        config.import.onImport({
-          packageName: exportData.packageName,
-          importedRelativePath: langTagFilePath,
-          originalExportName: match.variableName,
-          translations: parsedTranslations,
-          config: parsedConfig,
-          fileGenerationData
-        }, {
-          setFile: (f) => {
-            file = f;
-          },
-          setExportName: (name) => {
-            exportName = name;
-          },
-          setConfig: (newConfig) => {
-            parsedConfig = newConfig;
-          }
-        });
-        if (!file || !exportName) {
-          throw new Error(`[lang-tag] onImport did not set fileName or exportName for package: ${exportData.packageName}, file: '${file}' (original: '${langTagFilePath}'), exportName: '${exportName}' (original: ${match.variableName})`);
-        }
-        let exports = generationFiles[file];
-        if (!exports) {
-          exports = {};
-          generationFiles[file] = exports;
-        }
-        const param1 = config.translationArgPosition === 1 ? parsedTranslations : parsedConfig;
-        const param2 = config.translationArgPosition === 1 ? parsedConfig : parsedTranslations;
-        exports[exportName] = `${config.tagName}(${JSON5.stringify(param1, void 0, 4)}, ${JSON5.stringify(param2, void 0, 4)})`;
-      }
-    }
-  }
-  for (let fileName of Object.keys(generationFiles)) {
-    const filePath = resolve(
-      process$1.cwd(),
-      config.import.dir,
-      fileName
-    );
-    const exports = Object.entries(generationFiles[fileName]).map(([name, tag]) => {
-      return `export const ${name} = ${tag};`;
-    }).join("\n\n");
-    const content = `${config.import.tagImportPath}
-
-${exports}`;
-    await $LT_EnsureDirectoryExists(dirname$1(filePath));
-    await writeFile(filePath, content, "utf-8");
-    logger.success('Imported node_modules file: "{fileName}"', { fileName });
-  }
-  if (config.import.onImportFinish) config.import.onImportFinish();
-}
-async function $LT_ImportTranslations() {
-  const { config, logger } = await $LT_GetCommandEssentials();
-  await $LT_EnsureDirectoryExists(config.import.dir);
-  logger.info("Importing translations from libraries...");
-  await $LT_ImportLibraries(config, logger);
-  logger.success("Successfully imported translations from libraries.");
-}
-function renderTemplate(template, data) {
-  return mustache.render(template, data, {}, { escape: (text) => text });
-}
-function loadTemplate(templateName) {
-  const __filename = fileURLToPath(import.meta.url);
-  const __dirname = dirname(__filename);
-  const templatePath = join(__dirname, "template", `${templateName}.mustache`);
-  try {
-    return readFileSync(templatePath, "utf-8");
-  } catch (error) {
-    throw new Error(`Failed to load template ${templateName}: ${error}`);
-  }
-}
-function prepareTemplateData(options) {
-  return {
-    ...options,
-    tmpVariables: {
-      key: "{{key}}",
-      username: "{{username}}",
-      processRegex: "{{(.*?)}}"
-    }
-  };
-}
-function renderInitTagTemplates(options) {
-  const baseTemplateName = options.isLibrary ? "base-library" : "base-app";
-  const baseTemplate = loadTemplate(baseTemplateName);
-  const placeholderTemplate = loadTemplate("placeholder");
-  const templateData = prepareTemplateData(options);
-  const renderedBase = renderTemplate(baseTemplate, templateData);
-  const renderedPlaceholders = renderTemplate(placeholderTemplate, templateData);
-  return renderedBase + "\n\n" + renderedPlaceholders;
-}
-async function readPackageJson() {
-  const packageJsonPath = join(process.cwd(), "package.json");
-  if (!existsSync(packageJsonPath)) {
-    return null;
-  }
-  try {
-    const content = await readFile(packageJsonPath, "utf-8");
-    return JSON.parse(content);
-  } catch (error) {
-    return null;
-  }
-}
-function detectTypeScript(packageJson) {
-  if (!packageJson) return false;
-  const hasTypeScript = packageJson.devDependencies?.typescript || packageJson.dependencies?.typescript;
-  const hasTsConfig = existsSync(join(process.cwd(), "tsconfig.json"));
-  return Boolean(hasTypeScript || hasTsConfig);
-}
-function detectReact(packageJson) {
-  if (!packageJson) return false;
-  return Boolean(
-    packageJson.dependencies?.react || packageJson.devDependencies?.react || packageJson.dependencies?.["@types/react"] || packageJson.devDependencies?.["@types/react"]
-  );
-}
-async function detectInitTagOptions(options, config) {
-  const packageJson = await readPackageJson();
-  const isTypeScript = options.typescript !== void 0 ? options.typescript : detectTypeScript(packageJson);
-  const isReact = options.react !== void 0 ? options.react : detectReact(packageJson);
-  const isLibrary = options.library !== void 0 ? options.library : config.isLibrary;
-  const tagName = options.name || config.tagName || "lang";
-  const fileExtension = isLibrary && isReact ? isTypeScript ? "tsx" : "jsx" : isTypeScript ? "ts" : "js";
-  return {
-    tagName,
-    isLibrary,
-    isReact,
-    isTypeScript,
-    fileExtension,
-    packageName: packageJson?.name || "my-project",
-    packageVersion: packageJson?.version || "1.0.0"
-  };
-}
-async function $LT_CMD_InitTagFile(options = {}) {
-  const { config, logger } = await $LT_GetCommandEssentials();
-  const renderOptions = await detectInitTagOptions(options, config);
-  const outputPath = options.output || `${renderOptions.tagName}.${renderOptions.fileExtension}`;
-  logger.info("Initializing lang-tag with the following options:");
-  logger.info("  Tag name: {tagName}", { tagName: renderOptions.tagName });
-  logger.info("  Library mode: {isLibrary}", { isLibrary: renderOptions.isLibrary ? "Yes" : "No" });
-  logger.info("  React: {isReact}", { isReact: renderOptions.isReact ? "Yes" : "No" });
-  logger.info("  TypeScript: {isTypeScript}", { isTypeScript: renderOptions.isTypeScript ? "Yes" : "No" });
-  logger.info("  Output path: {outputPath}", { outputPath });
-  let renderedContent;
-  try {
-    renderedContent = renderInitTagTemplates(renderOptions);
-  } catch (error) {
-    logger.error("Failed to render templates: {error}", { error: error?.message });
-    return;
-  }
-  if (existsSync(outputPath)) {
-    logger.warn("File already exists: {outputPath}", { outputPath });
-    logger.info("Use --output to specify a different path or remove the existing file");
-    return;
-  }
-  try {
-    await $LT_WriteFileWithDirs(outputPath, renderedContent);
-    logger.success("Lang-tag file created successfully: {outputPath}", { outputPath });
-    logger.info("Next steps:");
-    logger.info("1. Import the {tagName} function in your files:", { tagName: renderOptions.tagName });
-    logger.info("   import { {tagName} } from './{importPath}';", {
-      tagName: renderOptions.tagName,
-      importPath: outputPath.replace(/^src\//, "")
-    });
-    logger.info("2. Create your translation objects and use the tag function");
-    logger.info('3. Run "lang-tag collect" to extract translations');
-  } catch (error) {
-    logger.error("Failed to write file: {error}", { error: error?.message });
-  }
-}
-function createCli() {
-  program.name("lang-tag").description("CLI to manage language translations").version("0.1.0");
-  program.command("collect").alias("c").description("Collect translations from source files").option("-c, --clean", "Remove output directory before collecting").action($LT_CMD_Collect);
-  program.command("import").alias("i").description("Import translations from libraries in node_modules").action($LT_ImportTranslations);
-  program.command("regenerate-tags").alias("rt").description("Regenerate configuration for language tags").action($LT_CMD_RegenerateTags);
-  program.command("watch").alias("w").description("Watch for changes in source files and automatically collect translations").action($LT_WatchTranslations);
-  program.command("init").description("Initialize project with default configuration").action($LT_CMD_InitConfig);
-  program.command("init-tag").description("Initialize a new lang-tag function file").option("-n, --name <name>", "Name of the tag function (default: from config)").option("-l, --library", "Generate library-style tag (default: from config)").option("-r, --react", "Include React-specific optimizations (default: auto-detect)").option("-t, --typescript", "Force TypeScript output (default: auto-detect)").option("-o, --output <path>", "Output file path (default: auto-generated)").action(async (options) => {
-    await $LT_CMD_InitTagFile(options);
-  });
-  return program;
-}
-createCli().parse();
-export {
-  createCli
-};