@intlayer/babel 9.5.10 → 9.5.12

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

@@ -1,6 +1,5 @@
 import { PackageName } from "./extractContent/utils/constants.js";
-import { PluginObject, PluginPass } from "@babel/core";
-import * as BabelTypes from "@babel/types";
+import { PluginTarget } from "@babel/core";
 import { Locale } from "@intlayer/types/allLocales";
 import { IntlayerConfig } from "@intlayer/types/config";
 import { FilePathPattern } from "@intlayer/types/filePathPattern";
@@ -28,28 +27,15 @@ export type ExtractPluginOptions = {
    */
   output?: FilePathPattern;
 };
-type State = PluginPass & {
-  opts: ExtractPluginOptions;
-};
 /**
- * Babel plugin that extracts translatable content from source files and
- * injects Intlayer hooks (`useIntlayer` / `getIntlayer`) automatically.
- *
- * Designed for use with Babel-based build tools such as Next.js and Webpack.
+ * Intlayer extract Babel plugin (see `extractBabelPlugin`), typed as Babel's
+ * `PluginTarget`.
  *
- * @example babel.config.js
- * ```js
- * const { intlayerExtractBabelPlugin, getExtractPluginOptions } = require('@intlayer/babel');
- * module.exports = {
- *   presets: ['next/babel'],
- *   plugins: [
- *     [intlayerExtractBabelPlugin, getExtractPluginOptions()],
- *   ],
- * };
- * ```
+ * Babel types tuple options as `object` (`[PluginTarget<object>, object]`), so
+ * a plugin whose handlers read typed `this.opts` is rejected in
+ * `plugins: [[plugin, options]]` under `strict`. The options passed in the
+ * tuple are the typed options read by the handlers.
  */
-export declare const intlayerExtractBabelPlugin: (_babel: {
-  types: typeof BabelTypes;
-}) => PluginObject<State>;
+export declare const intlayerExtractBabelPlugin: PluginTarget;
 //#endregion
 //# 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":";;;;;;;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"}
+{"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;;;;;;;;;;;qBA6HE,4BAA4B"}

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":";;;;;;;;;qBA2Ba,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"}
+{"version":3,"file":"babel-plugin-intlayer-field-rename.d.ts","names":[],"sources":["../../src/babel-plugin-intlayer-field-rename.ts"],"mappings":";;;;;;;;;qBA8Ba,yBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA0CtB,kCAA+B,0BAEzC;;;;;;;;;;;;qBA2EU,6BAA0B,WAC1B,iBAAe,iCAEzB;;;;;;;YAqBS;;EAEV;;EAEA,UAAU;;;YAIA,2BAA2B,eAErC;;;;;;;;;;;;;;qBAgCW,0BAAuB,cACpB,iBACb,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;qBA8dL,8BAA2B,mBACnB,YAAU,aAChB,SAAS,WAAW,UAAQ,cAC3B;;;;;;;;;;qBAyIH,6BAA0B,cACtB,oBAAY,OAAA;EACD,cAAc;MAAe"}

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

@@ -1,5 +1,4 @@
-import { PluginObject, PluginPass } from "@babel/core";
-import * as BabelTypes from "@babel/types";
+import { PluginTarget } from "@babel/core";
 import { CallerDescriptor } from "@intlayer/config/callers";
 //#region src/babel-plugin-intlayer-optimize.d.ts
 /**
@@ -93,117 +92,14 @@ export type OptimizePluginOptions = {
   compatCallers?: CallerDescriptor[];
 };
 /**
- * Per-file plugin state.
+ * Intlayer optimize Babel plugin (see `optimizeBabelPlugin`), typed as Babel's
+ * `PluginTarget`.
  *
- * Only the two flags that have to survive from `pre` / `Program.enter` into
- * `Program.exit` live here — the caller maps and the import registry are built
- * and consumed inside `exit`, so they stay local to it.
+ * Babel types tuple options as `object` (`[PluginTarget<object>, object]`), so
+ * a plugin whose handlers read typed `this.opts` is rejected in
+ * `plugins: [[plugin, options]]` under `strict`. The options passed in the
+ * tuple are the typed options read by the handlers.
  */
