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

package/dist/esm/normalizedFilesList.mjs

@@ -0,0 +1,29 @@
+import { normalizePath } from "@intlayer/config/utils";
+
+//#region src/normalizedFilesList.ts
+/**
+* Cache of normalized files-list sets, keyed by the files-list array
+* reference. Babel reuses the same plugin options object for every file of a
+* build, so the (potentially large) list is normalized once per build instead
+* of once per transformed file.
+*/
+const normalizedFilesListCache = /* @__PURE__ */ new WeakMap();
+/**
+* Returns a set of POSIX-normalized paths for the given files list, computed
+* once per unique array reference.
+*
+* @param filesList - The plugin's `filesList` option (absolute file paths).
+* @returns A set of the same paths normalized via `normalizePath`.
+*/
+const getNormalizedFilesListSet = (filesList) => {
+	let normalizedSet = normalizedFilesListCache.get(filesList);
+	if (!normalizedSet) {
+		normalizedSet = new Set(filesList.map(normalizePath));
+		normalizedFilesListCache.set(filesList, normalizedSet);
+	}
+	return normalizedSet;
+};
+
+//#endregion
+export { getNormalizedFilesListSet };
+//# sourceMappingURL=normalizedFilesList.mjs.map

package/dist/esm/normalizedFilesList.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizedFilesList.mjs","names":[],"sources":["../../src/normalizedFilesList.ts"],"sourcesContent":["import { normalizePath } from '@intlayer/config/utils';\n\n/**\n * Cache of normalized files-list sets, keyed by the files-list array\n * reference. Babel reuses the same plugin options object for every file of a\n * build, so the (potentially large) list is normalized once per build instead\n * of once per transformed file.\n */\nconst normalizedFilesListCache = new WeakMap<readonly string[], Set<string>>();\n\n/**\n * Returns a set of POSIX-normalized paths for the given files list, computed\n * once per unique array reference.\n *\n * @param filesList - The plugin's `filesList` option (absolute file paths).\n * @returns A set of the same paths normalized via `normalizePath`.\n */\nexport const getNormalizedFilesListSet = (\n  filesList: readonly string[]\n): Set<string> => {\n  let normalizedSet = normalizedFilesListCache.get(filesList);\n\n  if (!normalizedSet) {\n    normalizedSet = new Set(filesList.map(normalizePath));\n    normalizedFilesListCache.set(filesList, normalizedSet);\n  }\n\n  return normalizedSet;\n};\n"],"mappings":";;;;;;;;;AAQA,MAAM,2CAA2B,IAAI,QAAwC;;;;;;;;AAS7E,MAAa,6BACX,cACgB;CAChB,IAAI,gBAAgB,yBAAyB,IAAI,SAAS;CAE1D,IAAI,CAAC,eAAe;EAClB,gBAAgB,IAAI,IAAI,UAAU,IAAI,aAAa,CAAC;EACpD,yBAAyB,IAAI,WAAW,aAAa;CACvD;CAEA,OAAO;AACT"}

package/dist/esm/transformers.mjs

@@ -56,6 +56,24 @@ const buildUsageCheckRegex = (extraCallerNames) => {
 	const uniqueNames = [...new Set(callerNames)];
 	return new RegExp(`\\b(${uniqueNames.join("|")})\\b`);
 };
