@intlayer/core 8.4.4 → 8.4.5

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

@@ -1,2 +1,58 @@
-import { n as findMatchingCondition, r as getEnumeration } from "../index-BnEeKNKW.js";
-export { findMatchingCondition, getEnumeration };
+import { EnterFormat, EnumerationContentState } from "../transpiler/enumeration/enumeration.js";
+//#region src/interpreter/getEnumeration.d.ts
+/**
+ * Find the matching condition for a quantity.
+ *
+ * Usage:
+ *
+ * ```ts
+ * const key = findMatchingCondition({
+ *  '<=-2.3': 'You have less than -2.3',
+ *  '<1': 'You have less than one',
+ *  '2': 'You have two',
+ *  '>=3': 'You have three or more',
+ * }, 2);
+ * // '2'
+ * ```
+ *
+ * The order of the keys will define the priority of the content.
+ *
+ * ```ts
+ * const key = findMatchingCondition({
+ *  '<4': 'You have less than four',
+ *  '2': 'You have two',
+ * }, 2);
+ * // '<4'
+ * ```
+ *
+ * If no keys match, the default key is '1'.
+ */
+declare const findMatchingCondition: <Content>(enumerationContent: EnumerationContentState<Content>, quantity: number) => EnterFormat | undefined;
+/**
+ * Picks content from an enumeration map based on a provided quantity.
+ *
+ * Supported keys in the enumeration map:
+ * - Specific numbers: '0', '1', '2'
+ * - Comparison operators: '<5', '>=10', '<=2'
+ * - Fallback: 'fallback'
+ *
+ * The first matching key in the object's iteration order will be selected.
+ *
+ * @param enumerationContent - A map of conditions/quantities to content.
+ * @param quantity - The number to match against the conditions.
+ * @returns The matching content.
+ *
+ * @example
+ * ```ts
+ * const content = getEnumeration({
+ *   '0': 'No items',
+ *   '1': 'One item',
+ *   '>1': 'Many items',
+ * }, 5);
+ * // 'Many items'
+ * ```
+ */
+declare const getEnumeration: <Content>(enumerationContent: EnumerationContentState<Content>, quantity: number) => Content;
+//#endregion
+export { findMatchingCondition, getEnumeration };
+//# sourceMappingURL=getEnumeration.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getEnumeration.d.ts","names":[],"sources":["../../../src/interpreter/getEnumeration.ts"],"mappings":";;;;;AA6BA;;;;;;;;;;;;;;;;AA0DA;;;;;;;;cA1Da,qBAAA,YACX,kBAAA,EAAoB,uBAAA,CAAwB,OAAA,GAC5C,QAAA,aACC,WAAA;;;;;;;;;;;;;;;;;;;;;;;;;cAuDU,cAAA,YACX,kBAAA,EAAoB,uBAAA,CAAwB,OAAA,GAC5C,QAAA,aACC,OAAA"}

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

@@ -1,4 +1,4 @@
-import { r as GenderContentStates, t as Gender } from "../gender-Dd39Ijmf.js";
+import { Gender, GenderContentStates } from "../transpiler/gender/gender.js";
 //#region src/interpreter/getGender.d.ts
 type GenderEntry = Gender | 'm' | 'f';
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"getGender.d.ts","names":[],"sources":["../../../src/interpreter/getGender.ts"],"mappings":";;KAEK,WAAA,GAAc,MAAA;;;;;;;;;;;;;;;;;;;AAF8C;;;;cAgCpD,SAAA,YACX,aAAA,EAAe,mBAAA,CAAoB,OAAA,GACnC,MAAA,EAAQ,WAAA,KACP,OAAA"}
+{"version":3,"file":"getGender.d.ts","names":[],"sources":["../../../src/interpreter/getGender.ts"],"mappings":";;KAEK,WAAA,GAAc,MAAA;;;AAF8C;;;;;AAgCjE;;;;;;;;;;;;;;;cAAa,SAAA,YACX,aAAA,EAAe,mBAAA,CAAoB,OAAA,GACnC,MAAA,EAAQ,WAAA,KACP,OAAA"}

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

