@intlayer/babel 9.2.0 → 9.3.1

package/dist/esm/index.mjs

@@ -1,4 +1,4 @@
-import { DEFAULT_COMPAT_CALLERS, INTLAYER_CALLER_NAMES, createPruneContext, makeUsageAnalyzerBabelPlugin } from "./babel-plugin-intlayer-usage-analyzer.mjs";
+import { DEFAULT_COMPAT_CALLERS, INTLAYER_CALLER_NAMES, createPruneContext, makeUsageAnalyzerBabelPlugin, preserveNestedDictionaryFields } from "./babel-plugin-intlayer-usage-analyzer.mjs";
 import { extractScriptBlocks, injectScriptBlocks } from "./extractScriptBlocks.mjs";
 import { extractDictionaryKey, extractDictionaryKeyFromPath } from "./extractContent/utils/extractDictionaryKey.mjs";
 import { extractDictionaryInfo, getOutput, resolveContentFilePaths } from "./extractContent/utils/extractDictionaryInfo.mjs";
@@ -10,12 +10,12 @@ import { generateKey } from "./extractContent/utils/generateKey.mjs";
 import { getComponentName } from "./extractContent/utils/getComponentName.mjs";
 import { extractContent, extractContentSync } from "./extractContent/extractContent.mjs";
 import { intlayerExtractBabelPlugin } from "./babel-plugin-intlayer-extract.mjs";
-import { buildNestedRenameMapFromContent, generateShortFieldName, getNestedRenameEntryAtPath, makeFieldRenameBabelPlugin, renameIntlayerFieldAccesses } from "./babel-plugin-intlayer-field-rename.mjs";
+import { buildNestedRenameMapFromContent, generateShortFieldName, getNestedRenameEntryAtPath, makeFieldRenameBabelPlugin, renameIntlayerFieldAccesses, serializeFieldRenameMap } from "./babel-plugin-intlayer-field-rename.mjs";
 import { intlayerOptimizeBabelPlugin } from "./babel-plugin-intlayer-optimize.mjs";
 import { BABEL_PARSER_OPTIONS, INTLAYER_USAGE_REGEX, SOURCE_FILE_REGEX, analyzeFieldUsageInFile, buildUsageCheckRegex, getUsageCheckRegex, optimizeSourceFile, renameFieldsInCode, renameFieldsInSourceFile } from "./transformers.mjs";
-import { getSharedPruneContext, intlayerPurgeBabelPlugin } from "./babel-plugin-intlayer-purge.mjs";
+import { getSharedPruneContext, intlayerPurgeBabelPlugin, runIntlayerPurgePipeline } from "./babel-plugin-intlayer-purge.mjs";
 import { intlayerMinifyBabelPlugin } from "./babel-plugin-intlayer-minify.mjs";
 import { getOptimizePluginOptions } from "./getOptimizePluginOptions.mjs";
 import { getMinifyPluginOptions, getPurgePluginOptions } from "./getPurgePluginOptions.mjs";
 
-export { ATTRIBUTES_TO_EXTRACT, BABEL_PARSER_OPTIONS, DEFAULT_COMPAT_CALLERS, INTLAYER_CALLER_NAMES, INTLAYER_USAGE_REGEX, SERVER_CAPABLE_PACKAGES, SOURCE_FILE_REGEX, analyzeFieldUsageInFile, buildNestedRenameMapFromContent, buildUsageCheckRegex, createPruneContext, detectPackageName, extractContent, extractContentSync, extractDictionaryInfo, extractDictionaryKey, extractDictionaryKeyFromPath, extractScriptBlocks, generateKey, generateShortFieldName, getComponentName, getExtractPluginOptions, getMinifyPluginOptions, getNestedRenameEntryAtPath, getOptimizePluginOptions, getOutput, getPurgePluginOptions, getSharedPruneContext, getUsageCheckRegex, injectScriptBlocks, intlayerExtractBabelPlugin, intlayerMinifyBabelPlugin, intlayerOptimizeBabelPlugin, intlayerPurgeBabelPlugin, makeFieldRenameBabelPlugin, makeUsageAnalyzerBabelPlugin, mergeWithExistingMultilingualDictionary, mergeWithExistingPerLocaleDictionary, optimizeSourceFile, packageList, renameFieldsInCode, renameFieldsInSourceFile, renameIntlayerFieldAccesses, resolveContentFilePaths, writeContentHelper };
+export { ATTRIBUTES_TO_EXTRACT, BABEL_PARSER_OPTIONS, DEFAULT_COMPAT_CALLERS, INTLAYER_CALLER_NAMES, INTLAYER_USAGE_REGEX, SERVER_CAPABLE_PACKAGES, SOURCE_FILE_REGEX, analyzeFieldUsageInFile, buildNestedRenameMapFromContent, buildUsageCheckRegex, createPruneContext, detectPackageName, extractContent, extractContentSync, extractDictionaryInfo, extractDictionaryKey, extractDictionaryKeyFromPath, extractScriptBlocks, generateKey, generateShortFieldName, getComponentName, getExtractPluginOptions, getMinifyPluginOptions, getNestedRenameEntryAtPath, getOptimizePluginOptions, getOutput, getPurgePluginOptions, getSharedPruneContext, getUsageCheckRegex, injectScriptBlocks, intlayerExtractBabelPlugin, intlayerMinifyBabelPlugin, intlayerOptimizeBabelPlugin, intlayerPurgeBabelPlugin, makeFieldRenameBabelPlugin, makeUsageAnalyzerBabelPlugin, mergeWithExistingMultilingualDictionary, mergeWithExistingPerLocaleDictionary, optimizeSourceFile, packageList, preserveNestedDictionaryFields, renameFieldsInCode, renameFieldsInSourceFile, renameIntlayerFieldAccesses, resolveContentFilePaths, runIntlayerPurgePipeline, serializeFieldRenameMap, writeContentHelper };

