@intlayer/core 9.4.0-canary.0 → 9.4.1

package/README.md

@@ -214,6 +214,7 @@ Explore our comprehensive documentation to get started with Intlayer and learn h
   <li><a href="https://intlayer.org/doc/environment/vite-and-vue" rel=''>Vite + Vue</a></li>
   <li><a href="https://intlayer.org/doc/environment/nuxt-and-vue" rel=''>Vite + Nuxt</a></li>
   <li><a href="https://intlayer.org/doc/environment/vite-and-solid" rel=''>Vite + Solid</a></li>
+  <li><a href="https://intlayer.org/doc/environment/solid-start" rel=''>Solid Start</a></li>
   <li><a href="https://intlayer.org/doc/environment/angular" rel=''>Angular</a></li>
   <li>
      <a href="https://intlayer.org/doc/environment/express" rel=''>Backend</a>
@@ -223,7 +224,9 @@ Explore our comprehensive documentation to get started with Intlayer and learn h
       <li><a href="https://intlayer.org/doc/environment/fastify" rel=''>Fastify</a></li>
       <li><a href="https://intlayer.org/doc/environment/adonisjs" rel=''>AdonisJS</a></li>
       <li><a href="https://intlayer.org/doc/environment/hono" rel=''>Hono</a></li>
+      <li><a href="https://intlayer.org/doc/environment/elysia" rel=''>Elysia</a></li>
     </ul>
+
   </li>
 </ul>
 </details>

package/dist/cjs/dictionaryManipulator/index.cjs

@@ -1,5 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_dictionaryManipulator_qualifiedDictionary = require('./qualifiedDictionary.cjs');
+const require_dictionaryManipulator_preloadedDynamicLoader = require('./preloadedDynamicLoader.cjs');
+const require_dictionaryManipulator_qualifiedDynamicLoader = require('./qualifiedDynamicLoader.cjs');
+const require_dictionaryManipulator_plainDynamicLoader = require('./plainDynamicLoader.cjs');
 const require_dictionaryManipulator_editDictionaryByKeyPath = require('./editDictionaryByKeyPath.cjs');
 const require_dictionaryManipulator_getContentNodeByKeyPath = require('./getContentNodeByKeyPath.cjs');
 const require_dictionaryManipulator_getDefaultNode = require('./getDefaultNode.cjs');
