@intlayer/core 9.1.3 → 9.3.0

package/dist/types/dictionaryManipulator/qualifiedDictionary.d.ts

@@ -1,12 +1,6 @@
-import { Dictionary, DictionaryQualifierType, DictionarySelector, DictionaryVariantChain, DictionaryVariantValue, ProviderVariant, QualifiedDictionaryGroup } from "@intlayer/types/dictionary";
+import { Dictionary, DictionarySelector, DictionaryVariantChain, DictionaryVariantValue, ProviderVariant, QualifiedDictionaryGroup } from "@intlayer/types/dictionary";
 import { LocalesValues } from "@intlayer/types/module_augmentation";
 //#region src/dictionaryManipulator/qualifiedDictionary.d.ts
-/**
- * Canonical order of qualifier dimensions. A key that declares both dimensions
- * always nests them in this order, with `item` innermost so it can act as the
- * collection (array) axis.
- */
-declare const QUALIFIER_ORDER: readonly ["variant", "item"];
 /**
  * Separator joining per-dimension ids into a composite entry id. Also used as
  * the chunk path separator in dynamic mode.
@@ -37,36 +31,6 @@ declare const DEFAULT_VARIANT_ID = "default";
  * an object variant in a selector must equal the one declared on the dictionary.
  */
 declare const serializeVariant: (variant: DictionaryVariantValue | undefined) => string;
-/**
- * Normalizes the `variant` field of a dictionary into the list of variant ids
- * the declaration registers under. A single value yields one id; an **array**
- * fans out into one id per element (duplicates collapsed). Returns `undefined`
- * when the dictionary does not declare the variant dimension (no `variant`
- * field, or an empty array).
- */
-declare const getVariantIds: (variant: Dictionary['variant']) => string[] | undefined;
-/**
- * Returns the qualifier dimensions declared on a dictionary, in canonical
- * order (`variant → item`). Empty when the dictionary is unqualified
- * (plain dictionary or shared base content of a qualified group).
- */
-declare const getDictionaryQualifierTypes: (dictionary: Dictionary) => DictionaryQualifierType[];
-/**
- * Returns the qualifier identifiers of a dictionary for the given qualifier
- * dimension — the candidate segments of the composite entry ids.
- *
- * - 'variant' → the serialized variant id(s); an array variant yields one id
- *   per element (declaration-side fan-out)
- * - 'item' → the item index as a single-element list
- */
-declare const getDictionaryQualifierIds: (dictionary: Dictionary, qualifierType: DictionaryQualifierType) => string[] | undefined;
-/**
- * Builds every composite entry id of a dictionary — the cartesian product of
- * its per-dimension id lists, joined in canonical order. A dictionary with a
- * plain (non-array) variant yields exactly one id; an array variant fans out
- * into one id per element. `undefined` when a dimension of the set is missing.
- */
-declare const getDictionaryCompositeIds: (dictionary: Dictionary, qualifierTypes: DictionaryQualifierType[]) => string[] | undefined;
 /**
  * Serializes the variant coordinate of a selector into the ordered list of
  * candidate ids to try, so a single value and a preference chain share one code
@@ -80,6 +44,22 @@ declare const getDictionaryCompositeIds: (dictionary: Dictionary, qualifierTypes
  * as an unsatisfiable request.
  */
 declare const serializeVariantChain: (variant: DictionaryVariantChain | undefined) => string[];
+/**
+ * Resolves the variant id a selector actually targets among the ids a key
+ * declares — the sparse-override fallback.
+ *
+ * Candidates are tried in order and the first one the key declares wins.
+ * Otherwise the key falls back to its `default` entry, so a variant only has to
+ * be declared where its wording differs. When the key declares no `default`
+ * either, the first candidate is returned unchanged and the caller resolves to
+ * `null` / `[]`.
+ *
+ * @param requestedVariantIds - The serialized ids the selector asks for, in
+ *                              preference order (a single value is a 1-element
+ *                              list).
+ * @param isVariantIdDeclared - Whether the key declares an entry for an id.
+ */
+declare const resolveEffectiveVariantId: (requestedVariantIds: string[], isVariantIdDeclared: (variantId: string) => boolean) => string;
 /**
  * Type guard discriminating a `QualifiedDictionaryGroup` (merge output of a
  * qualified key) from a plain `Dictionary`. Both carry a `content` field; only
@@ -163,94 +143,6 @@ declare const resolveDictionaryArgument: (params: {
  * for cache keys and memoization dependencies.
  */
 declare const getDictionarySelectorCacheKey: (selector?: DictionarySelector) => string;
-/**
- * Marker property carrying the ordered qualifier dimensions on a dynamic loader
- * map. Its presence distinguishes a qualified group loader map (a nested tree
- * of chunks) from a plain dynamic loader map (one chunk per `locale`). Prefixed
- * and unlikely to collide with a real locale code.
- */
-declare const QUALIFIER_DYNAMIC_TYPES_KEY = "__intlayerQualifierTypes";
-/**
- * A lazily-imported per-locale dictionary chunk loader.
- */
-type DynamicDictionaryLoader = () => Promise<Dictionary>;
-/**
- * Nested tree of chunk loaders: one nesting level per declared dimension (in
- * canonical order), leaves are loaders.
- */
-type QualifiedDynamicLoaderTree = {
-  [segment: string]: QualifiedDynamicLoaderTree | DynamicDictionaryLoader;
-};
-/**
- * Default export shape of a generated dynamic entry point for a qualified key.
- * One nesting level per dimension under each locale, plus the dimension marker.
- *
- * ```ts
- * {
- *   __intlayerQualifierTypes: ['variant', 'item'],
- *   en: { promo: { '1': () => import('./json/x/promo/1/en.json'), … }, … },
- *   fr: { … },
- * }
- * ```
- */
-type QualifiedDynamicLoaderMap = {
-  [QUALIFIER_DYNAMIC_TYPES_KEY]: DictionaryQualifierType[];
-  [locale: string]: QualifiedDynamicLoaderTree | DictionaryQualifierType[];
-};
-/**
- * Type guard discriminating a qualified dynamic loader map (collections /
- * variants, possibly combined) from a plain dynamic loader map.
- */
-declare const isQualifiedDynamicLoaderMap: (value: unknown) => value is QualifiedDynamicLoaderMap;
-/**
- * Resolves the content of a qualified dynamic loader map against a selector,
- * loading only the chunk(s) the selector actually targets.
- *
- * Walks the nested loader tree one dimension at a time (canonical order
- * `variant → item`): `variant` descends by the serialized id, falling back to
- * `default` when the selected variant has no chunk of its own, and `item`
- * either narrows to the selected index or — when no item is given — expands
- * into every sibling chunk (the collection axis). Semantics mirror
- * {@link resolveQualifiedDictionary} so dynamic and static modes behave alike.
- *
- * The Suspense mechanism is injected through `loadChunk` so the same logic
- * serves both the client (suspender cache) and the server (`react.use`). Every
- * targeted loader is started before the first chunk is read, so sibling chunks
- * load in parallel rather than waterfalling.
- *
- * @param loaderMap - The qualified dynamic loader map (entry point default export).
- * @param key - The dictionary key (used to build stable chunk cache keys).
- * @param locale - The resolved locale to load chunks for.
- * @param selector - The selector splitting the qualifier dimensions.
- * @param loadChunk - Reads a started chunk promise, suspending until it resolves.
- * @param transform - Turns a resolved chunk dictionary into final content.
- */
-declare const resolveQualifiedDynamicContent: <Content>(params: {
-  loaderMap: QualifiedDynamicLoaderMap;
-  key: string;
-  locale: string;
-  selector: DictionarySelector | undefined;
-  loadChunk: (cacheKey: string, promise: Promise<Dictionary>) => Dictionary;
-  transform: (dictionary: Dictionary) => Content;
-}) => Content | Content[] | null;
-/**
- * Async counterpart of {@link resolveQualifiedDynamicContent} for frameworks
- * that load dictionaries with `await` instead of Suspense (Vue, Svelte, Lit,
- * vanilla). Awaits every targeted chunk in parallel, then resolves identically.
- *
- * @param loaderMap - The qualified dynamic loader map.
- * @param key - The dictionary key (used to build stable chunk cache keys).
- * @param locale - The resolved locale to load chunks for.
- * @param selector - The selector splitting the qualifier dimensions.
- * @param transform - Turns a resolved chunk dictionary into final content.
- */
-declare const resolveQualifiedDynamicContentAsync: <Content>(params: {
-  loaderMap: QualifiedDynamicLoaderMap;
-  key: string;
-  locale: string;
-  selector: DictionarySelector | undefined;
-  transform: (dictionary: Dictionary) => Content;
-}) => Promise<Content | Content[] | null>;
 //#endregion