package/dist/esm/transformers.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"transformers.mjs","names":[],"sources":["../../src/transformers.ts"],"sourcesContent":["import { type TransformOptions, transformAsync } from '@babel/core';\nimport { makeFieldRenameBabelPlugin } from './babel-plugin-intlayer-field-rename';\nimport {\n  intlayerOptimizeBabelPlugin,\n  type OptimizePluginOptions,\n} from './babel-plugin-intlayer-optimize';\nimport {\n  type CompatCallerConfig,\n  makeUsageAnalyzerBabelPlugin,\n  type PruneContext,\n} from './babel-plugin-intlayer-usage-analyzer';\nimport { extractScriptBlocks, injectScriptBlocks } from './extractScriptBlocks';\n\n// ── Shared Babel parser configuration ─────────────────────────────────────────\n\n/**\n * Babel parser options covering the superset of syntaxes used across all\n * supported frameworks (React / Vue / Svelte / Angular / …).\n */\nexport const BABEL_PARSER_OPTIONS: NonNullable<TransformOptions['parserOpts']> =\n  {\n    sourceType: 'module',\n    allowImportExportEverywhere: true,\n    plugins: [\n      'typescript',\n      'jsx',\n      'decorators-legacy',\n      'classProperties',\n      'objectRestSpread',\n      'asyncGenerators',\n      'functionBind',\n      'exportDefaultFrom',\n      'exportNamespaceFrom',\n      'dynamicImport',\n      'nullishCoalescingOperator',\n      'optionalChaining',\n    ],\n  };\n\n/**\n * Fast pre-check: matches files that could contain native intlayer calls\n * (`useIntlayer` / `getIntlayer`). Used by the optimize/transform pass, which\n * only rewrites native calls.\n */\nexport const INTLAYER_USAGE_REGEX = /\\b(use|get)Intlayer\\b/;\n\n/**\n * Builds a fast pre-check regex that matches files potentially containing\n * native intlayer calls and/or the given compat namespace caller names.\n *\n * The result is used to skip files that definitely contain none of the\n * relevant function names, avoiding unnecessary Babel parsing.\n *\n * Compat caller names are NOT hardcoded here — they are provided at runtime by\n * the compat adapter packages that configure the usage-analysis pipeline.\n *\n * @param extraCallerNames - Additional caller function names to match\n *   (e.g. `['useTranslation', 'getFixedT']` from `@intlayer/react-i18next`).\n * @returns A `RegExp` matching any of the native or provided caller names.\n */\nexport const buildUsageCheckRegex = (extraCallerNames?: string[]): RegExp => {\n  const callerNames = [\n    'useIntlayer',\n    'getIntlayer',\n    ...(extraCallerNames ?? []),\n  ];\n  const uniqueNames = [...new Set(callerNames)];\n  return new RegExp(`\\\\b(${uniqueNames.join('|')})\\\\b`);\n};\n\n/** Usage-check regex covering only the native callers (no compat callers). */\nconst NATIVE_USAGE_CHECK_REGEX = buildUsageCheckRegex();\n\n/** Cache of usage-check regexes, keyed by the compat-caller array reference. */\nconst usageCheckRegexCache = new WeakMap<\n  readonly CompatCallerConfig[],\n  RegExp\n>();\n\n/**\n * Returns the usage-check regex for the given compat callers, memoised by the\n * array reference. Plugins pass the same options array for every analysed\n * file, so the regex is built once per build instead of once per file.\n */\nexport const getUsageCheckRegex = (\n  compatCallers?: readonly CompatCallerConfig[]\n): RegExp => {\n  if (!compatCallers || compatCallers.length === 0) {\n    return NATIVE_USAGE_CHECK_REGEX;\n  }\n\n  let usageCheckRegex = usageCheckRegexCache.get(compatCallers);\n  if (!usageCheckRegex) {\n    usageCheckRegex = buildUsageCheckRegex(\n      compatCallers.map((caller) => caller.callerName)\n    );\n    usageCheckRegexCache.set(compatCallers, usageCheckRegex);\n  }\n  return usageCheckRegex;\n};\n\n/**\n * Matches source files that are valid targets for usage analysis and Babel\n * transformation. Excludes sourcemap files, declaration files, and other\n * non-source extensions.\n */\nexport const SOURCE_FILE_REGEX = /\\.(tsx?|[mc]?jsx?|vue|svelte|astro)$/;\n\n// ── High-level transformer functions ──────────────────────────────────────────\n\n/**\n * Runs the usage-analysis Babel plugin on a single JS/TS code string.\n *\n * This is analysis-only: the transformed code output is discarded.\n * Throws if Babel cannot parse the content.\n */\nconst analyzeScriptContent = async (\n  scriptContent: string,\n  sourceFilePath: string,\n  pruneContext: PruneContext,\n  compatCallers?: CompatCallerConfig[]\n): Promise<void> => {\n  await transformAsync(scriptContent, {\n    filename: sourceFilePath,\n    plugins: [makeUsageAnalyzerBabelPlugin(pruneContext, { compatCallers })],\n    parserOpts: BABEL_PARSER_OPTIONS,\n    ast: false,\n    code: false, // analysis only – no output needed\n  });\n};\n\n/**\n * Runs the usage-analysis Babel plugin on a source file, accumulating\n * field-usage data into `pruneContext`.\n *\n * For Vue / Svelte SFC files, script blocks are extracted before analysis so\n * Babel does not attempt to parse the full SFC syntax (templates, styles, …).\n * For plain JS/TS files, the whole file content is analysed directly.\n *\n * This is analysis-only: the transformed code output is discarded.\n * Throws if Babel cannot parse the file (caller should handle and flag\n * `pruneContext.hasUnparsableSourceFiles`).\n */\nexport const analyzeFieldUsageInFile = async (\n  sourceFilePath: string,\n  code: string,\n  pruneContext: PruneContext,\n  compatCallers?: CompatCallerConfig[]\n): Promise<void> => {\n  const usageCheckRegex = getUsageCheckRegex(compatCallers);\n  const scriptBlocks = extractScriptBlocks(sourceFilePath, code);\n\n  // For SFC files (Vue / Svelte): scriptBlocks[0].contentStartOffset > 0\n  // means we extracted actual <script> tags from the file.\n  // For plain JS/TS: extractScriptBlocks returns the whole file as a single\n  // block with offset 0, so we fall through to the same path.\n  for (const block of scriptBlocks) {\n    if (!usageCheckRegex.test(block.content)) continue;\n    await analyzeScriptContent(\n      block.content,\n      sourceFilePath,\n      pruneContext,\n      compatCallers\n    );\n  }\n};\n\n/**\n * Applies field-renaming to a single JS/TS code string (not an SFC).\n *\n * Returns the renamed code string, or `null` if nothing changed or if\n * Babel failed to parse the input (caller should fall back to original code).\n */\nexport const renameFieldsInCode = async (\n  code: string,\n  sourceFilePath: string,\n  pruneContext: PruneContext\n): Promise<string | null> => {\n  try {\n    const result = await transformAsync(code, {\n      filename: sourceFilePath,\n      plugins: [makeFieldRenameBabelPlugin(pruneContext)],\n      parserOpts: BABEL_PARSER_OPTIONS,\n      ast: false,\n    });\n    return result?.code ?? null;\n  } catch {\n    return null; // parse failure – caller falls back to original code\n  }\n};\n\n/**\n * Applies field-renaming to a source file, correctly handling both plain\n * JS/TS files and SFC files (Vue / Svelte) by operating on each script block\n * individually and injecting the results back into the original source.\n *\n * Returns the renamed code string, or `null` if nothing changed.\n */\nexport const renameFieldsInSourceFile = async (\n  sourceFilePath: string,\n  code: string,\n  pruneContext: PruneContext\n): Promise<string | null> => {\n  if (pruneContext.dictionaryKeyToFieldRenameMap.size === 0) return null;\n  if (!INTLAYER_USAGE_REGEX.test(code)) return null;\n\n  const scriptBlocks = extractScriptBlocks(sourceFilePath, code);\n\n  const isSFC =\n    scriptBlocks.length > 0 &&\n    ((scriptBlocks[0]?.contentStartOffset ?? 0) > 0 || scriptBlocks.length > 1);\n\n  if (isSFC) {\n    // Raw SFC: rename each script block individually and inject back.\n    const modifications: Array<{\n      block: (typeof scriptBlocks)[number];\n      modifiedContent: string;\n    }> = [];\n\n    for (const block of scriptBlocks) {\n      if (!INTLAYER_USAGE_REGEX.test(block.content)) continue;\n\n      const renamedCode = await renameFieldsInCode(\n        block.content,\n        sourceFilePath,\n        pruneContext\n      );\n      if (renamedCode && renamedCode !== block.content) {\n        modifications.push({ block, modifiedContent: renamedCode });\n      }\n    }\n\n    if (modifications.length === 0) return null;\n    return injectScriptBlocks(code, modifications);\n  }\n\n  // Plain JS/TS or compiled SFC (no block delimiters) – rename the whole file.\n  return renameFieldsInCode(code, sourceFilePath, pruneContext);\n};\n\n/**\n * Runs the intlayer optimize Babel plugin on a source file, transforming\n * `useIntlayer('key')` / `getIntlayer('key')` calls into `useDictionary(_hash)`\n * / `getDictionary(_hash)` and injecting the corresponding dictionary imports.\n *\n * Returns `{ code, map }` on success, or `null` if the transformation produced\n * no output.\n */\nexport const optimizeSourceFile = async (\n  code: string,\n  sourceFilePath: string,\n  options: OptimizePluginOptions\n): Promise<{\n  code: string;\n  map: string | object | null | undefined;\n} | null> => {\n  const result = await transformAsync(code, {\n    filename: sourceFilePath,\n    plugins: [[intlayerOptimizeBabelPlugin, options]],\n    parserOpts: BABEL_PARSER_OPTIONS,\n  });\n\n  if (!result?.code) return null;\n\n  return { code: result.code, map: result.map };\n};\n"],"mappings":"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"}
+{"version":3,"file":"transformers.mjs","names":[],"sources":["../../src/transformers.ts"],"sourcesContent":["import { transformAsync } from '@babel/core';\n// Typed from `@babel/parser` rather than `@babel/core`'s\n// `InputOptions['parserOpts']` (Babel 8's rename of `TransformOptions`): the\n// two describe the same shape, but naming `@babel/core` in an exported type\n// pulls its declaration file into every consumer's type-check, and that file\n// needs `@types/convert-source-map` to resolve.\nimport type { ParserOptions } from '@babel/parser';\nimport { makeFieldRenameBabelPlugin } from './babel-plugin-intlayer-field-rename';\nimport {\n  intlayerOptimizeBabelPlugin,\n  type OptimizePluginOptions,\n} from './babel-plugin-intlayer-optimize';\nimport {\n  type CompatCallerConfig,\n  makeUsageAnalyzerBabelPlugin,\n  type PruneContext,\n} from './babel-plugin-intlayer-usage-analyzer';\nimport { extractScriptBlocks, injectScriptBlocks } from './extractScriptBlocks';\n\n// ── Shared Babel parser configuration ─────────────────────────────────────────\n\n/**\n * Babel parser options covering the superset of syntaxes used across all\n * supported frameworks (React / Vue / Svelte / Angular / …).\n */\nexport const BABEL_PARSER_OPTIONS: ParserOptions = {\n  sourceType: 'module',\n  allowImportExportEverywhere: true,\n  plugins: [\n    'typescript',\n    'jsx',\n    'decorators-legacy',\n    'classProperties',\n    'objectRestSpread',\n    'asyncGenerators',\n    'functionBind',\n    'exportDefaultFrom',\n    'exportNamespaceFrom',\n    'dynamicImport',\n    'nullishCoalescingOperator',\n    'optionalChaining',\n  ],\n};\n\n/**\n * Fast pre-check: matches files that could contain native intlayer calls\n * (`useIntlayer` / `getIntlayer`). Used by the optimize/transform pass, which\n * only rewrites native calls.\n */\nexport const INTLAYER_USAGE_REGEX = /\\b(use|get)Intlayer\\b/;\n\n/**\n * Builds a fast pre-check regex that matches files potentially containing\n * native intlayer calls and/or the given compat namespace caller names.\n *\n * The result is used to skip files that definitely contain none of the\n * relevant function names, avoiding unnecessary Babel parsing.\n *\n * Compat caller names are NOT hardcoded here — they are provided at runtime by\n * the compat adapter packages that configure the usage-analysis pipeline.\n *\n * @param extraCallerNames - Additional caller function names to match\n *   (e.g. `['useTranslation', 'getFixedT']` from `@intlayer/react-i18next`).\n * @returns A `RegExp` matching any of the native or provided caller names.\n */\nexport const buildUsageCheckRegex = (extraCallerNames?: string[]): RegExp => {\n  const callerNames = [\n    'useIntlayer',\n    'getIntlayer',\n    ...(extraCallerNames ?? []),\n  ];\n  const uniqueNames = [...new Set(callerNames)];\n  return new RegExp(`\\\\b(${uniqueNames.join('|')})\\\\b`);\n};\n\n/** Usage-check regex covering only the native callers (no compat callers). */\nconst NATIVE_USAGE_CHECK_REGEX = buildUsageCheckRegex();\n\n/** Cache of usage-check regexes, keyed by the compat-caller array reference. */\nconst usageCheckRegexCache = new WeakMap<\n  readonly CompatCallerConfig[],\n  RegExp\n>();\n\n/**\n * Returns the usage-check regex for the given compat callers, memoised by the\n * array reference. Plugins pass the same options array for every analysed\n * file, so the regex is built once per build instead of once per file.\n */\nexport const getUsageCheckRegex = (\n  compatCallers?: readonly CompatCallerConfig[]\n): RegExp => {\n  if (!compatCallers || compatCallers.length === 0) {\n    return NATIVE_USAGE_CHECK_REGEX;\n  }\n\n  let usageCheckRegex = usageCheckRegexCache.get(compatCallers);\n  if (!usageCheckRegex) {\n    usageCheckRegex = buildUsageCheckRegex(\n      compatCallers.map((caller) => caller.callerName)\n    );\n    usageCheckRegexCache.set(compatCallers, usageCheckRegex);\n  }\n  return usageCheckRegex;\n};\n\n/**\n * Matches source files that are valid targets for usage analysis and Babel\n * transformation. Excludes sourcemap files, declaration files, and other\n * non-source extensions.\n */\nexport const SOURCE_FILE_REGEX = /\\.(tsx?|[mc]?jsx?|vue|svelte|astro)$/;\n\n// ── High-level transformer functions ──────────────────────────────────────────\n\n/**\n * Runs the usage-analysis Babel plugin on a single JS/TS code string.\n *\n * This is analysis-only: the transformed code output is discarded.\n * Throws if Babel cannot parse the content.\n */\nconst analyzeScriptContent = async (\n  scriptContent: string,\n  sourceFilePath: string,\n  pruneContext: PruneContext,\n  compatCallers?: CompatCallerConfig[]\n): Promise<void> => {\n  await transformAsync(scriptContent, {\n    filename: sourceFilePath,\n    plugins: [makeUsageAnalyzerBabelPlugin(pruneContext, { compatCallers })],\n    parserOpts: BABEL_PARSER_OPTIONS,\n    ast: false,\n    code: false, // analysis only – no output needed\n  });\n};\n\n/**\n * Runs the usage-analysis Babel plugin on a source file, accumulating\n * field-usage data into `pruneContext`.\n *\n * For Vue / Svelte SFC files, script blocks are extracted before analysis so\n * Babel does not attempt to parse the full SFC syntax (templates, styles, …).\n * For plain JS/TS files, the whole file content is analysed directly.\n *\n * This is analysis-only: the transformed code output is discarded.\n * Throws if Babel cannot parse the file (caller should handle and flag\n * `pruneContext.hasUnparsableSourceFiles`).\n */\nexport const analyzeFieldUsageInFile = async (\n  sourceFilePath: string,\n  code: string,\n  pruneContext: PruneContext,\n  compatCallers?: CompatCallerConfig[]\n): Promise<void> => {\n  const usageCheckRegex = getUsageCheckRegex(compatCallers);\n  const scriptBlocks = extractScriptBlocks(sourceFilePath, code);\n\n  // For SFC files (Vue / Svelte): scriptBlocks[0].contentStartOffset > 0\n  // means we extracted actual <script> tags from the file.\n  // For plain JS/TS: extractScriptBlocks returns the whole file as a single\n  // block with offset 0, so we fall through to the same path.\n  for (const block of scriptBlocks) {\n    if (!usageCheckRegex.test(block.content)) continue;\n    await analyzeScriptContent(\n      block.content,\n      sourceFilePath,\n      pruneContext,\n      compatCallers\n    );\n  }\n};\n\n/**\n * Applies field-renaming to a single JS/TS code string (not an SFC).\n *\n * Returns the renamed code string, or `null` if nothing changed or if\n * Babel failed to parse the input (caller should fall back to original code).\n */\nexport const renameFieldsInCode = async (\n  code: string,\n  sourceFilePath: string,\n  pruneContext: PruneContext\n): Promise<string | null> => {\n  try {\n    const result = await transformAsync(code, {\n      filename: sourceFilePath,\n      plugins: [makeFieldRenameBabelPlugin(pruneContext)],\n      parserOpts: BABEL_PARSER_OPTIONS,\n      ast: false,\n    });\n    return result?.code ?? null;\n  } catch {\n    return null; // parse failure – caller falls back to original code\n  }\n};\n\n/**\n * Applies field-renaming to a source file, correctly handling both plain\n * JS/TS files and SFC files (Vue / Svelte) by operating on each script block\n * individually and injecting the results back into the original source.\n *\n * Returns the renamed code string, or `null` if nothing changed.\n */\nexport const renameFieldsInSourceFile = async (\n  sourceFilePath: string,\n  code: string,\n  pruneContext: PruneContext\n): Promise<string | null> => {\n  if (pruneContext.dictionaryKeyToFieldRenameMap.size === 0) return null;\n  if (!INTLAYER_USAGE_REGEX.test(code)) return null;\n\n  const scriptBlocks = extractScriptBlocks(sourceFilePath, code);\n\n  const isSFC =\n    scriptBlocks.length > 0 &&\n    ((scriptBlocks[0]?.contentStartOffset ?? 0) > 0 || scriptBlocks.length > 1);\n\n  if (isSFC) {\n    // Raw SFC: rename each script block individually and inject back.\n    const modifications: Array<{\n      block: (typeof scriptBlocks)[number];\n      modifiedContent: string;\n    }> = [];\n\n    for (const block of scriptBlocks) {\n      if (!INTLAYER_USAGE_REGEX.test(block.content)) continue;\n\n      const renamedCode = await renameFieldsInCode(\n        block.content,\n        sourceFilePath,\n        pruneContext\n      );\n      if (renamedCode && renamedCode !== block.content) {\n        modifications.push({ block, modifiedContent: renamedCode });\n      }\n    }\n\n    if (modifications.length === 0) return null;\n    return injectScriptBlocks(code, modifications);\n  }\n\n  // Plain JS/TS or compiled SFC (no block delimiters) – rename the whole file.\n  return renameFieldsInCode(code, sourceFilePath, pruneContext);\n};\n\n/**\n * Runs the intlayer optimize Babel plugin on a source file, transforming\n * `useIntlayer('key')` / `getIntlayer('key')` calls into `useDictionary(_hash)`\n * / `getDictionary(_hash)` and injecting the corresponding dictionary imports.\n *\n * Returns `{ code, map }` on success, or `null` if the transformation produced\n * no output.\n */\nexport const optimizeSourceFile = async (\n  code: string,\n  sourceFilePath: string,\n  options: OptimizePluginOptions\n): Promise<{\n  code: string;\n  map: string | object | null | undefined;\n} | null> => {\n  const result = await transformAsync(code, {\n    filename: sourceFilePath,\n    plugins: [[intlayerOptimizeBabelPlugin, options]],\n    parserOpts: BABEL_PARSER_OPTIONS,\n  });\n\n  if (!result?.code) return null;\n\n  return { code: result.code, map: result.map };\n};\n"],"mappings":"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"}

