@intlayer/core 9.3.2 → 9.4.0-canary.0

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

@@ -0,0 +1,38 @@
+import { Dictionary } from "@intlayer/types/dictionary";
+import { LocalesValues } from "@intlayer/types/module_augmentation";
+import { PRELOADED_DYNAMIC_KEY } from "@intlayer/config/defaultValues";
+//#region src/dictionaryManipulator/preloadedDynamicLoader.d.ts
+/**
+ * The value attached under {@link PRELOADED_DYNAMIC_KEY}.
+ *
+ * `locale` is the locale the preamble resolved at module-evaluation time. It is
+ * compared against the locale the read actually asks for, so a disagreement
+ * (a client-side locale switch, or a resolution the provider overrode) falls
+ * back to loading rather than serving content in the wrong language.
+ */
+type PreloadedDynamicEntry = {
+  locale: LocalesValues;
+  dictionary: Dictionary;
+};
+/** A plain dynamic loader map that may carry a preloaded entry. */
+type PreloadableDynamicLoaderMap = {
+  [PRELOADED_DYNAMIC_KEY]?: PreloadedDynamicEntry;
+};
+/**
+ * Reads the preloaded dictionary of a dynamic loader map, when one was resolved
+ * for the requested locale.
+ *
+ * Deliberately synchronous, and deliberately not routed through the suspender
+ * cache: a suspender only leaves `pending` inside a `.then` callback, so feeding
+ * it an already-resolved promise would still suspend for one microtask — long
+ * enough for a pending fallback to paint, which is the flash this whole
+ * mechanism exists to remove.
+ *
+ * @param loaderMap - Default export of a generated dynamic entry point.
+ * @param locale - Locale the caller is about to render.
+ * @returns The dictionary when it was preloaded for `locale`, else `undefined`.
+ */
+declare const getPreloadedDictionary: (loaderMap: unknown, locale: LocalesValues) => Dictionary | undefined;
+//#endregion
+export { PRELOADED_DYNAMIC_KEY, PreloadableDynamicLoaderMap, PreloadedDynamicEntry, getPreloadedDictionary };
+//# sourceMappingURL=preloadedDynamicLoader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"preloadedDynamicLoader.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/preloadedDynamicLoader.ts"],"mappings":";;;;;;;;;;;;KAoBY;EACV,QAAQ;EACR,YAAY;;;KAIF;GACT,yBAAyB;;;;;;;;;;;;;;;;cAiBf,yBAAsB,oBACf,QACV,kBACP"}

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

@@ -1,12 +1,6 @@
 import { Dictionary, DictionaryQualifierType, DictionarySelector } from "@intlayer/types/dictionary";
+import { QUALIFIER_DYNAMIC_TYPES_KEY } from "@intlayer/config/defaultValues";
 //#region src/dictionaryManipulator/qualifiedDynamicLoader.d.ts
-/**
- * Marker property carrying the ordered qualifier dimensions on a dynamic loader
- * map. Its presence distinguishes a qualified group loader map (a nested tree
- * of chunks) from a plain dynamic loader map (one chunk per `locale`). Prefixed
- * and unlikely to collide with a real locale code.
- */
-declare const QUALIFIER_DYNAMIC_TYPES_KEY = "__intlayerQualifierTypes";
 /**
  * A lazily-imported per-locale dictionary chunk loader.
  */

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

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

package/dist/types/index.d.ts

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

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

@@ -1,5 +1,4 @@
-import { LocalesValues } from "@intlayer/types/module_augmentation";
-import { Locale } from "@intlayer/types/allLocales";
+import { DeclaredLocales, LocalesValues } from "@intlayer/types/module_augmentation";
 import { RoutingConfig } from "@intlayer/types/config";
 //#region src/localization/domainUtils.d.ts
 /**
@@ -52,7 +51,7 @@ declare const getDomainOrigin: (domain: string) => string;
  * @param domains - The configured locale → domain map.
  * @returns The exclusively mapped locale, or `undefined`.
  */
