@intlayer/core 9.4.3 → 9.5.0

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

@@ -5,7 +5,7 @@ import "./getContent/index.js";
 import { GetSubPath } from "@intlayer/types/dictionary";
 import { DictionaryKeys, DictionaryRegistryContent } from "@intlayer/types/module_augmentation";
 //#region src/interpreter/getNesting.d.ts
-type GetNestingResult<K extends DictionaryKeys, P = undefined, S = IInterpreterPluginState> = GetSubPath<DeepTransformContent<DictionaryRegistryContent<K>, S>, P>;
+export type GetNestingResult<K extends DictionaryKeys, P = undefined, S = IInterpreterPluginState> = GetSubPath<DeepTransformContent<DictionaryRegistryContent<K>, S>, P>;
 /**
  * Extracts content from another dictionary by its key and an optional path.
  *
@@ -22,7 +22,6 @@ type GetNestingResult<K extends DictionaryKeys, P = undefined, S = IInterpreterP
  * // 'Save'
  * ```
  */
-declare const getNesting: <const K extends DictionaryKeys, const P>(dictionaryKey: K, path?: P extends ValidDotPathsFor<K> ? P : never, props?: NodeProps) => GetNestingResult<K, P>;
+export declare const getNesting: <const K extends DictionaryKeys, const P>(dictionaryKey: K, path?: P extends ValidDotPathsFor<K> ? P : never, props?: NodeProps) => GetNestingResult<K, P>;
 //#endregion
-export { GetNestingResult, getNesting };
 //# sourceMappingURL=getNesting.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getNesting.d.ts","names":[],"sources":["../../../src/interpreter/getNesting.ts"],"mappings":";;;;;;;KAaY,iBACV,UAAU,gBACV,eACA,IAAI,2BACF,WAAW,qBAAqB,0BAA0B,IAAI,IAAI;;;;;;;;;;;;;;;;;cAkBzD,mBAAoB,UAAU,sBAAsB,GAAC,eACjD,GAAC,OACT,UAAU,iBAAiB,KAAK,WAAS,QACxC,cACP,iBAAiB,GAAG"}
+{"version":3,"file":"getNesting.d.ts","names":[],"sources":["../../../src/interpreter/getNesting.ts"],"mappings":";;;;;;;YAaY,iBACV,UAAU,gBACV,eACA,IAAI,2BACF,WAAW,qBAAqB,0BAA0B,IAAI,IAAI;;;;;;;;;;;;;;;;;qBAkBzD,mBAAoB,UAAU,sBAAsB,GAAC,eACjD,GAAC,OACT,UAAU,iBAAiB,KAAK,WAAS,QACxC,cACP,iBAAiB,GAAG"}

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

@@ -27,7 +27,6 @@ import { DictionaryKeys } from "@intlayer/types/module_augmentation";
  * @param props - Interpreter node props, carrying the attached dictionaries.
  * @returns The nested content.
  */
-declare const getNesting: <const K extends DictionaryKeys, const P>(dictionaryKey: K, path?: P extends ValidDotPathsFor<K> ? P : never, props?: NodeProps) => GetNestingResult<K, P>;
+export declare const getNesting: <const K extends DictionaryKeys, const P>(dictionaryKey: K, path?: P extends ValidDotPathsFor<K> ? P : never, props?: NodeProps) => GetNestingResult<K, P>;
 //#endregion
-export { getNesting };
 //# sourceMappingURL=getNesting.optimized.d.ts.map

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

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

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

@@ -1,6 +1,6 @@
 import { PluralContentState } from "../transpiler/plural/plural.js";
-import { LocalesValues } from "../intlayer/dist/types/index.js";
-import { DeclaredLocales } from "@intlayer/types";
+import { LocalesValues } from "@intlayer/types/module_augmentation";
+import { DeclaredLocales as DeclaredLocales$1 } from "@intlayer/types";
 //#region src/interpreter/getPlural.d.ts
 /**
  * Picks content from a plural map based on a count and locale, using CLDR
@@ -17,7 +17,6 @@ import { DeclaredLocales } from "@intlayer/types";
  * // '{{count}} items'
  * ```
  */
-declare const getPlural: <const L extends LocalesValues = DeclaredLocales>(pluralContent: PluralContentState<string>, count: number, locale: L) => string;
+export declare const getPlural: <const L extends LocalesValues = DeclaredLocales$1>(pluralContent: PluralContentState<string>, count: number, locale: L) => string;
 //#endregion
-export { getPlural };
 //# sourceMappingURL=getPlural.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getPlural.d.ts","names":[],"sources":["../../../src/interpreter/getPlural.ts"],"mappings":";;;;;;;;;;;;;;;;;;;cAuBa,kBAAmB,UAAU,gBAAgB,iBAAe,eACxD,4BAA0B,eAC5B,QACL"}
+{"version":3,"file":"getPlural.d.ts","names":[],"sources":["../../../src/interpreter/getPlural.ts"],"mappings":";;;;;;;;;;;;;;;;;;;qBAuBa,kBAAmB,UAAU,gBAAgB,mBAAe,eACxD,4BAA0B,eAC5B,QACL"}

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