package/dist/types/babel-plugin-intlayer-field-rename.d.ts

@@ -47,6 +47,34 @@ declare const buildNestedRenameMapFromContent: (contentValue: unknown) => Nested
  * @param fieldPath - Original (pre-rename) field names from the content root.
  */
 declare const getNestedRenameEntryAtPath: (renameMap: NestedRenameMap, fieldPath: readonly string[]) => NestedRenameEntry | undefined;
+/**
+ * JSON-serialisable form of a {@link NestedRenameEntry}.
+ *
+ * Mirrors `FieldRenameNode` in the `@intlayer/swc` crate — both sides must stay
+ * in sync.
+ */
+type SerializedFieldRenameEntry = {
+  /** Short alphabetic alias the field is renamed to (`'a'`, `'b'`, …). */
+  shortName: string;
+  /** Rename table of the fields nested inside this one. */
+  children: SerializedFieldRenameMap;
+};
+/** JSON-serialisable form of a {@link NestedRenameMap}. */
+type SerializedFieldRenameMap = Record<string, SerializedFieldRenameEntry>;
+/**
+ * Converts the field-rename tables of a {@link PruneContext} into a plain JSON
+ * object, keyed by dictionary key.
+ *
+ * Consumed by bundler integrations that cannot run the Babel rename plugin and
+ * must forward the tables to another transformer — currently the `@intlayer/swc`
+ * Wasm plugin used by Next.js, which rewrites the source accesses itself.
+ *
+ * Dictionaries flagged as structural edge cases are omitted: the JSON pipeline
+ * leaves them untouched, so their source accesses must stay untouched too.
+ * Empty tables are omitted as well, so the result is empty when there is
+ * nothing to rename.
+ */
+declare const serializeFieldRenameMap: (pruneContext: PruneContext) => Record<string, SerializedFieldRenameMap>;
 /**
  * Rewrites dictionary content field accesses in the given program to the
  * short aliases defined in `pruneContext.dictionaryKeyToFieldRenameMap`.
@@ -85,5 +113,5 @@ declare const makeFieldRenameBabelPlugin: (pruneContext: PruneContext) => ({ typ
   types: typeof BabelTypes;
 }) => PluginObject;
 //#endregion
-export { buildNestedRenameMapFromContent, generateShortFieldName, getNestedRenameEntryAtPath, makeFieldRenameBabelPlugin, renameIntlayerFieldAccesses };
+export { SerializedFieldRenameEntry, SerializedFieldRenameMap, buildNestedRenameMapFromContent, generateShortFieldName, getNestedRenameEntryAtPath, makeFieldRenameBabelPlugin, renameIntlayerFieldAccesses, serializeFieldRenameMap };
 //# sourceMappingURL=babel-plugin-intlayer-field-rename.d.ts.map

package/dist/types/babel-plugin-intlayer-field-rename.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"babel-plugin-intlayer-field-rename.d.ts","names":[],"sources":["../../src/babel-plugin-intlayer-field-rename.ts"],"mappings":";;;;;;;;cA0Ba,yBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA0CtB,kCAA+B,0BAEzC;;;;;;;;;;;;cA2EU,6BAA0B,WAC1B,iBAAe,iCAEzB;;;;;;;;;;;;;;;;;;;;;;;;;cAiSU,8BAA2B,mBACnB,YAAU,aAChB,SAAS,WAAW,UAAQ,cAC3B;;;;;;;;;;cA8IH,6BAA0B,cACtB,oBAAY,OAAA;EACD,cAAc;MAAe"}
+{"version":3,"file":"babel-plugin-intlayer-field-rename.d.ts","names":[],"sources":["../../src/babel-plugin-intlayer-field-rename.ts"],"mappings":";;;;;;;;cA0Ba,yBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA0CtB,kCAA+B,0BAEzC;;;;;;;;;;;;cA2EU,6BAA0B,WAC1B,iBAAe,iCAEzB;;;;;;;KAqBS;;EAEV;;EAEA,UAAU;;;KAIA,2BAA2B,eAErC;;;;;;;;;;;;;;cAgCW,0BAAuB,cACpB,iBACb,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;cAoSL,8BAA2B,mBACnB,YAAU,aAChB,SAAS,WAAW,UAAQ,cAC3B;;;;;;;;;;cA8IH,6BAA0B,cACtB,oBAAY,OAAA;EACD,cAAc;MAAe"}

package/dist/types/babel-plugin-intlayer-optimize.d.ts

@@ -47,6 +47,21 @@ type OptimizePluginOptions = {
    * If true, the plugin will replace the dictionary entry file with `export default {}`.
    */
   replaceDictionaryEntry: boolean;