@@ -1,2 +1,32 @@
-import { t as getHTML } from "../getHTML-CP6OXtdo.js";
-export { getHTML };
+//#region src/interpreter/getHTML.d.ts
+/**
+ * Component function that receives properly typed props
+ * Props include:
+ * - children?: any[] - Array of child elements (ReactNode[], VNode[], etc.)
+ * - [key: string]: any - Any HTML attributes (className, style, href, etc.)
+ */
+type Component = (props: {
+  children?: any[];
+  [key: string]: any;
+}) => any;
+/**
+ * Component object that delegates to another component
+ */
+type ComponentObject = {
+  tag: string;
+  props?: Record<string, any>;
+};
+/**
+ * Components map:
+ * - Function components receive typed props
+ * - String components delegate to another tag
+ * - Object components delegate with additional props
+ */
+type Components = Record<string, Component | string | ComponentObject>;
+/**
+ * Interprets a string containing HTML-like tags and replaces them with provided components or strings.
+ */
+declare const getHTML: (content: string, values: Components) => any;
+//#endregion
+export { getHTML };
+//# sourceMappingURL=getHTML.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getHTML.d.ts","names":[],"sources":["../../../src/interpreter/getHTML.ts"],"mappings":";;;;;;;KAMK,SAAA,IAAa,KAAA;EAAS,QAAA;EAAA,CAAmB,GAAA;AAAA;AAAmB;;;AAAA,KAK5D,eAAA;EACH,GAAA;EACA,KAAA,GAAQ,MAAA;AAAA;;;AAAM;;;;KASX,UAAA,GAAa,MAAA,SAAe,SAAA,YAAqB,eAAA;;;;cA4HzC,OAAA,GAAW,OAAA,UAAiB,MAAA,EAAQ,UAAA"}

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

@@ -1,4 +1,4 @@
-import { t as InsertionContent } from "../insertion-M5fwK-29.js";
+import { InsertionContent } from "../transpiler/insertion/insertion.js";
 //#region src/interpreter/getInsertion.d.ts
 /**
  * Allow to insert values in a string.

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

@@ -1 +1 @@
-{"version":3,"file":"getInsertion.d.ts","names":[],"sources":["../../../src/interpreter/getInsertion.ts"],"mappings":";;;;;;;;;;;;;;;cAea,YAAA,GACX,OAAA,UACA,MAAA,UAAgB,gBAAA"}
+{"version":3,"file":"getInsertion.d.ts","names":[],"sources":["../../../src/interpreter/getInsertion.ts"],"mappings":";;;;;AAeA;;;;;;;;;;cAAa,YAAA,GACX,OAAA,UACA,MAAA,UAAgB,gBAAA"}

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

@@ -1,2 +1,8 @@
-import { t as getIntlayer } from "../index-BnEeKNKW.js";
-export { getIntlayer };
+import { DeepTransformContent, IInterpreterPluginState, Plugins } from "./getContent/plugins.js";
+import { DeclaredLocales, DictionaryKeys, DictionaryRegistryContent, LocalesValues } from "@intlayer/types/module_augmentation";
+
+//#region src/interpreter/getIntlayer.d.ts
+declare const getIntlayer: <T extends DictionaryKeys, L extends LocalesValues = DeclaredLocales>(key: T, locale?: L, plugins?: Plugins[]) => DeepTransformContent<DictionaryRegistryContent<T>, IInterpreterPluginState, L>;
+//#endregion
+export { getIntlayer };
+//# sourceMappingURL=getIntlayer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getIntlayer.d.ts","names":[],"sources":["../../../src/interpreter/getIntlayer.ts"],"mappings":";;;;cAmDa,WAAA,aACD,cAAA,YACA,aAAA,GAAgB,eAAA,EAE1B,GAAA,EAAK,CAAA,EACL,MAAA,GAAS,CAAA,EACT,OAAA,GAAU,OAAA,OACT,oBAAA,CACD,yBAAA,CAA0B,CAAA,GAC1B,uBAAA,EACA,CAAA"}

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

@@ -1,2 +1,27 @@
-import { A as GetNestingResult, j as getNesting } from "../index-BnEeKNKW.js";
-export { GetNestingResult, getNesting };
+import { ValidDotPathsFor } from "../transpiler/nesting/nesting.js";
+import { DeepTransformContent, IInterpreterPluginState, NodeProps } from "./getContent/plugins.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>;
+/**
+ * Extracts content from another dictionary by its key and an optional path.
+ *
+ * This allows for reusing content across different dictionaries.
+ *
+ * @param dictionaryKey - The key of the dictionary to nest.
+ * @param path - Optional dot-separated path to a specific field within the nested dictionary.
+ * @param props - Optional properties like locale and plugins.
+ * @returns The nested content.
+ *
+ * @example
+ * ```ts
+ * const content = getNesting("common", "buttons.save");
+ * // 'Save'
+ * ```
+ */
+declare const getNesting: <K extends DictionaryKeys, 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

