@lang-tag/cli 0.15.0 → 0.17.0

package/index.js

@@ -1,20 +1,73 @@
 #!/usr/bin/env node
 import { program } from "commander";
+import * as process$1 from "node:process";
+import process__default from "node:process";
 import fs, { readFileSync, existsSync } from "fs";
-import { writeFile, readFile } from "fs/promises";
-import JSON5 from "json5";
-import * as path from "path";
-import path__default, { sep, join, dirname as dirname$1 } from "path";
 import { globby } from "globby";
-import path$1, { resolve, dirname } from "pathe";
+import * as path from "path";
+import path__default, { dirname, resolve, join, sep } from "path";
+import JSON5 from "json5";
+import { mkdir, writeFile, readFile } from "fs/promises";
+import path$1, { resolve as resolve$1 } from "pathe";
 import { pathToFileURL, fileURLToPath } from "url";
-import { N as NamespaceCollector, $ as $LT_ReadFileContent, a as $LT_ReadJSON, b as $LT_WriteJSON, c as $LT_EnsureDirectoryExists, d as $LT_WriteFileWithDirs } from "./namespace-collector-DCruv_PK.js";
-import * as process$1 from "node:process";
-import process__default from "node:process";
-import * as acorn from "acorn";
+import "case";
+import { N as NamespaceCollector } from "./chunks/namespace-collector.js";
 import micromatch from "micromatch";
-import chokidar from "chokidar";
+import * as acorn from "acorn";
 import mustache from "mustache";
