@lingo.dev/_compiler 0.1.1

package/build/index.mjs

@@ -0,0 +1,2468 @@
+// src/index.ts
+import { createUnplugin } from "unplugin";
+
+// package.json
+var package_default = {
+  name: "@lingo.dev/_compiler",
+  version: "0.1.1",
+  description: "Lingo.dev Compiler",
+  private: false,
+  publishConfig: {
+    access: "public"
+  },
+  sideEffects: false,
+  type: "module",
+  main: "build/index.cjs",
+  types: "build/index.d.ts",
+  module: "build/index.mjs",
+  files: [
+    "build"
+  ],
+  scripts: {
+    dev: "tsup --watch",
+    build: "tsc --noEmit && tsup",
+    clean: "rm -rf build",
+    test: "vitest --run",
+    "test:watch": "vitest -w"
+  },
+  keywords: [],
+  author: "",
+  license: "ISC",
+  devDependencies: {
+    "@types/babel__generator": "^7.6.8",
+    "@types/babel__traverse": "^7.20.6",
+    "@types/ini": "^4.1.1",
+    "@types/lodash": "^4.17.4",
+    "@types/object-hash": "^3.0.6",
+    "@types/react": "^18.3.18",
+    next: "15.2.4",
+    tsup: "^8.3.5",
+    typescript: "^5.4.5"
+  },
+  dependencies: {
+    "@ai-sdk/groq": "^1.2.3",
+    "@babel/generator": "^7.26.5",
+    "@babel/parser": "^7.26.7",
+    "@babel/traverse": "^7.26.7",
+    "@babel/types": "^7.26.7",
+    ai: "^4.2.10",
+    dedent: "^1.6.0",
+    dotenv: "^16.4.5",
+    "fast-xml-parser": "^5.0.8",
+    ini: "^5.0.0",
+    lodash: "^4.17.21",
+    "object-hash": "^3.0.0",
+    prettier: "^3.4.2",
+    unplugin: "^2.1.2",
+    vitest: "^2.1.4",
+    zod: "^3.24.1"
+  }
+};
+
+// src/index.ts
+import _12 from "lodash";
+import dedent2 from "dedent";
+
+// src/_base.ts
+import generate from "@babel/generator";
+import * as parser from "@babel/parser";
+function createCodeMutation(spec) {
+  return (payload) => {
+    const result = spec(payload);
+    return result;
+  };
+}
+function createPayload(input) {
+  const ast = parser.parse(input.code, {
+    sourceType: "module",
+    plugins: ["jsx", "typescript"]
+  });
+  return {
+    ...input,
+    ast
+  };
+}
+function createOutput(payload) {
+  const generationResult = generate(payload.ast, {}, payload.code);
+  return {
+    code: generationResult.code,
+    map: generationResult.map
+  };
+}
+function composeMutations(...mutations) {
+  return (input) => {
+    let result = input;
+    for (const mutate of mutations) {
+      const intermediateResult = mutate(result);
+      if (!intermediateResult) {
+        break;
+      } else {
+        result = intermediateResult;
+      }
+    }
+    return result;
+  };
+}
+var defaultParams = {
+  sourceRoot: "src",
+  lingoDir: "lingo",
+  sourceLocale: "en",
+  targetLocales: ["es"],
+  rsc: false,
+  useDirective: false,
+  debug: false,
+  models: {}
+};
+
+// src/utils/index.ts
+import traverse from "@babel/traverse";
+import * as t2 from "@babel/types";
+
+// src/utils/jsx-attribute.ts
+import * as t from "@babel/types";
+import _ from "lodash";
+function getJsxAttributesMap(nodePath) {
+  const attributes = nodePath.node.openingElement.attributes;
+  return _.reduce(
+    attributes,
+    (result, attr) => {
+      if (attr.type !== "JSXAttribute" || attr.name.type !== "JSXIdentifier") {
+        return result;
+      }
+      const name = attr.name.name;
+      const value = extractAttributeValue(attr);
+      return { ...result, [name]: value };
+    },
+    {}
+  );
+}
+function getJsxAttributeValue(nodePath, attributeName) {
+  const attributes = nodePath.node.openingElement.attributes;
+  const attribute = _.find(
+    attributes,
+    (attr) => attr.type === "JSXAttribute" && attr.name.type === "JSXIdentifier" && attr.name.name === attributeName
+  );
+  if (!attribute) {
+    return void 0;
+  }
+  return extractAttributeValue(attribute);
+}
+function extractAttributeValue(attribute) {
+  if (!attribute.value) {
+    return true;
+  }
+  if (attribute.value.type === "StringLiteral") {
+    return attribute.value.value;
+  }
+  if (attribute.value.type === "JSXExpressionContainer") {
+    const expression = attribute.value.expression;
+    if (expression.type === "BooleanLiteral") {
+      return expression.value;
+    }
+    if (expression.type === "NumericLiteral") {
+      return expression.value;
+    }
+    if (expression.type === "StringLiteral") {
+      return expression.value;
+    }
+  }
+  return null;
+}
+
+// src/utils/index.ts
+function getJsxRoots(node) {
+  const result = [];
+  traverse(node, {
+    JSXElement(path6) {
+      result.push(path6);
+      path6.skip();
+    }
+  });
+  return result;
+}
+function getOrCreateImport(ast, params) {
+  let importedName = params.exportedName;
+  let existingImport = findExistingImport(
+    ast,
+    params.exportedName,
+    params.moduleName
+  );
+  if (existingImport) {
+    return { importedName: existingImport };
+  }
+  importedName = generateUniqueImportName(ast, params.exportedName);
+  createImportDeclaration(
+    ast,
+    importedName,
+    params.exportedName,
+    params.moduleName
+  );
+  return { importedName };
+}
+function findExistingImport(ast, exportedName, moduleName) {
+  let result = null;
+  traverse(ast, {
+    ImportDeclaration(path6) {
+      if (path6.node.source.value !== moduleName) {
+        return;
+      }
+      for (const specifier of path6.node.specifiers) {
+        if (t2.isImportSpecifier(specifier) && (t2.isIdentifier(specifier.imported) && specifier.imported.name === exportedName || specifier.importKind === "value" && t2.isIdentifier(specifier.local) && specifier.local.name === exportedName)) {
+          result = specifier.local.name;
+          path6.stop();
+          return;
+        }
+      }
+    }
+  });
+  return result;
+}
+function generateUniqueImportName(ast, baseName) {
+  const usedNames = /* @__PURE__ */ new Set();
+  traverse(ast, {
+    Identifier(path6) {
+      usedNames.add(path6.node.name);
+    }
+  });
+  if (!usedNames.has(baseName)) {
+    return baseName;
+  }
+  let counter = 1;
+  let candidateName = `${baseName}${counter}`;
+  while (usedNames.has(candidateName)) {
+    counter++;
+    candidateName = `${baseName}${counter}`;
+  }
+  return candidateName;
+}
+function createImportDeclaration(ast, localName, exportedName, moduleName) {
+  traverse(ast, {
+    Program(path6) {
+      const importSpecifier2 = t2.importSpecifier(
+        t2.identifier(localName),
+        t2.identifier(exportedName)
+      );
+      const existingImport = path6.get("body").find(
+        (nodePath) => t2.isImportDeclaration(nodePath.node) && nodePath.node.source.value === moduleName
+      );
+      if (existingImport && t2.isImportDeclaration(existingImport.node)) {
+        existingImport.node.specifiers.push(importSpecifier2);
+      } else {
+        const importDeclaration2 = t2.importDeclaration(
+          [importSpecifier2],
+          t2.stringLiteral(moduleName)
+        );
+        const lastImportIndex = findLastImportIndex(path6);
+        path6.node.body.splice(lastImportIndex + 1, 0, importDeclaration2);
+      }
+      path6.stop();
+    }
+  });
+}
+function findLastImportIndex(programPath) {
+  const body = programPath.node.body;
+  for (let i = body.length - 1; i >= 0; i--) {
+    if (t2.isImportDeclaration(body[i])) {
+      return i;
+    }
+  }
+  return -1;
+}
+function _hasFileDirective(ast, directiveValue) {
+  let hasDirective = false;
+  traverse(ast, {
+    Directive(path6) {
+      if (path6.node.value.value === directiveValue) {
+        hasDirective = true;
+        path6.stop();
+      }
+    }
+  });
+  return hasDirective;
+}
+function hasI18nDirective(ast) {
+  return _hasFileDirective(ast, "use i18n");
+}
+function hasClientDirective(ast) {
+  return _hasFileDirective(ast, "use client");
+}
+function getModuleExecutionMode(ast, rscEnabled) {
+  if (rscEnabled) {
+    if (hasClientDirective(ast)) {
+      return "client";
+    } else {
+      return "server";
+    }
+  } else {
+    return "client";
+  }
+}
+
+// src/i18n-directive.ts
+var i18nDirectiveMutation = createCodeMutation((payload) => {
+  if (!payload.params.useDirective || hasI18nDirective(payload.ast)) {
+    return payload;
+  } else {
+    return null;
+  }
+});
+var i18n_directive_default = i18nDirectiveMutation;
+
+// src/jsx-provider.ts
+import traverse2 from "@babel/traverse";
+import * as t4 from "@babel/types";
+
+// src/utils/jsx-element.ts
+import * as t3 from "@babel/types";
+function getJsxElementName(nodePath) {
+  const openingElement = nodePath.node.openingElement;
+  if (t3.isJSXIdentifier(openingElement.name)) {
+    return openingElement.name.name;
+  }
+  return null;
+}
+function getNestedJsxElements(nodePath) {
+  const nestedElements = [];
+  nodePath.traverse({
+    JSXElement(path6) {
+      if (path6.node !== nodePath.node) {
+        nestedElements.push(path6.node);
+      }
+    }
+  });
+  const arrayOfElements = nestedElements.map((element, index) => {
+    const param = t3.identifier("children");
+    const clonedElement = t3.cloneNode(element);
+    clonedElement.children = [t3.jsxExpressionContainer(param)];
+    return t3.arrowFunctionExpression(
+      [t3.objectPattern([t3.objectProperty(param, param, false, true)])],
+      clonedElement
+    );
+  });
+  const result = t3.arrayExpression(arrayOfElements);
+  return result;
+}
+
+// src/_const.ts
+var LCP_DICTIONARY_FILE_NAME = "dictionary.js";
+
+// src/jsx-provider.ts
+var jsxProviderMutation = createCodeMutation((payload) => {
+  traverse2(payload.ast, {
+    JSXElement: (path6) => {
+      if (getJsxElementName(path6)?.toLowerCase() === "html") {
+        const mode = getModuleExecutionMode(payload.ast, payload.params.rsc);
+        if (mode === "client") {
+          return;
+        }
+        const lingoProviderImport = getOrCreateImport(payload.ast, {
+          moduleName: "lingo.dev/react/rsc" /* ReactRSC */,
+          exportedName: "LingoProvider"
+        });
+        const loadDictionaryImport = getOrCreateImport(payload.ast, {
+          moduleName: "lingo.dev/react/rsc" /* ReactRSC */,
+          exportedName: "loadDictionary"
+        });
+        const loadDictionaryArrow = t4.arrowFunctionExpression(
+          [t4.identifier("locale")],
+          t4.callExpression(t4.identifier(loadDictionaryImport.importedName), [
+            t4.identifier("locale")
+          ])
+        );
+        const providerProps = [
+          t4.jsxAttribute(
+            t4.jsxIdentifier("loadDictionary"),
+            t4.jsxExpressionContainer(loadDictionaryArrow)
+          )
+        ];
+        const provider = t4.jsxElement(
+          t4.jsxOpeningElement(
+            t4.jsxIdentifier(lingoProviderImport.importedName),
+            providerProps,
+            false
+          ),
+          t4.jsxClosingElement(
+            t4.jsxIdentifier(lingoProviderImport.importedName)
+          ),
+          [path6.node],
+          false
+        );
+        path6.replaceWith(provider);
+        path6.skip();
+      }
+    }
+  });
+  return payload;
+});
+var jsx_provider_default = jsxProviderMutation;
+
+// src/jsx-root-flag.ts
+import * as t5 from "@babel/types";
+var jsxRootFlagMutation = createCodeMutation((payload) => {
+  const jsxRoots = getJsxRoots(payload.ast);
+  for (const jsxElementPath of jsxRoots) {
+    jsxElementPath.node.openingElement.attributes.push(
+      t5.jsxAttribute(t5.jsxIdentifier("data-jsx-root"), null)
+    );
+  }
+  return {
+    ...payload
+  };
+});
+var jsx_root_flag_default = jsxRootFlagMutation;
+
+// src/jsx-scope-flag.ts
+import * as t8 from "@babel/types";
+
+// src/utils/ast-key.ts
+import * as t6 from "@babel/types";
+import traverse3 from "@babel/traverse";
+function getAstKey(nodePath) {
+  const keyChunks = [];
+  let current = nodePath;
+  while (current) {
+    keyChunks.push(current.key);
+    current = current.parentPath;
+    if (t6.isProgram(current?.node)) {
+      break;
+    }
+  }
+  const result = keyChunks.reverse().join("/");
+  return result;
+}
+
+// src/utils/jsx-scope.ts
+import * as t7 from "@babel/types";
+import traverse4 from "@babel/traverse";
+function collectJsxScopes(ast) {
+  const jsxScopes = [];
+  traverse4(ast, {
+    JSXElement: (path6) => {
+      if (!hasJsxScopeAttribute(path6)) return;
+      path6.skip();
+      jsxScopes.push(path6);
+    }
+  });
+  return jsxScopes;
+}
+function getJsxScopes(node) {
+  const result = [];
+  traverse4(node, {
+    JSXElement(path6) {
+      const hasNonEmptyTextSiblings = path6.getAllPrevSiblings().concat(path6.getAllNextSiblings()).some(
+        (sibling) => t7.isJSXText(sibling.node) && sibling.node.value.trim() !== ""
+      );
+      if (hasNonEmptyTextSiblings) {
+        return;
+      }
+      const hasNonEmptyTextChild = path6.get("children").some(
+        (child) => t7.isJSXText(child.node) && child.node.value.trim() !== ""
+      );
+      if (hasNonEmptyTextChild) {
+        result.push(path6);
+        path6.skip();
+      }
+    }
+  });
+  return result;
+}
+function hasJsxScopeAttribute(path6) {
+  return !!getJsxScopeAttribute(path6);
+}
+function getJsxScopeAttribute(path6) {
+  const attribute = path6.node.openingElement.attributes.find(
+    (attr) => attr.type === "JSXAttribute" && attr.name.name === "data-jsx-scope"
+  );
+  return attribute && t7.isJSXAttribute(attribute) && t7.isStringLiteral(attribute.value) ? attribute.value.value : void 0;
+}
+
+// src/jsx-scope-flag.ts
+var jsxScopeFlagMutation = createCodeMutation((payload) => {
+  const jsxScopes = getJsxScopes(payload.ast);
+  for (const jsxScope of jsxScopes) {
+    jsxScope.node.openingElement.attributes.push(
+      t8.jsxAttribute(
+        t8.jsxIdentifier("data-jsx-scope"),
+        t8.stringLiteral(getAstKey(jsxScope))
+      )
+    );
+  }
+  return {
+    ...payload
+  };
+});
+var jsx_scope_flag_default = jsxScopeFlagMutation;
+
+// src/jsx-attribute-flag.ts
+import * as t10 from "@babel/types";
+
+// src/utils/jsx-attribute-scope.ts
+import * as t9 from "@babel/types";
+import traverse5 from "@babel/traverse";
+function collectJsxAttributeScopes(node) {
+  const result = [];
+  traverse5(node, {
+    JSXElement(path6) {
+      if (!hasJsxAttributeScopeAttribute(path6)) return;
+      const localizableAttributes = getJsxAttributeScopeAttribute(path6);
+      if (!localizableAttributes) return;
+      result.push([path6, localizableAttributes]);
+    }
+  });
+  return result;
+}
+function getJsxAttributeScopes(node) {
+  const result = [];
+  const LOCALIZABLE_ATTRIBUTES = [
+    "title",
+    "aria-label",
+    "aria-description",
+    "alt",
+    "label",
+    "description",
+    "placeholder",
+    "content",
+    "subtitle"
+  ];
+  traverse5(node, {
+    JSXElement(path6) {
+      const openingElement = path6.node.openingElement;
+      const elementName = openingElement.name;
+      if (!t9.isJSXIdentifier(elementName) || !elementName.name) {
+        return;
+      }
+      const hasAttributeScope = openingElement.attributes.find(
+        (attr) => t9.isJSXAttribute(attr) && attr.name.name === "data-jsx-attribute-scope"
+      );
+      if (hasAttributeScope) {
+        return;
+      }
+      const localizableAttrs = openingElement.attributes.filter(
+        (attr) => {
+          if (!t9.isJSXAttribute(attr) || !t9.isStringLiteral(attr.value)) {
+            return false;
+          }
+          const name = attr.name.name;
+          return typeof name === "string" && LOCALIZABLE_ATTRIBUTES.includes(name);
+        }
+      ).map((attr) => attr.name.name);
+      if (localizableAttrs.length > 0) {
+        result.push([path6, localizableAttrs]);
+      }
+    }
+  });
+  return result;
+}
+function hasJsxAttributeScopeAttribute(path6) {
+  return !!getJsxAttributeScopeAttribute(path6);
+}
+function getJsxAttributeScopeAttribute(path6) {
+  const attribute = path6.node.openingElement.attributes.find(
+    (attr) => attr.type === "JSXAttribute" && attr.name.name === "data-jsx-attribute-scope"
+  );
+  if (!attribute || !t9.isJSXAttribute(attribute)) {
+    return void 0;
+  }
+  if (t9.isJSXExpressionContainer(attribute.value) && t9.isArrayExpression(attribute.value.expression)) {
+    const arrayExpr = attribute.value.expression;
+    return arrayExpr.elements.filter((el) => t9.isStringLiteral(el)).map((el) => el.value);
+  }
+  if (t9.isStringLiteral(attribute.value)) {
+    return [attribute.value.value];
+  }
+  return void 0;
+}
+
+// src/jsx-attribute-flag.ts
+var jsxAttributeFlagMutation = createCodeMutation(
+  (payload) => {
+    const jsxScopes = getJsxAttributeScopes(payload.ast);
+    for (const [jsxScope, attributes] of jsxScopes) {
+      const scopeKey = getAstKey(jsxScope);
+      jsxScope.node.openingElement.attributes.push(
+        t10.jsxAttribute(
+          t10.jsxIdentifier("data-jsx-attribute-scope"),
+          t10.jsxExpressionContainer(
+            t10.arrayExpression(
+              attributes.map(
+                (attr) => t10.stringLiteral(`${attr}:${scopeKey}-${attr}`)
+              )
+            )
+          )
+        )
+      );
+    }
+    return {
+      ...payload
+    };
+  }
+);
+var jsx_attribute_flag_default = jsxAttributeFlagMutation;
+
+// src/index.ts
+import path5 from "path";
+
+// src/utils/module-params.ts
+function parseParametrizedModuleId(rawId) {
+  const moduleUri = new URL(rawId, "module://");
+  return {
+    id: moduleUri.pathname.replace(/^\//, ""),
+    params: Object.fromEntries(moduleUri.searchParams.entries())
+  };
+}
+
+// src/lib/lcp/index.ts
+import * as fs from "fs";
+import _2 from "lodash";
+import * as path from "path";
+var LCP_FILE_NAME = "meta.json";
+var LCP = class _LCP {
+  constructor(filePath, data = {
+    version: 0.1
+  }) {
+    this.filePath = filePath;
+    this.data = data;
+  }
+  static getInstance(params) {
+    const filePath = path.resolve(
+      process.cwd(),
+      params.sourceRoot,
+      params.lingoDir,
+      LCP_FILE_NAME
+    );
+    if (fs.existsSync(filePath)) {
+      return new _LCP(filePath, JSON.parse(fs.readFileSync(filePath, "utf8")));
+    }
+    return new _LCP(filePath);
+  }
+  // wait until LCP file stops updating
+  // this ensures all files were transformed before loading / translating dictionaries
+  static async ready(params) {
+    const filePath = path.resolve(
+      process.cwd(),
+      params.sourceRoot,
+      params.lingoDir,
+      LCP_FILE_NAME
+    );
+    if (fs.existsSync(filePath)) {
+      const stats = fs.statSync(filePath);
+      if (Date.now() - stats.mtimeMs > 1500) {
+        return;
+      }
+    }
+    return new Promise((resolve3) => {
+      setTimeout(() => {
+        _LCP.ready(params).then(resolve3);
+      }, 750);
+    });
+  }
+  resetScope(fileKey, scopeKey) {
+    if (!_2.isObject(
+      _2.get(this.data, ["files", fileKey])
+    )) {
+      _2.set(this.data, ["files", fileKey], {});
+    }
+    _2.set(
+      this.data,
+      [
+        "files",
+        fileKey,
+        "scopes",
+        scopeKey
+      ],
+      {}
+    );
+    return this;
+  }
+  setScopeType(fileKey, scopeKey, type) {
+    return this._setScopeField(fileKey, scopeKey, "type", type);
+  }
+  setScopeContext(fileKey, scopeKey, context) {
+    return this._setScopeField(fileKey, scopeKey, "context", context);
+  }
+  setScopeHash(fileKey, scopeKey, hash) {
+    return this._setScopeField(fileKey, scopeKey, "hash", hash);
+  }
+  setScopeSkip(fileKey, scopeKey, skip) {
+    return this._setScopeField(fileKey, scopeKey, "skip", skip);
+  }
+  setScopeOverrides(fileKey, scopeKey, overrides) {
+    return this._setScopeField(fileKey, scopeKey, "overrides", overrides);
+  }
+  setScopeContent(fileKey, scopeKey, content) {
+    return this._setScopeField(fileKey, scopeKey, "content", content);
+  }
+  toJSON() {
+    const files = _2(this.data?.files).mapValues((file, fileName) => {
+      return {
+        ...file,
+        scopes: _2(file?.scopes).toPairs().sortBy([0]).fromPairs().value()
+      };
+    }).toPairs().sortBy([0]).fromPairs().value();
+    return { ...this.data, files };
+  }
+  toString() {
+    return JSON.stringify(this.toJSON(), null, 2);
+  }
+  save() {
+    const hasChanges = !fs.existsSync(this.filePath) || fs.readFileSync(this.filePath, "utf8") !== this.toString();
+    if (hasChanges) {
+      const dir = this.filePath.substring(0, this.filePath.lastIndexOf("/"));
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      fs.writeFileSync(this.filePath, this.toString());
+      this._triggerLCPReload();
+    }
+  }
+  _triggerLCPReload() {
+    const dir = this.filePath.substring(0, this.filePath.lastIndexOf("/"));
+    const filePath = path.resolve(dir, LCP_DICTIONARY_FILE_NAME);
+    if (fs.existsSync(filePath)) {
+      const now = Date.now();
+      fs.utimesSync(filePath, now, now);
+    }
+  }
+  _setScopeField(fileKey, scopeKey, field, value) {
+    _2.set(
+      this.data,
+      [
+        "files",
+        fileKey,
+        "scopes",
+        scopeKey,
+        field
+      ],
+      value
+    );
+    return this;
+  }
+};
+
+// src/lib/lcp/server.ts
+import _7 from "lodash";
+
+// src/lib/lcp/cache.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import * as prettier from "prettier";
+import _3 from "lodash";
+var LCPCache = class {
+  // make sure the cache file exists, otherwise imports will fail
+  static ensureDictionaryFile(params) {
+    const cachePath = this._getCachePath(params);
+    if (!fs2.existsSync(cachePath)) {
+      const dir = path2.dirname(cachePath);
+      if (!fs2.existsSync(dir)) {
+        fs2.mkdirSync(dir, { recursive: true });
+      }
+      fs2.writeFileSync(cachePath, "export default {};");
+    }
+  }
+  // read cache entries for given locale, validate entry hash from LCP schema
+  static readLocaleDictionary(locale, params) {
+    const cache = this._read(params);
+    const dictionary = this._extractLocaleDictionary(cache, locale, params.lcp);
+    return dictionary;
+  }
+  // write cache entries for given locale to existing cache file, use hash from LCP schema
+  static async writeLocaleDictionary(dictionary, params) {
+    const currentCache = this._read(params);
+    const newCache = this._mergeLocaleDictionary(
+      currentCache,
+      dictionary,
+      params.lcp
+    );
+    await this._write(newCache, params);
+  }
+  // merge dictionary with current cache, sort files, entries and locales to minimize diffs
+  static _mergeLocaleDictionary(currentCache, dictionary, lcp) {
+    const files = _3(dictionary.files).mapValues((file, fileName) => ({
+      ...file,
+      entries: _3(file.entries).mapValues((entry, entryName) => {
+        const cachedEntry = _3.get(currentCache, ["files", fileName, "entries", entryName]) ?? {};
+        const hash = _3.get(lcp, [
+          "files",
+          fileName,
+          "scopes",
+          entryName,
+          "hash"
+        ]);
+        const cachedEntryContent = cachedEntry.hash === hash ? cachedEntry.content : {};
+        const content = _3({
+          ...cachedEntryContent,
+          [dictionary.locale]: entry
+        }).toPairs().sortBy([0]).fromPairs().value();
+        return { content, hash };
+      }).toPairs().sortBy([0]).fromPairs().value()
+    })).toPairs().sortBy([0]).fromPairs().value();
+    const newCache = {
+      version: dictionary.version,
+      files
+    };
+    return newCache;
+  }
+  // extract dictionary from cache for given locale, validate entry hash from LCP schema
+  static _extractLocaleDictionary(cache, locale, lcp) {
+    const findCachedEntry = (hash) => {
+      const cachedEntry = _3(cache.files).flatMap((file) => _3.values(file.entries)).find((entry) => entry.hash === hash);
+      if (cachedEntry) {
+        return cachedEntry.content[locale];
+      }
+      return void 0;
+    };
+    const files = _3(lcp.files).mapValues((file) => {
+      return {
+        entries: _3(file.scopes).mapValues((entry) => {
+          return findCachedEntry(entry.hash);
+        }).pickBy((value) => value !== void 0).value()
+      };
+    }).pickBy((file) => !_3.isEmpty(file.entries)).value();
+    const dictionary = {
+      version: cache.version,
+      locale,
+      files
+    };
+    return dictionary;
+  }
+  // format with prettier
+  static async _format(cachedContent, cachePath) {
+    try {
+      const config2 = await prettier.resolveConfig(cachePath);
+      const prettierOptions = {
+        ...config2 ?? {},
+        parser: config2?.parser ? config2.parser : "typescript"
+      };
+      return await prettier.format(cachedContent, prettierOptions);
+    } catch (error) {
+    }
+    return cachedContent;
+  }
+  // write cache to file as JSON
+  static async _write(dictionaryCache, params) {
+    const cachePath = this._getCachePath(params);
+    const cache = `export default ${JSON.stringify(dictionaryCache, null, 2)};`;
+    const formattedCache = await this._format(cache, cachePath);
+    fs2.writeFileSync(cachePath, formattedCache);
+  }
+  // read cache from file as JSON
+  static _read(params) {
+    const cachePath = this._getCachePath(params);
+    if (!fs2.existsSync(cachePath)) {
+      return {
+        version: 0.1,
+        files: {}
+      };
+    }
+    const jsObjectString = fs2.readFileSync(cachePath, "utf8");
+    const cache = jsObjectString.replace(/^export default/, "").replace(/;\s*$/, "");
+    const obj = new Function(`return (${cache})`)();
+    return obj;
+  }
+  // get cache file path
+  static _getCachePath(params) {
+    return path2.resolve(
+      process.cwd(),
+      params.sourceRoot,
+      params.lingoDir,
+      LCP_DICTIONARY_FILE_NAME
+    );
+  }
+};
+
+// src/lib/lcp/api/index.ts
+import { createGroq } from "@ai-sdk/groq";
+import { generateText } from "ai";
+import _6 from "lodash";
+
+// src/utils/locales.ts
+function getInvalidLocales(localeModels, sourceLocale, targetLocales) {
+  return targetLocales.filter((targetLocale) => {
+    const { provider, model } = getLocaleModel(
+      localeModels,
+      sourceLocale,
+      targetLocale
+    );
+    return provider === void 0 || model === void 0;
+  });
+}
+function getLocaleModel(localeModels, sourceLocale, targetLocale) {
+  const localeKeys = [
+    `${sourceLocale}:${targetLocale}`,
+    `*:${targetLocale}`,
+    `${sourceLocale}:*`,
+    "*:*"
+  ];
+  const modelKey = localeKeys.find((key) => localeModels.hasOwnProperty(key));
+  if (modelKey) {
+    const [provider, model] = localeModels[modelKey]?.split(":");
+    if (provider && model) {
+      return { provider, model };
+    }
+  }
+  return { provider: void 0, model: void 0 };
+}
+
+// src/lib/lcp/api/prompt.ts
+var prompt_default = (args) => {
+  return getUserSystemPrompt(args) || getBuiltInSystemPrompt(args);
+};
+function getUserSystemPrompt(args) {
+  const userPrompt = args.prompt?.trim()?.replace("{SOURCE_LOCALE}", args.sourceLocale)?.replace("{TARGET_LOCALE}", args.targetLocale);
+  if (userPrompt) {
+    console.log("\u2728 Compiler is using user-defined prompt.");
+    return userPrompt;
+  }
+  return void 0;
+}
+function getBuiltInSystemPrompt(args) {
+  return `
+# Identity
+
+You are an advanced AI localization engine. You do state-of-the-art localization for software products.
+Your task is to localize pieces of data from one locale to another locale.
+You always consider context, cultural nuances of source and target locales, and specific localization requirements.
+You replicate the meaning, intent, style, tone, and purpose of the original data.
+
+## Setup
+
+Source language (locale code): ${args.sourceLocale}
+Target language (locale code): ${args.targetLocale}
+
+## Guidelines
+
+Follow these guidelines for translation:
+
+1. Analyze the source text to understand its overall context and purpose
+2. Translate the meaning and intent rather than word-for-word translation
+3. Rephrase and restructure sentences to sound natural and fluent in the target language
+4. Adapt idiomatic expressions and cultural references for the target audience
+5. Maintain the style and tone of the source text
+6. You must produce valid UTF-8 encoded output
+7. YOU MUST ONLY PRODUCE VALID XML.
+
+## Special Instructions
+
+Do not localize any of these technical elements:
+- Variables like {variable}, {variable.key}, {data[type]}
+- Expressions like <expression/>
+- Functions like <function:value/>, <function:getDisplayName/>
+- Elements like <element:strong>, </element:strong>, <element:LuPlus>, </element:LuPlus>, <element:LuSparkles>, </element:LuSparkles>
+
+Remember, you are a context-aware multilingual assistant helping international companies.
+Your goal is to perform state-of-the-art localization for software products and content.
+`;
+}
+
+// src/lib/lcp/api/xml2obj.ts
+import { XMLParser, XMLBuilder } from "fast-xml-parser";
+import _4 from "lodash";
+var TAG_OBJECT = "object";
+var TAG_ARRAY = "array";
+var TAG_VALUE = "value";
+function _toGenericNode(value, key) {
+  if (_4.isArray(value)) {
+    const children = _4.map(value, (item) => _toGenericNode(item));
+    return {
+      [TAG_ARRAY]: {
+        ...key ? { key } : {},
+        ..._groupChildren(children)
+      }
+    };
+  }
+  if (_4.isPlainObject(value)) {
+    const children = _4.map(
+      Object.entries(value),
+      ([k, v]) => _toGenericNode(v, k)
+    );
+    return {
+      [TAG_OBJECT]: {
+        ...key ? { key } : {},
+        ..._groupChildren(children)
+      }
+    };
+  }
+  return {
+    [TAG_VALUE]: {
+      ...key ? { key } : {},
+      "#text": value ?? ""
+    }
+  };
+}
+function _groupChildren(nodes) {
+  return _4(nodes).groupBy((node) => Object.keys(node)[0]).mapValues((arr) => _4.map(arr, (n) => n[Object.keys(n)[0]])).value();
+}
+function _fromGenericNode(tag, data) {
+  if (tag === TAG_VALUE) {
+    if (_4.isPlainObject(data)) {
+      return _4.get(data, "#text", "");
+    }
+    return data ?? "";
+  }
+  if (tag === TAG_ARRAY) {
+    const result = [];
+    _4.forEach([TAG_VALUE, TAG_OBJECT, TAG_ARRAY], (childTag) => {
+      const childNodes = _4.castArray(_4.get(data, childTag, []));
+      _4.forEach(childNodes, (child) => {
+        result.push(_fromGenericNode(childTag, child));
+      });
+    });
+    return result;
+  }
+  const obj = {};
+  _4.forEach([TAG_VALUE, TAG_OBJECT, TAG_ARRAY], (childTag) => {
+    const childNodes = _4.castArray(_4.get(data, childTag, []));
+    _4.forEach(childNodes, (child) => {
+      const key = _4.get(child, "key", "");
+      obj[key] = _fromGenericNode(childTag, child);
+    });
+  });
+  return obj;
+}
+function obj2xml(obj) {
+  const rootNode = _toGenericNode(obj)[TAG_OBJECT];
+  const builder = new XMLBuilder({
+    ignoreAttributes: false,
+    attributeNamePrefix: "",
+    format: true,
+    suppressEmptyNode: true
+  });
+  return builder.build({ [TAG_OBJECT]: rootNode });
+}
+function xml2obj(xml) {
+  const parser2 = new XMLParser({
+    ignoreAttributes: false,
+    attributeNamePrefix: "",
+    parseTagValue: true,
+    parseAttributeValue: false,
+    processEntities: true,
+    isArray: (name) => [TAG_VALUE, TAG_ARRAY, TAG_OBJECT].includes(name)
+  });
+  const parsed = parser2.parse(xml);
+  const withoutDeclaration = _4.omit(parsed, "?xml");
+  const rootTag = Object.keys(withoutDeclaration)[0];
+  const rootNode = _4.castArray(withoutDeclaration[rootTag])[0];
+  return _fromGenericNode(rootTag, rootNode);
+}
+
+// src/lib/lcp/api/shots.ts
+var shots_default = [
+  // Shot #1
+  [
+    {
+      version: 0.1,
+      locale: "en",
+      files: {
+        "demo-app/my-custom-header.tsx": {
+          entries: {
+            "1z2x3c4v": "Dashboard",
+            "5t6y7u8i": "Settings",
+            "9o0p1q2r": "Logout"
+          }
+        },
+        "demo-app/my-custom-footer.tsx": {
+          entries: {
+            "9k0l1m2n": "\xA9 2025 Lingo.dev. All rights reserved."
+          }
+        }
+      }
+    },
+    {
+      version: 0.1,
+      locale: "es",
+      files: {
+        "demo-app/my-custom-header.tsx": {
+          entries: {
+            "1z2x3c4v": "Panel de control",
+            "5t6y7u8i": "Configuraci\xF3n",
+            "9o0p1q2r": "Cerrar sesi\xF3n"
+          }
+        },
+        "demo-app/my-custom-footer.tsx": {
+          entries: {
+            "9k0l1m2n": "\xA9 2025 Lingo.dev. Todos los derechos reservados."
+          }
+        }
+      }
+    }
+  ]
+  // More shots here...
+];
+
+// src/utils/rc.ts
+import os from "os";
+import path3 from "path";
+import fs3 from "fs";
+import Ini from "ini";
+function getRc() {
+  const settingsFile = ".lingodotdevrc";
+  const homedir = os.homedir();
+  const settingsFilePath = path3.join(homedir, settingsFile);
+  const content = fs3.existsSync(settingsFilePath) ? fs3.readFileSync(settingsFilePath, "utf-8") : "";
+  const data = Ini.parse(content);
+  return data;
+}
+
+// src/utils/groq.ts
+import _5 from "lodash";
+import * as dotenv from "dotenv";
+function getGroqKey() {
+  return getGroqKeyFromEnv() || getGroqKeyFromRc();
+}
+function getGroqKeyFromRc() {
+  const rc = getRc();
+  const result = _5.get(rc, "llm.groqApiKey");
+  return result;
+}
+function getGroqKeyFromEnv() {
+  const ephemeralEnv = {
+    GROQ_API_KEY: process.env.GROQ_API_KEY
+  };
+  dotenv.config({ processEnv: ephemeralEnv });
+  return ephemeralEnv.GROQ_API_KEY;
+}
+
+// src/lib/lcp/api/index.ts
+import dedent from "dedent";
+
+// src/utils/env.ts
+import fs4 from "fs";
+function isRunningInCIOrDocker() {
+  return Boolean(process.env.CI) || fs4.existsSync("/.dockerenv");
+}
+
+// src/lib/lcp/api/index.ts
+var LCPAPI = class {
+  static async translate(models, sourceDictionary, sourceLocale, targetLocale) {
+    const timeLabel = `LCPAPI.translate: ${targetLocale}`;
+    console.time(timeLabel);
+    const chunks = this._chunkDictionary(sourceDictionary);
+    const translatedChunks = [];
+    for (const chunk of chunks) {
+      const translatedChunk = await this._translateChunk(
+        models,
+        chunk,
+        sourceLocale,
+        targetLocale
+      );
+      translatedChunks.push(translatedChunk);
+    }
+    const result = this._mergeDictionaries(translatedChunks);
+    console.timeEnd(timeLabel);
+    return result;
+  }
+  static _chunkDictionary(dictionary) {
+    const MAX_ENTRIES_PER_CHUNK = 100;
+    const { files, ...rest } = dictionary;
+    const chunks = [];
+    let currentChunk = {
+      ...rest,
+      files: {}
+    };
+    let currentEntryCount = 0;
+    Object.entries(files).forEach(([fileName, file]) => {
+      const entries = file.entries;
+      const entryPairs = Object.entries(entries);
+      let currentIndex = 0;
+      while (currentIndex < entryPairs.length) {
+        const remainingSpace = MAX_ENTRIES_PER_CHUNK - currentEntryCount;
+        const entriesToAdd = entryPairs.slice(
+          currentIndex,
+          currentIndex + remainingSpace
+        );
+        if (entriesToAdd.length > 0) {
+          currentChunk.files[fileName] = currentChunk.files[fileName] || {
+            entries: {}
+          };
+          currentChunk.files[fileName].entries = {
+            ...currentChunk.files[fileName].entries,
+            ...Object.fromEntries(entriesToAdd)
+          };
+          currentEntryCount += entriesToAdd.length;
+        }
+        currentIndex += entriesToAdd.length;
+        if (currentEntryCount >= MAX_ENTRIES_PER_CHUNK || currentIndex < entryPairs.length && currentEntryCount + (entryPairs.length - currentIndex) > MAX_ENTRIES_PER_CHUNK) {
+          chunks.push(currentChunk);
+          currentChunk = { ...rest, files: {} };
+          currentEntryCount = 0;
+        }
+      }
+    });
+    if (currentEntryCount > 0) {
+      chunks.push(currentChunk);
+    }
+    return chunks;
+  }
+  static _mergeDictionaries(dictionaries) {
+    const fileNames = _6.uniq(
+      _6.flatMap(dictionaries, (dict) => Object.keys(dict.files))
+    );
+    const files = _6(fileNames).map((fileName) => {
+      const entries = dictionaries.reduce((entries2, dict) => {
+        const file = dict.files[fileName];
+        if (file) {
+          entries2 = _6.merge(entries2, file.entries);
+        }
+        return entries2;
+      }, {});
+      return [fileName, { entries }];
+    }).fromPairs().value();
+    const dictionary = {
+      version: dictionaries[0].version,
+      locale: dictionaries[0].locale,
+      files
+    };
+    return dictionary;
+  }
+  static async _translateChunk(models, sourceDictionary, sourceLocale, targetLocale) {
+    try {
+      return await this._translateChunkGroq(
+        models,
+        sourceDictionary,
+        sourceLocale,
+        targetLocale
+      );
+    } catch (e) {
+      console.error(`\u26A0\uFE0F  Translation for ${targetLocale} failed:`, e);
+      return {
+        version: 0.1,
+        locale: targetLocale,
+        files: {}
+      };
+    }
+    if (isRunningInCIOrDocker()) {
+      const groqFromEnv = getGroqKeyFromEnv();
+      if (!groqFromEnv) {
+        this._failMissingGroqKeyCi();
+      }
+    }
+    throw new Error(
+      "\u26A0\uFE0F  No API key found. Please set GROQ_API_KEY environment variable. If you dont have one go to https://groq.com/"
+    );
+  }
+  static async _translateChunkGroq(models, sourceDictionary, sourceLocale, targetLocale) {
+    const groq = createGroq({ apiKey: getGroqKey() });
+    console.log(`Created Groq client for ${targetLocale}`);
+    const { provider, model } = getLocaleModel(
+      models,
+      sourceLocale,
+      targetLocale
+    );
+    if (!model) {
+      throw new Error(
+        `\u26A0\uFE0F  Locale ${targetLocale} is not configured. Add model for this locale to your config.`
+      );
+    }
+    if (provider !== "groq") {
+      throw new Error(
+        `\u26A0\uFE0F  Provider ${provider} is not supported. Only "groq" provider is supported at the moment.`
+      );
+    }
+    console.log(
+      `\u2728 Using model "${model}" from "${provider}" to translate from "${sourceLocale}" to "${targetLocale}"`
+    );
+    const groqModel = groq(model);
+    console.log(`Created model ${model}`);
+    const response = await generateText({
+      model: groqModel,
+      messages: [
+        {
+          role: "system",
+          content: prompt_default({ sourceLocale, targetLocale })
+        },
+        ...shots_default.flatMap((shotsTuple) => [
+          {
+            role: "user",
+            content: obj2xml(shotsTuple[0])
+          },
+          {
+            role: "assistant",
+            content: obj2xml(shotsTuple[1])
+          }
+        ]),
+        {
+          role: "user",
+          content: obj2xml(sourceDictionary)
+        }
+      ]
+    });
+    console.log("Response", response.text);
+    let responseText = response.text;
+    responseText = responseText.substring(
+      responseText.indexOf("<"),
+      responseText.lastIndexOf(">") + 1
+    );
+    return xml2obj(responseText);
+  }
+  /**
+   * Show an actionable error message and exit the process when the compiler
+   * is running in CI/CD without a GROQ API key.
+   * The message explains why this situation is unusual and how to fix it.
+   */
+  static _failMissingGroqKeyCi() {
+    console.log(
+      dedent`
+        \n
+        💡 You're using Lingo.dev Localization Compiler, and it detected unlocalized components in your app.
+
+        The compiler needs a GROQ API key to translate missing strings, but GROQ_API_KEY is not set in the environment.
+
+        This is unexpected: typically you run a full build locally, commit the generated translation files, and push them to CI/CD.
+
+        However, If you want CI/CD to translate the new strings, provide the key with:
+        • Session-wide: export GROQ_API_KEY=<your-api-key>
+        • Project-wide / CI: add GROQ_API_KEY=<your-api-key> to your pipeline environment variables
+
+        ⭐️ Also:
+        1. If you don't yet have a GROQ API key, get one for free at https://groq.com
+        2. If you want to use a different LLM, raise an issue in our open-source repo: https://lingo.dev/go/gh
+        3. If you have questions, feature requests, or would like to contribute, join our Discord: https://lingo.dev/go/discord
+
+        ✨
+      `
+    );
+    process.exit(1);
+  }
+};
+
+// src/lib/lcp/server.ts
+var LCPServer = class {
+  static isLoading = false;
+  static async loadDictionaries(params) {
+    while (this.isLoading) {
+      await new Promise(function(resolve3) {
+        setTimeout(resolve3, 500);
+      });
+    }
+    this.isLoading = true;
+    const targetLocales = _7.uniq([
+      ...params.targetLocales,
+      params.sourceLocale
+    ]);
+    const dictionaries = await Promise.all(
+      targetLocales.map(
+        (targetLocale) => this.loadDictionaryForLocale({ ...params, targetLocale })
+      )
+    );
+    const result = _7.fromPairs(
+      targetLocales.map((targetLocale, index) => [
+        targetLocale,
+        dictionaries[index]
+      ])
+    );
+    this.isLoading = false;
+    return result;
+  }
+  static async loadDictionaryForLocale(params) {
+    const sourceDictionary = this._extractSourceDictionary(
+      params.lcp,
+      params.sourceLocale,
+      params.targetLocale
+    );
+    const cacheParams = {
+      lcp: params.lcp,
+      sourceLocale: params.sourceLocale,
+      lingoDir: params.lingoDir,
+      sourceRoot: params.sourceRoot
+    };
+    if (this._countDictionaryEntries(sourceDictionary) === 0) {
+      console.log(
+        "Source dictionary is empty, returning empty dictionary for target locale"
+      );
+      return { ...sourceDictionary, locale: params.targetLocale };
+    }
+    const cache = LCPCache.readLocaleDictionary(
+      params.targetLocale,
+      cacheParams
+    );
+    const uncachedSourceDictionary = this._getDictionaryDiff(
+      sourceDictionary,
+      cache
+    );
+    let targetDictionary;
+    let newTranslations;
+    if (this._countDictionaryEntries(uncachedSourceDictionary) === 0) {
+      targetDictionary = cache;
+    } else if (params.targetLocale === params.sourceLocale) {
+      console.log(
+        "\u2139\uFE0F  Lingo.dev returns source dictionary - source and target locales are the same"
+      );
+      await LCPCache.writeLocaleDictionary(sourceDictionary, cacheParams);
+      return sourceDictionary;
+    } else {
+      newTranslations = await LCPAPI.translate(
+        params.models,
+        uncachedSourceDictionary,
+        params.sourceLocale,
+        params.targetLocale
+      );
+      targetDictionary = this._mergeDictionaries(newTranslations, cache);
+      await LCPCache.writeLocaleDictionary(targetDictionary, cacheParams);
+    }
+    const targetDictionaryWithFallback = this._mergeDictionaries(
+      targetDictionary,
+      sourceDictionary,
+      true
+    );
+    const result = this._addOverridesToDictionary(
+      targetDictionaryWithFallback,
+      params.lcp,
+      params.targetLocale
+    );
+    if (newTranslations) {
+      console.log(
+        `\u2139\uFE0F  Lingo.dev dictionary for ${params.targetLocale}:
+- %d entries
+- %d cached
+- %d uncached
+- %d translated
+- %d overrides`,
+        this._countDictionaryEntries(result),
+        this._countDictionaryEntries(cache),
+        this._countDictionaryEntries(uncachedSourceDictionary),
+        newTranslations ? this._countDictionaryEntries(newTranslations) : 0,
+        this._countDictionaryEntries(result) - this._countDictionaryEntries(targetDictionary)
+      );
+    }
+    return result;
+  }
+  static _extractSourceDictionary(lcp, sourceLocale, targetLocale) {
+    const dictionary = {
+      version: 0.1,
+      locale: sourceLocale,
+      files: {}
+    };
+    for (const [fileKey, fileData] of Object.entries(lcp.files || {})) {
+      for (const [scopeKey, scopeData] of Object.entries(
+        fileData.scopes || {}
+      )) {
+        if (scopeData.skip) {
+          continue;
+        }
+        if (this._getScopeLocaleOverride(scopeData, targetLocale)) {
+          continue;
+        }
+        _7.set(
+          dictionary,
+          [
+            "files",
+            fileKey,
+            "entries",
+            scopeKey
+          ],
+          scopeData.content
+        );
+      }
+    }
+    return dictionary;
+  }
+  static _addOverridesToDictionary(dictionary, lcp, targetLocale) {
+    for (const [fileKey, fileData] of Object.entries(lcp.files || {})) {
+      for (const [scopeKey, scopeData] of Object.entries(
+        fileData.scopes || {}
+      )) {
+        const override = this._getScopeLocaleOverride(scopeData, targetLocale);
+        if (!override) {
+          continue;
+        }
+        _7.set(
+          dictionary,
+          [
+            "files",
+            fileKey,
+            "entries",
+            scopeKey
+          ],
+          override
+        );
+      }
+    }
+    return dictionary;
+  }
+  static _getScopeLocaleOverride(scopeData, locale) {
+    return _7.get(scopeData.overrides, locale) ?? null;
+  }
+  static _getDictionaryDiff(sourceDictionary, targetDictionary) {
+    if (this._countDictionaryEntries(targetDictionary) === 0) {
+      return sourceDictionary;
+    }
+    const files = _7(sourceDictionary.files).mapValues((file, fileName) => ({
+      ...file,
+      entries: _7(file.entries).mapValues((entry, entryName) => {
+        const targetEntry = _7.get(targetDictionary.files, [
+          fileName,
+          "entries",
+          entryName
+        ]);
+        if (targetEntry !== void 0) {
+          return void 0;
+        }
+        return entry;
+      }).pickBy((value) => value !== void 0).value()
+    })).pickBy((value) => Object.keys(value.entries).length > 0).value();
+    const dictionary = {
+      version: sourceDictionary.version,
+      locale: sourceDictionary.locale,
+      files
+    };
+    return dictionary;
+  }
+  static _mergeDictionaries(sourceDictionary, targetDictionary, removeEmptyEntries = false) {
+    const fileNames = _7.uniq([
+      ...Object.keys(sourceDictionary.files),
+      ...Object.keys(targetDictionary.files)
+    ]);
+    const files = _7(fileNames).map((fileName) => {
+      const sourceFile = _7.get(sourceDictionary.files, fileName);
+      const targetFile = _7.get(targetDictionary.files, fileName);
+      const entries = removeEmptyEntries ? _7.pickBy(sourceFile?.entries, (value) => value.trim().length > 0) : sourceFile?.entries;
+      return [
+        fileName,
+        {
+          ...targetFile,
+          entries: _7.merge(targetFile?.entries, entries)
+        }
+      ];
+    }).fromPairs().value();
+    const dictionary = {
+      version: sourceDictionary.version,
+      locale: sourceDictionary.locale,
+      files
+    };
+    return dictionary;
+  }
+  static _countDictionaryEntries(dict) {
+    return Object.values(dict.files).reduce(
+      (sum, file) => sum + Object.keys(file.entries).length,
+      0
+    );
+  }
+};
+
+// src/utils/invokations.ts
+import * as t11 from "@babel/types";
+import traverse6 from "@babel/traverse";
+function findInvokations(ast, params) {
+  const result = [];
+  traverse6(ast, {
+    ImportDeclaration(path6) {
+      if (path6.node.source.value !== params.moduleName) return;
+      const importNames = /* @__PURE__ */ new Map();
+      const specifiers = path6.node.specifiers;
+      specifiers.forEach((specifier) => {
+        if (t11.isImportSpecifier(specifier) && t11.isIdentifier(specifier.imported) && specifier.imported.name === params.functionName) {
+          importNames.set(specifier.local.name, true);
+        } else if (t11.isImportDefaultSpecifier(specifier) && params.functionName === "default") {
+          importNames.set(specifier.local.name, true);
+        } else if (t11.isImportNamespaceSpecifier(specifier)) {
+          importNames.set(specifier.local.name, "namespace");
+        }
+      });
+      collectCallExpressions(path6, importNames, result, params.functionName);
+    }
+  });
+  return result;
+}
+function collectCallExpressions(path6, importNames, result, functionName) {
+  const program = path6.findParent(
+    (p) => p.isProgram()
+  );
+  if (!program) return;
+  program.traverse({
+    CallExpression(callPath) {
+      const callee = callPath.node.callee;
+      if (t11.isIdentifier(callee) && importNames.has(callee.name)) {
+        result.push(callPath.node);
+      } else if (t11.isMemberExpression(callee) && t11.isIdentifier(callee.object) && importNames.get(callee.object.name) === "namespace" && t11.isIdentifier(callee.property) && callee.property.name === functionName) {
+        result.push(callPath.node);
+      }
+    }
+  });
+}
+
+// src/rsc-dictionary-loader.ts
+import * as t12 from "@babel/types";
+var rscDictionaryLoaderMutation = createCodeMutation((payload) => {
+  const mode = getModuleExecutionMode(payload.ast, payload.params.rsc);
+  if (mode === "client") {
+    return payload;
+  }
+  const invokations = findInvokations(payload.ast, {
+    moduleName: "lingo.dev/react/rsc" /* ReactRSC */,
+    functionName: "loadDictionary"
+  });
+  const allLocales = Array.from(
+    /* @__PURE__ */ new Set([payload.params.sourceLocale, ...payload.params.targetLocales])
+  );
+  for (const invokation of invokations) {
+    const internalDictionaryLoader = getOrCreateImport(payload.ast, {
+      moduleName: "lingo.dev/react/rsc" /* ReactRSC */,
+      exportedName: "loadDictionary_internal"
+    });
+    if (t12.isIdentifier(invokation.callee)) {
+      invokation.callee.name = internalDictionaryLoader.importedName;
+    }
+    const localeImportMap = t12.objectExpression(
+      allLocales.map(
+        (locale) => t12.objectProperty(
+          t12.identifier(locale),
+          t12.arrowFunctionExpression(
+            [],
+            t12.callExpression(t12.identifier("import"), [
+              t12.stringLiteral(
+                `@/${payload.params.lingoDir}/${LCP_DICTIONARY_FILE_NAME}?locale=${locale}`
+              )
+            ])
+          )
+        )
+      )
+    );
+    invokation.arguments.push(localeImportMap);
+  }
+  return payload;
+});
+
+// src/react-router-dictionary-loader.ts
+import * as t13 from "@babel/types";
+var reactRouterDictionaryLoaderMutation = createCodeMutation(
+  (payload) => {
+    const mode = getModuleExecutionMode(payload.ast, payload.params.rsc);
+    if (mode === "server") {
+      return payload;
+    }
+    const invokations = findInvokations(payload.ast, {
+      moduleName: "lingo.dev/react/react-router" /* ReactRouter */,
+      functionName: "loadDictionary"
+    });
+    const allLocales = Array.from(
+      /* @__PURE__ */ new Set([payload.params.sourceLocale, ...payload.params.targetLocales])
+    );
+    for (const invokation of invokations) {
+      const internalDictionaryLoader = getOrCreateImport(payload.ast, {
+        moduleName: "lingo.dev/react/react-router" /* ReactRouter */,
+        exportedName: "loadDictionary_internal"
+      });
+      if (t13.isIdentifier(invokation.callee)) {
+        invokation.callee.name = internalDictionaryLoader.importedName;
+      }
+      const localeImportMap = t13.objectExpression(
+        allLocales.map(
+          (locale) => t13.objectProperty(
+            t13.identifier(locale),
+            t13.arrowFunctionExpression(
+              [],
+              t13.callExpression(t13.identifier("import"), [
+                t13.stringLiteral(
+                  `~/${payload.params.lingoDir}/${LCP_DICTIONARY_FILE_NAME}?locale=${locale}`
+                )
+              ])
+            )
+          )
+        )
+      );
+      invokation.arguments.push(localeImportMap);
+    }
+    return payload;
+  }
+);
+
+// src/jsx-fragment.ts
+import traverse7 from "@babel/traverse";
+import * as t14 from "@babel/types";
+function jsxFragmentMutation(payload) {
+  const { ast } = payload;
+  let foundFragments = false;
+  let fragmentImportName = null;
+  traverse7(ast, {
+    ImportDeclaration(path6) {
+      if (path6.node.source.value !== "react") return;
+      for (const specifier of path6.node.specifiers) {
+        if (t14.isImportSpecifier(specifier) && t14.isIdentifier(specifier.imported) && specifier.imported.name === "Fragment") {
+          fragmentImportName = specifier.local.name;
+          path6.stop();
+        }
+      }
+    }
+  });
+  traverse7(ast, {
+    JSXFragment(path6) {
+      foundFragments = true;
+      if (!fragmentImportName) {
+        const result = getOrCreateImport(ast, {
+          exportedName: "Fragment",
+          moduleName: "react"
+        });
+        fragmentImportName = result.importedName;
+      }
+      const fragmentElement = t14.jsxElement(
+        t14.jsxOpeningElement(t14.jsxIdentifier(fragmentImportName), [], false),
+        t14.jsxClosingElement(t14.jsxIdentifier(fragmentImportName)),
+        path6.node.children,
+        false
+      );
+      path6.replaceWith(fragmentElement);
+    }
+  });
+  return payload;
+}
+
+// src/jsx-html-lang.ts
+import traverse8 from "@babel/traverse";
+import * as t15 from "@babel/types";
+var jsxHtmlLangMutation = createCodeMutation((payload) => {
+  traverse8(payload.ast, {
+    JSXElement: (path6) => {
+      if (getJsxElementName(path6)?.toLowerCase() === "html") {
+        const mode = getModuleExecutionMode(payload.ast, payload.params.rsc);
+        const packagePath = mode === "client" ? "lingo.dev/react/client" /* ReactClient */ : "lingo.dev/react/rsc" /* ReactRSC */;
+        const lingoHtmlComponentImport = getOrCreateImport(payload.ast, {
+          moduleName: packagePath,
+          exportedName: "LingoHtmlComponent"
+        });
+        path6.node.openingElement.name = t15.jsxIdentifier(
+          lingoHtmlComponentImport.importedName
+        );
+        if (path6.node.closingElement) {
+          path6.node.closingElement.name = t15.jsxIdentifier(
+            lingoHtmlComponentImport.importedName
+          );
+        }
+        path6.skip();
+      }
+    }
+  });
+  return payload;
+});
+
+// src/utils/hash.ts
+import { MD5 } from "object-hash";
+function getJsxElementHash(nodePath) {
+  if (!nodePath.node) {
+    return "";
+  }
+  const content = nodePath.node.children.map((child) => child.value).join("");
+  const result = MD5(content);
+  return result;
+}
+function getJsxAttributeValueHash(attributeValue) {
+  if (!attributeValue) {
+    return "";
+  }
+  const result = MD5(attributeValue);
+  return result;
+}
+
+// src/jsx-attribute-scopes-export.ts
+import _8 from "lodash";
+function jsxAttributeScopesExportMutation(payload) {
+  const attributeScopes = collectJsxAttributeScopes(payload.ast);
+  if (_8.isEmpty(attributeScopes)) {
+    return payload;
+  }
+  const lcp = LCP.getInstance({
+    sourceRoot: payload.params.sourceRoot,
+    lingoDir: payload.params.lingoDir
+  });
+  for (const [scope, attributes] of attributeScopes) {
+    for (const attributeDefinition of attributes) {
+      const [attribute, scopeKey] = attributeDefinition.split(":");
+      lcp.resetScope(payload.fileKey, scopeKey);
+      const attributeValue = getJsxAttributeValue(scope, attribute);
+      if (!attributeValue) {
+        continue;
+      }
+      lcp.setScopeType(payload.fileKey, scopeKey, "attribute");
+      const hash = getJsxAttributeValueHash(String(attributeValue));
+      lcp.setScopeHash(payload.fileKey, scopeKey, hash);
+      lcp.setScopeContext(payload.fileKey, scopeKey, "");
+      lcp.setScopeSkip(payload.fileKey, scopeKey, false);
+      lcp.setScopeOverrides(payload.fileKey, scopeKey, {});
+      lcp.setScopeContent(payload.fileKey, scopeKey, String(attributeValue));
+    }
+  }
+  lcp.save();
+  return payload;
+}
+
+// src/jsx-scopes-export.ts
+import _10 from "lodash";
+
+// src/utils/jsx-content.ts
+import * as t16 from "@babel/types";
+import _9 from "lodash";
+var WHITESPACE_PLACEHOLDER = "[lingo-whitespace-placeholder]";
+function extractJsxContent(nodePath, replaceWhitespacePlaceholders = true) {
+  const chunks = [];
+  nodePath.traverse({
+    JSXElement(path6) {
+      if (path6.parent === nodePath.node) {
+        const content = extractJsxContent(path6, false);
+        const name = getJsxElementName(path6);
+        chunks.push(`<element:${name}>${content}</element:${name}>`);
+        path6.skip();
+      }
+    },
+    JSXText(path6) {
+      chunks.push(path6.node.value);
+    },
+    JSXExpressionContainer(path6) {
+      if (path6.parent !== nodePath.node) {
+        return;
+      }
+      const expr = path6.node.expression;
+      if (t16.isCallExpression(expr)) {
+        let key = "";
+        if (t16.isIdentifier(expr.callee)) {
+          key = `${expr.callee.name}`;
+        } else if (t16.isMemberExpression(expr.callee)) {
+          let firstCallee = expr.callee;
+          while (t16.isMemberExpression(firstCallee) && t16.isCallExpression(firstCallee.object)) {
+            firstCallee = firstCallee.object.callee;
+          }
+          let current = firstCallee;
+          const parts = [];
+          while (t16.isMemberExpression(current)) {
+            if (t16.isIdentifier(current.property)) {
+              parts.unshift(current.property.name);
+            }
+            current = current.object;
+          }
+          if (t16.isIdentifier(current)) {
+            parts.unshift(current.name);
+          }
+          if (t16.isMemberExpression(firstCallee) && t16.isNewExpression(firstCallee.object) && t16.isIdentifier(firstCallee.object.callee)) {
+            parts.unshift(firstCallee.object.callee.name);
+          }
+          key = parts.join(".");
+        }
+        chunks.push(`<function:${key}/>`);
+      } else if (t16.isIdentifier(expr)) {
+        chunks.push(`{${expr.name}}`);
+      } else if (t16.isMemberExpression(expr)) {
+        let current = expr;
+        const parts = [];
+        while (t16.isMemberExpression(current)) {
+          if (t16.isIdentifier(current.property)) {
+            if (current.computed) {
+              parts.unshift(`[${current.property.name}]`);
+            } else {
+              parts.unshift(current.property.name);
+            }
+          }
+          current = current.object;
+        }
+        if (t16.isIdentifier(current)) {
+          parts.unshift(current.name);
+          chunks.push(`{${parts.join(".").replaceAll(".[", "[")}}`);
+        }
+      } else if (isWhitespace(path6)) {
+        chunks.push(WHITESPACE_PLACEHOLDER);
+      } else if (isExpression2(path6)) {
+        chunks.push("<expression/>");
+      }
+      path6.skip();
+    }
+  });
+  const result = chunks.join("");
+  const normalized = normalizeJsxWhitespace(result);
+  if (replaceWhitespacePlaceholders) {
+    return normalized.replaceAll(WHITESPACE_PLACEHOLDER, " ");
+  }
+  return normalized;
+}
+var compilerProps = ["data-jsx-attribute-scope", "data-jsx-scope"];
+function isExpression2(nodePath) {
+  const isCompilerExpression = !_9.isArray(nodePath.container) && t16.isJSXAttribute(nodePath.container) && t16.isJSXIdentifier(nodePath.container.name) && compilerProps.includes(nodePath.container.name.name);
+  return !isCompilerExpression && !t16.isJSXEmptyExpression(nodePath.node.expression);
+}
+function isWhitespace(nodePath) {
+  const expr = nodePath.node.expression;
+  return t16.isStringLiteral(expr) && expr.value === " ";
+}
+function normalizeJsxWhitespace(input) {
+  const lines = input.split("\n");
+  let result = "";
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (line === "") continue;
+    if (i > 0 && (line.startsWith("<element:") || line.startsWith("<function:") || line.startsWith("{") || line.startsWith("<expression/>"))) {
+      result += line;
+    } else {
+      if (result && !result.endsWith(" ")) result += " ";
+      result += line;
+    }
+  }
+  result = result.replace(/\s+/g, " ");
+  return result.trim();
+}
+
+// src/jsx-scopes-export.ts
+function jsxScopesExportMutation(payload) {
+  const scopes = collectJsxScopes(payload.ast);
+  if (_10.isEmpty(scopes)) {
+    return payload;
+  }
+  const lcp = LCP.getInstance({
+    sourceRoot: payload.params.sourceRoot,
+    lingoDir: payload.params.lingoDir
+  });
+  for (const scope of scopes) {
+    const scopeKey = getAstKey(scope);
+    lcp.resetScope(payload.fileKey, scopeKey);
+    lcp.setScopeType(payload.fileKey, scopeKey, "element");
+    const hash = getJsxElementHash(scope);
+    lcp.setScopeHash(payload.fileKey, scopeKey, hash);
+    const context = getJsxAttributeValue(scope, "data-lingo-context");
+    lcp.setScopeContext(payload.fileKey, scopeKey, String(context || ""));
+    const skip = getJsxAttributeValue(scope, "data-lingo-skip");
+    lcp.setScopeSkip(payload.fileKey, scopeKey, Boolean(skip || false));
+    const attributesMap = getJsxAttributesMap(scope);
+    const overrides = _10.chain(attributesMap).entries().filter(
+      ([attributeKey]) => attributeKey.startsWith("data-lingo-override-")
+    ).map(([k, v]) => [k.split("data-lingo-override-")[1], v]).filter(([k]) => !!k).filter(([, v]) => !!v).fromPairs().value();
+    lcp.setScopeOverrides(payload.fileKey, scopeKey, overrides);
+    const content = extractJsxContent(scope);
+    lcp.setScopeContent(payload.fileKey, scopeKey, content);
+  }
+  lcp.save();
+  return payload;
+}
+
+// src/jsx-attribute-scope-inject.ts
+import * as t17 from "@babel/types";
+var lingoJsxAttributeScopeInjectMutation = createCodeMutation(
+  (payload) => {
+    const mode = getModuleExecutionMode(payload.ast, payload.params.rsc);
+    const jsxAttributeScopes = collectJsxAttributeScopes(payload.ast);
+    for (const [jsxScope, attributes] of jsxAttributeScopes) {
+      const packagePath = mode === "client" ? "lingo.dev/react/client" /* ReactClient */ : "lingo.dev/react/rsc" /* ReactRSC */;
+      const lingoComponentImport = getOrCreateImport(payload.ast, {
+        moduleName: packagePath,
+        exportedName: "LingoAttributeComponent"
+      });
+      const originalJsxElementName = getJsxElementName(jsxScope);
+      if (!originalJsxElementName) {
+        continue;
+      }
+      jsxScope.node.openingElement.name = t17.jsxIdentifier(
+        lingoComponentImport.importedName
+      );
+      if (jsxScope.node.closingElement) {
+        jsxScope.node.closingElement.name = t17.jsxIdentifier(
+          lingoComponentImport.importedName
+        );
+      }
+      const as = /^[A-Z]/.test(originalJsxElementName) ? t17.jsxExpressionContainer(t17.identifier(originalJsxElementName)) : t17.stringLiteral(originalJsxElementName);
+      jsxScope.node.openingElement.attributes.push(
+        t17.jsxAttribute(t17.jsxIdentifier("$attrAs"), as)
+      );
+      jsxScope.node.openingElement.attributes.push(
+        t17.jsxAttribute(
+          t17.jsxIdentifier("$fileKey"),
+          t17.stringLiteral(payload.fileKey)
+        )
+      );
+      jsxScope.node.openingElement.attributes.push(
+        t17.jsxAttribute(
+          t17.jsxIdentifier("$attributes"),
+          t17.jsxExpressionContainer(
+            t17.objectExpression(
+              attributes.map((attributeDefinition) => {
+                const [attribute, key = ""] = attributeDefinition.split(":");
+                return t17.objectProperty(
+                  t17.stringLiteral(attribute),
+                  t17.stringLiteral(key)
+                );
+              })
+            )
+          )
+        )
+      );
+      if (mode === "server") {
+        const loadDictionaryImport = getOrCreateImport(payload.ast, {
+          exportedName: "loadDictionary",
+          moduleName: "lingo.dev/react/rsc" /* ReactRSC */
+        });
+        jsxScope.node.openingElement.attributes.push(
+          t17.jsxAttribute(
+            t17.jsxIdentifier("$loadDictionary"),
+            t17.jsxExpressionContainer(
+              t17.arrowFunctionExpression(
+                [t17.identifier("locale")],
+                t17.callExpression(
+                  t17.identifier(loadDictionaryImport.importedName),
+                  [t17.identifier("locale")]
+                )
+              )
+            )
+          )
+        );
+      }
+    }
+    return payload;
+  }
+);
+
+// src/jsx-scope-inject.ts
+import * as t21 from "@babel/types";
+import _11 from "lodash";
+
+// src/utils/jsx-variables.ts
+import * as t18 from "@babel/types";
+var getJsxVariables = (nodePath) => {
+  const variables = /* @__PURE__ */ new Set();
+  nodePath.traverse({
+    JSXOpeningElement(path6) {
+      path6.skip();
+    },
+    JSXExpressionContainer(path6) {
+      if (t18.isIdentifier(path6.node.expression)) {
+        variables.add(path6.node.expression.name);
+      } else if (t18.isMemberExpression(path6.node.expression)) {
+        let current = path6.node.expression;
+        const parts = [];
+        while (t18.isMemberExpression(current)) {
+          if (t18.isIdentifier(current.property)) {
+            if (current.computed) {
+              parts.unshift(`[${current.property.name}]`);
+            } else {
+              parts.unshift(current.property.name);
+            }
+          }
+          current = current.object;
+        }
+        if (t18.isIdentifier(current)) {
+          parts.unshift(current.name);
+          variables.add(parts.join(".").replaceAll(".[", "["));
+        }
+      }
+      path6.skip();
+    }
+  });
+  const properties = Array.from(variables).map(
+    (name) => t18.objectProperty(t18.stringLiteral(name), t18.identifier(name))
+  );
+  const result = t18.objectExpression(properties);
+  return result;
+};
+
+// src/utils/jsx-functions.ts
+import * as t19 from "@babel/types";
+var getJsxFunctions = (nodePath) => {
+  const functions = /* @__PURE__ */ new Map();
+  let fnCounter = 0;
+  nodePath.traverse({
+    JSXOpeningElement(path6) {
+      path6.skip();
+    },
+    JSXExpressionContainer(path6) {
+      if (t19.isCallExpression(path6.node.expression)) {
+        let key = "";
+        if (t19.isIdentifier(path6.node.expression.callee)) {
+          key = `${path6.node.expression.callee.name}`;
+        } else if (t19.isMemberExpression(path6.node.expression.callee)) {
+          let firstCallee = path6.node.expression.callee;
+          while (t19.isMemberExpression(firstCallee) && t19.isCallExpression(firstCallee.object)) {
+            firstCallee = firstCallee.object.callee;
+          }
+          let current = firstCallee;
+          const parts = [];
+          while (t19.isMemberExpression(current)) {
+            if (t19.isIdentifier(current.property)) {
+              parts.unshift(current.property.name);
+            }
+            current = current.object;
+          }
+          if (t19.isIdentifier(current)) {
+            parts.unshift(current.name);
+          }
+          if (t19.isMemberExpression(firstCallee) && t19.isNewExpression(firstCallee.object) && t19.isIdentifier(firstCallee.object.callee)) {
+            parts.unshift(firstCallee.object.callee.name);
+          }
+          key = parts.join(".");
+        }
+        const existing = functions.get(key) ?? [];
+        functions.set(key, [...existing, path6.node.expression]);
+        fnCounter++;
+      }
+      path6.skip();
+    }
+  });
+  const properties = Array.from(functions.entries()).map(
+    ([name, callExpr]) => t19.objectProperty(t19.stringLiteral(name), t19.arrayExpression(callExpr))
+  );
+  return t19.objectExpression(properties);
+};
+
+// src/utils/jsx-expressions.ts
+import * as t20 from "@babel/types";
+var getJsxExpressions = (nodePath) => {
+  const expressions = [];
+  nodePath.traverse({
+    JSXOpeningElement(path6) {
+      path6.skip();
+    },
+    JSXExpressionContainer(path6) {
+      const expr = path6.node.expression;
+      if (!t20.isJSXEmptyExpression(expr) && !t20.isIdentifier(expr) && !t20.isMemberExpression(expr) && !t20.isCallExpression(expr) && !(t20.isStringLiteral(expr) && expr.value === " ")) {
+        expressions.push(expr);
+      }
+      path6.skip();
+    }
+  });
+  return t20.arrayExpression(expressions);
+};
+
+// src/jsx-scope-inject.ts
+var lingoJsxScopeInjectMutation = createCodeMutation((payload) => {
+  const mode = getModuleExecutionMode(payload.ast, payload.params.rsc);
+  const jsxScopes = collectJsxScopes(payload.ast);
+  for (const jsxScope of jsxScopes) {
+    const skip = getJsxAttributeValue(jsxScope, "data-lingo-skip");
+    if (skip) {
+      continue;
+    }
+    const packagePath = mode === "client" ? "lingo.dev/react/client" /* ReactClient */ : "lingo.dev/react/rsc" /* ReactRSC */;
+    const lingoComponentImport = getOrCreateImport(payload.ast, {
+      moduleName: packagePath,
+      exportedName: "LingoComponent"
+    });
+    const originalJsxScope = _11.cloneDeep(jsxScope);
+    const originalJsxElementName = getJsxElementName(jsxScope);
+    if (!originalJsxElementName) {
+      continue;
+    }
+    jsxScope.node.openingElement.name = t21.jsxIdentifier(
+      lingoComponentImport.importedName
+    );
+    if (jsxScope.node.closingElement) {
+      jsxScope.node.closingElement = null;
+      jsxScope.node.children = [];
+      jsxScope.node.selfClosing = true;
+      jsxScope.node.openingElement.selfClosing = true;
+    }
+    const as = /^[A-Z]/.test(originalJsxElementName) ? t21.jsxExpressionContainer(t21.identifier(originalJsxElementName)) : t21.stringLiteral(originalJsxElementName);
+    jsxScope.node.openingElement.attributes.push(
+      t21.jsxAttribute(t21.jsxIdentifier("$as"), as)
+    );
+    jsxScope.node.openingElement.attributes.push(
+      t21.jsxAttribute(
+        t21.jsxIdentifier("$fileKey"),
+        t21.stringLiteral(payload.fileKey)
+      )
+    );
+    jsxScope.node.openingElement.attributes.push(
+      t21.jsxAttribute(
+        t21.jsxIdentifier("$entryKey"),
+        t21.stringLiteral(getJsxScopeAttribute(jsxScope))
+      )
+    );
+    const $variables = getJsxVariables(originalJsxScope);
+    if ($variables.properties.length > 0) {
+      jsxScope.node.openingElement.attributes.push(
+        t21.jsxAttribute(
+          t21.jsxIdentifier("$variables"),
+          t21.jsxExpressionContainer($variables)
+        )
+      );
+    }
+    const $elements = getNestedJsxElements(originalJsxScope);
+    if ($elements.elements.length > 0) {
+      jsxScope.node.openingElement.attributes.push(
+        t21.jsxAttribute(
+          t21.jsxIdentifier("$elements"),
+          t21.jsxExpressionContainer($elements)
+        )
+      );
+    }
+    const $functions = getJsxFunctions(originalJsxScope);
+    if ($functions.properties.length > 0) {
+      jsxScope.node.openingElement.attributes.push(
+        t21.jsxAttribute(
+          t21.jsxIdentifier("$functions"),
+          t21.jsxExpressionContainer($functions)
+        )
+      );
+    }
+    const $expressions = getJsxExpressions(originalJsxScope);
+    if ($expressions.elements.length > 0) {
+      jsxScope.node.openingElement.attributes.push(
+        t21.jsxAttribute(
+          t21.jsxIdentifier("$expressions"),
+          t21.jsxExpressionContainer($expressions)
+        )
+      );
+    }
+    if (mode === "server") {
+      const loadDictionaryImport = getOrCreateImport(payload.ast, {
+        exportedName: "loadDictionary",
+        moduleName: "lingo.dev/react/rsc" /* ReactRSC */
+      });
+      jsxScope.node.openingElement.attributes.push(
+        t21.jsxAttribute(
+          t21.jsxIdentifier("$loadDictionary"),
+          t21.jsxExpressionContainer(
+            t21.arrowFunctionExpression(
+              [t21.identifier("locale")],
+              t21.callExpression(
+                t21.identifier(loadDictionaryImport.importedName),
+                [t21.identifier("locale")]
+              )
+            )
+          )
+        )
+      );
+    }
+  }
+  return payload;
+});
+
+// src/jsx-remove-attributes.ts
+import * as t22 from "@babel/types";
+import traverse9 from "@babel/traverse";
+var jsxRemoveAttributesMutation = createCodeMutation(
+  (payload) => {
+    const ATTRIBUTES_TO_REMOVE = [
+      "data-jsx-root",
+      "data-jsx-scope",
+      "data-jsx-attribute-scope"
+    ];
+    traverse9(payload.ast, {
+      JSXElement(path6) {
+        const openingElement = path6.node.openingElement;
+        openingElement.attributes = openingElement.attributes.filter((attr) => {
+          const removeAttr = t22.isJSXAttribute(attr) && t22.isJSXIdentifier(attr.name) && ATTRIBUTES_TO_REMOVE.includes(attr.name.name);
+          return !removeAttr;
+        });
+      }
+    });
+    return {
+      ...payload
+    };
+  }
+);
+
+// src/client-dictionary-loader.ts
+import path4 from "path";
+import * as t23 from "@babel/types";
+var clientDictionaryLoaderMutation = createCodeMutation((payload) => {
+  const lingoDir = path4.resolve(
+    process.cwd(),
+    payload.params.sourceRoot,
+    payload.params.lingoDir
+  );
+  const currentDir = path4.dirname(
+    path4.resolve(process.cwd(), payload.params.sourceRoot, payload.fileKey)
+  );
+  const relativeLingoPath = path4.relative(currentDir, lingoDir);
+  const invokations = findInvokations(payload.ast, {
+    moduleName: "lingo.dev/react/client" /* ReactClient */,
+    functionName: "loadDictionary"
+  });
+  const allLocales = Array.from(
+    /* @__PURE__ */ new Set([payload.params.sourceLocale, ...payload.params.targetLocales])
+  );
+  for (const invokation of invokations) {
+    const internalDictionaryLoader = getOrCreateImport(payload.ast, {
+      moduleName: "lingo.dev/react/client" /* ReactClient */,
+      exportedName: "loadDictionary_internal"
+    });
+    if (t23.isIdentifier(invokation.callee)) {
+      invokation.callee.name = internalDictionaryLoader.importedName;
+    }
+    const localeImportMap = t23.objectExpression(
+      allLocales.map(
+        (locale) => t23.objectProperty(
+          t23.identifier(locale),
+          t23.arrowFunctionExpression(
+            [],
+            t23.callExpression(t23.identifier("import"), [
+              t23.stringLiteral(
+                `./${relativeLingoPath}/${LCP_DICTIONARY_FILE_NAME}?locale=${locale}`
+              )
+            ])
+          )
+        )
+      )
+    );
+    invokation.arguments.push(localeImportMap);
+  }
+  return payload;
+});
+
+// src/index.ts
+var unplugin = createUnplugin(
+  (_params, _meta) => {
+    console.log("\u2139\uFE0F  Starting Lingo.dev compiler...");
+    if (!isRunningInCIOrDocker()) {
+      validateGroqKeyDetails();
+    }
+    const params = _12.defaults(_params, defaultParams);
+    const invalidLocales = getInvalidLocales(
+      params.models,
+      params.sourceLocale,
+      params.targetLocales
+    );
+    if (invalidLocales.length > 0) {
+      console.log(dedent2`
+        \n
+        ⚠️  Lingo.dev Localization Compiler requires LLM model setup for the following locales: ${invalidLocales.join(", ")}.
+
+        ⭐️ Next steps:
+        1. Refer to documentation for help: https://docs.lingo.dev/
+        2. If you want to use a different LLM, raise an issue in our open-source repo: https://lingo.dev/go/gh
+        3. If you have questions, feature requests, or would like to contribute, join our Discord: https://lingo.dev/go/discord
+  
+        ✨
+      `);
+      process.exit(1);
+    }
+    LCPCache.ensureDictionaryFile({
+      sourceRoot: params.sourceRoot,
+      lingoDir: params.lingoDir
+    });
+    return {
+      name: package_default.name,
+      loadInclude: (id) => !!id.match(LCP_DICTIONARY_FILE_NAME),
+      async load(id) {
+        const moduleInfo = parseParametrizedModuleId(id);
+        const lcpParams = {
+          sourceRoot: params.sourceRoot,
+          lingoDir: params.lingoDir
+        };
+        await LCP.ready(lcpParams);
+        const lcp = LCP.getInstance(lcpParams);
+        const dictionaries = await LCPServer.loadDictionaries({
+          models: params.models,
+          lcp: lcp.data,
+          sourceLocale: params.sourceLocale,
+          targetLocales: params.targetLocales,
+          sourceRoot: params.sourceRoot,
+          lingoDir: params.lingoDir
+        });
+        const dictionary = dictionaries[moduleInfo.params.locale];
+        return {
+          code: `export default ${JSON.stringify(dictionary, null, 2)}`
+        };
+      },
+      transformInclude: (id) => id.endsWith(".tsx") || id.endsWith(".jsx"),
+      enforce: "pre",
+      transform(code, id) {
+        try {
+          const result = _12.chain({
+            code,
+            params,
+            fileKey: path5.relative(
+              path5.resolve(process.cwd(), params.sourceRoot),
+              id
+            )
+          }).thru(createPayload).thru(
+            composeMutations(
+              i18n_directive_default,
+              jsxFragmentMutation,
+              jsx_attribute_flag_default,
+              // log here to see transformedfiles
+              // (input) => {
+              //   console.log(`transform ${id}`);
+              //   return input;
+              // },
+              jsx_provider_default,
+              jsxHtmlLangMutation,
+              jsx_root_flag_default,
+              jsx_scope_flag_default,
+              jsx_attribute_flag_default,
+              jsxAttributeScopesExportMutation,
+              jsxScopesExportMutation,
+              lingoJsxAttributeScopeInjectMutation,
+              lingoJsxScopeInjectMutation,
+              rscDictionaryLoaderMutation,
+              reactRouterDictionaryLoaderMutation,
+              jsxRemoveAttributesMutation,
+              clientDictionaryLoaderMutation
+            )
+          ).thru(createOutput).value();
+          return result;
+        } catch (error) {
+          console.error("\u26A0\uFE0F  Lingo.dev compiler failed to localize your app");
+          console.error("\u26A0\uFE0F  Details:", error);
+          return code;
+        }
+      }
+    };
+  }
+);
+var src_default = {
+  next: (compilerParams) => (nextConfig) => ({
+    ...nextConfig,
+    // what if we already have a webpack config?
+    webpack: (config2, { isServer }) => {
+      config2.plugins.push(
+        unplugin.webpack(
+          _12.merge({}, defaultParams, { rsc: true }, compilerParams)
+        )
+      );
+      return config2;
+    }
+  }),
+  vite: (compilerParams) => (config2) => {
+    config2.plugins.push(
+      unplugin.vite(_12.merge({}, defaultParams, { rsc: false }, compilerParams))
+    );
+    return config2;
+  }
+};
+function validateGroqKeyDetails() {
+  const groq = {
+    fromEnv: getGroqKeyFromEnv(),
+    fromRc: getGroqKeyFromRc()
+  };
+  if (!groq.fromEnv && !groq.fromRc) {
+    console.log(dedent2`
+      \n
+      💡 You're using Lingo.dev Localization Compiler in your project, which requires a GROQ API key to work.
+
+      👉 You can set the API key in one of the following ways:
+      1. User-wide: Run npx lingo.dev@latest config set llm.groqApiKey <your-api-key>
+      2. Project-wide: Add GROQ_API_KEY=<your-api-key> to .env file in every project that uses Lingo.dev Localization Compiler
+      3. Session-wide: Run export GROQ_API_KEY=<your-api-key> in your terminal before running the compiler to set the API key for the current session
+
+      ⭐️ Also:
+      1. If you don't yet have a GROQ API key, get one for free at https://groq.com
+      2. If you want to use a different LLM, raise an issue in our open-source repo: https://lingo.dev/go/gh
+      3. If you have questions, feature requests, or would like to contribute, join our Discord: https://lingo.dev/go/discord
+
+      ✨
+    `);
+    process.exit(1);
+  } else if (groq.fromEnv && groq.fromRc) {
+    console.log(
+      dedent2`
+        🔑  GROQ API key detected in both environment variables and your user-wide configuration.
+
+        👉  The compiler will use the key from the environment because it has higher priority.
+
+        • To update the user-wide key run: npx lingo.dev@latest config set llm.groqApiKey <your-api-key>
+        • To remove it run: npx lingo.dev@latest config unset llm.groqApiKey
+        • To remove the env variable from the current session run: unset GROQ_API_KEY
+      `
+    );
+  } else if (groq.fromEnv && !groq.fromRc) {
+    console.log(
+      dedent2`
+        🔑  GROQ API key loaded from environment variables.
+
+        • You can also save the key user-wide with: npx lingo.dev@latest config set llm.groqApiKey <your-api-key>
+        • Or remove the env variable from the current session with: unset GROQ_API_KEY
+      `
+    );
+  } else if (!groq.fromEnv && groq.fromRc) {
+    console.log(
+      dedent2`
+        🔑  GROQ API key loaded from your user-wide configuration.
+      `
+    );
+  }
+}
+export {
+  src_default as default
+};