@@ -0,0 +1 @@
+{"version":3,"file":"getNesting.d.ts","names":[],"sources":["../../../src/interpreter/getNesting.ts"],"mappings":";;;;;;KAUY,gBAAA,WACA,cAAA,qBAEN,uBAAA,IACF,UAAA,CAAW,oBAAA,CAAqB,yBAAA,CAA0B,CAAA,GAAI,CAAA,GAAI,CAAA;;;;AAJtE;;;;;;;;;;;;;cAsBa,UAAA,aAAwB,cAAA,KACnC,aAAA,EAAe,CAAA,EACf,IAAA,GAAO,CAAA,SAAU,gBAAA,CAAiB,CAAA,IAAK,CAAA,UACvC,KAAA,GAAQ,SAAA,KACP,gBAAA,CAAiB,CAAA,EAAG,CAAA"}

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

@@ -1,2 +1,30 @@
-import { t as getTranslation } from "../getTranslation-BG2Wg-af.js";
-export { getTranslation };
+import { LocalesValues, StrictModeLocaleMap } from "@intlayer/types/module_augmentation";
+
+//#region src/interpreter/getTranslation.d.ts
+/**
+ * Picks the appropriate content from a locale map based on the provided locale.
+ *
+ * It handles:
+ * 1. Exact locale match (e.g., 'en-US').
+ * 2. Generic locale fallback (e.g., 'en' if 'en-US' is not found).
+ * 3. Explicit fallback locale.
+ * 4. Deep merging of objects to ensure partial translations are complemented by fallbacks.
+ *
+ * @param languageContent - A map of locales to content.
+ * @param locale - The target locale to retrieve.
+ * @param fallback - Optional fallback locale if the target is not found.
+ * @returns The translated content.
+ *
+ * @example
+ * ```ts
+ * const content = getTranslation({
+ *   en: 'Hello',
+ *   fr: 'Bonjour',
+ * }, 'fr');
+ * // 'Bonjour'
+ * ```
+ */
+declare const getTranslation: <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

@@ -0,0 +1 @@
+{"version":3,"file":"getTranslation.d.ts","names":[],"sources":["../../../src/interpreter/getTranslation.ts"],"mappings":";;;;;AAyHA;;;;;;;;;;;;;;;;;;;;;cAAa,cAAA,qBACX,eAAA,EAAiB,mBAAA,CAAoB,OAAA,GACrC,MAAA,EAAQ,aAAA,EACR,QAAA,GAAW,aAAA,KACV,OAAA"}

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

@@ -1,5 +1,12 @@
-import { A as GetNestingResult, C as conditionPlugin, D as insertionPlugin, E as genderPlugin, M as getCondition, O as nestedPlugin, S as ValueAtKey, T as filePlugin, _ as NestedCond, a as getBasePlugins, b as TranslationCond, c as ConditionCond, d as FileCond, f as GenderCond, g as IsAny, h as InsertionCond, i as getDictionary, j as getNesting, k as translationPlugin, l as DeepTransformContent, m as IInterpreterPluginState, n as findMatchingCondition, o as getContent, p as IInterpreterPlugin, r as getEnumeration, s as deepTransformNode, t as getIntlayer, u as EnumerationCond, v as NodeProps, w as enumerationPlugin, x as UnionKeys, y as Plugins } from "../index-BnEeKNKW.js";
-import { t as getHTML } from "../getHTML-CP6OXtdo.js";
-import { t as getTranslation } from "../getTranslation-BG2Wg-af.js";
-import { t as splitInsertionTemplate } from "../splitAndJoinInsertion-bkuLa7o2.js";
+import { getCondition } from "./getCondition.js";
+import { GetNestingResult, getNesting } from "./getNesting.js";
+import { ConditionCond, DeepTransformContent, EnumerationCond, FileCond, GenderCond, IInterpreterPlugin, IInterpreterPluginState, InsertionCond, IsAny, NestedCond, NodeProps, Plugins, TranslationCond, UnionKeys, ValueAtKey, conditionPlugin, enumerationPlugin, filePlugin, genderPlugin, insertionPlugin, nestedPlugin, translationPlugin } from "./getContent/plugins.js";
+import { deepTransformNode } from "./getContent/deepTransform.js";
+import { getBasePlugins, getContent } from "./getContent/getContent.js";
+import { getDictionary } from "./getDictionary.js";
+import { findMatchingCondition, getEnumeration } from "./getEnumeration.js";
+import { getHTML } from "./getHTML.js";
+import { getIntlayer } from "./getIntlayer.js";
+import { getTranslation } from "./getTranslation.js";
+import { splitInsertionTemplate } from "./splitAndJoinInsertion.js";
 export { ConditionCond, DeepTransformContent, EnumerationCond, FileCond, GenderCond, GetNestingResult, IInterpreterPlugin, IInterpreterPluginState, InsertionCond, IsAny, NestedCond, NodeProps, Plugins, TranslationCond, UnionKeys, ValueAtKey, conditionPlugin, deepTransformNode, enumerationPlugin, filePlugin, findMatchingCondition, genderPlugin, getBasePlugins, getCondition, getContent, getDictionary, getEnumeration, getHTML, getIntlayer, getNesting, getTranslation, insertionPlugin, nestedPlugin, splitInsertionTemplate, translationPlugin };

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