-export { COMPOSITE_ID_SEPARATOR, DEFAULT_VARIANT_ID, DynamicDictionaryLoader, QUALIFIER_DYNAMIC_TYPES_KEY, QUALIFIER_ORDER, QualifiedDynamicLoaderMap, QualifiedDynamicLoaderTree, getDictionaryCompositeIds, getDictionaryQualifierIds, getDictionaryQualifierTypes, getDictionarySelectorCacheKey, getVariantIds, isQualifiedDictionaryGroup, isQualifiedDynamicLoaderMap, parseDictionarySelector, reconstructQualifiedEntry, resolveDictionaryArgument, resolveProviderVariant, resolveQualifiedDictionary, resolveQualifiedDynamicContent, resolveQualifiedDynamicContentAsync, serializeVariant, serializeVariantChain };
+export { COMPOSITE_ID_SEPARATOR, DEFAULT_VARIANT_ID, getDictionarySelectorCacheKey, isQualifiedDictionaryGroup, parseDictionarySelector, reconstructQualifiedEntry, resolveDictionaryArgument, resolveEffectiveVariantId, resolveProviderVariant, resolveQualifiedDictionary, serializeVariant, serializeVariantChain };
 //# sourceMappingURL=qualifiedDictionary.d.ts.map

package/dist/types/dictionaryManipulator/qualifiedDictionary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"qualifiedDictionary.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/qualifiedDictionary.ts"],"mappings":";;;;;;;;cAiBa;;;;;cASA;;;;;;cAOA;;;;;;;;;;;;;;;;;;;cAqDA,mBAAgB,SAClB;;;;;;;;cAuBE,gBAAa,SACf;;;;;;cAeE,8BAA2B,YAC1B,eACX;;;;;;;;;cAmBU,4BAAyB,YACxB,YAAU,eACP;;;;;;;cAcJ,4BAAyB,YACxB,YAAU,gBACN;;;;;;;;;;;;;cA8BL,wBAAqB,SACvB;;;;;;cAwEE,6BAA0B,mBAEpC,SAAS;;;;;;;;;;;;cAkBC,4BAAyB,OAC7B,0BAAwB,wBAE9B;;;;;;;;;;;;;;;;cAkCU,6BAA0B,mBAClB,aAAa,0BAAwB,WAC7C,uBACV,aAAa;;;;;cAoDH,0BAA2B,UAAU,eAAa,mBAC1C,IAAI;EACpB,SAAS;EAAG,WAAW;;;;;;;;;;;;;;;;;cA0Bf,yBAAsB,iBAChB,6BAA2B,0BAE3C;;;;;;;;;;;;;;;cA0BU,4BAAyB;EACpC,mBAAmB,gBAAgB;EACnC,gBAAgB;EAChB,iBAAiB;EACjB;MACE,gBAAgB;;;;;cAqCP,gCAA6B,WAC7B;;;;;;;cA0BA;;;;KAKD,gCAAgC,QAAQ;;;;;KAMxC;GACT,kBAAkB,6BAA6B;;;;;;;;;;;;;;KAetC;GACT,8BAA8B;GAC9B,iBAAiB,6BAA6B;;;;;;cAOpC,8BAA2B,mBAErC,SAAS;;;;;;;;;;;;;;;;;;;;;;;;cAkHC,iCAAkC,SAAO;EACpD,WAAW;EACX;EACA;EACA,UAAU;EACV,YAAY,kBAAkB,SAAS,QAAQ,gBAAgB;EAC/D,YAAY,YAAY,eAAe;MACrC,UAAU;;;;;;;;;;;;cAkCD,sCAA6C,SAAO;EAC/D,WAAW;EACX;EACA;EACA,UAAU;EACV,YAAY,YAAY,eAAe;MACrC,QAAQ,UAAU"}
+{"version":3,"file":"qualifiedDictionary.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/qualifiedDictionary.ts"],"mappings":";;;;;;;cAgBa;;;;;;cAOA;;;;;;;;;;;;;;;;;;;cAqDA,mBAAgB,SAClB;;;;;;;;;;;;;cA4BE,wBAAqB,SACvB;;;;;;;;;;;;;;;;cA0BE,4BAAyB,+BACP,sBACP;;;;;;cA4CX,6BAA0B,mBAEpC,SAAS;;;;;;;;;;;;cAkBC,4BAAyB,OAC7B,0BAAwB,wBAE9B;;;;;;;;;;;;;;;;cAkCU,6BAA0B,mBAClB,aAAa,0BAAwB,WAC7C,uBACV,aAAa;;;;;cAoDH,0BAA2B,UAAU,eAAa,mBAC1C,IAAI;EACpB,SAAS;EAAG,WAAW;;;;;;;;;;;;;;;;;cA0Bf,yBAAsB,iBAChB,6BAA2B,0BAE3C;;;;;;;;;;;;;;;cA0BU,4BAAyB;EACpC,mBAAmB,gBAAgB;EACnC,gBAAgB;EAChB,iBAAiB;EACjB;MACE,gBAAgB;;;;;cAqCP,gCAA6B,WAC7B"}

package/dist/types/dictionaryManipulator/qualifiedDictionaryDeclaration.d.ts

@@ -0,0 +1,41 @@
+import { Dictionary, DictionaryQualifierType } from "@intlayer/types/dictionary";
+//#region src/dictionaryManipulator/qualifiedDictionaryDeclaration.d.ts
+/**
+ * Canonical order of qualifier dimensions. A key that declares both dimensions
+ * always nests them in this order, with `item` innermost so it can act as the
+ * collection (array) axis.
+ */
+declare const QUALIFIER_ORDER: readonly ["variant", "item"];
+/**
+ * Normalizes the `variant` field of a dictionary into the list of variant ids
+ * the declaration registers under. A single value yields one id; an **array**
+ * fans out into one id per element (duplicates collapsed). Returns `undefined`
+ * when the dictionary does not declare the variant dimension (no `variant`
+ * field, or an empty array).
+ */
+declare const getVariantIds: (variant: Dictionary['variant']) => string[] | undefined;
+/**
+ * Returns the qualifier dimensions declared on a dictionary, in canonical
+ * order (`variant → item`). Empty when the dictionary is unqualified
+ * (plain dictionary or shared base content of a qualified group).
+ */
+declare const getDictionaryQualifierTypes: (dictionary: Dictionary) => DictionaryQualifierType[];
+/**
+ * Returns the qualifier identifiers of a dictionary for the given qualifier
+ * dimension — the candidate segments of the composite entry ids.
+ *
+ * - 'variant' → the serialized variant id(s); an array variant yields one id
+ *   per element (declaration-side fan-out)
+ * - 'item' → the item index as a single-element list
+ */
+declare const getDictionaryQualifierIds: (dictionary: Dictionary, qualifierType: DictionaryQualifierType) => string[] | undefined;
+/**
+ * Builds every composite entry id of a dictionary — the cartesian product of
+ * its per-dimension id lists, joined in canonical order. A dictionary with a
+ * plain (non-array) variant yields exactly one id; an array variant fans out
+ * into one id per element. `undefined` when a dimension of the set is missing.
+ */
+declare const getDictionaryCompositeIds: (dictionary: Dictionary, qualifierTypes: DictionaryQualifierType[]) => string[] | undefined;
+//#endregion
+export { QUALIFIER_ORDER, getDictionaryCompositeIds, getDictionaryQualifierIds, getDictionaryQualifierTypes, getVariantIds };
+//# sourceMappingURL=qualifiedDictionaryDeclaration.d.ts.map

package/dist/types/dictionaryManipulator/qualifiedDictionaryDeclaration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"qualifiedDictionaryDeclaration.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/qualifiedDictionaryDeclaration.ts"],"mappings":";;;;;;;cAca;;;;;;;;cAYA,gBAAa,SACf;;;;;;cAeE,8BAA2B,YAC1B,eACX;;;;;;;;;cAmBU,4BAAyB,YACxB,YAAU,eACP;;;;;;;cAcJ,4BAAyB,YACxB,YAAU,gBACN"}