+/** Usage-check regex covering only the native callers (no compat callers). */
+const NATIVE_USAGE_CHECK_REGEX = buildUsageCheckRegex();
+/** Cache of usage-check regexes, keyed by the compat-caller array reference. */
+const usageCheckRegexCache = /* @__PURE__ */ new WeakMap();
+/**
+* Returns the usage-check regex for the given compat callers, memoised by the
+* array reference. Plugins pass the same options array for every analysed
+* file, so the regex is built once per build instead of once per file.
+*/
+const getUsageCheckRegex = (compatCallers) => {
+	if (!compatCallers || compatCallers.length === 0) return NATIVE_USAGE_CHECK_REGEX;
+	let usageCheckRegex = usageCheckRegexCache.get(compatCallers);
+	if (!usageCheckRegex) {
+		usageCheckRegex = buildUsageCheckRegex(compatCallers.map((caller) => caller.callerName));
+		usageCheckRegexCache.set(compatCallers, usageCheckRegex);
+	}
+	return usageCheckRegex;
+};
 /**
 * Matches source files that are valid targets for usage analysis and Babel
 * transformation. Excludes sourcemap files, declaration files, and other
@@ -90,7 +108,7 @@ const analyzeScriptContent = async (scriptContent, sourceFilePath, pruneContext,
 * `pruneContext.hasUnparsableSourceFiles`).
 */
 const analyzeFieldUsageInFile = async (sourceFilePath, code, pruneContext, compatCallers) => {
-	const usageCheckRegex = buildUsageCheckRegex((compatCallers ?? []).map((caller) => caller.callerName));
+	const usageCheckRegex = getUsageCheckRegex(compatCallers);
 	const scriptBlocks = extractScriptBlocks(sourceFilePath, code);
 	for (const block of scriptBlocks) {
 		if (!usageCheckRegex.test(block.content)) continue;
@@ -163,5 +181,5 @@ const optimizeSourceFile = async (code, sourceFilePath, options) => {
 };
 
 //#endregion
-export { BABEL_PARSER_OPTIONS, INTLAYER_USAGE_REGEX, SOURCE_FILE_REGEX, analyzeFieldUsageInFile, buildUsageCheckRegex, optimizeSourceFile, renameFieldsInCode, renameFieldsInSourceFile };
+export { BABEL_PARSER_OPTIONS, INTLAYER_USAGE_REGEX, SOURCE_FILE_REGEX, analyzeFieldUsageInFile, buildUsageCheckRegex, getUsageCheckRegex, optimizeSourceFile, renameFieldsInCode, renameFieldsInSourceFile };
 //# sourceMappingURL=transformers.mjs.map

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/**\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 extraCallerNames = (compatCallers ?? []).map(\n    (caller) => caller.callerName\n  );\n  const usageCheckRegex = buildUsageCheckRegex(extraCallerNames);\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":";;;;;;;;;;;AAmBA,MAAa,uBACX;CACE,YAAY;CACZ,6BAA6B;CAC7B,SAAS;EACP;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACD;CACF;;;;;;AAOH,MAAa,uBAAuB;;;;;;;;;;;;;;;AAgBpC,MAAa,wBAAwB,qBAAwC;CAC3E,MAAM,cAAc;EAClB;EACA;EACA,GAAI,oBAAoB,EAAE;EAC3B;CACD,MAAM,cAAc,CAAC,GAAG,IAAI,IAAI,YAAY,CAAC;AAC7C,QAAO,IAAI,OAAO,OAAO,YAAY,KAAK,IAAI,CAAC,MAAM;;;;;;;AAQvD,MAAa,oBAAoB;;;;;;;AAUjC,MAAM,uBAAuB,OAC3B,eACA,gBACA,cACA,kBACkB;AAClB,OAAM,eAAe,eAAe;EAClC,UAAU;EACV,SAAS,CAAC,6BAA6B,cAAc,EAAE,eAAe,CAAC,CAAC;EACxE,YAAY;EACZ,KAAK;EACL,MAAM;EACP,CAAC;;;;;;;;;;;;;;AAeJ,MAAa,0BAA0B,OACrC,gBACA,MACA,cACA,kBACkB;CAIlB,MAAM,kBAAkB,sBAHE,iBAAiB,EAAE,EAAE,KAC5C,WAAW,OAAO,WAEwC,CAAC;CAC9D,MAAM,eAAe,oBAAoB,gBAAgB,KAAK;AAM9D,MAAK,MAAM,SAAS,cAAc;AAChC,MAAI,CAAC,gBAAgB,KAAK,MAAM,QAAQ,CAAE;AAC1C,QAAM,qBACJ,MAAM,SACN,gBACA,cACA,cACD;;;;;;;;;AAUL,MAAa,qBAAqB,OAChC,MACA,gBACA,iBAC2B;AAC3B,KAAI;AAOF,UAAO,MANc,eAAe,MAAM;GACxC,UAAU;GACV,SAAS,CAAC,2BAA2B,aAAa,CAAC;GACnD,YAAY;GACZ,KAAK;GACN,CAAC,GACa,QAAQ;SACjB;AACN,SAAO;;;;;;;;;;AAWX,MAAa,2BAA2B,OACtC,gBACA,MACA,iBAC2B;AAC3B,KAAI,aAAa,8BAA8B,SAAS,EAAG,QAAO;AAClE,KAAI,CAAC,qBAAqB,KAAK,KAAK,CAAE,QAAO;CAE7C,MAAM,eAAe,oBAAoB,gBAAgB,KAAK;AAM9D,KAHE,aAAa,SAAS,OACpB,aAAa,IAAI,sBAAsB,KAAK,KAAK,aAAa,SAAS,IAEhE;EAET,MAAM,gBAGD,EAAE;AAEP,OAAK,MAAM,SAAS,cAAc;AAChC,OAAI,CAAC,qBAAqB,KAAK,MAAM,QAAQ,CAAE;GAE/C,MAAM,cAAc,MAAM,mBACxB,MAAM,SACN,gBACA,aACD;AACD,OAAI,eAAe,gBAAgB,MAAM,QACvC,eAAc,KAAK;IAAE;IAAO,iBAAiB;IAAa,CAAC;;AAI/D,MAAI,cAAc,WAAW,EAAG,QAAO;AACvC,SAAO,mBAAmB,MAAM,cAAc;;AAIhD,QAAO,mBAAmB,MAAM,gBAAgB,aAAa;;;;;;;;;;AAW/D,MAAa,qBAAqB,OAChC,MACA,gBACA,YAIW;CACX,MAAM,SAAS,MAAM,eAAe,MAAM;EACxC,UAAU;EACV,SAAS,CAAC,CAAC,6BAA6B,QAAQ,CAAC;EACjD,YAAY;EACb,CAAC;AAEF,KAAI,CAAC,QAAQ,KAAM,QAAO;AAE1B,QAAO;EAAE,MAAM,OAAO;EAAM,KAAK,OAAO;EAAK"}
+{"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":";;;;;;;;;;;AAmBA,MAAa,uBACX;CACE,YAAY;CACZ,6BAA6B;CAC7B,SAAS;EACP;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;CACF;AACF;;;;;;AAOF,MAAa,uBAAuB;;;;;;;;;;;;;;;AAgBpC,MAAa,wBAAwB,qBAAwC;CAC3E,MAAM,cAAc;EAClB;EACA;EACA,GAAI,oBAAoB,CAAC;CAC3B;CACA,MAAM,cAAc,CAAC,GAAG,IAAI,IAAI,WAAW,CAAC;CAC5C,OAAO,IAAI,OAAO,OAAO,YAAY,KAAK,GAAG,EAAE,KAAK;AACtD;;AAGA,MAAM,2BAA2B,qBAAqB;;AAGtD,MAAM,uCAAuB,IAAI,QAG/B;;;;;;AAOF,MAAa,sBACX,kBACW;CACX,IAAI,CAAC,iBAAiB,cAAc,WAAW,GAC7C,OAAO;CAGT,IAAI,kBAAkB,qBAAqB,IAAI,aAAa;CAC5D,IAAI,CAAC,iBAAiB;EACpB,kBAAkB,qBAChB,cAAc,KAAK,WAAW,OAAO,UAAU,CACjD;EACA,qBAAqB,IAAI,eAAe,eAAe;CACzD;CACA,OAAO;AACT;;;;;;AAOA,MAAa,oBAAoB;;;;;;;AAUjC,MAAM,uBAAuB,OAC3B,eACA,gBACA,cACA,kBACkB;CAClB,MAAM,eAAe,eAAe;EAClC,UAAU;EACV,SAAS,CAAC,6BAA6B,cAAc,EAAE,cAAc,CAAC,CAAC;EACvE,YAAY;EACZ,KAAK;EACL,MAAM;CACR,CAAC;AACH;;;;;;;;;;;;;AAcA,MAAa,0BAA0B,OACrC,gBACA,MACA,cACA,kBACkB;CAClB,MAAM,kBAAkB,mBAAmB,aAAa;CACxD,MAAM,eAAe,oBAAoB,gBAAgB,IAAI;CAM7D,KAAK,MAAM,SAAS,cAAc;EAChC,IAAI,CAAC,gBAAgB,KAAK,MAAM,OAAO,GAAG;EAC1C,MAAM,qBACJ,MAAM,SACN,gBACA,cACA,aACF;CACF;AACF;;;;;;;AAQA,MAAa,qBAAqB,OAChC,MACA,gBACA,iBAC2B;CAC3B,IAAI;EAOF,QAAO,MANc,eAAe,MAAM;GACxC,UAAU;GACV,SAAS,CAAC,2BAA2B,YAAY,CAAC;GAClD,YAAY;GACZ,KAAK;EACP,CAAC,EACY,EAAE,QAAQ;CACzB,QAAQ;EACN,OAAO;CACT;AACF;;;;;;;;AASA,MAAa,2BAA2B,OACtC,gBACA,MACA,iBAC2B;CAC3B,IAAI,aAAa,8BAA8B,SAAS,GAAG,OAAO;CAClE,IAAI,CAAC,qBAAqB,KAAK,IAAI,GAAG,OAAO;CAE7C,MAAM,eAAe,oBAAoB,gBAAgB,IAAI;CAM7D,IAHE,aAAa,SAAS,OACpB,aAAa,EAAE,EAAE,sBAAsB,KAAK,KAAK,aAAa,SAAS,IAEhE;EAET,MAAM,gBAGD,CAAC;EAEN,KAAK,MAAM,SAAS,cAAc;GAChC,IAAI,CAAC,qBAAqB,KAAK,MAAM,OAAO,GAAG;GAE/C,MAAM,cAAc,MAAM,mBACxB,MAAM,SACN,gBACA,YACF;GACA,IAAI,eAAe,gBAAgB,MAAM,SACvC,cAAc,KAAK;IAAE;IAAO,iBAAiB;GAAY,CAAC;EAE9D;EAEA,IAAI,cAAc,WAAW,GAAG,OAAO;EACvC,OAAO,mBAAmB,MAAM,aAAa;CAC/C;CAGA,OAAO,mBAAmB,MAAM,gBAAgB,YAAY;AAC9D;;;;;;;;;AAUA,MAAa,qBAAqB,OAChC,MACA,gBACA,YAIW;CACX,MAAM,SAAS,MAAM,eAAe,MAAM;EACxC,UAAU;EACV,SAAS,CAAC,CAAC,6BAA6B,OAAO,CAAC;EAChD,YAAY;CACd,CAAC;CAED,IAAI,CAAC,QAAQ,MAAM,OAAO;CAE1B,OAAO;EAAE,MAAM,OAAO;EAAM,KAAK,OAAO;CAAI;AAC9C"}

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

@@ -1,10 +1,9 @@
 import { PackageName } from "./extractContent/utils/constants.js";
-import { PluginObj, PluginPass } from "@babel/core";
+import { PluginObject, PluginPass } from "@babel/core";
 import * as BabelTypes from "@babel/types";
 import { Locale } from "@intlayer/types/allLocales";
 import { IntlayerConfig } from "@intlayer/types/config";
 import { FilePathPattern } from "@intlayer/types/filePathPattern";
-
 //#region src/babel-plugin-intlayer-extract.d.ts
 type ExtractResult = {
   dictionaryKey: string;
@@ -51,7 +50,7 @@ type State = PluginPass & {
  */
 declare const intlayerExtractBabelPlugin: (_babel: {
   types: typeof BabelTypes;
-}) => PluginObj<State>;
+}) => PluginObject<State>;
 //#endregion
 export { ExtractPluginOptions, ExtractResult, intlayerExtractBabelPlugin };
 //# sourceMappingURL=babel-plugin-intlayer-extract.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"babel-plugin-intlayer-extract.d.ts","names":[],"sources":["../../src/babel-plugin-intlayer-extract.ts"],"mappings":";;;;;;;;KAcY,aAAA;EACV,aAAA;EACA,QAAA;EACA,OAAA,EAAS,MAAA;EACT,MAAA,EAAQ,MAAA;AAAA;AAAA,KAGE,oBAAA;EACV,WAAA,GAAc,WAAA;EACd,SAAA;EACA,OAAA;EAEA,aAAA,IAAiB,IAAA;EACjB,aAAA,EAAe,cAAA;EATD;;AAGhB;;;EAYE,SAAA,IAAa,MAAA,EAAQ,aAAA,YAAyB,OAAA;EAN/B;;;EAUf,MAAA,GAAS,eAAA;AAAA;AAAA,KAGN,KAAA,GAAQ,UAAA;EAAe,IAAA,EAAM,oBAAA;AAAA;;;;;;;;;;;;;;;AAFhC;;;cAqBW,0BAAA,GAA8B,MAAA;EACzC,KAAA,SAAc,UAAA;AAAA,MACZ,SAAA,CAAU,KAAA"}