@@ -1,2 +1,25 @@
-import { t as splitInsertionTemplate } from "../splitAndJoinInsertion-bkuLa7o2.js";
-export { splitInsertionTemplate };
+//#region src/interpreter/splitAndJoinInsertion.d.ts
+/**
+ * Core logic for splitting insertion strings and joining with values.
+ * Returns an array of parts that can be wrapped by framework-specific Fragment implementations.
+ *
+ * @param template - The template string with {{ placeholder }} syntax
+ * @param values - Map of placeholder names to their replacement values
+ * @returns Object with `isSimple` flag and `parts` array
+ *
+ * @example
+ * ```ts
+ * const result = splitInsertionTemplate('Hello {{ name }}!', { name: 'World' });
+ * // { isSimple: true, parts: 'Hello World!' }
+ *
+ * const result = splitInsertionTemplate('Hello {{ name }}!', { name: <Component /> });
+ * // { isSimple: false, parts: ['Hello ', <Component />, '!'] }
+ * ```
+ */
+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

@@ -0,0 +1 @@
+{"version":3,"file":"splitAndJoinInsertion.d.ts","names":[],"sources":["../../../src/interpreter/splitAndJoinInsertion.ts"],"mappings":";;AA+BA;;;;;;;;;;;;;;;;cAAa,sBAAA,YACX,QAAA,UACA,MAAA,GAAQ,MAAA,SAAe,CAAA;EACpB,QAAA;EAAmB,KAAA,WAAgB,CAAA;AAAA"}

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

@@ -1,2 +1,35 @@
-import { n as getBrowserLocale, r as localeStorageOptions, t as LanguageDetector } from "../getBrowserLocale-RD_Mwv1t.js";
-export { LanguageDetector, getBrowserLocale, localeStorageOptions };
+import { LocaleStorageOptions } from "../utils/localeStorage.js";
+import { Locale } from "@intlayer/types/allLocales";
+
+//#region src/localization/getBrowserLocale.d.ts
+declare enum LanguageDetector {
+  Querystring = "querystring",
+  Storage = "storage",
+  Navigator = "navigator",
+  HtmlTag = "htmlTag"
+}
+declare const localeStorageOptions: LocaleStorageOptions;
+type LanguageDetectorOptions = {
+  order?: LanguageDetector[];
+  lookupQuerystring?: string;
+  htmlTag?: HTMLElement | null;
+};
+/**
+ * Core language detector function for browser environments.
+ *
+ * Detects the user's preferred locale by checking multiple sources in order:
+ * 1. Query string parameter
+ * 2. Storage (cookies, localStorage, sessionStorage) - uses getLocaleFromStorage
+ * 3. Navigator languages - uses localeDetector
+ * 4. HTML lang attribute - uses localeDetector
+ *
+ * @param userOptions - Optional configuration for detection order and lookup keys
+ * @returns The detected locale or the default locale
+ *
+ * @example
+ * const locale = getBrowserLocale({ order: [LanguageDetector.Storage, LanguageDetector.Navigator] });
+ */
+declare const getBrowserLocale: (userOptions?: LanguageDetectorOptions | undefined) => Locale;
+//#endregion
+export { LanguageDetector, getBrowserLocale, localeStorageOptions };
+//# sourceMappingURL=getBrowserLocale.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getBrowserLocale.d.ts","names":[],"sources":["../../../src/localization/getBrowserLocale.tsx"],"mappings":";;;;aASY,gBAAA;EACV,WAAA;EACA,OAAA;EACA,SAAA;EACA,OAAA;AAAA;AAAA,cAGW,oBAAA,EAAsB,oBAAA;AAAA,KA2B9B,uBAAA;EACH,KAAA,GAAQ,gBAAA;EACR,iBAAA;EACA,OAAA,GAAU,WAAA;AAAA;AA9BZ;;;;;AAwBE;;;;;;;;;;AAxBF,cA4La,gBAAA,GACX,WAAA,GAAa,uBAAA,iBACZ,MAAA"}

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