+  /**
+   * Keys of the dictionaries that reference other dictionaries through
+   * `nest()`.
+   *
+   * For those, the injected static import points at the generated companion
+   * module (`<dictionariesDir>/nested/<key>.mjs`) instead of the raw JSON. The
+   * companion re-exports the dictionary with its nest targets attached, so
+   * `getNesting` resolves them from that local reference rather than from the
+   * global registry this plugin empties — and each target lands in the chunk of
+   * the dictionary referencing it.
+   *
+   * Dynamic and fetch modes need nothing here: their generated loaders already
+   * attach the same targets per locale.
+   */
+  nestingDictionaryKeys?: string[];
   /**
    * If true, the plugin will activate the dynamic import of the dictionaries. It will rely on Suspense to load the dictionaries.
    */

package/dist/types/babel-plugin-intlayer-optimize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"babel-plugin-intlayer-optimize.d.ts","names":[],"sources":["../../src/babel-plugin-intlayer-optimize.ts"],"mappings":";;;;cA6BM;;;;KAqDM;;;;EAIV;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA,oBAAoB;;;;EAOpB;;;;EAIA;;;;;;;;;;;;;;EAcA,gBAAgB;;KAGb,QAAQ;EACX,MAAM;;EAEN,oBAAoB,YAAY,WAAW;;EAE3C,qBAAqB,YAAY,WAAW;;EAE5C;;EAEA,aAAa,oBAAoB;;EAEjC,oBAAoB;;EAEpB,mBAAmB,YAAY;;EAE/B;;EAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA8RW,8BAA2B;EACtC,cAAc;MACZ,aAAa"}
+{"version":3,"file":"babel-plugin-intlayer-optimize.d.ts","names":[],"sources":["../../src/babel-plugin-intlayer-optimize.ts"],"mappings":";;;;cA8BM;;;;KAqDM;;;;EAIV;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;;;;;;;;;;;;EAeA;;;;EAIA;;;;EAIA,oBAAoB;;;;EAOpB;;;;EAIA;;;;;;;;;;;;;;EAcA,gBAAgB;;KAGb,QAAQ;EACX,MAAM;;EAEN,oBAAoB,YAAY,WAAW;;EAE3C,qBAAqB,YAAY,WAAW;;EAE5C;;EAEA,aAAa,oBAAoB;;EAEjC,oBAAoB;;EAEpB,mBAAmB,YAAY;;EAE/B;;EAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAiTW,8BAA2B;EACtC,cAAc;MACZ,aAAa"}

