@intlayer/core 9.0.0-canary.0 → 9.0.0-canary.10

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

@@ -3,19 +3,32 @@ 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.
+ * 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", "meta", "item"];
+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.
  */
 declare const COMPOSITE_ID_SEPARATOR = "/";
+/**
+ * Canonical serialization of a variant value into its identity string — the
+ * variant segment of a composite id and the runtime matching key.
+ *
+ * - `undefined` → `'default'` (the implicit fallback variant)
+ * - a string → the string itself (a named variant)
+ * - an object → its sorted `key=value` pairs joined by `&`
+ *   (e.g. `{ userId: '123', id: 'abc' }` → `'id=abc&userId=123'`)
+ *
+ * Two variants resolve to the same entry iff their serializations are equal, so
+ * an object variant in a selector must equal the one declared on the dictionary.
+ */
+declare const serializeVariant: (variant: string | Record<string, string | number> | undefined) => string;
 /**
  * Returns the qualifier dimensions declared on a dictionary, in canonical
- * order (`variant → meta → item`). Empty when the dictionary is unqualified
+ * 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[];
@@ -23,8 +36,7 @@ declare const getDictionaryQualifierTypes: (dictionary: Dictionary) => Dictionar
  * 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
+ * - 'variant' → the serialized variant (named string or object identity)
  * - 'item' → the item index as string
  */
 declare const getDictionaryQualifierId: (dictionary: Dictionary, qualifierType: DictionaryQualifierType) => string | undefined;