+{"version":3,"file":"babel-plugin-intlayer-extract.d.ts","names":[],"sources":["../../src/babel-plugin-intlayer-extract.ts"],"mappings":";;;;;;;KAeY;EACV;EACA;EACA,SAAS;EACT,QAAQ;;KAGE;EACV,cAAc;EACd;EACA;EAEA,iBAAiB;EACjB,eAAe;;;;;;EAMf,aAAa,QAAQ,yBAAyB;;;;EAI9C,SAAS;;KAGN,QAAQ;EAAe,MAAM;;;;;;;;;;;;;;;;;;;cAmBrB,6BAA0B;EACrC,cAAc;MACZ,aAAa"}

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

@@ -1,7 +1,6 @@
-import { NestedRenameMap, PruneContext } from "./babel-plugin-intlayer-usage-analyzer.js";
-import { PluginObj } from "@babel/core";
+import { NestedRenameEntry, NestedRenameMap, PruneContext } from "./babel-plugin-intlayer-usage-analyzer.js";
+import { NodePath, PluginObject } from "@babel/core";
 import * as BabelTypes from "@babel/types";
-
 //#region src/babel-plugin-intlayer-field-rename.d.ts
 /**
  * Converts a zero-based index to a short alphabetic identifier.
@@ -37,9 +36,20 @@ declare const generateShortFieldName: (index: number) => string;
  */
 declare const buildNestedRenameMapFromContent: (contentValue: unknown) => NestedRenameMap;
 /**
- * Creates a Babel plugin that rewrites dictionary content field accesses in
- * source files to their short aliases defined in
- * `pruneContext.dictionaryKeyToFieldRenameMap`.
+ * Walks `fieldPath` through a {@link NestedRenameMap} and returns the entry at
+ * the final path segment, or `undefined` when any segment is missing (e.g. the
+ * path crosses an array or leaf value whose children are not mapped).
+ *
+ * Used to locate the rename entry of an opaquely-consumed content value so its
+ * children map can be cleared before the JSON rename is applied.
+ *
+ * @param renameMap - The root rename map to walk.
+ * @param fieldPath - Original (pre-rename) field names from the content root.
+ */
+declare const getNestedRenameEntryAtPath: (renameMap: NestedRenameMap, fieldPath: readonly string[]) => NestedRenameEntry | undefined;
+/**
+ * Rewrites dictionary content field accesses in the given program to the
+ * short aliases defined in `pruneContext.dictionaryKeyToFieldRenameMap`.
  *
  * Handled patterns (mirrors the usage analyser):
  *
@@ -57,15 +67,23 @@ declare const buildNestedRenameMapFromContent: (contentValue: unknown) => Nested
  *     → const { shortA: fieldA } = useIntlayer('key');
  *       const { shortN: nested } = fieldA;
  *
+ * Exposed as a standalone function so that both
+ * {@link makeFieldRenameBabelPlugin} and `intlayerMinifyBabelPlugin` can
+ * invoke it from their own `Program.exit` visitors.
+ */
+declare const renameIntlayerFieldAccesses: (babelTypes: typeof BabelTypes, programPath: NodePath<BabelTypes.Program>, pruneContext: PruneContext) => void;
+/**
+ * Creates a Babel plugin that rewrites dictionary content field accesses in
+ * source files to their short aliases via
+ * {@link renameIntlayerFieldAccesses}.
+ *
  * This plugin must run in a separate `transformAsync` pass **before**
  * `intlayerOptimizeBabelPlugin`, because the latter replaces `useIntlayer`
  * with `useDictionary`, erasing the dictionary-key information needed here.
  */