-type State = PluginPass & {
-  opts: OptimizePluginOptions;
-  /** Whether the current file *is* a generated dictionaries entry file. */
-  _isDictEntry?: boolean;
-  /** Whether the current file is covered by the `filesList` allowlist. */
-  _isIncluded?: boolean;
-};
-/**
- * Babel plugin that transforms Intlayer function calls and auto-imports dictionaries.
- *
- * This plugin transforms calls to `useIntlayer()`, `getIntlayer()` and
- * `getIntlayerAsync()` from various Intlayer packages into optimized dictionary
- * access patterns, automatically importing the required dictionary files based
- * on the configured import mode.
- *
- * ## Supported Input Patterns
- *
- * The plugin recognizes these function calls:
- *
- * ```ts
- * // useIntlayer
- * import { useIntlayer } from 'react-intlayer';
- * import { useIntlayer } from 'next-intlayer';
- *
- * // getIntlayer / getIntlayerAsync
- * import { getIntlayer, getIntlayerAsync } from 'intlayer';
- *
- * // Usage
- * const content = useIntlayer('app');
- * const content = getIntlayer('app');
- * const content = await getIntlayerAsync('app', locale);
- * ```
- *
- * `getIntlayerAsync` is the exception to the mode table below: it always
- * resolves to the per-locale loader (`getDictionaryAsync`), in every import
- * mode, since loading a single locale is what it exists for.
- *
- * **Output (any mode):**
- * ```ts
- * import _dicHash_dyn from '../../.intlayer/dynamic_dictionaries/app.mjs';
- * import { getDictionaryAsync as getIntlayerAsync } from 'intlayer';
- *
- * const content = await getIntlayerAsync(_dicHash_dyn, 'app', locale);
- * ```
- *
- * ## Transformation Modes
- *
- * ### Static Mode (default: `importMode = "static"`)
- *
- * Imports JSON dictionaries directly and replaces function calls with dictionary access:
- *
- * **Output:**
- * ```ts
- * import _dicHash from '../../.intlayer/dictionaries/app.json' with { type: 'json' };
- * import { useDictionary as useIntlayer } from 'react-intlayer';
- * import { getDictionary as getIntlayer } from 'intlayer';
- *
- * const content1 = useIntlayer(_dicHash);
- * const content2 = getIntlayer(_dicHash);
- * ```
- *
- * ### Dynamic Mode (`importMode = "dynamic"`)
- *
- * Uses dynamic dictionary loading with Suspense support:
- *
- * **Output:**
- * ```ts
- * import _dicHash from '../../.intlayer/dictionaries/app.json' with { type: 'json' };
- * import _dicHash_dyn from '../../.intlayer/dynamic_dictionaries/app.mjs';
- * import { useDictionaryDynamic as useIntlayer } from 'react-intlayer';
- * import { getDictionary as getIntlayer } from 'intlayer';
- *
- * const content1 = useIntlayer(_dicHash_dyn, 'app');
- * const content2 = getIntlayer(_dicHash);
- * ```
- *
- * ### Fetch Mode (`importMode = "fetch"`)
- *
- * Uses fetch-based dictionary loading for remote dictionaries:
- *
- * **Output if `dictionaryModeMap` includes the key with "fetch" value:**
- * ```ts
- * import _dicHash from '../../.intlayer/dictionaries/app.json' with { type: 'json' };
- * import _dicHash_fetch from '../../.intlayer/fetch_dictionaries/app.mjs';
- * import { useDictionaryDynamic as useIntlayer } from 'react-intlayer';
- * import { getDictionary as getIntlayer } from 'intlayer';
- *
- * const content1 = useIntlayer(_dicHash_fetch, "app");
- * const content2 = getIntlayer(_dicHash);
- * ```
- *
- * > If `dictionaryModeMap` does not include the key with "fetch" value, the plugin will fallback to the dynamic import mode.
- *
- * ```ts
- * import _dicHash from '../../.intlayer/dictionaries/app.json' with { type: 'json' };
- * import _dicHash_dyn from '../../.intlayer/dynamic_dictionaries/app.mjs';
- * import { useDictionaryDynamic as useIntlayer } from 'react-intlayer';
- * import { getDictionary as getIntlayer } from 'intlayer';
- *
- * const content1 = useIntlayer(_dicHash_dyn, 'app');
- * const content2 = getIntlayer(_dicHash);
- * ```
- */
-export declare const intlayerOptimizeBabelPlugin: (babel: {
-  types: typeof BabelTypes;
-}) => PluginObject<State>;
+export declare const intlayerOptimizeBabelPlugin: PluginTarget;
 //#endregion
 //# 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":";;;;;;;YAmGY;;;;EAIV;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;;;;;;;;;;;;EAeA;;;;EAIA;;;;EAIA,oBAAoB;;;;EAOpB;;;;EAIA;;;;;;;;;;;;;;EAcA,gBAAgB;;;;;;;;;KAUb,QAAQ;EACX,MAAM;;EAEN;;EAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAgTW,8BAA2B;EACtC,cAAc;MACZ,aAAa"}