package/dist/types/babel-plugin-intlayer-purge.d.ts

@@ -1,6 +1,8 @@
 import { CompatCallerConfig, PruneContext } from "./babel-plugin-intlayer-usage-analyzer.js";
 import { PluginObject } from "@babel/core";
 import * as BabelTypes from "@babel/types";
+import { IntlayerConfig } from "@intlayer/types/config";
+import { NestedFieldReferences } from "@intlayer/core/dictionaryManipulator";
 //#region src/babel-plugin-intlayer-purge.d.ts
 /**
  * Pre-resolved options accepted by {@link intlayerPurgeBabelPlugin}.
@@ -54,6 +56,14 @@ type PurgePluginOptions = {
    * `content` glob patterns.
    */
   componentFilesList: string[];
+  /**
+   * Dictionaries referenced through `nest()`, mapped to the top-level fields
+   * those references read (`'all'` when the whole dictionary is nested).
+   *
+   * Those fields are resolved at runtime by `getNesting` using their original
+   * names, so they must survive purging and must never be renamed.
+   */
+  nestedDictionaryReferences?: Map<string, NestedFieldReferences>;
   /**
    * Per-dictionary import-mode overrides, keyed by dictionary `key`.
    * Dictionaries with mode `'fetch'` are excluded from field renaming because
@@ -72,6 +82,13 @@ type PurgePluginOptions = {
    * Defaults to `[]` (no compat callers) when omitted.
    */
   compatCallers?: CompatCallerConfig[];
+  /**
+   * Logging configuration used to report what the pipeline purged and
+   * minified, so a Babel- or SWC-driven build prints the same summary as the
+   * Vite one.  Mirrors `log` in `intlayer.config.ts`; omit to fall back to the
+   * logger defaults.
+   */
+  logConfig?: Pick<IntlayerConfig, 'log'>;
 };
 /**
  * Returns the shared {@link PruneContext} for the given base directory, or
@@ -82,6 +99,24 @@ type PurgePluginOptions = {
  * creating a circular dependency.
  */
 declare const getSharedPruneContext: (baseDir: string) => PruneContext | null;