-declare const makeFieldRenameBabelPlugin: (pruneContext: PruneContext) => ({
-  types: babelTypes
-}: {
+declare const makeFieldRenameBabelPlugin: (pruneContext: PruneContext) => ({ types: babelTypes }: {
   types: typeof BabelTypes;
-}) => PluginObj;
+}) => PluginObject;
 //#endregion
-export { buildNestedRenameMapFromContent, generateShortFieldName, makeFieldRenameBabelPlugin };
+export { buildNestedRenameMapFromContent, generateShortFieldName, getNestedRenameEntryAtPath, makeFieldRenameBabelPlugin, renameIntlayerFieldAccesses };
 //# 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":";;;;;;;AAsBA;;cAAa,sBAAA,GAA0B,KAAA;;;AAqCvC;;;;;AA0QA;;;;;;;;;;;;;;;;;;;;cA1Qa,+BAAA,GACX,YAAA,cACC,eAAA;;;;;;;;;;;;;;;;;;;;;;;;;;cAwQU,0BAAA,GACV,YAAA,EAAc,YAAA;EACd,KAAA,EAAA;AAAA;EAAyB,KAAA,SAAc,UAAA;AAAA,MAAe,SAAA"}
+{"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"}

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

@@ -1,6 +1,5 @@
-import { PluginObj } from "@babel/core";
+import { PluginObject } from "@babel/core";
 import * as BabelTypes from "@babel/types";
-
 //#region src/babel-plugin-intlayer-minify.d.ts
 /**
  * Pre-resolved options accepted by {@link intlayerMinifyBabelPlugin}.
@@ -78,7 +77,7 @@ type MinifyPluginOptions = {
  */
 declare const intlayerMinifyBabelPlugin: (babel: {
   types: typeof BabelTypes;
-}) => PluginObj;
+}) => PluginObject;
 //#endregion
 export { MinifyPluginOptions, intlayerMinifyBabelPlugin };
 //# sourceMappingURL=babel-plugin-intlayer-minify.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"babel-plugin-intlayer-minify.d.ts","names":[],"sources":["../../src/babel-plugin-intlayer-minify.ts"],"mappings":";;;;;;AAgBA;;;;;KAAY,mBAAA;EAkBV;;;;EAbA,OAAA;EA8ID;;;;;EAvIC,MAAA;EA+DE;;;;EAzDF,QAAA;;;;EAKA,aAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAkDW,yBAAA,GAA6B,KAAA;EACxC,KAAA,SAAc,UAAA;AAAA,MACZ,SAAA"}
+{"version":3,"file":"babel-plugin-intlayer-minify.d.ts","names":[],"sources":["../../src/babel-plugin-intlayer-minify.ts"],"mappings":";;;;;;;;;;KAgBY;;;;;EAKV;;;;;;EAOA;;;;;EAMA;;;;EAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAkDW,4BAAyB;EACpC,cAAc;MACZ"}

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

@@ -1,8 +1,8 @@
-import { PluginObj, PluginPass } from "@babel/core";
+import { PluginObject, PluginPass } from "@babel/core";
 import * as BabelTypes from "@babel/types";
-
+import { CallerDescriptor } from "@intlayer/config/callers";
 //#region src/babel-plugin-intlayer-optimize.d.ts
-declare const CALLER_LIST: readonly ["useIntlayer", "getIntlayer"];
+declare const CALLER_LIST: readonly ['useIntlayer', 'getIntlayer'];
 /**
  * Options for the optimization Babel plugin
  */