+{"version":3,"file":"babel-plugin-intlayer-optimize.d.ts","names":[],"sources":["../../src/babel-plugin-intlayer-optimize.ts"],"mappings":";;;;;;YAmGY;;;;EAIV;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;;;;;;;;;;;;EAeA;;;;EAIA;;;;EAIA,oBAAoB;;;;EAOpB;;;;EAIA;;;;;;;;;;;;;;EAcA,gBAAgB;;;;;;;;;;;qBAyyBL,6BAA6B"}

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":";;;;;;;;;;;;;;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"}
+{"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;;;;;;;;;;;;;;;;;;qBA4rB3C,2BAAwB,SAC1B,uBACR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAmIU,2BAAwB;EACnC,cAAc;MACZ"}

package/dist/types/staticAstReaders.d.ts

@@ -80,5 +80,46 @@ export declare const splitNamespace: (namespace: string) => {
  * is.
  */
 export declare const unwrapAwait: (babelTypes: typeof BabelTypes, path: NodePath<BabelTypes.Node>) => NodePath<BabelTypes.Node>;
+/**
+ * Climbs past every enclosing value-preserving wrapper (see
+ * {@link isTransparentWrapper}), so `(content.field as any).sub` is walked the
+ * same way as `content.field.sub`.
+ */
+export declare const skipTransparentWrappers: (babelTypes: typeof BabelTypes, path: NodePath<BabelTypes.Node>) => NodePath<BabelTypes.Node>;
+/** How the value of a content-producing expression is consumed. */
+export type ContentRootResolution =
+/** Consumed inline — inspect `rootPath.parent` (member access, argument…). */
+{
+  kind: 'expression';
+  rootPath: NodePath<BabelTypes.Node>;
+} |
+/** Stored into a local binding (`const x = …` / `const { a } = …`). */
+{
+  kind: 'binding';
+  rootPath: NodePath<BabelTypes.Node>;
+  bindingTarget: BabelTypes.Identifier | BabelTypes.ObjectPattern;
+} |
+/** Skipped by an array-pattern hole (`const [, b] = await Promise.all(…)`). */
+{
+  kind: 'discarded';
+};
+/**
+ * Resolves where the content returned by `path` (a `useIntlayer('key')` call
+ * or any expression evaluating to the same content) ends up.
+ *
+ * Looks through TypeScript casts, parentheses and `await`, and through
+ * `const [a, { b }] = await Promise.all([getIntlayerAsync('x'), …])`, where the
+ * array-pattern element at the call's index is the binding target.
+ *
+ * Both the usage analyser and the field renamer resolve roots through this
+ * function, so every shape the analyser tracks is one the renamer rewrites.
+ */
+export declare const resolveContentRoot: (babelTypes: typeof BabelTypes, path: NodePath<BabelTypes.Node>) => ContentRootResolution;
+/**
+ * Returns `true` when the value at `path` is only tested, never read: `!x`,
+ * `typeof x`, `if (x)`, `x ? … : …`, `x && …`, `x === y`. Such uses expose no
+ * key names, so they neither block pruning nor make a field opaque.
+ */
+export declare const isTestOnlyUse: (babelTypes: typeof BabelTypes, path: NodePath<BabelTypes.Node>) => boolean;
 //#endregion
 //# sourceMappingURL=staticAstReaders.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"staticAstReaders.d.ts","names":[],"sources":["../../src/staticAstReaders.ts"],"mappings":";;;;;;;;;;;;;;;;;qBAkBa,mBAAgB,mBACR,YAAU,MACvB,WAAW;;qBAeN,mBAAgB;;;;;;;;;qBAWhB,yBAAsB,mBACd,YAAU,MACvB,WAAW;;qBAkBN,qBAAkB,mBACV,YAAU,UACnB,WAAW,gBAAc;;;;;;qBAWxB,qBAAkB,mBACV,YAAU,kBACX,WAAW,kBAAgB,yBAE5C,WAAW;;;;;;qBAaD;;YAGD,eAAe,KAAK,WAAW;;;;;;qBAO9B,qBAAkB,mBACV,YAAU,kBACX,WAAW,kBAAgB,yBAE5C;;;;;;qBAeU,yBAAsB,mBACd,YAAU,kBACX,WAAW,kBAAgB,yBAE5C,eAAe,WAAW;;;;;;;qBAgBhB,yBAAsB,mBACd,YAAU,gBACb,WAAW,mBAAiB,0BAE3C,WAAW;;;;;;;;qBAgCD,iBAAc;EAEtB;EAAuB;;;;;;;;qBAef,cAAW,mBACH,YAAU,MACvB,SAAS,WAAW,UACzB,SAAS,WAAW"}
+{"version":3,"file":"staticAstReaders.d.ts","names":[],"sources":["../../src/staticAstReaders.ts"],"mappings":";;;;;;;;;;;;;;;;;qBAkBa,mBAAgB,mBACR,YAAU,MACvB,WAAW;;qBAeN,mBAAgB;;;;;;;;;qBAWhB,yBAAsB,mBACd,YAAU,MACvB,WAAW;;qBAkBN,qBAAkB,mBACV,YAAU,UACnB,WAAW,gBAAc;;;;;;qBAWxB,qBAAkB,mBACV,YAAU,kBACX,WAAW,kBAAgB,yBAE5C,WAAW;;;;;;qBAaD;;YAGD,eAAe,KAAK,WAAW;;;;;;qBAO9B,qBAAkB,mBACV,YAAU,kBACX,WAAW,kBAAgB,yBAE5C;;;;;;qBAeU,yBAAsB,mBACd,YAAU,kBACX,WAAW,kBAAgB,yBAE5C,eAAe,WAAW;;;;;;;qBAgBhB,yBAAsB,mBACd,YAAU,gBACb,WAAW,mBAAiB,0BAE3C,WAAW;;;;;;;;qBAgCD,iBAAc;EAEtB;EAAuB;;;;;;;;qBAef,cAAW,mBACH,YAAU,MACvB,SAAS,WAAW,UACzB,SAAS,WAAW;;;;;;qBA6BV,0BAAuB,mBACf,YAAU,MACvB,SAAS,WAAW,UACzB,SAAS,WAAW;;YAwCX;;;EAEN;EAAoB,UAAU,SAAS,WAAW;;;;EAGlD;EACA,UAAU,SAAS,WAAW;EAC9B,eAAe,WAAW,aAAa,WAAW;;;;EAGlD;;;;;;;;;;;;;qBAaO,qBAAkB,mBACV,YAAU,MACvB,SAAS,WAAW,UACzB;;;;;;qBAwEU,gBAAa,mBACL,YAAU,MACvB,SAAS,WAAW"}

package/dist/types/transformers.d.ts

@@ -79,10 +79,17 @@ export declare const renameFieldsInSourceFile: (sourceFilePath: string, code: st
  * `useIntlayer('key')` / `getIntlayer('key')` calls into `useDictionary(_hash)`
  * / `getDictionary(_hash)` and injecting the corresponding dictionary imports.
  *
+ * When `fieldRenamePruneContext` is given, dictionary field accesses are
+ * renamed in the same Babel pass (see {@link renameFieldsInSourceFile}): the
+ * rename plugin is listed first, so its `Program.exit` sees the dictionary
+ * keys before the optimize plugin's `Program.exit` erases them — saving a
+ * full parse and code generation per file. `code` must be plain or compiled
+ * JS, as in a bundler's post-transform hook.
+ *
  * Returns `{ code, map }` on success, or `null` if the transformation produced
  * no output.
  */
-export declare const optimizeSourceFile: (code: string, sourceFilePath: string, options: OptimizePluginOptions) => Promise<{
+export declare const optimizeSourceFile: (code: string, sourceFilePath: string, options: OptimizePluginOptions, fieldRenamePruneContext?: PruneContext) => Promise<{
   code: string;
   map: string | object | null | undefined;
 } | null>;

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

@@ -1 +1 @@
-{"version":3,"file":"transformers.d.ts","names":[],"sources":["../../src/transformers.ts"],"mappings":";;;;;;;;;qBA0Ba,sBAAsB;;;;;;;;;;;;;;;;;;;;qBAiCtB,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"}
+{"version":3,"file":"transformers.d.ts","names":[],"sources":["../../src/transformers.ts"],"mappings":";;;;;;;;;qBA0Ba,sBAAsB;;;;;;;;;;;;;;;;;;;;qBAiCtB,uBAAoB,gCAAkC;;;;;;qBAWtD,sBAAoB;;;;;;qBAgBpB,qBAAkB,yBACJ,yBACxB;;;;;;qBAoBU,mBAAiB;;;;;;;;;;;;;qBA8DjB,0BAAuB,wBACZ,cACV,cACE,cAAY,gBACV,yBACf;;;;;;;qBAyBU,qBAAkB,cACjB,wBACU,cACR,iBACb;;;;;;;;qBAqBU,2BAAwB,wBACb,cACV,cACE,iBACb;;;;;;;;;;;;;;;;qBAiDU,qBAAkB,cACjB,wBACU,SACb,uBAAqB,0BACJ,iBACzB;EACD;EACA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intlayer/babel",
-  "version": "9.5.10",
+  "version": "9.5.12",
   "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": [
@@ -90,11 +90,11 @@
     "@babel/plugin-syntax-jsx": "8.0.1",
     "@babel/traverse": "8.0.5",
     "@babel/types": "8.0.5",
-    "@intlayer/config": "9.5.10",
-    "@intlayer/core": "9.5.10",
-    "@intlayer/dictionaries-entry": "9.5.10",
-    "@intlayer/engine": "9.5.10",
-    "@intlayer/types": "9.5.10"
+    "@intlayer/config": "9.5.12",
+    "@intlayer/core": "9.5.12",
+    "@intlayer/dictionaries-entry": "9.5.12",
+    "@intlayer/engine": "9.5.12",
+    "@intlayer/types": "9.5.12"
   },
   "devDependencies": {
     "@babel/plugin-syntax-jsx": "8.0.1",
@@ -112,8 +112,8 @@
     "vitest": "5.0.2"
   },
   "peerDependencies": {
-    "@intlayer/svelte-compiler": "9.5.10",
-    "@intlayer/vue-compiler": "9.5.10"
+    "@intlayer/svelte-compiler": "9.5.12",
+    "@intlayer/vue-compiler": "9.5.12"
   },
   "peerDependenciesMeta": {
     "@intlayer/svelte-compiler": {