@intlayer/babel 9.4.3 → 9.5.0

package/dist/types/babelParser.d.ts

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

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

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

package/dist/types/compat/namespaceResolution.d.ts

@@ -0,0 +1,66 @@
+import { StaticOrAbsent } from "../staticAstReaders.js";
+import * as BabelTypes from "@babel/types";
+import { CallerDescriptor, CallerValueSource } from "@intlayer/config/callers";
+//#region src/compat/namespaceResolution.d.ts
+/**
+ * Resolution of a compat caller's namespace from its
+ * {@link CallerValueSource} list.
+ *
+ * Two flavours coexist on purpose, because the two passes ask different
+ * questions of the same descriptor:
+ *
+ * - {@link resolveNamespaceForAnalysis} answers *which dictionary does this
+ *   call read* — used by the usage analyser, which only needs to attribute a
+ *   call to a dictionary and may fall back to the caller's default namespace.
+ * - {@link resolveNamespaceForRewrite} answers *can this call be rewritten,
+ *   and where do I edit it* — used by the optimize pass, which needs an exact
+ *   static namespace plus a handle on the node it must replace. It has no
+ *   default-namespace fallback: rewriting a call whose namespace is only
+ *   implied would bind the wrong dictionary.
+ */
+/** Namespace used by compat callers when no namespace argument is given. */
+export declare const DEFAULT_COMPAT_NAMESPACE = "translation";
+/**
+ * Resolves the namespace from a list of `CallerValueSource`s, tried in
+ * declaration order. The first source yielding a static string wins.
+ * Returns {@link ABSENT_VALUE} when every source reports an absent value, and
+ * `undefined` when the namespace is present somewhere but dynamic.
+ */
+export declare const resolveNamespaceForAnalysis: (babelTypes: typeof BabelTypes, callArguments: BabelTypes.CallExpression['arguments'], sources: CallerValueSource[]) => StaticOrAbsent<string>;
+/**
+ * Resolves an optional `keyPrefix` for a compat caller. Returns the static
+ * prefix string, `null` when no prefix is configured/present, or `undefined`
+ * when a prefix is present but dynamic.
+ */
+export declare const resolveKeyPrefixForAnalysis: (babelTypes: typeof BabelTypes, callArguments: BabelTypes.CallExpression['arguments'], sources: CallerValueSource[] | undefined) => string | null | undefined;
+/**
+ * Result of statically resolving the namespace of a compat caller call-site
+ * for rewriting, carrying the handles the optimize pass mutates.
+ */
+export type RewritableNamespaceMatch = {
+  /** The full namespace string, e.g. `'about.counter'`. */
+  fullNamespace: string;
+  /** Index of the positional namespace argument, when read from an argument. */
+  argumentIndex?: number;
+  /**
+   * The options-object property holding the namespace, when read from an
+   * option. The rewrite mutates it in place (key-prefix remainder) or removes
+   * it from `optionsObject`.
+   */
+  optionProperty?: BabelTypes.ObjectProperty;
+  /** The options object owning `optionProperty`. */
+  optionsObject?: BabelTypes.ObjectExpression;
+};
+/**
+ * Statically resolves the namespace of a compat caller call-site for the
+ * optimize pass. Only the `argument` / `option` / `fixed` sources qualify: the
+ * per-message-id `path-first-segment` form cannot bind one dictionary to the
+ * call site and is skipped.
+ *
+ * Returns `undefined` when the namespace is absent or dynamic, in which case
+ * the call is left untouched and resolves through the runtime dictionary
+ * registry.
+ */
+export declare const resolveNamespaceForRewrite: (babelTypes: typeof BabelTypes, callArguments: BabelTypes.CallExpression['arguments'], descriptor: CallerDescriptor) => RewritableNamespaceMatch | undefined;
+//#endregion
+//# sourceMappingURL=namespaceResolution.d.ts.map

package/dist/types/compat/namespaceResolution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"namespaceResolution.d.ts","names":[],"sources":["../../../src/compat/namespaceResolution.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;qBAiCa;;;;;;;qBAoEA,8BAA2B,mBACnB,YAAU,eACd,WAAW,6BAA2B,SAC5C,wBACR;;;;;;qBAuBU,8BAA2B,mBACnB,YAAU,eACd,WAAW,6BAA2B,SAC5C;;;;;YAiBC;;EAEV;;EAEA;;;;;;EAMA,iBAAiB,WAAW;;EAE5B,gBAAgB,WAAW;;;;;;;;;;;;qBAahB,6BAA0B,mBAClB,YAAU,eACd,WAAW,6BAA2B,YACzC,qBACX"}

package/dist/types/compat/optimizePass.d.ts