@@ -63,15 +63,38 @@ type OptimizePluginOptions = {
    * Whether the current transform is for an SSR bundle.
    */
   isServer?: boolean;
+  /**
+   * Compat-adapter caller descriptors injected by the compat packages'
+   * bundler plugins (e.g. `@intlayer/react-i18next/plugin`).
+   *
+   * Callers carrying `staticReplacement` / `dynamicReplacement` are rewritten
+   * the same way as native `useIntlayer` calls: the namespace string argument
+   * is replaced by a pre-imported dictionary object and the import specifier
+   * is re-pointed to the dictionary-accepting variant, e.g.
+   * `useTranslation('about')` → `useDictionary(_dictHash)`.
+   *
+   * No compat-specific name is hard-coded in this plugin — the whole rewrite
+   * is driven by these descriptors.
+   */
+  compatCallers?: CallerDescriptor[];
 };
 type State = PluginPass & {
-  opts: OptimizePluginOptions; /** map key → generated ident (per-file) for static imports */
-  _newStaticImports?: Map<string, BabelTypes.Identifier>; /** map key → generated ident (per-file) for dynamic imports */
-  _newDynamicImports?: Map<string, BabelTypes.Identifier>; /** whether the current file imported *any* intlayer package */
-  _hasValidImport?: boolean; /** map from local identifier name to the imported intlayer func name ('useIntlayer' | 'getIntlayer') */
-  _callerMap?: Map<string, (typeof CALLER_LIST)[number]>; /** map from local identifier name to the intlayer package it was imported from */
-  _callerPackageMap?: Map<string, string>; /** whether the current file *is* the dictionaries entry file */
-  _isDictEntry?: boolean; /** whether the current file is included in the filesList */
+  opts: OptimizePluginOptions;
+  /** map key → generated ident (per-file) for static imports */
+  _newStaticImports?: Map<string, BabelTypes.Identifier>;
+  /** map key → generated ident (per-file) for dynamic imports */
+  _newDynamicImports?: Map<string, BabelTypes.Identifier>;
+  /** whether the current file imported *any* intlayer package */
+  _hasValidImport?: boolean;
+  /** map from local identifier name to the imported intlayer func name ('useIntlayer' | 'getIntlayer') */
+  _callerMap?: Map<string, (typeof CALLER_LIST)[number]>;
+  /** map from local identifier name to the intlayer package it was imported from */
+  _callerPackageMap?: Map<string, string>;
+  /** map from local identifier name to the compat caller descriptor it was imported as */
+  _compatCallerMap?: Map<string, CallerDescriptor>;
+  /** whether the current file *is* the dictionaries entry file */
+  _isDictEntry?: boolean;
+  /** whether the current file is included in the filesList */
   _isIncluded?: boolean;
 };
 /**
@@ -158,7 +181,7 @@ type State = PluginPass & {
  */
 declare const intlayerOptimizeBabelPlugin: (babel: {
   types: typeof BabelTypes;
-}) => PluginObj<State>;
+}) => PluginObject<State>;
 //#endregion
 export { OptimizePluginOptions, intlayerOptimizeBabelPlugin };
 //# sourceMappingURL=babel-plugin-intlayer-optimize.d.ts.map

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":";;;;cAwBM,WAAA;;AAtB0C;;KAqEpC,qBAAA;EA/C+C;;AA+C3D;EAIE,QAAA;;;;EAIA,eAAA;EAIA;;;EAAA,qBAAA;EAgBA;;;EAZA,6BAAA;EA4BA;;;EAxBA,uBAAA;EAuCA;;;EAnCA,sBAAA;EAsCQ;;;EAlCR,4BAAA;EAqCgC;;;EAjChC,oBAAA;EAuCiC;;;EAnCjC,0BAAA;EAqCuB;;;EAjCvB,sBAAA;EAyBA;;;EArBA,UAAA;EAuBA;;;EAnBA,iBAAA,GAAoB,MAAA;EAqBpB;;;EAdA,SAAA;EAkBA;;;EAdA,QAAA;AAAA;AAAA,KAGG,KAAA,GAAQ,UAAA;EACX,IAAA,EAAM,qBAAA,EA6mBP;EA3mBC,iBAAA,GAAoB,GAAA,SAAY,UAAA,CAAW,UAAA,GAgN7B;EA9Md,kBAAA,GAAqB,GAAA,SAAY,UAAA,CAAW,UAAA,GA+M1C;EA7MF,eAAA,YA6MW;EA3MX,UAAA,GAAa,GAAA,iBAAoB,WAAA,YA0MnB;EAxMd,iBAAA,GAAoB,GAAA,kBAyMlB;EAvMF,YAAA,YAuMiB;EArMjB,WAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmMW,2BAAA,GAA+B,KAAA;EAC1C,KAAA,SAAc,UAAA;AAAA,MACZ,SAAA,CAAU,KAAA"}
+{"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"}

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

@@ -1,7 +1,6 @@
 import { CompatCallerConfig, PruneContext } from "./babel-plugin-intlayer-usage-analyzer.js";
-import { PluginObj } from "@babel/core";
+import { PluginObject } from "@babel/core";
 import * as BabelTypes from "@babel/types";
-
 //#region src/babel-plugin-intlayer-purge.d.ts
 /**
  * Pre-resolved options accepted by {@link intlayerPurgeBabelPlugin}.
@@ -133,7 +132,7 @@ declare const getSharedPruneContext: (baseDir: string) => PruneContext | null;
  */
 declare const intlayerPurgeBabelPlugin: (_babel: {
   types: typeof BabelTypes;
-}) => PluginObj;
+}) => PluginObject;
 //#endregion
 export { PurgePluginOptions, getSharedPruneContext, intlayerPurgeBabelPlugin };
 //# 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":";;;;;;;AA6BA;;;;;KAAY,kBAAA;EAmBV;;;;;EAbA,OAAA;EAoDA;;;;EA9CA,KAAA;EA8DkC;AAyBpC;;;;EAhFE,MAAA;EA0sBW;;;;;EAnsBX,QAAA;EAmsBuC;;;;EA7rBvC,aAAA;;;;;EAMA,eAAA;;;;;EAMA,sBAAA;;;;;;EAOA,kBAAA;;;;;;EAOA,4BAAA,EAA8B,MAAA;;;;;;;;;;;;EAgB9B,aAAA,GAAgB,kBAAA;AAAA;;;;;;;;;cAyBL,qBAAA,GAAyB,OAAA,aAAkB,YAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA0nB3C,wBAAA,GAA4B,MAAA;EACvC,KAAA,SAAc,UAAA;AAAA,MACZ,SAAA"}
+{"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"}

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

@@ -1,6 +1,6 @@
-import { PluginObj } from "@babel/core";
+import { PluginObject } from "@babel/core";
 import * as BabelTypes from "@babel/types";
-
+import { CallerDescriptor, CallerDescriptor as CallerDescriptor$1, CallerResultShape, CallerValueSource } from "@intlayer/config/callers";
 //#region src/babel-plugin-intlayer-usage-analyzer.d.ts
 /**
  * Dictionary field usage result for a single dictionary key.
@@ -23,6 +23,22 @@ type NestedRenameEntry = {
 };
 /** A level of the field-rename tree, mapping original field names to entries. */
 type NestedRenameMap = Map<string, NestedRenameEntry>;