-declare const getLocaleFromDomain: (hostname: string, domains: LocaleDomainMap) => Locale | undefined;
+declare const getLocaleFromDomain: (hostname: string, domains: LocaleDomainMap) => DeclaredLocales | undefined;
 /**
  * Checks whether a locale is the only locale mapped to its configured domain.
  * When true, the domain alone identifies the locale and no URL prefix is needed.

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

@@ -1 +1 @@
-{"version":3,"file":"domainUtils.d.ts","names":[],"sources":["../../../src/localization/domainUtils.ts"],"mappings":";;;;;;;;KAQY,kBAAkB;;;;;;;;;;;;;;cAejB,oBAAiB;;;;;;;;;;;;;;;cAsBjB,kBAAe;;;;;;;;;;;;;;;;;cAmBf,sBAAmB,kBACd,SACP,oBACR;;;;;;;;;;;cAuBU,4BAAyB,QAC5B,eAAa,SACZ"}
+{"version":3,"file":"domainUtils.d.ts","names":[],"sources":["../../../src/localization/domainUtils.ts"],"mappings":";;;;;;;KAUY,kBAAkB;;;;;;;;;;;;;;cAejB,oBAAiB;;;;;;;;;;;;;;;cAsBjB,kBAAe;;;;;;;;;;;;;;;;;cAmBf,sBAAmB,kBACd,SACP,oBACR;;;;;;;;;;;cAuBU,4BAAyB,QAC5B,eAAa,SACZ"}

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

@@ -1 +1 @@
-{"version":3,"file":"getHTMLTextDir.d.ts","names":[],"sources":["../../../src/localization/getHTMLTextDir.ts"],"mappings":";;KAEK;;;;;;;;;;;;;;cAeQ,iBAAc,SAAa,kBAAgB"}
+{"version":3,"file":"getHTMLTextDir.d.ts","names":[],"sources":["../../../src/localization/getHTMLTextDir.ts"],"mappings":";;KAEK;;;;;;;;;;;;;;cA0BQ,iBAAc,SAAa,kBAAgB"}

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

@@ -1,10 +1,10 @@
-import { Locale } from "@intlayer/types/allLocales";
+import { DeclaredLocales } from "@intlayer/types/module_augmentation";
 //#region src/localization/getLocale.d.ts
 type RequestContext = {
   getHeader?: (name: string) => string | null | undefined;
   getCookie?: (name: string) => string | null | undefined;
 };
-declare const getLocale: (ctx?: RequestContext) => Promise<Locale>;
+declare const getLocale: (ctx?: RequestContext) => Promise<DeclaredLocales>;
 //#endregion
 export { RequestContext, getLocale };
 //# sourceMappingURL=getLocale.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getLocale.d.ts","names":[],"sources":["../../../src/localization/getLocale.ts"],"mappings":";;KAOY;EACV,aAAa;EACb,aAAa;;cAGF,YAAS,MAAe,mBAAsB,QAAQ"}
+{"version":3,"file":"getLocale.d.ts","names":[],"sources":["../../../src/localization/getLocale.ts"],"mappings":";;KAOY;EACV,aAAa;EACb,aAAa;;cAGF,YAAS,MACf,mBACJ,QAAQ"}

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

@@ -1,5 +1,5 @@
 import { RoutingOptions } from "./getPrefix.js";
-import { Locale } from "@intlayer/types/allLocales";
+import { DeclaredLocales } from "@intlayer/types/module_augmentation";
 //#region src/localization/getLocaleFromPath.d.ts
 /**
  * Extracts the locale segment from the given URL or pathname based on the routing mode.
@@ -13,7 +13,7 @@ import { Locale } from "@intlayer/types/allLocales";
  * @param inputUrl - The complete URL string or pathname to process.
  * @returns The detected locale, default locale (if fallback/implicit), or undefined.
  */
-declare const getLocaleFromPath: (inputUrl?: string, options?: RoutingOptions) => Locale | undefined;
+declare const getLocaleFromPath: (inputUrl?: string, options?: RoutingOptions) => DeclaredLocales | undefined;
 //#endregion
 export { getLocaleFromPath };
 //# sourceMappingURL=getLocaleFromPath.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getLocaleFromPath.d.ts","names":[],"sources":["../../../src/localization/getLocaleFromPath.ts"],"mappings":";;;;;;;;;;;;;;;cAgBa,oBAAiB,mBACZ,UACN,mBACT"}
+{"version":3,"file":"getLocaleFromPath.d.ts","names":[],"sources":["../../../src/localization/getLocaleFromPath.ts"],"mappings":";;;;;;;;;;;;;;;cAoBa,oBAAiB,mBACZ,UACN,mBACT"}

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