+import chokidar from "chokidar";
+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;
+  });
+}
 class $LT_TagProcessor {
   constructor(config) {
     this.config = config;
@@ -25,7 +78,10 @@ class $LT_TagProcessor {
     const matches = [];
     let currentIndex = 0;
     const skipRanges = this.buildSkipRanges(fileContent);
-    const startPattern = new RegExp(`${optionalVariableAssignment}${tagName}\\(\\s*\\{`, "g");
+    const startPattern = new RegExp(
+      `${optionalVariableAssignment}${tagName}\\(\\s*\\{`,
+      "g"
+    );
     while (true) {
       startPattern.lastIndex = currentIndex;
       const startMatch = startPattern.exec(fileContent);
@@ -47,7 +103,10 @@ class $LT_TagProcessor {
         currentIndex = matchStartIndex + 1;
         continue;
       }
-      let parameter1Text = fileContent.substring(matchStartIndex + startMatch[0].length - 1, i);
+      let parameter1Text = fileContent.substring(
+        matchStartIndex + startMatch[0].length - 1,
+        i
+      );
       let parameter2Text;
       while (i < fileContent.length && (fileContent[i] === " " || fileContent[i] === "\n" || fileContent[i] === "	")) {
         i++;
@@ -99,7 +158,10 @@ class $LT_TagProcessor {
       }
       i++;
       const fullMatch = fileContent.substring(matchStartIndex, i);
-      const { line, column } = getLineAndColumn(fileContent, matchStartIndex);
+      const { line, column } = getLineAndColumn(
+        fileContent,
+        matchStartIndex
+      );
       let validity = "ok";
       let parameter1 = void 0;
       let parameter2 = void 0;
@@ -114,7 +176,9 @@ class $LT_TagProcessor {
             parameter2 = JSON5.parse(parameter2Text);
           } catch (error) {
             try {
-              parameter2 = JSON5.parse(this.escapeNewlinesInStrings(parameter2Text));
+              parameter2 = JSON5.parse(
+                this.escapeNewlinesInStrings(parameter2Text)
+              );
             } catch {
               validity = "invalid-param-2";
             }
@@ -122,7 +186,9 @@ class $LT_TagProcessor {
         }
       } catch (error) {
         try {
-          parameter1 = JSON5.parse(this.escapeNewlinesInStrings(parameter1Text));
+          parameter1 = JSON5.parse(
+            this.escapeNewlinesInStrings(parameter1Text)
+          );
         } catch {
           validity = "invalid-param-1";
         }
@@ -156,22 +222,31 @@ class $LT_TagProcessor {
       }
       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!");
+      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}`);
+        throw new Error(
+          `Tag translations are invalid object! Translations: ${newTranslationsString}`
+        );
       }
       let newConfigString = R.config;
-      if (!newConfigString && newConfigString !== null) newConfigString = tag.parameterConfig;
+      if (!newConfigString && newConfigString !== null)
+        newConfigString = tag.parameterConfig;
       if (newConfigString) {
         try {
-          if (typeof newConfigString === "string") JSON5.parse(newConfigString);
+          if (typeof newConfigString === "string")
+            JSON5.parse(newConfigString);
           else newConfigString = JSON5.stringify(newConfigString);
         } catch (error) {
-          throw new Error(`Tag config is invalid object! Config: ${newConfigString}`);
+          throw new Error(
+            `Tag config is invalid object! Config: ${newConfigString}`
+          );
         }
       }
       if (newConfigString === null && this.config.translationArgPosition === 2) {
@@ -182,7 +257,8 @@ class $LT_TagProcessor {
       let tagFunction = `${this.config.tagName}(${arg1}`;
       if (arg2) tagFunction += `, ${arg2}`;
       tagFunction += ")";
-      if (tag.variableName) replaceMap.set(tag, ` ${tag.variableName} = ${tagFunction}`);
+      if (tag.variableName)
+        replaceMap.set(tag, ` ${tag.variableName} = ${tagFunction}`);
       else replaceMap.set(tag, tagFunction);
     });
     let offset = 0;
@@ -375,152 +451,447 @@ function getLineAndColumn(text, matchIndex) {
   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;
+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;
     }
-    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;
+    tags = $LT_FilterInvalidTags(tags, config, logger);
+    if (!tags.length) {
+      continue;
     }
-    return true;
-  });
-}
-function deepFreezeObject(obj) {
-  const propNames = Object.getOwnPropertyNames(obj);
-  for (const name of propNames) {
-    const value = obj[name];
-    if (value && typeof value === "object") {
-      deepFreezeObject(value);
+    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 Object.freeze(obj);
+  return candidates;
 }
-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;
+async function $LT_GroupTagsToCollections({
+  logger,
+  files,
+  config
+}) {
+  let totalTags = 0;
+  const collections = {};
+  function getTranslationsCollection(namespace) {
+    const collectionName = config.collect.collector.aggregateCollection(namespace);
+    const collection = collections[collectionName] || {};
+    if (!(collectionName in collections)) {
+      collections[collectionName] = collection;
+    }
+    return collection;
   }
-  const replacements = [];
-  let lastUpdatedLine = 0;
-  for (let tag of tags) {
-    let newConfig = void 0;
-    let shouldUpdate = false;
-    const frozenConfig = tag.parameterConfig ? deepFreezeObject(tag.parameterConfig) : tag.parameterConfig;
-    const event = {
-      langTagConfig: config,
-      config: frozenConfig,
-      absolutePath: file,
-      relativePath: path2,
-      isImportedLibrary: path2.startsWith(libraryImportsDir),
-      isSaved: false,
-      savedConfig: void 0,
-      save: (updatedConfig, triggerName) => {
-        if (!updatedConfig && updatedConfig !== null) throw new Error("Wrong config data");
-        newConfig = updatedConfig;
-        shouldUpdate = true;
-        event.isSaved = true;
-        event.savedConfig = updatedConfig;
-        logger.debug('Called save for "{path}" with config "{config}" triggered by: ("{trigger}")', { path: path2, config: JSON.stringify(updatedConfig), trigger: triggerName || "-" });
+  const allConflicts = [];
+  const existingValuesByNamespace = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    totalTags += file.tags.length;
+    for (const _tag of file.tags) {
+      const tag = config.collect.collector.transformTag(_tag);
+      const tagConfig = tag.parameterConfig;
+      const collection = getTranslationsCollection(tagConfig.namespace);
+      let existingValues = existingValuesByNamespace.get(
+        tagConfig.namespace
+      );
+      if (!existingValues) {
+        existingValues = /* @__PURE__ */ new Map();
+        existingValuesByNamespace.set(
+          tagConfig.namespace,
+          existingValues
+        );
       }
-    };
-    await config.onConfigGeneration(event);
-    if (!shouldUpdate) {
-      continue;
-    }
-    lastUpdatedLine = tag.line;
-    if (!isConfigSame(tag.parameterConfig, newConfig)) {
-      replacements.push({ tag, config: newConfig });
+      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,
+        collection,
+        valueTracker,
+        addConflict
+      );
+      await mergeWithConflictDetection(
+        target,
+        tag.parameterTranslations,
+        tagConfig.path || "",
+        valueTracker,
+        addConflict
+      );
     }
   }
-  if (replacements.length) {
-    const newContent = processor.replaceTags(fileContent, replacements);
-    await writeFile(file, newContent, "utf-8");
-    const encodedFile = encodeURI(file);
-    logger.info('Lang tag configurations written for file "{path}" (file://{file}:{line})', { path: path2, file: encodedFile, line: lastUpdatedLine });
-    return true;
+  if (allConflicts.length > 0) {
+    logger.warn(`Found ${allConflicts.length} conflicts.`);
   }
-  return false;
-}
-function isConfigSame(c1, c2) {
-  if (!c1 && !c2) return true;
-  if (c1 && typeof c1 === "object" && c2 && typeof c2 === "object" && JSON5.stringify(c1) === JSON5.stringify(c2)) 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",
-  isLibrary: false,
-  includes: ["src/**/*.{js,ts,jsx,tsx}"],
-  excludes: ["node_modules", "dist", "build"],
-  localesDirectory: "locales",
-  baseLanguageCode: "en",
-  collect: {
-    collector: new NamespaceCollector(),
-    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) => {
-      if (event.conflicts.length) 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}`);
+  if (config.collect?.onCollectFinish) {
+    let shouldContinue = true;
+    config.collect.onCollectFinish({
+      totalTags,
+      namespaces: collections,
+      conflicts: allConflicts,
+      logger,
+      exit() {
+        shouldContinue = false;
+      }
+    });
+    if (!shouldContinue) {
+      throw new Error(
+        `LangTagConflictResolution:Processing stopped due to collect finish handler`
+      );
     }
-  },
-  translationArgPosition: 1,
-  onConfigGeneration: async (event) => {
+  }
+  return collections;
+}
+async function ensureNestedObject(path2, rootCollection, valueTracker, addConflict) {
+  if (!path2 || !path2.trim()) return rootCollection;
+  let current = rootCollection;
+  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);
+    }
+  }
+}
+const CONFIG_FILE_NAME = "lang-tag.config.js";
+const EXPORTS_FILE_NAME = "lang-tags.json";
+async function $LT_EnsureDirectoryExists(filePath) {
+  await mkdir(filePath, { recursive: true });
+}
+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(cwd, relativeFilePath);
+  return await readFile(absolutePath, "utf-8");
+}
+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 exportData = {
+    baseLanguageCode: config.baseLanguageCode,
+    files: files.map(({ relativeFilePath, tags }) => ({
+      relativeFilePath,
+      tags: tags.map((tag) => ({
+        variableName: tag.variableName,
+        config: tag.parameterConfig,
+        translations: tag.parameterTranslations
+      }))
+    }))
+  };
+  await writeFile(EXPORTS_FILE_NAME, JSON.stringify(exportData), "utf-8");
+  logger.success(`Written {file}`, { file: EXPORTS_FILE_NAME });
+}
+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_WriteToCollections({
+  config,
+  collections,
+  logger,
+  clean
+}) {
+  await config.collect.collector.preWrite(clean);
+  const changedCollections = [];
+  for (let collectionName of Object.keys(collections)) {
+    if (!collectionName) {
+      continue;
+    }
+    const filePath = await config.collect.collector.resolveCollectionFilePath(
+      collectionName
+    );
+    let originalJSON = {};
+    try {
+      originalJSON = await $LT_ReadJSON(filePath);
+    } catch (e) {
+      await config.collect.collector.onMissingCollection(
+        collectionName
+      );
+    }
+    if (deepMergeTranslations(originalJSON, collections[collectionName])) {
+      changedCollections.push(collectionName);
+      await $LT_WriteJSON(filePath, originalJSON);
+    }
+  }
+  await config.collect.collector.postWrite(changedCollections);
+}
+const LANG_TAG_DEFAULT_CONFIG = {
+  tagName: "lang",
+  isLibrary: false,
+  includes: ["src/**/*.{js,ts,jsx,tsx}"],
+  excludes: ["node_modules", "dist", "build"],
+  localesDirectory: "locales",
+  baseLanguageCode: "en",
+  collect: {
+    collector: new NamespaceCollector(),
+    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) => {
+      if (event.conflicts.length) event.exit();
+    }
+  },
+  import: {
+    dir: "src/lang-libraries",
+    tagImportPath: 'import { lang } from "@/my-lang-tag-path"',
+    onImport: (event) => {
+      for (let e of event.exports) {
+        event.logger.info(
+          "Detected lang tag exports at package {packageName}",
+          { packageName: e.packageJSON.name }
+        );
+      }
+      event.logger.warn(
+        `
+Import Algorithm Not Configured
+
+To import external language tags, you need to configure an import algorithm.
+
+Setup Instructions:
+1. Add this import at the top of your configuration file:
+   {importStr}
+
+2. Replace import.onImport function with:
+   {onImport}
+
+This will enable import of language tags from external packages.
+            `.trim(),
+        {
+          importStr: "const { flexibleImportAlgorithm } = require('@lang-tag/cli/algorithms');",
+          onImport: "onImport: flexibleImportAlgorithm({ filePath: { includePackageInPath: true } })"
+        }
+      );
+    }
+  },
+  translationArgPosition: 1,
+  onConfigGeneration: async (event) => {
+    event.logger.info(
+      "Config generation event is not configured. Add onConfigGeneration handler to customize config generation."
+    );
   }
 };
 async function $LT_ReadConfig(projectPath) {
-  const configPath = resolve(projectPath, CONFIG_FILE_NAME);
+  const configPath = resolve$1(projectPath, CONFIG_FILE_NAME);
   if (!existsSync(configPath)) {
     throw new Error(`No "${CONFIG_FILE_NAME}" detected`);
   }
@@ -532,7 +903,9 @@ async function $LT_ReadConfig(projectPath) {
     const userConfig = configModule.default || {};
     const tn = (userConfig.tagName || "").toLowerCase().replace(/[-_\s]/g, "");
     if (tn === "langtag" || tn === "lang-tag") {
-      throw new Error('Custom tagName cannot be "lang-tag" or "langtag"! (It is not recommended for use with libraries)\n');
+      throw new Error(
+        'Custom tagName cannot be "lang-tag" or "langtag"! (It is not recommended for use with libraries)\n'
+      );
     }
     const config = {
       ...LANG_TAG_DEFAULT_CONFIG,
@@ -554,99 +927,6 @@ async function $LT_ReadConfig(projectPath) {
     throw error;
   }
 }
-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",
@@ -716,6 +996,99 @@ function getPriorityForNodeType(type) {
       return 0;
   }
 }
+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 = {
   reset: "\x1B[0m",
   white: "\x1B[97m",
@@ -747,18 +1120,24 @@ function printLines(lines, startLineNumber, errorLines = /* @__PURE__ */ new Set
     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}`);
+      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}`);
+          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}`);
+        console.log(
+          `${ANSI.gray}${lineNumStr}${ANSI.reset} ${ANSI.darkGray}│${ANSI.reset} ${line}`
+        );
         lastPrinted = i;
       }
     });
@@ -808,476 +1187,215 @@ async function logTagConflictInfo(tagInfo, prefix, conflictPath, translationArgP
     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);
+    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 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);
-      }
-    }
-    const encodedPath = encodeURI(filePath);
-    console.log(`${ANSI.gray}${prefix}${ANSI.reset} ${ANSI.cyan}file://${encodedPath}${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);
-  config.collect.collector.config = config;
-  config.collect.collector.logger = logger;
-  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) {
-      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_WriteToCollections({ config, collections, logger, clean }) {
-  await config.collect.collector.preWrite(clean);
-  const changedCollections = [];
-  for (let namespace of Object.keys(collections)) {
-    if (!namespace) {
-      continue;
-    }
-    const filePath = await config.collect.collector.resolveCollectionFilePath(namespace);
-    let originalJSON = {};
-    try {
-      originalJSON = await $LT_ReadJSON(filePath);
-    } catch (e) {
-      await config.collect.collector.onMissingCollection(namespace);
-    }
-    if (deepMergeTranslations(originalJSON, collections[namespace])) {
-      changedCollections.push(namespace);
-      await $LT_WriteJSON(filePath, originalJSON);
-    }
-  }
-  await config.collect.collector.postWrite(changedCollections);
-}
-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.baseLanguageCode,
-    packageName: packageJson.name || "",
-    files: langTagFiles
-  };
-  await $LT_WriteJSON(EXPORTS_FILE_NAME, data);
-  logger.success(`Written {file}`, { file: EXPORTS_FILE_NAME });
-}
-async function $LT_GroupTagsToCollections({ logger, files, config }) {
-  let totalTags = 0;
-  const collections = {};
-  function getTranslationsCollection(namespace) {
-    const collectionName = config.collect.collector.aggregateCollection(namespace);
-    const collection = collections[collectionName] || {};
-    if (!(collectionName in collections)) {
-      collections[collectionName] = collection;
-    }
-    return collection;
-  }
-  const allConflicts = [];
-  const existingValuesByNamespace = /* @__PURE__ */ new Map();
-  for (const file of files) {
-    totalTags += file.tags.length;
-    for (const _tag of file.tags) {
-      const tag = config.collect.collector.transformTag(_tag);
-      const tagConfig = tag.parameterConfig;
-      const collection = getTranslationsCollection(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,
-        collection,
-        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({
-      totalTags,
-      namespaces: collections,
-      conflicts: allConflicts,
-      logger,
-      exit() {
-        shouldContinue = false;
-      }
-    });
-    if (!shouldContinue) {
-      throw new Error(`LangTagConflictResolution:Processing stopped due to collect finish handler`);
-    }
-  }
-  return collections;
-}
-async function ensureNestedObject(path2, rootCollection, valueTracker, addConflict) {
-  if (!path2 || !path2.trim()) return rootCollection;
-  let current = rootCollection;
-  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");
+          });
+          if (translationErrorLines.size > 0) {
+            const lastTranslationErrorLine = Math.max(
+              ...Array.from(translationErrorLines)
+            );
+            lineNum = startLine + linesBeforeTranslation + lastTranslationErrorLine;
+          }
         }
