@lingo.dev/_compiler 0.2.2 → 0.2.4

package/build/index.mjs

@@ -4,7 +4,7 @@ import { createUnplugin } from "unplugin";
 // package.json
 var package_default = {
   name: "@lingo.dev/_compiler",
-  version: "0.2.2",
+  version: "0.2.4",
   description: "Lingo.dev Compiler",
   private: false,
   publishConfig: {
@@ -204,7 +204,7 @@ function findExistingImport(ast, exportedName, moduleName) {
   let result = null;
   traverse(ast, {
     ImportDeclaration(path7) {
-      if (path7.node.source.value !== moduleName) {
+      if (!moduleName.includes(path7.node.source.value)) {
         return;
       }
       for (const specifier of path7.node.specifiers) {
@@ -244,14 +244,14 @@ function createImportDeclaration(ast, localName, exportedName, moduleName) {
         t2.identifier(exportedName)
       );
       const existingImport = path7.get("body").find(
-        (nodePath) => t2.isImportDeclaration(nodePath.node) && nodePath.node.source.value === moduleName
+        (nodePath) => t2.isImportDeclaration(nodePath.node) && moduleName.includes(nodePath.node.source.value)
       );
       if (existingImport && t2.isImportDeclaration(existingImport.node)) {
         existingImport.node.specifiers.push(importSpecifier2);
       } else {
         const importDeclaration2 = t2.importDeclaration(
           [importSpecifier2],
-          t2.stringLiteral(moduleName)
+          t2.stringLiteral(moduleName[0])
         );
         const lastImportIndex = findLastImportIndex(path7);
         path7.node.body.splice(lastImportIndex + 1, 0, importDeclaration2);
@@ -345,6 +345,11 @@ function getNestedJsxElements(nodePath) {
 }
 
 // src/_const.ts
+var ModuleId = {
+  ReactClient: ["lingo.dev/react/client", "lingo.dev/react-client"],
+  ReactRSC: ["lingo.dev/react/rsc", "lingo.dev/react-rsc"],
+  ReactRouter: ["lingo.dev/react/react-router", "lingo.dev/react-router"]
+};
 var LCP_DICTIONARY_FILE_NAME = "dictionary.js";
 
 // src/jsx-provider.ts
@@ -357,11 +362,11 @@ var jsxProviderMutation = createCodeMutation((payload) => {
           return;
         }
         const lingoProviderImport = getOrCreateImport(payload.ast, {
-          moduleName: "lingo.dev/react/rsc" /* ReactRSC */,
+          moduleName: ModuleId.ReactRSC,
           exportedName: "LingoProvider"
         });
         const loadDictionaryImport = getOrCreateImport(payload.ast, {
-          moduleName: "lingo.dev/react/rsc" /* ReactRSC */,
+          moduleName: ModuleId.ReactRSC,
           exportedName: "loadDictionary"
         });
         const loadDictionaryArrow = t4.arrowFunctionExpression(
@@ -1731,7 +1736,7 @@ function findInvokations(ast, params) {
   const result = [];
   traverse6(ast, {
     ImportDeclaration(path7) {
-      if (path7.node.source.value !== params.moduleName) return;
+      if (!params.moduleName.includes(path7.node.source.value)) return;
       const importNames = /* @__PURE__ */ new Map();
       const specifiers = path7.node.specifiers;
       specifiers.forEach((specifier) => {
@@ -1766,17 +1771,38 @@ function collectCallExpressions(path7, importNames, result, functionName) {
 }
 
 // src/rsc-dictionary-loader.ts
-import * as t12 from "@babel/types";
+import * as t13 from "@babel/types";
 
 // src/_utils.ts
 import path5 from "path";
 var getDictionaryPath = (params) => {
-  return path5.relative(
-    params.relativeFilePath,
-    path5.resolve(params.sourceRoot, params.lingoDir, LCP_DICTIONARY_FILE_NAME)
+  const absolute = path5.resolve(
+    params.sourceRoot,
+    params.lingoDir,
+    LCP_DICTIONARY_FILE_NAME
   );
+  const rel = path5.relative(params.relativeFilePath, absolute);
+  return rel.split(path5.sep).join(path5.posix.sep);
 };
 
+// src/utils/create-locale-import-map.ts
+import * as t12 from "@babel/types";
+function createLocaleImportMap(allLocales, dictionaryPath) {
+  return t12.objectExpression(
+    allLocales.map(
+      (locale) => t12.objectProperty(
+        t12.stringLiteral(locale),
+        t12.arrowFunctionExpression(
+          [],
+          t12.callExpression(t12.identifier("import"), [
+            t12.stringLiteral(`${dictionaryPath}?locale=${locale}`)
+          ])
+        )
+      )
+    )
+  );
+}
+
 // src/rsc-dictionary-loader.ts
 var rscDictionaryLoaderMutation = createCodeMutation((payload) => {
   const mode = getModuleExecutionMode(payload.ast, payload.params.rsc);
@@ -1784,7 +1810,7 @@ var rscDictionaryLoaderMutation = createCodeMutation((payload) => {
     return payload;
   }
   const invokations = findInvokations(payload.ast, {
-    moduleName: "lingo.dev/react/rsc" /* ReactRSC */,
+    moduleName: ModuleId.ReactRSC,
     functionName: "loadDictionary"
   });
   const allLocales = Array.from(
@@ -1792,10 +1818,10 @@ var rscDictionaryLoaderMutation = createCodeMutation((payload) => {
   );
   for (const invokation of invokations) {
     const internalDictionaryLoader = getOrCreateImport(payload.ast, {
-      moduleName: "lingo.dev/react/rsc" /* ReactRSC */,
+      moduleName: ModuleId.ReactRSC,
       exportedName: "loadDictionary_internal"
     });
-    if (t12.isIdentifier(invokation.callee)) {
+    if (t13.isIdentifier(invokation.callee)) {
       invokation.callee.name = internalDictionaryLoader.importedName;
     }
     const dictionaryPath = getDictionaryPath({
@@ -1803,26 +1829,14 @@ var rscDictionaryLoaderMutation = createCodeMutation((payload) => {
       lingoDir: payload.params.lingoDir,
       relativeFilePath: payload.relativeFilePath
     });
-    const localeImportMap = t12.objectExpression(
-      allLocales.map(
-        (locale) => t12.objectProperty(
-          t12.identifier(locale),
-          t12.arrowFunctionExpression(
-            [],
-            t12.callExpression(t12.identifier("import"), [
-              t12.stringLiteral(`${dictionaryPath}?locale=${locale}`)
-            ])
-          )
-        )
-      )
-    );
+    const localeImportMap = createLocaleImportMap(allLocales, dictionaryPath);
     invokation.arguments.push(localeImportMap);
   }
   return payload;
 });
 
 // src/react-router-dictionary-loader.ts
-import * as t13 from "@babel/types";
+import * as t14 from "@babel/types";
 var reactRouterDictionaryLoaderMutation = createCodeMutation(
   (payload) => {
     const mode = getModuleExecutionMode(payload.ast, payload.params.rsc);
@@ -1830,7 +1844,7 @@ var reactRouterDictionaryLoaderMutation = createCodeMutation(
       return payload;
     }
     const invokations = findInvokations(payload.ast, {
-      moduleName: "lingo.dev/react/react-router" /* ReactRouter */,
+      moduleName: ModuleId.ReactRouter,
       functionName: "loadDictionary"
     });
     const allLocales = Array.from(
@@ -1838,10 +1852,10 @@ var reactRouterDictionaryLoaderMutation = createCodeMutation(
     );
     for (const invokation of invokations) {
       const internalDictionaryLoader = getOrCreateImport(payload.ast, {
-        moduleName: "lingo.dev/react/react-router" /* ReactRouter */,
+        moduleName: ModuleId.ReactRouter,
         exportedName: "loadDictionary_internal"
       });
-      if (t13.isIdentifier(invokation.callee)) {
+      if (t14.isIdentifier(invokation.callee)) {
         invokation.callee.name = internalDictionaryLoader.importedName;
       }
       const dictionaryPath = getDictionaryPath({
@@ -1849,19 +1863,7 @@ var reactRouterDictionaryLoaderMutation = createCodeMutation(
         lingoDir: payload.params.lingoDir,
         relativeFilePath: payload.relativeFilePath
       });
-      const localeImportMap = t13.objectExpression(
-        allLocales.map(
-          (locale) => t13.objectProperty(
-            t13.identifier(locale),
-            t13.arrowFunctionExpression(
-              [],
-              t13.callExpression(t13.identifier("import"), [
-                t13.stringLiteral(`${dictionaryPath}?locale=${locale}`)
-              ])
-            )
-          )
-        )
-      );
+      const localeImportMap = createLocaleImportMap(allLocales, dictionaryPath);
       invokation.arguments.push(localeImportMap);
     }
     return payload;
@@ -1870,7 +1872,7 @@ var reactRouterDictionaryLoaderMutation = createCodeMutation(
 
 // src/jsx-fragment.ts
 import traverse7 from "@babel/traverse";
-import * as t14 from "@babel/types";
+import * as t15 from "@babel/types";
 function jsxFragmentMutation(payload) {
   const { ast } = payload;
   let foundFragments = false;
@@ -1879,7 +1881,7 @@ function jsxFragmentMutation(payload) {
     ImportDeclaration(path7) {
       if (path7.node.source.value !== "react") return;
       for (const specifier of path7.node.specifiers) {
-        if (t14.isImportSpecifier(specifier) && t14.isIdentifier(specifier.imported) && specifier.imported.name === "Fragment") {
+        if (t15.isImportSpecifier(specifier) && t15.isIdentifier(specifier.imported) && specifier.imported.name === "Fragment") {
           fragmentImportName = specifier.local.name;
           path7.stop();
         }
@@ -1892,13 +1894,13 @@ function jsxFragmentMutation(payload) {
       if (!fragmentImportName) {
         const result = getOrCreateImport(ast, {
           exportedName: "Fragment",
-          moduleName: "react"
+          moduleName: ["react"]
         });
         fragmentImportName = result.importedName;
       }
-      const fragmentElement = t14.jsxElement(
-        t14.jsxOpeningElement(t14.jsxIdentifier(fragmentImportName), [], false),
-        t14.jsxClosingElement(t14.jsxIdentifier(fragmentImportName)),
+      const fragmentElement = t15.jsxElement(
+        t15.jsxOpeningElement(t15.jsxIdentifier(fragmentImportName), [], false),
+        t15.jsxClosingElement(t15.jsxIdentifier(fragmentImportName)),
         path7.node.children,
         false
       );
@@ -1910,22 +1912,22 @@ function jsxFragmentMutation(payload) {
 
 // src/jsx-html-lang.ts
 import traverse8 from "@babel/traverse";
-import * as t15 from "@babel/types";
+import * as t16 from "@babel/types";
 var jsxHtmlLangMutation = createCodeMutation((payload) => {
   traverse8(payload.ast, {
     JSXElement: (path7) => {
       if (getJsxElementName(path7)?.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 packagePath = mode === "client" ? ModuleId.ReactClient : ModuleId.ReactRSC;
         const lingoHtmlComponentImport = getOrCreateImport(payload.ast, {
           moduleName: packagePath,
           exportedName: "LingoHtmlComponent"
         });
-        path7.node.openingElement.name = t15.jsxIdentifier(
+        path7.node.openingElement.name = t16.jsxIdentifier(
           lingoHtmlComponentImport.importedName
         );
         if (path7.node.closingElement) {
-          path7.node.closingElement.name = t15.jsxIdentifier(
+          path7.node.closingElement.name = t16.jsxIdentifier(
             lingoHtmlComponentImport.importedName
           );
         }
@@ -1994,7 +1996,7 @@ function jsxAttributeScopesExportMutation(payload) {
 import _10 from "lodash";
 
 // src/utils/jsx-content.ts
-import * as t16 from "@babel/types";
+import * as t17 from "@babel/types";
 import _9 from "lodash";
 var WHITESPACE_PLACEHOLDER = "[lingo-whitespace-placeholder]";
 function extractJsxContent(nodePath, replaceWhitespacePlaceholders = true) {
@@ -2016,39 +2018,39 @@ function extractJsxContent(nodePath, replaceWhitespacePlaceholders = true) {
         return;
       }
       const expr = path7.node.expression;
-      if (t16.isCallExpression(expr)) {
+      if (t17.isCallExpression(expr)) {
         let key = "";
-        if (t16.isIdentifier(expr.callee)) {
+        if (t17.isIdentifier(expr.callee)) {
           key = `${expr.callee.name}`;
-        } else if (t16.isMemberExpression(expr.callee)) {
+        } else if (t17.isMemberExpression(expr.callee)) {
           let firstCallee = expr.callee;
-          while (t16.isMemberExpression(firstCallee) && t16.isCallExpression(firstCallee.object)) {
+          while (t17.isMemberExpression(firstCallee) && t17.isCallExpression(firstCallee.object)) {
             firstCallee = firstCallee.object.callee;
           }
           let current = firstCallee;
           const parts = [];
-          while (t16.isMemberExpression(current)) {
-            if (t16.isIdentifier(current.property)) {
+          while (t17.isMemberExpression(current)) {
+            if (t17.isIdentifier(current.property)) {
               parts.unshift(current.property.name);
             }
             current = current.object;
           }
-          if (t16.isIdentifier(current)) {
+          if (t17.isIdentifier(current)) {
             parts.unshift(current.name);
           }
-          if (t16.isMemberExpression(firstCallee) && t16.isNewExpression(firstCallee.object) && t16.isIdentifier(firstCallee.object.callee)) {
+          if (t17.isMemberExpression(firstCallee) && t17.isNewExpression(firstCallee.object) && t17.isIdentifier(firstCallee.object.callee)) {
             parts.unshift(firstCallee.object.callee.name);
           }
           key = parts.join(".");
         }
         chunks.push(`<function:${key}/>`);
-      } else if (t16.isIdentifier(expr)) {
+      } else if (t17.isIdentifier(expr)) {
         chunks.push(`{${expr.name}}`);
-      } else if (t16.isMemberExpression(expr)) {
+      } else if (t17.isMemberExpression(expr)) {
         let current = expr;
         const parts = [];
-        while (t16.isMemberExpression(current)) {
-          if (t16.isIdentifier(current.property)) {
+        while (t17.isMemberExpression(current)) {
+          if (t17.isIdentifier(current.property)) {
             if (current.computed) {
               parts.unshift(`[${current.property.name}]`);
             } else {
@@ -2057,7 +2059,7 @@ function extractJsxContent(nodePath, replaceWhitespacePlaceholders = true) {
           }
           current = current.object;
         }
-        if (t16.isIdentifier(current)) {
+        if (t17.isIdentifier(current)) {
           parts.unshift(current.name);
           chunks.push(`{${parts.join(".").replaceAll(".[", "[")}}`);
         }
@@ -2078,12 +2080,12 @@ function extractJsxContent(nodePath, replaceWhitespacePlaceholders = true) {
 }
 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);
+  const isCompilerExpression = !_9.isArray(nodePath.container) && t17.isJSXAttribute(nodePath.container) && t17.isJSXIdentifier(nodePath.container.name) && compilerProps.includes(nodePath.container.name.name);
+  return !isCompilerExpression && !t17.isJSXEmptyExpression(nodePath.node.expression);
 }
 function isWhitespace(nodePath) {
   const expr = nodePath.node.expression;
-  return t16.isStringLiteral(expr) && expr.value === " ";
+  return t17.isStringLiteral(expr) && expr.value === " ";
 }
 function normalizeJsxWhitespace(input) {
   const lines = input.split("\n");
@@ -2143,13 +2145,13 @@ function jsxScopesExportMutation(payload) {
 }
 
 // src/jsx-attribute-scope-inject.ts
-import * as t17 from "@babel/types";
+import * as t18 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 packagePath = mode === "client" ? ModuleId.ReactClient : ModuleId.ReactRSC;
       const lingoComponentImport = getOrCreateImport(payload.ast, {
         moduleName: packagePath,
         exportedName: "LingoAttributeComponent"
@@ -2158,34 +2160,34 @@ var lingoJsxAttributeScopeInjectMutation = createCodeMutation(
       if (!originalJsxElementName) {
         continue;
       }
-      jsxScope.node.openingElement.name = t17.jsxIdentifier(
+      jsxScope.node.openingElement.name = t18.jsxIdentifier(
         lingoComponentImport.importedName
       );
       if (jsxScope.node.closingElement) {
-        jsxScope.node.closingElement.name = t17.jsxIdentifier(
+        jsxScope.node.closingElement.name = t18.jsxIdentifier(
           lingoComponentImport.importedName
         );
       }
-      const as = /^[A-Z]/.test(originalJsxElementName) ? t17.jsxExpressionContainer(t17.identifier(originalJsxElementName)) : t17.stringLiteral(originalJsxElementName);
+      const as = /^[A-Z]/.test(originalJsxElementName) ? t18.jsxExpressionContainer(t18.identifier(originalJsxElementName)) : t18.stringLiteral(originalJsxElementName);
       jsxScope.node.openingElement.attributes.push(
-        t17.jsxAttribute(t17.jsxIdentifier("$attrAs"), as)
+        t18.jsxAttribute(t18.jsxIdentifier("$attrAs"), as)
       );
       jsxScope.node.openingElement.attributes.push(
-        t17.jsxAttribute(
-          t17.jsxIdentifier("$fileKey"),
-          t17.stringLiteral(payload.relativeFilePath)
+        t18.jsxAttribute(
+          t18.jsxIdentifier("$fileKey"),
+          t18.stringLiteral(payload.relativeFilePath)
         )
       );
       jsxScope.node.openingElement.attributes.push(
-        t17.jsxAttribute(
-          t17.jsxIdentifier("$attributes"),
-          t17.jsxExpressionContainer(
-            t17.objectExpression(
+        t18.jsxAttribute(
+          t18.jsxIdentifier("$attributes"),
+          t18.jsxExpressionContainer(
+            t18.objectExpression(
               attributes.map((attributeDefinition) => {
                 const [attribute, key = ""] = attributeDefinition.split(":");
-                return t17.objectProperty(
-                  t17.stringLiteral(attribute),
-                  t17.stringLiteral(key)
+                return t18.objectProperty(
+                  t18.stringLiteral(attribute),
+                  t18.stringLiteral(key)
                 );
               })
             )
@@ -2195,17 +2197,17 @@ var lingoJsxAttributeScopeInjectMutation = createCodeMutation(
       if (mode === "server") {
         const loadDictionaryImport = getOrCreateImport(payload.ast, {
           exportedName: "loadDictionary",
-          moduleName: "lingo.dev/react/rsc" /* ReactRSC */
+          moduleName: ModuleId.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")]
+          t18.jsxAttribute(
+            t18.jsxIdentifier("$loadDictionary"),
+            t18.jsxExpressionContainer(
+              t18.arrowFunctionExpression(
+                [t18.identifier("locale")],
+                t18.callExpression(
+                  t18.identifier(loadDictionaryImport.importedName),
+                  [t18.identifier("locale")]
                 )
               )
             )
@@ -2218,10 +2220,10 @@ var lingoJsxAttributeScopeInjectMutation = createCodeMutation(
 );
 
 // src/jsx-scope-inject.ts
-import * as t21 from "@babel/types";
+import * as t22 from "@babel/types";
 
 // src/utils/jsx-variables.ts
-import * as t18 from "@babel/types";
+import * as t19 from "@babel/types";
 var getJsxVariables = (nodePath) => {
   const variables = /* @__PURE__ */ new Set();
   nodePath.traverse({
@@ -2229,13 +2231,13 @@ var getJsxVariables = (nodePath) => {
       path7.skip();
     },
     JSXExpressionContainer(path7) {
-      if (t18.isIdentifier(path7.node.expression)) {
+      if (t19.isIdentifier(path7.node.expression)) {
         variables.add(path7.node.expression.name);
-      } else if (t18.isMemberExpression(path7.node.expression)) {
+      } else if (t19.isMemberExpression(path7.node.expression)) {
         let current = path7.node.expression;
         const parts = [];
-        while (t18.isMemberExpression(current)) {
-          if (t18.isIdentifier(current.property)) {
+        while (t19.isMemberExpression(current)) {
+          if (t19.isIdentifier(current.property)) {
             if (current.computed) {
               parts.unshift(`[${current.property.name}]`);
             } else {
@@ -2244,7 +2246,7 @@ var getJsxVariables = (nodePath) => {
           }
           current = current.object;
         }
-        if (t18.isIdentifier(current)) {
+        if (t19.isIdentifier(current)) {
           parts.unshift(current.name);
           variables.add(parts.join(".").replaceAll(".[", "["));
         }
@@ -2253,14 +2255,14 @@ var getJsxVariables = (nodePath) => {
     }
   });
   const properties = Array.from(variables).map(
-    (name) => t18.objectProperty(t18.stringLiteral(name), t18.identifier(name))
+    (name) => t19.objectProperty(t19.stringLiteral(name), t19.identifier(name))
   );
-  const result = t18.objectExpression(properties);
+  const result = t19.objectExpression(properties);
   return result;
 };
 
 // src/utils/jsx-functions.ts
-import * as t19 from "@babel/types";
+import * as t20 from "@babel/types";
 var getJsxFunctions = (nodePath) => {
   const functions = /* @__PURE__ */ new Map();
   let fnCounter = 0;
@@ -2269,27 +2271,27 @@ var getJsxFunctions = (nodePath) => {
       path7.skip();
     },
     JSXExpressionContainer(path7) {
-      if (t19.isCallExpression(path7.node.expression)) {
+      if (t20.isCallExpression(path7.node.expression)) {
         let key = "";
-        if (t19.isIdentifier(path7.node.expression.callee)) {
+        if (t20.isIdentifier(path7.node.expression.callee)) {
           key = `${path7.node.expression.callee.name}`;
-        } else if (t19.isMemberExpression(path7.node.expression.callee)) {
+        } else if (t20.isMemberExpression(path7.node.expression.callee)) {
           let firstCallee = path7.node.expression.callee;
-          while (t19.isMemberExpression(firstCallee) && t19.isCallExpression(firstCallee.object)) {
+          while (t20.isMemberExpression(firstCallee) && t20.isCallExpression(firstCallee.object)) {
             firstCallee = firstCallee.object.callee;
           }
           let current = firstCallee;
           const parts = [];
-          while (t19.isMemberExpression(current)) {
-            if (t19.isIdentifier(current.property)) {
+          while (t20.isMemberExpression(current)) {
+            if (t20.isIdentifier(current.property)) {
               parts.unshift(current.property.name);
             }
             current = current.object;
           }
-          if (t19.isIdentifier(current)) {
+          if (t20.isIdentifier(current)) {
             parts.unshift(current.name);
           }
-          if (t19.isMemberExpression(firstCallee) && t19.isNewExpression(firstCallee.object) && t19.isIdentifier(firstCallee.object.callee)) {
+          if (t20.isMemberExpression(firstCallee) && t20.isNewExpression(firstCallee.object) && t20.isIdentifier(firstCallee.object.callee)) {
             parts.unshift(firstCallee.object.callee.name);
           }
           key = parts.join(".");
@@ -2302,13 +2304,13 @@ var getJsxFunctions = (nodePath) => {
     }
   });
   const properties = Array.from(functions.entries()).map(
-    ([name, callExpr]) => t19.objectProperty(t19.stringLiteral(name), t19.arrayExpression(callExpr))
+    ([name, callExpr]) => t20.objectProperty(t20.stringLiteral(name), t20.arrayExpression(callExpr))
   );
-  return t19.objectExpression(properties);
+  return t20.objectExpression(properties);
 };
 
 // src/utils/jsx-expressions.ts
-import * as t20 from "@babel/types";
+import * as t21 from "@babel/types";
 var getJsxExpressions = (nodePath) => {
   const expressions = [];
   nodePath.traverse({
@@ -2317,13 +2319,13 @@ var getJsxExpressions = (nodePath) => {
     },
     JSXExpressionContainer(path7) {
       const expr = path7.node.expression;
-      if (!t20.isJSXEmptyExpression(expr) && !t20.isIdentifier(expr) && !t20.isMemberExpression(expr) && !t20.isCallExpression(expr) && !(t20.isStringLiteral(expr) && expr.value === " ")) {
+      if (!t21.isJSXEmptyExpression(expr) && !t21.isIdentifier(expr) && !t21.isMemberExpression(expr) && !t21.isCallExpression(expr) && !(t21.isStringLiteral(expr) && expr.value === " ")) {
         expressions.push(expr);
       }
       path7.skip();
     }
   });
-  return t20.arrayExpression(expressions);
+  return t21.arrayExpression(expressions);
 };
 
 // src/jsx-scope-inject.ts
@@ -2335,7 +2337,7 @@ var lingoJsxScopeInjectMutation = createCodeMutation((payload) => {
     if (skip) {
       continue;
     }
-    const packagePath = mode === "client" ? "lingo.dev/react/client" /* ReactClient */ : "lingo.dev/react/rsc" /* ReactRSC */;
+    const packagePath = mode === "client" ? ModuleId.ReactClient : ModuleId.ReactRSC;
     const lingoComponentImport = getOrCreateImport(payload.ast, {
       moduleName: packagePath,
       exportedName: "LingoComponent"
@@ -2345,79 +2347,79 @@ var lingoJsxScopeInjectMutation = createCodeMutation((payload) => {
       continue;
     }
     const originalAttributes = jsxScope.node.openingElement.attributes.slice();
-    const as = /^[A-Z]/.test(originalJsxElementName) ? t21.jsxExpressionContainer(t21.identifier(originalJsxElementName)) : t21.stringLiteral(originalJsxElementName);
-    originalAttributes.push(t21.jsxAttribute(t21.jsxIdentifier("$as"), as));
+    const as = /^[A-Z]/.test(originalJsxElementName) ? t22.jsxExpressionContainer(t22.identifier(originalJsxElementName)) : t22.stringLiteral(originalJsxElementName);
+    originalAttributes.push(t22.jsxAttribute(t22.jsxIdentifier("$as"), as));
     originalAttributes.push(
-      t21.jsxAttribute(
-        t21.jsxIdentifier("$fileKey"),
-        t21.stringLiteral(payload.relativeFilePath)
+      t22.jsxAttribute(
+        t22.jsxIdentifier("$fileKey"),
+        t22.stringLiteral(payload.relativeFilePath)
       )
     );
     originalAttributes.push(
-      t21.jsxAttribute(
-        t21.jsxIdentifier("$entryKey"),
-        t21.stringLiteral(getJsxScopeAttribute(jsxScope))
+      t22.jsxAttribute(
+        t22.jsxIdentifier("$entryKey"),
+        t22.stringLiteral(getJsxScopeAttribute(jsxScope))
       )
     );
     const $variables = getJsxVariables(jsxScope);
     if ($variables.properties.length > 0) {
       originalAttributes.push(
-        t21.jsxAttribute(
-          t21.jsxIdentifier("$variables"),
-          t21.jsxExpressionContainer($variables)
+        t22.jsxAttribute(
+          t22.jsxIdentifier("$variables"),
+          t22.jsxExpressionContainer($variables)
         )
       );
     }
     const $elements = getNestedJsxElements(jsxScope);
     if ($elements.elements.length > 0) {
       originalAttributes.push(
-        t21.jsxAttribute(
-          t21.jsxIdentifier("$elements"),
-          t21.jsxExpressionContainer($elements)
+        t22.jsxAttribute(
+          t22.jsxIdentifier("$elements"),
+          t22.jsxExpressionContainer($elements)
         )
       );
     }
     const $functions = getJsxFunctions(jsxScope);
     if ($functions.properties.length > 0) {
       originalAttributes.push(
-        t21.jsxAttribute(
-          t21.jsxIdentifier("$functions"),
-          t21.jsxExpressionContainer($functions)
+        t22.jsxAttribute(
+          t22.jsxIdentifier("$functions"),
+          t22.jsxExpressionContainer($functions)
         )
       );
     }
     const $expressions = getJsxExpressions(jsxScope);
     if ($expressions.elements.length > 0) {
       originalAttributes.push(
-        t21.jsxAttribute(
-          t21.jsxIdentifier("$expressions"),
-          t21.jsxExpressionContainer($expressions)
+        t22.jsxAttribute(
+          t22.jsxIdentifier("$expressions"),
+          t22.jsxExpressionContainer($expressions)
         )
       );
     }
     if (mode === "server") {
       const loadDictionaryImport = getOrCreateImport(payload.ast, {
         exportedName: "loadDictionary",
-        moduleName: "lingo.dev/react/rsc" /* ReactRSC */
+        moduleName: ModuleId.ReactRSC
       });
       originalAttributes.push(
-        t21.jsxAttribute(
-          t21.jsxIdentifier("$loadDictionary"),
-          t21.jsxExpressionContainer(
-            t21.arrowFunctionExpression(
-              [t21.identifier("locale")],
-              t21.callExpression(
-                t21.identifier(loadDictionaryImport.importedName),
-                [t21.identifier("locale")]
+        t22.jsxAttribute(
+          t22.jsxIdentifier("$loadDictionary"),
+          t22.jsxExpressionContainer(
+            t22.arrowFunctionExpression(
+              [t22.identifier("locale")],
+              t22.callExpression(
+                t22.identifier(loadDictionaryImport.importedName),
+                [t22.identifier("locale")]
               )
             )
           )
         )
       );
     }
-    const newNode = t21.jsxElement(
-      t21.jsxOpeningElement(
-        t21.jsxIdentifier(lingoComponentImport.importedName),
+    const newNode = t22.jsxElement(
+      t22.jsxOpeningElement(
+        t22.jsxIdentifier(lingoComponentImport.importedName),
         originalAttributes,
         true
         // selfClosing
@@ -2435,7 +2437,7 @@ var lingoJsxScopeInjectMutation = createCodeMutation((payload) => {
 });
 
 // src/jsx-remove-attributes.ts
-import * as t22 from "@babel/types";
+import * as t23 from "@babel/types";
 import traverse9 from "@babel/traverse";
 var jsxRemoveAttributesMutation = createCodeMutation(
   (payload) => {
@@ -2448,7 +2450,7 @@ var jsxRemoveAttributesMutation = createCodeMutation(
       JSXElement(path7) {
         const openingElement = path7.node.openingElement;
         openingElement.attributes = openingElement.attributes.filter((attr) => {
-          const removeAttr = t22.isJSXAttribute(attr) && t22.isJSXIdentifier(attr.name) && ATTRIBUTES_TO_REMOVE.includes(attr.name.name);
+          const removeAttr = t23.isJSXAttribute(attr) && t23.isJSXIdentifier(attr.name) && ATTRIBUTES_TO_REMOVE.includes(attr.name.name);
           return !removeAttr;
         });
       }
@@ -2460,10 +2462,10 @@ var jsxRemoveAttributesMutation = createCodeMutation(
 );
 
 // src/client-dictionary-loader.ts
-import * as t23 from "@babel/types";
+import * as t24 from "@babel/types";
 var clientDictionaryLoaderMutation = createCodeMutation((payload) => {
   const invokations = findInvokations(payload.ast, {
-    moduleName: "lingo.dev/react/client" /* ReactClient */,
+    moduleName: ModuleId.ReactClient,
     functionName: "loadDictionary"
   });
   const allLocales = Array.from(
@@ -2471,10 +2473,10 @@ var clientDictionaryLoaderMutation = createCodeMutation((payload) => {
   );
   for (const invokation of invokations) {
     const internalDictionaryLoader = getOrCreateImport(payload.ast, {
-      moduleName: "lingo.dev/react/client" /* ReactClient */,
+      moduleName: ModuleId.ReactClient,
       exportedName: "loadDictionary_internal"
     });
-    if (t23.isIdentifier(invokation.callee)) {
+    if (t24.isIdentifier(invokation.callee)) {
       invokation.callee.name = internalDictionaryLoader.importedName;
     }
     const dictionaryPath = getDictionaryPath({
@@ -2482,19 +2484,7 @@ var clientDictionaryLoaderMutation = createCodeMutation((payload) => {
       lingoDir: payload.params.lingoDir,
       relativeFilePath: payload.relativeFilePath
     });
-    const localeImportMap = t23.objectExpression(
-      allLocales.map(
-        (locale) => t23.objectProperty(
-          t23.identifier(locale),
-          t23.arrowFunctionExpression(
-            [],
-            t23.callExpression(t23.identifier("import"), [
-              t23.stringLiteral(`${dictionaryPath}?locale=${locale}`)
-            ])
-          )
-        )
-      )
-    );
+    const localeImportMap = createLocaleImportMap(allLocales, dictionaryPath);
     invokation.arguments.push(localeImportMap);
   }
   return payload;