@@ -0,0 +1,47 @@
+import { RoutingOptions } from "./getPrefix.js";
+import { LocalesValues, LocalizedPathname, ResolvedDefaultLocale } from "@intlayer/types/module_augmentation";
+//#region src/localization/getLocalizedPath.d.ts
+/**
+ * Localizes an application path for a locale: resolves the `routing.rewrite`
+ * rules, then applies the locale representation of the routing mode — a path
+ * prefix, a `locale` search parameter, or nothing at all.
+ *
+ * Any query string and hash of the input are preserved.
+ *
+ * This is the relative half of {@link getLocalizedUrl}, which builds on it to
+ * add an origin and cross-domain routing. For a relative input both return the
+ * same value; this one never returns an absolute URL — the origin of an
+ * absolute input is dropped and only its path is localized.
+ *
+ * Use `resolveLocalizedPath` instead to apply the rewrite rules alone, without
+ * any locale representation.
+ *
+ * @example
+ * ```ts
+ * // routing: { mode: 'prefix-no-default', rewrite: { '/about': { fr: '/a-propos' } } }
+ * getLocalizedPath('/about', 'fr');       // '/fr/a-propos'
+ * getLocalizedPath('/about', 'en');       // '/about'  (default locale, no prefix)
+ * getLocalizedPath('/', 'fr');            // '/fr'
+ * getLocalizedPath('/contact', 'fr');     // '/fr/contact' (no rewrite rule matches)
+ * getLocalizedPath('https://intlayer.org/about', 'fr'); // '/fr/a-propos' (origin dropped)
+ *
+ * // Manual rules, bypassing the configuration
+ * getLocalizedPath('/contact', 'fr', {
+ *   rewrite: { '/contact': { fr: '/contactez-nous' } },
+ * });
+ * // '/fr/contactez-nous'
+ * ```
+ *
+ * @param canonicalPath - The internal application path (e.g. `/about`, `/product/123`).
+ *   An absolute URL is accepted; only its path, query and hash are kept.
+ * @param locale - The target locale. Defaults to the configured default locale.
+ * @param options - Routing overrides (`locales`, `defaultLocale`, `mode`, `rewrite`,
+ *   `domains`). Each one defaults to the project configuration. `domains` only
+ *   suppresses the prefix of a locale served from its own domain — the origin
+ *   itself is never emitted.
+ * @returns The localized path for the target locale.
+ */
+declare const getLocalizedPath: <const CanonicalPath extends string, const CurrentLocale extends LocalesValues = ResolvedDefaultLocale>(canonicalPath: CanonicalPath, locale?: CurrentLocale, options?: RoutingOptions) => LocalizedPathname<CanonicalPath, CurrentLocale>;
+//#endregion
+export { getLocalizedPath };
+//# sourceMappingURL=getLocalizedPath.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getLocalizedPath.d.ts","names":[],"sources":["../../../src/localization/getLocalizedPath.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA2Da,yBACL,oCACA,sBAAsB,gBAAgB,uBAAqB,eAElD,eAAa,SACpB,eAAa,UACZ,mBACR,kBAAkB,eAAe"}

package/dist/types/localization/getLocalizedPath.test-d.d.ts

@@ -0,0 +1 @@
+export {}

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

@@ -7,6 +7,10 @@ import { LocalesValues, LocalizedUrl, ResolvedDefaultLocale } from "@intlayer/ty
  *
  * This function gets the locales, default locale, and routing mode from the configuration if not provided.
  *