+/**
+ * One opaque consumption of a dictionary content value: the value at
+ * `fieldPath` escapes static analysis (passed as-is to a child component or a
+ * function argument), so its children must keep their original key names in
+ * the compiled JSON.
+ */
+type OpaqueFieldOccurrence = {
+  /**
+   * Original (pre-rename) user-defined field names from the content root to
+   * the escaping value, e.g. `['sections', 'hero']` for
+   * `<Card data={content.sections.hero} />`.
+   */
+  fieldPath: string[];
+  /** Source locations (`filePath:line`) where the value escapes. */
+  locations: string[];
+};
 /**
  * Shared mutable state created once by the vite plugin and passed by reference
  * to the usage-analyzer (writer) and the prune/minify plugins (readers).
@@ -61,14 +77,17 @@ type PruneContext = {
    */
   dictionaryKeyToFieldRenameMap: Map<string, NestedRenameMap>;
   /**
-   * Maps each dictionary key to a per-field list of source locations where
-   * the field value is consumed "opaquely" (passed as-is to a child component
-   * or function argument). When a field is opaque AND has nested user-defined
-   * structure, its children must not be renamed.
+   * Maps each dictionary key to the content field paths whose values are
+   * consumed "opaquely" (passed as-is to a child component or function
+   * argument). When an opaque value has nested user-defined structure, its
+   * children must not be renamed.
    *
-   * Structure: dictionaryKey → fieldName → ["filePath:line", …]
+   * The inner map is keyed by the dot-joined field path for de-duplication
+   * only; the authoritative path is {@link OpaqueFieldOccurrence.fieldPath}.
+   *
+   * Structure: dictionaryKey → joinedFieldPath → { fieldPath, locations }
    */
-  dictionaryKeysWithOpaqueTopLevelFields: Map<string, Map<string, string[]>>;
+  dictionaryKeysWithOpaqueFields: Map<string, Map<string, OpaqueFieldOccurrence>>;
   /**
    * Dictionary keys for which field-key renaming must be skipped even if a
    * finite field-usage set was determined.
@@ -99,110 +118,15 @@ type PruneContext = {
 };
 declare const createPruneContext: () => PruneContext;
 /** Canonical intlayer caller names that trigger usage analysis. */
-declare const INTLAYER_CALLER_NAMES: readonly ["useIntlayer", "getIntlayer"];
+declare const INTLAYER_CALLER_NAMES: readonly ['useIntlayer', 'getIntlayer'];
 type IntlayerCallerName = (typeof INTLAYER_CALLER_NAMES)[number];
-/**
- * Describes how a compat-adapter "namespace caller" exposes the dictionary key
- * (namespace) and the translation function `t`.
- *
- * Compat adapters (`@intlayer/react-i18next`, `@intlayer/next-intl`, …) expose
- * the original i18n library API while delegating to intlayer under the hood.
- * Their call sites look like:
- *
- *   const { t } = useTranslation('about');   t('counter.label')
- *   const t     = useTranslations('about');  t('counter.label')
- *   const t     = await getTranslations('about');
- *   const t     = i18n.getFixedT(null, 'about', 'counter');
- *   const { t } = useI18n({ namespace: 'about' });
- *
- * The dictionary key is the *namespace* argument and the consumed top-level
- * field is the **first segment** of every dot-path passed to `t()` (or the
- * first segment of `keyPrefix` when one is supplied).
- */
-type CompatNamespaceSource = /** Namespace is a positional argument (string literal or `{ namespace }`). */{
-  from: 'argument';
-  index: number;
-} /** Namespace is a property of an options object argument. */ | {
-  from: 'option';
-  argumentIndex: number;
-  property: string;
-}
-/**
- * Namespace is a compile-time constant — the same dictionary key is used for
- * every call site. Used by single-catalog libraries such as lingui, where all
- * translations live in a `messages` dictionary regardless of call location.
- */
-| {
-  from: 'fixed';
-  value: string;
-}
-/**
- * Namespace is the first dot-segment of the `id` in the first call argument.
- *
- * Used for libraries like react-intl where the full dotted id encodes both the
- * dictionary key and the field path in a single string:
- *   `formatMessage({ id: 'home.title' })` → dictionaryKey = `'home'`, field = `'title'`
- *
- * Works with both string form (`func('home.title')`) and descriptor form
- * (`func({ id: 'home.title', ... })`). The paired `translationFunction` should
- * be `'self'` so the field (second segment) is also extracted from the same call.
- */
-| {
-  from: 'path-first-segment';
-};
 /**
  * Configuration entry for a single compat namespace caller.
+ *
+ * @deprecated Alias kept for backward compatibility — use the shared
+ * {@link CallerDescriptor} from `@intlayer/config/callers` instead.
  */