@@ -1,2 +1,21 @@
-import { t as getHTMLTextDir } from "../getHTMLTextDir-4Zh8J3x7.js";
-export { getHTMLTextDir };
+import { LocalesValues } from "@intlayer/types/module_augmentation";
+
+//#region src/localization/getHTMLTextDir.d.ts
+type Dir = 'ltr' | 'rtl' | 'auto';
+/**
+ * Returns the text direction of the given locale.
+ *
+ * Example:
+ *
+ * getHTMLTextDir('en-US') // 'ltr'
+ * getHTMLTextDir('en') // 'ltr'
+ * getHTMLTextDir('fr-CA') // 'ltr'
+ * getHTMLTextDir('fr') // 'ltr'
+ *
+ * @param locale The locale to get the text direction for.
+ * @returns The text direction of the given locale.
+ */
+declare const getHTMLTextDir: (locale?: LocalesValues) => Dir;
+//#endregion
+export { getHTMLTextDir };
+//# sourceMappingURL=getHTMLTextDir.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getHTMLTextDir.d.ts","names":[],"sources":["../../../src/localization/getHTMLTextDir.ts"],"mappings":";;;KAEK,GAAA;;AAFoE;;;;;AAiBzE;;;;;;;cAAa,cAAA,GAAkB,MAAA,GAAS,aAAA,KAAgB,GAAA"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"getLocale.d.ts","names":[],"sources":["../../../src/localization/getLocale.ts"],"mappings":";;;KAOY,cAAA;EACV,SAAA,IAAa,IAAA;EACb,SAAA,IAAa,IAAA;AAAA;AAAA,cAGF,SAAA,GAAmB,GAAA,GAAK,cAAA,KAAsB,OAAA,CAAQ,MAAA"}

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

@@ -1,2 +1,20 @@
-import { t as getLocaleFromPath } from "../getLocaleFromPath-621W32QA.js";
-export { getLocaleFromPath };
+import { RoutingOptions } from "./getPrefix.js";
+import { Locale } from "@intlayer/types/allLocales";
+
+//#region src/localization/getLocaleFromPath.d.ts
+/**
+ * Extracts the locale segment from the given URL or pathname based on the routing mode.
+ *
+ * Mode Behaviors:
+ * - 'prefix-no-default': Checks path prefix. If no prefix found, assumes default locale.
+ * - 'prefix-all': Checks path prefix.
+ * - 'search-params': Checks for 'locale' query parameter.
+ * - 'no-prefix': Returns the default locale.
+ *
+ * @param inputUrl - The complete URL string or pathname to process.
+ * @returns The detected locale, default locale (if fallback/implicit), or undefined.
+ */
+declare const getLocaleFromPath: (inputUrl?: string, options?: RoutingOptions) => Locale | undefined;
+//#endregion
+export { getLocaleFromPath };
+//# sourceMappingURL=getLocaleFromPath.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getLocaleFromPath.d.ts","names":[],"sources":["../../../src/localization/getLocaleFromPath.ts"],"mappings":";;;;;;AAgBA;;;;;;;;;;cAAa,iBAAA,GACX,QAAA,WACA,OAAA,GAAU,cAAA,KACT,MAAA"}

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

