@intlayer/core 9.0.0-canary.2 → 9.0.0-canary.4

package/dist/cjs/index.cjs

@@ -63,6 +63,7 @@ const require_dictionaryManipulator_renameContentNodeByKeyPath = require('./dict
 const require_dictionaryManipulator_updateNodeChildren = require('./dictionaryManipulator/updateNodeChildren.cjs');
 const require_utils_checkIsURLAbsolute = require('./utils/checkIsURLAbsolute.cjs');
 const require_localization_getPathWithoutLocale = require('./localization/getPathWithoutLocale.cjs');
+const require_localization_comparePaths = require('./localization/comparePaths.cjs');
 const require_localization_getPrefix = require('./localization/getPrefix.cjs');
 const require_localization_rewriteUtils = require('./localization/rewriteUtils.cjs');
 const require_localization_getLocalizedUrl = require('./localization/getLocalizedUrl.cjs');
@@ -186,6 +187,7 @@ exports.captureNothing = require_markdown_utils.captureNothing;
 exports.checkIsURLAbsolute = require_utils_checkIsURLAbsolute.checkIsURLAbsolute;
 exports.checkMissingLocalesPlugin = require_deepTransformPlugins_getMissingLocalesContent.checkMissingLocalesPlugin;
 exports.compact = require_formatters_compact.compact;
+exports.comparePaths = require_localization_comparePaths.comparePaths;
 exports.compile = require_markdown_compiler.compile;
 exports.compileWithOptions = require_markdown_compiler.compileWithOptions;
 exports.cond = require_transpiler_condition_condition.cond;
@@ -303,6 +305,7 @@ exports.nestedPlugin = require_interpreter_getContent_plugins.nestedPlugin;
 exports.normalizeAttributeKey = require_markdown_utils.normalizeAttributeKey;
 exports.normalizeDictionaries = require_dictionaryManipulator_normalizeDictionary.normalizeDictionaries;
 exports.normalizeDictionary = require_dictionaryManipulator_normalizeDictionary.normalizeDictionary;
+exports.normalizePath = require_localization_comparePaths.normalizePath;
 exports.normalizeWhitespace = require_markdown_utils.normalizeWhitespace;
 exports.number = require_formatters_number.number;
 exports.orderDictionaries = require_dictionaryManipulator_orderDictionaries.orderDictionaries;

package/dist/cjs/localization/comparePaths.cjs

@@ -0,0 +1,75 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_utils_checkIsURLAbsolute = require('../utils/checkIsURLAbsolute.cjs');
+const require_localization_getPathWithoutLocale = require('./getPathWithoutLocale.cjs');
+
+//#region src/localization/comparePaths.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.
+*/
+const normalizePath = (inputUrl, locales) => {
+	const withoutLocale = require_localization_getPathWithoutLocale.getPathWithoutLocale(inputUrl || "/", locales);
+	const { pathname } = require_utils_checkIsURLAbsolute.checkIsURLAbsolute(withoutLocale) ? new URL(withoutLocale) : new URL(withoutLocale, "http://example.com");
+	if (pathname.length > 1 && pathname.endsWith("/")) return pathname.slice(0, -1);
+	return pathname || "/";
+};
+/**
+* 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.
+*/
+const comparePaths = (pathname, href, locales) => normalizePath(pathname, locales) === normalizePath(href, locales);
+
+//#endregion
+exports.comparePaths = comparePaths;
+exports.normalizePath = normalizePath;
+//# sourceMappingURL=comparePaths.cjs.map

package/dist/cjs/localization/comparePaths.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"comparePaths.cjs","names":["getPathWithoutLocale","checkIsURLAbsolute"],"sources":["../../../src/localization/comparePaths.ts"],"sourcesContent":["import type {\n  DeclaredLocales,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { checkIsURLAbsolute } from '../utils/checkIsURLAbsolute';\nimport { getPathWithoutLocale } from './getPathWithoutLocale';\n\n/**\n * Normalizes a URL or pathname into a canonical, locale-agnostic pathname so\n * that two paths pointing to the same page compare equal — useful for\n * highlighting the active navigation link.\n *\n * The normalization:\n * - strips the locale segment (reusing {@link getPathWithoutLocale})\n * - strips the protocol/host so absolute and relative inputs compare equally\n * - drops the query string and hash\n * - ensures a single leading slash\n * - removes any trailing slash (except for the root path)\n * - falls back to `'/'` for empty values\n *\n * Example:\n *\n * ```ts\n * normalizePath('/ru/path')                    // '/path'\n * normalizePath('/ru/path/')                   // '/path'\n * normalizePath('ru/path')                     // '/path'\n * normalizePath('/ru/')                        // '/'\n * normalizePath('/ru')                         // '/'\n * normalizePath('')                            // '/'\n * normalizePath('https://example.com/ru/path') // '/path'\n * ```\n *\n * @param inputUrl - The URL string or pathname to normalize.\n * @param locales - Optional array of supported locales. Defaults to the\n *   configured locales.\n * @returns The normalized, locale-agnostic pathname.\n */\nexport const normalizePath = <const L extends LocalesValues = DeclaredLocales>(\n  inputUrl: string,\n  locales?: L[]\n): string => {\n  const withoutLocale = getPathWithoutLocale(inputUrl || '/', locales);\n\n  // Reuse the URL API to isolate the pathname from any host/query/hash.\n  const url = checkIsURLAbsolute(withoutLocale)\n    ? new URL(withoutLocale)\n    : new URL(withoutLocale, 'http://example.com');\n\n  const { pathname } = url;\n\n  // Remove a trailing slash, keeping the root path intact.\n  if (pathname.length > 1 && pathname.endsWith('/')) {\n    return pathname.slice(0, -1);\n  }\n\n  return pathname || '/';\n};\n\n/**\n * Compares two URLs or pathnames for equality, ignoring locale segment,\n * protocol/host, query string, hash and trailing slashes.\n *\n * Both inputs are normalized through {@link normalizePath} before comparison,\n * making this ideal for matching the current pathname against a navigation\n * link's `href`.\n *\n * Example:\n *\n * ```ts\n * comparePaths('/ru/path', '/path')   // true\n * comparePaths('/ru/path/', '/path')  // true\n * comparePaths('/ru/path', '/path/')  // true\n * comparePaths('/ru/', '/')           // true\n * comparePaths('/ru', '/')            // true\n * comparePaths('ru/path', '/path')    // true\n * comparePaths('', '/')               // true\n * comparePaths('/ru', '')             // true\n * comparePaths('/ru/path', '/other')  // false\n * ```\n *\n * @param pathname - The first URL string or pathname to compare.\n * @param href - The second URL string or pathname to compare.\n * @param locales - Optional array of supported locales. Defaults to the\n *   configured locales.\n * @returns `true` when both inputs resolve to the same locale-agnostic path.\n */\nexport const comparePaths = <const L extends LocalesValues = DeclaredLocales>(\n  pathname: string,\n  href: string,\n  locales?: L[]\n): boolean => normalizePath(pathname, locales) === normalizePath(href, locales);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,MAAa,iBACX,UACA,YACW;CACX,MAAM,gBAAgBA,+DAAqB,YAAY,KAAK,QAAQ;CAOpE,MAAM,EAAE,aAJIC,oDAAmB,cAAc,GACzC,IAAI,IAAI,cAAc,GACtB,IAAI,IAAI,eAAe,qBAAqB;AAKhD,KAAI,SAAS,SAAS,KAAK,SAAS,SAAS,IAAI,CAC/C,QAAO,SAAS,MAAM,GAAG,GAAG;AAG9B,QAAO,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BrB,MAAa,gBACX,UACA,MACA,YACY,cAAc,UAAU,QAAQ,KAAK,cAAc,MAAM,QAAQ"}

package/dist/cjs/localization/index.cjs

@@ -1,5 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_localization_getPathWithoutLocale = require('./getPathWithoutLocale.cjs');
+const require_localization_comparePaths = require('./comparePaths.cjs');
 const require_localization_getPrefix = require('./getPrefix.cjs');
 const require_localization_rewriteUtils = require('./rewriteUtils.cjs');
 const require_localization_getLocalizedUrl = require('./getLocalizedUrl.cjs');
@@ -16,6 +17,7 @@ const require_localization_getLocaleName = require('./getLocaleName.cjs');
 const require_localization_localeMapper = require('./localeMapper.cjs');
 const require_localization_validatePrefix = require('./validatePrefix.cjs');
 
+exports.comparePaths = require_localization_comparePaths.comparePaths;
 exports.generateSitemap = require_localization_generateSitemap.generateSitemap;
 exports.generateSitemapUrl = require_localization_generateSitemap.generateSitemapUrl;
 exports.getBrowserLocale = require_localization_getBrowserLocale.getBrowserLocale;
@@ -38,4 +40,5 @@ exports.localeFlatMap = require_localization_localeMapper.localeFlatMap;
 exports.localeMap = require_localization_localeMapper.localeMap;
 exports.localeRecord = require_localization_localeMapper.localeRecord;
 exports.localeResolver = require_localization_localeResolver.localeResolver;
+exports.normalizePath = require_localization_comparePaths.normalizePath;
 exports.validatePrefix = require_localization_validatePrefix.validatePrefix;

package/dist/esm/index.mjs

@@ -62,6 +62,7 @@ import { renameContentNodeByKeyPath } from "./dictionaryManipulator/renameConten
 import { updateNodeChildren } from "./dictionaryManipulator/updateNodeChildren.mjs";
 import { checkIsURLAbsolute } from "./utils/checkIsURLAbsolute.mjs";
 import { getPathWithoutLocale } from "./localization/getPathWithoutLocale.mjs";
+import { comparePaths, normalizePath } from "./localization/comparePaths.mjs";
 import { getPrefix } from "./localization/getPrefix.mjs";
 import { getCanonicalPath, getInternalPath, getLocalizedPath, getRewritePath, getRewriteRules } from "./localization/rewriteUtils.mjs";
 import { getLocalizedUrl } from "./localization/getLocalizedUrl.mjs";
@@ -92,4 +93,4 @@ import { interpolateMessage, parseTaggedMessage, resolveMessage, resolveMessageN
 import { isSameKeyPath } from "./utils/isSameKeyPath.mjs";
 import { stringifyYaml } from "./utils/stringifyYaml.mjs";
 
-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, 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, 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, HTML_TAGS, INLINE_SKIP_R, INTERPOLATION_R, LINK_AUTOLINK_BARE_URL_R, LINK_AUTOLINK_R, LIST_LOOKBEHIND_R, LOOKAHEAD, LocaleStorage, LocaleStorageClient, LocaleStorageServer, 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, QUALIFIER_DYNAMIC_TYPES_KEY, QUALIFIER_ORDER, REFERENCE_IMAGE_OR_LINK, REFERENCE_IMAGE_R, REFERENCE_LINK_R, RuleType, 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, VOID_HTML_ELEMENTS, 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, 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, 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, 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, HTML_TAGS, INLINE_SKIP_R, INTERPOLATION_R, LINK_AUTOLINK_BARE_URL_R, LINK_AUTOLINK_R, LIST_LOOKBEHIND_R, LOOKAHEAD, LocaleStorage, LocaleStorageClient, LocaleStorageServer, 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, QUALIFIER_DYNAMIC_TYPES_KEY, QUALIFIER_ORDER, REFERENCE_IMAGE_OR_LINK, REFERENCE_IMAGE_R, REFERENCE_LINK_R, RuleType, 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, VOID_HTML_ELEMENTS, 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, 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, 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/esm/localization/comparePaths.mjs

@@ -0,0 +1,73 @@
+import { checkIsURLAbsolute } from "../utils/checkIsURLAbsolute.mjs";
+import { getPathWithoutLocale } from "./getPathWithoutLocale.mjs";
+
+//#region src/localization/comparePaths.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.
+*/
+const normalizePath = (inputUrl, locales) => {
+	const withoutLocale = getPathWithoutLocale(inputUrl || "/", locales);
+	const { pathname } = checkIsURLAbsolute(withoutLocale) ? new URL(withoutLocale) : new URL(withoutLocale, "http://example.com");
+	if (pathname.length > 1 && pathname.endsWith("/")) return pathname.slice(0, -1);
+	return pathname || "/";
+};
+/**
+* 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.
+*/
+const comparePaths = (pathname, href, locales) => normalizePath(pathname, locales) === normalizePath(href, locales);
+
+//#endregion
+export { comparePaths, normalizePath };
+//# sourceMappingURL=comparePaths.mjs.map

package/dist/esm/localization/comparePaths.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"comparePaths.mjs","names":[],"sources":["../../../src/localization/comparePaths.ts"],"sourcesContent":["import type {\n  DeclaredLocales,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { checkIsURLAbsolute } from '../utils/checkIsURLAbsolute';\nimport { getPathWithoutLocale } from './getPathWithoutLocale';\n\n/**\n * Normalizes a URL or pathname into a canonical, locale-agnostic pathname so\n * that two paths pointing to the same page compare equal — useful for\n * highlighting the active navigation link.\n *\n * The normalization:\n * - strips the locale segment (reusing {@link getPathWithoutLocale})\n * - strips the protocol/host so absolute and relative inputs compare equally\n * - drops the query string and hash\n * - ensures a single leading slash\n * - removes any trailing slash (except for the root path)\n * - falls back to `'/'` for empty values\n *\n * Example:\n *\n * ```ts\n * normalizePath('/ru/path')                    // '/path'\n * normalizePath('/ru/path/')                   // '/path'\n * normalizePath('ru/path')                     // '/path'\n * normalizePath('/ru/')                        // '/'\n * normalizePath('/ru')                         // '/'\n * normalizePath('')                            // '/'\n * normalizePath('https://example.com/ru/path') // '/path'\n * ```\n *\n * @param inputUrl - The URL string or pathname to normalize.\n * @param locales - Optional array of supported locales. Defaults to the\n *   configured locales.\n * @returns The normalized, locale-agnostic pathname.\n */\nexport const normalizePath = <const L extends LocalesValues = DeclaredLocales>(\n  inputUrl: string,\n  locales?: L[]\n): string => {\n  const withoutLocale = getPathWithoutLocale(inputUrl || '/', locales);\n\n  // Reuse the URL API to isolate the pathname from any host/query/hash.\n  const url = checkIsURLAbsolute(withoutLocale)\n    ? new URL(withoutLocale)\n    : new URL(withoutLocale, 'http://example.com');\n\n  const { pathname } = url;\n\n  // Remove a trailing slash, keeping the root path intact.\n  if (pathname.length > 1 && pathname.endsWith('/')) {\n    return pathname.slice(0, -1);\n  }\n\n  return pathname || '/';\n};\n\n/**\n * Compares two URLs or pathnames for equality, ignoring locale segment,\n * protocol/host, query string, hash and trailing slashes.\n *\n * Both inputs are normalized through {@link normalizePath} before comparison,\n * making this ideal for matching the current pathname against a navigation\n * link's `href`.\n *\n * Example:\n *\n * ```ts\n * comparePaths('/ru/path', '/path')   // true\n * comparePaths('/ru/path/', '/path')  // true\n * comparePaths('/ru/path', '/path/')  // true\n * comparePaths('/ru/', '/')           // true\n * comparePaths('/ru', '/')            // true\n * comparePaths('ru/path', '/path')    // true\n * comparePaths('', '/')               // true\n * comparePaths('/ru', '')             // true\n * comparePaths('/ru/path', '/other')  // false\n * ```\n *\n * @param pathname - The first URL string or pathname to compare.\n * @param href - The second URL string or pathname to compare.\n * @param locales - Optional array of supported locales. Defaults to the\n *   configured locales.\n * @returns `true` when both inputs resolve to the same locale-agnostic path.\n */\nexport const comparePaths = <const L extends LocalesValues = DeclaredLocales>(\n  pathname: string,\n  href: string,\n  locales?: L[]\n): boolean => normalizePath(pathname, locales) === normalizePath(href, locales);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,MAAa,iBACX,UACA,YACW;CACX,MAAM,gBAAgB,qBAAqB,YAAY,KAAK,QAAQ;CAOpE,MAAM,EAAE,aAJI,mBAAmB,cAAc,GACzC,IAAI,IAAI,cAAc,GACtB,IAAI,IAAI,eAAe,qBAAqB;AAKhD,KAAI,SAAS,SAAS,KAAK,SAAS,SAAS,IAAI,CAC/C,QAAO,SAAS,MAAM,GAAG,GAAG;AAG9B,QAAO,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BrB,MAAa,gBACX,UACA,MACA,YACY,cAAc,UAAU,QAAQ,KAAK,cAAc,MAAM,QAAQ"}

package/dist/esm/localization/index.mjs

@@ -1,4 +1,5 @@
 import { getPathWithoutLocale } from "./getPathWithoutLocale.mjs";
+import { comparePaths, normalizePath } from "./comparePaths.mjs";
 import { getPrefix } from "./getPrefix.mjs";
 import { getCanonicalPath, getInternalPath, getLocalizedPath, getRewritePath, getRewriteRules } from "./rewriteUtils.mjs";
 import { getLocalizedUrl } from "./getLocalizedUrl.mjs";
@@ -15,4 +16,4 @@ import { getLocaleName } from "./getLocaleName.mjs";
 import { localeFlatMap, localeMap, localeRecord } from "./localeMapper.mjs";
 import { validatePrefix } from "./validatePrefix.mjs";
 
-export { generateSitemap, generateSitemapUrl, getBrowserLocale, getCanonicalPath, getHTMLTextDir, getInternalPath, getLocale, getLocaleFromPath, getLocaleLang, getLocaleName, getLocalizedPath, getLocalizedUrl, getMultilingualUrls, getPathWithoutLocale, getPrefix, getRewritePath, getRewriteRules, localeDetector, localeFlatMap, localeMap, localeRecord, localeResolver, validatePrefix };
+export { 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/index.d.ts

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

@@ -1,6 +1,6 @@
 {
   "name": "@intlayer/core",
-  "version": "9.0.0-canary.2",
+  "version": "9.0.0-canary.4",
   "private": false,
   "description": "Includes core Intlayer functions like translation, dictionary, and utility functions shared across multiple packages.",
   "keywords": [
@@ -172,15 +172,15 @@
     "typecheck": "tsc --noEmit --project tsconfig.types.json"
   },
   "dependencies": {
-    "@intlayer/api": "9.0.0-canary.2",
-    "@intlayer/config": "9.0.0-canary.2",
-    "@intlayer/dictionaries-entry": "9.0.0-canary.2",
-    "@intlayer/types": "9.0.0-canary.2",
-    "@intlayer/unmerged-dictionaries-entry": "9.0.0-canary.2",
+    "@intlayer/api": "9.0.0-canary.4",
+    "@intlayer/config": "9.0.0-canary.4",
+    "@intlayer/dictionaries-entry": "9.0.0-canary.4",
+    "@intlayer/types": "9.0.0-canary.4",
+    "@intlayer/unmerged-dictionaries-entry": "9.0.0-canary.4",
     "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",