-type CompatCallerConfig = {
-  /** The imported (or method) function name, e.g. `'useTranslation'`. */callerName: string;
-  /**
-   * Module specifiers from which `callerName` must be imported to be treated as
-   * a compat caller. Includes both the original library names and their
-   * `@intlayer/*` adapter equivalents, because the bundler aliases the former
-   * to the latter but user source code may import either.
-   *
-   * Ignored when `matchAsMethod` is `true`.
-   */
-  importSources: string[];
-  /**
-   * When `true`, the caller is matched by method name on any object
-   * (`x.getFixedT(...)`) without an import check. Used for `i18next` instance
-   * methods that are never imported as named specifiers.
-   */
-  matchAsMethod?: boolean; /** How the dictionary key (namespace) is read from the call arguments. */
-  namespace: CompatNamespaceSource;
-  /**
-   * Optional location of a `keyPrefix` that prefixes every `t()` path. When a
-   * static prefix is present, the only consumed top-level field is the first
-   * segment of the prefix.
-   */
-  keyPrefix?: CompatNamespaceSource;
-  /**
-   * How the translation function is obtained from the call result.
-   *
-   * - `'return-value'`   — `const t = useTranslations('ns'); t('key')`
-   * - `'destructured-t'` — `const { t } = useTranslation('ns'); t('key')`
-   * - `'self'`           — the caller IS the translation call;
-   *                        the first argument is the message key.
-   *                        Used for lingui's `i18n._('key')` / `i18n.t('key')`.
-   * - `'all'`            — mark the entire dictionary as used without tracking
-   *                        individual fields. Use when static key analysis is
-   *                        impossible (e.g. lingui hashed IDs, Angular templates).
-   */
-  translationFunction: 'return-value' | 'destructured-t' | 'self' | 'all';
-  /**
-   * When set, the caller is *also* matched as a JSX element whose local name is
-   * `callerName` (gated by `importSources`). The named attribute is read as the
-   * message id and analysed with the same `namespace` + `translationFunction`
-   * (`'self'` / `'all'`) semantics as the call-expression form.
-   *
-   * Required for libraries with a JSX message component, e.g. react-intl's
-   * `<FormattedMessage id="home.title" />`. Without it, JSX usages are invisible
-   * to the analyser and field-level pruning of the same dictionary becomes
-   * unsafe (it could prune a field only referenced from JSX).
-   */
-  jsxIdAttribute?: string;
-};
+type CompatCallerConfig = CallerDescriptor$1;
 /**
  * Default registry of compat namespace callers.
  *
@@ -230,11 +154,9 @@ declare const DEFAULT_COMPAT_CALLERS: CompatCallerConfig[];
  */
 declare const makeUsageAnalyzerBabelPlugin: (pruneContext: PruneContext, options?: {
   compatCallers?: CompatCallerConfig[];
-}) => ({
-  types: babelTypes
-}: {
+}) => ({ types: babelTypes }: {
   types: typeof BabelTypes;
-}) => PluginObj;
+}) => PluginObject;
 //#endregion
-export { CompatCallerConfig, CompatNamespaceSource, DEFAULT_COMPAT_CALLERS, DictionaryFieldUsage, INTLAYER_CALLER_NAMES, IntlayerCallerName, NestedRenameEntry, NestedRenameMap, 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 };
 //# 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":";;;;;;AAYA;;;;;KAAY,oBAAA,GAAuB,GAAA;;;;;;;;KASvB,iBAAA;EACV,SAAA;EACA,QAAA,EAAU,eAAA;AAAA;;KAIA,eAAA,GAAkB,GAAA,SAAY,iBAAA;AAS1C;;;;;;;AAAA,KAAY,YAAA;EAiCqB;;;;;EA3B/B,4BAAA,EAA8B,GAAA,SAAY,oBAAA;EA+Db;;;;EAzD7B,yBAAA,EAA2B,GAAA;EAAA;;;;;EAO3B,wBAAA;EAc2C;;;;;EAP3C,mCAAA,EAAqC,GAAA;EA2CrC;;;;;EApCA,6BAAA,EAA+B,GAAA,SAAY,eAAA;EA0ChC;;;;;AAiBb;;;EAjDE,sCAAA,EAAwC,GAAA,SAAY,GAAA;EAiDsB;AAC5E;;;;;AAsBA;;;;;;EA1DE,+BAAA,EAAiC,GAAA;EA8Db;;;;;;;AAuBtB;;;EAzEE,wBAAA,EAA0B,GAAA;IAEtB,YAAA;IAAsB,aAAA;EAAA;AAAA;AAAA,cAIf,kBAAA,QAAyB,YAAA;;cAiBzB,qBAAA;AAAA,KACD,kBAAA,WAA6B,qBAAA;;;;AAgHzC;;;;;AAw2BA;;;;;;;;;;KAl8BY,qBAAA;EAEN,IAAA;EAAkB,KAAA;AAAA;EAElB,IAAA;EAAgB,aAAA;EAAuB,QAAA;AAAA;;;;;;;EAMvC,IAAA;EAAe,KAAA;AAAA;;;;;;;;;;;;;EAYf,IAAA;AAAA;;;;KAKM,kBAAA;yEAEV,UAAA;;;;;;;;;EASA,aAAA;;;;;;EAMA,aAAA;EAEA,SAAA,EAAW,qBAAA;;;;;;EAMX,SAAA,GAAY,qBAAA;;;;;;;;;;;;;EAaZ,mBAAA;;;;;;;;;;;;EAYA,cAAA;AAAA;;;;;;;;;;;cAaW,sBAAA,EAAwB,kBAAA;;;;;;;;;;;;;;;cAw2BxB,4BAAA,GAET,YAAA,EAAc,YAAA,EACd,OAAA;EAAY,aAAA,GAAgB,kBAAA;AAAA;EAE7B,KAAA,EAAA;AAAA;EAAyB,KAAA,SAAc,UAAA;AAAA,MAAe,SAAA"}
+{"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"}

package/dist/types/babelParser.d.ts

@@ -0,0 +1,12 @@
+//#region src/babelParser.d.ts
+/** A parser object accepted by `recast.parse`'s `parser` option. */
+type RecastParser = {
+  parse: (source: string) => unknown;
+};
+/** Drop-in replacement for `recast/parsers/typescript` (TS without JSX). */
+declare const typescriptParser: RecastParser;
+/** Drop-in replacement for `recast/parsers/babel-ts` (TS *and* JSX). */
+declare const babelTsParser: RecastParser;
+//#endregion
+export { RecastParser, babelTsParser, typescriptParser };
+//# sourceMappingURL=babelParser.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"babelParser.d.ts","names":[],"sources":["../../src/babelParser.ts"],"mappings":";;KAuDY;EACV,QAAQ;;;cAIG,kBAAkB;;cAMlB,eAAe"}

package/dist/types/extractContent/babelProcessor.d.ts

@@ -1,7 +1,8 @@
+import { ExistingIntlayerInfo } from "./utils/getExistingIntlayerInfo.js";
+import "./utils/index.js";
 import * as t from "@babel/types";
 import { IntlayerConfig } from "@intlayer/types/config";
 import { NodePath } from "@babel/traverse";