@@ -48,12 +60,13 @@ declare const isQualifiedDictionaryGroup: (value: unknown) => value is Qualified
 /**
  * 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.
+ * qualifier coordinates decoded from that id (`variant`, `item`).
  *
  * 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.
+ * `{ key, content, variant?, item? }` shape, even though the stored format no
+ * longer duplicates those fields per entry. The `variant` coordinate stays in
+ * its serialized form (e.g. `'id=abc&userId=123'`), which round-trips through
+ * {@link serializeVariant} during matching.
  */
 declare const reconstructQualifiedEntry: (group: QualifiedDictionaryGroup, compositeId: string) => Dictionary;
 /**
@@ -63,8 +76,8 @@ declare const reconstructQualifiedEntry: (group: QualifiedDictionaryGroup, compo
  * - 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
+ * - `variant` defaults to the `default` entry when not selected; an object
+ *   variant resolves only when the selector provides an equal object
  *
  * Dimensions compose: e.g. a variant × item key with `{ variant: 'promo' }`
  * returns every promo item as an array; adding `{ item: 2 }` narrows to one.
@@ -119,7 +132,7 @@ type QualifiedDynamicLoaderMap = {
 };
 /**
  * Type guard discriminating a qualified dynamic loader map (collections /
- * variants / meta records, possibly combined) from a plain dynamic loader map.
+ * variants, possibly combined) from a plain dynamic loader map.
  */
 declare const isQualifiedDynamicLoaderMap: (value: unknown) => value is QualifiedDynamicLoaderMap;
 /**
@@ -127,11 +140,11 @@ declare const isQualifiedDynamicLoaderMap: (value: unknown) => value is Qualifie
  * 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.
+ * `variant → item`): `variant` defaults to `default` (or descends by the
+ * serialized object identity), 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
@@ -172,5 +185,5 @@ declare const resolveQualifiedDynamicContentAsync: <Content>(params: {
   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 };
+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, serializeVariant };
 //# 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":";;;;;;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"}
+{"version":3,"file":"qualifiedDictionary.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/qualifiedDictionary.ts"],"mappings":";;;;;;AAaA;;;cAAa,eAAA;;AASb;;;cAAa,sBAAA;;AAcb;;;;;AAiBA;;;;;;cAjBa,gBAAA,GACX,OAAA,WAAkB,MAAA;;;AAkCpB;;;cAlBa,2BAAA,GACX,UAAA,EAAY,UAAA,KACX,uBAAA;;;;;;;AAiCH;cAjBa,wBAAA,GACX,UAAA,EAAY,UAAA,EACZ,aAAA,EAAe,uBAAA;;;;;;cAeJ,8BAAA,GACX,UAAA,EAAY,UAAA,EACZ,cAAA,EAAgB,uBAAA;;;AAiBlB;;cAAa,wBAAA,GACX,UAAA,EAAY,UAAA,EACZ,cAAA,EAAgB,uBAAA;;;;;;cAmCL,0BAAA,GACX,KAAA,cACC,KAAA,IAAS,wBAAA;;AAFZ;;;;;;;;;AAoBA;cAAa,yBAAA,GACX,KAAA,EAAO,wBAAA,EACP,WAAA,aACC,UAAA;;;;;;;;;AAgCH;;;;;cAAa,0BAAA,GACX,iBAAA,EAAmB,UAAA,GAAa,wBAAA,EAChC,QAAA,GAAW,kBAAA,KACV,UAAA,GAAa,UAAA;;;;;cA6BH,uBAAA,aAAqC,aAAA,EAChD,gBAAA,GAAmB,CAAA,GAAI,kBAAA;EACpB,MAAA,GAAS,CAAA;EAAG,QAAA,GAAW,kBAAA;AAAA;;;;;cAef,6BAAA,GACX,QAAA,GAAW,kBAAA;AAlBb;;;;;;AAAA,cA0Ca,2BAAA;;;;KAKD,uBAAA,SAAgC,OAAA,CAAQ,UAAA;;;;;KAMxC,0BAAA;EAAA,CACT,OAAA,WAAkB,0BAAA,GAA6B,uBAAA;AAAA;;;;AArClD;;;;;AAyBA;;;;KA2BY,yBAAA;EAAA,CACT,2BAAA,GAA8B,uBAAA;EAAA,CAC9B,MAAA,WAAiB,0BAAA,GAA6B,uBAAA;AAAA;;;AAlBjD;;cAyBa,2BAAA,GACX,KAAA,cACC,KAAA,IAAS,yBAAA;;;;;;;AAXZ;;;;;;;;;;;;;;;;AASA;cA+Ga,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;;;;;;;;;;;AAAA,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

@@ -46,7 +46,7 @@ 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 { COMPOSITE_ID_SEPARATOR, DynamicDictionaryLoader, QUALIFIER_DYNAMIC_TYPES_KEY, QUALIFIER_ORDER, QualifiedDynamicLoaderMap, QualifiedDynamicLoaderTree, getDictionaryCompositeId, getDictionaryQualifierId, getDictionaryQualifierSegments, getDictionaryQualifierTypes, getDictionarySelectorCacheKey, isQualifiedDictionaryGroup, isQualifiedDynamicLoaderMap, parseDictionarySelector, reconstructQualifiedEntry, resolveQualifiedDictionary, resolveQualifiedDynamicContent, resolveQualifiedDynamicContentAsync, serializeVariant } from "./dictionaryManipulator/qualifiedDictionary.js";
 import { removeContentNodeByKeyPath } from "./dictionaryManipulator/removeContentNodeByKeyPath.js";
 import { renameContentNodeByKeyPath } from "./dictionaryManipulator/renameContentNodeByKeyPath.js";
 import { updateNodeChildren } from "./dictionaryManipulator/updateNodeChildren.js";
@@ -59,6 +59,7 @@ import { number } from "./formatters/number.js";
 import { percentage } from "./formatters/percentage.js";
 import { relativeTime } from "./formatters/relativeTime.js";
 import { units } from "./formatters/units.js";
+import { comparePaths, normalizePath } from "./localization/comparePaths.js";
 import { GenerateSitemapOptions, SitemapUrlEntry, generateSitemap, generateSitemapUrl } from "./localization/generateSitemap.js";
 import { getBrowserLocale } from "./localization/getBrowserLocale.js";
 import { getHTMLTextDir } from "./localization/getHTMLTextDir.js";
@@ -93,4 +94,4 @@ 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 { 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, 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 };
+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, comparePaths, 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, normalizePath, 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, serializeVariant, 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

@@ -6,14 +6,14 @@ import { DeclaredLocales, ExtractSelectorLocale, LocalesValues } from "@intlayer
 /**
  * Transforms a dictionary in a single pass, applying each plugin as needed.
  *
- * 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.
+ * Also accepts a `QualifiedDictionaryGroup` (collections, variants) together
+ * with a selector as second argument — the group is resolved to a single entry
+ * (or an ordered array of entries for collections without an `item` selector)
+ * before transformation.
  *
  * @param dictionary The dictionary (or qualified dictionary group) to transform.
  * @param localeOrSelector The locale, or a selector object (`{ item }`,
- *                         `{ variant }`, `{ id, ...meta }`, optionally with `locale`).
+ *                         `{ variant }`, 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.
  */

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