@@ -1,2 +1,20 @@
-import { t as getLocaleLang } from "../getLocaleLang-Bcan1gS4.js";
-export { getLocaleLang };
+import { LocalesValues } from "@intlayer/types/module_augmentation";
+
+//#region src/localization/getLocaleLang.d.ts
+/**
+ * Returns the language code of the given locale for locales including the country code.
+ *
+ * Example:
+ *
+ * getLocaleLang('en-US') // 'en'
+ * getLocaleLang('en') // 'en'
+ * getLocaleLang('fr-CA') // 'fr'
+ * getLocaleLang('fr') // 'fr'
+ *
+ * @param locale The locale to get the language code for.
+ * @returns The language code of the given locale.
+ */
+declare const getLocaleLang: (locale?: LocalesValues) => string;
+//#endregion
+export { getLocaleLang };
+//# sourceMappingURL=getLocaleLang.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getLocaleLang.d.ts","names":[],"sources":["../../../src/localization/getLocaleLang.ts"],"mappings":";;;;;AAeA;;;;;;;;;;;cAAa,aAAA,GAAiB,MAAA,GAAS,aAAA"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"getLocaleName.d.ts","names":[],"sources":["../../../src/localization/getLocaleName.ts"],"mappings":";;;cAGa,aAAA,GACX,aAAA,EAAe,aAAA,EACf,YAAA,GAAc,aAAA"}

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

@@ -1,2 +1,44 @@
-import { t as getLocalizedUrl } from "../getLocalizedUrl-BbqeA3-W.js";
-export { getLocalizedUrl };
+import { RoutingOptions } from "./getPrefix.js";
+import { LocalesValues } from "@intlayer/types/module_augmentation";
+
+//#region src/localization/getLocalizedUrl.d.ts
+/**
+ * Generate URL by prefixing the given URL with the referenced locale or adding search parameters
+ * based on the routing mode. Handles both absolute and relative URLs appropriately.
+ *
+ * This function gets the locales, default locale, and routing mode from the configuration if not provided.
+ *
+ * Example:
+ *
+ * ```ts
+ *  // prefix-no-default mode
+ *  getLocalizedUrl('/about', 'fr', { locales: ['en', 'fr'], defaultLocale: 'en', mode: 'prefix-no-default' });
+ *  // Returns '/fr/about' for the French locale
+ *  // Returns '/about' for the English locale (default)
+ *
+ *  // prefix-all mode
+ *  getLocalizedUrl('/about', 'en', { locales: ['en', 'fr'], defaultLocale: 'en', mode: 'prefix-all' });
+ *  // Returns '/en/about' for the English locale
+ *  // Returns '/fr/about' for the French locale
+ *
+ *  // search-params mode
+ *  getLocalizedUrl('/about', 'fr', { locales: ['en', 'fr'], defaultLocale: 'en', mode: 'search-params' });
+ *  // Returns '/about?locale=fr' for the French locale
+ *
+ *  // no-prefix mode
+ *  getLocalizedUrl('/about', 'fr', { locales: ['en', 'fr'], defaultLocale: 'en', mode: 'no-prefix' });
+ *  // Returns '/about' for any locale
+ * ```
+ *
+ * @param url - The original URL string to be processed.
+ * @param currentLocale - The current locale.
+ * @param options - Configuration options
+ * @param options.locales - Optional array of supported locales. Defaults to configured locales.
+ * @param options.defaultLocale - The default locale. Defaults to configured default locale.
+ * @param options.mode - URL routing mode for locale handling. Defaults to configured mode.
+ * @returns The localized URL for the current locale.
+ */
+declare const getLocalizedUrl: (url: string, currentLocale?: LocalesValues, options?: RoutingOptions) => string;
+//#endregion
+export { type RoutingOptions, getLocalizedUrl };
+//# sourceMappingURL=getLocalizedUrl.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getLocalizedUrl.d.ts","names":[],"sources":["../../../src/localization/getLocalizedUrl.ts"],"mappings":";;;;;AAsDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,eAAA,GACX,GAAA,UACA,aAAA,GAAe,aAAA,EAEf,OAAA,GAAS,cAAA"}

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