@@ -25,7 +25,6 @@ import "../transpiler/index.js";
  * // 'This post is live'
  * ```
  */
-declare const getSelect: <const Content>(selectContent: SelectContentStates<Content>, value?: string) => Content;
+export declare const getSelect: <const Content>(selectContent: SelectContentStates<Content>, value?: string) => Content;
 //#endregion
-export { getSelect };
 //# sourceMappingURL=getSelect.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getSelect.d.ts","names":[],"sources":["../../../src/interpreter/getSelect.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;cA0Ba,kBAAmB,SAAO,eACtB,oBAAoB,UAAQ,mBAE1C"}
+{"version":3,"file":"getSelect.d.ts","names":[],"sources":["../../../src/interpreter/getSelect.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;qBA0Ba,kBAAmB,SAAO,eACtB,oBAAoB,UAAQ,mBAE1C"}

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

@@ -23,7 +23,6 @@ import { LocalesValues, StrictModeLocaleMap } from "@intlayer/types/module_augme
  * // 'Bonjour'
  * ```
  */
-declare const getTranslation: <const Content = string>(languageContent: StrictModeLocaleMap<Content>, locale: LocalesValues, fallback?: LocalesValues) => Content;
+export declare const getTranslation: <const Content = string>(languageContent: StrictModeLocaleMap<Content>, locale: LocalesValues, fallback?: LocalesValues) => Content;
 //#endregion
-export { getTranslation };
 //# sourceMappingURL=getTranslation.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getTranslation.d.ts","names":[],"sources":["../../../src/interpreter/getTranslation.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;cA2Ea,uBAAwB,kBAAgB,iBAClC,oBAAoB,UAAQ,QACrC,eAAa,WACV,kBACV"}