+/**
+ * Runs the full purge/minify pipeline for the given options, using a
+ * module-level cache so the work happens at most once per process per
+ * unique `baseDir`.
+ *
+ * Exported so bundler integrations that do not go through Babel can drive the
+ * same pipeline. The Next.js integration is the main consumer: its SWC plugin
+ * runs as a per-file Wasm transform with no filesystem access, so the analysis
+ * and the dictionary rewrite happen here, in Node, and only the resulting
+ * field-rename tables (see {@link serializeFieldRenameMap}) are forwarded to
+ * the plugin.
+ *
+ * **This performs file I/O**: it reads every source file listed in
+ * `componentFilesList` and overwrites the compiled dictionary JSON files
+ * in-place. Call it at most once per build, after the dictionaries have been
+ * built.
+ */
+declare const runIntlayerPurgePipeline: (options: PurgePluginOptions) => PruneContext;
 /**
  * Babel plugin that analyses all project source files and rewrites compiled
  * dictionary JSON files in-place to remove unused content fields
@@ -134,5 +169,5 @@ declare const intlayerPurgeBabelPlugin: (_babel: {
   types: typeof BabelTypes;
 }) => PluginObject;
 //#endregion
-export { PurgePluginOptions, getSharedPruneContext, intlayerPurgeBabelPlugin };
+export { PurgePluginOptions, getSharedPruneContext, intlayerPurgeBabelPlugin, runIntlayerPurgePipeline };
 //# sourceMappingURL=babel-plugin-intlayer-purge.d.ts.map

package/dist/types/babel-plugin-intlayer-purge.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"babel-plugin-intlayer-purge.d.ts","names":[],"sources":["../../src/babel-plugin-intlayer-purge.ts"],"mappings":";;;;;;;;;;;KAgCY;;;;;;EAMV;;;;;EAMA;;;;;;EAOA;;;;;;EAOA;;;;;EAMA;;;;;EAMA;;;;;EAMA;;;;;;EAOA;;;;;;EAOA,8BAA8B;;;;;;;;;;;;EAgB9B,gBAAgB;;;;;;;;;;cAqBL,wBAAqB,oBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwjB3C,2BAAwB;EACnC,cAAc;MACZ"}
+{"version":3,"file":"babel-plugin-intlayer-purge.d.ts","names":[],"sources":["../../src/babel-plugin-intlayer-purge.ts"],"mappings":";;;;;;;;;;;;;KA2CY;;;;;;EAMV;;;;;EAMA;;;;;;EAOA;;;;;;EAOA;;;;;EAMA;;;;;EAMA;;;;;EAMA;;;;;;EAOA;;;;;;;;EASA,6BAA6B,YAAY;;;;;;EAOzC,8BAA8B;;;;;;;;;;;;EAgB9B,gBAAgB;;;;;;;EAQhB,YAAY,KAAK;;;;;;;;;;cAwBN,wBAAqB,oBAAsB;;;;;;;;;;;;;;;;;;cAssB3C,2BAAwB,SAC1B,uBACR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA2HU,2BAAwB;EACnC,cAAc;MACZ"}

package/dist/types/babel-plugin-intlayer-usage-analyzer.d.ts

@@ -1,6 +1,7 @@
 import { PluginObject } from "@babel/core";
 import * as BabelTypes from "@babel/types";
 import { CallerDescriptor, CallerDescriptor as CallerDescriptor$1, CallerResultShape, CallerValueSource } from "@intlayer/config/callers";
+import { NestedFieldReferences } from "@intlayer/core/dictionaryManipulator";
 //#region src/babel-plugin-intlayer-usage-analyzer.d.ts
 /**
  * Dictionary field usage result for a single dictionary key.
@@ -117,6 +118,34 @@ type PruneContext = {
   }[]>;
 };
 declare const createPruneContext: () => PruneContext;
+/**
+ * Records `nest()` references in a prune context so nest targets stay
+ * resolvable — and no larger than they need to be — after purge and minify.
+ *
+ * A nested node stores the ORIGINAL dot path of the field it reads
+ * (`nest('common', 'period')` → `'period'`) and `getNesting` resolves it at
+ * runtime against the compiled JSON. That drives three adjustments:
+ *
+ * - Nest targets never take part in field renaming, since the stored path
+ *   would no longer match the renamed keys.
+ * - A target already consumed by a call site keeps its analysed fields plus
+ *   the nested ones, so neither consumer loses content.
+ * - A target reached *only* through `nest()` is given a usage entry holding
+ *   exactly the nested fields. Without one, the purge pass leaves the whole
+ *   dictionary untouched; with one, it trims the dictionary down to what the
+ *   nest references actually read. This matters most for `dynamic` / `fetch`
+ *   dictionaries, whose full static snapshot would otherwise be pulled into
+ *   the eager bundle just to satisfy a single nested field.
+ *
+ * Seeding is skipped when a source file failed to parse: that file could
+ * reference the dictionary in a way the analysis never saw, which is the same
+ * guard the purge pass applies to keys with no usage entry.
+ *
+ * @param pruneContext - Shared analysis state to update in place.
+ * @param nestedDictionaryReferences - Nest-target key → referenced top-level
+ *   fields, as returned by `getNestedDictionaryReferences`.
+ */
+declare const preserveNestedDictionaryFields: (pruneContext: PruneContext, nestedDictionaryReferences: Map<string, NestedFieldReferences>) => void;
 /** Canonical intlayer caller names that trigger usage analysis. */
 declare const INTLAYER_CALLER_NAMES: readonly ['useIntlayer', 'getIntlayer'];
 type IntlayerCallerName = (typeof INTLAYER_CALLER_NAMES)[number];
@@ -158,5 +187,5 @@ declare const makeUsageAnalyzerBabelPlugin: (pruneContext: PruneContext, options
   types: typeof BabelTypes;
 }) => PluginObject;
 //#endregion
-export { type CallerDescriptor, type CallerResultShape, type CallerValueSource, CompatCallerConfig, DEFAULT_COMPAT_CALLERS, DictionaryFieldUsage, INTLAYER_CALLER_NAMES, IntlayerCallerName, NestedRenameEntry, NestedRenameMap, OpaqueFieldOccurrence, PruneContext, createPruneContext, makeUsageAnalyzerBabelPlugin };
+export { type CallerDescriptor, type CallerResultShape, type CallerValueSource, CompatCallerConfig, DEFAULT_COMPAT_CALLERS, DictionaryFieldUsage, INTLAYER_CALLER_NAMES, IntlayerCallerName, NestedRenameEntry, NestedRenameMap, OpaqueFieldOccurrence, PruneContext, createPruneContext, makeUsageAnalyzerBabelPlugin, preserveNestedDictionaryFields };
 //# sourceMappingURL=babel-plugin-intlayer-usage-analyzer.d.ts.map

package/dist/types/babel-plugin-intlayer-usage-analyzer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"babel-plugin-intlayer-usage-analyzer.d.ts","names":[],"sources":["../../src/babel-plugin-intlayer-usage-analyzer.ts"],"mappings":";;;;;;;;;;;KAgBY,uBAAuB;;;;;;;;KASvB;EACV;EACA,UAAU;;;KAIA,kBAAkB,YAAY;;;;;;;KAQ9B;;;;;;EAMV;;EAGA;;;;;;;;;KAUU;;;;;;EAMV,8BAA8B,YAAY;;;;;EAM1C,2BAA2B;;;;;;EAO3B;;;;;;EAOA,qCAAqC;;;;;;EAOrC,+BAA+B,YAAY;;;;;;;;;;;;EAa3C,gCAAgC,YAE9B,YAAY;;;;;;;;;;;;;EAed,iCAAiC;;;;;;;;;;;EAYjC,0BAA0B;IAEtB;IAAsB;;;cAIf,0BAAyB;;cAiBzB;KACD,6BAA6B;;;;;;;KAmB7B,qBAAqB;;;;;;;;;;;cAYpB,wBAAwB;;;;;;;;;;;;;;;cAmiCxB,+BAA4B,cAEvB,cAAY;EACd,gBAAgB;SAAsB,OAAA;EAE1B,cAAc;MAAe"}
+{"version":3,"file":"babel-plugin-intlayer-usage-analyzer.d.ts","names":[],"sources":["../../src/babel-plugin-intlayer-usage-analyzer.ts"],"mappings":";;;;;;;;;;;;KAiBY,uBAAuB;;;;;;;;KASvB;EACV;EACA,UAAU;;;KAIA,kBAAkB,YAAY;;;;;;;KAQ9B;;;;;;EAMV;;EAGA;;;;;;;;;KAUU;;;;;;EAMV,8BAA8B,YAAY;;;;;EAM1C,2BAA2B;;;;;;EAO3B;;;;;;EAOA,qCAAqC;;;;;;EAOrC,+BAA+B,YAAY;;;;;;;;;;;;EAa3C,gCAAgC,YAE9B,YAAY;;;;;;;;;;;;;EAed,iCAAiC;;;;;;;;;;;EAYjC,0BAA0B;IAEtB;IAAsB;;;cAIf,0BAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAyCzB,iCAA8B,cAC3B,cAAY,4BACE,YAAY;;cAwC7B;KACD,6BAA6B;;;;;;;KAmB7B,qBAAqB;;;;;;;;;;;cAYpB,wBAAwB;;;;;;;;;;;;;;;cAmiCxB,+BAA4B,cAEvB,cAAY;EACd,gBAAgB;SAAsB,OAAA;EAE1B,cAAc;MAAe"}

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