@@ -0,0 +1,58 @@
+import { DictionaryImportRegistry, ImportMode } from "../dictionaryImports.js";
+import * as BabelTypes from "@babel/types";
+import { CallerDescriptor } from "@intlayer/config/callers";
+//#region src/compat/optimizePass.d.ts
+/**
+ * Compat half of the optimize pass.
+ *
+ * Every adapter-specific behaviour of the build-time rewrite lives here:
+ * matching a compat caller's import, resolving its namespace, and re-pointing
+ * the import specifier at the dictionary-accepting helper.
+ *
+ * The pass works on plain AST nodes rather than `NodePath`s: the optimize
+ * plugin collects the call sites in its single traversal and hands them over,
+ * so nothing here walks the tree.
+ *
+ * It is created only when compat descriptors were injected by a compat
+ * package's bundler plugin, so a plain intlayer build never allocates it —
+ * {@link createCompatOptimizePass} returns `null` for an empty registry.
+ */
+export type CompatOptimizePass = {
+  /**
+   * Whether `importSource` exports at least one rewritable compat caller, so
+   * the optimize plugin knows the import is worth inspecting even though it is
+   * not a native intlayer package.
+   */
+  ownsImportSource: (importSource: string) => boolean;
+  /** Records the local alias one import specifier introduces. */
+  noteImport: (importSource: string, importedName: string, localName: string) => void;
+  /** Whether `localName` was bound to a compat caller by an import. */
+  ownsLocalName: (localName: string) => boolean;
+  /** Whether the file imported any compat caller at all. */
+  hasCallers: () => boolean;
+  /**
+   * Resolves the namespace of every collected call, dropping the callers that
+   * cannot be rewritten and deciding the file-level helper family. Must run
+   * after every import was noted and before any rewrite.
+   */
+  analyzeCalls: (callNodes: readonly BabelTypes.CallExpression[]) => void;
+  /** Rewrites one compat call site, if its caller survived {@link analyzeCalls}. */
+  rewriteCall: (callNode: BabelTypes.CallExpression) => void;
+  /** Re-points the compat specifiers of one import declaration. */
+  rewriteImportSpecifiers: (importNode: BabelTypes.ImportDeclaration) => void;
+};
+/**
+ * Builds the compat optimize pass for one source file, or `null` when no
+ * compat caller was injected.
+ *
+ * @param babelTypes - Babel's type helpers.
+ * @param compatCallers - Descriptors injected by the compat packages' plugins.
+ * @param imports - Shared dictionary-import registry for the file.
+ * @param buildModes - The file's global import mode and per-dictionary overrides.
+ */
+export declare const createCompatOptimizePass: (babelTypes: typeof BabelTypes, compatCallers: readonly CallerDescriptor[], imports: DictionaryImportRegistry, buildModes: {
+  importMode: ImportMode | undefined;
+  dictionaryModeMap?: Record<string, ImportMode | undefined>;
+}) => CompatOptimizePass | null;
+//#endregion
+//# sourceMappingURL=optimizePass.d.ts.map

package/dist/types/compat/optimizePass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"optimizePass.d.ts","names":[],"sources":["../../../src/compat/optimizePass.ts"],"mappings":";;;;;;;;;;;;;;;;;;;YA2BY;;;;;;EAMV,mBAAmB;;EAEnB,aACE,sBACA,sBACA;;EAGF,gBAAgB;;EAEhB;;;;;;EAMA,eAAe,oBAAoB,WAAW;;EAE9C,cAAc,UAAU,WAAW;;EAEnC,0BAA0B,YAAY,WAAW;;;;;;;;;;;qBA4EtC,2BAAwB,mBAChB,YAAU,wBACL,oBAAkB,SACjC,0BAAwB;EAE/B,YAAY;EACZ,oBAAoB,eAAe;MAEpC"}

package/dist/types/compat/usageAnalysis.d.ts