@@ -10,7 +10,7 @@ import { DeclaredLocales, DictionaryKeys, DictionaryRegistryResult, ExtractSelec
  * 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
+ * - `{ variant: { id: 'prod_abc', userId: '123' } }` — structured variant
  * - `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>>;

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

@@ -1,6 +1,6 @@
 import { PluralContentState } from "../transpiler/plural/plural.js";
-import { LocalesValues } from "../intlayer/dist/types/index.js";
 import { DeclaredLocales } from "@intlayer/types";
+import { LocalesValues } from "intlayer";
 
 //#region src/interpreter/getPlural.d.ts
 /**

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

@@ -0,0 +1,66 @@
+import { DeclaredLocales, LocalesValues } from "@intlayer/types/module_augmentation";
+
+//#region src/localization/comparePaths.d.ts
+/**
+ * Normalizes a URL or pathname into a canonical, locale-agnostic pathname so
+ * that two paths pointing to the same page compare equal — useful for
+ * highlighting the active navigation link.
+ *
+ * The normalization:
+ * - strips the locale segment (reusing {@link getPathWithoutLocale})
+ * - strips the protocol/host so absolute and relative inputs compare equally
+ * - drops the query string and hash
+ * - ensures a single leading slash
+ * - removes any trailing slash (except for the root path)
+ * - falls back to `'/'` for empty values
+ *
+ * Example:
+ *
+ * ```ts
+ * normalizePath('/ru/path')                    // '/path'
+ * normalizePath('/ru/path/')                   // '/path'
+ * normalizePath('ru/path')                     // '/path'
+ * normalizePath('/ru/')                        // '/'
+ * normalizePath('/ru')                         // '/'
+ * normalizePath('')                            // '/'
+ * normalizePath('https://example.com/ru/path') // '/path'
+ * ```
+ *
+ * @param inputUrl - The URL string or pathname to normalize.
+ * @param locales - Optional array of supported locales. Defaults to the
+ *   configured locales.
+ * @returns The normalized, locale-agnostic pathname.
+ */
+declare const normalizePath: <const L extends LocalesValues = DeclaredLocales>(inputUrl: string, locales?: L[]) => string;
+/**
+ * Compares two URLs or pathnames for equality, ignoring locale segment,
+ * protocol/host, query string, hash and trailing slashes.
+ *
+ * Both inputs are normalized through {@link normalizePath} before comparison,
+ * making this ideal for matching the current pathname against a navigation
+ * link's `href`.
+ *
+ * Example:
+ *
+ * ```ts
+ * comparePaths('/ru/path', '/path')   // true
+ * comparePaths('/ru/path/', '/path')  // true
+ * comparePaths('/ru/path', '/path/')  // true
+ * comparePaths('/ru/', '/')           // true
+ * comparePaths('/ru', '/')            // true
+ * comparePaths('ru/path', '/path')    // true
+ * comparePaths('', '/')               // true
+ * comparePaths('/ru', '')             // true
+ * comparePaths('/ru/path', '/other')  // false
+ * ```
+ *
+ * @param pathname - The first URL string or pathname to compare.
+ * @param href - The second URL string or pathname to compare.
+ * @param locales - Optional array of supported locales. Defaults to the
+ *   configured locales.
+ * @returns `true` when both inputs resolve to the same locale-agnostic path.
+ */
+declare const comparePaths: <const L extends LocalesValues = DeclaredLocales>(pathname: string, href: string, locales?: L[]) => boolean;
+//#endregion
+export { comparePaths, normalizePath };
+//# sourceMappingURL=comparePaths.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"comparePaths.d.ts","names":[],"sources":["../../../src/localization/comparePaths.ts"],"mappings":";;;;;AAqCA;;;;;;;;;;;;;;;;AAiDA;;;;;;;;;;;;cAjDa,aAAA,mBAAiC,aAAA,GAAgB,eAAA,EAC5D,QAAA,UACA,OAAA,GAAU,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+CC,YAAA,mBAAgC,aAAA,GAAgB,eAAA,EAC3D,QAAA,UACA,IAAA,UACA,OAAA,GAAU,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/localization/index.d.ts

@@ -1,3 +1,4 @@
+import { comparePaths, normalizePath } from "./comparePaths.js";
 import { GenerateSitemapOptions, SitemapUrlEntry, generateSitemap, generateSitemapUrl } from "./generateSitemap.js";
 import { getBrowserLocale } from "./getBrowserLocale.js";
 import { getHTMLTextDir } from "./getHTMLTextDir.js";
@@ -14,4 +15,4 @@ import { localeFlatMap, localeMap, localeRecord } from "./localeMapper.js";
 import { localeResolver } from "./localeResolver.js";
 import { LocalizedPathResult, getCanonicalPath, getInternalPath, getLocalizedPath, getRewritePath, getRewriteRules } from "./rewriteUtils.js";
 import { validatePrefix } from "./validatePrefix.js";
-export { type GenerateSitemapOptions, type GetPrefixOptions, type GetPrefixResult, type LocalizedPathResult, type SitemapUrlEntry, generateSitemap, generateSitemapUrl, getBrowserLocale, getCanonicalPath, getHTMLTextDir, getInternalPath, getLocale, getLocaleFromPath, getLocaleLang, getLocaleName, getLocalizedPath, getLocalizedUrl, getMultilingualUrls, getPathWithoutLocale, getPrefix, getRewritePath, getRewriteRules, localeDetector, localeFlatMap, localeMap, localeRecord, localeResolver, validatePrefix };
+export { type GenerateSitemapOptions, type GetPrefixOptions, type GetPrefixResult, type LocalizedPathResult, type SitemapUrlEntry, comparePaths, generateSitemap, generateSitemapUrl, getBrowserLocale, getCanonicalPath, getHTMLTextDir, getInternalPath, getLocale, getLocaleFromPath, getLocaleLang, getLocaleName, getLocalizedPath, getLocalizedUrl, getMultilingualUrls, getPathWithoutLocale, getPrefix, getRewritePath, getRewriteRules, localeDetector, localeFlatMap, localeMap, localeRecord, localeResolver, normalizePath, validatePrefix };

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intlayer/core",
-  "version": "9.0.0-canary.0",
+  "version": "9.0.0-canary.10",
   "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": "9.0.0-canary.0",
-    "@intlayer/config": "9.0.0-canary.0",
-    "@intlayer/dictionaries-entry": "9.0.0-canary.0",
-    "@intlayer/types": "9.0.0-canary.0",
-    "@intlayer/unmerged-dictionaries-entry": "9.0.0-canary.0",
+    "@intlayer/api": "9.0.0-canary.10",
+    "@intlayer/config": "9.0.0-canary.10",
+    "@intlayer/dictionaries-entry": "9.0.0-canary.10",
+    "@intlayer/types": "9.0.0-canary.10",
+    "@intlayer/unmerged-dictionaries-entry": "9.0.0-canary.10",
     "defu": "6.1.7"
   },
   "devDependencies": {
-    "@types/node": "25.9.3",
+    "@types/node": "25.9.4",
     "@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"

package/dist/cjs/interpreter/getCollection.cjs

@@ -1,25 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
-//#region src/interpreter/getCollection.ts
-/**
-* Picks a single item from a resolved collection array, or returns the full
-* array when no index is requested.
-*
-* @param items - The already-resolved collection items.
-* @param itemIndex - Optional 0-based index of the item to retrieve.
-* @returns The item at `itemIndex`, or the full array when no index is given.
-*
-* @example
-* ```ts
-* const all  = getCollection(['a', 'b', 'c']);      // ['a', 'b', 'c']
-* const one  = getCollection(['a', 'b', 'c'], 1);   // 'b'
-* ```
-*/
-const getCollection = (items, itemIndex) => {
-	if (itemIndex === void 0 || itemIndex === null) return items;
-	return items[itemIndex];
-};
-
-//#endregion
-exports.getCollection = getCollection;
-//# sourceMappingURL=getCollection.cjs.map

package/dist/cjs/interpreter/getCollection.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"getCollection.cjs","names":[],"sources":["../../../src/interpreter/getCollection.ts"],"sourcesContent":["/**\n * Picks a single item from a resolved collection array, or returns the full\n * array when no index is requested.\n *\n * @param items - The already-resolved collection items.\n * @param itemIndex - Optional 0-based index of the item to retrieve.\n * @returns The item at `itemIndex`, or the full array when no index is given.\n *\n * @example\n * ```ts\n * const all  = getCollection(['a', 'b', 'c']);      // ['a', 'b', 'c']\n * const one  = getCollection(['a', 'b', 'c'], 1);   // 'b'\n * ```\n */\nexport const getCollection = <T>(items: T[], itemIndex?: number): T | T[] => {\n  if (itemIndex === undefined || itemIndex === null) {\n    return items;\n  }\n\n  return items[itemIndex] as T;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;AAcA,MAAa,iBAAoB,OAAY,cAAgC;AAC3E,KAAI,cAAc,UAAa,cAAc,KAC3C,QAAO;AAGT,QAAO,MAAM"}

package/dist/cjs/interpreter/getVariant.cjs

@@ -1,30 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
-//#region src/interpreter/getVariant.ts
-/**
-* Resolves a variant node to its selected alternative.
-*
-* Falls back to `control` when the requested `variantKey` does not exist in
-* the node or when no key is specified.
-*
-* @param variantContent - The map of variant alternatives.
-* @param variantKey - Optional name of the alternative to select.
-* @returns The resolved content for the requested variant.
-*
-* @example
-* ```ts
-* const node = { control: 'Welcome', black_friday: 'Up to 50% off' };
-*
-* getVariant(node);                   // 'Welcome'
-* getVariant(node, 'black_friday');   // 'Up to 50% off'
-* getVariant(node, 'nonexistent');    // 'Welcome'  (fallback to control)
-* ```
-*/
-const getVariant = (variantContent, variantKey) => {
-	if (variantKey && variantKey in variantContent) return variantContent[variantKey];
-	return variantContent.control;
-};
-
-//#endregion
-exports.getVariant = getVariant;
-//# sourceMappingURL=getVariant.cjs.map

package/dist/cjs/interpreter/getVariant.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"getVariant.cjs","names":[],"sources":["../../../src/interpreter/getVariant.ts"],"sourcesContent":["import type { VariantContentState } from '../transpiler/variant/variant';\n\n/**\n * Resolves a variant node to its selected alternative.\n *\n * Falls back to `control` when the requested `variantKey` does not exist in\n * the node or when no key is specified.\n *\n * @param variantContent - The map of variant alternatives.\n * @param variantKey - Optional name of the alternative to select.\n * @returns The resolved content for the requested variant.\n *\n * @example\n * ```ts\n * const node = { control: 'Welcome', black_friday: 'Up to 50% off' };\n *\n * getVariant(node);                   // 'Welcome'\n * getVariant(node, 'black_friday');   // 'Up to 50% off'\n * getVariant(node, 'nonexistent');    // 'Welcome'  (fallback to control)\n * ```\n */\nexport const getVariant = <T>(\n  variantContent: VariantContentState<T>,\n  variantKey?: string\n): T => {\n  if (variantKey && variantKey in variantContent) {\n    return variantContent[variantKey] as T;\n  }\n\n  return variantContent.control as T;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAqBA,MAAa,cACX,gBACA,eACM;AACN,KAAI,cAAc,cAAc,eAC9B,QAAO,eAAe;AAGxB,QAAO,eAAe"}

package/dist/cjs/transpiler/collection/collection.cjs

@@ -1,32 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_runtime = require('../../_virtual/_rolldown/runtime.cjs');
-let _intlayer_types_nodeType = require("@intlayer/types/nodeType");
-
-//#region src/transpiler/collection/collection.ts
-/**
-* Declares an ordered list of content items inside a dictionary.
-*
-* At runtime, `useIntlayer('my-key')` returns all items as an array.
-* `useIntlayer('my-key', { item: 2 })` returns only the item at index 2.
-*
-* @example
-* ```ts
-* import { t, collection } from 'intlayer';
-*
-* export default {
-*   key: 'faq',
-*   content: collection([
-*     { question: t({ en: 'What is Intlayer?' }), answer: t({ en: '...' }) },
-*     { question: t({ en: 'Is it free?' }),       answer: t({ en: '...' }) },
-*   ]),
-* } satisfies Dictionary;
-* ```
-*/
-const collection = (items) => ({
-	nodeType: _intlayer_types_nodeType.COLLECTION,
-	collection: items
-});
-
-//#endregion
-exports.collection = collection;
-//# sourceMappingURL=collection.cjs.map

package/dist/cjs/transpiler/collection/collection.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"collection.cjs","names":["COLLECTION"],"sources":["../../../../src/transpiler/collection/collection.ts"],"sourcesContent":["import { COLLECTION } from '@intlayer/types/nodeType';\n\n/**\n * Shape of a collection node stored in the dictionary JSON.\n * Items may contain any other node type (translations, conditions, etc.).\n */\nexport type CollectionContent<T = unknown> = {\n  nodeType: typeof COLLECTION;\n  collection: T[];\n};\n\n/**\n * Declares an ordered list of content items inside a dictionary.\n *\n * At runtime, `useIntlayer('my-key')` returns all items as an array.\n * `useIntlayer('my-key', { item: 2 })` returns only the item at index 2.\n *\n * @example\n * ```ts\n * import { t, collection } from 'intlayer';\n *\n * export default {\n *   key: 'faq',\n *   content: collection([\n *     { question: t({ en: 'What is Intlayer?' }), answer: t({ en: '...' }) },\n *     { question: t({ en: 'Is it free?' }),       answer: t({ en: '...' }) },\n *   ]),\n * } satisfies Dictionary;\n * ```\n */\nexport const collection = <T>(items: T[]): CollectionContent<T> => ({\n  nodeType: COLLECTION,\n  collection: items,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AA8BA,MAAa,cAAiB,WAAsC;CAClE,UAAUA;CACV,YAAY;CACb"}

package/dist/cjs/transpiler/collection/index.cjs

@@ -1,4 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_transpiler_collection_collection = require('./collection.cjs');
-
-exports.collection = require_transpiler_collection_collection.collection;

package/dist/cjs/transpiler/variant/index.cjs

@@ -1,4 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_transpiler_variant_variant = require('./variant.cjs');
-
-exports.variant = require_transpiler_variant_variant.variant;

package/dist/cjs/transpiler/variant/variant.cjs

@@ -1,35 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_runtime = require('../../_virtual/_rolldown/runtime.cjs');
-let _intlayer_types_nodeType = require("@intlayer/types/nodeType");
-
-//#region src/transpiler/variant/variant.ts
-/**
-* Declares a set of named content alternatives for A/B testing or feature flags.
-*
-* The `control` key is mandatory and acts as the default when no variant is
-* selected. At runtime, `useIntlayer('my-key')` returns the `control` variant.
-* `useIntlayer('my-key', { variant: 'black_friday' })` returns that variant.
-*
-* @example
-* ```ts
-* import { t, variant } from 'intlayer';
-*
-* export default {
-*   key: 'hero-banner',
-*   content: {
-*     headline: variant({
-*       control:      t({ en: 'Welcome',       fr: 'Bienvenue'       }),
-*       black_friday: t({ en: 'Up to 50% off', fr: 'Jusqu\'à -50 %'  }),
-*     }),
-*   },
-* } satisfies Dictionary;
-* ```
-*/
-const variant = (variants) => ({
-	nodeType: _intlayer_types_nodeType.VARIANT,
-	variant: variants
-});
-
-//#endregion
-exports.variant = variant;
-//# sourceMappingURL=variant.cjs.map

package/dist/cjs/transpiler/variant/variant.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"variant.cjs","names":["VARIANT"],"sources":["../../../../src/transpiler/variant/variant.ts"],"sourcesContent":["import { VARIANT } from '@intlayer/types/nodeType';\n\n/**\n * Shape of a variant node stored in the dictionary JSON.\n * `control` is the mandatory default/fallback key; all other keys are\n * optional named experiment branches.\n */\nexport type VariantContentState<T = unknown> = { control: T } & Record<\n  string,\n  T\n>;\n\nexport type VariantContent<T = unknown> = {\n  nodeType: typeof VARIANT;\n  variant: VariantContentState<T>;\n};\n\n/**\n * Declares a set of named content alternatives for A/B testing or feature flags.\n *\n * The `control` key is mandatory and acts as the default when no variant is\n * selected. At runtime, `useIntlayer('my-key')` returns the `control` variant.\n * `useIntlayer('my-key', { variant: 'black_friday' })` returns that variant.\n *\n * @example\n * ```ts\n * import { t, variant } from 'intlayer';\n *\n * export default {\n *   key: 'hero-banner',\n *   content: {\n *     headline: variant({\n *       control:      t({ en: 'Welcome',       fr: 'Bienvenue'       }),\n *       black_friday: t({ en: 'Up to 50% off', fr: 'Jusqu\\'à -50 %'  }),\n *     }),\n *   },\n * } satisfies Dictionary;\n * ```\n */\nexport const variant = <T>(\n  variants: { control: T } & Partial<Record<string, T>>\n): VariantContent<T> => ({\n  nodeType: VARIANT,\n  variant: variants as VariantContentState<T>,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,MAAa,WACX,cACuB;CACvB,UAAUA;CACV,SAAS;CACV"}

package/dist/esm/interpreter/getCollection.mjs

@@ -1,23 +0,0 @@
-//#region src/interpreter/getCollection.ts
-/**
-* Picks a single item from a resolved collection array, or returns the full
-* array when no index is requested.
-*
-* @param items - The already-resolved collection items.
-* @param itemIndex - Optional 0-based index of the item to retrieve.
-* @returns The item at `itemIndex`, or the full array when no index is given.
-*
-* @example
-* ```ts
-* const all  = getCollection(['a', 'b', 'c']);      // ['a', 'b', 'c']
-* const one  = getCollection(['a', 'b', 'c'], 1);   // 'b'
-* ```
-*/
-const getCollection = (items, itemIndex) => {
-	if (itemIndex === void 0 || itemIndex === null) return items;
-	return items[itemIndex];
-};
-
-//#endregion
-export { getCollection };
-//# sourceMappingURL=getCollection.mjs.map

package/dist/esm/interpreter/getCollection.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"getCollection.mjs","names":[],"sources":["../../../src/interpreter/getCollection.ts"],"sourcesContent":["/**\n * Picks a single item from a resolved collection array, or returns the full\n * array when no index is requested.\n *\n * @param items - The already-resolved collection items.\n * @param itemIndex - Optional 0-based index of the item to retrieve.\n * @returns The item at `itemIndex`, or the full array when no index is given.\n *\n * @example\n * ```ts\n * const all  = getCollection(['a', 'b', 'c']);      // ['a', 'b', 'c']\n * const one  = getCollection(['a', 'b', 'c'], 1);   // 'b'\n * ```\n */\nexport const getCollection = <T>(items: T[], itemIndex?: number): T | T[] => {\n  if (itemIndex === undefined || itemIndex === null) {\n    return items;\n  }\n\n  return items[itemIndex] as T;\n};\n"],"mappings":";;;;;;;;;;;;;;;AAcA,MAAa,iBAAoB,OAAY,cAAgC;AAC3E,KAAI,cAAc,UAAa,cAAc,KAC3C,QAAO;AAGT,QAAO,MAAM"}