@@ -1,2 +1,42 @@
-import { t as getMultilingualUrls } from "../getMultilingualUrls-CUxYYfA4.js";
-export { getMultilingualUrls };
+import { RoutingOptions } from "./getPrefix.js";
+import { StrictModeLocaleMap } from "@intlayer/types/module_augmentation";
+
+//#region src/localization/getMultilingualUrls.d.ts
+/**
+ * Generates multilingual URLs by prefixing the given URL with each supported locale
+ * or adding search parameters based on the routing mode.
+ * Handles both absolute and relative URLs appropriately.
+ *
+ * This function gets the locales, default locale, and routing mode from the configuration if not provided.
+ *
+ * Example:
+ *
+ * ```ts
+ *  // prefix-no-default mode
+ *  getMultilingualUrls('/dashboard', { locales: ['en', 'fr'], defaultLocale: 'en', mode: 'prefix-no-default' })
+ *     // Returns { en: '/dashboard', fr: '/fr/dashboard' }
+ *
+ *  // prefix-all mode
+ *  getMultilingualUrls('/dashboard', { locales: ['en', 'fr'], defaultLocale: 'en', mode: 'prefix-all' })
+ *     // Returns { en: '/en/dashboard', fr: '/fr/dashboard' }
+ *
+ *  // search-params mode
+ *  getMultilingualUrls('/dashboard', { locales: ['en', 'fr'], defaultLocale: 'en', mode: 'search-params' })
+ *     // Returns { en: '/dashboard?locale=en', fr: '/dashboard?locale=fr' }
+ *
+ *  // no-prefix mode
+ *  getMultilingualUrls('/dashboard', { locales: ['en', 'fr'], defaultLocale: 'en', mode: 'no-prefix' })
+ *     // Returns { en: '/dashboard', fr: '/dashboard' }
+ * ```
+ *
+ * @param url - The original URL string to be processed.
+ * @param options - Configuration options
+ * @param options.locales - Optional array of supported locales. Defaults to configured locales.
+ * @param options.defaultLocale - The default locale. Defaults to configured default locale.
+ * @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>;
+//#endregion
+export { getMultilingualUrls };
+//# sourceMappingURL=getMultilingualUrls.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getMultilingualUrls.d.ts","names":[],"sources":["../../../src/localization/getMultilingualUrls.ts"],"mappings":";;;;;;AAsCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,mBAAA,GACX,GAAA,UACA,OAAA,GAAS,cAAA,KACR,mBAAA"}

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

@@ -1,2 +1,31 @@
-import { t as getPathWithoutLocale } from "../getPathWithoutLocale-B_aIR7O0.js";
-export { getPathWithoutLocale };
+import { LocalesValues } from "@intlayer/types/module_augmentation";
+
+//#region src/localization/getPathWithoutLocale.d.ts
+/**
+ * Removes the locale segment from the given URL or pathname if present.
+ * Also removes locale from search parameters if present.
+ *
+ * This function get the locales from the configuration if not provided.
+ *
+ * Example:
+ *
+ * ```ts
+ * getPathWithoutLocale('/en/dashboard') // Returns '/dashboard'
+ * getPathWithoutLocale('/fr/dashboard') // Returns '/dashboard'
+ * getPathWithoutLocale('/dashboard') // Returns '/dashboard'
+ * getPathWithoutLocale('dashboard') // Returns 'dashboard'
+ * getPathWithoutLocale('/dashboard?locale=fr') // Returns '/dashboard'
+ * getPathWithoutLocale('https://example.com/en/dashboard') // Returns 'https://example.com/dashboard'
+ * getPathWithoutLocale('https://example.com/fr/dashboard') // Returns 'https://example.com/dashboard'
+ * getPathWithoutLocale('https://example.com/dashboard') // Returns 'https://example.com/dashboard'
+ * getPathWithoutLocale('https://example.com/dashboard?locale=fr') // Returns 'https://example.com/dashboard'
+ * ```
+ *
+ * @param inputUrl - The complete URL string or pathname to process.
+ * @param locales - Optional array of supported locales. Defaults to `localesDefault`.
+ * @returns The URL string or pathname without the locale segment or locale search parameter.
+ */
+declare const getPathWithoutLocale: (inputUrl: string, locales?: LocalesValues[]) => string;
+//#endregion
+export { getPathWithoutLocale };
+//# sourceMappingURL=getPathWithoutLocale.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getPathWithoutLocale.d.ts","names":[],"sources":["../../../src/localization/getPathWithoutLocale.ts"],"mappings":";;;;;AA6BA;;;;;;;;;;;;;;;;;;;;;;cAAa,oBAAA,GACX,QAAA,UACA,OAAA,GAAS,aAAA"}