vite-intlayer 9.4.3 → 9.4.4

package/dist/esm/index.mjs

@@ -5,6 +5,6 @@ import { createDictionaryModuleParser, intlayerChunk, resolveBoundaries, toBound
 import { intlayerOptimize } from "./intlayerOptimizePlugin.mjs";
 import { intlayerPreload } from "./intlayerPreloadPlugin.mjs";
 import { createIntlayerProxyHandler, intLayerMiddlewarePlugin, intlayerMiddleware, intlayerProxy } from "./intlayerProxyPlugin.mjs";
-import { intLayerPlugin, intlayer, intlayerPlugin } from "./intlayerPlugin.mjs";
+import { INTLAYER_NO_EXTERNAL_PATTERN, intLayerPlugin, intlayer, intlayerPlugin } from "./intlayerPlugin.mjs";
 
-export { createDictionaryModuleParser, createIntlayerProxyHandler, intLayerMiddlewarePlugin, intLayerPlugin, intlayer, intlayerChunk, intlayerCompiler, intlayerMiddleware, intlayerMinify, intlayerOptimize, intlayerPlugin, intlayerPreload, intlayerProxy, intlayerPrune, resolveBoundaries, toBoundaryName };
+export { INTLAYER_NO_EXTERNAL_PATTERN, createDictionaryModuleParser, createIntlayerProxyHandler, intLayerMiddlewarePlugin, intLayerPlugin, intlayer, intlayerChunk, intlayerCompiler, intlayerMiddleware, intlayerMinify, intlayerOptimize, intlayerPlugin, intlayerPreload, intlayerProxy, intlayerPrune, resolveBoundaries, toBoundaryName };

package/dist/esm/intlayerPlugin.mjs

@@ -18,6 +18,17 @@ import { logConfigDetails } from "@intlayer/engine/logConfigDetails";
 
 //#region src/intlayerPlugin.ts
 /**
+* Packages that must go through Vite's transform pipeline instead of being
+* loaded natively by Node.
+*
+* `intlayer` and every `@intlayer/*` package resolve `@intlayer/dictionaries-entry`
+* through a Vite alias pointing at the generated `.intlayer` entry. A package
+* loaded natively by Node never sees that alias: it resolves the published stub
+* instead, whose CJS `require` of the generated dictionaries is cached for the
+* lifetime of the process — so content edits stop reaching the running server.
+*/
+const INTLAYER_NO_EXTERNAL_PATTERN = /(^@intlayer\/|intlayer$)/;
+/**
 * Vite plugin that integrates Intlayer into the Vite build process.
 *
 * It handles:
@@ -92,7 +103,7 @@ const intlayerPlugin = (configOptions) => {
 				define,
 				resolve: { alias },
 				optimizeDeps: { exclude: aliasPackages },
-				ssr: { noExternal: [/(^@intlayer\/|intlayer$)/] }
+				ssr: { noExternal: [INTLAYER_NO_EXTERNAL_PATTERN] }
 			};
 		},
 		configureServer: async (server) => {
@@ -141,5 +152,5 @@ const intlayer = intlayerPlugin;
 const intLayerPlugin = intlayerPlugin;
 
 //#endregion
-export { intLayerPlugin, intlayer, intlayerPlugin };
+export { INTLAYER_NO_EXTERNAL_PATTERN, intLayerPlugin, intlayer, intlayerPlugin };
 //# sourceMappingURL=intlayerPlugin.mjs.map

package/dist/esm/intlayerPlugin.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"intlayerPlugin.mjs","names":[],"sources":["../../src/intlayerPlugin.ts"],"sourcesContent":["import { resolve } from 'node:path';\nimport { type CompatCallerConfig, createPruneContext } from '@intlayer/babel';\nimport { BLUE } from '@intlayer/config/colors';\nimport {\n  formatDictionarySelectorEnvVar,\n  formatNodeTypeToEnvVar,\n  formatOptimizedNestingEnvVar,\n  getConfigEnvVars,\n} from '@intlayer/config/envVars';\nimport { colorize, getAppLogger } from '@intlayer/config/logger';\nimport {\n  type GetConfigurationOptions,\n  getConfiguration,\n} from '@intlayer/config/node';\nimport {\n  getAlias,\n  getHasDictionarySelector,\n  getUnusedNodeTypesAsync,\n} from '@intlayer/config/utils';\nimport { resolveProxyMode } from '@intlayer/core/localization';\nimport { getDictionaries } from '@intlayer/dictionaries-entry';\nimport { logConfigDetails } from '@intlayer/engine/logConfigDetails';\nimport type { PluginOption } from 'vite';\nimport { intlayerCompiler } from './IntlayerCompilerPlugin';\nimport { intlayerChunk } from './intlayerChunkPlugin';\nimport { intlayerMinify } from './intlayerMinifyPlugin';\nimport { intlayerOptimize } from './intlayerOptimizePlugin';\nimport { intlayerPreload } from './intlayerPreloadPlugin';\nimport {\n  type IntlayerProxyPluginOptions,\n  intlayerProxy,\n} from './intlayerProxyPlugin';\nimport { intlayerPrune } from './intlayerPrunePlugin';\n\n/**\n * Extended options accepted by the intlayer Vite plugin.\n *\n * Extends {@link GetConfigurationOptions} with compat-adapter caller\n * configurations.  Compat adapter packages (e.g. `@intlayer/react-i18next/plugin`,\n * `@intlayer/vue-i18n/plugin`) inject their own caller configs here so the\n * field-usage analyser can recognise their translation function call patterns\n * and prune unused dictionary fields accordingly.\n */\nexport type IntlayerPluginOptions = GetConfigurationOptions & {\n  /**\n   * Compat-adapter namespace caller configurations to pass to the\n   * field-usage analyser (Vite `buildStart` phase).\n   *\n   * Defined by each compat adapter package; the core `vite-intlayer` package\n   * ships with an empty default to stay framework-agnostic.\n   */\n  compatCallers?: CompatCallerConfig[];\n\n  /**\n   * Options forwarded to the bundled locale-routing proxy (`intlayerProxy`).\n   *\n   * Since Intlayer v9 the proxy is plugged directly into the main `intlayer()`\n   * plugin (controlled by `routing.enableProxy`, unset by default, which\n   * selects auto mode). These routing options let you tune that bundled proxy\n   * without registering it separately — e.g. ignore API routes from locale\n   * routing.\n   *\n   * @example\n   * ```ts\n   * intlayer({ proxy: { ignore: (req) => req.url?.startsWith('/api') } })\n   * ```\n   */\n  proxy?: Pick<IntlayerProxyPluginOptions, 'ignore'>;\n};\n\n/**\n * Vite plugin that integrates Intlayer into the Vite build process.\n *\n * It handles:\n * 1. Preparing Intlayer resources (dictionaries) before build.\n * 2. Configuring Vite aliases for dictionary access.\n * 3. Setting up dev-server watchers for content changes.\n * 4. Applying build optimizations (tree-shaking dictionaries).\n *\n * @param configOptions - Optional configuration to override default Intlayer settings.\n * @returns A Vite plugin option.\n *\n * @example\n * ```ts\n * import { intlayer } from 'vite-intlayer';\n *\n * export default defineConfig({\n *   plugins: [intlayer()],\n * });\n *\n * ```\n * @deprecated Rename to intlayer instead\n */\nexport const intlayerPlugin = (\n  configOptions?: IntlayerPluginOptions\n): PluginOption => {\n  const { compatCallers, proxy, ...getConfigOptions } = configOptions ?? {};\n  const intlayerConfig = getConfiguration(getConfigOptions);\n  logConfigDetails(getConfigOptions);\n  const appLogger = getAppLogger(intlayerConfig);\n\n  const alias = getAlias({\n    configuration: intlayerConfig,\n    formatter: (value: string) => resolve(value),\n  });\n\n  const aliasPackages = Object.keys(alias);\n\n  const plugins: PluginOption[] = [\n    {\n      name: 'vite-intlayer-plugin',\n\n      apply: (_config, env) => {\n        // Don't apply intlayer plugin during `preview` command\n        const isPreviewCommand =\n          env.command === 'serve' && env.mode === 'production';\n\n        // But if liveSync is enabled, ensure the data are fresh\n        const isLiveSyncEnabled = intlayerConfig.editor.liveSync;\n\n        return !isPreviewCommand || isLiveSyncEnabled;\n      },\n\n      config: async (_config, env) => {\n        const { mode } = intlayerConfig.build;\n\n        const isDevCommand =\n          env.command === 'serve' && env.mode === 'development';\n        const isBuildCommand = env.command === 'build';\n\n        // Only call prepareIntlayer during `dev` or `build` (not during `preview`)\n        // If prod: clean and rebuild once\n        // If dev: rebuild only once if it's more than 1 hour since last rebuild\n        if (isDevCommand || isBuildCommand || mode === 'auto') {\n          // Lazily load the heavy build pipeline (`@intlayer/engine/build`) only\n          // when a rebuild is actually required, keeping the Vite config phase\n          // lightweight (e.g. during `preview`).\n          const { prepareIntlayer } = await import('@intlayer/engine/build');\n\n          // prepareIntlayer use runOnce to ensure to run only once because will run twice on client and server side otherwise\n          await prepareIntlayer(intlayerConfig, {\n            clean: isBuildCommand,\n            cacheTimeoutMs: isBuildCommand\n              ? 1000 * 30 // 30 seconds for build (to ensure to rebuild all dictionaries)\n              : 1000 * 60 * 60, // 1 hour for dev (default cache timeout)\n            env: isBuildCommand ? 'prod' : 'dev',\n          });\n        }\n\n        let define: Record<string, string> = {\n          // Preset an env var to avoid 'process is not defined' error\n          // Needed for some libraries that does not add process.env\n          'process.env.INTLAYER': '\"true\"',\n        };\n\n        if (isBuildCommand) {\n          const dictionaries = getDictionaries(intlayerConfig);\n\n          // Mirrors the optimize plugin's own `apply` condition: the local\n          // `nest()` resolver may only be selected when that transform runs,\n          // since it is the transform that injects the nest attachment.\n          const isOptimizeEnabled = intlayerConfig.build.optimize !== false;\n\n          if (Object.keys(dictionaries).length === 0) {\n            appLogger(\n              'No dictionaries found. Please check your configuration.',\n              {\n                isVerbose: true,\n              }\n            );\n          }\n\n          const unusedNodeTypes = await getUnusedNodeTypesAsync(dictionaries);\n\n          if (unusedNodeTypes.length > 0) {\n            appLogger(\n              [\n                'Filtering out unused logic:',\n                unusedNodeTypes\n                  .filter(\n                    (key) =>\n                      !['reactNode', 'solidNode', 'preactNode'].includes(key)\n                  )\n                  .map((key) => colorize(key, BLUE))\n                  .join(', '),\n              ],\n              {\n                isVerbose: true,\n              }\n            );\n          }\n\n          define = {\n            ...define,\n\n            // Tree shacking env var based on config\n            ...formatNodeTypeToEnvVar(\n              unusedNodeTypes,\n              (key) => `process.env.${key}`,\n              (value) => `\"${value}\"`\n            ),\n\n            // Selects the local `nest()` resolver, which reads the nest\n            // targets attached to each dictionary by the optimize transform\n            // instead of the registry that transform empties.\n            ...formatOptimizedNestingEnvVar(\n              isOptimizeEnabled,\n              (key) => `process.env.${key}`,\n              (value) => `\"${value}\"`\n            ),\n\n            // Tree shacking env var for the dictionary selector logic\n            // (collections / variants)\n            ...formatDictionarySelectorEnvVar(\n              getHasDictionarySelector(dictionaries),\n              (key) => `process.env.${key}`,\n              (value) => `\"${value}\"`\n            ),\n\n            // Tree shacking env var based on config\n            ...getConfigEnvVars(\n              intlayerConfig,\n              (key) => `process.env.${key}`,\n              (value) => `\"${value}\"` // Wrap by \"\" to ensure env var set properly\n            ),\n          };\n        }\n\n        // mergeConfig handles both array and record alias formats,\n        // and correctly appends to optimizeDeps.exclude / ssr.noExternal\n        return {\n          define,\n          resolve: {\n            alias,\n          },\n          optimizeDeps: {\n            // Exclude alias entry points since they're local files, not npm packages\n            exclude: aliasPackages,\n          },\n          ssr: {\n            // Ensure intlayer packages are bundled so aliases are applied\n            noExternal: [/(^@intlayer\\/|intlayer$)/],\n          },\n        };\n      },\n\n      configureServer: async (server) => {\n        if (server.config.mode === 'development') {\n          // Lazily load the file watcher (`@intlayer/engine/watcher`, which pulls\n          // in `@parcel/watcher`) only when the dev server actually starts.\n          const { watch } = await import('@intlayer/engine/watcher');\n\n          // Start watching (assuming watch is also async)\n          await watch({ configuration: intlayerConfig });\n        }\n      },\n    },\n  ];\n\n  // Shared mutable state: the optimize plugin writes field-usage data during\n  // buildStart; the prune and minify plugins read it during transform.\n  const pruneContext = createPruneContext();\n\n  // Babel transform: rewrites useIntlayer/getIntlayer calls and injects\n  // JSON / dynamic-mjs imports.  Also runs the usage analyser in buildStart.\n  plugins.push(intlayerOptimize(intlayerConfig, pruneContext, compatCallers));\n\n  // Prune: removes unused content fields from dictionary JSON files.\n  // Runs with enforce:'pre' so it intercepts raw JSON before Vite's\n  // built-in JSON → ESM conversion.\n  plugins.push(intlayerPrune(intlayerConfig, pruneContext));\n\n  // Minify: compacts dictionary JSON files (parse + re-stringify).\n  // Registered after prune so it receives already-pruned output when both options are active.\n  plugins.push(intlayerMinify(intlayerConfig, pruneContext));\n\n  // Chunk: regroups the per-dictionary chunks that `importMode: 'dynamic'`\n  // emits, so each code-split boundary loads its content in one request.\n  plugins.push(intlayerChunk(intlayerConfig));\n\n  // Preload: makes each dynamic entry point await its locale's dictionary while\n  // it evaluates, so the content travels with the chunk that needs it instead\n  // of being fetched — and suspended on — once that chunk renders.\n  plugins.push(intlayerPreload(intlayerConfig));\n\n  // Compiler: extracts content declared inline in components into dictionaries.\n  // Bundled directly into the main plugin so users no longer need to register\n  // `intlayerCompiler()` separately. Only added when the compiler is enabled and\n  // an `output` path is configured. Registering `intlayerCompiler()` manually as\n  // well is safe — the compiler deduplicates itself.\n  if (intlayerConfig.compiler?.enabled && intlayerConfig.compiler?.output) {\n    plugins.push(intlayerCompiler({ configOptions: getConfigOptions }));\n  }\n\n  // Proxy: locale-routing middleware (detection / redirect / rewrite) for dev,\n  // preview, and production SSR. Bundled directly into the main plugin and\n  // controlled by the `routing.enableProxy` option, which is unset by default\n  // and therefore resolves to auto mode. Only an explicit `false` skips\n  // registration — a plain truthiness check would wrongly drop the proxy for\n  // every project that never set the option.\n  // Registering `intlayerProxy()` manually as well is safe — the proxy\n  // deduplicates itself.\n  if (resolveProxyMode(intlayerConfig.routing.enableProxy) !== 'disabled') {\n    plugins.push(intlayerProxy({ ...proxy, configOptions: getConfigOptions }));\n  }\n\n  return plugins;\n};\n\n/**\n * A Vite plugin that integrates Intlayer configuration into the build process\n *\n * ```ts\n * // Example usage of the plugin in a Vite configuration\n * export default defineConfig({\n *   plugins: [ intlayer() ],\n * });\n * ```\n */\nexport const intlayer = intlayerPlugin;\n/**\n * @deprecated Rename to intlayer instead\n *\n * A Vite plugin that integrates Intlayer configuration into the build process\n *\n * ```ts\n * // Example usage of the plugin in a Vite configuration\n * export default defineConfig({\n *   plugins: [ intlayer() ],\n * });\n * ```\n */\nexport const intLayerPlugin = intlayerPlugin;\n"],"mappings":"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"}
+{"version":3,"file":"intlayerPlugin.mjs","names":[],"sources":["../../src/intlayerPlugin.ts"],"sourcesContent":["import { resolve } from 'node:path';\nimport { type CompatCallerConfig, createPruneContext } from '@intlayer/babel';\nimport { BLUE } from '@intlayer/config/colors';\nimport {\n  formatDictionarySelectorEnvVar,\n  formatNodeTypeToEnvVar,\n  formatOptimizedNestingEnvVar,\n  getConfigEnvVars,\n} from '@intlayer/config/envVars';\nimport { colorize, getAppLogger } from '@intlayer/config/logger';\nimport {\n  type GetConfigurationOptions,\n  getConfiguration,\n} from '@intlayer/config/node';\nimport {\n  getAlias,\n  getHasDictionarySelector,\n  getUnusedNodeTypesAsync,\n} from '@intlayer/config/utils';\nimport { resolveProxyMode } from '@intlayer/core/localization';\nimport { getDictionaries } from '@intlayer/dictionaries-entry';\nimport { logConfigDetails } from '@intlayer/engine/logConfigDetails';\nimport type { PluginOption } from 'vite';\nimport { intlayerCompiler } from './IntlayerCompilerPlugin';\nimport { intlayerChunk } from './intlayerChunkPlugin';\nimport { intlayerMinify } from './intlayerMinifyPlugin';\nimport { intlayerOptimize } from './intlayerOptimizePlugin';\nimport { intlayerPreload } from './intlayerPreloadPlugin';\nimport {\n  type IntlayerProxyPluginOptions,\n  intlayerProxy,\n} from './intlayerProxyPlugin';\nimport { intlayerPrune } from './intlayerPrunePlugin';\n\n/**\n * Packages that must go through Vite's transform pipeline instead of being\n * loaded natively by Node.\n *\n * `intlayer` and every `@intlayer/*` package resolve `@intlayer/dictionaries-entry`\n * through a Vite alias pointing at the generated `.intlayer` entry. A package\n * loaded natively by Node never sees that alias: it resolves the published stub\n * instead, whose CJS `require` of the generated dictionaries is cached for the\n * lifetime of the process — so content edits stop reaching the running server.\n */\nexport const INTLAYER_NO_EXTERNAL_PATTERN = /(^@intlayer\\/|intlayer$)/;\n\n/**\n * Extended options accepted by the intlayer Vite plugin.\n *\n * Extends {@link GetConfigurationOptions} with compat-adapter caller\n * configurations.  Compat adapter packages (e.g. `@intlayer/react-i18next/plugin`,\n * `@intlayer/vue-i18n/plugin`) inject their own caller configs here so the\n * field-usage analyser can recognise their translation function call patterns\n * and prune unused dictionary fields accordingly.\n */\nexport type IntlayerPluginOptions = GetConfigurationOptions & {\n  /**\n   * Compat-adapter namespace caller configurations to pass to the\n   * field-usage analyser (Vite `buildStart` phase).\n   *\n   * Defined by each compat adapter package; the core `vite-intlayer` package\n   * ships with an empty default to stay framework-agnostic.\n   */\n  compatCallers?: CompatCallerConfig[];\n\n  /**\n   * Options forwarded to the bundled locale-routing proxy (`intlayerProxy`).\n   *\n   * Since Intlayer v9 the proxy is plugged directly into the main `intlayer()`\n   * plugin (controlled by `routing.enableProxy`, unset by default, which\n   * selects auto mode). These routing options let you tune that bundled proxy\n   * without registering it separately — e.g. ignore API routes from locale\n   * routing.\n   *\n   * @example\n   * ```ts\n   * intlayer({ proxy: { ignore: (req) => req.url?.startsWith('/api') } })\n   * ```\n   */\n  proxy?: Pick<IntlayerProxyPluginOptions, 'ignore'>;\n};\n\n/**\n * Vite plugin that integrates Intlayer into the Vite build process.\n *\n * It handles:\n * 1. Preparing Intlayer resources (dictionaries) before build.\n * 2. Configuring Vite aliases for dictionary access.\n * 3. Setting up dev-server watchers for content changes.\n * 4. Applying build optimizations (tree-shaking dictionaries).\n *\n * @param configOptions - Optional configuration to override default Intlayer settings.\n * @returns A Vite plugin option.\n *\n * @example\n * ```ts\n * import { intlayer } from 'vite-intlayer';\n *\n * export default defineConfig({\n *   plugins: [intlayer()],\n * });\n *\n * ```\n * @deprecated Rename to intlayer instead\n */\nexport const intlayerPlugin = (\n  configOptions?: IntlayerPluginOptions\n): PluginOption => {\n  const { compatCallers, proxy, ...getConfigOptions } = configOptions ?? {};\n  const intlayerConfig = getConfiguration(getConfigOptions);\n  logConfigDetails(getConfigOptions);\n  const appLogger = getAppLogger(intlayerConfig);\n\n  const alias = getAlias({\n    configuration: intlayerConfig,\n    formatter: (value: string) => resolve(value),\n  });\n\n  const aliasPackages = Object.keys(alias);\n\n  const plugins: PluginOption[] = [\n    {\n      name: 'vite-intlayer-plugin',\n\n      apply: (_config, env) => {\n        // Don't apply intlayer plugin during `preview` command\n        const isPreviewCommand =\n          env.command === 'serve' && env.mode === 'production';\n\n        // But if liveSync is enabled, ensure the data are fresh\n        const isLiveSyncEnabled = intlayerConfig.editor.liveSync;\n\n        return !isPreviewCommand || isLiveSyncEnabled;\n      },\n\n      config: async (_config, env) => {\n        const { mode } = intlayerConfig.build;\n\n        const isDevCommand =\n          env.command === 'serve' && env.mode === 'development';\n        const isBuildCommand = env.command === 'build';\n\n        // Only call prepareIntlayer during `dev` or `build` (not during `preview`)\n        // If prod: clean and rebuild once\n        // If dev: rebuild only once if it's more than 1 hour since last rebuild\n        if (isDevCommand || isBuildCommand || mode === 'auto') {\n          // Lazily load the heavy build pipeline (`@intlayer/engine/build`) only\n          // when a rebuild is actually required, keeping the Vite config phase\n          // lightweight (e.g. during `preview`).\n          const { prepareIntlayer } = await import('@intlayer/engine/build');\n\n          // prepareIntlayer use runOnce to ensure to run only once because will run twice on client and server side otherwise\n          await prepareIntlayer(intlayerConfig, {\n            clean: isBuildCommand,\n            cacheTimeoutMs: isBuildCommand\n              ? 1000 * 30 // 30 seconds for build (to ensure to rebuild all dictionaries)\n              : 1000 * 60 * 60, // 1 hour for dev (default cache timeout)\n            env: isBuildCommand ? 'prod' : 'dev',\n          });\n        }\n\n        let define: Record<string, string> = {\n          // Preset an env var to avoid 'process is not defined' error\n          // Needed for some libraries that does not add process.env\n          'process.env.INTLAYER': '\"true\"',\n        };\n\n        if (isBuildCommand) {\n          const dictionaries = getDictionaries(intlayerConfig);\n\n          // Mirrors the optimize plugin's own `apply` condition: the local\n          // `nest()` resolver may only be selected when that transform runs,\n          // since it is the transform that injects the nest attachment.\n          const isOptimizeEnabled = intlayerConfig.build.optimize !== false;\n\n          if (Object.keys(dictionaries).length === 0) {\n            appLogger(\n              'No dictionaries found. Please check your configuration.',\n              {\n                isVerbose: true,\n              }\n            );\n          }\n\n          const unusedNodeTypes = await getUnusedNodeTypesAsync(dictionaries);\n\n          if (unusedNodeTypes.length > 0) {\n            appLogger(\n              [\n                'Filtering out unused logic:',\n                unusedNodeTypes\n                  .filter(\n                    (key) =>\n                      !['reactNode', 'solidNode', 'preactNode'].includes(key)\n                  )\n                  .map((key) => colorize(key, BLUE))\n                  .join(', '),\n              ],\n              {\n                isVerbose: true,\n              }\n            );\n          }\n\n          define = {\n            ...define,\n\n            // Tree shacking env var based on config\n            ...formatNodeTypeToEnvVar(\n              unusedNodeTypes,\n              (key) => `process.env.${key}`,\n              (value) => `\"${value}\"`\n            ),\n\n            // Selects the local `nest()` resolver, which reads the nest\n            // targets attached to each dictionary by the optimize transform\n            // instead of the registry that transform empties.\n            ...formatOptimizedNestingEnvVar(\n              isOptimizeEnabled,\n              (key) => `process.env.${key}`,\n              (value) => `\"${value}\"`\n            ),\n\n            // Tree shacking env var for the dictionary selector logic\n            // (collections / variants)\n            ...formatDictionarySelectorEnvVar(\n              getHasDictionarySelector(dictionaries),\n              (key) => `process.env.${key}`,\n              (value) => `\"${value}\"`\n            ),\n\n            // Tree shacking env var based on config\n            ...getConfigEnvVars(\n              intlayerConfig,\n              (key) => `process.env.${key}`,\n              (value) => `\"${value}\"` // Wrap by \"\" to ensure env var set properly\n            ),\n          };\n        }\n\n        // mergeConfig handles both array and record alias formats,\n        // and correctly appends to optimizeDeps.exclude / ssr.noExternal\n        return {\n          define,\n          resolve: {\n            alias,\n          },\n          optimizeDeps: {\n            // Exclude alias entry points since they're local files, not npm packages\n            exclude: aliasPackages,\n          },\n          ssr: {\n            // Ensure intlayer packages are bundled so aliases are applied\n            noExternal: [INTLAYER_NO_EXTERNAL_PATTERN],\n          },\n        };\n      },\n\n      configureServer: async (server) => {\n        if (server.config.mode === 'development') {\n          // Lazily load the file watcher (`@intlayer/engine/watcher`, which pulls\n          // in `@parcel/watcher`) only when the dev server actually starts.\n          const { watch } = await import('@intlayer/engine/watcher');\n\n          // Start watching (assuming watch is also async)\n          await watch({ configuration: intlayerConfig });\n        }\n      },\n    },\n  ];\n\n  // Shared mutable state: the optimize plugin writes field-usage data during\n  // buildStart; the prune and minify plugins read it during transform.\n  const pruneContext = createPruneContext();\n\n  // Babel transform: rewrites useIntlayer/getIntlayer calls and injects\n  // JSON / dynamic-mjs imports.  Also runs the usage analyser in buildStart.\n  plugins.push(intlayerOptimize(intlayerConfig, pruneContext, compatCallers));\n\n  // Prune: removes unused content fields from dictionary JSON files.\n  // Runs with enforce:'pre' so it intercepts raw JSON before Vite's\n  // built-in JSON → ESM conversion.\n  plugins.push(intlayerPrune(intlayerConfig, pruneContext));\n\n  // Minify: compacts dictionary JSON files (parse + re-stringify).\n  // Registered after prune so it receives already-pruned output when both options are active.\n  plugins.push(intlayerMinify(intlayerConfig, pruneContext));\n\n  // Chunk: regroups the per-dictionary chunks that `importMode: 'dynamic'`\n  // emits, so each code-split boundary loads its content in one request.\n  plugins.push(intlayerChunk(intlayerConfig));\n\n  // Preload: makes each dynamic entry point await its locale's dictionary while\n  // it evaluates, so the content travels with the chunk that needs it instead\n  // of being fetched — and suspended on — once that chunk renders.\n  plugins.push(intlayerPreload(intlayerConfig));\n\n  // Compiler: extracts content declared inline in components into dictionaries.\n  // Bundled directly into the main plugin so users no longer need to register\n  // `intlayerCompiler()` separately. Only added when the compiler is enabled and\n  // an `output` path is configured. Registering `intlayerCompiler()` manually as\n  // well is safe — the compiler deduplicates itself.\n  if (intlayerConfig.compiler?.enabled && intlayerConfig.compiler?.output) {\n    plugins.push(intlayerCompiler({ configOptions: getConfigOptions }));\n  }\n\n  // Proxy: locale-routing middleware (detection / redirect / rewrite) for dev,\n  // preview, and production SSR. Bundled directly into the main plugin and\n  // controlled by the `routing.enableProxy` option, which is unset by default\n  // and therefore resolves to auto mode. Only an explicit `false` skips\n  // registration — a plain truthiness check would wrongly drop the proxy for\n  // every project that never set the option.\n  // Registering `intlayerProxy()` manually as well is safe — the proxy\n  // deduplicates itself.\n  if (resolveProxyMode(intlayerConfig.routing.enableProxy) !== 'disabled') {\n    plugins.push(intlayerProxy({ ...proxy, configOptions: getConfigOptions }));\n  }\n\n  return plugins;\n};\n\n/**\n * A Vite plugin that integrates Intlayer configuration into the build process\n *\n * ```ts\n * // Example usage of the plugin in a Vite configuration\n * export default defineConfig({\n *   plugins: [ intlayer() ],\n * });\n * ```\n */\nexport const intlayer = intlayerPlugin;\n/**\n * @deprecated Rename to intlayer instead\n *\n * A Vite plugin that integrates Intlayer configuration into the build process\n *\n * ```ts\n * // Example usage of the plugin in a Vite configuration\n * export default defineConfig({\n *   plugins: [ intlayer() ],\n * });\n * ```\n */\nexport const intLayerPlugin = intlayerPlugin;\n"],"mappings":"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"}

package/dist/types/IntlayerCompilerPlugin.d.ts

@@ -5,7 +5,7 @@ import { PluginOption } from "vite";
 /**
  * Options for initializing the compiler
  */
-type IntlayerCompilerOptions = {
+export type IntlayerCompilerOptions = {
   /**
    * Configuration options for getting the intlayer configuration
    */
@@ -37,7 +37,6 @@ type IntlayerCompilerOptions = {
  *
  * @deprecated Since Intlayer v9, the compiler is bundled directly into the `intlayer()` plugin and activates automatically once `compiler.enabled` is set with a `compiler.output` path. Registering `intlayerCompiler()` separately as shown below is now optional. See the [v9 release notes](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/releases/v9.md).
  */
-declare const intlayerCompiler: (options?: IntlayerCompilerOptions) => PluginOption;
+export declare const intlayerCompiler: (options?: IntlayerCompilerOptions) => PluginOption;
 //#endregion
-export { IntlayerCompilerOptions, intlayerCompiler };
 //# sourceMappingURL=IntlayerCompilerPlugin.d.ts.map

package/dist/types/IntlayerCompilerPlugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"IntlayerCompilerPlugin.d.ts","names":[],"sources":["../../src/IntlayerCompilerPlugin.ts"],"mappings":";;;;;;;KAkCY;;;;EAIV,gBAAgB;;;;EAKhB,iBAAiB,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;cAyBd,mBAAgB,UACjB,4BACT"}
+{"version":3,"file":"IntlayerCompilerPlugin.d.ts","names":[],"sources":["../../src/IntlayerCompilerPlugin.ts"],"mappings":";;;;;;;YAkCY;;;;EAIV,gBAAgB;;;;EAKhB,iBAAiB,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;qBAyBd,mBAAgB,UACjB,4BACT"}

package/dist/types/dedupePlugin.d.ts

@@ -19,7 +19,7 @@ type ResolvedConfigWithPlugins = {
  * plugin array (so Vite stays happy) while only the first instance sharing a
  * given `name` is treated as "primary" and actually executes.
  */
-type PrimaryInstanceGuard = {
+export type PrimaryInstanceGuard = {
   /**
    * Records the plugin object so the guard can later find the first instance by
    * identity in the resolved config.
@@ -41,7 +41,6 @@ type PrimaryInstanceGuard = {
  *
  * @param pluginName - The `name` of the Vite plugin to deduplicate.
  */
-declare const createPrimaryInstanceGuard: (pluginName: string) => PrimaryInstanceGuard;
+export declare const createPrimaryInstanceGuard: (pluginName: string) => PrimaryInstanceGuard;
 //#endregion
-export { PrimaryInstanceGuard, createPrimaryInstanceGuard };
 //# sourceMappingURL=dedupePlugin.d.ts.map

package/dist/types/dedupePlugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dedupePlugin.d.ts","names":[],"sources":["../../src/dedupePlugin.ts"],"mappings":";;;;;;KAMK;EACH;IAAoB;;;;;;;;;;;;;KAaV;;;;;EAKV,YAAY,QAAQ;;;;;EAMpB,UAAU,QAAQ;;;;;WAMT;;;;;;;cAQE,6BAA0B,uBAEpC"}
+{"version":3,"file":"dedupePlugin.d.ts","names":[],"sources":["../../src/dedupePlugin.ts"],"mappings":";;;;;;KAMK;EACH;IAAoB;;;;;;;;;;;;;YAaV;;;;;EAKV,YAAY,QAAQ;;;;;EAMpB,UAAU,QAAQ;;;;;WAMT;;;;;;;qBAQE,6BAA0B,uBAEpC"}

package/dist/types/index.d.ts

@@ -3,7 +3,7 @@ import { ChunkingContext, DictionaryModule, ModuleGraphNode, createDictionaryMod
 import { intlayerMinify } from "./intlayerMinifyPlugin.js";
 import { intlayerOptimize } from "./intlayerOptimizePlugin.js";
 import { IntlayerProxyPluginOptions, createIntlayerProxyHandler, intLayerMiddlewarePlugin, intlayerMiddleware, intlayerProxy } from "./intlayerProxyPlugin.js";
-import { IntlayerPluginOptions, intLayerPlugin, intlayer, intlayerPlugin } from "./intlayerPlugin.js";
+import { INTLAYER_NO_EXTERNAL_PATTERN, IntlayerPluginOptions, intLayerPlugin, intlayer, intlayerPlugin } from "./intlayerPlugin.js";
 import { intlayerPreload } from "./intlayerPreloadPlugin.js";
 import { intlayerPrune } from "./intlayerPrunePlugin.js";
-export { ChunkingContext, DictionaryModule, IntlayerCompilerOptions, IntlayerPluginOptions, IntlayerProxyPluginOptions, ModuleGraphNode, createDictionaryModuleParser, createIntlayerProxyHandler, intLayerMiddlewarePlugin, intLayerPlugin, intlayer, intlayerChunk, intlayerCompiler, intlayerMiddleware, intlayerMinify, intlayerOptimize, intlayerPlugin, intlayerPreload, intlayerProxy, intlayerPrune, resolveBoundaries, toBoundaryName };
+export { ChunkingContext, DictionaryModule, INTLAYER_NO_EXTERNAL_PATTERN, IntlayerCompilerOptions, IntlayerPluginOptions, IntlayerProxyPluginOptions, ModuleGraphNode, createDictionaryModuleParser, createIntlayerProxyHandler, intLayerMiddlewarePlugin, intLayerPlugin, intlayer, intlayerChunk, intlayerCompiler, intlayerMiddleware, intlayerMinify, intlayerOptimize, intlayerPlugin, intlayerPreload, intlayerProxy, intlayerPrune, resolveBoundaries, toBoundaryName };

package/dist/types/intlayerChunkPlugin.d.ts

@@ -8,10 +8,10 @@ import { Plugin } from "vite";
  * keeps working against the Rolldown bundled inside Vite, whose types are not
  * re-exported.
  */
-type ChunkingContext = {
+export type ChunkingContext = {
   getModuleInfo: (moduleId: string) => ModuleGraphNode | null;
 };
-type ModuleGraphNode = {
+export type ModuleGraphNode = {
   id: string;
   isEntry: boolean;
   /** Ids of the modules that statically `import` this one. */
@@ -20,7 +20,7 @@ type ModuleGraphNode = {
   dynamicImporters: string[];
 };
 /** A per-locale dictionary chunk, identified from its module id. */
-type DictionaryModule = {
+export type DictionaryModule = {
   key: string;
   locale: string;
 };
@@ -38,9 +38,9 @@ type DictionaryModule = {
  * @param dynamicDictionariesDir - Absolute, POSIX-normalized dictionaries root.
  * @returns Parser returning the key and locale, or `null` for any other module.
  */
-declare const createDictionaryModuleParser: (dynamicDictionariesDir: string) => ((moduleId: string) => DictionaryModule | null);
+export declare const createDictionaryModuleParser: (dynamicDictionariesDir: string) => ((moduleId: string) => DictionaryModule | null);
 /** Turns a boundary module id into a readable chunk-name fragment. */
-declare const toBoundaryName: (moduleId: string) => string;
+export declare const toBoundaryName: (moduleId: string) => string;
 /**
  * Walks up the import graph from a dictionary JSON to the code-split boundaries
  * that reach it.
@@ -55,7 +55,7 @@ declare const toBoundaryName: (moduleId: string) => string;
  * @returns Boundary ids reaching this dictionary, empty when the graph is
  *          unavailable (the module was pruned, or resolution failed).
  */
-declare const resolveBoundaries: (jsonModuleId: string, context: ChunkingContext) => string[];
+export declare const resolveBoundaries: (jsonModuleId: string, context: ChunkingContext) => string[];
 /**
  * Groups dynamically imported dictionaries by the code-split boundary that
  * consumes them, so each lazily loaded page or section fetches its content in
@@ -82,7 +82,6 @@ declare const resolveBoundaries: (jsonModuleId: string, context: ChunkingContext
  *
  * @param intlayerConfig - Resolved Intlayer configuration.
  */
-declare const intlayerChunk: (intlayerConfig: IntlayerConfig) => Plugin;
+export declare const intlayerChunk: (intlayerConfig: IntlayerConfig) => Plugin;
 //#endregion
-export { ChunkingContext, DictionaryModule, ModuleGraphNode, createDictionaryModuleParser, intlayerChunk, resolveBoundaries, toBoundaryName };
 //# sourceMappingURL=intlayerChunkPlugin.d.ts.map

package/dist/types/intlayerChunkPlugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"intlayerChunkPlugin.d.ts","names":[],"sources":["../../src/intlayerChunkPlugin.ts"],"mappings":";;;;;;;;;;KAaY;EACV,gBAAgB,qBAAqB;;KAG3B;EACV;EACA;;EAEA;;EAEA;;;KAIU;EACV;EACA;;;;;;;;;;;;;;;;cAiBW,+BAA4B,qCAEpC,qBAAqB;;cAuCb,iBAAc;;;;;;;;;;;;;;;cAuBd,oBAAiB,sBACR,SACX;;;;;;;;;;;;;;;;;;;;;;;;;;;cAyDE,gBAAa,gBAAoB,mBAAiB"}
+{"version":3,"file":"intlayerChunkPlugin.d.ts","names":[],"sources":["../../src/intlayerChunkPlugin.ts"],"mappings":";;;;;;;;;;YAaY;EACV,gBAAgB,qBAAqB;;YAG3B;EACV;EACA;;EAEA;;EAEA;;;YAIU;EACV;EACA;;;;;;;;;;;;;;;;qBAiBW,+BAA4B,qCAEpC,qBAAqB;;qBAuCb,iBAAc;;;;;;;;;;;;;;;qBAuBd,oBAAiB,sBACR,SACX;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAyDE,gBAAa,gBAAoB,mBAAiB"}

package/dist/types/intlayerMinifyPlugin.d.ts

@@ -38,7 +38,6 @@ import { PruneContext } from "@intlayer/babel";
  *                         skipped and field renames are applied.  Pass `null`
  *                         if the prune plugin is not active.
  */
-declare const intlayerMinify: (intlayerConfig: IntlayerConfig, pruneContext: PruneContext | null) => PluginOption[];
+export declare const intlayerMinify: (intlayerConfig: IntlayerConfig, pruneContext: PruneContext | null) => PluginOption[];
 //#endregion
-export { intlayerMinify };
 //# sourceMappingURL=intlayerMinifyPlugin.d.ts.map

package/dist/types/intlayerMinifyPlugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"intlayerMinifyPlugin.d.ts","names":[],"sources":["../../src/intlayerMinifyPlugin.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwKa,iBAAc,gBACT,gBAAc,cAChB,wBACb"}
+{"version":3,"file":"intlayerMinifyPlugin.d.ts","names":[],"sources":["../../src/intlayerMinifyPlugin.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAwKa,iBAAc,gBACT,gBAAc,cAChB,wBACb"}

package/dist/types/intlayerOptimizePlugin.d.ts

@@ -24,7 +24,6 @@ import { CallerDescriptor, PruneContext } from "@intlayer/babel";
  *                         analysis (e.g. when both `purge` and `minify` are
  *                         disabled).
  */
-declare const intlayerOptimize: (intlayerConfig: IntlayerConfig, pruneContext: PruneContext | null, compatCallers?: CallerDescriptor[]) => Promise<PluginOption[]>;
+export declare const intlayerOptimize: (intlayerConfig: IntlayerConfig, pruneContext: PruneContext | null, compatCallers?: CallerDescriptor[]) => Promise<PluginOption[]>;
 //#endregion
-export { intlayerOptimize };
 //# sourceMappingURL=intlayerOptimizePlugin.d.ts.map

package/dist/types/intlayerOptimizePlugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"intlayerOptimizePlugin.d.ts","names":[],"sources":["../../src/intlayerOptimizePlugin.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;cA+Da,mBAAgB,gBACX,gBAAc,cAChB,qBAAmB,gBACjB,uBACf,QAAQ"}
+{"version":3,"file":"intlayerOptimizePlugin.d.ts","names":[],"sources":["../../src/intlayerOptimizePlugin.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;qBA+Da,mBAAgB,gBACX,gBAAc,cAChB,qBAAmB,gBACjB,uBACf,QAAQ"}

package/dist/types/intlayerPlugin.d.ts

@@ -3,6 +3,17 @@ import { GetConfigurationOptions } from "@intlayer/config/node";
 import { PluginOption } from "vite";
 import { CompatCallerConfig } from "@intlayer/babel";
 //#region src/intlayerPlugin.d.ts
+/**
+ * Packages that must go through Vite's transform pipeline instead of being
+ * loaded natively by Node.
+ *
+ * `intlayer` and every `@intlayer/*` package resolve `@intlayer/dictionaries-entry`
+ * through a Vite alias pointing at the generated `.intlayer` entry. A package
+ * loaded natively by Node never sees that alias: it resolves the published stub
+ * instead, whose CJS `require` of the generated dictionaries is cached for the
+ * lifetime of the process — so content edits stop reaching the running server.
+ */
+export declare const INTLAYER_NO_EXTERNAL_PATTERN: RegExp;
 /**
  * Extended options accepted by the intlayer Vite plugin.
  *
@@ -12,7 +23,7 @@ import { CompatCallerConfig } from "@intlayer/babel";
  * field-usage analyser can recognise their translation function call patterns
  * and prune unused dictionary fields accordingly.
  */
-type IntlayerPluginOptions = GetConfigurationOptions & {
+export type IntlayerPluginOptions = GetConfigurationOptions & {
   /**
    * Compat-adapter namespace caller configurations to pass to the
    * field-usage analyser (Vite `buildStart` phase).
@@ -60,7 +71,7 @@ type IntlayerPluginOptions = GetConfigurationOptions & {
  * ```
  * @deprecated Rename to intlayer instead
  */
-declare const intlayerPlugin: (configOptions?: IntlayerPluginOptions) => PluginOption;
+export declare const intlayerPlugin: (configOptions?: IntlayerPluginOptions) => PluginOption;
 /**
  * A Vite plugin that integrates Intlayer configuration into the build process
  *
@@ -71,7 +82,7 @@ declare const intlayerPlugin: (configOptions?: IntlayerPluginOptions) => PluginO
  * });
  * ```
  */
-declare const intlayer: typeof intlayerPlugin;
+export declare const intlayer: typeof intlayerPlugin;
 /**
  * @deprecated Rename to intlayer instead
  *
@@ -84,7 +95,6 @@ declare const intlayer: typeof intlayerPlugin;
  * });
  * ```
  */
-declare const intLayerPlugin: typeof intlayerPlugin;
+export declare const intLayerPlugin: typeof intlayerPlugin;
 //#endregion
-export { IntlayerPluginOptions, intLayerPlugin, intlayer, intlayerPlugin };
 //# sourceMappingURL=intlayerPlugin.d.ts.map

package/dist/types/intlayerPlugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"intlayerPlugin.d.ts","names":[],"sources":["../../src/intlayerPlugin.ts"],"mappings":";;;;;;;;;;;;;;KA2CY,wBAAwB;;;;;;;;EAQlC,gBAAgB;;;;;;;;;;;;;;;EAgBhB,QAAQ,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;cA0BF,iBAAc,gBACT,0BACf;;;;;;;;;;;cAgOU,iBAAQ;;;;;;;;;;;;;cAaR,uBAAc"}
+{"version":3,"file":"intlayerPlugin.d.ts","names":[],"sources":["../../src/intlayerPlugin.ts"],"mappings":";;;;;;;;;;;;;;;qBA4Ca,8BAA4B;;;;;;;;;;YAW7B,wBAAwB;;;;;;;;EAQlC,gBAAgB;;;;;;;;;;;;;;;EAgBhB,QAAQ,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;qBA0BF,iBAAc,gBACT,0BACf;;;;;;;;;;;qBAgOU,iBAAQ;;;;;;;;;;;;;qBAaR,uBAAc"}

package/dist/types/intlayerPreloadPlugin.d.ts

@@ -28,7 +28,6 @@ import { Plugin } from "vite";
  *
  * @param intlayerConfig - Resolved Intlayer configuration.
  */
-declare const intlayerPreload: (intlayerConfig: IntlayerConfig) => Plugin;
+export declare const intlayerPreload: (intlayerConfig: IntlayerConfig) => Plugin;
 //#endregion
-export { intlayerPreload };
 //# sourceMappingURL=intlayerPreloadPlugin.d.ts.map

package/dist/types/intlayerPreloadPlugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"intlayerPreloadPlugin.d.ts","names":[],"sources":["../../src/intlayerPreloadPlugin.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmDa,kBAAe,gBAAoB,mBAAiB"}
+{"version":3,"file":"intlayerPreloadPlugin.d.ts","names":[],"sources":["../../src/intlayerPreloadPlugin.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAmDa,kBAAe,gBAAoB,mBAAiB"}

package/dist/types/intlayerProxyHandler.d.ts

@@ -6,8 +6,8 @@ import { IncomingMessage, ServerResponse } from "node:http";
  * Compatible with Vite dev/preview server, Node.js http, Express, and h3's
  * `fromNodeMiddleware` wrapper for Nitro/TanStack Start production use.
  */
-type NodeMiddleware = (req: IncomingMessage, res: ServerResponse<IncomingMessage>, next: () => void) => void;
-type IntlayerProxyHandlerOptions = {
+export type NodeMiddleware = (req: IncomingMessage, res: ServerResponse<IncomingMessage>, next: () => void) => void;
+export type IntlayerProxyHandlerOptions = {
   /**
    * The resolved Intlayer configuration driving locale detection and routing.
    */
@@ -44,7 +44,6 @@ type IntlayerProxyHandlerOptions = {
  *
  * @see `createIntlayerProxyHandler` for the public, configuration-loading entry point.
  */
-declare const createProxyHandler: (options: IntlayerProxyHandlerOptions) => NodeMiddleware;
+export declare const createProxyHandler: (options: IntlayerProxyHandlerOptions) => NodeMiddleware;
 //#endregion
-export { IntlayerProxyHandlerOptions, NodeMiddleware, createProxyHandler };
 //# sourceMappingURL=intlayerProxyHandler.d.ts.map

package/dist/types/intlayerProxyHandler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"intlayerProxyHandler.d.ts","names":[],"sources":["../../src/intlayerProxyHandler.ts"],"mappings":";;;;;;;;KAkIY,kBACV,KAAK,iBACL,KAAK,eAAe,kBACpB;KAGU;;;;EAIV,eAAe;;;;;;;EAOf,UAAU,KAAK;;;;;;;;;EASf;;;;;;;;;;;;;;;;;cAkBW,qBAAkB,SACpB,gCACR"}
+{"version":3,"file":"intlayerProxyHandler.d.ts","names":[],"sources":["../../src/intlayerProxyHandler.ts"],"mappings":";;;;;;;;YAkIY,kBACV,KAAK,iBACL,KAAK,eAAe,kBACpB;YAGU;;;;EAIV,eAAe;;;;;;;EAOf,UAAU,KAAK;;;;;;;;;EASf;;;;;;;;;;;;;;;;;qBAkBW,qBAAkB,SACpB,gCACR"}

package/dist/types/intlayerProxyPlugin.d.ts

@@ -3,7 +3,7 @@ import { GetConfigurationOptions } from "@intlayer/config/node";
 import { Plugin } from "vite";
 import { IncomingMessage } from "node:http";
 //#region src/intlayerProxyPlugin.d.ts
-type IntlayerProxyPluginOptions = {
+export type IntlayerProxyPluginOptions = {
   /**
    * A function that allows you to ignore specific requests from the intlayer proxy.
    *
@@ -66,7 +66,7 @@ type IntlayerProxyPluginOptions = {
  * @param options - Plugin-specific options, such as path ignoring and Intlayer configuration overrides.
  * @returns A Connect-compatible `(req, res, next) => void` middleware.
  */
-declare const createIntlayerProxyHandler: (options?: IntlayerProxyPluginOptions) => NodeMiddleware;
+export declare const createIntlayerProxyHandler: (options?: IntlayerProxyPluginOptions) => NodeMiddleware;
 /**
  * Vite plugin that provides locale-based routing middleware for **all environments**:
  * development, preview, and production SSR (Nitro / TanStack Start).
@@ -108,7 +108,7 @@ declare const createIntlayerProxyHandler: (options?: IntlayerProxyPluginOptions)
  *
  * @deprecated Since Intlayer v9, `intlayerProxy()` is bundled directly into the `intlayer()` plugin and enabled by default through the `routing.enableProxy` option (unset by default, which selects auto mode). Registering it separately as shown below is now optional.
  */
-declare const intlayerProxy: (options?: IntlayerProxyPluginOptions) => Plugin;
+export declare const intlayerProxy: (options?: IntlayerProxyPluginOptions) => Plugin;
 /**
  * @deprecated Rename to intlayerProxy instead
  *
@@ -121,7 +121,7 @@ declare const intlayerProxy: (options?: IntlayerProxyPluginOptions) => Plugin;
  * });
  * ```
  */
-declare const intlayerMiddleware: typeof intlayerProxy;
+export declare const intlayerMiddleware: typeof intlayerProxy;
 /**
  * @deprecated Rename to intlayerProxy instead
  *
@@ -134,7 +134,6 @@ declare const intlayerMiddleware: typeof intlayerProxy;
  * });
  * ```
  */
-declare const intLayerMiddlewarePlugin: typeof intlayerProxy;
+export declare const intLayerMiddlewarePlugin: typeof intlayerProxy;
 //#endregion
-export { IntlayerProxyPluginOptions, createIntlayerProxyHandler, intLayerMiddlewarePlugin, intlayerMiddleware, intlayerProxy };
 //# sourceMappingURL=intlayerProxyPlugin.d.ts.map

package/dist/types/intlayerProxyPlugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"intlayerProxyPlugin.d.ts","names":[],"sources":["../../src/intlayerProxyPlugin.ts"],"mappings":";;;;;KA6BY;;;;;;;;;;;;;;EAcV,UAAU,KAAK;;;;;;;;;;;EAWf,gBAAgB;;;;;;;;;;;;;;EAchB;;;;;;;;;;;;;;;;;;;;;;;;cAyBW,6BAA0B,UAC3B,+BACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAgDU,gBAAa,UAAc,+BAA6B;;;;;;;;;;;;;cAuIxD,2BAAkB;;;;;;;;;;;;;cAclB,iCAAwB"}
+{"version":3,"file":"intlayerProxyPlugin.d.ts","names":[],"sources":["../../src/intlayerProxyPlugin.ts"],"mappings":";;;;;YA6BY;;;;;;;;;;;;;;EAcV,UAAU,KAAK;;;;;;;;;;;EAWf,gBAAgB;;;;;;;;;;;;;;EAchB;;;;;;;;;;;;;;;;;;;;;;;;qBAyBW,6BAA0B,UAC3B,+BACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAgDU,gBAAa,UAAc,+BAA6B;;;;;;;;;;;;;qBAuIxD,2BAAkB;;;;;;;;;;;;;qBAclB,iCAAwB"}

package/dist/types/intlayerPrunePlugin.d.ts

@@ -34,7 +34,6 @@ import { PruneContext } from "@intlayer/babel";
  * @param pruneContext   - Shared state produced by the usage analyser that
  *                         runs inside `intlayerOptimizePlugin`.
  */
-declare const intlayerPrune: (intlayerConfig: IntlayerConfig, pruneContext: PruneContext) => PluginOption[];
+export declare const intlayerPrune: (intlayerConfig: IntlayerConfig, pruneContext: PruneContext) => PluginOption[];
 //#endregion
-export { intlayerPrune };
 //# sourceMappingURL=intlayerPrunePlugin.d.ts.map

package/dist/types/intlayerPrunePlugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"intlayerPrunePlugin.d.ts","names":[],"sources":["../../src/intlayerPrunePlugin.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAiNa,gBAAa,gBACR,gBAAc,cAChB,iBACb"}
+{"version":3,"file":"intlayerPrunePlugin.d.ts","names":[],"sources":["../../src/intlayerPrunePlugin.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAiNa,gBAAa,gBACR,gBAAc,cAChB,iBACb"}

package/dist/types/intlayerVueAsyncPlugin.d.ts

@@ -1,7 +1,6 @@
 import { IntlayerConfig } from "@intlayer/types/config";
 import { PluginOption } from "vite";
 //#region src/intlayerVueAsyncPlugin.d.ts
-declare const intlayerVueAsyncPlugin: (configuration: IntlayerConfig, filesList: string[]) => PluginOption;
+export declare const intlayerVueAsyncPlugin: (configuration: IntlayerConfig, filesList: string[]) => PluginOption;
 //#endregion
-export { intlayerVueAsyncPlugin };
 //# sourceMappingURL=intlayerVueAsyncPlugin.d.ts.map

package/dist/types/intlayerVueAsyncPlugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"intlayerVueAsyncPlugin.d.ts","names":[],"sources":["../../src/intlayerVueAsyncPlugin.ts"],"mappings":";;;cAIa,yBAAsB,eAClB,gBAAc,wBAE5B"}
+{"version":3,"file":"intlayerVueAsyncPlugin.d.ts","names":[],"sources":["../../src/intlayerVueAsyncPlugin.ts"],"mappings":";;;qBAIa,yBAAsB,eAClB,gBAAc,wBAE5B"}

package/dist/types/pruneContext.d.ts

@@ -1,6 +1,5 @@
 import { PruneContext } from "@intlayer/babel";
 //#region src/pruneContext.d.ts
-declare const createPruneContext: () => PruneContext;
+export declare const createPruneContext: () => PruneContext;
 //#endregion
-export { createPruneContext };
 //# sourceMappingURL=pruneContext.d.ts.map

package/dist/types/pruneContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pruneContext.d.ts","names":[],"sources":["../../src/pruneContext.ts"],"mappings":";;cAQa,0BAAyB"}
+{"version":3,"file":"pruneContext.d.ts","names":[],"sources":["../../src/pruneContext.ts"],"mappings":";;qBAQa,0BAAyB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite-intlayer",
-  "version": "9.4.3",
+  "version": "9.4.4",
   "private": false,
   "description": "A Vite plugin for seamless internationalization (i18n), providing locale detection, redirection, and environment-based configuration",
   "keywords": [
@@ -81,12 +81,12 @@
     "typecheck": "tsc --noEmit --project tsconfig.types.json"
   },
   "dependencies": {
-    "@intlayer/babel": "9.4.3",
-    "@intlayer/config": "9.4.3",
-    "@intlayer/core": "9.4.3",
-    "@intlayer/dictionaries-entry": "9.4.3",
-    "@intlayer/engine": "9.4.3",
-    "@intlayer/types": "9.4.3"
+    "@intlayer/babel": "9.4.4",
+    "@intlayer/config": "9.4.4",
+    "@intlayer/core": "9.4.4",
+    "@intlayer/dictionaries-entry": "9.4.4",
+    "@intlayer/engine": "9.4.4",
+    "@intlayer/types": "9.4.4"
   },
   "devDependencies": {
     "@types/node": "26.4.1",
@@ -94,14 +94,14 @@
     "@utils/ts-config-types": "1.0.4",
     "@utils/tsdown-config": "1.0.4",
     "rimraf": "6.1.3",
-    "tsdown": "0.22.14",
+    "tsdown": "0.23.0",
     "typescript": "7.0.2",
-    "vitest": "4.1.11"
+    "vitest": "5.0.0"
   },
   "peerDependencies": {
     "@babel/core": ">=6.0.0",
-    "@intlayer/svelte-compiler": "9.4.3",
-    "@intlayer/vue-compiler": "9.4.3",
+    "@intlayer/svelte-compiler": "9.4.4",
+    "@intlayer/vue-compiler": "9.4.4",
     "h3": ">=1.0.0",
     "vite": ">=4.0.0"
   },