package/dist/esm/interpreter/getVariant.mjs

@@ -1,28 +0,0 @@
-//#region src/interpreter/getVariant.ts
-/**
-* Resolves a variant node to its selected alternative.
-*
-* Falls back to `control` when the requested `variantKey` does not exist in
-* the node or when no key is specified.
-*
-* @param variantContent - The map of variant alternatives.
-* @param variantKey - Optional name of the alternative to select.
-* @returns The resolved content for the requested variant.
-*
-* @example
-* ```ts
-* const node = { control: 'Welcome', black_friday: 'Up to 50% off' };
-*
-* getVariant(node);                   // 'Welcome'
-* getVariant(node, 'black_friday');   // 'Up to 50% off'
-* getVariant(node, 'nonexistent');    // 'Welcome'  (fallback to control)
-* ```
-*/
-const getVariant = (variantContent, variantKey) => {
-	if (variantKey && variantKey in variantContent) return variantContent[variantKey];
-	return variantContent.control;
-};
-
-//#endregion
-export { getVariant };
-//# sourceMappingURL=getVariant.mjs.map

package/dist/esm/interpreter/getVariant.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"getVariant.mjs","names":[],"sources":["../../../src/interpreter/getVariant.ts"],"sourcesContent":["import type { VariantContentState } from '../transpiler/variant/variant';\n\n/**\n * Resolves a variant node to its selected alternative.\n *\n * Falls back to `control` when the requested `variantKey` does not exist in\n * the node or when no key is specified.\n *\n * @param variantContent - The map of variant alternatives.\n * @param variantKey - Optional name of the alternative to select.\n * @returns The resolved content for the requested variant.\n *\n * @example\n * ```ts\n * const node = { control: 'Welcome', black_friday: 'Up to 50% off' };\n *\n * getVariant(node);                   // 'Welcome'\n * getVariant(node, 'black_friday');   // 'Up to 50% off'\n * getVariant(node, 'nonexistent');    // 'Welcome'  (fallback to control)\n * ```\n */\nexport const getVariant = <T>(\n  variantContent: VariantContentState<T>,\n  variantKey?: string\n): T => {\n  if (variantKey && variantKey in variantContent) {\n    return variantContent[variantKey] as T;\n  }\n\n  return variantContent.control as T;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAqBA,MAAa,cACX,gBACA,eACM;AACN,KAAI,cAAc,cAAc,eAC9B,QAAO,eAAe;AAGxB,QAAO,eAAe"}