@intlayer/babel 9.0.0-canary.2 → 9.0.0-canary.21

package/dist/cjs/babel-plugin-intlayer-optimize.cjs

@@ -1,8 +1,9 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
+const require_normalizedFilesList = require('./normalizedFilesList.cjs');
 let node_path = require("node:path");
-let _intlayer_chokidar_utils = require("@intlayer/chokidar/utils");
+let _intlayer_engine_utils = require("@intlayer/engine/utils");
 let _intlayer_config_utils = require("@intlayer/config/utils");
+let _intlayer_config_callers = require("@intlayer/config/callers");
 
 //#region src/babel-plugin-intlayer-optimize.ts
 const PACKAGE_LIST = [
@@ -46,6 +47,11 @@ const STATIC_IMPORT_FUNCTION = {
 	useIntlayer: "useDictionary"
 };
 const DYNAMIC_IMPORT_FUNCTION = { useIntlayer: "useDictionaryDynamic" };
+/** Import rename table applied when the helper plan for a package is `dynamic`. */
+const DYNAMIC_HELPER_MAP = {
+	...STATIC_IMPORT_FUNCTION,
+	...DYNAMIC_IMPORT_FUNCTION
+};
 /**
 * Packages whose SSR-static `useDictionary` lives in a `/server` subpath
 * because it differs from the root one. Solid's reserves one hydration
@@ -60,7 +66,7 @@ const SSR_STATIC_IMPORT_SOURCE = { "solid-intlayer": "solid-intlayer/server" };
 * with user-defined ones.
 */
 const makeIdent = (key, t) => {
-	const hash = (0, _intlayer_chokidar_utils.getPathHash)(key);
+	const hash = (0, _intlayer_engine_utils.getPathHash)(key);
 	return t.identifier(`_${hash}`);
 };
 const computeImport = (fromFile, dictionariesDir, dynamicDictionariesDir, fetchDictionariesDir, key, importMode) => {
@@ -77,6 +83,60 @@ const getKeyFromArgument = (arg, t) => {
 	if (arg && t.isTemplateLiteral(arg) && arg.expressions.length === 0 && arg.quasis.length === 1) return arg.quasis[0]?.value.cooked ?? arg.quasis[0]?.value.raw;
 };
 const isCallerName = (name) => CALLER_LIST.includes(name);
+/**
+* Splits a namespace string at the first `.` to separate the dictionary key
+* from an optional key prefix for nested namespaces, mirroring the SWC
+* plugin's `split_namespace`.
+*
+*   `'about'`         → `{ dictionaryKey: 'about', keyPrefix: '' }`
+*   `'about.counter'` → `{ dictionaryKey: 'about', keyPrefix: 'counter' }`
+*/
+const splitNamespace = (namespace) => {
+	const dotPosition = namespace.indexOf(".");
+	if (dotPosition === -1) return {
+		dictionaryKey: namespace,
+		keyPrefix: ""
+	};
+	return {
+		dictionaryKey: namespace.slice(0, dotPosition),
+		keyPrefix: namespace.slice(dotPosition + 1)
+	};
+};
+/**
+* Statically resolves the namespace of a compat caller call-site from its
+* descriptor's `namespaceSources` (argument / option / fixed — the
+* per-message-id `path-first-segment` form cannot bind one dictionary to the
+* call site and is skipped). Returns `undefined` when the namespace is absent
+* or dynamic, in which case the call is left untouched and resolves through
+* the runtime dictionary registry.
+*/
+const resolveCompatNamespaceMatch = (t, callArguments, descriptor) => {
+	for (const source of descriptor.namespaceSources) {
+		if (source.from === "fixed") return { fullNamespace: source.value };
+		if (source.from === "argument") {
+			const namespace = getKeyFromArgument(callArguments[source.index], t);
+			if (namespace !== void 0) return {
+				fullNamespace: namespace,
+				argumentIndex: source.index
+			};
+			continue;
+		}
+		if (source.from === "option") {
+			const optionsArgument = callArguments[source.argumentIndex];
+			if (!optionsArgument || !t.isObjectExpression(optionsArgument)) continue;
+			for (const property of optionsArgument.properties) {
+				if (!t.isObjectProperty(property)) continue;
+				if (!(t.isIdentifier(property.key) && property.key.name === source.property || t.isStringLiteral(property.key) && property.key.value === source.property)) continue;
+				const namespace = getKeyFromArgument(property.value, t);
+				if (namespace !== void 0) return {
+					fullNamespace: namespace,
+					optionProperty: property,
+					optionsObject: optionsArgument
+				};
+			}
+		}
+	}
+};
 const isDynamicPackage = (packageName) => PACKAGE_LIST_DYNAMIC.includes(packageName);
 /**
 * Decides, once per package import, which helper family applies to this file.
@@ -183,6 +243,7 @@ const intlayerOptimizeBabelPlugin = (babel) => {
 			this._newDynamicImports = /* @__PURE__ */ new Map();
 			this._callerMap = /* @__PURE__ */ new Map();
 			this._callerPackageMap = /* @__PURE__ */ new Map();
+			this._compatCallerMap = /* @__PURE__ */ new Map();
 			this._isIncluded = true;
 			this._hasValidImport = false;
 			this._isDictEntry = false;
@@ -192,7 +253,7 @@ const intlayerOptimizeBabelPlugin = (babel) => {
 			}
 			const filename = this.file.opts.filename ? (0, _intlayer_config_utils.normalizePath)(this.file.opts.filename) : void 0;
 			if (this.opts.filesList && filename) {
-				if (!this.opts.filesList.map(_intlayer_config_utils.normalizePath).includes(filename)) {
+				if (!require_normalizedFilesList.getNormalizedFilesListSet(this.opts.filesList).has(filename)) {
 					this._isIncluded = false;
 					return;
 				}
@@ -225,24 +286,43 @@ const intlayerOptimizeBabelPlugin = (babel) => {
 			exit(programPath, state) {
 				if (state._isDictEntry) return;
 				if (!state._isIncluded) return;
+				const rewritableCompatCallers = (0, _intlayer_config_callers.getRewritableCallers)(state.opts.compatCallers ?? []);
 				programPath.traverse({ ImportDeclaration(path) {
 					const src = path.node.source.value;
-					if (!PACKAGE_LIST.includes(src)) return;
+					const isNativePackage = PACKAGE_LIST.includes(src);
+					const compatCallersForSource = rewritableCompatCallers.filter((descriptor) => descriptor.importSources.includes(src));
+					if (!isNativePackage && compatCallersForSource.length === 0) return;
 					state._hasValidImport = true;
 					for (const spec of path.node.specifiers) {
 						if (!t.isImportSpecifier(spec)) continue;
 						const importedName = t.isIdentifier(spec.imported) ? spec.imported.name : spec.imported.value;
-						if (isCallerName(importedName)) {
+						if (isNativePackage && isCallerName(importedName)) {
 							state._callerMap?.set(spec.local.name, importedName);
 							state._callerPackageMap?.set(spec.local.name, src);
 						}
+						const compatDescriptor = compatCallersForSource.find((descriptor) => descriptor.callerName === importedName);
+						if (compatDescriptor) state._compatCallerMap?.set(spec.local.name, compatDescriptor);
 					}
 				} });
 				const packagesWithDynamicCall = /* @__PURE__ */ new Set();
 				const packagesWithFetchCall = /* @__PURE__ */ new Set();
+				let compatHasDynamicCall = false;
+				const unresolvableCompatLocalNames = /* @__PURE__ */ new Set();
 				programPath.traverse({ CallExpression(path) {
 					const callee = path.node.callee;
 					if (!t.isIdentifier(callee)) return;
+					const compatDescriptor = state._compatCallerMap?.get(callee.name);
+					if (compatDescriptor) {
+						const namespaceMatch = resolveCompatNamespaceMatch(t, path.node.arguments, compatDescriptor);
+						if (!namespaceMatch) {
+							unresolvableCompatLocalNames.add(callee.name);
+							return;
+						}
+						const { dictionaryKey } = splitNamespace(namespaceMatch.fullNamespace);
+						const compatOverrideMode = state.opts.dictionaryModeMap?.[dictionaryKey];
+						if (compatOverrideMode === "dynamic" || compatOverrideMode === "fetch") compatHasDynamicCall = true;
+						return;
+					}
 					if (state._callerMap?.get(callee.name) !== "useIntlayer") return;
 					const callerPackage = state._callerPackageMap?.get(callee.name);
 					if (!callerPackage) return;
@@ -252,17 +332,23 @@ const intlayerOptimizeBabelPlugin = (babel) => {
 					if (dictionaryOverrideMode === "dynamic") packagesWithDynamicCall.add(callerPackage);
 					else if (dictionaryOverrideMode === "fetch") packagesWithFetchCall.add(callerPackage);
 				} });
+				for (const localName of unresolvableCompatLocalNames) state._compatCallerMap?.delete(localName);
 				const getHelperPlan = (packageName) => resolveHelperPlan(packageName, state.opts.importMode, state.opts.isServer, packagesWithDynamicCall.has(packageName), packagesWithFetchCall.has(packageName));
+				const compatUseDynamicHelpers = state.opts.importMode === "dynamic" || state.opts.importMode === "fetch" || compatHasDynamicCall;
 				programPath.traverse({
 					ImportDeclaration(path) {
 						const src = path.node.source.value;
+						for (const spec of path.node.specifiers) {
+							if (!t.isImportSpecifier(spec)) continue;
+							const compatDescriptor = state._compatCallerMap?.get(spec.local.name);
+							if (!compatDescriptor) continue;
+							if (!compatDescriptor.importSources.includes(src)) continue;
+							spec.imported = t.identifier(compatUseDynamicHelpers ? compatDescriptor.dynamicReplacement : compatDescriptor.staticReplacement);
+						}
 						if (!PACKAGE_LIST.includes(src)) return;
 						const helperPlan = getHelperPlan(src);
 						const serverSource = helperPlan === "ssrStatic" ? SSR_STATIC_IMPORT_SOURCE[src] : void 0;
-						const helperMap = helperPlan === "dynamic" ? {
-							...STATIC_IMPORT_FUNCTION,
-							...DYNAMIC_IMPORT_FUNCTION
-						} : { ...STATIC_IMPORT_FUNCTION };
+						const helperMap = helperPlan === "dynamic" ? DYNAMIC_HELPER_MAP : STATIC_IMPORT_FUNCTION;
 						const serverSpecifiers = [];
 						for (const spec of path.node.specifiers) {
 							if (!t.isImportSpecifier(spec)) continue;
@@ -285,6 +371,49 @@ const intlayerOptimizeBabelPlugin = (babel) => {
 					CallExpression(path) {
 						const callee = path.node.callee;
 						if (!t.isIdentifier(callee)) return;
+						const compatDescriptor = state._compatCallerMap?.get(callee.name);
+						if (compatDescriptor) {
+							const callArguments = path.node.arguments;
+							const namespaceMatch = resolveCompatNamespaceMatch(t, callArguments, compatDescriptor);
+							if (!namespaceMatch) return;
+							state._hasValidImport = true;
+							const { dictionaryKey, keyPrefix } = splitNamespace(namespaceMatch.fullNamespace);
+							const compatOverrideMode = state.opts.dictionaryModeMap?.[dictionaryKey];
+							let compatCallMode = "static";
+							if (compatUseDynamicHelpers) if (compatOverrideMode === "dynamic" || compatOverrideMode === "fetch") compatCallMode = compatOverrideMode;
+							else if (state.opts.importMode === "dynamic" || state.opts.importMode === "fetch") compatCallMode = state.opts.importMode;
+							else compatCallMode = "dynamic";
+							let dictionaryIdent;
+							if (compatCallMode === "static") {
+								let staticIdent = state._newStaticImports?.get(dictionaryKey);
+								if (!staticIdent) {
+									staticIdent = makeIdent(dictionaryKey, t);
+									state._newStaticImports?.set(dictionaryKey, staticIdent);
+								}
+								dictionaryIdent = staticIdent;
+							} else {
+								let dynamicIdent = state._newDynamicImports?.get(dictionaryKey);
+								if (!dynamicIdent) {
+									const hash = (0, _intlayer_engine_utils.getPathHash)(dictionaryKey);
+									const suffix = compatCallMode === "fetch" ? "fetch" : "dyn";
+									dynamicIdent = t.identifier(`_${hash}_${suffix}`);
+									state._newDynamicImports?.set(dictionaryKey, dynamicIdent);
+								}
+								dictionaryIdent = dynamicIdent;
+							}
+							if (namespaceMatch.argumentIndex !== void 0) {
+								callArguments[namespaceMatch.argumentIndex] = t.identifier(dictionaryIdent.name);
+								const insertAt = namespaceMatch.argumentIndex + 1;
+								const insertedArguments = [];
+								if (compatCallMode !== "static") insertedArguments.push(t.stringLiteral(dictionaryKey));
+								if (keyPrefix) insertedArguments.push(t.stringLiteral(keyPrefix));
+								callArguments.splice(insertAt, 0, ...insertedArguments);
+							} else if (compatCallMode !== "static") callArguments.unshift(t.identifier(dictionaryIdent.name), t.stringLiteral(dictionaryKey));
+							else callArguments.unshift(t.identifier(dictionaryIdent.name));
+							if (namespaceMatch.optionProperty && namespaceMatch.optionsObject) if (keyPrefix) namespaceMatch.optionProperty.value = t.stringLiteral(keyPrefix);
+							else namespaceMatch.optionsObject.properties = namespaceMatch.optionsObject.properties.filter((property) => property !== namespaceMatch.optionProperty);
+							return;
+						}
 						const originalImportedName = state._callerMap?.get(callee.name);
 						if (!originalImportedName) return;
 						state._hasValidImport = true;
@@ -306,7 +435,7 @@ const intlayerOptimizeBabelPlugin = (babel) => {
 						if (perCallMode === "fetch") {
 							let dynamicIdent = state._newDynamicImports?.get(key);
 							if (!dynamicIdent) {
-								const hash = (0, _intlayer_chokidar_utils.getPathHash)(key);
+								const hash = (0, _intlayer_engine_utils.getPathHash)(key);
 								dynamicIdent = t.identifier(`_${hash}_fetch`);
 								state._newDynamicImports?.set(key, dynamicIdent);
 							}
@@ -315,7 +444,7 @@ const intlayerOptimizeBabelPlugin = (babel) => {
 						} else if (perCallMode === "dynamic") {
 							let dynamicIdent = state._newDynamicImports?.get(key);
 							if (!dynamicIdent) {
-								const hash = (0, _intlayer_chokidar_utils.getPathHash)(key);
+								const hash = (0, _intlayer_engine_utils.getPathHash)(key);
 								dynamicIdent = t.identifier(`_${hash}_dyn`);
 								state._newDynamicImports?.set(key, dynamicIdent);
 							}
@@ -345,7 +474,8 @@ const intlayerOptimizeBabelPlugin = (babel) => {
 					imports.push(importDeclarationNode);
 				}
 				for (const [key, ident] of state._newDynamicImports) {
-					const rel = computeImport(file, dictionariesDir, dynamicDictionariesDir, fetchDictionariesDir, key, ident.name.endsWith("_fetch") ? "fetch" : "dynamic");
+					const modeForThisIdent = ident.name.endsWith("_fetch") ? "fetch" : "dynamic";
+					const rel = computeImport(file, dictionariesDir, dynamicDictionariesDir, fetchDictionariesDir, key, modeForThisIdent);
 					imports.push(t.importDeclaration([t.importDefaultSpecifier(t.identifier(ident.name))], t.stringLiteral(rel)));
 				}
 				if (!imports.length) return;

package/dist/cjs/babel-plugin-intlayer-optimize.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"babel-plugin-intlayer-optimize.cjs","names":["normalizePath"],"sources":["../../src/babel-plugin-intlayer-optimize.ts"],"sourcesContent":["import { dirname, join, relative } from 'node:path';\nimport type { NodePath, PluginObj, PluginPass } from '@babel/core';\nimport type * as BabelTypes from '@babel/types';\nimport { getPathHash } from '@intlayer/chokidar/utils';\nimport { normalizePath } from '@intlayer/config/utils';\n\nconst PACKAGE_LIST = [\n  'intlayer',\n  '@intlayer/core',\n  'react-intlayer',\n  'react-intlayer/client',\n  'react-intlayer/server',\n  'next-intlayer',\n  'next-intlayer/client',\n  'next-intlayer/server',\n  'svelte-intlayer',\n  'vue-intlayer',\n  'angular-intlayer',\n  'preact-intlayer',\n  'solid-intlayer',\n  'lit-intlayer',\n  'vanilla-intlayer',\n];\n\nconst CALLER_LIST = ['useIntlayer', 'getIntlayer'] as const;\n\n/**\n * Packages that support dynamic import\n */\nconst PACKAGE_LIST_DYNAMIC = [\n  'react-intlayer',\n  'react-intlayer/client',\n  'react-intlayer/server',\n  'next-intlayer',\n  'next-intlayer/client',\n  'next-intlayer/server',\n  'preact-intlayer',\n  'vue-intlayer',\n  'solid-intlayer',\n  'svelte-intlayer',\n  'angular-intlayer',\n  'lit-intlayer',\n  'vanilla-intlayer',\n] as const;\n\nconst STATIC_IMPORT_FUNCTION = {\n  getIntlayer: 'getDictionary',\n  useIntlayer: 'useDictionary',\n} as const;\n\nconst DYNAMIC_IMPORT_FUNCTION = {\n  useIntlayer: 'useDictionaryDynamic',\n} as const;\n\n/**\n * Packages whose SSR-static `useDictionary` lives in a `/server` subpath\n * because it differs from the root one. Solid's reserves one hydration\n * resource slot so hydration ids stay aligned with the client's\n * `useDictionaryDynamic`; for other frameworks the root `useDictionary` is\n * already the correct SSR-static implementation.\n */\nconst SSR_STATIC_IMPORT_SOURCE: Partial<Record<string, string>> = {\n  'solid-intlayer': 'solid-intlayer/server',\n};\n\ntype CallerName = (typeof CALLER_LIST)[number];\ntype ImportMode = 'static' | 'dynamic' | 'fetch';\n\n/**\n * Options for the optimization Babel plugin\n */\nexport type OptimizePluginOptions = {\n  /**\n   * If false, the plugin will not apply any transformation.\n   */\n  optimize?: boolean;\n  /**\n   * The path to the dictionaries directory.\n   */\n  dictionariesDir: string;\n  /**\n   * The path to the dictionaries entry file.\n   */\n  dictionariesEntryPath: string;\n  /**\n   * The path to the unmerged dictionaries entry file.\n   */\n  unmergedDictionariesEntryPath: string;\n  /**\n   * The path to the unmerged dictionaries directory.\n   */\n  unmergedDictionariesDir: string;\n  /**\n   * The path to the dictionaries directory.\n   */\n  dynamicDictionariesDir: string;\n  /**\n   * The path to the dynamic dictionaries entry file.\n   */\n  dynamicDictionariesEntryPath: string;\n  /**\n   * The path to the fetch dictionaries directory.\n   */\n  fetchDictionariesDir: string;\n  /**\n   * The path to the fetch dictionaries entry file.\n   */\n  fetchDictionariesEntryPath: string;\n  /**\n   * If true, the plugin will replace the dictionary entry file with `export default {}`.\n   */\n  replaceDictionaryEntry: boolean;\n  /**\n   * If true, the plugin will activate the dynamic import of the dictionaries. It will rely on Suspense to load the dictionaries.\n   */\n  importMode: 'static' | 'dynamic' | 'fetch' | undefined;\n  /**\n   * Map of dictionary keys to their specific import mode.\n   */\n  dictionaryModeMap?: Record<\n    string,\n    'static' | 'dynamic' | 'fetch' | undefined\n  >;\n  /**\n   * Files list to traverse.\n   */\n  filesList: string[];\n  /**\n   * Whether the current transform is for an SSR bundle.\n   */\n  isServer?: boolean;\n};\n\ntype State = PluginPass & {\n  opts: OptimizePluginOptions;\n  /** map key → generated ident (per-file) for static imports */\n  _newStaticImports?: Map<string, BabelTypes.Identifier>;\n  /** map key → generated ident (per-file) for dynamic imports */\n  _newDynamicImports?: Map<string, BabelTypes.Identifier>;\n  /** whether the current file imported *any* intlayer package */\n  _hasValidImport?: boolean;\n  /** map from local identifier name to the imported intlayer func name ('useIntlayer' | 'getIntlayer') */\n  _callerMap?: Map<string, (typeof CALLER_LIST)[number]>;\n  /** map from local identifier name to the intlayer package it was imported from */\n  _callerPackageMap?: Map<string, string>;\n  /** whether the current file *is* the dictionaries entry file */\n  _isDictEntry?: boolean;\n  /** whether the current file is included in the filesList */\n  _isIncluded?: boolean;\n};\n\n/**\n * Replicates the xxHash64 → Base-62 algorithm used by the SWC version\n * and prefixes an underscore so the generated identifiers never collide\n * with user-defined ones.\n */\nconst makeIdent = (\n  key: string,\n  t: typeof BabelTypes\n): BabelTypes.Identifier => {\n  const hash = getPathHash(key);\n  return t.identifier(`_${hash}`);\n};\n\nconst computeImport = (\n  fromFile: string,\n  dictionariesDir: string,\n  dynamicDictionariesDir: string,\n  fetchDictionariesDir: string,\n  key: string,\n  importMode: 'static' | 'dynamic' | 'fetch'\n): string => {\n  let relativePath = join(dictionariesDir, `${key}.json`);\n\n  if (importMode === 'fetch') {\n    relativePath = join(fetchDictionariesDir, `${key}.mjs`);\n  }\n\n  if (importMode === 'dynamic') {\n    relativePath = join(dynamicDictionariesDir, `${key}.mjs`);\n  }\n\n  let rel = relative(dirname(fromFile), relativePath);\n\n  // Fix windows path\n  rel = normalizePath(rel);\n\n  // Fix relative path\n  if (!rel.startsWith('./') && !rel.startsWith('../')) {\n    rel = `./${rel}`;\n  }\n\n  return rel;\n};\n\nconst getKeyFromArgument = (\n  arg: BabelTypes.Node | null | undefined,\n  t: typeof BabelTypes\n): string | undefined => {\n  if (arg && t.isStringLiteral(arg)) {\n    return arg.value;\n  }\n\n  if (\n    arg &&\n    t.isTemplateLiteral(arg) &&\n    arg.expressions.length === 0 &&\n    arg.quasis.length === 1\n  ) {\n    return arg.quasis[0]?.value.cooked ?? arg.quasis[0]?.value.raw;\n  }\n\n  return undefined;\n};\n\nconst isCallerName = (name: string): name is CallerName =>\n  CALLER_LIST.includes(name as CallerName);\n\nconst isDynamicPackage = (\n  packageName: string\n): packageName is (typeof PACKAGE_LIST_DYNAMIC)[number] =>\n  PACKAGE_LIST_DYNAMIC.includes(\n    packageName as (typeof PACKAGE_LIST_DYNAMIC)[number]\n  );\n\n/**\n * Helper family every `useIntlayer`/`getIntlayer` call from one package import\n * resolves to in the current file. `ssrStatic` is the SSR bundle of a\n * dynamic-mode file: rewritten to the static `useDictionary` (from the\n * package's `/server` entry when it has one — see\n * `SSR_STATIC_IMPORT_SOURCE`) so the server renders static JSON while the\n * client keeps the dynamic loader.\n */\ntype PackageHelperPlan = 'static' | 'dynamic' | 'ssrStatic';\n\n/**\n * Decides, once per package import, which helper family applies to this file.\n * The import rewrite and the per-call rewrite must both derive from this\n * single decision, or the emitted helper and its argument shape diverge.\n *\n * Fetch wins over `ssrStatic`: fetch dictionaries are runtime content, so the\n * server must keep the real fetch path instead of rendering build-time JSON.\n */\nconst resolveHelperPlan = (\n  packageName: string,\n  importMode: ImportMode | undefined,\n  isServer: boolean | undefined,\n  packageHasDynamicCall: boolean,\n  packageHasFetchCall: boolean\n): PackageHelperPlan => {\n  if (!isDynamicPackage(packageName)) return 'static';\n\n  if (importMode === 'fetch' || packageHasFetchCall) return 'dynamic';\n\n  if (importMode === 'dynamic' || packageHasDynamicCall) {\n    return isServer === true ? 'ssrStatic' : 'dynamic';\n  }\n\n  return 'static';\n};\n\n/**\n * Babel plugin that transforms Intlayer function calls and auto-imports dictionaries.\n *\n * This plugin transforms calls to `useIntlayer()` and `getIntlayer()` from various Intlayer\n * packages into optimized dictionary access patterns, automatically importing the required\n * dictionary files based on the configured import mode.\n *\n * ## Supported Input Patterns\n *\n * The plugin recognizes these function calls:\n *\n * ```ts\n * // useIntlayer\n * import { useIntlayer } from 'react-intlayer';\n * import { useIntlayer } from 'next-intlayer';\n *\n * // getIntlayer\n * import { getIntlayer } from 'intlayer';\n *\n * // Usage\n * const content = useIntlayer('app');\n * const content = getIntlayer('app');\n * ```\n *\n * ## Transformation Modes\n *\n * ### Static Mode (default: `importMode = \"static\"`)\n *\n * Imports JSON dictionaries directly and replaces function calls with dictionary access:\n *\n * **Output:**\n * ```ts\n * import _dicHash from '../../.intlayer/dictionaries/app.json' with { type: 'json' };\n * import { useDictionary as useIntlayer } from 'react-intlayer';\n * import { getDictionary as getIntlayer } from 'intlayer';\n *\n * const content1 = useIntlayer(_dicHash);\n * const content2 = getIntlayer(_dicHash);\n * ```\n *\n * ### Dynamic Mode (`importMode = \"dynamic\"`)\n *\n * Uses dynamic dictionary loading with Suspense support:\n *\n * **Output:**\n * ```ts\n * import _dicHash from '../../.intlayer/dictionaries/app.json' with { type: 'json' };\n * import _dicHash_dyn from '../../.intlayer/dynamic_dictionaries/app.mjs';\n * import { useDictionaryDynamic as useIntlayer } from 'react-intlayer';\n * import { getDictionary as getIntlayer } from 'intlayer';\n *\n * const content1 = useIntlayer(_dicHash_dyn, 'app');\n * const content2 = getIntlayer(_dicHash);\n * ```\n *\n * ### Fetch Mode (`importMode = \"fetch\"`)\n *\n * Uses fetch-based dictionary loading for remote dictionaries:\n *\n * **Output if `dictionaryModeMap` includes the key with \"fetch\" value:**\n * ```ts\n * import _dicHash from '../../.intlayer/dictionaries/app.json' with { type: 'json' };\n * import _dicHash_fetch from '../../.intlayer/fetch_dictionaries/app.mjs';\n * import { useDictionaryDynamic as useIntlayer } from 'react-intlayer';\n * import { getDictionary as getIntlayer } from 'intlayer';\n *\n * const content1 = useIntlayer(_dicHash_fetch, \"app\");\n * const content2 = getIntlayer(_dicHash);\n * ```\n *\n * > If `dictionaryModeMap` does not include the key with \"fetch\" value, the plugin will fallback to the dynamic import mode.\n *\n * ```ts\n * import _dicHash from '../../.intlayer/dictionaries/app.json' with { type: 'json' };\n * import _dicHash_dyn from '../../.intlayer/dynamic_dictionaries/app.mjs';\n * import { useDictionaryDynamic as useIntlayer } from 'react-intlayer';\n * import { getDictionary as getIntlayer } from 'intlayer';\n *\n * const content1 = useIntlayer(_dicHash_dyn, 'app');\n * const content2 = getIntlayer(_dicHash);\n * ```\n */\nexport const intlayerOptimizeBabelPlugin = (babel: {\n  types: typeof BabelTypes;\n}): PluginObj<State> => {\n  const { types: t } = babel;\n\n  return {\n    name: 'babel-plugin-intlayer-transform',\n\n    pre() {\n      this._newStaticImports = new Map();\n      this._newDynamicImports = new Map();\n      this._callerMap = new Map();\n      this._callerPackageMap = new Map();\n      this._isIncluded = true;\n      this._hasValidImport = false;\n      this._isDictEntry = false;\n\n      // If optimize is false, skip processing entirely\n      if (this.opts.optimize === false) {\n        this._isIncluded = false;\n        return;\n      }\n\n      // If filesList is provided, check if current file is included\n      const filename = this.file.opts.filename\n        ? normalizePath(this.file.opts.filename)\n        : undefined;\n      if (this.opts.filesList && filename) {\n        const filesList = this.opts.filesList.map(normalizePath);\n        const isIncluded = filesList.includes(filename);\n\n        if (!isIncluded) {\n          // Force _isIncluded to false to skip processing\n          this._isIncluded = false;\n          return;\n        }\n      }\n    },\n\n    visitor: {\n      /* If this file *is* the dictionaries entry, short-circuit: export {} */\n      Program: {\n        enter(programPath, state) {\n          // Safe access to filename\n          const filename = state.file.opts.filename\n            ? normalizePath(state.file.opts.filename)\n            : undefined;\n          const dictionariesEntryPath = state.opts.dictionariesEntryPath\n            ? normalizePath(state.opts.dictionariesEntryPath)\n            : undefined;\n\n          // Check if this is the correct file to transform\n\n          if (\n            state.opts.replaceDictionaryEntry &&\n            filename === dictionariesEntryPath\n          ) {\n            state._isDictEntry = true;\n\n            // Traverse the program to surgically remove/edit specific parts\n            programPath.traverse({\n              // Remove all import statements (cleaning up 'sssss.json')\n              ImportDeclaration(path) {\n                path.remove();\n              },\n\n              // Find the variable definition and empty the object\n              VariableDeclarator(path) {\n                // We look for: const x = { ... }\n\n                if (t.isObjectExpression(path.node.init)) {\n                  // Set the object properties to an empty array: {}\n                  path.node.init.properties = [];\n                }\n              },\n            });\n\n            // (Optional) Stop other plugins from processing this file further if needed\n            // programPath.stop();\n          }\n        },\n\n        /**\n         * After full traversal, process imports and call expressions, then inject the JSON dictionary imports.\n         *\n         * We do the transformation in Program.exit (via a manual traverse) rather than using\n         * top-level ImportDeclaration/CallExpression visitors. This ensures that if another plugin\n         * (like babel-plugin-intlayer-extract) adds new useIntlayer calls in its Program.exit,\n         * we will see and transform them here because our Program.exit runs after theirs.\n         */\n        exit(programPath, state) {\n          if (state._isDictEntry) return; // nothing else to do – already replaced\n\n          if (!state._isIncluded) return; // early-out if file is not included\n\n          // Manual traversal to process imports and call expressions\n          // This runs AFTER all other plugins' visitors have completed\n          programPath.traverse({\n            /* Inspect every intlayer import before deciding helper rewrites. */\n            ImportDeclaration(path) {\n              const src = path.node.source.value;\n\n              if (!PACKAGE_LIST.includes(src)) return;\n\n              state._hasValidImport = true;\n\n              for (const spec of path.node.specifiers) {\n                if (!t.isImportSpecifier(spec)) continue;\n\n                const importedName = t.isIdentifier(spec.imported)\n                  ? spec.imported.name\n                  : (spec.imported as BabelTypes.StringLiteral).value;\n\n                if (isCallerName(importedName)) {\n                  state._callerMap?.set(spec.local.name, importedName);\n                  state._callerPackageMap?.set(spec.local.name, src);\n                }\n              }\n            },\n          });\n\n          // Pre-pass to determine if dictionary-level overrides require the\n          // dynamic helper in an otherwise static file.\n          const packagesWithDynamicCall = new Set<string>();\n          const packagesWithFetchCall = new Set<string>();\n          programPath.traverse({\n            CallExpression(path) {\n              const callee = path.node.callee;\n\n              if (!t.isIdentifier(callee)) return;\n\n              const originalImportedName = state._callerMap?.get(callee.name);\n              if (originalImportedName !== 'useIntlayer') return;\n\n              const callerPackage = state._callerPackageMap?.get(callee.name);\n              if (!callerPackage) return;\n\n              const key = getKeyFromArgument(path.node.arguments[0], t);\n              if (!key) return;\n\n              const dictionaryOverrideMode =\n                state.opts.dictionaryModeMap?.[key];\n\n              if (dictionaryOverrideMode === 'dynamic') {\n                packagesWithDynamicCall.add(callerPackage);\n              } else if (dictionaryOverrideMode === 'fetch') {\n                packagesWithFetchCall.add(callerPackage);\n              }\n            },\n          });\n\n          const getHelperPlan = (packageName: string): PackageHelperPlan =>\n            resolveHelperPlan(\n              packageName,\n              state.opts.importMode,\n              state.opts.isServer,\n              packagesWithDynamicCall.has(packageName),\n              packagesWithFetchCall.has(packageName)\n            );\n\n          programPath.traverse({\n            ImportDeclaration(path) {\n              const src = path.node.source.value;\n\n              if (!PACKAGE_LIST.includes(src)) return;\n\n              // Per-import swap, mirrored across bundles — Solid hydration\n              // ids rely on the SSR and client helpers consuming one\n              // resource slot per call alike (see solid-intlayer/server).\n              const helperPlan = getHelperPlan(src);\n              const serverSource =\n                helperPlan === 'ssrStatic'\n                  ? SSR_STATIC_IMPORT_SOURCE[src]\n                  : undefined;\n\n              const helperMap: Record<string, string> =\n                helperPlan === 'dynamic'\n                  ? { ...STATIC_IMPORT_FUNCTION, ...DYNAMIC_IMPORT_FUNCTION }\n                  : { ...STATIC_IMPORT_FUNCTION };\n\n              const serverSpecifiers: BabelTypes.ImportSpecifier[] = [];\n\n              for (const spec of path.node.specifiers) {\n                if (!t.isImportSpecifier(spec)) continue;\n\n                const importedName = t.isIdentifier(spec.imported)\n                  ? spec.imported.name\n                  : (spec.imported as BabelTypes.StringLiteral).value;\n\n                if (!isCallerName(importedName)) continue;\n\n                if (serverSource && importedName === 'useIntlayer') {\n                  spec.imported = t.identifier('useDictionary');\n                  serverSpecifiers.push(spec);\n                  continue;\n                }\n\n                const newIdentifier = helperMap[importedName];\n\n                if (newIdentifier) {\n                  // Keep the local alias intact (so calls remain `useIntlayer` /\n                  // `getIntlayer`), but rewrite the imported identifier so it\n                  // points to our helper implementation.\n                  spec.imported = t.identifier(newIdentifier);\n                }\n              }\n\n              if (serverSpecifiers.length > 0 && serverSource) {\n                // Move the helper to the /server entry, keeping any other\n                // specifiers (useLocale, …) on the original import.\n                path.insertAfter(\n                  t.importDeclaration(\n                    serverSpecifiers,\n                    t.stringLiteral(serverSource)\n                  )\n                );\n                path.node.specifiers = path.node.specifiers.filter(\n                  (spec) =>\n                    !serverSpecifiers.includes(\n                      spec as BabelTypes.ImportSpecifier\n                    )\n                );\n                if (path.node.specifiers.length === 0) {\n                  path.remove();\n                }\n              }\n            },\n\n            /* Replace calls: useIntlayer(\"foo\") → useDictionary(_hash) or useDictionaryDynamic(_hash, \"foo\") */\n            CallExpression(path) {\n              const callee = path.node.callee;\n\n              if (!t.isIdentifier(callee)) return;\n\n              const originalImportedName = state._callerMap?.get(callee.name);\n              if (!originalImportedName) return;\n\n              // Ensure we ultimately emit helper imports for files that *invoke*\n              // the hooks, even if they didn't import them directly (edge cases with\n              // re-exports).\n              state._hasValidImport = true;\n\n              const key = getKeyFromArgument(path.node.arguments[0], t);\n              if (!key) return;\n\n              const callerPackage = state._callerPackageMap?.get(callee.name);\n              const importMode = state.opts.importMode;\n              const isUseIntlayer = originalImportedName === 'useIntlayer';\n              const dictionaryOverrideMode =\n                state.opts.dictionaryModeMap?.[key];\n              const helperPlan =\n                callerPackage === undefined\n                  ? 'static'\n                  : getHelperPlan(callerPackage);\n\n              // Decide per-call mode: 'static' | 'dynamic' | 'fetch'.\n              let perCallMode: ImportMode = 'static';\n\n              if (isUseIntlayer && helperPlan === 'dynamic') {\n                if (dictionaryOverrideMode) {\n                  perCallMode = dictionaryOverrideMode;\n                } else if (importMode === 'dynamic' || importMode === 'fetch') {\n                  perCallMode = importMode;\n                }\n              } else if (isUseIntlayer && helperPlan === 'static') {\n                // The global mode is static, but a per-dictionary override can\n                // still force dynamic/fetch for this specific call.\n                if (\n                  dictionaryOverrideMode === 'dynamic' ||\n                  dictionaryOverrideMode === 'fetch'\n                ) {\n                  perCallMode = dictionaryOverrideMode;\n                }\n              }\n\n              let ident: BabelTypes.Identifier;\n\n              if (perCallMode === 'fetch') {\n                // Use fetch dictionaries entry for selected keys\n                let dynamicIdent = state._newDynamicImports?.get(key);\n\n                if (!dynamicIdent) {\n                  const hash = getPathHash(key);\n                  dynamicIdent = t.identifier(`_${hash}_fetch`);\n                  state._newDynamicImports?.set(key, dynamicIdent);\n                }\n                ident = dynamicIdent;\n\n                // Helper: first argument is the dictionary entry, second is the key\n                path.node.arguments = [\n                  t.identifier(ident.name),\n                  ...path.node.arguments,\n                ];\n              } else if (perCallMode === 'dynamic') {\n                // Use dynamic dictionaries entry\n                let dynamicIdent = state._newDynamicImports?.get(key);\n\n                if (!dynamicIdent) {\n                  // Create a unique identifier for dynamic imports by appending a suffix\n                  const hash = getPathHash(key);\n                  dynamicIdent = t.identifier(`_${hash}_dyn`);\n                  state._newDynamicImports?.set(key, dynamicIdent);\n                }\n                ident = dynamicIdent;\n\n                // Dynamic helper: first argument is the dictionary, second is the key.\n                path.node.arguments = [\n                  t.identifier(ident.name),\n                  ...path.node.arguments,\n                ];\n              } else {\n                // Use static imports for getIntlayer or useIntlayer when not using dynamic helpers\n                let staticIdent = state._newStaticImports?.get(key);\n\n                if (!staticIdent) {\n                  staticIdent = makeIdent(key, t);\n                  state._newStaticImports?.set(key, staticIdent);\n                }\n                ident = staticIdent;\n\n                // Static helper (useDictionary / getDictionary): replace key with ident.\n                // After the splice above the key is always at index 0.\n                path.node.arguments[0] = t.identifier(ident.name);\n              }\n            },\n          });\n\n          // Early-out if we touched nothing\n\n          if (!state._hasValidImport) return;\n\n          const file = state.file.opts.filename!;\n          const dictionariesDir = state.opts.dictionariesDir;\n          const dynamicDictionariesDir = state.opts.dynamicDictionariesDir;\n          const fetchDictionariesDir = state.opts.fetchDictionariesDir;\n          const imports: BabelTypes.ImportDeclaration[] = [];\n\n          // Generate static JSON imports (getIntlayer always uses JSON dictionaries)\n          for (const [key, ident] of state._newStaticImports!) {\n            const rel = computeImport(\n              file,\n              dictionariesDir,\n              dynamicDictionariesDir,\n              fetchDictionariesDir,\n              key,\n              'static'\n            );\n\n            const importDeclarationNode = t.importDeclaration(\n              [t.importDefaultSpecifier(t.identifier(ident.name))],\n              t.stringLiteral(rel)\n            );\n\n            // Add 'type: json' attribute for JSON files\n            importDeclarationNode.attributes = [\n              t.importAttribute(t.identifier('type'), t.stringLiteral('json')),\n            ];\n\n            imports.push(importDeclarationNode);\n          }\n\n          // Generate dynamic/fetch imports (for useIntlayer when using dynamic/fetch helpers)\n          for (const [key, ident] of state._newDynamicImports!) {\n            const modeForThisIdent: 'dynamic' | 'fetch' = ident.name.endsWith(\n              '_fetch'\n            )\n              ? 'fetch'\n              : 'dynamic';\n\n            const rel = computeImport(\n              file,\n              dictionariesDir,\n              dynamicDictionariesDir,\n              fetchDictionariesDir,\n              key,\n              modeForThisIdent\n            );\n            imports.push(\n              t.importDeclaration(\n                [t.importDefaultSpecifier(t.identifier(ident.name))],\n                t.stringLiteral(rel)\n              )\n            );\n          }\n\n          if (!imports.length) return;\n\n          /* Keep \"use client\" / \"use server\" directives at the very top. */\n          const bodyPaths = programPath.get(\n            'body'\n          ) as NodePath<BabelTypes.Statement>[];\n          let insertPos = 0;\n          for (const stmtPath of bodyPaths) {\n            const stmt = stmtPath.node;\n\n            if (\n              t.isExpressionStatement(stmt) &&\n              t.isStringLiteral(stmt.expression) &&\n              !stmt.expression.value.startsWith('import') &&\n              !stmt.expression.value.startsWith('require')\n            ) {\n              insertPos += 1;\n            } else {\n              break;\n            }\n          }\n\n          programPath.node.body.splice(insertPos, 0, ...imports);\n        },\n      },\n    },\n  };\n};\n"],"mappings":"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"}
+{"version":3,"file":"babel-plugin-intlayer-optimize.cjs","names":["getNormalizedFilesListSet"],"sources":["../../src/babel-plugin-intlayer-optimize.ts"],"sourcesContent":["import { dirname, join, relative } from 'node:path';\nimport type { NodePath, PluginObject, PluginPass } from '@babel/core';\nimport type * as BabelTypes from '@babel/types';\nimport {\n  type CallerDescriptor,\n  getRewritableCallers,\n} from '@intlayer/config/callers';\nimport { normalizePath } from '@intlayer/config/utils';\nimport { getPathHash } from '@intlayer/engine/utils';\nimport { getNormalizedFilesListSet } from './normalizedFilesList';\n\nconst PACKAGE_LIST = [\n  'intlayer',\n  '@intlayer/core',\n  'react-intlayer',\n  'react-intlayer/client',\n  'react-intlayer/server',\n  'next-intlayer',\n  'next-intlayer/client',\n  'next-intlayer/server',\n  'svelte-intlayer',\n  'vue-intlayer',\n  'angular-intlayer',\n  'preact-intlayer',\n  'solid-intlayer',\n  'lit-intlayer',\n  'vanilla-intlayer',\n];\n\nconst CALLER_LIST = ['useIntlayer', 'getIntlayer'] as const;\n\n/**\n * Packages that support dynamic import\n */\nconst PACKAGE_LIST_DYNAMIC = [\n  'react-intlayer',\n  'react-intlayer/client',\n  'react-intlayer/server',\n  'next-intlayer',\n  'next-intlayer/client',\n  'next-intlayer/server',\n  'preact-intlayer',\n  'vue-intlayer',\n  'solid-intlayer',\n  'svelte-intlayer',\n  'angular-intlayer',\n  'lit-intlayer',\n  'vanilla-intlayer',\n] as const;\n\nconst STATIC_IMPORT_FUNCTION = {\n  getIntlayer: 'getDictionary',\n  useIntlayer: 'useDictionary',\n} as const;\n\nconst DYNAMIC_IMPORT_FUNCTION = {\n  useIntlayer: 'useDictionaryDynamic',\n} as const;\n\n/** Import rename table applied when the helper plan for a package is `dynamic`. */\nconst DYNAMIC_HELPER_MAP: Record<string, string> = {\n  ...STATIC_IMPORT_FUNCTION,\n  ...DYNAMIC_IMPORT_FUNCTION,\n};\n\n/**\n * Packages whose SSR-static `useDictionary` lives in a `/server` subpath\n * because it differs from the root one. Solid's reserves one hydration\n * resource slot so hydration ids stay aligned with the client's\n * `useDictionaryDynamic`; for other frameworks the root `useDictionary` is\n * already the correct SSR-static implementation.\n */\nconst SSR_STATIC_IMPORT_SOURCE: Partial<Record<string, string>> = {\n  'solid-intlayer': 'solid-intlayer/server',\n};\n\ntype CallerName = (typeof CALLER_LIST)[number];\ntype ImportMode = 'static' | 'dynamic' | 'fetch';\n\n/**\n * Options for the optimization Babel plugin\n */\nexport type OptimizePluginOptions = {\n  /**\n   * If false, the plugin will not apply any transformation.\n   */\n  optimize?: boolean;\n  /**\n   * The path to the dictionaries directory.\n   */\n  dictionariesDir: string;\n  /**\n   * The path to the dictionaries entry file.\n   */\n  dictionariesEntryPath: string;\n  /**\n   * The path to the unmerged dictionaries entry file.\n   */\n  unmergedDictionariesEntryPath: string;\n  /**\n   * The path to the unmerged dictionaries directory.\n   */\n  unmergedDictionariesDir: string;\n  /**\n   * The path to the dictionaries directory.\n   */\n  dynamicDictionariesDir: string;\n  /**\n   * The path to the dynamic dictionaries entry file.\n   */\n  dynamicDictionariesEntryPath: string;\n  /**\n   * The path to the fetch dictionaries directory.\n   */\n  fetchDictionariesDir: string;\n  /**\n   * The path to the fetch dictionaries entry file.\n   */\n  fetchDictionariesEntryPath: string;\n  /**\n   * If true, the plugin will replace the dictionary entry file with `export default {}`.\n   */\n  replaceDictionaryEntry: boolean;\n  /**\n   * If true, the plugin will activate the dynamic import of the dictionaries. It will rely on Suspense to load the dictionaries.\n   */\n  importMode: 'static' | 'dynamic' | 'fetch' | undefined;\n  /**\n   * Map of dictionary keys to their specific import mode.\n   */\n  dictionaryModeMap?: Record<\n    string,\n    'static' | 'dynamic' | 'fetch' | undefined\n  >;\n  /**\n   * Files list to traverse.\n   */\n  filesList: string[];\n  /**\n   * Whether the current transform is for an SSR bundle.\n   */\n  isServer?: boolean;\n  /**\n   * Compat-adapter caller descriptors injected by the compat packages'\n   * bundler plugins (e.g. `@intlayer/react-i18next/plugin`).\n   *\n   * Callers carrying `staticReplacement` / `dynamicReplacement` are rewritten\n   * the same way as native `useIntlayer` calls: the namespace string argument\n   * is replaced by a pre-imported dictionary object and the import specifier\n   * is re-pointed to the dictionary-accepting variant, e.g.\n   * `useTranslation('about')` → `useDictionary(_dictHash)`.\n   *\n   * No compat-specific name is hard-coded in this plugin — the whole rewrite\n   * is driven by these descriptors.\n   */\n  compatCallers?: CallerDescriptor[];\n};\n\ntype State = PluginPass & {\n  opts: OptimizePluginOptions;\n  /** map key → generated ident (per-file) for static imports */\n  _newStaticImports?: Map<string, BabelTypes.Identifier>;\n  /** map key → generated ident (per-file) for dynamic imports */\n  _newDynamicImports?: Map<string, BabelTypes.Identifier>;\n  /** whether the current file imported *any* intlayer package */\n  _hasValidImport?: boolean;\n  /** map from local identifier name to the imported intlayer func name ('useIntlayer' | 'getIntlayer') */\n  _callerMap?: Map<string, (typeof CALLER_LIST)[number]>;\n  /** map from local identifier name to the intlayer package it was imported from */\n  _callerPackageMap?: Map<string, string>;\n  /** map from local identifier name to the compat caller descriptor it was imported as */\n  _compatCallerMap?: Map<string, CallerDescriptor>;\n  /** whether the current file *is* the dictionaries entry file */\n  _isDictEntry?: boolean;\n  /** whether the current file is included in the filesList */\n  _isIncluded?: boolean;\n};\n\n/**\n * Replicates the xxHash64 → Base-62 algorithm used by the SWC version\n * and prefixes an underscore so the generated identifiers never collide\n * with user-defined ones.\n */\nconst makeIdent = (\n  key: string,\n  t: typeof BabelTypes\n): BabelTypes.Identifier => {\n  const hash = getPathHash(key);\n  return t.identifier(`_${hash}`);\n};\n\nconst computeImport = (\n  fromFile: string,\n  dictionariesDir: string,\n  dynamicDictionariesDir: string,\n  fetchDictionariesDir: string,\n  key: string,\n  importMode: 'static' | 'dynamic' | 'fetch'\n): string => {\n  let relativePath = join(dictionariesDir, `${key}.json`);\n\n  if (importMode === 'fetch') {\n    relativePath = join(fetchDictionariesDir, `${key}.mjs`);\n  }\n\n  if (importMode === 'dynamic') {\n    relativePath = join(dynamicDictionariesDir, `${key}.mjs`);\n  }\n\n  let rel = relative(dirname(fromFile), relativePath);\n\n  // Fix windows path\n  rel = normalizePath(rel);\n\n  // Fix relative path\n  if (!rel.startsWith('./') && !rel.startsWith('../')) {\n    rel = `./${rel}`;\n  }\n\n  return rel;\n};\n\nconst getKeyFromArgument = (\n  arg: BabelTypes.Node | null | undefined,\n  t: typeof BabelTypes\n): string | undefined => {\n  if (arg && t.isStringLiteral(arg)) {\n    return arg.value;\n  }\n\n  if (\n    arg &&\n    t.isTemplateLiteral(arg) &&\n    arg.expressions.length === 0 &&\n    arg.quasis.length === 1\n  ) {\n    return arg.quasis[0]?.value.cooked ?? arg.quasis[0]?.value.raw;\n  }\n\n  return undefined;\n};\n\nconst isCallerName = (name: string): name is CallerName =>\n  CALLER_LIST.includes(name as CallerName);\n\n/**\n * Splits a namespace string at the first `.` to separate the dictionary key\n * from an optional key prefix for nested namespaces, mirroring the SWC\n * plugin's `split_namespace`.\n *\n *   `'about'`         → `{ dictionaryKey: 'about', keyPrefix: '' }`\n *   `'about.counter'` → `{ dictionaryKey: 'about', keyPrefix: 'counter' }`\n */\nconst splitNamespace = (\n  namespace: string\n): { dictionaryKey: string; keyPrefix: string } => {\n  const dotPosition = namespace.indexOf('.');\n  if (dotPosition === -1) return { dictionaryKey: namespace, keyPrefix: '' };\n  return {\n    dictionaryKey: namespace.slice(0, dotPosition),\n    keyPrefix: namespace.slice(dotPosition + 1),\n  };\n};\n\n/**\n * Result of statically resolving the namespace of a compat caller call-site.\n */\ntype CompatNamespaceMatch = {\n  /** The full namespace string, e.g. `'about.counter'`. */\n  fullNamespace: string;\n  /** Index of the positional namespace argument, when read from an argument. */\n  argumentIndex?: number;\n  /**\n   * The options-object property holding the namespace, when read from an\n   * option. The rewrite mutates it in place (key-prefix remainder) or removes\n   * it from `optionsObject`.\n   */\n  optionProperty?: BabelTypes.ObjectProperty;\n  /** The options object owning `optionProperty`. */\n  optionsObject?: BabelTypes.ObjectExpression;\n};\n\n/**\n * Statically resolves the namespace of a compat caller call-site from its\n * descriptor's `namespaceSources` (argument / option / fixed — the\n * per-message-id `path-first-segment` form cannot bind one dictionary to the\n * call site and is skipped). Returns `undefined` when the namespace is absent\n * or dynamic, in which case the call is left untouched and resolves through\n * the runtime dictionary registry.\n */\nconst resolveCompatNamespaceMatch = (\n  t: typeof BabelTypes,\n  callArguments: BabelTypes.CallExpression['arguments'],\n  descriptor: CallerDescriptor\n): CompatNamespaceMatch | undefined => {\n  for (const source of descriptor.namespaceSources) {\n    if (source.from === 'fixed') {\n      return { fullNamespace: source.value };\n    }\n\n    if (source.from === 'argument') {\n      const namespace = getKeyFromArgument(callArguments[source.index], t);\n      if (namespace !== undefined) {\n        return { fullNamespace: namespace, argumentIndex: source.index };\n      }\n      continue;\n    }\n\n    if (source.from === 'option') {\n      const optionsArgument = callArguments[source.argumentIndex];\n      if (!optionsArgument || !t.isObjectExpression(optionsArgument)) continue;\n\n      for (const property of optionsArgument.properties) {\n        if (!t.isObjectProperty(property)) continue;\n        const keyMatches =\n          (t.isIdentifier(property.key) &&\n            property.key.name === source.property) ||\n          (t.isStringLiteral(property.key) &&\n            property.key.value === source.property);\n        if (!keyMatches) continue;\n\n        const namespace = getKeyFromArgument(property.value, t);\n        if (namespace !== undefined) {\n          return {\n            fullNamespace: namespace,\n            optionProperty: property,\n            optionsObject: optionsArgument,\n          };\n        }\n      }\n    }\n  }\n\n  return undefined;\n};\n\nconst isDynamicPackage = (\n  packageName: string\n): packageName is (typeof PACKAGE_LIST_DYNAMIC)[number] =>\n  PACKAGE_LIST_DYNAMIC.includes(\n    packageName as (typeof PACKAGE_LIST_DYNAMIC)[number]\n  );\n\n/**\n * Helper family every `useIntlayer`/`getIntlayer` call from one package import\n * resolves to in the current file. `ssrStatic` is the SSR bundle of a\n * dynamic-mode file: rewritten to the static `useDictionary` (from the\n * package's `/server` entry when it has one — see\n * `SSR_STATIC_IMPORT_SOURCE`) so the server renders static JSON while the\n * client keeps the dynamic loader.\n */\ntype PackageHelperPlan = 'static' | 'dynamic' | 'ssrStatic';\n\n/**\n * Decides, once per package import, which helper family applies to this file.\n * The import rewrite and the per-call rewrite must both derive from this\n * single decision, or the emitted helper and its argument shape diverge.\n *\n * Fetch wins over `ssrStatic`: fetch dictionaries are runtime content, so the\n * server must keep the real fetch path instead of rendering build-time JSON.\n */\nconst resolveHelperPlan = (\n  packageName: string,\n  importMode: ImportMode | undefined,\n  isServer: boolean | undefined,\n  packageHasDynamicCall: boolean,\n  packageHasFetchCall: boolean\n): PackageHelperPlan => {\n  if (!isDynamicPackage(packageName)) return 'static';\n\n  if (importMode === 'fetch' || packageHasFetchCall) return 'dynamic';\n\n  if (importMode === 'dynamic' || packageHasDynamicCall) {\n    return isServer === true ? 'ssrStatic' : 'dynamic';\n  }\n\n  return 'static';\n};\n\n/**\n * Babel plugin that transforms Intlayer function calls and auto-imports dictionaries.\n *\n * This plugin transforms calls to `useIntlayer()` and `getIntlayer()` from various Intlayer\n * packages into optimized dictionary access patterns, automatically importing the required\n * dictionary files based on the configured import mode.\n *\n * ## Supported Input Patterns\n *\n * The plugin recognizes these function calls:\n *\n * ```ts\n * // useIntlayer\n * import { useIntlayer } from 'react-intlayer';\n * import { useIntlayer } from 'next-intlayer';\n *\n * // getIntlayer\n * import { getIntlayer } from 'intlayer';\n *\n * // Usage\n * const content = useIntlayer('app');\n * const content = getIntlayer('app');\n * ```\n *\n * ## Transformation Modes\n *\n * ### Static Mode (default: `importMode = \"static\"`)\n *\n * Imports JSON dictionaries directly and replaces function calls with dictionary access:\n *\n * **Output:**\n * ```ts\n * import _dicHash from '../../.intlayer/dictionaries/app.json' with { type: 'json' };\n * import { useDictionary as useIntlayer } from 'react-intlayer';\n * import { getDictionary as getIntlayer } from 'intlayer';\n *\n * const content1 = useIntlayer(_dicHash);\n * const content2 = getIntlayer(_dicHash);\n * ```\n *\n * ### Dynamic Mode (`importMode = \"dynamic\"`)\n *\n * Uses dynamic dictionary loading with Suspense support:\n *\n * **Output:**\n * ```ts\n * import _dicHash from '../../.intlayer/dictionaries/app.json' with { type: 'json' };\n * import _dicHash_dyn from '../../.intlayer/dynamic_dictionaries/app.mjs';\n * import { useDictionaryDynamic as useIntlayer } from 'react-intlayer';\n * import { getDictionary as getIntlayer } from 'intlayer';\n *\n * const content1 = useIntlayer(_dicHash_dyn, 'app');\n * const content2 = getIntlayer(_dicHash);\n * ```\n *\n * ### Fetch Mode (`importMode = \"fetch\"`)\n *\n * Uses fetch-based dictionary loading for remote dictionaries:\n *\n * **Output if `dictionaryModeMap` includes the key with \"fetch\" value:**\n * ```ts\n * import _dicHash from '../../.intlayer/dictionaries/app.json' with { type: 'json' };\n * import _dicHash_fetch from '../../.intlayer/fetch_dictionaries/app.mjs';\n * import { useDictionaryDynamic as useIntlayer } from 'react-intlayer';\n * import { getDictionary as getIntlayer } from 'intlayer';\n *\n * const content1 = useIntlayer(_dicHash_fetch, \"app\");\n * const content2 = getIntlayer(_dicHash);\n * ```\n *\n * > If `dictionaryModeMap` does not include the key with \"fetch\" value, the plugin will fallback to the dynamic import mode.\n *\n * ```ts\n * import _dicHash from '../../.intlayer/dictionaries/app.json' with { type: 'json' };\n * import _dicHash_dyn from '../../.intlayer/dynamic_dictionaries/app.mjs';\n * import { useDictionaryDynamic as useIntlayer } from 'react-intlayer';\n * import { getDictionary as getIntlayer } from 'intlayer';\n *\n * const content1 = useIntlayer(_dicHash_dyn, 'app');\n * const content2 = getIntlayer(_dicHash);\n * ```\n */\nexport const intlayerOptimizeBabelPlugin = (babel: {\n  types: typeof BabelTypes;\n}): PluginObject<State> => {\n  const { types: t } = babel;\n\n  return {\n    name: 'babel-plugin-intlayer-transform',\n\n    pre() {\n      this._newStaticImports = new Map();\n      this._newDynamicImports = new Map();\n      this._callerMap = new Map();\n      this._callerPackageMap = new Map();\n      this._compatCallerMap = new Map();\n      this._isIncluded = true;\n      this._hasValidImport = false;\n      this._isDictEntry = false;\n\n      // If optimize is false, skip processing entirely\n      if (this.opts.optimize === false) {\n        this._isIncluded = false;\n        return;\n      }\n\n      // If filesList is provided, check if current file is included\n      const filename = this.file.opts.filename\n        ? normalizePath(this.file.opts.filename)\n        : undefined;\n      if (this.opts.filesList && filename) {\n        const isIncluded = getNormalizedFilesListSet(this.opts.filesList).has(\n          filename\n        );\n\n        if (!isIncluded) {\n          // Force _isIncluded to false to skip processing\n          this._isIncluded = false;\n          return;\n        }\n      }\n    },\n\n    visitor: {\n      /* If this file *is* the dictionaries entry, short-circuit: export {} */\n      Program: {\n        enter(programPath, state) {\n          // Safe access to filename\n          const filename = state.file.opts.filename\n            ? normalizePath(state.file.opts.filename)\n            : undefined;\n          const dictionariesEntryPath = state.opts.dictionariesEntryPath\n            ? normalizePath(state.opts.dictionariesEntryPath)\n            : undefined;\n\n          // Check if this is the correct file to transform\n\n          if (\n            state.opts.replaceDictionaryEntry &&\n            filename === dictionariesEntryPath\n          ) {\n            state._isDictEntry = true;\n\n            // Traverse the program to surgically remove/edit specific parts\n            programPath.traverse({\n              // Remove all import statements (cleaning up 'sssss.json')\n              ImportDeclaration(path) {\n                path.remove();\n              },\n\n              // Find the variable definition and empty the object\n              VariableDeclarator(path) {\n                // We look for: const x = { ... }\n\n                if (t.isObjectExpression(path.node.init)) {\n                  // Set the object properties to an empty array: {}\n                  path.node.init.properties = [];\n                }\n              },\n            });\n\n            // (Optional) Stop other plugins from processing this file further if needed\n            // programPath.stop();\n          }\n        },\n\n        /**\n         * After full traversal, process imports and call expressions, then inject the JSON dictionary imports.\n         *\n         * We do the transformation in Program.exit (via a manual traverse) rather than using\n         * top-level ImportDeclaration/CallExpression visitors. This ensures that if another plugin\n         * (like babel-plugin-intlayer-extract) adds new useIntlayer calls in its Program.exit,\n         * we will see and transform them here because our Program.exit runs after theirs.\n         */\n        exit(programPath, state) {\n          if (state._isDictEntry) return; // nothing else to do – already replaced\n\n          if (!state._isIncluded) return; // early-out if file is not included\n\n          // Compat callers the optimize pass can rewrite (injected by the\n          // compat packages' bundler plugins — nothing is hard-coded here).\n          const rewritableCompatCallers = getRewritableCallers(\n            state.opts.compatCallers ?? []\n          );\n\n          // Manual traversal to process imports and call expressions\n          // This runs AFTER all other plugins' visitors have completed\n          programPath.traverse({\n            /* Inspect every intlayer import before deciding helper rewrites. */\n            ImportDeclaration(path) {\n              const src = path.node.source.value;\n\n              const isNativePackage = PACKAGE_LIST.includes(src);\n              const compatCallersForSource = rewritableCompatCallers.filter(\n                (descriptor) => descriptor.importSources.includes(src)\n              );\n\n              if (!isNativePackage && compatCallersForSource.length === 0) {\n                return;\n              }\n\n              state._hasValidImport = true;\n\n              for (const spec of path.node.specifiers) {\n                if (!t.isImportSpecifier(spec)) continue;\n\n                const importedName = t.isIdentifier(spec.imported)\n                  ? spec.imported.name\n                  : (spec.imported as BabelTypes.StringLiteral).value;\n\n                if (isNativePackage && isCallerName(importedName)) {\n                  state._callerMap?.set(spec.local.name, importedName);\n                  state._callerPackageMap?.set(spec.local.name, src);\n                }\n\n                const compatDescriptor = compatCallersForSource.find(\n                  (descriptor) => descriptor.callerName === importedName\n                );\n                if (compatDescriptor) {\n                  state._compatCallerMap?.set(\n                    spec.local.name,\n                    compatDescriptor\n                  );\n                }\n              }\n            },\n          });\n\n          // Pre-pass to determine if dictionary-level overrides require the\n          // dynamic helper in an otherwise static file, and to disable the\n          // rewrite for compat callers with unresolvable call sites.\n          const packagesWithDynamicCall = new Set<string>();\n          const packagesWithFetchCall = new Set<string>();\n          let compatHasDynamicCall = false;\n          const unresolvableCompatLocalNames = new Set<string>();\n          programPath.traverse({\n            CallExpression(path) {\n              const callee = path.node.callee;\n\n              if (!t.isIdentifier(callee)) return;\n\n              const compatDescriptor = state._compatCallerMap?.get(callee.name);\n              if (compatDescriptor) {\n                const namespaceMatch = resolveCompatNamespaceMatch(\n                  t,\n                  path.node.arguments,\n                  compatDescriptor\n                );\n\n                if (!namespaceMatch) {\n                  // Dynamic/absent namespace: the whole local caller must keep\n                  // its original implementation — rewriting the import while\n                  // leaving this call untouched would hand a raw namespace\n                  // string to the dictionary-accepting helper.\n                  unresolvableCompatLocalNames.add(callee.name);\n                  return;\n                }\n\n                const { dictionaryKey } = splitNamespace(\n                  namespaceMatch.fullNamespace\n                );\n                const compatOverrideMode =\n                  state.opts.dictionaryModeMap?.[dictionaryKey];\n                if (\n                  compatOverrideMode === 'dynamic' ||\n                  compatOverrideMode === 'fetch'\n                ) {\n                  compatHasDynamicCall = true;\n                }\n                return;\n              }\n\n              const originalImportedName = state._callerMap?.get(callee.name);\n              if (originalImportedName !== 'useIntlayer') return;\n\n              const callerPackage = state._callerPackageMap?.get(callee.name);\n              if (!callerPackage) return;\n\n              const key = getKeyFromArgument(path.node.arguments[0], t);\n              if (!key) return;\n\n              const dictionaryOverrideMode =\n                state.opts.dictionaryModeMap?.[key];\n\n              if (dictionaryOverrideMode === 'dynamic') {\n                packagesWithDynamicCall.add(callerPackage);\n              } else if (dictionaryOverrideMode === 'fetch') {\n                packagesWithFetchCall.add(callerPackage);\n              }\n            },\n          });\n\n          for (const localName of unresolvableCompatLocalNames) {\n            state._compatCallerMap?.delete(localName);\n          }\n\n          const getHelperPlan = (packageName: string): PackageHelperPlan =>\n            resolveHelperPlan(\n              packageName,\n              state.opts.importMode,\n              state.opts.isServer,\n              packagesWithDynamicCall.has(packageName),\n              packagesWithFetchCall.has(packageName)\n            );\n\n          // Compat helpers are swapped per file (one import specifier serves\n          // every call), so the dynamic decision is file-level: a global\n          // dynamic/fetch mode or any per-dictionary override flips all\n          // rewritten compat calls to the dynamic helper.\n          const compatUseDynamicHelpers =\n            state.opts.importMode === 'dynamic' ||\n            state.opts.importMode === 'fetch' ||\n            compatHasDynamicCall;\n\n          programPath.traverse({\n            ImportDeclaration(path) {\n              const src = path.node.source.value;\n\n              // Compat caller import rename: point the specifier at the\n              // dictionary-accepting helper exported by the compat package\n              // (`useTranslation` → `useDictionary`), keeping the local alias\n              // so call sites read unchanged. Locals with unresolvable call\n              // sites were dropped from the map and keep the original import.\n              for (const spec of path.node.specifiers) {\n                if (!t.isImportSpecifier(spec)) continue;\n\n                const compatDescriptor = state._compatCallerMap?.get(\n                  spec.local.name\n                );\n                if (!compatDescriptor) continue;\n                if (!compatDescriptor.importSources.includes(src)) continue;\n\n                spec.imported = t.identifier(\n                  compatUseDynamicHelpers\n                    ? compatDescriptor.dynamicReplacement!\n                    : compatDescriptor.staticReplacement!\n                );\n              }\n\n              if (!PACKAGE_LIST.includes(src)) return;\n\n              // Per-import swap, mirrored across bundles — Solid hydration\n              // ids rely on the SSR and client helpers consuming one\n              // resource slot per call alike (see solid-intlayer/server).\n              const helperPlan = getHelperPlan(src);\n              const serverSource =\n                helperPlan === 'ssrStatic'\n                  ? SSR_STATIC_IMPORT_SOURCE[src]\n                  : undefined;\n\n              const helperMap: Record<string, string> =\n                helperPlan === 'dynamic'\n                  ? DYNAMIC_HELPER_MAP\n                  : STATIC_IMPORT_FUNCTION;\n\n              const serverSpecifiers: BabelTypes.ImportSpecifier[] = [];\n\n              for (const spec of path.node.specifiers) {\n                if (!t.isImportSpecifier(spec)) continue;\n\n                const importedName = t.isIdentifier(spec.imported)\n                  ? spec.imported.name\n                  : (spec.imported as BabelTypes.StringLiteral).value;\n\n                if (!isCallerName(importedName)) continue;\n\n                if (serverSource && importedName === 'useIntlayer') {\n                  spec.imported = t.identifier('useDictionary');\n                  serverSpecifiers.push(spec);\n                  continue;\n                }\n\n                const newIdentifier = helperMap[importedName];\n\n                if (newIdentifier) {\n                  // Keep the local alias intact (so calls remain `useIntlayer` /\n                  // `getIntlayer`), but rewrite the imported identifier so it\n                  // points to our helper implementation.\n                  spec.imported = t.identifier(newIdentifier);\n                }\n              }\n\n              if (serverSpecifiers.length > 0 && serverSource) {\n                // Move the helper to the /server entry, keeping any other\n                // specifiers (useLocale, …) on the original import.\n                path.insertAfter(\n                  t.importDeclaration(\n                    serverSpecifiers,\n                    t.stringLiteral(serverSource)\n                  )\n                );\n                path.node.specifiers = path.node.specifiers.filter(\n                  (spec) =>\n                    !serverSpecifiers.includes(\n                      spec as BabelTypes.ImportSpecifier\n                    )\n                );\n                if (path.node.specifiers.length === 0) {\n                  path.remove();\n                }\n              }\n            },\n\n            /* Replace calls: useIntlayer(\"foo\") → useDictionary(_hash) or useDictionaryDynamic(_hash, \"foo\") */\n            CallExpression(path) {\n              const callee = path.node.callee;\n\n              if (!t.isIdentifier(callee)) return;\n\n              // Compat caller rewrite, e.g. (mirroring the SWC plugin):\n              //   static:  useTranslation('about.counter', opts)\n              //            → useDictionary(_hash, 'counter', opts)\n              //   dynamic: useTranslation('about.counter', opts)\n              //            → useDictionaryDynamic(_hash_dyn, 'about', 'counter', opts)\n              //   option:  useI18n({ namespace: 'about' })\n              //            → useDictionary(_hash, {})\n              //   fixed:   useLingui() → useDictionary(_hash)\n              const compatDescriptor = state._compatCallerMap?.get(callee.name);\n              if (compatDescriptor) {\n                const callArguments = path.node.arguments;\n                const namespaceMatch = resolveCompatNamespaceMatch(\n                  t,\n                  callArguments,\n                  compatDescriptor\n                );\n                if (!namespaceMatch) return; // filtered by the pre-pass — stay safe\n\n                state._hasValidImport = true;\n\n                const { dictionaryKey, keyPrefix } = splitNamespace(\n                  namespaceMatch.fullNamespace\n                );\n                const compatOverrideMode =\n                  state.opts.dictionaryModeMap?.[dictionaryKey];\n\n                // The import specifier serves every call in the file, so a\n                // dynamic file receives a dynamic loader for every call.\n                let compatCallMode: ImportMode = 'static';\n                if (compatUseDynamicHelpers) {\n                  if (\n                    compatOverrideMode === 'dynamic' ||\n                    compatOverrideMode === 'fetch'\n                  ) {\n                    compatCallMode = compatOverrideMode;\n                  } else if (\n                    state.opts.importMode === 'dynamic' ||\n                    state.opts.importMode === 'fetch'\n                  ) {\n                    compatCallMode = state.opts.importMode;\n                  } else {\n                    compatCallMode = 'dynamic';\n                  }\n                }\n\n                let dictionaryIdent: BabelTypes.Identifier;\n                if (compatCallMode === 'static') {\n                  let staticIdent = state._newStaticImports?.get(dictionaryKey);\n                  if (!staticIdent) {\n                    staticIdent = makeIdent(dictionaryKey, t);\n                    state._newStaticImports?.set(dictionaryKey, staticIdent);\n                  }\n                  dictionaryIdent = staticIdent;\n                } else {\n                  let dynamicIdent =\n                    state._newDynamicImports?.get(dictionaryKey);\n                  if (!dynamicIdent) {\n                    const hash = getPathHash(dictionaryKey);\n                    const suffix = compatCallMode === 'fetch' ? 'fetch' : 'dyn';\n                    dynamicIdent = t.identifier(`_${hash}_${suffix}`);\n                    state._newDynamicImports?.set(dictionaryKey, dynamicIdent);\n                  }\n                  dictionaryIdent = dynamicIdent;\n                }\n\n                if (namespaceMatch.argumentIndex !== undefined) {\n                  // Positional namespace: replace the string with the\n                  // dictionary, then (dynamic) key and (nested) prefix.\n                  callArguments[namespaceMatch.argumentIndex] = t.identifier(\n                    dictionaryIdent.name\n                  );\n                  const insertAt = namespaceMatch.argumentIndex + 1;\n                  const insertedArguments: BabelTypes.Expression[] = [];\n                  if (compatCallMode !== 'static') {\n                    insertedArguments.push(t.stringLiteral(dictionaryKey));\n                  }\n                  if (keyPrefix) {\n                    insertedArguments.push(t.stringLiteral(keyPrefix));\n                  }\n                  callArguments.splice(insertAt, 0, ...insertedArguments);\n                } else if (compatCallMode !== 'static') {\n                  // Fixed / option namespace, dynamic helper: prepend the\n                  // loader and the dictionary key.\n                  callArguments.unshift(\n                    t.identifier(dictionaryIdent.name),\n                    t.stringLiteral(dictionaryKey)\n                  );\n                } else {\n                  // Fixed / option namespace, static helper: prepend the\n                  // dictionary object.\n                  callArguments.unshift(t.identifier(dictionaryIdent.name));\n                }\n\n                // Option namespace: leave only the key-prefix remainder in the\n                // options object (or drop the property for a plain namespace),\n                // so the runtime helper does not re-apply the dictionary key\n                // as a lookup prefix.\n                if (\n                  namespaceMatch.optionProperty &&\n                  namespaceMatch.optionsObject\n                ) {\n                  if (keyPrefix) {\n                    namespaceMatch.optionProperty.value =\n                      t.stringLiteral(keyPrefix);\n                  } else {\n                    namespaceMatch.optionsObject.properties =\n                      namespaceMatch.optionsObject.properties.filter(\n                        (property) => property !== namespaceMatch.optionProperty\n                      );\n                  }\n                }\n\n                return;\n              }\n\n              const originalImportedName = state._callerMap?.get(callee.name);\n              if (!originalImportedName) return;\n\n              // Ensure we ultimately emit helper imports for files that *invoke*\n              // the hooks, even if they didn't import them directly (edge cases with\n              // re-exports).\n              state._hasValidImport = true;\n\n              const key = getKeyFromArgument(path.node.arguments[0], t);\n              if (!key) return;\n\n              const callerPackage = state._callerPackageMap?.get(callee.name);\n              const importMode = state.opts.importMode;\n              const isUseIntlayer = originalImportedName === 'useIntlayer';\n              const dictionaryOverrideMode =\n                state.opts.dictionaryModeMap?.[key];\n              const helperPlan =\n                callerPackage === undefined\n                  ? 'static'\n                  : getHelperPlan(callerPackage);\n\n              // Decide per-call mode: 'static' | 'dynamic' | 'fetch'.\n              let perCallMode: ImportMode = 'static';\n\n              if (isUseIntlayer && helperPlan === 'dynamic') {\n                if (dictionaryOverrideMode) {\n                  perCallMode = dictionaryOverrideMode;\n                } else if (importMode === 'dynamic' || importMode === 'fetch') {\n                  perCallMode = importMode;\n                }\n              } else if (isUseIntlayer && helperPlan === 'static') {\n                // The global mode is static, but a per-dictionary override can\n                // still force dynamic/fetch for this specific call.\n                if (\n                  dictionaryOverrideMode === 'dynamic' ||\n                  dictionaryOverrideMode === 'fetch'\n                ) {\n                  perCallMode = dictionaryOverrideMode;\n                }\n              }\n\n              let ident: BabelTypes.Identifier;\n\n              if (perCallMode === 'fetch') {\n                // Use fetch dictionaries entry for selected keys\n                let dynamicIdent = state._newDynamicImports?.get(key);\n\n                if (!dynamicIdent) {\n                  const hash = getPathHash(key);\n                  dynamicIdent = t.identifier(`_${hash}_fetch`);\n                  state._newDynamicImports?.set(key, dynamicIdent);\n                }\n                ident = dynamicIdent;\n\n                // Helper: first argument is the dictionary entry, second is the key\n                path.node.arguments = [\n                  t.identifier(ident.name),\n                  ...path.node.arguments,\n                ];\n              } else if (perCallMode === 'dynamic') {\n                // Use dynamic dictionaries entry\n                let dynamicIdent = state._newDynamicImports?.get(key);\n\n                if (!dynamicIdent) {\n                  // Create a unique identifier for dynamic imports by appending a suffix\n                  const hash = getPathHash(key);\n                  dynamicIdent = t.identifier(`_${hash}_dyn`);\n                  state._newDynamicImports?.set(key, dynamicIdent);\n                }\n                ident = dynamicIdent;\n\n                // Dynamic helper: first argument is the dictionary, second is the key.\n                path.node.arguments = [\n                  t.identifier(ident.name),\n                  ...path.node.arguments,\n                ];\n              } else {\n                // Use static imports for getIntlayer or useIntlayer when not using dynamic helpers\n                let staticIdent = state._newStaticImports?.get(key);\n\n                if (!staticIdent) {\n                  staticIdent = makeIdent(key, t);\n                  state._newStaticImports?.set(key, staticIdent);\n                }\n                ident = staticIdent;\n\n                // Static helper (useDictionary / getDictionary): replace key with ident.\n                // After the splice above the key is always at index 0.\n                path.node.arguments[0] = t.identifier(ident.name);\n              }\n            },\n          });\n\n          // Early-out if we touched nothing\n\n          if (!state._hasValidImport) return;\n\n          const file = state.file.opts.filename!;\n          const dictionariesDir = state.opts.dictionariesDir;\n          const dynamicDictionariesDir = state.opts.dynamicDictionariesDir;\n          const fetchDictionariesDir = state.opts.fetchDictionariesDir;\n          const imports: BabelTypes.ImportDeclaration[] = [];\n\n          // Generate static JSON imports (getIntlayer always uses JSON dictionaries)\n          for (const [key, ident] of state._newStaticImports!) {\n            const rel = computeImport(\n              file,\n              dictionariesDir,\n              dynamicDictionariesDir,\n              fetchDictionariesDir,\n              key,\n              'static'\n            );\n\n            const importDeclarationNode = t.importDeclaration(\n              [t.importDefaultSpecifier(t.identifier(ident.name))],\n              t.stringLiteral(rel)\n            );\n\n            // Add 'type: json' attribute for JSON files\n            importDeclarationNode.attributes = [\n              t.importAttribute(t.identifier('type'), t.stringLiteral('json')),\n            ];\n\n            imports.push(importDeclarationNode);\n          }\n\n          // Generate dynamic/fetch imports (for useIntlayer when using dynamic/fetch helpers)\n          for (const [key, ident] of state._newDynamicImports!) {\n            const modeForThisIdent: 'dynamic' | 'fetch' = ident.name.endsWith(\n              '_fetch'\n            )\n              ? 'fetch'\n              : 'dynamic';\n\n            const rel = computeImport(\n              file,\n              dictionariesDir,\n              dynamicDictionariesDir,\n              fetchDictionariesDir,\n              key,\n              modeForThisIdent\n            );\n            imports.push(\n              t.importDeclaration(\n                [t.importDefaultSpecifier(t.identifier(ident.name))],\n                t.stringLiteral(rel)\n              )\n            );\n          }\n\n          if (!imports.length) return;\n\n          /* Keep \"use client\" / \"use server\" directives at the very top. */\n          const bodyPaths = programPath.get(\n            'body'\n          ) as NodePath<BabelTypes.Statement>[];\n          let insertPos = 0;\n          for (const stmtPath of bodyPaths) {\n            const stmt = stmtPath.node;\n\n            if (\n              t.isExpressionStatement(stmt) &&\n              t.isStringLiteral(stmt.expression) &&\n              !stmt.expression.value.startsWith('import') &&\n              !stmt.expression.value.startsWith('require')\n            ) {\n              insertPos += 1;\n            } else {\n              break;\n            }\n          }\n\n          programPath.node.body.splice(insertPos, 0, ...imports);\n        },\n      },\n    },\n  };\n};\n"],"mappings":"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"}