-        continue;
+        const colorizedTranslation = colorizeFromAST(
+          translationTagCode,
+          markedTranslationNodes
+        );
+        colorizedWhole = colorizedWhole.replace(
+          translationTagCode,
+          colorizedTranslation
+        );
+      } catch (error) {
+        console.error("Failed to colorize translation:", error);
       }
-      if (targetType !== "object") {
-        if (existingInfo) {
-          await addConflict(currentPath, existingInfo, sourceValue, "path_overwrite");
-        }
-        if (targetValue !== sourceValue) {
-          continue;
+    }
+    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);
       }
     }
-    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);
+    const encodedPath = encodeURI(filePath);
+    console.log(
+      `${ANSI.gray}${prefix}${ANSI.reset} ${ANSI.cyan}file://${encodedPath}${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
+  );
+  config.collect.collector.config = config;
+  config.collect.collector.logger = logger;
+  return {
+    config,
+    logger
+  };
 }
 async function $LT_CMD_Collect(options) {
   const { config, logger } = await $LT_GetCommandEssentials();
@@ -1285,7 +1403,10 @@ async function $LT_CMD_Collect(options) {
   const files = await $LT_CollectCandidateFilesWithTags({ config, logger });
   if (config.debug) {
     for (let file of files) {
-      logger.debug("Found {count} translations tags inside: {file}", { count: file.tags.length, file: file.relativeFilePath });
+      logger.debug("Found {count} translations tags inside: {file}", {
+        count: file.tags.length,
+        file: file.relativeFilePath
+      });
     }
   }
   if (config.isLibrary) {
@@ -1293,10 +1414,22 @@ async function $LT_CMD_Collect(options) {
     return;
   }
   try {
-    const collections = await $LT_GroupTagsToCollections({ logger, files, config });
-    const totalTags = files.reduce((sum, file) => sum + file.tags.length, 0);
+    const collections = await $LT_GroupTagsToCollections({
+      logger,
+      files,
+      config
+    });
+    const totalTags = files.reduce(
+      (sum, file) => sum + file.tags.length,
+      0
+    );
     logger.debug("Found {totalTags} translation tags", { totalTags });
-    await $LT_WriteToCollections({ config, collections, logger, clean: options?.clean });
+    await $LT_WriteToCollections({
+      config,
+      collections,
+      logger,
+      clean: options?.clean
+    });
   } catch (e) {
     const prefix = "LangTagConflictResolution:";
     if (e.message.startsWith(prefix)) {
@@ -1306,64 +1439,213 @@ async function $LT_CMD_Collect(options) {
     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;
+async function $LT_CollectExportFiles(logger) {
+  const nodeModulesPath = path$1.join(process__default.cwd(), "node_modules");
+  if (!fs.existsSync(nodeModulesPath)) {
+    logger.error('"node_modules" directory not found');
+    return [];
   }
-  if (endIndex === -1) {
-    const lastSlashIndex = pattern.lastIndexOf("/");
-    return lastSlashIndex !== -1 ? pattern.substring(0, lastSlashIndex) : ".";
+  const results = [];
+  try {
+    const exportFiles = await globby(
+      [`node_modules/**/${EXPORTS_FILE_NAME}`],
+      {
+        cwd: process__default.cwd(),
+        onlyFiles: true,
+        ignore: ["**/node_modules/**/node_modules/**"],
+        deep: 4
+      }
+    );
+    for (const exportFile of exportFiles) {
+      const fullExportPath = path$1.resolve(exportFile);
+      const packageJsonPath = findPackageJsonForExport(
+        fullExportPath,
+        nodeModulesPath
+      );
+      if (packageJsonPath) {
+        results.push({
+          exportPath: fullExportPath,
+          packageJsonPath
+        });
+      } else {
+        logger.warn(
+          "Found export file but could not match package.json: {exportPath}",
+          {
+            exportPath: fullExportPath
+          }
+        );
+      }
+    }
+    logger.debug(
+      "Found {count} export files with matching package.json in node_modules",
+      {
+        count: results.length
+      }
+    );
+  } catch (error) {
+    logger.error("Error scanning node_modules with globby: {error}", {
+      error: String(error)
+    });
   }
-  const lastSeparatorIndex = pattern.lastIndexOf("/", endIndex);
-  return lastSeparatorIndex === -1 ? "." : pattern.substring(0, lastSeparatorIndex);
+  return results;
 }
-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
+function findPackageJsonForExport(exportPath, nodeModulesPath) {
+  const relativePath = path$1.relative(nodeModulesPath, exportPath);
+  const pathParts = relativePath.split(path$1.sep);
+  if (pathParts.length < 2) {
+    return null;
+  }
+  if (pathParts[0].startsWith("@")) {
+    if (pathParts.length >= 3) {
+      const packageDir = path$1.join(
+        nodeModulesPath,
+        pathParts[0],
+        pathParts[1]
+      );
+      const packageJsonPath = path$1.join(packageDir, "package.json");
+      if (fs.existsSync(packageJsonPath)) {
+        return packageJsonPath;
+      }
     }
-  });
+  } else {
+    const packageDir = path$1.join(nodeModulesPath, pathParts[0]);
+    const packageJsonPath = path$1.join(packageDir, "package.json");
+    if (fs.existsSync(packageJsonPath)) {
+      return packageJsonPath;
+    }
+  }
+  return null;
 }
-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 });
-  });
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const templatePath = join(
+  __dirname,
+  "templates",
+  "import",
+  "imported-tag.mustache"
+);
+const template = readFileSync(templatePath, "utf-8");
+function renderTemplate$1(data) {
+  return mustache.render(template, data, {}, { escape: (text) => text });
 }
-async function handleFile(config, logger, cwdRelativeFilePath, event) {
-  if (!micromatch.isMatch(cwdRelativeFilePath, config.includes)) {
+async function generateImportFiles(config, logger, importManager) {
+  const importedFiles = importManager.getImportedFiles();
+  for (const importedFile of importedFiles) {
+    const filePath = resolve$1(
+      process$1.cwd(),
+      config.import.dir,
+      importedFile.pathRelativeToImportDir
+    );
+    const processedExports = importedFile.tags.map((tag) => {
+      const parameter1 = config.translationArgPosition === 1 ? tag.translations : tag.config;
+      const parameter2 = config.translationArgPosition === 1 ? tag.config : tag.translations;
+      const hasParameter2 = parameter2 !== null && parameter2 !== void 0 && (typeof parameter2 !== "object" || Object.keys(parameter2).length > 0);
+      return {
+        name: tag.variableName,
+        parameter1: JSON5.stringify(parameter1, void 0, 4),
+        parameter2: hasParameter2 ? JSON5.stringify(parameter2, void 0, 4) : null,
+        hasParameter2,
+        config: {
+          tagName: config.tagName
+        }
+      };
+    });
+    const templateData = {
+      tagImportPath: config.import.tagImportPath,
+      exports: processedExports
+    };
+    const content = renderTemplate$1(templateData);
+    await $LT_EnsureDirectoryExists(dirname(filePath));
+    await writeFile(filePath, content, "utf-8");
+    logger.success('Created tag file: "{file}"', {
+      file: importedFile.pathRelativeToImportDir
+    });
+  }
+}
+class ImportManager {
+  importedFiles = [];
+  constructor() {
+    this.importedFiles = [];
+  }
+  importTag(pathRelativeToImportDir, tag) {
+    if (!pathRelativeToImportDir) {
+      throw new Error(
+        `pathRelativeToImportDir required, got: ${pathRelativeToImportDir}`
+      );
+    }
+    if (!tag?.variableName) {
+      throw new Error(
+        `tag.variableName required, got: ${tag?.variableName}`
+      );
+    }
+    if (!this.isValidJavaScriptIdentifier(tag.variableName)) {
+      throw new Error(
+        `Invalid JavaScript identifier: "${tag.variableName}". Variable names must start with a letter, underscore, or dollar sign, and contain only letters, digits, underscores, and dollar signs.`
+      );
+    }
+    if (tag.translations == null) {
+      throw new Error(`tag.translations required`);
+    }
+    let importedFile = this.importedFiles.find(
+      (file) => file.pathRelativeToImportDir === pathRelativeToImportDir
+    );
+    if (importedFile) {
+      const duplicateTag = importedFile.tags.find(
+        (existingTag) => existingTag.variableName === tag.variableName
+      );
+      if (duplicateTag) {
+        throw new Error(
+          `Duplicate variable name "${tag.variableName}" in file "${pathRelativeToImportDir}". Variable names must be unique within the same file.`
+        );
+      }
+    }
+    if (!importedFile) {
+      importedFile = { pathRelativeToImportDir, tags: [] };
+      this.importedFiles.push(importedFile);
+    }
+    importedFile.tags.push(tag);
+  }
+  getImportedFiles() {
+    return [...this.importedFiles];
+  }
+  getImportedFilesCount() {
+    return this.importedFiles.length;
+  }
+  hasImportedFiles() {
+    return this.importedFiles.length > 0;
+  }
+  isValidJavaScriptIdentifier(name) {
+    return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
+  }
+}
+async function $LT_ImportLibraries(config, logger) {
+  const exportFiles = await $LT_CollectExportFiles(logger);
+  const importManager = new ImportManager();
+  let exports = [];
+  for (const { exportPath, packageJsonPath } of exportFiles) {
+    const exportData = await $LT_ReadJSON(exportPath);
+    const packageJSON = await $LT_ReadJSON(packageJsonPath);
+    exports.push({ packageJSON, exportData });
+  }
+  config.import.onImport({
+    exports,
+    importManager,
+    logger,
+    langTagConfig: config
+  });
+  if (!importManager.hasImportedFiles()) {
+    logger.warn("No tags were imported from any library files");
     return;
   }
-  const cwd = process.cwd();
-  const absoluteFilePath = path__default.join(cwd, cwdRelativeFilePath);
-  await checkAndRegenerateFileLangTags(config, logger, absoluteFilePath, cwdRelativeFilePath);
-  const files = await $LT_CollectCandidateFilesWithTags({ filesToScan: [cwdRelativeFilePath], config, logger });
-  const namespaces = await $LT_GroupTagsToCollections({ logger, files, config });
-  await $LT_WriteToCollections({ config, collections: namespaces, logger });
+  await generateImportFiles(config, logger, importManager);
+  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.");
 }
 async function detectModuleSystem() {
   const packageJsonPath = join(process.cwd(), "package.json");
@@ -1416,7 +1698,7 @@ const generationAlgorithm = pathBasedConfigGenerator({
 });
 const keeper = configKeeper({ propertyName: 'keep' });
 
-/** @type {import('@lang-tag/cli/config').LangTagCLIConfig} */
+/** @type {import('@lang-tag/cli/type').LangTagCLIConfig} */
 const config = {
     tagName: 'lang',
     isLibrary: false,
@@ -1454,7 +1736,9 @@ ${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");
+    logger.success(
+      "Configuration file already exists. Please remove the existing configuration file before creating a new default one"
+    );
     return;
   }
   try {
@@ -1465,138 +1749,6 @@ async function $LT_CMD_InitConfig() {
     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(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$1(__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)) {
@@ -1638,51 +1790,312 @@ async function detectInitTagOptions(options, config) {
     packageVersion: packageJson?.version || "1.0.0"
   };
 }
+function renderTemplate(template2, data) {
+  return mustache.render(template2, data, {}, { escape: (text) => text });
+}
+function loadTemplate(templateName) {
+  const __filename2 = fileURLToPath(import.meta.url);
+  const __dirname2 = dirname(__filename2);
+  const templatePath2 = join(
+    __dirname2,
+    "templates",
+    "tag",
+    `${templateName}.mustache`
+  );
+  try {
+    return readFileSync(templatePath2, "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 $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("  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 });
+    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");
+    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.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("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(
+      "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 });
+    logger.error("Failed to write file: {error}", {
+      error: error?.message
+    });
+  }
+}
+function deepFreezeObject(obj) {
+  const propNames = Object.getOwnPropertyNames(obj);
+  for (const name of propNames) {
+    const value = obj[name];
+    if (value && typeof value === "object") {
+      deepFreezeObject(value);
+    }
+  }
+  return Object.freeze(obj);
+}
+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 = [];
+  let lastUpdatedLine = 0;
+  for (let tag of tags) {
+    let newConfig = void 0;
+    let shouldUpdate = false;
+    const frozenConfig = tag.parameterConfig ? deepFreezeObject(tag.parameterConfig) : tag.parameterConfig;
+    const event = {
+      langTagConfig: config,
+      logger,
+      config: frozenConfig,
+      absolutePath: file,
+      relativePath: path2,
+      isImportedLibrary: path2.startsWith(libraryImportsDir),
+      isSaved: false,
+      savedConfig: void 0,
+      save: (updatedConfig, triggerName) => {
+        if (!updatedConfig && updatedConfig !== null)
+          throw new Error("Wrong config data");
+        newConfig = updatedConfig;
+        shouldUpdate = true;
+        event.isSaved = true;
+        event.savedConfig = updatedConfig;
+        logger.debug(
+          'Called save for "{path}" with config "{config}" triggered by: ("{trigger}")',
+          {
+            path: path2,
+            config: JSON.stringify(updatedConfig),
+            trigger: triggerName || "-"
+          }
+        );
+      }
+    };
+    await config.onConfigGeneration(event);
+    if (!shouldUpdate) {
+      continue;
+    }
+    lastUpdatedLine = tag.line;
+    if (!isConfigSame(tag.parameterConfig, newConfig)) {
+      replacements.push({ tag, config: newConfig });
+    }
+  }
+  if (replacements.length) {
+    const newContent = processor.replaceTags(fileContent, replacements);
+    await writeFile(file, newContent, "utf-8");
+    const encodedFile = encodeURI(file);
+    logger.info(
+      'Lang tag configurations written for file "{path}" (file://{file}:{line})',
+      { path: path2, file: encodedFile, line: lastUpdatedLine }
+    );
+    return true;
+  }
+  return false;
+}
+function isConfigSame(c1, c2) {
+  if (!c1 && !c2) return true;
+  if (c1 && typeof c1 === "object" && c2 && typeof c2 === "object" && JSON5.stringify(c1) === JSON5.stringify(c2))
+    return true;
+  return false;
+}
+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) {
+      dirty = true;
+    }
   }
+  if (!dirty) {
+    logger.info(
+      "No changes were made based on the current configuration and files"
+    );
+  }
+}
+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);
+  await checkAndRegenerateFileLangTags(
+    config,
+    logger,
+    absoluteFilePath,
+    cwdRelativeFilePath
+  );
+  const files = await $LT_CollectCandidateFilesWithTags({
+    filesToScan: [cwdRelativeFilePath],
+    config,
+    logger
+  });
+  const namespaces = await $LT_GroupTagsToCollections({
+    logger,
+    files,
+    config
+  });
+  await $LT_WriteToCollections({ config, collections: namespaces, logger });
 }
 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("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) => {
+  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;