@intlayer/core 8.12.5-canary.0 → 9.0.0-canary.1

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

@@ -0,0 +1,22 @@
+import { Dictionary, QualifiedDictionaryGroup } from "@intlayer/types/dictionary";
+
+//#region src/dictionaryManipulator/mergeQualifiedDictionaries.d.ts
+/**
+ * Merges sibling dictionaries sharing the same key, honouring qualifiers.
+ *
+ * - No dictionary declares a qualifier → behaves exactly like
+ *   `mergeDictionaries` (single merged dictionary).
+ * - At least one dictionary declares a qualifier → the group's dimension set is
+ *   the union of every declared dimension (in canonical order
+ *   `variant → meta → item`). Dictionaries are grouped by their composite id
+ *   (one segment per dimension), merged within each group (locale completion /
+ *   priority overrides preserved), and a `QualifiedDictionaryGroup` is returned.
+ *   Unqualified siblings act as shared base content merged into every entry.
+ *
+ * Every qualified entry must declare ALL dimensions of the group; an entry that
+ * declares only a subset is ambiguous and is rejected with an error log.
+ */
+declare const mergeQualifiedDictionaries: (dictionaries: Dictionary[]) => Dictionary | QualifiedDictionaryGroup;
+//#endregion
+export { mergeQualifiedDictionaries };
+//# sourceMappingURL=mergeQualifiedDictionaries.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mergeQualifiedDictionaries.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/mergeQualifiedDictionaries.ts"],"mappings":";;;;;AA8BA;;;;;;;;;;;;;cAAa,0BAAA,GACX,YAAA,EAAc,UAAA,OACb,UAAA,GAAa,wBAAA"}

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