-
 //#region src/extractContent/babelProcessor.d.ts
 type BabelReplacement = {
   path: NodePath;
@@ -26,7 +27,9 @@ declare const extractBabelContentForComponents: (ast: t.File, fileCode: string,
   componentsNeedingHooks: Set<NodePath>;
   componentKeyMap: Map<t.Node, string>;
   componentPaths: NodePath[];
-  hookMap: Map<t.Node, "useIntlayer" | "getIntlayer">;
+  hookMap: Map<t.Node, 'useIntlayer' | 'getIntlayer'>;
+  /** Cached `getExistingIntlayerInfo` result per component node, so callers do not re-traverse. */
+  existingInfoByNode: Map<t.Node, ExistingIntlayerInfo | undefined>;
   isSolid: boolean;
 };
 /**

package/dist/types/extractContent/babelProcessor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"babelProcessor.d.ts","names":[],"sources":["../../../src/extractContent/babelProcessor.ts"],"mappings":";;;;;KAYY,gBAAA;EACV,IAAA,EAAM,QAAA;EACN,GAAA;EACA,IAAA;EAOA,YAAA;EACA,iBAAA,GAAoB,CAAA,CAAE,IAAA;EACtB,SAAA;AAAA;;;;;cAYW,uBAAA,GACX,IAAA,EAAM,QAAA,CAAS,CAAA,CAAE,UAAA,GAAa,CAAA,CAAE,WAAA,GAChC,QAAA,UACA,YAAA,EAAc,GAAA,UACd,sBAAA,GAAyB,IAAA,EAAM,QAAA,aAC/B,gBAAA,EAAkB,MAAA,SAAe,MAAA,mBACjC,YAAA,EAAc,gBAAA,IACd,YAAA,EAAc,GAAA,CAAI,CAAA,CAAE,IAAA;;;;;cAwIT,gCAAA,GACX,GAAA,EAAK,CAAA,CAAE,IAAA,EACP,QAAA,UACA,YAAA,EAAc,GAAA,UACd,UAAA,UACA,aAAA,EAAe,cAAA,EACf,QAAA,UACA,oBAAA,GAAsB,MAAA;EAEtB,gBAAA,EAAkB,MAAA,SAAe,MAAA;EACjC,YAAA,EAAc,gBAAA;EACd,sBAAA,EAAwB,GAAA,CAAI,QAAA;EAC5B,eAAA,EAAiB,GAAA,CAAI,CAAA,CAAE,IAAA;EACvB,cAAA,EAAgB,QAAA;EAChB,OAAA,EAAS,GAAA,CAAI,CAAA,CAAE,IAAA;EACf,OAAA;AAAA;;;;cAobW,gBAAA,GACX,GAAA,EAAK,CAAA,CAAE,IAAA,EACP,QAAA,UACA,YAAA,EAAc,GAAA,UACd,aAAA,EAAe,cAAA,EACf,QAAA,UACA,oBAAA,GAAsB,MAAA;EAEtB,gBAAA,EAAkB,MAAA;EAClB,YAAA,EAAc,gBAAA;AAAA"}
+{"version":3,"file":"babelProcessor.d.ts","names":[],"sources":["../../../src/extractContent/babelProcessor.ts"],"mappings":";;;;;;KAaY;EACV,MAAM;EACN;EACA;EAOA;EACA,oBAAoB,EAAE;EACtB;;;;;;cA4IW,0BAAuB,MAC5B,SAAS,EAAE,aAAa,EAAE,cAAY,kBAC5B,cACF,aAAW,yBACA,MAAM,qBAAmB,kBAChC,eAAe,yBAAuB,cAC1C,oBAAkB,cAClB,IAAI,EAAE;;;;;cAwIT,mCAAgC,KACtC,EAAE,MAAI,kBACK,cACF,aAAW,oBACP,eACH,gBAAc,kBACb,uBACM;EAEtB,kBAAkB,eAAe;EACjC,cAAc;EACd,wBAAwB,IAAI;EAC5B,iBAAiB,IAAI,EAAE;EACvB,gBAAgB;EAChB,SAAS,IAAI,EAAE;;EAEf,oBAAoB,IAAI,EAAE,MAAM;EAChC;;;;;cA6ZW,mBAAgB,KACtB,EAAE,MAAI,kBACK,cACF,aAAW,eACV,gBAAc,kBACb,uBACM;EAEtB,kBAAkB;EAClB,cAAc"}

package/dist/types/extractContent/contentWriter.d.ts

@@ -1,6 +1,5 @@
 import { IntlayerConfig } from "@intlayer/types/config";
 import { Dictionary, DictionaryKey } from "@intlayer/types/dictionary";
-
 //#region src/extractContent/contentWriter.d.ts
 /**
  * Translation node structure used in dictionaries

package/dist/types/extractContent/contentWriter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"contentWriter.d.ts","names":[],"sources":["../../../src/extractContent/contentWriter.ts"],"mappings":";;;;;;AAY4E;KA2BvE,eAAA;EACH,QAAA;EACA,WAAA,EAAa,MAAA;AAAA;;;;KAMV,oBAAA,GAAuB,MAAA,SAAe,eAAA;AANtB;;;;;AAmBrB;AAnBqB,cAmBR,uCAAA,GACX,gBAAA,EAAkB,MAAA,kBAClB,kBAAA,EAAoB,UAAA,SACpB,aAAA,aACC,oBAAA;;;;;;;cAkDU,oCAAA,GACX,gBAAA,EAAkB,MAAA,kBAClB,kBAAA,EAAoB,UAAA,YACnB,MAAA;;;;cA8CU,kBAAA,GACX,gBAAA,EAAkB,MAAA,kBAClB,aAAA,EAAe,aAAA,EACf,QAAA,UACA,aAAA,EAAe,cAAA,KACd,OAAA"}
+{"version":3,"file":"contentWriter.d.ts","names":[],"sources":["../../../src/extractContent/contentWriter.ts"],"mappings":";;;;;;KAmCK;EACH;EACA,aAAa;;;;;KAMV,uBAAuB,eAAe;;;;;;;cAa9B,0CAAuC,kBAChC,wBAAsB,oBACpB,mBAAiB,0BAEpC;;;;;;;cAkDU,uCAAoC,kBAC7B,wBAAsB,oBACpB,sBACnB;;;;cA8CU,qBAAkB,kBACX,wBAAsB,eACzB,eAAa,kBACZ,eACD,mBACd"}

package/dist/types/extractContent/extractContent.d.ts

@@ -1,7 +1,7 @@
 import { PackageName } from "./utils/constants.js";
+import "./utils/index.js";
 import { IntlayerConfig } from "@intlayer/types/config";
 import { GetConfigurationOptions } from "@intlayer/config/node";
-
 //#region src/extractContent/extractContent.d.ts
 type ExtractIntlayerOptions = {
   configOptions?: GetConfigurationOptions;