@@ -0,0 +1,75 @@
+import { PruneContext } from "../pruneContext.js";
+import { NodePath } from "@babel/core";
+import * as BabelTypes from "@babel/types";
+import { CallerDescriptor } from "@intlayer/config/callers";
+//#region src/compat/usageAnalysis.d.ts
+/**
+ * Analyses how the translation function produced by a compat namespace caller
+ * (`useTranslation`, `useTranslations`, `getTranslations`, `getFixedT`,
+ * `useI18n`) is consumed, then records the accessed top-level dictionary fields
+ * into `pruneContext`.
+ *
+ * Dictionaries consumed this way are always added to
+ * `dictionariesSkippingFieldRename`: the field accesses are string-literal
+ * dot-paths inside `t()` calls, which the field-rename plugin cannot rewrite,
+ * so renaming the compiled JSON keys would break runtime lookups. Pruning
+ * (top-level field removal) remains safe because it preserves field names.
+ */
+export declare const analyzeNamespaceCallerUsage: (babelTypes: typeof BabelTypes, pruneContext: PruneContext, callArguments: BabelTypes.CallExpression['arguments'], callerConfig: CallerDescriptor, isSfcFile: boolean,
+/** Absolute path of the analysed file (for untracked-binding reporting). */
+currentSourceFilePath: string,
+/**
+ * The call-expression path, when the caller was matched as a call. Omitted
+ * for JSX-element matches (`<FormattedMessage id>`), where only the static
+ * `'self'` / `'all'` analysis paths apply — the binding-based
+ * `'destructured-t'` / `'return-value'` paths require a call site.
+ */
+callExpressionPath?: NodePath<BabelTypes.CallExpression>,
+/**
+ * Pre-resolved namespace bypassing `namespaceSources`, e.g. the `ns`
+ * attribute of react-i18next's `<Trans ns="home" i18nKey="title" />`.
+ */
+namespaceOverride?: string) => void;
+/**
+ * Compat half of the usage analyser, kept behind one object so the native
+ * plugin body contains no adapter-specific branching.
+ *
+ * The analyser is created only when compat callers were injected, so a plain
+ * intlayer build never allocates it and never pays for its lookups —
+ * {@link createCompatUsageAnalyzer} returns `null` for an empty registry.
+ */
+export type CompatUsageAnalyzer = {
+  /**
+   * Records the local aliases one import declaration introduces. Called for
+   * every import of the file, before any call site is inspected.
+   */
+  noteImport: (importSource: string, importedName: string, localName: string) => void;
+  /**
+   * Whether any compat caller can match in this file — either an imported
+   * alias was recorded, or a method-matched caller is active. Checked after
+   * every import was noted, so the plugin can skip the call traversal.
+   */
+  hasMatchableCallers: () => boolean;
+  /**
+   * Analyses one call site. Returns `true` when the call belonged to a compat
+   * caller and was handled, `false` when the native path should look at it.
+   */
+  analyzeCall: (callExpressionPath: NodePath<BabelTypes.CallExpression>, localCallerName: string, isMethodCall: boolean) => boolean;
+  /** Analyses one JSX element, e.g. `<Trans i18nKey="…" />`. */
+  analyzeJsxElement: (jsxOpeningElementPath: NodePath<BabelTypes.JSXOpeningElement>) => void;
+};
+/**
+ * Builds the compat analyser for one source file, or `null` when no compat
+ * caller was injected — the base intlayer pipeline then runs untouched.
+ *
+ * @param babelTypes - Babel's type helpers.
+ * @param pruneContext - Shared analysis state to write into.
+ * @param compatCallers - Descriptors injected by the compat packages' plugins.
+ * @param fileContext - Path of the analysed file and whether it is an SFC.
+ */
+export declare const createCompatUsageAnalyzer: (babelTypes: typeof BabelTypes, pruneContext: PruneContext, compatCallers: readonly CallerDescriptor[], fileContext: {
+  sourceFilePath: string;
+  isSfcFile: boolean;
+}) => CompatUsageAnalyzer | null;
+//#endregion
+//# sourceMappingURL=usageAnalysis.d.ts.map

package/dist/types/compat/usageAnalysis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usageAnalysis.d.ts","names":[],"sources":["../../../src/compat/usageAnalysis.ts"],"mappings":";;;;;;;;;;;;;;;;;qBAgCa,8BAA2B,mBACnB,YAAU,cACf,cAAY,eACX,WAAW,6BAA2B,cACvC,kBAAgB,oBAGP;;AAAA,+BAOF;;;;;;;AAAA,qBAAA,SAAS,WAAW,iBAKrB;;;;;AAAA;;;;;;;;;YAgRV;;;;;EAKV,aACE,sBACA,sBACA;;;;;;EAOF;;;;;EAKA,cACE,oBAAoB,SAAS,WAAW,iBACxC,yBACA;;EAGF,oBACE,uBAAuB,SAAS,WAAW;;;;;;;;;;;qBAalC,4BAAyB,mBACjB,YAAU,cACf,cAAY,wBACF,oBAAkB;EAC3B;EAAwB;MACtC"}

package/dist/types/dictionaryImports.d.ts

@@ -0,0 +1,46 @@
+import * as BabelTypes from "@babel/types";
+//#region src/dictionaryImports.d.ts
+/**
+ * How a dictionary reaches a call site.
+ *
+ * - `static`  — the compiled JSON is imported directly.
+ * - `dynamic` — a generated per-locale loader is imported and resolved at
+ *               runtime (Suspense).
+ * - `fetch`   — same as `dynamic`, but the loader fetches remote content.
+ */
+export type ImportMode = 'static' | 'dynamic' | 'fetch';
+/**
+ * Builds the generated identifier for a dictionary key.
+ *
+ * Replicates the xxHash64 → Base-62 algorithm used by the SWC version and
+ * prefixes an underscore so the generated identifiers never collide with
+ * user-defined ones.
+ */
+export declare const makeDictionaryIdent: (babelTypes: typeof BabelTypes, key: string, mode: ImportMode) => BabelTypes.Identifier;
+/**
+ * The dictionary imports one file needs, accumulated while its call sites are
+ * rewritten and injected in one pass at the end.
+ *
+ * Both the native and the compat rewrites write here, so a dictionary read
+ * through `useIntlayer('about')` and through `useTranslation('about')` in the
+ * same file shares a single import.
+ *
+ * `dynamic` and `fetch` share one map because they occupy the same import
+ * slot, distinguished only by their identifier suffix — mirroring
+ * `InjectedImports` in the SWC plugin.
+ */
+export type DictionaryImportRegistry = {
+  /** Dictionary key → identifier of the static JSON (or nested companion) import. */
+  readonly staticImports: Map<string, BabelTypes.Identifier>;
+  /** Dictionary key → identifier of the dynamic / fetch loader import. */
+  readonly dynamicImports: Map<string, BabelTypes.Identifier>;
+  /**
+   * Returns the identifier for `key` in `mode`, creating and registering it on
+   * first use.
+   */
+  identFor: (key: string, mode: ImportMode) => BabelTypes.Identifier;
+};
+/** Creates an empty registry for one source file. */
+export declare const createDictionaryImportRegistry: (babelTypes: typeof BabelTypes) => DictionaryImportRegistry;
+//#endregion
+//# sourceMappingURL=dictionaryImports.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dictionaryImports.d.ts","names":[],"sources":["../../src/dictionaryImports.ts"],"mappings":";;;;;;;;;;YAWY;;;;;;;;qBAgBC,sBAAmB,mBACX,YAAU,aAClB,MACL,eACL,WAAW;;;;;;;;;;;;;YAeF;;WAED,eAAe,YAAY,WAAW;;WAEtC,gBAAgB,YAAY,WAAW;;;;;EAKhD,WAAW,aAAa,MAAM,eAAe,WAAW;;;qBAI7C,iCAA8B,mBACtB,eAClB"}

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