@@ -1 +1 @@
-{"version":3,"file":"getOptimizePluginOptions.d.ts","names":[],"sources":["../../src/getOptimizePluginOptions.ts"],"mappings":";;;;KAUK;;;;EAIH,gBAAgB;;;;EAIhB,eAAe;;;;;;EAMf;;;;EAIA,YAAY,QAAQ;;;;;;;cAyBT,2BAAwB,SAC1B,mCACR"}
+{"version":3,"file":"getOptimizePluginOptions.d.ts","names":[],"sources":["../../src/getOptimizePluginOptions.ts"],"mappings":";;;;KAWK;;;;EAIH,gBAAgB;;;;EAIhB,eAAe;;;;;;EAMf;;;;EAIA,YAAY,QAAQ;;;;;;;cAyBT,2BAAwB,SAC1B,mCACR"}

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

@@ -1 +1 @@
-{"version":3,"file":"getPurgePluginOptions.d.ts","names":[],"sources":["../../src/getPurgePluginOptions.ts"],"mappings":";;;;;KAkCK;;;;;;EAMH,gBAAgB;;;;;;EAOhB,eAAe;;;;EAKf,YAAY,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;cA0BT,wBAAqB,SACvB,gCACR;KA4CE;;;;EAIH,gBAAgB;;;;EAKhB,YAAY,QAAQ;;;;;;;;;;;;;;;;;;;;;;;cAwBT,yBAAsB,SACxB,iCACR"}
+{"version":3,"file":"getPurgePluginOptions.d.ts","names":[],"sources":["../../src/getPurgePluginOptions.ts"],"mappings":";;;;;KAmCK;;;;;;EAMH,gBAAgB;;;;;;EAOhB,eAAe;;;;EAKf,YAAY,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;cA0BT,wBAAqB,SACvB,gCACR;KA8CE;;;;EAIH,gBAAgB;;;;EAKhB,YAAY,QAAQ;;;;;;;;;;;;;;;;;;;;;;;cAwBT,yBAAsB,SACxB,iCACR"}

package/dist/types/index.d.ts

@@ -1,10 +1,10 @@
 import { ATTRIBUTES_TO_EXTRACT, PackageName, SERVER_CAPABLE_PACKAGES, packageList } from "./extractContent/utils/constants.js";
 import { ExtractPluginOptions, ExtractResult, intlayerExtractBabelPlugin } from "./babel-plugin-intlayer-extract.js";
-import { CallerDescriptor, CallerResultShape, CallerValueSource, CompatCallerConfig, DEFAULT_COMPAT_CALLERS, DictionaryFieldUsage, INTLAYER_CALLER_NAMES, IntlayerCallerName, NestedRenameEntry, NestedRenameMap, OpaqueFieldOccurrence, PruneContext, createPruneContext, makeUsageAnalyzerBabelPlugin } from "./babel-plugin-intlayer-usage-analyzer.js";
-import { buildNestedRenameMapFromContent, generateShortFieldName, getNestedRenameEntryAtPath, makeFieldRenameBabelPlugin, renameIntlayerFieldAccesses } from "./babel-plugin-intlayer-field-rename.js";
+import { CallerDescriptor, CallerResultShape, CallerValueSource, CompatCallerConfig, DEFAULT_COMPAT_CALLERS, DictionaryFieldUsage, INTLAYER_CALLER_NAMES, IntlayerCallerName, NestedRenameEntry, NestedRenameMap, OpaqueFieldOccurrence, PruneContext, createPruneContext, makeUsageAnalyzerBabelPlugin, preserveNestedDictionaryFields } from "./babel-plugin-intlayer-usage-analyzer.js";
+import { SerializedFieldRenameEntry, SerializedFieldRenameMap, buildNestedRenameMapFromContent, generateShortFieldName, getNestedRenameEntryAtPath, makeFieldRenameBabelPlugin, renameIntlayerFieldAccesses, serializeFieldRenameMap } from "./babel-plugin-intlayer-field-rename.js";
 import { MinifyPluginOptions, intlayerMinifyBabelPlugin } from "./babel-plugin-intlayer-minify.js";
 import { OptimizePluginOptions, intlayerOptimizeBabelPlugin } from "./babel-plugin-intlayer-optimize.js";
-import { PurgePluginOptions, getSharedPruneContext, intlayerPurgeBabelPlugin } from "./babel-plugin-intlayer-purge.js";
+import { PurgePluginOptions, getSharedPruneContext, intlayerPurgeBabelPlugin, runIntlayerPurgePipeline } from "./babel-plugin-intlayer-purge.js";
 import { detectPackageName } from "./extractContent/utils/detectPackageName.js";
 import { ExtractDictionaryInfoOptions, ResolveContentFilePaths, extractDictionaryInfo, getOutput, resolveContentFilePaths } from "./extractContent/utils/extractDictionaryInfo.js";
 import { extractDictionaryKey, extractDictionaryKeyFromPath } from "./extractContent/utils/extractDictionaryKey.js";
@@ -18,4 +18,4 @@ import { CompilerMode, getExtractPluginOptions } from "./getExtractPluginOptions
 import { getOptimizePluginOptions } from "./getOptimizePluginOptions.js";
 import { getMinifyPluginOptions, getPurgePluginOptions } from "./getPurgePluginOptions.js";
 import { BABEL_PARSER_OPTIONS, INTLAYER_USAGE_REGEX, SOURCE_FILE_REGEX, analyzeFieldUsageInFile, buildUsageCheckRegex, getUsageCheckRegex, optimizeSourceFile, renameFieldsInCode, renameFieldsInSourceFile } from "./transformers.js";