@@ -0,0 +1,176 @@
+import { Dictionary, DictionaryQualifierType, DictionarySelector, 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 several
+ * 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", "meta", "item"];
+/**
+ * Separator joining per-dimension ids into a composite entry id. Also used as
+ * the chunk path separator in dynamic mode.
+ */
+declare const COMPOSITE_ID_SEPARATOR = "/";
+/**
+ * Returns the qualifier dimensions declared on a dictionary, in canonical
+ * order (`variant → meta → 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 identifier of a dictionary for the given qualifier
+ * dimension — one segment of the composite entry id.
+ *
+ * - 'variant' → the variant name
+ * - 'meta' → the `meta.id` discriminator
+ * - 'item' → the item index as string
+ */
+declare const getDictionaryQualifierId: (dictionary: Dictionary, qualifierType: DictionaryQualifierType) => string | undefined;
+/**
+ * Returns the per-dimension id segments of a dictionary for the given ordered
+ * dimension set, or `undefined` when the dictionary does not declare every
+ * dimension of the set.
+ */
+declare const getDictionaryQualifierSegments: (dictionary: Dictionary, qualifierTypes: DictionaryQualifierType[]) => string[] | undefined;
+/**
+ * Builds the composite entry id of a dictionary — its per-dimension id segments
+ * joined in canonical order. `undefined` when a dimension is missing.
+ */
+declare const getDictionaryCompositeId: (dictionary: Dictionary, qualifierTypes: DictionaryQualifierType[]) => string | undefined;
+/**
+ * Type guard discriminating a `QualifiedDictionaryGroup` (merge output of a
+ * qualified key) from a plain `Dictionary`. Both carry a `content` field; only
+ * the group declares `qualifierTypes`, which is therefore the discriminator.
+ */
+declare const isQualifiedDictionaryGroup: (value: unknown) => value is QualifiedDictionaryGroup;
+/**
+ * Reconstructs a resolvable {@link Dictionary} from a single entry of a
+ * qualified group: the content node stored under its composite id, plus the
+ * qualifier coordinates decoded from that id (`variant`, `item`) and the
+ * preserved `meta` object for the meta dimension.
+ *
+ * This keeps the resolver's matching/transform code unchanged: it still sees a
+ * `{ key, content, variant?, item?, meta? }` shape, even though the stored
+ * format no longer duplicates those fields per entry.
+ */
+declare const reconstructQualifiedEntry: (group: QualifiedDictionaryGroup, compositeId: string) => Dictionary;
+/**
+ * Resolves a dictionary (or qualified dictionary group) against a selector,
+ * across every declared dimension.
+ *
+ * - Plain dictionary → returned as-is (selector ignored)
+ * - `item` declared but not selected → every matching entry ordered by index
+ * - `item` selected → the matching entry or null
+ * - `variant` defaults to the `default` entry when not selected
+ * - `meta` requires `{ id }` and every declared meta field to match
+ *
+ * Dimensions compose: e.g. a variant × item key with `{ variant: 'promo' }`
+ * returns every promo item as an array; adding `{ item: 2 }` narrows to one.
+ */
+declare const resolveQualifiedDictionary: (dictionaryOrGroup: Dictionary | QualifiedDictionaryGroup, selector?: DictionarySelector) => Dictionary | Dictionary[] | null;
+/**
+ * Splits the second argument of `getIntlayer` / `getDictionary` into the
+ * effective locale and the selector object (if any).
+ */
+declare const parseDictionarySelector: <L extends LocalesValues>(localeOrSelector?: L | DictionarySelector) => {
+  locale?: L;
+  selector?: DictionarySelector;
+};
+/**
+ * Builds a stable string identity of a selector (excluding `locale`), suitable
+ * 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 / meta records, 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 → meta → item`): `variant` defaults to `default`, `meta` descends by
+ * `id`, and `item` either narrows to the selected index or — when no item is
+ * given — expands into every sibling chunk (the collection axis). Meta-equality
+ * is verified on the loaded chunk. 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, DynamicDictionaryLoader, QUALIFIER_DYNAMIC_TYPES_KEY, QUALIFIER_ORDER, QualifiedDynamicLoaderMap, QualifiedDynamicLoaderTree, getDictionaryCompositeId, getDictionaryQualifierId, getDictionaryQualifierSegments, getDictionaryQualifierTypes, getDictionarySelectorCacheKey, isQualifiedDictionaryGroup, isQualifiedDynamicLoaderMap, parseDictionarySelector, reconstructQualifiedEntry, resolveQualifiedDictionary, resolveQualifiedDynamicContent, resolveQualifiedDynamicContentAsync };
+//# sourceMappingURL=qualifiedDictionary.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"qualifiedDictionary.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/qualifiedDictionary.ts"],"mappings":";;;;;;AAmBA;;;cAAa,eAAA;;AAUb;;;cAAa,sBAAA;;AAOb;;;;cAAa,2BAAA,GACX,UAAA,EAAY,UAAA,KACX,uBAAA;;;;;AAmBH;;;;cAAa,wBAAA,GACX,UAAA,EAAY,UAAA,EACZ,aAAA,EAAe,uBAAA;;;;;;cAeJ,8BAAA,GACX,UAAA,EAAY,UAAA,EACZ,cAAA,EAAgB,uBAAA;;;;;cAiBL,wBAAA,GACX,UAAA,EAAY,UAAA,EACZ,cAAA,EAAgB,uBAAA;;;;;AAFlB;cAgEa,0BAAA,GACX,KAAA,cACC,KAAA,IAAS,wBAAA;;;;;;;;;AAFZ;;cAmBa,yBAAA,GACX,KAAA,EAAO,wBAAA,EACP,WAAA,aACC,UAAA;;;;;;;AAHH;;;;;;;cAwCa,0BAAA,GACX,iBAAA,EAAmB,UAAA,GAAa,wBAAA,EAChC,QAAA,GAAW,kBAAA,KACV,UAAA,GAAa,UAAA;;;AAHhB;;cAqCa,uBAAA,aAAqC,aAAA,EAChD,gBAAA,GAAmB,CAAA,GAAI,kBAAA;EACpB,MAAA,GAAS,CAAA;EAAG,QAAA,GAAW,kBAAA;AAAA;;;;;cAef,6BAAA,GACX,QAAA,GAAW,kBAAA;;;;;;;cAiBA,2BAAA;;AAnCb;;KAwCY,uBAAA,SAAgC,OAAA,CAAQ,UAAA;;;;;KAMxC,0BAAA;EAAA,CACT,OAAA,WAAkB,0BAAA,GAA6B,uBAAA;AAAA;;;;;;;;;;;;AA9BlD;KA6CY,yBAAA;EAAA,CACT,2BAAA,GAA8B,uBAAA;EAAA,CAC9B,MAAA,WAAiB,0BAAA,GAA6B,uBAAA;AAAA;AA7BjD;;;;AAAA,cAoCa,2BAAA,GACX,KAAA,cACC,KAAA,IAAS,yBAAA;AAjCZ;;;;;AAMA;;;;;;;;;AAgBA;;;;;;;;;AAtBA,cAuLa,8BAAA,YAA2C,MAAA;EACtD,SAAA,EAAW,yBAAA;EACX,GAAA;EACA,MAAA;EACA,QAAA,EAAU,kBAAA;EACV,SAAA,GAAY,QAAA,UAAkB,OAAA,EAAS,OAAA,CAAQ,UAAA,MAAgB,UAAA;EAC/D,SAAA,GAAY,UAAA,EAAY,UAAA,KAAe,OAAA;AAAA,MACrC,OAAA,GAAU,OAAA;;;;;;;;;AAPd;;;cAyCa,mCAAA,YAAsD,MAAA;EACjE,SAAA,EAAW,yBAAA;EACX,GAAA;EACA,MAAA;EACA,QAAA,EAAU,kBAAA;EACV,SAAA,GAAY,UAAA,EAAY,UAAA,KAAe,OAAA;AAAA,MACrC,OAAA,CAAQ,OAAA,GAAU,OAAA"}

package/dist/types/index.d.ts

@@ -1,3 +1,4 @@
+import { getEditedContent, getEditedDictionary } from "./deepTransformPlugins/getEditedContent.js";
 import { ConditionContent, ConditionContentStates, cond as condition } from "./transpiler/condition/condition.js";
 import { EnterFormat, EnumerationContent, EnumerationContentState, enu as enumeration } from "./transpiler/enumeration/enumeration.js";
 import { FileContent, FileContentConstructor, file, fileContent } from "./transpiler/file/file.js";
@@ -42,8 +43,10 @@ import { getEmptyNode } from "./dictionaryManipulator/getEmptyNode.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, DynamicDictionaryLoader, QUALIFIER_DYNAMIC_TYPES_KEY, QUALIFIER_ORDER, QualifiedDynamicLoaderMap, QualifiedDynamicLoaderTree, getDictionaryCompositeId, getDictionaryQualifierId, getDictionaryQualifierSegments, getDictionaryQualifierTypes, getDictionarySelectorCacheKey, isQualifiedDictionaryGroup, isQualifiedDynamicLoaderMap, parseDictionarySelector, reconstructQualifiedEntry, resolveQualifiedDictionary, resolveQualifiedDynamicContent, resolveQualifiedDynamicContentAsync } from "./dictionaryManipulator/qualifiedDictionary.js";
 import { removeContentNodeByKeyPath } from "./dictionaryManipulator/removeContentNodeByKeyPath.js";
 import { renameContentNodeByKeyPath } from "./dictionaryManipulator/renameContentNodeByKeyPath.js";
 import { updateNodeChildren } from "./dictionaryManipulator/updateNodeChildren.js";
@@ -81,12 +84,13 @@ import { allowInline, anyScopeRegex, attributeValueToNodePropValue, blockRegex,
 import { JsonValue, icuToIntlayerFormatter, intlayerToICUFormatter } from "./messageFormat/ICU.js";
 import { i18nextToIntlayerFormatter, intlayerToI18nextFormatter } from "./messageFormat/i18next.js";
 import { PortableObject, intlayerToPortableObjectFormatter, portableObjectToIntlayerFormatter } from "./messageFormat/po.js";
+import { MessageFormatDialect, MessageValues, TaggedMessageToken, interpolateMessage, parseTaggedMessage, resolveMessage, resolveMessageNode } from "./messageFormat/resolveMessage.js";
 import { intlayerToVueI18nFormatter, vueI18nToIntlayerFormatter } from "./messageFormat/vue-i18n.js";
 import { checkIsURLAbsolute } from "./utils/checkIsURLAbsolute.js";
 import { getCookie } from "./utils/getCookie.js";
 import { isSameKeyPath } from "./utils/isSameKeyPath.js";
 import { isValidElement } from "./utils/isValidReactElement.js";
 import { CookieBuildAttributes, LocaleStorage, LocaleStorageClient, LocaleStorageClientOptions, LocaleStorageOptions, LocaleStorageServer, LocaleStorageServerOptions, getLocaleFromStorage, getLocaleFromStorageClient, getLocaleFromStorageServer, localeStorageOptions, setLocaleInStorage, setLocaleInStorageClient, setLocaleInStorageServer } from "./utils/localeStorage.js";
-import { parseYaml } from "./utils/parseYaml.js";
+import { YamlRecord, YamlValue, parseYaml } from "./utils/parseYaml.js";
 import { stringifyYaml } from "./utils/stringifyYaml.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, BlockQuoteNode, BoldTextNode, BreakLineNode, BreakThematicNode, CAPTURE_LETTER_AFTER_HYPHEN, CODE_BLOCK_FENCED_R, CODE_BLOCK_R, CODE_INLINE_R, CONSECUTIVE_NEWLINE_R, CR_NEWLINE_R, CUSTOM_COMPONENT_R, CachedIntl, CachedIntl as Intl, CodeBlockNode, CodeFencedNode, CodeInlineNode, CompileOptions, ComponentOverrides, ConditionCond, ConditionContent, ConditionContentStates, CookieBuildAttributes, CustomComponentNode, DO_NOT_PROCESS_HTML_ELEMENTS, DURATION_DELAY_TRIGGER, DateTimePreset, DeepTransformContent, DotPath, ElementType, EnterFormat, EnumerationCond, EnumerationContent, EnumerationContentState, EscapedTextNode, FOOTNOTE_R, FOOTNOTE_REFERENCE_R, FORMFEED_R, FRONT_MATTER_R, FileCond, FileContent, FileContentConstructor, FootnoteNode, FootnoteReferenceNode, GFMTaskNode, GFM_TASK_R, Gender, GenderCond, GenderContent, GenderContentStates, GenerateSitemapOptions, GetNestingResult, GetPrefixOptions, GetPrefixResult, HEADING_ATX_COMPLIANT_R, HEADING_R, HEADING_SETEXT_R, HTMLCommentNode, HTMLContent, HTMLContentConstructor, HTMLNode, HTMLSelfClosingNode, 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, HeadingNode, HeadingSetextNode, IInterpreterPlugin, IInterpreterPluginState, INLINE_SKIP_R, INTERPOLATION_R, ImageNode, InsertionCond, InsertionContent, InsertionContentConstructor, IsAny, ItalicTextNode, JsonValue, LINK_AUTOLINK_BARE_URL_R, LINK_AUTOLINK_R, LIST_LOOKBEHIND_R, LOOKAHEAD, LinkAngleBraceNode, LinkBareURLNode, LinkNode, ListType, LocaleStorage, LocaleStorageClient, LocaleStorageClientOptions, LocaleStorageOptions, LocaleStorageServer, LocaleStorageServerOptions, LocalizedPathResult, MarkdownContent, MarkdownContentConstructor, MarkdownContext, MarkdownOptions, MarkdownRuntime, HTMLValidationIssue as MarkdownValidationIssue, MarkdownValidationResult, MarkedTextNode, NAMED_CODES_TO_UNICODE, NP_TABLE_R, NestedCond, NestedContent, NestedContentState, NestedParser, NewlineNode, NodeProps, ORDERED, ORDERED_LIST_BULLET, ORDERED_LIST_ITEM_PREFIX, ORDERED_LIST_ITEM_PREFIX_R, ORDERED_LIST_ITEM_R, ORDERED_LIST_R, OrderedListNode, PARAGRAPH_R, ParagraphNode, ParseState, ParsedMarkdown, Parser, ParserResult, Plugins, PluralCategory, PluralCond, PluralContent, PluralContentState, PortableObject, Priority, PriorityValue, REFERENCE_IMAGE_OR_LINK, REFERENCE_IMAGE_R, REFERENCE_LINK_R, ReferenceImageNode, ReferenceLinkNode, ReferenceNode, RenderRuleHook, Rule, RuleOutput, RuleType, RuleTypeValue, Rules, SHORTCODE_R, SHOULD_RENDER_AS_BLOCK_R, SitemapUrlEntry, 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, TableNode, TableSeparatorNode, 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, UnorderedListNode, VOID_HTML_ELEMENTS, ValidDotPathsFor, ValueAtKey, WrappedIntl, allowInline, anyScopeRegex, attributeValueToNodePropValue, bindIntl, blockRegex, buildMaskPlugin, captureNothing, checkIsURLAbsolute, checkMissingLocalesPlugin, compact, compile, compileWithOptions, condition as cond, conditionPlugin, createCompiler, createRenderer, currency, cx, date, deepTransformNode, editDictionaryByKeyPath, enumeration as enu, enumerationPlugin, fallbackPlugin, file, fileContent, filePlugin, filterMissingTranslationsOnlyPlugin, filterTranslationsOnlyPlugin, findMatchingCondition, gender, genderPlugin, generateListItemPrefix, generateListItemPrefixRegex, generateListItemRegex, generateListRegex, generateSitemap, generateSitemapUrl, get, getBasePlugins, getBrowserLocale, getCachedIntl, getCanonicalPath, getCondition, getContent, getContentNodeByKeyPath, getCookie, getDefaultNode, getDictionary, getEmptyNode, getEnumeration, getFilterMissingTranslationsContent, getFilterMissingTranslationsDictionary, getFilterTranslationsOnlyContent, getFilterTranslationsOnlyDictionary, getFilteredLocalesContent, getFilteredLocalesDictionary, getHTML, getHTMLTextDir, getInsertionValues, getInternalPath, getIntlayer, getLocale, 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, getSplittedContent, getSplittedDictionaryContent, getTranslation, html, i18nextToIntlayerFormatter, icuToIntlayerFormatter, inlineRegex, insertion as insert, insertContentInDictionary, insertionPlugin, intlayerToI18nextFormatter, intlayerToICUFormatter, intlayerToPortableObjectFormatter, intlayerToVueI18nFormatter, isSameKeyPath, isValidElement, list, localeDetector, localeFlatMap, localeMap, localeRecord, localeResolver, localeStorageOptions, markdown as md, mergeDictionaries, nesting as nest, nestedPlugin, normalizeAttributeKey, normalizeDictionaries, normalizeDictionary, normalizeWhitespace, number, orderDictionaries, parseBlock, parseCaptureInline, parseInline, parseMarkdown, parseSimpleInline, parseStyleAttribute, parseTableAlign, parseTableAlignCapture, parseTableCells, parseTableRow, parseYaml, parserFor, percentage, plural, pluralPlugin, portableObjectToIntlayerFormatter, presets, qualifies, relativeTime, removeContentNodeByKeyPath, renameContentNodeByKeyPath, renderFor, renderMarkdownAst, renderNothing, sanitizer, setLocaleInStorage, setLocaleInStorageClient, setLocaleInStorageServer, simpleInlineRegex, slugify, some, splitInsertionTemplate, startsWith, stringifyYaml, translation as t, 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, BlockQuoteNode, BoldTextNode, BreakLineNode, 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, CodeBlockNode, CodeFencedNode, CodeInlineNode, CompileOptions, ComponentOverrides, ConditionCond, ConditionContent, ConditionContentStates, CookieBuildAttributes, CustomComponentNode, DO_NOT_PROCESS_HTML_ELEMENTS, DURATION_DELAY_TRIGGER, DateTimePreset, DeepTransformContent, DotPath, DynamicDictionaryLoader, ElementType, EnterFormat, EnumerationCond, EnumerationContent, EnumerationContentState, EscapedTextNode, FOOTNOTE_R, FOOTNOTE_REFERENCE_R, FORMFEED_R, FRONT_MATTER_R, FileCond, FileContent, FileContentConstructor, FootnoteNode, FootnoteReferenceNode, GFMTaskNode, GFM_TASK_R, Gender, GenderCond, GenderContent, GenderContentStates, GenerateSitemapOptions, GetNestingResult, GetPrefixOptions, GetPrefixResult, HEADING_ATX_COMPLIANT_R, HEADING_R, HEADING_SETEXT_R, HTMLCommentNode, HTMLContent, HTMLContentConstructor, HTMLNode, HTMLSelfClosingNode, 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, HeadingNode, HeadingSetextNode, IInterpreterPlugin, IInterpreterPluginState, INLINE_SKIP_R, INTERPOLATION_R, ImageNode, InsertionCond, InsertionContent, InsertionContentConstructor, IsAny, ItalicTextNode, JsonValue, LINK_AUTOLINK_BARE_URL_R, LINK_AUTOLINK_R, LIST_LOOKBEHIND_R, LOOKAHEAD, LinkAngleBraceNode, LinkBareURLNode, LinkNode, ListType, LocaleStorage, LocaleStorageClient, LocaleStorageClientOptions, LocaleStorageOptions, LocaleStorageServer, LocaleStorageServerOptions, LocalizedPathResult, MarkdownContent, MarkdownContentConstructor, MarkdownContext, MarkdownOptions, MarkdownRuntime, HTMLValidationIssue as MarkdownValidationIssue, MarkdownValidationResult, MarkedTextNode, MessageFormatDialect, MessageValues, NAMED_CODES_TO_UNICODE, NP_TABLE_R, NestedCond, NestedContent, NestedContentState, NestedParser, NewlineNode, NodeProps, ORDERED, ORDERED_LIST_BULLET, ORDERED_LIST_ITEM_PREFIX, ORDERED_LIST_ITEM_PREFIX_R, ORDERED_LIST_ITEM_R, ORDERED_LIST_R, OrderedListNode, PARAGRAPH_R, ParagraphNode, ParseState, ParsedMarkdown, Parser, 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, ReferenceImageNode, ReferenceLinkNode, ReferenceNode, RenderRuleHook, Rule, RuleOutput, RuleType, RuleTypeValue, Rules, SHORTCODE_R, SHOULD_RENDER_AS_BLOCK_R, SitemapUrlEntry, 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, TableNode, TableSeparatorNode, TaggedMessageToken, 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, UnorderedListNode, VOID_HTML_ELEMENTS, ValidDotPathsFor, ValueAtKey, WrappedIntl, YamlRecord, YamlValue, allowInline, anyScopeRegex, attributeValueToNodePropValue, bindIntl, blockRegex, buildMaskPlugin, captureNothing, checkIsURLAbsolute, checkMissingLocalesPlugin, compact, compile, compileWithOptions, condition as cond, conditionPlugin, createCompiler, createRenderer, currency, cx, date, deepTransformNode, editDictionaryByKeyPath, enumeration as enu, enumerationPlugin, fallbackPlugin, file, fileContent, filePlugin, filterMissingTranslationsOnlyPlugin, filterTranslationsOnlyPlugin, findMatchingCondition, gender, genderPlugin, generateListItemPrefix, generateListItemPrefixRegex, generateListItemRegex, generateListRegex, generateSitemap, generateSitemapUrl, get, getBasePlugins, getBrowserLocale, getCachedIntl, getCanonicalPath, getCondition, getContent, getContentNodeByKeyPath, getCookie, getDefaultNode, getDictionary, getDictionaryCompositeId, getDictionaryQualifierId, getDictionaryQualifierSegments, getDictionaryQualifierTypes, getDictionarySelectorCacheKey, getEditedContent, getEditedDictionary, getEmptyNode, getEnumeration, getFilterMissingTranslationsContent, getFilterMissingTranslationsDictionary, getFilterTranslationsOnlyContent, getFilterTranslationsOnlyDictionary, getFilteredLocalesContent, getFilteredLocalesDictionary, getHTML, getHTMLTextDir, getInsertionValues, getInternalPath, getIntlayer, getLocale, 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, getSplittedContent, getSplittedDictionaryContent, getTranslation, html, i18nextToIntlayerFormatter, icuToIntlayerFormatter, inlineRegex, insertion as insert, insertContentInDictionary, insertionPlugin, interpolateMessage, intlayerToI18nextFormatter, intlayerToICUFormatter, intlayerToPortableObjectFormatter, intlayerToVueI18nFormatter, isQualifiedDictionaryGroup, isQualifiedDynamicLoaderMap, isSameKeyPath, isValidElement, list, localeDetector, localeFlatMap, localeMap, localeRecord, localeResolver, localeStorageOptions, markdown as md, mergeDictionaries, mergeQualifiedDictionaries, nesting as nest, nestedPlugin, normalizeAttributeKey, normalizeDictionaries, normalizeDictionary, normalizeWhitespace, number, orderDictionaries, parseBlock, parseCaptureInline, parseDictionarySelector, parseInline, parseMarkdown, parseSimpleInline, parseStyleAttribute, parseTableAlign, parseTableAlignCapture, parseTableCells, parseTableRow, parseTaggedMessage, parseYaml, parserFor, percentage, plural, pluralPlugin, portableObjectToIntlayerFormatter, presets, qualifies, reconstructQualifiedEntry, relativeTime, removeContentNodeByKeyPath, renameContentNodeByKeyPath, renderFor, renderMarkdownAst, renderNothing, resolveMessage, resolveMessageNode, resolveQualifiedDictionary, resolveQualifiedDynamicContent, resolveQualifiedDynamicContentAsync, sanitizer, setLocaleInStorage, setLocaleInStorageClient, setLocaleInStorageServer, simpleInlineRegex, slugify, some, splitInsertionTemplate, startsWith, stringifyYaml, translation as t, translationPlugin, trimEnd, trimLeadingWhitespaceOutsideFences, unescapeString, units, unquote, updateNodeChildren, validateHTML, validateMarkdown, validatePrefix, vueI18nToIntlayerFormatter };

package/dist/types/interpreter/getDictionary.d.ts

@@ -1,17 +1,23 @@
 import { DeepTransformContent, IInterpreterPluginState, Plugins } from "./getContent/plugins.js";
-import { Dictionary } from "@intlayer/types/dictionary";
-import { DeclaredLocales, LocalesValues } from "@intlayer/types/module_augmentation";
+import { Dictionary, DictionarySelector, QualifiedDictionaryGroup, ResolveQualifiedDictionaryContent } from "@intlayer/types/dictionary";
+import { DeclaredLocales, ExtractSelectorLocale, LocalesValues } from "@intlayer/types/module_augmentation";
 
 //#region src/interpreter/getDictionary.d.ts
 /**
  * Transforms a dictionary in a single pass, applying each plugin as needed.
  *
- * @param dictionary The dictionary to transform.
- * @param locale The locale to use if your transformers need it (e.g. for translations).
- * @param additionalPlugins An array of NodeTransformer that define how to transform recognized nodes.
- *                      If omitted, we’ll use a default set of plugins.
+ * Also accepts a `QualifiedDictionaryGroup` (collections, variants, meta
+ * records) 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 }`, `{ id, ...meta }`, optionally with `locale`).
+ * @param plugins An array of NodeTransformer that define how to transform recognized nodes.
+ *                If omitted, we’ll use a default set of plugins.
  */
-declare const getDictionary: <const T extends Dictionary, const L extends LocalesValues = DeclaredLocales>(dictionary: T, locale?: L, plugins?: Plugins[]) => DeepTransformContent<T["content"], IInterpreterPluginState, L>;
+declare const getDictionary: <const T extends Dictionary | QualifiedDictionaryGroup, const A extends LocalesValues | DictionarySelector = DeclaredLocales>(dictionary: T, localeOrSelector?: A, plugins?: Plugins[]) => DeepTransformContent<ResolveQualifiedDictionaryContent<T, A>, IInterpreterPluginState, ExtractSelectorLocale<A>>;
 //#endregion
 export { getDictionary };
 //# sourceMappingURL=getDictionary.d.ts.map

package/dist/types/interpreter/getDictionary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getDictionary.d.ts","names":[],"sources":["../../../src/interpreter/getDictionary.ts"],"mappings":";;;;;;;;AAqBA;;;;;cAAa,aAAA,mBACK,UAAA,kBACA,aAAA,GAAgB,eAAA,EAEhC,UAAA,EAAY,CAAA,EACZ,MAAA,GAAS,CAAA,EACT,OAAA,GAAS,OAAA,OACR,oBAAA,CAAqB,CAAA,aAAc,uBAAA,EAAyB,CAAA"}
+{"version":3,"file":"getDictionary.d.ts","names":[],"sources":["../../../src/interpreter/getDictionary.ts"],"mappings":";;;;;;;;AAqCA;;;;;;;;;;;cAAa,aAAA,mBACK,UAAA,GAAa,wBAAA,kBACb,aAAA,GAAgB,kBAAA,GAAqB,eAAA,EAErD,UAAA,EAAY,CAAA,EACZ,gBAAA,GAAmB,CAAA,EACnB,OAAA,GAAU,OAAA,OACT,oBAAA,CACD,iCAAA,CAAkC,CAAA,EAAG,CAAA,GACrC,uBAAA,EACA,qBAAA,CAAsB,CAAA"}

package/dist/types/interpreter/getIntlayer.d.ts

@@ -1,8 +1,19 @@
 import { DeepTransformContent, IInterpreterPluginState, Plugins } from "./getContent/plugins.js";
-import { DeclaredLocales, DictionaryKeys, DictionaryRegistryContent, LocalesValues } from "@intlayer/types/module_augmentation";
+import { DictionarySelector } from "@intlayer/types/dictionary";
+import { DeclaredLocales, DictionaryKeys, DictionaryRegistryResult, ExtractSelectorLocale, LocalesValues } from "@intlayer/types/module_augmentation";
 
 //#region src/interpreter/getIntlayer.d.ts
-declare const getIntlayer: <const T extends DictionaryKeys, const L extends LocalesValues = DeclaredLocales>(key: T, locale?: L, plugins?: Plugins[]) => DeepTransformContent<DictionaryRegistryContent<T>, IInterpreterPluginState, L>;
+/**
+ * Picks one dictionary by its key and returns its content for the given
+ * locale or selector.
+ *
+ * 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)
+ * - `{ id: 'prod_abc', ...metaFields }` — meta record
+ * - `locale` can be combined with any selector: `{ item: 2, locale: 'fr' }`
+ */
+declare const getIntlayer: <const T extends DictionaryKeys, const A extends LocalesValues | DictionarySelector = DeclaredLocales>(key: T, localeOrSelector?: A, plugins?: Plugins[]) => DeepTransformContent<DictionaryRegistryResult<T, A>, IInterpreterPluginState, ExtractSelectorLocale<A>>;
 //#endregion
 export { getIntlayer };
 //# sourceMappingURL=getIntlayer.d.ts.map

package/dist/types/interpreter/getIntlayer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getIntlayer.d.ts","names":[],"sources":["../../../src/interpreter/getIntlayer.ts"],"mappings":";;;;cAmDa,WAAA,mBACK,cAAA,kBACA,aAAA,GAAgB,eAAA,EAEhC,GAAA,EAAK,CAAA,EACL,MAAA,GAAS,CAAA,EACT,OAAA,GAAU,OAAA,OACT,oBAAA,CACD,yBAAA,CAA0B,CAAA,GAC1B,uBAAA,EACA,CAAA"}
+{"version":3,"file":"getIntlayer.d.ts","names":[],"sources":["../../../src/interpreter/getIntlayer.ts"],"mappings":";;;;;;;;AAkEA;;;;;;;cAAa,WAAA,mBACK,cAAA,kBACA,aAAA,GAAgB,kBAAA,GAAqB,eAAA,EAErD,GAAA,EAAK,CAAA,EACL,gBAAA,GAAmB,CAAA,EACnB,OAAA,GAAU,OAAA,OACT,oBAAA,CACD,wBAAA,CAAyB,CAAA,EAAG,CAAA,GAC5B,uBAAA,EACA,qBAAA,CAAsB,CAAA"}

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

@@ -29,24 +29,10 @@ type RoutingOptions = {
  * Resolves routing configuration by merging provided options with configuration defaults.
  * Single source of truth for default routing config resolution across all localization functions.
  */
-declare const resolveRoutingConfig: (options?: RoutingOptions) => {
-  locales: any;
-  defaultLocale: any;
-  mode: any;
-  rewrite: any;
-  domains: any;
-  /**
-   * The hostname of the page currently being rendered (e.g. `'intlayer.org'`).
-   * When provided, `getLocalizedUrl` returns a relative URL for locales whose
-   * configured domain matches `currentDomain`, and an absolute URL only when
-   * the target locale lives on a different domain.
-   *
-   * When omitted the function tries to infer it from:
-   *   1. The domain of an absolute input URL.
-   *   2. `window.location.hostname` in browser environments.
-   * Falls back to always generating absolute URLs when neither is available.
-   */
-  currentDomain?: string;
+declare const resolveRoutingConfig: (options?: RoutingOptions) => Omit<RoutingOptions, "defaultLocale" | "mode" | "locales"> & {
+  defaultLocale: LocalesValues;
+  mode: RoutingConfig["mode"];
+  locales: LocalesValues[];
 };
 type GetPrefixOptions = {
   defaultLocale?: LocalesValues;

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

@@ -1 +1 @@
-{"version":3,"file":"getPrefix.d.ts","names":[],"sources":["../../../src/localization/getPrefix.ts"],"mappings":";;;;;;;AAuBA;KAAY,cAAA;EACV,OAAA,GAAU,aAAA;EACV,aAAA,GAAgB,aAAA;EAChB,IAAA,GAAO,aAAA;EACP,OAAA,GAAU,aAAA;EACV,OAAA,GAAU,aAAA;EAAA;;;;;;;;;;;EAYV,aAAA;AAAA;;;;AAOF;cAAa,oBAAA,GAAwB,OAAA,GAAS,cAAA;;;;;;;;;;;;;AAS9C;;;;;;KAAY,gBAAA;EACV,aAAA,GAAgB,aAAA;EAChB,IAAA,GAAO,aAAA;AAAA;AAAA,KAGG,eAAA;EAAe;;;;EAKzB,MAAA;EAIc;;;EAAd,YAAA,EAAc,MAAA;AAAA;;;;;;;;;;KAYJ,uBAAA,WACA,aAAA,oCACY,mBAAA,kBACN,aAAA,GAAgB,qBAAA,IAC9B,CAAA,oCACkB,CAAA,IAChB,uBAAA,CAAwB,eAAA,EAAiB,IAAA,EAAM,OAAA,sBAC7B,IAAA,IAChB,eAAA,GACA,IAAA;EACI,MAAA,KAAW,CAAA;EAAM,YAAA,EAAc,CAAA;AAAA,IACjC,IAAA,+BACE,CAAA,SAAU,OAAA;EACN,MAAA;EAAY,YAAA;AAAA;EACZ,MAAA,KAAW,CAAA;EAAM,YAAA,EAAc,CAAA;AAAA;EACjC,MAAA;EAAY,YAAA;AAAA;EACpB,MAAA;EAAY,YAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmCL,SAAA,mBAA6B,aAAA,cACxC,MAAA,EAAQ,CAAA,EACR,OAAA,GAAS,cAAA,KACR,uBAAA,CAAwB,CAAA"}
+{"version":3,"file":"getPrefix.d.ts","names":[],"sources":["../../../src/localization/getPrefix.ts"],"mappings":";;;;;;;AAuBA;KAAY,cAAA;EACV,OAAA,GAAU,aAAA;EACV,aAAA,GAAgB,aAAA;EAChB,IAAA,GAAO,aAAA;EACP,OAAA,GAAU,aAAA;EACV,OAAA,GAAU,aAAA;EAAA;;;;;;;;;;;EAYV,aAAA;AAAA;;;;AAOF;cAAa,oBAAA,GACX,OAAA,GAAS,cAAA,KACR,IAAA,CAAK,cAAA;EACN,aAAA,EAAe,aAAA;EACf,IAAA,EAAM,aAAA;EACN,OAAA,EAAS,aAAA;AAAA;AAAA,KAUC,gBAAA;EACV,aAAA,GAAgB,aAAA;EAChB,IAAA,GAAO,aAAA;AAAA;AAAA,KAGG,eAAA;EAnBD;;;;EAwBT,MAAA;EAtBe;;;EA0Bf,YAAA,EAAc,MAAA;AAAA;;;AAdhB;;;;;;;KA0BY,uBAAA,WACA,aAAA,oCACY,mBAAA,kBACN,aAAA,GAAgB,qBAAA,IAC9B,CAAA,oCACkB,CAAA,IAChB,uBAAA,CAAwB,eAAA,EAAiB,IAAA,EAAM,OAAA,sBAC7B,IAAA,IAChB,eAAA,GACA,IAAA;EACI,MAAA,KAAW,CAAA;EAAM,YAAA,EAAc,CAAA;AAAA,IACjC,IAAA,+BACE,CAAA,SAAU,OAAA;EACN,MAAA;EAAY,YAAA;AAAA;EACZ,MAAA,KAAW,CAAA;EAAM,YAAA,EAAc,CAAA;AAAA;EACjC,MAAA;EAAY,YAAA;AAAA;EACpB,MAAA;EAAY,YAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmCL,SAAA,mBAA6B,aAAA,cACxC,MAAA,EAAQ,CAAA,EACR,OAAA,GAAS,cAAA,KACR,uBAAA,CAAwB,CAAA"}

package/dist/types/messageFormat/ICU.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ICU.d.ts","names":[],"sources":["../../../src/messageFormat/ICU.ts"],"mappings":";;;KA6CY,SAAA,sCAKR,SAAA;EAAA,CACG,GAAA,WAAc,SAAA;AAAA;AAAA,cAkiBR,sBAAA,GACX,OAAA,EAAS,UAAA,gBACR,SAAA;AAAA,cAQU,sBAAA,GACX,OAAA,EAAS,UAAA,gBACR,SAAA"}
+{"version":3,"file":"ICU.d.ts","names":[],"sources":["../../../src/messageFormat/ICU.ts"],"mappings":";;;KAkDY,SAAA,sCAKR,SAAA;EAAA,CACG,GAAA,WAAc,SAAA;AAAA;AAAA,cAwlBR,sBAAA,GACX,OAAA,EAAS,UAAA,gBACR,SAAA;AAAA,cAQU,sBAAA,GACX,OAAA,EAAS,UAAA,gBACR,SAAA"}

package/dist/types/messageFormat/i18next.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"i18next.d.ts","names":[],"sources":["../../../src/messageFormat/i18next.ts"],"mappings":";;;;cAqjBa,0BAAA,GACX,OAAA,EAAS,UAAA,gBACR,SAAA;AAAA,cAQU,0BAAA,GACX,OAAA,EAAS,SAAA,KACR,UAAA"}
+{"version":3,"file":"i18next.d.ts","names":[],"sources":["../../../src/messageFormat/i18next.ts"],"mappings":";;;;cAsjBa,0BAAA,GACX,OAAA,EAAS,UAAA,gBACR,SAAA;AAAA,cAQU,0BAAA,GACX,OAAA,EAAS,SAAA,KACR,UAAA"}

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

@@ -1,5 +1,6 @@
 import { JsonValue, icuToIntlayerFormatter, intlayerToICUFormatter } from "./ICU.js";
 import { i18nextToIntlayerFormatter, intlayerToI18nextFormatter } from "./i18next.js";
 import { PortableObject, intlayerToPortableObjectFormatter, portableObjectToIntlayerFormatter } from "./po.js";
+import { MessageFormatDialect, MessageValues, TaggedMessageToken, interpolateMessage, parseTaggedMessage, resolveMessage, resolveMessageNode } from "./resolveMessage.js";
 import { intlayerToVueI18nFormatter, vueI18nToIntlayerFormatter } from "./vue-i18n.js";
-export { JsonValue, PortableObject, i18nextToIntlayerFormatter, icuToIntlayerFormatter, intlayerToI18nextFormatter, intlayerToICUFormatter, intlayerToPortableObjectFormatter, intlayerToVueI18nFormatter, portableObjectToIntlayerFormatter, vueI18nToIntlayerFormatter };
+export { JsonValue, MessageFormatDialect, MessageValues, PortableObject, TaggedMessageToken, i18nextToIntlayerFormatter, icuToIntlayerFormatter, interpolateMessage, intlayerToI18nextFormatter, intlayerToICUFormatter, intlayerToPortableObjectFormatter, intlayerToVueI18nFormatter, parseTaggedMessage, portableObjectToIntlayerFormatter, resolveMessage, resolveMessageNode, vueI18nToIntlayerFormatter };

package/dist/types/messageFormat/resolveMessage.d.ts

@@ -0,0 +1,72 @@
+import { LocalesValues } from "@intlayer/types/module_augmentation";
+
+//#region src/messageFormat/resolveMessage.d.ts
+/**
+ * Runtime counterpart of the `messageFormat` converters.
+ *
+ * The converters (`icuToIntlayerFormatter`, `i18nextToIntlayerFormatter`,
+ * `vueI18nToIntlayerFormatter`) turn library-specific message syntax into
+ * intlayer nodes (`insert`, `plural`, `enu`, `gender`, `html`). This module
+ * resolves those nodes — or raw message strings — into a final string using
+ * the provided interpolation values and locale.
+ *
+ * It is the mutualized resolution engine used by the compat adapter packages
+ * (`@intlayer/i18next`, `@intlayer/next-intl`, `@intlayer/vue-i18n`, …).
+ */
+/** Message syntax dialect of the source i18n library. */
+type MessageFormatDialect = 'icu' | 'i18next' | 'vue-i18n';
+/** Interpolation values passed alongside a translation lookup. */
+type MessageValues = Record<string, unknown>;
+/**
+ * Interpolates a message template with values.
+ *
+ * Handles, in order:
+ * 1. Intlayer insertions `{{name}}` (whitespace-tolerant, dotted paths)
+ * 2. ICU formatted arguments `{value, number}` / `{ts, date, long}`
+ * 3. Bare single-brace arguments `{name}` (ICU / vue-i18n simple args)
+ */
+declare const interpolateMessage: (template: string, values?: MessageValues, locale?: LocalesValues) => string;
+/**
+ * Resolves an intlayer message node tree (as produced by the
+ * `*ToIntlayerFormatter` converters, or already present in a built
+ * dictionary) into its final value using interpolation values and locale.
+ *
+ * Function nodes (produced by the interpreter plugins for `insertion`,
+ * `enumeration` and `plural` content) are invoked with the values.
+ */
+declare const resolveMessageNode: (node: unknown, values?: MessageValues, locale?: LocalesValues) => unknown;
+/**
+ * Resolves a raw message — string in a library dialect, or an intlayer node
+ * tree — into a final string using interpolation values and locale.
+ *
+ * @example
+ * ```ts
+ * resolveMessage('Hello {name}', { name: 'John' }, 'en', 'icu');
+ * // 'Hello John'
+ *
+ * resolveMessage(
+ *   '{count, plural, one {# item} other {# items}}',
+ *   { count: 3 },
+ *   'en',
+ *   'icu'
+ * );
+ * // '3 items'
+ * ```
+ */
+declare const resolveMessage: (message: unknown, values?: MessageValues, locale?: LocalesValues, dialect?: MessageFormatDialect) => string;
+/** A parsed token of a tagged message: plain text or a tag with children. */
+type TaggedMessageToken = string | {
+  tag: string;
+  children: TaggedMessageToken[];
+};
+/**
+ * Tokenizes a message containing XML-like tags (`'Visit <link>the docs</link>'`,
+ * `'hello <1>{{name}}</1>'`, `'line<br/>break'`) into a token tree.
+ *
+ * Used by rich-text renderers (`t.rich`, `<Trans components>`,
+ * `<i18n-t>` slots) to map tags to framework elements.
+ */
+declare const parseTaggedMessage: (message: string) => TaggedMessageToken[];
+//#endregion
+export { MessageFormatDialect, MessageValues, TaggedMessageToken, interpolateMessage, parseTaggedMessage, resolveMessage, resolveMessageNode };
+//# sourceMappingURL=resolveMessage.d.ts.map

package/dist/types/messageFormat/resolveMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveMessage.d.ts","names":[],"sources":["../../../src/messageFormat/resolveMessage.ts"],"mappings":";;;;;AAwBA;;;;;AAGA;;;;;AAsFA;AAAA,KAzFY,oBAAA;;KAGA,aAAA,GAAgB,MAAA;;;;;;;;AA2H5B;cArCa,kBAAA,GACX,QAAA,UACA,MAAA,GAAQ,aAAA,EACR,MAAA,GAAQ,aAAA;;;;;;;;;cAkCG,kBAAA,GACX,IAAA,WACA,MAAA,GAAQ,aAAA,EACR,MAAA,GAAQ,aAAA;AA6IV;;;;;;;;;;;;;;;;;AAiBA;AAjBA,cAAa,cAAA,GACX,OAAA,WACA,MAAA,GAAQ,aAAA,EACR,MAAA,GAAQ,aAAA,EACR,OAAA,GAAS,oBAAA;;KAaC,kBAAA;EAEN,GAAA;EAAa,QAAA,EAAU,kBAAA;AAAA;;;AAS7B;;;;;cAAa,kBAAA,GAAsB,OAAA,aAAkB,kBAAA"}

package/dist/types/messageFormat/vue-i18n.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vue-i18n.d.ts","names":[],"sources":["../../../src/messageFormat/vue-i18n.ts"],"mappings":";;;;cA2Ta,0BAAA,GACX,OAAA,EAAS,UAAA,gBACR,SAAA;AAAA,cAQU,0BAAA,GACX,OAAA,EAAS,SAAA,KACR,UAAA"}
+{"version":3,"file":"vue-i18n.d.ts","names":[],"sources":["../../../src/messageFormat/vue-i18n.ts"],"mappings":";;;;cAoUa,0BAAA,GACX,OAAA,EAAS,UAAA,gBACR,SAAA;AAAA,cAQU,0BAAA,GACX,OAAA,EAAS,SAAA,KACR,UAAA"}

package/dist/types/transpiler/markdown/validateMarkdown.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validateMarkdown.d.ts","names":[],"sources":["../../../../src/transpiler/markdown/validateMarkdown.ts"],"mappings":";;;KAIY,wBAAA;EACV,KAAA;EACA,MAAA,EAAQ,mBAAA;AAAA;;;;;;;AAwFV;cAAa,gBAAA,GAAoB,OAAA,aAAkB,wBAAA"}
+{"version":3,"file":"validateMarkdown.d.ts","names":[],"sources":["../../../../src/transpiler/markdown/validateMarkdown.ts"],"mappings":";;;KAIY,wBAAA;EACV,KAAA;EACA,MAAA,EAAQ,mBAAA;AAAA;;;;;;;AA6FV;cAAa,gBAAA,GAAoB,OAAA,aAAkB,wBAAA"}

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

@@ -4,6 +4,6 @@ import { getCookie } from "./getCookie.js";
 import { isSameKeyPath } from "./isSameKeyPath.js";
 import { isValidElement } from "./isValidReactElement.js";
 import { CookieBuildAttributes, LocaleStorage, LocaleStorageClient, LocaleStorageClientOptions, LocaleStorageOptions, LocaleStorageServer, LocaleStorageServerOptions, getLocaleFromStorage, getLocaleFromStorageClient, getLocaleFromStorageServer, localeStorageOptions, setLocaleInStorage, setLocaleInStorageClient, setLocaleInStorageServer } from "./localeStorage.js";
-import { parseYaml } from "./parseYaml.js";
+import { YamlRecord, YamlValue, parseYaml } from "./parseYaml.js";
 import { stringifyYaml } from "./stringifyYaml.js";
-export { CachedIntl, CachedIntl as Intl, CookieBuildAttributes, LocaleStorage, LocaleStorageClient, LocaleStorageClientOptions, LocaleStorageOptions, LocaleStorageServer, LocaleStorageServerOptions, WrappedIntl, bindIntl, checkIsURLAbsolute, getCachedIntl, getCookie, getLocaleFromStorage, getLocaleFromStorageClient, getLocaleFromStorageServer, isSameKeyPath, isValidElement, localeStorageOptions, parseYaml, setLocaleInStorage, setLocaleInStorageClient, setLocaleInStorageServer, stringifyYaml };
+export { CachedIntl, CachedIntl as Intl, CookieBuildAttributes, LocaleStorage, LocaleStorageClient, LocaleStorageClientOptions, LocaleStorageOptions, LocaleStorageServer, LocaleStorageServerOptions, WrappedIntl, YamlRecord, YamlValue, bindIntl, checkIsURLAbsolute, getCachedIntl, getCookie, getLocaleFromStorage, getLocaleFromStorageClient, getLocaleFromStorageServer, isSameKeyPath, isValidElement, localeStorageOptions, parseYaml, setLocaleInStorage, setLocaleInStorageClient, setLocaleInStorageServer, stringifyYaml };

package/dist/types/utils/parseYaml.d.ts

@@ -1,5 +1,15 @@
 //#region src/utils/parseYaml.d.ts
-declare const parseYaml: <T = any>(input: string) => T | null;
+interface YamlRecord {
+  [key: string]: YamlValue;
+}
+type YamlValue = string | number | YamlValue[] | YamlRecord;
+/**
+ * Parses a YAML/JSON-like string into a typed value.
+ * Supports scalars, quoted strings, inline arrays/objects, and indented YAML syntax.
+ * Boolean/null literals (true, false, null, yes, no, etc.) are preserved as strings,
+ * not coerced to their native JS equivalents.
+ */
+declare const parseYaml: <T = YamlValue>(input: string) => T | null;
 //#endregion
-export { parseYaml };
+export { YamlRecord, YamlValue, parseYaml };
 //# sourceMappingURL=parseYaml.d.ts.map

package/dist/types/utils/parseYaml.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parseYaml.d.ts","names":[],"sources":["../../../src/utils/parseYaml.ts"],"mappings":";cAca,SAAA,YAAsB,KAAA,aAAgB,CAAA"}
+{"version":3,"file":"parseYaml.d.ts","names":[],"sources":["../../../src/utils/parseYaml.ts"],"mappings":";UAciB,UAAA;EAAA,CACd,GAAA,WAAc,SAAA;AAAA;AAAA,KAEL,SAAA,qBAA8B,SAAA,KAAc,UAAA;;;AAAxD;;;;cAQa,SAAA,OAAiB,SAAA,EAAW,KAAA,aAAgB,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intlayer/core",
-  "version": "8.12.5-canary.0",
+  "version": "9.0.0-canary.1",
   "private": false,
   "description": "Includes core Intlayer functions like translation, dictionary, and utility functions shared across multiple packages.",
   "keywords": [
@@ -172,22 +172,22 @@
     "typecheck": "tsc --noEmit --project tsconfig.types.json"
   },
   "dependencies": {
-    "@intlayer/api": "8.12.5-canary.0",
-    "@intlayer/config": "8.12.5-canary.0",
-    "@intlayer/dictionaries-entry": "8.12.5-canary.0",
-    "@intlayer/types": "8.12.5-canary.0",
-    "@intlayer/unmerged-dictionaries-entry": "8.12.5-canary.0",
+    "@intlayer/api": "9.0.0-canary.1",
+    "@intlayer/config": "9.0.0-canary.1",
+    "@intlayer/dictionaries-entry": "9.0.0-canary.1",
+    "@intlayer/types": "9.0.0-canary.1",
+    "@intlayer/unmerged-dictionaries-entry": "9.0.0-canary.1",
     "defu": "6.1.7"
   },
   "devDependencies": {
-    "@types/node": "25.9.2",
+    "@types/node": "25.9.3",
     "@utils/ts-config": "1.0.4",
     "@utils/ts-config-types": "1.0.4",
     "@utils/tsdown-config": "1.0.4",
     "rimraf": "6.1.3",
     "tsdown": "0.21.10",
     "typescript": "6.0.3",
-    "vitest": "4.1.8"
+    "vitest": "4.1.9"
   },
   "engines": {
     "node": ">=14.18"