@intlayer/babel 9.4.2 → 9.4.4

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

@@ -5,13 +5,13 @@ 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 = {
+export type ExtractResult = {
   dictionaryKey: string;
   filePath: string;
   content: Record<string, string>;
   locale: Locale;
 };
-type ExtractPluginOptions = {
+export type ExtractPluginOptions = {
   packageName?: PackageName;
   filesList: string[];
   enabled: boolean;
@@ -48,9 +48,8 @@ type State = PluginPass & {
  * };
  * ```
  */
-declare const intlayerExtractBabelPlugin: (_babel: {
+export declare const intlayerExtractBabelPlugin: (_babel: {
   types: typeof BabelTypes;
 }) => 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":";;;;;;;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"}
+{"version":3,"file":"babel-plugin-intlayer-extract.d.ts","names":[],"sources":["../../src/babel-plugin-intlayer-extract.ts"],"mappings":";;;;;;;YAeY;EACV;EACA;EACA,SAAS;EACT,QAAQ;;YAGE;EACV,cAAc;EACd;EACA;EAEA,iBAAiB;EACjB,eAAe;;;;;;EAMf,aAAa,QAAQ,yBAAyB;;;;EAI9C,SAAS;;KAGN,QAAQ;EAAe,MAAM;;;;;;;;;;;;;;;;;;;qBAmBrB,6BAA0B;EACrC,cAAc;MACZ,aAAa"}

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

@@ -6,7 +6,7 @@ import * as BabelTypes from "@babel/types";
  * Converts a zero-based index to a short alphabetic identifier.
  *   0 → 'a', 1 → 'b', …, 25 → 'z', 26 → 'aa', 27 → 'ab', …
  */
-declare const generateShortFieldName: (index: number) => string;
+export declare const generateShortFieldName: (index: number) => string;
 /**
  * Recursively builds a `NestedRenameMap` from a compiled dictionary content
  * value by traversing the intlayer node structure.
@@ -34,7 +34,7 @@ declare const generateShortFieldName: (index: number) => string;
  *
  * @param contentValue - The dictionary content value to analyse.
  */
-declare const buildNestedRenameMapFromContent: (contentValue: unknown) => NestedRenameMap;
+export declare const buildNestedRenameMapFromContent: (contentValue: unknown) => NestedRenameMap;
 /**
  * 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
@@ -46,21 +46,21 @@ declare const buildNestedRenameMapFromContent: (contentValue: unknown) => Nested
  * @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;
+export declare const getNestedRenameEntryAtPath: (renameMap: NestedRenameMap, fieldPath: readonly string[]) => NestedRenameEntry | undefined;
 /**
  * JSON-serialisable form of a {@link NestedRenameEntry}.
  *
  * Mirrors `FieldRenameNode` in the `@intlayer/swc` crate — both sides must stay
  * in sync.
  */
-type SerializedFieldRenameEntry = {
+export type SerializedFieldRenameEntry = {
   /** Short alphabetic alias the field is renamed to (`'a'`, `'b'`, …). */
   shortName: string;
   /** Rename table of the fields nested inside this one. */
   children: SerializedFieldRenameMap;
 };
 /** JSON-serialisable form of a {@link NestedRenameMap}. */
-type SerializedFieldRenameMap = Record<string, SerializedFieldRenameEntry>;
+export type SerializedFieldRenameMap = Record<string, SerializedFieldRenameEntry>;
 /**
  * Converts the field-rename tables of a {@link PruneContext} into a plain JSON
  * object, keyed by dictionary key.
@@ -74,7 +74,7 @@ type SerializedFieldRenameMap = Record<string, SerializedFieldRenameEntry>;
  * Empty tables are omitted as well, so the result is empty when there is
  * nothing to rename.
  */
-declare const serializeFieldRenameMap: (pruneContext: PruneContext) => Record<string, SerializedFieldRenameMap>;
+export declare const serializeFieldRenameMap: (pruneContext: PruneContext) => Record<string, SerializedFieldRenameMap>;
 /**
  * Rewrites dictionary content field accesses in the given program to the
  * short aliases defined in `pruneContext.dictionaryKeyToFieldRenameMap`.
@@ -99,7 +99,7 @@ declare const serializeFieldRenameMap: (pruneContext: PruneContext) => Record<st
  * {@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;
+export 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
@@ -109,9 +109,8 @@ declare const renameIntlayerFieldAccesses: (babelTypes: typeof BabelTypes, progr
  * `intlayerOptimizeBabelPlugin`, because the latter replaces `useIntlayer`
  * with `useDictionary`, erasing the dictionary-key information needed here.
  */
-declare const makeFieldRenameBabelPlugin: (pruneContext: PruneContext) => ({ types: babelTypes }: {
+export declare const makeFieldRenameBabelPlugin: (pruneContext: PruneContext) => ({ types: babelTypes }: {
   types: typeof BabelTypes;
 }) => PluginObject;
 //#endregion
-export { SerializedFieldRenameEntry, SerializedFieldRenameMap, buildNestedRenameMapFromContent, generateShortFieldName, getNestedRenameEntryAtPath, makeFieldRenameBabelPlugin, renameIntlayerFieldAccesses, serializeFieldRenameMap };
 //# sourceMappingURL=babel-plugin-intlayer-field-rename.d.ts.map

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

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

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

@@ -8,7 +8,7 @@ import * as BabelTypes from "@babel/types";
  * {@link getMinifyPluginOptions}) so the plugin does not read the intlayer
  * configuration file on every file transform.
  */
-type MinifyPluginOptions = {
+export type MinifyPluginOptions = {
   /**
    * Absolute path to the project root.  Used to look up the shared
    * {@link PruneContext} built by {@link intlayerPurgeBabelPlugin}.
@@ -75,9 +75,8 @@ type MinifyPluginOptions = {
  *   `useDictionary`, erasing the dictionary-key information needed to look up
  *   the rename map.
  */
-declare const intlayerMinifyBabelPlugin: (babel: {
+export declare const intlayerMinifyBabelPlugin: (babel: {
   types: typeof BabelTypes;
 }) => 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":";;;;;;;;;;KAgBY;;;;;EAKV;;;;;;EAOA;;;;;EAMA;;;;EAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAkDW,4BAAyB;EACpC,cAAc;MACZ"}
+{"version":3,"file":"babel-plugin-intlayer-minify.d.ts","names":[],"sources":["../../src/babel-plugin-intlayer-minify.ts"],"mappings":";;;;;;;;;;YAgBY;;;;;EAKV;;;;;;EAOA;;;;;EAMA;;;;EAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAkDW,4BAAyB;EACpC,cAAc;MACZ"}

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

@@ -6,7 +6,7 @@ declare const CALLER_LIST: readonly ['useIntlayer', 'getIntlayer', 'getIntlayerA
 /**
  * Options for the optimization Babel plugin
  */
-type OptimizePluginOptions = {
+export type OptimizePluginOptions = {
   /**
    * If false, the plugin will not apply any transformation.
    */
@@ -208,9 +208,8 @@ type State = PluginPass & {
  * const content2 = getIntlayer(_dicHash);
  * ```
  */
-declare const intlayerOptimizeBabelPlugin: (babel: {
+export declare const intlayerOptimizeBabelPlugin: (babel: {
   types: typeof BabelTypes;
 }) => 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":";;;;cA8BM;;;;KAwDM;;;;EAIV;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;;;;;;;;;;;;EAeA;;;;EAIA;;;;EAIA,oBAAoB;;;;EAOpB;;;;EAIA;;;;;;;;;;;;;;EAcA,gBAAgB;;KAGb,QAAQ;EACX,MAAM;;EAEN,oBAAoB,YAAY,WAAW;;EAE3C,qBAAqB,YAAY,WAAW;;EAE5C;;EAEA,aAAa,oBAAoB;;EAEjC,oBAAoB;;EAEpB,mBAAmB,YAAY;;EAE/B;;EAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+TW,8BAA2B;EACtC,cAAc;MACZ,aAAa"}
+{"version":3,"file":"babel-plugin-intlayer-optimize.d.ts","names":[],"sources":["../../src/babel-plugin-intlayer-optimize.ts"],"mappings":";;;;cA8BM;;;;YAwDM;;;;EAIV;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;;;;;;;;;;;;EAeA;;;;EAIA;;;;EAIA,oBAAoB;;;;EAOpB;;;;EAIA;;;;;;;;;;;;;;EAcA,gBAAgB;;KAGb,QAAQ;EACX,MAAM;;EAEN,oBAAoB,YAAY,WAAW;;EAE3C,qBAAqB,YAAY,WAAW;;EAE5C;;EAEA,aAAa,oBAAoB;;EAEjC,oBAAoB;;EAEpB,mBAAmB,YAAY;;EAE/B;;EAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA+TW,8BAA2B;EACtC,cAAc;MACZ,aAAa"}

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

@@ -11,7 +11,7 @@ import { NestedFieldReferences } from "@intlayer/core/dictionaryManipulator";
  * {@link getPurgePluginOptions}) so the plugin itself does not need to read
  * the configuration file on every file transform.
  */
-type PurgePluginOptions = {
+export type PurgePluginOptions = {
   /**
    * Absolute path to the project root.  Used as the cache key for the shared
    * {@link PruneContext} so two Babel transform pipelines for different
@@ -99,7 +99,7 @@ type PurgePluginOptions = {
  * Used by {@link intlayerMinifyBabelPlugin} to read the rename map without
  * creating a circular dependency.
  */
-declare const getSharedPruneContext: (baseDir: string) => PruneContext | null;
+export declare const getSharedPruneContext: (baseDir: string) => PruneContext | null;
 /**
  * Runs the full purge/minify pipeline for the given options, using a
  * module-level cache so the work happens at most once per process per
@@ -117,7 +117,7 @@ declare const getSharedPruneContext: (baseDir: string) => PruneContext | null;
  * in-place. Call it at most once per build, after the dictionaries have been
  * built.
  */
-declare const runIntlayerPurgePipeline: (options: PurgePluginOptions) => PruneContext;
+export declare const runIntlayerPurgePipeline: (options: PurgePluginOptions) => PruneContext;
 /**
  * Babel plugin that analyses all project source files and rewrites compiled
  * dictionary JSON files in-place to remove unused content fields
@@ -168,9 +168,8 @@ declare const runIntlayerPurgePipeline: (options: PurgePluginOptions) => PruneCo
  *   renaming is skipped, so the `keyPath` the visual editor receives keeps
  *   matching the unmerged dictionaries it edits.
  */
-declare const intlayerPurgeBabelPlugin: (_babel: {
+export declare const intlayerPurgeBabelPlugin: (_babel: {
   types: typeof BabelTypes;
 }) => PluginObject;
 //#endregion
-export { PurgePluginOptions, getSharedPruneContext, intlayerPurgeBabelPlugin, runIntlayerPurgePipeline };
 //# sourceMappingURL=babel-plugin-intlayer-purge.d.ts.map

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

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

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

@@ -10,7 +10,7 @@ import { NestedFieldReferences } from "@intlayer/core/dictionaryManipulator";
  *                  keep every field (no pruning possible).
  *   Set<string>  → the exact top-level content field names that were accessed.
  */
-type DictionaryFieldUsage = Set<string> | 'all';
+export type DictionaryFieldUsage = Set<string> | 'all';
 /**
  * One node in the nested field-rename tree.
  *
@@ -18,19 +18,19 @@ type DictionaryFieldUsage = Set<string> | 'all';
  *   children  – rename table for the next level of user-defined keys inside
  *               this field's value (empty when the value is a leaf / primitive).
  */
-type NestedRenameEntry = {
+export type NestedRenameEntry = {
   shortName: string;
   children: NestedRenameMap;
 };
 /** A level of the field-rename tree, mapping original field names to entries. */
-type NestedRenameMap = Map<string, NestedRenameEntry>;
+export 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 = {
+export type OpaqueFieldOccurrence = {
   /**
    * Original (pre-rename) user-defined field names from the content root to
    * the escaping value, e.g. `['sections', 'hero']` for
@@ -47,7 +47,7 @@ type OpaqueFieldOccurrence = {
  * All mutations happen during the usage-analysis `buildStart` phase; readers
  * only access this state during the subsequent `transform` phase.
  */
-type PruneContext = {
+export type PruneContext = {
   /**
    * Maps every dictionary key seen in source files to the set of top-level
    * content fields statically accessed, or `'all'` when the access pattern
@@ -117,7 +117,7 @@ type PruneContext = {
     dictionaryKey: string;
   }[]>;
 };
-declare const createPruneContext: () => PruneContext;
+export declare const createPruneContext: () => PruneContext;
 /**
  * Records `nest()` references in a prune context so nest targets stay
  * resolvable — and no larger than they need to be — after purge and minify.
@@ -145,7 +145,7 @@ declare const createPruneContext: () => PruneContext;
  * @param nestedDictionaryReferences - Nest-target key → referenced top-level
  *   fields, as returned by `getNestedDictionaryReferences`.
  */
-declare const preserveNestedDictionaryFields: (pruneContext: PruneContext, nestedDictionaryReferences: Map<string, NestedFieldReferences>) => void;
+export declare const preserveNestedDictionaryFields: (pruneContext: PruneContext, nestedDictionaryReferences: Map<string, NestedFieldReferences>) => void;
 /**
  * Methods the runtime attaches to a resolved content object rather than fields
  * declared in a `.content` file.
@@ -160,17 +160,17 @@ declare const preserveNestedDictionaryFields: (pruneContext: PruneContext, neste
  * as a fresh content root, and the call result is analysed again because the
  * helpers return the content object for chaining.
  */
-declare const CHAINABLE_RUNTIME_METHOD_NAMES: Set<string>;
+export declare const CHAINABLE_RUNTIME_METHOD_NAMES: Set<string>;
 /** Canonical intlayer caller names that trigger usage analysis. */
-declare const INTLAYER_CALLER_NAMES: readonly ['useIntlayer', 'getIntlayer', 'getIntlayerAsync'];
-type IntlayerCallerName = (typeof INTLAYER_CALLER_NAMES)[number];
+export declare const INTLAYER_CALLER_NAMES: readonly ['useIntlayer', 'getIntlayer', 'getIntlayerAsync'];
+export type IntlayerCallerName = (typeof INTLAYER_CALLER_NAMES)[number];
 /**
  * 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 = CallerDescriptor$1;
+export type CompatCallerConfig = CallerDescriptor$1;
 /**
  * Default registry of compat namespace callers.
  *
@@ -181,14 +181,14 @@ type CompatCallerConfig = CallerDescriptor$1;
  * core `@intlayer/babel` package to every compat adapter, which violates the
  * design principle that compat logic lives in compat packages.
  */
-declare const DEFAULT_COMPAT_CALLERS: CompatCallerConfig[];
+export declare const DEFAULT_COMPAT_CALLERS: CompatCallerConfig[];
 /**
  * Climbs past an enclosing `await` expression so that
  * `const t = await getTranslations('ns')` — or `await getIntlayerAsync('key')`
  * — is resolved to its variable declarator the same way the synchronous form
  * is.
  */
-declare const unwrapAwait: (babelTypes: typeof BabelTypes, path: NodePath<BabelTypes.Node>) => NodePath<BabelTypes.Node>;
+export declare const unwrapAwait: (babelTypes: typeof BabelTypes, path: NodePath<BabelTypes.Node>) => NodePath<BabelTypes.Node>;
 /**
  * Creates a Babel plugin that traverses source files and records which
  * top-level dictionary fields each `useIntlayer` / `getIntlayer` call-site —
@@ -203,11 +203,11 @@ declare const unwrapAwait: (babelTypes: typeof BabelTypes, path: NodePath<BabelT
  *                       {@link DEFAULT_COMPAT_CALLERS}; pass `[]` to disable
  *                       compat-adapter analysis entirely.
  */
-declare const makeUsageAnalyzerBabelPlugin: (pruneContext: PruneContext, options?: {
+export declare const makeUsageAnalyzerBabelPlugin: (pruneContext: PruneContext, options?: {
   compatCallers?: CompatCallerConfig[];
 }) => ({ types: babelTypes }: {
   types: typeof BabelTypes;
 }) => PluginObject;
 //#endregion
-export { CHAINABLE_RUNTIME_METHOD_NAMES, type CallerDescriptor, type CallerResultShape, type CallerValueSource, CompatCallerConfig, DEFAULT_COMPAT_CALLERS, DictionaryFieldUsage, INTLAYER_CALLER_NAMES, IntlayerCallerName, NestedRenameEntry, NestedRenameMap, OpaqueFieldOccurrence, PruneContext, createPruneContext, makeUsageAnalyzerBabelPlugin, preserveNestedDictionaryFields, unwrapAwait };
+export type { CallerDescriptor, CallerResultShape, CallerValueSource };
 //# 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":";;;;;;;;;;;;KAiBY,uBAAuB;;;;;;;;KASvB;EACV;EACA,UAAU;;;KAIA,kBAAkB,YAAY;;;;;;;KAQ9B;;;;;;EAMV;;EAGA;;;;;;;;;KAUU;;;;;;EAMV,8BAA8B,YAAY;;;;;EAM1C,2BAA2B;;;;;;EAO3B;;;;;;EAOA,qCAAqC;;;;;;EAOrC,+BAA+B,YAAY;;;;;;;;;;;;EAa3C,gCAAgC,YAE9B,YAAY;;;;;;;;;;;;;EAed,iCAAiC;;;;;;;;;;;EAYjC,0BAA0B;IAEtB;IAAsB;;;cAIf,0BAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAyCzB,iCAA8B,cAC3B,cAAY,4BACE,YAAY;;;;;;;;;;;;;;;cAqD7B,gCAA8B;;cAG9B;KAKD,6BAA6B;;;;;;;KAmB7B,qBAAqB;;;;;;;;;;;cAYpB,wBAAwB;;;;;;;cAWxB,cAAW,mBACH,YAAU,MACvB,SAAS,WAAW,UACzB,SAAS,WAAW;;;;;;;;;;;;;;;cA8rCV,+BAA4B,cAEvB,cAAY;EACd,gBAAgB;SAAsB,OAAA;EAE1B,cAAc;MAAe"}
+{"version":3,"file":"babel-plugin-intlayer-usage-analyzer.d.ts","names":[],"sources":["../../src/babel-plugin-intlayer-usage-analyzer.ts"],"mappings":";;;;;;;;;;;;YAiBY,uBAAuB;;;;;;;;YASvB;EACV;EACA,UAAU;;;YAIA,kBAAkB,YAAY;;;;;;;YAQ9B;;;;;;EAMV;;EAGA;;;;;;;;;YAUU;;;;;;EAMV,8BAA8B,YAAY;;;;;EAM1C,2BAA2B;;;;;;EAO3B;;;;;;EAOA,qCAAqC;;;;;;EAOrC,+BAA+B,YAAY;;;;;;;;;;;;EAa3C,gCAAgC,YAE9B,YAAY;;;;;;;;;;;;;EAed,iCAAiC;;;;;;;;;;;EAYjC,0BAA0B;IAEtB;IAAsB;;;qBAIf,0BAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAyCzB,iCAA8B,cAC3B,cAAY,4BACE,YAAY;;;;;;;;;;;;;;;qBAqD7B,gCAA8B;;qBAG9B;YAKD,6BAA6B;;;;;;;YAmB7B,qBAAqB;;;;;;;;;;;qBAYpB,wBAAwB;;;;;;;qBAWxB,cAAW,mBACH,YAAU,MACvB,SAAS,WAAW,UACzB,SAAS,WAAW;;;;;;;;;;;;;;;qBA8rCV,+BAA4B,cAEvB,cAAY;EACd,gBAAgB;SAAsB,OAAA;EAE1B,cAAc;MAAe"}

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/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"}

package/dist/types/extractScriptBlocks.d.ts

@@ -8,7 +8,7 @@
  *   `contentEndOffset`   – Byte offset one past the last byte of `content` in the
  *                          full source string (i.e. `source.slice(start, end) === content`).
  */
-type ScriptBlock = {
+export type ScriptBlock = {
   content: string;
   contentStartOffset: number;
   contentEndOffset: number;
@@ -27,7 +27,7 @@ type ScriptBlock = {
  *  - everything else → treats the whole file as a single script block and
  *    returns it wrapped in a single-element array.
  */
-declare const extractScriptBlocks: (filePath: string, code: string) => ScriptBlock[];
+export declare const extractScriptBlocks: (filePath: string, code: string) => ScriptBlock[];
 /**
  * Applies modified script block content back into the original source string.
  *
@@ -38,10 +38,9 @@ declare const extractScriptBlocks: (filePath: string, code: string) => ScriptBlo
  *
  * Returns `originalCode` unchanged when `modifications` is empty.
  */
-declare const injectScriptBlocks: (originalCode: string, modifications: ReadonlyArray<{
+export declare const injectScriptBlocks: (originalCode: string, modifications: ReadonlyArray<{
   block: ScriptBlock;
   modifiedContent: string;
 }>) => string;
 //#endregion
-export { ScriptBlock, extractScriptBlocks, injectScriptBlocks };
 //# sourceMappingURL=extractScriptBlocks.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"extractScriptBlocks.d.ts","names":[],"sources":["../../src/extractScriptBlocks.ts"],"mappings":";;;;;;;;;;KAWY;EACV;EACA;EACA;;;;;;;;;;;;;;;;cA8FW,sBAAmB,kBACd,iBAEf;;;;;;;;;;;cA+BU,qBAAkB,sBACT,eACL;EACb,OAAO;EACP"}
+{"version":3,"file":"extractScriptBlocks.d.ts","names":[],"sources":["../../src/extractScriptBlocks.ts"],"mappings":";;;;;;;;;;YAWY;EACV;EACA;EACA;;;;;;;;;;;;;;;;qBA8FW,sBAAmB,kBACd,iBAEf;;;;;;;;;;;qBA+BU,qBAAkB,sBACT,eACL;EACb,OAAO;EACP"}

package/dist/types/getExtractPluginOptions.d.ts

@@ -6,13 +6,12 @@ import { IntlayerConfig } from "@intlayer/types/config";
  * - 'dev': Development mode with HMR support
  * - 'build': Production build mode
  */
-type CompilerMode = 'dev' | 'build';
+export type CompilerMode = 'dev' | 'build';
 /**
  * Get the options for the Intlayer Babel extraction plugin
  * This function loads the Intlayer configuration and sets up the onExtract callback
  * to write dictionaries to the filesystem.
  */
-declare const getExtractPluginOptions: (configuration?: IntlayerConfig, isDev?: CompilerMode | string | undefined) => ExtractPluginOptions;
+export declare const getExtractPluginOptions: (configuration?: IntlayerConfig, isDev?: CompilerMode | string | undefined) => ExtractPluginOptions;
 //#endregion
-export { CompilerMode, getExtractPluginOptions };
 //# sourceMappingURL=getExtractPluginOptions.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getExtractPluginOptions.d.ts","names":[],"sources":["../../src/getExtractPluginOptions.ts"],"mappings":";;;;;;;;KAcY;;;;;;cAOC,0BAAuB,gBACnB,gBAAc,QACtB,sCACN"}
+{"version":3,"file":"getExtractPluginOptions.d.ts","names":[],"sources":["../../src/getExtractPluginOptions.ts"],"mappings":";;;;;;;;YAcY;;;;;;qBAOC,0BAAuB,gBACnB,gBAAc,QACtB,sCACN"}

package/dist/types/getOptimizePluginOptions.d.ts

@@ -27,7 +27,6 @@ type GetOptimizePluginOptionsParams = {
  * This function loads the Intlayer configuration and returns the paths
  * needed for dictionary optimization and import rewriting.
  */
-declare const getOptimizePluginOptions: (params?: GetOptimizePluginOptionsParams) => OptimizePluginOptions;
+export declare const getOptimizePluginOptions: (params?: GetOptimizePluginOptionsParams) => OptimizePluginOptions;
 //#endregion
-export { getOptimizePluginOptions };
 //# sourceMappingURL=getOptimizePluginOptions.d.ts.map

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

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

package/dist/types/getPurgePluginOptions.d.ts

@@ -44,7 +44,7 @@ type GetPurgePluginOptionsParams = {
  * };
  * ```
  */
-declare const getPurgePluginOptions: (params?: GetPurgePluginOptionsParams) => PurgePluginOptions;
+export declare const getPurgePluginOptions: (params?: GetPurgePluginOptionsParams) => PurgePluginOptions;
 type GetMinifyPluginOptionsParams = {
   /**
    * Options forwarded to the intlayer configuration loader.
@@ -76,7 +76,6 @@ type GetMinifyPluginOptionsParams = {
  * };
  * ```
  */
-declare const getMinifyPluginOptions: (params?: GetMinifyPluginOptionsParams) => MinifyPluginOptions;
+export declare const getMinifyPluginOptions: (params?: GetMinifyPluginOptionsParams) => MinifyPluginOptions;
 //#endregion
-export { getMinifyPluginOptions, getPurgePluginOptions };
 //# sourceMappingURL=getPurgePluginOptions.d.ts.map

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

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

package/dist/types/normalizedFilesList.d.ts

@@ -6,7 +6,6 @@
  * @param filesList - The plugin's `filesList` option (absolute file paths).
  * @returns A set of the same paths normalized via `normalizePath`.
  */
-declare const getNormalizedFilesListSet: (filesList: readonly string[]) => Set<string>;
+export declare const getNormalizedFilesListSet: (filesList: readonly string[]) => Set<string>;
 //#endregion
-export { getNormalizedFilesListSet };
 //# sourceMappingURL=normalizedFilesList.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"normalizedFilesList.d.ts","names":[],"sources":["../../src/normalizedFilesList.ts"],"mappings":";;;;;;;;cAiBa,4BAAyB,iCAEnC"}
+{"version":3,"file":"normalizedFilesList.d.ts","names":[],"sources":["../../src/normalizedFilesList.ts"],"mappings":";;;;;;;;qBAiBa,4BAAyB,iCAEnC"}

package/dist/types/transformers.d.ts

@@ -6,7 +6,7 @@ import { ParserOptions } from "@babel/parser";
  * Babel parser options covering the superset of syntaxes used across all
  * supported frameworks (React / Vue / Svelte / Angular / …).
  */
-declare const BABEL_PARSER_OPTIONS: ParserOptions;
+export declare const BABEL_PARSER_OPTIONS: ParserOptions;
 /**
  * Builds a fast pre-check regex that matches files potentially containing
  * native intlayer calls and/or the given compat namespace caller names.
@@ -26,25 +26,25 @@ declare const BABEL_PARSER_OPTIONS: ParserOptions;
  *   (e.g. `['useTranslation', 'getFixedT']` from `@intlayer/react-i18next`).
  * @returns A `RegExp` matching any of the native or provided caller names.
  */
-declare const buildUsageCheckRegex: (extraCallerNames?: string[]) => RegExp;
+export declare const buildUsageCheckRegex: (extraCallerNames?: string[]) => RegExp;
 /**
  * Fast pre-check: matches files that could contain native intlayer calls
  * (`useIntlayer` / `getIntlayer` / `getIntlayerAsync`). Used by the
  * optimize/transform pass, which only rewrites native calls.
  */
-declare const INTLAYER_USAGE_REGEX: RegExp;
+export declare const INTLAYER_USAGE_REGEX: RegExp;
 /**
  * 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.
  */
-declare const getUsageCheckRegex: (compatCallers?: readonly CompatCallerConfig[]) => RegExp;
+export declare const getUsageCheckRegex: (compatCallers?: readonly CompatCallerConfig[]) => RegExp;
 /**
  * Matches source files that are valid targets for usage analysis and Babel
  * transformation. Excludes sourcemap files, declaration files, and other
  * non-source extensions.
  */
-declare const SOURCE_FILE_REGEX: RegExp;
+export declare const SOURCE_FILE_REGEX: RegExp;
 /**
  * Runs the usage-analysis Babel plugin on a source file, accumulating
  * field-usage data into `pruneContext`.
@@ -57,14 +57,14 @@ declare const SOURCE_FILE_REGEX: RegExp;
  * Throws if Babel cannot parse the file (caller should handle and flag
  * `pruneContext.hasUnparsableSourceFiles`).
  */
-declare const analyzeFieldUsageInFile: (sourceFilePath: string, code: string, pruneContext: PruneContext, compatCallers?: CompatCallerConfig[]) => Promise<void>;
+export declare const analyzeFieldUsageInFile: (sourceFilePath: string, code: string, pruneContext: PruneContext, compatCallers?: CompatCallerConfig[]) => Promise<void>;
 /**
  * Applies field-renaming to a single JS/TS code string (not an SFC).
  *
  * Returns the renamed code string, or `null` if nothing changed or if
  * Babel failed to parse the input (caller should fall back to original code).
  */
-declare const renameFieldsInCode: (code: string, sourceFilePath: string, pruneContext: PruneContext) => Promise<string | null>;
+export declare const renameFieldsInCode: (code: string, sourceFilePath: string, pruneContext: PruneContext) => Promise<string | null>;
 /**
  * Applies field-renaming to a source file, correctly handling both plain
  * JS/TS files and SFC files (Vue / Svelte) by operating on each script block
@@ -72,7 +72,7 @@ declare const renameFieldsInCode: (code: string, sourceFilePath: string, pruneCo
  *
  * Returns the renamed code string, or `null` if nothing changed.
  */
-declare const renameFieldsInSourceFile: (sourceFilePath: string, code: string, pruneContext: PruneContext) => Promise<string | null>;
+export declare const renameFieldsInSourceFile: (sourceFilePath: string, code: string, pruneContext: PruneContext) => Promise<string | null>;
 /**
  * Runs the intlayer optimize Babel plugin on a source file, transforming
  * `useIntlayer('key')` / `getIntlayer('key')` calls into `useDictionary(_hash)`
@@ -81,10 +81,9 @@ declare const renameFieldsInSourceFile: (sourceFilePath: string, code: string, p
  * Returns `{ code, map }` on success, or `null` if the transformation produced
  * no output.
  */
-declare const optimizeSourceFile: (code: string, sourceFilePath: string, options: OptimizePluginOptions) => Promise<{
+export declare const optimizeSourceFile: (code: string, sourceFilePath: string, options: OptimizePluginOptions) => Promise<{
   code: string;
   map: string | object | null | undefined;
 } | null>;
 //#endregion
-export { BABEL_PARSER_OPTIONS, INTLAYER_USAGE_REGEX, SOURCE_FILE_REGEX, analyzeFieldUsageInFile, buildUsageCheckRegex, getUsageCheckRegex, optimizeSourceFile, renameFieldsInCode, renameFieldsInSourceFile };
 //# sourceMappingURL=transformers.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"transformers.d.ts","names":[],"sources":["../../src/transformers.ts"],"mappings":";;;;;;;;cA0Ba,sBAAsB;;;;;;;;;;;;;;;;;;;;cAsCtB,uBAAoB,gCAAkC;;;;;;cAWtD,sBAAoB;;;;;;cAgBpB,qBAAkB,yBACJ,yBACxB;;;;;;cAoBU,mBAAiB;;;;;;;;;;;;;cAqCjB,0BAAuB,wBACZ,cACV,cACE,cAAY,gBACV,yBACf;;;;;;;cAyBU,qBAAkB,cACjB,wBACU,cACR,iBACb;;;;;;;;cAqBU,2BAAwB,wBACb,cACV,cACE,iBACb;;;;;;;;;cA8CU,qBAAkB,cACjB,wBACU,SACb,0BACR;EACD;EACA"}
+{"version":3,"file":"transformers.d.ts","names":[],"sources":["../../src/transformers.ts"],"mappings":";;;;;;;;qBA0Ba,sBAAsB;;;;;;;;;;;;;;;;;;;;qBAsCtB,uBAAoB,gCAAkC;;;;;;qBAWtD,sBAAoB;;;;;;qBAgBpB,qBAAkB,yBACJ,yBACxB;;;;;;qBAoBU,mBAAiB;;;;;;;;;;;;;qBAqCjB,0BAAuB,wBACZ,cACV,cACE,cAAY,gBACV,yBACf;;;;;;;qBAyBU,qBAAkB,cACjB,wBACU,cACR,iBACb;;;;;;;;qBAqBU,2BAAwB,wBACb,cACV,cACE,iBACb;;;;;;;;;qBA8CU,qBAAkB,cACjB,wBACU,SACb,0BACR;EACD;EACA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intlayer/babel",
-  "version": "9.4.2",
+  "version": "9.4.4",
   "private": false,
   "description": "A Babel plugin for Intlayer that transforms declaration files and provides internationalization features during the build process according to the Intlayer configuration.",
   "keywords": [
@@ -89,12 +89,12 @@
     "@babel/plugin-syntax-jsx": "8.0.1",
     "@babel/traverse": "8.0.4",
     "@babel/types": "8.0.4",
-    "@intlayer/config": "9.4.2",
-    "@intlayer/core": "9.4.2",
-    "@intlayer/dictionaries-entry": "9.4.2",
-    "@intlayer/engine": "9.4.2",
-    "@intlayer/types": "9.4.2",
-    "@intlayer/unmerged-dictionaries-entry": "9.4.2"
+    "@intlayer/config": "9.4.4",
+    "@intlayer/core": "9.4.4",
+    "@intlayer/dictionaries-entry": "9.4.4",
+    "@intlayer/engine": "9.4.4",
+    "@intlayer/types": "9.4.4",
+    "@intlayer/unmerged-dictionaries-entry": "9.4.4"
   },
   "devDependencies": {
     "@babel/plugin-syntax-jsx": "8.0.1",
@@ -107,13 +107,13 @@
     "@utils/tsdown-config": "1.0.4",
     "@vitejs/plugin-react": "6.1.1",
     "rimraf": "6.1.3",
-    "tsdown": "0.22.14",
+    "tsdown": "0.23.0",
     "typescript": "7.0.2",
-    "vitest": "4.1.11"
+    "vitest": "5.0.0"
   },
   "peerDependencies": {
-    "@intlayer/svelte-compiler": "9.4.2",
-    "@intlayer/vue-compiler": "9.4.2"
+    "@intlayer/svelte-compiler": "9.4.4",
+    "@intlayer/vue-compiler": "9.4.4"
   },
   "peerDependenciesMeta": {
     "@intlayer/svelte-compiler": {