package/dist/types/dictionaryManipulator/qualifiedDynamicLoader.d.ts

@@ -0,0 +1,93 @@
+import { Dictionary, DictionaryQualifierType, DictionarySelector } from "@intlayer/types/dictionary";
+//#region src/dictionaryManipulator/qualifiedDynamicLoader.d.ts
+/**
+ * Marker property carrying the ordered qualifier dimensions on a dynamic loader
+ * map. Its presence distinguishes a qualified group loader map (a nested tree
+ * of chunks) from a plain dynamic loader map (one chunk per `locale`). Prefixed
+ * and unlikely to collide with a real locale code.
+ */
+declare const QUALIFIER_DYNAMIC_TYPES_KEY = "__intlayerQualifierTypes";
+/**
+ * A lazily-imported per-locale dictionary chunk loader.
+ */
+type DynamicDictionaryLoader = () => Promise<Dictionary>;
+/**
+ * Nested tree of chunk loaders: one nesting level per declared dimension (in
+ * canonical order), leaves are loaders.
+ */
+type QualifiedDynamicLoaderTree = {
+  [segment: string]: QualifiedDynamicLoaderTree | DynamicDictionaryLoader;
+};
+/**
+ * Default export shape of a generated dynamic entry point for a qualified key.
+ * One nesting level per dimension under each locale, plus the dimension marker.
+ *
+ * ```ts
+ * {
+ *   __intlayerQualifierTypes: ['variant', 'item'],
+ *   en: { promo: { '1': () => import('./json/x/promo/1/en.json'), … }, … },
+ *   fr: { … },
+ * }
+ * ```
+ */
+type QualifiedDynamicLoaderMap = {
+  [QUALIFIER_DYNAMIC_TYPES_KEY]: DictionaryQualifierType[];
+  [locale: string]: QualifiedDynamicLoaderTree | DictionaryQualifierType[];
+};
+/**
+ * Type guard discriminating a qualified dynamic loader map (collections /
+ * variants, possibly combined) from a plain dynamic loader map.
+ */
+declare const isQualifiedDynamicLoaderMap: (value: unknown) => value is QualifiedDynamicLoaderMap;
+/**
+ * Resolves the content of a qualified dynamic loader map against a selector,
+ * loading only the chunk(s) the selector actually targets.
+ *
+ * Walks the nested loader tree one dimension at a time (canonical order
+ * `variant → item`): `variant` descends by the serialized id, falling back to
+ * `default` when the selected variant has no chunk of its own, and `item`
+ * either narrows to the selected index or — when no item is given — expands
+ * into every sibling chunk (the collection axis). Semantics mirror
+ * `resolveQualifiedDictionary` so dynamic and static modes behave alike.
+ *
+ * The Suspense mechanism is injected through `loadChunk` so the same logic
+ * serves both the client (suspender cache) and the server (`react.use`). Every
+ * targeted loader is started before the first chunk is read, so sibling chunks
+ * load in parallel rather than waterfalling.
+ *
+ * @param loaderMap - The qualified dynamic loader map (entry point default export).
+ * @param key - The dictionary key (used to build stable chunk cache keys).
+ * @param locale - The resolved locale to load chunks for.
+ * @param selector - The selector splitting the qualifier dimensions.
+ * @param loadChunk - Reads a started chunk promise, suspending until it resolves.
+ * @param transform - Turns a resolved chunk dictionary into final content.
+ */
+declare const resolveQualifiedDynamicContent: <Content>(params: {
+  loaderMap: QualifiedDynamicLoaderMap;
+  key: string;
+  locale: string;
+  selector: DictionarySelector | undefined;
+  loadChunk: (cacheKey: string, promise: Promise<Dictionary>) => Dictionary;
+  transform: (dictionary: Dictionary) => Content;
+}) => Content | Content[] | null;
+/**
+ * Async counterpart of {@link resolveQualifiedDynamicContent} for frameworks
+ * that load dictionaries with `await` instead of Suspense (Vue, Svelte, Lit,
+ * vanilla). Awaits every targeted chunk in parallel, then resolves identically.
+ *
+ * @param loaderMap - The qualified dynamic loader map.
+ * @param key - The dictionary key (used to build stable chunk cache keys).
+ * @param locale - The resolved locale to load chunks for.
+ * @param selector - The selector splitting the qualifier dimensions.
+ * @param transform - Turns a resolved chunk dictionary into final content.
+ */
+declare const resolveQualifiedDynamicContentAsync: <Content>(params: {
+  loaderMap: QualifiedDynamicLoaderMap;
+  key: string;
+  locale: string;
+  selector: DictionarySelector | undefined;
+  transform: (dictionary: Dictionary) => Content;
+}) => Promise<Content | Content[] | null>;
+//#endregion
+export { DynamicDictionaryLoader, QUALIFIER_DYNAMIC_TYPES_KEY, QualifiedDynamicLoaderMap, QualifiedDynamicLoaderTree, isQualifiedDynamicLoaderMap, resolveQualifiedDynamicContent, resolveQualifiedDynamicContentAsync };
+//# sourceMappingURL=qualifiedDynamicLoader.d.ts.map

package/dist/types/dictionaryManipulator/qualifiedDynamicLoader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"qualifiedDynamicLoader.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/qualifiedDynamicLoader.ts"],"mappings":";;;;;;;;cAiBa;;;;KAKD,gCAAgC,QAAQ;;;;;KAMxC;GACT,kBAAkB,6BAA6B;;;;;;;;;;;;;;KAetC;GACT,8BAA8B;GAC9B,iBAAiB,6BAA6B;;;;;;cAOpC,8BAA2B,mBAErC,SAAS;;;;;;;;;;;;;;;;;;;;;;;;cAiHC,iCAAkC,SAAO;EACpD,WAAW;EACX;EACA;EACA,UAAU;EACV,YAAY,kBAAkB,SAAS,QAAQ,gBAAgB;EAC/D,YAAY,YAAY,eAAe;MACrC,UAAU;;;;;;;;;;;;cAkCD,sCAA6C,SAAO;EAC/D,WAAW;EACX;EACA;EACA,UAAU;EACV,YAAY,YAAY,eAAe;MACrC,QAAQ,UAAU"}

package/dist/types/index.d.ts

@@ -48,13 +48,16 @@ import { editDictionaryByKeyPath } from "./dictionaryManipulator/editDictionaryB
 import { getContentNodeByKeyPath } from "./dictionaryManipulator/getContentNodeByKeyPath.js";
 import { getDefaultNode } from "./dictionaryManipulator/getDefaultNode.js";
 import { getEmptyNode } from "./dictionaryManipulator/getEmptyNode.js";
+import { NestedFieldReferences, getNestedDictionaryGraph, getNestedDictionaryKeys, getNestedDictionaryReferences } from "./dictionaryManipulator/getNestedDictionaryReferences.js";
 import { getNodeChildren } from "./dictionaryManipulator/getNodeChildren.js";
 import { getNodeType } from "./dictionaryManipulator/getNodeType.js";
 import { mergeDictionaries } from "./dictionaryManipulator/mergeDictionaries.js";
 import { mergeQualifiedDictionaries } from "./dictionaryManipulator/mergeQualifiedDictionaries.js";
 import { normalizeDictionaries, normalizeDictionary } from "./dictionaryManipulator/normalizeDictionary.js";
 import { orderDictionaries } from "./dictionaryManipulator/orderDictionaries.js";