+ * The path itself is localized by {@link getLocalizedPath}; this function only
+ * resolves the origin to put in front of it — the one of an absolute input, or
+ * the domain mapped to the target locale.
+ *
  * Example:
  *
  * ```ts
@@ -47,5 +51,5 @@ import { LocalesValues, LocalizedUrl, ResolvedDefaultLocale } from "@intlayer/ty
  */
 declare const getLocalizedUrl: <const T extends string, const L extends LocalesValues = ResolvedDefaultLocale>(url: T, currentLocale?: L, options?: RoutingOptions) => LocalizedUrl<T, L>;
 //#endregion
-export { type RoutingOptions, getLocalizedUrl };
+export { getLocalizedUrl };
 //# sourceMappingURL=getLocalizedUrl.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getLocalizedUrl.d.ts","names":[],"sources":["../../../src/localization/getLocalizedUrl.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwEa,wBACL,wBACA,UAAU,gBAAgB,uBAAqB,KAEhD,GAAC,gBACS,GAAC,UACP,mBACR,aAAa,GAAG"}
+{"version":3,"file":"getLocalizedUrl.d.ts","names":[],"sources":["../../../src/localization/getLocalizedUrl.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA2Da,wBACL,wBACA,UAAU,gBAAgB,uBAAqB,KAEhD,GAAC,gBACS,GAAC,UACP,mBACR,aAAa,GAAG"}

package/dist/types/localization/getLocalizedUrl.test-d.d.ts

@@ -0,0 +1 @@
+export {}

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

@@ -1,6 +1,5 @@
 import { DeclaredLocales, LocalesValues, ResolvedDefaultLocale, ResolvedRoutingMode } from "@intlayer/types/module_augmentation";
-import { Locale } from "@intlayer/types/allLocales";
-import { RoutingConfig } from "@intlayer/types/config";
+import { RewriteRules, RoutingConfig } from "@intlayer/types/config";
 //#region src/localization/getPrefix.d.ts
 /**
  * Shared routing options used across all URL localization functions.
@@ -9,7 +8,7 @@ type RoutingOptions = {
   locales?: LocalesValues[];
   defaultLocale?: LocalesValues;
   mode?: RoutingConfig['mode'];
-  rewrite?: RoutingConfig['rewrite'];
+  rewrite?: RoutingConfig['rewrite'] | RewriteRules;
   domains?: RoutingConfig['domains'];
   /**
    * The hostname of the page currently being rendered (e.g. `'intlayer.org'`).
@@ -29,12 +28,25 @@ type RoutingOptions = {
  * Single source of truth for default routing config resolution across all localization functions.
  */
 declare const resolveRoutingConfig: (options?: RoutingOptions) => Omit<RoutingOptions, 'defaultLocale' | 'mode' | 'locales'> & {
-  defaultLocale: LocalesValues;
+  defaultLocale: DeclaredLocales;
   mode: RoutingConfig['mode'];
-  locales: LocalesValues[];
+  locales: DeclaredLocales[];
 };
+/**
+ * Narrows an arbitrary string to a declared locale by membership test.
+ *
+ * `locales` is typed as `DeclaredLocales[]`, so a plain `includes` rejects the
+ * `string` values that actually need testing (a URL segment, a query param, a
+ * stored value). This keeps the check honest and hands back a narrowed type
+ * instead of forcing a cast at every call site.
+ *
+ * @param value - The candidate locale, from a URL segment / storage / header.
+ * @param locales - The locales declared by the configuration.
+ * @returns Whether `value` is one of the declared locales.
+ */
+declare const isDeclaredLocale: (value: LocalesValues | undefined | null, locales?: readonly LocalesValues[]) => value is DeclaredLocales;
 type GetPrefixOptions = {
-  defaultLocale?: LocalesValues;
+  defaultLocale?: ResolvedDefaultLocale;
   mode?: RoutingConfig['mode'];
 };
 type GetPrefixResult = {
@@ -46,7 +58,7 @@ type GetPrefixResult = {
   /**
    * The bare locale identifier (e.g. `'fr'`), or `undefined` when no prefix is applied.
    */
-  localePrefix: Locale | undefined;
+  localePrefix: DeclaredLocales | undefined;
 };
 /**
  * Narrowed return type for {@link getPrefix} that carries the locale literal through.
@@ -108,5 +120,5 @@ type GetPrefixResultNarrowed<L extends LocalesValues | undefined, Mode extends s
  */
 declare const getPrefix: <const L extends LocalesValues | undefined>(locale: L, options?: RoutingOptions) => GetPrefixResultNarrowed<L>;
 //#endregion
-export { GetPrefixOptions, GetPrefixResult, GetPrefixResultNarrowed, RoutingOptions, getPrefix, resolveRoutingConfig };
+export { GetPrefixOptions, GetPrefixResult, GetPrefixResultNarrowed, RoutingOptions, getPrefix, isDeclaredLocale, resolveRoutingConfig };
 //# sourceMappingURL=getPrefix.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getPrefix.d.ts","names":[],"sources":["../../../src/localization/getPrefix.ts"],"mappings":";;;;;;;KAwBY;EACV,UAAU;EACV,gBAAgB;EAChB,OAAO;EACP,UAAU;EACV,UAAU;;;;;;;;;;;;EAYV;;;;;;cAOW,uBAAoB,UACtB,mBACR,KAAK;EACN,eAAe;EACf,MAAM;EACN,SAAS;;KAUC;EACV,gBAAgB;EAChB,OAAO;;KAGG;;;;;EAKV;;;;EAIA,cAAc;;;;;;;;;;;KAYJ,wBACV,UAAU,2BACV,sBAAsB,qBACtB,gBAAgB,gBAAgB,yBAC9B,qCACkB,KAChB,wBAAwB,iBAAiB,MAAM,6BAC7B,QAChB,kBACA;EACI,WAAW;EAAM,cAAc;IACjC,mCACE,UAAU;EACN;EAAY;;EACZ,WAAW;EAAM,cAAc;;EACjC;EAAY;;EACpB;EAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmCL,kBAAmB,UAAU,2BAAyB,QACzD,GAAC,UACA,mBACR,wBAAwB"}
+{"version":3,"file":"getPrefix.d.ts","names":[],"sources":["../../../src/localization/getPrefix.ts"],"mappings":";;;;;;KAkBY;EACV,UAAU;EACV,gBAAgB;EAChB,OAAO;EACP,UAAU,2BAA2B;EACrC,UAAU;;;;;;;;;;;;EAYV;;;;;;cAOW,uBAAoB,UACtB,mBACR,KAAK;EACN,eAAe;EACf,MAAM;EACN,SAAS;;;;;;;;;;;;;;cAsBE,mBAAgB,OACpB,kCAAgC,mBACpB,oBAClB,SAAS;KAGA;EACV,gBAAgB;EAChB,OAAO;;KAGG;;;;;EAKV;;;;EAIA,cAAc;;;;;;;;;;;KAYJ,wBACV,UAAU,2BACV,sBAAsB,qBACtB,gBAAgB,gBAAgB,yBAC9B,qCACkB,KAChB,wBAAwB,iBAAiB,MAAM,6BAC7B,QAChB,kBACA;EACI,WAAW;EAAM,cAAc;IACjC,mCACE,UAAU;EACN;EAAY;;EACZ,WAAW;EAAM,cAAc;;EACjC;EAAY;;EACpB;EAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmCL,kBAAmB,UAAU,2BAAyB,QACzD,GAAC,UACA,mBACR,wBAAwB"}

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

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

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

@@ -1,3 +1,4 @@
+import { DeclaredLocales } from "@intlayer/types/module_augmentation";
 import { Locale } from "@intlayer/types/allLocales";
 //#region src/localization/localeDetector.d.ts
 /**
@@ -11,7 +12,7 @@ declare const getPreferredLanguages: (acceptHeader: string | undefined, availabl
  * Headers are provided by the browser/client and can be used to determine the user's preferred language.
  * This function intersects the user's `Accept-Language` header with the application's available locales.
  */
-declare const localeDetector: (headers: Record<string, string | undefined>, availableLocales?: Locale[], defaultLocale?: Locale) => Locale;
+declare const localeDetector: (headers: Record<string, string | undefined>, availableLocales?: Locale[], defaultLocale?: Locale) => DeclaredLocales;
 //#endregion
 export { getPreferredLanguages, localeDetector };
 //# sourceMappingURL=localeDetector.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"localeDetector.d.ts","names":[],"sources":["../../../src/localization/localeDetector.ts"],"mappings":";;;;;;cA+Ma,wBAAqB,kCACA;;;;;;;cAgCrB,iBAAc,SAChB,oCAAkC,mBACxB,UAAQ,gBACX,WACf"}
+{"version":3,"file":"localeDetector.d.ts","names":[],"sources":["../../../src/localization/localeDetector.ts"],"mappings":";;;;;;;cAqNa,wBAAqB,kCACA;;;;;;;cAgCrB,iBAAc,SAChB,oCAAkC,mBACxB,UAAQ,gBACX,WACf"}

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

@@ -1,11 +1,10 @@
-import { LocalesValues } from "@intlayer/types/module_augmentation";
-import { Locale } from "@intlayer/types/allLocales";
+import { DeclaredLocales, LocalesValues } from "@intlayer/types/module_augmentation";
 //#region src/localization/localeMapper.d.ts
 type LocaleData = {
-  locale: Locale;
-  defaultLocale: Locale;
+  locale: DeclaredLocales;
+  defaultLocale: DeclaredLocales;
   isDefault: boolean;
-  locales: Locale[];
+  locales: DeclaredLocales[];
   urlPrefix: string;
 };
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"localeMapper.d.ts","names":[],"sources":["../../../src/localization/localeMapper.ts"],"mappings":";;;KAMY;EACV,QAAQ;EACR,eAAe;EACf;EACA,SAAS;EACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA6BW,YAAa,GAAC,SAChB,QAAQ,eAAe,GAAC,UACxB,iBAAe,gBACT,eAAa,8EAO3B;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwCU,gBAAiB,GAAC,SACpB,QAAQ,eAAe,KAAG,UAC1B,iBAAe,gBACT,eAAa,8EAO3B;;;;;;;;;;;;;;;;;;;;;;;;cAqCU,eAAgB,GAAC,SACnB,QAAQ,eAAe,GAAC,UACxB,iBAAe,gBACT,eAAa,8EAO3B,OAAO,eAAe"}
+{"version":3,"file":"localeMapper.d.ts","names":[],"sources":["../../../src/localization/localeMapper.ts"],"mappings":";;KAQY;EACV,QAAQ;EACR,eAAe;EACf;EACA,SAAS;EACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA6BW,YAAa,GAAC,SAChB,QAAQ,eAAe,GAAC,UACxB,iBAAe,gBACT,eAAa,8EAO3B;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwCU,gBAAiB,GAAC,SACpB,QAAQ,eAAe,KAAG,UAC1B,iBAAe,gBACT,eAAa,8EAO3B;;;;;;;;;;;;;;;;;;;;;;;;cAqCU,eAAgB,GAAC,SACnB,QAAQ,eAAe,GAAC,UACxB,iBAAe,gBACT,eAAa,8EAO3B,OAAO,eAAe"}

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

@@ -1,11 +1,10 @@
-import { LocalesValues } from "@intlayer/types/module_augmentation";
-import { Locale } from "@intlayer/types/allLocales";
+import { DeclaredLocales, LocalesValues } from "@intlayer/types/module_augmentation";
 //#region src/localization/localeResolver.d.ts
 /**
  * Resolves the most specific locale from a user-provided list,
  * or falls back to the default locale if no match is found.
  */
-declare const localeResolver: (selectedLocale: LocalesValues | LocalesValues[], locales?: LocalesValues[], defaultLocale?: LocalesValues) => Locale;
+declare const localeResolver: (selectedLocale: LocalesValues | LocalesValues[], locales?: LocalesValues[], defaultLocale?: LocalesValues) => DeclaredLocales;
 //#endregion
 export { localeResolver };
 //# sourceMappingURL=localeResolver.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"localeResolver.d.ts","names":[],"sources":["../../../src/localization/localeResolver.ts"],"mappings":";;;;;;;cAQa,iBAAc,gBACT,gBAAgB,iBAAe,UACtC,iBAAe,gBACT,kBACd"}
+{"version":3,"file":"localeResolver.d.ts","names":[],"sources":["../../../src/localization/localeResolver.ts"],"mappings":";;;;;;cAUa,iBAAc,gBACT,gBAAgB,iBAAe,UACtC,iBAAe,gBACT,kBACd"}

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

@@ -0,0 +1,35 @@
+import { RoutingOptions } from "./getPrefix.js";
+import { LocalesValues } from "@intlayer/types/module_augmentation";
+//#region src/localization/resolveBrowserLocale.d.ts
+/**
+ * Resolves the locale of the current document outside of React.
+ *
+ * Generated dynamic entry points need the locale while they are still
+ * evaluating, long before a provider exists, so this reproduces the precedence
+ * a provider applies — URL first (which is what a router hands the provider as
+ * `locale`), then browser storage, then the configured default. Agreeing with
+ * the provider is what makes the preloaded read hit; disagreeing is safe but
+ * costs a load, since the consumer compares locales before using a preloaded
+ * dictionary.
+ *
+ * @param options - Routing overrides, defaulting to the built configuration.
+ * @returns The resolved locale, falling back to the default locale off-browser.
+ */
+declare const resolveBrowserLocale: (options?: RoutingOptions) => LocalesValues;
+/**
+ * {@link resolveBrowserLocale}, memoized for the current URL.
+ *
+ * Every generated dynamic entry point calls this as it evaluates, and an
+ * application has hundreds of them — repeating the cookie and storage reads
+ * that many times on startup is pure cost, since they cannot change while a
+ * page is being assembled.
+ *
+ * Keying the cache on the URL rather than caching forever keeps a client-side
+ * locale change honest: navigating to another locale's URL loads further
+ * chunks with that locale, instead of preloading the old one and silently
+ * falling back to an asynchronous read.
+ */
+declare const getPreloadLocale: () => LocalesValues;
+//#endregion
+export { getPreloadLocale, resolveBrowserLocale };
+//# sourceMappingURL=resolveBrowserLocale.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resolveBrowserLocale.d.ts","names":[],"sources":["../../../src/localization/resolveBrowserLocale.ts"],"mappings":";;;;;;;;;;;;;;;;;cAoBa,uBAAoB,UACrB,mBACT;;;;;;;;;;;;;;cAqDU,wBAAuB"}

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

@@ -1,33 +1,73 @@
-import { LocalesValues } from "@intlayer/types/module_augmentation";
-import { Locale } from "@intlayer/types/allLocales";
+import { LocalesValues, ResolvedDefaultLocale } from "@intlayer/types/module_augmentation";
 import { RewriteObject, RewriteRules, RoutingConfig } from "@intlayer/types/config";
 //#region src/localization/rewriteUtils.d.ts
-type LocalizedPathResult = {
+/**
+ * Outcome of resolving a canonical path against the rewrite rules.
+ *
+ * Discriminated on `isRewritten`: when no rule matched, `path` is the very
+ * input that was passed in, so a literal input keeps its literal type. Only a
+ * rewritten path is computed at runtime and therefore widens to `string`.
+ */
+type LocalizedPathResult<CanonicalPath extends string = string> = {
+  path: CanonicalPath;
+  isRewritten: false;
+} | {
   path: string;
-  isRewritten: boolean;
+  isRewritten: true;
 };
+/** Adds the leading slash a path may be missing. */
+type WithLeadingSlash<Path extends string> = Path extends `/${string}` ? Path : `/${Path}`;
+/**
+ * Computes the locale-prefixed internal path for a path and a locale, mirroring
+ * `getInternalPath`'s runtime behaviour: an already-prefixed path is returned
+ * untouched, the root collapses to `/${Locale}` (never a trailing slash), and
+ * anything else gets the prefix prepended.
+ *
+ * Falls back to `string` for a non-literal path, where the prefixed and
+ * already-prefixed cases cannot be told apart.
+ *
+ * @example
+ * type A = InternalPath<'/about', 'fr'>;    // '/fr/about'
+ * type B = InternalPath<'/', 'fr'>;         // '/fr'
+ * type C = InternalPath<'/fr/about', 'fr'>; // '/fr/about' (already prefixed)
+ */
+type InternalPath<Path extends string, Locale extends string> = string extends Path ? string : WithLeadingSlash<Path> extends (infer Prefixed extends string) ? Prefixed extends `/${Locale}` | `/${Locale}/${string}` ? Prefixed : Prefixed extends '/' ? `/${Locale}` : `/${Locale}${Prefixed}` : never;
 /**
  * Normalizes legacy Record format or extracts specialized rules from RewriteObject.
+ *
+ * Idempotent: already-normalized rules are handed back untouched, so a caller
+ * holding resolved rules can pass them on without re-normalizing.
  */
-declare const getRewriteRules: (rewrite: RoutingConfig['rewrite'], context?: keyof RewriteObject) => RewriteRules | undefined;
+declare const getRewriteRules: <const Context extends keyof RewriteObject = 'url'>(rewrite: RoutingConfig['rewrite'] | RewriteRules, context?: Context) => RewriteRules | undefined;
 /**
  * Given a localized URL (e.g., "/produits/123"), finds the canonical internal path (e.g., "/products/123").
  * If locale is provided, only check for that locale. Otherwise, check for all locales.
  */
-declare const getCanonicalPath: (localizedPath: string, locale?: Locale, rewriteRules?: RewriteRules) => string;
+declare const getCanonicalPath: <const Path extends string, const Locale extends LocalesValues = LocalesValues>(localizedPath: Path, locale?: Locale, rewriteRules?: RewriteRules) => string;
 /**
- * Given a canonical path (e.g., "/products/123"), finds the localized URL pattern (e.g., "/produits/123").
+ * Given a canonical path (e.g., "/products/123"), finds the localized URL pattern
+ * (e.g., "/produits/123") and reports whether a rule actually matched.
+ *
+ * Takes already-normalized rules, so callers that resolve the rules once (proxies,
+ * static emitters) can reuse them. {@link getLocalizedPath} is the user-facing
+ * counterpart: it accepts the raw `routing.rewrite` configuration, defaults to the
+ * project configuration, and returns the path alone.
+ *
+ * @param canonicalPath - The internal application path (e.g. `/product/:id`, `/about`).
+ * @param locale - The target locale. Defaults to the configured default locale.
+ * @param rewriteRules - Normalized rules, as returned by {@link getRewriteRules}.
+ * @returns The localized path, discriminated on whether a rewrite rule matched.
  */
-declare const getLocalizedPath: (canonicalPath: string, locale: LocalesValues, rewriteRules?: RewriteRules) => LocalizedPathResult;
+declare const resolveLocalizedPath: <const CanonicalPath extends string, const Locale extends LocalesValues = ResolvedDefaultLocale>(canonicalPath: CanonicalPath, locale?: Locale, rewriteRules?: RewriteRules) => LocalizedPathResult<CanonicalPath>;
 /**
  * Returns the internal path for a given canonical path and locale.
  * Ensures the locale prefix is present exactly once.
  */
-declare const getInternalPath: (canonicalPath: string, locale: Locale) => string;
+declare const getInternalPath: <const Path extends string, const Locale extends LocalesValues>(canonicalPath: Path, locale: Locale) => InternalPath<Path, Locale>;
 /**
  * Given a current pathname and locale, returns the pretty localized path if a rewrite rule exists and the path is not already localized.
  */
-declare const getRewritePath: (pathname: string, locale: Locale, rewrite?: RoutingConfig['rewrite']) => string | undefined;
+declare const getRewritePath: <const Path extends string, const Locale extends LocalesValues = ResolvedDefaultLocale>(pathname: Path, locale: Locale, rewrite?: RoutingConfig['rewrite']) => string | undefined;
 //#endregion
-export { LocalizedPathResult, getCanonicalPath, getInternalPath, getLocalizedPath, getRewritePath, getRewriteRules };
+export { InternalPath, LocalizedPathResult, getCanonicalPath, getInternalPath, getRewritePath, getRewriteRules, resolveLocalizedPath };
 //# sourceMappingURL=rewriteUtils.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"rewriteUtils.d.ts","names":[],"sources":["../../../src/localization/rewriteUtils.ts"],"mappings":";;;;KAmBY;EACV;EACA;;;;;cAMW,kBAAe,SACjB,0BAAwB,gBAClB,kBACd;;;;;cA2EU,mBAAgB,uBACN,SACZ,QAAM,eACA;;;;cA2BJ,mBAAgB,uBACN,QACb,eAAa,eACN,iBACd;;;;;cA6BU,kBAAe,uBACL,QACb;;;;cAmBG,iBAAc,kBACT,QACR,QAAM,UACJ"}
+{"version":3,"file":"rewriteUtils.d.ts","names":[],"sources":["../../../src/localization/rewriteUtils.ts"],"mappings":";;;;;;;;;;KAkBY,oBAAoB;EAC1B,MAAM;EAAe;;EACrB;EAAc;;;KAGf,iBAAiB,uBAAuB,4BACzC,WACI;;;;;;;;;;;;;;;KAgBI,aACV,qBACA,wCACiB,gBAEf,iBAAiB,qBAAoB,2BACnC,qBAAqB,eAAe,qBAClC,WACA,2BACM,eACA,SAAS;;;;;;;cASV,wBACL,sBAAsB,uBAAqB,SAExC,2BAA2B,cAAY,UACvC,YACR;;;;;cAsFU,yBACL,2BACA,eAAe,gBAAgB,eAAa,eAEnC,MAAI,SACV,QAAM,eACA;;;;;;;;;;;;;;;cA2CJ,6BACL,oCACA,eAAe,gBAAgB,uBAAqB,eAE3C,eAAa,SACnB,QAAM,eACA,iBACd,oBAAoB;;;;;cAkCV,wBACL,2BACA,eAAe,eAAa,eAEnB,MAAI,QACX,WACP,aAAa,MAAM;;;;cAoBT,uBACL,2BACA,eAAe,gBAAgB,uBAAqB,UAEhD,MAAI,QACN,QAAM,UACJ"}

package/dist/types/localization/rewriteUtils.test-d.d.ts

@@ -0,0 +1 @@
+export {}