+{"version":3,"file":"getTranslation.d.ts","names":[],"sources":["../../../src/interpreter/getTranslation.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;qBA2Ea,uBAAwB,kBAAgB,iBAClC,oBAAoB,UAAQ,QACrC,eAAa,WACV,kBACV"}

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

@@ -10,7 +10,7 @@ import * as NodeTypes from "@intlayer/types/nodeType";
  * be able to interpolate into that inner string before the html/markdown
  * renderer turns it into a component tree.
  */
-type InterpolableNode = string | {
+export type InterpolableNode = string | {
   nodeType: typeof NodeTypes.HTML;
   [NodeTypes.HTML]: string;
 } | {
@@ -25,7 +25,7 @@ type InterpolableNode = string | {
  * so bundlers can eliminate the branch (and downstream handling code) when the
  * html/markdown node types are tree-shaken out of the user bundle.
  */
-declare const isInterpolableWrapperNode: (node: unknown) => node is Exclude<InterpolableNode, string>;
+export declare const isInterpolableWrapperNode: (node: unknown) => node is Exclude<InterpolableNode, string>;
 /**
  * Extracts the raw interpolable string from a string, `html()` or `markdown()`
  * node. Returns `undefined` for any other node so callers can fall back to
@@ -38,7 +38,7 @@ declare const isInterpolableWrapperNode: (node: unknown) => node is Exclude<Inte
  * getInterpolableContent({ nodeType: 'translation' }); // undefined
  * ```
  */
-declare const getInterpolableContent: (node: unknown) => string | undefined;
+export declare const getInterpolableContent: (node: unknown) => string | undefined;
 /**
  * Rebuilds an interpolable node from its interpolated raw string, preserving
  * the original node shape (plain string stays a string, `html()`/`markdown()`
@@ -50,7 +50,7 @@ declare const getInterpolableContent: (node: unknown) => string | undefined;
  * // { nodeType: 'html', html: '<b>1</b>', … }
  * ```
  */
-declare const rebuildInterpolableContent: <T>(node: T, interpolated: string) => T;
+export declare const rebuildInterpolableContent: <T>(node: T, interpolated: string) => T;
 /**
  * Interpolates `{{ … }}` values into an `html()`/`markdown()` wrapper node,
  * then re-runs the transform with the parent plugin list so the html/markdown
@@ -60,7 +60,6 @@ declare const rebuildInterpolableContent: <T>(node: T, interpolated: string) =>
  * framework package — framework nodes (React elements, VNodes…) cannot be
  * injected into a raw markup string, so plain string interpolation is used.
  */
-declare const transformInterpolableNode: (node: Exclude<InterpolableNode, string>, values: Record<string, string | number>, subProps: NodeProps, parentPlugins: Plugins[] | undefined, deepTransformNode: (node: unknown, props: NodeProps) => unknown) => unknown;
+export declare const transformInterpolableNode: (node: Exclude<InterpolableNode, string>, values: Record<string, string | number>, subProps: NodeProps, parentPlugins: Plugins[] | undefined, deepTransformNode: (node: unknown, props: NodeProps) => unknown) => unknown;
 //#endregion
-export { InterpolableNode, getInterpolableContent, isInterpolableWrapperNode, rebuildInterpolableContent, transformInterpolableNode };
 //# sourceMappingURL=interpolableNode.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"interpolableNode.d.ts","names":[],"sources":["../../../src/interpreter/interpolableNode.ts"],"mappings":";;;;;;;;;;;;KAaY;EAEN,iBAAiB,UAAU;GAAO,UAAU;;EAC5C,iBAAiB,UAAU;GAAW,UAAU;;;;;;;;;;cAUzC,4BAAyB,kBAEnC,QAAQ,QAAQ;;;;;;;;;;;;;cA2BN,yBAAsB;;;;;;;;;;;;cAyBtB,6BAA8B,GAAC,MACpC,GAAC,yBAEN;;;;;;;;;;cAwBU,4BAAyB,MAC9B,QAAQ,2BAAyB,QAC/B,iCAA+B,UAC7B,WAAS,eACJ,uBAAqB,oBAChB,eAAe,OAAO"}
+{"version":3,"file":"interpolableNode.d.ts","names":[],"sources":["../../../src/interpreter/interpolableNode.ts"],"mappings":";;;;;;;;;;;;YAaY;EAEN,iBAAiB,UAAU;GAAO,UAAU;;EAC5C,iBAAiB,UAAU;GAAW,UAAU;;;;;;;;;;qBAUzC,4BAAyB,kBAEnC,QAAQ,QAAQ;;;;;;;;;;;;;qBA2BN,yBAAsB;;;;;;;;;;;;qBAyBtB,6BAA8B,GAAC,MACpC,GAAC,yBAEN;;;;;;;;;;qBAwBU,4BAAyB,MAC9B,QAAQ,2BAAyB,QAC/B,iCAA+B,UAC7B,WAAS,eACJ,uBAAqB,oBAChB,eAAe,OAAO"}

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

@@ -1,8 +1,7 @@
 //#region src/interpreter/splitAndJoinInsertion.d.ts
-declare const splitInsertionTemplate: <T = any>(template: string, values?: Record<string, T>) => {
+export declare const splitInsertionTemplate: <T = any>(template: string, values?: Record<string, T>) => {
   isSimple: boolean;
   parts: string | T[];
 };
 //#endregion
-export { splitInsertionTemplate };
 //# sourceMappingURL=splitAndJoinInsertion.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"splitAndJoinInsertion.d.ts","names":[],"sources":["../../../src/interpreter/splitAndJoinInsertion.ts"],"mappings":";cAaa,yBAA0B,SAAO,kBAC5B,SACR,eAAe;EACpB;EAAmB,gBAAgB"}
+{"version":3,"file":"splitAndJoinInsertion.d.ts","names":[],"sources":["../../../src/interpreter/splitAndJoinInsertion.ts"],"mappings":";qBAaa,yBAA0B,SAAO,kBAC5B,SACR,eAAe;EACpB;EAAmB,gBAAgB"}

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

@@ -30,7 +30,7 @@ import { DeclaredLocales, LocalesValues } from "@intlayer/types/module_augmentat
  *   configured locales.
  * @returns The normalized, locale-agnostic pathname.
  */
-declare const normalizePath: <const L extends LocalesValues = DeclaredLocales>(inputUrl: string, locales?: L[]) => string;
+export 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.
@@ -59,7 +59,6 @@ declare const normalizePath: <const L extends LocalesValues = DeclaredLocales>(i
  *   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;
+export 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

@@ -1 +1 @@
-{"version":3,"file":"comparePaths.d.ts","names":[],"sources":["../../../src/localization/comparePaths.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAqCa,sBAAuB,UAAU,gBAAgB,iBAAe,kBAC3D,UACN;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+CC,qBAAsB,UAAU,gBAAgB,iBAAe,kBAC1D,cACJ,UACF"}
+{"version":3,"file":"comparePaths.d.ts","names":[],"sources":["../../../src/localization/comparePaths.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAqCa,sBAAuB,UAAU,gBAAgB,iBAAe,kBAC3D,UACN;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA+CC,qBAAsB,UAAU,gBAAgB,iBAAe,kBAC1D,cACJ,UACF"}

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

@@ -5,7 +5,7 @@ import { RoutingConfig } from "@intlayer/types/config";
  * The locale → domain map configured under `routing.domains`
  * (e.g. `{ en: 'intlayer.org', zh: 'intlayer.cn' }`).
  */
-type LocaleDomainMap = RoutingConfig['domains'];
+export type LocaleDomainMap = RoutingConfig['domains'];
 /**
  * Strips the protocol from a domain string and returns only the hostname.
  *
@@ -19,7 +19,7 @@ type LocaleDomainMap = RoutingConfig['domains'];
  * @param domain - A domain value from `routing.domains`, with or without protocol.
  * @returns The bare hostname.
  */
-declare const getDomainHostname: (domain: string) => string;
+export declare const getDomainHostname: (domain: string) => string;
 /**
  * Returns the absolute origin for a domain value, prepending `https://`
  * when no protocol is present.
@@ -34,7 +34,7 @@ declare const getDomainHostname: (domain: string) => string;
  * @param domain - A domain value from `routing.domains`, with or without protocol.
  * @returns The origin usable as a URL base.
  */
-declare const getDomainOrigin: (domain: string) => string;
+export declare const getDomainOrigin: (domain: string) => string;
 /**
  * Returns the locale exclusively mapped to a given hostname via `routing.domains`,
  * or `undefined` when zero or more than one locale share that hostname.
@@ -51,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) => DeclaredLocales | undefined;
+export 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.
@@ -62,7 +62,6 @@ declare const getLocaleFromDomain: (hostname: string, domains: LocaleDomainMap)
  * @param domains - The configured locale → domain map.
  * @returns `true` when the locale has a domain shared with no other locale.
  */
-declare const isLocaleExclusiveOnDomain: (locale: LocalesValues, domains: LocaleDomainMap) => boolean;
+export declare const isLocaleExclusiveOnDomain: (locale: LocalesValues, domains: LocaleDomainMap) => boolean;
 //#endregion
-export { LocaleDomainMap, getDomainHostname, getDomainOrigin, getLocaleFromDomain, isLocaleExclusiveOnDomain };
 //# sourceMappingURL=domainUtils.d.ts.map

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"domainUtils.d.ts","names":[],"sources":["../../../src/localization/domainUtils.ts"],"mappings":";;;;;;;YAUY,kBAAkB;;;;;;;;;;;;;;qBAejB,oBAAiB;;;;;;;;;;;;;;;qBAsBjB,kBAAe;;;;;;;;;;;;;;;;;qBAmBf,sBAAmB,kBACd,SACP,oBACR;;;;;;;;;;;qBAuBU,4BAAyB,QAC5B,eAAa,SACZ"}

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

@@ -1,7 +1,7 @@
 import { LocalesValues } from "@intlayer/types/module_augmentation";
 import { RoutingConfig } from "@intlayer/types/config";
 //#region src/localization/generateSitemap.d.ts
-type SitemapUrlEntry = {
+export type SitemapUrlEntry = {
   /** The canonical path, e.g. '/dashboard' */
   path: string;
   changefreq?: string;
@@ -9,7 +9,7 @@ type SitemapUrlEntry = {
   /** ISO date string, e.g. '2024-01-15' */
   lastmod?: string;
 };
-type GenerateSitemapOptions = {
+export type GenerateSitemapOptions = {
   /** Base site URL without trailing slash, e.g. 'https://example.com' */
   siteUrl: string;
   /**
@@ -85,7 +85,7 @@ type GenerateSitemapOptions = {
  * @param options - Configuration options.
  * @returns One or more `<url>` XML strings, joined by a newline.
  */
-declare const generateSitemapUrl: (path: string, options: SitemapUrlEntry & GenerateSitemapOptions) => string;
+export declare const generateSitemapUrl: (path: string, options: SitemapUrlEntry & GenerateSitemapOptions) => string;
 /**
  * Generates a full XML sitemap string from an array of URL entries.
  *
@@ -114,7 +114,6 @@ declare const generateSitemapUrl: (path: string, options: SitemapUrlEntry & Gene
  * @param options - Sitemap generation options.
  * @returns A full XML sitemap string.
  */
-declare const generateSitemap: (entries: SitemapUrlEntry[], options: GenerateSitemapOptions) => string;
+export declare const generateSitemap: (entries: SitemapUrlEntry[], options: GenerateSitemapOptions) => string;
 //#endregion
-export { GenerateSitemapOptions, SitemapUrlEntry, generateSitemap, generateSitemapUrl };
 //# sourceMappingURL=generateSitemap.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"generateSitemap.d.ts","names":[],"sources":["../../../src/localization/generateSitemap.ts"],"mappings":";;;KAMY;;EAEV;EACA;EACA;;EAEA;;KAGU;;EAEV;;;;;;;;;;;;;EAaA;;;;;;;;;;;;;;;;;;;;;EAqBA;EACA,UAAU;EACV,gBAAgB;EAChB,OAAO;EACP,UAAU;EACV,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsFC,qBAAkB,cACjB,SACH,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAuFhB,kBAAe,SACjB,mBAAiB,SACjB"}
+{"version":3,"file":"generateSitemap.d.ts","names":[],"sources":["../../../src/localization/generateSitemap.ts"],"mappings":";;;YAMY;;EAEV;EACA;EACA;;EAEA;;YAGU;;EAEV;;;;;;;;;;;;;EAaA;;;;;;;;;;;;;;;;;;;;;EAqBA;EACA,UAAU;EACV,gBAAgB;EAChB,OAAO;EACP,UAAU;EACV,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAsFC,qBAAkB,cACjB,SACH,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAuFhB,kBAAe,SACjB,mBAAiB,SACjB"}

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

@@ -1,6 +1,6 @@
 import { Locale } from "@intlayer/types/allLocales";
 //#region src/localization/getBrowserLocale.d.ts
-declare enum LanguageDetector {
+export declare enum LanguageDetector {
   Querystring = "querystring",
   Storage = "storage",
   Navigator = "navigator",
@@ -26,7 +26,6 @@ type LanguageDetectorOptions = {
  * @example
  * const locale = getBrowserLocale({ order: [LanguageDetector.Storage, LanguageDetector.Navigator] });
  */
-declare const getBrowserLocale: (userOptions?: LanguageDetectorOptions | undefined) => Locale;
+export declare const getBrowserLocale: (userOptions?: LanguageDetectorOptions | undefined) => Locale;
 //#endregion
-export { LanguageDetector, getBrowserLocale };
 //# sourceMappingURL=getBrowserLocale.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getBrowserLocale.d.ts","names":[],"sources":["../../../src/localization/getBrowserLocale.tsx"],"mappings":";;aAMY;EACV;EACA;EACA;EACA;;KAIG;EACH,QAAQ;EACR;EACA,UAAU;;;;;;;;;;;;;;;;;cA4JC,mBAAgB,cACd,wCACZ"}
+{"version":3,"file":"getBrowserLocale.d.ts","names":[],"sources":["../../../src/localization/getBrowserLocale.tsx"],"mappings":";;oBAMY;EACV;EACA;EACA;EACA;;KAIG;EACH,QAAQ;EACR;EACA,UAAU;;;;;;;;;;;;;;;;;qBA4JC,mBAAgB,cACd,wCACZ"}

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

@@ -13,7 +13,6 @@ import { RewriteRules, RoutingConfig } from "@intlayer/types/config";
  * @param rewriteRules - Raw `routing.rewrite` configuration or already-normalized
  *   rules. Defaults to the project configuration's `routing.rewrite`.
  */
-declare const getCanonicalPath: <const Path extends string, const Locale extends LocalesValues = LocalesValues>(localizedPath: Path, locale?: Locale, rewriteRules?: RoutingConfig['rewrite'] | RewriteRules) => string;
+export declare const getCanonicalPath: <const Path extends string, const Locale extends LocalesValues = LocalesValues>(localizedPath: Path, locale?: Locale, rewriteRules?: RoutingConfig['rewrite'] | RewriteRules) => string;
 //#endregion
-export { getCanonicalPath };
 //# sourceMappingURL=getCanonicalPath.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getCanonicalPath.d.ts","names":[],"sources":["../../../src/localization/getCanonicalPath.ts"],"mappings":";;;;;;;;;;;;;;;cAkCa,yBACL,2BACA,eAAe,gBAAgB,eAAa,eAEnC,MAAI,SACV,QAAM,eACA,2BAA2B"}
+{"version":3,"file":"getCanonicalPath.d.ts","names":[],"sources":["../../../src/localization/getCanonicalPath.ts"],"mappings":";;;;;;;;;;;;;;;qBAkCa,yBACL,2BACA,eAAe,gBAAgB,eAAa,eAEnC,MAAI,SACV,QAAM,eACA,2BAA2B"}

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

@@ -14,7 +14,6 @@ type Dir = 'ltr' | 'rtl' | 'auto';
  * @param locale The locale to get the text direction for.
  * @returns The text direction of the given locale.
  */
-declare const getHTMLTextDir: (locale?: LocalesValues) => Dir;
+export declare const getHTMLTextDir: (locale?: LocalesValues) => Dir;
 //#endregion
-export { getHTMLTextDir };
 //# sourceMappingURL=getHTMLTextDir.d.ts.map

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

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

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

@@ -1,10 +1,9 @@
 import { DeclaredLocales } from "@intlayer/types/module_augmentation";
 //#region src/localization/getLocale.d.ts
-type RequestContext = {
+export type RequestContext = {
   getHeader?: (name: string) => string | null | undefined;
   getCookie?: (name: string) => string | null | undefined;
 };
-declare const getLocale: (ctx?: RequestContext) => Promise<DeclaredLocales>;
+export 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,MACf,mBACJ,QAAQ"}
+{"version":3,"file":"getLocale.d.ts","names":[],"sources":["../../../src/localization/getLocale.ts"],"mappings":";;YAOY;EACV,aAAa;EACb,aAAa;;qBAGF,YAAS,MACf,mBACJ,QAAQ"}

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

@@ -13,7 +13,6 @@ import { DeclaredLocales } from "@intlayer/types/module_augmentation";
  * @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) => DeclaredLocales | undefined;
+export 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":";;;;;;;;;;;;;;;cAoBa,oBAAiB,mBACZ,UACN,mBACT"}
+{"version":3,"file":"getLocaleFromPath.d.ts","names":[],"sources":["../../../src/localization/getLocaleFromPath.ts"],"mappings":";;;;;;;;;;;;;;;qBAoBa,oBAAiB,mBACZ,UACN,mBACT"}

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

@@ -13,7 +13,6 @@ import { GetLocaleLang, LocalesValues } from "@intlayer/types/module_augmentatio
  * @param locale The locale to get the language code for.
  * @returns The language code of the given locale.
  */
-declare const getLocaleLang: <const L extends LocalesValues>(locale?: L) => GetLocaleLang<L & string>;
+export declare const getLocaleLang: <const L extends LocalesValues>(locale?: L) => GetLocaleLang<L & string>;
 //#endregion
-export { getLocaleLang };
 //# sourceMappingURL=getLocaleLang.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getLocaleLang.d.ts","names":[],"sources":["../../../src/localization/getLocaleLang.ts"],"mappings":";;;;;;;;;;;;;;;cAkBa,sBAAuB,UAAU,eAAa,SAChD,MACR,cAAc"}
+{"version":3,"file":"getLocaleLang.d.ts","names":[],"sources":["../../../src/localization/getLocaleLang.ts"],"mappings":";;;;;;;;;;;;;;;qBAkBa,sBAAuB,UAAU,eAAa,SAChD,MACR,cAAc"}

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

@@ -1,6 +1,5 @@
 import { LocalesValues } from "@intlayer/types/module_augmentation";
 //#region src/localization/getLocaleName.d.ts
-declare const getLocaleName: (displayLocale: LocalesValues, targetLocale?: LocalesValues) => string;
+export declare const getLocaleName: (displayLocale: LocalesValues, targetLocale?: LocalesValues) => string;
 //#endregion
-export { getLocaleName };
 //# sourceMappingURL=getLocaleName.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getLocaleName.d.ts","names":[],"sources":["../../../src/localization/getLocaleName.ts"],"mappings":";;cAGa,gBAAa,eACT,eAAa,eACd"}
+{"version":3,"file":"getLocaleName.d.ts","names":[],"sources":["../../../src/localization/getLocaleName.ts"],"mappings":";;qBAGa,gBAAa,eACT,eAAa,eACd"}

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

@@ -44,7 +44,6 @@ import { LocalesValues, LocalizedPathname, ResolvedDefaultLocale } from "@intlay
  *   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>;
+export 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

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

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

@@ -57,7 +57,6 @@ import { LocalesValues, LocalizedUrl, ResolvedDefaultLocale } from "@intlayer/ty
  * of the two URLs this function can return — the absolute one on that domain,
  * and the relative one it returns when the current page already lives there.
  */
-declare const getLocalizedUrl: <const T extends string, const L extends LocalesValues = ResolvedDefaultLocale>(url: T, currentLocale?: L, options?: RoutingOptions) => LocalizedUrl<T, L>;
+export declare const getLocalizedUrl: <const T extends string, const L extends LocalesValues = ResolvedDefaultLocale>(url: T, currentLocale?: L, options?: RoutingOptions) => LocalizedUrl<T, L>;
 //#endregion
-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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmEa,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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAmEa,wBACL,wBACA,UAAU,gBAAgB,uBAAqB,KAEhD,GAAC,gBACS,GAAC,UACP,mBACR,aAAa,GAAG"}

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

@@ -35,7 +35,6 @@ import { StrictModeLocaleMap } from "@intlayer/types/module_augmentation";
  * @param options.mode - URL routing mode for locale handling. Defaults to configured mode.
  * @returns An object mapping each locale to its corresponding multilingual URL.
  */
-declare const getMultilingualUrls: (url: string, options?: RoutingOptions) => StrictModeLocaleMap<string>;
+export declare const getMultilingualUrls: (url: string, options?: RoutingOptions) => StrictModeLocaleMap<string>;
 //#endregion
-export { getMultilingualUrls };
 //# sourceMappingURL=getMultilingualUrls.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getMultilingualUrls.d.ts","names":[],"sources":["../../../src/localization/getMultilingualUrls.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsCa,sBAAmB,aACnB,UACF,mBACR"}
+{"version":3,"file":"getMultilingualUrls.d.ts","names":[],"sources":["../../../src/localization/getMultilingualUrls.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAsCa,sBAAmB,aACnB,UACF,mBACR"}

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

@@ -29,7 +29,6 @@ import { DeclaredLocales, LocalesValues, PathWithoutLocale } from "@intlayer/typ
  * and `locales` are string literals known at compile time. Absolute URLs fall
  * back to `string`.
  */
-declare const getPathWithoutLocale: <const T extends string, const L extends LocalesValues = DeclaredLocales>(inputUrl: T, locales?: L[]) => PathWithoutLocale<T, L>;
+export declare const getPathWithoutLocale: <const T extends string, const L extends LocalesValues = DeclaredLocales>(inputUrl: T, locales?: L[]) => PathWithoutLocale<T, L>;
 //#endregion
-export { getPathWithoutLocale };
 //# sourceMappingURL=getPathWithoutLocale.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getPathWithoutLocale.d.ts","names":[],"sources":["../../../src/localization/getPathWithoutLocale.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA0Da,6BACL,wBACA,UAAU,gBAAgB,iBAAe,UAErC,GAAC,UACF,QACR,kBAAkB,GAAG"}
+{"version":3,"file":"getPathWithoutLocale.d.ts","names":[],"sources":["../../../src/localization/getPathWithoutLocale.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA0Da,6BACL,wBACA,UAAU,gBAAgB,iBAAe,UAErC,GAAC,UACF,QACR,kBAAkB,GAAG"}

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

@@ -4,7 +4,7 @@ import { RewriteRules, RoutingConfig } from "@intlayer/types/config";
 /**
  * Shared routing options used across all URL localization functions.
  */
-type RoutingOptions = {
+export type RoutingOptions = {
   locales?: LocalesValues[];
   defaultLocale?: LocalesValues;
   mode?: RoutingConfig['mode'];
@@ -27,7 +27,7 @@ type RoutingOptions = {
  * Resolves routing configuration by merging provided options with configuration defaults.
  * Single source of truth for default routing config resolution across all localization functions.
  */
-declare const resolveRoutingConfig: (options?: RoutingOptions) => Omit<RoutingOptions, 'defaultLocale' | 'mode' | 'locales'> & {
+export declare const resolveRoutingConfig: (options?: RoutingOptions) => Omit<RoutingOptions, 'defaultLocale' | 'mode' | 'locales'> & {
   defaultLocale: DeclaredLocales;
   mode: RoutingConfig['mode'];
   locales: DeclaredLocales[];
@@ -44,12 +44,12 @@ declare const resolveRoutingConfig: (options?: RoutingOptions) => Omit<RoutingOp
  * @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 = {
+export declare const isDeclaredLocale: (value: LocalesValues | undefined | null, locales?: readonly LocalesValues[]) => value is DeclaredLocales;
+export type GetPrefixOptions = {
   defaultLocale?: ResolvedDefaultLocale;
   mode?: RoutingConfig['mode'];
 };
-type GetPrefixResult = {
+export type GetPrefixResult = {
   /**
    * The locale path segment appended to `/`, with a trailing slash (e.g. `'fr/'`).
    * Empty string when no prefix is needed.
@@ -71,7 +71,7 @@ type GetPrefixResult = {
  * Note: the "locale not in locales" edge case returns an empty result at runtime
  * regardless of what this type reports.
  */
-type GetPrefixResultNarrowed<L extends LocalesValues | undefined, Mode extends string = ResolvedRoutingMode, Default extends LocalesValues = ResolvedDefaultLocale, Domains extends DomainRuleMap = ResolvedDomains> = L extends string ? [string] extends [L] ? GetPrefixResultNarrowed<DeclaredLocales, Mode, Default, Domains> : IsDomainExclusive<L, Domains> extends true ? {
+export type GetPrefixResultNarrowed<L extends LocalesValues | undefined, Mode extends string = ResolvedRoutingMode, Default extends LocalesValues = ResolvedDefaultLocale, Domains extends DomainRuleMap = ResolvedDomains> = L extends string ? [string] extends [L] ? GetPrefixResultNarrowed<DeclaredLocales, Mode, Default, Domains> : IsDomainExclusive<L, Domains> extends true ? {
   prefix: '';
   localePrefix: undefined;
 } : [string] extends [Mode] ? GetPrefixResult : Mode extends 'prefix-all' ? {
@@ -123,7 +123,6 @@ type GetPrefixResultNarrowed<L extends LocalesValues | undefined, Mode extends s
  * @param options.mode - URL routing mode for locale handling. Defaults to configured mode.
  * @returns An object containing pathPrefix, prefix, and localePrefix for the given locale.
  */
-declare const getPrefix: <const L extends LocalesValues | undefined>(locale: L, options?: RoutingOptions) => GetPrefixResultNarrowed<L>;
+export declare const getPrefix: <const L extends LocalesValues | undefined>(locale: L, options?: RoutingOptions) => GetPrefixResultNarrowed<L>;
 //#endregion
-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":";;;;;;KAqBY;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;;;;;;;;;;;;;KAcJ,wBACV,UAAU,2BACV,sBAAsB,qBACtB,gBAAgB,gBAAgB,uBAChC,gBAAgB,gBAAgB,mBAC9B,qCACkB,KAChB,wBAAwB,iBAAiB,MAAM,SAAS,WACxD,kBAAkB,GAAG;EACjB;EAAY;sBACI,QAChB,kBACA;EACI,WAAW;EAAM,cAAc;IACjC,mCACE,UAAU;EACN;EAAY;;EACZ,WAAW;EAAM,cAAc;;EACjC;EAAY;;EACtB;EAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmCL,kBAAmB,UAAU,2BAAyB,QACzD,GAAC,UACA,mBACR,wBAAwB"}
+{"version":3,"file":"getPrefix.d.ts","names":[],"sources":["../../../src/localization/getPrefix.ts"],"mappings":";;;;;;YAqBY;EACV,UAAU;EACV,gBAAgB;EAChB,OAAO;EACP,UAAU,2BAA2B;EACrC,UAAU;;;;;;;;;;;;EAYV;;;;;;qBAOW,uBAAoB,UACtB,mBACR,KAAK;EACN,eAAe;EACf,MAAM;EACN,SAAS;;;;;;;;;;;;;;qBAsBE,mBAAgB,OACpB,kCAAgC,mBACpB,oBAClB,SAAS;YAGA;EACV,gBAAgB;EAChB,OAAO;;YAGG;;;;;EAKV;;;;EAIA,cAAc;;;;;;;;;;;;;YAcJ,wBACV,UAAU,2BACV,sBAAsB,qBACtB,gBAAgB,gBAAgB,uBAChC,gBAAgB,gBAAgB,mBAC9B,qCACkB,KAChB,wBAAwB,iBAAiB,MAAM,SAAS,WACxD,kBAAkB,GAAG;EACjB;EAAY;sBACI,QAChB,kBACA;EACI,WAAW;EAAM,cAAc;IACjC,mCACE,UAAU;EACN;EAAY;;EACZ,WAAW;EAAM,cAAc;;EACjC;EAAY;;EACtB;EAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAmCL,kBAAmB,UAAU,2BAAyB,QACzD,GAAC,UACA,mBACR,wBAAwB"}

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

@@ -5,14 +5,13 @@ import { Locale } from "@intlayer/types/allLocales";
  * Derives the list of preferred languages based on the Accept-Language header
  * and an optional list of available languages.
  */
-declare const getPreferredLanguages: (acceptHeader: string | undefined, availableLanguages?: string[]) => string[];
+export declare const getPreferredLanguages: (acceptHeader: string | undefined, availableLanguages?: string[]) => string[];
 /**
  * Detects the locale from the request headers.
  *
  * 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) => DeclaredLocales;
+export 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":";;;;;;;cAqNa,wBAAqB,kCACA;;;;;;;cAgCrB,iBAAc,SAChB,oCAAkC,mBACxB,UAAQ,gBACX,WACf"}
+{"version":3,"file":"localeDetector.d.ts","names":[],"sources":["../../../src/localization/localeDetector.ts"],"mappings":";;;;;;;qBAqNa,wBAAqB,kCACA;;;;;;;qBAgCrB,iBAAc,SAChB,oCAAkC,mBACxB,UAAQ,gBACX,WACf"}

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

@@ -1,6 +1,6 @@
 import { DeclaredLocales, LocalesValues } from "@intlayer/types/module_augmentation";
 //#region src/localization/localeMapper.d.ts
-type LocaleData = {
+export type LocaleData = {
   locale: DeclaredLocales;
   defaultLocale: DeclaredLocales;
   isDefault: boolean;
@@ -33,7 +33,7 @@ type LocaleData = {
  * @param mapper - The mapper function that returns an object
  * @returns An array of objects
  */
-declare const localeMap: <T>(mapper: (locale: LocaleData) => T, locales?: LocalesValues[], defaultLocale?: LocalesValues, mode?: 'prefix-no-default' | 'prefix-all' | 'no-prefix' | 'search-params') => T[];
+export declare const localeMap: <T>(mapper: (locale: LocaleData) => T, locales?: LocalesValues[], defaultLocale?: LocalesValues, mode?: 'prefix-no-default' | 'prefix-all' | 'no-prefix' | 'search-params') => T[];
 /**
  * Flatten the locale map into a single array of objects
  *
@@ -60,7 +60,7 @@ declare const localeMap: <T>(mapper: (locale: LocaleData) => T, locales?: Locale
  * @param mapper - The mapper function that returns an array of objects
  * @returns An array of objects
  */
-declare const localeFlatMap: <T>(mapper: (locale: LocaleData) => T[], locales?: LocalesValues[], defaultLocale?: LocalesValues, mode?: 'prefix-no-default' | 'prefix-all' | 'no-prefix' | 'search-params') => T[];
+export declare const localeFlatMap: <T>(mapper: (locale: LocaleData) => T[], locales?: LocalesValues[], defaultLocale?: LocalesValues, mode?: 'prefix-no-default' | 'prefix-all' | 'no-prefix' | 'search-params') => T[];
 /**
  * Creates a record object mapping locales to values transformed by the mapper function
  *
@@ -84,7 +84,6 @@ declare const localeFlatMap: <T>(mapper: (locale: LocaleData) => T[], locales?:
  * @param mode - URL routing mode for locale handling (defaults to configured value)
  * @returns Record mapping locale codes to mapped values
  */
-declare const localeRecord: <T>(mapper: (locale: LocaleData) => T, locales?: LocalesValues[], defaultLocale?: LocalesValues, mode?: 'prefix-no-default' | 'prefix-all' | 'no-prefix' | 'search-params') => Record<LocalesValues, T>;
+export declare const localeRecord: <T>(mapper: (locale: LocaleData) => T, locales?: LocalesValues[], defaultLocale?: LocalesValues, mode?: 'prefix-no-default' | 'prefix-all' | 'no-prefix' | 'search-params') => Record<LocalesValues, T>;
 //#endregion
-export { LocaleData, localeFlatMap, localeMap, localeRecord };
 //# sourceMappingURL=localeMapper.d.ts.map

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"localeMapper.d.ts","names":[],"sources":["../../../src/localization/localeMapper.ts"],"mappings":";;YAQY;EACV,QAAQ;EACR,eAAe;EACf;EACA,SAAS;EACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA6BW,YAAa,GAAC,SAChB,QAAQ,eAAe,GAAC,UACxB,iBAAe,gBACT,eAAa,8EAO3B;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAwCU,gBAAiB,GAAC,SACpB,QAAQ,eAAe,KAAG,UAC1B,iBAAe,gBACT,eAAa,8EAO3B;;;;;;;;;;;;;;;;;;;;;;;;qBAqCU,eAAgB,GAAC,SACnB,QAAQ,eAAe,GAAC,UACxB,iBAAe,gBACT,eAAa,8EAO3B,OAAO,eAAe"}

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

@@ -4,7 +4,6 @@ import { DeclaredLocales, LocalesValues } from "@intlayer/types/module_augmentat
  * 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) => DeclaredLocales;
+export 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":";;;;;;cAUa,iBAAc,gBACT,gBAAgB,iBAAe,UACtC,iBAAe,gBACT,kBACd"}
+{"version":3,"file":"localeResolver.d.ts","names":[],"sources":["../../../src/localization/localeResolver.ts"],"mappings":";;;;;;qBAUa,iBAAc,gBACT,gBAAgB,iBAAe,UACtC,iBAAe,gBACT,kBACd"}