-import { COMPOSITE_ID_SEPARATOR, DEFAULT_VARIANT_ID, DynamicDictionaryLoader, QUALIFIER_DYNAMIC_TYPES_KEY, QUALIFIER_ORDER, QualifiedDynamicLoaderMap, QualifiedDynamicLoaderTree, getDictionaryCompositeIds, getDictionaryQualifierIds, getDictionaryQualifierTypes, getDictionarySelectorCacheKey, getVariantIds, isQualifiedDictionaryGroup, isQualifiedDynamicLoaderMap, parseDictionarySelector, reconstructQualifiedEntry, resolveDictionaryArgument, resolveProviderVariant, resolveQualifiedDictionary, resolveQualifiedDynamicContent, resolveQualifiedDynamicContentAsync, serializeVariant, serializeVariantChain } from "./dictionaryManipulator/qualifiedDictionary.js";
+import { COMPOSITE_ID_SEPARATOR, DEFAULT_VARIANT_ID, getDictionarySelectorCacheKey, isQualifiedDictionaryGroup, parseDictionarySelector, reconstructQualifiedEntry, resolveDictionaryArgument, resolveEffectiveVariantId, resolveProviderVariant, resolveQualifiedDictionary, serializeVariant, serializeVariantChain } from "./dictionaryManipulator/qualifiedDictionary.js";
+import { QUALIFIER_ORDER, getDictionaryCompositeIds, getDictionaryQualifierIds, getDictionaryQualifierTypes, getVariantIds } from "./dictionaryManipulator/qualifiedDictionaryDeclaration.js";
+import { DynamicDictionaryLoader, QUALIFIER_DYNAMIC_TYPES_KEY, QualifiedDynamicLoaderMap, QualifiedDynamicLoaderTree, isQualifiedDynamicLoaderMap, resolveQualifiedDynamicContent, resolveQualifiedDynamicContentAsync } from "./dictionaryManipulator/qualifiedDynamicLoader.js";
 import { removeContentNodeByKeyPath } from "./dictionaryManipulator/removeContentNodeByKeyPath.js";
 import { renameContentNodeByKeyPath } from "./dictionaryManipulator/renameContentNodeByKeyPath.js";
 import { updateNodeChildren } from "./dictionaryManipulator/updateNodeChildren.js";
@@ -85,6 +88,7 @@ import { getPathWithoutLocale } from "./localization/getPathWithoutLocale.js";
 import { localeDetector } from "./localization/localeDetector.js";
 import { localeFlatMap, localeMap, localeRecord } from "./localization/localeMapper.js";
 import { localeResolver } from "./localization/localeResolver.js";
+import { ProxyMode, formatProxyEnabledMessage, isProxyStorageLocaleEnabled, resolveProxyMode } from "./localization/proxyMode.js";
 import { LocalizedPathResult, getCanonicalPath, getInternalPath, getLocalizedPath, getRewritePath, getRewriteRules } from "./localization/rewriteUtils.js";
 import { validatePrefix } from "./localization/validatePrefix.js";
 import "./localization/index.js";