@@ -12,8 +15,6 @@ const require_dictionaryManipulator_qualifiedDictionaryDeclaration = require('./
 const require_dictionaryManipulator_mergeQualifiedDictionaries = require('./mergeQualifiedDictionaries.cjs');
 const require_dictionaryManipulator_orderDictionaries = require('./orderDictionaries.cjs');
 const require_dictionaryManipulator_normalizeDictionary = require('./normalizeDictionary.cjs');
-const require_dictionaryManipulator_preloadedDynamicLoader = require('./preloadedDynamicLoader.cjs');
-const require_dictionaryManipulator_qualifiedDynamicLoader = require('./qualifiedDynamicLoader.cjs');
 const require_dictionaryManipulator_removeContentNodeByKeyPath = require('./removeContentNodeByKeyPath.cjs');
 const require_dictionaryManipulator_renameContentNodeByKeyPath = require('./renameContentNodeByKeyPath.cjs');
 const require_dictionaryManipulator_updateNodeChildren = require('./updateNodeChildren.cjs');
@@ -25,6 +26,7 @@ exports.PRELOADED_DYNAMIC_KEY = _intlayer_config_defaultValues.PRELOADED_DYNAMIC
 exports.QUALIFIER_DYNAMIC_TYPES_KEY = _intlayer_config_defaultValues.QUALIFIER_DYNAMIC_TYPES_KEY;
 exports.QUALIFIER_ORDER = require_dictionaryManipulator_qualifiedDictionaryDeclaration.QUALIFIER_ORDER;
 exports.editDictionaryByKeyPath = require_dictionaryManipulator_editDictionaryByKeyPath.editDictionaryByKeyPath;
+exports.findPlainDynamicLoader = require_dictionaryManipulator_plainDynamicLoader.findPlainDynamicLoader;
 exports.getContentNodeByKeyPath = require_dictionaryManipulator_getContentNodeByKeyPath.getContentNodeByKeyPath;
 exports.getDefaultNode = require_dictionaryManipulator_getDefaultNode.getDefaultNode;
 exports.getDictionaryCompositeIds = require_dictionaryManipulator_qualifiedDictionaryDeclaration.getDictionaryCompositeIds;
@@ -52,6 +54,7 @@ exports.removeContentNodeByKeyPath = require_dictionaryManipulator_removeContent
 exports.renameContentNodeByKeyPath = require_dictionaryManipulator_renameContentNodeByKeyPath.renameContentNodeByKeyPath;
 exports.resolveDictionaryArgument = require_dictionaryManipulator_qualifiedDictionary.resolveDictionaryArgument;
 exports.resolveEffectiveVariantId = require_dictionaryManipulator_qualifiedDictionary.resolveEffectiveVariantId;
+exports.resolvePlainDynamicLoader = require_dictionaryManipulator_plainDynamicLoader.resolvePlainDynamicLoader;
 exports.resolveProviderVariant = require_dictionaryManipulator_qualifiedDictionary.resolveProviderVariant;
 exports.resolveQualifiedDictionary = require_dictionaryManipulator_qualifiedDictionary.resolveQualifiedDictionary;
 exports.resolveQualifiedDynamicContent = require_dictionaryManipulator_qualifiedDynamicLoader.resolveQualifiedDynamicContent;

package/dist/cjs/index.cjs

@@ -1,5 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_deepTransformPlugins_getEditedContent = require('./deepTransformPlugins/getEditedContent.cjs');
+const require_interpreter_dictionaryTransformCache = require('./interpreter/dictionaryTransformCache.cjs');
 const require_interpreter_getCondition = require('./interpreter/getCondition.cjs');
 const require_interpreter_getContent_deepTransform = require('./interpreter/getContent/deepTransform.cjs');
 const require_interpreter_getEnumeration = require('./interpreter/getEnumeration.cjs');
@@ -24,7 +25,12 @@ const require_interpreter_getTranslation = require('./interpreter/getTranslation
 const require_interpreter_interpolableNode = require('./interpreter/interpolableNode.cjs');
 const require_interpreter_getContent_plugins = require('./interpreter/getContent/plugins.cjs');
 const require_interpreter_getContent_getContent = require('./interpreter/getContent/getContent.cjs');
+const require_dictionaryManipulator_preloadedDynamicLoader = require('./dictionaryManipulator/preloadedDynamicLoader.cjs');
+const require_dictionaryManipulator_qualifiedDynamicLoader = require('./dictionaryManipulator/qualifiedDynamicLoader.cjs');
+const require_dictionaryManipulator_plainDynamicLoader = require('./dictionaryManipulator/plainDynamicLoader.cjs');
+const require_interpreter_getDictionaryAsync = require('./interpreter/getDictionaryAsync.cjs');
 const require_interpreter_getHTML = require('./interpreter/getHTML.cjs');
+const require_interpreter_getIntlayerAsync = require('./interpreter/getIntlayerAsync.cjs');
 const require_interpreter_splitAndJoinInsertion = require('./interpreter/splitAndJoinInsertion.cjs');
 const require_deepTransformPlugins_getFilteredLocalesContent = require('./deepTransformPlugins/getFilteredLocalesContent.cjs');
 const require_transpiler_condition_condition = require('./transpiler/condition/condition.cjs');
@@ -65,8 +71,6 @@ const require_dictionaryManipulator_qualifiedDictionaryDeclaration = require('./
 const require_dictionaryManipulator_mergeQualifiedDictionaries = require('./dictionaryManipulator/mergeQualifiedDictionaries.cjs');
 const require_dictionaryManipulator_orderDictionaries = require('./dictionaryManipulator/orderDictionaries.cjs');
 const require_dictionaryManipulator_normalizeDictionary = require('./dictionaryManipulator/normalizeDictionary.cjs');
-const require_dictionaryManipulator_preloadedDynamicLoader = require('./dictionaryManipulator/preloadedDynamicLoader.cjs');
-const require_dictionaryManipulator_qualifiedDynamicLoader = require('./dictionaryManipulator/qualifiedDynamicLoader.cjs');
 const require_dictionaryManipulator_removeContentNodeByKeyPath = require('./dictionaryManipulator/removeContentNodeByKeyPath.cjs');
 const require_dictionaryManipulator_renameContentNodeByKeyPath = require('./dictionaryManipulator/renameContentNodeByKeyPath.cjs');
 const require_dictionaryManipulator_updateNodeChildren = require('./dictionaryManipulator/updateNodeChildren.cjs');
@@ -224,6 +228,7 @@ exports.filePlugin = require_interpreter_getContent_plugins.filePlugin;
 exports.filterMissingTranslationsOnlyPlugin = require_deepTransformPlugins_getFilterMissingTranslationsContent.filterMissingTranslationsOnlyPlugin;
 exports.filterTranslationsOnlyPlugin = require_deepTransformPlugins_getFilterTranslationsOnlyContent.filterTranslationsOnlyPlugin;
 exports.findMatchingCondition = require_interpreter_getEnumeration.findMatchingCondition;
+exports.findPlainDynamicLoader = require_dictionaryManipulator_plainDynamicLoader.findPlainDynamicLoader;
 exports.formatProxyEnabledMessage = require_localization_proxyMode.formatProxyEnabledMessage;
 exports.gender = require_transpiler_gender_gender.gender;
 exports.genderPlugin = require_interpreter_getContent_plugins.genderPlugin;
@@ -244,10 +249,12 @@ exports.getContentNodeByKeyPath = require_dictionaryManipulator_getContentNodeBy
 exports.getCookie = require_utils_getCookie.getCookie;
 exports.getDefaultNode = require_dictionaryManipulator_getDefaultNode.getDefaultNode;
 exports.getDictionary = require_interpreter_getDictionary.getDictionary;
+exports.getDictionaryAsync = require_interpreter_getDictionaryAsync.getDictionaryAsync;
 exports.getDictionaryCompositeIds = require_dictionaryManipulator_qualifiedDictionaryDeclaration.getDictionaryCompositeIds;
 exports.getDictionaryQualifierIds = require_dictionaryManipulator_qualifiedDictionaryDeclaration.getDictionaryQualifierIds;
 exports.getDictionaryQualifierTypes = require_dictionaryManipulator_qualifiedDictionaryDeclaration.getDictionaryQualifierTypes;
 exports.getDictionarySelectorCacheKey = require_dictionaryManipulator_qualifiedDictionary.getDictionarySelectorCacheKey;
+exports.getDictionaryTransformCacheKey = require_interpreter_dictionaryTransformCache.getDictionaryTransformCacheKey;
 exports.getDomainHostname = require_localization_domainUtils.getDomainHostname;
 exports.getDomainOrigin = require_localization_domainUtils.getDomainOrigin;
 exports.getEditedContent = require_deepTransformPlugins_getEditedContent.getEditedContent;
@@ -268,6 +275,7 @@ exports.getInsertionValues = require_transpiler_insertion_getInsertionValues.get
 exports.getInternalPath = require_localization_rewriteUtils.getInternalPath;
 exports.getInterpolableContent = require_interpreter_interpolableNode.getInterpolableContent;
 exports.getIntlayer = require_interpreter_getIntlayer.getIntlayer;
+exports.getIntlayerAsync = require_interpreter_getIntlayerAsync.getIntlayerAsync;
 exports.getLocale = require_localization_getLocale.getLocale;
 exports.getLocaleFromDomain = require_localization_domainUtils.getLocaleFromDomain;
 exports.getLocaleFromPath = require_localization_getLocaleFromPath.getLocaleFromPath;
@@ -293,6 +301,7 @@ exports.getNodeChildren = require_dictionaryManipulator_getNodeChildren.getNodeC
 exports.getNodeType = require_dictionaryManipulator_getNodeType.getNodeType;
 exports.getPathWithoutLocale = require_localization_getPathWithoutLocale.getPathWithoutLocale;
 exports.getPerLocaleDictionary = require_deepTransformPlugins_getLocalizedContent.getPerLocaleDictionary;
+exports.getPluginsCacheKey = require_interpreter_dictionaryTransformCache.getPluginsCacheKey;
 exports.getPlural = require_interpreter_getPlural.getPlural;
 exports.getPrefix = require_localization_getPrefix.getPrefix;
 exports.getPreloadLocale = require_localization_resolveBrowserLocale.getPreloadLocale;
@@ -365,6 +374,7 @@ exports.pluralPlugin = require_interpreter_getContent_plugins.pluralPlugin;
 exports.portableObjectToIntlayerFormatter = require_messageFormat_po.portableObjectToIntlayerFormatter;
 exports.presets = require_formatters_date.presets;
 exports.qualifies = require_markdown_utils.qualifies;
+exports.readTransformCache = require_interpreter_dictionaryTransformCache.readTransformCache;
 exports.rebuildInterpolableContent = require_interpreter_interpolableNode.rebuildInterpolableContent;
 exports.reconstructQualifiedEntry = require_dictionaryManipulator_qualifiedDictionary.reconstructQualifiedEntry;
 exports.relativeTime = require_formatters_relativeTime.relativeTime;
@@ -379,6 +389,7 @@ exports.resolveEffectiveVariantId = require_dictionaryManipulator_qualifiedDicti
 exports.resolveLocalizedPath = require_localization_rewriteUtils.resolveLocalizedPath;
 exports.resolveMessage = require_messageFormat_resolveMessage.resolveMessage;
 exports.resolveMessageNode = require_messageFormat_resolveMessage.resolveMessageNode;
+exports.resolvePlainDynamicLoader = require_dictionaryManipulator_plainDynamicLoader.resolvePlainDynamicLoader;
 exports.resolveProviderVariant = require_dictionaryManipulator_qualifiedDictionary.resolveProviderVariant;
 exports.resolveProxyMode = require_localization_proxyMode.resolveProxyMode;
 exports.resolveQualifiedDictionary = require_dictionaryManipulator_qualifiedDictionary.resolveQualifiedDictionary;
@@ -410,4 +421,5 @@ exports.updateNodeChildren = require_dictionaryManipulator_updateNodeChildren.up
 exports.validateHTML = require_transpiler_html_validateHTML.validateHTML;
 exports.validateMarkdown = require_transpiler_markdown_validateMarkdown.validateMarkdown;
 exports.validatePrefix = require_localization_validatePrefix.validatePrefix;
-exports.vueI18nToIntlayerFormatter = require_messageFormat_vue_i18n.vueI18nToIntlayerFormatter;
+exports.vueI18nToIntlayerFormatter = require_messageFormat_vue_i18n.vueI18nToIntlayerFormatter;
+exports.writeTransformCache = require_interpreter_dictionaryTransformCache.writeTransformCache;

package/dist/cjs/interpreter/dictionaryTransformCache.cjs

@@ -0,0 +1,111 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+//#region src/interpreter/dictionaryTransformCache.ts
+/**
+* Stable identity per plugin array, so a cache key can tell two custom plugin
+* sets apart.
+*
+* A boolean `custom / default` discriminator is not enough: two callers passing
+* *different* plugin arrays for the same dictionary and locale would collide,
+* and the second one would be served the first one's transformed content.
+*
+* Every framework package memoizes `getPlugins(locale)` per locale, so the same
+* locale always hands over the same array reference and reuses its identity —
+* an array built fresh on every call only ever costs a cache miss, never a
+* wrong hit.
+*/
+const pluginsIdentities = /* @__PURE__ */ new WeakMap();
+let nextPluginsIdentity = 0;
+/**
+* Returns the cache-key fragment identifying a plugin array.
+*
+* @param plugins - The plugin array a transform runs with, or `undefined` when
+*                  the interpreter's base plugins are used.
+*/
+const getPluginsCacheKey = (plugins) => {
+	if (!plugins) return "base";
+	const existingIdentity = pluginsIdentities.get(plugins);
+	if (existingIdentity) return existingIdentity;
+	nextPluginsIdentity += 1;
+	const identity = `p${nextPluginsIdentity}`;
+	pluginsIdentities.set(plugins, identity);
+	return identity;
+};
+/**
+* Upper bound of transformed entries kept per dictionary. A dictionary is
+* transformed once per `locale × selector × plugin set`, so the realistic count
+* stays in the tens; the cap only guards pathological selector fan-out (a
+* collection read by hundreds of item ids). Reaching it drops the dictionary's
+* entries rather than evicting one by one — the next reads simply re-transform.
+*/
+const MAX_ENTRIES_PER_DICTIONARY = 256;
+/**
+* Transformed content, keyed first by the dictionary object it came from, then
+* by `locale × selector × plugin set`.
+*
+* Keying on the object rather than on the dictionary key is what makes this
+* safe for the paths the build optimization produces: `useDictionary` and
+* `useDictionaryDynamic` receive the dictionary itself, never its key, and a
+* dictionary replaced at runtime — a hot reload, a freshly loaded locale chunk
+* — is a new object, so it can never be served stale content. Being weak also
+* means a dictionary that goes out of scope takes its entries with it.
+*/
+const transformCache = /* @__PURE__ */ new WeakMap();
+/**
+* Whether a value is a settled dictionary worth memoizing.
+*
+* Two kinds of argument are deliberately excluded, and both are callable:
+* - a callable stand-in proxy — `solid-intlayer`'s `useLoadDynamic` hands
+*   `getDictionary` a placeholder that reads a Solid resource on every property
+*   access, so its content changes the moment the chunk lands. Memoizing it
+*   would freeze the pending, empty state for the rest of the session.
+* - anything a non-typed caller passes that a `WeakMap` cannot hold as a key,
+*   which would otherwise throw instead of simply running uncached.
+*/
+const isMemoizableDictionary = (value) => value !== null && typeof value === "object";
+/**
+* Builds the cache key for one transformed entry.
+*
+* @param locale - The resolved locale, already defaulted by the caller.
+* @param selectorCacheKey - Serialized selector, empty for a plain dictionary.
+* @param plugins - The plugin array the transform runs with.
+*/
+const getDictionaryTransformCacheKey = (locale, selectorCacheKey, plugins) => `${locale}_${selectorCacheKey}_${getPluginsCacheKey(plugins)}`;
+/**
+* Looks up the transformed content cached for `dictionary` under `cacheKey`.
+*
+* The hit is reported through a discriminated result rather than through the
+* value: `null` is a legitimate cached content — an unresolvable qualified
+* coordinate — so a miss can never be inferred from the value alone.
+*/
+const readTransformCache = (dictionary, cacheKey) => {
+	if (!isMemoizableDictionary(dictionary)) return { hit: false };
+	const entries = transformCache.get(dictionary);
+	if (!entries?.has(cacheKey)) return { hit: false };
+	return {
+		hit: true,
+		content: entries.get(cacheKey)
+	};
+};
+/**
+* Stores transformed content for `dictionary` under `cacheKey`.
+*
+* @returns The stored content, so callers can `return writeTransformCache(...)`.
+*/
+const writeTransformCache = (dictionary, cacheKey, content) => {
+	if (!isMemoizableDictionary(dictionary)) return content;
+	let entries = transformCache.get(dictionary);
+	if (!entries) {
+		entries = /* @__PURE__ */ new Map();
+		transformCache.set(dictionary, entries);
+	}
+	if (entries.size >= MAX_ENTRIES_PER_DICTIONARY) entries.clear();
+	entries.set(cacheKey, content);
+	return content;
+};
+
+//#endregion
+exports.getDictionaryTransformCacheKey = getDictionaryTransformCacheKey;
+exports.getPluginsCacheKey = getPluginsCacheKey;
+exports.readTransformCache = readTransformCache;
+exports.writeTransformCache = writeTransformCache;
+//# sourceMappingURL=dictionaryTransformCache.cjs.map

package/dist/cjs/interpreter/dictionaryTransformCache.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"dictionaryTransformCache.cjs","names":[],"sources":["../../../src/interpreter/dictionaryTransformCache.ts"],"sourcesContent":["import type { Dictionary } from '@intlayer/types/dictionary';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport type { Plugins } from './getContent';\n\n/**\n * Stable identity per plugin array, so a cache key can tell two custom plugin\n * sets apart.\n *\n * A boolean `custom / default` discriminator is not enough: two callers passing\n * *different* plugin arrays for the same dictionary and locale would collide,\n * and the second one would be served the first one's transformed content.\n *\n * Every framework package memoizes `getPlugins(locale)` per locale, so the same\n * locale always hands over the same array reference and reuses its identity —\n * an array built fresh on every call only ever costs a cache miss, never a\n * wrong hit.\n */\nconst pluginsIdentities = new WeakMap<Plugins[], string>();\n\nlet nextPluginsIdentity = 0;\n\n/**\n * Returns the cache-key fragment identifying a plugin array.\n *\n * @param plugins - The plugin array a transform runs with, or `undefined` when\n *                  the interpreter's base plugins are used.\n */\nexport const getPluginsCacheKey = (plugins?: Plugins[]): string => {\n  if (!plugins) return 'base';\n\n  const existingIdentity = pluginsIdentities.get(plugins);\n  if (existingIdentity) return existingIdentity;\n\n  nextPluginsIdentity += 1;\n  const identity = `p${nextPluginsIdentity}`;\n  pluginsIdentities.set(plugins, identity);\n\n  return identity;\n};\n\n/**\n * Upper bound of transformed entries kept per dictionary. A dictionary is\n * transformed once per `locale × selector × plugin set`, so the realistic count\n * stays in the tens; the cap only guards pathological selector fan-out (a\n * collection read by hundreds of item ids). Reaching it drops the dictionary's\n * entries rather than evicting one by one — the next reads simply re-transform.\n */\nconst MAX_ENTRIES_PER_DICTIONARY = 256;\n\n/**\n * Transformed content, keyed first by the dictionary object it came from, then\n * by `locale × selector × plugin set`.\n *\n * Keying on the object rather than on the dictionary key is what makes this\n * safe for the paths the build optimization produces: `useDictionary` and\n * `useDictionaryDynamic` receive the dictionary itself, never its key, and a\n * dictionary replaced at runtime — a hot reload, a freshly loaded locale chunk\n * — is a new object, so it can never be served stale content. Being weak also\n * means a dictionary that goes out of scope takes its entries with it.\n */\nconst transformCache = new WeakMap<object, Map<string, unknown>>();\n\n/**\n * Whether a value is a settled dictionary worth memoizing.\n *\n * Two kinds of argument are deliberately excluded, and both are callable:\n * - a callable stand-in proxy — `solid-intlayer`'s `useLoadDynamic` hands\n *   `getDictionary` a placeholder that reads a Solid resource on every property\n *   access, so its content changes the moment the chunk lands. Memoizing it\n *   would freeze the pending, empty state for the rest of the session.\n * - anything a non-typed caller passes that a `WeakMap` cannot hold as a key,\n *   which would otherwise throw instead of simply running uncached.\n */\nconst isMemoizableDictionary = (value: unknown): value is object =>\n  value !== null && typeof value === 'object';\n\n/**\n * Builds the cache key for one transformed entry.\n *\n * @param locale - The resolved locale, already defaulted by the caller.\n * @param selectorCacheKey - Serialized selector, empty for a plain dictionary.\n * @param plugins - The plugin array the transform runs with.\n */\nexport const getDictionaryTransformCacheKey = (\n  locale: LocalesValues,\n  selectorCacheKey: string,\n  plugins?: Plugins[]\n): string => `${locale}_${selectorCacheKey}_${getPluginsCacheKey(plugins)}`;\n\n/**\n * Looks up the transformed content cached for `dictionary` under `cacheKey`.\n *\n * The hit is reported through a discriminated result rather than through the\n * value: `null` is a legitimate cached content — an unresolvable qualified\n * coordinate — so a miss can never be inferred from the value alone.\n */\nexport const readTransformCache = <Content>(\n  dictionary: Dictionary | object,\n  cacheKey: string\n): { hit: true; content: Content } | { hit: false } => {\n  if (!isMemoizableDictionary(dictionary)) return { hit: false };\n\n  const entries = transformCache.get(dictionary);\n\n  if (!entries?.has(cacheKey)) return { hit: false };\n\n  return { hit: true, content: entries.get(cacheKey) as Content };\n};\n\n/**\n * Stores transformed content for `dictionary` under `cacheKey`.\n *\n * @returns The stored content, so callers can `return writeTransformCache(...)`.\n */\nexport const writeTransformCache = <Content>(\n  dictionary: Dictionary | object,\n  cacheKey: string,\n  content: Content\n): Content => {\n  if (!isMemoizableDictionary(dictionary)) return content;\n\n  let entries = transformCache.get(dictionary);\n\n  if (!entries) {\n    entries = new Map<string, unknown>();\n    transformCache.set(dictionary, entries);\n  }\n\n  if (entries.size >= MAX_ENTRIES_PER_DICTIONARY) entries.clear();\n\n  entries.set(cacheKey, content);\n\n  return content;\n};\n"],"mappings":";;;;;;;;;;;;;;;AAiBA,MAAM,oCAAoB,IAAI,QAA2B;AAEzD,IAAI,sBAAsB;;;;;;;AAQ1B,MAAa,sBAAsB,YAAgC;CACjE,IAAI,CAAC,SAAS,OAAO;CAErB,MAAM,mBAAmB,kBAAkB,IAAI,OAAO;CACtD,IAAI,kBAAkB,OAAO;CAE7B,uBAAuB;CACvB,MAAM,WAAW,IAAI;CACrB,kBAAkB,IAAI,SAAS,QAAQ;CAEvC,OAAO;AACT;;;;;;;;AASA,MAAM,6BAA6B;;;;;;;;;;;;AAanC,MAAM,iCAAiB,IAAI,QAAsC;;;;;;;;;;;;AAajE,MAAM,0BAA0B,UAC9B,UAAU,QAAQ,OAAO,UAAU;;;;;;;;AASrC,MAAa,kCACX,QACA,kBACA,YACW,GAAG,OAAO,GAAG,iBAAiB,GAAG,mBAAmB,OAAO;;;;;;;;AASxE,MAAa,sBACX,YACA,aACqD;CACrD,IAAI,CAAC,uBAAuB,UAAU,GAAG,OAAO,EAAE,KAAK,MAAM;CAE7D,MAAM,UAAU,eAAe,IAAI,UAAU;CAE7C,IAAI,CAAC,SAAS,IAAI,QAAQ,GAAG,OAAO,EAAE,KAAK,MAAM;CAEjD,OAAO;EAAE,KAAK;EAAM,SAAS,QAAQ,IAAI,QAAQ;CAAa;AAChE;;;;;;AAOA,MAAa,uBACX,YACA,UACA,YACY;CACZ,IAAI,CAAC,uBAAuB,UAAU,GAAG,OAAO;CAEhD,IAAI,UAAU,eAAe,IAAI,UAAU;CAE3C,IAAI,CAAC,SAAS;EACZ,0BAAU,IAAI,IAAqB;EACnC,eAAe,IAAI,YAAY,OAAO;CACxC;CAEA,IAAI,QAAQ,QAAQ,4BAA4B,QAAQ,MAAM;CAE9D,QAAQ,IAAI,UAAU,OAAO;CAE7B,OAAO;AACT"}

package/dist/cjs/interpreter/getDictionary.cjs

@@ -1,16 +1,13 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_interpreter_dictionaryTransformCache = require('./dictionaryTransformCache.cjs');
 const require_dictionaryManipulator_qualifiedDictionary = require('../dictionaryManipulator/qualifiedDictionary.cjs');
 const require_interpreter_getContent_getContent = require('./getContent/getContent.cjs');
+let _intlayer_config_built = require("@intlayer/config/built");
 
 //#region src/interpreter/getDictionary.ts
 /**
 * Transforms a dictionary in a single pass, applying each plugin as needed.
 *
-* Also accepts a `QualifiedDictionaryGroup` (collections, variants) together
-* with a selector as second argument — the group is resolved to a single entry
-* (or an ordered array of entries for collections without an `item` selector)
-* before transformation.
-*
 * @param dictionary The dictionary (or qualified dictionary group) to transform.
 * @param localeOrSelector The locale, or a selector object (`{ item }`,
 *                         `{ variant }`, optionally with `locale`).
@@ -19,6 +16,9 @@ const require_interpreter_getContent_getContent = require('./getContent/getConte
 */
 const getDictionary = (dictionary, localeOrSelector, plugins) => {
 	const { locale, selector } = require_dictionaryManipulator_qualifiedDictionary.parseDictionarySelector(localeOrSelector);
+	const cacheKey = require_interpreter_dictionaryTransformCache.getDictionaryTransformCacheKey(locale ?? _intlayer_config_built.internationalization.defaultLocale, require_dictionaryManipulator_qualifiedDictionary.getDictionarySelectorCacheKey(selector), plugins);
+	const cached = require_interpreter_dictionaryTransformCache.readTransformCache(dictionary, cacheKey);
+	if (cached.hit) return cached.content;
 	const appliedPlugins = plugins ?? require_interpreter_getContent_getContent.getBasePlugins(locale);
 	const resolved = require_dictionaryManipulator_qualifiedDictionary.resolveQualifiedDictionary(dictionary, selector);
 	const transformDictionary = (resolvedDictionary) => {
@@ -31,9 +31,9 @@ const getDictionary = (dictionary, localeOrSelector, plugins) => {
 		};
 		return require_interpreter_getContent_getContent.getContent(resolvedDictionary.content, props, appliedPlugins);
 	};
-	if (resolved === null) return null;
-	if (Array.isArray(resolved)) return resolved.map(transformDictionary);
-	return transformDictionary(resolved);
+	if (resolved === null) return require_interpreter_dictionaryTransformCache.writeTransformCache(dictionary, cacheKey, null);
+	if (Array.isArray(resolved)) return require_interpreter_dictionaryTransformCache.writeTransformCache(dictionary, cacheKey, resolved.map(transformDictionary));
+	return require_interpreter_dictionaryTransformCache.writeTransformCache(dictionary, cacheKey, transformDictionary(resolved));
 };
 
 //#endregion

package/dist/cjs/interpreter/getDictionary.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"getDictionary.cjs","names":["parseDictionarySelector","getBasePlugins","resolveQualifiedDictionary","getContent"],"sources":["../../../src/interpreter/getDictionary.ts"],"sourcesContent":["import type {\n  Dictionary,\n  DictionarySelector,\n  QualifiedDictionaryGroup,\n  ResolveQualifiedDictionaryContent,\n} from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  ExtractSelectorLocale,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport {\n  parseDictionarySelector,\n  resolveQualifiedDictionary,\n} from '../dictionaryManipulator/qualifiedDictionary';\nimport type {\n  DeepTransformContent,\n  IInterpreterPluginState,\n  NodeProps,\n  Plugins,\n} from './getContent';\nimport { getBasePlugins, getContent } from './getContent/getContent';\n\n/**\n * Transforms a dictionary in a single pass, applying each plugin as needed.\n *\n * Also accepts a `QualifiedDictionaryGroup` (collections, variants) together\n * with a selector as second argument — the group is resolved to a single entry\n * (or an ordered array of entries for collections without an `item` selector)\n * before transformation.\n *\n * @param dictionary The dictionary (or qualified dictionary group) to transform.\n * @param localeOrSelector The locale, or a selector object (`{ item }`,\n *                         `{ variant }`, optionally with `locale`).\n * @param plugins An array of NodeTransformer that define how to transform recognized nodes.\n *                If omitted, we’ll use a default set of plugins.\n */\nexport const getDictionary = <\n  const T extends Dictionary | QualifiedDictionaryGroup,\n  const A extends LocalesValues | DictionarySelector = DeclaredLocales,\n>(\n  dictionary: T,\n  localeOrSelector?: A,\n  plugins?: Plugins[]\n): DeepTransformContent<\n  ResolveQualifiedDictionaryContent<T, A>,\n  IInterpreterPluginState,\n  ExtractSelectorLocale<A>\n> => {\n  const { locale, selector } = parseDictionarySelector(localeOrSelector);\n  const appliedPlugins = plugins ?? getBasePlugins(locale);\n\n  const resolved = resolveQualifiedDictionary(dictionary, selector);\n\n  const transformDictionary = (resolvedDictionary: Dictionary) => {\n    const props: NodeProps = {\n      dictionaryKey: resolvedDictionary.key,\n      dictionaryPath: resolvedDictionary.filePath,\n      keyPath: [],\n      plugins: appliedPlugins,\n      // Attached by the build optimization so `nest()` resolves without the\n      // global registry. Undefined in unoptimized builds, where the\n      // registry-based resolver is used instead.\n      nestedDictionaries: resolvedDictionary.nestedDictionaries,\n    };\n\n    return getContent(resolvedDictionary.content, props, appliedPlugins);\n  };\n\n  if (resolved === null) return null as any;\n\n  if (Array.isArray(resolved)) {\n    return resolved.map(transformDictionary) as any;\n  }\n\n  return transformDictionary(resolved) as any;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAqCA,MAAa,iBAIX,YACA,kBACA,YAKG;CACH,MAAM,EAAE,QAAQ,aAAaA,0EAAwB,gBAAgB;CACrE,MAAM,iBAAiB,WAAWC,yDAAe,MAAM;CAEvD,MAAM,WAAWC,6EAA2B,YAAY,QAAQ;CAEhE,MAAM,uBAAuB,uBAAmC;EAC9D,MAAM,QAAmB;GACvB,eAAe,mBAAmB;GAClC,gBAAgB,mBAAmB;GACnC,SAAS,CAAC;GACV,SAAS;GAIT,oBAAoB,mBAAmB;EACzC;EAEA,OAAOC,qDAAW,mBAAmB,SAAS,OAAO,cAAc;CACrE;CAEA,IAAI,aAAa,MAAM,OAAO;CAE9B,IAAI,MAAM,QAAQ,QAAQ,GACxB,OAAO,SAAS,IAAI,mBAAmB;CAGzC,OAAO,oBAAoB,QAAQ;AACrC"}
+{"version":3,"file":"getDictionary.cjs","names":["parseDictionarySelector","getDictionaryTransformCacheKey","internationalization","getDictionarySelectorCacheKey","readTransformCache","getBasePlugins","resolveQualifiedDictionary","getContent","writeTransformCache"],"sources":["../../../src/interpreter/getDictionary.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport type {\n  Dictionary,\n  DictionarySelector,\n  QualifiedDictionaryGroup,\n  ResolveQualifiedDictionaryContent,\n} from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  ExtractSelectorLocale,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport {\n  getDictionarySelectorCacheKey,\n  parseDictionarySelector,\n  resolveQualifiedDictionary,\n} from '../dictionaryManipulator/qualifiedDictionary';\nimport {\n  getDictionaryTransformCacheKey,\n  readTransformCache,\n  writeTransformCache,\n} from './dictionaryTransformCache';\nimport type {\n  DeepTransformContent,\n  IInterpreterPluginState,\n  NodeProps,\n  Plugins,\n} from './getContent';\nimport { getBasePlugins, getContent } from './getContent/getContent';\n\n/**\n * Transforms a dictionary in a single pass, applying each plugin as needed.\n *\n * @param dictionary The dictionary (or qualified dictionary group) to transform.\n * @param localeOrSelector The locale, or a selector object (`{ item }`,\n *                         `{ variant }`, optionally with `locale`).\n * @param plugins An array of NodeTransformer that define how to transform recognized nodes.\n *                If omitted, we’ll use a default set of plugins.\n */\nexport const getDictionary = <\n  const T extends Dictionary | QualifiedDictionaryGroup,\n  const A extends LocalesValues | DictionarySelector = DeclaredLocales,\n>(\n  dictionary: T,\n  localeOrSelector?: A,\n  plugins?: Plugins[]\n): DeepTransformContent<\n  ResolveQualifiedDictionaryContent<T, A>,\n  IInterpreterPluginState,\n  ExtractSelectorLocale<A>\n> => {\n  const { locale, selector } = parseDictionarySelector(localeOrSelector);\n\n  // The base plugins are rebuilt on every call, so they cannot identify\n  // themselves — but they are fully determined by the locale, which the key\n  // already carries. Only an explicitly passed array needs its own identity.\n  const cacheKey = getDictionaryTransformCacheKey(\n    locale ?? internationalization.defaultLocale,\n    getDictionarySelectorCacheKey(selector),\n    plugins\n  );\n\n  const cached = readTransformCache<any>(dictionary, cacheKey);\n  if (cached.hit) return cached.content;\n\n  const appliedPlugins = plugins ?? getBasePlugins(locale);\n\n  const resolved = resolveQualifiedDictionary(dictionary, selector);\n\n  const transformDictionary = (resolvedDictionary: Dictionary) => {\n    const props: NodeProps = {\n      dictionaryKey: resolvedDictionary.key,\n      dictionaryPath: resolvedDictionary.filePath,\n      keyPath: [],\n      plugins: appliedPlugins,\n      // Attached by the build optimization so `nest()` resolves without the\n      // global registry. Undefined in unoptimized builds, where the\n      // registry-based resolver is used instead.\n      nestedDictionaries: resolvedDictionary.nestedDictionaries,\n    };\n\n    return getContent(resolvedDictionary.content, props, appliedPlugins);\n  };\n\n  if (resolved === null) return writeTransformCache(dictionary, cacheKey, null);\n\n  if (Array.isArray(resolved)) {\n    return writeTransformCache(\n      dictionary,\n      cacheKey,\n      resolved.map(transformDictionary)\n    ) as any;\n  }\n\n  return writeTransformCache(\n    dictionary,\n    cacheKey,\n    transformDictionary(resolved)\n  ) as any;\n};\n"],"mappings":";;;;;;;;;;;;;;;;AAuCA,MAAa,iBAIX,YACA,kBACA,YAKG;CACH,MAAM,EAAE,QAAQ,aAAaA,0EAAwB,gBAAgB;CAKrE,MAAM,WAAWC,4EACf,UAAUC,4CAAqB,eAC/BC,gFAA8B,QAAQ,GACtC,OACF;CAEA,MAAM,SAASC,gEAAwB,YAAY,QAAQ;CAC3D,IAAI,OAAO,KAAK,OAAO,OAAO;CAE9B,MAAM,iBAAiB,WAAWC,yDAAe,MAAM;CAEvD,MAAM,WAAWC,6EAA2B,YAAY,QAAQ;CAEhE,MAAM,uBAAuB,uBAAmC;EAC9D,MAAM,QAAmB;GACvB,eAAe,mBAAmB;GAClC,gBAAgB,mBAAmB;GACnC,SAAS,CAAC;GACV,SAAS;GAIT,oBAAoB,mBAAmB;EACzC;EAEA,OAAOC,qDAAW,mBAAmB,SAAS,OAAO,cAAc;CACrE;CAEA,IAAI,aAAa,MAAM,OAAOC,iEAAoB,YAAY,UAAU,IAAI;CAE5E,IAAI,MAAM,QAAQ,QAAQ,GACxB,OAAOA,iEACL,YACA,UACA,SAAS,IAAI,mBAAmB,CAClC;CAGF,OAAOA,iEACL,YACA,UACA,oBAAoB,QAAQ,CAC9B;AACF"}

package/dist/cjs/interpreter/getDictionaryAsync.cjs

@@ -0,0 +1,79 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_interpreter_dictionaryTransformCache = require('./dictionaryTransformCache.cjs');
+const require_dictionaryManipulator_qualifiedDictionary = require('../dictionaryManipulator/qualifiedDictionary.cjs');
+const require_interpreter_getDictionary = require('./getDictionary.cjs');
+const require_dictionaryManipulator_qualifiedDynamicLoader = require('../dictionaryManipulator/qualifiedDynamicLoader.cjs');
+const require_dictionaryManipulator_plainDynamicLoader = require('../dictionaryManipulator/plainDynamicLoader.cjs');
+let _intlayer_config_built = require("@intlayer/config/built");
+
+//#region src/interpreter/getDictionaryAsync.ts
+/**
+* Content already resolved for a `key + locale + selector` triple, or the
+* in-flight promise resolving it. Storing the promise itself makes the cache
+* double as an in-flight deduplication table: concurrent calls for the same
+* chunk await one single load.
+*/
+const contentPromiseCache = /* @__PURE__ */ new Map();
+/**
+* Awaits the chunk a plain loader map holds for `locale` — walking the same
+* fallback chain as static mode — and transforms it.
+*
+* Returns `null` when the map emitted no chunk for the locale nor for any of
+* its fallbacks, mirroring how a missing qualified coordinate resolves.
+*/
+const loadPlainChunk = async (dictionaryLoaders, locale, transform) => {
+	const resolved = require_dictionaryManipulator_plainDynamicLoader.findPlainDynamicLoader(dictionaryLoaders, locale);
+	if (!resolved) return null;
+	return transform(await resolved.loader());
+};
+/**
+* Loads a single locale chunk of a dictionary and returns its transformed
+* content.
+*
+* Counterpart of {@link getDictionary} for the per-locale loader maps emitted
+* in `.intlayer/dynamic_dictionaries/`: instead of receiving a dictionary
+* holding every locale, it receives the loader map and awaits only the chunk
+* the requested locale needs.
+*
+* The loader map is either plain (`locale → loader`) or qualified
+* (`locale → qualifierId → loader`, for collections and variants). For a
+* qualified map, only the chunk(s) the selector targets are loaded.
+*
+* Build plugins rewrite every `getIntlayerAsync('key', locale)` call into a
+* `getDictionaryAsync(loaderMap, 'key', locale)` one, so applications call
+* {@link getIntlayerAsync} and never this function directly.
+*
+* @param dictionaryLoaders - Plain or qualified per-locale loader map.
+* @param key - Dictionary key, used to namespace the chunk cache.
+* @param localeOrSelector - The locale, or a selector object (`{ item }`,
+*                           `{ variant }`, optionally with `locale`).
+* @param plugins - Node transformers. Defaults to the base interpreter set.
+*/
+const getDictionaryAsync = async (dictionaryLoaders, key, localeOrSelector, plugins) => {
+	let locale;
+	let selector;
+	if (process.env.INTLAYER_DICTIONARY_SELECTOR !== "false") {
+		const parsed = require_dictionaryManipulator_qualifiedDictionary.parseDictionarySelector(localeOrSelector);
+		locale = parsed.locale;
+		selector = parsed.selector;
+	} else locale = localeOrSelector;
+	const localeTarget = locale ?? _intlayer_config_built.internationalization.defaultLocale;
+	const cacheKey = `${key}_${localeTarget}_${require_dictionaryManipulator_qualifiedDictionary.getDictionarySelectorCacheKey(selector)}_${require_interpreter_dictionaryTransformCache.getPluginsCacheKey(plugins)}`;
+	const cachedContent = contentPromiseCache.get(cacheKey);
+	if (cachedContent) return cachedContent;
+	const transform = (dictionary) => require_interpreter_getDictionary.getDictionary(dictionary, localeTarget, plugins);
+	const contentPromise = process.env.INTLAYER_DICTIONARY_SELECTOR !== "false" && require_dictionaryManipulator_qualifiedDynamicLoader.isQualifiedDynamicLoaderMap(dictionaryLoaders) ? require_dictionaryManipulator_qualifiedDynamicLoader.resolveQualifiedDynamicContentAsync({
+		loaderMap: dictionaryLoaders,
+		key,
+		locale: localeTarget,
+		selector,
+		transform
+	}) : loadPlainChunk(dictionaryLoaders, localeTarget, transform);
+	contentPromiseCache.set(cacheKey, contentPromise);
+	contentPromise.catch(() => contentPromiseCache.delete(cacheKey));
+	return contentPromise;
+};
+
+//#endregion
+exports.getDictionaryAsync = getDictionaryAsync;
+//# sourceMappingURL=getDictionaryAsync.cjs.map

package/dist/cjs/interpreter/getDictionaryAsync.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"getDictionaryAsync.cjs","names":["findPlainDynamicLoader","parseDictionarySelector","internationalization","getDictionarySelectorCacheKey","getPluginsCacheKey","getDictionary","isQualifiedDynamicLoaderMap","resolveQualifiedDynamicContentAsync"],"sources":["../../../src/interpreter/getDictionaryAsync.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport type {\n  Dictionary,\n  DictionarySelector,\n} from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  ExtractSelectorLocale,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport {\n  findPlainDynamicLoader,\n  type PlainDynamicLoaderMap,\n} from '../dictionaryManipulator/plainDynamicLoader';\nimport {\n  getDictionarySelectorCacheKey,\n  parseDictionarySelector,\n} from '../dictionaryManipulator/qualifiedDictionary';\nimport {\n  isQualifiedDynamicLoaderMap,\n  type QualifiedDynamicLoaderMap,\n  resolveQualifiedDynamicContentAsync,\n} from '../dictionaryManipulator/qualifiedDynamicLoader';\nimport { getPluginsCacheKey } from './dictionaryTransformCache';\nimport type {\n  DeepTransformContent,\n  IInterpreterPluginState,\n  Plugins,\n} from './getContent';\nimport { getDictionary } from './getDictionary';\n\n/**\n * Content already resolved for a `key + locale + selector` triple, or the\n * in-flight promise resolving it. Storing the promise itself makes the cache\n * double as an in-flight deduplication table: concurrent calls for the same\n * chunk await one single load.\n */\nconst contentPromiseCache = new Map<string, Promise<unknown>>();\n\n/**\n * Awaits the chunk a plain loader map holds for `locale` — walking the same\n * fallback chain as static mode — and transforms it.\n *\n * Returns `null` when the map emitted no chunk for the locale nor for any of\n * its fallbacks, mirroring how a missing qualified coordinate resolves.\n */\nconst loadPlainChunk = async <T extends Dictionary, Content>(\n  dictionaryLoaders: PlainDynamicLoaderMap<T>,\n  locale: LocalesValues,\n  transform: (dictionary: Dictionary) => Content\n): Promise<Content | null> => {\n  const resolved = findPlainDynamicLoader<T>(dictionaryLoaders, locale);\n\n  if (!resolved) return null;\n\n  return transform(await resolved.loader());\n};\n\n/**\n * Loads a single locale chunk of a dictionary and returns its transformed\n * content.\n *\n * Counterpart of {@link getDictionary} for the per-locale loader maps emitted\n * in `.intlayer/dynamic_dictionaries/`: instead of receiving a dictionary\n * holding every locale, it receives the loader map and awaits only the chunk\n * the requested locale needs.\n *\n * The loader map is either plain (`locale → loader`) or qualified\n * (`locale → qualifierId → loader`, for collections and variants). For a\n * qualified map, only the chunk(s) the selector targets are loaded.\n *\n * Build plugins rewrite every `getIntlayerAsync('key', locale)` call into a\n * `getDictionaryAsync(loaderMap, 'key', locale)` one, so applications call\n * {@link getIntlayerAsync} and never this function directly.\n *\n * @param dictionaryLoaders - Plain or qualified per-locale loader map.\n * @param key - Dictionary key, used to namespace the chunk cache.\n * @param localeOrSelector - The locale, or a selector object (`{ item }`,\n *                           `{ variant }`, optionally with `locale`).\n * @param plugins - Node transformers. Defaults to the base interpreter set.\n */\nexport const getDictionaryAsync = async <\n  const T extends Dictionary,\n  const A extends LocalesValues | DictionarySelector = DeclaredLocales,\n>(\n  dictionaryLoaders: PlainDynamicLoaderMap<T> | QualifiedDynamicLoaderMap,\n  key: string,\n  localeOrSelector?: A,\n  plugins?: Plugins[]\n): Promise<\n  DeepTransformContent<\n    T['content'],\n    IInterpreterPluginState,\n    ExtractSelectorLocale<A>\n  >\n> => {\n  let locale: LocalesValues | undefined;\n  let selector: DictionarySelector | undefined;\n\n  if (process.env.INTLAYER_DICTIONARY_SELECTOR !== 'false') {\n    const parsed = parseDictionarySelector<LocalesValues>(localeOrSelector);\n    locale = parsed.locale;\n    selector = parsed.selector;\n  } else {\n    // Selectors are unused in this project (build-time flag): the argument can\n    // only be a locale, so the selector parsing is dead code.\n    locale = localeOrSelector as LocalesValues | undefined;\n  }\n\n  const localeTarget = locale ?? internationalization.defaultLocale;\n\n  const cacheKey = `${key}_${localeTarget}_${getDictionarySelectorCacheKey(\n    selector\n  )}_${getPluginsCacheKey(plugins)}`;\n\n  const cachedContent = contentPromiseCache.get(cacheKey);\n  if (cachedContent) return cachedContent as Promise<any>;\n\n  const transform = (dictionary: Dictionary) =>\n    getDictionary(dictionary, localeTarget, plugins);\n\n  const contentPromise =\n    process.env.INTLAYER_DICTIONARY_SELECTOR !== 'false' &&\n    isQualifiedDynamicLoaderMap(dictionaryLoaders)\n      ? resolveQualifiedDynamicContentAsync({\n          loaderMap: dictionaryLoaders,\n          key,\n          locale: localeTarget,\n          selector,\n          transform,\n        })\n      : loadPlainChunk(\n          dictionaryLoaders as PlainDynamicLoaderMap<T>,\n          localeTarget,\n          transform\n        );\n\n  contentPromiseCache.set(cacheKey, contentPromise);\n\n  // A rejected load must not stay cached, or every later call replays the\n  // same failure without ever retrying the chunk.\n  contentPromise.catch(() => contentPromiseCache.delete(cacheKey));\n\n  return contentPromise as Promise<any>;\n};\n"],"mappings":";;;;;;;;;;;;;;;AAqCA,MAAM,sCAAsB,IAAI,IAA8B;;;;;;;;AAS9D,MAAM,iBAAiB,OACrB,mBACA,QACA,cAC4B;CAC5B,MAAM,WAAWA,wEAA0B,mBAAmB,MAAM;CAEpE,IAAI,CAAC,UAAU,OAAO;CAEtB,OAAO,UAAU,MAAM,SAAS,OAAO,CAAC;AAC1C;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,MAAa,qBAAqB,OAIhC,mBACA,KACA,kBACA,YAOG;CACH,IAAI;CACJ,IAAI;CAEJ,IAAI,QAAQ,IAAI,iCAAiC,SAAS;EACxD,MAAM,SAASC,0EAAuC,gBAAgB;EACtE,SAAS,OAAO;EAChB,WAAW,OAAO;CACpB,OAGE,SAAS;CAGX,MAAM,eAAe,UAAUC,4CAAqB;CAEpD,MAAM,WAAW,GAAG,IAAI,GAAG,aAAa,GAAGC,gFACzC,QACF,EAAE,GAAGC,gEAAmB,OAAO;CAE/B,MAAM,gBAAgB,oBAAoB,IAAI,QAAQ;CACtD,IAAI,eAAe,OAAO;CAE1B,MAAM,aAAa,eACjBC,gDAAc,YAAY,cAAc,OAAO;CAEjD,MAAM,iBACJ,QAAQ,IAAI,iCAAiC,WAC7CC,iFAA4B,iBAAiB,IACzCC,yFAAoC;EAClC,WAAW;EACX;EACA,QAAQ;EACR;EACA;CACF,CAAC,IACD,eACE,mBACA,cACA,SACF;CAEN,oBAAoB,IAAI,UAAU,cAAc;CAIhD,eAAe,YAAY,oBAAoB,OAAO,QAAQ,CAAC;CAE/D,OAAO;AACT"}

package/dist/cjs/interpreter/getIntlayer.cjs

@@ -1,5 +1,4 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_dictionaryManipulator_qualifiedDictionary = require('../dictionaryManipulator/qualifiedDictionary.cjs');
 const require_interpreter_getDictionary = require('./getDictionary.cjs');
 let _intlayer_config_built = require("@intlayer/config/built");
 let _intlayer_config_logger = require("@intlayer/config/logger");
@@ -7,13 +6,33 @@ let _intlayer_dictionaries_entry = require("@intlayer/dictionaries-entry");
 
 //#region src/interpreter/getIntlayer.ts
 /**
+* Object.prototype methods libraries call on arbitrary values while inspecting
+* them — TanStack Router's `isPlainObject` reaches for `hasOwnProperty` on
+* every value it deep-compares. Answering them with another path proxy turns
+* a missing dictionary into `hasOwnProperty is not a function`, thrown deep
+* inside the consumer, so they are forwarded to the real implementations.
+*/
+const PROTOTYPE_METHOD_NAMES = /* @__PURE__ */ new Set([
+	"hasOwnProperty",
+	"isPrototypeOf",
+	"propertyIsEnumerable",
+	"toLocaleString"
+]);
+/**
 * Creates a Recursive Proxy that returns the path of the accessed key
 * stringified. This prevents the app from crashing on undefined access.
+*
+* The proxy wraps a function so that calling any leaf — `keywords.join(', ')`,
+* `title.trim()` — resolves to the path too, instead of throwing
+* `join is not a function`. Being callable also keeps structural checks
+* (`Object.prototype.toString`) from mistaking it for a plain object worth
+* walking.
 */
 const createSafeFallback = (path = "") => {
-	return new Proxy({}, { get: (_target, prop) => {
+	return new Proxy((() => path), { get: (target, prop) => {
 		if (prop === "toJSON" || prop === Symbol.toPrimitive || prop === "toString" || prop === "valueOf") return () => path;
 		if (prop === "then") return;
+		if (PROTOTYPE_METHOD_NAMES.has(prop)) return Object.prototype[prop].bind(target);
 		if (prop === Symbol.iterator) return function* () {
 			yield path;
 		};
@@ -21,7 +40,6 @@ const createSafeFallback = (path = "") => {
 		return createSafeFallback(nextPath);
 	} });
 };
-const dictionaryCache = /* @__PURE__ */ new Map();
 const warnedMissingDictionaries = /* @__PURE__ */ new Set();
 /**
 * Picks one dictionary by its key and returns its content for the given
@@ -42,18 +60,7 @@ const getIntlayer = (key, localeOrSelector, plugins) => {
 		}
 		return createSafeFallback(key);
 	}
-	let locale;
-	let selectorCacheKey = "";
-	if (process.env.INTLAYER_DICTIONARY_SELECTOR !== "false") {
-		const parsed = require_dictionaryManipulator_qualifiedDictionary.parseDictionarySelector(localeOrSelector);
-		locale = parsed.locale;
-		selectorCacheKey = require_dictionaryManipulator_qualifiedDictionary.getDictionarySelectorCacheKey(parsed.selector);
-	} else locale = localeOrSelector;
-	const cacheKey = `${key}_${locale ?? "default"}_${selectorCacheKey}_${plugins ? "custom_plugins" : "default_plugins"}`;
-	if (dictionaryCache.has(cacheKey)) return dictionaryCache.get(cacheKey);
-	const result = require_interpreter_getDictionary.getDictionary(dictionary, localeOrSelector, plugins);
-	dictionaryCache.set(cacheKey, result);
-	return result;
+	return require_interpreter_getDictionary.getDictionary(dictionary, localeOrSelector, plugins);
 };
 
 //#endregion

package/dist/cjs/interpreter/getIntlayer.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"getIntlayer.cjs","names":["getDictionaries","getAppLogger","colorizeKey","parseDictionarySelector","getDictionarySelectorCacheKey","getDictionary"],"sources":["../../../src/interpreter/getIntlayer.ts"],"sourcesContent":["import { log } from '@intlayer/config/built';\nimport { colorizeKey, getAppLogger } from '@intlayer/config/logger';\nimport { getDictionaries } from '@intlayer/dictionaries-entry';\nimport type { DictionarySelector } from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  DictionaryKeys,\n  DictionaryRegistryResult,\n  ExtractSelectorLocale,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport {\n  getDictionarySelectorCacheKey,\n  parseDictionarySelector,\n} from '../dictionaryManipulator/qualifiedDictionary';\nimport type {\n  DeepTransformContent,\n  IInterpreterPluginState,\n  Plugins,\n} from './getContent';\nimport { getDictionary } from './getDictionary';\n\n/**\n * Creates a Recursive Proxy that returns the path of the accessed key\n * stringified. This prevents the app from crashing on undefined access.\n */\nconst createSafeFallback = (path = ''): any => {\n  return new Proxy({} as Record<string | symbol, unknown>, {\n    get: (_target, prop) => {\n      if (\n        prop === 'toJSON' ||\n        prop === Symbol.toPrimitive ||\n        prop === 'toString' ||\n        prop === 'valueOf'\n      ) {\n        return () => path;\n      }\n      if (prop === 'then') {\n        return undefined; // Prevent it from being treated as a Promise\n      }\n      if (prop === Symbol.iterator) {\n        return function* () {\n          yield path;\n        };\n      }\n\n      // Recursively build the path (e.g., \"myDictionary.home.title\")\n      const nextPath = path ? `${path}.${String(prop)}` : String(prop);\n      return createSafeFallback(nextPath);\n    },\n  });\n};\n\nconst dictionaryCache = new Map<string, any>();\nconst warnedMissingDictionaries = new Set<string>();\n\n/**\n * Picks one dictionary by its key and returns its content for the given\n * locale or selector.\n *\n * The second argument is either a locale (`'fr'`) or a selector object:\n * - `{ item: 2 }` — collection item (omit `item` to get every item as array)\n * - `{ variant: 'black-friday' }` — named variant (omit for the `default` one)\n * - `{ variant: { id: 'prod_abc', userId: '123' } }` — structured variant\n * - `locale` can be combined with any selector: `{ item: 2, locale: 'fr' }`\n */\nexport const getIntlayer = <\n  const T extends DictionaryKeys,\n  const A extends LocalesValues | DictionarySelector = DeclaredLocales,\n>(\n  key: T,\n  localeOrSelector?: A,\n  plugins?: Plugins[]\n): DeepTransformContent<\n  DictionaryRegistryResult<T, A>,\n  IInterpreterPluginState,\n  ExtractSelectorLocale<A>\n> => {\n  const dictionaries = getDictionaries();\n  const dictionary = dictionaries[key as T];\n\n  if (!dictionary && process.env.NODE_ENV === 'development') {\n    if (!warnedMissingDictionaries.has(key as string)) {\n      // Log a warning instead of throwing (so developers know it's missing)\n      const logger = getAppLogger({ log });\n      logger(\n        typeof window === 'undefined'\n          ? `Dictionary ${colorizeKey(key)} was not found. Using fallback proxy.`\n          : `Dictionary ${key} was not found. Using fallback proxy.`,\n        {\n          level: 'warn',\n        }\n      );\n      warnedMissingDictionaries.add(key as string);\n    }\n\n    return createSafeFallback(key as string);\n  }\n\n  let locale: LocalesValues | undefined;\n  let selectorCacheKey = '';\n\n  if (process.env.INTLAYER_DICTIONARY_SELECTOR !== 'false') {\n    const parsed = parseDictionarySelector(localeOrSelector);\n    locale = parsed.locale;\n    selectorCacheKey = getDictionarySelectorCacheKey(parsed.selector);\n  } else {\n    // Selectors are unused in this project (build-time flag): the second\n    // argument can only be a locale, so the selector parsing is dead code.\n    locale = localeOrSelector as LocalesValues | undefined;\n  }\n\n  const cacheKey = `${key}_${locale ?? 'default'}_${selectorCacheKey}_${plugins ? 'custom_plugins' : 'default_plugins'}`;\n\n  if (dictionaryCache.has(cacheKey)) {\n    return dictionaryCache.get(cacheKey);\n  }\n\n  const result = getDictionary(dictionary, localeOrSelector, plugins);\n\n  dictionaryCache.set(cacheKey, result);\n\n  return result as any;\n};\n"],"mappings":";;;;;;;;;;;;AA0BA,MAAM,sBAAsB,OAAO,OAAY;CAC7C,OAAO,IAAI,MAAM,CAAC,GAAuC,EACvD,MAAM,SAAS,SAAS;EACtB,IACE,SAAS,YACT,SAAS,OAAO,eAChB,SAAS,cACT,SAAS,WAET,aAAa;EAEf,IAAI,SAAS,QACX;EAEF,IAAI,SAAS,OAAO,UAClB,OAAO,aAAa;GAClB,MAAM;EACR;EAIF,MAAM,WAAW,OAAO,GAAG,KAAK,GAAG,OAAO,IAAI,MAAM,OAAO,IAAI;EAC/D,OAAO,mBAAmB,QAAQ;CACpC,EACF,CAAC;AACH;AAEA,MAAM,kCAAkB,IAAI,IAAiB;AAC7C,MAAM,4CAA4B,IAAI,IAAY;;;;;;;;;;;AAYlD,MAAa,eAIX,KACA,kBACA,YAKG;CAEH,MAAM,iBADeA,8CACS,CAAC,CAAC;CAEhC,IAAI,CAAC,cAAc,QAAQ,IAAI,aAAa,eAAe;EACzD,IAAI,CAAC,0BAA0B,IAAI,GAAa,GAAG;GAGjD,IADeC,sCAAa,EAAE,gCAAI,CAC7B,CAAC,CACJ,OAAO,WAAW,cACd,kBAAcC,qCAAY,GAAG,EAAE,yCAC/B,cAAc,IAAI,wCACtB,EACE,OAAO,OACT,CACF;GACA,0BAA0B,IAAI,GAAa;EAC7C;EAEA,OAAO,mBAAmB,GAAa;CACzC;CAEA,IAAI;CACJ,IAAI,mBAAmB;CAEvB,IAAI,QAAQ,IAAI,iCAAiC,SAAS;EACxD,MAAM,SAASC,0EAAwB,gBAAgB;EACvD,SAAS,OAAO;EAChB,mBAAmBC,gFAA8B,OAAO,QAAQ;CAClE,OAGE,SAAS;CAGX,MAAM,WAAW,GAAG,IAAI,GAAG,UAAU,UAAU,GAAG,iBAAiB,GAAG,UAAU,mBAAmB;CAEnG,IAAI,gBAAgB,IAAI,QAAQ,GAC9B,OAAO,gBAAgB,IAAI,QAAQ;CAGrC,MAAM,SAASC,gDAAc,YAAY,kBAAkB,OAAO;CAElE,gBAAgB,IAAI,UAAU,MAAM;CAEpC,OAAO;AACT"}
+{"version":3,"file":"getIntlayer.cjs","names":["getDictionaries","getAppLogger","colorizeKey","getDictionary"],"sources":["../../../src/interpreter/getIntlayer.ts"],"sourcesContent":["import { log } from '@intlayer/config/built';\nimport { colorizeKey, getAppLogger } from '@intlayer/config/logger';\nimport { getDictionaries } from '@intlayer/dictionaries-entry';\nimport type { DictionarySelector } from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  DictionaryKeys,\n  DictionaryRegistryResult,\n  ExtractSelectorLocale,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport type {\n  DeepTransformContent,\n  IInterpreterPluginState,\n  Plugins,\n} from './getContent';\nimport { getDictionary } from './getDictionary';\n\n/**\n * Object.prototype methods libraries call on arbitrary values while inspecting\n * them — TanStack Router's `isPlainObject` reaches for `hasOwnProperty` on\n * every value it deep-compares. Answering them with another path proxy turns\n * a missing dictionary into `hasOwnProperty is not a function`, thrown deep\n * inside the consumer, so they are forwarded to the real implementations.\n */\nconst PROTOTYPE_METHOD_NAMES = new Set<string | symbol>([\n  'hasOwnProperty',\n  'isPrototypeOf',\n  'propertyIsEnumerable',\n  'toLocaleString',\n]);\n\n/**\n * Creates a Recursive Proxy that returns the path of the accessed key\n * stringified. This prevents the app from crashing on undefined access.\n *\n * The proxy wraps a function so that calling any leaf — `keywords.join(', ')`,\n * `title.trim()` — resolves to the path too, instead of throwing\n * `join is not a function`. Being callable also keeps structural checks\n * (`Object.prototype.toString`) from mistaking it for a plain object worth\n * walking.\n */\nconst createSafeFallback = (path = ''): any => {\n  return new Proxy((() => path) as Record<string | symbol, any>, {\n    get: (target, prop) => {\n      if (\n        prop === 'toJSON' ||\n        prop === Symbol.toPrimitive ||\n        prop === 'toString' ||\n        prop === 'valueOf'\n      ) {\n        return () => path;\n      }\n      if (prop === 'then') {\n        return undefined; // Prevent it from being treated as a Promise\n      }\n      if (PROTOTYPE_METHOD_NAMES.has(prop)) {\n        return (Object.prototype as Record<string | symbol, any>)[prop].bind(\n          target\n        );\n      }\n      if (prop === Symbol.iterator) {\n        return function* () {\n          yield path;\n        };\n      }\n\n      // Recursively build the path (e.g., \"myDictionary.home.title\")\n      const nextPath = path ? `${path}.${String(prop)}` : String(prop);\n      return createSafeFallback(nextPath);\n    },\n  });\n};\n\nconst warnedMissingDictionaries = new Set<string>();\n\n/**\n * Picks one dictionary by its key and returns its content for the given\n * locale or selector.\n *\n * The second argument is either a locale (`'fr'`) or a selector object:\n * - `{ item: 2 }` — collection item (omit `item` to get every item as array)\n * - `{ variant: 'black-friday' }` — named variant (omit for the `default` one)\n * - `{ variant: { id: 'prod_abc', userId: '123' } }` — structured variant\n * - `locale` can be combined with any selector: `{ item: 2, locale: 'fr' }`\n */\nexport const getIntlayer = <\n  const T extends DictionaryKeys,\n  const A extends LocalesValues | DictionarySelector = DeclaredLocales,\n>(\n  key: T,\n  localeOrSelector?: A,\n  plugins?: Plugins[]\n): DeepTransformContent<\n  DictionaryRegistryResult<T, A>,\n  IInterpreterPluginState,\n  ExtractSelectorLocale<A>\n> => {\n  const dictionaries = getDictionaries();\n  const dictionary = dictionaries[key as T]!;\n\n  if (!dictionary && process.env.NODE_ENV === 'development') {\n    if (!warnedMissingDictionaries.has(key as string)) {\n      // Log a warning instead of throwing (so developers know it's missing)\n      const logger = getAppLogger({ log });\n      logger(\n        typeof window === 'undefined'\n          ? `Dictionary ${colorizeKey(key)} was not found. Using fallback proxy.`\n          : `Dictionary ${key} was not found. Using fallback proxy.`,\n        {\n          level: 'warn',\n        }\n      );\n      warnedMissingDictionaries.add(key as string);\n    }\n\n    return createSafeFallback(key as string);\n  }\n\n  return getDictionary(dictionary, localeOrSelector, plugins) as any;\n};\n"],"mappings":";;;;;;;;;;;;;;AAyBA,MAAM,yCAAyB,IAAI,IAAqB;CACtD;CACA;CACA;CACA;AACF,CAAC;;;;;;;;;;;AAYD,MAAM,sBAAsB,OAAO,OAAY;CAC7C,OAAO,IAAI,aAAa,OAAuC,EAC7D,MAAM,QAAQ,SAAS;EACrB,IACE,SAAS,YACT,SAAS,OAAO,eAChB,SAAS,cACT,SAAS,WAET,aAAa;EAEf,IAAI,SAAS,QACX;EAEF,IAAI,uBAAuB,IAAI,IAAI,GACjC,OAAQ,OAAO,UAA2C,KAAK,CAAC,KAC9D,MACF;EAEF,IAAI,SAAS,OAAO,UAClB,OAAO,aAAa;GAClB,MAAM;EACR;EAIF,MAAM,WAAW,OAAO,GAAG,KAAK,GAAG,OAAO,IAAI,MAAM,OAAO,IAAI;EAC/D,OAAO,mBAAmB,QAAQ;CACpC,EACF,CAAC;AACH;AAEA,MAAM,4CAA4B,IAAI,IAAY;;;;;;;;;;;AAYlD,MAAa,eAIX,KACA,kBACA,YAKG;CAEH,MAAM,iBADeA,8CACS,CAAC,CAAC;CAEhC,IAAI,CAAC,cAAc,QAAQ,IAAI,aAAa,eAAe;EACzD,IAAI,CAAC,0BAA0B,IAAI,GAAa,GAAG;GAGjD,IADeC,sCAAa,EAAE,gCAAI,CAC7B,CAAC,CACJ,OAAO,WAAW,cACd,kBAAcC,qCAAY,GAAG,EAAE,yCAC/B,cAAc,IAAI,wCACtB,EACE,OAAO,OACT,CACF;GACA,0BAA0B,IAAI,GAAa;EAC7C;EAEA,OAAO,mBAAmB,GAAa;CACzC;CAEA,OAAOC,gDAAc,YAAY,kBAAkB,OAAO;AAC5D"}

package/dist/cjs/interpreter/getIntlayerAsync.cjs

@@ -0,0 +1,36 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_interpreter_getIntlayer = require('./getIntlayer.cjs');
+
+//#region src/interpreter/getIntlayerAsync.ts
+/**
+* Picks one dictionary by its key and resolves its content for the given
+* locale or selector, loading that locale alone.
+*
+* Async counterpart of {@link getIntlayer}, meant for the places a dictionary
+* is read outside of rendering — route `head` / metadata builders, loaders,
+* server functions. Where `getIntlayer` pulls in the merged dictionary holding
+* every locale, the build plugins (`@intlayer/babel`, `@intlayer/swc`) rewrite
+* this call into `getDictionaryAsync(loaderMap, key, locale)`, pointing it at
+* the per-locale chunks in `.intlayer/dynamic_dictionaries/`, so the bundle
+* only ever carries the locale actually requested.
+*
+* Without those plugins — an unoptimized build — the call resolves through the
+* synchronous dictionary registry instead: the same content, without the
+* per-locale split.
+*
+* The second argument is either a locale (`'fr'`) or a selector object:
+* - `{ item: 2 }` — collection item (omit `item` to get every item as array)
+* - `{ variant: 'black-friday' }` — named variant (omit for the `default` one)
+* - `{ variant: { id: 'prod_abc', userId: '123' } }` — structured variant
+* - `locale` can be combined with any selector: `{ item: 2, locale: 'fr' }`
+*
+* @example
+* ```ts
+* const { title } = await getIntlayerAsync('home-metadata', locale);
+* ```
+*/
+const getIntlayerAsync = async (key, localeOrSelector, plugins) => require_interpreter_getIntlayer.getIntlayer(key, localeOrSelector, plugins);
+
+//#endregion
+exports.getIntlayerAsync = getIntlayerAsync;
+//# sourceMappingURL=getIntlayerAsync.cjs.map

package/dist/cjs/interpreter/getIntlayerAsync.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"getIntlayerAsync.cjs","names":["getIntlayer"],"sources":["../../../src/interpreter/getIntlayerAsync.ts"],"sourcesContent":["import type { DictionarySelector } from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  DictionaryKeys,\n  DictionaryRegistryResult,\n  ExtractSelectorLocale,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport type {\n  DeepTransformContent,\n  IInterpreterPluginState,\n  Plugins,\n} from './getContent';\nimport { getIntlayer } from './getIntlayer';\n\n/**\n * Picks one dictionary by its key and resolves its content for the given\n * locale or selector, loading that locale alone.\n *\n * Async counterpart of {@link getIntlayer}, meant for the places a dictionary\n * is read outside of rendering — route `head` / metadata builders, loaders,\n * server functions. Where `getIntlayer` pulls in the merged dictionary holding\n * every locale, the build plugins (`@intlayer/babel`, `@intlayer/swc`) rewrite\n * this call into `getDictionaryAsync(loaderMap, key, locale)`, pointing it at\n * the per-locale chunks in `.intlayer/dynamic_dictionaries/`, so the bundle\n * only ever carries the locale actually requested.\n *\n * Without those plugins — an unoptimized build — the call resolves through the\n * synchronous dictionary registry instead: the same content, without the\n * per-locale split.\n *\n * The second argument is either a locale (`'fr'`) or a selector object:\n * - `{ item: 2 }` — collection item (omit `item` to get every item as array)\n * - `{ variant: 'black-friday' }` — named variant (omit for the `default` one)\n * - `{ variant: { id: 'prod_abc', userId: '123' } }` — structured variant\n * - `locale` can be combined with any selector: `{ item: 2, locale: 'fr' }`\n *\n * @example\n * ```ts\n * const { title } = await getIntlayerAsync('home-metadata', locale);\n * ```\n */\nexport const getIntlayerAsync = async <\n  const T extends DictionaryKeys,\n  const A extends LocalesValues | DictionarySelector = DeclaredLocales,\n>(\n  key: T,\n  localeOrSelector?: A,\n  plugins?: Plugins[]\n): Promise<\n  DeepTransformContent<\n    DictionaryRegistryResult<T, A>,\n    IInterpreterPluginState,\n    ExtractSelectorLocale<A>\n  >\n> => getIntlayer<T, A>(key, localeOrSelector, plugins);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CA,MAAa,mBAAmB,OAI9B,KACA,kBACA,YAOGA,4CAAkB,KAAK,kBAAkB,OAAO"}

package/dist/cjs/interpreter/index.cjs

@@ -1,4 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_interpreter_dictionaryTransformCache = require('./dictionaryTransformCache.cjs');
 const require_interpreter_getCondition = require('./getCondition.cjs');
 const require_interpreter_getContent_deepTransform = require('./getContent/deepTransform.cjs');
 const require_interpreter_getEnumeration = require('./getEnumeration.cjs');
@@ -13,7 +14,9 @@ const require_interpreter_getTranslation = require('./getTranslation.cjs');
 const require_interpreter_interpolableNode = require('./interpolableNode.cjs');
 const require_interpreter_getContent_plugins = require('./getContent/plugins.cjs');
 const require_interpreter_getContent_getContent = require('./getContent/getContent.cjs');
+const require_interpreter_getDictionaryAsync = require('./getDictionaryAsync.cjs');
 const require_interpreter_getHTML = require('./getHTML.cjs');
+const require_interpreter_getIntlayerAsync = require('./getIntlayerAsync.cjs');
 const require_interpreter_splitAndJoinInsertion = require('./splitAndJoinInsertion.cjs');
 
 exports.conditionPlugin = require_interpreter_getContent_plugins.conditionPlugin;
@@ -27,13 +30,17 @@ exports.getBasePlugins = require_interpreter_getContent_getContent.getBasePlugin
 exports.getCondition = require_interpreter_getCondition.getCondition;
 exports.getContent = require_interpreter_getContent_getContent.getContent;
 exports.getDictionary = require_interpreter_getDictionary.getDictionary;
+exports.getDictionaryAsync = require_interpreter_getDictionaryAsync.getDictionaryAsync;
+exports.getDictionaryTransformCacheKey = require_interpreter_dictionaryTransformCache.getDictionaryTransformCacheKey;
 exports.getEnumeration = require_interpreter_getEnumeration.getEnumeration;
 exports.getGender = require_interpreter_getGender.getGender;
 exports.getHTML = require_interpreter_getHTML.getHTML;
 exports.getInsertion = require_interpreter_getInsertion.getInsertion;
 exports.getInterpolableContent = require_interpreter_interpolableNode.getInterpolableContent;
 exports.getIntlayer = require_interpreter_getIntlayer.getIntlayer;
+exports.getIntlayerAsync = require_interpreter_getIntlayerAsync.getIntlayerAsync;
 exports.getNesting = require_interpreter_getNesting.getNesting;
+exports.getPluginsCacheKey = require_interpreter_dictionaryTransformCache.getPluginsCacheKey;
 exports.getPlural = require_interpreter_getPlural.getPlural;
 exports.getSelect = require_interpreter_getSelect.getSelect;
 exports.getTranslation = require_interpreter_getTranslation.getTranslation;
@@ -41,8 +48,10 @@ exports.insertionPlugin = require_interpreter_getContent_plugins.insertionPlugin
 exports.isInterpolableWrapperNode = require_interpreter_interpolableNode.isInterpolableWrapperNode;
 exports.nestedPlugin = require_interpreter_getContent_plugins.nestedPlugin;
 exports.pluralPlugin = require_interpreter_getContent_plugins.pluralPlugin;
+exports.readTransformCache = require_interpreter_dictionaryTransformCache.readTransformCache;
 exports.rebuildInterpolableContent = require_interpreter_interpolableNode.rebuildInterpolableContent;
 exports.selectPlugin = require_interpreter_getContent_plugins.selectPlugin;
 exports.splitInsertionTemplate = require_interpreter_splitAndJoinInsertion.splitInsertionTemplate;
 exports.transformInterpolableNode = require_interpreter_interpolableNode.transformInterpolableNode;
-exports.translationPlugin = require_interpreter_getContent_plugins.translationPlugin;
+exports.translationPlugin = require_interpreter_getContent_plugins.translationPlugin;
+exports.writeTransformCache = require_interpreter_dictionaryTransformCache.writeTransformCache;