@@ -4,7 +4,7 @@ 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 = {
+export type BabelReplacement = {
   path: NodePath;
   key: string;
   type: 'jsx-text' | 'jsx-attribute' | 'string-literal' | 'jsx-insertion' | 'jsx-text-combined' | 'template-literal';
@@ -16,12 +16,12 @@ type BabelReplacement = {
  * Handles JSX insertions (elements with multiple children, including expressions).
  * Replaces complex JSX structures with variable-based translations.
  */
-declare const handleJsxInsertionBabel: (path: NodePath<t.JSXElement | t.JSXFragment>, fileCode: string, existingKeys: Set<string>, getComponentKeyForPath: (path: NodePath) => string, extractedContent: Record<string, Record<string, string>>, replacements: BabelReplacement[], handledNodes: Set<t.Node>) => boolean;
+export declare const handleJsxInsertionBabel: (path: NodePath<t.JSXElement | t.JSXFragment>, fileCode: string, existingKeys: Set<string>, getComponentKeyForPath: (path: NodePath) => string, extractedContent: Record<string, Record<string, string>>, replacements: BabelReplacement[], handledNodes: Set<t.Node>) => boolean;
 /**
  * Traverses the AST to identify components and extract content.
  * Returns extraction results and metadata about which components need Intlayer hooks.
  */
-declare const extractBabelContentForComponents: (ast: t.File, fileCode: string, existingKeys: Set<string>, defaultKey: string, configuration: IntlayerConfig, filePath: string, unmergedDictionaries?: Record<string, unknown>) => {
+export declare const extractBabelContentForComponents: (ast: t.File, fileCode: string, existingKeys: Set<string>, defaultKey: string, configuration: IntlayerConfig, filePath: string, unmergedDictionaries?: Record<string, unknown>) => {
   extractedContent: Record<string, Record<string, string>>;
   replacements: BabelReplacement[];
   componentsNeedingHooks: Set<NodePath>;
@@ -35,10 +35,9 @@ declare const extractBabelContentForComponents: (ast: t.File, fileCode: string,
 /**
  * High-level function to extract content from TS/JS/JSX/TSX AST.
  */
-declare const extractTsContent: (ast: t.File, fileCode: string, existingKeys: Set<string>, configuration: IntlayerConfig, filePath: string, unmergedDictionaries?: Record<string, unknown>) => {
+export declare const extractTsContent: (ast: t.File, fileCode: string, existingKeys: Set<string>, configuration: IntlayerConfig, filePath: string, unmergedDictionaries?: Record<string, unknown>) => {
   extractedContent: Record<string, string>;
   replacements: BabelReplacement[];
 };
 //#endregion
-export { BabelReplacement, extractBabelContentForComponents, extractTsContent, handleJsxInsertionBabel };
 //# sourceMappingURL=babelProcessor.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"babelProcessor.d.ts","names":[],"sources":["../../../src/extractContent/babelProcessor.ts"],"mappings":";;;;;;KAYY;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"}
+{"version":3,"file":"babelProcessor.d.ts","names":[],"sources":["../../../src/extractContent/babelProcessor.ts"],"mappings":";;;;;;YAYY;EACV,MAAM;EACN;EACA;EAOA;EACA,oBAAoB,EAAE;EACtB;;;;;;qBA4IW,0BAAuB,MAC5B,SAAS,EAAE,aAAa,EAAE,cAAY,kBAC5B,cACF,aAAW,yBACA,MAAM,qBAAmB,kBAChC,eAAe,yBAAuB,cAC1C,oBAAkB,cAClB,IAAI,EAAE;;;;;qBAwIT,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;;;;;qBA6ZW,mBAAgB,KACtB,EAAE,MAAI,kBACK,cACF,aAAW,eACV,gBAAc,kBACb,uBACM;EAEtB,kBAAkB;EAClB,cAAc"}

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

@@ -18,18 +18,17 @@ type DictionaryContentMap = Record<string, TranslationNode>;
  * - Keys in both: preserve existing translations, update default locale value
  * - Keys in existing but not in extracted: removed (no longer in source)
  */
-declare const mergeWithExistingMultilingualDictionary: (extractedContent: Record<string, string>, existingDictionary: Dictionary | null, defaultLocale: string) => DictionaryContentMap;
+export declare const mergeWithExistingMultilingualDictionary: (extractedContent: Record<string, string>, existingDictionary: Dictionary | null, defaultLocale: string) => DictionaryContentMap;
 /**
  * Merge extracted content with existing dictionary for per-locale format.
  * - Keys in extracted but not in existing: added
  * - Keys in both: update value
  * - Keys in existing but not in extracted: removed (no longer in source)
  */
-declare const mergeWithExistingPerLocaleDictionary: (extractedContent: Record<string, string>, existingDictionary: Dictionary | null) => Record<string, string>;
+export declare const mergeWithExistingPerLocaleDictionary: (extractedContent: Record<string, string>, existingDictionary: Dictionary | null) => Record<string, string>;
 /**
  * Helper to write extracted content to dictionary file(s).
  */
-declare const writeContentHelper: (extractedContent: Record<string, string>, dictionaryKey: DictionaryKey, filePath: string, configuration: IntlayerConfig) => Promise<string>;
+export declare const writeContentHelper: (extractedContent: Record<string, string>, dictionaryKey: DictionaryKey, filePath: string, configuration: IntlayerConfig) => Promise<string>;
 //#endregion
-export { mergeWithExistingMultilingualDictionary, mergeWithExistingPerLocaleDictionary, writeContentHelper };
 //# sourceMappingURL=contentWriter.d.ts.map

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"contentWriter.d.ts","names":[],"sources":["../../../src/extractContent/contentWriter.ts"],"mappings":";;;;;;KAmCK;EACH;EACA,aAAa;;;;;KAMV,uBAAuB,eAAe;;;;;;;qBAa9B,0CAAuC,kBAChC,wBAAsB,oBACpB,mBAAiB,0BAEpC;;;;;;;qBAkDU,uCAAoC,kBAC7B,wBAAsB,oBACpB,sBACnB;;;;qBA8CU,qBAAkB,kBACX,wBAAsB,eACzB,eAAa,kBACZ,eACD,mBACd"}

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

@@ -3,7 +3,7 @@ import "./utils/index.js";
 import { IntlayerConfig } from "@intlayer/types/config";
 import { GetConfigurationOptions } from "@intlayer/config/node";
 //#region src/extractContent/extractContent.d.ts
-type ExtractIntlayerOptions = {
+export type ExtractIntlayerOptions = {
   configOptions?: GetConfigurationOptions;
   codeOnly?: boolean;
   declarationOnly?: boolean;
@@ -20,7 +20,7 @@ type ExtractResult = {
   transformedCode: string | null;
   extractedContentMap: Record<string, Record<string, string>>;
 };
-declare const extractContent: (filePath: string, packageName: PackageName, options?: ExtractIntlayerOptions) => Promise<ExtractResult | undefined>;
+export declare const extractContent: (filePath: string, packageName: PackageName, options?: ExtractIntlayerOptions) => Promise<ExtractResult | undefined>;
 /**
  * Synchronous variant of `extractContent` — used by the Babel plugin which
  * runs in a sync transform context (e.g. Next.js / Webpack).
@@ -31,7 +31,6 @@ declare const extractContent: (filePath: string, packageName: PackageName, optio
  * - Does NOT write dictionary files or run the code formatter; callers that
  *   need persistence should supply an `onExtract` callback
  */
-declare const extractContentSync: (filePath: string, packageName: PackageName, options?: ExtractIntlayerOptions) => ExtractResult | undefined;
+export declare const extractContentSync: (filePath: string, packageName: PackageName, options?: ExtractIntlayerOptions) => ExtractResult | undefined;
 //#endregion
-export { ExtractIntlayerOptions, extractContent, extractContentSync };
 //# sourceMappingURL=extractContent.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"extractContent.d.ts","names":[],"sources":["../../../src/extractContent/extractContent.ts"],"mappings":";;;;;KAsBY;EACV,gBAAgB;EAChB;EACA;EACA,uBAAuB;EACvB,gBAAgB;EAChB;EACA,aAAa;IACX;IACA,SAAS;IACT;eACW;;KAsRV;EACH;EACA,qBAAqB,eAAe;;cAmCzB,iBAAc,kBACT,aACH,aAAW,UACd,2BACT,QAAQ;;;;;;;;;;;cA8EE,qBAAkB,kBACb,aACH,aAAW,UACd,2BACT"}
+{"version":3,"file":"extractContent.d.ts","names":[],"sources":["../../../src/extractContent/extractContent.ts"],"mappings":";;;;;YAsBY;EACV,gBAAgB;EAChB;EACA;EACA,uBAAuB;EACvB,gBAAgB;EAChB;EACA,aAAa;IACX;IACA,SAAS;IACT;eACW;;KAsRV;EACH;EACA,qBAAqB,eAAe;;qBAmCzB,iBAAc,kBACT,aACH,aAAW,UACd,2BACT,QAAQ;;;;;;;;;;;qBA8EE,qBAAkB,kBACb,aACH,aAAW,UACd,2BACT"}

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

@@ -2,7 +2,7 @@ import { PackageName } from "./utils/constants.js";
 import "./utils/index.js";
 import { IntlayerConfig } from "@intlayer/types/config";
 //#region src/extractContent/processTsxFile.d.ts
-type TextEdit = {
+export type TextEdit = {
   start: number;
   end: number;
   replacement: string;
@@ -10,10 +10,9 @@ type TextEdit = {
 /**
  * Processes a TSX/JSX/TS/JS file to extract content and inject Intlayer hooks/calls.
  */
-declare const processTsxFile: (filePath: string, componentKey: string, packageName: PackageName, configuration: IntlayerConfig, save?: boolean, unmergedDictionaries?: Record<string, unknown>, providedFileCode?: string) => {
+export declare const processTsxFile: (filePath: string, componentKey: string, packageName: PackageName, configuration: IntlayerConfig, save?: boolean, unmergedDictionaries?: Record<string, unknown>, providedFileCode?: string) => {
   extractedContent: Record<string, Record<string, string>>;
   modifiedCode: string;
 } | null;
 //#endregion
-export { TextEdit, processTsxFile };
 //# sourceMappingURL=processTsxFile.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"processTsxFile.d.ts","names":[],"sources":["../../../src/extractContent/processTsxFile.ts"],"mappings":";;;;KAcY;EACV;EACA;EACA;;;;;cA4BW,iBAAc,kBACT,sBACI,aACP,aAAW,eACT,gBAAc,gBAChB,uBACS,yBAAuB;EAG7C,kBAAkB,eAAe;EACjC"}
+{"version":3,"file":"processTsxFile.d.ts","names":[],"sources":["../../../src/extractContent/processTsxFile.ts"],"mappings":";;;;YAcY;EACV;EACA;EACA;;;;;qBA4BW,iBAAc,kBACT,sBACI,aACP,aAAW,eACT,gBAAc,gBAChB,uBACS,yBAAuB;EAG7C,kBAAkB,eAAe;EACjC"}

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

@@ -5,10 +5,9 @@
  *
  * Order matter for resolution
  */
-declare const packageList: readonly ['next-intlayer', 'react-intlayer', 'vue-intlayer', 'svelte-intlayer', 'preact-intlayer', 'solid-intlayer', 'angular-intlayer', 'lit-intlayer', 'express-intlayer', 'hono-intlayer', 'fastify-intlayer', 'adonis-intlayer', 'intlayer'];
+export declare const packageList: readonly ['next-intlayer', 'react-intlayer', 'vue-intlayer', 'svelte-intlayer', 'preact-intlayer', 'solid-intlayer', 'angular-intlayer', 'lit-intlayer', 'express-intlayer', 'hono-intlayer', 'fastify-intlayer', 'adonis-intlayer', 'intlayer'];
 /** Packages that support a `/server` sub-path for React Server Components. */
-declare const SERVER_CAPABLE_PACKAGES: ReadonlySet<string>;
-type PackageName = (typeof packageList)[number];
+export declare const SERVER_CAPABLE_PACKAGES: ReadonlySet<string>;
+export type PackageName = (typeof packageList)[number];
 //#endregion
-export { PackageName, SERVER_CAPABLE_PACKAGES, packageList };
 //# sourceMappingURL=constants.d.ts.map

package/dist/types/extractContent/utils/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","names":[],"sources":["../../../../src/extractContent/utils/constants.ts"],"mappings":";;;;;;;cAMa;;cAiBA,yBAAyB;KAI1B,sBAAsB"}
+{"version":3,"file":"constants.d.ts","names":[],"sources":["../../../../src/extractContent/utils/constants.ts"],"mappings":";;;;;;;qBAMa;;qBAiBA,yBAAyB;YAI1B,sBAAsB"}

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

@@ -3,7 +3,6 @@ import { PackageName } from "./constants.js";
 /**
  * Detects which intlayer package is used in the project by reading package.json.
  */
-declare const detectPackageName: (searchDir: string) => PackageName;
+export declare const detectPackageName: (searchDir: string) => PackageName;
 //#endregion
-export { detectPackageName };
 //# sourceMappingURL=detectPackageName.d.ts.map

package/dist/types/extractContent/utils/detectPackageName.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"detectPackageName.d.ts","names":[],"sources":["../../../../src/extractContent/utils/detectPackageName.ts"],"mappings":";;;;;cAOa,oBAAiB,sBAAwB"}
+{"version":3,"file":"detectPackageName.d.ts","names":[],"sources":["../../../../src/extractContent/utils/detectPackageName.ts"],"mappings":";;;;;qBAOa,oBAAiB,sBAAwB"}

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

@@ -2,8 +2,8 @@ import { Locale } from "@intlayer/types/allLocales";
 import { IntlayerConfig } from "@intlayer/types/config";
 import { FilePathPatternFunction } from "@intlayer/types/filePathPattern";
 //#region src/extractContent/utils/extractDictionaryInfo.d.ts
-declare const getOutput: (configuration: IntlayerConfig, locale?: Locale) => FilePathPatternFunction | false;
-type ResolveContentFilePaths = {
+export declare const getOutput: (configuration: IntlayerConfig, locale?: Locale) => FilePathPatternFunction | false;
+export type ResolveContentFilePaths = {
   absolutePath: string;
   relativePath: string;
   isPerLocale: boolean;
@@ -12,16 +12,15 @@ type ResolveContentFilePaths = {
  * Resolves the paths for the content files associated with a component.
  * Checks for existing dictionaries first.
  */
-declare const resolveContentFilePaths: (filePath: string, componentKey: string, configuration: IntlayerConfig, locale?: Locale) => Promise<ResolveContentFilePaths>;
-type ExtractDictionaryInfoOptions = {
+export declare const resolveContentFilePaths: (filePath: string, componentKey: string, configuration: IntlayerConfig, locale?: Locale) => Promise<ResolveContentFilePaths>;
+export type ExtractDictionaryInfoOptions = {
   configuration?: IntlayerConfig;
 };
 /**
  * Extracts the dictionary key and dictionary file path for a given component file.
  */
-declare const extractDictionaryInfo: (filePath: string, fileText: string, configuration: IntlayerConfig) => Promise<{
+export declare const extractDictionaryInfo: (filePath: string, fileText: string, configuration: IntlayerConfig) => Promise<{
   dictionaryKey: string;
 } & ResolveContentFilePaths>;
 //#endregion
-export { ExtractDictionaryInfoOptions, ResolveContentFilePaths, extractDictionaryInfo, getOutput, resolveContentFilePaths };
 //# sourceMappingURL=extractDictionaryInfo.d.ts.map

package/dist/types/extractContent/utils/extractDictionaryInfo.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extractDictionaryInfo.d.ts","names":[],"sources":["../../../../src/extractContent/utils/extractDictionaryInfo.ts"],"mappings":";;;;cAmBa,YAAS,eACL,gBAAc,SACpB,WACR;KA0CS;EACV;EACA;EACA;;;;;;cAOW,0BAAuB,kBAClB,sBACI,eACL,gBAAc,SACpB,WACR,QAAQ;KA+GC;EACV,gBAAgB;;;;;cAML,wBAAqB,kBAChB,kBACA,eACD,mBACd;EAEC;IACE"}
+{"version":3,"file":"extractDictionaryInfo.d.ts","names":[],"sources":["../../../../src/extractContent/utils/extractDictionaryInfo.ts"],"mappings":";;;;qBAmBa,YAAS,eACL,gBAAc,SACpB,WACR;YA0CS;EACV;EACA;EACA;;;;;;qBAOW,0BAAuB,kBAClB,sBACI,eACL,gBAAc,SACpB,WACR,QAAQ;YA+GC;EACV,gBAAgB;;;;;qBAML,wBAAqB,kBAChB,kBACA,eACD,mBACd;EAEC;IACE"}

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

@@ -4,8 +4,7 @@
  *
  * Example: "src/components/MyComponent/index.tsx" -> "comp-my-component"
  */
-declare const extractDictionaryKeyFromPath: (filePath: string, prefix?: string) => string;
-declare const extractDictionaryKey: (filePath: string, fileText: string, prefix?: string) => string;
+export declare const extractDictionaryKeyFromPath: (filePath: string, prefix?: string) => string;
+export declare const extractDictionaryKey: (filePath: string, fileText: string, prefix?: string) => string;
 //#endregion
-export { extractDictionaryKey, extractDictionaryKeyFromPath };
 //# sourceMappingURL=extractDictionaryKey.d.ts.map

package/dist/types/extractContent/utils/extractDictionaryKey.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extractDictionaryKey.d.ts","names":[],"sources":["../../../../src/extractContent/utils/extractDictionaryKey.ts"],"mappings":";;;;;;cASa,+BAA4B,kBACvB;cAkBL,uBAAoB,kBACf,kBACA"}
+{"version":3,"file":"extractDictionaryKey.d.ts","names":[],"sources":["../../../../src/extractContent/utils/extractDictionaryKey.ts"],"mappings":";;;;;;qBASa,+BAA4B,kBACvB;qBAkBL,uBAAoB,kBACf,kBACA"}

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

@@ -1,5 +1,4 @@
 //#region src/extractContent/utils/generateKey.d.ts
-declare const generateKey: (text: string, existingKeys: Set<string>) => string;
+export declare const generateKey: (text: string, existingKeys: Set<string>) => string;
 //#endregion
-export { generateKey };
 //# sourceMappingURL=generateKey.d.ts.map

package/dist/types/extractContent/utils/generateKey.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generateKey.d.ts","names":[],"sources":["../../../../src/extractContent/utils/generateKey.ts"],"mappings":";cAAa,cAAW,cACV,cACE"}
+{"version":3,"file":"generateKey.d.ts","names":[],"sources":["../../../../src/extractContent/utils/generateKey.ts"],"mappings":";qBAAa,cAAW,cACV,cACE"}

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

@@ -3,7 +3,6 @@ import { NodePath } from "@babel/traverse";
 /**
  * Resolves the name of the component from various function declaration types.
  */
-declare const getComponentName: (path: NodePath) => string | undefined;
+export declare const getComponentName: (path: NodePath) => string | undefined;
 //#endregion
-export { getComponentName };
 //# sourceMappingURL=getComponentName.d.ts.map

package/dist/types/extractContent/utils/getComponentName.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getComponentName.d.ts","names":[],"sources":["../../../../src/extractContent/utils/getComponentName.ts"],"mappings":";;;;;cAMa,mBAAgB,MAAU"}
+{"version":3,"file":"getComponentName.d.ts","names":[],"sources":["../../../../src/extractContent/utils/getComponentName.ts"],"mappings":";;;;;qBAMa,mBAAgB,MAAU"}

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

@@ -1,7 +1,7 @@
 import * as t from "@babel/types";
 import { NodePath } from "@babel/traverse";
 //#region src/extractContent/utils/getExistingIntlayerInfo.d.ts
-type ExistingIntlayerInfo = {
+export type ExistingIntlayerInfo = {
   key: string;
   hook: 'useIntlayer' | 'getIntlayer';
   /** The variable name used to store the call result (e.g. `t` in `const t = useIntlayer(...)`) */
@@ -16,7 +16,6 @@ type ExistingIntlayerInfo = {
 /**
  * Searches for an existing useIntlayer or getIntlayer call in the function body.
  */
-declare const getExistingIntlayerInfo: (path: NodePath) => ExistingIntlayerInfo | undefined;
+export declare const getExistingIntlayerInfo: (path: NodePath) => ExistingIntlayerInfo | undefined;
 //#endregion
-export { ExistingIntlayerInfo, getExistingIntlayerInfo };
 //# sourceMappingURL=getExistingIntlayerInfo.d.ts.map

package/dist/types/extractContent/utils/getExistingIntlayerInfo.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getExistingIntlayerInfo.d.ts","names":[],"sources":["../../../../src/extractContent/utils/getExistingIntlayerInfo.ts"],"mappings":";;;KAGY;EACV;EACA;;EAEA;;EAEA;;EAEA;;EAEA,oBAAoB,EAAE;;;;;cAMX,0BAAuB,MAC5B,aACL"}
+{"version":3,"file":"getExistingIntlayerInfo.d.ts","names":[],"sources":["../../../../src/extractContent/utils/getExistingIntlayerInfo.ts"],"mappings":";;;YAGY;EACV;EACA;;EAEA;;EAEA;;EAEA;;EAEA,oBAAoB,EAAE;;;;;qBAMX,0BAAuB,MAC5B,aACL"}

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

@@ -2,7 +2,6 @@
 /**
  * Gets an existing key for a given text or generates a new one.
  */
-declare const getOrGenerateKey: (text: string, componentKey: string, existingKeys: Set<string>, extractedContent: Record<string, Record<string, string>>) => string;
+export declare const getOrGenerateKey: (text: string, componentKey: string, existingKeys: Set<string>, extractedContent: Record<string, Record<string, string>>) => string;
 //#endregion
-export { getOrGenerateKey };
 //# sourceMappingURL=getOrGenerateKey.d.ts.map

package/dist/types/extractContent/utils/getOrGenerateKey.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getOrGenerateKey.d.ts","names":[],"sources":["../../../../src/extractContent/utils/getOrGenerateKey.ts"],"mappings":";;;;cAKa,mBAAgB,cACf,sBACQ,cACN,aAAW,kBACP,eAAe"}
+{"version":3,"file":"getOrGenerateKey.d.ts","names":[],"sources":["../../../../src/extractContent/utils/getOrGenerateKey.ts"],"mappings":";;;;qBAKa,mBAAgB,cACf,sBACQ,cACN,aAAW,kBACP,eAAe"}

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

@@ -5,7 +5,6 @@ import { IntlayerConfig } from "@intlayer/types/config";
  * Note: this chokidar-specific variant fetches unmergedDictionaries internally
  * from the configuration (unlike the `@intlayer/babel` version which takes it as a parameter).
  */
-declare const resolveDictionaryKey: (initialKey: string, filePath: string, configuration: IntlayerConfig, unmergedDictionaries?: Record<string, unknown>, usedKeys?: Set<string>) => string;
+export declare const resolveDictionaryKey: (initialKey: string, filePath: string, configuration: IntlayerConfig, unmergedDictionaries?: Record<string, unknown>, usedKeys?: Set<string>) => string;
 //#endregion
-export { resolveDictionaryKey };
 //# sourceMappingURL=resolveDictionaryKey.d.ts.map

package/dist/types/extractContent/utils/resolveDictionaryKey.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolveDictionaryKey.d.ts","names":[],"sources":["../../../../src/extractContent/utils/resolveDictionaryKey.ts"],"mappings":";;;;;;;cAYa,uBAAoB,oBACb,kBACF,eACD,gBAAc,uBACN,yBAAuB,WACpC"}
+{"version":3,"file":"resolveDictionaryKey.d.ts","names":[],"sources":["../../../../src/extractContent/utils/resolveDictionaryKey.ts"],"mappings":";;;;;;;qBAYa,uBAAoB,oBACb,kBACF,eACD,gBAAc,uBACN,yBAAuB,WACpC"}