@@ -110,4 +114,4 @@ import { CookieBuildAttributes, LocaleStorage, LocaleStorageClient, LocaleStorag
 import { YamlRecord, YamlValue, parseYaml } from "./utils/parseYaml.js";
 import { stringifyYaml } from "./utils/stringifyYaml.js";
 import "./utils/index.js";
-export { ATTRIBUTES_TO_SANITIZE, ATTRIBUTE_TO_NODE_PROP_MAP, ATTR_EXTRACTOR_R, BLOCKQUOTE_ALERT_R, BLOCKQUOTE_R, BLOCKQUOTE_TRIM_LEFT_MULTILINE_R, BLOCK_END_R, BREAK_LINE_R, BREAK_THEMATIC_R, type BlockQuoteNode, type BoldTextNode, type BreakLineNode, type BreakThematicNode, CAPTURE_LETTER_AFTER_HYPHEN, CODE_BLOCK_FENCED_R, CODE_BLOCK_R, CODE_INLINE_R, COMPOSITE_ID_SEPARATOR, CONSECUTIVE_NEWLINE_R, CR_NEWLINE_R, CUSTOM_COMPONENT_R, CachedIntl, CachedIntl as Intl, type CodeBlockNode, type CodeFencedNode, type CodeInlineNode, type CompileOptions, type ComponentOverrides, ConditionCond, ConditionContent, ConditionContentStates, CookieBuildAttributes, type CustomComponentNode, DEFAULT_VARIANT_ID, DO_NOT_PROCESS_HTML_ELEMENTS, DURATION_DELAY_TRIGGER, DateTimePreset, DeepTransformContent, DotPath, DynamicDictionaryLoader, type ElementType, EnterFormat, EnumerationCond, EnumerationContent, EnumerationContentState, type EscapedTextNode, FOOTNOTE_R, FOOTNOTE_REFERENCE_R, FORMFEED_R, FRONT_MATTER_R, FileCond, type FileContent, type FileContentConstructor, type FootnoteNode, type FootnoteReferenceNode, type GFMTaskNode, GFM_TASK_R, Gender, GenderCond, GenderContent, GenderContentStates, type GenerateSitemapOptions, GetNestingResult, type GetPrefixOptions, type GetPrefixResult, HEADING_ATX_COMPLIANT_R, HEADING_R, HEADING_SETEXT_R, type HTMLCommentNode, HTMLContent, HTMLContentConstructor, type HTMLNode, type HTMLSelfClosingNode, type HTMLTag, HTMLTagsType, HTMLValidationIssue, HTMLValidationResult, HTML_BLOCK_ELEMENT_R, HTML_CHAR_CODE_R, HTML_COMMENT_R, HTML_CUSTOM_ATTR_R, HTML_LEFT_TRIM_AMOUNT_R, HTML_SELF_CLOSING_ELEMENT_R, HTML_TAGS, type HeadingNode, type HeadingSetextNode, IInterpreterPlugin, IInterpreterPluginState, INLINE_SKIP_R, INTERPOLATION_R, type ImageNode, InsertionCond, InsertionContent, InsertionContentConstructor, InterpolableNode, IntlConstructorName, IsAny, type ItalicTextNode, JsonValue, LINK_AUTOLINK_BARE_URL_R, LINK_AUTOLINK_R, LIST_LOOKBEHIND_R, LOOKAHEAD, type LinkAngleBraceNode, type LinkBareURLNode, type LinkNode, ListType, type LocaleDomainMap, LocaleStorage, LocaleStorageClient, LocaleStorageClientOptions, LocaleStorageOptions, LocaleStorageServer, LocaleStorageServerOptions, type LocalizedPathResult, MarkdownContent, MarkdownContentConstructor, type MarkdownContext, type MarkdownOptions, type MarkdownRuntime, type HTMLValidationIssue as MarkdownValidationIssue, MarkdownValidationResult, type MarkedTextNode, MessageFormatDialect, MessageValues, NAMED_CODES_TO_UNICODE, NP_TABLE_R, NestedCond, NestedContent, NestedContentState, type NestedParser, type NewlineNode, NodeProps, ORDERED, ORDERED_LIST_BULLET, ORDERED_LIST_ITEM_PREFIX, ORDERED_LIST_ITEM_PREFIX_R, ORDERED_LIST_ITEM_R, ORDERED_LIST_R, type OrderedListNode, PARAGRAPH_R, type ParagraphNode, type ParseState, ParsedMarkdown, type Parser, type ParserResult, Plugins, PluralCategory, PluralCond, PluralContent, PluralContentState, PortableObject, Priority, PriorityValue, QUALIFIER_DYNAMIC_TYPES_KEY, QUALIFIER_ORDER, QualifiedDynamicLoaderMap, QualifiedDynamicLoaderTree, REFERENCE_IMAGE_OR_LINK, REFERENCE_IMAGE_R, REFERENCE_LINK_R, type ReferenceImageNode, type ReferenceLinkNode, type ReferenceNode, type RenderRuleHook, type Rule, type RuleOutput, RuleType, RuleTypeValue, type Rules, SHORTCODE_R, SHOULD_RENDER_AS_BLOCK_R, SelectCond, SelectContent, SelectContentStates, SelectSelector, type SitemapUrlEntry, type StrikethroughTextNode, TABLE_CENTER_ALIGN, TABLE_LEFT_ALIGN, TABLE_RIGHT_ALIGN, TABLE_TRIM_PIPES, TAB_R, TEXT_BOLD_R, TEXT_EMPHASIZED_R, TEXT_ESCAPED_R, TEXT_MARKED_R, TEXT_PLAIN_R, TEXT_STRIKETHROUGHED_R, TRIM_STARTING_NEWLINES, type TableNode, type TableSeparatorNode, TaggedMessageToken, type TextNode, TranslationCond, TranslationContent, UNESCAPE_R, UNORDERED, UNORDERED_LIST_BULLET, UNORDERED_LIST_ITEM_PREFIX, UNORDERED_LIST_ITEM_PREFIX_R, UNORDERED_LIST_ITEM_R, UNORDERED_LIST_R, UnionKeys, type UnorderedListNode, VOID_HTML_ELEMENTS, ValidDotPathsFor, ValueAtKey, WrappedIntl, YamlRecord, YamlValue, allowInline, anyScopeRegex, attributeValueToNodePropValue, bindIntl, blockRegex, buildMaskPlugin, captureNothing, checkIsURLAbsolute, checkMissingLocalesPlugin, compact, comparePaths, compile, compileWithOptions, condition as cond, conditionPlugin, createCompiler, createRenderer, currency, cx, date, deepTransformNode, editDictionaryByKeyPath, enumeration as enu, enumerationPlugin, fallbackPlugin, type file, type fileContent, filePlugin, filterMissingTranslationsOnlyPlugin, filterTranslationsOnlyPlugin, findMatchingCondition, gender, genderPlugin, generateListItemPrefix, generateListItemPrefixRegex, generateListItemRegex, generateListRegex, generateSitemap, generateSitemapUrl, get, getBasePlugins, getBrowserLocale, getCachedIntl, getCanonicalPath, getCondition, getContent, getContentNodeByKeyPath, getCookie, getDefaultNode, getDictionary, getDictionaryCompositeIds, getDictionaryQualifierIds, getDictionaryQualifierTypes, getDictionarySelectorCacheKey, getDomainHostname, getDomainOrigin, getEditedContent, getEditedDictionary, getEmptyNode, getEnumeration, getFilterMissingTranslationsContent, getFilterMissingTranslationsDictionary, getFilterTranslationsOnlyContent, getFilterTranslationsOnlyDictionary, getFilteredLocalesContent, getFilteredLocalesDictionary, getGender, getHTML, getHTMLTextDir, getInsertion, getInsertionValues, getInternalPath, getInterpolableContent, getIntlayer, getLocale, getLocaleFromDomain, getLocaleFromPath, getLocaleFromStorage, getLocaleFromStorageClient, getLocaleFromStorageServer, getLocaleLang, getLocaleName, getLocalizedContent, getLocalizedPath, getLocalizedUrl, getMarkdownMetadata, getMaskContent, getMissingLocalesContent, getMissingLocalesContentFromDictionary, getMultilingualDictionary, getMultilingualUrls, getNesting, getNodeChildren, getNodeType, getPathWithoutLocale, getPerLocaleDictionary, getPlural, getPrefix, getReplacedValuesContent, getRewritePath, getRewriteRules, getSelect, getSplittedContent, getSplittedDictionaryContent, getTranslation, getVariantIds, html, i18nextToIntlayerFormatter, icuToIntlayerFormatter, inlineRegex, insertion as insert, insertContentInDictionary, insertionPlugin, interpolateMessage, intlayerToI18nextFormatter, intlayerToICUFormatter, intlayerToPortableObjectFormatter, intlayerToVueI18nFormatter, isInterpolableWrapperNode, isLocaleExclusiveOnDomain, isQualifiedDictionaryGroup, isQualifiedDynamicLoaderMap, isSameKeyPath, isValidElement, list, localeDetector, localeFlatMap, localeMap, localeRecord, localeResolver, localeStorageOptions, markdown as md, mergeDictionaries, mergeQualifiedDictionaries, navigatePath, nesting as nest, nestedPlugin, normalizeAttributeKey, normalizeDictionaries, normalizeDictionary, normalizePath, normalizeWhitespace, number, orderDictionaries, parseBlock, parseCaptureInline, parseDictionarySelector, parseInline, parseMarkdown, parseSimpleInline, parseStyleAttribute, parseTableAlign, parseTableAlignCapture, parseTableCells, parseTableRow, parseTaggedMessage, parseYaml, parserFor, percentage, plural, pluralPlugin, portableObjectToIntlayerFormatter, presets, qualifies, rebuildInterpolableContent, reconstructQualifiedEntry, relativeTime, removeContentNodeByKeyPath, renameContentNodeByKeyPath, renderFor, renderMarkdownAst, renderNothing, resolveDictionaryArgument, resolveMessage, resolveMessageNode, resolveProviderVariant, resolveQualifiedDictionary, resolveQualifiedDynamicContent, resolveQualifiedDynamicContentAsync, sanitizer, select, selectPlugin, serializeVariant, serializeVariantChain, setLocaleInStorage, setLocaleInStorageClient, setLocaleInStorageServer, simpleInlineRegex, slugify, some, splitInsertionTemplate, startsWith, stringifyYaml, translation as t, transformInterpolableNode, translationPlugin, trimEnd, trimLeadingWhitespaceOutsideFences, unescapeString, units, unquote, updateNodeChildren, validateHTML, validateMarkdown, validatePrefix, vueI18nToIntlayerFormatter };
+export { ATTRIBUTES_TO_SANITIZE, ATTRIBUTE_TO_NODE_PROP_MAP, ATTR_EXTRACTOR_R, BLOCKQUOTE_ALERT_R, BLOCKQUOTE_R, BLOCKQUOTE_TRIM_LEFT_MULTILINE_R, BLOCK_END_R, BREAK_LINE_R, BREAK_THEMATIC_R, type BlockQuoteNode, type BoldTextNode, type BreakLineNode, type BreakThematicNode, CAPTURE_LETTER_AFTER_HYPHEN, CODE_BLOCK_FENCED_R, CODE_BLOCK_R, CODE_INLINE_R, COMPOSITE_ID_SEPARATOR, CONSECUTIVE_NEWLINE_R, CR_NEWLINE_R, CUSTOM_COMPONENT_R, CachedIntl, CachedIntl as Intl, type CodeBlockNode, type CodeFencedNode, type CodeInlineNode, type CompileOptions, type ComponentOverrides, ConditionCond, ConditionContent, ConditionContentStates, CookieBuildAttributes, type CustomComponentNode, DEFAULT_VARIANT_ID, DO_NOT_PROCESS_HTML_ELEMENTS, DURATION_DELAY_TRIGGER, DateTimePreset, DeepTransformContent, DotPath, DynamicDictionaryLoader, type ElementType, EnterFormat, EnumerationCond, EnumerationContent, EnumerationContentState, type EscapedTextNode, FOOTNOTE_R, FOOTNOTE_REFERENCE_R, FORMFEED_R, FRONT_MATTER_R, FileCond, type FileContent, type FileContentConstructor, type FootnoteNode, type FootnoteReferenceNode, type GFMTaskNode, GFM_TASK_R, Gender, GenderCond, GenderContent, GenderContentStates, type GenerateSitemapOptions, GetNestingResult, type GetPrefixOptions, type GetPrefixResult, HEADING_ATX_COMPLIANT_R, HEADING_R, HEADING_SETEXT_R, type HTMLCommentNode, HTMLContent, HTMLContentConstructor, type HTMLNode, type HTMLSelfClosingNode, type HTMLTag, HTMLTagsType, HTMLValidationIssue, HTMLValidationResult, HTML_BLOCK_ELEMENT_R, HTML_CHAR_CODE_R, HTML_COMMENT_R, HTML_CUSTOM_ATTR_R, HTML_LEFT_TRIM_AMOUNT_R, HTML_SELF_CLOSING_ELEMENT_R, HTML_TAGS, type HeadingNode, type HeadingSetextNode, IInterpreterPlugin, IInterpreterPluginState, INLINE_SKIP_R, INTERPOLATION_R, type ImageNode, InsertionCond, InsertionContent, InsertionContentConstructor, InterpolableNode, IntlConstructorName, IsAny, type ItalicTextNode, JsonValue, LINK_AUTOLINK_BARE_URL_R, LINK_AUTOLINK_R, LIST_LOOKBEHIND_R, LOOKAHEAD, type LinkAngleBraceNode, type LinkBareURLNode, type LinkNode, ListType, type LocaleDomainMap, LocaleStorage, LocaleStorageClient, LocaleStorageClientOptions, LocaleStorageOptions, LocaleStorageServer, LocaleStorageServerOptions, type LocalizedPathResult, MarkdownContent, MarkdownContentConstructor, type MarkdownContext, type MarkdownOptions, type MarkdownRuntime, type HTMLValidationIssue as MarkdownValidationIssue, MarkdownValidationResult, type MarkedTextNode, MessageFormatDialect, MessageValues, NAMED_CODES_TO_UNICODE, NP_TABLE_R, NestedCond, NestedContent, NestedContentState, NestedFieldReferences, type NestedParser, type NewlineNode, NodeProps, ORDERED, ORDERED_LIST_BULLET, ORDERED_LIST_ITEM_PREFIX, ORDERED_LIST_ITEM_PREFIX_R, ORDERED_LIST_ITEM_R, ORDERED_LIST_R, type OrderedListNode, PARAGRAPH_R, type ParagraphNode, type ParseState, ParsedMarkdown, type Parser, type ParserResult, Plugins, PluralCategory, PluralCond, PluralContent, PluralContentState, PortableObject, Priority, PriorityValue, type ProxyMode, QUALIFIER_DYNAMIC_TYPES_KEY, QUALIFIER_ORDER, QualifiedDynamicLoaderMap, QualifiedDynamicLoaderTree, REFERENCE_IMAGE_OR_LINK, REFERENCE_IMAGE_R, REFERENCE_LINK_R, type ReferenceImageNode, type ReferenceLinkNode, type ReferenceNode, type RenderRuleHook, type Rule, type RuleOutput, RuleType, RuleTypeValue, type Rules, SHORTCODE_R, SHOULD_RENDER_AS_BLOCK_R, SelectCond, SelectContent, SelectContentStates, SelectSelector, type SitemapUrlEntry, type StrikethroughTextNode, TABLE_CENTER_ALIGN, TABLE_LEFT_ALIGN, TABLE_RIGHT_ALIGN, TABLE_TRIM_PIPES, TAB_R, TEXT_BOLD_R, TEXT_EMPHASIZED_R, TEXT_ESCAPED_R, TEXT_MARKED_R, TEXT_PLAIN_R, TEXT_STRIKETHROUGHED_R, TRIM_STARTING_NEWLINES, type TableNode, type TableSeparatorNode, TaggedMessageToken, type TextNode, TranslationCond, TranslationContent, UNESCAPE_R, UNORDERED, UNORDERED_LIST_BULLET, UNORDERED_LIST_ITEM_PREFIX, UNORDERED_LIST_ITEM_PREFIX_R, UNORDERED_LIST_ITEM_R, UNORDERED_LIST_R, UnionKeys, type UnorderedListNode, VOID_HTML_ELEMENTS, ValidDotPathsFor, ValueAtKey, WrappedIntl, YamlRecord, YamlValue, allowInline, anyScopeRegex, attributeValueToNodePropValue, bindIntl, blockRegex, buildMaskPlugin, captureNothing, checkIsURLAbsolute, checkMissingLocalesPlugin, compact, comparePaths, compile, compileWithOptions, condition as cond, conditionPlugin, createCompiler, createRenderer, currency, cx, date, deepTransformNode, editDictionaryByKeyPath, enumeration as enu, enumerationPlugin, fallbackPlugin, type file, type fileContent, filePlugin, filterMissingTranslationsOnlyPlugin, filterTranslationsOnlyPlugin, findMatchingCondition, formatProxyEnabledMessage, gender, genderPlugin, generateListItemPrefix, generateListItemPrefixRegex, generateListItemRegex, generateListRegex, generateSitemap, generateSitemapUrl, get, getBasePlugins, getBrowserLocale, getCachedIntl, getCanonicalPath, getCondition, getContent, getContentNodeByKeyPath, getCookie, getDefaultNode, getDictionary, getDictionaryCompositeIds, getDictionaryQualifierIds, getDictionaryQualifierTypes, getDictionarySelectorCacheKey, getDomainHostname, getDomainOrigin, getEditedContent, getEditedDictionary, getEmptyNode, getEnumeration, getFilterMissingTranslationsContent, getFilterMissingTranslationsDictionary, getFilterTranslationsOnlyContent, getFilterTranslationsOnlyDictionary, getFilteredLocalesContent, getFilteredLocalesDictionary, getGender, getHTML, getHTMLTextDir, getInsertion, getInsertionValues, getInternalPath, getInterpolableContent, getIntlayer, getLocale, getLocaleFromDomain, getLocaleFromPath, getLocaleFromStorage, getLocaleFromStorageClient, getLocaleFromStorageServer, getLocaleLang, getLocaleName, getLocalizedContent, getLocalizedPath, getLocalizedUrl, getMarkdownMetadata, getMaskContent, getMissingLocalesContent, getMissingLocalesContentFromDictionary, getMultilingualDictionary, getMultilingualUrls, getNestedDictionaryGraph, getNestedDictionaryKeys, getNestedDictionaryReferences, getNesting, getNodeChildren, getNodeType, getPathWithoutLocale, getPerLocaleDictionary, getPlural, getPrefix, getReplacedValuesContent, getRewritePath, getRewriteRules, getSelect, getSplittedContent, getSplittedDictionaryContent, getTranslation, getVariantIds, html, i18nextToIntlayerFormatter, icuToIntlayerFormatter, inlineRegex, insertion as insert, insertContentInDictionary, insertionPlugin, interpolateMessage, intlayerToI18nextFormatter, intlayerToICUFormatter, intlayerToPortableObjectFormatter, intlayerToVueI18nFormatter, isInterpolableWrapperNode, isLocaleExclusiveOnDomain, isProxyStorageLocaleEnabled, isQualifiedDictionaryGroup, isQualifiedDynamicLoaderMap, isSameKeyPath, isValidElement, list, localeDetector, localeFlatMap, localeMap, localeRecord, localeResolver, localeStorageOptions, markdown as md, mergeDictionaries, mergeQualifiedDictionaries, navigatePath, nesting as nest, nestedPlugin, normalizeAttributeKey, normalizeDictionaries, normalizeDictionary, normalizePath, normalizeWhitespace, number, orderDictionaries, parseBlock, parseCaptureInline, parseDictionarySelector, parseInline, parseMarkdown, parseSimpleInline, parseStyleAttribute, parseTableAlign, parseTableAlignCapture, parseTableCells, parseTableRow, parseTaggedMessage, parseYaml, parserFor, percentage, plural, pluralPlugin, portableObjectToIntlayerFormatter, presets, qualifies, rebuildInterpolableContent, reconstructQualifiedEntry, relativeTime, removeContentNodeByKeyPath, renameContentNodeByKeyPath, renderFor, renderMarkdownAst, renderNothing, resolveDictionaryArgument, resolveEffectiveVariantId, resolveMessage, resolveMessageNode, resolveProviderVariant, resolveProxyMode, resolveQualifiedDictionary, resolveQualifiedDynamicContent, resolveQualifiedDynamicContentAsync, sanitizer, select, selectPlugin, serializeVariant, serializeVariantChain, setLocaleInStorage, setLocaleInStorageClient, setLocaleInStorageServer, simpleInlineRegex, slugify, some, splitInsertionTemplate, startsWith, stringifyYaml, translation as t, transformInterpolableNode, translationPlugin, trimEnd, trimLeadingWhitespaceOutsideFences, unescapeString, units, unquote, updateNodeChildren, validateHTML, validateMarkdown, validatePrefix, vueI18nToIntlayerFormatter };

package/dist/types/interpreter/getContent/plugins.d.ts

@@ -149,6 +149,16 @@ interface NodeProps {
   locale?: Locale;
   dictionaryPath?: string;
   children?: any;
+  /**
+   * Dictionaries referenced through `nest()`, attached to the consuming
+   * dictionary by the build optimization and threaded down by
+   * `deepTransformNode`.
+   *
+   * Present only in optimized builds, where the global dictionary registry is
+   * stripped and `getNesting` resolves from this map instead. See
+   * `getNesting.optimized.ts`.
+   */
+  nestedDictionaries?: Record<string, unknown>;
   /**
    * Forces eager traversal of plain objects in `deepTransformNode`. By default
    * traversal is lazy (property getters), so callers that discard the returned

package/dist/types/interpreter/getContent/plugins.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugins.d.ts","names":[],"sources":["../../../../src/interpreter/getContent/plugins.ts"],"mappings":"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"}
+{"version":3,"file":"plugins.d.ts","names":[],"sources":["../../../../src/interpreter/getContent/plugins.ts"],"mappings":";;;;;;;;;;;;;;;;;;;KAmDY;EACV;EACA,YAAY;EACZ,YACE,WACA,OAAO,WACP,cAAc,WAAW,OAAO;;;;;;;cAUvB,gBAAgB;;;;KAUjB,UAAU,KAAK,0BAA0B;KACzC,WAAW,GAAG,KAAK,oBAC3B,gBAAgB,IACd,EAAE;KAII,gBAAgB,GAAG,GAAG,UAAU,iBAAiB;EAC3D,UAAU;GACT,UAAU,oBAAoB;IAE7B,UAAU,OAAO,wBACf,QAAQ,WAAW,OAAO,2BAErB,KAAK,UAAU,QAAQ,MAAM,gBAAgB,IAC1C,gBAAgB,EAAE,KAChB,EAAE,GAAG,KACL,WAAW,QAAQ,IAAI,KACzB,WAAW,QAAQ,IAAI,qBACb,WACd,qBAAqB,SAAS,cAE/B,gBAAgB,IAAI,EAAE,KAAK,QAAQ,mBAAkB,WACpD,qBAAqB,SAAS;;cAM3B,oBAAiB,QACpB,eAAa,WACV,kBACV;;;;KAkCS,gBAAgB,GAAG,GAAG,MAAM;EACtC,UAAU;GACT,UAAU;KAGP,qBACG,qBACH,SAAS,UAAU,mBAAmB,SAAS,UAAU,eACzD;;cAKO,mBAAmB;;;;KAyCpB,WAAW,GAAG,GAAG,MAAM;EACjC,UAAU;GACT,UAAU;KAGP;EAAgB;GAAgB;MAC7B,qBACH,SAAS,UAAU,cAAc,SAAS,UAAU,UACpD;;;;;;cAWO,eAAY,SAAa,kBAAgB;;;;KA+F1C,cAAc,GAAG,GAAG,MAAM;EACpC,UAAU;GACT,UAAU;KAGP;EAAmB;MAChB,qBACH,SAAS,UAAU,iBAAiB,SAAS,UAAU,aACvD;;cAKO,iBAAiB;;;;KAyClB,cAAc,GAAG,GAAG,MAAM;EACpC,UAAU;GACT,UAAU,kBAAkB;EAC7B;KAGI,WACG,KAAK,6CAEL,mBACD,6BAA6B,KAC7B,qBAAqB,GAAG;;cAInB,iBAAiB;;;;KAgFlB,WAAW,GAAG,GAAG,MAAM;EACjC,UAAU;GACT,UAAU;KAGP,OAAO,WACJ,qBACH,SAAS,UAAU,cAAc,SAAS,UAAU,UACpD;;cAKO,cAAc;;;;;;;;;;;KAuCf,eAAe,mCAAmC,SAC1D,cAAc,qDACR;KAEE,WAAW,GAAG,GAAG,MAAM;EACjC,UAAU;GACT,UAAU;KAGP,OACI,eAAe,SAAS,UAAU;EAChC,OAAO,eAAe,SAAS,UAAU;MAC5C,qBACH,SAAS,UAAU,cAAc,SAAS,UAAU,UACpD;;cAKO,cAAc;;;;KAyCf,WAAW,GAAG,GAAG,MAAM;EACjC,UAAU;GACT,UAAU,eAAe;IAExB;EACE,qBAAqB,UAAU;EAC/B,aAAa;IAEb,iBAAiB,GAAG,GAAG;;cAmBhB,eAAY,SAAa,kBAAgB;;;;KAuB1C,SAAS,GAAG,GAAG,MAAM;EAC/B,UAAU;GACT,UAAU;EACX;IAEE,6BAA6B;;cAIpB,YAAY;;;;;;;;UAsBR;EACf;EACA,SAAS;EACT,UAAU;EACV,SAAS;EACT;EACA;;;;;;;;;;EAUA,qBAAqB;;;;;;;EAOrB;;;;;;UAOe,mBAAmB,GAAG,GAAG,UAAU;EAClD,aAAa,gBAAgB,GAAG,GAAG;EACnC,aAAa,gBAAgB,GAAG,GAAG;EACnC,QAAQ,WAAW,GAAG,GAAG;EACzB,WAAW,cAAc,GAAG,GAAG;EAC/B,WAAW,cAAc,GAAG,GAAG;EAC/B,QAAQ,WAAW,GAAG,GAAG;EACzB,QAAQ,WAAW,GAAG,GAAG;EACzB,QAAQ,WAAW,GAAG,GAAG;EACzB,MAAM,SAAS,GAAG,GAAG;;;;;KAMX;EACV;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;;;KAMG,iBACH,GACA,gBAAgB,mBAAmB,GAAG,GAAG,IACzC,GACA,UAAU,gBAAgB,mBACxB,gBAAgB,IAEhB,EAAE,kBAEA,mBAAmB,GAAG,GAAG,GAAG,2BAG1B,mBAAmB,GAAG,GAAG,GAAG;;;;KAO/B,SAAS,GAAG,GAAG,UAAU,gBAAgB,mBAC5C,UAAU,oBAAoB,KAC1B,MAAM,qBAAqB,GAAG,GAAG,MACjC,sBACK,WAAW,IAAI,qBAAqB,EAAE,IAAI,GAAG,QAChD;KAEI,MAAM,mBAAmB;;;;KAKzB,qBACV,GACA,IAAI,yBACJ,UAAU,gBAAgB,mBAE1B,MAAM,kBACF,IACA,iBAAiB,SAAS,mBAAmB,GAAG,GAAG,IAAI,GAAG,mBAExD,SAAS,GAAG,GAAG,KAEf,iBAAiB,SAAS,mBAAmB,GAAG,GAAG,IAAI,GAAG"}

package/dist/types/interpreter/getNesting.optimized.d.ts

@@ -0,0 +1,33 @@
+import { ValidDotPathsFor } from "../transpiler/nesting/nesting.js";
+import "../transpiler/index.js";
+import { GetNestingResult } from "./getNesting.js";
+import { NodeProps } from "./getContent/plugins.js";
+import "./getContent/index.js";
+import { DictionaryKeys } from "@intlayer/types/module_augmentation";
+//#region src/interpreter/getNesting.optimized.d.ts
+/**
+ * Optimized-build replacement for `getNesting`.
+ *
+ * Resolves a `nest()` reference from the dictionaries the compiler attached to
+ * the consuming dictionary (`props.nestedDictionaries`) instead of looking the
+ * key up in the global registry exposed by `@intlayer/dictionaries-entry`.
+ *
+ * That is what lets the build optimization erase the registry entirely: this
+ * module never imports `getIntlayer`, so no dictionary reaches the bundle
+ * except through the static import injected at the call site. The nest target
+ * then lands in the same chunk as the dictionary referencing it — and, in
+ * `dynamic` / `fetch` mode, is loaded by the same lazy per-locale loader.
+ *
+ * The compiler guarantees the attachment for every dictionary holding a nested
+ * node, so a missing entry means the dictionary was not produced by the
+ * optimized pipeline; the reference then resolves to `undefined`.
+ *
+ * @param dictionaryKey - The key of the dictionary to nest.
+ * @param path - Optional dot-separated path within the nested dictionary.
+ * @param props - Interpreter node props, carrying the attached dictionaries.
+ * @returns The nested content.
+ */
+declare const getNesting: <const K extends DictionaryKeys, const P>(dictionaryKey: K, path?: P extends ValidDotPathsFor<K> ? P : never, props?: NodeProps) => GetNestingResult<K, P>;
+//#endregion
+export { getNesting };
+//# sourceMappingURL=getNesting.optimized.d.ts.map

package/dist/types/interpreter/getNesting.optimized.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getNesting.optimized.d.ts","names":[],"sources":["../../../src/interpreter/getNesting.optimized.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmDa,mBAAoB,UAAU,sBAAsB,GAAC,eACjD,GAAC,OACT,UAAU,iBAAiB,KAAK,WAAS,QACxC,cACP,iBAAiB,GAAG"}

package/dist/types/localization/index.d.ts

@@ -14,6 +14,7 @@ import { getPathWithoutLocale } from "./getPathWithoutLocale.js";
 import { localeDetector } from "./localeDetector.js";
 import { localeFlatMap, localeMap, localeRecord } from "./localeMapper.js";
 import { localeResolver } from "./localeResolver.js";
+import { ProxyMode, formatProxyEnabledMessage, isProxyStorageLocaleEnabled, resolveProxyMode } from "./proxyMode.js";
 import { LocalizedPathResult, getCanonicalPath, getInternalPath, getLocalizedPath, getRewritePath, getRewriteRules } from "./rewriteUtils.js";
 import { validatePrefix } from "./validatePrefix.js";
-export { type GenerateSitemapOptions, type GetPrefixOptions, type GetPrefixResult, type LocaleDomainMap, type LocalizedPathResult, type SitemapUrlEntry, comparePaths, generateSitemap, generateSitemapUrl, getBrowserLocale, getCanonicalPath, getDomainHostname, getDomainOrigin, getHTMLTextDir, getInternalPath, getLocale, getLocaleFromDomain, getLocaleFromPath, getLocaleLang, getLocaleName, getLocalizedPath, getLocalizedUrl, getMultilingualUrls, getPathWithoutLocale, getPrefix, getRewritePath, getRewriteRules, isLocaleExclusiveOnDomain, localeDetector, localeFlatMap, localeMap, localeRecord, localeResolver, normalizePath, validatePrefix };
+export { type GenerateSitemapOptions, type GetPrefixOptions, type GetPrefixResult, type LocaleDomainMap, type LocalizedPathResult, type ProxyMode, type SitemapUrlEntry, comparePaths, formatProxyEnabledMessage, generateSitemap, generateSitemapUrl, getBrowserLocale, getCanonicalPath, getDomainHostname, getDomainOrigin, getHTMLTextDir, getInternalPath, getLocale, getLocaleFromDomain, getLocaleFromPath, getLocaleLang, getLocaleName, getLocalizedPath, getLocalizedUrl, getMultilingualUrls, getPathWithoutLocale, getPrefix, getRewritePath, getRewriteRules, isLocaleExclusiveOnDomain, isProxyStorageLocaleEnabled, localeDetector, localeFlatMap, localeMap, localeRecord, localeResolver, normalizePath, resolveProxyMode, validatePrefix };

package/dist/types/localization/proxyMode.d.ts

@@ -0,0 +1,92 @@
+//#region src/localization/proxyMode.d.ts
+/**
+ * Effective mode of the Intlayer locale-routing proxy, resolved from the
+ * `routing.enableProxy` configuration option.
+ *
+ * - `'auto'` — the option was left unset. The proxy is registered, but it stays
+ *   URL-driven while a development or preview server is serving the app: the
+ *   stored locale (cookie / header) is not used as a redirect source, so a
+ *   stale cookie cannot silently pull every navigation to another locale. In
+ *   production the mode behaves exactly like `'forced'`.
+ * - `'forced'` — the option was explicitly set to `true`. Full proxy behaviour
+ *   in every environment, storage-driven redirects included.
+ * - `'disabled'` — the option was explicitly set to `false`. The proxy is not
+ *   registered at all (Vite) or becomes a pass-through (Next.js).
+ */
+type ProxyMode = 'auto' | 'forced' | 'disabled';
+/**
+ * Resolves the effective {@link ProxyMode} from the `routing.enableProxy`
+ * configuration value.
+ *
+ * `process.env.INTLAYER_ROUTING_ENABLE_PROXY` is injected at build time by
+ * `getConfigEnvVars` and takes precedence, so bundlers can dead-code-eliminate
+ * the branches guarded by the resolved mode. The variable is only emitted for
+ * the two explicit states; its absence means `'auto'` and defers to the
+ * configuration value read at runtime.
+ *
+ * @param enableProxy - The `routing.enableProxy` value; `undefined` means auto.
+ * @returns The resolved proxy mode.
+ *
+ * @example
+ * ```ts
+ * resolveProxyMode(undefined); // 'auto'
+ * resolveProxyMode(true);      // 'forced'
+ * resolveProxyMode(false);     // 'disabled'
+ * ```
+ */
+declare const resolveProxyMode: (enableProxy?: boolean) => ProxyMode;
+/**
+ * Indicates whether the proxy may use the locale held in storage (cookie or
+ * header) as a source when deciding which locale a request resolves to.
+ *
+ * Auto mode suppresses it on development and preview servers only. Every other
+ * combination keeps the stored locale active, which notably preserves the
+ * behaviour of `createIntlayerProxyHandler` when it is mounted manually in a
+ * production Nitro server.
+ *
+ * Suppressing the read affects redirect *sources* only — the locale is still
+ * persisted onto responses, the URL locale prefix still wins over everything,
+ * and `Accept-Language` detection still applies as the fallback.
+ *
+ * @param proxyMode - The resolved proxy mode.
+ * @param isDevServer - Whether a development or preview server is serving the app.
+ * @returns `true` when the stored locale may drive locale resolution.
+ *
+ * @example
+ * ```ts
+ * isProxyStorageLocaleEnabled('auto', true);    // false — dev server, URL-driven only
+ * isProxyStorageLocaleEnabled('auto', false);   // true  — production
+ * isProxyStorageLocaleEnabled('forced', true);  // true  — explicitly opted in
+ * ```
+ */
+declare const isProxyStorageLocaleEnabled: (proxyMode: ProxyMode, isDevServer: boolean) => boolean;
+/**
+ * Builds the line announcing that a server has mounted the locale-routing
+ * proxy.
+ *
+ * Shared by every integration (Vite plugin, Next.js middleware) so the reported
+ * state cannot drift between them: when the stored locale is suppressed the
+ * message says so, which would otherwise look like a broken proxy to anyone
+ * testing locale switching with a cookie already set.
+ *
+ * Takes the suppression flag rather than the {@link ProxyMode} on purpose. Auto
+ * mode only suppresses storage on a dev server, so a mode-based signature would
+ * let a production caller — such as the Nitro production handler — announce a
+ * suppression that is not actually in effect.
+ *
+ * @param isStorageLocaleSuppressed - Whether the stored locale is barred from
+ *   driving redirects, i.e. the negation of {@link isProxyStorageLocaleEnabled}.
+ * @returns An ANSI-coloured, ready-to-log message.
+ *
+ * @example
+ * ```ts
+ * formatProxyEnabledMessage(true);
+ * // Intlayer proxy enabled - storage redirection disabled for dev purpose
+ * formatProxyEnabledMessage(false);
+ * // Intlayer proxy enabled
+ * ```
+ */
+declare const formatProxyEnabledMessage: (isStorageLocaleSuppressed: boolean) => string;
+//#endregion
+export { ProxyMode, formatProxyEnabledMessage, isProxyStorageLocaleEnabled, resolveProxyMode };
+//# sourceMappingURL=proxyMode.d.ts.map

package/dist/types/localization/proxyMode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proxyMode.d.ts","names":[],"sources":["../../../src/localization/proxyMode.ts"],"mappings":";;;;;;;;;;;;;;;KAiBY;;;;;;;;;;;;;;;;;;;;;cAsBC,mBAAgB,0BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;cAkC5C,8BAA2B,WAC3B,WAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;cA8BT,4BAAyB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intlayer/core",
-  "version": "9.1.3",
+  "version": "9.3.0",
   "private": false,
   "description": "Includes core Intlayer functions like translation, dictionary, and utility functions shared across multiple packages.",
   "keywords": [
@@ -172,15 +172,15 @@
     "typecheck": "tsc --noEmit --project tsconfig.types.json"
   },
   "dependencies": {
-    "@intlayer/api": "9.1.3",
-    "@intlayer/config": "9.1.3",
-    "@intlayer/dictionaries-entry": "9.1.3",
-    "@intlayer/types": "9.1.3",
-    "@intlayer/unmerged-dictionaries-entry": "9.1.3",
+    "@intlayer/api": "9.3.0",
+    "@intlayer/config": "9.3.0",
+    "@intlayer/dictionaries-entry": "9.3.0",
+    "@intlayer/types": "9.3.0",
+    "@intlayer/unmerged-dictionaries-entry": "9.3.0",
     "defu": "6.1.7"
   },
   "devDependencies": {
-    "@types/node": "26.1.2",
+    "@types/node": "26.2.0",
     "@utils/ts-config": "1.0.4",
     "@utils/ts-config-types": "1.0.4",
     "@utils/tsdown-config": "1.0.4",