-export { ATTRIBUTES_TO_EXTRACT, BABEL_PARSER_OPTIONS, type CallerDescriptor, type CallerResultShape, type CallerValueSource, CompatCallerConfig, CompilerMode, DEFAULT_COMPAT_CALLERS, DictionaryFieldUsage, ExtractDictionaryInfoOptions, ExtractIntlayerOptions, ExtractPluginOptions, ExtractResult, INTLAYER_CALLER_NAMES, INTLAYER_USAGE_REGEX, IntlayerCallerName, MinifyPluginOptions, NestedRenameEntry, NestedRenameMap, OpaqueFieldOccurrence, OptimizePluginOptions, PackageName, PruneContext, PurgePluginOptions, ResolveContentFilePaths, SERVER_CAPABLE_PACKAGES, SOURCE_FILE_REGEX, ScriptBlock, analyzeFieldUsageInFile, buildNestedRenameMapFromContent, buildUsageCheckRegex, createPruneContext, detectPackageName, extractContent, extractContentSync, extractDictionaryInfo, extractDictionaryKey, extractDictionaryKeyFromPath, extractScriptBlocks, generateKey, generateShortFieldName, getComponentName, getExtractPluginOptions, getMinifyPluginOptions, getNestedRenameEntryAtPath, getOptimizePluginOptions, getOutput, getPurgePluginOptions, getSharedPruneContext, getUsageCheckRegex, injectScriptBlocks, intlayerExtractBabelPlugin, intlayerMinifyBabelPlugin, intlayerOptimizeBabelPlugin, intlayerPurgeBabelPlugin, makeFieldRenameBabelPlugin, makeUsageAnalyzerBabelPlugin, mergeWithExistingMultilingualDictionary, mergeWithExistingPerLocaleDictionary, optimizeSourceFile, packageList, renameFieldsInCode, renameFieldsInSourceFile, renameIntlayerFieldAccesses, resolveContentFilePaths, writeContentHelper };
+export { ATTRIBUTES_TO_EXTRACT, BABEL_PARSER_OPTIONS, type CallerDescriptor, type CallerResultShape, type CallerValueSource, CompatCallerConfig, CompilerMode, DEFAULT_COMPAT_CALLERS, DictionaryFieldUsage, ExtractDictionaryInfoOptions, ExtractIntlayerOptions, ExtractPluginOptions, ExtractResult, INTLAYER_CALLER_NAMES, INTLAYER_USAGE_REGEX, IntlayerCallerName, MinifyPluginOptions, NestedRenameEntry, NestedRenameMap, OpaqueFieldOccurrence, OptimizePluginOptions, PackageName, PruneContext, PurgePluginOptions, ResolveContentFilePaths, SERVER_CAPABLE_PACKAGES, SOURCE_FILE_REGEX, ScriptBlock, SerializedFieldRenameEntry, SerializedFieldRenameMap, analyzeFieldUsageInFile, buildNestedRenameMapFromContent, buildUsageCheckRegex, createPruneContext, detectPackageName, extractContent, extractContentSync, extractDictionaryInfo, extractDictionaryKey, extractDictionaryKeyFromPath, extractScriptBlocks, generateKey, generateShortFieldName, getComponentName, getExtractPluginOptions, getMinifyPluginOptions, getNestedRenameEntryAtPath, getOptimizePluginOptions, getOutput, getPurgePluginOptions, getSharedPruneContext, getUsageCheckRegex, injectScriptBlocks, intlayerExtractBabelPlugin, intlayerMinifyBabelPlugin, intlayerOptimizeBabelPlugin, intlayerPurgeBabelPlugin, makeFieldRenameBabelPlugin, makeUsageAnalyzerBabelPlugin, mergeWithExistingMultilingualDictionary, mergeWithExistingPerLocaleDictionary, optimizeSourceFile, packageList, preserveNestedDictionaryFields, renameFieldsInCode, renameFieldsInSourceFile, renameIntlayerFieldAccesses, resolveContentFilePaths, runIntlayerPurgePipeline, serializeFieldRenameMap, writeContentHelper };

package/dist/types/transformers.d.ts

@@ -1,12 +1,12 @@
 import { CompatCallerConfig, PruneContext } from "./babel-plugin-intlayer-usage-analyzer.js";
 import { OptimizePluginOptions } from "./babel-plugin-intlayer-optimize.js";
-import { TransformOptions } from "@babel/core";
+import { ParserOptions } from "@babel/parser";
 //#region src/transformers.d.ts
 /**
  * Babel parser options covering the superset of syntaxes used across all
  * supported frameworks (React / Vue / Svelte / Angular / …).
  */
-declare const BABEL_PARSER_OPTIONS: NonNullable<TransformOptions['parserOpts']>;
+declare const BABEL_PARSER_OPTIONS: ParserOptions;
 /**
  * Fast pre-check: matches files that could contain native intlayer calls
  * (`useIntlayer` / `getIntlayer`). Used by the optimize/transform pass, which

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

@@ -1 +1 @@
-{"version":3,"file":"transformers.d.ts","names":[],"sources":["../../src/transformers.ts"],"mappings":";;;;;;;;cAmBa,sBAAsB,YAAY;;;;;;cAyBlC,sBAAoB;;;;;;;;;;;;;;;cAgBpB,uBAAoB,gCAAkC;;;;;;cAwBtD,qBAAkB,yBACJ,yBACxB;;;;;;cAoBU,mBAAiB;;;;;;;;;;;;;cAqCjB,0BAAuB,wBACZ,cACV,cACE,cAAY,gBACV,yBACf;;;;;;;cAyBU,qBAAkB,cACjB,wBACU,cACR,iBACb;;;;;;;;cAqBU,2BAAwB,wBACb,cACV,cACE,iBACb;;;;;;;;;cA8CU,qBAAkB,cACjB,wBACU,SACb,0BACR;EACD;EACA"}
+{"version":3,"file":"transformers.d.ts","names":[],"sources":["../../src/transformers.ts"],"mappings":";;;;;;;;cAyBa,sBAAsB;;;;;;cAwBtB,sBAAoB;;;;;;;;;;;;;;;cAgBpB,uBAAoB,gCAAkC;;;;;;cAwBtD,qBAAkB,yBACJ,yBACxB;;;;;;cAoBU,mBAAiB;;;;;;;;;;;;;cAqCjB,0BAAuB,wBACZ,cACV,cACE,cAAY,gBACV,yBACf;;;;;;;cAyBU,qBAAkB,cACjB,wBACU,cACR,iBACb;;;;;;;;cAqBU,2BAAwB,wBACb,cACV,cACE,iBACb;;;;;;;;;cA8CU,qBAAkB,cACjB,wBACU,SACb,0BACR;EACD;EACA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intlayer/babel",
-  "version": "9.2.0",
+  "version": "9.3.1",
   "private": false,
   "description": "A Babel plugin for Intlayer that transforms declaration files and provides internationalization features during the build process according to the Intlayer configuration.",
   "keywords": [
@@ -89,19 +89,19 @@
     "@babel/plugin-syntax-jsx": "8.0.1",
     "@babel/traverse": "8.0.4",
     "@babel/types": "8.0.4",
-    "@intlayer/config": "9.2.0",
-    "@intlayer/core": "9.2.0",
-    "@intlayer/dictionaries-entry": "9.2.0",
-    "@intlayer/engine": "9.2.0",
-    "@intlayer/types": "9.2.0",
-    "@intlayer/unmerged-dictionaries-entry": "9.2.0"
+    "@intlayer/config": "9.3.1",
+    "@intlayer/core": "9.3.1",
+    "@intlayer/dictionaries-entry": "9.3.1",
+    "@intlayer/engine": "9.3.1",
+    "@intlayer/types": "9.3.1",
+    "@intlayer/unmerged-dictionaries-entry": "9.3.1"
   },
   "devDependencies": {
     "@babel/plugin-syntax-jsx": "8.0.1",
     "@types/babel__core": "7.20.5",
     "@types/babel__generator": "7.27.0",
     "@types/babel__traverse": "7.28.0",
-    "@types/node": "26.1.2",
+    "@types/node": "26.2.0",
     "@utils/ts-config": "1.0.4",
     "@utils/ts-config-types": "1.0.4",
     "@utils/tsdown-config": "1.0.4",
@@ -112,8 +112,8 @@
     "vitest": "4.1.10"
   },
   "peerDependencies": {
-    "@intlayer/svelte-compiler": "9.2.0",
-    "@intlayer/vue-compiler": "9.2.0"
+    "@intlayer/svelte-compiler": "9.3.1",
+    "@intlayer/vue-compiler": "9.3.1"
   },
   "peerDependenciesMeta": {
     "@intlayer/svelte-compiler": {